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

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),