Use UnaryOperator and BinaryOperator in ConstantSystem.

pkg/compiler/lib/src/resolution/operators.dart

 // Copyright (c) 2015, 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.operators;
 
+import '../elements/elements.dart';
+
 enum UnaryOperatorKind {
   NOT,
   NEGATE,
   COMPLEMENT,
 }
 
 class UnaryOperator {
   final UnaryOperatorKind kind;
   final String name;
   final String selectorName;
@@ skipping 19 matching lines @@
   static UnaryOperator parse(String value) {
     switch (value) {
       case '!': return NOT;
       case '-': return NEGATE;
       case '~': return COMPLEMENT;
       default: return null;
     }
   }
 }
 
-
 enum BinaryOperatorKind {
   EQ,
   NOT_EQ,
   INDEX,
   ADD,
   SUB,
   MUL,
   DIV,
   IDIV,
   MOD,
   SHL,
   SHR,
   GTEQ,
   GT,
   LTEQ,
   LT,
   AND,
   OR,
   XOR,
+  LOGICAL_AND,
+  LOGICAL_OR,
 }
 
 class BinaryOperator {
   final BinaryOperatorKind kind;
   final String name;
 
   const BinaryOperator._(this.kind, this.name);
 
+  /// `true` if this operator can be implemented through an `operator [name]`
+  /// method.
   bool get isUserDefinable => true;
+
   String get selectorName => name;
 
   String toString() => name;
 
   /// The == operator.
   static const BinaryOperator EQ =
       const BinaryOperator._(BinaryOperatorKind.EQ, '==');
 
   /// The != operator.
   static const BinaryOperator NOT_EQ = const _NotEqualsOperator();
@@ skipping 55 matching lines @@
       const BinaryOperator._(BinaryOperatorKind.AND, '&');
 
   /// The binary | operator.
   static const BinaryOperator OR =
       const BinaryOperator._(BinaryOperatorKind.OR, '|');
 
   /// The binary ^ operator.
   static const BinaryOperator XOR =
       const BinaryOperator._(BinaryOperatorKind.XOR, '^');
 
+  /// The logical && operator.
+  static const BinaryOperator LOGICAL_AND =
+      const _LogicalOperator(BinaryOperatorKind.LOGICAL_AND, '&&');
+
+  /// The binary | operator.
+  static const BinaryOperator LOGICAL_OR =
+      const _LogicalOperator(BinaryOperatorKind.LOGICAL_OR, '||');
+
   static BinaryOperator parse(String value) {
     switch (value) {
       case '==': return EQ;
       case '!=': return NOT_EQ;
       case '[]': return INDEX;
       case '*': return MUL;
       case '/': return DIV;
       case '%': return MOD;
       case '~/': return IDIV;
       case '+': return ADD;
       case '-': return SUB;
       case '<<': return SHL;
       case '>>': return SHR;
       case '>=': return GTEQ;
       case '>': return GT;
       case '<=': return LTEQ;
       case '<': return LT;
       case '&': return AND;
       case '^': return XOR;
       case '|': return OR;
+      case '&&': return LOGICAL_AND;
+      case '||': return LOGICAL_OR;
       default: return null;
     }
   }
 }
 
-/// The operator !=, which is not user definable operator but instead is a negation
+/// The operator !=, which is not user definable operator but instead is a
+/// negation of a call to user definable operator, namely ==.
 class _NotEqualsOperator extends BinaryOperator {
   const _NotEqualsOperator() : super._(BinaryOperatorKind.NOT_EQ, '!=');
 
   bool get isUserDefinable => false;
 
   String get selectorName => '==';
 }
 
+/// The operators && and || which are not user definable operators but control
+/// structures.
+class _LogicalOperator extends BinaryOperator {
+  const _LogicalOperator(BinaryOperatorKind kind, String name)
+      : super._(kind, name);
+
+  bool get isUserDefinable => false;
+
+  String get selectorName => null;
+}
+
 enum AssignmentOperatorKind {
   ASSIGN,
   ADD,
   SUB,
   MUL,
   DIV,
   IDIV,
   MOD,
   SHL,
   SHR,
@@ skipping 121 matching lines @@
       const IncDecOperator._(IncDecOperatorKind.DEC, '--', BinaryOperator.SUB);
 
   static IncDecOperator parse(String value) {
     switch (value) {
       case '++': return INC;
       case '--': return DEC;
       default: return null;
     }
   }
 }