CHANGELOG.md

Changelog

1.5.4

• Bugfix: import would be displayed as unused if last reference in a file was a fully qualified reference.
• Bugfix: Fixing problem with resolving setter method reference from property.
• Bugfix: Imports would not be added automatically when package statement was missing.
• Fixed: Constraints and defaults could not be used together in type generics
• Fixed: Type-hierarchy would not include types that contained generics
• Improvement: major rework of completion suggestions
  • Added completion for constructors
  • Added public static members to completion suggestions
  • Added auto insertion of import statement if missing
  • Fixed documentation lookup for indexed items
  • Fixed issue for classes with identical names
  • Ignoring files in platform specific implementations of standard library (_std)
  • Changed the rendering of the completion elements to look more like the intellij default.
  • initial attempt at prioritizing lookup elements by relevance.

1.5.3

• Fixed: Problem displaying import suggestions in Intellij 2024.1
• Improvement: Syntax highlighting for metadata arguments
• Improvement: Changed parser so it can handle parenthesis in the middle of functionTypes (ex. Int->(Array<String>->void))
• Misc: Initial attempt at resolving types for macro expressions
• Misc: Bugfixes

1.5.2

• Fixed: Methods and properties in module scope are now resolved correctly.
• Fixed: Issue with reification parsing
• Fixed: Issue parsing switchCaseExtractors in objectLiterals
• Fixed: Issue with Enum unification
• Fixed: Issue where try-catch valueExpressions was not correctly evaluated
• Fixed: Typedefs are now fully resolved to find Enum values from modules imported using using statements
• Fixed: Incorrect type parameter use in some cases where Method typeParameter and classParameter was the same name.

1.5.1

• Fixed: Issue setting up Haxe SDK in intelliJ 2024.1

1.5.0

• Improvement: Better type inferences

• Improvement: Better resolve of TypeParameters (generics)

• Fixed: Incorrect parsing of functionTypes where old and new styles where mixed.

• Added: Support for enum extractors in switch-case with array expressions.

• Misc: Lots of minor improvements (mostly for resolver and annotators).

• Known issues:

  • Resolver might not select correct method when extension methods and member methods got the same name.
  • Parser fails to parse more complex cases of Reification

1.4.47

• Fixed: Incorrect sorting of Project roots
• Fixed: Resolve of super types would fail when type was import alias
• Fixed: Issue where cached values where not invalidated correctly (type names)
• Fixed: Try-catch value expressions was not resolved correctly to type
• Fixed: loop iterators would not resolve correctly.
• Fixed: Nested enum extractor expressions did not resolve type.
• Fixed: Type-from-usage resolver could in some cases prefer unknown type parameters over real ones.
• Added: syntax highlighting on reification expressions
• Improvement: Better type resolve for parameters without type tag in functionLiterals

1.4.46

• Bugfix: The plugin was unable to resolve types if an abstract enum had defined enum values with identical name.
• Change: Misc work to reduce memory footprint for import statements.

1.4.45

• Added: Support for Intellij 2024.1
• Fixed: Parser bug not recognizing top-level variables without modifiers
• Fixed: Lexer incorrectly included whitespace in "external" keyword token
• Fixed: Allow referencing constructors using new keyword (MyClass.new)
• Fixed: Arguments with default values was not treated as optional
• Added: support for implicit cast to/from function types.
• Changed: show warning instead of error when type compare is not possible.
• Misc: added a bunch of null safety fixes.

1.4.44

• Fixed: Issue where parser would pass recursion limit
• Fixed: TypeParameter was shown instead of resolved type for enum extractor inlay
• Fixed: Bug in unused imports where usage in callExpressions where ignored.
• Changed : buggy logic that resolves generics from call expressions has been rewritten.
• Added: More guards against stack overflow (abstracts to/from cast circularity etc)

1.4.43

• Adding overflow guard when converting GenericSpecialization to genericResolver

1.4.42

• Bugfix: Function bindings was incorrectly treated as static extensions
• Bugfix: Stack overflow when resolving expression type
• Misc resolver tweaks to better resolve untyped parameters and performance

1.4.41

• Bugfix: fixed type resolve regression for iterators

1.4.40

• Fixed: incomplete member list for anonymous strcutures
• Fixed: wrongfully marking wildcard import statement as unused
• Improved: Better support for untyped parameters in function literals
• Improved: Better support for default values for generics
• Added: Honoring @:noUsing meta when resolving extension methods
• Fixed: Incorrect parsing of some macro expressions
• Fixed: Incorrect parsing of some switchCaseBlocks

1.4.39

• Added: More format options for minimum newlines
• Fixed: Unused imports bugfix (fully qualified references would mask normal references)
• Added: Checking typeParameters in new expressions.
• Added: Misc. debug and trace logging for debugging resolver bugs.

1.4.38

• Trying to fix some minor resolver regression

1.4.37

• Fixed: Issue where function-literal would show error if assigned to variable of type Dynamic or Any
• Improved: Better type resolve when generics are specified through constructor
• Misc other resolver changes for better type detection.

1.4.36

• Fixed: Restored broken formatting rules
• Fixed: Prevent anonymous types from being formatted as code-blocks

1.4.35

• Fixed: Assign hint was not working when resolving function return type.

1.4.34

• Improved: Better typechecking for implicit casts to typedefs.
• Changed: Avoiding testing OR operator on EnumValues.
• Fixed: incorrect error on uninitialized static final vars in extern types.

1.4.33

• Fixed: Another case where types where resolved to enumValue

1.4.31

• Fixed: Issue where classes with identical names as Enumvalues would resolve to enumvalue
• Added: Indent options under haxe code style (PR #1148 from virtulis)

1.4.30

• Fixed: Resolver bug

1.4.29

• Fixed: Incorrect resolver caching
• Fixed: Incorrect type compare when checking interface implementations

1.4.28

• Fixed: Allow final keyword in anonymous structures
• Fixed: Check inherited members from classes when comparing anonymous types with classes
• Improvement: Use switch expression as enum type hint when resolving case expressions.
• Misc: Caching class inherit lists

1.4.27

• Fixed: broken macro type conversion
• Improved: Resolve parameter-type from init-expression when typeTag is missing.
• Improved: Use field type as hint when class and enumValue names causes resolve conflicts.
• Improved: Null-safety fixes and overflow prevention.
• Improved: Misc improvements to auto-completion suggestions.

1.4.26

• Fixed: Parser bug that caused massive slowdown in code with many level nested structures
• Fixed: Return type inlay was not placed correctly in some cases.
• Improved: Better type checking for parameters and assignment expressions.

1.4.25

• Improved: how function types where resolved
• Improved: how call expressions with function types where checked.
• Fixed: now resolving values from Null and typeDef when checking if field is callable
• Fixed: typedefs of function types should now resolve correctly
• Fixed: Introduce variable feature for introduce key-value intention
• Fixed: Issue where members of anonymous structures using type-parameters did not resolve.
• Added: Suggest enum values for case completion in switch blocks.

1.4.22

• Added: Auto-detect preprocessing definitions from build config (enabled by default)

This feature can be disabled under Settings -> Build, Execution, Deployment -> Haxe. If disabled only manually configured definitions will be used.

Auto-detected definitions can be overridden with user defined definitions or removed by setting definition value = *UNSET*

• Added: Completion suggestions for preprocessor definitions
• Added: Support for resolving & completion for typeParameters with anonymous structures.
• Added: Check argument types in call expressions for functionTypes from typeParameters.
• Improvement: better handling of import statements with aliases.
• Added: Documentation and examples for intentions
• Misc NPE fixes.

1.4.21

• Added: Support for comment line/block command in HXML files
• Improvement: Attempt at restoring Member pull up refactoring
• Improvement: Attempt at restoring Member push down refactoring
• Improvement: Attempt at restoring extract to interface refactoring
• Added: intent for convert variable to property
• Added: intent for convert property to variable
• Added: intent for creating for loop from variables implementing iterator
• Improved type resolving for key-value loops
• Improvement: Reworked keyword completion
• Fixed: Incorrect keyword suggestions (KNEVER-> never, KTO -> to, KFROM -> from)
• Fixed: Type completion should now allow identical names if package is different
• Fixed: callExpression annotator now checks for @:callable
• Misc NPE fixes.

1.4.20

• Added: Allow Extract method from fields
• Bugfix: Extract method did not return value when used in var/field init expressions
• Bugfix: Extract method did not include parameters from parent method
• Bugfix: Extract method parameter list was not formatted correctly
• Bugfix: Extract method was not correctly handling trailing semicolon
• Bugfix: Name suggestion for Extract Method was suggestion names from outside selection

1.4.19

• Added: Intent for adding/removing type tags (return types & variable types)
• Added: Very basic Extract Method support
• Minor tweaks for Intellij 2023.3 Support

1.4.18

• Support for Intellij 2023.3
• Improvement: Better support for local functions
• Improvement: Better support for anonymous structure extensions
• Changed: Switched to EcmaScript Regexp as injected regex language
• Bugfix: untyped return values was incorrectly treated as the expression type
• bugfix: Resolver was resolving enumValue instead of typeParameter when identical names were used.

1.4.17

• Bugfix: Fixed broken caching logic (Broken in 1.4.15, Disabled in 1.4.16, Fixed in 1.4.17)
• Improvement: Show Warnings instead of errors when class may have code generated by macros compile time (@:Build/ @:AutoBuild).
• Improvement: Better TypeParameter handling for methods with optional parameters
• Improvement: Better TypeParameter resolving when not defined in init expression.

1.4.16

• Hotfix: Disabling broken caching that broke assign checks and could lead to memory leaks.
• Improvement: Resolve typeParameter for function types
• Improvement: Handle implicit cast of function types
• bugfix: Fixed issue where type parameters in some cases where treated as real types.
• bugfix: Allow subclass of T to be assigned to Class
• Added: show error when variable without type is assigned to Void expression

1.4.15

• Improvement: Large performance improvement for projects with complex type inheritance graphs
• Improvement: Resolving same package types across libraries
• Added: support for resolve variable type from usage
• Bugfix: Module layer in psi broke type hierarchy resolving.
• Bugfix: Fixed type resolve for parameters with only default value
• Bugfix: Fixed incorrect error on fields defined by interfaces

1.4.14

• Replacing deprecated APIs and using idea 2023.2 as baseline
• Fixed: Allow module level keywords for module fields. (#1135)
• Fixed: Allow trailing commas in anonymousTypeField list
• Fixed: Incorrect resolve order (defined in function vs inherited class member)
• Fixed: incorrect error highlighting on abstract classes with interfaces (#1136)
• Fixed: incorrect error highlighting on bitwise xor (#1137)
• Fixed: Regular expressions where incorrectly shown as dynamic in inlays
• Change: Regex rules changed from Java to JS to better match Haxe rules.
• Reworked resolving logic to better support modules and EnumValues.

1.4.13

• Added: Quick fix for incorrect extends and implements (#940)
• Fixed: Resolving type from inline method calls (#868)
• Fixed: Automatic import was placed after class Doc comment (#842)

1.4.12

• Bugfix: "import class quickfix" missing in some cases (#1132)
• Bugfix: "Find Usages" was not checking catch blocks correctly(#929)
• Bugfix: "Introduce Constant" placed outside of class
• Bugfix: "Pull member up" placed code outside of class
• Change: hiding haxe context menus in non-haxe projects

1.4.11

• Added: better support for anonymous structures (#1131)
• Bugfix: Fixed incorrect symbol resolve (#968)
• Added: Support for special interface ArrayAccess (#957)
• Added: Resolve type from ExprOf when used with reification
• Added: QuickNavigateInfo (ctrl+hover over symbols)
• Bugfix: Prevent automatic asterisk insert for HaxeDoc

1.4.10

• Bugfix: macro keyword was not parsed correctly when immediately followed by a new line
• Bugfix: type reification was not parsed correctly when macro keyword was immediately followed by colon
• Bugfix: macro expressions used as value (in call expressions etc.) was incorrectly showing missing semicolon warning

1.4.9

• Added inlay hints for capture variable (haxe 4 syntax)
• Improved type resolving for array access expressions
• Improved handing of null return type.
• Bugfix: Incorrect type-mismatch error for methods with parameter of type EnumValue.
• Bugfix: CallExpression type-check used typeParameter from parent and not method.

1.4.8

• parser support for abstract classes
• Inlay hints for parameter names, variable and field types, return type and for-in loops
• Experimental macro type conversion when resolving types (parameter and return types)
• Experimental color selector
• Fixed incorrect type resolve of switch case expressions
• Made extract to variable ignore trailing ;
• Fixed NPEs and type errors

1.4.7

• Fixed rendering bugs for haxeDoc
• Fixed bug where type parameters where not propagating properly
• Experimental caching of resolved Parameter type
• Cache repository path response from Haxelib to avoid unnecessary calls
• Resolved conflict between Maven and Lime project files
• Improved haxeSDK detection for linux and MacOS

1.4.6

• Coalescing operator support
• support for spread operator in method calls
• Added missing support for unsigned shift right operator
• Reworked type checking for method calls
• Reworked switch-case extractor internals
• Improving operator overload handling
• Misc type resolving fixes

1.4.5

• Improved HaxeDoc rendering and displaying resolved type
• Improved switch-case extractor type resolving
• bugfix: wrong logic for comparing operators for strings.
• bugfix: typedefs did not resolve function types in some cases.
• bugfix: Map and Array literals was showing incorrect type mismatch when assigned to variable with a super type type-parameter.
• bugfix: incorrect override warnings in interfaces

1.4.4

• Bugfix for operator semantics (+ Tests)
• Bugfix (Nullpointer fix)
• Using java 11 as target for JPS module

1.4.3

• Added custom syntax color for type-parameters
• Bugfix callExpression annotator did not check against declaring class type-parameters
• support for inline constructor and function calls
• Improved return type detection for methods without return type specified
• Improved typechecking for functions when Function abstract is used.
• improved type resolving for loops
• initial support for @:op meta

1.4.2

• Bugfix for haxelib libraries with dots in name
• Bugfix for haxelib libraries with names with uppercase characters
• Bugfix for function-type generics as method arguments
• Added support for rest arguments (no type checking yet)
• Added support for Null-safe navigation

1.4.1

• Fixed bug that prevented Mac users from creating or opening projects
• Improved type-checking for function calls with generic types

1.4.0

• Updated to work with intellij 2023 and Android Studio Giraffe
• Added "open as project" support for nme, lime/openfl and hxml files
• Reworked haxelib dependency management
• Added support for more haxe language features to the parser.
• Improved type resolving/detection

1.3.2 (no official release)

• Add HXML completion for Haxe 4
• Fixed issue where IDE would freeze when writing HXML files
• Add HashLink target
• improved block-statement parsing and added quickfix for missing semicolon
• Add support for import.hx
• Recognize and use static extensions having unifiable (assignable) types. (Issue #964)
• Add support for 'is' keyword.
• Rewrite expression parsing.
• Don't break parsing when multiple package statements occur in the same file. (Warning and quick-fix provided.)
• Fixed NPE when typing 'cast' expressions.
• Checks field and property implementations when implementing interfaces
• Improved method implementation checks for interfaces
• Recognize implicit cast methods in Abstracts (Methods annotated with @:to / @From)
• Fix type incompatiblity warning when assigning parameterized (generic) function result type.
• Fix a few cases where empty square brackets were not recognized for initializing Maps. (Issue #980)
• Updated which classes are auto-imported.
• Follow usings as if they were imports when resolving identifiers.
• Fixed resolving static extensions in usings. (Issue #992)
• Better support for quote handling when typing.
• Allow double-dollar escapes in strings.
• Allow assigning to Dynamic, now that Dynamic allows a type parameter.
• Adjust "Darcula" colors for readability.
• Fixed some problems parsing switch cases with multiple extractor (fat arrow) expressions.
• Haxe4: Support new syntax for optional variables and type constraints (including auto-completions). (Issue #950)
• Removed parsing of templates in regular (double-quoted) strings. (Issues #289, #718)
• Treat successive expressions and statements without semi-colons as errors.

1.3.1 (HaxeFoundation release)

• Allow both 'inline' and 'extern' to exist on functions and vars.
• Correctly resolve when 'using' static extensions such as StringTools.
• Correctly resolve expressions inside of parenthesis.

1.3.0 (HaxeFoundation release)

• IDEA Versions 2020.2, 2020.1 and 2019.3 support.

• Add fine-grained control of the semantic annotator to the Settings panel. (File->Settings->Editor->Inspections->Haxe)

• Rewrite metadata handling:

  • Allow metadata at all positions.
  • Validate object syntax in compile-time metadata.
  • Parse code in run-time metadata, and highlight errors.
  • Check @forward() for existing method names.
  • Allow completion within metadata parens.
  • Add UI to allow reformatting and color options.

• Allow immediate array accesses on literal arrays. (e.g. var a=["1","2"][1];)

• Fix several issues with type checking, particularly when generics are involved.

• Allow non-standard orderings of class and method modifiers (e.g. final, private, extern) and warn on duplicates.

• Recover from circular class dependencies.

• Better error messages for a number of parsing errors.

• Fix not finding packages which begin with and underscore. (Issue 941)

• Handle function-level type parameters during semantic checks. (Issue 973)

• Don't use class type parameters when resolving static function parameters.

• Better handling of function types an mismatched assignments. (Issues 943, 773)

• Fix crash when reading libraries if the library name was empty. (Issue 949)

• Haxe 4: Allow dotted identifiers in conditional compilation.

• Haxe 4: Allow dotted meta names.

• Haxe 4: Allow 'final' on var declarations in switch cases.

• Mark attempts to write to 'final' variables.

• Handle Map types as extended map types. (e.g. IntMap, StringMap, etc.)

• Better constant detection and handling of default parameters for methods.

• Detect function type constants and report accordingly.

• Detect initialization calculations containing only constants as constant.

• Detect several standard library functions as returning constants when their arguments are constant. (e.g. Std.int("1"))

• Detect identifiers/constants referencing other constants as still constant.

• Detect enums without parameters as constants.

• Better flagging of errors when default parameters are not constants.

• Much better handling of generics throughout, including type error checking code.

• Use type parameters from left-hand (e.g. left.right) expressions when resolving right-hand fields and method return types.

• Color unparseable data when typing; shows developers where functionality is limited while code is invalid.

• Better handling/recovery of errors in String Interpolation. (e.g. '${expr}')

• Allow/disallow variable declarations in various places.

• Require semi-colon on return statements in non-lambda bodies.

• Better recovery on class parsing errors.

• Fix PsiInvalidElementAccessExceptions (Issue #953)

• Upgrade smart-enter statement fixer for 'if' statements.

• Better handling of missing bodies when using smart-enter.

• Properly handle generics on typedefs over generic types.

• Properly unify EnumValue with enum values.

• Fix indenting for map comprehensions.

• Fix and update inspection descriptions in settings dialog.

• Implement "Implement methods" for missing interface functions.

• Fix the case where generic parameters used in superclasses were not being correctly translated through the type hierarchy when resolving (or were resolving to the wrong type).

• Fix apparent hang when presenting the "Override Method" dialog in large code bases. (Issue #990)

1.2.0 (HaxeFoundation release)

• Update builds for 2019.1 and 2018.x versions.
• Fix completion on abstracts using generic underlying types (e.g. abstract MyClass(T) {}) (Issue #772)
• Fix completion through abstracts.
• Resolve fields and methods through abstracts.
• Haxe 4: Special rules to resolve Null as abstract.
• Fixed constructor being renamed when a class is renamed (refactored). (Issue #776, #785)
• Fixed ClassCastException when Refactor->Rename was used on generic type names.
• No longer display type mismatch errors when using abstracts with (varying) generic type parameters. (e.g. Null, Null)
• Better detection of types inferred after declaration (monomorphs).
• Fixed type detection for expressions in parenthesis.
• Downgrade visibility (public/private) incompatibility to a warning.
• Allow "Dynamic" as an interface type.
• Detect simple type mismatches in declarations and assignments. Add quick fixes for them.
• Check type of type check statements (e.g. `(myExpression : Float)`) and warn. Add quick fixes.
• Auto-close regions and conditionally (un)compiled code, and add checkboxes to the Settings panel for folding.
• Fix Extract Variable and Extract Constant refactorings (Issue #844):
  • Fixed infinite loop when extracting multiple occurrences.
  • Avoid keywords when making name suggestions.
  • Fix multi-select for custom names in all occurrences.
  • Fix semi-colon insertion/detection.
  • Suggest variable names based upon expression type.
• Allow AIR targets to be debugged using the flash system. (Issue #849)

1.1.0 (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 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.

1.0.2 (HaxeFoundation release)

• Performance hot-fix for projects that have multiple source roots. (Issue #799)

1.0.1 (HaxeFoundation release)

• Updated change notes for 1.0.0 (enumerated several important import changes).
• Add Haxe Sdk setup validation.
• Use SDK classpath as well as sourcepath to find the standard library. (Issue #774)
• Better error handling when haxelibs are installed incorrectly. (Issue #780)
• 2017.3 and 2018.1 builds. (Issues #719, #789)
• Workaround debugger crash. (Issue #792)
• Fix typo in haxelib metadata parser, which was keeping library sub-tree source directories from being found.

1.0.0 (HaxeFoundation release)

• Import of static fields/methods.
• Imports alias hinting support.
• Proper wildcard import resolution.
• Import optimizer now works properly.
• Proper module scoping for resolving.
• 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.
• 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)

0.11.2 (Haxe Foundation Release)

• Parsing fixes:
  • Expressions inside of type parameters.
  • Make sequential operators cause syntax errors.
  • Allow anonymous local function declarations.
  • External function declarations with simple bodies getting 'Unexpected semicolon' messages.
  • Custom meta-data with empty parenthesis.
  • Named nested (local) function declarations.
  • Prototype functions in abstract .types.
  • Allow @arrayAccess
  • Array access where the name is parenthesized.
  • Allow @final on property declarations.
  • Allow and recover from variable declarations that don't require a semicolon (e.g. preceded by a block).
  • Allow trailing comma inside of an object literal.
  • Allow trailing comma at the end of an array literal.
  • Block statements when used as an initializer.
• Fix NPE when haxelib.json was missing from a library.
• Fix an exception when the Haxe SDK is set up incorrectly.
• Added Adobe AIR target
• Refactor haxelib library dependency detection and project update.
• For FindUsages, ask whether to search for base class/interface usages.
• Fix bug with environment variables not being passed through to forked processes in some cases. (Issue #659)
• Add haxelib and neko directories to (the start of) the Path before forking a process.
• Better tracking of settings changes.
• Better parsing of HXML/lime (or "haxelib run lime") output.
• Fix IndexOutOfBoundsException when checking for static extensions and static member methods have no parameters. (Issue #652)
• Better parser recovery for "extends" and "implements" statements. (Issue #137)
• Fixed identifier resolving for dot-references defined in "type params." (Issue#674)
• Fixed parameter count resolution for anonymous functions. (Partially closes issue #521.)
• Add neko and haxelib directories to the PATH/Path environment variable when running plugin commands (affects lime, etc.).
• Better cache coherency for completions.
• Improved hxml parsing.
• Added mechanism to track project and module settings changes.
• Improve locating files when traversing the stack frames during debugging.

0.11.1 (community release)

• 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).

0.11.0 (community release)

• Support IDEA 2017.1
• Add parsing support for "Arrow Functions."
• Better recovery of parsing errors in function parameter lists.
• Fixed exceptions occurring when adding libraries, so auto-adding will work again.
• Delay using project indexes until scanning is complete.
• Proper resolution of constructors ('new').
• Display parameter tip text when creating new object instantiations.
• Better parsing of shift-and-assign operators.
• Now correctly resolves variables declared in 'for' statements when the iterated type is parameterized. (Issue #528)
• Resolve chained classes with type parameters (generics).
• Correct completion with EitherType<>. (Issue#512).
• Parse @:const type parameters without error. Also allow constants as type parameters.
• Added navigation to getter/setter methods from property accessors.
• Annotate strings with incorrect quotes and add quick-fix intention to convert them.
• Note optional arguments with a ? when displaying methods.
• Improved method signature check.
• Added searching of implementation declared by superclasses.
• Properly parse and evaluate compiler conditionals (#if...#else...#end)
• Resolve array access with types other than "Array."
• Better 'Main class' chooser for the 'Project Settings->Haxe Compiler' dialog.
• Fix property getter/setter quick-fixes.
• Add location data, if known, to compiler completion error messages.
• Display available completions even when the compiler reports an error.
• Fixed incomplete results from a compiler run.
• Better logic for removing duplicate entries from completion lists.
• Better code completion using the compiler -- OFF BY DEFAULT! Turn on in File->Project Structure...
• Fix parsing of all compiler conditionals. (#417, #121, partly #115, and others)
• Fix parsing of one-liner conditional compilation style (issue #417, #121, partly #115)
• Support for `@:require` haxe_ver comparing (issue #418)
• Support for `@:require` and `@:jsRequire` with multiple arguments
• Better handling of closing parens, brackets, quotes. (Issues #545, 546)
• Fix parsing when an anonymous function call is defined and immediately executed. (Issue #544)
• Fix library name parsing issues for haxelibs using non-standard paths.
• Resolve URLs properly when adding haxelibs.
• Updated Haxe logo bitmaps.

0.10.1.1 (community release)

• Update compatibility for 2016.3.2
• Update documentation to refer to HaxeFoundation instead of TiVo.

0.10.1 (community release)

• Use Java's file library for detecting symlinks instead of IDEA's.
• Formatting: Prevent excess linefeed between doctyp and function.
• Fix completion for for loop variables. (issue #511)
• Support for IDEA up through 2016.3.
• Updated parsing for hxcpp 3.3 compiler error output.
• Add support for type check syntax (expr : type). (issue #510)
• Fixed cursor not indented in class body after var or function declaration. (issue #492, case 1)
• Highlight "in" and "as" as keywords when they appear in import statements.
• Highlight "in" as a keyword when it appears in a for statement. (issue #501)
• Add support for string literals as the keys in structures. (issue #498)
• Support @:native annotation for functions and variables. (issue #490)
• Stop using the classpath to auto-add external libraries to projects. (issues #477 #100)
• Fix re-ordering imports in certain situations. (issue #494)
• Fix 'never' setter. (issue #486)
• Change class paths for external libraries on OSX.
• Fixed creating classes in TEST source roots
• Fixed debug Flash on Haxe-compiler target
• Fixed crash on MACRO_CLASS_LIST assert
• @:deprecated support (issue #459, #473)
• Alias imports support (issue #466)
• Imports optimization: reordering added (issue #471)
• Fixed typedef multiple extensions highlighting

0.9.10 (community release)

• Better packages resolving
• Fix catch parameter declaration (issue #419)
• Fix inherited type in field initializer (issue #412)
• Delete single-class file in one operation from Project View (issue #424)
• Fix interface properties accessor check annotation (issue #411)
• Error highlighting added for variable redefinition (issue #431)
• Fix generic sub-type resolving when import just type-module (issue #435)
• Extensions: using variants and resolving for children and implementations of base class or interface added (issue #433)
• Fix typedef generic params resolving (issue #304)
• General "@:enum abstract" support (issues #427, #428, #429)
• Fix import / using statements class name completion (issue #286)
• Incorrect “public” modifier when override methods fixed (issue #439)
• Incorrect field access modifier after action generate set/get methods. Can't use action generate set/get methods for static fields. (TiVo Issue #442)
• Fix use scope for var declarations (issue #235)
• Find usages import filtering (issue #426)
• Completion for word `super`: handle `super` word like `this` word (issue #87)
• Fix forwarding abstract fields completion and resolving. (issue #447, #108)
• Navigate to symbols (issue #340)
• Fix incorrect error annotation in extended class for static fields and methods with same names like in base class. (issue #449)
• Fix method local variables and arguments completion. (issue #455)

0.9.9: (community release)

• IDEA v15 compatibility. (IDEA 13 compatiblity removed.)
• v15 Project Structure and Module settings dialogs work. (TiVo Issue #380)
• HXML: Fix `Editor/Colors & Fonts/HXML` tab (name & preview)
• HXML: highlighting for included `.hxml` file
• Fix unhandled exceptions while parsing numeric constants
• Fix typedef types not resolved variants for completion list
• Fix error annotation when implements `extern interface`
• Fix extending anonymous types. (TiVo Issue #353)
• Error annotation if type extends itself. (TiVo Issue #377)
• Fix qualified name resolving for ancillary types declaration (multiple types inside .hx file)
• Fix resolving variables having names identical to type names except for case. (TiVo Issues #405, #234)
• Fix incorrect package resolution. (TiVo Issues #95, #176)
• Fix base fields resolving for extended anonymous types (TiVo Issue #408)
• Prevent recursion due to extending self for classes and typedefs.
• Using file with multiple helper classes typedefs (for example `haxe.macro.Tools`) (TiVo Issue #128)
• Allow short assignment syntax for generics. (TiVo Issue #388)
• Fixed expected package name to no longer reference the system root. (TiVo Issue #387)
• Save and restore OpenFL arguments on the Haxe Module settings dialog. (TiVo Issue #74)
• Fixed repainting issue for OpenFL dialog when selecting compiler types. (TiVo Issue #44)
• Fixed error parsing for Windows platforms.

0.9.8: (community release)

• Version 14.1.5 and 14.1.6 compatibility.
• Fix up some expressions to ignore non-error messages.
• Fix comment alignment for single-line comments.(Issue #295)

0.9.7: (community release)

• Fix the watch pane when debugging: typing and completion now work.
• Load files using canonical names so that sym-linked files use the same buffer as the original file.
• Use full package name when determining file to open when debugging.
• Attempt to follow the classpath to determine which file to open when multiple files have the same package names.
• Use implicit classpath entries during classpath operations. (e.g. haxe/std)
• Remove "statics of XXX" from the debugger variable window pane. (The Haxe debugger at https://github.com/tivo/hxcpp-debugger has been updated to show statics as part of the object tree for objects in view.
• Remove error embellishments before displaying errors in the debugger variable pane.

0.9.6: (community release)

• Fix debugger trying to populate all variables when stopped at a breakpoint.
• Suppress display of back-end generated intermediate variables when debugging.
• Fix NPE when editing files outside of a project.

0.9.5: (community release)

• Add new typing support for type checking and completion. (Thanks to Carlos Ballesteros!) (Issues #288,#291,#308,#317)

• Support static extensions in completion. (Again, Thanks, Carlos!)

• Fix debugger getting stuck "collecting data" for some variables (particularly, "this"). (Issue #325)

• Better compiler error highlighting. (Issue #180 redux.)

• Fix Cut/Copy/Paste buffer inconsistencies (Issue #196)

• Add generics support. (First level only, chained sequences remain incomplete.)

• Allow object literals as return statements. (Issue #278)

• Fix NPE during annotation, causing annotation to stop. (Issue #316)

0.9.4: (community release)

• Fix compile error highlighting in the output pane and jumping to source location when an error is clicked upon (Issues #129, #160, #180).
• Fix debugger execution under IDEA 14 and 14.1.
• Fix move package
• Fix MoveFile showing "unimplemented" message. (Issues #222, #88)
• Fix copy/paste clipboard functionality.
• Show completion for all static members (Issue #262).
• All unit tests enabled and passing for IDEA versions 13.1, 14.0, and 14.1.1.
• Fix rename not updating all usages (Issue #222)
• Fix parameter info tool tips and code tips.
• Command line ant builds (of the plugin) for automated testing.
• Fix parsing 'new' in ternary expressions (Issue #229).
• Better handling of comments.
• Fix member visibility scoping issues with extern and private keywords.
• Stop generating 'public' and 'private' modifiers when generating getter/setters.
• Stop treating interfaces and extern class declarations identically.
• Disallow multiple variables being declared in one statement for class fields.
• Print compiler commands to the message pane along with command output.
• Fix hang when using the OpenFL compiler for variable and method completion.
• Use correct completion contributor for OpenFL project configurations.
• Fix parsing failures for certain cases of "@meta" and "@:pos" (Issue #81).
• Fix unresolved type error if using full class path without importing the class (Issue #39).
• Resolve extern enum values via qualified name.
• Resolve classes within the same package but defined in a different module (Issue #168).
• Hopefully fix compiler based auto-complete performance problems (Issue #230).
• Fix Plugin wrongly accepting comma separated fields that the compiler wont (Issue #83).
• Fix rare ClassCastException when re-opening projects.
• Fix NotNullExceptions when getting field types for dynamic fields.

0.9.3: (community release)

• Fix local variable name suggestions to not clash with existing class fields.
• Fix Introduce Variable refactoring to find all occurrences of the selected expression.
• No longer block Java (and other) tests from running when Haxe plugin is installed. (Issue #166)
• Resolve static function imports for import with in keyword. ("import String.fromCharCode in f;") (Issue #191)
• Give extern fields public visibility: 'function a()' will be treated as 'public function a()' and will appear in completions.
• Fix (un)comment multiple lines of code feature. (Issue #209)
• Support 'as' keyword in import statements.
• Implemented Refactoring: Pull Members Up/Push Members Down
• Support extern interfaces. (Issue #202)
• Fix visibility determination for methods. (Better completions)
• Check for duplicate imports when copy/pasting.
• Fix resolving classes that appear inside of an import file with a different name than the class itself. Fixes goto declaration as well.
• Fix colorizing identifiers (variable names) in code.
• Fix Issue 162: "call(new x(), new x());" parse failure.
• (Re)Allow "new" for extern and prototype function declarations.
• Fixed IDEA freeze when XML is edited
• Implemented Refactoring: Extract Superclass
• Implemented Refactoring: Extract Interface
• Implemented Refactoring: Push Members Down
• Fixed OutOfBoundsException when resolving names.
• Fix most unit tests.

0.9.2: (community release, IDEA 14 only)

• Fixed: HaxeReferenceCopyPasteProcessor issue preventing from using copy paste clipboard functionality

0.9: (community release)

• Release ID change only

0.8.1.1.TiVo.4: (community version, TiVo Release 4)

• Class Hierarchy view panels implemented. (Menu->Navigate->Type Hierarchy, et al)
• Better handling of import files.
• Better handling of Haxe language parsing, including many Haxe 3 features.
• Automatic detection and use of installed haxe libraries (using the 'haxelib' command).
• Better completion (Ctrl-space) using the Haxe compiler -- OpenFL projects only.
• Refactorings:
  • Pull up members from class to super-class
  • Pull up members from class to interface
  • Split into declaration and assignment
  • Optimize imports

The following sub-releases are included:

• 0.8.1.1.TiVo.ClassHierarchy.16: (community version, TiVo RC5)

  • Refactoring: Pull up members from class to super-class
  • Refactoring: Pull up members from class to interface
  • Launch Haxe/Neko tests (Patch #131)

• 0.8.1.1.TiVo.ClassHierarchy.15: (community version, TiVo RC4)

  • Fixed issue 37 (Parser doesn't recover after new A)
  • Fixed issue 95 (Local and class variable names resolving to similar package names)
  • Fixed issue 132 (incorrect processing of duplicate imports)
  • Fixed issue 134 (incorrect reformat of object and array children)
  • Fixed reference resolution for expressions in parenthesis - otherwise, code assist does not work for those.
  • Fixed: launching test with neko, overriding haxe build parameters for test run configuration, filtering test result output, compilation path of non test build, line number for ErrorFilter; and removed hard-coded path for ErrorFilter

• 0.8.1.1.TiVo.ClassHierarchy.14: (community version, TiVo RC3)

  • Fixed NPE causing the structure view to not populate, resulting from an errant merge.

• 0.8.1.1.TiVo.ClassHierarchy.13: (community version, TiVo RC2)

  • Resolve 'convenience' imports that do not export a class named similarly to the file. (TiVo Issue #55)
  • Update unbalanced preprocessor token highlighting and detection.
  • Improve indentation of comments and preprocessor macros.
  • Update for Grammar-Kit 1.2.0.1
  • Fixed syntax rules (BNF) for constructors and external functions.
  • Fixed syntax rules (BNF) for code blocks; removed them from being valid syntax everywhere an expression can appear.
  • Fixed syntax rules (BNF) to allow meta tags on typedefs.

• 0.8.1.1.TiVo.ClassHierarchy.12: (community version, TiVo RC1+Fixes)

  • Auto-indent when adding curly brackets now works correctly. Fixes github tivo/intellij-haxe Issue #119. (Thanks, Jérémy!)
  • Fix IDE hang on completion for Haxe compiler completions.
  • Fix auto-adding new import statements above package declaration and/or comments.
  • Fix NPE when manually adding new import statements.
  • Put debugging dialogs on the UI thread.
  • Fix ArrayOutOfBounds exception when initializing haxelib cache.

• 0.8.1.1.TiVo.ClassHierarchy.11: (community version, TiVo RC1)

  • Fix NPE when colorizing.

• 0.8.1.1.TiVo.ClassHierarchy.10: (community version, TiVo WIP)

  • Added timeout to long-running call hierarchy searches.

• 0.8.1.1.TiVo.ClassHierarchy.9: (community version, TiVo WIP)

  • Fixed Haxe command-line debugger integration for OpenFL projects that are targetting C++ native runtime environments.
  • Fixed method hierarchy runtime exceptions, and auto-scrolling to source.
  • Fixed type hierarchy auto-scrolling to source.
  • Enhanced run & debug output to be color-coded for improved readability.
  • Fixed find-usages regression.

• 0.8.1.1.TiVo.ClassHierarchy.8: (community version, TiVo WIP)

  • More load-time optimizations using new 'haxelib list-path' command.
  • Add package and file names to Type hierarchy window. (File names only display if the file name differs from the type name.)
  • Fixed supertypes list in the combo view of the Type hierarchy window.
  • Allow block statements everywhere.
  • Allow array literals to have additional comma [1,]
  • Moving a file from one package to another no longer displays "Unimplemented" and now moves the file, however references are not yet updated. Issue #88 -- still unresolved.
  • Updated unit tests. Issues: #71, #68.
  • Fix formatting for ">=", which is used be to reformatted to "> =". Issue
  • Fix logic for HaxeIfSurrounder.java /testIf test case/

• 0.8.1.1.TiVo.ClassHierarchy.7: (community version, TiVo WIP)

  • Repaired resolving references to classes and variables.

• 0.8.1.1.TiVo.ClassHierarchy.6: (community version, TiVo WIP)

  • Further optimized load time for large projects.
  • Run haxelib->Project/SDK/Module library dependency synchronization in the background.
  • HXML completion: add parameters for compiler argument to presentable text of completion item
  • Completion from Haxe compiler: parse function parameters and return type to generate completion item with parameters and return type
  • Completion from Haxe compiler: format data from compiler replace "<" to "<" and ">" to ">"
  • HaxeReferenceImpl.java getVariants(completion): Handle case when "var d:Array = []; d.|" when d is not resolved
  • Add description to completion recived from Haxe compiler: HaxeMetaTagsCompletionContributor.java HXMLDefineCompletionContributor.java HXMLCompilerArgumentsCompletionContributor.java
  • Preliminary Haxe compiler completion support (OpenFL only)

• 0.8.1.1.TiVo.ClassHierarchy.5: (community version, TiVo WIP)

  • Decreased time to load large projects considerably. Note that project loading is still on the UI thread, so it may appear to lock up for a short period of time. For very large projects, 90 seconds is not out of the ordinary.
  • HXML completion: Provide available libraries list
  • HXML completion: show installed haxelibs(also installed libs removed from available haxelibs list)
  • Fix meta tag parsing issues
  • HaxeMetaTagsCompletionContributor provides completion for meta tags
  • Project Xml(NME, OpenFL project project) completion: show available and installed haxelibs
  • SplitIntoDeclarationAndAssignment intention action

• 0.8.1.1.TiVo.ClassHierarchy.4: (community version, TiVo WIP)

  • Merged with version 0.8.1.1.TiVo.2 from the TiVo/master branch.
  • Class Hierarchy partial implementation.
  • SuperTypes work. Sub-types work within the same module.
  • All recent changes from github.com/Jetbrains/intellij-haxe/master
  • Support typedef optional parameters
  • Support optional function types
  • Eat compile-time conditional statements only (prevent eating conditional body as it was before)
  • Fix multiple metas issue on class
  • Highlight compile-time conditional statements if they don't have matching closing statements
  • Remove "from" and "to" from keywords, instead highlight them only if they used in abstract declaration
  • Prevent suggesting imports for using statements
  • Resolve references that have full path to type/field
  • Support function types, anonymous types as abstract type
  • Automatically add and remove dependencies when project gets opened
  • Remove ">=" and ">>=" tokens from lexer, instead parse ('>' '=') to avoid issues(#42)
  • Support "inline" declaration attribute on local functions
  • Suggest to import class on code paste
  • Support macro expressions(including ECheckType)
  • Lots more... TODO: Get a complete list of updates.

0.8.1.1.TiVo.2: (TiVo version)

• openFL path can now be retrieved from an .iml file

0.8.1.1: (community version)

• "Find usages in project" fixed.
• Allowed @:final on methods and fields.
• Re-implemented hxcpp debugger support to work with Haxe v3 built-in debugger

0.8.1: (community version)

• Remove com.intellij.modules.java from dependencies list to make plugin work in PHPStorm(and other IntelliJ IDEA platform-based IDEs)

0.8: (community version)

• Migration to new IntelliJ IDEA 13.1 API
• HXML syntax highlighting
• HXML completion
• Parser support for different types of imports
• Parser support for @:jsRequire and more parser fixes

0.7.2: (community version)

• New version number
• basic hxml support
• @:jsRequire meta support
• Haxe grammar: @:jsRequire and macro support
• templates naming fix ("create new class/enum/interface" issue)
• new/get/set/never keywords, get/set identifiers are valid, jar build

0.7.1:

• Bug fixes for 13.1.1

0.7:

• Bug fixes

0.6.9:

• Neko target for OpenFL
• Bug fixes

0.6.5:

• OpenFL support

0.6.4:

• Optimize imports

0.6.3:

• Parser improvements

0.6.2:

• Bug fixes

0.6.1:

• Haxe 3 support

0.6:

• Folding

0.5.8:

• Bug fixes

0.5.6:

• NME support improvements
• HXCPP debugger improvements

0.5.5:

• Bug fixes

0.5.4:

• New Compiler Mode

0.5.2:

• Bug fixes

0.5.1:

• Bug fixes

0.5:

• HXCPP Debugging
• Bug fixes

0.4.7:

• Introduce Variable Refactoring
• Using Completion
• Bug fixes

0.4.6:

• Conditional Compilation Support
• Bug fixes

0.4.5:

• Live Templates
• Surround With Action
• Smart completion
• Goto Test Action

0.4.4:

• Bug fixes
• EReg support

0.4.3:

• Bug fixes
• Structure view

0.4.1:

• Bug fixes
• Unresolved type inspection

0.4:

• NME Support
• Override/Implement method action
• Generate getter/setter action
• Parameter info action

0.3:

• Type resolving improvements
• Goto Implementation(s) action
• Goto Super Method action
• Move refactoring

0.2.3:

• Completion fixes

0.2.2:

• Type resolving improvements
• Rename refactoring
• NMML scheme
• HXML support

0.2.1:

• Type resolving improvements
• Documentation support
• New color settings

0.2:

• Jump to declaration of local, std symbol or class
• Reference completion
• Class completion
• Color settings
• Code formatter
• Go to Class
• Icons for Haxe files
• Search for usages
• Highlight symbol occurencies
• Debugger for Flash target ("Flash/Flex Support" plugin required)

0.1:

• Haxe module and SDK
• Parsing Haxe files
• Keyword completion
• Compile Haxe files and run in Neko VM