remove dependency on compiler from resolution

pkg/compiler/lib/src/resolution/members.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.members;
 
 import '../common.dart';
 import '../common/names.dart' show Selectors;
-import '../common/resolution.dart' show Feature;
-import '../compiler.dart' show Compiler;
+import '../common/resolution.dart' show Feature, Resolution;
+import '../compile_time_constants.dart';
 import '../constants/constructors.dart'
     show RedirectingFactoryConstantConstructor;
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../core_types.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart'
     show
         ConstructorElementX,
         ErroneousElementX,
         FunctionElementX,
         InitializingFormalElementX,
         JumpTargetX,
         LocalFunctionElementX,
         LocalParameterElementX,
         ParameterElementX,
         VariableElementX,
         VariableList;
+import '../options.dart';
 import '../tokens/token.dart' show isUserDefinableOperator;
 import '../tree/tree.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import '../universe/use.dart' show DynamicUse, StaticUse, TypeUse;
 import '../util/util.dart' show Link;
 import 'access_semantics.dart';
 import 'class_members.dart' show MembersCreator;
 import 'constructors.dart'
     show ConstructorResolver, ConstructorResult, ConstructorResultKind;
@@ skipping 95 matching lines @@
           r'>=|'
           r'>|'
           r'<=|'
           r'<|'
           r'&|'
           r'\^|'
           r'\|'
           r')$');
 
   ResolverVisitor(
-      Compiler compiler, Element element, ResolutionRegistry registry,
+      Resolution resolution, Element element, ResolutionRegistry registry,
       {Scope scope, bool useEnclosingScope: false})
       : this.enclosingElement = element,
         // When the element is a field, we are actually resolving its
         // initial value, which should not have access to instance
         // fields.
         inInstanceContext = (element.isInstanceMember && !element.isField) ||
             element.isGenerativeConstructor,
         this.currentClass =
             element.isClassMember ? element.enclosingClass : null,
         this.statementScope = new StatementScope(),
         this.scope = scope ??
             (useEnclosingScope
                 ? Scope.buildEnclosingScope(element)
                 : element.buildScope()),
         // The type annotations on a typedef do not imply type checks.
         // TODO(karlklose): clean this up (dartbug.com/8870).
-        inCheckContext = compiler.options.enableTypeAssertions &&
+        inCheckContext = resolution.options.enableTypeAssertions &&
             !element.isLibrary &&
             !element.isTypedef &&
             !element.enclosingElement.isTypedef,
         inCatchBlock = false,
         constantState = element.isConst
             ? ConstantState.CONSTANT
             : ConstantState.NON_CONSTANT,
-        super(compiler, registry);
+        super(resolution, registry);
 
-  CoreClasses get coreClasses => compiler.coreClasses;
-
-  CoreTypes get coreTypes => compiler.coreTypes;
+  CoreClasses get coreClasses => resolution.coreClasses;
+  CoreTypes get coreTypes => resolution.coreTypes;
+  ConstantEnvironment get constants => resolution.constants;
+  ResolverTask get resolver => resolution.resolver;
+  CompilerOptions get options => resolution.options;
 
   AsyncMarker get currentAsyncMarker {
     if (enclosingElement is FunctionElement) {
       FunctionElement function = enclosingElement;
       return function.asyncMarker;
     }
     return AsyncMarker.SYNC;
   }
 
   Element reportLookupErrorIfAny(Element result, Node node, String name) {
@@ skipping 262 matching lines @@
       } else {
         LocalParameterElementX parameterElement = element;
         defineLocalVariable(parameterNode, parameterElement);
         addToScope(parameterElement);
       }
       parameterNodes = parameterNodes.tail;
     });
     addDeferredAction(enclosingElement, () {
       functionSignature.forEachOptionalParameter((ParameterElementX parameter) {
         parameter.constant =
-            compiler.resolver.constantCompiler.compileConstant(parameter);
+            resolver.constantCompiler.compileConstant(parameter);
       });
     });
     if (inCheckContext) {
       functionSignature.forEachParameter((ParameterElement element) {
         registry.registerTypeUse(new TypeUse.checkedModeCheck(element.type));
       });
     }
   }
 
   ResolutionResult visitAssert(Assert node) {
-    if (!compiler.options.enableAssertMessage) {
+    if (!options.enableAssertMessage) {
       if (node.hasMessage) {
         reporter.reportErrorMessage(
             node, MessageKind.EXPERIMENTAL_ASSERT_MESSAGE);
       }
     }
     // TODO(sra): We could completely ignore the assert in production mode if we
     // didn't need it to be resolved for type checking.
     registry.registerFeature(
         node.hasMessage ? Feature.ASSERT_WITH_MESSAGE : Feature.ASSERT);
     visit(node.condition);
@@ skipping 87 matching lines @@
     }
     visit(node.returnType);
     String name;
     if (node.name == null) {
       name = "";
     } else {
       name = node.name.asIdentifier().source;
     }
     LocalFunctionElementX function = new LocalFunctionElementX(
         name, node, ElementKind.FUNCTION, Modifiers.EMPTY, enclosingElement);
-    ResolverTask.processAsyncMarker(compiler, function, registry);
+    ResolverTask.processAsyncMarker(resolution, function, registry);
     function.functionSignature = SignatureResolver.analyze(
-        compiler,
+        resolution,
         scope,
         node.typeVariables,
         node.parameters,
         node.returnType,
         function,
         registry,
         createRealParameters: true,
         isFunctionExpression: !inFunctionDeclaration);
     checkLocalDefinitionName(node, function);
     registry.defineFunction(node, function);
@@ skipping 1421 matching lines @@
   }
 
   /// Handle access to a constant type literal of [type].
   // TODO(johnniwinther): Remove [name] when [Selector] is not required for the
   // the [GetStructure].
   // TODO(johnniwinther): Remove [element] when it is no longer needed for
   // evaluating constants.
   ResolutionResult handleConstantTypeLiteralUpdate(SendSet node, Name name,
       TypeDeclarationElement element, DartType type, ConstantAccess semantics) {
     // TODO(johnniwinther): Remove this when all constants are evaluated.
-    compiler.resolver.constantCompiler.evaluate(semantics.constant);
+    resolver.constantCompiler.evaluate(semantics.constant);
 
     ErroneousElement error;
     if (node.isIfNullAssignment) {
       error = reportAndCreateErroneousElement(node.selector, name.text,
           MessageKind.IF_NULL_ASSIGNING_TYPE, const {});
       // TODO(23998): Remove these when all information goes through
       // the [SendStructure].
       registry.setConstant(node.selector, semantics.constant);
       registry.useElement(node.selector, element);
     } else {
@@ skipping 531 matching lines @@
     ErroneousElement error;
     if (element.isParameter) {
       if (element.isFinal) {
         error = reportAndCreateErroneousElement(node.selector, name.text,
             MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER, {'name': name});
         semantics = new StaticAccess.finalParameter(element);
       } else {
         semantics = new StaticAccess.parameter(element);
       }
     } else if (element.isInitializingFormal &&
-        compiler.options.enableInitializingFormalAccess) {
+        options.enableInitializingFormalAccess) {
       error = reportAndCreateErroneousElement(node.selector, name.text,
           MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER, {'name': name});
       semantics = new StaticAccess.finalParameter(element);
     } else if (element.isVariable) {
       if (element.isFinal || element.isConst) {
         error = reportAndCreateErroneousElement(node.selector, name.text,
             MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER, {'name': name});
         semantics = new StaticAccess.finalLocalVariable(element);
       } else {
         semantics = new StaticAccess.localVariable(element);
@@ skipping 37 matching lines @@
       } else {
         member = abstractField.setter;
       }
     } else {
       member = element;
     }
     // TODO(johnniwinther): Needed to provoke a parsing and with it discovery
     // of parse errors to make [element] erroneous. Fix this!
     member.computeType(resolution);
 
-    if (member == compiler.mirrorSystemGetNameFunction &&
-        !compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(enclosingElement)) {
+    if (member == resolution.mirrorSystemGetNameFunction &&
+        !resolution.mirrorUsageAnalyzerTask.hasMirrorUsage(enclosingElement)) {
       reporter
           .reportHintMessage(node.selector, MessageKind.STATIC_FUNCTION_BLOAT, {
-        'class': compiler.mirrorSystemClass.name,
-        'name': compiler.mirrorSystemGetNameFunction.name
+        'class': resolution.mirrorSystemClass.name,
+        'name': resolution.mirrorSystemGetNameFunction.name
       });
     }
 
     Selector selector;
     AccessSemantics semantics =
         computeStaticOrTopLevelAccessSemantics(node, member);
     if (node.isCall) {
       ArgumentsResult argumentsResult = resolveArguments(node.argumentsNode);
       CallStructure callStructure = argumentsResult.callStructure;
       selector = new Selector.call(name, callStructure);
 
       bool isIncompatibleInvoke = false;
       switch (semantics.kind) {
         case AccessKind.STATIC_METHOD:
         case AccessKind.TOPLEVEL_METHOD:
           MethodElement method = semantics.element;
           method.computeType(resolution);
           if (!callStructure.signatureApplies(method.functionSignature)) {
             registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
             registry.registerDynamicUse(new DynamicUse(selector, null));
             isIncompatibleInvoke = true;
           } else {
             registry.registerStaticUse(
                 new StaticUse.staticInvoke(semantics.element, callStructure));
             handleForeignCall(node, semantics.element, callStructure);
-            if (method == compiler.identicalFunction &&
+            if (method == resolution.identicalFunction &&
                 argumentsResult.isValidAsConstant) {
               result = new ConstantResult(
                   node,
                   new IdenticalConstantExpression(
                       argumentsResult.argumentResults[0].constant,
                       argumentsResult.argumentResults[1].constant));
             }
           }
           break;
         case AccessKind.STATIC_FIELD:
@@ skipping 349 matching lines @@
         for (Node scope in promotionScope) {
           registry.setAccessedByClosureIn(scope, target, node);
         }
       }
     }
   }
 
   // TODO(johnniwinther): Move this to the backend resolution callbacks.
   void handleForeignCall(
       Send node, Element target, CallStructure callStructure) {
-    if (target != null && compiler.backend.isForeign(target)) {
+    if (target != null && resolution.target.isForeign(target)) {
       registry.registerForeignCall(node, target, callStructure, this);
     }
   }
 
   /// Callback for native enqueuer to parse a type.  Returns [:null:] on error.
   DartType resolveTypeFromString(Node node, String typeName) {
     Element element = lookupInScope(reporter, node, scope, typeName);
     if (element == null) return null;
     if (element is! ClassElement) return null;
     ClassElement cls = element;
@@ skipping 528 matching lines @@
       } else if (!node.isArrowBody && currentAsyncMarker.isYielding) {
         reporter.reportErrorMessage(node, MessageKind.RETURN_IN_GENERATOR,
             {'modifier': currentAsyncMarker});
       }
     }
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitYield(Yield node) {
-    if (!compiler.backend.supportsAsyncAwait) {

[Johnni Winther, 2016/07/08 08:05:39]

Dartino still needs this. Move the [supportsAsyncAwait] to [Target] and leave
the check in.

[Harry Terkelsen, 2016/07/18 17:35:58]

Done.

-      reporter.reportErrorMessage(
-          node.yieldToken, MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
+    if (!currentAsyncMarker.isYielding) {
+      reporter.reportErrorMessage(node, MessageKind.INVALID_YIELD);
+    }
+    if (currentAsyncMarker.isAsync) {
+      coreClasses.streamClass.ensureResolved(resolution);
     } else {
-      if (!currentAsyncMarker.isYielding) {
-        reporter.reportErrorMessage(node, MessageKind.INVALID_YIELD);
-      }
-      if (currentAsyncMarker.isAsync) {
-        coreClasses.streamClass.ensureResolved(resolution);
-      } else {
-        coreClasses.iterableClass.ensureResolved(resolution);
-      }
+      coreClasses.iterableClass.ensureResolved(resolution);
     }
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     if (!enclosingElement.isFactoryConstructor) {
       reporter.reportErrorMessage(
           node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
       reporter.reportHintMessage(
@@ skipping 12 matching lines @@
       constructor.redirectionDeferredPrefix = result.prefix;
     }
 
     registry.setRedirectingTargetConstructor(node, redirectionTarget);
     switch (result.kind) {
       case ConstructorResultKind.GENERATIVE:
       case ConstructorResultKind.FACTORY:
         // Register a post process to check for cycles in the redirection chain
         // and set the actual generative constructor at the end of the chain.
         addDeferredAction(constructor, () {
-          compiler.resolver.resolveRedirectionChain(constructor, node);
+          resolver.resolveRedirectionChain(constructor, node);
         });
         break;
       case ConstructorResultKind.ABSTRACT:
       case ConstructorResultKind.INVALID_TYPE:
       case ConstructorResultKind.UNRESOLVED_CONSTRUCTOR:
       case ConstructorResultKind.NON_CONSTANT:
         isValidAsConstant = false;
         constructor.setEffectiveTarget(result.element, result.type,
             isMalformed: true);
         break;
@@ skipping 17 matching lines @@
 
     // Check that the target constructor is type compatible with the
     // redirecting constructor.
     ClassElement targetClass = redirectionTarget.enclosingClass;
     InterfaceType type = registry.getType(node);
     FunctionType targetConstructorType = redirectionTarget
         .computeType(resolution)
         .subst(type.typeArguments, targetClass.typeVariables);
     FunctionType constructorType = constructor.computeType(resolution);
     bool isSubtype =
-        compiler.types.isSubtype(targetConstructorType, constructorType);
+        resolution.types.isSubtype(targetConstructorType, constructorType);
     if (!isSubtype) {
       reporter.reportWarningMessage(node, MessageKind.NOT_ASSIGNABLE,
           {'fromType': targetConstructorType, 'toType': constructorType});
       // TODO(johnniwinther): Handle this (potentially) erroneous case.
       isValidAsConstant = false;
     }
 
     redirectionTarget.computeType(resolution);
     FunctionSignature targetSignature = redirectionTarget.functionSignature;
     constructor.computeType(resolution);
     FunctionSignature constructorSignature = constructor.functionSignature;
     if (!targetSignature.isCompatibleWith(constructorSignature)) {
       assert(!isSubtype);
       registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
       isValidAsConstant = false;
     }
 
     registry.registerStaticUse(
         new StaticUse.constructorRedirect(redirectionTarget));
     // TODO(johnniwinther): Register the effective target type as part of the
     // static use instead.
     registry.registerTypeUse(new TypeUse.instantiation(redirectionTarget
         .enclosingClass.thisType
         .subst(type.typeArguments, targetClass.typeVariables)));
-    if (enclosingElement == compiler.symbolConstructor) {
+    if (enclosingElement == resolution.symbolConstructor) {
       registry.registerFeature(Feature.SYMBOL_CONSTRUCTOR);
     }
     if (isValidAsConstant) {
       List<String> names = <String>[];
       List<ConstantExpression> arguments = <ConstantExpression>[];
       int index = 0;
       constructorSignature.forEachParameter((ParameterElement parameter) {
         if (parameter.isNamed) {
           String name = parameter.name;
           names.add(name);
@@ skipping 13 matching lines @@
     return const NoneResult();
   }
 
   ResolutionResult visitThrow(Throw node) {
     registry.registerFeature(Feature.THROW_EXPRESSION);
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitAwait(Await node) {
-    if (!compiler.backend.supportsAsyncAwait) {

[Johnni Winther, 2016/07/08 08:05:39]

Ditto.

[Harry Terkelsen, 2016/07/18 17:35:58]

Done.

-      reporter.reportErrorMessage(
-          node.awaitToken, MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
-    } else {
-      if (!currentAsyncMarker.isAsync) {
-        reporter.reportErrorMessage(node, MessageKind.INVALID_AWAIT);
-      }
-      coreClasses.futureClass.ensureResolved(resolution);
+    if (!currentAsyncMarker.isAsync) {
+      reporter.reportErrorMessage(node, MessageKind.INVALID_AWAIT);
     }
+    coreClasses.futureClass.ensureResolved(resolution);
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitVariableDefinitions(VariableDefinitions node) {
     DartType type;
     if (node.type != null) {
       type = resolveTypeAnnotation(node.type);
     } else {
       type = const DynamicType();
     }
     VariableList variables = new VariableList.node(node, type);
     VariableDefinitionsVisitor visitor =
-        new VariableDefinitionsVisitor(compiler, node, this, variables);
+        new VariableDefinitionsVisitor(resolution, node, this, variables);
 
     Modifiers modifiers = node.modifiers;
     void reportExtraModifier(String modifier) {
       Node modifierNode;
       for (Link<Node> nodes = modifiers.nodes.nodes;
           !nodes.isEmpty;
           nodes = nodes.tail) {
         if (modifier == nodes.head.asIdentifier().source) {
           modifierNode = nodes.head;
           break;
@@ skipping 12 matching lines @@
     if (enclosingElement.isFunction || enclosingElement.isConstructor) {
       if (modifiers.isAbstract) {
         reportExtraModifier('abstract');
       }
       if (modifiers.isStatic) {
         reportExtraModifier('static');
       }
     }
     if (node.metadata != null) {
       variables.metadataInternal =
-          compiler.resolver.resolveMetadata(enclosingElement, node);
+          resolver.resolveMetadata(enclosingElement, node);
     }
     visitor.visit(node.definitions);
     return const NoneResult();
   }
 
   ResolutionResult visitWhile(While node) {
     visit(node.condition);
     visitLoopBodyIn(node, node.body, new BlockScope(scope));
     return const NoneResult();
   }
@@ skipping 99 matching lines @@
           constructor.declaration, callStructure));
       // TODO(johniwinther): Avoid registration of `type` in face of redirecting
       // factory constructors.
       registry.registerTypeUse(new TypeUse.instantiation(type));
     }
 
     ResolutionResult resolutionResult = const NoneResult();
     if (node.isConst) {
       bool isValidAsConstant = !isInvalid && constructor.isConst;
 
-      if (constructor == compiler.symbolConstructor) {
+      if (constructor == resolution.symbolConstructor) {
         Node argumentNode = node.send.arguments.head;
-        ConstantExpression constant = compiler.resolver.constantCompiler
+        ConstantExpression constant = resolver.constantCompiler
             .compileNode(argumentNode, registry.mapping);
-        ConstantValue name = compiler.constants.getConstantValue(constant);
+        ConstantValue name = resolution.constants.getConstantValue(constant);
         if (!name.isString) {
           DartType type = name.getType(coreTypes);
           reporter.reportErrorMessage(
               argumentNode, MessageKind.STRING_EXPECTED, {'type': type});
         } else {
           StringConstantValue stringConstant = name;
           String nameString = stringConstant.toDartString().slowToString();
           if (validateSymbol(argumentNode, nameString)) {
             registry.registerConstSymbol(nameString);
           }
         }
-      } else if (constructor == compiler.mirrorsUsedConstructor) {
-        compiler.mirrorUsageAnalyzerTask.validate(node, registry.mapping);
+      } else if (constructor == resolution.mirrorsUsedConstructor) {
+        resolution.mirrorUsageAnalyzerTask.validate(node, registry.mapping);
       }
 
       analyzeConstantDeferred(node);
 
       if (type.containsTypeVariables) {
         reporter.reportErrorMessage(
             node.send.selector, MessageKind.TYPE_VARIABLE_IN_CONSTANT);
         isValidAsConstant = false;
         isInvalid = true;
       }
@@ skipping 38 matching lines @@
         // [LateConstInvokeStructure]; it might not be necessary.
         registry.registerNewStructure(node, structure);
         onAnalyzed = () {
           registry.registerNewStructure(node, structure.resolve(node));
         };
       }
 
       analyzeConstantDeferred(node, onAnalyzed: onAnalyzed);
     } else {
       // Not constant.
-      if (constructor == compiler.symbolConstructor &&
-          !compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(enclosingElement)) {
+      if (constructor == resolution.symbolConstructor &&
+          !resolution.mirrorUsageAnalyzerTask
+              .hasMirrorUsage(enclosingElement)) {
         reporter.reportHintMessage(node.newToken, MessageKind.NON_CONST_BLOAT,
             {'name': coreClasses.symbolClass.name});
       }
       registry.registerNewStructure(
           node,
           new NewInvokeStructure(
               new ConstructorAccessSemantics(kind, constructor, type),
               selector));
     }
 
@@ skipping 10 matching lines @@
       if (cls == coreClasses.stringClass) continue;
       Element equals = cls.lookupMember('==');
       if (equals.enclosingClass != coreClasses.objectClass) {
         reporter.reportErrorMessage(spannable,
             MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS, {'type': keyType});
       }
     }
   }
 
   void analyzeConstant(Node node, {enforceConst: true}) {
-    ConstantExpression constant = compiler.resolver.constantCompiler
+    ConstantExpression constant = resolver.constantCompiler
         .compileNode(node, registry.mapping, enforceConst: enforceConst);
 
     if (constant == null) {
-      assert(invariant(node, compiler.compilationFailed));
+      assert(invariant(node, reporter.hasReportedError));
       return;
     }
 
-    ConstantValue value = compiler.constants.getConstantValue(constant);
+    ConstantValue value = resolution.constants.getConstantValue(constant);
     if (value.isMap) {
       checkConstMapKeysDontOverrideEquals(node, value);
     }
   }
 
   void analyzeConstantDeferred(Node node,
       {bool enforceConst: true, void onAnalyzed()}) {
     addDeferredAction(enclosingElement, () {
       analyzeConstant(node, enforceConst: enforceConst);
       if (onAnalyzed != null) {
@@ skipping 20 matching lines @@
     }
     return true;
   }
 
   /**
    * Try to resolve the constructor that is referred to by [node].
    * Note: this function may return an ErroneousFunctionElement instead of
    * [:null:], if there is no corresponding constructor, class or library.
    */
   ConstructorResult resolveConstructor(NewExpression node) {
-    return node.accept(
-        new ConstructorResolver(compiler, this, inConstContext: node.isConst));
+    return node.accept(new ConstructorResolver(resolution, this,
+        inConstContext: node.isConst));
   }
 
   ConstructorResult resolveRedirectingFactory(RedirectingFactoryBody node,
       {bool inConstContext: false}) {
-    return node.accept(new ConstructorResolver(compiler, this,
+    return node.accept(new ConstructorResolver(resolution, this,
         inConstContext: inConstContext));
   }
 
   DartType resolveTypeAnnotation(TypeAnnotation node,
       {bool malformedIsError: false, bool deferredIsMalformed: true}) {
     DartType type = typeResolver.resolveTypeAnnotation(this, node,
         malformedIsError: malformedIsError,
         deferredIsMalformed: deferredIsMalformed);
     if (inCheckContext) {
       registry.registerTypeUse(new TypeUse.checkedModeCheck(type));
@@ skipping 168 matching lines @@
     }
     registry.registerTargetOf(node, target);
     return const NoneResult();
   }
 
   registerImplicitInvocation(Selector selector) {
     registry.registerDynamicUse(new DynamicUse(selector, null));
   }
 
   ResolutionResult visitAsyncForIn(AsyncForIn node) {
-    if (!compiler.backend.supportsAsyncAwait) {

[Johnni Winther, 2016/07/08 08:05:39]

Ditto.

+    if (!currentAsyncMarker.isAsync) {
       reporter.reportErrorMessage(
-          node.awaitToken, MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
-    } else {
-      if (!currentAsyncMarker.isAsync) {
-        reporter.reportErrorMessage(
-            node.awaitToken, MessageKind.INVALID_AWAIT_FOR_IN);
-      }
-      registry.registerFeature(Feature.ASYNC_FOR_IN);
-      registry.registerDynamicUse(new DynamicUse(Selectors.current, null));
-      registry.registerDynamicUse(new DynamicUse(Selectors.moveNext, null));
+          node.awaitToken, MessageKind.INVALID_AWAIT_FOR_IN);
     }
+    registry.registerFeature(Feature.ASYNC_FOR_IN);
+    registry.registerDynamicUse(new DynamicUse(Selectors.current, null));
+    registry.registerDynamicUse(new DynamicUse(Selectors.moveNext, null));
+
     visit(node.expression);
 
     Scope blockScope = new BlockScope(scope);
     visitForInDeclaredIdentifierIn(node.declaredIdentifier, node, blockScope);
     visitLoopBodyIn(node, node.body, blockScope);
     return const NoneResult();
   }
 
   ResolutionResult visitSyncForIn(SyncForIn node) {
     registry.registerFeature(Feature.SYNC_FOR_IN);
@@ skipping 56 matching lines @@
     if (loopVariableSelector != null) {
       registry.setSelector(declaration, loopVariableSelector);
       if (loopVariable == null || loopVariable.isInstanceMember) {
         registry.registerDynamicUse(new DynamicUse(loopVariableSelector, null));
       } else if (loopVariable.isStatic || loopVariable.isTopLevel) {
         registry.registerStaticUse(
             new StaticUse.staticSet(loopVariable.declaration));
       }
     } else {
       // The selector may only be null if we reported an error.
-      assert(invariant(declaration, compiler.compilationFailed));
+      assert(invariant(declaration, reporter.hasReportedError));
     }
     if (loopVariable != null) {
       // loopVariable may be null if it could not be resolved.
       registry.setForInVariable(node, loopVariable);
     }
   }
 
   visitLabel(Label node) {
     // Labels are handled by their containing statements/cases.
   }
@@ skipping 142 matching lines @@
       for (Node labelOrCase in switchCase.labelsAndCases) {
         CaseMatch caseMatch = labelOrCase.asCaseMatch();
         if (caseMatch == null) continue;
 
         // Analyze the constant.
         ConstantExpression constant =
             registry.getConstant(caseMatch.expression);
         assert(invariant(node, constant != null,
             message: 'No constant computed for $node'));
 
-        ConstantValue value = compiler.constants.getConstantValue(constant);
+        ConstantValue value = resolution.constants.getConstantValue(constant);
         DartType caseType = value.getType(coreTypes); //typeOfConstant(value);
 
         if (firstCaseType == null) {
           firstCase = caseMatch;
           firstCaseType = caseType;
 
           // We only report the bad type on the first class element. All others
           // get a "type differs" error.
           if (caseType == coreTypes.doubleType) {
             reporter.reportErrorMessage(
@@ skipping 216 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(
     DiagnosticReporter reporter, Node node, Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }