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

pkg/compiler/lib/src/native/enqueue.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.
 
 part of native;
 
 /**
  * This could be an abstract class but we use it as a stub for the dart_backend.
  */
 class NativeEnqueuer {
@@ skipping 113 matching lines @@
   ClassElement _annotationCreatesClass;
   ClassElement _annotationReturnsClass;
   ClassElement _annotationJsNameClass;
 
   /// Subclasses of [NativeEnqueuerBase] are constructed by the backend.
   NativeEnqueuerBase(this.world, Compiler compiler, this.enableLiveTypeAnalysis)
       : this.compiler = compiler,
         processedLibraries = compiler.cacheStrategy.newSet();
 
   JavaScriptBackend get backend => compiler.backend;
+  Resolution get resolution => compiler.resolution;
 
   void processNativeClasses(Iterable<LibraryElement> libraries) {
     if (compiler.hasIncrementalSupport) {
       // Since [Set.add] returns bool if an element was added, this restricts
       // [libraries] to ones that haven't already been processed. This saves
       // time during incremental compiles.
       libraries = libraries.where(processedLibraries.add);
     }
     libraries.forEach(processNativeClassesInLibrary);
     if (backend.isolateHelperLibrary != null) {
@@ skipping 12 matching lines @@
       if (element.isClass && element.isNative) {
         processNativeClass(element);
       }
     });
   }
 
   void processNativeClass(ClassElement classElement) {
     nativeClasses.add(classElement);
     unusedClasses.add(classElement);
     // Resolve class to ensure the class has valid inheritance info.
-    classElement.ensureResolved(compiler);
+    classElement.ensureResolved(resolution);
   }
 
   void processSubclassesOfNativeClasses(Iterable<LibraryElement> libraries) {
     // Collect potential subclasses, e.g.
     //
     //     class B extends foo.A {}
     //
     // String "A" has a potential subclass B.
 
     var potentialExtends = new Map<String, Set<ClassElement>>();
@@ skipping 18 matching lines @@
     // fact a subclass of a native class.
 
     ClassElement nativeSuperclassOf(ClassElement classElement) {
       if (classElement.isNative) return classElement;
       if (classElement.superclass == null) return null;
       return nativeSuperclassOf(classElement.superclass);
     }
 
     void walkPotentialSubclasses(ClassElement element) {
       if (nativeClassesAndSubclasses.contains(element)) return;
-      element.ensureResolved(compiler);
+      element.ensureResolved(resolution);
       ClassElement nativeSuperclass = nativeSuperclassOf(element);
       if (nativeSuperclass != null) {
         nativeClassesAndSubclasses.add(element);
         if (!element.isNative) {
           nonNativeSubclasses.putIfAbsent(nativeSuperclass,
               () => new Set<ClassElement>())
             .add(element);
         }
         Set<ClassElement> potentialSubclasses = potentialExtends[element.name];
         if (potentialSubclasses != null) {
@@ skipping 96 matching lines @@
     _annotationReturnsClass = find('Returns');
     _annotationJsNameClass = find('JSName');
   }
 
   /// Returns the JSName annotation string or `null` if no JSName annotation is
   /// present.
   String findJsNameFromAnnotation(Element element) {
     String name = null;
     ClassElement annotationClass = annotationJsNameClass;
     for (MetadataAnnotation annotation in element.implementation.metadata) {
-      annotation.ensureResolved(compiler);
+      annotation.ensureResolved(resolution);
       ConstantValue value =
           compiler.constants.getConstantValue(annotation.constant);
       if (!value.isConstructedObject) continue;
       ConstructedConstantValue constructedObject = value;
       if (constructedObject.type.element != annotationClass) continue;
 
       Iterable<ConstantValue> fields = constructedObject.fields.values;
       // TODO(sra): Better validation of the constant.
       if (fields.length != 1 || fields.single is! StringConstantValue) {
-        PartialMetadataAnnotation partial = annotation;
         compiler.internalError(annotation,
-            'Annotations needs one string: ${partial.parseNode(compiler)}');
+            'Annotations needs one string: ${annotation.node}');
       }
       StringConstantValue specStringConstant = fields.single;
       String specString = specStringConstant.toDartString().slowToString();
       if (name == null) {
         name = specString;
       } else {
-        PartialMetadataAnnotation partial = annotation;
         compiler.internalError(annotation,
-            'Too many JSName annotations: ${partial.parseNode(compiler)}');
+            'Too many JSName annotations: ${annotation.node}');
       }
     }
     return name;
   }
 
   enqueueClass(ClassElement classElement, cause) {
     assert(unusedClasses.contains(classElement));
     unusedClasses.remove(classElement);
     pendingClasses.add(classElement);
     queue.add(() { processClass(classElement, cause); });
@@ skipping 11 matching lines @@
   processClass(BaseClassElementX classElement, cause) {
     // TODO(ahe): Fix this assertion to work in incremental compilation.
     assert(compiler.hasIncrementalSupport ||
            !registeredClasses.contains(classElement));
 
     bool firstTime = registeredClasses.isEmpty;
     pendingClasses.remove(classElement);
     registeredClasses.add(classElement);
 
     // TODO(ahe): Is this really a global dependency?
-    classElement.ensureResolved(compiler);
+    classElement.ensureResolved(resolution);
     compiler.backend.registerInstantiatedType(
         classElement.rawType, world, compiler.globalDependencies);
 
-    // Also parse the node to know all its methods because otherwise it will
-    // only be parsed if there is a call to one of its constructors.
-    classElement.parseNode(compiler);
-
     if (firstTime) {
       queue.add(onFirstNativeClass);
     }
   }
 
   registerElement(Element element) {
     compiler.withCurrentElement(element, () {
       if (element.isFunction || element.isGetter || element.isSetter) {
         handleMethodAnnotations(element);
         if (element.isNative) {
@@ skipping 62 matching lines @@
       element.setNative(name);
     }
   }
 
   bool isIdentifier(String s) => _identifier.hasMatch(s);
 
   bool isNativeMethod(FunctionElementX element) {
     if (!element.library.canUseNative) return false;
     // Native method?
     return compiler.withCurrentElement(element, () {
-      Node node = element.parseNode(compiler);
+      Node node = element.parseNode(resolution.parsing);
       if (node is! FunctionExpression) return false;
       FunctionExpression functionExpression = node;
       node = functionExpression.body;
       Token token = node.getBeginToken();
       if (identical(token.stringValue, 'native')) return true;
       return false;
     });
   }
 
   void registerNativeBehavior(NativeBehavior nativeBehavior, cause) {
@@ skipping 207 matching lines @@
         superclass,
         () => <ClassElement>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${registeredClasses.length} native classes, '
         '${unusedClasses.length} native classes omitted.');
   }
 }