Support type literals as compile-time constants.

sdk/lib/_internal/compiler/implementation/constants.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.
 
 part of dart2js;
 
 abstract class ConstantVisitor<R> {
   R visitSentinel(SentinelConstant constant);
   R visitFunction(FunctionConstant constant);
   R visitNull(NullConstant constant);
   R visitInt(IntConstant constant);
   R visitDouble(DoubleConstant constant);
   R visitTrue(TrueConstant constant);
   R visitFalse(FalseConstant constant);
   R visitString(StringConstant constant);
   R visitList(ListConstant constant);
   R visitMap(MapConstant constant);
   R visitConstructed(ConstructedConstant constant);
+  R visitType(TypeConstant constant);
 }
 
 abstract class Constant {
   const Constant();
 
   bool isNull() => false;
   bool isBool() => false;
   bool isTrue() => false;
   bool isFalse() => false;
   bool isInt() => false;
   bool isDouble() => false;
   bool isNum() => false;
   bool isString() => false;
   bool isList() => false;
   bool isMap() => false;
   bool isConstructedObject() => false;
   bool isFunction() => false;
   /** Returns true if the constant is null, a bool, a number or a string. */
   bool isPrimitive() => false;
   /** Returns true if the constant is a list, a map or a constructed object. */
   bool isObject() => false;
+  bool isType() => false;
   bool isSentinel() => false;
 
   bool isNaN() => false;
   bool isMinusZero() => false;
 
   DartType computeType(Compiler compiler);
 
   List<Constant> getDependencies();
 
-  accept(ConstantVisitor);
+  accept(ConstantVisitor visitor);
 }
 
 class SentinelConstant extends Constant {
   const SentinelConstant();
   static final SENTINEL = const SentinelConstant();
 
   List<Constant> getDependencies() => const <Constant>[];
 
   // Just use a random value.
   int get hashCode => 24297418;
@@ skipping 248 matching lines @@
   accept(ConstantVisitor visitor) => visitor.visitString(this);
 }
 
 abstract class ObjectConstant extends Constant {
   final DartType type;
 
   ObjectConstant(this.type);
   bool isObject() => true;
 
   DartType computeType(Compiler compiler) => type;
+}
 
-  // TODO(1603): The class should be marked as abstract, but the VM doesn't
-  // currently allow this.
-  int get hashCode;
+class TypeConstant extends ObjectConstant {
+  /// The user type that this constant represents.
+  final DartType representedType;
+
+  TypeConstant(this.representedType, type) : super(type);
+
+  bool isType() => true;
+
+  bool operator ==(other) {
+    return other is TypeConstant && representedType == other.representedType;
+  }
+
+  int get hashCode => representedType.hashCode * 13;
+
+  List<Constant> getDependencies() => const <Constant>[];
+
+  accept(ConstantVisitor visitor) => visitor.visitType(this);
 }
 
 class ListConstant extends ObjectConstant {
   final List<Constant> entries;
   final int hashCode;
 
   ListConstant(DartType type, List<Constant> entries)
       : this.entries = entries,
         hashCode = _computeHash(entries),
         super(type);
@@ skipping 115 matching lines @@
     for (int i = 0; i < fields.length; i++) {
       if (fields[i] != other.fields[i]) return false;
     }
     return true;
   }
 
   List<Constant> getDependencies() => fields;
 
   accept(ConstantVisitor visitor) => visitor.visitConstructed(this);
 }