More dart2js strong mode cleanup.

pkg/compiler/lib/src/elements/elements.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 elements;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
@@ skipping 728 matching lines @@
   static List<T> makeArgumentsList<T>(
       CallStructure callStructure,
       Link<Node> arguments,
       FunctionElement element,
       T compileArgument(Node argument),
       T compileDefaultValue(ParameterElement element)) {
     assert(element.isImplementation, failedAt(element));
     List<T> result = <T>[];
 
     FunctionSignature parameters = element.functionSignature;
-    parameters.forEachRequiredParameter((ParameterElement element) {
+    parameters.forEachRequiredParameter((_) {
       result.add(compileArgument(arguments.head));
       arguments = arguments.tail;
     });
 
     if (!parameters.optionalParametersAreNamed) {
-      parameters.forEachOptionalParameter((ParameterElement element) {
+      parameters.forEachOptionalParameter((_element) {
+        ParameterElement element = _element;
         if (!arguments.isEmpty) {
           result.add(compileArgument(arguments.head));
           arguments = arguments.tail;
         } else {
           result.add(compileDefaultValue(element));
         }
       });
     } else {
       // Visit named arguments and add them into a temporary list.
       List compiledNamedArguments = [];
       for (; !arguments.isEmpty; arguments = arguments.tail) {
         NamedArgument namedArgument = arguments.head;
         compiledNamedArguments.add(compileArgument(namedArgument.expression));
       }
       // Iterate over the optional parameters of the signature, and try to
       // find them in [compiledNamedArguments]. If found, we use the
       // value in the temporary list, otherwise the default value.
-      parameters.orderedOptionalParameters.forEach((ParameterElement element) {
+      parameters.orderedOptionalParameters.forEach((_element) {
+        ParameterElement element = _element;
         int foundIndex = callStructure.namedArguments.indexOf(element.name);
         if (foundIndex != -1) {
           result.add(compiledNamedArguments[foundIndex]);
         } else {
           result.add(compileDefaultValue(element));
         }
       });
     }
     return result;
   }
@@ skipping 24 matching lines @@
             "Cannot compute arguments to malformed constructor: "
             "$caller calling $callee."));
 
     FunctionSignature signature = caller.functionSignature;
     Map<Node, ParameterElement> mapping = <Node, ParameterElement>{};
 
     // TODO(ngeoffray): This is a hack that fakes up AST nodes, so
     // that we can call [addArgumentsToList].
     Link<Node> computeCallNodesFromParameters() {
       LinkBuilder<Node> builder = new LinkBuilder<Node>();
-      signature.forEachRequiredParameter((ParameterElement element) {
+      signature.forEachRequiredParameter((_element) {
+        ParameterElement element = _element;
         Node node = element.node;
         mapping[node] = element;
         builder.addLast(node);
       });
       if (signature.optionalParametersAreNamed) {
-        signature.forEachOptionalParameter((ParameterElement element) {
+        signature.forEachOptionalParameter((_element) {
+          ParameterElement element = _element;
           mapping[element.initializer] = element;
           builder.addLast(new NamedArgument(null, null, element.initializer));
         });
       } else {
-        signature.forEachOptionalParameter((ParameterElement element) {
+        signature.forEachOptionalParameter((_element) {
+          ParameterElement element = _element;
           Node node = element.node;
           mapping[node] = element;
           builder.addLast(node);
         });
       }
       return builder.toLink();
     }
 
     T internalCompileArgument(Node node) {
       return compileArgument(mapping[node]);
@@ skipping 1025 matching lines @@
   /// by a field.
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }