Revert "Reduce use of Element in optimize.dart"

pkg/compiler/lib/src/ssa/builder.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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 50 matching lines @@
   SsaBuilderTask(JavaScriptBackend backend, this.sourceInformationFactory)
       : emitter = backend.emitter,
         backend = backend,
         compiler = backend.compiler,
         super(backend.compiler.measurer);
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   HGraph build(CodegenWorkItem work, ClosedWorld closedWorld) {
     return measure(() {
-      MemberElement element = work.element.implementation;
+      Element element = work.element.implementation;
       return reporter.withCurrentElement(element, () {
         SsaBuilder builder = new SsaBuilder(
             work.element.implementation,
             work.resolvedAst,
             work.registry,
             backend,
             closedWorld,
             emitter.nativeEmitter,
             sourceInformationFactory);
         HGraph graph = builder.build();
 
         // Default arguments are handled elsewhere, but we must ensure
         // that the default values are computed during codegen.
         if (!identical(element.kind, ElementKind.FIELD)) {
-          MethodElement function = element;
+          FunctionElement function = element;
           FunctionSignature signature = function.functionSignature;
           signature.forEachOptionalParameter((ParameterElement parameter) {
             // This ensures the default value will be computed.
             ConstantValue constant =
                 backend.constants.getConstantValue(parameter.constant);
             work.registry.registerCompileTimeConstant(constant);
           });
         }
         if (backend.tracer.isEnabled) {
           String name;
@@ skipping 23 matching lines @@
     with
         BaseImplementationOfCompoundsMixin,
         BaseImplementationOfSetIfNullsMixin,
         BaseImplementationOfSuperIndexSetIfNullMixin,
         SemanticSendResolvedMixin,
         NewBulkMixin,
         ErrorBulkMixin,
         GraphBuilder
     implements SemanticSendVisitor {
   /// The element for which this SSA builder is being used.
-  final MemberElement target;
+  final Element target;
   final ClosedWorld closedWorld;
 
   ResolvedAst resolvedAst;
 
   /// Used to report information about inlining (which occurs while building the
   /// SSA graph), when dump-info is enabled.
   final InfoReporter infoReporter;
 
   /// Registry used to enqueue work during codegen, may be null to avoid
   /// enqueing any work.
@@ skipping 29 matching lines @@
   /**
    * True if we are visiting the expression of a throw statement; we assume this
    * is a slow path.
    */
   bool inExpressionOfThrow = false;
 
   /**
    * This stack contains declaration elements of the functions being built
    * or inlined by this builder.
    */
-  final List<MemberElement> sourceElementStack = <MemberElement>[];
+  final List<Element> sourceElementStack = <Element>[];
 
   HInstruction rethrowableException;
 
   /// Returns `true` if the current element is an `async` function.
   bool get isBuildingAsyncFunction {
     Element element = sourceElement;
     return (element is FunctionElement &&
         element.asyncMarker == AsyncMarker.ASYNC);
   }
 
@@ skipping 57 matching lines @@
   void apply(ast.Node node, [_]) {
     node.accept(this);
   }
 
   /// Returns the current source element.
   ///
   /// The returned element is a declaration element.
   // TODO(johnniwinther): Check that all usages of sourceElement agree on
   // implementation/declaration distinction.
   @override
-  MemberElement get sourceElement => sourceElementStack.last;
+  Element get sourceElement => sourceElementStack.last;
 
   /// Helper to retrieve global inference results for [element] with special
   /// care for `ConstructorBodyElement`s which don't exist at the time the
   /// global analysis run.
   ///
   /// Note: this helper is used selectively. When we know that we are in a
   /// context were we don't expect to see a constructor body element, we
   /// directly fetch the data from the global inference results.
   GlobalTypeInferenceElementResult _resultOf(AstElement element) =>
       inferenceResults.resultOf(
@@ skipping 161 matching lines @@
     // Bail out early if the inlining decision is in the cache and we can't
     // inline (no need to check the hard constraints).
     bool cachedCanBeInlined =
         backend.inlineCache.canInline(function, insideLoop: insideLoop);
     if (cachedCanBeInlined == false) return false;
 
     bool meetsHardConstraints() {
       if (compiler.options.disableInlining) return false;
 
       assert(invariant(
-          currentNode != null ? currentNode : function,
+          currentNode != null ? currentNode : element,
           selector != null ||
-              Elements.isStaticOrTopLevel(function) ||
-              function.isGenerativeConstructorBody,
-          message: "Missing selector for inlining of $function."));
+              Elements.isStaticOrTopLevel(element) ||
+              element.isGenerativeConstructorBody,
+          message: "Missing selector for inlining of $element."));
       if (selector != null) {
         if (!selector.applies(function)) return false;
         if (mask != null && !mask.canHit(function, selector, closedWorld)) {
           return false;
         }
       }
 
-      if (backend.isJsInterop(function)) return false;
+      if (backend.isJsInterop(element)) return false;
 
       // Don't inline operator== methods if the parameter can be null.
-      if (function.name == '==') {
-        if (function.enclosingClass != commonElements.objectClass &&
+      if (element.name == '==') {
+        if (element.enclosingClass != commonElements.objectClass &&
             providedArguments[1].canBeNull()) {
           return false;
         }
       }
 
       // Generative constructors of native classes should not be called directly
       // and have an extra argument that causes problems with inlining.
-      if (function.isGenerativeConstructor &&
-          backend.isNativeOrExtendsNative(function.enclosingClass)) {
+      if (element.isGenerativeConstructor &&
+          backend.isNativeOrExtendsNative(element.enclosingClass)) {
         return false;
       }
 
       // A generative constructor body is not seen by global analysis,
       // so we should not query for its type.
-      if (!function.isGenerativeConstructorBody) {
-        if (inferenceResults.resultOf(function).throwsAlways) {
+      if (!element.isGenerativeConstructorBody) {
+        if (inferenceResults.resultOf(element).throwsAlways) {
           isReachable = false;
           return false;
         }
       }
 
       return true;
     }
 
     bool doesNotContainCode() {
       // A function with size 1 does not contain any code.
       return InlineWeeder.canBeInlined(functionResolvedAst, 1, true,
           enableUserAssertions: compiler.options.enableUserAssertions);
     }
 
     bool reductiveHeuristic() {
       // The call is on a path which is executed rarely, so inline only if it
       // does not make the program larger.
-      if (isCalledOnce(function)) {
+      if (isCalledOnce(element)) {
         return InlineWeeder.canBeInlined(functionResolvedAst, -1, false,
             enableUserAssertions: compiler.options.enableUserAssertions);
       }
       // TODO(sra): Measure if inlining would 'reduce' the size.  One desirable
       // case we miss by doing nothing is inlining very simple constructors
       // where all fields are initialized with values from the arguments at this
       // call site.  The code is slightly larger (`new Foo(1)` vs `Foo$(1)`) but
       // that usually means the factory constructor is left unused and not
       // emitted.
       // We at least inline bodies that are empty (and thus have a size of 1).
       return doesNotContainCode();
     }
 
     bool heuristicSayGoodToGo() {
       // Don't inline recursively
       if (inliningStack.any((entry) => entry.function == function)) {
         return false;
       }
 
-      if (function.isSynthesized) return true;
+      if (element.isSynthesized) return true;
 
       // Don't inline across deferred import to prevent leaking code. The only
       // exception is an empty function (which does not contain code).
       bool hasOnlyNonDeferredImportPaths = compiler.deferredLoadTask
-          .hasOnlyNonDeferredImportPaths(compiler.currentElement, function);
+          .hasOnlyNonDeferredImportPaths(compiler.currentElement, element);
 
       if (!hasOnlyNonDeferredImportPaths) {
         return doesNotContainCode();
       }
 
       // Do not inline code that is rarely executed unless it reduces size.
       if (inExpressionOfThrow || inLazyInitializerExpression) {
         return reductiveHeuristic();
       }
 
@@ skipping 13 matching lines @@
         maxInliningNodes = InlineWeeder.INLINING_NODES_INSIDE_LOOP +
             InlineWeeder.INLINING_NODES_INSIDE_LOOP_ARG_FACTOR * numParameters;
       } else {
         maxInliningNodes = InlineWeeder.INLINING_NODES_OUTSIDE_LOOP +
             InlineWeeder.INLINING_NODES_OUTSIDE_LOOP_ARG_FACTOR * numParameters;
       }
 
       // If a method is called only once, and all the methods in the
       // inlining stack are called only once as well, we know we will
       // save on output size by inlining this method.
-      if (isCalledOnce(function)) {
+      if (isCalledOnce(element)) {
         useMaxInliningNodes = false;
       }
       bool canInline;
       canInline = InlineWeeder.canBeInlined(
           functionResolvedAst, maxInliningNodes, useMaxInliningNodes,
           enableUserAssertions: compiler.options.enableUserAssertions);
       if (canInline) {
-        backend.inlineCache.markAsInlinable(function, insideLoop: insideLoop);
+        backend.inlineCache.markAsInlinable(element, insideLoop: insideLoop);
       } else {
-        backend.inlineCache
-            .markAsNonInlinable(function, insideLoop: insideLoop);
+        backend.inlineCache.markAsNonInlinable(element, insideLoop: insideLoop);
       }
       return canInline;
     }
 
     void doInlining() {
       // Add an explicit null check on the receiver before doing the
       // inlining. We use [element] to get the same name in the
       // NoSuchMethodError message as if we had called it.
-      if (function.isInstanceMember &&
-          !function.isGenerativeConstructorBody &&
+      if (element.isInstanceMember &&
+          !element.isGenerativeConstructorBody &&
           (mask == null || mask.isNullable)) {
         addWithPosition(
             new HFieldGet(null, providedArguments[0], commonMasks.dynamicType,
                 isAssignable: false),
             currentNode);
       }
       List<HInstruction> compiledArguments = completeSendArgumentsList(
           function, selector, providedArguments, currentNode);
       enterInlinedMethod(function, functionResolvedAst, compiledArguments,
           instanceType: instanceType);
       inlinedFrom(functionResolvedAst, () {
         if (!isReachable) {
           emitReturn(graph.addConstantNull(closedWorld), null);
         } else {
           doInline(functionResolvedAst);
         }
       });
       leaveInlinedMethod();
     }
 
     if (meetsHardConstraints() && heuristicSayGoodToGo()) {
       doInlining();
-      infoReporter?.reportInlined(function,
+      infoReporter?.reportInlined(element,
           inliningStack.isEmpty ? target : inliningStack.last.function);
       return true;
     }
 
     return false;
   }
 
   bool get allInlinedFunctionsCalledOnce {
     return inliningStack.isEmpty || inliningStack.last.allFunctionsCalledOnce;
   }
 
-  bool isFunctionCalledOnce(MethodElement element) {
+  bool isFunctionCalledOnce(element) {
     // ConstructorBodyElements are not in the type inference graph.
     if (element is ConstructorBodyElement) return false;
     return inferenceResults.resultOf(element).isCalledOnce;
   }
 
-  bool isCalledOnce(MethodElement element) {
+  bool isCalledOnce(Element element) {
     return allInlinedFunctionsCalledOnce && isFunctionCalledOnce(element);
   }
 
   inlinedFrom(ResolvedAst resolvedAst, f()) {
-    MemberElement element = resolvedAst.element;
+    Element element = resolvedAst.element;
     assert(element is FunctionElement || element is VariableElement);
     return reporter.withCurrentElement(element.implementation, () {
       // The [sourceElementStack] contains declaration elements.
       SourceInformationBuilder oldSourceInformationBuilder =
           sourceInformationBuilder;
       sourceInformationBuilder =
           sourceInformationBuilder.forContext(resolvedAst);
       sourceElementStack.add(element.declaration);
       var result = f();
       sourceInformationBuilder = oldSourceInformationBuilder;
@@ skipping 52 matching lines @@
 
   HInstruction addConstant(ast.Node node) {
     return graph.addConstant(getConstantForNode(node), closedWorld);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be an implementation element.
    */
-  HGraph buildMethod(MethodElement functionElement) {
+  HGraph buildMethod(FunctionElement functionElement) {
     assert(invariant(functionElement, functionElement.isImplementation));
     graph.calledInLoop = closedWorld.isCalledInLoop(functionElement);
     ast.FunctionExpression function = resolvedAst.node;
     assert(function != null);
     assert(elements.getFunctionDefinition(function) != null);
     openFunction(functionElement, function);
     String name = functionElement.name;
     if (backend.isJsInterop(functionElement)) {
       push(invokeJsInteropFunction(functionElement, parameters.values.toList(),
           sourceInformationBuilder.buildGeneric(function)));
@@ skipping 62 matching lines @@
     // Add the parameter as the last instruction of the entry block.
     // If the method is intercepted, we want the actual receiver
     // to be the first parameter.
     graph.entry.addBefore(graph.entry.last, parameter);
     HInstruction value =
         typeBuilder.potentiallyCheckOrTrustType(parameter, field.type);
     add(new HFieldSet(field, thisInstruction, value));
     return closeFunction();
   }
 
-  HGraph buildLazyInitializer(FieldElement variable) {
+  HGraph buildLazyInitializer(VariableElement variable) {
     assert(invariant(variable, resolvedAst.element == variable,
         message: "Unexpected variable $variable for $resolvedAst."));
     inLazyInitializerExpression = true;
     ast.VariableDefinitions node = resolvedAst.node;
     ast.Node initializer = resolvedAst.body;
     assert(invariant(variable, initializer != null,
         message: "Non-constant variable $variable has no initializer."));
     openFunction(variable, node);
     visit(initializer);
     HInstruction value = pop();
@@ skipping 5623 matching lines @@
   }
 
   visitTypeVariable(ast.TypeVariable node) {
     reporter.internalError(node, 'SsaFromAstMixin.visitTypeVariable.');
   }
 
   /**
    * This method is invoked before inlining the body of [function] into this
    * [SsaBuilder].
    */
-  void enterInlinedMethod(MethodElement function,
+  void enterInlinedMethod(FunctionElement function,
       ResolvedAst functionResolvedAst, List<HInstruction> compiledArguments,
       {InterfaceType instanceType}) {
     AstInliningState state = new AstInliningState(
         function,
         returnLocal,
         returnType,
         resolvedAst,
         stack,
         localsHandler,
         inTryStatement,
@@ skipping 328 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }