More dart2js strong mode cleanup.

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 'package:front_end/src/fasta/scanner.dart' show isUserDefinableOperator;
 
 import '../common.dart';
 import '../common/names.dart' show Selectors;
@@ skipping 408 matching lines @@
 
     // Create the scope where the type variables are introduced, if any.
     scope = new MethodScope(scope, function);
     functionSignature.typeVariables
         .forEach((ResolutionDartType type) => addToScope(type.element));
 
     // Create the scope for the function body, and put the parameters in scope.
     scope = new BlockScope(scope);
     Link<Node> parameterNodes =
         (node.parameters == null) ? const Link<Node>() : node.parameters.nodes;
-    functionSignature.forEachParameter((ParameterElementX element) {
+    functionSignature.forEachParameter((_element) {
+      ParameterElementX element = _element;
       // TODO(karlklose): should be a list of [FormalElement]s, but the actual
       // implementation uses [Element].
       List<Element> optionals = functionSignature.optionalParameters;
       if (!optionals.isEmpty && element == optionals.first) {
         NodeList nodes = parameterNodes.head;
         parameterNodes = nodes.nodes;
       }
       if (element.isOptional) {
         if (element.initializer != null) {
           ResolutionResult result = visitInConstantContext(element.initializer);
@@ skipping 11 matching lines @@
       if (element.isInitializingFormal) {
         registry.useElement(parameterNode, element);
       } else {
         LocalParameterElementX parameterElement = element;
         defineLocalVariable(parameterNode, parameterElement);
         addToScope(parameterElement);
       }
       parameterNodes = parameterNodes.tail;
     });
     addDeferredAction(enclosingElement, () {
-      functionSignature.forEachOptionalParameter((ParameterElementX parameter) {
+      functionSignature.forEachOptionalParameter((_parameter) {
+        ParameterElementX parameter = _parameter;
         parameter.constant =
             resolver.constantCompiler.compileConstant(parameter);
       });
     });
     registry.registerCheckedModeCheck(functionSignature.returnType);
-    functionSignature.forEachParameter((ParameterElement element) {
+    functionSignature.forEachParameter((_element) {
+      ParameterElement element = _element;
       registry.registerCheckedModeCheck(element.type);
     });
   }
 
   ResolutionResult visitAssert(Assert node) {
     // 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 3245 matching lines @@
         redirectionTarget,
         redirectionTarget.enclosingClass.thisType
             .subst(type.typeArguments, targetClass.typeVariables)));
     if (resolution.commonElements.isSymbolConstructor(constructor)) {
       registry.registerFeature(Feature.SYMBOL_CONSTRUCTOR);
     }
     if (isValidAsConstant) {
       List<String> names = <String>[];
       List<ConstantExpression> arguments = <ConstantExpression>[];
       int index = 0;
-      constructorSignature.forEachParameter((ParameterElement parameter) {
+      constructorSignature.forEachParameter((_parameter) {
+        ParameterElement parameter = _parameter;
         if (parameter.isNamed) {
           String name = parameter.name;
           names.add(name);
           arguments.add(new NamedArgumentReference(name));
         } else {
           arguments.add(new PositionalArgumentReference(index));
         }
         index++;
       });
       CallStructure callStructure =
@@ skipping 1069 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);
 }