For example :

var icon_paths:Map<String, String> = [
    "dislike" => "down_big.png",
    "neutral" => "neutral_big.png",
    "like" => "up_big.png"
];

First => is higlighted with red.

Using the latest plugin build (https://github.com/JetBrains/intellij-haxe/blob/master/intellij-haxe.jar?raw=true) in conjunction with the latest OpenFL (2.1) and lime (2.0-alpha) results in "blank errors".

/
Error:
/Users/rickDocuments/GameProjects/haxe/test
Error:

When manually running via

lime test neko or lime build neko

There are no actual compile errors.

typedef NamedObject = {
    @:optional var name : String;
}
var namedObject = {};
namedObject.name = "Bob"; // no code completion on name

This worked fine in the jar from JetBrains/intellij-haxe@a81562d, but since then it was broken.

In Haxe source files, add missing import statements and remove unused ones. New code shall be generated at the top of the file, right after the opening comment and before any other definitions.

TIR: STB-2902

Currently, we cannot debug native Haxe code within IDEA; we have to compile it to some other language first and then debug that code. This is both complex and tedious. The generated code is not obviously identified from the original and vice versa.
Bryan Ischo has written a text mode debugger for Haxe. TiVo has already made this code public and other folks are using it (in non-IDEA environments; FlashDevelop, I think). We want to hook it up to the IDEA debugging hooks so that our developers can have native-Haxe debugging within the IDE.

Goals:

• Debugging hxcpp targets in the IntelliJ IDE supports all of the command-line debugger functionality in a seamless way, similar or identical to how these functions are handled in the Flash debugger.
• A document has been posted to the TiVo wiki which describes how to set up debugging hxcpp in IntelliJ (may require starting a debugging server process or some such) and the basics of using it.

TiVo internal reference: STB-1369

https://www.jetbrains.com/idea/webhelp/completing-statements.html

Really useful feature.

TIR: STB-7287

grisevg reported:

Also there is an error if there are two @:access in a row.
Example:

@:access(openfl.display.Graphics)
@:access(openfl.text.TextFormat)
class TextField extends InteractiveObject {

It works fine in JetBrains branch, but errors out with ',', or enum expected, got '@:access' in this jar: https://github.com/EBatTiVo/intellij-haxe/blob/a66aba37f1d4f6be2c25d2e3d896547e03fabbac/intellij-haxe.jar

Two related things don’t work: Find Usages and the Type Hierarchy. Find Usages is dependent upon the deprecated-and-now-deleted APIs that were available up to version 13.1.1. When usages are requested, only those within a file currently loaded within the IDE are found. The underlying problem is that the background processing which reads type information, etc. from un-opened files is hitting a “method not found” error and stopping.
It is likely that the Type Hierarchy is also dependent upon the missing APIs.

TiVo internal reference: STB-2610

Haxe is a constantly evolving language, gaining several new features each year. In addition, the language cannot be precisely described using the Backus Normal Form (BNF) because it has a rich macro processing capability which effectively changes the semantics of the language locally. That is: the language can be redefined contextually and on-the-fly by the engineers using it.
The currently implemented plug-in has no such contextual polymorphism and is implemented using a fairly rigid BNF syntax that can be (is) passed through a code generation process to create both the lexer and parser portions of code. Then, nontrivial functionality is added to it. Basically, the language is baked in one way, and if you use any of the advanced features, you are out of luck when it comes to IDE support.
Since Haxe already has a compiler that does understand the language flexibility, and the language is designed to be cross-compiled into other languages, it makes sense that the compiler can be extended to build an abstract syntax tree (AST, which is what a ‘PSI’ is in the IDEA environment) that the IDE can consume. In fact, the Haxe implementers have already built a similar functionality so that IDEs can support completion (the ability for a portion of text to be typed and the IDE can propose matches, which reduces keystrokes required by developers and reduces mis-typing errors).
This task at hand is to create a mode of the compiler that will create an AST that can be translated into the target environment, then to create a specific translation into the IntelliJ IDEA environment.

TiVo internal reference: STB-2045

This plugin version works as expected: https://github.com/JetBrains/intellij-haxe/blob/7e56ead5a1dfa555b48a89a039ef36e1fca0df7a/intellij-haxe.jar
While latest build has broken #if conditionals causing failure to parse haxe code that has them: https://github.com/JetBrains/intellij-haxe/blob/eb94f32bbaccf3b3b193303ad340c00e337d5f2f/intellij-haxe.jar

When using the "Auto-Indent Lines" command, it looks like this...

extern class MyClass {
function new() : Void;
}

but it should look like this.

extern class MyClass {
    function new() : Void;
}

Array comprehension was added to haxe3 and can be found in the updated documentation here: http://haxe.org/manual/lf-array-comprehension.html

e.g. var a = [for (i in 0...10) i];

The IDE reports a syntax error upon seeing the '[for'.

TIR: STB-2047

Another issue that @profelis reported earlier:

package ;
class Main {
    public function new() {
    }

    private static function main():Void {
        trace("hello world");

        var s = "";
        var d = Date.now();
        trace(d);

        test();

        new RT|
    }

    static public function test() {

    }
}

class RTask {
    public var a:Int;

    public function new() {

    }

}

The problem is that parser chokes on new A| and it should recover after it somehow, but it doesn't, so all data below this new expression statement doesn't get parsed properly.

TIR: STB-7293

idea 13.1
haxe version 0.8.1

some error with
https://www.dropbox.com/s/dpkix5ma8i8m9y9/Screenshot%202014-10-31%2018.33.20.png?dl=0

This feature is simply not implemented. I believe that what it should do is to temporarily disable all breakpoints, then create a temporary breakpoint at the specified position, then run the program until that temporary breakpoint is hit, then delete that temporary breakpoint and re-enable all other breakpoints.

There are some tricky issues to address though. So right now this functionality just isn't implemented.

This can't be implemented easily at the moment because of the PSI rework. Should eventually be implemented once the PSI tree has settled down.

var map = ["key" => 123];
var value = map.get("key"); // unresolved symbol warning

The type of map actually shows up as an Array, probably because of the array syntax. Calling get on it gives no code completion and shows up as an unresolved symbol warning. It also confusing to get code completion for Array methods when it's not an Array.

In this example abstract Signal<T>(Callback<T>->CallbackLink) IDEA would highlight -> with ')' expected, got '->' error.

So as you can see, after I clicked on NMML circle it still shows up options for OpenFL, when I click on NMML text it does works as expected.

Perhaps can be fixed just by adding corresponding handler to radiobutton if possible.
TIR: STB-7294

Classpath:

OpenFL/NME:

1. Add basic classpaths to IntelliJ project(by parsing haxelib path nme to get path to currently active nme path)
2. Perhaps use haxelib run nme display target on project file which returns basically HXML data, in which we can get all classpaths(-cp) and libs for that target. Or just parse project.xml using plugin, but that should consider target conditionals and etc.

HXML projects:
parse *.hxml files data to get classpaths and libs, basically it's implemented in HXML parser.

HAXE projects and all other:
Take into consideration project arguments and etc, for example if Haxe project has specified additional compiler arguments - parse it too, basically same HXML data.

OpenFL/NME: if project.xml gets changed - data should be reparsed and classpath should be updated.
Same for .hxml and compiler arguments options in project options.

And if user changes type of project(or picks another project.xml/*.hxml), it should be updated too.

TIR: STB-7286

Haxe support local inline functions

http://try.haxe.org/#06A18

but intellij-haxe not 😢

var a:String->String; //function, not a String
a.| //completion for String type

@Simn, is there is a class for function with bind method?

TIR: STB-7292

I think currently initial project set-up is too complicated for new users, so I suggest to make some templates for project types like project for each Haxe target, HXML-based project, NME and OpenFL.
And by having such project templates it would be easier for devs to add project templates for other frameworks like (Flambe, HaxeFlixel, HaxePunk, Kha and other).

That might be a tricky one to fix and it's not a big deal at all (it doesn't stop code from parsing/highlighting), but for consistency sake it's should have a ticket.

#if flash
    @:setter(height)
    public function set_height(value:Null<Float>):Void // An error is highlighted at the end of this line.
#else
    override public function set_height(value:Null<Float>):Float
#end

TIR: STB-7297

In the latest jar class members and method arguments are not highlighted as such anymore:

While in older jar it highlighted as expected:

(Please note how method argument has an underscore. In default IntelliJ Darcula theme method arguments do not have such underscore. You can modify default style yourself, but here is my theme for testing convenience - http://pastebin.com/download.php?i=gcErwThZ save as ".icsl" inside "~.IntelliJIdea13\config\colors" folders)

TIR: STB-7296

In both JetBrains branch and ClassHierarchy branch:

In local variable declaration var a = macro 5; "macro" highlighted with warning saying "unresolved symbol".
In field declaration macro static function foo():Expr {} "macro" highlighted with error saying " 'macro' unexpected ".

I don't know how it's happening. Idea says "unresolved symbol" only :).

next for copy-paste:

using StringTools;
class Demo{
    function demo(){
        var lines = "--+--+--".split("+");
        for(i in 0...lines.length)
            if((lines[i] = lines[i].rtrim()).length > 0)
                trace(lines[i]);
    }
}

TIR: STB-7290

For example:

class StringChild extends Parent<String> {}
class Parent<T> {}

Auto-complete won't work for StringChild, there won't be a way to navigate to it's members, refactor or even see it highlighted as a member.

Another very good and important example is the popular HaxeFlixel project - any class that extends FlxGroup (https://github.com/HaxeFlixel/flixel/blob/master/flixel/group/FlxGroup.hx) won't have auto-complete or any other features working for them.

TIR: STB-7288

In the latest jar :

//Std.hx:22-24
#if !(core_api || cross)
#error "Please don't add haxe/std to your classpath, instead set HAXE_STD_PATH env var"
#end

|| in conditional is highlighted as an error. If those 3 lines are removed, whole class is parsed without any errors.

Type inference works fine for the following because it's an array. Item will be recognized as a String and will give code completion for the "indexOf" method.

var array : Array<String> = ["item"];
for (item in array) {
    var index = item.indexOf("e"); // works fine
}

However, on a map, the same thing does not work. The type of "key" is unknown, so there is no code completion, and calling "indexOf" gives an unresolved symbol warning.

var map : Map<String,String> = ["key" => "value"];
for (key in map.keys()) {
    var index = key.indexOf("e"); // unresolved symbol warning
}

I am not sure if it works on other types of iterators, but it doesn't work on Map.keys() or Map.iterator(), so I assume it's not working for any others.

TIR: STB-7289

Source line:
typedef SetBodyFunctionArguments = Rectangle -> Int -> NamedTextFormat -> ?TruncationPolicy -> ?String -> ?Bool -> ?Int -> ?Int -> Void;

Parses to:
TYPEDEF_DECLARATION(1435,1505)
PsiElement(typedef)('typedef')(1435,1442)
PsiWhiteSpace(' ')(1442,1443)
COMPONENT_NAME(1443,1467)
IDENTIFIER(1443,1467)
PsiElement(ID)('SetBodyFunctionArguments')(1443,1467)
PsiWhiteSpace(' ')(1467,1468)
PsiElement(=)('=')(1468,1469)
PsiWhiteSpace(' ')(1469,1470)
FUNCTION_TYPE(1470,1505)
FUNCTION_TYPE(1470,1486)
TYPE_OR_ANONYMOUS(1470,1479)
TYPE(1470,1479)
REFERENCE_EXPRESSION(1470,1479)
IDENTIFIER(1470,1479)
PsiElement(ID)('Rectangle')(1470,1479)
PsiWhiteSpace(' ')(1479,1480)
PsiElement(->)('->')(1480,1482)
PsiWhiteSpace(' ')(1482,1483)
TYPE_OR_ANONYMOUS(1483,1486)
TYPE(1483,1486)
REFERENCE_EXPRESSION(1483,1486)
IDENTIFIER(1483,1486)
PsiElement(ID)('Int')(1483,1486)
PsiWhiteSpace(' ')(1486,1487)
PsiElement(->)('->')(1487,1489)
PsiWhiteSpace(' ')(1489,1490)
TYPE_OR_ANONYMOUS(1490,1505)
TYPE(1490,1505)
REFERENCE_EXPRESSION(1490,1505)
IDENTIFIER(1490,1505)
PsiElement(ID)('NamedTextFormat')(1490,1505)
PsiWhiteSpace(' ')(1505,1506)
PsiElement(->)('->')(1506,1508)
PsiWhiteSpace(' ')(1508,1509)
PsiErrorElement: expected, got '?'(1509,1510)
PsiElement(?)('?')(1509,1510)
PsiElement(DUMMY_BLOCK)(1510,1554)
PsiElement(ID)('TruncationPolicy')(1510,1526)
PsiWhiteSpace(' ')(1526,1527)
PsiElement(->)('->')(1527,1529)
PsiWhiteSpace(' ')(1529,1530)
PsiElement(?)('?')(1530,1531)
PsiElement(ID)('String')(1531,1537)
PsiWhiteSpace(' ')(1537,1538)
PsiElement(->)('->')(1538,1540)
PsiWhiteSpace(' ')(1540,1541)
PsiElement(?)('?')(1541,1542)
PsiElement(ID)('Bool')(1542,1546)
PsiWhiteSpace(' ')(1546,1547)
PsiElement(->)('->')(1547,1549)
PsiWhiteSpace(' ')(1549,1550)
PsiElement(?)('?')(1550,1551)
PsiElement(ID)('Int')(1551,1554)
PsiWhiteSpace(' ')(1554,1555)
PsiElement(->)('->')(1555,1557)
PsiWhiteSpace(' ')(1557,1558)
PsiElement(?)('?')(1558,1559)
PsiElement(ID)('Int')(1559,1562)
PsiWhiteSpace(' ')(1562,1563)
PsiElement(->)('->')(1563,1565)
PsiWhiteSpace(' ')(1565,1566)
PsiElement(ID)('Void')(1566,1570)
PsiElement(;)(';')(1570,1571)

TIR: STB-4528

I think NMML may be not clear for first time users. It's just the project format, but the framework itself.

It will be great if we can use a native for Idea autocompletion for Java-libs added/used in the Haxe-project.

Currently, within the IDE, the Haxe compiler output is interpreted as WARNINGs. Errors are easily overlooked, and informational information is presented/counted as WARNINGS. We need to classify compiler output correctly and ensure that it is presented correctly through the IDE.
As a possibly separate work item, all errors and warnings containing source code location information (having file and line numbers) should be navigable by clicking and/or selecting the message. (EMB: This currently works for me, though some developers have had issue with it.)

TiVo internal reference: STB-2044

Example:

public function new() super(); // ';' highlighted as error saying "; unexpected"

IDEA currently depends upon the FindUsages database for code completion (suggestions). The Haxe compiler itself has been extended to provide completion support, and it’s contextually aware. Make the IDEA plug-in use the Haxe compiler as a completion engine.

TIR: STB-2901

Currently the multithreading support is only partially implemented. All thread stack frames are reported but attempts to move through stack frames may not work correctly, and variable display will be all wrong (only variables for the "main" thread will be displayed, or maybe the thread that most recently hit a breakpoint; it isn't well tested).

This needs to be completed at some point.

var array = ["item"];
var index = array[0].charAt(1); // no code completion

The compiler should be able to infer that the array contains Strings, but it doesn't, so there is no code completion. Map literals have the same problems, although it's worse, as explained in #26.

I was never able to get Javascript debugging to work correctly with Haxe's source maps.
Anyone else tried this?

I assume there was more work involved with the Javascript debugger to get this working for the other coffeescript and dart plugins.

Being able to debug with breakpoints for cpp, flash and js targets all from the same codebase and IDE, maybe a first for any language.

In this example TextFormatAlign is highlighted with red with "Unresolved Type" error. Error goes away once the class is imported.
Surprisingly enough new flash.display.Sprite() and new flash.text.TextField() cause no errors.

var sprite = new flash.display.Sprite();
var textField = new flash.text.TextField();
textField.defaultTextFormat.align = flash.text.TextFormatAlign.CENTER;

This one is not urgent, it seems like JetBrains works mostly on 14 version and we will have to migrate eventually. It seems like they removed JpsSerialization modules and other jps stuff from API. So it shouldn't be hard to upgrade plugin to work with 14 version. Currently it's in preview, but we might need to consider such possibility in near future.

TIR: STB-2896

Build and run MUnit tests. Display the pass/fail results in a rational way.
Automated tests are to be selectable as “Run” or “Debug” targets within the IDE.
Optionally: Auto-generate the wrapper TestSuite Haxe code
(EMB: There is some support for this already, though it may be JUnit instead. The Haxe plug-in itself has a set of unit tests that can be run as described above.)

TIR: STB-1368

Several refactoring features would be very handy to have:
• Pull up, push down
• Extract class
• Extract variable
• Override base class
• Implement missing method stubs
• Generate interface method stubs

TIR: STB-2903

i need your help. i am fresh with hexe. i download idea community 13 as haxe editor.but after i create a openfl project with command lime by commandline.i import in the IDEA,i tried to debug on flash target.but to my surprise, i can't make a debug point on the editor side.the red point didn't appear.then i click the debug icon button, i saw nothing happened after compiled.can anybody help me? i wish you everything goes well. whether the idea 13 community version support for debugging on flash target? if can, how to set?

See a detailed description of the feature in the Haxe Manual.

@:forward(length) // unresolved symbol
abstract Hello(String) {
    public function new() {
        this = "hello";
    }
}
var hello = new Hello();
hello.length; // unresolved symbol, no completion

In the above example, only the field length should be forwarded and should have completion. You can also write @:forward with no arguments to forward all fields.

TIR: STB-7291

This is waiting on the PSI tree rework to settle down.

The Haxe language has been extended and the IDEA plug-in has not been extended to handle its new features.
Improve IntelliJ Haxe plugin:
• Better handling for @ and @:
(so that they continue with proper compilation even in the face of an error)
EMB Note: This may have already been addressed by ‘as3boyan’ and included in the https://github.com/HaxeIDE/intellij-haxe repository.

TiVo internal reference: STB-2046

ClassHierarchy has broken variables resolving

Even simple

var z:Int;
z = 1; //marked as unresolved

Calling autoalign-feature wrong behavior:
It switch from

@:buildXml("&<include name='${haxelib:hx-nanovg}/Build.xml'/>")
class Main...

to

@:buildXml("&<include name='${haxelib:hx - nanovg}/Build.xml'/>")

• added spaces to hx - nanovg.

For full example look Demo.hx#L9.

TIR: STB-7295