IntelliJ Elixir Plugin

The IntelliJ Elixir plugin is compatible with a wide range of JetBrains IDEs. It is categorized into two types:

1. Rich IDEs: These allow you to set an Elixir SDK as the Project SDK. This is the recommended way to use the plugin as it simplifies the configuration for running elixir, erl, or mix.
2. Small IDEs: These are language-specific IDEs where the native language SDK is always present. Using Elixir in these IDEs requires more complex manual configuration for SDK-dependent tools.

The plugin is free to use in all JetBrains IDEs, regardless of the IDE's own licensing model.

The StrT chunk contains a contiguous pool of Erlang strings (Elixir charlists) used in the Code chunk for byte code operations like bs_put_string.

Key details:

• Not all strings appear in StrT. Most Elixir strings (Erlang binaries) are stored in the LitT (literals) chunk.
• The chunk does not encode the start and length of each string internally; instead, the start and length are passed as arguments to the byte code operations in the Code chunk. This allows for efficient encoding of shared substrings.

Sources

Mark directories as:

• Excluded
• Sources
• Tests

Paths

Configures output directories for compilation:

• Output path: For dev MIX_ENV.
• Test output path: For test MIX_ENV.

Dependencies

Mix dependencies from deps/ are automatically detected and registered as IDE Libraries via background file system monitoring of deps/ and _build/.

• Automatic Detection: Triggered by mix deps.get, mix compile, or folder deletions.
• Structure: Creates an IDE Library with source roots from deps/APP/lib and class roots from _build/ENV/lib/APP/ebin.
• Troubleshooting: If dependencies don't appear after mix deps.get, run mix compile to generate _build/ output, then wait for the file watcher. Alternatively, use Tools → Elixir → Install Mix Dependencies.

When choosing an IDE for Elixir development with this plugin, consider the distinction between 'Rich' and 'Small' IDEs:

• Rich IDEs (e.g., IntelliJ IDEA Community/Ultimate) allow you to define the Elixir SDK as the primary Project SDK. This provides the most seamless experience for internal and external tool integration.
• Small IDEs (e.g., PyCharm, WebStorm, GoLand, etc.) are language-specific. Because the native language SDK is always prioritized, you will need to perform additional configuration steps to ensure tools like elixir, erl, and mix work correctly.

The ExDc chunk stores documentation attributes (@doc, @moduledoc, and @typedoc) extracted from the BEAM file. This is the same data consulted by the h helper in iex.

Navigation Tree

The ExDc tab uses a tree to navigate documentation levels. Selecting a node shows documentation for that level and its descendants:

Elements in the Structure tool window are identified by icons representing their lifecycle and visibility:

Time (Lifecycle)

• Compile Time: The element is used or checked at compile time and may not be accessible at runtime (e.g., macros).
• Runtime: The element is usable at runtime (e.g., functions).

Visibility

• Public: The element is accessible outside its defining module.
• Private: The element is only accessible within its defining module (macros defining private elements often end in p).

In Elixir, keywords must appear at the end of an argument list. The 'Keywords Not At End' inspection detects when keywords appear before other positional arguments in a list.

To fix this, either wrap the preceding expression in parentheses or move the keywords to the very end of the argument list.

Anonymous functions (defined with fn in Elixir or fun in Erlang) do not exist as distinct entities in the BEAM format. Instead, they are represented as named functions in the LocT chunk.

Their names follow a specific pattern: they start with a hyphen -, followed by the parent function's name, a forward slash /, and a unique number for that scope (e.g., -<PARENT_FUNCTION>/<NUMBER>-fun-<INDEX>-).

Example of a decompiled anonymous function name: defp unquote(:"-MACRO-binding/2-fun-0-")(p0, p1, p2, p3)

defp unquote(:"-MACRO-binding/2-fun-0-")(p0, p1, p2, p3) do
  # body not decompiled
end

The 'Ambiguous parentheses' inspection detects spaces between a function name and its opening parentheses. This prevents the compiler from distinguishing between a function call with parentheses and a function call without parentheses where the first argument is a parenthetical group.

Common scenarios:

• Empty Parentheses: function () should be function().
• Keywords in Parentheses: function (key: value) should be function(key: value).
• Positional arguments in Parentheses: function (arg1, arg2) should be function(arg1, arg2).

# Ambiguous
function ()

# Fixed (no arguments)
function()

# Fixed (first argument is an empty tuple)
function(())

In the IntelliJ Elixir Structure View, functions marked as overridable via defoverridable are visually distinguished.

• defoverridable declaration: Marked with an Overridable icon. It acts as a parent element in the structure tree.
• Overridable functions: The specific functions being made overridable appear as children of the defoverridable element. They are displayed with the NAME/ARITY format and include the Overridable icon to distinguish them from standard functions.