spider-src 0.1.5

data/lib/spider-src/support/spider/lib/ast/expressions/FunctionExpression.js

@@ -0,0 +1,157 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node,
+      Parameter = module.require("../Parameter").Parameter,
+      CallExpression = module.require("../expressions/CallExpression").CallExpression;
+  function FunctionExpression(id, params, body, inheritsFrom, operator) {
+    Node.call(this);
+    if (operator === "=>") {
+      this.type = "ArrowFunctionExpression";
+    } else {
+      this.type = "FunctionExpression";
+    }
+    this.defaults = [];
+    this.rest = null;
+    this.generator = false;
+    this.expression = false;
+    this.operator = operator;
+    this.id = id;
+    if (typeof this.id !== "undefined" && this.id !== null) {
+      this.id.parent = this;
+    }
+    this.body = body;
+    this.params = params;
+    body.parent = this;
+    for (var $__0 = params[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var param = $__1.value;
+      {
+        param.parent = this;
+      }
+    }
+    this.inheritsFrom = inheritsFrom;
+    if (typeof this.inheritsFrom !== "undefined" && this.inheritsFrom !== null) {
+      this.inheritsFrom.parent = this;
+    }
+    if (this.body.type !== "BlockStatement") {
+      this.autoBlock = true;
+      this.body = {
+        "type": "BlockStatement",
+        "body": [{
+          "type": "ReturnStatement",
+          "argument": this.body
+        }]
+      };
+      var self = this;
+      this.getContext = function() {
+        return {
+          node: self.body,
+          position: -1
+        };
+      };
+    }
+  }
+  FunctionExpression.prototype = Object.create(Node);
+  FunctionExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    if (typeof this.id !== "undefined" && this.id !== null) {
+      this.id = this.id.codegen(false);
+    }
+    Parameter.generateFunctionBody(this, this.params, this.body, this.defaults);
+    if (this.autoBlock) {
+      this.body.body[0].argument = this.body.body[this.body.body.length - 1].argument.codegen();
+    } else {
+      this.body = this.body.codegen();
+    }
+    if (typeof this.inheritsFrom !== "undefined" && this.inheritsFrom !== null) {
+      if (this.inheritsFrom.type !== "CallExpression") {
+        this.inheritsFrom = new CallExpression(this.inheritsFrom, []);
+        this.inheritsFrom.parent = this;
+      }
+      var context = this.getContext();
+      this.body.body.splice(0, 0, {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "CallExpression",
+          "callee": {
+            "type": "MemberExpression",
+            "computed": false,
+            "object": this.inheritsFrom.callee,
+            "property": {
+              "type": "Identifier",
+              "name": "call"
+            }
+          },
+          "arguments": [{"type": "ThisExpression"}].concat(this.inheritsFrom.arguments)
+        }
+      });
+      var id = {
+        "type": "Identifier",
+        "name": FunctionExpression.getNextVariableName()
+      };
+      context.node.body.splice(context.position, 0, {
+        "type": "VariableDeclaration",
+        "declarations": [{
+          "type": "VariableDeclarator",
+          "id": id,
+          "init": this
+        }],
+        "kind": "let",
+        "codeGenerated": true
+      });
+      context.node.body.splice(context.position + 1, 0, {
+        "type": "ExpressionStatement",
+        "codeGenerated": "true",
+        "expression": {
+          "type": "AssignmentExpression",
+          "operator": "=",
+          "left": {
+            "type": "MemberExpression",
+            "computed": false,
+            "object": id,
+            "property": {
+              "type": "Identifier",
+              "name": "prototype"
+            }
+          },
+          "right": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "MemberExpression",
+              "computed": false,
+              "object": {
+                "type": "Identifier",
+                "name": "Object"
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "create"
+              }
+            },
+            "arguments": [this.inheritsFrom.callee]
+          }
+        }
+      });
+      return id;
+    }
+    return this;
+  };
+  FunctionExpression.prototype.hasCallExpression = function() {
+    return true;
+  };
+  FunctionExpression.getNextVariableName = function() {
+    if (!(typeof this.functionExpressionIndex !== "undefined" && this.functionExpressionIndex !== null)) {
+      this.functionExpressionIndex = 0;
+    }
+    return "functionExpression" + this.functionExpressionIndex++;
+  };
+  FunctionExpression.resetVariableNames = function() {
+    this.functionExpressionIndex = 0;
+  };
+  exports.FunctionExpression = FunctionExpression;
+  return {};
+});
+
+//# sourceMappingURL=FunctionExpression.map

data/lib/spider-src/support/spider/lib/ast/expressions/InExpression.js

@@ -0,0 +1,99 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function InExpression(left, right) {
+    Node.call(this);
+    this.type = "InExpression";
+    this.left = left;
+    this.left.parent = this;
+    this.right = right;
+    this.right.parent = this;
+  }
+  InExpression.prototype = Object.create(Node);
+  InExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.left = this.left.codegen();
+    this.right = this.right.codegen();
+    if (typeof this.right.hasCallExpression === "function" ? this.right.hasCallExpression() : void 0) {
+      var context = this.getContext();
+      var id = {
+        "type": "Identifier",
+        "name": InExpression.getNextVariableName(),
+        "codeGenerated": true
+      };
+      context.node.body.splice(context.position + (InExpression.inExpressionIndex - 2), 0, {
+        "type": "VariableDeclaration",
+        "declarations": [{
+          "type": "VariableDeclarator",
+          "id": id,
+          "init": this.right
+        }],
+        "kind": "let",
+        "codeGenerated": true
+      });
+      this.right = id;
+    }
+    this.type = "ConditionalExpression";
+    this.test = {
+      "type": "BinaryExpression",
+      "operator": "instanceof",
+      "left": this.right,
+      "right": {
+        "type": "Identifier",
+        "name": "Array"
+      }
+    };
+    this.consequent = {
+      "type": "BinaryExpression",
+      "operator": "!==",
+      "left": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "MemberExpression",
+          "computed": false,
+          "object": this.right,
+          "property": {
+            "type": "Identifier",
+            "name": "indexOf"
+          }
+        },
+        "arguments": [this.left]
+      },
+      "right": {
+        "type": "UnaryExpression",
+        "operator": "-",
+        "argument": {
+          "type": "Literal",
+          "value": 1,
+          "raw": "1"
+        },
+        "prefix": true
+      }
+    };
+    this.alternate = {
+      "type": "BinaryExpression",
+      "operator": "in",
+      "left": this.left,
+      "right": this.right
+    };
+    return this;
+  };
+  InExpression.prototype.hasCallExpression = function() {
+    return true;
+  };
+  InExpression.getNextVariableName = function() {
+    if (!(typeof this.inExpressionIndex !== "undefined" && this.inExpressionIndex !== null)) {
+      this.inExpressionIndex = 0;
+    }
+    return "inExpression" + this.inExpressionIndex++;
+  };
+  InExpression.resetVariableNames = function() {
+    this.inExpressionIndex = 0;
+  };
+  exports.InExpression = InExpression;
+  return {};
+});
+
+//# sourceMappingURL=InExpression.map

data/lib/spider-src/support/spider/lib/ast/expressions/LogicalExpression.js

@@ -0,0 +1,50 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function LogicalExpression(left, operator, right) {
+    Node.call(this);
+    this.type = "LogicalExpression";
+    this.operator = operator;
+    if (this.operator === "and") {
+      this.operator = "&&";
+    } else if (this.operator === "or") {
+      this.operator = "||";
+    }
+    this.left = left;
+    this.left.parent = this;
+    this.right = right;
+    this.right.parent = this;
+  }
+  LogicalExpression.prototype = Object.create(Node);
+  LogicalExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var enforceBooleanExpression = function(o) {
+      if (!!(o.type === "UnaryExpression") && !!(o.operator === "!")) {
+        return o;
+      }
+      return {
+        "type": "UnaryExpression",
+        "operator": "!",
+        "argument": {
+          "type": "UnaryExpression",
+          "operator": "!",
+          "argument": o,
+          "prefix": true
+        },
+        "prefix": true
+      };
+    };
+    this.left = enforceBooleanExpression(this.left.codegen());
+    this.right = enforceBooleanExpression(this.right.codegen());
+    return this;
+  };
+  LogicalExpression.prototype.hasCallExpression = function() {
+    return !!(typeof this.left !== "undefined" && this.left !== null ? this.left.hasCallExpression() : void 0) || !!(typeof this.right !== "undefined" && this.right !== null ? this.right.hasCallExpression() : void 0);
+  };
+  exports.LogicalExpression = LogicalExpression;
+  return {};
+});
+
+//# sourceMappingURL=LogicalExpression.map

data/lib/spider-src/support/spider/lib/ast/expressions/MemberExpression.js

@@ -0,0 +1,43 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function MemberExpression(left, right, computed) {
+    Node.call(this);
+    this.type = "MemberExpression";
+    this.computed = computed;
+    this.object = left;
+    this.object.parent = this;
+    this.property = right;
+    this.property.parent = this;
+  }
+  MemberExpression.prototype = Object.create(Node);
+  MemberExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var objectType = this.object.type;
+    this.object = this.object.codegen();
+    if (!this.property.codeGenerated) {
+      this.property = this.property.codegen(false);
+    }
+    if (!!(this.object.type === "ConditionalExpression") && !!(!!(!!(!!(objectType === "NullPropagatingExpression") || !!(objectType === "MemberExpression")) || !!(objectType === "CallExpression")) || !!(objectType === "NullCheckCallExpression"))) {
+      this.type = this.object.type;
+      this.test = this.object.test;
+      this.alternate = this.object.alternate;
+      this.consequent = {
+        type: "MemberExpression",
+        object: this.object.consequent,
+        property: this.property,
+        computed: this.computed
+      };
+    }
+    return this;
+  };
+  MemberExpression.prototype.hasCallExpression = function() {
+    return !!(!!this.object.__null_propagating || !!(typeof this.object !== "undefined" && this.object !== null && typeof this.object.hasCallExpression === "function" ? this.object.hasCallExpression() : void 0)) || !!(typeof this.property !== "undefined" && this.property !== null ? this.property.hasCallExpression() : void 0);
+  };
+  exports.MemberExpression = MemberExpression;
+  return {};
+});
+
+//# sourceMappingURL=MemberExpression.map

data/lib/spider-src/support/spider/lib/ast/expressions/NewExpression.js

@@ -0,0 +1,46 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function NewExpression(callee, args) {
+    Node.call(this);
+    this.type = "NewExpression";
+    this.callee = callee;
+    this.callee.parent = this;
+    Object.defineProperty(this, "arguments", {
+      value: args,
+      enumerable: true
+    });
+    for (var $__0 = args[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var arg = $__1.value;
+      {
+        arg.parent = this;
+      }
+    }
+  }
+  NewExpression.prototype = Object.create(Node);
+  NewExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.callee = this.callee.codegen();
+    var args = this.arguments;
+    var i = 0;
+    for (var $__0 = args[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var arg = $__1.value;
+      {
+        args[i] = arg.codegen();
+        i++;
+      }
+    }
+    return this;
+  };
+  NewExpression.prototype.hasCallExpression = function() {
+    return true;
+  };
+  exports.NewExpression = NewExpression;
+  return {};
+});
+
+//# sourceMappingURL=NewExpression.map

data/lib/spider-src/support/spider/lib/ast/expressions/NullCheckCallExpression.js

@@ -0,0 +1,132 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node,
+      CallExpression = module.require("./CallExpression").CallExpression;
+  function NullCheckCallExpression(callee, args) {
+    Node.call(this);
+    this.type = "NullCheckCallExpression";
+    this.callee = callee;
+    this.callee.parent = this;
+    this.args = args;
+    for (var $__0 = args[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var arg = $__1.value;
+      {
+        arg.parent = this;
+      }
+    }
+  }
+  NullCheckCallExpression.prototype = Object.create(Node);
+  NullCheckCallExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var calleeType = this.callee.type;
+    this.callee = this.callee.codegen();
+    var args = this.args;
+    var i = 0;
+    for (var $__0 = args[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var arg = $__1.value;
+      {
+        var isSplat = args[i].type === "SplatExpression";
+        args[i] = arg.codegen();
+        args[i].codeGenerated = true;
+        if (isSplat) {
+          args[i].__splat = true;
+        }
+        i++;
+      }
+    }
+    if (typeof this.callee.hasCallExpression === "function" ? this.callee.hasCallExpression() : void 0) {
+      var context = this.getContext();
+      var id = {
+        "type": "Identifier",
+        "name": NullCheckCallExpression.getNextVariableName(),
+        "codeGenerated": true
+      };
+      context.node.body.splice(context.position + (NullCheckCallExpression.nullCheckIndex - 2), 0, {
+        "type": "VariableDeclaration",
+        "declarations": [{
+          "type": "VariableDeclarator",
+          "id": id,
+          "init": this.callee
+        }],
+        "kind": "let",
+        "codeGenerated": true
+      });
+      this.callee = id;
+    }
+    var test = {
+      "type": "BinaryExpression",
+      "operator": "===",
+      "left": {
+        "type": "UnaryExpression",
+        "operator": "typeof",
+        "argument": this.callee,
+        "prefix": true
+      },
+      "right": {
+        "type": "Literal",
+        "value": "function",
+        "raw": "\"function\""
+      }
+    };
+    var argument = test.left.argument;
+    if (calleeType === "NullPropagatingExpression") {
+      argument = argument.consequent;
+      test.left.argument = argument;
+      test = {
+        "type": "LogicalExpression",
+        "operator": "&&",
+        "left": this.callee.test,
+        "right": test
+      };
+    }
+    argument.codeGenerated = true;
+    var consequent = new CallExpression(argument, args).codegen();
+    if (this.parent.type === "ExpressionStatement") {
+      this.parent.type = "IfStatement";
+      this.parent.test = test;
+      this.parent.consequent = {
+        type: "BlockStatement",
+        body: [{
+          type: "ExpressionStatement",
+          expression: consequent
+        }]
+      };
+      this.parent.alternate = null;
+    } else {
+      this.type = "ConditionalExpression";
+      this.test = test;
+      this.consequent = consequent;
+      this.alternate = {
+        "type": "UnaryExpression",
+        "operator": "void",
+        "argument": {
+          "type": "Literal",
+          "value": 0,
+          "raw": "0"
+        },
+        "prefix": true
+      };
+    }
+    return this;
+  };
+  NullCheckCallExpression.prototype.hasCallExpression = function() {
+    return true;
+  };
+  NullCheckCallExpression.getNextVariableName = function() {
+    if (!(typeof this.nullCheckIndex !== "undefined" && this.nullCheckIndex !== null)) {
+      this.nullCheckIndex = 0;
+    }
+    return "nullCheck" + this.nullCheckIndex++;
+  };
+  NullCheckCallExpression.resetVariableNames = function() {
+    this.nullCheckIndex = 0;
+  };
+  exports.NullCheckCallExpression = NullCheckCallExpression;
+  return {};
+});
+
+//# sourceMappingURL=NullCheckCallExpression.map

data/lib/spider-src/support/spider/lib/ast/expressions/NullCoalescingExpression.js

@@ -0,0 +1,114 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function NullCoalescingExpression(left, right) {
+    Node.call(this);
+    this.type = "NullCoalescingExpression";
+    this.left = left;
+    this.left.parent = this;
+    this.right = right;
+    this.right.parent = this;
+  }
+  NullCoalescingExpression.prototype = Object.create(Node);
+  NullCoalescingExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var leftType = this.left.type;
+    this.left = this.left.codegen();
+    this.right = this.right.codegen();
+    var context = this.getContext();
+    var addUndefinedCheck = true;
+    if (!!(!!(leftType === "NullPropagatingExpression") || !!(leftType === "NullCoalescingExpression")) || !!(typeof this.left.hasCallExpression === "function" ? this.left.hasCallExpression() : void 0)) {
+      var id = {
+        "type": "Identifier",
+        "name": NullCoalescingExpression.getNextLeftName()
+      };
+      context.node.body.splice(context.position, 0, {
+        "type": "VariableDeclaration",
+        "declarations": [{
+          "type": "VariableDeclarator",
+          "id": id,
+          "init": this.left
+        }],
+        "kind": "let",
+        "codeGenerated": true
+      });
+      this.left = id;
+      addUndefinedCheck = false;
+    }
+    var test = {
+      "type": "BinaryExpression",
+      "operator": "==",
+      "left": this.left,
+      "right": {
+        "type": "Literal",
+        "value": null,
+        "raw": "null"
+      }
+    };
+    if (this.left.type !== "Identifier") {
+      addUndefinedCheck = false;
+    }
+    if (addUndefinedCheck) {
+      test = {
+        "type": "LogicalExpression",
+        "operator": "||",
+        "left": {
+          "type": "BinaryExpression",
+          "operator": "===",
+          "left": {
+            "type": "UnaryExpression",
+            "operator": "typeof",
+            "argument": this.left,
+            "prefix": true
+          },
+          "right": {
+            "type": "Literal",
+            "value": "undefined",
+            "raw": "'undefined'"
+          }
+        },
+        "right": test
+      };
+    }
+    if ((typeof this.parent !== "undefined" && this.parent !== null ? this.parent.type : void 0) === "ExpressionStatement") {
+      if (!this.right.hasCallExpression()) {
+        this.parent.type = "EmptyStatement";
+        return this;
+      }
+      this.parent.type = "IfStatement";
+      this.parent.test = test;
+      this.parent.consequent = {
+        "type": "BlockStatement",
+        "body": [{
+          "type": "ExpressionStatement",
+          "expression": this.right
+        }]
+      };
+    } else {
+      return {
+        "type": "ConditionalExpression",
+        "test": test,
+        "consequent": this.right,
+        "alternate": this.left
+      };
+    }
+  };
+  NullCoalescingExpression.prototype.hasCallExpression = function() {
+    return !!(typeof this.left !== "undefined" && this.left !== null ? this.left.hasCallExpression() : void 0) || !!(typeof this.right !== "undefined" && this.right !== null ? this.right.hasCallExpression() : void 0);
+  };
+  NullCoalescingExpression.getNextLeftName = function() {
+    if (!(typeof this.nullCoalescingIndex !== "undefined" && this.nullCoalescingIndex !== null)) {
+      this.nullCoalescingIndex = 0;
+    }
+    return "nullCoalescing" + this.nullCoalescingIndex++;
+  };
+  NullCoalescingExpression.resetVariableNames = function() {
+    this.nullCoalescingIndex = 0;
+  };
+  exports.NullCoalescingExpression = NullCoalescingExpression;
+  return {};
+});
+
+//# sourceMappingURL=NullCoalescingExpression.map