如何在haxe中以宏模式获取导入列表？

Question

How do you get the list of imports a .hx file uses in macro mode? More specificity, suppose I have a "haxe.macro.Position" that tells me which file an expression belongs to. I need to know the imports the file uses in order to convert abridged type declarations such as "Car" into full-package-path types such as "vehicles.fourWheels.Car".

Answer 1

It is planned to add in haxe 3.3: https://github.com/HaxeFoundation/haxe/issues/3560

At the moment, you may try to read the source file directly (as String ) and parse the import statements manually.

For getting the fully-qualified type name, there is also a suggestion made in the above mentioned issue :

var someComplexType:ComplexType = getComplexType();
switch (Context.typeof( macro ( _ : $someComplexType )))
{
    case TInst(_.get() => c,_):
      var pack = c.pack, name = c.name;
    case _: 
}

---

edit:

Here is a more complete solution to get the fully-qualified type name:

#if macro
import haxe.macro.*;
import haxe.macro.Expr;
import haxe.macro.Type;
#end
import haxe.ds.Option;

class Test {
    #if macro
    static public function typeToTypePath(t:Type):TypePath {
        return switch (Context.follow(t)) {
            case TInst(t, params):
                baseTypeToTypePath(t.get(), [for (p in params) TPType(Context.toComplexType(p))]);
            case TEnum(t, params):
                baseTypeToTypePath(t.get(), [for (p in params) TPType(Context.toComplexType(p))]);
            case TType(t, params):
                baseTypeToTypePath(t.get(), [for (p in params) TPType(Context.toComplexType(p))]);
            case TAbstract(t, params):
                baseTypeToTypePath(t.get(), [for (p in params) TPType(Context.toComplexType(p))]);
            case _: throw 'Cannot convert this to TypePath: $t';
        };
    }

    static function baseTypeToTypePath(t:BaseType, params:Array<TypeParam>):TypePath {
        return {
            pack:t.pack, 
            name:t.module.substring(t.module.lastIndexOf(".")+1), 
            sub:t.name,
            params:params
        };
    }

    /**
        Fully-qualify a `ComplexType`.
        For example, turn `Option<Int>` to `haxe.ds.Option.Option<StdTypes.Int>`.
        In case the process fail, it will return the input `ComplexType`.
    */
    static public function qualifyComplexType(ct:ComplexType):ComplexType {
        var type = Context.typeof(macro ( null : $ct ));
        try {
            var tp = typeToTypePath(type);
            return TPath(tp);
        } catch(e:Dynamic) {
            return ct;
        }
    }
    #end

    /**
        Just an example to demostrate `qualifyComplexType`.
        It accepts an `e` expression in the form of `var _:Type`,
        and trace the fully-qualified name of `Type` at compile-time.
    */
    macro static public function printType(e:Expr):Expr {
        switch (e) {
            case macro var a:$ct:
                trace(ComplexTypeTools.toString(qualifyComplexType(ct)));
            case _:
        }
        return e;
    }


    static function main() {
        printType(var a:Int);          //StdTypes.Int
        printType(var a:Test);         //Test.Test
        printType(var a:Option<Int>);  //haxe.ds.Option.Option<StdTypes.Int>
        printType(var a:Void->Void);   //Void -> Void
    }
}