Add Resolution and Parsing interfaces for computeType, ensureResolved and parseNode.

pkg/compiler/lib/src/deferred_load.dart

 // Copyright (c) 2014, 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 deferred_load;
 
 import 'common/backend_api.dart' show
     Backend;
+import 'common/resolution.dart' show
+    Resolution;
 import 'common/tasks.dart' show
     CompilerTask;
 import 'compiler.dart' show
     Compiler;
 import 'constants/values.dart' show
     ConstantValue,
     ConstructedConstantValue,
     DeferredConstantValue,
     StringConstantValue;
 import 'dart_types.dart';
@@ skipping 257 matching lines @@
         }
         for (DartType argumentType in type.optionalParameterTypes) {
           collectTypeDependencies(argumentType);
         }
         for (DartType argumentType in type.namedParameterTypes) {
           collectTypeDependencies(argumentType);
         }
         collectTypeDependencies(type.returnType);
       } else if (type is TypedefType) {
         elements.add(type.element);
-        collectTypeDependencies(type.unalias(compiler));
+        collectTypeDependencies(type.unalias(compiler.resolution));
       } else if (type is InterfaceType) {
         elements.add(type.element);
       }
     }
 
     /// Collects all direct dependencies of [element].
     ///
     /// The collected dependent elements and constants are are added to
     /// [elements] and [constants] respectively.
     void collectDependencies(Element element) {
@@ skipping 420 matching lines @@
       compiler.withCurrentElement(library, () {
         prefixDeferredImport.clear();
         usedPrefixes.clear();
         // TODO(sigurdm): Make helper getLibraryImportTags when tags is a List
         // instead of a Link.
         for (ImportElement import in library.imports) {
           /// Give an error if the old annotation-based syntax has been used.
           List<MetadataAnnotation> metadataList = import.metadata;
           if (metadataList != null) {
             for (MetadataAnnotation metadata in metadataList) {
-              metadata.ensureResolved(compiler);
+              metadata.ensureResolved(compiler.resolution);
               ConstantValue value =
                   compiler.constants.getConstantValue(metadata.constant);
               Element element = value.getType(compiler.coreTypes).element;
               if (element == deferredLibraryClass) {
                  compiler.reportErrorMessage(
                      import, MessageKind.DEFERRED_OLD_SYNTAX);
               }
             }
           }
 
@@ skipping 177 matching lines @@
       } else {
         // This happens when the deferred import isn't declared with a prefix.
         assert(compiler.compilationFailed);
         result = '';
       }
     } else {
       // Finds the first argument to the [DeferredLibrary] annotation
       List<MetadataAnnotation> metadatas = declaration.metadata;
       assert(metadatas != null);
       for (MetadataAnnotation metadata in metadatas) {
-        metadata.ensureResolved(compiler);
+        metadata.ensureResolved(compiler.resolution);
         ConstantValue value =
             compiler.constants.getConstantValue(metadata.constant);
         Element element = value.getType(compiler.coreTypes).element;
         if (element == compiler.deferredLibraryClass) {
           ConstructedConstantValue constant = value;
           StringConstantValue s = constant.fields.values.single;
           result = s.primitiveValue.slowToString();
           break;
         }
       }
     }
     assert(result != null);
     return result;
   }
 
   bool operator ==(other) {
     if (other is! _DeclaredDeferredImport) return false;
     return declaration == other.declaration;
   }
 
   int get hashCode => declaration.hashCode * 17;
 }