fix: When literals are returned from kernel, freeze their type

feat: Parse GLSL and get return type and argument types
feat: Properly look up native function return types and cast if needed
feat: Properly look up native function argument types and cast if needed
fix: Move this.chooseKernel() to beginning of GPU instantiation

As well as test all the above

Author: robertleeplummerjr

src/backend/cpu/kernel.js

@@ -41,6 +41,14 @@ class CPUKernel extends Kernel {
 		return 'cpu';
 	}
 
+	static nativeFunctionArgumentTypes() {
+		return null;
+	}
+
+	static nativeFunctionReturnType() {
+		return null;
+	}
+
 	constructor(source, settings) {
 		super(source, settings);
 

src/backend/function-builder.js

@@ -33,14 +33,33 @@ class FunctionBuilder {
 			})));
 		};
 
+		const parsedReturnTypes = {};
 		const lookupReturnType = (functionName) => {
+			if (parsedReturnTypes[functionName]) return parsedReturnTypes[functionName];
+			const source = functionBuilder.nativeFunctions[functionName];
+			if (source) {
+				return parsedReturnTypes[functionName] = kernel.constructor.nativeFunctionReturnType(source);
+			}
 			return functionBuilder.lookupReturnType(functionName);
 		};
 
+		const nativeFunctionReturnTypes = {};
+		const nativeFunctionArgumentTypes = {};
+
+		if (kernel.nativeFunctions) {
+			for (let i = 0; i < kernel.nativeFunctions.length; i++) {
+				const nativeFunction = kernel.nativeFunctions[i];
+				nativeFunctionReturnTypes[nativeFunction.name] = nativeFunction.returnType;
+				nativeFunctionArgumentTypes[nativeFunction.name] = nativeFunction.argumentTypes;
+			}
+		}
+
 		const nodeOptions = Object.assign({
 			isRootKernel: false,
 			onNestedFunction,
 			lookupReturnType,
+			nativeFunctionReturnTypes,
+			nativeFunctionArgumentTypes,
 			constants,
 			constantTypes,
 			debug,

src/backend/function-node.js

@@ -35,6 +35,8 @@ class FunctionNode {
 		this.declarations = {};
 		this.states = [];
 		this.lookupReturnType = null;
+		this.nativeFunctionReturnTypes = null;
+		this.nativeFunctionArgumentTypes = null;
 		this.onNestedFunction = null;
 		this.loopMaxIterations = null;
 		this.argumentNames = (typeof this.source === 'string' ? utils.getArgumentNamesFromString(this.source) : null);
@@ -43,6 +45,7 @@ class FunctionNode {
 		this.returnType = null;
 		this.output = [];
 		this.plugins = null;
+		this.literalTypes = {};
 
 		if (settings) {
 			for (const p in settings) {
@@ -302,6 +305,10 @@ class FunctionNode {
 			case 'ArrayExpression':
 				return `Array(${ ast.elements.length })`;
 			case 'Literal':
+				const literalKey = `${ast.start},${ast.end}`;
+				if (this.literalTypes[literalKey]) {
+					return this.literalTypes[literalKey];
+				}
 				if (Number.isInteger(ast.value)) {
 					return 'LiteralInteger';
 				} else {
@@ -311,6 +318,10 @@ class FunctionNode {
 				if (this.isAstMathFunction(ast)) {
 					return 'Number';
 				}
+				if (!ast.callee || !ast.callee.name) return null;
+				if (this.nativeFunctionReturnTypes && this.nativeFunctionReturnTypes[ast.callee.name]) {
+					return this.nativeFunctionReturnTypes[ast.callee.name];
+				}
 				return ast.callee && ast.callee.name && this.lookupReturnType ? this.lookupReturnType(ast.callee.name) : null;
 			case 'BinaryExpression':
 				// modulos is Number
@@ -753,6 +764,7 @@ class FunctionNode {
 		return retArr;
 	}
 	astLiteral(ast, retArr) {
+		this.literalTypes[`${ast.start},${ast.end}`] = 'Number';
 		return retArr;
 	}
 	astBinaryExpression(ast, retArr) {

src/backend/gl-kernel.js

@@ -113,8 +113,139 @@ class GLKernel extends Kernel {
 		this.floatOutputForce = null;
 		this.fixIntegerDivisionAccuracy = null;
 	}
+
+	/**
+	 * A highly readable very forgiving micro-parser for a glsl function that gets argument types
+	 * @param {String} source
+	 * @returns {{types: String[], names: String[]}}
+	 */
+	static nativeFunctionArgumentTypes(source) {
+		const types = [];
+		const names = [];
+		const states = [];
+		const isStartingVariableName = /^[a-zA-Z_]/;
+		const isVariableChar = /[a-zA-Z_0-9]/;
+		let i = 0;
+		let name = null;
+		let type = null;
+		while (i < source.length) {
+			const char = source[i];
+			const nextChar = source[i + 1];
+			const state = states.length > 0 ? states[states.length - 1] : null;
+
+			// begin MULTI_LINE_COMMENT handling
+			if (state === 'FUNCTION_ARGUMENTS' && char === '/' && nextChar === '*') {
+				states.push('MULTI_LINE_COMMENT');
+				i += 2;
+				continue;
+			} else if (state === 'MULTI_LINE_COMMENT' && char === '*' && nextChar === '/') {
+				states.pop();
+				i += 2;
+				continue;
+			}
+			// end MULTI_LINE_COMMENT handling
+
+			// begin COMMENT handling
+			else if (state === 'FUNCTION_ARGUMENTS' && char === '/' && nextChar === '/') {
+				states.push('COMMENT');
+				i += 2;
+				continue;
+			} else if (state === 'COMMENT' && char === '\n') {
+				states.pop();
+				i++;
+				continue;
+			}
+			// end COMMENT handling
+
+			// being FUNCTION_ARGUMENTS handling
+			else if (state === null && char === '(') {
+				states.push('FUNCTION_ARGUMENTS');
+				i++;
+				continue;
+			} else if (state === 'FUNCTION_ARGUMENTS') {
+				if (char === ')') {
+					states.pop();
+					break;
+				}
+				if (char === 'f' && nextChar === 'l' && source[i + 2] === 'o' && source[i + 3] === 'a' && source[i + 4] === 't' && source[i + 5] === ' ') {
+					states.push('DECLARE_VARIABLE');
+					type = 'float';
+					name = '';
+					i += 6;
+					continue;
+				} else if (char === 'i' && nextChar === 'n' && source[i + 2] === 't' && source[i + 3] === ' ') {
+					states.push('DECLARE_VARIABLE');
+					type = 'int';
+					name = '';
+					i += 4;
+					continue;
+				} else if (char === 'v' && nextChar === 'e' && source[i + 2] === 'c' && source[i + 3] === '2' && source[i + 4] === ' ') {
+					states.push('DECLARE_VARIABLE');
+					type = 'vec2';
+					name = '';
+					i += 5;
+					continue;
+				} else if (char === 'v' && nextChar === 'e' && source[i + 2] === 'c' && source[i + 3] === '3' && source[i + 4] === ' ') {
+					states.push('DECLARE_VARIABLE');
+					type = 'vec3';
+					name = '';
+					i += 5;
+					continue;
+				} else if (char === 'v' && nextChar === 'e' && source[i + 2] === 'c' && source[i + 3] === '4' && source[i + 4] === ' ') {
+					states.push('DECLARE_VARIABLE');
+					type = 'vec4';
+					name = '';
+					i += 5;
+					continue;
+				}
+			}
+			// end FUNCTION_ARGUMENTS handling
+
+			// begin DECLARE_VARIABLE handling
+			else if (state === 'DECLARE_VARIABLE') {
+				if (name === '') {
+					if (char === ' ') {
+						i++;
+						continue;
+					}
+					if (!isStartingVariableName.test(char)) {
+						throw new Error('variable name is not expected string');
+					}
+				}
+				name += char;
+				if (!isVariableChar.test(nextChar)) {
+					states.pop();
+					names.push(name);
+					types.push(typeMap[type]);
+				}
+			}
+			// end DECLARE_VARIABLE handling
+
+			// Progress to next character
+			i++;
+		}
+		if (states.length > 0) {
+			throw new Error('GLSL function was not parsable');
+		}
+		return {
+			names,
+			types
+		};
+	}
+
+	static nativeFunctionReturnType(source) {
+		return typeMap[source.match(/int|float|vec[2-4]/)[0]];
+	}
 }
 
+const typeMap = {
+	int: 'Integer',
+	float: 'Number',
+	vec2: 'Array(2)',
+	vec3: 'Array(3)',
+	vec4: 'Array(4)',
+};
+
 module.exports = {
 	GLKernel
 };

src/backend/headless-gl/kernel.js

@@ -1,3 +1,4 @@
+// const exokit = require('exokit');
 const getContext = require('gl');
 const {
 	WebGLKernel

src/backend/kernel.js

@@ -28,6 +28,14 @@ class Kernel {
 		throw new Error(`"destroyContext" called on ${ this.name }`);
 	}
 
+	static nativeFunctionArgumentTypes() {
+		throw new Error(`"nativeFunctionArgumentTypes" called on ${ this.name }`);
+	}
+
+	static nativeFunctionReturnType() {
+		throw new Error(`"nativeFunctionReturnType" called on ${ this.name }`);
+	}
+
 	/**
 	 *
 	 * @param {string|object} source
@@ -109,7 +117,7 @@ class Kernel {
 
 		/**
 		 *
-		 * @type {INativeFunctionList[]}
+		 * @type {IGPUNativeFunction[]}
 		 */
 		this.nativeFunctions = null;