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 isSentinel() => false;
 
   bool isNaN() => false;
   bool isMinusZero() => false;
 
+  bool get isType => false;

[ngeoffray, 2012/11/15 16:07:24]

bool isType() => false and move it to where the other predicates are.

[karlklose, 2012/11/19 15:08:58]

Done.

+
   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 249 matching lines @@
 }
 
 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;

[floitsch, 2012/11/16 13:53:31]

Remove the hashCode line too.

[karlklose, 2012/11/19 15:08:58]

Done.

 }
 
+class TypeConstant extends Constant {

[ngeoffray, 2012/11/15 16:07:24]

extends ObjectConstant ?

[karlklose, 2012/11/19 15:08:58]

Done.

+  /// The user type that this constant represents.
+  final DartType representedType;
+  /// The type of the constant (currently always [Type]).

[ngeoffray, 2012/11/15 16:07:24]

Should it be something else? Please add a comment.

[karlklose, 2012/11/19 15:08:58]

It could be more specific in the future, but the comment is perhaps misleading.
After extending ObjectConstant, I removed this comment, since it is now clear
how this type is used.

+  final DartType type;
+
+  TypeConstant(this.representedType, this.type);
+
+  bool get isType => true;
+  bool isObject() => true;
+
+  DartType computeType(Compiler compiler) {
+    return compiler.typeClass.computeType(compiler);

[ngeoffray, 2012/11/15 16:07:24]

Remove, it will be inherited with ObjectConstant.

[karlklose, 2012/11/19 15:08:58]

Done.

+  }
+
+  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);
   bool isList() => true;
 
@@ skipping 113 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);
 }