spider-src 0.1.5

data/lib/spider-src/support/spider/src/ast/Node.spider

@@ -0,0 +1,104 @@
+use :node;
+
+fn Node() {
+  var self = this;
+  self.codeGenerated = false;
+  self.definedIdentifiers = [];
+  
+  ::Object.defineProperty(self, 'parent', {
+    value: null,
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+  
+  self.getContext = () -> {
+    if self.type == 'Program' ||
+       self.type == 'BlockStatement' {
+      return { 
+        node: self,
+        position: -1
+      };
+    }
+    
+    if !self.parent? {
+      return null;
+    }
+    
+    var context = self.parent.getContext();
+    
+    if !context? { 
+      return null;
+    }
+    
+    if context.position == -1 {
+      return {
+        node: context.node,
+        position: context.node.body.indexOf(self)
+      };
+    } else {
+      return context;
+    }
+  };
+  
+  self.defineIdentifier = (identifier) -> {
+    self.definedIdentifiers.push(identifier);
+  };
+  
+  self.isIdentifierDefined = (name) -> {
+    var defined = false;
+    
+    for identifier in self.definedIdentifiers {
+      if identifier.name == name {
+        defined = true;
+      }
+    }
+    
+    return defined || (self.parent && self.parent.isIdentifierDefined(name));
+  };
+  
+  self.getDefinedIdentifier = (name) -> {
+    var id;
+    
+    for identifier in self.definedIdentifiers {
+      if identifier.name == name {
+        id = identifier;
+      }
+    }
+    
+    return id ?? (self.parent.getDefinedIdentifier(name) if self.parent else null);
+  };
+  
+  self.blockWrap = () -> {
+    if self.type == 'BlockStatement' {
+      return self;
+    }
+    
+    var myParent = self.parent;
+    var blockStatement = module.require('./statements/BlockStatement');
+    
+    var block = new blockStatement.BlockStatement([self]);
+    block.parent = myParent;
+    
+    return block;
+  };  
+}
+
+Node.prototype.codegen = () -> {
+  if this.codeGenerated {
+    return false;
+  }
+  
+  this.codeGenerated = true;
+  return true;
+};
+
+Node.setErrorManager = (errorManager) -> {
+  this.errorManager = errorManager;
+};
+
+Node.getErrorManager = () -> {
+  return this.errorManager;
+};
+
+exports.Node = Node;

data/lib/spider-src/support/spider/src/ast/Parameter.spider

@@ -0,0 +1,233 @@
+use :node;
+
+var Node = module.require('./Node').Node;
+
+fn Parameter(id, defaultValue, splat)
+  extends Node {
+  
+  this.type = 'Parameter';
+  this.splat = splat;
+  
+  this.id = id;
+  this.id.parent = this;
+  
+  this.defaultValue = defaultValue;
+  
+  if this.defaultValue? {
+    this.defaultValue.parent = this;
+  }
+}
+
+Parameter.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.id = this.id.codegen(false);
+  
+  if this.defaultValue? {
+    this.defaultValue = this.defaultValue.codegen();
+  }
+  
+  return this;
+};
+
+
+Parameter.prototype.hasCallExpression = () -> {
+  return false;
+};
+
+Parameter.generateFunctionBody = (func, params, body, defaults) -> {
+  var splatPosition = -1;
+  
+  for param, i in params {   
+    if param.splat {
+      if splatPosition != -1 {
+        Node.getErrorManager().error({
+          type: "MultipleSplatsDisallowed",
+          message: "multiple splats are disallowed in a function declaration",
+          loc: param.loc
+        });
+      }
+      
+      splatPosition = i;
+    }
+    
+    param = param.codegen();
+    defaults.push(param.defaultValue);
+    params[i] = param.id;
+    func.defineIdentifier(param.id);
+  }
+  
+  if splatPosition != -1 {
+    var declarations = [{
+      "type": "VariableDeclarator",
+      "id": {
+        "type": "Identifier",
+        "name": "__splat"
+      },
+      "init": null
+    }];
+    
+    for param, i in params {
+      var init;
+      if i < splatPosition {
+        init = {
+          "type": "MemberExpression",
+          "computed": true,
+          "object": {
+            "type": "Identifier",
+            "name": "arguments"
+          },
+          "property": {
+            "type": "Literal",
+            "value": i
+          }
+        };
+      } else if i == splatPosition {
+        init = {
+          "type": "ConditionalExpression",
+          "test": {
+            "type": "BinaryExpression",
+            "operator": "<=",
+            "left": {
+              "type": "Literal",
+              "value": params.length
+            },
+            "right": {
+              "type": "MemberExpression",
+              "computed": false,
+              "object": {
+                "type": "Identifier",
+                "name": "arguments"
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "length" 
+              }
+            }
+          },
+          "consequent": {
+            "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": [{
+              "type": "Identifier",
+              "name": "arguments"
+            }, {
+              "type": "Literal",
+              "value": splatPosition
+            }]
+          },
+          "alternate": {
+            "type": "ArrayExpression",
+            "elements": []
+          }
+        };
+            
+        if splatPosition < params.length - 1 {
+          init.consequent.arguments.push({
+            "type": "AssignmentExpression",
+            "operator": "=",
+            "left": {
+              "type": "Identifier",
+              "name": "__splat"
+            },
+            "right": {
+              "type": "BinaryExpression",
+              "operator": "-",
+              "left": {
+                "type": "MemberExpression",
+                "computed": false,
+                "object": {
+                  "type": "Identifier",
+                  "name": "arguments"
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "length"
+                }
+              },
+              "right": {
+                "type": "Literal",
+                "value": params.length - splatPosition - 1
+              }
+            }
+          });
+          
+          init.alternate = {
+            "type": "SequenceExpression",
+            "expressions": [{
+              "type": "AssignmentExpression",
+              "operator": "=",
+              "left": {
+                "type": "Identifier",
+                "name": "__splat"
+              },
+              "right": {
+                "type": "Literal",
+                "value": splatPosition
+              }
+            }, {
+              "type": "ArrayExpression",
+              "elements": []
+            }]
+          };
+        }
+      } else {
+        init = {
+          "type": "MemberExpression",
+          "computed": true,
+          "object": {
+            "type": "Identifier",
+            "name": "arguments"
+          },
+          "property": {
+            "type": "UpdateExpression",
+            "operator": "++",
+            "argument": {
+              "type": "Identifier",
+              "name": "__splat"
+            },
+            "prefix": false
+          }
+        };
+      }
+      
+      declarations.push({
+        "type": "VariableDeclarator",
+        "id": param,
+        "init": init
+      });
+    }
+    
+    body.body = [{
+      "type": "VariableDeclaration",
+      "codeGenerated": true,
+      "declarations": declarations,
+      "kind": "let"
+    }].concat(body.body);
+    
+    params.length = 0;
+  }
+};
+
+exports.Parameter = Parameter;

data/lib/spider-src/support/spider/src/ast/Program.spider

@@ -0,0 +1,109 @@
+use :node;
+
+var Node = module.require('./Node').Node;
+
+fn Program(body) 
+  extends Node {
+  
+  this.type = 'Program';
+  this.body = body;
+  
+  for statement, i in body {
+    if statement? {
+      statement.parent = this;
+    } else {
+      body[i] = { type: 'EmptyStatement' };
+    }
+  }
+  
+  this.definedIdentifiers = Program.prototype.generateIdentifiers(
+    'Infinity',
+    'NaN',
+    'eval',
+    'uneval',
+    'isFinite',
+    'isNaN',
+    'parseFloat',
+    'parseInt',
+    'decodeURI',
+    'decodeURIComponent',
+    'encodeURI',
+    'encodeURIComponent',
+    'escape',
+    'unescape',
+    'Object',
+    'Function',
+    'Boolean',
+    'Symbol',
+    'Error',
+    'EvalError',
+    'InternalError',
+    'RangeError',
+    'ReferenceError',
+    'StopIteration',
+    'SyntaxError',
+    'TypeError',
+    'URIError', 
+    'Number',
+    'Math',
+    'Date',
+    'String',
+    'RegExp',
+    'Array',
+    'Int8Array',
+    'Uint8Array',
+    'Uint8ClampedArray',
+    'Int16Array',
+    'Uint16Array',
+    'Int32Array',
+    'Uint32Array',
+    'Float32Array',
+    'Float64Array',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'ArrayBuffer',
+    'DataView',
+    'JSON',
+    'Iterator',
+    'Generator',
+    'Promise',
+    'arguments');    
+}
+
+Program.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+
+  var i = 0;
+  while (i < this.body.length) {
+    var statement = this.body[i];
+    
+    if !statement || statement.codeGenerated {
+      i++;
+      continue;
+    }
+    
+    if statement.codegen && statement.codegen() {
+      this.body[this.body.indexOf(statement)] = statement;
+      i++;
+    } else {
+      this.body.splice(i, 1);
+    }
+  }
+
+  return this;
+};
+
+Program.prototype.generateIdentifiers = (identifiers...) -> {
+  return identifiers.map((id) -> {
+    return {
+      "type": "Identifier",
+      "name": id
+    };
+  });
+};
+
+exports.Program = Program;

data/lib/spider-src/support/spider/src/ast/Property.spider

@@ -0,0 +1,36 @@
+use :node;
+
+var Node = module.require('./Node').Node;
+
+fn Property(key, value, shorthand, method)
+  extends Node {
+  
+  this.type = 'Property';
+  this.kind = 'init';
+  this.method = method;
+  this.shorthand = shorthand;
+  this.computed = false;
+                
+  this.key = key;
+  this.key.parent = this;
+  
+  this.value = value;
+  this.value.parent = this;
+}
+
+Property.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.key = this.key.codegen(false);
+  this.value = this.value.codegen(this.parent.type != "ObjectPattern");
+  
+  return this;
+};
+
+Property.prototype.hasCallExpression = () -> {
+  return this.value.hasCallExpression();
+};
+
+exports.Property = Property;