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

.haxerc

@@ -1,4 +1,4 @@
 {
-  "version": "4.0.0-rc.3",
+  "version": "e552bdc",
   "resolveLibs": "scoped"
 }

.travis.yml

@@ -17,7 +17,7 @@ env:
   - HAXE_VERSION=edge
   
 install:
-  - npm i -g lix@15.3.13
+  - npm i -g lix@15.5.4
   - lix install haxe $HAXE_VERSION
   - lix download
 

haxe_libraries/tink_core.hxml

@@ -1,3 +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
+-D tink_core=1.24.0
+# @install: lix --silent download "haxelib:/tink_core#1.24.0" into tink_core/1.24.0/haxelib
+-cp ${HAXE_LIBCACHE}/tink_core/1.24.0/haxelib/src

haxelib.json

@@ -1,20 +1,20 @@
 {
 	"name": "tink_macro",
-	"description": "The macro toolkit ;)",
-	"classPath": "src",
-	"dependencies": {
-		"tink_core": ""
-	},
-	"url": "http://haxetink.org/tink_macro",
-	"contributors": [
-		"back2dos"
-	],
-	"version": "0.17.7",
-	"releasenote": "Use @:persistent as necessary.",
+	"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": ""
+	}
 }

src/tink/macro/Constructor.hx

@@ -21,24 +21,24 @@ 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>;
-  
+
   public function new(owner:ClassBuilder, f:Function, ?isPublic:Null<Bool> = null, ?pos:Position, ?meta:Metadata) {
     this.nuStatements = [];
     this.owner = owner;
     this.isPublic = isPublic;
     this.pos = pos.sanitize();
-    
+
     this.onGenerateHooks = [];
     this.args = [];
     this.beforeArgs = [];
     this.afterArgs = [];
     this.meta = meta;
-    
-    this.oldStatements = 
+
+    this.oldStatements =
       if (f == null) [];
       else {
         for (i in 0...f.args.length) {
@@ -49,62 +49,67 @@ class Constructor {
           }
           beforeArgs.push(a);
         }
-          
+
         if (f.expr == null) [];
         else
           switch (f.expr.expr) {
             case EBlock(exprs): exprs;
-            default: oldStatements = [f.expr]; 
+            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>
     return beforeArgs.concat(args).concat(afterArgs);
 
-  public function addStatement(e:Expr, ?prepend) 
+  public function addStatement(e:Expr, ?prepend)
     if (prepend)
       this.nuStatements.unshift(e)
     else
       this.nuStatements.push(e);
-  
-  public function addArg(name:String, ?t:ComplexType, ?e:Expr, ?opt = false) 
+
+  public function addArg(name:String, ?t:ComplexType, ?e:Expr, ?opt = false)
     args.push( { name : name, opt : opt || e != null, type : t, value: e } );
-  
+
   public function init(name:String, pos:Position, with:FieldInit, ?options:{ ?prepend:Bool, ?bypass:Bool }) {
-    if (options == null) 
+    if (options == null)
       options = {};
     var e =
       switch with {
         case Arg(t, noPublish):
-          if (noPublish != true) 
+          if (noPublish != true)
             publish();
           args.push( { name : name, opt : false, type : t } );
           name.resolve(pos);
         case OptArg(e, t, noPublish):
-          if (noPublish != true) 
+          if (noPublish != true)
             publish();
           args.push( { name : name, opt : true, type : t, value: e } );
           name.resolve(pos);
         case Value(e): e;
       }
-      
+
     var tmp = MacroApi.tempName();
     var member = owner.memberByName(name).sure();
-    
+
     if (options.bypass && member.kind.match(FProp(_, 'never' | 'set', _, _))) {
-      
+
       member.addMeta(':isVar');
 
       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) {
@@ -112,15 +117,15 @@ class Constructor {
               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: 
+          case null:
             pos.error('this direct initialization causes the compiler to do really weird things');
           case f:
             switch f.kind {
@@ -138,24 +143,24 @@ class Constructor {
                 pos.error('not implemented');
             }
         }
-      }).bounce(), options.prepend);    
+      }).bounce(), options.prepend);
     }
-    else 
+    else
       addStatement(macro @:pos(pos) this.$name = $e, options.prepend);
   }
-  public inline function publish() 
-    if (isPublic == null) 
+  public inline function publish()
+    if (isPublic == null)
       isPublic = true;
-  
-  function toBlock() 
-    return [superCall]
+
+  function toBlock()
+    return superCall
       .concat(nuStatements)
       .concat(oldStatements)
       .toBlock(pos);
-  
-  public function onGenerate(hook) 
+
+  public function onGenerate(hook)
     this.onGenerateHooks.push(hook);
-    
+
   public function toHaxe():Field {
     var f:Function = {
       args: this.beforeArgs.concat(this.args).concat(this.afterArgs),

src/tink/macro/Functions.hx

@@ -4,9 +4,18 @@ import haxe.macro.Expr;
 
 using tink.macro.Exprs;
 
+#if haxe4
+private abstract Kind(FunctionKind) from FunctionKind to FunctionKind {
+  @:from static function ofString(s:String):Kind
+    return FNamed(s);
+}
+#else
+private typedef Kind = String;
+#end
+
 class Functions {
-  static public inline function asExpr(f:Function, ?name, ?pos) 
-    return EFunction(name, f).at(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 {

tests/Functions.hx

@@ -0,0 +1,11 @@
+import haxe.macro.Context;
+import haxe.macro.Expr;
+using tink.MacroApi;
+
+class Functions extends Base {
+  function test() {
+    var f:Function = (macro function () {}).getFunction().sure();
+    f.asExpr('foo');
+    assertTrue(true);
+  }
+}

tests/Run.hx

@@ -12,6 +12,7 @@ class Run {
     new Types(),
     new Positions(),
     new TypeMapTest(),
+    new Functions(),
     new Misc(),
   ];
   #end