Partial workaround for https://github.com/benmerckx/genes/issues/6

2020-01-02 19:44:41 +01:00
20 changed files with 333 additions and 613 deletions
--- a/.haxerc
+++ b/.haxerc
@@ -1,4 +1,4 @@
 {
-  "version": "4.0.5",
+  "version": "e552bdc",
  "resolveLibs": "scoped"
 }
--- a/.travis.yml
+++ b/.travis.yml
@@ -15,14 +15,14 @@ os:
 env:
  - HAXE_VERSION=3.4.7
  - HAXE_VERSION=edge
-
+  
 install:
  - npm i -g lix@15.5.4
  - lix install haxe $HAXE_VERSION
  - lix download

 script:
-  - lix run travix node
+  - lix run travix node -lib hx3compat

 jobs:
  include:
--- a/haxe_libraries/hx3compat.hxml
+++ b/haxe_libraries/hx3compat.hxml
@@ -1,3 +1,3 @@
-# @install: lix --silent download "haxelib:/hx3compat#1.0.3" into hx3compat/1.0.3/haxelib
-cp ${HAXE_LIBCACHE}/hx3compat/1.0.3/haxelib/std
-D hx3compat=1.0.3
+-D hx3compat=1.0.0
+# @install: lix --silent download "haxelib:/hx3compat#1.0.0" into hx3compat/1.0.0/haxelib
+-cp ${HAXE_LIBCACHE}/hx3compat/1.0.0/haxelib/std
--- a/haxe_libraries/hxnodejs.hxml
+++ b/haxe_libraries/hxnodejs.hxml
@@ -1,6 +1,6 @@
-# @install: lix --silent download "haxelib:/hxnodejs#12.0.0" into hxnodejs/12.0.0/haxelib
-cp ${HAXE_LIBCACHE}/hxnodejs/12.0.0/haxelib/src
-D hxnodejs=12.0.0
+# @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')
-# should behave like other target defines and not be defined in macro context
--macro define('nodejs')
+--macro _hxnodejs.VersionWarning.include()
--- a/haxelib.json
+++ b/haxelib.json
@@ -1,20 +1,20 @@
 {
 	"name": "tink_macro",
-	"description": "The macro toolkit ;)",
-	"classPath": "src",
-	"dependencies": {
-		"tink_core": ""
-	},
-	"url": "https://github.com/haxetink/tink_macro",
-	"contributors": [
-		"back2dos"
-	],
-	"version": "0.22.0",
-	"releasenote": "Support Haxe 4.2",
+	"license": "MIT",
 	"tags": [
 		"tink",
 		"macro",
 		"utility"
 	],
-	"license": "MIT"
+	"classPath": "src",
+	"description": "The macro toolkit ;)",
+	"contributors": [
+		"back2dos"
+	],
+	"releasenote": "Compat with haxe 4 rc4 onward.",
+	"version": "0.18.0",
+	"url": "http://haxetink.org/tink_macro",
+	"dependencies": {
+		"tink_core": ""
+	}
 }
--- a/src/tink/MacroApi.hx
+++ b/src/tink/MacroApi.hx
@@ -8,8 +8,6 @@ using StringTools;

 typedef Positions = tink.macro.Positions;
 typedef ExprTools = haxe.macro.ExprTools;
-typedef TypedExprTools = haxe.macro.TypedExprTools;
-typedef TypedExprs = tink.macro.TypedExprs;
 typedef Exprs = tink.macro.Exprs;
 typedef Functions = tink.macro.Functions;
 typedef Metadatas = tink.macro.Metadatas;
@@ -30,11 +28,11 @@ typedef ClassBuilder = tink.macro.ClassBuilder;
 typedef TypeResolution = Ref<Either<String, TypeDefinition>>;

 class MacroApi {
-
+  
  static var MAIN_CANDIDATES = ['-main', '-x', '--run'];
  static public function getMainClass():Option<String> {
    var args = Sys.args();
-
+    
    for (c in MAIN_CANDIDATES)
      switch args.indexOf(c) {
        case -1:
@@ -44,26 +42,19 @@ class MacroApi {
    return None;
  }

-  @:persistent static var idCounter = 0;
-
+  @:persistent static var idCounter = 0;  
+  
  @:noUsing static public inline function tempName(?prefix:String = 'tmp'):String
    return '__tink_' + prefix + Std.string(idCounter++);
-
-  static public function pos()
+    
+  static public function pos() 
    return haxe.macro.Context.currentPos();

  static public var completionPoint(default, null):Option<{
    var file(default, never):String;
-    var content(default, never):Null<String>;
    var pos(default, never):Int;
  }>;

-  static public function getBuildFields():Option<Array<haxe.macro.Expr.Field>>
-    return switch completionPoint {
-      case Some(v) if (v.content != null && (v.content.charAt(v.pos - 1) == '@' || (v.content.charAt(v.pos - 1) == ':' && v.content.charAt(v.pos - 2) == '@'))): None;
-      default: Some(haxe.macro.Context.getBuildFields());
-    }
-
  static public var args(default, null):Iterable<String>;
  static var initialized = initArgs();

@@ -72,7 +63,7 @@ class MacroApi {
    args = sysArgs;
    completionPoint = switch sysArgs.indexOf('--display') {
      case -1: None;
-      case sysArgs[_ + 1] => arg:
+      case sysArgs[_ + 1] => arg: 
        if (arg.startsWith('{"jsonrpc":')) {
          var payload:{
            jsonrpc:String,
@@ -80,15 +71,12 @@ class MacroApi {
            params:{
              file:String,
              offset:Int,
-              contents:String,
            }
          } = haxe.Json.parse(arg);
-
          switch payload {
            case { jsonrpc: '2.0', method: 'display/completion' }:
              Some({
                file: payload.params.file,
-                content: payload.params.contents,
                pos: payload.params.offset,
              });
            default: None;
@@ -120,26 +108,26 @@ class MacroApi {
  @:forward
  abstract ObjectField(F) to F {

-    static var QUOTED = "@$__hx__";
+    static var QUOTED = "@$__hx__"; 

    inline function new(o) this = o;

    public var field(get, never):String;
-
+    
    function get_field()
-      return
-        if (quotes == Quoted)
+      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:
+        case null | Unquoted: 
          new ObjectField({ field: o.field, expr: o.expr });
        default:
          new ObjectField({ field: QUOTED + o.field, expr: o.expr });
--- a/src/tink/macro/BuildCache.hx
+++ b/src/tink/macro/BuildCache.hx
@@ -31,23 +31,23 @@ typedef BuildContext3 = {>BuildContext2,
  type3:Type,
 }

-class BuildCache {
-
+class BuildCache { 
+  
  @:persistent static var cache = new Map();
-
-  static public function getType3(name, ?types, ?pos:Position, build:BuildContext3->TypeDefinition, ?normalizer:Type->Type) {
+  
+  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,
@@ -55,62 +55,62 @@ class BuildCache {
      pos: ctx.pos,
      name: ctx.name,
      usings: ctx.usings
-    }), normalizer);
+    }));   
  }
-
-  static public function getTypeN(name, ?types, ?pos:Position, build:BuildContextN->TypeDefinition, ?normalizer:Type->Type) {
-
+  
+  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(switch types[i] {
-        case TInst(_.get().kind => KExpr(e), _):
+        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({
      types: types,
      pos: ctx.pos,
      name: ctx.name,
      usings: ctx.usings
-    }), normalizer);
-  }
-
-  static public function getType2(name, ?types, ?pos:Position, build:BuildContext2->TypeDefinition, ?normalizer:Type->Type) {
+    }));
+  }  
+  
+  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
-    }), normalizer);
+    }));
  }

-  static public function getParams(name:String, ?pos:Position)
+  static public function getParams(name:String, ?pos:Position)     
    return
      switch Context.getLocalType() {
        case TInst(_.toString() == name => true, v):
@@ -119,9 +119,9 @@ class BuildCache {
          pos.makeFailure('Expected $name');
        case v:
          pos.makeFailure('$v should be a class');
-      }
+      }  

-  static public function getParam(name:String, ?pos:Position)
+  static public function getParam(name:String, ?pos:Position)     
    return
      getParams(name, pos)
        .flatMap(function (args:Array<Type>) return switch args {
@@ -130,18 +130,18 @@ class BuildCache {
          default: pos.makeFailure('too many parameters');
        });

-  static public function getType(name, ?type, ?pos:Position, build:BuildContext->TypeDefinition, ?normalizer:Type->Type) {
-
+  static public function getType(name, ?type, ?pos:Position, build:BuildContext->TypeDefinition) {
+    
    if (type == null)
      type = getParam(name, pos).sure();
-
-    var forName =
+      
+    var forName = 
      switch cache[name] {
-        case null: cache[name] = new Group(name, normalizer);
+        case null: cache[name] = new Group(name);
        case v: v;
      }
-
-    var ret = forName.get(type, pos.sanitize(), build);
+    
+    var ret = forName.get(type, pos.sanitize(), build);  
    ret.getFields();// workaround for https://github.com/HaxeFoundation/haxe/issues/7905
    return ret;
  }
@@ -152,24 +152,23 @@ private typedef Entry = {
 }

 private class Group {
-
+  
  var name:String;
  var counter = 0;
-  var entries:TypeMap<Entry>;
-
-  public function new(name, ?normalizer) {
+  var entries = new TypeMap<Entry>();
+  
+  public function new(name) {
    this.name = name;
-    this.entries = new TypeMap(normalizer);
  }
-
+  
  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,
+        pos: pos, 
+        type: type, 
+        usings: usings, 
        name: path.split('.').pop()
      });

@@ -178,15 +177,15 @@ private class Group {
      return Context.getType(path);
    }

-    function doMake()
-      while (true)
+    function doMake() 
+      while (true) 
        switch '$name${counter++}' {
          case _.definedType() => Some(_):
          case v:
            return make(v);
-        }
+        } 

-    return
+    return 
      switch entries.get(type) {
        case null:
          doMake();
--- a/src/tink/macro/ClassBuilder.hx
+++ b/src/tink/macro/ClassBuilder.hx
@@ -23,10 +23,7 @@ class ClassBuilder {
      target = Context.getLocalClass().get();

    if (fields == null)
-      fields = switch MacroApi.getBuildFields() {
-        case None: target.pos.error('Impossible to get builds fields now. Possible cause: https://github.com/HaxeFoundation/haxe/issues/9853');
-        case Some(v): v;
-      }
+      fields = Context.getBuildFields();

    this.initializeFrom = fields;
    this.target = target;
@@ -195,14 +192,10 @@ class ClassBuilder {
    return m;
  }

-  static public function run(plugins:Array<ClassBuilder->Void>, ?verbose)
-    return switch MacroApi.getBuildFields() {
-      case None: null;
-      case Some(fields):
-        var builder = new ClassBuilder(fields);
-        for (p in plugins)
-          p(builder);
-        return builder.export(verbose);
-
-    }
+  static public function run(plugins:Array<ClassBuilder->Void>, ?verbose) {
+    var builder = new ClassBuilder();
+    for (p in plugins)
+      p(builder);
+    return builder.export(verbose);
+  }
 }
--- a/src/tink/macro/Constructor.hx
+++ b/src/tink/macro/Constructor.hx
@@ -21,7 +21,7 @@ class Constructor {
  var afterArgs:Array<FunctionArg>;
  var pos:Position;
  var onGenerateHooks:Array<Function->Void>;
-  var superCall:Expr;
+  var superCall:Array<Expr>;
  var owner:ClassBuilder;
  var meta:Metadata;
  public var isPublic:Null<Bool>;
@@ -57,12 +57,17 @@ class Constructor {
            default: oldStatements = [f.expr];
          }
      }
-    superCall =
-      if (oldStatements.length == 0) [].toBlock();
-      else switch oldStatements[0] {
-        case macro super($a{_}): oldStatements.shift();
-        default: [].toBlock();
+
+    for (i in 0...oldStatements.length)
+      switch oldStatements[i] {
+        case macro super($a{_}):
+          superCall = oldStatements.splice(0, i + 1);
+          break;
+        default:
      }
+
+    if (superCall == null)
+      superCall = [];
  }

  public function getArgList():Array<FunctionArg>
@@ -95,33 +100,10 @@ class Constructor {
        case Value(e): e;
      }

-    var member = owner.memberByName(name).sure(),
-        initStatement = macro @:pos(pos) this.$name = $e;
+    var tmp = MacroApi.tempName();
+    var member = owner.memberByName(name).sure();

-    var bypass = switch options.bypass {
-      case null:
-        switch member.kind {
-          case FProp(_, 'default' | 'null', _):
-            false;
-          #if haxe4
-          case FProp('default', 'never', _):
-            member.isFinal = true;
-            false;
-          case FProp(_, 'set', _):
-            member.addMeta(':isVar');
-            initStatement = macro @:pos(pos) @:bypassAccessor this.$name = $e;
-            false;
-          #end
-          case FProp(_):
-            true;
-          case FFun(_):
-            pos.error('cannot rebind function');
-          default: false;
-        }
-      case v: v;
-    }
-
-    if (bypass && member.kind.match(FProp(_, 'never' | 'set', _, _))) {
+    if (options.bypass && member.kind.match(FProp(_, 'never' | 'set', _, _))) {

      member.addMeta(':isVar');

@@ -153,14 +135,8 @@ class Constructor {
                macro @:pos(pos) this.$name = $e;
              case FVar(AccNo | AccNormal, AccNever):
                setDirectly(Context.typeExpr(macro @:pos(pos) this.$name));
-              #if haxe4
-              case FVar(AccCall, _):
-                var target = Context.storeTypedExpr(Context.typeExpr(macro @:pos(pos) @:bypassAccessor this.$name));
-                macro @:pos(pos) $target = $e;
-              #else
              case FVar(AccCall, AccNever):
                setDirectly(fields['get_$name'].expr());
-              #end
              case FVar(_, AccCall):
                setDirectly(fields['set_$name'].expr());
              default:
@@ -170,17 +146,14 @@ class Constructor {
      }).bounce(), options.prepend);
    }
    else
-      addStatement(
-        initStatement,
-        options.prepend
-      );
+      addStatement(macro @:pos(pos) this.$name = $e, options.prepend);
  }
  public inline function publish()
    if (isPublic == null)
      isPublic = true;

  function toBlock()
-    return [superCall]
+    return superCall
      .concat(nuStatements)
      .concat(oldStatements)
      .toBlock(pos);
--- a/src/tink/macro/Exprs.hx
+++ b/src/tink/macro/Exprs.hx
@@ -1,11 +1,12 @@
 package tink.macro;

+import Type in Inspect;
+
 import haxe.macro.Context;
 import haxe.macro.Expr;
 import haxe.macro.Type;
 import haxe.PosInfos;
 import haxe.macro.Printer;
-import haxe.DynamicAccess as Dict;

 using Lambda;
 using StringTools;
@@ -19,7 +20,6 @@ typedef VarDecl = { name : String, type : ComplexType, expr : Null<Expr> };
 typedef ParamSubst = {
  var exists(default, null):String->Bool;
  var get(default, null):String->ComplexType;
-  function iterator():Iterator<ComplexType>;
 }

 private class Heureka { public function new() {} }
@@ -34,7 +34,7 @@ class Exprs {
        case _ if (condition(e)): throw new Heureka();
        default: haxe.macro.ExprTools.iter(e, seek);
      }
-
+    
    return try {
      haxe.macro.ExprTools.iter(e, seek);
      false;
@@ -48,23 +48,22 @@ class Exprs {
  static public inline function as(e:Expr, c:ComplexType)
    return ECheckType(e, c).at(e.pos);

-  static public function finalize(e:Expr, ?nuPos:Position, ?rules:Dict<String>, ?skipFields = false, ?callPos:PosInfos) {
+  static public function finalize(e:Expr, ?nuPos:Position, ?rules:Dynamic<String>, ?skipFields = false, ?callPos:PosInfos) {
    if (nuPos == null)
      nuPos = Context.currentPos();
    if (rules == null)
      rules = { };
-
-    function replace(s:String):String
-      return switch rules[s] {
-        case null:
-          if (s.startsWith('tmp')) {
-            rules[s] = MacroApi.tempName(s.substr(3));
-            replace(s);
-          }
-          else s;
-        case v: v;
+    function replace(s:String) 
+      return {
+        if (Reflect.hasField(rules, s)) 
+          Reflect.field(rules, s)
+        else if (s.startsWith('tmp')) {
+          Reflect.setField(rules, s, MacroApi.tempName(s.substr(3)));
+          replace(s);
+        }
+        else s;
      }
-
+      
    return e.transform(function (e:Expr) {
      return
        if (Context.getPosInfos(e.pos).file != callPos.fileName) e;
@@ -72,7 +71,7 @@ class Exprs {
          e.pos = nuPos;
          switch (e.expr) {
            case EVars(vars):
-              for (v in vars)
+              for (v in vars) 
                v.name = replace(v.name);
              e;
            case EField(owner, field):
@@ -87,7 +86,7 @@ class Exprs {
                for (f in fields)
                  f.field = replace(f.field);
              e;
-            default:
+            default:  
              switch (e.getIdent()) {
                case Success(s): replace(s).resolve(e.pos);
                default: e;
@@ -96,10 +95,10 @@ class Exprs {
        }
    });
  }
-
+  
  static public function withPrivateAccess(e:Expr)
-    return
-      e.transform(function (e:Expr)
+    return 
+      e.transform(function (e:Expr) 
        return
          switch (e.expr) {
            case EField(owner, field):
@@ -107,95 +106,72 @@ class Exprs {
            default: e;
          }
      );
-
+      
  static public function getPrivate(e:Expr, field:String, ?pos:Position)
    return macro @:pos(pos.sanitize()) @:privateAccess $e.$field;

-  static public function substitute(source:Expr, vars:Dict<Expr>, ?pos)
-    return
+  static public function substitute(source:Expr, vars:Dynamic<Expr>, ?pos) 
+    return 
      transform(source, function (e:Expr) {
-        return switch e {
-          case macro $i{name}:
-            switch vars[name] {
-              case null: e;
-              case v: v;
-            }
-          default: e;
-        }
+        return
+          switch (e.getIdent()) {
+            case Success(name):
+              if (Reflect.hasField(vars, name)) 
+                Reflect.field(vars, name);
+              else
+                e;
+            default: e;
+          }
      }, pos);
-
-  static public inline function ifNull(e:Expr, fallback:Expr)
+  
+  static public inline function ifNull(e:Expr, fallback:Expr) 
    return
      switch e {
        case macro null: fallback;
        default: e;
      }
-
-  static public function substParams(source:Expr, subst:ParamSubst, ?pos:Position):Expr {
-    if (!subst.iterator().hasNext())
-      return source;
-
-    function replace(ct:ComplexType)
-      return switch ct {
-        case TPath({ pack: [], name: name }) if (subst.exists(name)):
-          subst.get(name);
-        default: ct;
-      }
-
-    return source
-      .transform(
-        function (e) return switch e {
-          case macro $i{name} if (subst.exists(name)):
+  
+  static public function substParams(source:Expr, subst:ParamSubst, ?pos):Expr 
+    return crawl(
+      source, 
+      function (e) 
+        return switch e.expr {
+          case ENew({ pack: [], name: name }, args) if (subst.exists(name)):
+            switch subst.get(name) {
+              case TPath(p):
+                ENew(p, args).at(e.pos);
+              default: e;//TODO: report an error?
+            }
+          case EConst(CIdent(name)) if (subst.exists(name)):
            switch subst.get(name) {
              case TPath({ pack: pack, name: name }):
                pack.concat([name]).drill(e.pos);
              default: e;//TODO: report an error?
            }
          default: e;
-        })
-      .mapTypes(replace);
-  }
-
-  static public function mapTypes(e:Expr, transformer:ComplexType->ComplexType, ?pos:Position) {
-    return e.transform(
-      function (e) return switch e {
-        case { expr: ENew(p, args) }:
-          switch TPath(p).map(transformer) {
-            case TPath(nu):
-              ENew(nu, args).at(e.pos);
-            case v:
-              pos.error(v.toString() + ' cannot be instantiated in ${e.pos}');
+        },
+      function (c:ComplexType) 
+        return
+          switch (c) {
+            case TPath({ pack: [], name: name }) if (subst.exists(name)):
+              subst.get(name);
+            default: c;
          }
-        case macro cast($v, $ct):
-          ct = ct.map(transformer);
-          (macro @:pos(e.pos) cast($v, $ct));
-        case { expr: ECheckType(v, ct) }: // cannot use reification, because that's `EParentheses(ECheckType)` and macros can (and apparently do) generate a non-wrapped one
-          ECheckType(v, ct.map(transformer)).at(e.pos);
-        case { expr: EVars(vars) }:
-          EVars([for (v in vars) {
-            name: v.name,
-            type: v.type.map(transformer),
-            expr: v.expr,
-          }]).at(e.pos);
-        case { expr: EFunction(kind, f) }:
-          EFunction(kind, Functions.mapSignature(f, transformer)).at(e.pos);
-        default: e;
-      }
-    );
-  }
-
-  static public function transform(source:Expr, transformer:Expr->Expr, ?pos):Expr {
-    function apply(e:Expr)
-      return switch e {
-        case null | { expr: null }: e;
-        default: transformer(haxe.macro.ExprTools.map(e, apply));
-      }
-
-    return apply(source);
-  }
-
-  static public function getIterType(target:Expr)
+      , pos);
+  
+  static public function transform(source:Expr, transformer:Expr->Expr, ?pos):Expr 
+    return crawl(source, transformer, function (t) return t, pos);
+  
+  static function crawlArray(a:Array<Dynamic>, transformer:Expr->Expr, retyper:ComplexType-> ComplexType, pos:Position):Array<Dynamic>
    return
+      if (a == null) a;
+      else 
+        [for (v in a)
+          crawl(v, transformer, retyper, pos)
+        ];
+      
+  static public function getIterType(target:Expr) 
+    return 
      (macro @:pos(target.pos) {
        var t = null,
          target = $target;
@@ -203,21 +179,21 @@ class Exprs {
          t = i;
        t;
      }).typeof();
-
+  
  static public function yield(e:Expr, yielder:Expr->Expr, ?options: { ?leaveLoops: Bool }):Expr {
-    inline function rec(e)
+    inline function rec(e) 
      return yield(e, yielder, options);
-
+      
    if (options == null)
      options = { };
-
+      
    var loops = options.leaveLoops != true;
    return
      if (e == null || e.expr == null) e;
      else switch (e.expr) {
        case EVars(_):
          e.pos.error('Variable declaration not supported here');
-        case EBlock(exprs) if (exprs.length > 0):
+        case EBlock(exprs) if (exprs.length > 0): 
          exprs = exprs.copy();
          exprs.push(rec(exprs.pop()));
          EBlock(exprs).at(e.pos);
@@ -225,11 +201,10 @@ class Exprs {
          ,ETernary(econd, eif, eelse):
          EIf(econd, rec(eif), rec(eelse)).at(e.pos);
        case ESwitch(e, cases, edef):
-          ESwitch(e, [for (c in cases) {
-            expr: rec(c.expr),
-            guard: c.guard,
-            values: c.values,
-          }], rec(edef)).at(e.pos);
+          cases = Reflect.copy(cases);//not exactly pretty, but does the job
+          for (c in cases)
+            c.expr = rec(c.expr);
+          ESwitch(e, cases, rec(edef)).at(e.pos);
        case EFor(it, expr) if (loops):
          EFor(it, rec(expr)).at(e.pos);
        case EWhile(cond, body, normal) if (loops):
@@ -243,77 +218,101 @@ class Exprs {
        default: yielder(e);
      }
  }
-
-  static public inline function iterate(target:Expr, body:Expr, ?loopVar:String = 'i', ?pos:Position)
+      
+  static function crawl(target:Dynamic, transformer:Expr->Expr, retyper:ComplexType->ComplexType, pos:Position):Dynamic
+    return
+      if (Std.is(target, Array)) 
+        crawlArray(target, transformer, retyper, pos);
+      else
+        switch (Inspect.typeof(target)) {
+          case TNull, TInt, TFloat, TBool, TFunction, TUnknown, TClass(_): target;
+          case TEnum(e): 
+            var ret:Dynamic = Inspect.createEnumIndex(e, Inspect.enumIndex(target), crawlArray(Inspect.enumParameters(target), transformer, retyper, pos));
+            if (Inspect.getEnum(ret) == ComplexType) 
+              retyper(ret);
+            else 
+              ret;              
+          case TObject:
+            var ret:Dynamic = { };
+            for (field in Reflect.fields(target))
+              Reflect.setField(ret, field, crawl(Reflect.field(target, field), transformer, retyper, pos));
+            if (Std.is(ret.expr, ExprDef)) {
+              ret = transformer(ret);
+              if (pos != null) ret.pos = pos;
+            }
+            ret;
+        }
+        
+  static public inline function iterate(target:Expr, body:Expr, ?loopVar:String = 'i', ?pos:Position) 
    return macro @:pos(pos.sanitize()) for ($i{loopVar} in $target) $body;
-
-  static public function toFields(object:Dict<Expr>, ?pos:Position)
-    return EObjectDecl([for (field in object.keys())
-      { field:field, expr: object[field] }
+  
+  static public function toFields(object:Dynamic<Expr>, ?pos:Position)
+    return EObjectDecl([for (field in Reflect.fields(object))
+      { field:field, expr: untyped Reflect.field(object, field) }
    ]).at(pos);

  static public inline function log(e:Expr, ?pos:PosInfos):Expr {
    haxe.Log.trace(e.toString(), pos);
    return e;
  }
-
-  static public inline function reject(e:Expr, ?reason:String = 'cannot handle expression'):Dynamic
+  
+  static public inline function reject(e:Expr, ?reason:String = 'cannot handle expression'):Dynamic 
    return e.pos.error(reason);
-
-  static public inline function toString(e:Expr):String
+  
+  static public inline function toString(e:Expr):String 
    return new haxe.macro.Printer().printExpr(e);
-
-  static public inline function at(e:ExprDef, ?pos:Position)
+    
+  static public inline function at(e:ExprDef, ?pos:Position) 
    return {
      expr: e,
      pos: pos.sanitize()
    };
-
-  static public inline function instantiate(s:String, ?args:Array<Expr>, ?params:Array<TypeParam>, ?pos:Position)
+  
+  static public inline function instantiate(s:String, ?args:Array<Expr>, ?params:Array<TypeParam>, ?pos:Position) 
    return s.asTypePath(params).instantiate(args, pos);
-
-  static public inline function assign(target:Expr, value:Expr, ?op:Binop, ?pos:Position)
+  
+  static public inline function assign(target:Expr, value:Expr, ?op:Binop, ?pos:Position) 
    return binOp(target, value, op == null ? OpAssign : OpAssignOp(op), pos);
-
-  static public inline function define(name:String, ?init:Expr, ?typ:ComplexType, ?pos:Position)
+  
+  static public inline function define(name:String, ?init:Expr, ?typ:ComplexType, ?pos:Position) 
    return at(EVars([ { name:name, type: typ, expr: init } ]), pos);
-
-  static public inline function add(e1:Expr, e2, ?pos)
+  
+  static public inline function add(e1:Expr, e2, ?pos) 
    return binOp(e1, e2, OpAdd, pos);
-
-  static public inline function unOp(e:Expr, op, ?postFix = false, ?pos)
+    
+  static public inline function unOp(e:Expr, op, ?postFix = false, ?pos) 
    return EUnop(op, postFix, e).at(pos);
-
-  static public inline function binOp(e1:Expr, e2, op, ?pos)
+  
+  static public inline function binOp(e1:Expr, e2, op, ?pos) 
    return EBinop(op, e1, e2).at(pos);
-
-  static public inline function field(e:Expr, field, ?pos)
+    
+  static public inline function field(e:Expr, field, ?pos) 
    return EField(e, field).at(pos);
-
-  static public inline function call(e:Expr, ?params, ?pos)
+    
+  static public inline function call(e:Expr, ?params, ?pos) 
    return ECall(e, params == null ? [] : params).at(pos);
-
-  static public inline function toExpr(v:Dynamic, ?pos:Position)
+    
+  static public inline function toExpr(v:Dynamic, ?pos:Position) 
    return Context.makeExpr(v, pos.sanitize());
-
-  static public inline function toArray(exprs:Iterable<Expr>, ?pos)
+    
+  static public inline function toArray(exprs:Iterable<Expr>, ?pos) 
    return EArrayDecl(exprs.array()).at(pos);
-
-  static public inline function toMBlock(exprs:Array<Expr>, ?pos)
+    
+  static public inline function toMBlock(exprs:Array<Expr>, ?pos) 
    return EBlock(exprs).at(pos);
-
-  static public inline function toBlock(exprs:Iterable<Expr>, ?pos)
-    return toMBlock(Lambda.array(exprs), pos);
-
+    
+  static public inline function toBlock(exprs:Iterable<Expr>, ?pos) 
+    return toMBlock(Lambda.array(exprs), pos);    
+    
  static public function drill(parts:Array<String>, ?pos:Position, ?target:Expr) {
-    if (target == null)
+    if (target == null) 
      target = at(EConst(CIdent(parts.shift())), pos);
    for (part in parts)
      target = field(target, part, pos);
-    return target;
+    return target;    
  }
-
-  static public inline function resolve(s:String, ?pos)
+  
+  static public inline function resolve(s:String, ?pos) 
    return drill(s.split('.'), pos);

  static var scopes = new Array<Array<Var>>();
@@ -321,7 +320,7 @@ class Exprs {
  static function inScope<T>(a:Array<Var>, f:Void->T) {
    scopes.push(a);

-    inline function leave()
+    inline function leave() 
      scopes.pop();
    try {
      var ret = f();
@@ -331,24 +330,24 @@ class Exprs {
    catch (e:Dynamic) {
      leave();
      return Error.rethrow(e);
-    }
+    }    
  }

-  static public function scoped<T>(f:Void->T)
+  static public function scoped<T>(f:Void->T) 
    return inScope([], f);

-  static public function inSubScope<T>(f:Void->T, a:Array<Var>)
+  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)
+        if (locals != null) 
          expr = [EVars(locals).at(expr.pos), expr].toMBlock(expr.pos);
        Success(Context.typeof(expr));
      }
@@ -357,20 +356,20 @@ class Exprs {
      }
      catch (e:Dynamic) {
        expr.pos.makeFailure(e);
-      }
-
-  static public inline function cond(cond:Expr, cons:Expr, ?alt:Expr, ?pos)
+      }        
+    
+  static public inline function cond(cond:Expr, cons:Expr, ?alt:Expr, ?pos) 
    return EIf(cond, cons, alt).at(pos);
-
-  static public function isWildcard(e:Expr)
-    return
+    
+  static public function isWildcard(e:Expr) 
+    return 
      switch e {
        case macro _: true;
        default: false;
      }
-
-  static public function getString(e:Expr)
-    return
+      
+  static public function getString(e:Expr) 
+    return 
      switch (e.expr) {
        case EConst(c):
          switch (c) {
@@ -378,10 +377,10 @@ class Exprs {
            default: e.pos.makeFailure(NOT_A_STRING);
          }
        default: e.pos.makeFailure(NOT_A_STRING);
-      }
-
-  static public function getInt(e:Expr)
-    return
+      }      
+    
+  static public function getInt(e:Expr) 
+    return 
      switch (e.expr) {
        case EConst(c):
          switch (c) {
@@ -389,22 +388,22 @@ class Exprs {
            default: e.pos.makeFailure(NOT_AN_INT);
          }
        default: e.pos.makeFailure(NOT_AN_INT);
-      }
-
-  static public function getIdent(e:Expr)
-    return
+      }              
+  
+  static public function getIdent(e:Expr) 
+    return 
      switch (e.expr) {
        case EConst(c):
          switch (c) {
            case CIdent(id): Success(id);
            default: e.pos.makeFailure(NOT_AN_IDENT);
          }
-        default:
+        default: 
          e.pos.makeFailure(NOT_AN_IDENT);
-      }
-
-  static public function getName(e:Expr)
-    return
+      }          
+  
+  static public function getName(e:Expr) 
+    return 
      switch (e.expr) {
        case EConst(c):
          switch (c) {
@@ -412,15 +411,15 @@ class Exprs {
            default: e.pos.makeFailure(NOT_A_NAME);
          }
        default: e.pos.makeFailure(NOT_A_NAME);
-      }
-
-  static public function getFunction(e:Expr)
+      }          
+  
+  static public function getFunction(e:Expr) 
    return
      switch (e.expr) {
        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
@@ -431,7 +430,7 @@ class Exprs {
        default: EBlock([e, with]).at(pos);
      }
  }
-
+  
  static var FIRST = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
  static var LATER = FIRST + '0123456789';

@@ -439,7 +438,7 @@ class Exprs {
    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);
@@ -447,7 +446,7 @@ class Exprs {

    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";
--- a/src/tink/macro/Functions.hx
+++ b/src/tink/macro/Functions.hx
@@ -14,9 +14,9 @@ private typedef Kind = String;
 #end

 class Functions {
-  static public inline function asExpr(f:Function, ?kind:Kind, ?pos)
+  static public inline function asExpr(f:Function, ?kind:Kind, ?pos) 
    return EFunction(kind, f).at(pos);
-
+  
  static public inline function toArg(name:String, ?t, ?opt = false, ?value = null):FunctionArg {
    return {
      name: name,
@@ -31,24 +31,8 @@ class Functions {
      ret: ret,
      params: params == null ? [] : params,
      expr: if (makeReturn) EReturn(e).at(e.pos) else e
-    }
+    }    
  }
-
-  static public function mapSignature(f:Function, transform):Function
-    return {
-      ret: Types.map(f.ret, transform),
-      args: [for (a in f.args) {
-        name: a.name,
-        value: a.value,
-        type: Types.map(a.type, transform),
-        #if haxe4
-        meta: a.meta,
-        #end
-      }],
-      expr: f.expr,
-      params: Types.mapTypeParamDecls(f.params, transform),
-    }
-
  static public function getArgIdents(f:Function):Array<Expr> {
    var ret = [];
    for (arg in f.args)
--- a/src/tink/macro/Sisyphus.hx
+++ b/src/tink/macro/Sisyphus.hx
@@ -23,8 +23,8 @@ class Sisyphus {
    if (cf.params.length == 0) {
      name: cf.name,
      doc: cf.doc,
-      access:
-        (cf.isPublic ? [ APublic ] : [ APrivate ])
+      access: 
+        (cf.isPublic ? [ APublic ] : [ APrivate ]) 
          #if haxe4 .concat(if (cf.isFinal) [AFinal] else []) #end
        ,
      kind: switch([ cf.kind, cf.type ]) {
@@ -84,7 +84,7 @@ class Sisyphus {
                cl.kind.match(KTypeParameter(_))
                && cl.module == classType.module
                && cl.pack.join('.') == classType.pack.join('.')
-              ): ct;
+              ): ct;                
              default:
                direct();
            }
@@ -95,12 +95,8 @@ class Sisyphus {
        TPath(toTypePath(baseType, params));
      case TFun(args, ret):
        TFunction(
-          [for (a in args) {
-            var t = #if haxe4 TNamed(a.name, #else ( #end toComplexType(a.t));
-            if (a.opt) TOptional(t) else t;
-          }],
-          toComplexType(ret)
-        );
+          [ 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):
@@ -125,7 +121,7 @@ class Sisyphus {
      case _ == name => true: null;
      case v: v;
    }
-
+    
    {
      pack: baseType.pack,
      name: name,
--- a/src/tink/macro/TypeMap.hx
+++ b/src/tink/macro/TypeMap.hx
@@ -8,33 +8,14 @@ import haxe.macro.Type;
 using tink.MacroApi;

 class TypeMap<V> extends BalancedTree<Type, V> implements IMap<Type, V> {
-  var normalize:Type->Type;
-
-  public function new(?normalize:Type->Type) {
-    this.normalize = switch normalize {
-      case null: function (t) return t.reduce();
-      case fn: fn;
-    }
+  var follow:Bool;
+  
+  public function new(?noFollow:Bool) {
+    this.follow = noFollow != true;
    super();
  }
-
+  
  override function compare(k1:Type, k2:Type):Int
-    return normalize(k1).compare(normalize(k2), false);
-
-  static public function noFollow(t:Type)
-    return t;
-
-  static public function keepNull(t:Type):Type
-    return switch t {
-      case TAbstract(_.get() => { name: 'Null', pack: [] }, [t])
-        #if !haxe4 | TType(_.get() => { name: 'Null', pack: []}, [t]) #end
-        :
-        var ct = keepNull(t).toComplex({ direct: true });
-        (macro : Null<$ct>).toType().sure();
-
-      case TLazy(f): keepNull(f());
-      case TType(_, _): keepNull(Context.follow(t, true));
-      default: t;
-    }
-
+    return k1.compare(k2, follow);
+  
 }
--- a/src/tink/macro/TypedExprs.hx
+++ b/src/tink/macro/TypedExprs.hx
@@ -1,55 +0,0 @@
-package tink.macro;
-
-import haxe.macro.Type;
-import haxe.ds.Option;
-using haxe.macro.Tools;
-
-class TypedExprs {
-
-  static public function extractAll<T>(t:TypedExpr, f:TypedExpr->Option<T>):Array<T> {
-    var out = [];
-    function rec(t:TypedExpr)
-      if (t != null) {
-        switch f(t) {
-          case Some(v): out.push(v);
-          default:
-        }
-        t.iter(rec);
-      }
-    rec(t);
-    return out;
-  }
-
-  static public function extract<T>(t:TypedExpr, f:TypedExpr->Option<T>):Option<T> {
-    try extractAll(t, function (t) {
-      var ret = f(t);
-      if (ret != None)
-        throw ret;
-      return ret;
-    })
-    catch (e:Option<Dynamic>) return cast e;
-    return None;
-  }
-
-  static public function isThis(t:TypedExpr):Bool
-    return switch t {
-      case null: false;
-      case { expr: TConst(TThis) | TLocal({ name: '`this' })}: true;
-      default: false;
-    }
-
-  static public inline function hasThis(t)
-    return contains(t, isThis);
-
-  static public function findAll(t:TypedExpr, f:TypedExpr->Bool):Array<TypedExpr>
-    return extractAll(t, collect(f));
-
-  static public function find(t:TypedExpr, f:TypedExpr->Bool):Option<TypedExpr>
-    return extract(t, collect(f));
-
-  static public function contains(t:TypedExpr, f:TypedExpr->Bool):Bool
-    return find(t, f) != None;
-
-  static inline function collect(f)
-    return function (t) return if (f(t)) Some(t) else None;
-}
--- a/src/tink/macro/Types.hx
+++ b/src/tink/macro/Types.hx
@@ -70,79 +70,6 @@ class Types {
      getDeclaredFields(t.superClass.t.get(), out, marker);
  }

-  static public function mapTypeParams(a:Array<TypeParam>, f)
-    return
-      if (a == null) null;
-      else [for (p in a) switch p {
-        case TPType(t): TPType(t.map(f));
-        default: p;
-      }];
-
-  static public function mapTypeParamDecls(a:Array<TypeParamDecl>, f:ComplexType->ComplexType):Array<TypeParamDecl>
-    return
-      if (a == null) null;
-      else [for (p in a) {
-        name: p.name,
-        meta: p.meta,
-        params: mapTypeParamDecls(p.params, f),
-        constraints: switch p.constraints {
-          case null: null;
-          case a: [for (t in a) map(t, f)];
-        }
-      }];
-
-  static public function mapTypePath(p:TypePath, transform):TypePath
-    return {
-      name: p.name,
-      pack: p.pack,
-      sub: p.sub,
-      params: mapTypeParams(p.params, transform),
-    }
-
-  static public function map(ct:ComplexType, transform:ComplexType->ComplexType) {
-    if (ct == null)
-      return null;
-    inline function rec(ct)
-      return map(transform(ct), transform);
-
-    function mapFields(fields:Array<Field>):Array<Field>
-      return [for (f in fields) {
-        name: f.name,
-        pos: f.pos,
-        kind: switch f.kind {
-          case FVar(t, e): FVar(rec(t), e);
-          case FProp(get, set, t, e): FProp(get, set, rec(t), e);
-          case FFun(f): FFun(Functions.mapSignature(f, transform));
-        },
-        access: f.access,
-        meta: switch f.meta {
-          case null: null;
-          case a: [for (m in a) {
-            name: m.name,
-            pos: m.pos,
-            params: [for (e in m.params) e.mapTypes(transform)],
-          }];
-        },
-        doc: f.doc,
-      }];
-    return transform(switch ct {
-      case TParent(t): TParent(rec(t));
-      #if haxe4
-      case TNamed(n, t): TNamed(n, rec(t));
-      case TIntersection(tl): TIntersection([for (t in tl) rec(t)]);
-      #end
-      case TOptional(t): TOptional(rec(t));
-      case TAnonymous(fields):
-        TAnonymous(mapFields(fields));
-      case TPath(p):
-        TPath(mapTypePath(p, transform));
-      case TExtend(paths, fields):
-        TExtend([for (p in paths) mapTypePath(p, transform)], mapFields(fields));
-      case TFunction(args, ret):
-        TFunction([for (a in args) rec(a)], rec(ret));
-    });
-  }
-
  static var fieldsCache = new Map();
  static public function getFields(t:Type, ?substituteParams = true)
    return
@@ -157,31 +84,12 @@ class Types {
          }
          var ret = fieldsCache.get(id);
          if (substituteParams && ret.isSuccess()) {
-            ret = Success([
-              for (field in ret.sure()) ({
-                name: field.name,
-                type: haxe.macro.TypeTools.applyTypeParameters(field.type, c.params, params),
-                pos: field.pos,
-                meta: field.meta,
-                doc: field.doc,
-                expr: function () return field.expr(),
-                isPublic: field.isPublic,
-                params: field.params,
-                kind: field.kind,
-                overloads: field.overloads,
-                #if haxe4
-                isExtern: field.isExtern,
-                isFinal: field.isFinal,
-                #if (haxe >= version("4.2.0-rc.1"))
-                isAbstract: field.isAbstract,
-                #end
-                #end
-              }:ClassField)
-            ]);
+            var fields = Reflect.copy(ret.sure());
+
+            for (field in fields)
+              field.type = haxe.macro.TypeTools.applyTypeParameters(field.type, c.params, params);
          }
-          #if !haxe4
          fieldsCache.remove(id);//TODO: find a proper solution to avoid stale cache
-          #end
          ret;
        case TAnonymous(anon): Success(anon.get().fields);
        default: Context.currentPos().makeFailure('type $t has no fields');
@@ -193,8 +101,8 @@ class Types {
        case TInst(t, _): Success(t.get().statics.get());
        default: Failure('type has no statics');
      }
-
-
+      
+      
  static public function getPosition(t:Type)
    return
      switch t {
@@ -207,19 +115,8 @@ class Types {
        case TDynamic(v) if(v != null): getPosition(v);
        default: Failure('type "$t" has no position');
      }
-  
-  static public function deduceCommonType(types:Array<Type>):Outcome<Type, Error> {
-    var exprs = types.map(function(t) {
-      var ct = t.toComplex();
-      return macro (null:$ct);
-    });
-    
-    return switch (macro $a{exprs}).typeof() {
-      case Success(TInst(_, [v])): Success(v);
-      case Success(_): throw 'unreachable';
-      case Failure(e): Failure(new Error('Unable to deduce common type among $types'));
-    }
-  }
+      
+      

  static public function toString(t:ComplexType)
    return new Printer().printComplexType(t);
@@ -272,7 +169,8 @@ class Types {
      return if (once) t else reduce(t, false);
    return switch type {
      case TAbstract(_.get() => { name: 'Null', pack: [] }, [t]): rec(t);
-      case TLazy(_) | TType(_): rec(Context.follow(type, once));
+      case TLazy(f): rec(f());
+      case TType(_, _): rec(Context.follow(type, once));
      default: type;
    }
  }
@@ -304,7 +202,7 @@ class Types {
  }

  static public function intersect(types:Array<ComplexType>, ?pos:Position):Outcome<ComplexType, Error> {
-
+    
    if (types.length == 1) return Success(types[1]);

    var paths = [],
@@ -313,17 +211,17 @@ class Types {
    for (t in types)
      switch t {
        case TPath(p): paths.push(p);
-        case TAnonymous(f):
-
+        case TAnonymous(f): 
+          
          for (f in f) fields.push(f);

-        case TExtend(p, f):
-
+        case TExtend(p, f): 
+          
          for (f in f) fields.push(f);
          for (p in p) paths.push(p);

        default:
-
+          
          return Failure(new Error(t.toString() + ' cannot be interesected', pos));
      }

@@ -353,23 +251,23 @@ class Types {
      t1 = t1.reduce();
      t2 = t2.reduce();
    }
-
+    
    return switch t1.getIndex() - t2.getIndex() {
-      case 0:
+      case 0: 
        Reflect.compare(t1.toString(), t2.toString());//much to my surprise, this actually seems to work (at least with 3.4)
      case v: v;
-    }
+    }    
  }

  static var SUGGESTIONS = ~/ \(Suggestions?: .*\)$/;

-  static public function getFieldSuggestions(type:ComplexType, name:String):String
+  static public function getFieldSuggestions(type:ComplexType, name:String):String 
    return switch (macro (null : $type).$name).typeof() {
      case Failure(SUGGESTIONS.match(_.message) => true): SUGGESTIONS.matched(0);
      default: '';
    }

-  static public function toDecl(p:TypeParameter):TypeParamDecl
+  static public function toDecl(p:TypeParameter):TypeParamDecl 
    return {
      name: p.name,
      constraints: switch p.t {
@@ -381,4 +279,4 @@ class Types {
  static public function toTypeParam(p:TypeParameter):TypeParam
    return TPType(p.t.toComplex());

-}
+}
--- a/tests.hxml
+++ b/tests.hxml
@@ -1,3 +1,2 @@
 -cp tests
-lib hx3compat
 -main Run
--- a/tests/MyString.hx
+++ b/tests/MyString.hx
@@ -1 +0,0 @@
-typedef MyString = String;
--- a/tests/Run.hx
+++ b/tests/Run.hx
@@ -3,8 +3,8 @@ package ;
 import haxe.unit.*;

 class Run {
-  #if !macro
-  static function main()
+  #if !macro 
+  static function main() 
    test();//It compiles ...
  #else
  static var cases:Array<TestCase> = [
@@ -19,13 +19,12 @@ class Run {
  macro static function test() {
    var runner = new TestRunner();
    tink.macro.ClassBuilder;
-    tink.macro.BuildCache;
    for (c in cases)
      runner.add(c);
    runner.run();
    if (!runner.result.success)
      haxe.macro.Context.error(runner.result.toString(), haxe.macro.Context.currentPos());
-
+    
    return macro {
      trace('Let\'s ship it!');
    }
--- a/tests/TypeMapTest.hx
+++ b/tests/TypeMapTest.hx
@@ -1,17 +1,17 @@
 package;

 import haxe.unit.TestCase;
-import haxe.macro.Expr;

-using tink.MacroApi;
+import tink.macro.TypeMap;
+using haxe.macro.Context;

 class TypeMapTest extends TestCase {

  function testMap() {
    var t = new TypeMap();
-    var t1 = (macro [{ foo: [{ bar: '5' }]}]).typeof().sure();
-    var t2 = (macro [{ foo: [{ bar: 5 }]}]).typeof().sure();
-
+    var t1 = (macro [{ foo: [{ bar: '5' }]}]).typeof();
+    var t2 = (macro [{ foo: [{ bar: 5 }]}]).typeof();
+    
    t.set(t1, 0);
    assertEquals(Lambda.count(t), 1);
    t.set(t2, 1);
@@ -20,29 +20,11 @@ class TypeMapTest extends TestCase {
    assertEquals(Lambda.count(t), 2);
    t.set(t2, 3);
    assertEquals(Lambda.count(t), 2);
-
+    
    assertEquals(t.get(t1), 2);
    assertEquals(t.get(t2), 3);
-
+    
    assertTrue(true);
  }
-
-  function testNormalization() {
-    for (settings in [
-      { count: 4, map: new TypeMap(TypeMap.noFollow)},
-      { count: 2, map: new TypeMap(TypeMap.keepNull)},
-      { count: 1, map: new TypeMap()},
-    ]) {
-
-      function set(ct:ComplexType)
-        settings.map.set(ct.toType().sure(), ct);
-
-      set(macro : String);
-      set(macro : MyString);
-      set(macro : Null<String>);
-      set(macro : Null<MyString>);
-
-      assertEquals(settings.count, Lambda.count(settings.map));
-    }
-  }
+  
 }
--- a/tests/Types.hx
+++ b/tests/Types.hx
@@ -65,20 +65,5 @@ class Types extends Base {
    assertEquals('String', Context.getType('String').toComplex().toString());
    assertEquals('tink.CoreApi.Noise', Context.getType('tink.CoreApi.Noise').toComplex().toString());
  }
-  
-  function testDeduceCommonType() {
-    function ct2t(ct:ComplexType) return ct.toType().sure();
-    assertEquals('StdTypes.Float', tink.macro.Types.deduceCommonType([(macro:Float), (macro:Int)].map(ct2t)).sure().toComplex().toString());
-    assertEquals('Types.CommonI1', tink.macro.Types.deduceCommonType([(macro:Types.CommonA), (macro:Types.CommonB), (macro:Types.CommonC)].map(ct2t)).sure().toComplex().toString());
-    assertEquals('Types.CommonI2', tink.macro.Types.deduceCommonType([(macro:Types.CommonB), (macro:Types.CommonC)].map(ct2t)).sure().toComplex().toString());
-    // assertEquals('Types.CommonI3', tink.macro.Types.deduceCommonType([(macro:Types.CommonC)].map(ct2t)).sure().toComplex().toString());
-  }
 }
-#end
-
-interface CommonI1 {}
-interface CommonI2 {}
-interface CommonI3 {}
-class CommonA implements CommonI1 {}
-class CommonB implements CommonI2 implements CommonI1 {}
-class CommonC implements CommonI3 implements CommonI2 implements CommonI1 {}
+#end