Release 0.14.2

Support for haxe 4 EIn change to EBinop(OpIn)

.gitignore

@@ -0,0 +1 @@
+/bin

.travis.yml

@@ -2,18 +2,26 @@ sudo: required
 dist: trusty
 
 language: haxe
-
 haxe:
-  - "3.2.1"
-  - development
-  
+- 3.2.1
+- development
+
 matrix:
   allow_failures:
-    - haxe: development
-    
+  - haxe: development
+
 install:
-  - haxelib install travix
-  - haxelib run travix install
+- haxelib install travix
+- haxelib run travix install
 
 script:
-  - haxelib run travix node
+- haxelib run travix node
+
+env:
+  secure: T4SCtY5qmEsK1ARWPevJmqLm23tv4CobLrbPOQV3FsoQno7FCP1S/+9GmuoJKzeTjWMzdTeDsp8TVwZ6AyGjvhl2nZNjhU+QTsir4tfbYYRyvsz/QK6pveFbPQVv7OsnnaB4wbZtqGZ8mzFeQf7Ol4tsNe7iUFJb/iVc+4/lUxo=
+
+deploy:
+  provider: script
+  script: haxe && haxelib run travix release
+  on:
+    tags: true

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "haxe.displayConfigurations": [
+        ["tests.hxml"]
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,6 @@
+{
+    "version": "0.1.0",
+    "command": "haxelib",
+    "args": ["run", "travix", "node"],
+    "problemMatcher": "$haxe"
+}

README.md

@@ -1,5 +1,8 @@
 # Tinkerbell Macro Library
 
+[![Build Status](https://travis-ci.org/haxetink/tink_macro.svg?branch=master)](https://travis-ci.org/haxetink/tink_macro)
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/haxetink/public)
+
 Explained in current marketing speak, `tink_macro` is *the* macro toolkit ;)
 
 ### History and Mission
@@ -63,6 +66,8 @@ Rejects an expression and displays a generic or custom error message
 Converts an expression into the corresponding Haxe source code
 - `log(e:Expr, ?pos:Position):Expr`  
 Traces the string representation of an expression and returns it.
+- `concat(e1:Expr, e2:Expr):Expr`
+Concats two expressions into a block. If either sub-expression is a block itself, it gets flattened into the resulting block.
 
 #### Extracting Constants
 
@@ -412,4 +417,4 @@ Because the state of a constructor is rather delicate, the API prohibits you to
 
 #  TypeMap
 
-You can find a type map, i.e. a map where the keys are `haxe.macro.Type`, in `tink.macro.TypeMap`. It's pretty much an ordinary map. Currently, it relies rather strongly on [`haxe.macro.TypeTools.toString()`](http://api.haxe.org/haxe/macro/TypeTools.html#toString) and it remains to be determined whether that is a reliable choice. Please report any issues you might face.
+You can find a type map, i.e. a map where the keys are `haxe.macro.Type`, in `tink.macro.TypeMap`. It's pretty much an ordinary map. Currently, it relies rather strongly on [`haxe.macro.TypeTools.toString()`](http://api.haxe.org/haxe/macro/TypeTools.html#toString) and it remains to be determined whether that is a reliable choice. Please report any issues you might face.

Run.bat

@@ -1,3 +0,0 @@
-cd bin
-neko tests.n
-pause

bin/.gitignore

@@ -1 +0,0 @@
-*.n

haxelib.json

@@ -11,8 +11,8 @@
 	"contributors": [
 		"back2dos"
 	],
-	"releasenote": "Add TypeMap.",
-	"version": "0.7.0",
+	"releasenote": "Add way to get constructor args.",
+	"version": "0.14.2",
 	"url": "http://haxetink.org/tink_macro",
 	"dependencies": {
 		"tink_core": ""

src/tink/MacroApi.hx

@@ -14,13 +14,12 @@ typedef Bouncer = tink.macro.Bouncer;
 typedef Types = tink.macro.Types;
 typedef Binops = tink.macro.Ops.Binary;
 typedef Unops = tink.macro.Ops.Unary;
+typedef TypeMap<T> = tink.macro.TypeMap<T>;
 
 //TODO: consider adding stuff from haxe.macro.Expr here
 typedef MacroOutcome<D, F> = tink.core.Outcome<D, F>;
 typedef MacroOutcomeTools = tink.OutcomeTools;
 
-typedef Option<T> = haxe.ds.Option<T>;
-
 typedef Member = tink.macro.Member;
 typedef Constructor = tink.macro.Constructor;
 typedef ClassBuilder = tink.macro.ClassBuilder;
@@ -37,4 +36,4 @@ class MacroApi {
   static public function pos() 
     return haxe.macro.Context.currentPos();
 
-}
+}

src/tink/macro/BuildCache.hx

@@ -0,0 +1,185 @@
+package tink.macro;
+
+import haxe.macro.Context;
+import haxe.macro.Expr;
+import haxe.macro.Type;
+import tink.macro.TypeMap;
+
+using tink.MacroApi;
+using haxe.macro.Tools;
+
+typedef BuildContextN = {
+  pos:Position,
+  types:Array<Type>,
+  usings:Array<TypePath>,
+  name:String,
+}
+
+
+typedef BuildContext = {
+  pos:Position,
+  type:Type,
+  usings:Array<TypePath>,
+  name:String,
+}
+
+typedef BuildContext2 = {>BuildContext,
+  type2:Type,
+}
+
+typedef BuildContext3 = {>BuildContext2,
+  type3:Type,
+}
+
+class BuildCache { 
+  
+  static var cache = new Map();
+  
+  static public function getType3(name, ?types, ?pos:Position, build:BuildContext3->TypeDefinition) {
+     if (types == null)
+      switch Context.getLocalType() {
+        case TInst(_.toString() == name => true, [t1, t2, t3]):
+          types = { t1: t1, t2: t2, t3: t3 };
+        default:
+          throw 'assert';
+      }  
+      
+    var t1 = types.t1.toComplexType(),
+        t2 = types.t2.toComplexType(),
+        t3 = types.t2.toComplexType();
+        
+    return getType(name, (macro : { t1: $t1, t2: $t2, t3: $t3 } ).toType(), pos, function (ctx) return build({
+      type: types.t1,
+      type2: types.t2,
+      type3: types.t3,
+      pos: ctx.pos,
+      name: ctx.name,
+      usings: ctx.usings
+    }));   
+  }
+  
+  static public function getTypeN(name, ?types, ?pos:Position, build:BuildContextN->TypeDefinition) {
+    
+    if (pos == null)
+      pos = Context.currentPos();
+    
+    if (types == null)
+      switch Context.getLocalType() {
+        case TInst(_.toString() == name => true, params):
+          types = params;
+        default:
+          throw 'assert';
+      }  
+      
+    var compound = ComplexType.TAnonymous([for (i in 0...types.length) {
+      name: 't$i',
+      pos: pos,
+      kind: FVar(types[i].toComplexType()),
+    }]).toType();
+        
+    return getType(name, compound, pos, function (ctx) return build({
+      types: types,
+      pos: ctx.pos,
+      name: ctx.name,
+      usings: ctx.usings
+    }));
+  }  
+  
+  static public function getType2(name, ?types, ?pos:Position, build:BuildContext2->TypeDefinition) {
+    if (types == null)
+      switch Context.getLocalType() {
+        case TInst(_.toString() == name => true, [t1, t2]):
+          types = { t1: t1, t2: t2 };
+        default:
+          throw 'assert';
+      }  
+      
+    var t1 = types.t1.toComplexType(),
+        t2 = types.t2.toComplexType();
+        
+    return getType(name, (macro : { t1: $t1, t2: $t2 } ).toType(), pos, function (ctx) return build({
+      type: types.t1,
+      type2: types.t2,
+      pos: ctx.pos,
+      name: ctx.name,
+      usings: ctx.usings
+    }));
+  }
+
+  static public function getType(name, ?type, ?pos:Position, build:BuildContext->TypeDefinition) {
+    
+    if (pos == null)
+      pos = Context.currentPos();
+    
+    if (type == null)
+      switch Context.getLocalType() {
+        case TInst(_.toString() == name => true, [v]):
+          type = v;
+        case TInst(_.toString() == name => true, _):
+          Context.fatalError('type parameter expected', pos);
+        case TInst(_.get() => { pos: pos }, _):
+          Context.fatalError('Expected $name', pos);
+        default:
+          throw 'assert';
+      }  
+      
+    var forName = 
+      switch cache[name] {
+        case null: cache[name] = new Group(name);
+        case v: v;
+      }
+    
+    return forName.get(type, pos, build);  
+  }
+}
+
+private typedef Entry = {
+  name:String,
+}
+
+private class Group {
+  
+  var name:String;
+  var counter = 0;
+  var entries = new TypeMap<Entry>();
+  
+  public function new(name) {
+    this.name = name;
+  }
+  
+  public function get(type:Type, pos:Position, build:BuildContext->TypeDefinition):Type {
+    
+    function make(path:String) {
+      var usings = [];
+      var def = build({
+        pos: pos, 
+        type: type, 
+        usings: usings, 
+        name: path.split('.').pop()
+      });
+
+      entries.set(type, { name: path } );
+      Context.defineModule(path, [def], usings);
+      return Context.getType(path);
+    }
+
+    function doMake() 
+      while (true) 
+        switch '$name${counter++}' {
+          case _.definedType() => Some(_):
+          case v:
+            return make(v);
+        } 
+
+    return 
+      switch entries.get(type) {
+        case null:
+          doMake();
+        case v:
+          switch v.name.definedType() {
+            case Some(v): v;
+            default: doMake();
+          }
+      }
+  }
+}

src/tink/macro/ClassBuilder.hx

@@ -9,53 +9,53 @@ using tink.MacroApi;
 using Lambda;
 
 class ClassBuilder {
-  
+
   var memberList:Array<Member>;
   var macros:Map<String,Field>;
   var constructor:Null<Constructor>;
   public var target(default, null):ClassType;
   var superFields:Map<String,Bool>;
-  
+
   var initializeFrom:Array<Field>;
-    
-  public function new(?target, ?fields) { 
-    if (target == null) 
+
+  public function new(?target, ?fields) {
+    if (target == null)
       target = Context.getLocalClass().get();
-      
+
     if (fields == null)
       fields = Context.getBuildFields();
-    
+
     this.initializeFrom = fields;
     this.target = target;
   }
-  
+
   function init() {
     if (initializeFrom == null) return;
-    
+
     var fields = initializeFrom;
     initializeFrom = null;
-    
+
     this.memberList = [];
     this.macros = new Map();
-    
-    for (field in fields) 
+
+    for (field in fields)
       if (field.access.has(AMacro))
         macros.set(field.name, field)
       else if (field.name == 'new') {
         var m:Member = field;
         this.constructor = new Constructor(this, m.getFunction().sure(), m.isPublic, m.pos, field.meta);
       }
-      else 
+      else
         doAddMember(field);
-        
-    
+
+
   }
-  
+
   public function getConstructor(?fallback:Function):Constructor {
     init();
-    if (constructor == null) 
+    if (constructor == null)
       if (fallback != null)
-        new Constructor(this, fallback);
+        constructor = new Constructor(this, fallback);
       else {
         var sup = target.superClass;
         while (sup != null) {
@@ -64,18 +64,18 @@ class ClassBuilder {
             try {
               var ctor = cl.constructor.get();
               var func = Context.getTypedExpr(ctor.expr()).getFunction().sure();
-              
+
               for (arg in func.args) //this is to deal with type parameter substitutions
                 arg.type = null;
-                
+
               func.expr = "super".resolve().call(func.getArgIdents());
               constructor = new Constructor(this, func);
               if (ctor.isPublic)
-                constructor.publish();          
+                constructor.publish();
             }
             catch (e:Dynamic) {//fails for unknown reason
               if (e == 'assert')
-                neko.Lib.rethrow(e);
+                tink.core.Error.rethrow(e);
               constructor = new Constructor(this, null);
             }
             break;
@@ -85,15 +85,15 @@ class ClassBuilder {
         if (constructor == null)
           constructor = new Constructor(this, null);
       }
-        
+
     return constructor;
   }
-  
+
   public function hasConstructor():Bool {
     init();
     return this.constructor != null;
   }
-    
+
   public function export(?verbose):Array<Field> {
     if (initializeFrom != null) return null;
     var ret = (constructor == null || target.isInterface) ? [] : [constructor.toHaxe()];
@@ -108,24 +108,24 @@ class ClassBuilder {
     }
     for (m in macros)
       ret.push(m);
-    
-    if (verbose) 
-      for (field in ret) 
+
+    if (verbose)
+      for (field in ret)
         Context.warning(new Printer().printField(field), field.pos);
-    
-    return ret;    
+
+    return ret;
   }
   public function iterator():Iterator<Member> {
     init();
     return this.memberList.copy().iterator();
   }
-    
+
   public function hasOwnMember(name:String):Bool {
     init();
-    return 
+    return
       macros.exists(name) || memberByName(name).isSuccess();
   }
-  
+
   public function hasSuperField(name:String):Bool {
     if (superFields == null) {
       superFields = new Map();
@@ -139,51 +139,51 @@ class ClassBuilder {
     }
     return superFields.get(name);
   }
-  
+
   public function memberByName(name:String, ?pos:Position) {
     init();
     for (m in memberList)
-      if (m.name == name) 
+      if (m.name == name)
         return Success(m);
-        
+
     return pos.makeFailure('unknown member $name');
   }
-  
+
   public function removeMember(member:Member):Bool {
     init();
-    return 
+    return
       memberList.remove(member);
   }
-  
-  public function hasMember(name:String):Bool 
+
+  public function hasMember(name:String):Bool
     return hasOwnMember(name) || hasSuperField(name);
 
   function doAddMember(m:Member, ?front:Bool = false):Member {
     init();
-    
-    if (m.name == 'new') 
+
+    if (m.name == 'new')
       throw 'Constructor must not be registered as ordinary member';
-      
-    //if (hasOwnMember(m.name)) 
+
+    //if (hasOwnMember(m.name))
       //m.pos.error('duplicate member declaration ' + m.name);
-      
-    if (front) 
+
+    if (front)
       memberList.unshift(m);
-    else 
-      memberList.push(m);        
-      
-    return m;
-  }    
-    
-  public function addMember(m:Member, ?front:Bool = false):Member {
-    doAddMember(m, front);
-    
-    if (!m.isStatic && hasSuperField(m.name))
-      m.overrides = true;
-      
+    else
+      memberList.push(m);
+
     return m;
   }
-  
+
+  public function addMember(m:Member, ?front:Bool = false):Member {
+    doAddMember(m, front);
+
+    if (!m.isStatic && hasSuperField(m.name))
+      m.overrides = true;
+
+    return m;
+  }
+
   static public function run(plugins:Array<ClassBuilder->Void>, ?verbose) {
     var builder = new ClassBuilder();
     for (p in plugins)

src/tink/macro/Constructor.hx

@@ -62,6 +62,10 @@ class Constructor {
         default: [].toBlock();
       }
   }
+
+  public function getArgList():Array<FunctionArg>
+    return beforeArgs.concat(args).concat(afterArgs);
+
   public function addStatement(e:Expr, ?prepend) 
     if (prepend)
       this.nuStatements.unshift(e)
@@ -96,7 +100,7 @@ class Constructor {
         case Success(member): member.addMeta(':isVar');
         default:
       }
-      addStatement(macro @:pos(pos) (cast this).$name = if (true) $e else this.$name, options.prepend);        
+      addStatement(macro @:pos(pos) (cast this).$name = if (true) $e else this.$name, options.prepend);//TODO: this seems to report type errors here rather than at the declaration position
     }
     else 
       addStatement(macro @:pos(pos) this.$name = $e, options.prepend);

src/tink/macro/DirectType.hx

@@ -0,0 +1,6 @@
+package tink.macro;
+
+@:genericBuild(tink.macro.Types.resolveDirectType())
+class DirectType<Const> {
+
+}

src/tink/macro/Exprs.hx

@@ -27,10 +27,10 @@ private class Heureka { public function new() {} }
 class Exprs {
 
   static public function has(e:Expr, condition:Expr->Bool, ?options: { ?enterFunctions: Bool }) {
-    var enterFunctions = options != null && options.enterFunctions;
+    var skipFunctions = options == null || options.enterFunctions != true;
     function seek(e:Expr)
       switch e {
-        case { expr: EFunction(_) } if (options != null || options.enterFunctions != true):
+        case { expr: EFunction(_) } if (skipFunctions):
         case _ if (condition(e)): throw new Heureka();
         default: haxe.macro.ExprTools.iter(e, seek);
       }
@@ -241,7 +241,7 @@ class Exprs {
         }
         
   static public inline function iterate(target:Expr, body:Expr, ?loopVar:String = 'i', ?pos:Position) 
-    return EFor(EIn(loopVar.resolve(pos), target).at(pos), body).at(pos);
+    return macro @:pos(pos.sanitize()) for ($i{loopVar} in $target) $body;
   
   static public function toFields(object:Dynamic<Expr>, ?pos:Position)
     return EObjectDecl([for (field in Reflect.fields(object))
@@ -388,10 +388,21 @@ class Exprs {
         case EFunction(_, f): Success(f);
         default: e.pos.makeFailure(NOT_A_FUNCTION);
       }
+      
+  static public function concat(e:Expr, with:Expr, ?pos) {
+    if(pos == null) pos = e.pos;
+    return
+      switch [e.expr, with.expr] {
+        case [EBlock(e1), EBlock(e2)]: EBlock(e1.concat(e2)).at(pos);
+        case [EBlock(e1), e2]: EBlock(e1.concat([with])).at(pos);
+        case [e1, EBlock(e2)]: EBlock([e].concat(e2)).at(pos);
+        default: EBlock([e, with]).at(pos);
+      }
+  }
   
   static inline var NOT_AN_INT = "integer constant expected";
   static inline var NOT_AN_IDENT = "identifier expected";
   static inline var NOT_A_STRING = "string constant expected";
   static inline var NOT_A_NAME = "name expected";
   static inline var NOT_A_FUNCTION = "function expected";
-}
+}

src/tink/macro/Positions.hx

@@ -35,7 +35,7 @@ class Positions {
     return errorFunc(sanitize(pos), Std.string(error));
   
   static function contextError(pos:Position, error:String):Dynamic 
-    return Context.error(error, pos);
+    return Context.fatalError(error, pos);
   
   static function abortTypeBuild(pos:Position, error:String):Dynamic 
     return throw new AbortBuild(error, pos);

src/tink/macro/Sisyphus.hx

@@ -0,0 +1,105 @@
+package tink.macro;
+
+import haxe.macro.Expr;
+import haxe.macro.Type;
+
+class Sisyphus {
+
+  static function nullable(complexType : ComplexType) : ComplexType return macro : Null<$complexType>;
+
+  static function toField(cf : ClassField) : Field return {
+    function varAccessToString(va : VarAccess, getOrSet : String) : String return {
+      switch (va) {
+        case AccNormal: "default";
+        case AccNo: "null";
+        case AccNever: "never";
+        case AccResolve: throw "Invalid TAnonymous";
+        case AccCall: getOrSet;
+        case AccInline: "default";
+        case AccRequire(_, _): "default";
+      }
+    }
+    if (cf.params.length == 0) {
+      name: cf.name,
+      doc: cf.doc,
+      access: cf.isPublic ? [ APublic ] : [ APrivate ],
+      kind: switch([ cf.kind, cf.type ]) {
+        case [ FVar(read, write), ret ]:
+          FProp(
+            varAccessToString(read, "get"),
+            varAccessToString(write, "set"),
+            toComplexType(ret),
+            null);
+        case [ FMethod(_), TFun(args, ret) ]:
+          FFun({
+            args: [
+              for (a in args) {
+                name: a.name,
+                opt: a.opt,
+                type: toComplexType(a.t),
+              }
+            ],
+            ret: toComplexType(ret),
+            expr: null,
+          });
+        default:
+          throw "Invalid TAnonymous";
+      },
+      pos: cf.pos,
+      meta: cf.meta.get(),
+    } else {
+      throw "Invalid TAnonymous";
+    }
+  }
+
+  public static function toComplexType(type : Null<Type>) : Null<ComplexType> return
+    switch (type) {
+      case null:
+        null;
+      case TMono(_.get() => t):
+        t == null ? Types.toComplex(type, { direct: true }) : toComplexType(t);
+      case TEnum(_.get() => baseType, params):
+        TPath(toTypePath(baseType, params));
+      case TInst(_.get() => classType, params):
+        switch (classType.kind) {
+          case KTypeParameter(_):
+            TPath({
+              name: classType.name,
+              pack: [],
+            });
+          default:
+            TPath(toTypePath(classType, params));
+        }
+      case TType(_.get() => baseType, params):
+        TPath(toTypePath(baseType, params));
+      case TFun(args, ret):
+        TFunction(
+          [ for (a in args) a.opt ? nullable(toComplexType(a.t)) : toComplexType(a.t) ],
+          toComplexType(ret));
+      case TAnonymous(_.get() => { fields: fields }):
+        TAnonymous([ for (cf in fields) toField(cf) ]);
+      case TDynamic(t):
+        if (t == null) {
+          macro : Dynamic;
+        } else {
+          var ct = toComplexType(t);
+          macro : Dynamic<$ct>;
+        }
+      case TLazy(f):
+        toComplexType(f());
+      case TAbstract(_.get() => baseType, params):
+        TPath(toTypePath(baseType, params));
+      default:
+        throw "Invalid type";
+    }
+
+  static function toTypePath(baseType : BaseType, params : Array<Type>) : TypePath return {
+    var module = baseType.module;
+    {
+      pack: baseType.pack,
+      name: module.substring(module.lastIndexOf(".") + 1),
+      sub: baseType.name,
+      params: [ for (t in params) TPType(toComplexType(t)) ],
+    }
+  }
+}

src/tink/macro/TypeMap.hx

@@ -17,14 +17,15 @@ class TypeMap<V> extends BalancedTree<Type, V> implements IMap<Type, V> {
   }
   
   override function compare(k1:Type, k2:Type):Int {
+    
     if (follow) {
       k1 = k1.reduce();
       k2 = k2.reduce();
     }
-    //trace(k1.toString());
-    //trace(k2.toString());
+    
     return switch k1.getIndex() - k2.getIndex() {
-      case 0: Reflect.compare(k1.toString(), k2.toString());//TODO: this may be rather expensive and not very reliable
+      case 0: 
+        Reflect.compare(k1.toString(), k2.toString());//much to my surprise, this actually seems to work (at least with 3.4)
       case v: v;
     }
   }

src/tink/macro/Types.hx

@@ -13,12 +13,18 @@ using tink.macro.Functions;
 using tink.CoreApi;
 
 class Types {
+
+  static public function definedType(typeName:String)
+    return
+      try {
+        Some(Context.getType(typeName));
+      }
+      catch (e:Dynamic)
+        if (Std.string(e) == 'Type not found \'$typeName\'') None;
+        else tink.core.Error.rethrow(e);
+
   static var types = new Map<Int,Void->Type>();
   static var idCounter = 0;
-
-  @:noUsing macro static public function getType(id:Int):Type
-    return types.get(id)();
-
   static public function getID(t:Type, ?reduced = true)
     return
       if (reduced)
@@ -43,6 +49,16 @@ class Types {
           throw 'not implemented';
       }
 
+  static public function getMeta(type:Type)
+    return switch type {
+      case TInst(_.get().meta => m, _): [m];
+      case TEnum(_.get().meta => m, _): [m];
+      case TAbstract(_.get().meta => m, _): [m];
+      case TType(_.get() => t, _): [t.meta].concat(getMeta(t.type));
+      case TLazy(f): getMeta(f());
+      default: [];
+    }
+
   static function getDeclaredFields(t:ClassType, out:Array<ClassField>, marker:Map<String,Bool>) {
     for (field in t.fields.get())
       if (!marker.exists(field.name)) {
@@ -70,12 +86,12 @@ class Types {
           }
           var ret = fieldsCache.get(id);
           if (substituteParams && ret.isSuccess()) {
-            var e = ECheckType(macro null, toComplex(t)).at();
             var fields = Reflect.copy(ret.sure());
 
             for (field in fields)
               field.type = haxe.macro.TypeTools.applyTypeParameters(field.type, c.params, params);
           }
+          fieldsCache.remove(id);//TODO: find a proper solution to avoid stale cache
           ret;
         case TAnonymous(anon): Success(anon.get().fields);
         default: Context.currentPos().makeFailure('type has no fields');
@@ -152,7 +168,7 @@ class Types {
 
   static public function toComplex(type:Type, ?options:{ ?direct: Bool }):ComplexType {
     var ret =
-      if (options == null || options.direct != true) haxe.macro.TypeTools.toComplexType(type);
+      if (options == null || options.direct != true) tink.macro.Sisyphus.toComplexType(type);
       else null;
     if (ret == null)
       ret = lazyComplex(function () return type);
@@ -162,9 +178,19 @@ class Types {
   static public function lazyComplex(f:Void->Type)
     return
       TPath({
-        pack : ['haxe','macro'],
-        name : 'MacroType',
-        params : [TPExpr('tink.macro.Types.getType'.resolve().call([register(f).toExpr()]))],
+        pack : ['tink','macro'],
+        name : 'DirectType',
+        params : [TPExpr(register(f).toExpr())],
         sub : null,
       });
+
+  static function resolveDirectType()
+    return
+      switch reduce(Context.getLocalType()) {
+        case TInst(_, [TInst(_.get() => { kind: KExpr(e) }, _)]):
+          types[e.getInt().sure()]();//When using compiler server, this call throws on occasion, in which case modifying this file (to update mtime and invalidate the cache) will solve the problem
+        default:
+          throw 'assert';
+      }
+
 }

tests/Exprs.hx

@@ -80,4 +80,11 @@ class Exprs extends Base {
       ])
     );
   }
+  
+  function testConcat() {
+    exprEq(macro {a; b;}, (macro a).concat(macro b));
+    exprEq(macro {a; b; c;}, (macro {a; b;}).concat(macro c));
+    exprEq(macro {a; b; c;}, (macro a).concat(macro {b; c;}));
+    exprEq(macro {a; b; c; d;}, (macro {a; b;}).concat(macro {c; d;}));
+  }
 }