spider-src 0.1.5

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

@@ -0,0 +1,161 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function NullPropagatingExpression(left, right) {
+    Node.call(this);
+    this.type = "NullPropagatingExpression";
+    this.computed = false;
+    this.object = left;
+    this.object.parent = this;
+    this.property = right;
+    this.property.parent = this;
+  }
+  NullPropagatingExpression.prototype = Object.create(Node);
+  NullPropagatingExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var context = this.getContext();
+    var childType = this.object.type;
+    this.object = this.object.codegen();
+    this.property = this.property.codegen(false);
+    if (typeof this.object.hasCallExpression === "function" ? this.object.hasCallExpression() : void 0) {
+      var id = {
+        "type": "Identifier",
+        "name": NullPropagatingExpression.getNextObjectName(),
+        "__member_expression": {
+          "type": "MemberExpression",
+          "object": this.object,
+          "property": this.property,
+          "computed": false
+        }
+      };
+      context.node.body.splice(context.position + (NullPropagatingExpression.nullPropagatingIndex - 1), 0, {
+        "type": "VariableDeclaration",
+        "declarations": [{
+          "type": "VariableDeclarator",
+          "id": id,
+          "init": this.object
+        }],
+        "kind": "let",
+        "codeGenerated": true
+      });
+      this.object = id;
+    }
+    var condition;
+    if (childType !== "NullPropagatingExpression") {
+      condition = {
+        "type": "BinaryExpression",
+        "operator": "!==",
+        "left": this.object,
+        "right": {
+          "type": "Literal",
+          "value": null,
+          "raw": "null"
+        },
+        "__member_expression": {
+          "type": "MemberExpression",
+          "object": this.object,
+          "property": this.property,
+          "computed": false
+        },
+        "__first_object": this.object
+      };
+    } else {
+      condition = {
+        "type": "LogicalExpression",
+        "operator": "&&",
+        "left": this.object,
+        "right": {
+          "type": "BinaryExpression",
+          "operator": "!==",
+          "left": {
+            "type": "MemberExpression",
+            "object": this.object.__member_expression.object,
+            "property": this.object.__member_expression.property,
+            "computed": false
+          },
+          "right": {
+            "type": "Literal",
+            "value": null,
+            "raw": "null"
+          }
+        },
+        "__member_expression": {
+          "type": "MemberExpression",
+          "object": this.object.__member_expression,
+          "property": this.property,
+          "computed": false
+        },
+        "__first_object": this.object.__first_object
+      };
+    }
+    if ((typeof this.parent !== "undefined" && this.parent !== null ? this.parent.type : void 0) === "NullPropagatingExpression") {
+      return condition;
+    }
+    condition = {
+      "type": "LogicalExpression",
+      "operator": "&&",
+      "left": {
+        "type": "BinaryExpression",
+        "operator": "!==",
+        "left": {
+          "type": "UnaryExpression",
+          "operator": "typeof",
+          "argument": this.object.__first_object == null ? this.object : this.object.__first_object
+        },
+        "right": {
+          "type": "Literal",
+          "value": "undefined",
+          "raw": "\"undefined\""
+        }
+      },
+      "right": condition
+    };
+    condition = {
+      "type": "ConditionalExpression",
+      "test": condition,
+      "consequent": {
+        "type": "MemberExpression",
+        "object": !!(this.object.type === "Identifier") || !this.object.__member_expression ? this.object : this.object.__member_expression,
+        "property": this.property,
+        "computed": false
+      },
+      "alternate": {
+        "type": "UnaryExpression",
+        "operator": "void",
+        "argument": {
+          "type": "Literal",
+          "value": 0,
+          "raw": "0"
+        },
+        "prefix": true
+      },
+      "__null_propagating": true
+    };
+    return condition;
+  };
+  NullPropagatingExpression.prototype.hasCallExpression = function() {
+    return true;
+  };
+  NullPropagatingExpression.getNextObjectName = function() {
+    if (!(typeof this.nullPropagatingIndex !== "undefined" && this.nullPropagatingIndex !== null)) {
+      this.nullPropagatingIndex = 0;
+      this.definedObjectNames = [];
+    }
+    var name = "nullPropagating" + this.nullPropagatingIndex++;
+    this.definedObjectNames.push(name);
+    return name;
+  };
+  NullPropagatingExpression.isObjectNameDefined = function(name) {
+    return this.definedObjectNames.indexOf(name) !== -1;
+  };
+  NullPropagatingExpression.resetVariableNames = function() {
+    this.nullPropagatingIndex = 0;
+    this.definedObjectNames = [];
+  };
+  exports.NullPropagatingExpression = NullPropagatingExpression;
+  return {};
+});
+
+//# sourceMappingURL=NullPropagatingExpression.map

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

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

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

@@ -0,0 +1,49 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function ObjectPattern(properties) {
+    Node.call(this);
+    this.type = "ObjectPattern";
+    this.properties = properties;
+    for (var $__0 = this.properties[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var property = $__1.value;
+      {
+        property.parent = this;
+      }
+    }
+  }
+  ObjectPattern.prototype = Object.create(Node);
+  ObjectPattern.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var context = this.getContext().node;
+    var i = 0;
+    for (var $__0 = this.properties[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var property = $__1.value;
+      {
+        this.properties[i] = property.codegen();
+        if (typeof property.value !== "undefined" && property.value !== null) {
+          if (property.value.type === "Identifier") {
+            context.defineIdentifier(property.value);
+          }
+        } else {
+          if (property.key.type === "Identifier") {
+            context.defineIdentifier(property.key);
+          }
+        }
+        i++;
+      }
+    }
+    return this;
+  };
+  ObjectPattern.prototype.hasCallExpression = function() {
+    return true;
+  };
+  exports.ObjectPattern = ObjectPattern;
+  return {};
+});
+
+//# sourceMappingURL=ObjectPattern.map

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

@@ -0,0 +1,157 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function RangeMemberExpression(object, range) {
+    Node.call(this);
+    this.type = "RangeMemberExpression";
+    this.object = object;
+    this.object.parent = this;
+    this.range = range;
+    this.range.parent = this;
+  }
+  RangeMemberExpression.prototype = Object.create(Node);
+  RangeMemberExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var isNumber = function(n) {
+      return !isNaN(parseFloat(n)) && !!isFinite(n);
+    };
+    if (!!(this.parent.type === "AssignmentExpression") && !!(this.parent.left === this)) {
+      this.parent.type = "CallExpression";
+      this.parent.callee = {
+        "type": "MemberExpression",
+        "computed": false,
+        "object": {
+          "type": "MemberExpression",
+          "computed": false,
+          "object": {
+            "type": "ArrayExpression",
+            "elements": []
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "splice"
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "apply"
+        }
+      };
+      var to;
+      var start = this.range.start ? this.range.start.codegen() : {
+        "type": "Literal",
+        "value": 0
+      };
+      if (typeof this.range.to !== "undefined" && this.range.to !== null) {
+        if (!!isNumber(start.value) && !!isNumber(this.range.to.value)) {
+          to = {
+            "type": "Literal",
+            "value": this.range.to.value - start.value + (this.range.operator === ".." ? 1 : 0)
+          };
+        } else {
+          to = this.range.to.codegen();
+          if (start.value !== 0) {
+            to = {
+              "type": "BinaryExpression",
+              "operator": "-",
+              "left": to,
+              "right": start
+            };
+          }
+          if (this.range.operator === "..") {
+            to = {
+              "type": "BinaryExpression",
+              "operator": "+",
+              "left": to,
+              "right": {
+                "type": "Literal",
+                "value": 1
+              }
+            };
+          }
+        }
+      } else {
+        to = {
+          "type": "Literal",
+          "value": 9000000000,
+          "raw": "9e9"
+        };
+      }
+      Object.defineProperty(this.parent, "arguments", {
+        value: [this.object.codegen(), {
+          "type": "CallExpression",
+          "callee": {
+            "type": "MemberExpression",
+            "computed": false,
+            "object": {
+              "type": "ArrayExpression",
+              "elements": [start, to]
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "concat"
+            }
+          },
+          "arguments": [this.parent.right]
+        }],
+        enumerable: true
+      });
+    } else {
+      this.type = "CallExpression";
+      this.callee = {
+        "type": "MemberExpression",
+        "computed": false,
+        "object": this.object.codegen(),
+        "property": {
+          "type": "Identifier",
+          "name": "slice"
+        }
+      };
+      var args = [];
+      if (!(typeof this.range.start !== "undefined" && this.range.start !== null)) {
+        args.push({
+          "type": "Literal",
+          "value": 0
+        });
+      } else {
+        args.push(this.range.start.codegen());
+      }
+      if (typeof this.range.to !== "undefined" && this.range.to !== null) {
+        if (this.range.operator === "...") {
+          args.push(this.range.to.codegen());
+        } else {
+          if (!!this.range.to.value && !!isNumber(this.range.to.value)) {
+            args.push({
+              "type": "Literal",
+              "value": this.range.to.value + 1
+            });
+          } else {
+            args.push({
+              "type": "BinaryExpression",
+              "operator": "+",
+              "left": this.range.to.codegen(),
+              "right": {
+                "type": "Literal",
+                "value": 1
+              }
+            });
+          }
+        }
+      }
+      Object.defineProperty(this, "arguments", {
+        value: args,
+        enumerable: true
+      });
+    }
+    return this;
+  };
+  RangeMemberExpression.prototype.hasCallExpression = function() {
+    return true;
+  };
+  exports.RangeMemberExpression = RangeMemberExpression;
+  return {};
+});
+
+//# sourceMappingURL=RangeMemberExpression.map

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

@@ -0,0 +1,48 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function SplatExpression(expression) {
+    Node.call(this);
+    this.type = "SplatExpression";
+    this.expression = expression;
+    this.expression.parent = this;
+  }
+  SplatExpression.prototype = Object.create(Node);
+  SplatExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.expression = this.expression.codegen();
+    return {
+      "type": "CallExpression",
+      "callee": {
+        "type": "MemberExpression",
+        "computed": false,
+        "object": {
+          "type": "MemberExpression",
+          "computed": false,
+          "object": {
+            "type": "ArrayExpression",
+            "elements": []
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "slice"
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "call"
+        }
+      },
+      "arguments": [this.expression]
+    };
+  };
+  SplatExpression.prototype.hasCallExpression = function() {
+    return true;
+  };
+  exports.SplatExpression = SplatExpression;
+  return {};
+});
+
+//# sourceMappingURL=SplatExpression.map

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

@@ -0,0 +1,170 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  var extend = require("util")._extend;
+  function SuperExpression() {
+    Node.call(this);
+    this.type = "SuperExpression";
+  }
+  SuperExpression.prototype = Object.create(Node);
+  SuperExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    if (this.parent.type === "NullPropagatingExpression") {
+      Node.getErrorManager().error({
+        type: "InvalidSuperReference",
+        message: "cannot refer to super before the ?. operator",
+        loc: this.loc
+      });
+      return {type: "ThisExpression"};
+    }
+    if (this.parent.type !== "MemberExpression") {
+      Node.getErrorManager().error({
+        type: "InvalidUsageForSuper",
+        message: "invalid usage of super keyword",
+        loc: this.loc
+      });
+      return {type: "ThisExpression"};
+    }
+    var parentNode = this;
+    var node = this;
+    while (!!(!!node && !node.inheritsFrom) && !!(!!(node.type !== "AssignmentExpression") || !!(!!(!node.left.property || !!(node.left.property.name !== "prototype")) && !!(!node.left.object.property || !!(node.left.object.property.name !== "prototype"))))) {
+      parentNode = node;
+      node = node.parent;
+    }
+    if (!node) {
+      Node.getErrorManager().error({
+        type: "InvalidContextForSuper",
+        message: "invalid context for super keyword",
+        loc: this.loc
+      });
+      return {type: "ThisExpression"};
+    }
+    var addSelf = function(context) {
+      var selfId = {
+        "type": "Identifier",
+        "name": "_self",
+        "codeGenerated": "true"
+      };
+      if (!context.node.__isSelfDefined) {
+        context.node.body.splice(0, 0, {
+          "type": "VariableDeclaration",
+          "declarations": [{
+            "type": "VariableDeclarator",
+            "id": selfId,
+            "init": {type: "ThisExpression"}
+          }],
+          "kind": "let"
+        });
+        context.node.__isSelfDefined = true;
+      }
+      return selfId;
+    };
+    var mutateCallExpression = function(id, parent, selfNode) {
+      selfNode.codeGenerated = true;
+      parent.object = id;
+      parent.property = Object.create({
+        "codeGenerated": "true",
+        "type": "Identifier",
+        "name": "call"
+      });
+      parent.parent.arguments.splice(0, 0, selfNode);
+    };
+    if (node.type === "AssignmentExpression") {
+      var identifier = node.left.object;
+      var context;
+      if (node.left.property.name !== "prototype") {
+        identifier = identifier.object;
+        context = {node: node.right.body};
+      } else {
+        if (node.right.type !== "ObjectExpression") {
+          Node.getErrorManager().error({
+            type: "InvalidUsageForSuper",
+            message: "invalid usage of super keyword",
+            loc: this.loc
+          });
+          return {type: "ThisExpression"};
+        }
+        var contextNode = this;
+        while (!!(typeof contextNode.parent !== "undefined" && contextNode.parent !== null) && !!(contextNode.parent !== node.right)) {
+          contextNode = contextNode.parent;
+        }
+        if (!!((typeof contextNode !== "undefined" && contextNode !== null ? contextNode.type : void 0) !== "Property") || !!((typeof contextNode !== "undefined" && (contextNode !== null && contextNode.value !== null) ? contextNode.value.type : void 0) !== "FunctionExpression")) {
+          Node.getErrorManager().error({
+            type: "InvalidUsageForSuper",
+            message: "invalid usage of super keyword",
+            loc: this.loc
+          });
+          return {type: "ThisExpression"};
+        }
+        context = {node: contextNode.value.body};
+      }
+      var selfNode;
+      if (context.node === this.getContext().node) {
+        selfNode = {type: "ThisExpression"};
+      } else {
+        selfNode = addSelf(context);
+      }
+      if (this.parent.parent.type === "CallExpression") {
+        var memberExpression = {
+          type: "MemberExpression",
+          computed: false,
+          object: {
+            type: "MemberExpression",
+            computed: false,
+            object: this.parent.getDefinedIdentifier(identifier.name).parent.inheritsFrom.callee,
+            property: {
+              type: "Identifier",
+              name: "prototype"
+            }
+          },
+          property: this.parent.parent.callee.property
+        };
+        mutateCallExpression(memberExpression, this.parent, selfNode);
+        return memberExpression;
+      }
+      return selfNode;
+    }
+    var superContext = parentNode.getContext();
+    var lastObject = this.parent;
+    while (lastObject.object.type === "MemberExpression") {
+      lastObject = lastObject.object;
+    }
+    lastObject.object = {type: "ThisExpression"};
+    var id = {
+      "type": "Identifier",
+      "name": "_" + this.parent.property.name
+    };
+    if (!this.parent.isIdentifierDefined(id.name)) {
+      superContext.node.body.splice(superContext.position, 0, {
+        "codeGenerated": "true",
+        "type": "VariableDeclaration",
+        "declarations": [{
+          "type": "VariableDeclarator",
+          "id": id,
+          "init": extend({}, lastObject)
+        }],
+        "kind": "let"
+      });
+      superContext.node.defineIdentifier(id);
+    }
+    if (this.parent.parent.type === "CallExpression") {
+      mutateCallExpression(id, this.parent, addSelf(superContext));
+    } else {
+      this.parent.type = "Identifier";
+      Object.defineProperty(this.parent, "name", {
+        value: id.name,
+        enumerable: true
+      });
+    }
+    return id;
+  };
+  SuperExpression.prototype.hasCallExpression = function() {
+    return false;
+  };
+  exports.SuperExpression = SuperExpression;
+  return {};
+});
+
+//# sourceMappingURL=SuperExpression.map

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

@@ -0,0 +1,22 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function ThisExpression() {
+    Node.call(this);
+    this.type = "ThisExpression";
+  }
+  ThisExpression.prototype = Object.create(Node);
+  ThisExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    return this;
+  };
+  ThisExpression.prototype.hasCallExpression = function() {
+    return false;
+  };
+  exports.ThisExpression = ThisExpression;
+  return {};
+});
+
+//# sourceMappingURL=ThisExpression.map