vshaxe / haxe-tmlanguage

TextMate grammars for Haxe and HXML

Haxe Support for Visual Studio Code

This is an extension for Visual Studio Code that adds support for the Haxe language, leveraging the Haxe Language Server. It works best with the latest Haxe 4 release, but supports any Haxe version starting from 3.4.0.

Some framework-specific extensions exist to extend the functionality further:

• If you're using Lime or OpenFL, you should also install the Lime extension.
• If you're using Kha, the Kha Extension Pack should be used.

Features

This is just a brief overview of the supported features. For more details, check out our extensive documentation.

• Syntax Highlighting
• Tasks (Tasks -> Run Task...)
• Debugging (F5)
• Commands (F1 -> search "Haxe")
• Dependency Explorer
• Auto Indentation
• Completion
• Postfix Completion
• Snippets
• Code Generation
• Signature Help
• Hover Hints
• Go to Definition (F12)
• Go to Type Definition
• Go to Implementations (Ctrl+F12)
• Peek Definition (Alt+F12)
• Find All References (Shift+Alt+F12)
• Peek References (Shift+F12)
• Rename Symbol (F2)
• Document Symbols (Ctrl+Shift+O)
• Workspace Symbols (Ctrl+T)
• Outline
• Folding
• Diagnostics
• Code Actions (Ctrl+. on light bulbs)
• Code Lens (F1 -> Haxe: Toggle Code Lens)
• Formatting (Shift+Alt+F)
• Extension API
• Inlay Hints

Building

For instructions on building/installing from source, please see the dedicated wiki page.

haxe-tmlanguage's Issues

Invalid string interpolation

The compiler does not interpolate invalid identifiers (e.g. starting with number)

'$1' should not be highlighted as interpolation.

Unclosed struct extends breaks highlighting in following lines

Single-letter uppercase constants

Uppercase identifiers are highlighted as variables, rather than types, but there's an exception for single-letter uppercase identifiers (mostly because that's a common in type paramters, e.g. T). This leads to issues like this:

We can probably get rid of this hack because the grammar should know about the places where type parameters can occur by now, and still highlight T etc correctly as a result.

Abstract with inline struct types

abstract B({b:Int}) from {b:Int} to {b:Int} {}

IntIterator literal with number in class name

Utf8 is not highlighted as a class name:

0...Utf8.length(_result)

`import` in `--macro`

--macro utest.utils.Macro.importEnvSettings()

Highlighting fails after arrow function with types

I don't think this is the case mentioned in #29 (comment)

With the type hint in the return, the highlighting stops for the following functions:

If I remove the type hint:

And a text version for copypasting (which also shows the problem):

abstract Callback<T>(CallbackData<T>) from CallbackData<T> {
	@:from static inline function fromOptionalErrorOnly(f:(?error:Error) -> Void):Callback<NoData> return (?err:Error, ?result:NoData) -> f(err);

	@:from static inline function fromErrorOnly(f:(error:Error) -> Void):Callback<NoData> return (?err:Error, ?result:NoData) -> f(err);
}

anon functions within string interpolation

class Main {
    static function main() {
        trace('${f(function(j) return j)}'); // oh my everything is a string
    }
}

if highlighted as a function call within another function call

macro with colon

kind: FieldType.FProp("default", "null", macro:Dynamic, macro $v{sha})

import and using at root level

importFoo();
usingBar();

Incorrect type hint highlighting for final

class Foo {
	final foo:(bar:Int) -> Void;
	var foo:(bar:Int) -> Void;
}

Haxe highlighting not working properly

Hi, the haxe highlighting doesnt work properly for some reason, i would like to get help. I installed every extensions, but it doesnt work properly. The output says that the haxe language server runs fine.

Windows 11 22H2

Typedef without semicolon breaks highlighting

Example:

typedef IntType = Int
typedef StringType = String

// but this works
typedef IntType = Int;
typedef StringType = String;

Unclosed function scope in enum constructor + structure in ternary

Reduced from vshaxe/vshaxe#219.

Foo(function(i) return i);
return e2 == null ? { t : HDyn } : bar(e2);

new function type

https://github.com/HaxeFoundation/haxe-evolution/blob/master/proposals/0003-new-function-type.md

Still highlight keywords in identifier locations

function foo(default:Int) {}
var default:Int;
default

default is highlighted as an identifier here. This gives the misleading impression that the code is correct, but in reality it does of course not compile. It would be better to still highlight keywords as such in these positions.

String interpolation with nested brackets

The last } here should not be highlighted as a string.

'${{}}'

Regex literal as Const type parameter not highlighted

function keyword in parens

(function() {})

function is highlighted as a method call rather than as a keyword.

Complex compiler conditionals

#elseif (!no_ssl && (hxssl || hl || cpp || (neko && !(macro || interp)))) new sys.ssl.Socket();

Note the last two closing parenthesis.

Conditional type declaration

#if hscriptPos
enum ExprDef {
#else
enum Expr {
#end
}

The second enum is not highlighted correctly. Probably an issue for all types (and in other places as well).

Doubly nested parens in conditional compilation

#if (((foo)) && bar)
#end

Hxml highlighting after -cmd

We highlight -xml as an argument here when it's actually still part of the command:

-cmd lime build flash -xml

Incorrect arrow function highlighting

function new( init : (T -> Void) -> (Dynamic -> Void) -> Void ) : Void;

function new( )

class C {
    function new( ) {} // note the space between parens, removing it fixes the coloring

    function f() { // broken
        trace("hi"); // better here :)
    }
}

---

see vshaxe/vshaxe#80

Inline block comment on function declaration

...breaks highlights afterwards

Add support for \u and \x escape sequences in strings

See https://github.com/HaxeFoundation/haxe/blob/bc2ff8acc33798556882d0b47ce253d2cb7fb380/src/core/ast.ml#L489-L521

string and keywords not highlighted inside a non-block function expr

class A {
    function f() return new B("name", null, this);
}

---

see vshaxe/vshaxe#81

another funny `new` highlighting issue

Highlighting stops in weird conditions

class Foo {
  function func() {
    switch x {
      case _:
        new X(Y(function () foo));
      case A({a: _}, _):
        // highlighting is broken at this point
        new Map<String, String>();
        trace("foobar");
        var x = 1 + 2;
        var etc = "etc";
    }
  }
}

It seems the lines with new X and case A are both required for the issue to happen. Can be alleviated by putting foo inside {}.

var in case

var option = haxe.ds.Option.Some(0);
switch (option) {
    case Some(var i): "foo";
    case None:
}

Comment after conditional without spacing

#if foo/*test*/#end
#if foo//test
#end

#if (foo)/*test*/#end
#if (foo)//
#end

In the case without braces, foo is highlighted incorrectly.

Type.property.Property highlighted as a type path

This is highlighted as Type.package.package.Type. It looks correct with a lowercase c:

Should be possible to say that it can't be a type path if the first segment (FlxG) looks like a type already.

Highlight lone package / Type in hxml

Type paths can occur not only after --main, but also with no argument preceding it, like the vshaxe.Main here:

Should be possible to highlight properly.

`case {x: _}` screws up highlighting

class Main {
    public static function main() {
        var obj = {
            foo: switch baz() {
                case {x: x}: [x];
            },
            bar: switch baz() {
                case {x: x}: [x];
            },
        }
   }
}

Braceless anonymous function scopes are not always closed

The grammar relies on a ; to close function scopes when there are no braces. However, for instance inside of function arguments, like in the following example, it doesn't ever get to match against the ;:

class C {
    function f() {
        f(
            function() f,
            function() f,
            function() f
        );
    }
}

As a result, there are too many function scopes on the stack that won't ever be closed:

This causes subsequent highlighting to break in some cases, for instance the type name T here:

Highlight inline templates (jsx/hxx/html, etc)

I see language-haxe (atom) did it (screenshot)
So I think it is possible to do.

Or let me know where to start from, I may give it a try.

Type.SubType

var f:Type.SubType;

Regression, probably caused by 5d96890.

Var init with block is unclosed

var foo = {
	1;
}
typedef Bar = T<T1, T2>;

code in comment make the highlighting less happy

See attached image.

Folds

With the old Haxe TM bundle, any { ... } block or structure was detected as such and it was possible (in TextMate 2) to collapse the blocks. With this repo, that feature is no longer available. Would it be possible to add folds for { ... } and conditional compilation?

Types in typedef extensions

Not highlighted as types:

typedef JNode = {
    >JNodeBase,
    @:optional var sub:Array<JNodeBase>;
}

Strings not highlighted in metadata

enum Item {
  @:json({ type: 'sword' }) Sword(damage:{max:Int});
  @:json({ type: 'shield' }) Shield(shield:{armor:Int});
  @:json({ type: 'staff' }) Staff(block:Float, ?magic:Int);
  Potion(effect:PotionEffect);
}

unclosed highlighting scope

class A {
    inline function
}

// comment

---

see vshaxe/vshaxe#82

Highlighting of "as" in import module.Type.SubType

import module.Module.SubType as Foo;

vs without the SubType, where it works correctly:

HXML names with substrings of arguments

# exe-runner
--next
compile-exe-runner.hxml

# java-runner
--next
compile-java-runner.hxml

Strings highlighted incorrectly after var in call

This is a regression. Started occurring after updating to vshaxe 1.3.1.
Hope this is the right place to post the bug.

Text Version:

class X {
    public static function a() {
        foo( var bar = 0
           , 'Specialize ${foo.toString()}'
           );
    }
}

class X {
    public static function a() {
        foo( bar = 0
           , 'Specialize ${foo.toString()}'
           );
    }
}

String concatenation with )

trace("Begin of my text" + ") -> rest of my text");

No space after {

function() {return null; }