Support for untyped new.

build.hxml

-js test.js
-main Usage
--macro UntypedNew.use()
-cmd node test.js

UntypedNew.hx

package ;

#if macro
import haxe.macro.Compiler;
import haxe.macro.Context;
import haxe.macro.Expr;

using haxe.macro.Tools;
#end

class UntypedNew {
  #if macro
  static public function use() 
    Compiler.addGlobalMetadata('', '@:build(UntypedNew.allow())');
    
  var occurrenceFound:Bool = false;
  var fields:Array<Field>;
  
  function new() {
    fields = Context.getBuildFields();
    for (f in fields)
      switch f.kind {
        case FVar(t, e): f.kind = FVar(t, fix(e));
        case FProp(get, set, t, e): f.kind = FProp(get, set, t, fix(e));
        case FFun(f): f.expr = fix(f.expr);
      } 
    if (!occurrenceFound)
      fields = null;
  }
  function seek(e:Expr)
    switch e {
      case null:
      case macro untyped new $p($a{args}):
        throw this;            
      default:
        e.iter(seek);
    }
    
  function replace(e:Expr)
    return
      switch e {
        case macro untyped new $p($a{args}): 
          var path = p.pack.concat([p.name]);
          if (p.sub != null) 
            path.push(p.sub);
            
          macro @:pos(e.pos) Type.createInstance(untyped $p{path}, [$a{args}]);
        default: e.map(replace);    
      }
      
  function fix(e:Expr) 
    return 
      try {
        seek(e);
        e;
      }
      catch (_:UntypedNew) {
        occurrenceFound = true;
        replace(e);
      }
      
  static public function allow():Array<Field> 
    return new UntypedNew().fields;
  #end
}

Usage.hx

package ;

class Usage {
  static function main() {
    function X() { }
    untyped X.prototype.foo = 5;
    var x:Dynamic = untyped new X();
    trace(x.foo);//5 ... yay!
  }
}