Release 0.12.2

Add concat()

README.md

@@ -1,4 +1,5 @@
 # Tinkerbell Macro Library
+[![Gitter](https://img.shields.io/gitter/room/nwjs/nw.js.svg?maxAge=2592000)](https://gitter.im/haxetink/public)
 
 Explained in current marketing speak, `tink_macro` is *the* macro toolkit ;)
 
@@ -63,6 +64,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 +415,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

haxelib.json

@@ -11,8 +11,8 @@
 	"contributors": [
 		"back2dos"
 	],
-	"releasenote": "Store user defined constructors.",
-	"version": "0.9.1",
+	"releasenote": "Fix issue with .toComplex()",
+	"version": "0.12.2",
 	"url": "http://haxetink.org/tink_macro",
 	"dependencies": {
 		"tink_core": ""

src/tink/MacroApi.hx

@@ -19,8 +19,6 @@ typedef Unops = tink.macro.Ops.Unary;
 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;

src/tink/macro/BuildCache.hx

@@ -5,6 +5,16 @@ import haxe.macro.Expr;
 import haxe.macro.Type;
 import tink.macro.TypeMap;
 
+using haxe.macro.Tools;
+
+typedef BuildContextN = {
+  pos:Position,
+  types:Array<Type>,
+  usings:Array<TypePath>,
+  name:String,
+}
+
+
 typedef BuildContext = {
   pos:Position,
   type:Type,
@@ -12,21 +22,87 @@ typedef BuildContext = {
   name:String,
 }
 
+typedef BuildContext2 = {>BuildContext,
+  type2:Type,
+}
+
+typedef BuildContext3 = {>BuildContext2,
+  type3:Type,
+}
+
 class BuildCache { 
   
-  static var cache = init();
+  static var cache = new Map();
   
-  static function init() {
+  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) {
     
-    function refresh() {
-      cache = new Map();
-      return true;
-    }
+    if (pos == null)
+      pos = Context.currentPos();
     
-    Context.onMacroContextReused(refresh);
-    refresh();
-    
-    return cache;
+    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) {
@@ -38,20 +114,42 @@ class BuildCache {
       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 TypeMap();
+        case null: cache[name] = new Group(name);
         case v: v;
       }
-          
-    if (!forName.exists(type)) {
-      var path = '$name${Lambda.count(forName)}',
-          usings = [];
-          
+    
+    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, 
@@ -60,9 +158,16 @@ class BuildCache {
       });
       
       Context.defineModule(path, [def], usings);
-      forName.set(type, Context.getType(path));
+      entries.set(type, { name: path } );
+      return Context.getType(path);
     }
     
-    return forName.get(type);  
+    return 
+      switch entries.get(type) {
+        case null:
+          make('$name${counter++}');
+        case v:
+          Context.getType(v.name);
+      }
   }
 }

src/tink/macro/Constructor.hx

@@ -96,7 +96,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/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);
       }
@@ -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 ? null : 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

@@ -15,10 +15,6 @@ using tink.CoreApi;
 class Types {
   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)
@@ -152,7 +148,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);
@@ -168,12 +164,11 @@ class Types {
         sub : null,
       });
       
-  
-  static function resolveDirectType() 
+  static function resolveDirectType()
     return 
       switch reduce(Context.getLocalType()) {
         case TInst(_, [TInst(_.get() => { kind: KExpr(e) }, _)]):  
-          types.get(Std.parseInt(e.toString()))();
+          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;}));
+  }
 }