IntelliJ IDEA 2018.1 Help

Using Language Injections

You can inject a language (such as HTML, CSS, XML, SQL, RegExp, etc.) into a string literal in your code and, as a result, get comprehensive coding assistance when editing that literal.

Prerequisite

For language injection features to be available, the IntelliLang plugin must be enabled. (This plugin is bundled with the IDE and enabled by default.)

Example: Injecting HTML. Opening a fragment editor

To get an impression of how language injections work:

  1. Create a Java class and open that class in the editor.
  2. Within the class body, type:
    String s = "";
  3. Place the cursor between the quotation marks.
  4. Click quick fix large or press Alt+Enter, select Inject language or reference, and then select HTML (HTML files).
  5. Type:
    <body><h1>Hello, World!</h1></body>
    java injected html added

    When typing, note that auto-completion for HTML tags is now available. Also note how the HTML code is highlighted.

  6. Let's now open a fragment editor for the injected HTML code: press Alt+Enter and select Edit HTML Fragment.
    java injected html edit

    Here is the result:

    java injected html editor

    You can use the fragment editor as an alternative (or in addition) to editing injected string literals in the "main editor".

  7. To complete the example, let's cancel the injection: switch to the main editor, press Alt+Enter and select Un-inject Language/Reference.

    Note that the text between the quotation marks has become green which is the default color for string values. This indicates that the value in the quotation marks is now treated simply as text.

    java html uninjected

    Don't close the editor yet. Later in this topic, we'll use our Java class for showing other language injection features.

Accessing language injection functions

Most of the functions related to language injections are accessed through a "light bulb menu" (quick fix large or Alt+Enter).

Ways to inject a language

You can inject a language by using:

Using language injection comments

To inject a language by means of an injection comment, on a separate line preceding the one that contains the target string literal, add:

// language=<language_ID>

e.g.

// language=HTML

NOTE: The syntax of comments should be appropriate for the language that you are using. So you may want to use # language=... or -- language=... rather than // language=....

Example

  1. On the line preceding String s = "...";, type // language=HTML.
  2. Check the light bulb menu (Alt+Enter).
    java injection comment html

    As you can see, HTML has been injected into the string literal.

  3. Remove the commented line (e.g. Ctrl+Y) to come back to the previous state.

Language IDs

The language IDs, generally, are intuitive, e.g. MySQL, RegExp, XML, HTML. If not sure about the language ID, use the suggestion list for the Inject language or reference command. What precedes the opening parentheses there is the language IDs.

See also, Using language injection prefixes and suffixes.

Using the @Language annotation

In Java code, you can use the @Language("language_ID") annotation.

To be able to use this annotation: 1) the annotations.jar (or annotations-java8.jar) file should be included in your module dependencies and 2) the import org.intellij.lang.annotations.Language; statement should be added to your class file. For both these tasks, IntelliJ IDEA provides the intention actions as shown in the Example that follows.

In other respects, the @Language annotation works similarly to the injection comments.

Example

  1. On the line preceding String s = "...";, type @Language("HTML").

    If you haven't used this annotation in your project yet:

  2. To add annotations.jar to the module dependencies: place the cursor within Language, press Alt+Enter and select Add 'annotations' to classpath.
    java inject html annotation to classpath

    In the dialog that opens, just click OK.

    java inject annotations lib
  3. If IntelliJ IDEA suggests adding the import statement, just press Alt+Enter. Otherwise, press Alt+Enter and select Import class.
    java inject html annotation import class

    In both cases, the result will look something like this:

    java inject annotation html injected
  4. Place the cursor within the string literal and check the light bulb menu (Alt+Enter) to see that HTML has been injected.
    java inject annotation html edit
  5. Remove the @Language("HTML") line to return to the previous state (Ctrl+Y).

Accessing injection settings

To access the language injection settings:

  1. Open the Settings / Preferences dialog (e.g. Ctrl+Alt+S).
  2. Go to the Language Injections page: Editor | Language Injections.

For more info, see Language Injections page.

Using language injection prefixes and suffixes

A language fragment may be combined with a prefix and a suffix which together act as a wrapper, thereby turning the fragment into a syntactically complete language unit. When editing your code, you can see the prefix and the suffix only in the fragment editor. They are not shown in the main editor.

The prefix and the suffix can be included in the injection comment as follows:

// language=<language_ID> prefix=<prefix> suffix=<suffix>

The prefix and suffix attributes are optional.

Example

In this example, we'll remove the opening and closing <body> tags from the injected code fragment and add these tags to the injection comment as the prefix and suffix.

  1. Remove the opening and closing <body> tags: e.g. place the cursor within the injected fragment, press Ctrl+Shift+Delete and select Remove Enclosing Tag body.
  2. On the line preceding String s = "...";, type // language=HTML prefix=<body> suffix=</body>
  3. For the injected fragment, open the fragment editor.
    java inject html prefix and suffix

    Compare the fragments shown in the main and in the fragment editors.

Last modified: 24 July 2018
Generating JavaDoc Reference for a ProjectNavigating Through the Source Code

See Also

Procedures:

Reference:

External Links: