fix: #556 followup fix, not all declared types need to be integers

Author: robertleeplummerjr

dist/gpu-browser-core.js

@@ -4,13 +4,13 @@
  *
  * GPU Accelerated JavaScript
  *
- * @version 2.4.3
- * @date Fri Dec 27 2019 16:33:11 GMT-0500 (Eastern Standard Time)
+ * @version 2.4.4
+ * @date Thu Jan 02 2020 12:26:36 GMT-0500 (Eastern Standard Time)
  *
  * @license MIT
  * The MIT License
  *
- * Copyright (c) 2019 gpu.js Team
+ * Copyright (c) 2020 gpu.js Team
  */(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.GPU = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
 
 },{}],2:[function(require,module,exports){
@@ -2596,12 +2596,12 @@ class FunctionNode {
     this.functions = functions;
     for (let i = 0; i < declarations.length; i++) {
       const declaration = declarations[i];
-      const { ast, context, name, origin, forceInteger, assignable } = declaration;
+      const { ast, context, name, origin, inForLoopInit, inForLoopTest, assignable } = declaration;
       const { init } = ast;
       const dependencies = this.getDependencies(init);
       let valueType = null;
 
-      if (forceInteger) {
+      if (inForLoopInit && inForLoopTest) {
         valueType = 'Integer';
       } else {
         if (init) {
@@ -2626,6 +2626,8 @@ class FunctionNode {
       }
       this.declarations.push({
         valueType,
+        inForLoopInit,
+        inForLoopTest,
         dependencies,
         isSafe: this.isSafeDependencies(dependencies),
         ast,
@@ -3833,6 +3835,12 @@ function last(array) {
   return array.length > 0 ? array[array.length - 1] : null;
 }
 
+const states = {
+  trackIdentifiers: 'trackIdentifiers',
+  memberExpression: 'memberExpression',
+  inForLoopInit: 'inForLoopInit'
+};
+
 class FunctionTracer {
   constructor(ast) {
     this.runningContexts = [];
@@ -3843,11 +3851,32 @@ class FunctionTracer {
     this.identifiers = [];
     this.functions = [];
     this.returnStatements = [];
-    this.inLoopInit = false;
+    this.trackedIdentifiers = null;
+    this.states = [];
     this.newFunctionContext();
     this.scan(ast);
   }
 
+  isState(state) {
+    return this.states[this.states.length - 1] === state;
+  }
+
+  hasState(state) {
+    return this.states.indexOf(state) > -1;
+  }
+
+  pushState(state) {
+    this.states.push(state);
+  }
+
+  popState(state) {
+    if (this.isState(state)) {
+      this.states.pop();
+    } else {
+      throw new Error(`Cannot pop the non-active state "${state}"`);
+    }
+  }
+
   get currentFunctionContext() {
     return last(this.functionContexts);
   }
@@ -3857,13 +3886,13 @@ class FunctionTracer {
   }
 
   newFunctionContext() {
-    const newContext = { '@contextType': 'var' };
+    const newContext = { '@contextType': 'function' };
     this.contexts.push(newContext);
     this.functionContexts.push(newContext);
   }
 
   newContext(run) {
-    const newContext = Object.assign({ '@contextType': 'var/const/let' }, this.currentContext);
+    const newContext = Object.assign({ '@contextType': 'const/let' }, this.currentContext);
     this.contexts.push(newContext);
     this.runningContexts.push(newContext);
     run();
@@ -3873,6 +3902,7 @@ class FunctionTracer {
       newContext[p] = currentFunctionContext[p];
     }
     this.runningContexts.pop();
+    return newContext;
   }
 
   useFunctionContext(run) {
@@ -3882,6 +3912,15 @@ class FunctionTracer {
     this.runningContexts.pop();
   }
 
+  getIdentifiers(run) {
+    const trackedIdentifiers = this.trackedIdentifiers = [];
+    this.pushState(states.trackIdentifiers);
+    run();
+    this.trackedIdentifiers = null;
+    this.popState(states.trackIdentifiers);
+    return trackedIdentifiers;
+  }
+
   scan(ast) {
     if (!ast) return;
     if (Array.isArray(ast)) {
@@ -3892,7 +3931,9 @@ class FunctionTracer {
     }
     switch (ast.type) {
       case 'Program':
-        this.scan(ast.body);
+        this.useFunctionContext(() => {
+          this.scan(ast.body);
+        });
         break;
       case 'BlockStatement':
         this.newContext(() => {
@@ -3925,13 +3966,15 @@ class FunctionTracer {
         break;
       case 'VariableDeclarator':
         const { currentContext } = this;
+        const inForLoopInit = this.hasState(states.inForLoopInit);
         const declaration = {
           ast: ast,
           context: currentContext,
           name: ast.id.name,
           origin: 'declaration',
-          forceInteger: this.inLoopInit,
-          assignable: currentContext === this.currentFunctionContext || (!this.inLoopInit && !currentContext.hasOwnProperty(ast.id.name)),
+          inForLoopInit,
+          inForLoopTest: null,
+          assignable: currentContext === this.currentFunctionContext || (!inForLoopInit && !currentContext.hasOwnProperty(ast.id.name)),
         };
         currentContext[ast.id.name] = declaration;
         this.declarations.push(declaration);
@@ -3952,16 +3995,30 @@ class FunctionTracer {
         if (ast.alternate) this.scan(ast.alternate);
         break;
       case 'ForStatement':
-        this.newContext(() => {
-          this.inLoopInit = true;
+        let testIdentifiers;
+        const context = this.newContext(() => {
+          testIdentifiers = this.getIdentifiers(() => {
+            this.scan(ast.test);
+          });
+
+          this.pushState(states.inForLoopInit);
           this.scan(ast.init);
-          this.inLoopInit = false;
-          this.scan(ast.test);
+          this.popState(states.inForLoopInit);
+
           this.scan(ast.update);
           this.newContext(() => {
             this.scan(ast.body);
           });
         });
+
+        if (testIdentifiers) {
+          for (const p in context) {
+            if (p === '@contextType') continue;
+            if (testIdentifiers.indexOf(p) > -1) {
+              context[p].inForLoopTest = true;
+            }
+          }
+        }
         break;
       case 'DoWhileStatement':
       case 'WhileStatement':
@@ -3971,6 +4028,9 @@ class FunctionTracer {
         });
         break;
       case 'Identifier':
+        if (this.isState(states.trackIdentifiers)) {
+          this.trackedIdentifiers.push(ast.name);
+        }
         this.identifiers.push({
           context: this.currentContext,
           ast,
@@ -3981,8 +4041,10 @@ class FunctionTracer {
         this.scan(ast.argument);
         break;
       case 'MemberExpression':
+        this.pushState(states.memberExpression);
         this.scan(ast.object);
         this.scan(ast.property);
+        this.popState(states.memberExpression);
         break;
       case 'ExpressionStatement':
         this.scan(ast.expression);
@@ -7489,7 +7551,11 @@ class WebGLFunctionNode extends FunctionNode {
       const actualType = this.getType(declaration.init);
       let type = inForLoopInit ? 'Integer' : actualType;
       if (type === 'LiteralInteger') {
-        type = 'Number';
+        if (info.inForLoopInit && info.inForLoopTest) {
+          type = 'Integer';
+        } else {
+          type = 'Number';
+        }
       }
       const markupType = typeMap[type];
       if (!markupType) {
@@ -7530,6 +7596,8 @@ class WebGLFunctionNode extends FunctionNode {
             this.astGeneric(init, declarationResult);
             declarationResult.push(')');
           }
+        } else if (actualType === 'LiteralInteger' && type === 'Integer') {
+          this.castLiteralToInteger(init, declarationResult);
         } else {
           this.astGeneric(init, declarationResult);
         }
@@ -13031,7 +13099,8 @@ class GPU {
   createKernelMap() {
     let fn;
     let settings;
-    if (typeof arguments[arguments.length - 2] === 'function') {
+    const argument2Type = typeof arguments[arguments.length - 2];
+    if (argument2Type === 'function' || argument2Type === 'string') {
       fn = arguments[arguments.length - 2];
       settings = arguments[arguments.length - 1];
     } else {
@@ -14339,6 +14408,14 @@ const utils = {
       visualKernelB.canvas,
       visualKernelA.canvas,
     ];
+  },
+
+  getMinifySafeName: (fn) => {
+    const ast = acorn.parse(fn.toString());
+    if (!ast.body || !ast.body[0] || !ast.body[0].expression || !ast.body[0].expression.body || !ast.body[0].expression.body.name) {
+      throw new Error('Unrecognized function type.  Please use `() => yourFunctionVariableHere`');
+    }
+    return ast.body[0].expression.body.name;
   }
 };