feat(jstree): type inference version 1

Author: MrTelanie

README.md

@@ -12,8 +12,7 @@ this libary is going to provide you a simple way of writing typed js code.
 this code can run and tested directly with js.
 but with types it can be transpiled to other languages, too.
 
-a type checker is in process, too. there will be a simple checking without type inference,
-this can be archived with typescript, but not at runtime.
+type inference is supported by type checker.
 
 | environment              | jsto... checker | typescript |
 | ------------------------ | :-------------: | :--------: |
@@ -25,9 +24,7 @@ this can be archived with typescript, but not at runtime.
 | ----------- | :-------------: | :--------: |
 | functions   |        ✓        |     ✓      |
 | arguments   |        ✓        |     ✓      |
-| prototypes  |        ✓        |     ✓      |
-| classes     |        ✗        |     ✓      |
-| attributes  |        ✓        |     ✓      |
+| classes     |        ✓        |     ✓      |
 | methods     |        ✓        |     ✓      |
 | variables   |        ✗        |     ✓      |
 | arithmetics |        ✓        |     ✗      |
@@ -37,7 +34,7 @@ this can be archived with typescript, but not at runtime.
 - [x] generate JSTree out of js
   - ESTree + type annotations
 - [ ] index.d.ts file with generics for typescript
-- [ ] type inference
+- [x] type inference
 - [ ] jstoGLSL transpiler great for performance
   - [x] generate valid glsl code
   - [ ] js transformations to glsl
@@ -53,17 +50,12 @@ this can be archived with typescript, but not at runtime.
   - [x] painting (slowly) to image buffer
   - [x] vector arithmetic (component wise) operator support
   - [x] partly matrix algebraic operator support
-  - [ ] multithreading
   - [ ] typesafety
 
 in future
 
-- [ ] jstoWASM transpiler great for headless rendering
-  - [ ] first iteration implement glsl behavior (vector and matrix)
-  inspired by <https://github.com/AssemblyScript/assemblyscript>
-  use decompiler to compare <https://v8.dev/blog/wasm-decompile>
-- [ ] jstoWASM simulator
-- [ ] what other languages do we need?
+- [ ] jstoWorker
+  - [ ] transpile js code without overhead of types and arithmetics
 
 # JSTree extended from ESTree
 

src/jstree.js

@@ -1,16 +1,19 @@
 import * as acorn from 'acorn';
 
-function handleParam(param) {
+function handleParam(param, options) {
   const { type, left, right } = param;
   if (type !== 'AssignmentPattern') {
     throw new Error(`handleParam() no type defined for ${param}`);
   }
   if (right.type === 'Identifier') {
     const typeAnnotation = right.name;
-    return { ...left, typeAnnotation };
+    const p = { ...left, typeAnnotation };
+    options.scope[left.name] = typeAnnotation;
+    return p;
   } else if (right.type === 'CallExpression') {
     param.left.typeAnnotation = right.callee.name;
     [param.right] = right.arguments;
+    options.scope[param.left.name] = param.left.typeAnnotation;
     return param;
   }
   throw new Error(`dont know ${right}`);
@@ -28,7 +31,7 @@ function handleParams(fn, options) {
       [param.right] = right.arguments;
     }
 
-    return handleParam(param);
+    return handleParam(param, options);
   });
 
   let { body } = fn;
@@ -41,8 +44,22 @@ function handleParams(fn, options) {
   return { ...fn, body, params };
 }
 
+function extractFromScope(scope, name, args) {
+  if (!scope) {
+    return name;
+  }
+  const sc = scope[name];
+  if (!sc) {
+    return name;
+  }
+  if (typeof sc === 'function') {
+    return sc.apply(undefined, args.map(({ name }) => scope[name]));
+  }
+  return sc;
+}
+
 function extractType(node, target, options) {
-  const { qualifiers, integer, float, string, boolean } = options;
+  const { qualifiers, integer, float, string, boolean, scope, operators } = options;
   const { type, name, callee, arguments: args, value, raw } = node;
 
   if (type === 'CallExpression' || type === 'NewExpression') {
@@ -73,13 +90,16 @@ function extractType(node, target, options) {
     } else {
 
       const typeAnnotation = callee.name;
-
-
-      target.typeAnnotation = typeAnnotation;
+      target.typeAnnotation = extractFromScope(scope, typeAnnotation, args);
       target.newInit = node;
     }
   } else if (type === 'Identifier') {
-    target.typeAnnotation = name;
+    if (scope && scope[name]) {
+      target.typeAnnotation = extractFromScope(scope, name, []);
+      target.newInit = node;
+    } else {
+      target.typeAnnotation = name;
+    }
   } else if (type === 'NumericLiteral' || type === 'Literal') {
     if (typeof value === 'number') {
       if (raw.indexOf('.') < 0) {
@@ -113,8 +133,14 @@ function extractType(node, target, options) {
       value: operator === '-' ? -value : value
     };
   } else if (type === 'ArrowFunctionExpression') {
-    target.newInit = handleParams(node, options);
+    const newScope = { ...scope };
+    target.newInit = handleParams(node, { ...options, scope: newScope });
     target.newInit.returnType = 'void';
+  } else if (operators && type === 'BinaryExpression') {
+    const left = extractFromScope(scope, node.left.name, []);
+    const right = extractFromScope(scope, node.right.name, []);
+    target.typeAnnotation = operators(left, node.operator, right);
+    target.newInit = node;
   } else {
     target.newInit = node;
   }
@@ -160,6 +186,9 @@ function handleNode(node, options) {
     const { newInit = null, typeAnnotation = null, qualifier = null } = extractType(init, {}, options);
     node.id = { ...node.id, typeAnnotation, qualifier };
     node.init = newInit;
+
+    options.scope[node.id.name] = typeAnnotation;
+
     return node;
   }
 
@@ -169,10 +198,10 @@ function handleNode(node, options) {
   return node;
 }
 
-export function parse(input, { qualifiers = [], float = 'Number', integer = float, string = 'String', boolean = 'Boolean', locations = false, ranges = false, ...options } = {}) {
+export function parse(input, { qualifiers = [], float = 'Number', integer = float, string = 'String', boolean = 'Boolean', locations = false, ranges = false, operators, scope = {}, ...options } = {}) {
   // TODO: use onToken !!!!
   const ast = acorn.parse(input, { ...options, locations, ranges, ecmaVersion: 6 });
-  const node = handleNode(ast, { qualifiers, integer, float, string, boolean });
+  const node = handleNode(ast, { qualifiers, integer, float, string, boolean, scope, operators });
 
   return node;
 }

test/jstree.js

@@ -411,7 +411,7 @@ describe('jstree autodetect primitive tests', () => {
     assert.equal(init.raw, 'true');
   });
 
-  it('works with cls', () => {
+  it('works with class', () => {
 
     const node = parse(`
       let MyType = cls({
@@ -435,4 +435,95 @@ describe('jstree autodetect primitive tests', () => {
     assert.equal(vNormal.typeAnnotation, 'Vec4');
     assert.equal(vNormal.key.name, 'vNormal');
   });
+
+  it('auto detects type for inline variables', () => {
+    const node = parse(`let x = Vec2((y = Vec2()) => {
+      let foo = y;
+      return foo;
+    });`);
+
+    const [declarator] = node.body[0].declarations[0].init.body.body[0].declarations;
+    const { id, init } = declarator;
+
+    assert.equal(id.type, 'Identifier');
+    assert.equal(id.typeAnnotation, 'Vec2');
+    assert.equal(id.name, 'foo');
+    assert.equal(id.qualifier, null);
+
+    assert.equal(init.type, 'Identifier');
+    assert.equal(init.name, 'y');
+
+  });
+
+  it('auto detects type from builtin function', () => {
+    const node = parse(`let x = Vec2((y = Vec2()) => {
+      let foo = normalize(y);
+      return foo;
+    });`, { scope: {
+      normalize: (arg) => arg
+    } });
+
+    const [declarator] = node.body[0].declarations[0].init.body.body[0].declarations;
+    const { id, init } = declarator;
+
+    assert.equal(id.type, 'Identifier');
+    assert.equal(id.typeAnnotation, 'Vec2');
+    assert.equal(id.name, 'foo');
+    assert.equal(id.qualifier, null);
+
+    assert.equal(init.type, 'CallExpression');
+    assert.equal(init.callee.name, 'normalize');
+
+  });
+
+  it('auto detects type from mathematical calculations', () => {
+    const node = parse(`let x = Vec2((y = Vec2(), z = Mat3()) => {
+      let foo = z * z;
+      let bar = y * foo;
+      return foo;
+    });`, { operators: (left, operator, right) => {
+      if (left === 'Mat3' && right === 'Mat3') {
+        return 'Mat3';
+      } if (left === 'Vec2' && right === 'Mat3') {
+        return 'Vec2';
+      }
+    } });
+
+    const [decl1] = node.body[0].declarations[0].init.body.body[0].declarations;
+    const [decl2] = node.body[0].declarations[0].init.body.body[1].declarations;
+
+    const { id: id1 } = decl1;
+    const { id: id2 } = decl2;
+
+    assert.equal(id1.type, 'Identifier');
+    assert.equal(id1.typeAnnotation, 'Mat3');
+    assert.equal(id1.name, 'foo');
+    assert.equal(id1.qualifier, null);
+
+    assert.equal(id2.type, 'Identifier');
+    assert.equal(id2.typeAnnotation, 'Vec2');
+    assert.equal(id2.name, 'bar');
+    assert.equal(id2.qualifier, null);
+
+  });
+
+  it('explicit type priority over auto detects type', () => {
+    const node = parse(`let x = Vec2((y = Vec2()) => {
+      let foo = Vec3(normalize(y));
+      return foo;
+    });`, { scope: {
+      normalize: (arg) => arg
+    } });
+
+    const [declarator] = node.body[0].declarations[0].init.body.body[0].declarations;
+    const { id, init } = declarator;
+
+    assert.equal(id.type, 'Identifier');
+    assert.equal(id.typeAnnotation, 'Vec3');
+    assert.equal(id.name, 'foo');
+    assert.equal(id.qualifier, null);
+
+    assert.equal(init.type, 'CallExpression');
+    assert.equal(init.callee.name, 'Vec3');
+  });
 });