Release 0.16.0

Update README.md

.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,7 @@
 # Tinkerbell Macro Library
-[![Gitter](https://img.shields.io/gitter/room/nwjs/nw.js.svg?maxAge=2592000)](https://gitter.im/haxetink/public)
+
+[![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 ;)
 
@@ -301,7 +303,7 @@ abstract Member from Field to Field {
 
 Most of the API should be self-explaining. The `isBound` property is a bad name to convey the concept that a field can be either `inline` (`true`) or `dynamic` (`false`) or neither (`null`). Equally, `isPublic` is nullable which means that normally defaults to `private`.
 
-The `publish` method will make a field `public` if it is not `private`. This can also be done with `if (m.isPublic == null) m.isPublic = true;` but the implementation is far more efficient - for what its worth.
+The `publish` method will make a field `public` if it is not explicitly marked as `private`. This can also be done with `if (m.isPublic == null) m.isPublic = true;` but the implementation is far more efficient - for what its worth.
 
 The `extractMeta` method will "peel of" the first tag with a given `name` - if available. Note that the tag will be removed from the member.
 
@@ -389,7 +391,7 @@ The `init` method is the swiss army knife of initializing fields. The `options.p
 
 #### Setter Bypass
 
-It is important to know that when you initialize a field with `options.bypass` set to true, existing setters will by bypassed. That's particularly helpful if your setter triggers a side effect that you don't want triggered. This is achieved by generating the assignment as `(untyped this).$name = $value`. To make the code typesafe again, this is prefixed with `if (false) { var __tmp = this.$name; __tmp = $value; }`. This code is later thrown out by the compiler. Its role is to ensure type safety without interfering with the normal typing order.
+It is important to know that when you initialize a field with `options.bypass` set to true, existing setters will be bypassed. That's particularly helpful if your setter triggers a side effect that you don't want triggered. This is achieved by generating the assignment as `(untyped this).$name = $value`. To make the code typesafe again, this is prefixed with `if (false) { var __tmp = this.$name; __tmp = $value; }`. This code is later thrown out by the compiler. Its role is to ensure type safety without interfering with the normal typing order.
 
 Setter bypass also causes the field to gain an `@:isVar`. And currently, with `-dce full`, additional code will be generated to avoid the field to be eliminated.
 

bin/.gitignore

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

haxelib.json

@@ -11,8 +11,8 @@
 	"contributors": [
 		"back2dos"
 	],
-	"releasenote": "Fix issue with .toComplex()",
-	"version": "0.12.2",
+	"releasenote": "Support artificial scopes when typing. Expose more BuildCache logic. Further improve Type -> ComplexType transformation.",
+	"version": "0.16.0",
 	"url": "http://haxetink.org/tink_macro",
 	"dependencies": {
 		"tink_core": ""

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 = {
@@ -105,22 +106,30 @@ class BuildCache {
     }));
   }
 
+  static public function getParams(name:String, ?pos:Position)     
+    return
+      switch Context.getLocalType() {
+        case TInst(_.toString() == name => true, v):
+          Success(v);
+        case TInst(_.get() => { pos: pos }, _):
+          pos.makeFailure('Expected $name');
+        case v:
+          pos.makeFailure('$v should be a class');
+      }  
+
+  static public function getParam(name:String, ?pos:Position)     
+    return
+      getParams(name, pos)
+        .flatMap(function (args:Array<Type>) return switch args {
+          case [v]: Success(v);
+          case []: pos.makeFailure('type parameter expected');
+          default: pos.makeFailure('too many parameters');
+        });
+
   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';
-      }  
+      type = getParam(name, pos).sure();
       
     var forName = 
       switch cache[name] {
@@ -128,7 +137,7 @@ class BuildCache {
         case v: v;
       }
     
-    return forName.get(type, pos, build);  
+    return forName.get(type, pos.sanitize(), build);  
   }
 }
 
@@ -157,17 +166,28 @@ private class Group {
         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:
-          Context.getType(v.name);
+          switch v.name.definedType() {
+            case Some(v): v;
+            default: doMake();
+          }
       }
   }
 }

src/tink/macro/ClassBuilder.hx

@@ -75,7 +75,7 @@ class ClassBuilder {
             }
             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;
@@ -175,6 +175,12 @@ class ClassBuilder {
     return m;
   }
 
+  public function addMembers(td:TypeDefinition):Array<Member> {
+    for (f in td.fields)
+      addMember(f);
+    return td.fields;
+  }
+
   public function addMember(m:Member, ?front:Bool = false):Member {
     doAddMember(m, front);
 

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);//TODO: this seems to report type errors here rather than at the declaration position
+      addStatement(macro @:pos(pos) (cast this).$name = if (false) this.$name else $e, 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

@@ -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))
@@ -312,16 +312,44 @@ class Exprs {
   static public inline function resolve(s:String, ?pos) 
     return drill(s.split('.'), pos);
 
+  static var scopes = new Array<Array<Var>>();
+
+  static function inScope<T>(a:Array<Var>, f:Void->T) {
+    scopes.push(a);
+
+    inline function leave() 
+      scopes.pop();
+    try {
+      var ret = f();
+      leave();
+      return ret;
+    }
+    catch (e:Dynamic) {
+      leave();
+      return Error.rethrow(e);
+    }    
+  }
+
+  static public function scoped<T>(f:Void->T) 
+    return inScope([], f);
+
+  static public function inSubScope<T>(f:Void->T, a:Array<Var>) 
+    return inScope(switch scopes[scopes.length - 1] {
+      case null: a;
+      case v: v.concat(a);
+    }, f);
+  
   static public function typeof(expr:Expr, ?locals)
     return
       try {
+        if (locals == null)
+          locals = scopes[scopes.length - 1];
         if (locals != null) 
           expr = [EVars(locals).at(expr.pos), expr].toMBlock(expr.pos);
         Success(Context.typeof(expr));
       }
-      catch (e:Error) {
-        var m:Dynamic = e.message;
-        e.pos.makeFailure(m);
+      catch (e:haxe.macro.Error) {
+        e.pos.makeFailure(e.message);
       }
       catch (e:Dynamic) {
         expr.pos.makeFailure(e);

src/tink/macro/Positions.hx

@@ -12,7 +12,7 @@ class Positions {
     return 
       switch outcome {
         case Success(d): d;
-        case Failure(f): sanitize(pos).error(f);
+        case Failure(f): pos.error(f);
       }
   
   static public function makeBlankType(pos:Position):ComplexType 
@@ -32,7 +32,17 @@ class Positions {
 
 
   static public function error(pos:Position, error:Dynamic):Dynamic 
-    return errorFunc(sanitize(pos), Std.string(error));
+    return 
+      switch Std.instance(error, tink.core.Error) {
+        case null: errorFunc(sanitize(pos), Std.string(error));
+        case error: 
+          errorFunc(
+            error.pos, 
+            error.message + 
+              if (pos == null) ''
+              else ' (referenced from ' + Std.string(pos).substr(5)
+          );
+      }
   
   static function contextError(pos:Position, error:String):Dynamic 
     return Context.fatalError(error, pos);

src/tink/macro/Sisyphus.hx

@@ -17,6 +17,7 @@ class Sisyphus {
         case AccCall: getOrSet;
         case AccInline: "default";
         case AccRequire(_, _): "default";
+        default: throw "not implemented";
       }
     }
     if (cf.params.length == 0) {
@@ -52,21 +53,24 @@ class Sisyphus {
     }
   }
 
-  public static function toComplexType(type : Null<Type>) : Null<ComplexType> return
+
+  public static function toComplexType(type : Null<Type>) : Null<ComplexType> return {
+    inline function direct()
+      return Types.toComplex(type, { direct: true });
     switch (type) {
       case null:
         null;
-      case TMono(_.get() => t):
-        t == null ? null : toComplexType(t);
+      case TEnum(_.get().isPrivate => true, _): direct();
+      case TInst(_.get().isPrivate => true, _): direct();
+      case TType(_.get().isPrivate => true, _): direct();
+      case TAbstract(_.get().isPrivate => true, _): direct();
+      case TMono(_): direct();
       case TEnum(_.get() => baseType, params):
         TPath(toTypePath(baseType, params));
       case TInst(_.get() => classType, params):
         switch (classType.kind) {
           case KTypeParameter(_):
-            TPath({
-              name: classType.name,
-              pack: [],
-            });
+            direct();//TODO: check if the parameter is in scope, in which case the name can simply be used
           default:
             TPath(toTypePath(classType, params));
         }
@@ -92,7 +96,7 @@ class Sisyphus {
       default:
         throw "Invalid type";
     }
-
+  }
   static function toTypePath(baseType : BaseType, params : Array<Type>) : TypePath return {
     var module = baseType.module;
     {

src/tink/macro/Types.hx

@@ -13,6 +13,16 @@ 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;
   static public function getID(t:Type, ?reduced = true)
@@ -39,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)) {
@@ -74,7 +94,7 @@ class Types {
           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');
+        default: Context.currentPos().makeFailure('type $t has no fields');
       }
 
   static public function getStatics(t:Type)