remove dependency on compiler from 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;
 import '../common/resolution.dart'
-    show Feature, ParsingContext, Resolution, ResolutionImpact;
-import '../common/tasks.dart' show CompilerTask;
+    show Feature, ParsingContext, Resolution, ResolutionImpact, Target;
+import '../common/tasks.dart' show CompilerTask, Measurer;
 import '../compile_time_constants.dart' show ConstantCompiler;
-import '../compiler.dart' show Compiler;
 import '../constants/expressions.dart'
     show
         ConstantExpression,
         ConstantExpressionKind,
         ConstructedConstantExpression,
         ErroneousConstantExpression;
 import '../constants/values.dart' show ConstantValue;
 import '../core_types.dart' show CoreClasses, CoreTypes;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart'
     show
         BaseClassElementX,
         BaseFunctionElementX,
         ConstructorElementX,
         FieldElementX,
         FunctionElementX,
         GetterElementX,
         MetadataAnnotationX,
         MixinApplicationElementX,
         ParameterMetadataAnnotation,
         SetterElementX,
         TypedefElementX;
+import '../enqueue.dart';
+import '../options.dart';
 import '../tokens/token.dart'
     show
         isBinaryOperator,
         isMinusOperator,
         isTernaryOperator,
         isUnaryOperator,
         isUserDefinableOperator;
 import '../tree/tree.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/use.dart' show StaticUse, TypeUse;
 import '../universe/world_impact.dart' show WorldImpact;
 import '../util/util.dart' show Link, Setlet;
+import '../world.dart';
 import 'class_hierarchy.dart';
 import 'class_members.dart' show MembersCreator;
 import 'constructors.dart';
 import 'members.dart';
 import 'registry.dart';
 import 'resolution_result.dart';
-import 'scope.dart' show MutableScope;
 import 'signatures.dart';
 import 'tree_elements.dart';
 import 'typedefs.dart';
 
 class ResolverTask extends CompilerTask {
   final ConstantCompiler constantCompiler;
-  final Compiler compiler;
+  final Resolution resolution;
+  final World world;
 
-  ResolverTask(Compiler compiler, this.constantCompiler)
-      : compiler = compiler,
-        super(compiler.measurer);
+  ResolverTask(
+      this.resolution, this.constantCompiler, this.world, Measurer measurer)
+      : super(measurer);
 
   String get name => 'Resolver';
 
-  DiagnosticReporter get reporter => compiler.reporter;
-
-  Resolution get resolution => compiler.resolution;
-
-  ParsingContext get parsingContext => compiler.parsingContext;
-
-  CoreClasses get coreClasses => compiler.coreClasses;
-
-  CoreTypes get coreTypes => compiler.coreTypes;
+  DiagnosticReporter get reporter => resolution.reporter;
+  Target get target => resolution.target;
+  CoreTypes get coreTypes => resolution.coreTypes;
+  CoreClasses get coreClasses => resolution.coreClasses;
+  ParsingContext get parsingContext => resolution.parsingContext;
+  CompilerOptions get options => resolution.options;
+  ResolutionEnqueuer get enqueuer => resolution.enqueuer;
 
   ResolutionImpact resolve(Element element) {
     return measure(() {
       if (Elements.isMalformed(element)) {
         // TODO(johnniwinther): Add a predicate for this.
         assert(invariant(element, element is! ErroneousElement,
             message: "Element $element expected to have parse errors."));
         _ensureTreeElements(element);
         return const ResolutionImpact();
       }
@@ skipping 17 matching lines @@
       }
       if (element.isClass) {
         ClassElement cls = element;
         cls.ensureResolved(resolution);
         return processMetadata(const ResolutionImpact());
       } else if (element.isTypedef) {
         TypedefElement typdef = element;
         return processMetadata(resolveTypedef(typdef));
       }
 
-      compiler.unimplemented(element, "resolve($element)");
+      reporter.internalError(element, "resolve($element) not implemented.");
     });
   }
 
   void resolveRedirectingConstructor(InitializerResolver resolver, Node node,
       FunctionElement constructor, FunctionElement redirection) {
     assert(invariant(node, constructor.isImplementation,
         message: 'Redirecting constructors must be resolved on implementation '
             'elements.'));
     Setlet<FunctionElement> seen = new Setlet<FunctionElement>();
     seen.add(constructor);
     while (redirection != null) {
       // Ensure that we follow redirections through implementation elements.
       redirection = redirection.implementation;
       if (redirection.isError) {
         break;
       }
       if (seen.contains(redirection)) {
         reporter.reportErrorMessage(
             node, MessageKind.REDIRECTING_CONSTRUCTOR_CYCLE);
         return;
       }
       seen.add(redirection);
       redirection = resolver.visitor.resolveConstructorRedirection(redirection);
     }
   }
 
-  static void processAsyncMarker(Compiler compiler,
+  static void processAsyncMarker(Resolution resolution,
       BaseFunctionElementX element, ResolutionRegistry registry) {
-    DiagnosticReporter reporter = compiler.reporter;
-    Resolution resolution = compiler.resolution;
-    CoreClasses coreClasses = compiler.coreClasses;
+    DiagnosticReporter reporter = resolution.reporter;
+    CoreClasses coreClasses = resolution.coreClasses;
     FunctionExpression functionExpression = element.node;
     AsyncModifier asyncModifier = functionExpression.asyncModifier;
     if (asyncModifier != null) {
-      if (!compiler.backend.supportsAsyncAwait) {
-        reporter.reportErrorMessage(functionExpression.asyncModifier,
-            MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
+      if (asyncModifier.isAsynchronous) {

[Harry Terkelsen, 2016/07/06 22:44:45]

this diff looks a lot crazier than it actually is... I am just getting rid of
the check for if we support async/await

+        element.asyncMarker = asyncModifier.isYielding
+            ? AsyncMarker.ASYNC_STAR
+            : AsyncMarker.ASYNC;
       } else {
-        if (asyncModifier.isAsynchronous) {
-          element.asyncMarker = asyncModifier.isYielding
-              ? AsyncMarker.ASYNC_STAR
-              : AsyncMarker.ASYNC;
-        } else {
-          element.asyncMarker = AsyncMarker.SYNC_STAR;
-        }
-        if (element.isAbstract) {
+        element.asyncMarker = AsyncMarker.SYNC_STAR;
+      }
+      if (element.isAbstract) {
+        reporter.reportErrorMessage(
+            asyncModifier,
+            MessageKind.ASYNC_MODIFIER_ON_ABSTRACT_METHOD,
+            {'modifier': element.asyncMarker});
+      } else if (element.isConstructor) {
+        reporter.reportErrorMessage(
+            asyncModifier,
+            MessageKind.ASYNC_MODIFIER_ON_CONSTRUCTOR,
+            {'modifier': element.asyncMarker});
+      } else {
+        if (element.isSetter) {
           reporter.reportErrorMessage(
               asyncModifier,
-              MessageKind.ASYNC_MODIFIER_ON_ABSTRACT_METHOD,
+              MessageKind.ASYNC_MODIFIER_ON_SETTER,
               {'modifier': element.asyncMarker});
-        } else if (element.isConstructor) {
+        }
+        if (functionExpression.body.asReturn() != null &&
+            element.asyncMarker.isYielding) {
           reporter.reportErrorMessage(
               asyncModifier,
-              MessageKind.ASYNC_MODIFIER_ON_CONSTRUCTOR,
+              MessageKind.YIELDING_MODIFIER_ON_ARROW_BODY,
               {'modifier': element.asyncMarker});
-        } else {
-          if (element.isSetter) {
-            reporter.reportErrorMessage(
-                asyncModifier,
-                MessageKind.ASYNC_MODIFIER_ON_SETTER,
-                {'modifier': element.asyncMarker});
-          }
-          if (functionExpression.body.asReturn() != null &&
-              element.asyncMarker.isYielding) {
-            reporter.reportErrorMessage(
-                asyncModifier,
-                MessageKind.YIELDING_MODIFIER_ON_ARROW_BODY,
-                {'modifier': element.asyncMarker});
-          }
         }
-        switch (element.asyncMarker) {
-          case AsyncMarker.ASYNC:
-            registry.registerFeature(Feature.ASYNC);
-            coreClasses.futureClass.ensureResolved(resolution);
-            break;
-          case AsyncMarker.ASYNC_STAR:
-            registry.registerFeature(Feature.ASYNC_STAR);
-            coreClasses.streamClass.ensureResolved(resolution);
-            break;
-          case AsyncMarker.SYNC_STAR:
-            registry.registerFeature(Feature.SYNC_STAR);
-            coreClasses.iterableClass.ensureResolved(resolution);
-            break;
-        }
+      }
+      switch (element.asyncMarker) {
+        case AsyncMarker.ASYNC:
+          registry.registerFeature(Feature.ASYNC);
+          coreClasses.futureClass.ensureResolved(resolution);
+          break;
+        case AsyncMarker.ASYNC_STAR:
+          registry.registerFeature(Feature.ASYNC_STAR);
+          coreClasses.streamClass.ensureResolved(resolution);
+          break;
+        case AsyncMarker.SYNC_STAR:
+          registry.registerFeature(Feature.SYNC_STAR);
+          coreClasses.iterableClass.ensureResolved(resolution);
+          break;
       }
     }
   }
 
   bool _isNativeClassOrExtendsNativeClass(ClassElement classElement) {
     assert(classElement != null);
     while (classElement != null) {
-      if (compiler.backend.isNative(classElement)) return true;
+      if (target.isNative(classElement)) return true;
       classElement = classElement.superclass;
     }
     return false;
   }
 
   WorldImpact resolveMethodElementImplementation(
       FunctionElement element, FunctionExpression tree) {
     return reporter.withCurrentElement(element, () {
       if (element.isExternal && tree.hasBody) {
         reporter.reportErrorMessage(element, MessageKind.EXTERNAL_WITH_BODY,
@@ skipping 11 matching lines @@
           } else if (!tree.isRedirectingFactory) {
             reporter.reportErrorMessage(tree, MessageKind.CONST_FACTORY);
           }
         }
       }
 
       ResolverVisitor visitor = visitorFor(element);
       ResolutionRegistry registry = visitor.registry;
       registry.defineFunction(tree, element);
       visitor.setupFunction(tree, element); // Modifies the scope.
-      processAsyncMarker(compiler, element, registry);
+      processAsyncMarker(resolution, element, registry);
 
       if (element.isGenerativeConstructor) {
         // Even if there is no initializer list we still have to do the
         // resolution in case there is an implicit super constructor call.
         InitializerResolver resolver =
             new InitializerResolver(visitor, element, tree);
         FunctionElement redirection = resolver.resolveInitializers(
             enableInitializingFormalAccess:
-                compiler.options.enableInitializingFormalAccess);
+                options.enableInitializingFormalAccess);
         if (redirection != null) {
           resolveRedirectingConstructor(resolver, tree, element, redirection);
         }
       } else if (tree.initializers != null) {
         reporter.reportErrorMessage(
             tree, MessageKind.FUNCTION_WITH_INITIALIZER);
       }
 
-      if (!compiler.options.analyzeSignaturesOnly ||
-          tree.isRedirectingFactory) {
+      if (!options.analyzeSignaturesOnly || tree.isRedirectingFactory) {
         // We need to analyze the redirecting factory bodies to ensure that
         // we can analyze compile-time constants.
         visitor.visit(tree.body);
       }
 
       // Get the resolution tree and check that the resolved
       // function doesn't use 'super' if it is mixed into another
       // class. This is the part of the 'super' mixin check that
       // happens when a function is resolved after the mixin
       // application has been performed.
       TreeElements resolutionTree = registry.mapping;
       ClassElement enclosingClass = element.enclosingClass;
       if (enclosingClass != null) {
         // TODO(johnniwinther): Find another way to obtain mixin uses.
         Iterable<MixinApplicationElement> mixinUses =
-            compiler.world.allMixinUsesOf(enclosingClass);
+            world.allMixinUsesOf(enclosingClass);
         ClassElement mixin = enclosingClass;
         for (MixinApplicationElement mixinApplication in mixinUses) {
           checkMixinSuperUses(resolutionTree, mixinApplication, mixin);
         }
       }
 
       // TODO(9631): support noSuchMethod on native classes.
       if (element.isFunction &&
           element.isInstanceMember &&
           element.name == Identifiers.noSuchMethod_ &&
           _isNativeClassOrExtendsNativeClass(enclosingClass)) {
         reporter.reportErrorMessage(tree, MessageKind.NO_SUCH_METHOD_IN_NATIVE);
       }
 
       resolution.target.resolveNativeElement(element, registry.worldImpact);
 
       return registry.worldImpact;
     });
   }
 
   WorldImpact resolveMethodElement(FunctionElementX element) {
     assert(invariant(element, element.isDeclaration));
     return reporter.withCurrentElement(element, () {
-      if (compiler.enqueuer.resolution.hasBeenProcessed(element)) {
+      if (enqueuer.hasBeenProcessed(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 const ResolutionImpact();
       }
       if (element.isSynthesized) {
         if (element.isGenerativeConstructor) {
           ResolutionRegistry registry =
-              new ResolutionRegistry(compiler, _ensureTreeElements(element));
+              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.
           element.computeType(resolution);
           if (!target.isMalformed) {
             registry.registerStaticUse(new StaticUse.superConstructorInvoke(
                 target, CallStructure.NO_ARGS));
           }
           return registry.worldImpact;
         } else {
           assert(element.isDeferredLoaderGetter || element.isMalformed);
           _ensureTreeElements(element);
           return const ResolutionImpact();
         }
       } else {
         element.parseNode(resolution.parsingContext);
         element.computeType(resolution);
         FunctionElementX implementation = element;
         if (element.isExternal) {
-          implementation = compiler.backend.resolveExternalFunction(element);
+          implementation = target.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, _ensureTreeElements(element)),
+    return new ResolverVisitor(resolution, element,
+        new ResolutionRegistry(target, _ensureTreeElements(element)),
         useEnclosingScope: useEnclosingScope);
   }
 
   WorldImpact resolveField(FieldElementX 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);
@@ skipping 177 matching lines @@
         assert(invariant(from, cls.supertype != null,
             message: 'Missing supertype on cyclic class $cls.'));
         cls.interfaces = const Link<DartType>();
         return;
       }
       cls.supertypeLoadState = STATE_STARTED;
       reporter.withCurrentElement(cls, () {
         // TODO(ahe): Cache the node in cls.
         cls
             .parseNode(parsingContext)
-            .accept(new ClassSupertypeResolver(compiler, cls));
+            .accept(new ClassSupertypeResolver(resolution, cls));
         if (cls.supertypeLoadState != STATE_DONE) {
           cls.supertypeLoadState = STATE_DONE;
         }
       });
     });
   }
 
   // TODO(johnniwinther): Remove this queue when resolution has been split into
   // syntax and semantic resolution.
   TypeDeclarationElement currentlyResolvedTypeDeclaration;
@@ skipping 44 matching lines @@
    * scanner and most fields are null or empty. This method fills in
    * these fields and also ensure that the supertypes of [element] are
    * resolved.
    *
    * Warning: Do not call this method directly. Instead use
    * [:element.ensureResolved(resolution):].
    */
   TreeElements resolveClass(BaseClassElementX element) {
     return _resolveTypeDeclaration(element, () {
       // TODO(johnniwinther): Store the mapping in the resolution enqueuer.
-      ResolutionRegistry registry =
-          new ResolutionRegistry(compiler, _ensureTreeElements(element));
+      ResolutionRegistry registry = new ResolutionRegistry(
+          resolution.target, _ensureTreeElements(element));
       resolveClassInternal(element, registry);
       return element.treeElements;
     });
   }
 
   void ensureClassWillBeResolvedInternal(ClassElement element) {
     if (currentlyResolvedTypeDeclaration == null) {
       element.ensureResolved(resolution);
     } else {
       pendingClassesToBeResolved.add(element);
     }
   }
 
   void resolveClassInternal(
       BaseClassElementX element, ResolutionRegistry registry) {
     if (!element.isPatch) {
       reporter.withCurrentElement(
           element,
           () => measure(() {
                 assert(element.resolutionState == STATE_NOT_STARTED);
                 element.resolutionState = STATE_STARTED;
                 Node tree = element.parseNode(parsingContext);
                 loadSupertypes(element, tree);
 
                 ClassResolverVisitor visitor =
-                    new ClassResolverVisitor(compiler, element, registry);
+                    new ClassResolverVisitor(resolution, element, registry);
                 visitor.visit(tree);
                 element.resolutionState = STATE_DONE;
-                compiler.onClassResolved(element);
+                resolution.onClassResolved(element);
                 pendingClassesToBePostProcessed.add(element);
               }));
       if (element.isPatched) {
         // Ensure handling patch after origin.
         element.patch.ensureResolved(resolution);
       }
     } else {
       // Handle patch classes:
       element.resolutionState = STATE_STARTED;
       // Ensure handling origin before patch.
@@ skipping 10 matching lines @@
       element.resolutionState = STATE_DONE;
       // TODO(johnniwinther): Check matching type variables and
       // empty extends/implements clauses.
     }
   }
 
   void _postProcessClassElement(BaseClassElementX element) {
     for (MetadataAnnotation metadata in element.implementation.metadata) {
       metadata.ensureResolved(resolution);
       ConstantValue value =
-          compiler.constants.getConstantValue(metadata.constant);
-      if (!element.isProxy && compiler.isProxyConstant(value)) {
+          resolution.constants.getConstantValue(metadata.constant);
+      if (!element.isProxy && resolution.isProxyConstant(value)) {
         element.isProxy = true;
       }
     }
 
     // Force resolution of metadata on non-instance members since they may be
     // inspected by the backend while emitting. Metadata on instance members is
     // handled as a result of processing instantiated class members in the
     // enqueuer.
     // TODO(ahe): Avoid this eager resolution.
     element.forEachMember((_, Element member) {
@@ skipping 67 matching lines @@
       if (member.isGenerativeConstructor && !member.isSynthesized) {
         reporter.reportErrorMessage(
             member, MessageKind.ILLEGAL_MIXIN_CONSTRUCTOR);
       } else {
         // Get the resolution tree and check that the resolved member
         // doesn't use 'super'. This is the part of the 'super' mixin
         // check that happens when a function is resolved before the
         // mixin application has been performed.
         // TODO(johnniwinther): Obtain the [TreeElements] for [member]
         // differently.
-        if (compiler.enqueuer.resolution.hasBeenProcessed(member)) {
+        if (resolution.enqueuer.hasBeenProcessed(member)) {
           if (member.resolvedAst.kind == ResolvedAstKind.PARSED) {
             checkMixinSuperUses(
                 member.resolvedAst.elements, mixinApplication, mixin);
           }
         }
       }
     });
   }
 
   void checkMixinSuperUses(TreeElements elements,
@@ skipping 228 matching lines @@
     MessageKind defaultValuesError = null;
     if (element.isFactoryConstructor) {
       FunctionExpression body = element.parseNode(parsingContext);
       if (body.isRedirectingFactory) {
         defaultValuesError = MessageKind.REDIRECTING_FACTORY_WITH_DEFAULT;
       }
     }
     return reporter.withCurrentElement(element, () {
       FunctionExpression node = element.parseNode(parsingContext);
       return measure(() => SignatureResolver.analyze(
-          compiler,
+          resolution,
           element.enclosingElement.buildScope(),
           node.typeVariables,
           node.parameters,
           node.returnType,
           element,
-          new ResolutionRegistry(compiler, _ensureTreeElements(element)),
+          new ResolutionRegistry(
+              resolution.target, _ensureTreeElements(element)),
           defaultValuesError: defaultValuesError,
           createRealParameters: true));
     });
   }
 
   WorldImpact resolveTypedef(TypedefElementX element) {
     if (element.isResolved) return const ResolutionImpact();
-    compiler.world.allTypedefs.add(element);
+    world.allTypedefs.add(element);
     return _resolveTypeDeclaration(element, () {
-      ResolutionRegistry registry =
-          new ResolutionRegistry(compiler, _ensureTreeElements(element));
+      ResolutionRegistry registry = new ResolutionRegistry(
+          resolution.target, _ensureTreeElements(element));
       return reporter.withCurrentElement(element, () {
         return measure(() {
           assert(element.resolutionState == STATE_NOT_STARTED);
           element.resolutionState = STATE_STARTED;
           Typedef node = element.parseNode(parsingContext);
           TypedefResolverVisitor visitor =
-              new TypedefResolverVisitor(compiler, element, registry);
+              new TypedefResolverVisitor(resolution, element, registry);
           visitor.visit(node);
           element.resolutionState = STATE_DONE;
           return registry.worldImpact;
         });
       });
     });
   }
 
   void resolveMetadataAnnotation(MetadataAnnotationX annotation) {
     reporter.withCurrentElement(
@@ skipping 80 matching lines @@
   TreeElements get treeElements {
     assert(invariant(this, _treeElements != null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 
   void reuseElement() {
     _treeElements = null;
   }
 }