More dart2js strong mode cleanup.

pkg/compiler/lib/src/kernel/kernel_visitor.dart

 // Copyright (c) 2016, 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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/frontend/accessors.dart'
     show
         Accessor,
         IndexAccessor,
         NullAwarePropertyAccessor,
@@ skipping 1475 matching lines @@
     if (kernel.hasHierarchyProblem(constructor.enclosingClass)) {
       constructorInitializers.add(new ir.InvalidInitializer());
     } else if (constructor.isSynthesized) {
       List<ir.Expression> arguments = const <ir.Expression>[];
       List<ir.NamedExpression> named = const <ir.NamedExpression>[];
       FunctionSignature signature = constructor.functionSignature;
       if (signature.parameterCount != 0) {
         // Mixin application implicit super call.
         arguments = <ir.Expression>[];
         named = <ir.NamedExpression>[];
-        signature.orderedForEachParameter((ParameterElement parameter) {
+        signature.orderedForEachParameter((_parameter) {
+          ParameterElement parameter = _parameter;
           ir.VariableGet argument = buildLocalGet(parameter);
           if (parameter.isNamed) {
             named.add(new ir.NamedExpression(parameter.name, argument));
           } else {
             arguments.add(argument);
           }
         });
       }
       if (kernel.isSyntheticError(constructor.definingConstructor)) {
         constructorInitializers.add(new ir.InvalidInitializer());
@@ skipping 598 matching lines @@
   ir.FunctionNode buildFunctionNode(FunctionElement function, Node bodyNode) {
     List<ir.TypeParameter> typeParameters = <ir.TypeParameter>[];
     List<ir.VariableDeclaration> positionalParameters =
         <ir.VariableDeclaration>[];
     List<ir.VariableDeclaration> namedParameters = <ir.VariableDeclaration>[];
     int requiredParameterCount = 0;
     ir.DartType returnType = const ir.DynamicType();
     if (function.hasFunctionSignature) {
       FunctionSignature signature = function.functionSignature;
       requiredParameterCount = signature.requiredParameterCount;
-      signature.forEachParameter((ParameterElement parameter) {
+      signature.forEachParameter((_parameter) {
+        ParameterElement parameter = _parameter;
         ir.VariableDeclaration variable = getLocal(parameter);
         if (parameter.isNamed) {
           namedParameters.add(variable);
         } else {
           positionalParameters.add(variable);
         }
       });
-      signature.forEachParameter((ParameterElement parameter) {
+      signature.forEachParameter((_parameter) {
+        ParameterElement parameter = _parameter;
         if (!parameter.isOptional) return;
         ir.Expression initializer = visitForValue(parameter.initializer);
         ir.VariableDeclaration variable = getLocal(parameter);
         if (initializer != null) {
           variable.initializer = initializer;
           initializer.parent = variable;
           kernel.parameterInitializerNodeToConstant[initializer] =
               parameter.constant;
         }
       });
@@ skipping 737 matching lines @@
   }
 
   @override
   ir.Expression visitSuperIndexSetIfNull(SendSet node, MethodElement getter,
       MethodElement setter, Node index, Node rhs, _) {
     return _finishSetIfNull(
         node, buildSuperIndexAccessor(index, getter, setter), rhs);
   }
 
   @override
-  // ignore: INVALID_METHOD_OVERRIDE_RETURN_TYPE
   ir.Node visitVariableDefinitions(VariableDefinitions definitions) {
     // TODO(ahe): This method is copied from [SemanticDeclarationResolvedMixin]
     // and modified. Perhaps we can find a way to avoid code duplication.
     List<ir.VariableDeclaration> variables = <ir.VariableDeclaration>[];
     computeVariableStructures(definitions,
         (Node node, VariableStructure structure) {
       if (structure == null) {
-        return internalError(node, 'No structure for $node');
+        internalError(node, 'No structure for $node');
       } else {
         ir.VariableDeclaration variable =
             structure.dispatch(declVisitor, node, null);
         variables.add(variable);
-        return variable;

[Emily Fortuna, 2017/06/14 20:31:20]

we remove this return statement, too?

[ahe, 2017/06/14 20:46:58]

computeVariableStructures ignores what this callback returns.

       }
     });
     if (variables.length == 1) return variables.single;
     return new VariableDeclarations(variables);
   }
 
   IrFunction buildFunction() {
     return kernel.compiler.reporter.withCurrentElement(currentElement, () {
       if (kernel.isSyntheticError(currentElement)) {
         kernel.internalError(currentElement,
@@ skipping 62 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }