Fix type annotation for deferred constants.

pkg/compiler/lib/src/resolution/semantic_visitor.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.semantics_visitor;
 
 import '../constants/expressions.dart';
 import '../dart2jslib.dart' show invariant;
 import '../dart_types.dart';
 import '../elements/elements.dart';
@@ skipping 882 matching lines @@
       A arg);
 
   /// Read of the type literal for class [element].
   ///
   /// For instance
   ///     class C {}
   ///     m() => C;
   ///
   R visitClassTypeLiteralGet(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       A arg);
 
   /// Invocation of the type literal for class [element] with [arguments].
   ///
   /// For instance
   ///     class C {}
   ///     m() => C(null, 42);
   ///
   R visitClassTypeLiteralInvoke(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       NodeList arguments,
       Selector selector,
       A arg);
 
   /// Assignment of [rhs] to the type literal for class [element].
   ///
   /// For instance
   ///     class C {}
   ///     m() { C = rhs; }
   ///
   R errorClassTypeLiteralSet(
       SendSet node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       Node rhs,
       A arg);
 
   /// Read of the type literal for typedef [element].
   ///
   /// For instance
   ///     typedef F();
   ///     m() => F;
   ///
   R visitTypedefTypeLiteralGet(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       A arg);
 
   /// Invocation of the type literal for typedef [element] with [arguments].
   ///
   /// For instance
   ///     typedef F();
   ///     m() => F(null, 42);
   ///
   R visitTypedefTypeLiteralInvoke(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       NodeList arguments,
       Selector selector,
       A arg);
 
   /// Assignment of [rhs] to the type literal for typedef [element].
   ///
   /// For instance
   ///     typedef F();
   ///     m() { F = rhs; }
   ///
   R errorTypedefTypeLiteralSet(
       SendSet node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       Node rhs,
       A arg);
 
   /// Read of the type literal for type variable [element].
   ///
   /// For instance
   ///     class C<T> {
   ///       m() => T;
   ///     }
   ///
@@ skipping 30 matching lines @@
       Node rhs,
       A arg);
 
   /// Read of the type literal for `dynamic`.
   ///
   /// For instance
   ///     m() => dynamic;
   ///
   R visitDynamicTypeLiteralGet(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       A arg);
 
   /// Invocation of the type literal for `dynamic` with [arguments].
   ///
   /// For instance
   ///     m() { dynamic(null, 42); }
   ///
   R visitDynamicTypeLiteralInvoke(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       NodeList arguments,
       Selector selector,
       A arg);
 
   /// Assignment of [rhs] to the type literal for `dynamic`.
   ///
   /// For instance
   ///     m() { dynamic = rhs; }
   ///
   R errorDynamicTypeLiteralSet(
       SendSet node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       Node rhs,
       A arg);
 
   /// Call to `assert` with [expression] as the condition.
   ///
   /// For instance:
   ///     m() { assert(expression); }
   ///
   R visitAssert(
       Send node,
@@ skipping 740 matching lines @@
 
   /// Compound assignment expression of [rhs] with [operator] on a type literal
   /// for class [element].
   ///
   /// For instance:
   ///     class C {}
   ///     m(rhs) => C += rhs;
   ///
   R errorClassTypeLiteralCompound(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a type literal
   /// for typedef [element].
   ///
   /// For instance:
   ///     typedef F();
   ///     m(rhs) => F += rhs;
   ///
   R errorTypedefTypeLiteralCompound(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a type literal
   /// for type variable [element].
   ///
   /// For instance:
   ///     class C<T> {
   ///       m(rhs) => T += rhs;
   ///     }
   ///
   R errorTypeVariableTypeLiteralCompound(
       Send node,
       TypeVariableElement element,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on the type
   /// literal for `dynamic`.
   ///
   /// For instance:
   ///     m(rhs) => dynamic += rhs;
   ///
   R errorDynamicTypeLiteralCompound(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on the index
   /// operators of [receiver] whose getter and setter are defined by
   /// [getterSelector] and [setterSelector], respectively.
   ///
   /// For instance:
   ///     m(receiver, index, rhs) => receiver[index] += rhs;
@@ skipping 312 matching lines @@
       A arg);
 
   /// Prefix expression with [operator] on a type literal for a class [element].
   ///
   /// For instance:
   ///     class C {}
   ///     m() => ++C;
   ///
   R errorClassTypeLiteralPrefix(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Prefix expression with [operator] on a type literal for a typedef
   /// [element].
   ///
   /// For instance:
   ///     typedef F();
   ///     m() => ++F;
   ///
   R errorTypedefTypeLiteralPrefix(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Prefix expression with [operator] on a type literal for a type variable
   /// [element].
   ///
   /// For instance:
   ///     class C<T> {
   ///       m() => ++T;
   ///     }
   ///
   R errorTypeVariableTypeLiteralPrefix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       A arg);
 
   /// Prefix expression with [operator] on the type literal for `dynamic`.
   ///
   /// For instance:
   ///     m() => ++dynamic;
   ///
   R errorDynamicTypeLiteralPrefix(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] of the property on [receiver] whose
   /// getter and setter are defined by [getterSelector] and [setterSelector],
   /// respectively.
   ///
   /// For instance:
   ///     m(receiver) => receiver.foo++;
   ///
@@ skipping 276 matching lines @@
 
   /// Postfix expression with [operator] on a type literal for a class
   /// [element].
   ///
   /// For instance:
   ///     class C {}
   ///     m() => C++;
   ///
   R errorClassTypeLiteralPostfix(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] on a type literal for a typedef
   /// [element].
   ///
   /// For instance:
   ///     typedef F();
   ///     m() => F++;
   ///
   R errorTypedefTypeLiteralPostfix(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] on a type literal for a type variable
   /// [element].
   ///
   /// For instance:
   ///     class C<T> {
   ///       m() => T++;
   ///     }
   ///
   R errorTypeVariableTypeLiteralPostfix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] on the type literal for `dynamic`.
   ///
   /// For instance:
   ///     m() => dynamic++;
   ///
   R errorDynamicTypeLiteralPostfix(
       Send node,
-      TypeConstantExpression constant,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Read of the [constant].
   ///
   /// For instance
   ///     const c = c;
   ///     m() => c;
   ///
   R visitConstantGet(
@@ skipping 203 matching lines @@
 
   /// Invocation of an undefined unary [operator] with operands
   /// [left] and [right].
   R errorUndefinedBinaryExpression(
       Send node,
       Node left,
       Operator operator,
       Node right,
       A arg);
 }