994 lines
26 KiB
Haxe
994 lines
26 KiB
Haxe
package hscript.macros;
|
|
|
|
import haxe.macro.Type.Ref;
|
|
#if macro
|
|
import haxe.macro.Type.ClassType;
|
|
import haxe.macro.Type.ModuleType;
|
|
import Type.ValueType;
|
|
import haxe.macro.Expr.Function;
|
|
import haxe.macro.Expr;
|
|
import haxe.macro.Type.MetaAccess;
|
|
import haxe.macro.Type.FieldKind;
|
|
import haxe.macro.Type.ClassField;
|
|
import haxe.macro.Type.VarAccess;
|
|
import haxe.macro.*;
|
|
|
|
using haxe.macro.ComplexTypeTools;
|
|
using haxe.macro.ExprTools;
|
|
using haxe.macro.TypeTools;
|
|
using StringTools;
|
|
using Lambda;
|
|
|
|
typedef ClassInfo = {
|
|
var imports:Array<ImportExpr>;
|
|
var ?params:Array<haxe.macro.Type.TypeParameter>;
|
|
}
|
|
|
|
@:nullSafety(Loose)
|
|
class CustomClassMacro {
|
|
public static inline final FUNC_PREFIX = "_HX_SUPER__";
|
|
public static inline final CLASS_SUFFIX = "_HSX";
|
|
|
|
public static var unallowedMetas:Array<String> = [":bitmap", ":noCustomClass", ":generic"];
|
|
private static var classesToBuild:Map<String, ClassInfo> = [];
|
|
|
|
public static function init() {
|
|
#if !display
|
|
#if CUSTOM_CLASSES
|
|
if (Context.defined("display"))
|
|
return;
|
|
for (apply in Config.ALLOWED_CUSTOM_CLASSES) {
|
|
Compiler.addGlobalMetadata(apply, "@:build(hscript.macros.CustomClassMacro.fetchClass())");
|
|
}
|
|
Context.onAfterTyping(build);
|
|
#end
|
|
#end
|
|
}
|
|
|
|
public static function fetchClass():Array<Field> {
|
|
var fields = Context.getBuildFields();
|
|
var clRef = Context.getLocalClass();
|
|
if (clRef == null)
|
|
return fields;
|
|
var cl = clRef.get();
|
|
if (cl.isAbstract || cl.isExtern || cl.isFinal || cl.isInterface)
|
|
return fields;
|
|
if (!cl.name.endsWith("_Impl_") && !cl.name.endsWith(CLASS_SUFFIX) && !cl.name.endsWith("_HSC")) {
|
|
var metas = cl.meta.get();
|
|
|
|
for (m in metas)
|
|
if (unallowedMetas.contains(m.name))
|
|
return fields;
|
|
|
|
// if(cl.params.length > 0)
|
|
// return fields;
|
|
|
|
var key = cl.module;
|
|
var fkey = '${cl.module}.${cl.name}';
|
|
if (key == "sys.thread.FixedThreadPool")
|
|
return fields; // Error: Type name sys.thread.Worker_HSX is redefined from module sys.thread.FixedThreadPool
|
|
if (key == "StdTypes")
|
|
return fields; // Error: Cant extend basic class
|
|
if (key == "Xml")
|
|
return fields; // Error: Cant extend basic class
|
|
if (key == "Date")
|
|
return fields; // Error: Cant extend basic class
|
|
if (key == "away3d.tools.commands.Mirror")
|
|
return fields; // Error: Unknown identifier
|
|
if (key == "away3d.tools.commands.SphereMaker")
|
|
return fields; // Error: Unknown identifier
|
|
if (key == "away3d.tools.commands.Weld")
|
|
return fields; // Error: Unknown identifier
|
|
if (fkey == "hscript.CustomClassHandler.TemplateClass")
|
|
return fields; // Error: Redefined
|
|
if (fkey == "hscript.CustomClassHandler.CustomTemplateClass")
|
|
return fields; // Error: Redefined
|
|
if (fkey == "hscript.CustomClass")
|
|
return fields; // Error: Redefined
|
|
if (key == "sys.thread.EventLoop")
|
|
return fields; // Error: cant override force inlined
|
|
if (Config.DISALLOW_CUSTOM_CLASSES.contains(key) || Config.DISALLOW_CUSTOM_CLASSES.contains(fkey))
|
|
return fields;
|
|
if (key.contains("_"))
|
|
return fields;
|
|
|
|
var imports = Context.getLocalImports().copy();
|
|
var clsDecl:ClassInfo = {
|
|
imports: imports,
|
|
params: cl.params.length > 0 ? cl.params : null
|
|
}
|
|
|
|
classesToBuild.set(fkey, clsDecl);
|
|
}
|
|
return fields;
|
|
}
|
|
|
|
// called in an onAfterTyping callback
|
|
public static function build(modules:Array<ModuleType>) {
|
|
var classesToApply:Array<ClassType> = [];
|
|
for (m in modules) {
|
|
switch (m) {
|
|
case TClassDecl(c):
|
|
if (c == null)
|
|
continue;
|
|
var cl = c.get();
|
|
var fkey = '${cl.module}.${cl.name}';
|
|
if (classesToBuild.exists(fkey) /*&& classesToBuild.get(fkey).params == null*/) {
|
|
classesToApply.push(cl);
|
|
}
|
|
/*
|
|
if(cl.isAbstract || cl.isExtern || cl.isFinal || cl.isInterface) continue;
|
|
if(!cl.name.endsWith("_Impl_") && !cl.name.endsWith(CLASS_SUFFIX) && !cl.name.endsWith("_HSC")) {
|
|
var fkey = '${cl.module}.${cl.name}';
|
|
if(classesToBuild.exists(fkey) && classesToBuild.get(fkey).params == null) {
|
|
classesToApply.push(cl);
|
|
}
|
|
}
|
|
*/
|
|
default:
|
|
}
|
|
}
|
|
|
|
if (classesToApply.length > 0)
|
|
buildClasses(classesToApply);
|
|
}
|
|
|
|
private static function buildClasses(classes:Array<ClassType>) {
|
|
for (cl in classes)
|
|
buildClass(cl);
|
|
}
|
|
|
|
private static function buildClass(cl:ClassType) {
|
|
var classFields:Array<ClassField> = cl.fields.get();
|
|
var classParams:Map<String, haxe.macro.Type> = [];
|
|
if (cl.params.length != 0) {
|
|
for (i => p in cl.params) {
|
|
var pName = '${cl.pack.join(".")}.${cl.name}.${p.name}';
|
|
var pFinalType = p.defaultType == null ? haxe.macro.Type.TDynamic(null) : p.defaultType;
|
|
classParams.set(pName, pFinalType);
|
|
}
|
|
}
|
|
|
|
var fields:Array<ClassField> = classFields.concat(getSuperFields(cl));
|
|
|
|
var shadowClass:TypeDefinition = macro class {};
|
|
|
|
var definedFields:Array<String> = [];
|
|
var hasNew:Bool = false;
|
|
|
|
if (cl.constructor != null) {
|
|
hasNew = true;
|
|
var constField = cl.constructor.get();
|
|
switch (constField.type) {
|
|
case TFun(args, ret):
|
|
var constArgs:Array<FunctionArg> = [
|
|
for (arg in args)
|
|
{name: arg.name, opt: arg.opt, type: Context.toComplexType(arg.t)}
|
|
];
|
|
|
|
var constructor:Field = buildConstructor(constArgs, constField.pos);
|
|
shadowClass.fields.push(constructor);
|
|
definedFields.push(constField.name); // kinda redundant since is the constructor
|
|
case TLazy(builder):
|
|
var v = builder();
|
|
switch (v) {
|
|
case TFun(args, ret):
|
|
var constArgs:Array<FunctionArg> = [
|
|
for (arg in args)
|
|
{name: arg.name, opt: arg.opt, type: Context.toComplexType(arg.t)}
|
|
];
|
|
|
|
var constructor:Field = buildConstructor(constArgs, constField.pos);
|
|
shadowClass.fields.push(constructor);
|
|
definedFields.push(constField.name);
|
|
default:
|
|
}
|
|
default:
|
|
}
|
|
}
|
|
|
|
for (f in fields) {
|
|
if (f == null)
|
|
continue;
|
|
|
|
if (f.name.startsWith(FUNC_PREFIX))
|
|
continue;
|
|
if (f.isExtern || f.isFinal)
|
|
continue;
|
|
switch (f.kind) {
|
|
case FMethod(k):
|
|
switch (k) {
|
|
case MethInline | MethDynamic | MethMacro: continue;
|
|
default:
|
|
}
|
|
case FVar(_, _):
|
|
continue;
|
|
}
|
|
|
|
if (f.name == "hget" || f.name == "hset")
|
|
continue;
|
|
if (definedFields.contains(f.name))
|
|
continue;
|
|
|
|
for (m in f.meta.get())
|
|
if (unallowedMetas.contains(m.name))
|
|
continue;
|
|
|
|
switch (f.kind) {
|
|
case FMethod(k):
|
|
var newFields = overrideField(f, cl, f.type, classParams);
|
|
|
|
var overField:Field = newFields[0];
|
|
var superField:Field = newFields[1];
|
|
|
|
if (!overField.access.contains(AOverride))
|
|
overField.access.push(AOverride);
|
|
if (superField.access.contains(AOverride))
|
|
superField.access.remove(AOverride);
|
|
|
|
shadowClass.fields.push(overField);
|
|
shadowClass.fields.push(superField);
|
|
definedFields.push(f.name);
|
|
default:
|
|
// No :>
|
|
}
|
|
}
|
|
|
|
if (definedFields.length == 0 && !hasNew) return;
|
|
|
|
shadowClass.kind = TDClass({
|
|
pack: cl.pack.copy(),
|
|
name: cl.name,
|
|
params: cl.params.length == 0 ? null : [
|
|
for (s => p in classParams)
|
|
switch (p) {
|
|
case TInst(_.get() => {kind: KExpr(e)}, _):
|
|
TPExpr(e);
|
|
default:
|
|
TPType(FixedTypeTools.toComplexType(p));
|
|
}
|
|
]
|
|
}, [
|
|
{name: "IHScriptCustomClassBehaviour", pack: ["hscript"]}
|
|
], false, true, false);
|
|
shadowClass.name = '${cl.name}$CLASS_SUFFIX';
|
|
var fkey = '${cl.module}.${cl.name}';
|
|
var imports = classesToBuild.get(fkey).imports;
|
|
if (imports != null) {
|
|
setupMetas(shadowClass, imports, cl);
|
|
processImport(imports, "hscript.utils.UnsafeReflect", "UnsafeReflect", cl.pos);
|
|
}
|
|
|
|
shadowClass.fields.push({
|
|
name: "__cachedFieldSet",
|
|
pos: cl.pos,
|
|
kind: FVar(macro :Map<String, Dynamic>),
|
|
access: [APublic, AStatic]
|
|
});
|
|
|
|
shadowClass.fields.push({
|
|
name: "__interp",
|
|
kind: FVar(macro :hscript.Interp),
|
|
pos: cl.pos,
|
|
access: [APublic]
|
|
});
|
|
|
|
shadowClass.fields.push({
|
|
name: "__allowSetGet",
|
|
pos: cl.pos,
|
|
kind: FVar(macro :Bool, macro true),
|
|
access: [APublic]
|
|
});
|
|
|
|
shadowClass.fields.push({
|
|
name: "__real_fields",
|
|
pos: cl.pos,
|
|
kind: FVar(macro :Array<String>),
|
|
access: [APublic]
|
|
});
|
|
|
|
shadowClass.fields.push({
|
|
name: "__class__fields",
|
|
pos: cl.pos,
|
|
kind: FVar(macro :Array<String>),
|
|
access: [APublic]
|
|
});
|
|
|
|
shadowClass.fields.push({
|
|
name: "__callGetter",
|
|
pos: cl.pos,
|
|
kind: FFun({
|
|
ret: macro :Dynamic,
|
|
params: [],
|
|
expr: macro {
|
|
return null;
|
|
},
|
|
args: [
|
|
{
|
|
name: "name",
|
|
opt: false,
|
|
meta: [],
|
|
type: macro :String
|
|
}
|
|
]
|
|
}),
|
|
access: [APublic]
|
|
});
|
|
|
|
shadowClass.fields.push({
|
|
name: "__callSetter",
|
|
pos: cl.pos,
|
|
kind: FFun({
|
|
ret: macro :Dynamic,
|
|
params: [],
|
|
expr: macro {
|
|
return null;
|
|
},
|
|
args: [
|
|
{
|
|
name: "name",
|
|
opt: false,
|
|
meta: [],
|
|
type: macro :String
|
|
},
|
|
{
|
|
name: "val",
|
|
opt: false,
|
|
meta: [],
|
|
type: macro :Dynamic
|
|
}
|
|
]
|
|
}),
|
|
access: [APublic]
|
|
});
|
|
|
|
if (cl.name == "FunkinShader" || cl.name == "CustomShader" || cl.name == "MultiThreadedScript") {
|
|
Context.defineModule(cl.module, [shadowClass], imports);
|
|
return;
|
|
}
|
|
|
|
var hasHgetInSuper = false;
|
|
var hasHsetInSuper = false;
|
|
|
|
// TODO: hget & hset
|
|
|
|
for (f in fields) {
|
|
if (f.name == "new")
|
|
continue;
|
|
if (f.name.startsWith(FUNC_PREFIX))
|
|
continue;
|
|
if (f.isExtern || f.isFinal)
|
|
continue;
|
|
switch (f.kind) {
|
|
case FMethod(k):
|
|
switch (k) {
|
|
case MethInline | MethDynamic | MethMacro: continue;
|
|
default:
|
|
}
|
|
case FVar(read, write):
|
|
switch ([read, write]) {
|
|
case [AccInline, AccInline]: continue;
|
|
default:
|
|
}
|
|
}
|
|
|
|
switch (f.type) {
|
|
case TFun(args, ret):
|
|
if (f.params != null && f.params.length > 0)
|
|
continue;
|
|
|
|
hasHgetInSuper = f.name == "hget";
|
|
hasHsetInSuper = f.name == "hset";
|
|
|
|
if (hasHgetInSuper && hasHsetInSuper)
|
|
break;
|
|
default:
|
|
}
|
|
}
|
|
|
|
var hgetField = if (hasHgetInSuper) {
|
|
macro {
|
|
if (__interp != null) {
|
|
if (__class__fields.contains(name)) {
|
|
var v:Dynamic = __interp.variables.get(name);
|
|
if (v != null && v is hscript.Property)
|
|
return cast(v, hscript.Property).callGetter(name);
|
|
return v;
|
|
} else
|
|
@:privateAccess {
|
|
var cls:hscript.CustomClass = cast __interp.__customClass.__upperClass;
|
|
while (cls != null) {
|
|
if (cls.hasField(name))
|
|
return cls.getField(name);
|
|
|
|
var prev:hscript.CustomClass = cast cls.__upperClass;
|
|
if (prev == null)
|
|
break;
|
|
cls = prev;
|
|
}
|
|
}
|
|
}
|
|
|
|
return super.hget(name);
|
|
}
|
|
} else {
|
|
macro {
|
|
if (__interp != null) {
|
|
if (__class__fields.contains(name)) {
|
|
var v:Dynamic = __interp.variables.get(name);
|
|
if (v != null && v is hscript.Property)
|
|
return cast(v, hscript.Property).callGetter(name);
|
|
return v;
|
|
} else
|
|
@:privateAccess {
|
|
var cls:hscript.CustomClass = cast __interp.__customClass.__upperClass;
|
|
while (cls != null) {
|
|
if (cls.hasField(name))
|
|
return cls.getField(name);
|
|
|
|
var prev:hscript.CustomClass = cast cls.__upperClass;
|
|
if (prev == null)
|
|
break;
|
|
cls = prev;
|
|
}
|
|
}
|
|
}
|
|
|
|
return UnsafeReflect.getProperty(this, name);
|
|
}
|
|
}
|
|
|
|
var hsetField = if (hasHsetInSuper) {
|
|
macro {
|
|
if (__interp != null) {
|
|
if (__class__fields.contains(name)) {
|
|
var v:Dynamic = __interp.variables.get(name);
|
|
if (v != null && v is hscript.Property)
|
|
return cast(v, hscript.Property).callSetter(name, val);
|
|
__interp.variables.set(name, val);
|
|
return val;
|
|
} else
|
|
@:privateAccess {
|
|
var cls:hscript.CustomClass = cast __interp.__customClass.__upperClass;
|
|
while (cls != null) {
|
|
if (cls.hasField(name))
|
|
return cls.setField(name, val);
|
|
|
|
var prev:hscript.CustomClass = cast cls.__upperClass;
|
|
if (prev == null)
|
|
break;
|
|
cls = prev;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (__real_fields.contains(name)) {
|
|
UnsafeReflect.setProperty(this, name, val);
|
|
return UnsafeReflect.field(this, name);
|
|
}
|
|
return super.hset(name, val);
|
|
}
|
|
} else {
|
|
macro {
|
|
if (__interp != null) {
|
|
if (__class__fields.contains(name)) {
|
|
var v:Dynamic = __interp.variables.get(name);
|
|
if (v != null && v is hscript.Property)
|
|
return cast(v, hscript.Property).callSetter(name, val);
|
|
__interp.variables.set(name, val);
|
|
return val;
|
|
} else
|
|
@:privateAccess {
|
|
var cls:hscript.CustomClass = cast __interp.__customClass.__upperClass;
|
|
while (cls != null) {
|
|
if (cls.hasField(name))
|
|
return cls.setField(name, val);
|
|
|
|
var prev:hscript.CustomClass = cast cls.__upperClass;
|
|
if (prev == null)
|
|
break;
|
|
cls = prev;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (__real_fields.contains(name)) {
|
|
UnsafeReflect.setProperty(this, name, val);
|
|
return UnsafeReflect.field(this, name);
|
|
}
|
|
// __custom__variables.set(name, val);
|
|
return val;
|
|
}
|
|
}
|
|
|
|
shadowClass.fields.push({
|
|
name: "hset",
|
|
pos: cl.pos,
|
|
access: hasHsetInSuper ? [AOverride, APublic] : [APublic],
|
|
kind: FFun({
|
|
ret: macro :Dynamic,
|
|
params: [],
|
|
expr: hsetField,
|
|
args: [
|
|
{
|
|
name: "name",
|
|
opt: false,
|
|
meta: [],
|
|
type: macro :String
|
|
},
|
|
{
|
|
name: "val",
|
|
opt: false,
|
|
meta: [],
|
|
type: macro :Dynamic
|
|
}
|
|
]
|
|
})
|
|
});
|
|
|
|
shadowClass.fields.push({
|
|
name: "hget",
|
|
pos: cl.pos,
|
|
access: hasHgetInSuper ? [AOverride, APublic] : [APublic],
|
|
kind: FFun({
|
|
ret: macro :Dynamic,
|
|
params: [],
|
|
expr: hgetField,
|
|
args: [
|
|
{
|
|
name: "name",
|
|
opt: false,
|
|
meta: [],
|
|
type: macro :String
|
|
}
|
|
]
|
|
})
|
|
});
|
|
|
|
/*
|
|
var p = new Printer();
|
|
var aa = p.printTypeDefinition(shadowClass);
|
|
trace('\n');
|
|
trace(aa);
|
|
*/
|
|
|
|
Context.defineModule(cl.module, [shadowClass], imports);
|
|
}
|
|
|
|
// Based on Polymod HScriptClass Macro: https://github.com/larsiusprime/polymod/blob/develop/polymod/hscript/_internal/HScriptedClassMacro.hx#L686
|
|
private static function overrideField(field:ClassField, cl:ClassType, ?type:haxe.macro.Type, ?params:Map<String, haxe.macro.Type>):Array<Field> {
|
|
if (type == null)
|
|
type = field.type;
|
|
|
|
switch (type) {
|
|
case TLazy(f):
|
|
var fv = f();
|
|
return overrideField(field, cl, fv, params);
|
|
case TFun(args, ret):
|
|
for (a in args)
|
|
switch (a.t) {
|
|
case TInst(t, p):
|
|
var tp = t.get();
|
|
if (tp != null && tp.isPrivate) return [];
|
|
default:
|
|
}
|
|
// Inline functions are already skipped
|
|
// As well for "@:generic" fields
|
|
|
|
var fnInputArgs:Array<FunctionArg> = [];
|
|
|
|
// We only get limited information about the args from Type, we need to use TypedExprDef.
|
|
|
|
if (field.expr() == null)
|
|
return [];
|
|
|
|
var fnAccess:Array<Access> = [field.isPublic ? APublic : APrivate];
|
|
if (field.isFinal)
|
|
fnAccess.push(AFinal);
|
|
|
|
switch (field.expr().expr) {
|
|
case TFunction(tfunc):
|
|
for (arg in tfunc.args) {
|
|
var opt:Bool = (arg.value != null);
|
|
var fnMeta:Metadata = arg.v.meta.get();
|
|
var fnExpr:Null<Expr> = !opt ? null : Context.getTypedExpr(arg.value);
|
|
// The argument type. We have to handle any type parameters, and deparameterizeType does so recursively.
|
|
var fnType:ComplexType = Context.toComplexType(deparameterizeType(arg.v.t, params));
|
|
|
|
var fnArg:FunctionArg = {
|
|
name: arg.v.name,
|
|
type: fnType,
|
|
value: fnExpr,
|
|
meta: fnMeta
|
|
};
|
|
|
|
fnInputArgs.push(fnArg);
|
|
}
|
|
case TConst(_):
|
|
// This is actually a VARIABLE storing a function.
|
|
return [];
|
|
default:
|
|
}
|
|
|
|
// TODO
|
|
|
|
var returnsVoid:Bool = ret.toString() == "Void";
|
|
|
|
var fnCall:Array<Expr> = [for (a in args) macro $i{a.name}];
|
|
var fnParams:Array<TypeParamDecl> = [for (fp in field.params) {name: fp.name}];
|
|
var fnRet:Null<ComplexType> = returnsVoid ? null : Context.toComplexType(deparameterizeType(ret, params));
|
|
var fnName:String = field.name;
|
|
|
|
var overField:Field = {
|
|
name: fnName,
|
|
access: fnAccess,
|
|
pos: field.pos,
|
|
meta: field.meta.get(),
|
|
kind: FFun({
|
|
args: fnInputArgs,
|
|
params: fnParams,
|
|
ret: fnRet,
|
|
expr: macro {
|
|
var name:String = $v{fnName};
|
|
|
|
if (__interp != null && __class__fields.contains(name)) {
|
|
var v:Dynamic = null;
|
|
if (Reflect.isFunction(v = __interp.variables.get(name))) {
|
|
${
|
|
!returnsVoid ? (macro return v($a{fnCall})) : macro {
|
|
v($a{fnCall});
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
${
|
|
!returnsVoid ? (macro return super.$fnName($a{fnCall})) : (macro super.$fnName($a{fnCall}))
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
var superFunField:Field = {
|
|
name: '$FUNC_PREFIX${fnName}',
|
|
pos: field.pos,
|
|
access: [APrivate],
|
|
meta: field.meta.get(),
|
|
kind: FFun({
|
|
args: fnInputArgs,
|
|
params: fnParams,
|
|
ret: fnRet,
|
|
expr: macro {
|
|
${
|
|
!returnsVoid ? (macro return super.$fnName($a{fnCall})) : (macro super.$fnName($a{fnCall}))
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
return [overField, superFunField];
|
|
|
|
/* case TInst(_, _): return [];
|
|
case TEnum(_, _): return [];
|
|
case TMono(_): return [];
|
|
case TAnonymous(_): return [];
|
|
case TDynamic(_): return [];
|
|
case TAbstract(_, _): return []; */
|
|
default:
|
|
}
|
|
return [];
|
|
}
|
|
|
|
static function getBaseParamsOfType(parentType:haxe.macro.Type, paramTypes:Array<haxe.macro.Type>):Array<haxe.macro.Type.TypeParameter> {
|
|
var parentParams:Array<haxe.macro.Type.TypeParameter> = [];
|
|
|
|
switch (parentType) {
|
|
case TMono(t):
|
|
var ty = t.get();
|
|
return getBaseParamsOfType(ty, paramTypes);
|
|
|
|
case TInst(t, params):
|
|
// Continue
|
|
parentParams = t.get().params;
|
|
|
|
case TType(t, params):
|
|
// Recurse
|
|
var ty:haxe.macro.Type = t.get().type;
|
|
return getBaseParamsOfType(ty, paramTypes);
|
|
|
|
case TDynamic(t):
|
|
// Recurse
|
|
return getBaseParamsOfType(t, paramTypes);
|
|
|
|
case TLazy(f):
|
|
// Recurse
|
|
var ty:haxe.macro.Type = f();
|
|
return getBaseParamsOfType(ty, paramTypes);
|
|
|
|
case TAbstract(t, _params):
|
|
// Continue
|
|
parentParams = t.get().params;
|
|
|
|
// case TEnum(t:Ref<EnumType>, params:Array<Type>):
|
|
// case TFun(args:Array<{name:String, opt:Bool, t:Type}>, ret:Type):
|
|
// case TAnonymous(a:Ref<AnonType>):
|
|
default:
|
|
// Context.error('Unsupported type: ${parentType}', Context.currentPos());
|
|
}
|
|
|
|
var result:Array<haxe.macro.Type.TypeParameter> = [];
|
|
|
|
for (i => parentParam in parentParams) {
|
|
var newParam:haxe.macro.Type.TypeParameter = {
|
|
name: parentParam.name,
|
|
t: paramTypes[i],
|
|
};
|
|
result.push(newParam);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static function scanBaseTypes(type:haxe.macro.Type):Array<haxe.macro.Type> {
|
|
switch (type) {
|
|
case TFun(args, ret):
|
|
var results:Array<haxe.macro.Type> = [];
|
|
|
|
for (result in scanBaseTypes(ret)) {
|
|
results.push(result);
|
|
}
|
|
for (arg in args) {
|
|
for (result in scanBaseTypes(arg.t)) {
|
|
results.push(result);
|
|
}
|
|
}
|
|
return results;
|
|
case TAbstract(ty, params):
|
|
if (params.length == 0) {
|
|
return [type];
|
|
} else {
|
|
var results:Array<haxe.macro.Type> = [];
|
|
for (param in params) {
|
|
for (result in scanBaseTypes(param)) {
|
|
results.push(result);
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
default:
|
|
return [type];
|
|
}
|
|
}
|
|
|
|
static function deparameterizeType(targetType:haxe.macro.Type, targetParams:Map<String, haxe.macro.Type>):haxe.macro.Type {
|
|
var resultType:haxe.macro.Type = targetType;
|
|
|
|
switch (targetType) {
|
|
case TFun(args, ret):
|
|
// Function type.
|
|
// This is not referring to functions of a class, but rather a function taken as a parameter (like a callback).
|
|
|
|
// Deparameterize the return type.
|
|
var retType:haxe.macro.Type = deparameterizeType(ret, targetParams);
|
|
// Deparameterize the argument types.
|
|
var argTypes:Array<{name:String, opt:Bool, t:haxe.macro.Type}> = args.map(function(arg) {
|
|
return {
|
|
name: arg.name,
|
|
opt: arg.opt,
|
|
t: deparameterizeType(arg.t, targetParams),
|
|
};
|
|
});
|
|
|
|
// Construct the new type.
|
|
resultType = TFun(argTypes, retType);
|
|
|
|
case TAbstract(ty, params):
|
|
// Abstract type. Sometimes used by types like Null<T>.
|
|
|
|
var name = ty.toString();
|
|
var typ = ty.get();
|
|
|
|
// Check if the Abstract type is a parameter we recognize and can replace.
|
|
if (targetParams.exists(ty.toString())) {
|
|
// If so, replace it with the real type.
|
|
resultType = targetParams.get(ty.toString());
|
|
// recursive call in case result is a parameter
|
|
resultType = deparameterizeType(resultType, targetParams);
|
|
} else if (params.length != 0) {
|
|
var oldParams:Array<haxe.macro.Type> = [];
|
|
var newParams:Array<haxe.macro.Type> = [];
|
|
for (param in params) {
|
|
var baseTypes = scanBaseTypes(param);
|
|
|
|
for (baseType in baseTypes) {
|
|
var newParam = deparameterizeType(baseType, targetParams);
|
|
if (newParam.toString() != "Void") {
|
|
oldParams.push(baseType);
|
|
newParams.push(newParam);
|
|
}
|
|
}
|
|
}
|
|
var baseParams = getBaseParamsOfType(resultType, oldParams);
|
|
newParams = newParams.slice(0, baseParams.length);
|
|
|
|
if (newParams.length > 0) {
|
|
// Context.info('Building new abstract (${baseParams} + ${newParams})...', Context.currentPos());
|
|
resultType = resultType.applyTypeParameters(baseParams, newParams);
|
|
// Context.info('Deparameterized abstract type: ${resultType.toString()}', Context.currentPos());
|
|
}
|
|
}
|
|
case TInst(ty, params):
|
|
// Instance type. Used by most variables.
|
|
|
|
// Check if the Instance type is a parameter we recognize and can replace.
|
|
if (targetParams.exists(ty.toString())) {
|
|
// If so, replace it with the real type.
|
|
resultType = targetParams.get(ty.toString());
|
|
// recursive call in case result is a parameter
|
|
resultType = deparameterizeType(resultType, targetParams);
|
|
} else if (params.length != 0) {
|
|
var oldParams:Array<haxe.macro.Type> = [];
|
|
var newParams:Array<haxe.macro.Type> = [];
|
|
for (param in params) {
|
|
var baseTypes = scanBaseTypes(param);
|
|
|
|
for (baseType in baseTypes) {
|
|
var newParam = deparameterizeType(baseType, targetParams);
|
|
if (newParam.toString() != "Void") {
|
|
oldParams.push(baseType);
|
|
newParams.push(newParam);
|
|
}
|
|
}
|
|
}
|
|
var baseParams = getBaseParamsOfType(resultType, oldParams);
|
|
newParams = newParams.slice(0, baseParams.length);
|
|
|
|
if (newParams.length > 0) {
|
|
// Context.info('Building new abstract (${baseParams} + ${newParams})...', Context.currentPos());
|
|
resultType = resultType.applyTypeParameters(baseParams, newParams);
|
|
// Context.info('Deparameterized abstract type: ${resultType.toString()}', Context.currentPos());
|
|
} else {
|
|
// Leave the type as is.
|
|
}
|
|
}
|
|
|
|
default:
|
|
// Do nothing.
|
|
// Muted because I haven't actually seen any issues caused by this. Maybe investigate in the future.
|
|
}
|
|
|
|
return resultType;
|
|
}
|
|
|
|
private static function getSuperFields(cl:ClassType):Array<ClassField> {
|
|
var fields:Array<ClassField> = [];
|
|
var superClsRef = cl.superClass;
|
|
while (superClsRef != null) {
|
|
var superCls:ClassType = superClsRef.t.get();
|
|
fields = fields.concat(superCls.fields.get());
|
|
var next = superCls.superClass;
|
|
if (next == null)
|
|
break;
|
|
superClsRef = next;
|
|
}
|
|
|
|
return fields;
|
|
}
|
|
|
|
private static function buildConstructor(args:Array<FunctionArg>, pos:Position):Field {
|
|
var superCallArgs:Array<Expr> = [for (arg in args) macro $i{arg.name}];
|
|
|
|
return {
|
|
name: 'new',
|
|
access: [APublic],
|
|
pos: pos,
|
|
kind: FFun({
|
|
args: args,
|
|
expr: macro {
|
|
// Call the super constructor with appropriate args
|
|
super($a{superCallArgs});
|
|
|
|
if (__cachedFieldSet != null) {
|
|
for (k => v in __cachedFieldSet) {
|
|
Reflect.setProperty(this, k, v);
|
|
}
|
|
__cachedFieldSet.clear();
|
|
__cachedFieldSet = null;
|
|
}
|
|
}
|
|
}),
|
|
}
|
|
}
|
|
|
|
// Grabbed from Utils.hx
|
|
static function setupMetas(shadowClass:TypeDefinition, imports:Array<ImportExpr>, cl:ClassType) {
|
|
shadowClass.meta = [
|
|
{
|
|
name: ":dox",
|
|
params: [macro hide],
|
|
pos: cl.pos
|
|
},
|
|
{
|
|
name: ":noCompletion",
|
|
params: [],
|
|
pos: cl.pos
|
|
}
|
|
];
|
|
var module = Context.getModule(cl.module);
|
|
for (m in module)
|
|
switch (m) {
|
|
case TInst(t, params):
|
|
if (t == null)
|
|
continue;
|
|
var ty = t.get();
|
|
processModule(shadowClass, ty.module, ty.name, cl.pos);
|
|
processImport(imports, ty.module, ty.name, cl.pos);
|
|
case TEnum(t, params):
|
|
if (t == null)
|
|
continue;
|
|
var ty = t.get();
|
|
processModule(shadowClass, ty.module, ty.name, cl.pos);
|
|
processImport(imports, ty.module, ty.name, cl.pos);
|
|
case TType(t, params):
|
|
if (t == null)
|
|
continue;
|
|
var ty = t.get();
|
|
processModule(shadowClass, ty.module, ty.name, cl.pos);
|
|
processImport(imports, ty.module, ty.name, cl.pos);
|
|
case TAbstract(t, params):
|
|
if (t == null)
|
|
continue;
|
|
var ty = t.get();
|
|
processModule(shadowClass, ty.module, ty.name, cl.pos);
|
|
processImport(imports, ty.module, ty.name, cl.pos);
|
|
default:
|
|
}
|
|
}
|
|
|
|
static function processImport(imports:Array<ImportExpr>, module:String, n:String, pos:Position) {
|
|
if (n.endsWith("_Impl_"))
|
|
n = n.substr(0, n.length - 6);
|
|
module = fixModuleName(module);
|
|
if (module.endsWith("_Impl_"))
|
|
module = module.substr(0, module.length - 6);
|
|
|
|
trace(module);
|
|
imports.push({
|
|
path: [
|
|
for (m in module.split("."))
|
|
{
|
|
name: m,
|
|
pos: pos
|
|
}
|
|
],
|
|
mode: INormal
|
|
});
|
|
}
|
|
|
|
static function processModule(shadowClass:TypeDefinition, module:String, n:String, pos:Position) {
|
|
if (n.endsWith("_Impl_"))
|
|
n = n.substr(0, n.length - 6);
|
|
if (module.endsWith("_Impl_"))
|
|
module = module.substr(0, module.length - 6);
|
|
|
|
shadowClass.meta.push({
|
|
name: ':access',
|
|
params: [
|
|
Context.parse(fixModuleName(module.endsWith('.${n}') ? module : '${module}.${n}'), pos)
|
|
],
|
|
pos: pos
|
|
});
|
|
}
|
|
|
|
static function fixModuleName(name:String):String {
|
|
return [for (s in name.split(".")) if (s.charAt(0) == "_") s.substr(1) else s].join(".");
|
|
}
|
|
}
|
|
#else
|
|
class CustomClassMacro {
|
|
public var usedClass:Class<Dynamic>;
|
|
public var className:String;
|
|
}
|
|
#end
|