spider-src 0.1.5

data/lib/spider-src/support/spider/src/ast/statements/ForOfStatement.spider

@@ -0,0 +1,117 @@
+use :node;
+
+var Node = module.require('../Node').Node,
+    ForInStatement = module.require('./ForInStatement').ForInStatement;
+
+fn ForOfStatement(key, value, object, body)
+  extends Node {
+  
+  this.type = 'ForOfStatement';
+  
+  this.key = key;
+  this.key.parent = this;
+  
+  this.value = value;
+  if this.value? {
+    this.value.parent = this;
+  }
+  
+  this.object = object;
+  this.object.parent = this;
+  
+  this.body = body;
+  this.body.parent = this;
+}
+
+ForOfStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+
+  this.object = this.object.codegen();
+  
+  if this.value? {
+    this.value = this.value.codegen(false);
+    this.body.defineIdentifier(this.value);
+    
+    if this.object.hasCallExpression() {
+      var id = {
+        "type": "Identifier",
+        "name": exports.ForOfStatement.getNextVariableName()
+      };
+      
+      var context = this.getContext();
+      context.node.body.splice(context.position, 0, {
+        "type": "VariableDeclaration",
+        "declarations": [{
+          "type": "VariableDeclarator",
+          "id": id,
+          "init": this.object
+        }],
+        "kind": "let",
+        "codeGenerated": true
+      });
+      
+      this.object = id;
+    }
+    
+    this.body.body = [{
+      "type": "VariableDeclaration",
+      "codeGenerated": true,
+      "declarations": [{
+        "type": "VariableDeclarator",
+        "id": this.value,
+        "init": {
+          "type": "MemberExpression",
+          "computed": "true",
+          "object": this.object,
+          "property": this.key
+        }
+      }],
+      "kind": "let",
+    }].concat(this.body.body);
+  }
+  
+  var forInLoop = (new ForInStatement(this.key, 
+    null, 
+    {
+      "type": "CallExpression",
+      "codeGenerated": true,
+      "callee": {
+        "type": "MemberExpression",
+        "computed": false,
+        "object": {
+          "type": "Identifier",
+          "name": "Object"
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "keys"
+        }
+      },
+      "arguments": [this.object]
+    },
+    this.body
+  )).codegen();
+  
+  this.type = forInLoop.type;
+  this.right = forInLoop.right;
+  this.left = forInLoop.left;
+  this.each = forInLoop.each;
+  
+  return this;
+};
+
+ForOfStatement.getNextVariableName = () -> {
+  if (!this.forOfIndex) { 
+    this.forOfIndex = 0; 
+  }
+
+  return "forOf" + this.forOfIndex++;
+};
+
+ForOfStatement.resetVariableNames = () -> {
+  this.forOfIndex = 0;
+};
+
+exports.ForOfStatement = ForOfStatement;

data/lib/spider-src/support/spider/src/ast/statements/ForStatement.spider

@@ -0,0 +1,51 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ForStatement(init, test, update, body)
+  extends Node {
+  
+  this.type = 'ForStatement';
+  
+  this.init = init; 
+  if this.init? {
+    this.init.parent = this;
+  }
+  
+  this.test = test;
+  if this.test? {
+    this.test.parent = this;
+  }
+
+  this.update = update;
+  if this.update? {
+    this.update.parent = this;
+  }
+  
+  this.body = body;
+  this.body.parent = this;
+}
+
+ForStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  if this.init? {
+    this.init = this.init.codegen();
+  }
+  
+  if this.test? {
+    this.test = this.test.codegen();
+  }
+  
+  if this.update? {
+    this.update = this.update.codegen();
+  }
+  
+  this.body = this.body.blockWrap().codegen();
+  
+  return this;
+};
+
+exports.ForStatement = ForStatement;

data/lib/spider-src/support/spider/src/ast/statements/FunctionDeclarationStatement.spider

@@ -0,0 +1,115 @@
+use :node;
+
+var Node = module.require('../Node').Node,
+    Parameter = module.require('../Parameter').Parameter,
+    CallExpression = module.require('../expressions/CallExpression').CallExpression;
+
+fn FunctionDeclarationStatement(id, params, body, inheritsFrom)
+  extends Node {
+  
+  this.type = 'FunctionDeclaration';
+  this.defaults = [];
+  this.rest = null;
+  this.generator = false;
+  this.expression = false;
+  
+  this.id = id;
+  this.id.parent = this;
+  
+  this.body = body;
+  this.body.parent = this;
+  
+  this.params = params;
+  
+  for param in params {
+    param.parent = this;
+  }
+  
+  this.inheritsFrom = inheritsFrom;
+  
+  if this.inheritsFrom? {
+    this.inheritsFrom.parent = this;
+  }
+}
+
+FunctionDeclarationStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.id = this.id.codegen();
+  Parameter.generateFunctionBody(this, this.params, this.body, this.defaults);
+  
+  this.body = this.body.codegen();
+  
+  if this.inheritsFrom? {
+    if this.inheritsFrom.type != 'CallExpression' {
+      this.inheritsFrom = new CallExpression(this.inheritsFrom, []);
+      this.inheritsFrom.parent = this;
+    }
+        
+    this.inheritsFrom = this.inheritsFrom.codegen();
+    
+    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 context = this.getContext();
+    context.node.body.splice(context.position + 1, 0, {
+      "type": "ExpressionStatement",
+      "codeGenerated": "true",
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": {
+          "type": "MemberExpression",
+          "computed": false,
+          "object": this.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 this;
+};
+
+FunctionDeclarationStatement.prototype.hasCallExpression = () -> true;
+
+exports.FunctionDeclarationStatement = FunctionDeclarationStatement;

data/lib/spider-src/support/spider/src/ast/statements/GoStatement.spider

@@ -0,0 +1,44 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn GoStatement(body)
+  extends Node {
+  
+  this.type = 'GoStatement';
+  
+  this.body = body;
+  this.body.parent = this;
+}
+
+GoStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+    
+  this.body = this.body.codegen();
+  
+  this.type = "ExpressionStatement";
+  this.expression = {
+    "type": "CallExpression",
+    "callee": {
+      "type": "UnaryExpression",
+      "operator": "async",
+      "argument": {
+        "type": "FunctionExpression",
+        "id": null,
+        "params": [],
+        "defaults": [],
+        "body": this.body,
+        "rest": null,
+        "generator": false,
+        "expression": false
+      }
+    },
+    "arguments": []
+  };
+  
+  return this;
+};
+
+exports.GoStatement = GoStatement;

data/lib/spider-src/support/spider/src/ast/statements/IfStatement.spider

@@ -0,0 +1,38 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn IfStatement(test, consequent, alternate)
+  extends Node {
+  
+  this.type = 'IfStatement';
+  
+  this.test = test;
+  this.test.parent = this;
+  
+  this.consequent = consequent;
+  this.consequent.parent = this;
+  
+  this.alternate = alternate;
+  
+  if this.alternate? {
+    this.alternate.parent = this;
+  }
+}
+
+IfStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.test = this.test.codegen();
+  this.consequent = this.consequent.blockWrap().codegen();
+  
+  if this.alternate? {
+    this.alternate = this.alternate.blockWrap().codegen();
+  }
+  
+  return this;
+};
+
+exports.IfStatement = IfStatement;

data/lib/spider-src/support/spider/src/ast/statements/ImportDeclarationStatement.spider

@@ -0,0 +1,33 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ImportDeclarationStatement(specifiers, source, kind)
+  extends Node {
+  
+  this.type = "ImportDeclaration";
+  this.kind = kind;
+  
+  this.specifiers = specifiers;
+  for specifier in this.specifiers {
+    specifier.parent = this;
+  }
+  
+  this.source = source;
+  this.source.parent = this;
+}
+
+ImportDeclarationStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  for specifier, i in this.specifiers {
+    this.specifiers[i] = specifier.codegen();
+  }
+  
+  this.source = this.source.codegen();
+  return this;
+};
+
+exports.ImportDeclarationStatement = ImportDeclarationStatement;

data/lib/spider-src/support/spider/src/ast/statements/PushStatement.spider

@@ -0,0 +1,40 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn PushStatement(left, right)
+  extends Node {
+  
+  this.type = 'PushStatement';
+  
+  this.left = left;
+  this.left.parent = this;
+
+  this.right = right;
+  this.right.parent = this;  
+}
+
+PushStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+    
+  this.type = "ExpressionStatement";
+  this.expression = {
+    "type": "CallExpression",
+    "callee": {
+      "type": "MemberExpression",
+      "object": this.left.codegen(),
+      "property": {
+        "type": "Identifier",
+        "name": "push"
+      },
+      "computed": false
+    },
+    "arguments": [this.right.codegen()]
+  };
+  
+  return this;
+};
+
+exports.PushStatement = PushStatement;

data/lib/spider-src/support/spider/src/ast/statements/ReturnStatement.spider

@@ -0,0 +1,28 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ReturnStatement(argument)
+  extends Node {
+  
+  this.type = 'ReturnStatement';
+  this.argument = argument;
+  
+  if this.argument? {
+    this.argument.parent = this;
+  }
+}
+
+ReturnStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  if this.argument? {
+    this.argument = this.argument.codegen();
+  }
+
+  return this;
+};
+
+exports.ReturnStatement = ReturnStatement;

data/lib/spider-src/support/spider/src/ast/statements/SwitchStatement.spider

@@ -0,0 +1,161 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn SwitchStatement(discriminant, cases)
+  extends Node {
+  
+  this.type = 'SwitchStatement';
+  
+  this.discriminant = discriminant;
+  this.discriminant.parent = this;
+  
+  this.cases = cases;
+  
+  for caseClause in this.cases {
+    caseClause.parent = this;
+  }
+}
+
+SwitchStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var context = this.getContext();
+  var firstCase, currentCase, defaultCase;
+  var fallthroughPosition = 1;
+  
+  this.discriminant = this.discriminant.codegen();
+  
+  if this.discriminant.hasCallExpression() {
+    var id = {
+      "type": "Identifier",
+      "name": SwitchStatement.getNextVariableName()
+    };
+    
+    context.node.body.splice(context.position, 0, {
+      "type": "VariableDeclaration",
+      "codeGenerated": true,
+      "declarations": [{
+        "type": "VariableDeclarator",
+        "id": id,
+        "init": this.discriminant
+      }],
+      "kind": "let"
+    });
+    
+    this.discriminant = id;
+  }
+  
+  var hasFallthrough = false;
+  
+  for caseClause in this.cases {
+    if (!caseClause.tests) {
+      defaultCase = caseClause;
+      break;
+    }
+    
+    if !firstCase? {
+      firstCase = caseClause.codegen();
+      currentCase = firstCase;
+    } else {
+      if currentCase.fallthrough {
+        hasFallthrough = true;
+        currentCase = caseClause.codegen(this.branchFallthrough);
+        context.node.body.splice(context.position + fallthroughPosition++, 0, currentCase);
+      } else {        
+        currentCase.alternate = caseClause.codegen(this.fallthroughId?);
+        currentCase = currentCase.alternate;
+      }      
+    }
+  }
+  
+  if hasFallthrough {
+    for caseClause in this.cases {
+      if !caseClause.fallthrough and caseClause != defaultCase {
+        caseClause.body.body = [{
+          "type": "ExpressionStatement",
+          "codeGenerated": true,
+          "expression": {
+            "type": "AssignmentExpression",
+            "operator": "=",
+            "left": this.fallthroughId,
+            "right": {
+              "type": "Literal",
+              "value": 2
+            }
+          }
+        }].concat(caseClause.body.body);
+      }
+    }
+  }
+  
+  if defaultCase? {
+    if !firstCase? {
+      Node.getErrorManager().error({
+        type: "SingleDefaultClause",
+        message: "default clause without other case clauses is disallowed.",
+        loc: defaultCase.loc
+      });
+    } else {
+      if currentCase.fallthrough {
+        defaultCase = defaultCase.codegen(this.fallthroughId?);
+        defaultCase.codeGenerated = true;
+        if this.fallthroughId? {
+          context.node.body.splice(context.position + fallthroughPosition++, 0, defaultCase);
+        } else {
+          for statement in defaultCase.body {
+            context.node.body.splice(context.position + fallthroughPosition++, 0, statement);
+          }
+        }        
+      } else {
+        currentCase.alternate = defaultCase.codegen(this.fallthroughId?);
+      }
+    }
+  }
+  
+  if this.fallthroughId? {
+    context.node.body.splice(context.position, 0, {
+      "type": "VariableDeclaration",
+      "codeGenerated": true,
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": this.fallthroughId,
+          "init": {
+            "type": "Literal",
+            "value": 0
+          }
+        }
+      ],
+      "kind": "let"
+    });
+  }
+  
+  if !firstCase? {
+    this.type = "ExpressionStatement";
+    this.expression = this.discriminant;
+  } else {
+    this.type = firstCase.type;
+    this.test = firstCase.test;
+    this.consequent = firstCase.consequent;
+    this.alternate = firstCase.alternate;
+  }
+  
+  return this;
+};
+
+SwitchStatement.getNextVariableName = () -> {
+  if !this.switchStatementIndex? { 
+    this.switchStatementIndex = 0;
+  }
+  
+  return "switchStatement" + this.switchStatementIndex++;
+};
+
+SwitchStatement.resetVariableNames = () -> {
+  this.switchStatementIndex = 0;
+};
+
+exports.SwitchStatement = SwitchStatement;

data/lib/spider-src/support/spider/src/ast/statements/ThrowStatement.spider

@@ -0,0 +1,23 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ThrowStatement(argument)
+  extends Node {
+    
+  this.type = 'ThrowStatement';
+  
+  this.argument = argument;
+  this.argument.parent = this;
+}
+
+ThrowStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.argument = this.argument.codegen();
+  return this;
+};
+
+exports.ThrowStatement = ThrowStatement;

data/lib/spider-src/support/spider/src/ast/statements/TryStatement.spider

@@ -0,0 +1,42 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn TryStatement(block, handler, finalizer)
+  extends Node {
+  
+  this.type = 'TryStatement';
+  
+  this.block = block;
+  this.block.parent = this;
+  
+  this.handler = handler;
+  if this.handler? {
+    this.handler.parent = this;
+  }
+  
+  this.finalizer = finalizer;
+  if this.finalizer? {
+    this.finalizer.parent = this;
+  }
+}
+
+TryStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.block = this.block.codegen();
+  
+  if this.handler? {
+    this.handler = this.handler.codegen();
+  }
+  
+  if this.finalizer? {
+    this.finalizer = this.finalizer.codegen();
+  }
+  
+  return this;
+};
+
+exports.TryStatement = TryStatement;