Introduce WorldImpact

pkg/compiler/lib/src/resolution/resolution_common.dart

 // Copyright (c) 2015, 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 resolution;
 
 class ResolverTask extends CompilerTask {
   final ConstantCompiler constantCompiler;
 
   ResolverTask(Compiler compiler, this.constantCompiler) : super(compiler);
 
   String get name => 'Resolver';
 
-  TreeElements resolve(Element element) {
+  WorldImpact resolve(Element element) {
     return measure(() {
       if (Elements.isErroneous(element)) return null;
 
-      processMetadata([result]) {
+      WorldImpact processMetadata([WorldImpact result]) {
         for (MetadataAnnotation metadata in element.metadata) {
           metadata.ensureResolved(compiler);
         }
         return result;
       }
 
       ElementKind kind = element.kind;
       if (identical(kind, ElementKind.GENERATIVE_CONSTRUCTOR) ||
           identical(kind, ElementKind.FUNCTION) ||
           identical(kind, ElementKind.GETTER) ||
           identical(kind, ElementKind.SETTER)) {
         return processMetadata(resolveMethodElement(element));
       }
 
       if (identical(kind, ElementKind.FIELD)) {
         return processMetadata(resolveField(element));
       }
       if (element.isClass) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
-        return processMetadata();
+        return processMetadata(const WorldImpact());
       } else if (element.isTypedef) {
         TypedefElement typdef = element;
         return processMetadata(resolveTypedef(typdef));
       }
 
       compiler.unimplemented(element, "resolve($element)");
     });
   }
 
   void resolveRedirectingConstructor(InitializerResolver resolver,
@@ skipping 12 matching lines @@
         resolver.visitor.error(node, MessageKind.REDIRECTING_CONSTRUCTOR_CYCLE);
         return;
       }
       seen.add(redirection);
       redirection = resolver.visitor.resolveConstructorRedirection(redirection);
     }
   }
 
   static void processAsyncMarker(Compiler compiler,
                                  BaseFunctionElementX element,
-                                 Registry registry) {
+                                 ResolutionRegistry registry) {
     FunctionExpression functionExpression = element.node;
     AsyncModifier asyncModifier = functionExpression.asyncModifier;
     if (asyncModifier != null) {
 
       if (asyncModifier.isAsynchronous) {
         element.asyncMarker = asyncModifier.isYielding
             ? AsyncMarker.ASYNC_STAR : AsyncMarker.ASYNC;
       } else {
         element.asyncMarker = AsyncMarker.SYNC_STAR;
       }
@@ skipping 36 matching lines @@
 
   bool _isNativeClassOrExtendsNativeClass(ClassElement classElement) {
     assert(classElement != null);
     while (classElement != null) {
       if (classElement.isNative) return true;
       classElement = classElement.superclass;
     }
     return false;
   }
 
-  TreeElements resolveMethodElementImplementation(
+  WorldImpact resolveMethodElementImplementation(
       FunctionElement element, FunctionExpression tree) {
     return compiler.withCurrentElement(element, () {
       if (element.isExternal && tree.hasBody()) {
         error(element,
             MessageKind.EXTERNAL_WITH_BODY,
             {'functionName': element.name});
       }
       if (element.isConstructor) {
         if (tree.returnType != null) {
           error(tree, MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE);
@@ skipping 47 matching lines @@
         }
       }
 
       // TODO(9631): support noSuchMethod on native classes.
       if (Elements.isInstanceMethod(element) &&
           element.name == Compiler.NO_SUCH_METHOD &&
           _isNativeClassOrExtendsNativeClass(enclosingClass)) {
         error(tree, MessageKind.NO_SUCH_METHOD_IN_NATIVE);
       }
 
-      return resolutionTree;
+      return registry.worldImpact;
     });
 
   }
 
-  TreeElements resolveMethodElement(FunctionElementX element) {
+  WorldImpact resolveMethodElement(FunctionElementX element) {
     assert(invariant(element, element.isDeclaration));
     return compiler.withCurrentElement(element, () {
       if (compiler.enqueuer.resolution.hasBeenResolved(element)) {
         // TODO(karlklose): Remove the check for [isConstructor]. [elememts]
         // should never be non-null, not even for constructors.
         assert(invariant(element, element.isConstructor,
             message: 'Non-constructor element $element '
                      'has already been analyzed.'));
-        return element.resolvedAst.elements;
+        return const WorldImpact();
       }
       if (element.isSynthesized) {
         if (element.isGenerativeConstructor) {
           ResolutionRegistry registry =
               new ResolutionRegistry(compiler, 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.
           element.computeSignature(compiler);
           if (!target.isErroneous) {
             registry.registerStaticUse(target);
             registry.registerImplicitSuperCall(target);
           }
-          return registry.mapping;
+          return registry.worldImpact;
         } else {
           assert(element.isDeferredLoaderGetter || element.isErroneous);
-          return _ensureTreeElements(element);
+          _ensureTreeElements(element);
+          return const WorldImpact();
         }
       } else {
         element.parseNode(compiler);
         element.computeType(compiler);
         FunctionElementX implementation = element;
         if (element.isExternal) {
           implementation = compiler.backend.resolveExternalFunction(element);
         }
         return resolveMethodElementImplementation(
             implementation, implementation.node);
       }
     });
   }
 
   /// Creates a [ResolverVisitor] for resolving an AST in context of [element].
   /// If [useEnclosingScope] is `true` then the initial scope of the visitor
   /// does not include inner scope of [element].
   ///
   /// This method should only be used by this library (or tests of
   /// this library).
   ResolverVisitor visitorFor(Element element, {bool useEnclosingScope: false}) {
     return new ResolverVisitor(compiler, element,
         new ResolutionRegistry(compiler, element),
         useEnclosingScope: useEnclosingScope);
   }
 
-  TreeElements resolveField(FieldElementX element) {
+  WorldImpact resolveField(FieldElementX element) {
     VariableDefinitions tree = element.parseNode(compiler);
     if(element.modifiers.isStatic && element.isTopLevel) {
       error(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.
     registry.defineElement(tree.definitions.nodes.head, element);
@@ skipping 32 matching lines @@
           // TODO(johnniwinther): Determine the const-ness eagerly to avoid
           // unnecessary registrations.
           registry.registerLazyField();
         }
       }
     }
 
     // Perform various checks as side effect of "computing" the type.
     element.computeType(compiler);
 
-    return registry.mapping;
+    return registry.worldImpact;
   }
 
   DartType resolveTypeAnnotation(Element element, TypeAnnotation annotation) {
     DartType type = resolveReturnType(element, annotation);
     if (type.isVoid) {
       error(annotation, MessageKind.VOID_NOT_ALLOWED);
     }
     return type;
   }
 
@@ skipping 558 matching lines @@
       FunctionExpression node =
           compiler.parser.measure(() => element.parseNode(compiler));
       return measure(() => SignatureResolver.analyze(
           compiler, node.parameters, node.returnType, element,
           new ResolutionRegistry(compiler, element),
           defaultValuesError: defaultValuesError,
           createRealParameters: true));
     });
   }
 
-  TreeElements resolveTypedef(TypedefElementX element) {
-    if (element.isResolved) return element.treeElements;
+  WorldImpact resolveTypedef(TypedefElementX element) {
+    if (element.isResolved) return const WorldImpact();
     compiler.world.allTypedefs.add(element);
     return _resolveTypeDeclaration(element, () {
       ResolutionRegistry registry = new ResolutionRegistry(compiler, element);
       return compiler.withCurrentElement(element, () {
         return measure(() {
           assert(element.resolutionState == STATE_NOT_STARTED);
           element.resolutionState = STATE_STARTED;
           Typedef node =
             compiler.parser.measure(() => element.parseNode(compiler));
           TypedefResolverVisitor visitor =
             new TypedefResolverVisitor(compiler, element, registry);
           visitor.visit(node);
           element.resolutionState = STATE_DONE;
-          return registry.mapping;
+          return registry.worldImpact;
         });
       });
     });
   }
 
   void resolveMetadataAnnotation(MetadataAnnotationX annotation) {
     compiler.withCurrentElement(annotation.annotatedElement, () => measure(() {
       assert(annotation.resolutionState == STATE_NOT_STARTED);
       annotation.resolutionState = STATE_STARTED;
 
@@ skipping 125 matching lines @@
 
   void reportDuplicateDefinition(String name,
                                  Spannable definition,
                                  Spannable existing) {
     compiler.reportError(definition,
         MessageKind.DUPLICATE_DEFINITION, {'name': name});
     compiler.reportInfo(existing,
         MessageKind.EXISTING_DEFINITION, {'name': name});
   }
 }