spider-src 0.1.5

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

@@ -0,0 +1,62 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn LogicalExpression(left, operator, right)
+  extends Node {
+  
+  this.type = 'LogicalExpression';
+  this.operator = operator;
+  
+  switch this.operator {
+    case 'and': {
+      this.operator = '&&';
+    },
+    
+    case 'or': {
+      this.operator = '||';
+    }
+  }
+   
+  this.left = left;
+  this.left.parent = this;
+  
+  this.right = right;
+  this.right.parent = this;
+}
+
+LogicalExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var enforceBooleanExpression = (o) -> {
+    if o.type == "UnaryExpression" and o.operator == "!" {
+      return o;
+    }
+    
+    return {
+      "type": "UnaryExpression",
+      "operator": "!",
+      "argument": {
+        "type": "UnaryExpression",
+        "operator": "!",
+        "argument": o,
+        "prefix": true
+      },
+      "prefix": true
+    };
+  };
+  
+  this.left = enforceBooleanExpression(this.left.codegen());
+  this.right = enforceBooleanExpression(this.right.codegen());
+  
+  return this;
+};
+
+LogicalExpression.prototype.hasCallExpression = () -> {
+  return this.left?.hasCallExpression() ||
+         this.right?.hasCallExpression();
+};
+
+exports.LogicalExpression = LogicalExpression;

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

@@ -0,0 +1,57 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn MemberExpression(left, right, computed)
+  extends Node {
+
+  this.type = 'MemberExpression';
+  this.computed = computed;
+  
+  this.object = left;
+  this.object.parent = this;
+  
+  this.property = right;
+  this.property.parent = this;
+}
+
+MemberExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var objectType = this.object.type;
+  this.object = this.object.codegen(); 
+    
+  if !this.property.codeGenerated {
+    this.property = this.property.codegen(false);
+  }
+  
+  // compile an expression such as: b?.c?.d.e
+  // to: typeof b !== "undefined" && (b !== null && b.c !== null) ? b.c.d.e : null
+  // instead of: (typeof b !== "undefined" && (b !== null && b.c !== null) ? b.c.d : null).e;
+  if (this.object.type == 'ConditionalExpression' &&
+      (objectType == 'NullPropagatingExpression' || objectType == 'MemberExpression' || 
+       objectType == 'CallExpression' || objectType == 'NullCheckCallExpression')) {
+    this.type = this.object.type;
+    this.test = this.object.test;
+    this.alternate = this.object.alternate;
+    
+    this.consequent = {
+      type: 'MemberExpression',
+      object: this.object.consequent,
+      property: this.property,
+      computed: this.computed
+    };
+  }
+  
+  return this;
+};
+
+MemberExpression.prototype.hasCallExpression = () -> {
+  return this.object.__null_propagating ||
+         this.object?.hasCallExpression?() ||
+         this.property?.hasCallExpression();
+};
+
+exports.MemberExpression = MemberExpression;

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

@@ -0,0 +1,40 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn NewExpression(callee, args)
+  extends Node {
+  
+  this.type = 'NewExpression';
+  
+  this.callee = callee;
+  this.callee.parent = this;
+  
+  ::Object.defineProperty(this, 'arguments', { 
+    value: args, 
+    enumerable: true 
+  });
+  
+  for arg in args {
+    arg.parent = this;
+  }
+}
+
+NewExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.callee = this.callee.codegen();
+  
+  var args = this.arguments;
+  for arg, i in args {
+    args[i] = arg.codegen();
+  }
+  
+  return this;
+};
+
+NewExpression.prototype.hasCallExpression = () -> true;
+
+exports.NewExpression = NewExpression;

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

@@ -0,0 +1,151 @@
+use :node;
+
+var Node = module.require('../Node').Node,
+    CallExpression = module.require('./CallExpression').CallExpression;
+    
+fn NullCheckCallExpression(callee, args)
+  extends Node {
+  
+  this.type = 'NullCheckCallExpression';
+  
+  this.callee = callee;
+  this.callee.parent = this;
+  
+  this.args = args;
+  
+  for arg in args {
+    arg.parent = this;
+  }
+}
+
+NullCheckCallExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var calleeType = this.callee.type;
+  
+  this.callee = this.callee.codegen();
+  
+  var args = this.args;
+  for arg, i in args {
+    var isSplat = args[i].type == "SplatExpression";    
+    args[i] = arg.codegen();
+    args[i].codeGenerated = true;
+    
+    if isSplat {
+      args[i].__splat = true;
+    }
+  }
+  
+  // If the callee has a function call (e.g: a().b)
+  // then store its value in a separate variable to avoid
+  // calling the function twice.
+  if this.callee.hasCallExpression?() {
+    var context = this.getContext();
+    
+    var id = {
+      "type": "Identifier",
+      "name": NullCheckCallExpression.getNextVariableName(),
+      "codeGenerated": true
+    };
+    
+    context.node.body.splice(context.position + 
+      (NullCheckCallExpression.nullCheckIndex - 2), 0, {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": id,
+          "init": this.callee
+        }
+      ],
+      "kind": "let",
+      "codeGenerated": true
+    });
+    
+    this.callee = id;
+  }
+  
+  // Create a basic typeof callee !== "function" check
+  var test = {
+    "type": "BinaryExpression",
+    "operator": "===",
+    "left": {
+      "type": "UnaryExpression",
+      "operator": "typeof",
+      "argument": this.callee,
+      "prefix": true
+    },
+    "right": {
+      "type": "Literal",
+      "value": "function",
+      "raw": "\"function\""
+    }
+  };
+  
+  var argument = test.left.argument;
+  
+  // If we are null propagating (?.), then make sure to
+  // add the null propagating condition 
+  if calleeType == 'NullPropagatingExpression' {
+    argument = argument.consequent;
+    test.left.argument = argument;
+    
+    test = {
+      "type": "LogicalExpression",
+      "operator": "&&",
+      "left": this.callee.test,
+      "right": test
+    };
+  } 
+  
+  argument.codeGenerated = true;
+  var consequent = new CallExpression(argument, args).codegen();
+    
+  if this.parent.type == 'ExpressionStatement' {
+    this.parent.type = 'IfStatement';
+    this.parent.test = test;
+    this.parent.consequent = {
+      type: 'BlockStatement',
+      body: [
+        {
+          type: 'ExpressionStatement',
+          expression: consequent
+        }
+      ]
+    };
+    this.parent.alternate = null;
+  } else {
+    this.type = 'ConditionalExpression';
+    this.test = test;
+    this.consequent = consequent;
+    this.alternate = {
+      "type": "UnaryExpression",
+      "operator": "void",
+      "argument": {
+        "type": "Literal",
+        "value": 0,
+        "raw": "0"
+      },
+      "prefix": true
+    };
+  }
+  return this;
+};
+
+NullCheckCallExpression.prototype.hasCallExpression = () -> true;
+
+NullCheckCallExpression.getNextVariableName = () -> {
+  if !this.nullCheckIndex? { 
+    this.nullCheckIndex = 0;
+  }
+  
+  return "nullCheck" + this.nullCheckIndex++;
+};
+
+NullCheckCallExpression.resetVariableNames = () -> {
+  this.nullCheckIndex = 0;
+};
+
+exports.NullCheckCallExpression = NullCheckCallExpression;

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

@@ -0,0 +1,151 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn NullCoalescingExpression(left, right)
+  extends Node {
+  
+  this.type = 'NullCoalescingExpression';
+  
+  this.left = left;
+  this.left.parent = this;
+  
+  this.right = right;
+  this.right.parent = this;
+}
+
+NullCoalescingExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var leftType = this.left.type;
+  
+  this.left = this.left.codegen();
+  this.right = this.right.codegen();
+  
+  var context = this.getContext();
+  var addUndefinedCheck = true;
+  
+  // If the left expression is a function call (e.g: f() ?? 5)
+  // then store its value in a separate variable to avoid
+  // calling the function twice.
+  if leftType == 'NullPropagatingExpression' ||
+     leftType == 'NullCoalescingExpression' ||
+     this.left.hasCallExpression?() {
+         
+    var id = {
+      "type": "Identifier",
+      "name": NullCoalescingExpression.getNextLeftName()
+    };
+    
+    context.node.body.splice(context.position, 0, {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": id,
+          "init": this.left
+        }
+      ],
+      "kind": "let",
+      "codeGenerated": true
+    });
+    
+    this.left = id;
+    addUndefinedCheck = false;
+  }
+   
+  var test = {
+    "type": "BinaryExpression",
+    "operator": "==",
+    "left": this.left,
+    "right": {
+      "type": "Literal",
+      "value": null,
+      "raw": "null"
+    }
+  };
+
+  if this.left.type != 'Identifier' {
+    addUndefinedCheck = false;
+  }
+
+  if addUndefinedCheck {
+    test = {
+      "type": "LogicalExpression",
+      "operator": "||",
+      "left": {
+        "type": "BinaryExpression",
+        "operator": "===",
+        "left": {
+          "type": "UnaryExpression",
+          "operator": "typeof",
+          "argument": this.left,
+          "prefix": true
+        },
+        "right": {
+          "type": "Literal",
+          "value": "undefined",
+          "raw": "'undefined'"
+        }
+      },
+      "right": test
+    };
+  }
+
+  // If the null coalescing operator is an expression
+  // statement child, the generated JS should be an if statement.
+  if this.parent?.type == 'ExpressionStatement' {
+    
+    if !this.right.hasCallExpression() {
+      this.parent.type = 'EmptyStatement';
+      return this;
+    }
+    
+    this.parent.type = 'IfStatement';
+    this.parent.test = test;
+        
+    this.parent.consequent = {
+      "type": "BlockStatement",
+      "body": [
+        {
+          "type": "ExpressionStatement",
+          "expression": this.right
+        }
+      ]
+    };
+  } else {
+    // Otherwise - if the null coalescing operator is 
+    // inside an expression, the generated JS should 
+    // look like:
+    // 
+    // typeof left === 'undefined' || left === null ? right : left
+    
+    return {
+      "type": "ConditionalExpression",
+      "test": test,
+      "consequent": this.right,
+      "alternate": this.left
+    };
+  }
+};
+
+NullCoalescingExpression.prototype.hasCallExpression = () -> {
+  return this.left?.hasCallExpression() ||
+         this.right?.hasCallExpression();
+};
+
+NullCoalescingExpression.getNextLeftName = () -> {
+  if (!this.nullCoalescingIndex?) { 
+    this.nullCoalescingIndex = 0; 
+  }
+
+  return "nullCoalescing" + this.nullCoalescingIndex++;
+};
+
+NullCoalescingExpression.resetVariableNames = () -> {
+  this.nullCoalescingIndex = 0;
+};
+
+exports.NullCoalescingExpression = NullCoalescingExpression;

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

@@ -0,0 +1,190 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn NullPropagatingExpression(left, right)
+  extends Node {
+  
+  this.type = 'NullPropagatingExpression';
+  this.computed = false;
+  
+  this.object = left;
+  this.object.parent = this;
+  
+  this.property = right;
+  this.property.parent = this;
+}
+
+NullPropagatingExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var context = this.getContext();
+  var childType = this.object.type;
+  
+  this.object = this.object.codegen();
+  this.property = this.property.codegen(false);
+  
+  // If the left expression is a function call (e.g: a()?.b)
+  // then store its value in a separate variable to avoid
+  // calling the function twice.
+  if this.object.hasCallExpression?() {
+    var id = {
+      "type": "Identifier",
+      "name": NullPropagatingExpression.getNextObjectName(),
+      "__member_expression": {
+        "type": "MemberExpression",
+        "object": this.object,
+        "property": this.property,
+        "computed": false
+      },      
+    };
+    
+    context.node.body.splice(context.position + 
+      (NullPropagatingExpression.nullPropagatingIndex - 1), 0, {
+      "type": "VariableDeclaration",
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "id": id,
+          "init": this.object
+        }
+      ],
+      "kind": "let",
+      "codeGenerated": true
+    });
+    
+    this.object = id;
+  }
+  
+  var condition;
+  
+  // If this node is the last NullPropagatingExpression in
+  // the tree, then just create a simple object !== null condition
+  if childType != 'NullPropagatingExpression' {
+    condition = {
+      "type": "BinaryExpression",
+      "operator": "!==",
+      "left": this.object,
+      "right": {
+        "type": "Literal",
+        "value": null,
+        "raw": "null"
+      },
+      "__member_expression": {
+        "type": "MemberExpression",
+        "object": this.object,
+        "property": this.property,
+        "computed": false
+      },
+      "__first_object": this.object
+    };
+  } else {
+    // Otherwise create an object !== null condition and add it
+    // with logical AND to the previous condition
+    condition = {
+      "type": 'LogicalExpression',
+      "operator": '&&',
+      "left": this.object,
+      "right": {
+        "type": "BinaryExpression",
+        "operator": "!==",
+        "left": {
+          "type": "MemberExpression",
+          "object": this.object.__member_expression.object,
+          "property": this.object.__member_expression.property,
+          "computed": false
+        },
+        "right": {
+          "type": "Literal",
+          "value": null,
+          "raw": "null"
+        },
+      },
+      "__member_expression": {
+        "type": "MemberExpression",
+        "object": this.object.__member_expression,
+        "property": this.property,
+        "computed": false
+      },
+      "__first_object": this.object.__first_object
+    };
+  }
+  
+  // Return the condition if this isn't the first NullPropagatingExpression
+  if this.parent?.type == 'NullPropagatingExpression' {
+    return condition;
+  }
+    
+  // Add typeof object !== undefined check
+  condition = {
+    "type": 'LogicalExpression',
+    "operator": '&&',
+    "left": {
+      "type": "BinaryExpression",
+      "operator": "!==",
+      "left": {
+        "type": "UnaryExpression",
+        "operator": "typeof",
+        "argument": this.object.__first_object ?? this.object
+      },
+      "right": {
+        "type": "Literal",
+        "value": "undefined",
+        "raw": "\"undefined\""
+      },
+    },
+    "right": condition
+  };
+
+  condition = {
+    "type": "ConditionalExpression",
+    "test": condition,
+    "consequent": {
+      "type": "MemberExpression",
+      "object": this.object if this.object.type == 'Identifier' || !this.object.__member_expression 
+        else this.object.__member_expression,
+      "property": this.property,
+      "computed": false
+    },
+    "alternate": {
+      "type": "UnaryExpression",
+      "operator": "void",
+      "argument": {
+        "type": "Literal",
+        "value": 0,
+        "raw": "0"
+      },
+      "prefix": true
+    },
+    "__null_propagating": true
+  };  
+
+  return condition;
+};
+
+NullPropagatingExpression.prototype.hasCallExpression = () -> true;
+
+NullPropagatingExpression.getNextObjectName = () -> {
+  if !this.nullPropagatingIndex? { 
+    this.nullPropagatingIndex = 0;
+    this.definedObjectNames = [];
+  }
+
+  var name = "nullPropagating" + this.nullPropagatingIndex++;
+  this.definedObjectNames.push(name);
+  
+  return name;
+};
+
+NullPropagatingExpression.isObjectNameDefined = (name) -> {
+  return this.definedObjectNames.indexOf(name) != -1;
+};
+
+NullPropagatingExpression.resetVariableNames = () -> {
+  this.nullPropagatingIndex = 0;
+  this.definedObjectNames = [];
+};
+
+exports.NullPropagatingExpression = NullPropagatingExpression;

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

@@ -0,0 +1,30 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ObjectExpression(properties)
+  extends Node {
+  
+  this.type = 'ObjectExpression';
+  this.properties = properties;
+  
+  for property in this.properties {
+    property.parent = this;
+  }
+}
+
+ObjectExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+    
+  for property, i in this.properties {
+    this.properties[i] = property.codegen();
+  }
+  
+  return this;
+};
+
+ObjectExpression.prototype.hasCallExpression = () -> true;
+
+exports.ObjectExpression = ObjectExpression;