feat(glsl): autodetect type calling function

Author: MrTelanie

src/glsl/index.js

@@ -337,7 +337,7 @@ function handleAlloc(init, typeAnnotation, name) {
       case 'vec4':
       case 'mat3':
       case 'mat4':
-        if (init.arguments.length) {
+        if (init.arguments.length || typeAnnotation !== init.callee.name) {
           allocation = ` = ${handleNode(init)}`;
         } else {
           allocation = '';

src/jstree.js

@@ -187,7 +187,11 @@ function handleNode(node, options) {
     node.id = { ...node.id, typeAnnotation, qualifier };
     node.init = newInit;
 
-    options.scope[node.id.name] = typeAnnotation;
+    if (typeAnnotation) {
+      options.scope[node.id.name] = typeAnnotation;
+    } else if (newInit.returnType) {
+      options.scope[node.id.name] = newInit.returnType;
+    }
 
     return node;
   }

test/glsl/index.js

@@ -362,4 +362,51 @@ void main() {
 
     assert.equal(glsl.trim(), expected.trim());
   });
+
+  it('works with glsl autodetect type calling function', () => {
+    const { glsl } = buildGLSL(() => {
+      let baz = float(() => {
+        let foo = float(makeFloat());
+        return foo;
+      });
+
+      let bar = baz();
+    });
+
+    const expected = `
+float baz() {
+\tfloat foo = float(makeFloat());
+\treturn foo;
+}
+float bar = baz();
+    `;
+
+    assert.equal(glsl.trim(), expected.trim());
+  });
+
+//   it('works with joining chunks auto detection', () => {
+//     const one = buildGLSL(() => {
+//       let foo = uniform(vec2);
+//     });
+//
+//     const two = buildGLSL(() => {
+//       let bar = vec2(() => {
+//         let res = foo;
+//         return res;
+//       });
+//     });
+//
+//     const { glsl } = joinGLSL([one, two]);
+//
+//     const expected = `
+// uniform vec2 foo;
+// vec2 bar() {
+// \tvec2 res = foo;
+// \treturn res;
+// }
+//     `;
+//
+//
+//     assert.equal(glsl.trim(), expected.trim());
+//   });
 });

test/jstree.js

@@ -455,6 +455,28 @@ describe('jstree autodetect primitive tests', () => {
 
   });
 
+  it('auto detects return type of other functions for inline variables', () => {
+    const node = parse(`
+    let bar = float(() => {
+      return 5.0;
+    });
+
+    let x = Vec2((y = Vec2()) => {
+      let foo = bar();
+      return vec2(foo);
+    });
+    `);
+
+    const [declarator] = node.body[1].declarations[0].init.body.body[0].declarations;
+    const { id } = declarator;
+
+    assert.equal(id.type, 'Identifier');
+    assert.equal(id.typeAnnotation, 'float');
+    assert.equal(id.name, 'foo');
+    assert.equal(id.qualifier, null);
+
+  });
+
   it('auto detects type from builtin function', () => {
     const node = parse(`let x = Vec2((y = Vec2()) => {
       let foo = normalize(y);