WIP: Compute constant expressions in resolution.

pkg/compiler/lib/src/constant_system_dart.dart

 // Copyright (c) 2012, 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.constant_system.dart;
 
 import 'compiler.dart' show
     Compiler;
 import 'constants/constant_system.dart';
 import 'constants/values.dart';
 import 'dart_types.dart';
+import 'elements/elements.dart' show
+    ClassElement,
+    FieldElement;
 import 'tree/tree.dart' show
     DartString;
 
 const DART_CONSTANT_SYSTEM = const DartConstantSystem();
 
 class BitNotOperation implements UnaryOperation {
   final String name = '~';
   const BitNotOperation();
   ConstantValue fold(ConstantValue constant) {
     if (constant.isInt) {
@@ skipping 290 matching lines @@
     if (left.isConstructedObject) {
       // Unless we know that the user-defined object does not implement the
       // equality operator we cannot fold here.
       return null;
     }
     return DART_CONSTANT_SYSTEM.createBool(left == right);
   }
   apply(left, right) => left == right;
 }
 
+class NotEqualsOperation implements BinaryOperation {
+  final String name = '!=';
+  const NotEqualsOperation();
+
+  @override
+  ConstantValue fold(ConstantValue left, ConstantValue right) {
+    BoolConstantValue result = const EqualsOperation().fold(left, right);
+    if (result != null) {
+      result = result.negate();
+    }
+    return result;
+  }
+
+  apply(left, right) => left != right;
+}
+
 class IdentityOperation implements BinaryOperation {
   final String name = '===';
   const IdentityOperation();
   BoolConstantValue fold(ConstantValue left, ConstantValue right) {
     // In order to preserve runtime semantics which says that NaN !== NaN don't
     // constant fold NaN === NaN. Otherwise the output depends on inlined
     // variables and other optimizations.
     if (left.isNaN && right.isNaN) return null;
     return DART_CONSTANT_SYSTEM.createBool(left == right);
   }
@@ skipping 49 matching lines @@
   final equal = const EqualsOperation();
   final greaterEqual = const GreaterEqualOperation();
   final greater = const GreaterOperation();
   final identity = const IdentityOperation();
   final lessEqual = const LessEqualOperation();
   final less = const LessOperation();
   final modulo = const ModuloOperation();
   final multiply = const MultiplyOperation();
   final negate = const NegateOperation();
   final not = const NotOperation();
+  final notEqual = const NotEqualsOperation();
   final shiftLeft = const ShiftLeftOperation();
   final shiftRight = const ShiftRightOperation();
   final subtract = const SubtractOperation();
   final truncatingDivide = const TruncatingDivideOperation();
   final codeUnitAt = const CodeUnitAtConstantOperation();
 
   const DartConstantSystem();
 
 
   @override
@@ skipping 29 matching lines @@
 
   @override
   ConstantValue createType(Compiler compiler, DartType type) {
     // TODO(johnniwinther): Change the `Type` type to
     // `compiler.coreTypes.typeType` and check the backend specific value in
     // [checkConstMapKeysDontOverrideEquals] in 'members.dart'.
     return new TypeConstantValue(type,
         compiler.backend.typeImplementation.computeType(compiler.resolution));
   }
 
+  @override
+  ConstantValue createSymbol(Compiler compiler, String text) {
+    // TODO(johnniwinther): Create a backend agnostic value.
+    InterfaceType type = compiler.symbolClass.rawType;
+    ConstantValue argument = createString(new DartString.literal(text));
+    Map<FieldElement, ConstantValue> fields = <FieldElement, ConstantValue>{};
+    compiler.symbolImplementationClass.forEachInstanceField(
+        (ClassElement enclosingClass, FieldElement field) {
+      fields[field] = argument;
+    });
+    assert(fields.length == 1);
+    return new ConstructedConstantValue(type, fields);
+  }
+
   bool isInt(ConstantValue constant) => constant.isInt;
   bool isDouble(ConstantValue constant) => constant.isDouble;
   bool isString(ConstantValue constant) => constant.isString;
   bool isBool(ConstantValue constant) => constant.isBool;
   bool isNull(ConstantValue constant) => constant.isNull;
 
   bool isSubtype(DartTypes types, DartType s, DartType t) {
     return types.isSubtype(s, t);
   }
 }