spider-src 0.1.5

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

@@ -0,0 +1,34 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ConditionalExpression(test, consequent, alternate) 
+  extends Node {
+  
+  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.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+    
+  this.test = this.test.codegen();
+  this.consequent = this.consequent.codegen();
+  this.alternate = this.alternate.codegen();
+  
+  return this;
+};
+
+ConditionalExpression.prototype.hasCallExpression = () -> true;
+
+exports.ConditionalExpression = ConditionalExpression;

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

@@ -0,0 +1,109 @@
+use :node;
+
+var Node = module.require('../Node').Node,
+    CallExpression = module.require('./CallExpression').CallExpression;
+    
+fn CurryCallExpression(callee, args) 
+  extends Node {
+  
+  this.type = 'CurryCallExpression';
+  
+  this.callee = callee;
+  this.args = args;
+}
+
+CurryCallExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var call = new CallExpression(this.callee, this.args);
+  call.parent = this;
+  call = call.codegen();
+  
+  if call.type != "CallExpression" or (call?.callee.type == "MemberExpression" and call?.callee.property.name == "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 = () -> true;
+
+exports.CurryCallExpression = CurryCallExpression;

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

@@ -0,0 +1,102 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ExistentialExpression(argument) 
+  extends Node {
+  
+  this.type = 'ExistentialExpression';
+  this.argument = argument;
+  this.argument.parent = this;
+}
+
+ExistentialExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var isArgumentCallExpression = this.argument.hasCallExpression?() ?? false;
+  
+  this.argument = this.argument.codegen();
+  
+  // If the argument has a function call (e.g: a().b)
+  // then store its value in a separate variable to avoid
+  // calling the function twice.
+  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;
+  }
+  
+  // The generated syntax looks like:
+  // argument === null
+  var nullCheck = {
+    "type": "BinaryExpression",
+    "operator": "!==",
+    "left": this.argument,
+    "right": {
+      "type": "Literal",
+      "value": null,
+      "raw": "null"
+    }
+  };
+  
+  // Add undefined check
+  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 = () -> {
+  return this.argument?.hasCallExpression?() ?? false;
+};
+
+ExistentialExpression.getNextVariableName = () -> {
+  if !this.existentialIndex? { 
+    this.existentialIndex = 0;
+  }
+  
+  return "existential" + this.existentialIndex++;
+};
+
+ExistentialExpression.resetVariableNames = () -> {
+  this.existentialIndex = 0;
+};
+
+exports.ExistentialExpression = ExistentialExpression;

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

@@ -0,0 +1,140 @@
+use :node;
+
+var Node = module.require('../Node').Node,
+    ForInStatement = module.require('../statements/ForInStatement').ForInStatement,
+    BlockStatement = module.require('../statements/BlockStatement').BlockStatement;
+
+fn ForInExpression(expression, item, index, array, condition) 
+  extends Node {
+  
+  this.type = 'ForInExpression';
+
+  this.expression = expression;
+  this.expression.parent = this;
+  
+  this.item = item;
+  this.item.parent = this;
+  
+  this.index = index;
+  if this.index? {
+    this.index.parent = this;
+  }
+  
+  this.array = array;
+  this.array.parent = this;
+  
+  this.condition = condition;
+  if this.condition? {
+    this.condition.parent = this;
+  }  
+}
+
+ForInExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.defineIdentifier(this.item);
+  
+  if this.index? {
+    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 this.condition? {
+    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 = () -> true;
+
+ForInExpression.getNextVariableName = () -> {
+  if !this.forInIndex? { 
+    this.forInIndex = 0;
+  }
+  
+  return "forIn" + this.forInIndex++;
+};
+
+ForInExpression.resetVariableNames = () -> {
+  this.forInIndex = 0;
+};
+
+exports.ForInExpression = ForInExpression;

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

@@ -0,0 +1,183 @@
+use :node;
+
+var Node = module.require('../Node').Node,
+    Parameter = module.require('../Parameter').Parameter,
+    CallExpression = module.require('../expressions/CallExpression').CallExpression;
+    
+fn FunctionExpression (id, params, body, inheritsFrom, operator) 
+  extends Node {
+ 
+  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 this.id? {
+    this.id.parent = this;
+  }
+  
+  this.body = body;
+  this.params = params;
+  
+  body.parent = this;
+  
+  for param in params {
+    param.parent = this;
+  }
+  
+  this.inheritsFrom = inheritsFrom;
+  
+  if this.inheritsFrom? {
+    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 = () -> {
+      return { 
+        node: self.body,
+        position: -1
+      };
+    };
+  }
+}
+
+FunctionExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  if this.id? {
+    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 this.inheritsFrom? {
+    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 = () -> true;
+
+FunctionExpression.getNextVariableName = () -> {
+  if !this.functionExpressionIndex? { 
+    this.functionExpressionIndex = 0; 
+  }
+
+  return "functionExpression" + this.functionExpressionIndex++;
+};
+
+FunctionExpression.resetVariableNames = () -> {
+  this.functionExpressionIndex = 0;
+};
+
+exports.FunctionExpression = FunctionExpression;

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

@@ -0,0 +1,114 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn InExpression(left, right)
+  extends Node {
+  
+  this.type = 'InExpression';
+  
+  this.left = left;
+  this.left.parent = this;
+  
+  this.right = right;
+  this.right.parent = this;
+}
+
+InExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.left = this.left.codegen();
+  this.right = this.right.codegen();
+  
+  if this.right.hasCallExpression?() {
+    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 = () -> true;
+
+InExpression.getNextVariableName = () -> {
+  if !this.inExpressionIndex? { 
+    this.inExpressionIndex = 0;
+  }
+  
+  return "inExpression" + this.inExpressionIndex++;
+};
+
+InExpression.resetVariableNames = () -> {
+  this.inExpressionIndex = 0;
+};
+
+exports.InExpression = InExpression;