@dacely/toildefender 0.1.4 → 0.1.6

package/processors/methods.js

@@ -18,7 +18,14 @@ function veilmark$sliceArguments(args, num) {
     return Array.prototype.slice.call(args, num);
 }
 
-function veilmark$toObject(schema, values) {
+var veilmark$objectKeys = {};
+
+function veilmark$toObject(cacheKey, schema, values) {
+    if (values === undefined && Array.isArray(cacheKey)) {
+        values = schema;
+        schema = cacheKey;
+        cacheKey = "";
+    }
     var obj = {};
     if (values === undefined) {
         for (var legacy = 0; legacy < schema.length; legacy += 2) {
@@ -26,20 +33,45 @@ function veilmark$toObject(schema, values) {
         }
         return obj;
     }
+    var decoded = cacheKey ? veilmark$objectKeys[cacheKey] : null;
+    if (decoded) {
+        for (var cached = 0; cached < decoded.length; cached += 1) {
+            obj[decoded[cached]] = values[cached];
+        }
+        return obj;
+    }
     var cursor = 2;
     var salt = schema[0];
     var count = schema[1];
+    var keys = new Array(count);
     for (var i = 0; i < count; i += 1) {
         var len = schema[cursor++] ^ ((salt + i * 131) & 65535);
         var key = "";
         for (var j = 0; j < len; j += 1) {
             key += String.fromCharCode(schema[cursor++] ^ ((salt + i * 257 + j * 17) & 65535));
         }
+        keys[i] = key;
         obj[key] = values[i];
     }
+    if (cacheKey) {
+        veilmark$objectKeys[cacheKey] = keys;
+    }
     return obj;
 }
 
+function veilmark$objectWithoutKeys(source, excluded) {
+    var target = {};
+    if (source == null) {
+        return target;
+    }
+    for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key) && excluded.indexOf(key) < 0) {
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+
 function veilmark$decodeString(arr) {
     return arr.map(function(x) { return String.fromCharCode(x & ~0 >>> 16) + String.fromCharCode(x >> 16); }).join("");
 }
@@ -94,6 +126,74 @@ function anonymousMethodName(node) {
     return node[ANON_METHOD_ID];
 }
 
+function functionDeclarationName(node) {
+    assert.equal(node.type, "FunctionDeclaration");
+
+    if (!node.id || !node.id.name) {
+        if (!node[ANON_METHOD_ID]) {
+            Object.defineProperty(node, ANON_METHOD_ID, {
+                configurable: false,
+                enumerable: false,
+                value: `veilmark$anon$${utils.hash(node)}`
+            });
+        }
+        node.id = { type: "Identifier", name: node[ANON_METHOD_ID] };
+    }
+
+    return node.id.name;
+}
+
+function isReferenceIdentifier(node, stack) {
+    var parentFrame = stack[1];
+    if (!parentFrame) {
+        return true;
+    }
+
+    var parent = parentFrame.node;
+    var key = parentFrame.key;
+
+    if ((parent.type == "FunctionDeclaration" || parent.type == "FunctionExpression") && (key == "id" || key == "params")) {
+        return false;
+    }
+    if (parent.type == "VariableDeclarator" && key == "id") {
+        return false;
+    }
+    if (parent.type == "CatchClause" && key == "param") {
+        return false;
+    }
+    if ((parent.type == "MemberExpression" || parent.type == "Property") && key == "property" && parent.computed === false) {
+        return false;
+    }
+    if (parent.type == "Property" && key == "key" && parent.computed === false) {
+        return false;
+    }
+    if ((parent.type == "LabeledStatement" || parent.type == "BreakStatement" || parent.type == "ContinueStatement") && key == "label") {
+        return false;
+    }
+
+    return true;
+}
+
+function renameFunctionExpressionSelfReferences(node, name) {
+    assert.equal(node.type, "FunctionExpression");
+
+    if (!node.id || !node.id.name || node.id.name == name) {
+        return;
+    }
+
+    var oldName = node.id.name;
+    traverser.traverse(node.body, [], (child, stack) => {
+        if (child.type == "Identifier" && child.name == oldName && isReferenceIdentifier(child, stack)) {
+            child.name = name;
+        }
+        return child;
+    });
+}
+
+function isClassMethodFunction(stack) {
+    return stack.some(frame => frame.node.type == "MethodDefinition" || frame.node.type == "ClassBody");
+}
+
 /**
  * Get index of argument in function.
  * @param {Function} method Function
@@ -129,8 +229,7 @@ module.exports = class Methods {
         assert.ok(estest.isNode(ast));
         
         var code = esprima.parse(METHODS_INJECT);
-        code.type = "BlockStatement";
-        ast.body.splice(0, 0, code);
+        ast.body.splice.apply(ast.body, [0, 0].concat(code.body));
     }
     
     /**
@@ -200,8 +299,8 @@ module.exports = class Methods {
         
         traverser.traverse(ast, [], (node, stack) => {
             if (node.type == "FunctionDeclaration") { // Statement
-                methods.push(node.id.name);
-            } else if (node.type == "FunctionExpression") { // Expression
+                methods.push(functionDeclarationName(node));
+            } else if (node.type == "FunctionExpression" && !isClassMethodFunction(stack)) { // Expression
                 methods.push(anonymousMethodName(node));
             }
             
@@ -223,10 +322,12 @@ module.exports = class Methods {
         
         traverser.traverse(ast, [], (node, stack) => {
             if (node.type == "FunctionDeclaration") { // Statement
+                functionDeclarationName(node);
                 methods.push(node);
                 return { type: "ExpressionStatement", expression: createMethodStub(node.id) }; // This is not ideal
-            } else if (node.type == "FunctionExpression") { // Expression
+            } else if (node.type == "FunctionExpression" && !isClassMethodFunction(stack)) { // Expression
                 var id = anonymousMethodName(node);
+                renameFunctionExpressionSelfReferences(node, id);
                 // Merge into old object instead of creating a new one to preserve object references
                 methods.push(_.assign(node, {
                     type: "FunctionDeclaration",
@@ -293,11 +394,12 @@ module.exports = class Methods {
         
         traverser.traverse(ast, [], (node, stack) => {
             if (node.type == "Identifier" && methodEntryExitPoints[node.name] && methodEntryExitPoints[node.name].entry) {
+                var dispatcher = methodEntryExitPoints[node.name].dispatcher || "main";
                 return {
                     type: "CallExpression",
                     callee: { type: "Identifier", name: "veilmark$bind" },
                     arguments: [
-                        { type: "Identifier", name: "main" },
+                        { type: "Identifier", name: dispatcher },
                         { type: "Identifier", name: methodEntryExitPoints[node.name].entry }
                     ]
                 };