Prefix resolution_types with Resolution.

pkg/compiler/lib/src/resolution/resolution.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.resolution;
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 292 matching lines @@
       }
       if (element.isSynthesized) {
         if (element.isGenerativeConstructor) {
           ResolutionRegistry registry =
               new ResolutionRegistry(this.target, _ensureTreeElements(element));
           ConstructorElement constructor = element.asFunctionElement();
           ConstructorElement target = constructor.definingConstructor;
           // Ensure the signature of the synthesized element is
           // resolved. This is the only place where the resolver is
           // seeing this element.
-          FunctionType type = element.computeType(resolution);
+          ResolutionFunctionType type = element.computeType(resolution);
           if (!target.isMalformed) {
             registry.registerStaticUse(new StaticUse.superConstructorInvoke(
                 // TODO(johnniwinther): Provide the right call structure for
                 // forwarding constructors.
                 target,
                 CallStructure.NO_ARGS));
           }
           // TODO(johnniwinther): Remove this substitution when synthesized
           // constructors handle type variables correctly.
           type = type.substByContext(
@@ skipping 35 matching lines @@
 
   WorldImpact resolveField(FieldElementX element) {
     return reporter.withCurrentElement(element, () {
       VariableDefinitions tree = element.parseNode(parsingContext);
       if (element.modifiers.isStatic && element.isTopLevel) {
         reporter.reportErrorMessage(element.modifiers.getStatic(),
             MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
       }
       ResolverVisitor visitor = visitorFor(element);
       ResolutionRegistry registry = visitor.registry;
-      // TODO(johnniwinther): Maybe remove this when placeholderCollector migrates
-      // to the backend ast.
+      // TODO(johnniwinther): Maybe remove this when placeholderCollector
+      // migrates to the backend ast.
       registry.defineElement(element.definition, element);
       // TODO(johnniwinther): Share the resolved type between all variables
       // declared in the same declaration.
       if (tree.type != null) {
-        DartType type = visitor.resolveTypeAnnotation(tree.type);
+        ResolutionDartType type = visitor.resolveTypeAnnotation(tree.type);
         assert(invariant(
             element,
             element.variables.type == null ||
                 // Crude check but we have no equivalence relation that
                 // equates malformed types, like matching creations of type
                 // `Foo<Unresolved>`.
                 element.variables.type.toString() == type.toString(),
             message: "Unexpected type computed for $element. "
                 "Was ${element.variables.type}, computed $type."));
         element.variables.type = type;
       } else if (element.variables.type == null) {
         // Only assign the dynamic type if the element has no known type. This
         // happens for enum fields where the type is known but is not in the
         // synthesized AST.
-        element.variables.type = const DynamicType();
+        element.variables.type = const ResolutionDynamicType();
       } else {
         registry.registerCheckedModeCheck(element.variables.type);
       }
 
       Expression initializer = element.initializer;
       Modifiers modifiers = element.modifiers;
       if (initializer != null) {
         // TODO(johnniwinther): Avoid analyzing initializers if
         // [Compiler.analyzeSignaturesOnly] is set.
         ResolutionResult result = visitor.visit(initializer);
@@ skipping 30 matching lines @@
 
       // Perform various checks as side effect of "computing" the type.
       element.computeType(resolution);
 
       resolution.target.resolveNativeElement(element, registry.impactBuilder);
 
       return registry.impactBuilder;
     });
   }
 
-  DartType resolveTypeAnnotation(Element element, TypeAnnotation annotation) {
-    DartType type = _resolveReturnType(element, annotation);
+  ResolutionDartType resolveTypeAnnotation(
+      Element element, TypeAnnotation annotation) {
+    ResolutionDartType type = _resolveReturnType(element, annotation);
     if (type.isVoid) {
       reporter.reportErrorMessage(annotation, MessageKind.VOID_NOT_ALLOWED);
     }
     return type;
   }
 
-  DartType _resolveReturnType(Element element, TypeAnnotation annotation) {
-    if (annotation == null) return const DynamicType();
-    DartType result = visitorFor(element).resolveTypeAnnotation(annotation);
+  ResolutionDartType _resolveReturnType(
+      Element element, TypeAnnotation annotation) {
+    if (annotation == null) return const ResolutionDynamicType();
+    ResolutionDartType result =
+        visitorFor(element).resolveTypeAnnotation(annotation);
     assert(invariant(annotation, result != null,
         message: "No type computed for $annotation."));
     if (result == null) {
       // TODO(karklose): warning.
-      return const DynamicType();
+      return const ResolutionDynamicType();
     }
     return result;
   }
 
   void resolveRedirectionChain(ConstructorElement constructor, Spannable node) {
     ConstructorElement target = constructor;
-    DartType targetType;
+    ResolutionDartType targetType;
     List<ConstructorElement> seen = new List<ConstructorElement>();
     bool isMalformed = false;
     // Follow the chain of redirections and check for cycles.
     while (target.isRedirectingFactory) {
       if (target.hasEffectiveTarget) {
         // We found a constructor that already has been processed.
         // TODO(johnniwinther): Should `effectiveTargetType` be part of the
         // interface?
         targetType =
             target.computeEffectiveTargetType(target.enclosingClass.thisType);
@@ skipping 34 matching lines @@
     // do not have to run the loop for these constructors again. Furthermore,
     // compute [redirectionTargetType] for each factory by computing the
     // substitution of the target type with respect to the factory type.
     while (!seen.isEmpty) {
       ConstructorElementX factory = seen.removeLast();
       ResolvedAst resolvedAst = factory.resolvedAst;
       assert(invariant(node, resolvedAst != null,
           message: 'No ResolvedAst for $factory.'));
       FunctionExpression functionNode = resolvedAst.node;
       RedirectingFactoryBody redirectionNode = resolvedAst.body;
-      DartType factoryType = resolvedAst.elements.getType(redirectionNode);
+      ResolutionDartType factoryType =
+          resolvedAst.elements.getType(redirectionNode);
       if (!factoryType.isDynamic) {
         targetType = targetType.substByContext(factoryType);
       }
       factory.setEffectiveTarget(target, targetType, isMalformed: isMalformed);
     }
   }
 
   /**
    * Load and resolve the supertypes of [cls].
    *
    * Warning: do not call this method directly. It should only be
    * called by [resolveClass] and [ClassSupertypeResolver].
    */
   void loadSupertypes(BaseClassElementX cls, Spannable from) {
     measure(() {
       if (cls.supertypeLoadState == STATE_DONE) return;
       if (cls.supertypeLoadState == STATE_STARTED) {
         reporter.reportErrorMessage(
             from, MessageKind.CYCLIC_CLASS_HIERARCHY, {'className': cls.name});
         cls.supertypeLoadState = STATE_DONE;
         cls.hasIncompleteHierarchy = true;
         cls.allSupertypesAndSelf = commonElements
             .objectClass.allSupertypesAndSelf
             .extendClass(cls.computeType(resolution));
         cls.supertype = cls.allSupertypes.head;
         assert(invariant(from, cls.supertype != null,
             message: 'Missing supertype on cyclic class $cls.'));
-        cls.interfaces = const Link<DartType>();
+        cls.interfaces = const Link<ResolutionDartType>();
         return;
       }
       cls.supertypeLoadState = STATE_STARTED;
       reporter.withCurrentElement(cls, () {
         // TODO(ahe): Cache the node in cls.
         cls
             .parseNode(parsingContext)
             .accept(new ClassSupertypeResolver(resolution, cls));
         if (cls.supertypeLoadState != STATE_DONE) {
           cls.supertypeLoadState = STATE_DONE;
@@ skipping 534 matching lines @@
                   break;
                 default:
                   reporter.reportErrorMessage(
                       node, MessageKind.INVALID_METADATA);
                   constant = new ErroneousConstantExpression();
                   break;
               }
               annotation.constant = constant;
 
               constantCompiler.evaluate(annotation.constant);
-              // TODO(johnniwinther): Register the relation between the annotation
-              // and the annotated element instead. This will allow the backend to
-              // retrieve the backend constant and only register metadata on the
-              // elements for which it is needed. (Issue 17732).
+              // TODO(johnniwinther): Register the relation between the
+              // annotation and the annotated element instead. This will allow
+              // the backend to retrieve the backend constant and only register
+              // metadata on the elements for which it is needed. (Issue 17732).
               annotation.resolutionState = STATE_DONE;
             }));
   }
 
   List<MetadataAnnotation> resolveMetadata(
       Element element, VariableDefinitions node) {
     List<MetadataAnnotation> metadata = <MetadataAnnotation>[];
     for (Metadata annotation in node.metadata.nodes) {
       ParameterMetadataAnnotation metadataAnnotation =
           new ParameterMetadataAnnotation(annotation);
@@ skipping 19 matching lines @@
   TreeElements get treeElements {
     assert(invariant(this, _treeElements != null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 
   void reuseElement() {
     _treeElements = null;
   }
 }