glayzzle#66 fix precendence on other nodes

Author: ichiriac

src/ast.js

@@ -172,6 +172,21 @@ AST.prototype.prepare = function(kind, parser) {
     }
     var result = Object.create(node.prototype);
     node.apply(result, args);
+    if (
+      result.kind === 'bin' &&
+      result.right &&
+      typeof result.right.precedence === 'function'
+    ) {
+      var out = result.right.precedence(result);
+      if (out) { // shift with precedence
+        result = out;
+      }
+    } else if (result.kind === 'unary') {
+      var out = result.precedence(result.what);
+      if (out) { // shift with precedence
+        result = out;
+      }
+    }
     return result;
   };
 };

src/ast/bin.js

@@ -13,8 +13,8 @@ var binOperatorsPrecedence = [
   ['or'],
   ['xor'],
   ['and'],
-  // TODO: assignment
-  // TODO: ternary ? :
+  // TODO: assignment / not sure that PHP allows this with expressions
+  ['retif'],
   ['??'],
   ['||'],
   ['&&'],
@@ -26,21 +26,13 @@ var binOperatorsPrecedence = [
   ['<<', '>>'],
   ['+', '-', '.'],
   ['*', '/', '%'],
-  // TODO: unary !
+  ['!'],
   ['instanceof'],
-  // TODO: unary ++, --, ~, @, typecasts
+  // TODO: typecasts
   // TODO: [ (array)
   // TODO: clone, new
 ];
 
-// define nodes shifting
-var precedence = {};
-binOperatorsPrecedence.forEach(function (list, index) {
-  list.forEach(function (operator) {
-    precedence[operator] = index + 1;
-  });
-});
-
 /*
 x OP1 (y OP2 z)
 z OP1 (x OP2 y)
@@ -56,26 +48,28 @@ z OP2 (x OP1 y)
  */
 var Bin = Operation.extends(function Bin(type, left, right, location) {
   Operation.apply(this, [KIND, location]);
-  if (right && right.kind === 'bin') {
-    var lLevel = precedence[type];
-    var rLevel = precedence[right.type];
-    if (lLevel && rLevel && rLevel < lLevel) {
-      // shift precedence
-      var buffer = right.right;
-      right.right = right.left;
-      right.left = left;
-      left = buffer;
-      buffer = right.type;
-      right.type = type;
-      type = buffer;
-      buffer = left;
-      left = right;
-      right = buffer;
-    }
-  }
   this.type = type;
   this.left = left;
   this.right = right;
 });
 
+Bin.prototype.precedence = function(node) {
+  var lLevel = Bin.precedence[node.type];
+  var rLevel = Bin.precedence[this.type];
+  if (lLevel && rLevel && rLevel < lLevel) {
+    // shift precedence
+    node.right = this.left;
+    this.left = node;
+    return this;
+  }
+};
+
+// define nodes shifting
+Bin.precedence = {};
+binOperatorsPrecedence.forEach(function (list, index) {
+  list.forEach(function (operator) {
+    Bin.precedence[operator] = index + 1;
+  });
+});
+
 module.exports = Bin;

src/ast/retif.js

@@ -7,6 +7,8 @@
 
 var Statement = require('./statement');
 var KIND = 'retif';
+var Bin = require('./bin');
+var PRECEDENCE = Bin.precedence[KIND];
 
 /**
  * Defines a short if statement that returns a value
@@ -23,4 +25,21 @@ var RetIf = Statement.extends(function RetIf(test, trueExpr, falseExpr, location
   this.falseExpr = falseExpr;
 });
 
+/**
+ * Handles precedence over items
+ */
+RetIf.prototype.precedence = function(node) {
+  var what = node.kind === 'bin' ? node.type : node.kind;
+  var lLevel = Bin.precedence[what];
+  if (lLevel && PRECEDENCE < lLevel) {
+    if (node.kind === 'bin') {
+      node.right = this.test;
+      this.test = node;
+      return this;
+    } else {
+      throw new Error('@todo ' + node.kind);
+    }
+  }
+};
+
 module.exports = RetIf;

src/ast/unary.js

@@ -21,4 +21,16 @@ var Unary = Operation.extends(function Unary(type, what, location) {
   this.what = what;
 });
 
+Unary.prototype.precedence = function(node) {
+  if (node.kind === 'bin') {
+    this.what = node.left;
+    node.left = this;
+    return node;
+  } else if (node.kind === 'retif') {
+    this.what = node.test;
+    node.test = this;
+    return node;
+  }
+};
+
 module.exports = Unary;

test/exprTests.js

@@ -87,7 +87,9 @@ describe('Test expressions', function() {
       '$a > 5 ? true : false;',
       '$a ?: false;'
     ].join('\n'));
-    console.log(ast);
+    console.log(ast.children[1]);
+    ast.children[1].kind.should.be.exactly('retif');
+
   });
 
   it('test silent', function() {

test/precedence.js

@@ -0,0 +1,110 @@
+var should = require("should");
+var parser = require('../src/index');
+
+/**
+ * Check precedence by using parenthesis on node B
+ */
+var checkPrecedence = function(a, b) {
+  if (!a || !b) return false;
+  if (b.kind === 'parenthesis') {
+    b = b.inner;
+  }
+  for(var k in b) {
+    if (b.hasOwnProperty(k)) {
+      if (!a.hasOwnProperty(k)) return false;
+      if (typeof b[k] === 'object') {
+        checkPrecedence(a[k], b[k]);
+      } else {
+        a[k].should.be.equal(b[k]);
+      }
+    }
+  }
+  return true;
+};
+
+var shouldBeSame = function(a, b) {
+  var ast = parser.parseEval([
+    a + ';',
+    b + ';'
+  ].join('\n'));
+  checkPrecedence(ast.children[0], ast.children[1]).should.be.true();
+};
+
+// START TESTS HERE
+describe('Test precedence', function() {
+  it('test *', function() {
+    shouldBeSame('5 * 3 - 2', '(5 * 3) - 2');
+    shouldBeSame('2 - 5 * 3', '2 - (5 * 3)');
+  });
+  it('test /', function() {
+    shouldBeSame('5 / 3 + 2', '(5 / 3) + 2');
+    shouldBeSame('5 + 3 / 2', '5 + (3 / 2)');
+  });
+  it('test %', function() {
+    shouldBeSame('5 % 3 . 2', '(5 % 3) . 2');
+  });
+  it('test instanceof', function() {
+    shouldBeSame('3 instanceof 2 * 5', '(3 instanceof 2) * 5');
+  });
+  it('test <<', function() {
+    shouldBeSame('1 + 3 << 5', '(1 + 3) << 5');
+  });
+  it('test ==', function() {
+    shouldBeSame('1 + 5 == 3', '(1 + 5 ) == 3');
+  });
+  it('test &', function() {
+    shouldBeSame('1 == 2 & 3', '(1 == 2) & 3');
+  });
+  it('test ^', function() {
+    shouldBeSame('1 & 2 ^ 3', '(1 & 2) ^ 3');
+  });
+  it('test |', function() {
+    shouldBeSame('1 ^ 2 | 3', '(1 ^ 2) | 3;');
+  });
+  it('test &&', function() {
+    var ast = parser.parseEval([
+      '1 | 2 && 3;',
+      '(1 | 2) && 3;'
+    ].join('\n'));
+    checkPrecedence(ast.children[0],ast.children[1]).should.be.true();
+  });
+  it('test ||', function() {
+    var ast = parser.parseEval([
+      '1 && 2 || 3;',
+      '(1 && 2) || 3;'
+    ].join('\n'));
+    checkPrecedence(ast.children[0], ast.children[1]).should.be.true();
+  });
+  it('test ??', function() {
+    var ast = parser.parseEval([
+      '1 || 2 ?? 3;',
+      '(1 || 2) ?? 3;'
+    ].join('\n'));
+    checkPrecedence(ast.children[0], ast.children[1]).should.be.true();
+  });
+  it('test ?:', function() {
+    shouldBeSame('1 ?? 2 ? 3 : 5', '(1 ?? 2) ? 3 : 5');
+    shouldBeSame('1 and 2 ? 3 : 5', '1 and (2 ? 3 : 5)');
+  });
+  it('test =', function() {
+    shouldBeSame('5 + $a = 1', '5 + ($a = 1)');
+    shouldBeSame('5 XOR $a += 1', '5 XOR ($a += 1)');
+  });
+  it('test OR', function() {
+    shouldBeSame('5 XOR 4 OR 3', '(5 XOR 4) OR 3');
+    shouldBeSame('5 OR 4 XOR 3', '5 OR (4 XOR 3)');
+  });
+  it('test XOR', function() {
+    shouldBeSame('5 AND 4 XOR 3', '(5 AND 4) XOR 3');
+    shouldBeSame('5 XOR 4 AND 3', '5 XOR (4 AND 3)');
+  });
+  it('test AND', function() {
+    shouldBeSame('5 + 4 AND 3', '(5 + 4) AND 3');
+    shouldBeSame('5 AND 4 + 3', '5 AND (4 + 3)');
+  });
+  it('test !', function() {
+    shouldBeSame('!4 instanceof 3', '(!4) instanceof 3');
+    shouldBeSame('!4 + 5 instanceof 3', '(!4) + (5 instanceof 3)');
+    shouldBeSame('6 + !4 + 5', '6 + (!4) + 5');
+  });
+});