spider-src 0.1.5

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

@@ -0,0 +1,42 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ObjectPattern(properties)
+  extends Node {
+  
+  this.type = 'ObjectPattern';
+  this.properties = properties;
+  
+  for property in this.properties {
+    property.parent = this;
+  }
+}
+
+ObjectPattern.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+    
+  var context = this.getContext().node;
+  for property, i in this.properties {
+    this.properties[i] = property.codegen();
+    
+    
+    if property.value? {
+      if property.value.type == "Identifier" {
+        context.defineIdentifier(property.value);
+      }    
+    } else {
+      if property.key.type == "Identifier" {
+        context.defineIdentifier(property.key);
+      }
+    }   
+  }
+  
+  return this;
+};
+
+ObjectPattern.prototype.hasCallExpression = () -> true;
+
+exports.ObjectPattern = ObjectPattern;

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

@@ -0,0 +1,179 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn RangeMemberExpression(object, range)
+  extends Node {
+  
+  this.type = 'RangeMemberExpression';
+  this.object = object;
+  this.object.parent = this;
+  
+  this.range = range;
+  this.range.parent = this;
+}
+
+RangeMemberExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var isNumber = (n) -> !::isNaN(::parseFloat(n)) && ::isFinite(n);
+   
+  // If this node is the left side of an assignment expression,  
+  // it means we're dealing with splice. For example: 
+  // items[1..2] = [1, 2];
+  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.codegen() if this.range.start else {
+                 "type": "Literal",
+                 "value": 0
+               };   
+    
+    if this.range.to? {
+      if isNumber(start.value) &&
+         isNumber(this.range.to.value) {
+        to = {
+          "type": "Literal",
+          "value": this.range.to.value - start.value + (1 if this.range.operator == '..' else 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 {
+    // Otherwise, we're dealing with slice. For example:
+    // var x = items[1..2];
+    this.type = "CallExpression";
+    this.callee = {
+      "type": "MemberExpression",
+      "computed": false,
+      "object": this.object.codegen(),
+      "property": {
+        "type": "Identifier",
+        "name": "slice"
+      }
+    };
+    
+    var args = [];
+    
+    if !this.range.start? {
+      args.push({
+        "type": "Literal",
+        "value": 0
+      });
+    } else {
+      args.push(this.range.start.codegen());
+    }
+    
+    if this.range.to? {
+      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 = () -> true;
+
+exports.RangeMemberExpression = RangeMemberExpression;

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

@@ -0,0 +1,49 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn SplatExpression(expression)
+  extends Node {
+  
+  this.type = 'SplatExpression';
+  
+  this.expression = expression;
+  this.expression.parent = this;
+}
+
+SplatExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    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 = () -> true;
+
+exports.SplatExpression = SplatExpression;

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

@@ -0,0 +1,235 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+var extend = require('util')._extend;
+
+fn SuperExpression()
+  extends Node {
+
+  this.type = 'SuperExpression';
+}
+
+SuperExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  // Raise an error if we are getting a syntax  
+  // such as: super?.test
+  if this.parent.type == 'NullPropagatingExpression' {
+    Node.getErrorManager().error({
+      type: "InvalidSuperReference",
+      message: "cannot refer to super before the ?. operator",
+      loc: this.loc
+    });
+    
+    return { type: 'ThisExpression' };
+  }
+  
+  // The only supported use case for super is 
+  // member expression (e.g: super.x)
+  if this.parent.type != 'MemberExpression' {
+    Node.getErrorManager().error({
+      type: "InvalidUsageForSuper",
+      message: "invalid usage of super keyword",
+      loc: this.loc
+    });
+    
+    return { type: 'ThisExpression' };
+  }
+  
+  // Find a parent function that extends another function
+  // (has the extends keyword) or a prototype assignment
+  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;
+  }
+  
+  // Raise an error if there's no parent function
+  if !node {   
+    Node.getErrorManager().error({
+      type: "InvalidContextForSuper",
+      message: "invalid context for super keyword",
+      loc: this.loc
+    });
+    
+    return { type: 'ThisExpression' };
+  }
+  
+  // Add _self variable to a context.
+  var addSelf = (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;
+  };
+  
+  // Modify the call expression to look like:
+  // _fn.call(_self)
+  var mutateCallExpression = (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 we are inside a prototype function, change 
+  // something like: super.x() to Base.prototype.x.call(_self);
+  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 {
+      // Make sure that the syntax is something like:
+      // Fn.prototype = { ... }
+      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 (contextNode.parent? && contextNode.parent != node.right) {
+        contextNode = contextNode.parent;
+      }
+
+      // Make sure that the syntax is something like:
+      // Fn.prototype = { test: fn () { ... } }
+      if contextNode?.type != 'Property' ||
+         contextNode?.value?.type != '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 is a call expression, e.g: super.test(), 
+    // Turn this into Base.prototype.test.call(_self)
+    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;
+    }
+    
+    // Otherwise, just return (this|_self).property
+    return selfNode;
+  }
+  
+  var superContext = parentNode.getContext(); 
+  
+  // Find the most left side in the member expression
+  // For super.a.b.c.d, the most left side would be super
+  var lastObject = this.parent;
+  while (lastObject.object.type == 'MemberExpression') {
+    lastObject = lastObject.object;
+  }
+  
+  // Change it to a this expression
+  lastObject.object = {
+    type: 'ThisExpression'
+  };
+  
+  var id = {
+    "type": "Identifier",
+    "name": "_" + this.parent.property.name
+  };
+  
+  // Declare a new variable in the function that extends
+  // with a reference to our property
+  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 we are in a call expression, change it to:
+  // _fn.call(_self)
+  if this.parent.parent.type == 'CallExpression' {
+    mutateCallExpression(id, this.parent, addSelf(superContext));
+  } else {
+    // Otherwise, just refer to the variable
+    this.parent.type = 'Identifier';
+    ::Object.defineProperty(this.parent, 'name', { 
+      value: id.name, 
+      enumerable: true 
+    });  
+  }
+  
+  return id;
+};
+
+SuperExpression.prototype.hasCallExpression = () -> false;
+
+exports.SuperExpression = SuperExpression;

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

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

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

@@ -0,0 +1,158 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn UnaryExpression(operator, argument)
+  extends Node {
+  
+  this.type = 'UnaryExpression';
+  this.operator = operator;
+  this.argument = argument;
+  this.argument.parent = this;
+  this.prefix = true;
+}
+
+UnaryExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.argument = this.argument.codegen();
+    
+  // typeof operator should compile to:
+  // ({}).toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase()
+  if (this.operator == 'typeof') {    
+    var typeofExpression = {
+      "type": "CallExpression",
+      "callee": {
+        "type": "MemberExpression",
+        "computed": false,
+        "object": {
+          "type": "MemberExpression",
+          "computed": true,
+          "object": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "MemberExpression",
+              "computed": false,
+              "object": {
+                "type": "CallExpression",
+                "callee": {
+                  "type": "MemberExpression",
+                  "computed": false,
+                  "object": {
+                    "type": "MemberExpression",
+                    "computed": false,
+                    "object": {
+                      "type": "ObjectExpression",
+                      "properties": []
+                    },
+                    "property": {
+                      "type": "Identifier",
+                      "name": "toString"
+                    }
+                  },
+                  "property": {
+                    "type": "Identifier",
+                    "name": "call"
+                  }
+                },
+                "arguments": [this.argument]
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "match"
+              }
+            },
+            "arguments": [{
+              "type": "Literal",
+              "value": new ::RegExp("\\s([a-zA-Z]+)")
+            }]
+          },
+          "property": {
+            "type": "Literal",
+            "value": 1,
+            "raw": "1"
+          }
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "toLowerCase"
+        }
+      },
+      "arguments": []
+    };
+    
+    if !this.argument.hasCallExpression() {
+      this.type = "ConditionalExpression";
+      this.test = {
+        "type": "BinaryExpression",
+        "operator": "===",
+        "left": {
+          "type": "UnaryExpression",
+          "operator": "typeof",
+          "argument": this.argument,
+          "prefix": true
+        },
+        "right": {
+          "type": "Literal",
+          "value": "undefined",
+          "raw": "'undefined'"
+        }
+      };
+      
+      this.consequent = {
+        "type": "Literal",
+        "value": "undefined"
+      };
+      
+      this.alternate = typeofExpression;
+    } else {
+      this.type = typeofExpression.type;
+      this.callee = typeofExpression.callee;
+      ::Object.defineProperty(this, 'arguments', { 
+        value: typeofExpression.arguments, 
+        enumerable: true 
+      });
+    }
+  } else if this.operator == "<-" {
+    var parent = this.parent;
+    while parent? and parent.type != "FunctionExpression" and parent.type != "GoStatement" {
+      parent = parent.parent;
+    }
+    
+    if not parent? or
+       (parent.type != "GoStatement" and 
+          (parent.parent.type != "UnaryExpression" or
+          parent.parent.operator != "async")) {
+      Node.getErrorManager().error({
+        type: "GetExpressionRequiresAsync",
+        message: "unary <- must be in a go statement or an async function",
+        loc: this.loc
+      });
+    }
+        
+    this.operator = "await";
+    this.argument = {
+      "type": "CallExpression",
+      "callee": {
+        "type": "MemberExpression",
+        "object": this.argument,
+        "property": {
+          "type": "Identifier",
+          "name": "get"
+        },
+        "computed": false
+      },
+      "arguments": []
+    };
+  }
+  
+  return this;
+};
+
+UnaryExpression.prototype.hasCallExpression = () -> {
+  return this.argument?.hasCallExpression();
+};
+
+exports.UnaryExpression = UnaryExpression;