All strong mode cleaning of dart2js.

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 '../common/resolution.dart';
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
@@ skipping 17 matching lines @@
 
 /**
  * [SignatureResolver] resolves function signatures.
  */
 class SignatureResolver extends MappingVisitor<FormalElementX> {
   final ResolverVisitor resolver;
   final FunctionTypedElement enclosingElement;
   final Scope scope;
   final MessageKind defaultValuesError;
   final bool createRealParameters;
-  List<Element> optionalParameters = const <Element>[];
+  List<FormalElement> optionalParameters = const <FormalElement>[];
   int optionalParameterCount = 0;
   bool isOptionalParameter = false;
   bool optionalParametersAreNamed = false;
   VariableDefinitions currentDefinitions;
 
   SignatureResolver(
       Resolution resolution,
       FunctionTypedElement enclosingElement,
       Scope scope,
       ResolutionRegistry registry,
       {this.defaultValuesError,
       this.createRealParameters})
       : this.scope = scope,
         this.enclosingElement = enclosingElement,
         this.resolver = new ResolverVisitor(
             resolution, enclosingElement, registry,
             scope: scope),
         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, '{'));
     isOptionalParameter = true;
-    LinkBuilder<Element> elements = analyzeNodes(node.nodes);
+    LinkBuilder<FormalElement> elements = analyzeNodes(node.nodes);
     optionalParameterCount = elements.length;
     optionalParameters = elements.toList();
   }
 
   FormalElementX visitVariableDefinitions(VariableDefinitions node) {
     Link<Node> definitions = node.definitions.nodes;
     if (definitions.isEmpty) {
       reporter.internalError(node, 'no parameter definition');
       return null;
     }
@@ skipping 166 matching lines @@
       }
       element = new InitializingFormalElementX(
           enclosingElement, currentDefinitions, name, initializer, fieldElement,
           isOptional: isOptionalParameter, isNamed: optionalParametersAreNamed);
       computeParameterType(element, fieldElement);
     }
     return element;
   }
 
   /// A [SendSet] node is an optional parameter with a default value.
-  Element visitSendSet(SendSet node) {
+  FormalElementX visitSendSet(SendSet node) {
     FormalElementX element;
     if (node.receiver != null) {
       element = createFieldParameter(node, node.arguments.first);
     } else if (node.selector.asIdentifier() != null ||
         node.selector.asFunctionExpression() != null) {
       element = createParameter(getParameterName(node), node.arguments.first);
     }
     Node defaultValue = node.arguments.head;
     if (!defaultValuesAllowed) {
       reporter.reportErrorMessage(defaultValue, defaultValuesError);
     }
     return element;
   }
 
-  Element visitFunctionExpression(FunctionExpression node) {
+  FormalElementX visitFunctionExpression(FunctionExpression node) {
     // This is a function typed parameter.
     Modifiers modifiers = currentDefinitions.modifiers;
     if (modifiers.isFinal) {
       reporter.reportErrorMessage(
           modifiers, MessageKind.FINAL_FUNCTION_TYPE_PARAMETER);
     }
     if (modifiers.isVar) {
       reporter.reportErrorMessage(
           modifiers, MessageKind.VAR_FUNCTION_TYPE_PARAMETER);
     }
 
     return createParameter(node.name, null);
   }
 
-  LinkBuilder<Element> analyzeNodes(Link<Node> link) {
-    LinkBuilder<Element> elements = new LinkBuilder<Element>();
+  LinkBuilder<FormalElement> analyzeNodes(Link<Node> link) {
+    LinkBuilder<FormalElement> elements = new LinkBuilder<FormalElement>();
     for (; !link.isEmpty; link = link.tail) {
       Element element = link.head.accept(this);
       if (element != null) {
         elements.addLast(element);
       } else {
         // If parameter is null, the current node should be the last,
         // and a list of optional named parameters.
         if (!link.tail.isEmpty || (link.head is! NodeList)) {
           reporter.internalError(link.head, "expected optional parameters");
         }
@@ skipping 52 matching lines @@
       return arguments;
     }
 
     List<ResolutionDartType> typeVariableTypes =
         createTypeVariables(typeVariables);
     scope = new FunctionSignatureBuildingScope(scope, typeVariableTypes);
     SignatureResolver visitor = new SignatureResolver(
         resolution, element, scope, registry,
         defaultValuesError: defaultValuesError,
         createRealParameters: createRealParameters);
-    List<Element> parameters = const <Element>[];
+    List<FormalElement> parameters = const <FormalElement>[];
     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(reporter.hasReportedError, failedAt(element));
         } 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 =
+      LinkBuilder<FormalElement> parametersBuilder =
           visitor.analyzeNodes(formalParameters.nodes);
       requiredParameterCount = parametersBuilder.length;
       parameters = parametersBuilder.toList();
     }
     ResolutionDartType 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.
       registry.registerCheckedModeCheck(returnType);
@@ skipping 37 matching lines @@
     }
     LinkBuilder<ResolutionDartType> parameterTypes =
         new LinkBuilder<ResolutionDartType>();
     for (FormalElement parameter in parameters) {
       parameterTypes.addLast(parameter.type);
     }
     List<ResolutionDartType> optionalParameterTypes =
         const <ResolutionDartType>[];
     List<String> namedParameters = const <String>[];
     List<ResolutionDartType> namedParameterTypes = const <ResolutionDartType>[];
-    List<Element> orderedOptionalParameters =
+    List<FormalElement> orderedOptionalParameters =
         visitor.optionalParameters.toList();
     if (visitor.optionalParametersAreNamed) {
       // TODO(karlklose); replace when [visitor.optionalParameters] is a [List].
       orderedOptionalParameters.sort((Element a, Element b) {
         return a.name.compareTo(b.name);
       });
       LinkBuilder<String> namedParametersBuilder = new LinkBuilder<String>();
       LinkBuilder<ResolutionDartType> namedParameterTypesBuilder =
           new LinkBuilder<ResolutionDartType>();
       for (FormalElement parameter in orderedOptionalParameters) {
@@ skipping 53 matching lines @@
 /// variables of the function signature itself when its signature is analyzed.
 class FunctionSignatureBuildingScope extends TypeVariablesScope {
   @override
   final List<ResolutionDartType> typeVariables;
 
   FunctionSignatureBuildingScope(Scope parent, this.typeVariables)
       : super(parent);
 
   String toString() => 'FunctionSignatureBuildingScope($typeVariables)';
 }