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

pkg/compiler/lib/src/compiler.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.compiler_base;
 
 import 'dart:async' show
     EventSink,
     Future;
 
 import '../compiler_new.dart' as api;
 import 'cache_strategy.dart' show
     CacheStrategy;
 import 'closure.dart' as closureMapping show
     ClosureTask;
 import 'common/backend_api.dart' show
     Backend;
 import 'common/codegen.dart' show
     CodegenRegistry,
     CodegenWorkItem;
 import 'common/names.dart' show
     Identifiers,
     Uris;
 import 'common/registry.dart' show
     Registry;
 import 'common/resolution.dart' show
+    Parsing,
+    Resolution,
     ResolutionWorkItem;
 import 'common/tasks.dart' show
     CompilerTask,
     GenericTask;
 import 'common/work.dart' show
     WorkItem;
 import 'compile_time_constants.dart';
 import 'constants/values.dart';
 import 'core_types.dart' show
     CoreTypes;
@@ skipping 76 matching lines @@
 import 'tokens/token.dart' show
     StringToken,
     Token,
     TokenPair;
 import 'tokens/token_constants.dart' as Tokens show
     COMMENT_TOKEN,
     EOF_TOKEN;
 import 'tokens/token_map.dart' show
     TokenMap;
 import 'tree/tree.dart' show
-    Node;
+    Node,
+    TypeAnnotation;
 import 'typechecker.dart' show
     TypeCheckerTask;
 import 'types/types.dart' as ti;
 import 'universe/call_structure.dart' show
     CallStructure;
 import 'universe/selector.dart' show
     Selector;
 import 'universe/universe.dart' show
     Universe;
 import 'util/util.dart' show
     Link,
     Setlet;
 import 'world.dart' show
     World;
 
 abstract class Compiler extends DiagnosticListener {
 
   final Stopwatch totalCompileTime = new Stopwatch();
   int nextFreeClassId = 0;
   World world;
   Types types;
   _CompilerCoreTypes _coreTypes;
+  _CompilerResolution _resolution;
+  _CompilerParsing _parsing;
 
   final CacheStrategy cacheStrategy;
 
   /**
    * Map from token to the first preceding comment token.
    */
   final TokenMap commentMap = new TokenMap();
 
   /**
    * Records global dependencies, that is, dependencies that don't
@@ skipping 152 matching lines @@
   ClassElement get listClass => _coreTypes.listClass;
   ClassElement get typeClass => _coreTypes.typeClass;
   ClassElement get mapClass => _coreTypes.mapClass;
   ClassElement get symbolClass => _coreTypes.symbolClass;
   ClassElement get stackTraceClass => _coreTypes.stackTraceClass;
   ClassElement get futureClass => _coreTypes.futureClass;
   ClassElement get iterableClass => _coreTypes.iterableClass;
   ClassElement get streamClass => _coreTypes.streamClass;
 
   CoreTypes get coreTypes => _coreTypes;
+  Resolution get resolution => _resolution;
+  Parsing get parsing => _parsing;
 
   ClassElement typedDataClass;
 
   /// The constant for the [proxy] variable defined in dart:core.
   ConstantValue proxyConstant;
 
   // TODO(johnniwinther): Move this to the JavaScriptBackend.
   /// The class for patch annotation defined in dart:_js_helper.
   ClassElement patchAnnotationClass;
 
@@ skipping 209 matching lines @@
         this.userOutputProvider = outputProvider == null
             ? const NullCompilerOutput() : outputProvider {
     if (hasIncrementalSupport) {
       // TODO(ahe): This is too much. Any method from platform and package
       // libraries can be inlined.
       disableInlining = true;
     }
     world = new World(this);
     // TODO(johnniwinther): Initialize core types in [initializeCoreClasses] and
     // make its field final.
-    _coreTypes = new _CompilerCoreTypes(this);
+    _parsing = new _CompilerParsing(this);
+    _resolution = new _CompilerResolution(this);
+    _coreTypes = new _CompilerCoreTypes(_resolution);
     types = new Types(this);
     tracer = new Tracer(this, this.outputProvider);
 
     if (verbose) {
       progress = new Stopwatch()..start();
     }
 
     // TODO(johnniwinther): Separate the dependency tracking from the enqueuing
     // for global dependencies.
     globalDependencies =
@@ skipping 323 matching lines @@
               MessageKind.MIRRORS_LIBRARY_NOT_SUPPORT_BY_BACKEND);
         } else {
           reportWarningMessage(
               NO_LOCATION_SPANNABLE,
               MessageKind.IMPORT_EXPERIMENTAL_MIRRORS,
               {'importChain': importChains.join(
                    MessageTemplate.IMPORT_EXPERIMENTAL_MIRRORS_PADDING)});
         }
       }
 
-      functionClass.ensureResolved(this);
+      functionClass.ensureResolved(resolution);
       functionApplyMethod = functionClass.lookupLocalMember('apply');
 
       if (preserveComments) {
         return libraryLoader.loadLibrary(Uris.dart_mirrors)
             .then((LibraryElement libraryElement) {
           documentClass = libraryElement.find('Comment');
         });
       }
     }).then((_) => backend.onLibrariesLoaded(loadedLibraries));
   }
@@ skipping 154 matching lines @@
         internalError(main, 'Problem with ${Identifiers.main}.');
       }
       mainFunction = backend.helperForBadMain();
     } else if (!main.isFunction) {
       errorElement = new ErroneousElementX(
           MessageKind.MAIN_NOT_A_FUNCTION, {'main': Identifiers.main},
           Identifiers.main, main);
       mainFunction = backend.helperForBadMain();
     } else {
       mainFunction = main;
-      mainFunction.computeType(this);
+      mainFunction.computeType(resolution);
       FunctionSignature parameters = mainFunction.functionSignature;
       if (parameters.requiredParameterCount > 2) {
         int index = 0;
         parameters.orderedForEachParameter((Element parameter) {
           if (index++ < 2) return;
           errorElement = new ErroneousElementX(
               MessageKind.MAIN_WITH_EXTRA_PARAMETER, {'main': Identifiers.main},
               Identifiers.main,
               parameter);
           mainFunction = backend.helperForMainArity();
@@ skipping 156 matching lines @@
   void fullyEnqueueLibrary(LibraryElement library, Enqueuer world) {
     void enqueueAll(Element element) {
       fullyEnqueueTopLevelElement(element, world);
     }
     library.implementation.forEachLocalMember(enqueueAll);
   }
 
   void fullyEnqueueTopLevelElement(Element element, Enqueuer world) {
     if (element.isClass) {
       ClassElement cls = element;
-      cls.ensureResolved(this);
+      cls.ensureResolved(resolution);
       cls.forEachLocalMember(enqueuer.resolution.addToWorkList);
       backend.registerInstantiatedType(
           cls.rawType, world, globalDependencies);
     } else {
       world.addToWorkList(element);
     }
   }
 
   // Resolves metadata on library elements.  This is necessary in order to
   // resolve metadata classes referenced only from metadata on library tags.
   // TODO(ahe): Figure out how to do this lazily.
   void resolveLibraryMetadata() {
     for (LibraryElement library in libraryLoader.libraries) {
       if (library.metadata != null) {
         for (MetadataAnnotation metadata in library.metadata) {
-          metadata.ensureResolved(this);
+          metadata.ensureResolved(resolution);
         }
       }
     }
   }
 
   /**
    * Empty the [world] queue.
    */
   void emptyQueue(Enqueuer world) {
     world.forEach((WorkItem work) {
       withCurrentElement(work.element, () {
         world.applyImpact(work.element, work.run(this, world));
       });
     });
   }
 
   void processQueue(Enqueuer world, Element main) {
     world.nativeEnqueuer.processNativeClasses(libraryLoader.libraries);
     if (main != null && !main.isErroneous) {
       FunctionElement mainMethod = main;
-      mainMethod.computeType(this);
+      mainMethod.computeType(resolution);
       if (mainMethod.functionSignature.parameterCount != 0) {
         // The first argument could be a list of strings.
-        backend.listImplementation.ensureResolved(this);
+        backend.listImplementation.ensureResolved(resolution);
         backend.registerInstantiatedType(
             backend.listImplementation.rawType, world, globalDependencies);
-        backend.stringImplementation.ensureResolved(this);
+        backend.stringImplementation.ensureResolved(resolution);
         backend.registerInstantiatedType(
             backend.stringImplementation.rawType, world, globalDependencies);
 
         backend.registerMainHasArguments(world);
       }
       world.addToWorkList(main);
     }
     if (verbose) {
       progress.reset();
     }
@@ skipping 449 matching lines @@
   }
 }
 
 /// Information about suppressed warnings and hints for a given library.
 class SuppressionInfo {
   int warnings = 0;
   int hints = 0;
 }
 
 class _CompilerCoreTypes implements CoreTypes {
-  final Compiler compiler;
+  final Resolution resolution;
 
   ClassElement objectClass;
   ClassElement boolClass;
   ClassElement numClass;
   ClassElement intClass;
   ClassElement doubleClass;
   ClassElement stringClass;
   ClassElement functionClass;
   ClassElement nullClass;
   ClassElement listClass;
   ClassElement typeClass;
   ClassElement mapClass;
   ClassElement symbolClass;
   ClassElement stackTraceClass;
   ClassElement futureClass;
   ClassElement iterableClass;
   ClassElement streamClass;
   ClassElement resourceClass;
 
-  _CompilerCoreTypes(this.compiler);
+  _CompilerCoreTypes(this.resolution);
 
   @override
-  InterfaceType get objectType => objectClass.computeType(compiler);
+  InterfaceType get objectType => objectClass.computeType(resolution);
 
   @override
-  InterfaceType get boolType => boolClass.computeType(compiler);
+  InterfaceType get boolType => boolClass.computeType(resolution);
 
   @override
-  InterfaceType get doubleType => doubleClass.computeType(compiler);
+  InterfaceType get doubleType => doubleClass.computeType(resolution);
 
   @override
-  InterfaceType get functionType => functionClass.computeType(compiler);
+  InterfaceType get functionType => functionClass.computeType(resolution);
 
   @override
-  InterfaceType get intType => intClass.computeType(compiler);
+  InterfaceType get intType => intClass.computeType(resolution);
 
   @override
-  InterfaceType get resourceType => resourceClass.computeType(compiler);
+  InterfaceType get resourceType => resourceClass.computeType(resolution);
 
   @override
   InterfaceType listType([DartType elementType]) {
-    InterfaceType type = listClass.computeType(compiler);
+    InterfaceType type = listClass.computeType(resolution);
     if (elementType == null) {
       return listClass.rawType;
     }
     return type.createInstantiation([elementType]);
   }
 
   @override
   InterfaceType mapType([DartType keyType,
                          DartType valueType]) {
-    InterfaceType type = mapClass.computeType(compiler);
+    InterfaceType type = mapClass.computeType(resolution);
     if (keyType == null && valueType == null) {
       return mapClass.rawType;
     } else if (keyType == null) {
       keyType = const DynamicType();
     } else if (valueType == null) {
       valueType = const DynamicType();
     }
     return type.createInstantiation([keyType, valueType]);
   }
 
   @override
-  InterfaceType get nullType => nullClass.computeType(compiler);
+  InterfaceType get nullType => nullClass.computeType(resolution);
 
   @override
-  InterfaceType get numType => numClass.computeType(compiler);
+  InterfaceType get numType => numClass.computeType(resolution);
 
   @override
-  InterfaceType get stringType => stringClass.computeType(compiler);
+  InterfaceType get stringType => stringClass.computeType(resolution);
 
   @override
-  InterfaceType get symbolType => symbolClass.computeType(compiler);
+  InterfaceType get symbolType => symbolClass.computeType(resolution);
 
   @override
-  InterfaceType get typeType => typeClass.computeType(compiler);
+  InterfaceType get typeType => typeClass.computeType(resolution);
 
   @override
   InterfaceType iterableType([DartType elementType]) {
-    InterfaceType type = iterableClass.computeType(compiler);
+    InterfaceType type = iterableClass.computeType(resolution);
     if (elementType == null) {
       return iterableClass.rawType;
     }
     return type.createInstantiation([elementType]);
   }
 
   @override
   InterfaceType futureType([DartType elementType]) {
-    InterfaceType type = futureClass.computeType(compiler);
+    InterfaceType type = futureClass.computeType(resolution);
     if (elementType == null) {
       return futureClass.rawType;
     }
     return type.createInstantiation([elementType]);
   }
 
   @override
   InterfaceType streamType([DartType elementType]) {
-    InterfaceType type = streamClass.computeType(compiler);
+    InterfaceType type = streamClass.computeType(resolution);
     if (elementType == null) {
       return streamClass.rawType;
     }
     return type.createInstantiation([elementType]);
   }
 }
+
+// TODO(johnniwinther): Move [ResolverTask] here.
+class _CompilerResolution implements Resolution {
+  final Compiler compiler;
+
+  _CompilerResolution(this.compiler);
+
+  @override
+  DiagnosticListener get listener => compiler;
+
+  @override
+  Parsing get parsing => compiler.parsing;
+
+  @override
+  CoreTypes get coreTypes => compiler.coreTypes;
+
+  @override
+  void registerClass(ClassElement cls) {
+    compiler.world.registerClass(cls);
+  }
+
+  @override
+  void resolveClass(ClassElement cls) {
+    compiler.resolver.resolveClass(cls);
+  }
+
+  @override
+  void resolveTypedef(TypedefElement typdef) {
+    compiler.resolver.resolve(typdef);
+  }
+
+  @override
+  void resolveMetadataAnnotation(MetadataAnnotation metadataAnnotation) {
+    compiler.resolver.resolveMetadataAnnotation(metadataAnnotation);
+  }
+
+  @override
+  FunctionSignature resolveSignature(FunctionElement function) {
+    return compiler.resolver.resolveSignature(function);
+  }
+
+  @override
+  DartType resolveTypeAnnotation(Element element, TypeAnnotation node) {
+    return compiler.resolver.resolveTypeAnnotation(element, node);
+  }
+}
+
+// TODO(johnniwinther): Move [ParserTask], [PatchParserTask], [DietParserTask]
+// and [ScannerTask] here.
+class _CompilerParsing implements Parsing {
+  final Compiler compiler;
+
+  _CompilerParsing(this.compiler);
+
+  @override
+  DiagnosticListener get listener => compiler;
+
+  @override
+  measure(f()) => compiler.parser.measure(f);
+
+  @override
+  void parsePatchClass(ClassElement cls) {
+    compiler.patchParser.measure(() {
+      if (cls.isPatch) {
+        compiler.patchParser.parsePatchClassNode(cls);
+      }
+    });
+  }
+}