Use entities in the TypeSystem interface.

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

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 294 matching lines @@
     if (compiler.options.verbose) {
       compiler.progress.reset();
     }
     sortResolvedAsts().forEach((ResolvedAst resolvedAst) {
       if (compiler.shouldPrintProgress) {
         reporter.log('Added $addedInGraph elements in inferencing graph.');
         compiler.progress.reset();
       }
       // This also forces the creation of the [ElementTypeInformation] to ensure
       // it is in the graph.
-      types.withMember(resolvedAst.element, () => analyze(resolvedAst, null));
+      MemberElement member = resolvedAst.element;
+      types.withMember(member, () => analyze(resolvedAst, null));
     });
     reporter.log('Added $addedInGraph elements in inferencing graph.');
 
     TypeGraphDump dump = debug.PRINT_GRAPH ? new TypeGraphDump(this) : null;
 
     dump?.beforeAnalysis();
     buildWorkQueue();
     refine();
 
     // Try to infer element types of lists and compute their escape information.
@@ skipping 15 matching lines @@
           Iterable<FunctionEntity> elements, ClosureTracerVisitor tracer) {
         tracer.run();
         if (!tracer.continueAnalyzing) {
           elements.forEach((FunctionEntity _element) {
             MethodElement element = _element;
             MethodElement implementation = element.implementation;
             closedWorldRefiner.registerMightBePassedToApply(element);
             if (debug.VERBOSE) {
               print("traced closure $element as ${true} (bail)");
             }
-            implementation.functionSignature.forEachParameter((parameter) {
+            implementation.functionSignature
+                .forEachParameter((FormalElement _parameter) {
+              ParameterElement parameter = _parameter;
               types
                   .getInferredTypeOfParameter(parameter)
                   .giveUp(this, clearAssignments: false);
             });
           });
           bailedOutOn.addAll(elements);
           return;
         }
         elements
             .where((e) => !bailedOutOn.contains(e))
             .forEach((FunctionEntity _element) {
           MethodElement element = _element;
           MethodElement implementation = element.implementation;
-          implementation.functionSignature.forEachParameter((parameter) {
-            var info = types.getInferredTypeOfParameter(parameter);
+          implementation.functionSignature
+              .forEachParameter((FormalElement _parameter) {
+            ParameterElement parameter = _parameter;
+            ParameterTypeInformation info =
+                types.getInferredTypeOfParameter(parameter);
             info.maybeResume();
             workQueue.add(info);
           });
           if (tracer.tracedType.mightBePassedToFunctionApply) {
             closedWorldRefiner.registerMightBePassedToApply(element);
           }
           if (debug.VERBOSE) {
             print("traced closure $element as "
                 "${closedWorldRefiner
                 .getCurrentlyKnownMightBePassedToApply(element)}");
@@ skipping 82 matching lines @@
             if (target is MethodElement) {
               print(
                   '${types.getInferredSignatureOfMethod(target)} for ${target}');
             } else {
               print(
                   '${types.getInferredTypeOfMember(target).type} for ${target}');
             }
           }
         } else if (info is StaticCallSiteTypeInformation) {
           ClassElement cls = info.calledElement.enclosingClass;
-          FunctionElement callMethod = cls.lookupMember(Identifiers.call);
+          MethodElement callMethod = cls.lookupMember(Identifiers.call);
           print('${types.getInferredSignatureOfMethod(callMethod)} for ${cls}');
         } else {
           print('${info.type} for some unknown kind of closure');
         }
       });
       analyzedElements.forEach((MemberElement elem) {
         TypeInformation type = types.getInferredTypeOfMember(elem);
         print('${elem} :: ${type} from ${type.assignments} ');
       });
     }
@@ skipping 177 matching lines @@
         info.closurizedCount++;
         if (Elements.isStaticOrTopLevel(method)) {
           types.allocatedClosures.add(info);
         } else {
           // We add the call-site type information here so that we
           // can benefit from further refinement of the selector.
           types.allocatedClosures.add(caller);
         }
         FunctionElement function = method.implementation;
         FunctionSignature signature = function.functionSignature;
-        signature.forEachParameter((Element parameter) {
+        signature.forEachParameter((FormalElement _parameter) {
+          ParameterElement parameter = _parameter;
           ParameterTypeInformation info =
               types.getInferredTypeOfParameter(parameter);
           info.tagAsTearOffClosureParameter(this);
           if (addToQueue) workQueue.add(info);
         });
       }
     } else {
       MethodElement method = callee;
       FunctionElement function = method.implementation;
       FunctionSignature signature = function.functionSignature;
       int parameterIndex = 0;
       bool visitingRequiredParameter = true;
-      signature.forEachParameter((Element parameter) {
+      signature.forEachParameter((FormalElement _parameter) {
+        ParameterElement parameter = _parameter;
         if (signature.hasOptionalParameters &&
             parameter == signature.optionalParameters.first) {
           visitingRequiredParameter = false;
         }
         TypeInformation type = visitingRequiredParameter
             ? arguments.positional[parameterIndex]
             : signature.optionalParametersAreNamed
                 ? arguments.named[parameter.name]
                 : parameterIndex < arguments.positional.length
                     ? arguments.positional[parameterIndex]
@@ skipping 416 matching lines @@
   /**
    * Records that the captured variable [local] is read.
    */
   void recordCapturedLocalRead(Local local) {}
 
   /**
    * Records that the variable [local] is being updated.
    */
   void recordLocalUpdate(Local local, TypeInformation type) {}
 }