Finish strong mode cleaning of dart2js.

pkg/compiler/lib/src/inferrer/builder.dart

 // Copyright (c) 2013, 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 simple_types_inferrer;
 
 import '../closure.dart' show ClosureRepresentationInfo;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
@@ skipping 911 matching lines @@
     });
     closureData.forEachBoxedVariable((variable, field) {
       locals.setCapturedAndBoxed(variable, field);
     });
     if (analyzedElement.isField) {
       return visit(initializer);
     }
 
     FunctionElement function = analyzedElement;
     FunctionSignature signature = function.functionSignature;
-    signature.forEachOptionalParameter((ParameterElement element) {
+    signature.forEachOptionalParameter((FormalElement _element) {
+      ParameterElement element = _element;
       ast.Expression defaultValue = element.initializer;
       // TODO(25566): The default value of a parameter of a redirecting factory
       // constructor comes from the corresponding parameter of the target.
 
       // If this is a default value from a different context (because
       // the current function is synthetic, e.g., a constructor from
       // a mixin application), we have to start a new inferrer visitor
       // with the correct context.
       // TODO(johnniwinther): Remove once function signatures are fixed.
       ElementGraphBuilder visitor = this;
       if (inferrer.hasAlreadyComputedTypeOfParameterDefault(element)) return;
       if (element.functionDeclaration != analyzedElement) {
         visitor = new ElementGraphBuilder(element.functionDeclaration,
             element.functionDeclaration.resolvedAst, compiler, inferrer);
       }
       TypeInformation type =
           (defaultValue == null) ? types.nullType : visitor.visit(defaultValue);
       inferrer.setDefaultTypeOfParameter(element, type);
     });
 
     if (inferrer.isNativeMember(analyzedElement)) {
       // Native methods do not have a body, and we currently just say
       // they return dynamic.
       return types.dynamicType;
     }
 
     if (analyzedElement.isGenerativeConstructor) {
       isThisExposed = false;
-      signature.forEachParameter((ParameterElement element) {
+      signature.forEachParameter((FormalElement _element) {
+        ParameterElement element = _element;
         TypeInformation parameterType = inferrer.typeOfElement(element);
         if (element.isInitializingFormal) {
           InitializingFormalElement initializingFormal = element;
           if (initializingFormal.fieldElement.isFinal) {
             inferrer.recordTypeOfFinalField(node, analyzedElement,
                 initializingFormal.fieldElement, parameterType);
           } else {
             locals.updateField(initializingFormal.fieldElement, parameterType);
             inferrer.recordTypeOfNonFinalField(initializingFormal.node,
                 initializingFormal.fieldElement, parameterType);
@@ skipping 55 matching lines @@
           returnType = types.nonNullSubclass(cls);
         } else {
           // TODO(johnniwinther): Avoid analyzing [analyzedElement] in this
           // case; it's never called.
           returnType = types.nonNullEmpty();
         }
       } else {
         returnType = types.nonNullExact(cls);
       }
     } else {
-      signature.forEachParameter((LocalParameterElement element) {
+      signature.forEachParameter((FormalElement _element) {
+        ParameterElement element = _element;
         locals.update(element, inferrer.typeOfElement(element), node);
       });
       visit(node.body);
       switch (function.asyncMarker) {
         case AsyncMarker.SYNC:
           if (returnType == null) {
             // No return in the body.
             returnType = locals.seenReturnOrThrow
                 ? types.nonNullEmpty() // Body always throws.
                 : types.nullType;
@@ skipping 139 matching lines @@
   bool isThisOrSuper(ast.Node node) => node.isThis() || node.isSuper();
 
   bool isInClassOrSubclass(Element element) {
     ClassElement cls = outermostElement.enclosingClass;
     ClassElement enclosing = element.enclosingClass;
     return closedWorld.isSubclassOf(enclosing, cls);
   }
 
   void checkIfExposesThis(Selector selector, TypeMask mask) {
     if (isThisExposed) return;
-    inferrer.forEachElementMatching(selector, mask, (element) {
+    inferrer.forEachElementMatching(selector, mask, (dynamic element) {
       if (element.isField) {
         ResolvedAst elementResolvedAst = element.resolvedAst;
         if (!selector.isSetter &&
             isInClassOrSubclass(element) &&
             !element.isFinal &&
             locals.fieldScope.readField(element) == null &&
             elementResolvedAst.body == null) {
           // If the field is being used before this constructor
           // actually had a chance to initialize it, say it can be
           // null.
@@ skipping 1623 matching lines @@
       Spannable node, ConstructorElement element) {
     element = element.implementation;
     FunctionElement function = analyzedElement;
     FunctionSignature signature = function.functionSignature;
     FunctionSignature calleeSignature = element.functionSignature;
     if (!calleeSignature.isCompatibleWith(signature)) {
       return types.nonNullEmpty();
     }
 
     List<TypeInformation> unnamed = <TypeInformation>[];
-    signature.forEachRequiredParameter((ParameterElement element) {
+    signature.forEachRequiredParameter((FormalElement _element) {
+      ParameterElement element = _element;
       assert(locals.use(element) != null);
       unnamed.add(locals.use(element));
     });
 
     Map<String, TypeInformation> named;
     if (signature.optionalParametersAreNamed) {
       named = new Map<String, TypeInformation>();
-      signature.forEachOptionalParameter((ParameterElement element) {
+      signature.forEachOptionalParameter((FormalElement _element) {
+        ParameterElement element = _element;
         named[element.name] = locals.use(element);
       });
     } else {
-      signature.forEachOptionalParameter((ParameterElement element) {
+      signature.forEachOptionalParameter((FormalElement _element) {
+        ParameterElement element = _element;
         unnamed.add(locals.use(element));
       });
     }
 
     ArgumentsTypes arguments = new ArgumentsTypes(unnamed, named);
     return inferrer.registerCalledElement(node, null, null, outermostElement,
         element, arguments, sideEffects, inLoop);
   }
 
   TypeInformation visitRedirectingFactoryBody(ast.RedirectingFactoryBody node) {
@@ skipping 87 matching lines @@
     Selector moveNextSelector = Selectors.moveNext;
     TypeMask moveNextMask = inTreeData.typeOfIteratorMoveNext(node);
 
     TypeInformation iteratorType = handleDynamicSend(node, iteratorSelector,
         iteratorMask, expressionType, new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }