Deprecated EditorWindow.INITIAL_INDEX_KEY with replacement marked as @ApiStatus.Internal

In my plugin, I have an option to reopen editors when file type changes. Official JetBrains policy was that file type changes do not reload editors, keeping the file type as it was when the file was opened. So, I implemented my own reopen editors, preserving the tab order.

I am compiling against 2021.3, it is the com.intellij.openapi.fileEditor.impl.EditorWindow class.

package com.intellij.openapi.fileEditor.impl;

public final class EditorWindow {
   /**
   * @deprecated Use file opening methods taking {@link FileEditorOpenOptions} instead
   * and pass the index through {@link FileEditorOpenOptions#withIndex(int)}.
   */
  @Deprecated
  public static final Key<Integer> INITIAL_INDEX_KEY = Key.create("initial editor index");
}

Meanwhile, FileEditorOpenOptions:

package com.intellij.openapi.fileEditor.impl

import org.jetbrains.annotations.ApiStatus

@ApiStatus.Internal
data class FileEditorOpenOptions(
  var selectAsCurrent: Boolean = true,
  var reuseOpen: Boolean = false,
  var usePreviewTab: Boolean = false,
  var requestFocus: Boolean = false,
  var pin: Boolean? = null,
  var index: Int = -1,
  var isExactState: Boolean = false,
  var isReopeningOnStartup: Boolean = false,
) {
  fun clone() = copy()  // no arg copying for Java

  // @formatter:off
  @JvmOverloads fun withSelectAsCurrent(value: Boolean = true)     = apply { selectAsCurrent = value }
  @JvmOverloads fun withReuseOpen(value: Boolean = true)           = apply { reuseOpen = value }
  @JvmOverloads fun withUsePreviewTab(value: Boolean = true)       = apply { usePreviewTab = value }
  @JvmOverloads fun withRequestFocus(value: Boolean = true)        = apply { requestFocus = value }
  @JvmOverloads fun withExactState(value: Boolean = true)          = apply { isExactState = value }
  @JvmOverloads fun withReopeningOnStartup(value: Boolean = true)  = apply { isReopeningOnStartup = value }
  fun withPin(value: Boolean?)  = apply { pin = value }
  fun withIndex(value: Int)     = apply { index = value }
  // @formatter:on
}

Hi 

> Official JetBrains policy was that file type changes do not reload editors, keeping the file type as it was when the file was opened

I'm sorry, this is still the case. 

I'm against opening FileEditorOpenOptions, because this subsystem is being actively re-designed.

I see two options, though:

1. We can consider providing an API to trigger the reopening of all existing editors.
2. We can re-consider re-opening affected tabs on file type change. 

Can you describe your use-case in details? Why do you need to re-open right away? 

I feel your dilemma, but the view from the other side is that what you don't officially provide, will wind up using internal, brittle solution or hacks (reflection and setAccessible()) that are more pain for everyone involved.

In my plugin, there is an option to associate HTML files with the plugin's split editor with an HTML preview pane. When the plugin detects that an editor file mismatches with what the plugin's EditorProvider.acceptFile() thinks about the file, then my plugin will reload those tabs so they can be associated with the correct editor handling the type.

I personally like the use of configuration like the INITIAL_INDEX_KEY with putUserData because it does not create class, interface or method signature dependencies in dependent code. Whoever needs it, uses it, everyone else is oblivious. I can also easily use reflection to test if the field is available and provide my own dummy, when it is not, that way your implementation will ignore it, but my code will work without modification. 

However, it can be more error prone, but then I have not encountered an error free programming model, yet.

Have there been a lot of bug reports related to use of the old implementation? Just curious if it is churning because it is ugly or it creates real issues in maintenance?

BTW, reloading all editors tabs, depending on how many are open, can create a jarring visual effect. That is why I dove into the innards with my own implementation.

How about a method taking a Predicate<VirtualFile> so you only reload only what needs to be reloaded?

If it helps, the method I use is here, it gets an array of files whose editor association changed. The INITIAL_INDEX_KEY is my wrapper delegating to EditorWindow.INITIAL_INDEX_KEY if one is available or do nothing if it is not.

    private fun reopenFileEditors(files: Array<out VirtualFile>) {
        val fileEditorManager = FileEditorManagerEx.getInstanceEx(project)
        val windows = fileEditorManager.windows
        val dummyVirtualFile: VirtualFile? by lazy { LightVirtualFile("dummy.txt", "\n") }

        for (window in windows) {
            val focusedEditor = window.selectedEditor
            val editors = window.editors

            for (file in files) {
                val editorIndex = editors.indexOfFirst { it.file == file }
                if (editorIndex == -1) continue

                val pinned = window.isFilePinned(file)

                // may need to add a dummy file if there is only one tab so that when we close the file the tab stays open
                val dummy: VirtualFile? = if (window.tabCount == 1) dummyVirtualFile else null

                if (dummy != null) fileEditorManager.openFileWithProviders(dummy, false, window)

                INITIAL_INDEX_KEY.setEditorWindowInitialIndex(file, editorIndex)
                window.closeFile(file, true, false)
                fileEditorManager.openFileWithProviders(file, false, window)

                if (dummy != null) window.closeFile(dummy)

                if (pinned) window.setFilePinned(file, true)

                // clear the index key so it does not keep opening at that tab index by accident
                INITIAL_INDEX_KEY.setEditorWindowInitialIndex(file, null)
            }

            if (focusedEditor != null) {
                // restore focused tab for the window
                window.setSelectedEditor(focusedEditor, false)
            }
        }
    }