Release 0.16.6

Fix ClassBuilder's getConstructor() when super class is extern

.haxerc

@@ -0,0 +1 @@
+{"version":"3.4.4","resolveLibs":"scoped"}

.travis.yml

@@ -13,9 +13,10 @@ matrix:
 install:
 - haxelib install travix
 - haxelib run travix install
+- haxelib install hx3compat
 
 script:
-- haxelib run travix node
+- haxelib run travix node -lib hx3compat
 
 env:
   secure: T4SCtY5qmEsK1ARWPevJmqLm23tv4CobLrbPOQV3FsoQno7FCP1S/+9GmuoJKzeTjWMzdTeDsp8TVwZ6AyGjvhl2nZNjhU+QTsir4tfbYYRyvsz/QK6pveFbPQVv7OsnnaB4wbZtqGZ8mzFeQf7Ol4tsNe7iUFJb/iVc+4/lUxo=

README.md

@@ -17,18 +17,17 @@ The library is build on top of the haxe macro API and `tink_core`, having three
 
 <!-- START INDEX -->
 - [Macro API](#macro-api)
-	- 
-		- [Expression Tools](#expression-tools)
-			- [Basic Helpers](#basic-helpers)
-			- [Extracting Constants](#extracting-constants)
-			- [Shortcuts](#shortcuts)
-			- [Type Inspection](#type-inspection)
-			- [Advanced Transformations](#advanced-transformations)
-		- [Position Tools](#position-tools)
-		- [Type Tools](#type-tools)
-		- [Function Tools](#function-tools)
-		- [Operation Tools](#operation-tools)
-		- [Metadata Tools](#metadata-tools)
+	- [Expression Tools](#expression-tools)
+		- [Basic Helpers](#basic-helpers)
+		- [Extracting Constants](#extracting-constants)
+		- [Shortcuts](#shortcuts)
+		- [Type Inspection](#type-inspection)
+		- [Advanced Transformations](#advanced-transformations)
+	- [Position Tools](#position-tools)
+	- [Type Tools](#type-tools)
+	- [Function Tools](#function-tools)
+	- [Operation Tools](#operation-tools)
+	- [Metadata Tools](#metadata-tools)
 - [Build Infrastructure](#build-infrastructure)
 	- [Member](#member)
 	- [ClassBuilder](#classbuilder)
@@ -51,9 +50,9 @@ It is suggested to use this API by `using tink.MacroApi;`
 
 Apart form `tink_macro` specific things, it will also use `haxe.macro.ExprTools` and `tink.core.Outcome`.
 
-### Expression Tools
+## Expression Tools
 
-#### Basic Helpers
+### Basic Helpers
 
 - `at(e:ExprDef, ?pos:Position):Expr`  
 A short hand for creating expression as for example `EReturn(value).at(position)`, instead of the more verbose `{ expr: EReturn(value), pos: position }`.
@@ -69,7 +68,7 @@ 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
+### Extracting Constants
 
 - `isWildcard(e:Expr):Bool`  
 Checks whether an expression is the identifier `_`
@@ -82,7 +81,7 @@ Attempts extracting an identifier from an expression. Note that an identifier ca
 - `getName(e:Expr):Outcome<String, tink.core.Error>`  
 Attempts extracting a name, i.e. a string constant or identifier from an expression
 
-#### Shortcuts
+### Shortcuts
 
 Often reification is prefereable to these shortcuts - if applicable. Unlike reification, the position of these expressions will default to `Context.currentPos()` rather than the position where they were created.
 
@@ -119,7 +118,7 @@ Generates a simple if statement.
 - `iterate(target:Expr, body:Expr, ?loopVar:String = 'i', ?pos:Position):Expr`  
 Will loop over `target` with a loop variable called `loopVar` using `body`-
 
-#### Type Inspection
+### Type Inspection
 
 - `is(e:Expr, c:ComplexType):Bool`  
 Tells you whether a given expression has a given type. 
@@ -129,7 +128,7 @@ Inspects, whether an expression can be iterated over and if so returns the eleme
 - `typeof(expr:Expr, ?locals:Array<Var>):Outcome<Type, tink.core.Error>`  
 Attempts to determine the type of an expression. Note that you can use `locals` to hint the compiler the type of certain identifiers. For example if you are in a build macro, and you want to get the type of a subexpression of a method body, you could "fake" the other members of the class as local variables, because in that context, the other members do not yet exists from the compiler's perspective.
 
-#### Advanced Transformations
+### Advanced Transformations
 
 - `has(e:Expr, condition:Expr->Bool, ?options: { ?enterFunctions: Bool })`
 This function actually does no transformation, but is very close to the rest of these functions. It allows you to check whether an expression has a sub-expression that satisfies `condition`. By default, it does not enter nested functions. 
@@ -187,7 +186,7 @@ This will traverse an expression and will apply the `yielder` to the "leafs", wh
 
 	If you set `options.leaveLoops` to `true`, then loops (both for and while) will be considered leafs. 
 	
-### Position Tools
+## Position Tools
 
 - `sanitize(pos:Position):Position`  
 Returns the position ITself or `Context.currentPos()` if it's null.
@@ -202,7 +201,7 @@ Creates a failed `Outcome` associated with the supplied position.
 - `getOutcome<D, F>(pos:Position, outcome:Outcome<D, F>):D`  
 Attempts getting the result of the supplied outcome. If it is a failure, it will cause an error at the given position.
 
-### Type Tools
+## Type Tools
 
 - `getID(t:Type, ?reduced = true):Null<String>`  
 Returns a String identifier for a type if available. By default, the type will be reduced prior to getting its name (typedefs are resolved etc.). With `reduced = false` you can also get the name of a typedef.
@@ -225,7 +224,7 @@ Will tell you whether a field is a variable or not. Signature is likely to chang
 - `toComplex(type:Type, ?option:{ ?direct: Bool }):ComplexType`  
 Will convert a `Type` to a `ComplexType`. Ideally this is done with `Context.toComplexType` but for monomorphs and the like, this builtin method fails and `tink_macro` uses a hack to make it work none the less. You can also use `{ direct : true }` to force this hack in case the translation fails (which can be the case with private types).
 
-### Function Tools
+## Function Tools
 
 - `asExpr(f:Function, ?name:String, ?pos:Position):Expr`  
 Converts a function to an expression, i.e. a local function definition.
@@ -236,7 +235,7 @@ A shorthand to create function arguments.
 - `getArgIdents(f:Function):Array<Expr>`  
 Will extract the argument list of a function as an expression list of identifiers (usefull when writing call-forwarding macros or the like).
 
-### Operation Tools
+## Operation Tools
 
 - `get(o:Binop, e:Expr):Outcome<{ e1:Expr, e2:Expr, pos:Position }, tink.core.Error>`  
 Attempts to extract a specific binary operation from an expression.
@@ -250,7 +249,7 @@ Attempts to extract a specific unary operation from an expression.
 - `getUnop(e:Expr):Outcome<{ op:Unop, e:Expr, postFix:Bool, pos:Position }, tink.core.Error>`  
 Attempts to decompose an expression into the parts of a unary operation.
 
-### Metadata Tools
+## Metadata Tools
 
 - `toMap(m:Metadata):Map<String, Array<Array<Expr>>`
 Will deconstruct an array of metadata tags to a `Map` mapping the tag names to an array of the argument lists of each tag with that name. So `@foo(1) @foo(2) @bar` becomes `["foo" => [[1], [2]], "bar" => [[]]]`

haxe_libraries/hxnodejs.hxml

@@ -0,0 +1,6 @@
+# @install: lix --silent download "haxelib:hxnodejs#4.0.9" into hxnodejs/4.0.9/haxelib
+-D hxnodejs=4.0.9
+-cp ${HAXESHIM_LIBCACHE}/hxnodejs/4.0.9/haxelib/src
+-D nodejs
+--macro allowPackage('sys')
+--macro _hxnodejs.VersionWarning.include()

haxe_libraries/tink_core.hxml

@@ -0,0 +1,3 @@
+# @install: lix --silent download "haxelib:tink_core#1.16.1" into tink_core/1.16.1/haxelib
+-D tink_core=1.16.1
+-cp ${HAXESHIM_LIBCACHE}/tink_core/1.16.1/haxelib/src

haxe_libraries/tink_macro.hxml

@@ -0,0 +1,3 @@
+-D tink_macro
+-cp src
+-lib tink_core

haxe_libraries/travix.hxml

@@ -0,0 +1,4 @@
+# @run: haxelib run-dir travix ${HAXESHIM_LIBCACHE}/travix/0.10.3/haxelib
+# @install: lix --silent download "haxelib:travix#0.10.3" into travix/0.10.3/haxelib
+-D travix=0.10.3
+-cp ${HAXESHIM_LIBCACHE}/travix/0.10.3/haxelib/src

haxelib.json

@@ -11,8 +11,8 @@
 	"contributors": [
 		"back2dos"
 	],
-	"releasenote": "Report invalid type in getFields.",
-	"version": "0.15.4",
+	"releasenote": "Add haxe3 polyfill for ObjectField.",
+	"version": "0.16.6",
 	"url": "http://haxetink.org/tink_macro",
 	"dependencies": {
 		"tink_core": ""

src/tink/MacroApi.hx

@@ -37,3 +37,50 @@ class MacroApi {
     return haxe.macro.Context.currentPos();
 
 }
+
+
+#if (haxe >= 4)
+  typedef ObjectField = haxe.macro.Expr.ObjectField;
+  typedef QuoteStatus = haxe.macro.Expr.QuoteStatus;
+#else
+  enum QuoteStatus {
+    Unquoted;
+    Quoted;
+  }
+  private typedef F = {
+    var field:String;
+    var expr:haxe.macro.Expr;
+  }
+
+  @:forward
+  abstract ObjectField(F) to F {
+
+    static var QUOTED = "@$__hx__"; 
+
+    inline function new(o) this = o;
+
+    public var field(get, never):String;
+    
+    function get_field()
+      return 
+        if (quotes == Quoted) 
+          this.field.substr(QUOTED.length);
+        else this.field;
+
+    public var quotes(get, never):QuoteStatus;
+    
+    function get_quotes()
+      return if (StringTools.startsWith(this.field, QUOTED)) Quoted else Unquoted;
+
+    @:from static function ofFull(o:{>F, quotes:QuoteStatus }):ObjectField
+      return switch o.quotes {
+        case null | Unquoted: 
+          new ObjectField({ field: o.field, expr: o.expr });
+        default:
+          new ObjectField({ field: QUOTED + o.field, expr: o.expr });
+      }
+
+    @:from static function ofOld(o:F):ObjectField
+      return new ObjectField(o);
+  }
+#end

src/tink/macro/BuildCache.hx

@@ -74,7 +74,11 @@ class BuildCache {
     var compound = ComplexType.TAnonymous([for (i in 0...types.length) {
       name: 't$i',
       pos: pos,
-      kind: FVar(types[i].toComplexType()),
+      kind: FVar(switch types[i] {
+        case TInst(_.get().kind => KExpr(e), _): 
+          TPath('tink.macro.ConstParam'.asTypePath([TPExpr(e)]));
+        case t: t.toComplex();
+      }),
     }]).toType();
         
     return getType(name, compound, pos, function (ctx) return build({
@@ -106,22 +110,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] {
@@ -129,7 +141,7 @@ class BuildCache {
         case v: v;
       }
     
-    return forName.get(type, pos, build);  
+    return forName.get(type, pos.sanitize(), build);  
   }
 }
 

src/tink/macro/ClassBuilder.hx

@@ -63,7 +63,9 @@ class ClassBuilder {
           if (cl.constructor != null) {
             try {
               var ctor = cl.constructor.get();
-              var func = Context.getTypedExpr(ctor.expr()).getFunction().sure();
+              var ctorExpr = ctor.expr();
+              if (ctorExpr == null) throw 'Super constructor has no expression';
+              var func = Context.getTypedExpr(ctorExpr).getFunction().sure();
 
               for (arg in func.args) //this is to deal with type parameter substitutions
                 arg.type = null;
@@ -175,6 +177,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);
 
@@ -190,4 +198,4 @@ class ClassBuilder {
       p(builder);
     return builder.export(verbose);
   }
-}
+}

src/tink/macro/ConstParam.hx

@@ -0,0 +1,3 @@
+package tink.macro;
+
+class ConstParam<Const> {}

src/tink/macro/Constructor.hx

@@ -1,8 +1,10 @@
 package tink.macro;
 
+import haxe.macro.Type;
 import haxe.macro.Expr;
 import haxe.macro.Context;
 import tink.core.Pair;
+using haxe.macro.Tools;
 using tink.MacroApi;
 
 enum FieldInit {
@@ -100,7 +102,43 @@ class Constructor {
         case Success(member): member.addMeta(':isVar');
         default:
       }
-      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
+      addStatement((function () {
+        var fields = [for (f in  (macro this).typeof().sure().getClass().fields.get()) f.name => f];
+        
+        function setDirectly(t:TypedExpr) {
+          var direct = null;
+          function seek(t:TypedExpr) {
+            switch t.expr {
+              case TField({ expr: TConst(TThis) }, FInstance(_, _, f)) if (f.get().name == name): direct = t;
+              default: t.iter(seek);
+            }
+          }			
+          seek(t);
+          if (direct == null) pos.error('nope');
+          var direct = Context.storeTypedExpr(direct);
+          return macro @:pos(pos) $direct = $e;
+        }
+        
+        return switch fields[name] {
+          case null: 
+            pos.error('this direct initialization causes the compiler to do really weird things');
+          case f:
+            switch f.kind {
+              case FVar(_, AccNormal | AccNo):
+                macro @:pos(pos) this.$name = $e;
+              case FVar(AccNever, AccNever):
+                macro @:pos(pos) this.$name = $e;
+              case FVar(AccNo | AccNormal, AccNever):
+                setDirectly(Context.typeExpr(macro @:pos(pos) this.$name));
+              case FVar(AccCall, AccNever):
+                setDirectly(fields['get_$name'].expr());
+              case FVar(_, AccCall):
+                setDirectly(fields['set_$name'].expr());
+              default:
+                pos.error('not implemented');
+            }
+        }
+      }).bounce(), options.prepend);    
     }
     else 
       addStatement(macro @:pos(pos) this.$name = $e, options.prepend);

src/tink/macro/Exprs.hx

@@ -311,10 +311,39 @@ 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));
@@ -399,6 +428,22 @@ class Exprs {
       }
   }
   
+  static var FIRST = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  static var LATER = FIRST + '0123456789';
+
+  static public function shortIdent(i:Int) {
+    var ret = FIRST.charAt(i % FIRST.length);
+
+    i = Std.int(i / FIRST.length);
+    
+    while (i > 0) {
+      ret += LATER.charAt(i % LATER.length);
+      i = Std.int(i / LATER.length);
+    }
+
+    return ret;
+  }
+  
   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";

src/tink/macro/Member.hx

@@ -32,6 +32,7 @@ abstract Member(Field) from Field to Field {
   }
   
   public var name(get, set):String;
+  public var meta(get, set):Metadata;
   public var doc(get, set):Null<String>;
   public var kind(get, set):FieldType;
   public var pos(get, set):Position;
@@ -76,6 +77,11 @@ abstract Member(Field) from Field to Field {
       }
     return pos.makeFailure('missing @$name');
   }
+
+  public function metaNamed(name) 
+    return 
+      if (this.meta == null) [];
+      else [for (tag in this.meta) if (tag.name == name) tag];
   
   public inline function asField():Field return this;
   public function publish() 
@@ -86,6 +92,12 @@ abstract Member(Field) from Field to Field {
       this.access.push(APublic);
     }
   
+  inline function get_meta() return switch this.meta {
+    case null: this.meta = [];
+    case v: v;
+  }
+  inline function set_meta(param) return this.meta = param;
+
   inline function get_name() return this.name;
   inline function set_name(param) return this.name = param;
   

src/tink/macro/Sisyphus.hx

@@ -70,10 +70,7 @@ class Sisyphus {
       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));
         }
@@ -102,11 +99,20 @@ class Sisyphus {
   }
   static function toTypePath(baseType : BaseType, params : Array<Type>) : TypePath return {
     var module = baseType.module;
+    var name = module.substring(module.lastIndexOf(".") + 1);
+    var sub = switch baseType.name {
+      case _ == name => true: null;
+      case v: v;
+    }
+    
     {
       pack: baseType.pack,
-      name: module.substring(module.lastIndexOf(".") + 1),
-      sub: baseType.name,
-      params: [ for (t in params) TPType(toComplexType(t)) ],
+      name: name,
+      sub: sub,
+      params: [for (t in params) switch t {
+        case TInst(_.get().kind => KExpr(e), _): TPExpr(e);
+        default: TPType(toComplexType(t));
+      }],
     }
   }
 }

src/tink/macro/Types.hx

@@ -146,8 +146,16 @@ class Types {
   static public inline function asComplexType(s:String, ?params)
     return TPath(asTypePath(s, params));
 
-  static public inline function reduce(type:Type, ?once)
-    return Context.follow(type, once);
+  static public function reduce(type:Type, ?once) {
+    function rec(t:Type)
+      return if (once) t else reduce(t, false);
+    return switch type {
+      case TAbstract(_.get() => { name: 'Null', pack: [] }, [t]): rec(t);
+      case TLazy(f): rec(f());
+      case TType(_, _): rec(Context.follow(type, once));
+      default: type;
+    }
+  }
 
   static public function isVar(field:ClassField)
     return switch (field.kind) {

tests/Exprs.hx

@@ -1,5 +1,6 @@
 package ;
 
+import haxe.macro.Context;
 import haxe.macro.Expr;
 using tink.MacroApi;
 
@@ -7,6 +8,14 @@ class Exprs extends Base {
   function exprEq(e1:Expr, e2:Expr) {
     assertEquals(e1.toString(), e2.toString());
   }
+
+  function testShort() {
+    for (i in 0...100) {
+      var id = (100 * i).shortIdent();
+      Context.parseInlineString(id, (macro null).pos);
+      assertTrue(id.length <= 3);
+    }
+  }
   function testGet() {
     assertEquals('foo', (macro foo).getIdent().sure());
     assertEquals('foo', (macro "foo").getString().sure());

tests/Types.hx

@@ -44,4 +44,13 @@ class Types extends Base {
     
     MacroApi.pos().makeBlankType().toString();
   }
+
+  function testExpr() {
+    assertEquals('VarChar<255>', (macro : VarChar<255>).toType().sure().toComplex().toString());
+  }
+
+  function testToComplex() {
+    assertEquals('String', Context.getType('String').toComplex().toString());
+    assertEquals('tink.CoreApi.Noise', Context.getType('tink.CoreApi.Noise').toComplex().toString());
+  }
 }

tests/VarChar.hx

@@ -0,0 +1 @@
+typedef VarChar<Const> = String;