add links to plugin_configuration_file.md

reference_guide/api_changes_list_2020.md

@@ -353,7 +353,7 @@ Java code migrated to use `TYPE_USE` nullability annotations
 
 Images module functionality (package `org.intellij.images.*`) extracted to plugin
 : The dependency [must be declared](plugin_dependencies.md) explicitly now by the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) element:
-  * Add `<depends>com.intellij.platform.images</depends>` in <path>plugin.xml</path>
+  * Add `<depends>com.intellij.platform.images</depends>` in <path>[plugin.xml](plugin_configuration_file.md)</path>
   * Add to <path>build.gradle</path>:
 
     ```groovy

topics/appendix/api_notable/api_notable_list_2019.md

@@ -10,7 +10,7 @@
 : Now reflects its "heavy test" characteristics (see [Light and Heavy Tests](light_and_heavy_tests.md)).
 
 Support for transitive optional plugin dependencies
-: Optional <path>plugin.xml</path> configuration files can now specify [`<depends>`](plugin_configuration_file.md#idea-plugin__depends). [Issue](https://youtrack.jetbrains.com/issue/IDEA-209769)
+: [Optional <path>plugin.xml</path> configuration files](plugin_configuration_file.md#additional-plugin-configuration-files) can now specify [`<depends>`](plugin_configuration_file.md#idea-plugin__depends). [Issue](https://youtrack.jetbrains.com/issue/IDEA-209769)
 
 Theme/Keymap plugins do not require restart
 : (Un)Installing or enabling/disabling [Theme](themes_intro.md) or [Keymap](https://plugins.jetbrains.com/search?tags=Keymap) plugins doesn't require an IDE restart anymore.

topics/appendix/api_notable/api_notable_list_2020.md

@@ -124,7 +124,7 @@ JCEF Support (_Experimental Feature_)
 : Allows [embedding](jcef.md) Chromium-based browser in the IDE.
 
 Override text presentation for actions depending on menu context
-: Set the [`<override-text>`](basic_action_system.md#setting-the-override-text-element) element within the [`<action>`](plugin_configuration_file.md#idea-plugin__actions__action) declaration in <path>plugin.xml</path>.
+: Set the [`<override-text>`](basic_action_system.md#setting-the-override-text-element) element within the [`<action>`](plugin_configuration_file.md#idea-plugin__actions__action) declaration in <path>[plugin.xml](plugin_configuration_file.md)</path>.
 
 Changes in Project Open/Import
 : **Import from Existing Sources** has been removed from the Welcome Screen, leaving only **Open or Import**, which calls a different extension than the one previously used to contribute a wizard step to **Import from Existing Sources** (which is still available in the <control>File</control> menu). To support **Open or Import**, a plugin must provide [`ProjectOpenProcessor`](%gh-ic%/platform/platform-api/src/com/intellij/projectImport/ProjectOpenProcessor.java).

topics/appendix/resources/custom_plugin_repository.md

@@ -88,7 +88,7 @@ available at this repository.
 During plugin installation, the IDE reads the plugin JAR/ZIP file and thereafter displays more information about the plugin.
 In some cases, additional information included in <path>updatePlugins.xml</path> might help a user select a plugin when [browsing the custom plugin repository](https://www.jetbrains.com/help/idea/managing-plugins.html#repos) before installation.
 The decision on what elements should be included in the file depends on the plugins and repository consumers.
-It is recommended to avoid adding unnecessary elements as they will have to be synchronized with each plugin's <path>plugin.xml</path> file.
+It is recommended to avoid adding unnecessary elements as they will have to be synchronized with each plugin's <path>[plugin.xml](plugin_configuration_file.md)</path> file.
 
 The additional candidate elements:
 

topics/appendix/resources/explore_api.md

@@ -30,7 +30,7 @@ Additionally, dedicated Extension Point Lists specific to IDEs are available und
 ### 1.2 Use Autocompletion Information
 
 Another way to discover EPs is by using autocompletion or navigating through EP XML files.
-When you open a new tag in your <path>plugin.xml</path> file (inside the `extensions` block with `defaultExtensionNs="com.intellij"`),
+When you open a new tag in your <path>[plugin.xml](plugin_configuration_file.md)</path> file (inside the [`<extensions>`](plugin_configuration_file.md#idea-plugin__extensions) block with `defaultExtensionNs="com.intellij"`),
 the IDE will automatically suggest possible EPs.
 
 ![Using Completion Suggestions](plugin_xml_completion_suggestion.png){width="706"}{animated="true"}{border-effect="rounded"}

topics/appendix/tools/gradle_intellij_plugin/tools_gradle_intellij_plugin.md

@@ -284,7 +284,7 @@ Notes:
 - For plugins from [JetBrains Marketplace](https://plugins.jetbrains.com), use format `pluginId:version`.
 - For bundled plugins, version must be omitted: e.g. `org.intellij.groovy`.
 - For subprojects, use project reference `project(':subproject')`.
-- If you need to refer plugin's classes from your project, you also have to define a dependency in your <path>plugin.xml</path> file, see [](plugin_dependencies.md).
+- If you need to refer plugin's classes from your project, you also have to define a dependency in your <path>[plugin.xml](plugin_configuration_file.md)</path> file, see [](plugin_dependencies.md).
 
 {style="narrow"}
 Type

topics/appendix/verifying_plugin_compatibility.md

@@ -25,5 +25,5 @@ Consider using the following [IDE inspections](https://www.jetbrains.com/help/id
 - <control>JVM languages | Unstable API Usage</control>
 - <control>JVM languages | Unstable type is used in signature</control>
 
-Usage of [Extension Points](plugin_extensions.md) which are deprecated or annotated with [`org.jetbrains.annotations.ApiStatus`](https://github.com/JetBrains/java-annotations/blob/master/common/src/main/java/org/jetbrains/annotations/ApiStatus.java) `@Experimental`/`@Internal` is highlighted in <path>plugin.xml</path> files.
+Usage of [Extension Points](plugin_extensions.md) which are deprecated or annotated with [`org.jetbrains.annotations.ApiStatus`](https://github.com/JetBrains/java-annotations/blob/master/common/src/main/java/org/jetbrains/annotations/ApiStatus.java) `@Experimental`/`@Internal` is highlighted in <path>[plugin.xml](plugin_configuration_file.md)</path> files.
 

topics/basics/architectural_overview/file_view_providers.md

@@ -30,7 +30,7 @@ To create a file type that has multiple interspersing trees for different langua
 
 Implement [`FileViewProviderFactory`](%gh-ic%/platform/core-api/src/com/intellij/psi/FileViewProviderFactory.java) and return your `FileViewProvider` implementation from `createFileViewProvider()` method.
 
-Register as follows in <path>plugin.xml</path>:
+Register as follows in <path>[plugin.xml](plugin_configuration_file.md)</path>:
 
 ```xml
 <extensions defaultExtensionNs="com.intellij">

topics/basics/architectural_overview/uast.md

@@ -251,7 +251,7 @@ could be different, not only in the number of elements, but also in their order.
 
 ## Using UAST in Plugins
 
-To register extensions applicable to UAST, specify `language="UAST"` in <path>plugin.xml</path>.
+To register extensions applicable to UAST, specify `language="UAST"` in <path>[plugin.xml](plugin_configuration_file.md)</path>.
 
 ### Inspecting UAST Tree
 

topics/basics/basic_action_system.md

@@ -154,7 +154,7 @@ See the [Grouping Actions](grouping_action.md) tutorial for examples of creating
 
 ## Registering Actions
 
-There are two main ways to register an action: either by listing it in the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section of a plugin's <path>plugin.xml</path> file or through code.
+There are two main ways to register an action: either by listing it in the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section of a plugin's <path>[plugin.xml](plugin_configuration_file.md)</path> file or through code.
 
 ### Registering Actions in plugin.xml
 

topics/basics/disposers.md

@@ -21,7 +21,7 @@ The most important type of such objects is [services](plugin_services.md).
 Application-level services are automatically disposed by the platform when the IDE is closed or the plugin providing the service is unloaded.
 Project-level services are disposed when the project is closed, or the plugin is unloaded.
 
-Note that extensions registered in <path>plugin.xml</path> are *not* automatically disposed.
+Note that extensions registered in <path>[plugin.xml](plugin_configuration_file.md)</path> are *not* automatically disposed.
 If an extension requires executing some code to dispose it, you need to define a service and to put the code in its `dispose()` method or use it as a parent disposable.
 
 ## The Disposer Singleton

topics/basics/getting_started/build_number_ranges.md

@@ -2,7 +2,7 @@
 <!-- Copyright 2000-2022 JetBrains s.r.o. and other contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. -->
 
 Use this reference of build number ranges to specify the correct `since-build` and `until-build` values in your plugin descriptor.
-Setting the actual values in <path>plugin.xml</path> is managed by [`patchPluginXml`](tools_gradle_intellij_plugin.md#tasks-patchpluginxml) Gradle task, see [](gradle_guide.md#patching-the-plugin-configuration-file).
+Setting the actual values in <path>[plugin.xml](plugin_configuration_file.md)</path> is managed by [`patchPluginXml`](tools_gradle_intellij_plugin.md#tasks-patchpluginxml) Gradle task, see [](gradle_guide.md#patching-the-plugin-configuration-file).
 
 Please note the following regarding values:
 

topics/basics/getting_started/plugin_compatibility.md

@@ -23,7 +23,7 @@ Declaring a dependency on a module also expresses a plugin's compatibility with
 [Part I](plugin_dependencies.md) of this document describes the syntax for declaring plugin dependencies and optional plugin dependencies.
 Part II of this document (below) describes the IntelliJ Platform modules' functionality to aid in determining the dependencies of a plugin.
 
-The way dependency declarations are handled by the Intellij Platform is determined by the contents of the <path>plugin.xml</path> file:
+The way dependency declarations are handled by the Intellij Platform is determined by the contents of the <path>[plugin.xml](plugin_configuration_file.md)</path> file:
 * If a plugin does not declare any dependencies in its <path>plugin.xml</path> file, or if it declares dependencies only on other plugins but not modules, it's assumed to be a legacy plugin and is loaded only in IntelliJ IDEA.
   This configuration of the dependency declaration is deprecated; do not use it for new plugin projects.
 * If a plugin declares at least _one_ module dependency in its <path>plugin.xml</path> file, the plugin is loaded if an IntelliJ Platform-based product contains _all the modules and plugins_ on which the plugin has declared a dependency.

topics/basics/ide_infrastructure.md

@@ -88,7 +88,7 @@ To disable red exclamation notification icon in status bar, invoke <menupath>Hel
 ## Runtime Information
 
 [`ApplicationInfo`](%gh-ic%/platform/core-api/src/com/intellij/openapi/application/ApplicationInfo.java) provides information on the IDE version and vendor.
-NOTE: to restrict compatibility, declare [IDEs](plugin_compatibility.md) and [versions](build_number_ranges.md) via <path>plugin.xml</path>.
+NOTE: to restrict compatibility, declare [IDEs](plugin_compatibility.md) and [versions](build_number_ranges.md) via <path>[plugin.xml](plugin_configuration_file.md)</path>.
 
 To obtain information about OS and Java VM, use [`SystemInfo`](%gh-ic%/platform/util/src/com/intellij/openapi/util/SystemInfo.java).
 

topics/basics/indexing_and_psi_stubs/stub_indexes.md

@@ -25,7 +25,7 @@ You usually don't need to have stubs for things like statements or local variabl
 The following steps need to be performed only once for each language that supports stubs:
 
 * Change the file element type for your language (the element type that you return from `ParserDefinition.getFileNodeType()`) to a class that extends [`IStubFileElementType`](%gh-ic%/platform/core-impl/src/com/intellij/psi/tree/IStubFileElementType.java).
-* In your <path>plugin.xml</path>, define the `com.intellij.stubElementTypeHolder` extension and specify the interface which contains the `IElementType` constants used by your language's parser and common `externalIdPrefix` (see Javadoc for requirements).
+* In your <path>[plugin.xml](plugin_configuration_file.md)</path>, define the `com.intellij.stubElementTypeHolder` extension and specify the interface which contains the `IElementType` constants used by your language's parser and common `externalIdPrefix` (see Javadoc for requirements).
 
 **Example**: [`JavaStubElementTypes`](%gh-ic%/java/java-psi-impl/src/com/intellij/psi/impl/java/stubs/JavaStubElementTypes.java) registered in [`JavaPsiPlugin.xml`](%gh-ic%/java/java-psi-impl/src/META-INF/JavaPsiPlugin.xml)
 

topics/basics/persisting_state_of_components.md

@@ -197,5 +197,5 @@ Implementations can manually store the state in attributes and sub-elements or u
 Components save their state in the following files:
 
 * Project-level: project (<path>.ipr</path>) file.
-  However, if the workspace option in the <path>plugin.xml</path> file is set to `true`, then the workspace (<path>.iws</path>) file is used instead.
+  However, if the workspace option in the <path>[plugin.xml](plugin_configuration_file.md)</path> file is set to `true`, then the workspace (<path>.iws</path>) file is used instead.
 * Module-level: module (<path>.iml</path>) file.

topics/basics/plugin_structure/dynamic_plugins.md

@@ -9,7 +9,7 @@ To test whether dynamic installation works correctly, verify installing [local b
 
 Please note that any unloading problems in a production environment will simply ask the user to restart the IDE.
 
-> If a plugin _requires_ restart (e.g., due to using native libraries) specify `require-restart="true"` for [`<idea-plugin>`](plugin_configuration_file.md#idea-plugin) root tag in <path>plugin.xml</path>.
+> If a plugin _requires_ restart (e.g., due to using native libraries) specify `require-restart="true"` for [`<idea-plugin>`](plugin_configuration_file.md#idea-plugin) root tag in <path>[plugin.xml](plugin_configuration_file.md)</path>.
 >
 {type="note"}
 

topics/basics/plugin_structure/plugin_class_loaders.md

@@ -34,7 +34,7 @@ configurations.all {
 ## Classes from Plugin Dependencies
 
 By default, the main IDE class loader loads classes that are not found in the plugin class loader.
-However, in the <path>plugin.xml</path> file, you may use the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) element to specify that a [plugin depends](plugin_dependencies.md) on one or more other plugins.
+However, in the <path>[plugin.xml](plugin_configuration_file.md)</path> file, you may use the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) element to specify that a [plugin depends](plugin_dependencies.md) on one or more other plugins.
 In this case, the class loaders of those plugins will be used for classes not found in the current plugin.
 This allows a plugin to reference classes from other plugins.
 

topics/basics/plugin_structure/plugin_dependencies.md

@@ -16,7 +16,7 @@ To express a dependency on classes from other plugins or modules, perform the fo
 
 1. Locate Plugin ID
 2. Project Setup
-3. Declaration in <path>plugin.xml</path>
+3. Declaration in <path>[plugin.xml](plugin_configuration_file.md)</path>
 
 If `java.lang.NoClassDefFoundError` occurs at runtime, it means that either Step 3 was omitted or loading the plugin dependency failed (please check log files from [Development Instance](ide_development_instance.md#development-instance-settings-caches-logs-and-plugins)).
 
@@ -143,7 +143,7 @@ Continuing with the example from [Project Setup](#2-project-setup) above, the de
 A plugin can also specify an optional plugin dependency.
 In this case, the plugin will load even if the plugin it depends on is not installed or enabled, but part of the plugin's functionality will not be available.
 
-Declare additional `optional="true"` and `config-file` attribute pointing to optional plugin descriptor file:
+Declare additional `optional="true"` and `config-file` attribute pointing to [optional plugin descriptor file](plugin_configuration_file.md#additional-plugin-configuration-files):
 
 ```xml
 <depends

topics/basics/plugin_structure/plugin_extension_points.md

@@ -17,7 +17,7 @@ There are two types of extension points:
 
 ## Declaring Extension Points
 
-You can declare extensions and extension points in the plugin configuration file <path>plugin.xml</path>, within the [`<extensions>`](plugin_configuration_file.md#idea-plugin__extensions) and [`<extensionPoints>`](plugin_configuration_file.md#idea-plugin__extensionPoints) sections.
+You can declare extensions and extension points in the plugin configuration file <path>[plugin.xml](plugin_configuration_file.md)</path>, within the [`<extensions>`](plugin_configuration_file.md#idea-plugin__extensions) and [`<extensionPoints>`](plugin_configuration_file.md#idea-plugin__extensionPoints) sections.
 
 To declare extension points in your plugin, add an `<extensionPoints>` section to your <path>plugin.xml</path>.
 Then insert a child element [`<extensionPoint>`](plugin_configuration_file.md#idea-plugin__extensionPoints__extensionPoint) that defines the extension point name and the name of a bean class or an interface that is allowed to extend the plugin functionality in the `name`, `beanClass` and `interface` attributes, respectively.

topics/basics/plugin_structure/plugin_extensions.md

@@ -20,7 +20,7 @@ There are more than 1000 extension points available in the platform and the bund
 Additionally, dedicated Extension Point and Listener Lists specific to IDEs are available under _Part VIII — Product Specific_.
 Browse usages inside existing implementations of open-source IntelliJ Platform plugins via [IntelliJ Platform Explorer](https://jb.gg/ipe).
 
-Alternatively (or when using 3rd party extension points), all available extension points for the specified namespace (`defaultExtensionNs`) can be listed using auto-completion inside the [`<extensions>`](plugin_configuration_file.md#idea-plugin__extensions) block in <path>plugin.xml</path>.
+Alternatively (or when using 3rd party extension points), all available extension points for the specified namespace (`defaultExtensionNs`) can be listed using auto-completion inside the [`<extensions>`](plugin_configuration_file.md#idea-plugin__extensions) block in <path>[plugin.xml](plugin_configuration_file.md)</path>.
 Use <menupath>View | Quick Documentation</menupath> in the lookup list to access more information about the extension point and implementation (if applicable).
 See [](explore_api.md) for more information and strategies.
 

topics/basics/plugin_structure/plugin_listeners.md

@@ -23,7 +23,7 @@ The advantage is because listener instances get created lazily — the first tim
 
 ## Defining Application-Level Listeners
 
-To define an application-level listener, add the [`<applicationListeners>`](plugin_configuration_file.md#idea-plugin__applicationListeners) section to your <path>plugin.xml</path>:
+To define an application-level listener, add the [`<applicationListeners>`](plugin_configuration_file.md#idea-plugin__applicationListeners) section to your <path>[plugin.xml](plugin_configuration_file.md)</path>:
 
 ```xml
 <idea-plugin>

topics/basics/plugin_structure/plugin_services.md

@@ -35,7 +35,7 @@ To improve startup performance, avoid any heavy initializations in the construct
 >
 {type="note"}
 
-A service not going to be overridden does not need to be registered in <path>plugin.xml</path> (see [Declaring a Service](#declaring-a-service)).
+A service not going to be overridden does not need to be registered in <path>[plugin.xml](plugin_configuration_file.md)</path> (see [Declaring a Service](#declaring-a-service)).
 Instead, annotate service class with [`@Service`](%gh-ic%/platform/core-api/src/com/intellij/openapi/components/Service.java).
 The service instance will be created in scope according to the caller (see [Retrieving a Service](#retrieving-a-service)).
 

topics/basics/run_configurations/run_configuration_management.md

@@ -89,7 +89,7 @@ If it is, you return a [`RefactoringElementListener`](%gh-ic%/platform/analysis-
 ## Creating Configurations from Context
 
 Many plugins support automatic creation of run configurations from context so that the user can click, for example, on an application or test class and automatically run it using the correct run configuration type.
-To support that, you need to provide an implementation of the [`RunConfigurationProducer`](%gh-ic%/platform/lang-api/src/com/intellij/execution/actions/RunConfigurationProducer.java) interface and to register it as `<runConfigurationProducer>` in your <path>plugin.xml</path>.
+To support that, you need to provide an implementation of the [`RunConfigurationProducer`](%gh-ic%/platform/lang-api/src/com/intellij/execution/actions/RunConfigurationProducer.java) interface and to register it as `<runConfigurationProducer>` in your <path>[plugin.xml](plugin_configuration_file.md)</path>.
 This API was redesigned in IntelliJ IDEA 13; the previous [`RuntimeConfigurationProducer`](%gh-ic%/platform/lang-api/src/com/intellij/execution/junit/RuntimeConfigurationProducer.java) is a much more confusing version of the same API.
 
 The two main methods that you need to implement are:

topics/intro/sdk_code_guidelines.md

@@ -77,7 +77,7 @@ A plugin with a longer directory name, such as <path>conditional_operator_intent
 
 ## Plugin ID Conventions
 
-The plugin ID appears between [`<id>`](plugin_configuration_file.md#idea-plugin__id) elements in the <path>plugin.xml</path> file.
+The plugin ID appears between [`<id>`](plugin_configuration_file.md#idea-plugin__id) elements in the <path>[plugin.xml](plugin_configuration_file.md)</path> file.
 
 In general, the plugin ID is the `Group ID` concatenated with the `Artifact ID`.
 For example, a plugin like <path>facet_basics</path> has the plugin ID `org.intellij.sdk.facet`.

topics/products/androidstudio/android_studio.md

@@ -119,7 +119,7 @@ When using APIs from the `android` plugin, declare a dependency:
   <depends>org.jetbrains.android</depends>
 ```
 
-As discussed in the [Plugin Dependencies](plugin_compatibility.md#declaring-plugin-dependencies) section of this guide, a plugin's dependency on [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) must be declared in <path>plugin.xml</path>.
+As discussed in the [Plugin Dependencies](plugin_compatibility.md#declaring-plugin-dependencies) section of this guide, a plugin's dependency on [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) must be declared in <path>[plugin.xml](plugin_configuration_file.md)</path>.
 When using Android Studio-specific features (APIs), a dependency on `com.intellij.modules.androidstudio` must be declared as shown in the code snippet below.
 Otherwise, if only general IntelliJ Platform features (APIs) are used, then a dependency on `com.intellij.modules.platform` must be declared as discussed in [Plugin Compatibility with IntelliJ Platform Products](plugin_compatibility.md).
 

topics/products/appcode/app_code.md

@@ -29,7 +29,7 @@ Click on an entry in the table's *Attribute* column to go to the documentation a
 | [`intellij.localPath`](tools_gradle_intellij_plugin.md#intellij-extension-localpath) | Path to locally installed target version of AppCode. For example, for macOS:<br/><path>/Users/$USERNAME$/Library/Application Support/JetBrains/Toolbox/apps/AppCode/ch-0/193.5662.55/AppCode.app/Contents</path>. |
 | [`runIde.ideDir`](tools_gradle_intellij_plugin.md#runide-task-idedir)                | Path to locally installed target version of AppCode. For example, for macOS:<br/><path>/Users/$USERNAME$/Library/Application Support/JetBrains/Toolbox/apps/AppCode/ch-0/193.5662.55/AppCode.app/Contents</path>. |
 
-The dependency on the AppCode APIs must be declared in the <path>plugin.xml</path> file.
+The dependency on the AppCode APIs must be declared in the <path>[plugin.xml](plugin_configuration_file.md)</path> file.
 As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) tags must declare `com.intellij.modules.appcode` module dependency, or `com.intellij.appcode` plugin dependency for plugins targeting only versions 2020.3+.
 
 ## Available AppCode APIs

topics/products/clion/clion.md

@@ -28,7 +28,7 @@ Click on an entry in the table's *Attribute* column to go to the documentation a
 | [`intellij.downloadSources`](tools_gradle_intellij_plugin.md#intellij-extension-downloadsources) | `false` is required because no public source code is available.                |
 | [`runIde.ideDir`](tools_gradle_intellij_plugin.md#runide-task-idedir)                            | Not needed; the Development Instance will automatically match `intellij.type`. |
 
-The dependency on the CLion APIs must be declared in the <path>plugin.xml</path> file.
+The dependency on the CLion APIs must be declared in the <path>[plugin.xml](plugin_configuration_file.md)</path> file.
 As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) tags must declare `com.intellij.modules.clion` module dependency, or `com.intellij.clion` plugin dependency for plugins targeting only versions 2020.3+.
 
 ## Available CLion APIs

topics/products/datagrip/data_grip.md

@@ -23,7 +23,7 @@ To see how these attributes appear in a similar Gradle build script for PhpStorm
 | [`intellij.plugins`](tools_gradle_intellij_plugin.md#intellij-extension-plugins) | `DatabaseTools` Dependency on the bundled `DatabaseTools` plugin.                                                                                                                                                     |
 | [`runIde.ideDir`](tools_gradle_intellij_plugin.md#runide-task-idedir)            | Path to locally installed target version of DataGrip. For example, for macOS:<br/><path>/Users/$USERNAME$/Library/Application Support/JetBrains/Toolbox/apps/datagrip/ch-0/193.5233.139/DataGrip.app/Contents</path>. |
 
-The dependency on the DataGrip APIs must be declared in the <path>plugin.xml</path> file.
+The dependency on the DataGrip APIs must be declared in the <path>[plugin.xml](plugin_configuration_file.md)</path> file.
 As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) tags must declare `com.intellij.database`.
 **Note** that DataGrip plugins must also declare a dependency on `com.intellij.modules.platform` because `com.intellij.database` is not recognized as a module.
 Consequently, without the `com.intellij.modules.platform` declaration the plugin is assumed to be a [legacy plugin](plugin_compatibility.md#declaring-plugin-dependencies) and will not load in DataGrip.

topics/products/dev_alternate_products.md

@@ -21,7 +21,7 @@ All the Gradle configuration attributes described here are discussed in-depth on
 To create a new Gradle plugin project, follow the tutorial on the [](gradle_prerequisites.md) page.
 The tutorial produces a skeleton Gradle project suitable to use as a starting point.
 
-Modifications are needed to the skeleton project's Gradle build script and <path>plugin.xml</path> files, as described below, and on the individual product pages in _Part VIII — Product Specific_.
+Modifications are needed to the skeleton project's Gradle build script and <path>[plugin.xml](plugin_configuration_file.md)</path> files, as described below, and on the individual product pages in _Part VIII — Product Specific_.
 The Gradle build script is modified to specify the target product, determining the APIs available during development.
 The <path>plugin.xml</path> file is modified to declare the plugin's dependency on modules or libraries.
 

topics/products/goland/goland.md

@@ -67,7 +67,7 @@ Select a [version](https://plugins.jetbrains.com/plugin/9568-go/versions) of the
 
 </tabs>
 
-The dependency on the Go plugin APIs must be declared in the <path>plugin.xml</path> file.
+The dependency on the Go plugin APIs must be declared in the <path>[plugin.xml](plugin_configuration_file.md)</path> file.
 As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) tags must declare `com.intellij.modules.goland`.
 The <path>plugin.xml</path> file must also declare a dependency on `com.intellij.modules.platform` as explained in [Configuring the plugin.xml File](dev_alternate_products.md#configuring-pluginxml).
 The dependency declaration is illustrated in the <path>plugin.xml</path> snippet below:

topics/products/idea/spring_api.md

@@ -21,7 +21,7 @@ Please use only Spring-related functionality exposed in <path>spring-api.jar</pa
 Using any other "internal" (implementation) classes from Spring plugin itself (<path>spring.jar</path>) is _not_ supported.
 
 ### plugin.xml
-Add `<depends>com.intellij.spring</depends>` to your <path>plugin.xml</path> to require "Spring Support" plugin to be activated.
+Add `<depends>com.intellij.spring</depends>` to your <path>[plugin.xml](plugin_configuration_file.md)</path> to require "Spring Support" plugin to be activated.
 All available extension points are provided under `com.intellij.spring` prefix.
 Note that the "Spring Support" plugin itself has dependencies on a few other plugins which need to be enabled in your sandbox (see notifications on startup).
 
@@ -176,7 +176,7 @@ Spring Boot API allows extending/accessing Spring Boot specific support in the I
 Sources for Spring Boot API are available in <path>$IDEA_HOME$/lib/src/src_spring-boot-openapi.zip</path>.
 
 ### Update plugin.xml
-Add `<depends>com.intellij.spring.boot</depends>` to your <path>plugin.xml</path> to require "Spring Boot" plugin to be activated.
+Add `<depends>com.intellij.spring.boot</depends>` to your <path>[plugin.xml](plugin_configuration_file.md)</path> to require "Spring Boot" plugin to be activated.
 All available extension points are provided under `com.intellij.spring.boot` prefix.
 
 ### Spring Boot Library

topics/products/phpstorm/phpstorm.md

@@ -37,4 +37,4 @@ To see how these attributes appear in the Gradle build script for PhpStorm, see
 The PHP plugin version is explicitly declared because it isn't bundled with IntelliJ IDEA Ultimate Edition.
 Select a [version](https://plugins.jetbrains.com/plugin/6610-php/versions) of the PHP plugin compatible with the [`intellij.version`](tools_gradle_intellij_plugin.md#intellij-extension-version).
 
-The dependency on the PHP plugin APIs must be declared in the <path>plugin.xml</path> file, as shown in the tutorial [Configuring plugin.xml](dev_alternate_products.md#configuring-pluginxml) section.
+The dependency on the PHP plugin APIs must be declared in the <path>[plugin.xml](plugin_configuration_file.md)</path> file, as shown in the tutorial [Configuring plugin.xml](dev_alternate_products.md#configuring-pluginxml) section.

topics/products/pycharm/pycharm.md

@@ -22,7 +22,7 @@ Click on an entry in the table's *Attribute* column to go to the documentation a
 | [`intellij.downloadSources`](tools_gradle_intellij_plugin.md#intellij-extension-downloadsources) | `false` is required because no public source code is available.                |
 | [`runIde.ideDir`](tools_gradle_intellij_plugin.md#runide-task-idedir)                            | Not needed; the Development Instance will automatically match `intellij.type`. |
 
-The dependency on the PyCharm APIs must be declared in the <path>plugin.xml</path> file.
+The dependency on the PyCharm APIs must be declared in the <path>[plugin.xml](plugin_configuration_file.md)</path> file.
 As described in [Configuring the plugin.xml File](dev_alternate_products.md#configuring-pluginxml), the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) tags must declare `com.intellij.modules.python`.
 
 See the SDK code sample [`pycharm_basics`](%gh-sdk-samples%/product_specific/pycharm_basics/) for an example configuration.

topics/products/rider/rider.md

@@ -34,7 +34,7 @@ This is useful e.g. when a plugin brings its own file templates.
 
 For the ReSharper part to pick these settings, the settings files should be available in the plugin JAR file under the path <path>dotnet/Extensions/$backend-plugin-id$/settings</path>, where `backend-plugin-id` is calculated according to the following rules:
 
-- if the IntelliJ plugin id (the [`<id>`](plugin_configuration_file.md#idea-plugin__id) element of the <path>plugin.xml</path>) includes a dot, then `backend-plugin-id` is the same as the IntelliJ plugin id;
+- if the IntelliJ plugin id (the [`<id>`](plugin_configuration_file.md#idea-plugin__id) element of the <path>[plugin.xml](plugin_configuration_file.md)</path>) includes a dot, then `backend-plugin-id` is the same as the IntelliJ plugin id;
 - otherwise, the `backend-plugin-id` is a concatenation of the IntelliJ plugin vendor name (the [`<vendor>`](plugin_configuration_file.md#idea-plugin__vendor) element of the <path>plugin.xml</path>) and the IntelliJ plugin id.
 
 For example, for a plugin with the following <path>plugin.xml</path> contents, the file <path>dotnet/Extensions/com.example.awesomeplugin/settings/templates.DotSettings</path> would be picked up:

topics/products/rubymine/rubymine.md

@@ -29,7 +29,7 @@ Product compatibility is determined from the Ruby plugin [version page](https://
 The Ruby plugin isn't bundled with `IU`, so the Ruby plugin version must be explicitly declared to support the target RubyMine (and `IU`) BRANCH.BUILD version.
 The correct Ruby plugin version is also determined from the Ruby plugin version page.
 
-The dependency on the Ruby plugin APIs must be declared in the <path>plugin.xml</path> file.
+The dependency on the Ruby plugin APIs must be declared in the <path>[plugin.xml](plugin_configuration_file.md)</path> file.
 As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) elements must contain `com.intellij.modules.ruby`.
 The dependency declaration is illustrated in the <path>plugin.xml</path> snippet below:
 

topics/products/webstorm/webstorm.md

@@ -27,7 +27,7 @@ To see how these attributes appear in a similar Gradle build script for PhpStorm
 | [`intellij.plugins`](tools_gradle_intellij_plugin.md#intellij-extension-plugins) | Dependency on the `JavaScriptLanguage` plugin.                                                                                                                                                                       |
 | [`runIde.ideDir`](tools_gradle_intellij_plugin.md#runide-task-idedir)            | Path to locally installed target version of WebStorm. For example, for macOS:<br/><path>/Users/$USERNAME$/Library/Application Support/JetBrains/Toolbox/apps/WebStorm/ch-0/192.7142.35/WebStorm.app/Contents</path>. |
 
-The dependency on the WebStorm APIs must be declared in the <path>plugin.xml</path> file.
+The dependency on the WebStorm APIs must be declared in the <path>[plugin.xml](plugin_configuration_file.md)</path> file.
 As described in [Modules Specific to Functionality](plugin_compatibility.md#modules-specific-to-functionality) table, the [`<depends>`](plugin_configuration_file.md#idea-plugin__depends) tags must declare `JavaScriptLanguage`.
 **Note** that for WebStorm, the <path>plugin.xml</path> file must also declare a dependency on `com.intellij.modules.platform` because `JavaScriptLanguage` is not recognized as a module.
 Consequently, without the `com.intellij.modules.platform` declaration the plugin is assumed to be a [legacy plugin](plugin_compatibility.md#declaring-plugin-dependencies) and will not load in WebStorm.

topics/reference_guide/color_scheme_management.md

@@ -48,7 +48,7 @@ If the scheme designer doesn't have a language plug-in, he will not be able to f
 ### Providing Attributes for Specific Schemes
 
 A language plug-in may provide default text attributes for "Default" and "Darcula" bundled schemes or basically for any other scheme if the scheme's name is known.
-This can be done in <path>plugin.xml</path> by adding an `com.intellij.additionalTextAttributes` extension providing the name of the file containing desired text attributes, for example:
+This can be done in <path>[plugin.xml](plugin_configuration_file.md)</path> by adding an `com.intellij.additionalTextAttributes` extension providing the name of the file containing desired text attributes, for example:
 
 ```xml
 <extensions defaultExtensionNs="com.intellij">

topics/reference_guide/custom_language_support/additional_minor_features.md

@@ -6,7 +6,7 @@
 
 A number of minor features are listed in the following format:
 
-_EP: `fully.qualified.extensionPointName`_ - Extension Point Name (must be specified in <path>plugin.xml</path>)
+_EP: `fully.qualified.extensionPointName`_ - Extension Point Name (must be specified in <path>[plugin.xml](plugin_configuration_file.md)</path>)
 
 _`com.extensionPoint.class`_ _description text_ - Extension Point class/interface to provide functionality
 

topics/reference_guide/custom_language_support/language_injection.md

@@ -89,7 +89,7 @@ The XML file with the injection configurations is loaded through the `org.intell
 ### Implementation
 
 It is important to make a distinction between plugin authors who want to provide injections into existing languages and plugin authors who want to provide support for IntelliLang injections in their custom language.
-Both define their injections by providing XML configurations and loading them through the <path>plugin.xml</path>.
+Both define their injections by providing XML configurations and loading them through the <path>[plugin.xml](plugin_configuration_file.md)</path>.
 However, custom language authors need to implement the `org.intellij.intelliLang.languageSupport` EP to make their language and PSI element patterns known to IntelliLang.
 Therefore, plugin authors who want to provide injections for known languages can skip the first step.
 

topics/reference_guide/frameworks_and_external_apis/external_system_integration.md

@@ -96,7 +96,7 @@ Then register the instance with `ExternalSystemProjectTracker` to start tracking
 ### Icon for Reload Notification
 
 From 2020.1, the icon for reload notification can be specified per external system.
-Implement [`ExternalSystemIconProvider`](%gh-ic%/platform/external-system-api/src/com/intellij/openapi/externalSystem/ui/ExternalSystemIconProvider.kt) and register via [com.intellij.externalIconProvider](https://jb.gg/ipe?extensions=com.intellij.externalIconProvider) extension point in <path>plugin.xml</path>.
+Implement [`ExternalSystemIconProvider`](%gh-ic%/platform/external-system-api/src/com/intellij/openapi/externalSystem/ui/ExternalSystemIconProvider.kt) and register via [com.intellij.externalIconProvider](https://jb.gg/ipe?extensions=com.intellij.externalIconProvider) extension point in <path>[plugin.xml](plugin_configuration_file.md)</path>.
 Alternatively, set `reloadIcon` field external system implements `ExternalSystemIconProvider` directly.
 
 ## Settings

topics/reference_guide/frameworks_and_external_apis/xml_dom_api.md

@@ -85,7 +85,7 @@ interface Bar extends com.intellij.util.xml.DomElement {
 ```
 
 Next, you should create a [`DomFileDescription`](%gh-ic%/xml/dom-openapi/src/com/intellij/util/xml/DomFileDescription.java) class, pass to its constructor the root tag name and root element interface.
-Register it in <path>plugin.xml</path> using `com.intellij.dom.fileMetaData` extension point and specify `rootTagName` and `domVersion`/`stubVersion` attributes.
+Register it in <path>[plugin.xml](plugin_configuration_file.md)</path> using `com.intellij.dom.fileMetaData` extension point and specify `rootTagName` and `domVersion`/`stubVersion` attributes.
 
 > When targeting 2019.1 or earlier, use `com.intellij.dom.fileDescription` extension point instead.
 >

topics/reference_guide/settings_guide.md

@@ -15,7 +15,7 @@ This document describes adding custom Settings at the Project and Application (o
 
 ## Extension Points for Settings
 
-Custom Settings implementations are declared in a plugin's configuration (<path>plugin.xml</path>) file using one of two extension points (EP), depending on the level of the Settings.
+Custom Settings implementations are declared in the <path>[plugin.xml](plugin_configuration_file.md)</path> file using one of two extension points (EP), depending on the level of the Settings.
 Many [attributes](#settings-declaration-attributes) are shared between the EP declarations.
 
 Application and Project Settings typically provide an implementation based on the [`Configurable`](%gh-ic%/platform/ide-core/src/com/intellij/openapi/options/Configurable.java) interface because they do not have runtime dependencies.

topics/reference_guide/text_selection.md

@@ -4,7 +4,7 @@
 
 ## Extending/Shrinking Text Selection
 
-Implementing [`ExtendWordSelectionHandler`](%gh-ic%/platform/lang-api/src/com/intellij/codeInsight/editorActions/ExtendWordSelectionHandler.java) and registering it as `com.intellij.extendWordSelectionHandler` EP in your <path>plugin.xml</path> allows you to provide additional text ranges to be used when extending or shrinking a selection.
+Implementing [`ExtendWordSelectionHandler`](%gh-ic%/platform/lang-api/src/com/intellij/codeInsight/editorActions/ExtendWordSelectionHandler.java) and registering it as `com.intellij.extendWordSelectionHandler` EP in your <path>[plugin.xml](plugin_configuration_file.md)</path> allows you to provide additional text ranges to be used when extending or shrinking a selection.
 Return `true` from `canSelect(PsiElement)` for the PSI elements that you want to provide additional text-ranges for.
 The IntelliJ Platform will call `select(PsiElement, CharSequence, int, Editor)` for these elements where you can compute additional text ranges and return them as `List<TextRange>`.
 

topics/reference_guide/ui_themes/themes.md

@@ -18,7 +18,7 @@ This approach provides the best user experience because it avoids an IDE restart
 
 UI Themes have several components:
 * A required Theme description (JSON) file in the plugin project's <path>resources</path> folder.
-* A required `themeProvider` declaration in the plugin's <path>plugin.xml</path> file, located in the plugin project's <path>META-INF</path> folder.
+* A required `themeProvider` declaration in the plugin's <path>[plugin.xml](plugin_configuration_file.md)</path> file, located in the plugin project's <path>META-INF</path> folder.
 * An optional Editor Scheme description (XML) file derived from an exported IDE editor scheme.
   This file is located in the plugin project's <path>resources</path> folder.
 * An optional background image file, located in the plugin project's <path>resources</path> folder.

topics/reference_guide/vcs_integration_for_plugins.md

@@ -85,7 +85,7 @@ This section describes the different components which comprise a VCS integration
 ### AbstractVcs
 
 This is the main entry point for a VCS plugin, which is used by the IntelliJ Platform to retrieve all other services provided by the plugin.
-Register `AbstractVcs` implementation in `com.intellij.vcs` extension point in <path>plugin.xml</path>, as shown in the following example:
+Register `AbstractVcs` implementation in `com.intellij.vcs` extension point in <path>[plugin.xml](plugin_configuration_file.md)</path>, as shown in the following example:
 
 ```xml
 <idea-plugin>

topics/reference_guide/work_with_icons_and_images.md

@@ -72,7 +72,7 @@ object MyIcons {
 {type="note"}
 
 
-Use these constants inside <path>plugin.xml</path> when specifying `icon` attribute for [`<action>`](plugin_configuration_file.md#idea-plugin__actions__action) or extension point, as well in [`@Presentation`](%gh-ic%/platform/analysis-api/src/com/intellij/ide/presentation/Presentation.java) `icon` attribute.
+Use these constants inside <path>[plugin.xml](plugin_configuration_file.md)</path> when specifying `icon` attribute for [`<action>`](plugin_configuration_file.md#idea-plugin__actions__action) or extension point, as well in [`@Presentation`](%gh-ic%/platform/analysis-api/src/com/intellij/ide/presentation/Presentation.java) `icon` attribute.
 Note that the package name `icons` will be automatically prefixed and must not be specified.
 
 ```xml

topics/tutorials/action_system/grouping_action.md

@@ -15,7 +15,7 @@ The group is based on a default IntelliJ Platform implementation.
 
 ### Creating Simple Groups
 
-Grouping can be registered by adding a [`<group>`](plugin_configuration_file.md#idea-plugin__actions__group) element to the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section of a plugin's <path>plugin.xml</path> file.
+Grouping can be registered by adding a [`<group>`](plugin_configuration_file.md#idea-plugin__actions__group) element to the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section of a plugin's <path>[plugin.xml](plugin_configuration_file.md)</path> file.
 This example has no `class` attribute in the `<group>` element because the IntelliJ Platform framework will supply a default implementation class for the group.
 This default implementation is used if a set of actions belonging to the group is static, i.e., does not change at runtime, which is the majority of cases.
 The `id` attribute must be unique, so incorporating the plugin ID or package name is the best practice.

topics/tutorials/action_system/working_with_custom_actions.md

@@ -51,7 +51,7 @@ Before fleshing out those methods, to complete this minimal implementation, `Pop
 
 ## Registering a Custom Action
 
-Actions are registered by declaring them in code or by declaring them in the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section of a plugin configuration (<path>plugin.xml</path>) file.
+Actions are registered by declaring them in code or by declaring them in the [`<actions>`](plugin_configuration_file.md#idea-plugin__actions) section of a [plugin configuration file](plugin_configuration_file.md).
 This section describes using IDE tooling - the <control>New Action</control> form - to add a declaration to the <path>plugin.xml</path> file, and then tuning registration attributes manually.
 A more comprehensive explanation of action registration is available in the [](basic_action_system.md#registering-actions) section of this guide.
 

topics/tutorials/code_documentation.md

@@ -12,7 +12,7 @@ Implementations of `DocumentationProvider` can be registered either at the `com.
 `com.intellij.lang.documentationProvider` extension point (EP).
 It is recommended to use the latter one when creating documentation that targets a specific language because providers registered
 as `com.intellij.lang.documentationProvider` will only be called for elements from that language.
-This is the reason they require the `language` attribute when registering the EP in the <path>plugin.xml</path>.
+This is the reason they require the `language` attribute when registering the EP in the <path>[plugin.xml](plugin_configuration_file.md)</path>.
 The bigger picture here is that documentation providers co-exist and if there is more than one provider for the same element,
 the first one that returns a value different from `null` wins.
 

topics/tutorials/code_inspections.md

@@ -35,7 +35,7 @@ The overall approach works for inspections aimed at other languages as well.
   For example, the Java/Probable Bugs inspection <control>Object comparison using '==', instead of 'equals()'</control> is very similar to `comparing_references_inspection`.
 * Use the display name text as the [target for a search](https://www.jetbrains.com/help/idea/finding-and-replacing-text-in-project.html) within the _intellij_community_ project.
   This will identify a bundle file if the display name is localized.
-  If it is not localized, the search finds either the plugin configuration (<path>plugin.xml</path>) file where it is an attribute in the inspection description, or the implementation where it is provided by an overridden method.
+  If it is not localized, the search finds either the <path>[plugin.xml](plugin_configuration_file.md)</path> file where it is an attribute in the inspection description, or the implementation where it is provided by an overridden method.
 * In the case of localization, copy the key from the bundle file identified by the search.
   * Use the key text as the target for a search within the _intellij_community_ project.
     This search locates the plugin configuration file that describes the inspection.

topics/tutorials/custom_language_support/annotator.md

@@ -38,7 +38,7 @@ intellij {
 </tab>
 </tabs>
 
-Then, declare the dependency in <path>plugin.xml</path> (use code insight)
+Then, declare the dependency in <path>[plugin.xml](plugin_configuration_file.md)</path> (use code insight)
 
 ```xml
 <depends>com.intellij.java</depends>

topics/tutorials/custom_language_support/documentation_provider.md

@@ -15,7 +15,7 @@ the file where it is defined, and any related documentation comment.
 
 In the first step, we create an empty class that extends
 [`AbstractDocumentationProvider`](%gh-ic%/platform/analysis-api/src/com/intellij/lang/documentation/AbstractDocumentationProvider.java)
-and registers it in the <path>plugin.xml</path>.
+and register it in the <path>[plugin.xml](plugin_configuration_file.md)</path>.
 
 ```java
 public class SimpleDocumentationProvider extends AbstractDocumentationProvider { }

topics/tutorials/custom_language_support/language_and_filetype.md

@@ -48,7 +48,7 @@ The Simple Language file type is defined by subclassing [`LanguageFileType`](%gh
 
 <tab title="2019.2 and later">
 
-The Simple Language file type is registered via the `com.intellij.fileType` extension point in <path>plugin.xml</path> and registered with <path>*.simple</path> extension:
+The Simple Language file type is registered via the `com.intellij.fileType` extension point in <path>[plugin.xml](plugin_configuration_file.md)</path> and registered with <path>*.simple</path> extension:
 
 ```xml
 <extensions defaultExtensionNs="com.intellij">

topics/tutorials/custom_language_support/lexer_and_parser_definition.md

@@ -58,7 +58,7 @@ The Simple Language parser is defined by subclassing [`ParserDefinition`](%gh-ic
 
 ## Register the Parser Definition
 
-Registering the parser definition in the <path>plugin.xml</path> file makes it available to the IntelliJ Platform.
+Registering the parser definition in the <path>[plugin.xml](plugin_configuration_file.md)</path> file makes it available to the IntelliJ Platform.
 Use the `com.intellij.lang.parserDefinition` extension point for registration.
 For example, see <path>simple_language_plugin/src/main/resources/META-INF/plugin.xml</path>.
 

topics/tutorials/kotlin.md

@@ -127,7 +127,7 @@ Depending on exact functionality, a plugin can also target [UAST (Unified Abstra
 
 Plugins *may* use [Kotlin classes](https://kotlinlang.org/docs/classes.html) to implement declarations in the [plugin configuration file](plugin_configuration_file.md).
 When registering an extension, the platform uses a dependency injection framework to instantiate these classes.
-For this reason, plugins *must not* use [Kotlin objects](https://kotlinlang.org/docs/object-declarations.html) to implement any <path>plugin.xml</path> declarations.
+For this reason, plugins *must not* use [Kotlin objects](https://kotlinlang.org/docs/object-declarations.html) to implement any <path>[plugin.xml](plugin_configuration_file.md)</path> declarations.
 
 ## Examples
 

topics/tutorials/project_wizard/adding_new_steps.md

@@ -12,7 +12,7 @@ See [Creating a Plugin Project](gradle_build_system.md) to know how to do it.
 ## Register Module Builder
 
 Project configuration settings depend on the project's module type.
-Register a new `com.intellij.moduleBuilder` extension point in the <path>plugin.xml</path> configuration file.
+Register a new `com.intellij.moduleBuilder` extension point in the <path>[plugin.xml](plugin_configuration_file.md)</path> configuration file.
 
 ```xml
 <extensions defaultExtensionNs="com.intellij">

topics/tutorials/project_wizard/module_types.md

@@ -18,7 +18,7 @@ Create an empty plugin project, see [Creating a Plugin Project](gradle_build_sys
 
 ## Register a New Module Type
 
-Add a new `com.intellij.moduleType` implementation with the IntelliJ Platform in the <path>plugin.xml</path> configuration file.
+Add a new `com.intellij.moduleType` implementation with the IntelliJ Platform in the <path>[plugin.xml](plugin_configuration_file.md)</path> configuration file.
 
 ```xml
 <extensions defaultExtensionNs="com.intellij">

topics/tutorials/settings_tutorial.md

@@ -33,7 +33,7 @@ It is based on the [IntelliJ Platform Persistence Model](persisting_state_of_com
 
 ### Declaring AppSettingsState
 
-Given a [Light Service](plugin_services.md#light-services) is not used, the persistent data class must be declared as a [Service](plugin_services.md#declaring-a-service) EP in the <path>plugin.xml</path> file.
+Given a [Light Service](plugin_services.md#light-services) is not used, the persistent data class must be declared as a [Service](plugin_services.md#declaring-a-service) EP in the <path>[plugin.xml](plugin_configuration_file.md)</path> file.
 If these were Project Settings, the `com.intellij.projectService` EP would be used.
 However, because these are Application Settings, the `com.intellij.applicationService` EP is used with the fully qualified name (FQN) of the implementation class:
 

topics/user_interface_components/notifications.md

@@ -62,7 +62,7 @@ Please see the following steps for setup, depending on the target platform versi
 
 <tab title="2020.3 and later">
 
-`NotificationGroup` is registered in <path>plugin.xml</path> using `com.intellij.notificationGroup` extension point.
+`NotificationGroup` is registered in <path>[plugin.xml](plugin_configuration_file.md)</path> using `com.intellij.notificationGroup` extension point.
 Use `key` to provide a localized group display name.
 
 ```xml

topics/user_interface_components/tool_windows.md

@@ -19,7 +19,7 @@ Project-level topic [`ToolWindowManagerListener`](%gh-ic%/platform/platform-impl
 
 ### Declarative Setup
 
-The tool window is registered in <path>plugin.xml</path> using the `com.intellij.toolWindow` extension point.
+The tool window is registered in <path>[plugin.xml](plugin_configuration_file.md)</path> using the `com.intellij.toolWindow` extension point.
 The extension point attributes specify all the data which is necessary to display the tool window button:
 
 *  The `id` of the tool window - corresponds to the text displayed on the tool window button.