fix(glsl): multiple fixes

Author: MrTelanie

src/glsl/builtin.js

@@ -354,4 +354,24 @@ export class BuiltIn {
   fun(func) {
     return fun(func);
   }
+
+  equal(x, y) {
+    if (x === y) {
+      return true;
+    }
+    if (!x && !y) {
+      return true;
+    }
+    if (!x) {
+      return false;
+    }
+    if (x.equals) {
+      return x.equals(y);
+    }
+    return false;
+  }
+
+  notEqual(x, y) {
+    return !this.equal(x, y);
+  }
 }

src/glsl/index.js

@@ -83,10 +83,10 @@ function handleNode(node) {
     return updExp(node);
   }
   if (type === 'BreakStatement') {
-    return breSta(node);
+    return breSta();
   }
   if (type === 'ContinueStatement') {
-    return conSta(node);
+    return conSta();
   }
   if (type === 'ThrowStatement') {
     return thrSta(node);
@@ -352,7 +352,7 @@ function handleBody(body, tabCount = 0) {
     .join('\n');
 }
 
-export function buildGLSL(fun, { glsl = true, js = false, ast = false } = {}) {
+export function buildGLSL(fun, { glsl = true, js = undefined, ast = undefined } = {}) {
   // console.log('fun', fun.toString());
 
   let str;

src/index.js

@@ -56,6 +56,9 @@ export function fun(type, func) {
 }
 
 export function cls(classDesc) {
+  if (!(typeof classDesc === 'object')) {
+    return classDesc;
+  }
   const { constructor, ...proto } = classDesc;
 
   const types = {};

src/jstree.js

@@ -87,6 +87,8 @@ function extractType(node, target, options) {
   } else if (type === 'ArrowFunctionExpression') {
     target.newInit = handleParams(node, options);
     target.newInit.returnType = 'void';
+  } else {
+    target.newInit = node;
   }
   return target;
 }

test/glsl/index.js

@@ -1,5 +1,6 @@
+// @ts-nocheck
 import { assert } from 'chai';
-import { buildGLSL, sampler2D, joinGLSL } from '../../src/glsl';
+import { buildGLSL, joinGLSL } from '../../src/glsl';
 
 describe('glsl tests', () => {
   it('glsl hello world works.', () => {
@@ -65,7 +66,7 @@ float baz() {
         let bar = vec2((x = vec2(1.0, 2.0)) => {
           x = normalize(x);
           return vec2(x.x, y);
-        })
+        });
       });
     });
   });

test/glsl/sim.js

@@ -10,10 +10,6 @@ describe('glsl tests', () => {
     return MOCKED;
   }
 
-  function multiplySim(a, b) {
-    return a.x * b.x;
-  }
-
   class Vec2 {
     constructor(x = 0, y = x) {
       this.x = x;
@@ -48,11 +44,10 @@ describe('glsl tests', () => {
   }
 
   const jsOptions = {
-    multiply: multiplySim,
     Vec2, Vec3, Vec4,
     calc: calcSim
   };
-  buildGLSL(() => { return {} }, { glsl: false, js: jsOptions });
+  buildGLSL(() => { return {}; }, { glsl: false, js: jsOptions });
 
   it('works glsl vectors.', () => {
     const shader = ({ vec2 }) => {
@@ -336,7 +331,7 @@ vec4 bar(vec2 x) {
         return foo;
       });
       let bar = Foo((x = float()) => {
-        let foo = new Foo(boom(x))
+        let foo = new Foo(boom(x));
         return foo;
       });
       return { bar };

test/index.js

@@ -1,6 +1,12 @@
 import { assert } from 'chai';
 import { typ, fun, cls, string, number } from '../src';
 
+class Test {
+  get foo() {
+    return 'foo';
+  }
+}
+
 describe('type tests', () => {
 
 
@@ -9,10 +15,6 @@ describe('type tests', () => {
   // }
   // type bla = Parameters<(typeof f1)>;
 
-  class Test {
-
-  }
-
   it('should work with valid number declarations', () => {
     let nr1 = typ(number);
 
@@ -40,6 +42,7 @@ describe('type tests', () => {
   });
 
   it('should work with valid type declarations', () => {
+
     let h1 = typ(Test);
 
     assert.equal(h1, undefined);
@@ -57,19 +60,18 @@ describe('type tests', () => {
 
 describe('function tests', () => {
 
-  class Test {
 
-  }
 
   it('should work with valid function declarations', () => {
     const fn1 = fun(string, (p = typ(number)) => {
-      return `hallo ${p}`
+      return `hallo ${p}`;
     });
 
     const res1 = fn1(5);
     assert.equal(res1, 'hallo 5');
 
     assert.throws(() => {
+      // @ts-ignore
       fn1('string instead of number');
     });
   });
@@ -88,13 +90,16 @@ describe('function tests', () => {
 
   it('should not work with invalid function declarations', () => {
     assert.throws(() => {
+      // @ts-ignore
       const fn = fun((p = typ(number)) => {
-        return 'hello'
+        return 'hello';
       });
+      // @ts-ignore
       const bla = fn(5);
     });
 
     assert.throws(() => {
+      // @ts-ignore
       fun(string, () => {
         return 5;
       })();
@@ -113,14 +118,14 @@ describe('class tests', () => {
     let Test = cls({
       bar: number,
 
-      constructor: fun(function () {
+      constructor() {
         this.bar = 7;
-      }),
+      },
 
       foo: fun(number, function (str = typ(string)) {
         return parseFloat(str);
       })
-    })
+    });
 
     const test = new Test();
     const nr = test.foo('12');
@@ -129,32 +134,40 @@ describe('class tests', () => {
     assert.equal(nr, 12);
 
     assert.throws(() => {
+      // @ts-ignore
       test.foo(12);
     });
   });
 
   it('should not work with invalid class declarations', () => {
 
     assert.throws(() => {
-      let Test = cls({
-        bar: number,
+      const Test = cls({
+        bar: typ(number),
 
-        constructor: fun(function () {
-          this.bar = '12';
+        constructor() {
+          this.bar = 12;
+        },
+
+        foo: fun((blub = typ(number)) => {
+          // FIXME:
+          this.bar = `${blub}`;
         })
-      })
+      });
 
       const test = new Test();
+
+      test.foo(12);
     });
   });
 
   it('should work with valid class as type usage', () => {
     let Test = cls({
       bar: number,
 
-      constructor: fun(function () {
+      constructor() {
         this.bar = 7;
-      }),
+      },
 
       foo: fun(number, function (str = typ(string)) {
         return parseFloat(str);

test/jstree.js

@@ -268,6 +268,26 @@ describe('jstree implicit tests', () => {
     assert.equal(args[1].value, 2);
   });
 
+  it('extract init from implicit VariableDeclarator inside fun without getting the type', () => {
+    const node = parse(`let x = Vec2(() => {
+      let foo = x.yx;
+      return foo;
+    });`);
+
+    const [declarator] = node.body[0].declarations[0].init.body.body[0].declarations;
+    const { id, init: { type, object, property } } = declarator;
+
+    assert.equal(id.type, 'Identifier');
+    assert.equal(id.typeAnnotation, null);
+    assert.equal(id.name, 'foo');
+    assert.equal(id.qualifier, null);
+
+    assert.equal(type, 'MemberExpression');
+    assert.equal(object.name, 'x');
+    assert.equal(property.name, 'yx');
+
+  });
+
   it('extract type and init from implicit VariableDeclarator inside fun with multiple args', () => {
     const node = parse(`let x = String(() => {
       let foo = String(createString());