Release 0.13.5

Add TypeMap alias

.gitignore

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

.travis.yml

@@ -2,18 +2,26 @@ sudo: required
 dist: trusty
 
 language: haxe
-
 haxe:
-  - "3.2.1"
+- 3.2.1
-  - development
+- development
-  
+
 matrix:
   allow_failures:
-    - haxe: development
+  - haxe: development
-    
+
 install:
-  - haxelib install travix
+- haxelib install travix
-  - haxelib run travix install
+- 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

@@ -64,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
 

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": "Improved build cache.",
+	"releasenote": "Fix 3.2.1.",
-	"version": "0.12.0",
+	"version": "0.13.5",
 	"url": "http://haxetink.org/tink_macro",
 	"dependencies": {
 		"tink_core": ""

src/tink/MacroApi.hx

@@ -14,6 +14,7 @@ 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>;
@@ -35,4 +36,4 @@ class MacroApi {
   static public function pos() 
     return haxe.macro.Context.currentPos();
 
-}
+}

src/tink/macro/BuildCache.hx

@@ -5,6 +5,7 @@ import haxe.macro.Expr;
 import haxe.macro.Type;
 import tink.macro.TypeMap;
 
+using tink.MacroApi;
 using haxe.macro.Tools;
 
 typedef BuildContextN = {
@@ -104,7 +105,7 @@ class BuildCache {
       usings: ctx.usings
     }));
   }
-  
+
   static public function getType(name, ?type, ?pos:Position, build:BuildContext->TypeDefinition) {
     
     if (pos == null)
@@ -156,22 +157,28 @@ private class Group {
         usings: usings, 
         name: path.split('.').pop()
       });
-      
+
-      Context.defineModule(path, [def], usings);
       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:
-          make('$name${counter++}');
+          doMake();
         case v:
-          try {
+          switch v.name.definedType() {
-            Context.getType(v.name);
+            case Some(v): v;
-          }
+            default: doMake();
-          catch (e:Dynamic) {
-            make(v.name);
           }
       }
   }

src/tink/macro/Exprs.hx

@@ -388,6 +388,17 @@ 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";

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 neko.Lib.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)) {
@@ -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);
@@ -168,11 +184,11 @@ class Types {
         sub : null,
       });
       
-  static function resolveDirectType() 
+  static function resolveDirectType()
     return 
       switch reduce(Context.getLocalType()) {
         case TInst(_, [TInst(_.get() => { kind: KExpr(e) }, _)]):  
-          types[e.getInt().sure()]();
+          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;}));
+  }
 }