Version 1.1 Released

Hello folks!

We have included a number of new Haxe 4 features as well as increased the responsiveness of IDEA when editing Haxe sources.

You can pick it up at the usual places:

  • Inside of the IntelliJ IDE: Find it in your menus: `File -> Settings… -> Plugins -> Haxe Toolkit`
  • On github. (
  • On JetBrains’ plugin repository.


Change notes:

1.1 (HaxeFoundation release)

  • Added support of haxe 4 syntax “enum abstract”.
  • Add support of final syntax introduced in Haxe 4.
  • Add support of new function types syntax introduced in Haxe 4.
  • Increased responsiveness in UI, annotations, and other operations that look up type information by a factor of 10.
  • Now infers generic types from map and array literals. (e.g. [“this” => “yours”] is Map).
  • Now resolves typedefs to underlying types. (e.g. `var v:Null` is resolved as a `String` type.)
  • Now propagates type parameters (generics) properly through typedefs.
  • Now resolves types when used with array access (e.g. `map[0].length` no longer marked as errors).
  • Now infers types of methods without specific typing (e.g. `map.get(0).length` no longer marked as errors).
  • Added support of read/write access separation for “find usages”.
  • Inspections for non-haxe files disabled. (Issue #875)
  • Fixed recognizing type of “this” expression.
  • Fixed bug when physical variables were marked as not real.
  • Fixed searching of interface implementations and inheritance hierarchy.
  • Added find usages support for constructors. (Issue #530)
  • Fixed find usages support for properties.
  • Add completion dropdown when ‘:’ is typed and a type is expected.
  • Fix of support of explicit abstract forwards. Now fields and methods that have not been forwarded will not be resolved as valid.
  • Fixed recognition of standard types.
  • Fixed NPE that occurred if current project sdk was not properly configured.
  • Fix indents for anonymous structures fields and extends list.
  • Fix indents for fat arrow expressions.
  • Fix parsing of anonymous type with empty body.
  • Add anonymous types in anonymous types support.
  • Add anonymous structures names support.
  • Added chained anonymous fields recognition.
  • Add proper generics propagation for anonymous structures, typedefs and classes.
  • Add generic constraint support.
  • Add Null<T> support.
  • Add proper from-to declaration support, types infer and compatibility checks.
  • Fix referenced var-init support check.
  • Automatically change references when moving a class across packages.
  • Add super() call when generating override methods.
  • Generate module and automatically set up SDK, libraries, and run configurations on “Import project from sources.”
  • Create “Hello World” example as initial content for new projects.
  • Auto-open Main.hx when creating a new module.

Version 1.0.0 Released

Hello folks!

We are proud to announce our 1.0.0 release of the intellij-haxe plugin.  The major version number change is because we’ve broken backward source compatibility rather than for reaching any particular product milestone.  As of this release, we’ve moved to Java 8 and the sources no longer build with versions of IDEA prior to 2016.1.  Accordingly, we no longer provide a pre-built product for those versions of IDEA.  (Be sure to contact our professional support team if you need support for older versions.)

Shiny Things!

There are a few important changes we would like to point out:

  • Semantic Annotation has been greatly improved.  Many items which were marked as errors are no longer errors; most notably, Map initializers.
  • Completion has been enhanced to show Enumerations (values).
  • Folding support has been added, and many types of regions are recognized, including those from other popular IDEs.

Installation instructions are available in our WIKI pages.

We need your help

Also, if you use the product regularly — particularly if you use it in your work or business — we would appreciate your patronage.  Our corporate sponsors are generous (and very much appreciated) and they currently only provide a portion of the financial support required to keep this as a full-time project.  For us to continue at our current pace, we need you to get directly involved.

Individuals should visit the links on the right of this page to support active contributors — plus there are perks!  Businesses should consider support contracts which give specific levels of service and underwrite business-critical features.

The Haxe Foundation does not currently provide any support of this project.

Change notes:

  • Add $trace to the list of built-ins to recognize.
  • Semantic Annotation: Infer missing function types from code blocks.
  • Semantic Annotation: Support arrow functions.
  • Semantic Annotation: Add local variable type checking.
  • Properly detect function types when used in type parameters (generics).
  • Fix Flash “Run” target to launch the file that the compile process creates.
  • Non-OpenFL projects now use a better algorithm to determine output directories and files.
  • Add source directories to classpath during compiler completions. (More completions, fewer errors.)
  • Use non-haxe-logo version of icons when completions are not provided by the compiler.
  • Compatibility fix for non-IDEA products: stop logging to stderr! (Issue #724)
  • Improved Enum parsing; added generalized algebraic data types support.
  • Add true Map literal support. (No longer parsed as Array.)
  • Added visibility detection rules (e.g. @NoCompletion) regarding language docs.
  • Fixes to error message parsing (no longer account info messages to JetBrains installation directory).
  • Split ‘lime test’ into ‘lime update; lime build’ and ‘lime run’, for Make and Run/Debug tasks.
  • Add folding support:
    • For documentation comments (/** */).
    • For comment regions. (// region Name … // end region) (Issue #529)
    • Braces for classes, methods, etc.
    • For imports and usings.
    • For compiler conditionals (#if, etc.)
  • Fixed a number of NPEs in the ProjectUpdater.
  • Add enums from the current file completion suggestion lists.
  • Fixed the resolution order for imports vs. package. (Issue #741)
  • Fixed inability to resolve enum parameter symbols at case statement. (Issue #351)
  • Dropped support for IDEA versions 14 and 15.
  • Internal: Began refactoring the resolver. New models are introduced.
  • Changed “static variable override” to a weak warning, instead of a regular warning.
  • Imports handling has been refactored.
  • Allow @:meta without parens.
  • Properly parse variable declarations in return statements. (Issue #329)
  • Fixed parsing of ‘throw’ statements within a ternary expression. (Issue #704)
  • Allow all string literal forms as field identifiers in structures. (Issue #662)

Release 0.11.2 is now available.

We are proud to release our 0.11.2 release of the IntelliJ-Haxe plugin.  We’ve been hard at work fixing parsing issues and adding new usability features.  Chief among the latter is that “Find Usages” now presents the option to search for usages of a parent interface method instead of just the instance under the cursor.  You’ll also find that the automatic project updates to haxelib dependencies has been rewritten — and can be disabled via the user interface.  Now, it traverses the entire dependency tree and adds all of the libraries that the compiler would.  It’s also been made a LOT faster.

In related news: The Haxe Foundation’s fork of the plugin’s sources have now become the primary repository; JetBrains made their repository a fork of ours!  This is great news because it means that searches for Haxe and IntelliJ on github (and other search engines!) now point to our project rather than the inactive sources that JetBrains had originally provided.

The full sources and associated release notes can be found at github:

The plugin can be downloaded within IntelliJ-IDEA by following the installation instructions here.

As always… Enjoy!



Release 0.11.1 is now available.

Hi folks,

Today, we released version 0.11.1 of the IntelliJ-Haxe plugin.  You can pick it up in JetBrains plugin repository, or on github.

This is primarily a bug-fix version, but you will likely be happy about seeing these fixed:

  • Check for and halt type resolution when a cyclical/recursive definition is found.
  • Address some freezes by delaying use of indices until indexing is complete.
  • Speed haxelib syncing (and stop unnecessary re-indexing). (Regression)
  • Fix freezes by fixing some multi-threading issues and other exceptions being thrown.
  • Speed up parsing of arrow functions.
  • Add Haxe-specific double-click selection logic for strings and comments. (Issue #212)
  • Reroute debugging informational errors to the status bar instead of modal dialogs.
  • Fix compilation halting on “- Link” informational messages.
  • Add neko and haxelib directories to the path when building projects (for all platforms; used to be OSX-only).
  • Fix multi-platform build issues (for the plugin, particularly affects Windows builds).

Take a test drive and tell us what you think! We love to hear from you.