Prefix resolution_types with Resolution.

pkg/compiler/lib/src/compile_time_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.
 
 library dart2js.compile_time_constant_evaluator;
 
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask, Measurer;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
@@ skipping 234 matching lines @@
       // No initial value.
       expression = new NullConstantExpression();
       constantValueMap[expression] = constantSystem.createNull();
     } else {
       expression = compileNodeWithDefinitions(initializer, definitions,
           isConst: isConst);
       if (compiler.options.enableTypeAssertions &&
           checkType &&
           expression != null &&
           element.isField) {
-        DartType elementType = element.type;
+        ResolutionDartType elementType = element.type;
         ConstantValue value = getConstantValue(expression);
         if (elementType.isMalformed && !value.isNull) {
           if (isConst) {
             // TODO(johnniwinther): Check that it is possible to reach this
             // point in a situation where `elementType is! MalformedType`.
             if (elementType is MalformedType) {
               ErroneousElement element = elementType.element;
               reporter.reportErrorMessage(
                   node, element.messageKind, element.messageArguments);
             } else {
               assert(elementType is MethodTypeVariableType);
               reporter.reportErrorMessage(
                   node, MessageKind.TYPE_VARIABLE_FROM_METHOD_NOT_REIFIED);
             }
           } else {
             // We need to throw an exception at runtime.
             expression = null;
           }
         } else {
-          DartType constantType = value.getType(commonElements);
+          ResolutionDartType constantType = value.getType(commonElements);
           if (!constantSystem.isSubtype(
               compiler.types, constantType, elementType)) {
             if (isConst) {
               reporter.reportErrorMessage(node, MessageKind.NOT_ASSIGNABLE,
                   {'fromType': constantType, 'toType': elementType});
             } else {
               // If the field cannot be lazily initialized, we will throw
               // the exception at runtime.
               expression = null;
             }
@@ skipping 177 matching lines @@
     for (Link<Node> link = node.elements.nodes;
         !link.isEmpty;
         link = link.tail) {
       AstConstant argument = evaluateConstant(link.head);
       if (argument == null || argument.isError) {
         return argument;
       }
       argumentExpressions.add(argument.expression);
       argumentValues.add(argument.value);
     }
-    DartType type = elements.getType(node);
+    ResolutionDartType type = elements.getType(node);
     return new AstConstant(
         context,
         node,
         new ListConstantExpression(type, argumentExpressions),
         constantSystem.createList(type, argumentValues));
   }
 
   AstConstant visitLiteralMap(LiteralMap node) {
     if (!node.isConst) {
       return signalNotCompileTimeConstant(node);
@@ skipping 17 matching lines @@
       if (!map.containsKey(key.value)) {
         keyValues.add(key.value);
       } else {
         reporter.reportWarningMessage(
             entry.key, MessageKind.EQUAL_MAP_ENTRY_KEY);
       }
       keyExpressions.add(key.expression);
       valueExpressions.add(value.expression);
       map[key.value] = value.value;
     }
-    InterfaceType type = elements.getType(node);
+    ResolutionInterfaceType type = elements.getType(node);
     return new AstConstant(
         context,
         node,
         new MapConstantExpression(type, keyExpressions, valueExpressions),
         constantSystem.createMap(
             compiler, type, keyValues, map.values.toList()));
   }
 
   AstConstant visitLiteralNull(LiteralNull node) {
     return new AstConstant(context, node, new NullConstantExpression(),
@@ skipping 65 matching lines @@
           new DartString.concat(accumulator, partStringValue.primitiveValue);
     }
     return new AstConstant(
         context,
         node,
         new ConcatenateConstantExpression(subexpressions),
         constantSystem.createString(accumulator));
   }
 
   AstConstant visitLiteralSymbol(LiteralSymbol node) {
-    InterfaceType type = commonElements.symbolType;
+    ResolutionInterfaceType type = commonElements.symbolType;
     String text = node.slowNameString;
     List<AstConstant> arguments = <AstConstant>[
       new AstConstant(context, node, new StringConstantExpression(text),
           constantSystem.createString(new LiteralDartString(text)))
     ];
     ConstructorElement constructor = compiler.commonElements.symbolConstructor;
     AstConstant constant = createConstructorInvocation(
         node, type, constructor, CallStructure.ONE_ARG,
         normalizedArguments: arguments);
     return new AstConstant(
         context, node, new SymbolConstantExpression(text), constant.value);
   }
 
-  ConstantValue makeTypeConstant(DartType elementType) {
+  ConstantValue makeTypeConstant(ResolutionDartType elementType) {
     return constantSystem.createType(compiler, elementType);
   }
 
   /// Returns true if the prefix of the send resolves to a deferred import
   /// prefix.
   bool isDeferredUse(Send send) {
     if (send == null) return false;
     return compiler.deferredLoadTask.deferredPrefixElement(send, elements) !=
         null;
   }
 
   AstConstant visitIdentifier(Identifier node) {
     Element element = elements[node];
     if (Elements.isClass(element) || Elements.isTypedef(element)) {
       TypeDeclarationElement typeDeclarationElement = element;
-      DartType type = typeDeclarationElement.rawType;
+      ResolutionDartType type = typeDeclarationElement.rawType;
       return new AstConstant(element, node, new TypeConstantExpression(type),
           makeTypeConstant(type));
     }
     return signalNotCompileTimeConstant(node);
   }
 
   // TODO(floitsch): provide better error-messages.
   AstConstant visitSend(Send send) {
     Element element = elements[send];
     if (send.isPropertyAccess) {
@@ skipping 15 matching lines @@
         }
         if (elementExpression != null) {
           result = new AstConstant(
               context,
               send,
               new VariableConstantExpression(element),
               handler.getConstantValue(elementExpression));
         }
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
         assert(elements.isTypeLiteral(send));
-        DartType elementType = elements.getTypeLiteralType(send);
+        ResolutionDartType elementType = elements.getTypeLiteralType(send);
         result = new AstConstant(
             context,
             send,
             new TypeConstantExpression(elementType),
             makeTypeConstant(elementType));
       } else if (send.receiver != null) {
         if (send.selector.asIdentifier().source == "length") {
           AstConstant left = evaluate(send.receiver);
           if (left != null && left.value.isString) {
             StringConstantValue stringConstantValue = left.value;
@@ skipping 129 matching lines @@
           folded);
     }
     return signalNotCompileTimeConstant(send);
   }
 
   AstConstant visitConditional(Conditional node) {
     AstConstant condition = evaluate(node.condition);
     if (condition == null || condition.isError) {
       return condition;
     } else if (!condition.value.isBool) {
-      DartType conditionType = condition.value.getType(commonElements);
+      ResolutionDartType conditionType =
+          condition.value.getType(commonElements);
       if (isEvaluatingConstant) {
         reporter.reportErrorMessage(node.condition, MessageKind.NOT_ASSIGNABLE,
             {'fromType': conditionType, 'toType': commonElements.boolType});
         return new ErroneousAstConstant(context, node);
       }
       return null;
     }
     AstConstant thenExpression = evaluate(node.thenExpression);
     AstConstant elseExpression = evaluate(node.elseExpression);
     if (thenExpression == null || thenExpression.isError) {
@@ skipping 66 matching lines @@
       return signalNotCompileTimeConstant(node);
     }
 
     // Deferred types can not be used in const instance creation expressions.
     // Check if the constructor comes from a deferred library.
     if (isDeferredUse(node.send.selector.asSend())) {
       return signalNotCompileTimeConstant(node,
           message: MessageKind.DEFERRED_COMPILE_TIME_CONSTANT_CONSTRUCTION);
     }
 
-    InterfaceType type = elements.getType(node);
+    ResolutionInterfaceType type = elements.getType(node);
     CallStructure callStructure = elements.getSelector(send).callStructure;
 
     return createConstructorInvocation(node, type, constructor, callStructure,
         arguments: node.send.arguments);
   }
 
-  AstConstant createConstructorInvocation(Node node, InterfaceType type,
-      ConstructorElement constructor, CallStructure callStructure,
-      {Link<Node> arguments, List<AstConstant> normalizedArguments}) {
+  AstConstant createConstructorInvocation(
+      Node node,
+      ResolutionInterfaceType type,
+      ConstructorElement constructor,
+      CallStructure callStructure,
+      {Link<Node> arguments,
+      List<AstConstant> normalizedArguments}) {
     // TODO(ahe): This is nasty: we must eagerly analyze the
     // constructor to ensure the redirectionTarget has been computed
     // correctly.  Find a way to avoid this.
     resolution.ensureResolved(constructor.declaration);
 
     // The redirection chain of this element may not have been resolved through
     // a post-process action, so we have to make sure it is done here.
     compiler.resolver.resolveRedirectionChain(constructor, node);
 
     bool isInvalid = false;
-    InterfaceType constructedType = type;
+    ResolutionInterfaceType constructedType = type;
     ConstructorElement implementation;
     if (constructor.isRedirectingFactory) {
       if (constructor.isEffectiveTargetMalformed) {
         isInvalid = true;
       } else {
         constructedType = constructor.computeEffectiveTargetType(type);
         ConstructorElement target = constructor.effectiveTarget;
         // The constructor must be an implementation to ensure that field
         // initializers are handled correctly.
         implementation = target.implementation;
@@ skipping 56 matching lines @@
           constructedType,
           implementation,
           callStructure,
           concreteArguments,
           normalizedArguments);
     }
   }
 
   AstConstant createFromEnvironmentConstant(
       Node node,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       ConstructorElement constructor,
       CallStructure callStructure,
       List<AstConstant> normalizedArguments,
       List<AstConstant> concreteArguments) {
     var firstArgument = normalizedArguments[0].value;
     ConstantValue defaultValue = normalizedArguments[1].value;
 
     if (firstArgument.isNull) {
       return reportNotCompileTimeConstant(
           normalizedArguments[0].node, MessageKind.NULL_NOT_ALLOWED);
     }
 
     if (!firstArgument.isString) {
-      DartType type = defaultValue.getType(commonElements);
+      ResolutionDartType type = defaultValue.getType(commonElements);
       return reportNotCompileTimeConstant(
           normalizedArguments[0].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type, 'toType': commonElements.stringType});
     }
 
     if (constructor.isIntFromEnvironmentConstructor &&
         !(defaultValue.isNull || defaultValue.isInt)) {
-      DartType type = defaultValue.getType(commonElements);
+      ResolutionDartType type = defaultValue.getType(commonElements);
       return reportNotCompileTimeConstant(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type, 'toType': commonElements.intType});
     }
 
     if (constructor.isBoolFromEnvironmentConstructor &&
         !(defaultValue.isNull || defaultValue.isBool)) {
-      DartType type = defaultValue.getType(commonElements);
+      ResolutionDartType type = defaultValue.getType(commonElements);
       return reportNotCompileTimeConstant(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type, 'toType': commonElements.boolType});
     }
 
     if (constructor.isStringFromEnvironmentConstructor &&
         !(defaultValue.isNull || defaultValue.isString)) {
-      DartType type = defaultValue.getType(commonElements);
+      ResolutionDartType type = defaultValue.getType(commonElements);
       return reportNotCompileTimeConstant(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type, 'toType': commonElements.stringType});
     }
 
     String name = firstArgument.primitiveValue.slowToString();
     String value = compiler.fromEnvironment(name);
 
     AstConstant createEvaluatedConstant(ConstantValue value) {
@@ skipping 36 matching lines @@
       return createEvaluatedConstant(
           constantSystem.createString(new DartString.literal(value)));
     }
   }
 
   static AstConstant makeConstructedConstant(
       Compiler compiler,
       ConstantCompilerBase handler,
       Element context,
       Node node,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       ConstructorElement constructor,
-      InterfaceType constructedType,
+      ResolutionInterfaceType constructedType,
       ConstructorElement target,
       CallStructure callStructure,
       List<AstConstant> concreteArguments,
       List<AstConstant> normalizedArguments) {
     if (target.isRedirectingFactory) {
       // This happens in case of cyclic redirection.
       assert(invariant(node, compiler.compilationFailed,
           message: "makeConstructedConstant can only be called with the "
               "effective target: $constructor"));
       return new ErroneousAstConstant(context, node);
@@ skipping 48 matching lines @@
     // Else we don't need to do anything. The final handler is only
     // optimistically trying to compile constants. So it is normal that we
     // sometimes see non-compile time constants.
     // Simply return [:null:] which is used to propagate a failing
     // compile-time compilation.
     return null;
   }
 }
 
 class ConstructorEvaluator extends CompileTimeConstantEvaluator {
-  final InterfaceType constructedType;
+  final ResolutionInterfaceType constructedType;
   final ConstructorElement constructor;
   final Map<Element, AstConstant> definitions;
   final Map<Element, AstConstant> fieldValues;
   final ResolvedAst resolvedAst;
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructor] must be an implementation element.
    */
   ConstructorEvaluator(
-      InterfaceType this.constructedType,
+      ResolutionInterfaceType this.constructedType,
       ConstructorElement constructor,
       ConstantCompiler handler,
       Compiler compiler)
       : this.constructor = constructor,
         this.definitions = new Map<Element, AstConstant>(),
         this.fieldValues = new Map<Element, AstConstant>(),
         this.resolvedAst =
             compiler.resolution.computeResolvedAst(constructor.declaration),
         super(handler, null, compiler, isConst: true) {
     assert(invariant(constructor, constructor.isImplementation));
@@ skipping 12 matching lines @@
       if (constant == null) {
         reporter.internalError(send, "Local variable without value.");
       }
       return constant;
     }
     return super.visitSend(send);
   }
 
   void potentiallyCheckType(TypedElement element, AstConstant constant) {
     if (compiler.options.enableTypeAssertions) {
-      DartType elementType = element.type.substByContext(constructedType);
-      DartType constantType = constant.value.getType(commonElements);
+      ResolutionDartType elementType =
+          element.type.substByContext(constructedType);
+      ResolutionDartType constantType = constant.value.getType(commonElements);
       if (!constantSystem.isSubtype(
           compiler.types, constantType, elementType)) {
         reporter.withCurrentElement(constant.element, () {
           reporter.reportErrorMessage(constant.node, MessageKind.NOT_ASSIGNABLE,
               {'fromType': constantType, 'toType': elementType});
         });
       }
     }
   }
 
@@ skipping 20 matching lines @@
         updateFieldValue(node, initializingFormal.fieldElement, argument);
       } else {
         potentiallyCheckType(parameter, argument);
       }
       definitions[parameter] = argument;
     });
   }
 
   void evaluateSuperOrRedirectSend(List<AstConstant> compiledArguments,
       CallStructure callStructure, ConstructorElement targetConstructor) {
-    InterfaceType type =
+    ResolutionInterfaceType type =
         constructedType.asInstanceOf(targetConstructor.enclosingClass);
     if (compiler.serialization.isDeserialized(targetConstructor)) {
       List<ConstantExpression> arguments =
           compiledArguments.map((c) => c.expression).toList();
       ConstructedConstantExpression expression =
           new ConstructedConstantExpression(
               type, targetConstructor, callStructure, arguments);
 
       Map<FieldElement, ConstantExpression> fields =
           expression.computeInstanceFields();
@@ skipping 179 matching lines @@
 class _CompilerEnvironment implements Environment {
   final Compiler compiler;
 
   _CompilerEnvironment(this.compiler);
 
   @override
   String readFromEnvironment(String name) {
     return compiler.fromEnvironment(name);
   }
 }