dart2dart: Logical operators and related rewrite rules in dart_tree.

sdk/lib/_internal/compiler/implementation/dart_backend/tree_tracer.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart_backend.tracer;
 
 import 'dart:async' show EventSink;
 import '../tracer.dart';
 import 'dart_tree.dart';
 
@@ skipping 34 matching lines @@
     visitStatement(function.body);
   }
 
   visitVariable(Variable node) {}
   visitInvokeStatic(InvokeStatic node) {}
   visitInvokeMethod(InvokeMethod node) {}
   visitInvokeConstructor(InvokeConstructor node) {}
   visitConcatenateStrings(ConcatenateStrings node) {}
   visitConstant(Constant node) {}
   visitConditional(Conditional node) {}
+  visitLogicalOperator(LogicalOperator node) {}
+  visitNot(Not node) {}
 
   visitLabeledStatement(LabeledStatement node) {
     Block target = new Block();
     breakTargets[node.label] = target;
     visitStatement(node.body);
     _addBlock(target);
     visitStatement(node.next);
   }
 
   visitAssign(Assign node) {
@@ skipping 114 matching lines @@
   }
 
   visitConcatenateStrings(ConcatenateStrings node) {
     printStatement(null, expr(node));
   }
 
   visitConditional(Conditional node) {
     printStatement(null, expr(node));
   }
 
+  visitLogicalOperator(LogicalOperator node) {
+    printStatement(null, expr(node));
+  }
+
+  visitNot(Not node) {
+    printStatement(null, expr(node));
+  }
+
   visitReturn(Return node) {
     printStatement(null, "return ${expr(node.value)}");
   }
 
   visitBreak(Break node) {
     printStatement(null, "break ${collector.breakTargets[node.target].name}");
   }
 
   visitIf(If node) {
     String condition = expr(node.condition);
@@ skipping 60 matching lines @@
 
   String visitConcatenateStrings(ConcatenateStrings node) {
     String args = node.arguments.map(visitExpression).join(', ');
     return "concat [$args]";
   }
 
   String visitConstant(Constant node) {
     return "${node.value}";
   }
 
+  bool usesInfixNotation(Expression node) {
+    return node is Conditional || node is LogicalOperator;

[Kevin Millikin (Google), 2014/05/19 11:36:41]

The implementation doesn't seem to match the name.  I  worry that it either
doesn't scale or is a source of later bugs.

I would expect an implementation like !usesPrefixNotation(node) &&
!usesPostfixNotation(node).  Alternately, a different approach in terms of
precedence.

I guess it's fine for now.

[asgerf, 2014/05/19 13:29:07]

Yeah we need proper precedence-awareness. Right now, things like (x ? y :
z).foo() will be printed as x ? y : z.foo() in the tracer.

+  }
+
   String visitConditional(Conditional node) {
-    return visitExpression(node.condition) + ' ? ' +
-           visitExpression(node.thenExpression) + ' : ' +
-           visitExpression(node.elseExpression);
+    String condition = visitExpression(node.condition);
+    String thenExpr = visitExpression(node.thenExpression);
+    String elseExpr = visitExpression(node.elseExpression);
+    return "$condition ? $thenExpr : $elseExpr";
+  }
+
+  String visitLogicalOperator(LogicalOperator node) {
+    String left = visitExpression(node.left);
+    String right = visitExpression(node.right);
+    if (usesInfixNotation(node.left)) {
+      left = "($left)";
+    }
+    if (usesInfixNotation(node.right)) {
+      right = "($right)";
+    }
+    return "$left ${node.operator} $right";
+  }
+
+  String visitNot(Not node) {
+    String operand = visitExpression(node.operand);
+    if (usesInfixNotation(node.operand)) {
+      operand = '($operand)';
+    }
+    return '!$operand';
   }
 
   // Note: There should not be statements in the context of expressions.
   String visitStatement(Statement node) {
     return "$node statement in expression context";
   }
 
   String visitLabeledStatement(LabeledStatement node) => visitStatement(node);
   String visitAssign(Assign node) => visitStatement(node);
   String visitReturn(Return node) => visitStatement(node);
@@ skipping 25 matching lines @@
       }
       while (name == null || _usedNames.contains(name)) {
         name = "v${_counter++}";
       }
       _names[v] = name;
       _usedNames.add(name);
     }
     return name;
   }
 }