implementing function type...

examples/src/basic/FunctionType.hx

@@ -14,10 +14,9 @@ private class Module extends ShaderModule {
 
 class FunctionType extends ShaderMain {
 	function vertex():Void {
-		final funcAlias:(x:Float, y:Float) -> Float = max;
-		final func = Module.someFunc;
+		final funcAlias:(x:Float, y:Float) -> Float = 1.0 > 2.0 ? min : max;
+		var max = 1.0;
 		funcAlias(1, 2);
-		func(1, 2);
 	}
 
 	function fragment():Void {

src/hgsl/macro/Builder.hx

@@ -326,11 +326,11 @@ class Builder {
 				switch f.kind {
 					case BuiltIn:
 						throw ierror(macro "unexpected bult-in function");
-					case User(expr, field, _):
+					case User(data):
 						final origName = f.name;
 						// define the function with its original name,
 						// this one can be overridden
-						env.defineFunc(origName, f.type, f.args, f.region, expr, field, f.pos);
+						env.defineFunc(origName, f.type, f.args, f.region, data.expr, data.field, f.pos);
 
 						// also define the function with the tweaked name,
 						// this one cannot be overridden and can be accessed with super keyword
@@ -345,7 +345,7 @@ class Builder {
 								// already registered, use it
 								name;
 						}
-						env.defineFunc(tweakedName, f.type, f.args, f.region, expr, field, f.pos);
+						env.defineFunc(tweakedName, f.type, f.args, f.region, data.expr, data.field, f.pos);
 						tweakedSuperFuncFields.push({
 							name: tweakedName,
 							access: [AExtern, AOverload],

src/hgsl/macro/Environment.hx

@@ -112,14 +112,14 @@ class Environment {
 					switch f.kind {
 						case BuiltIn:
 							throw ierror(macro "unexpected built-in function");
-						case User(_, field, _):
+						case User(data):
 							final ptype = f.type;
 							final pargs = f.args.map(arg -> arg.type);
 							f.type = parser.resolveArraySize(this, f.type, f.pos);
 							for (arg in f.args) {
 								arg.type = parser.resolveArraySize(this, arg.type, f.pos);
 							}
-							switch field.kind {
+							switch data.field.kind {
 								case FFun(func):
 									if (f.type.match(TStruct(_) | TArray(_))) {
 										func.ret = f.type.toComplexType();
@@ -266,7 +266,11 @@ class Environment {
 			name: name,
 			region: region,
 			ctor: false,
-			kind: User(expr, field, this),
+			kind: User({
+				expr: expr,
+				field: field,
+				env: this
+			}),
 			pos: pos
 		}
 		defineField(FFunc(res));

src/hgsl/macro/FunctionToParse.hx

@@ -0,0 +1,58 @@
+package hgsl.macro;
+
+import haxe.macro.Context;
+
+#if macro
+class FunctionToParse {
+	public final target:GFunc;
+	public final userFuncData:UserFuncData;
+	public final passedFuncs:Array<GFunc>;
+	public final normalArgs:Array<{name:String, type:GType}> = [];
+	public final funcArgs:Array<{name:String, type:GFuncType, func:GFunc}> = [];
+
+	public function new(target:GFunc, passedFuncs:Array<GFunc>) {
+		this.target = target;
+		this.passedFuncs = passedFuncs;
+		userFuncData = switch target.kind {
+			case BuiltIn:
+				throw ierror(macro "unexpected built-in function");
+			case User(data):
+				data;
+		}
+		checkArguments();
+	}
+
+	function checkArguments():Void {
+		final funcArgs = target.args.filter(arg -> arg.type.isFunctionType()).map(arg -> switch arg.type {
+			case TFunc(f):
+				{
+					name: arg.name,
+					type: f,
+					func: null
+				}
+			case TFuncUnknown:
+				throw ierror(macro "unexpected unknown function type");
+			case _:
+				throw ierror(macro "expected function type");
+		});
+		if (funcArgs.length != passedFuncs.length)
+			throw ierror(macro "function argument count mismatch");
+		if (!funcArgs.zip(passedFuncs, (a, f) -> {
+			a.func = f;
+			a.type.match(f);
+		}).all())
+			throw ierror(macro "function types mismatch");
+		final normalArgs = target.args.filter(arg -> !arg.type.isFunctionType()).map(arg -> {name: arg.name, type: arg.type});
+		for (a in funcArgs)
+			this.funcArgs.push(a);
+		for (a in normalArgs)
+			this.normalArgs.push(a);
+	}
+
+	public function generateKey():String {
+		final env = userFuncData.env;
+		return env.module + "." + env.className + "." + target.name + "(" + target.args.map(arg -> arg.type.toString())
+			.join(",") + "):" + target.type.toString() + "<" + passedFuncs.map(f -> f.pos).join(", ") + ">";
+	}
+}
+#end

src/hgsl/macro/ParsedFunction.hx

@@ -3,15 +3,17 @@ package hgsl.macro;
 #if macro
 class ParsedFunction {
 	public final name:String;
-	public final returnType:GType;
-	public final args:Array<GFuncArg>;
-	public final source:Source;
+	// public final returnType:GType;
+	// public final args:Array<GFuncArg>;
+	public final defSource:Source;
+	public final mainSource:Source;
 
-	public function new(name:String, returnType:GType, args:Array<GFuncArg>) {
+	public function new(name:String /*,returnType:GType, args:Array<GFuncArg>*/) {
 		this.name = name;
-		this.returnType = returnType;
-		this.args = args;
-		source = new Source();
+		// this.returnType = returnType;
+		// this.args = args;
+		defSource = new Source();
+		mainSource = new Source();
 	}
 }
 #end