spider-src 0.1.5

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

@@ -0,0 +1,29 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function AssignmentExpression(left, operator, right) {
+    Node.call(this);
+    this.type = "AssignmentExpression";
+    this.operator = operator;
+    this.left = left;
+    this.left.parent = this;
+    this.right = right;
+    this.right.parent = this;
+  }
+  AssignmentExpression.prototype = Object.create(Node);
+  AssignmentExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.left = this.left.codegen();
+    this.right = this.right.codegen();
+    return this;
+  };
+  AssignmentExpression.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.AssignmentExpression = AssignmentExpression;
+  return {};
+});
+
+//# sourceMappingURL=AssignmentExpression.map

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

@@ -0,0 +1,104 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function BinaryExpression(left, operator, right) {
+    Node.call(this);
+    this.type = "BinaryExpression";
+    this.operator = operator;
+    this.left = left;
+    this.left.parent = this;
+    this.right = right;
+    this.right.parent = this;
+  }
+  BinaryExpression.prototype = Object.create(Node);
+  BinaryExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var isRelational = function(operator) {
+      var inExpression0 = [">", ">=", "<", ">="];
+      return inExpression0 instanceof Array ? inExpression0.indexOf(operator) !== -1 : operator in inExpression0;
+    };
+    if (!!isRelational(this.operator) && !!isRelational(this.left.operator)) {
+      this.type = "LogicalExpression";
+      this.right = {
+        "type": "BinaryExpression",
+        "operator": this.operator,
+        "left": this.left.right,
+        "right": this.right.codegen()
+      };
+      this.left = this.left.codegen();
+      this.operator = "&&";
+    } else {
+      this.left = this.left.codegen();
+      this.right = this.right.codegen();
+      if (this.operator === "==") {
+        this.operator = "===";
+      } else if (this.operator === "!=") {
+        this.operator = "!==";
+      } else if (this.operator === "**") {
+        this.type = "CallExpression";
+        this.callee = {
+          "type": "MemberExpression",
+          "computed": false,
+          "object": {
+            "type": "Identifier",
+            "name": "Math"
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "pow"
+          }
+        };
+        Object.defineProperty(this, "arguments", {
+          value: [this.left, this.right],
+          enumerable: true
+        });
+      } else if (this.operator === "#") {
+        this.type = "CallExpression";
+        this.callee = {
+          "type": "MemberExpression",
+          "computed": false,
+          "object": {
+            "type": "Identifier",
+            "name": "Math"
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "floor"
+          }
+        };
+        Object.defineProperty(this, "arguments", {
+          value: [{
+            "type": "BinaryExpression",
+            "operator": "/",
+            "left": this.left,
+            "right": this.right
+          }],
+          enumerable: true
+        });
+      } else if (this.operator === "%%") {
+        this.operator = "%";
+        this.left = {
+          "type": "BinaryExpression",
+          "operator": "+",
+          "left": {
+            "type": "BinaryExpression",
+            "operator": "%",
+            "left": this.left,
+            "right": this.right
+          },
+          "right": this.right
+        };
+      }
+    }
+    return this;
+  };
+  BinaryExpression.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.BinaryExpression = BinaryExpression;
+  return {};
+});
+
+//# sourceMappingURL=BinaryExpression.map

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

@@ -0,0 +1,139 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function CallExpression(callee, args) {
+    Node.call(this);
+    this.type = "CallExpression";
+    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;
+      }
+    }
+  }
+  CallExpression.prototype = Object.create(Node);
+  CallExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var calleeType = this.callee.type;
+    if (!this.callee.codeGenerated) {
+      this.callee = this.callee.codegen();
+    }
+    var args = this.arguments;
+    var splatPositions = [];
+    var i = 0;
+    for (var $__0 = args[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var arg = $__1.value;
+      {
+        if (!!(args[i].type === "SplatExpression") || !!args[i].__splat) {
+          splatPositions.push(i);
+        }
+        if (!args[i].codeGenerated) {
+          args[i] = arg.codegen();
+        }
+        i++;
+      }
+    }
+    if (splatPositions.length > 0) {
+      var argsClone = args.slice(0);
+      args.length = 0;
+      args.push({
+        "type": "Literal",
+        "value": null
+      });
+      if (argsClone.length === 1) {
+        args.push(argsClone[0].arguments[0]);
+      } else {
+        args.push({
+          "type": "CallExpression",
+          "callee": {
+            "type": "MemberExpression",
+            "computed": false,
+            "object": splatPositions[0] === 0 ? argsClone[0] : {
+              "type": "ArrayExpression",
+              "elements": argsClone.slice(0, splatPositions[0])
+            },
+            "property": {
+              "type": "Identifier",
+              "name": "concat"
+            }
+          },
+          "arguments": argsClone.slice(splatPositions[0] === 0 ? 1 : splatPositions[0]).map(function(arg, i) {
+            if (splatPositions.indexOf(i + (splatPositions[0] === 0 ? 1 : splatPositions[0])) !== -1) {
+              return arg;
+            }
+            return {
+              "type": "ArrayExpression",
+              "elements": [arg]
+            };
+          })
+        });
+      }
+    }
+    if (!!(this.callee.type === "ConditionalExpression") && !!(!!(calleeType === "NullPropagatingExpression") || !!(calleeType === "MemberExpression"))) {
+      var parent = this.parent;
+      var consequent = {
+        type: "CallExpression",
+        callee: this.callee.consequent,
+        arguments: this.arguments
+      };
+      if (splatPositions.length > 0) {
+        this.callee.consequent = {
+          "type": "MemberExpression",
+          "computed": false,
+          "object": this.callee.consequent,
+          "property": {
+            "type": "Identifier",
+            "name": "apply"
+          }
+        };
+      }
+      if (parent.type === "ExpressionStatement") {
+        parent.type = "IfStatement";
+        parent.test = this.callee.test;
+        parent.consequent = {
+          type: "BlockStatement",
+          body: [{
+            type: "ExpressionStatement",
+            expression: consequent
+          }]
+        };
+        parent.alternate = null;
+      } else {
+        this.type = "ConditionalExpression";
+        this.test = this.callee.test;
+        this.consequent = consequent;
+        this.alternate = this.callee.alternate;
+      }
+    } else {
+      if (splatPositions.length > 0) {
+        this.callee = {
+          "type": "MemberExpression",
+          "computed": false,
+          "object": this.callee,
+          "property": {
+            "type": "Identifier",
+            "name": "apply"
+          }
+        };
+      }
+    }
+    return this;
+  };
+  CallExpression.prototype.hasCallExpression = function() {
+    return true;
+  };
+  exports.CallExpression = CallExpression;
+  return {};
+});
+
+//# sourceMappingURL=CallExpression.map

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

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

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

@@ -0,0 +1,102 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node,
+      CallExpression = module.require("./CallExpression").CallExpression;
+  function CurryCallExpression(callee, args) {
+    Node.call(this);
+    this.type = "CurryCallExpression";
+    this.callee = callee;
+    this.args = args;
+  }
+  CurryCallExpression.prototype = Object.create(Node);
+  CurryCallExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var call = new CallExpression(this.callee, this.args);
+    call.parent = this;
+    call = call.codegen();
+    if (!!(call.type !== "CallExpression") || !!(!!((typeof call !== "undefined" && call !== null ? call.callee.type : void 0) === "MemberExpression") && !!((typeof call !== "undefined" && call !== null ? call.callee.property.name : void 0) === "apply"))) {
+      Node.getErrorManager().error({
+        type: "InvalidFunctionCurrying",
+        message: "currying functions with existential operator or splats is disallowed.",
+        loc: this.loc
+      });
+    }
+    this.type = "FunctionExpression";
+    this.id = null;
+    this.params = [];
+    this.defaults = [];
+    this.body = {
+      "type": "BlockStatement",
+      "body": [{
+        "type": "ReturnStatement",
+        "argument": {
+          "type": "CallExpression",
+          "callee": {
+            "type": "MemberExpression",
+            "computed": false,
+            "object": call.callee,
+            "property": {
+              "type": "Identifier",
+              "name": "apply"
+            }
+          },
+          "arguments": [{"type": "ThisExpression"}, {
+            "type": "CallExpression",
+            "callee": {
+              "type": "MemberExpression",
+              "computed": false,
+              "object": {
+                "type": "ArrayExpression",
+                "elements": call.arguments
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "concat"
+              }
+            },
+            "arguments": [{
+              "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": "apply"
+                }
+              },
+              "arguments": [{
+                "type": "Identifier",
+                "name": "arguments"
+              }]
+            }]
+          }]
+        }
+      }]
+    };
+    this.rest = null;
+    this.generator = false;
+    this.expression = false;
+    return this;
+  };
+  CurryCallExpression.prototype.hasCallExpression = function() {
+    return true;
+  };
+  exports.CurryCallExpression = CurryCallExpression;
+  return {};
+});
+
+//# sourceMappingURL=CurryCallExpression.map

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

@@ -0,0 +1,83 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function ExistentialExpression(argument) {
+    Node.call(this);
+    this.type = "ExistentialExpression";
+    this.argument = argument;
+    this.argument.parent = this;
+  }
+  ExistentialExpression.prototype = Object.create(Node);
+  ExistentialExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var nullCoalescing0 = typeof this.argument.hasCallExpression === "function" ? this.argument.hasCallExpression() : void 0;
+    var isArgumentCallExpression = nullCoalescing0 == null ? false : nullCoalescing0;
+    this.argument = this.argument.codegen();
+    if (isArgumentCallExpression) {
+      var context = this.getContext();
+      var id = {
+        "type": "Identifier",
+        "name": ExistentialExpression.getNextVariableName()
+      };
+      context.node.body.splice(context.position + (ExistentialExpression.existentialIndex - 2), 0, {
+        "type": "VariableDeclaration",
+        "declarations": [{
+          "type": "VariableDeclarator",
+          "id": id,
+          "init": this.argument
+        }],
+        "kind": "let",
+        "codeGenerated": true
+      });
+      this.argument = id;
+    }
+    var nullCheck = {
+      "type": "BinaryExpression",
+      "operator": "!==",
+      "left": this.argument,
+      "right": {
+        "type": "Literal",
+        "value": null,
+        "raw": "null"
+      }
+    };
+    this.type = "LogicalExpression";
+    this.operator = "&&";
+    this.left = {
+      "type": "BinaryExpression",
+      "operator": "!==",
+      "left": {
+        "type": "UnaryExpression",
+        "operator": "typeof",
+        "argument": this.argument,
+        "prefix": true
+      },
+      "right": {
+        "type": "Literal",
+        "value": "undefined",
+        "raw": "'undefined'"
+      }
+    };
+    this.right = nullCheck;
+    return this;
+  };
+  ExistentialExpression.prototype.hasCallExpression = function() {
+    var nullCoalescing1 = typeof this.argument !== "undefined" && this.argument !== null && typeof this.argument.hasCallExpression === "function" ? this.argument.hasCallExpression() : void 0;
+    return nullCoalescing1 == null ? false : nullCoalescing1;
+  };
+  ExistentialExpression.getNextVariableName = function() {
+    if (!(typeof this.existentialIndex !== "undefined" && this.existentialIndex !== null)) {
+      this.existentialIndex = 0;
+    }
+    return "existential" + this.existentialIndex++;
+  };
+  ExistentialExpression.resetVariableNames = function() {
+    this.existentialIndex = 0;
+  };
+  exports.ExistentialExpression = ExistentialExpression;
+  return {};
+});
+
+//# sourceMappingURL=ExistentialExpression.map

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

@@ -0,0 +1,116 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node,
+      ForInStatement = module.require("../statements/ForInStatement").ForInStatement,
+      BlockStatement = module.require("../statements/BlockStatement").BlockStatement;
+  function ForInExpression(expression, item, index, array, condition) {
+    Node.call(this);
+    this.type = "ForInExpression";
+    this.expression = expression;
+    this.expression.parent = this;
+    this.item = item;
+    this.item.parent = this;
+    this.index = index;
+    if (typeof this.index !== "undefined" && this.index !== null) {
+      this.index.parent = this;
+    }
+    this.array = array;
+    this.array.parent = this;
+    this.condition = condition;
+    if (typeof this.condition !== "undefined" && this.condition !== null) {
+      this.condition.parent = this;
+    }
+  }
+  ForInExpression.prototype = Object.create(Node);
+  ForInExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.defineIdentifier(this.item);
+    if (typeof this.index !== "undefined" && this.index !== null) {
+      this.defineIdentifier(this.index);
+    }
+    var id = {
+      "type": "Identifier",
+      "name": ForInExpression.getNextVariableName(),
+      "codeGenerated": true
+    };
+    var pushStatement = {
+      "type": "ExpressionStatement",
+      "codeGenerated": true,
+      "expression": {
+        "type": "CallExpression",
+        "callee": {
+          "type": "MemberExpression",
+          "computed": false,
+          "object": id,
+          "property": {
+            "type": "Identifier",
+            "name": "push"
+          }
+        },
+        "arguments": [this.expression.codegen()]
+      }
+    };
+    if (typeof this.condition !== "undefined" && this.condition !== null) {
+      pushStatement = {
+        "type": "IfStatement",
+        "codeGenerated": true,
+        "test": this.condition.codegen(),
+        "consequent": {
+          "type": "BlockStatement",
+          "body": [pushStatement]
+        },
+        "alternate": null
+      };
+    }
+    var forInStatement = new ForInStatement(this.item, this.index, this.array, new BlockStatement([pushStatement]));
+    var fnBlock = new BlockStatement([{
+      "type": "VariableDeclaration",
+      "declarations": [{
+        "type": "VariableDeclarator",
+        "id": id,
+        "init": {
+          "type": "ArrayExpression",
+          "elements": []
+        }
+      }],
+      "kind": "let",
+      "codeGenerated": true
+    }, forInStatement, {
+      "type": "ReturnStatement",
+      "codeGenerated": true,
+      "argument": id
+    }]);
+    forInStatement.parent = fnBlock;
+    this.type = "CallExpression";
+    this.callee = {
+      "type": "FunctionExpression",
+      "id": null,
+      "params": [],
+      "defaults": [],
+      "body": fnBlock.codegen()
+    };
+    Object.defineProperty(this, "arguments", {
+      value: [],
+      enumerable: true
+    });
+    return this;
+  };
+  ForInExpression.prototype.hasCallExpression = function() {
+    return true;
+  };
+  ForInExpression.getNextVariableName = function() {
+    if (!(typeof this.forInIndex !== "undefined" && this.forInIndex !== null)) {
+      this.forInIndex = 0;
+    }
+    return "forIn" + this.forInIndex++;
+  };
+  ForInExpression.resetVariableNames = function() {
+    this.forInIndex = 0;
+  };
+  exports.ForInExpression = ForInExpression;
+  return {};
+});
+
+//# sourceMappingURL=ForInExpression.map