Use UnaryOperator and BinaryOperator in ConstantSystem.

pkg/compiler/lib/src/constants/expressions.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 dart2js.constants.expressions;
 
 import '../dart2jslib.dart' show assertDebugMode;
 import '../dart_types.dart';
 import '../elements/elements.dart' show
     Element,
     FunctionElement,
     VariableElement;
+import '../resolution/operators.dart';
 import '../universe/universe.dart' show CallStructure;
 import 'values.dart';
 
 /// An expression that is a compile-time constant.
 ///
 /// Whereas [ConstantValue] represent a compile-time value, a
 /// [ConstantExpression] represents an expression for creating a constant.
 ///
 /// There is no one-to-one mapping between [ConstantExpression] and
 /// [ConstantValue], because different expressions can denote the same constant.
@@ skipping 152 matching lines @@
   final FunctionConstantValue value;
   final FunctionElement element;
 
   FunctionConstantExpression(this.value, this.element);
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitFunction(this, context);
   }
 }
 
-/// A constant binary expression like `a * b` or `identical(a, b)`.
+/// A constant binary expression like `a * b`.
 class BinaryConstantExpression extends ConstantExpression {
   final ConstantValue value;
   final ConstantExpression left;
-  final String operator;
+  final BinaryOperator operator;
   final ConstantExpression right;
 
   BinaryConstantExpression(this.value, this.left, this.operator, this.right) {
-    assert(PRECEDENCE_MAP[operator] != null);
+    assert(PRECEDENCE_MAP[operator.kind] != null);
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitBinary(this, context);
   }
 
-  int get precedence => PRECEDENCE_MAP[operator];
+  int get precedence => PRECEDENCE_MAP[operator.kind];
 
-  static const Map<String, int> PRECEDENCE_MAP = const {
-    'identical': 15,
-    '==': 6,
-    '!=': 6,
-    '&&': 5,
-    '||': 4,
-    '^': 9,
-    '&': 10,
-    '|': 8,
-    '>>': 11,
-    '<<': 11,
-    '+': 12,
-    '-': 12,
-    '*': 13,
-    '/': 13,
-    '~/': 13,
-    '>': 7,
-    '<': 7,
-    '>=': 7,
-    '<=': 7,
-    '%': 13,
+  static const Map<BinaryOperatorKind, int> PRECEDENCE_MAP = const {
+    BinaryOperatorKind.EQ: 6,
+    BinaryOperatorKind.NOT_EQ: 6,
+    BinaryOperatorKind.LOGICAL_AND: 5,
+    BinaryOperatorKind.LOGICAL_OR: 4,
+    BinaryOperatorKind.XOR: 9,
+    BinaryOperatorKind.AND: 10,
+    BinaryOperatorKind.OR: 8,
+    BinaryOperatorKind.SHR: 11,
+    BinaryOperatorKind.SHL: 11,
+    BinaryOperatorKind.ADD: 12,
+    BinaryOperatorKind.SUB: 12,
+    BinaryOperatorKind.MUL: 13,
+    BinaryOperatorKind.DIV: 13,
+    BinaryOperatorKind.IDIV: 13,
+    BinaryOperatorKind.GT: 7,
+    BinaryOperatorKind.LT: 7,
+    BinaryOperatorKind.GTEQ: 7,
+    BinaryOperatorKind.LTEQ: 7,
+    BinaryOperatorKind.MOD: 13,
   };
 }
 
+/// A constant identical invocation like `identical(a, b)`.
+class IdenticalConstantExpression extends ConstantExpression {
+  final ConstantValue value;
+  final ConstantExpression left;
+  final ConstantExpression right;
+
+  IdenticalConstantExpression(this.value, this.left, this.right);
+
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitIdentical(this, context);
+  }
+
+  int get precedence => 15;
+}
+
 /// A unary constant expression like `-a`.
 class UnaryConstantExpression extends ConstantExpression {
   final ConstantValue value;
-  final String operator;
+  final UnaryOperator operator;
   final ConstantExpression expression;
 
   UnaryConstantExpression(this.value, this.operator, this.expression) {
-    assert(PRECEDENCE_MAP[operator] != null);
+    assert(PRECEDENCE_MAP[operator.kind] != null);
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitUnary(this, context);
   }
 
-  int get precedence => PRECEDENCE_MAP[operator];
+  int get precedence => PRECEDENCE_MAP[operator.kind];
 
-  static const Map<String, int> PRECEDENCE_MAP = const {
-    '!': 14,
-    '~': 14,
-    '-': 14,
+  static const Map<UnaryOperatorKind, int> PRECEDENCE_MAP = const {
+    UnaryOperatorKind.NOT: 14,
+    UnaryOperatorKind.COMPLEMENT: 14,
+    UnaryOperatorKind.NEGATE: 14,
   };
 }
 
 /// A constant conditional expression like `a ? b : c`.
 class ConditionalConstantExpression extends ConstantExpression {
   final ConstantValue value;
   final ConstantExpression condition;
   final ConstantExpression trueExp;
   final ConstantExpression falseExp;
 
@@ skipping 19 matching lines @@
   R visitPrimitive(PrimitiveConstantExpression exp, C context);
   R visitList(ListConstantExpression exp, C context);
   R visitMap(MapConstantExpression exp, C context);
   R visitConstructed(ConstructedConstantExpression exp, C context);
   R visitConcatenate(ConcatenateConstantExpression exp, C context);
   R visitSymbol(SymbolConstantExpression exp, C context);
   R visitType(TypeConstantExpression exp, C context);
   R visitVariable(VariableConstantExpression exp, C context);
   R visitFunction(FunctionConstantExpression exp, C context);
   R visitBinary(BinaryConstantExpression exp, C context);
+  R visitIdentical(IdenticalConstantExpression exp, C context);
   R visitUnary(UnaryConstantExpression exp, C context);
   R visitConditional(ConditionalConstantExpression exp, C context);
 }
 
 /// Represents the declaration of a constant [element] with value [expression].
 // TODO(johnniwinther): Where does this class belong?
 class ConstDeclaration {
   final VariableElement element;
   final ConstantExpression expression;
 
@@ skipping 133 matching lines @@
   void visitFunction(FunctionConstantExpression exp, [_]) {
     if (exp.element.isStatic) {
       sb.write(exp.element.enclosingClass.name);
       sb.write('.');
     }
     sb.write(exp.element.name);
   }
 
   @override
   void visitBinary(BinaryConstantExpression exp, [_]) {
-    if (exp.operator == 'identical') {
-      sb.write('identical(');
-      visit(exp.left);
-      sb.write(', ');
-      visit(exp.right);
-      sb.write(')');
-    } else {
-      write(exp, exp.left);
-      sb.write(' ');
-      sb.write(exp.operator);
-      sb.write(' ');
-      write(exp, exp.right);
-    }
+    write(exp, exp.left);
+    sb.write(' ');
+    sb.write(exp.operator.name);
+    sb.write(' ');
+    write(exp, exp.right);
   }
 
   @override
+  void visitIdentical(IdenticalConstantExpression exp, [_]) {
+    sb.write('identical(');
+    visit(exp.left);
+    sb.write(', ');
+    visit(exp.right);
+    sb.write(')');
+  }
+
+  @override
   void visitUnary(UnaryConstantExpression exp, [_]) {
     sb.write(exp.operator);
     write(exp, exp.expression);
   }
 
   @override
   void visitConditional(ConditionalConstantExpression exp, [_]) {
     write(exp, exp.condition, leftAssociative: false);
     sb.write(' ? ');
     write(exp, exp.trueExp);
     sb.write(' : ');
     write(exp, exp.falseExp);
   }
 
   String toString() => sb.toString();
 }