remove dependency on compiler from resolution

pkg/compiler/lib/src/resolution/signatures.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.
 
 library dart2js.resolution.signatures;
 
 import '../common.dart';
-import '../compiler.dart' show Compiler;
+import '../common/resolution.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart'
     show
         ErroneousFieldElementX,
         ErroneousInitializingFormalElementX,
         FormalElementX,
         FunctionSignatureX,
         InitializingFormalElementX,
         LocalParameterElementX,
@@ skipping 14 matching lines @@
   final FunctionTypedElement enclosingElement;
   final Scope scope;
   final MessageKind defaultValuesError;
   final bool createRealParameters;
   List<Element> optionalParameters = const <Element>[];
   int optionalParameterCount = 0;
   bool isOptionalParameter = false;
   bool optionalParametersAreNamed = false;
   VariableDefinitions currentDefinitions;
 
-  SignatureResolver(Compiler compiler, FunctionTypedElement enclosingElement,
-      Scope scope, ResolutionRegistry registry,
-      {this.defaultValuesError, this.createRealParameters})
+  SignatureResolver(
+      Resolution resolution,
+      FunctionTypedElement enclosingElement,
+      Scope scope,
+      ResolutionRegistry registry,
+      {this.defaultValuesError,
+      this.createRealParameters})
       : this.scope = scope,
         this.enclosingElement = enclosingElement,
         this.resolver = new ResolverVisitor(
-            compiler, enclosingElement, registry,
+            resolution, enclosingElement, registry,
             scope: scope),
-        super(compiler, registry);
+        super(resolution, registry);
 
   bool get defaultValuesAllowed => defaultValuesError == null;
 
   visitNodeList(NodeList node) {
     // This must be a list of optional arguments.
     String value = node.beginToken.stringValue;
     if ((!identical(value, '[')) && (!identical(value, '{'))) {
       reporter.internalError(node, "expected optional parameters");
     }
     optionalParametersAreNamed = (identical(value, '{'));
@@ skipping 24 matching lines @@
       reporter.reportErrorMessage(node, MessageKind.FORMAL_DECLARED_STATIC);
     }
 
     if (currentDefinitions != null) {
       reporter.internalError(node, 'function type parameters not supported');
     }
     currentDefinitions = node;
     FormalElementX element = definition.accept(this);
     if (currentDefinitions.metadata != null) {
       element.metadataInternal =
-          compiler.resolver.resolveMetadata(element, node);
+          resolution.resolver.resolveMetadata(element, node);
     }
     currentDefinitions = null;
     return element;
   }
 
   void validateName(Identifier node) {
     if (isOptionalParameter &&
         optionalParametersAreNamed &&
         Name.isPrivateName(node.source)) {
       reporter.reportErrorMessage(node, MessageKind.PRIVATE_NAMED_PARAMETER);
     }
   }
 
   void computeParameterType(FormalElementX element,
       [VariableElement fieldElement]) {
     void computeFunctionType(FunctionExpression functionExpression) {
       FunctionSignature functionSignature = SignatureResolver.analyze(
-          compiler,
+          resolution,
           scope,
           functionExpression.typeVariables,
           functionExpression.parameters,
           functionExpression.returnType,
           element,
           registry,
           defaultValuesError: MessageKind.FUNCTION_TYPE_FORMAL_WITH_DEFAULT);
       element.functionSignature = functionSignature;
     }
 
@@ skipping 158 matching lines @@
 
   /**
    * Resolves formal parameters and return type of a [FunctionExpression]
    * to a [FunctionSignature].
    *
    * If [createRealParameters] is `true`, the parameters will be
    * real parameters implementing the [ParameterElement] interface. Otherwise,
    * the parameters will only implement [FormalElement].
    */
   static FunctionSignature analyze(
-      Compiler compiler,
+      Resolution resolution,
       Scope scope,
       NodeList typeVariables,
       NodeList formalParameters,
       Node returnNode,
       FunctionTypedElement element,
       ResolutionRegistry registry,
       {MessageKind defaultValuesError,
       bool createRealParameters: false,
       bool isFunctionExpression: false}) {
-    DiagnosticReporter reporter = compiler.reporter;
+    DiagnosticReporter reporter = resolution.reporter;
 
     List<DartType> createTypeVariables(NodeList typeVariableNodes) {
       if (typeVariableNodes == null) return const <DartType>[];
 
       // Create the types and elements corresponding to [typeVariableNodes].
       Link<Node> nodes = typeVariableNodes.nodes;
       List<DartType> arguments =
           new List.generate(nodes.slowLength(), (int index) {
         TypeVariable node = nodes.head;
         String variableName = node.name.source;
         nodes = nodes.tail;
         TypeVariableElementX variableElement =
             new TypeVariableElementX(variableName, element, index, node);
         // GENERIC_METHODS: When method type variables are implemented fully we
         // must resolve the actual bounds; currently we just claim that
         // every method type variable has upper bound [dynamic].
         variableElement.boundCache = const DynamicType();
         TypeVariableType variableType =
             new MethodTypeVariableType(variableElement);
         variableElement.typeCache = variableType;
         return variableType;
       }, growable: false);
       return arguments;
     }
 
     List<DartType> typeVariableTypes = createTypeVariables(typeVariables);
     scope = new FunctionSignatureBuildingScope(scope, typeVariableTypes);
     SignatureResolver visitor = new SignatureResolver(
-        compiler, element, scope, registry,
+        resolution, element, scope, registry,
         defaultValuesError: defaultValuesError,
         createRealParameters: createRealParameters);
     List<Element> parameters = const <Element>[];
     int requiredParameterCount = 0;
     if (formalParameters == null) {
       if (!element.isGetter) {
         if (element.isMalformed) {
           // If the element is erroneous, an error should already have been
           // reported. In the case of parse errors, it is possible that there
           // are formal parameters, but something else in the method failed to
           // parse. So we suppress the message about missing formals.
-          assert(invariant(element, compiler.compilationFailed));
+          assert(invariant(element, reporter.hasReportedError));
         } else {
           reporter.reportErrorMessage(element, MessageKind.MISSING_FORMALS);
         }
       }
     } else {
       if (element.isGetter) {
         if (!identical(
             formalParameters.endToken.next.stringValue,
             // TODO(ahe): Remove the check for native keyword.
             'native')) {
           reporter.reportErrorMessage(
               formalParameters, MessageKind.EXTRA_FORMALS);
         }
       }
       LinkBuilder<Element> parametersBuilder =
           visitor.analyzeNodes(formalParameters.nodes);
       requiredParameterCount = parametersBuilder.length;
       parameters = parametersBuilder.toList();
     }
     DartType returnType;
     if (element.isFactoryConstructor) {
       returnType = element.enclosingClass.thisType;
       // Because there is no type annotation for the return type of
       // this element, we explicitly add one.
-      if (compiler.options.enableTypeAssertions) {
+      if (resolution.options.enableTypeAssertions) {
         registry.registerTypeUse(new TypeUse.checkedModeCheck(returnType));
       }
     } else {
       AsyncMarker asyncMarker = AsyncMarker.SYNC;
       if (isFunctionExpression) {
         // Use async marker to determine the return type of function
         // expressions.
         FunctionElement function = element;
         asyncMarker = function.asyncMarker;
       }
       switch (asyncMarker) {
         case AsyncMarker.SYNC:
           returnType = visitor.resolveReturnType(returnNode);
           break;
         case AsyncMarker.SYNC_STAR:
-          returnType = compiler.coreTypes.iterableType();
+          returnType = resolution.coreTypes.iterableType();
           break;
         case AsyncMarker.ASYNC:
-          returnType = compiler.coreTypes.futureType();
+          returnType = resolution.coreTypes.futureType();
           break;
         case AsyncMarker.ASYNC_STAR:
-          returnType = compiler.coreTypes.streamType();
+          returnType = resolution.coreTypes.streamType();
           break;
       }
     }
 
     if (element.isSetter &&
         (requiredParameterCount != 1 || visitor.optionalParameterCount != 0)) {
       // If there are no formal parameters, we already reported an error above.
       if (formalParameters != null) {
         reporter.reportErrorMessage(
             formalParameters, MessageKind.ILLEGAL_SETTER_FORMALS);
@@ skipping 73 matching lines @@
 /// variables of the function signature itself when its signature is analyzed.
 class FunctionSignatureBuildingScope extends TypeVariablesScope {
   @override
   final List<DartType> typeVariables;
 
   FunctionSignatureBuildingScope(Scope parent, this.typeVariables)
       : super(parent);
 
   String toString() => 'FunctionSignatureBuildingScope($typeVariables)';
 }