Change inference element invariants

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 221 matching lines @@
       this.registry,
       JavaScriptBackend backend,
       this.closedWorld,
       this.nativeEmitter,
       SourceInformationStrategy sourceInformationFactory)
       : this.infoReporter = backend.compiler.dumpInfoTask,
         this.backend = backend,
         this.constantSystem = backend.constantSystem,
         this.rtiSubstitutions = backend.rtiSubstitutions {
     assert(target.isImplementation);
-    elementInferenceResults = _resultOf(target);
+    elementInferenceResults = _resultOf(target.declaration);
     assert(elementInferenceResults != null);
     graph.element = target;
-    sourceElementStack.add(target);
+    sourceElementStack.add(target.declaration);
     sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(target);
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     localsHandler = new LocalsHandler(
         this,
         target,
         target.memberContext,
         target.contextClass,
         null,
@@ skipping 29 matching lines @@
   @override
   MemberElement 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(MemberElement element) =>
-      globalInferenceResults.resultOfMember(
-          element is ConstructorBodyElementX ? element.constructor : element);
+  GlobalTypeInferenceElementResult _resultOf(MemberElement element) {
+    assert(element.isDeclaration);
+    return globalInferenceResults.resultOfMember(
+        element is ConstructorBodyElementX ? element.constructor : element);
+  }
 
   /// Build the graph for [target].
   HGraph build() {
     assert(target.isImplementation, failedAt(target));
     HInstruction.idCounter = 0;
     // TODO(sigmund): remove `result` and return graph directly, need to ensure
     // that it can never be null (see result in buildFactory for instance).
     var result;
     if (target.isGenerativeConstructor) {
       result = buildFactory(resolvedAst);
@@ skipping 174 matching lines @@
       // Generative constructors of native classes should not be called directly
       // and have an extra argument that causes problems with inlining.
       if (function.isGenerativeConstructor &&
           nativeData.isNativeOrExtendsNative(function.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 (globalInferenceResults.resultOfMember(function).throwsAlways) {
+        if (globalInferenceResults.resultOfMember(declaration).throwsAlways) {
           isReachable = false;
           return false;
         }
       }
 
       return true;
     }
 
     bool doesNotContainCode() {
       // A function with size 1 does not contain any code.
       return InlineWeeder.canBeInlined(functionResolvedAst, 1,
           enableUserAssertions: 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(declaration)) {
         return InlineWeeder.canBeInlined(functionResolvedAst, null,
             enableUserAssertions: 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).
@@ skipping 37 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(declaration)) {
         maxInliningNodes = null;
       }
       bool canInline = InlineWeeder.canBeInlined(
           functionResolvedAst, maxInliningNodes,
           enableUserAssertions: options.enableUserAssertions);
       if (canInline) {
         inlineCache.markAsInlinable(declaration, insideLoop: insideLoop);
       } else {
         inlineCache.markAsNonInlinable(declaration, insideLoop: insideLoop);
       }
@@ skipping 42 matching lines @@
     return inliningStack.isEmpty || inliningStack.last.allFunctionsCalledOnce;
   }
 
   bool isFunctionCalledOnce(MethodElement element) {
     // ConstructorBodyElements are not in the type inference graph.
     if (element is ConstructorBodyElement) return false;
     return globalInferenceResults.resultOfMember(element).isCalledOnce;
   }
 
   bool isCalledOnce(MethodElement element) {
+    assert(element.isDeclaration);
     return allInlinedFunctionsCalledOnce && isFunctionCalledOnce(element);
   }
 
   inlinedFrom(ResolvedAst resolvedAst, f()) {
     MemberElement 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(element);
-      sourceElementStack.add(element.declaration);
+      sourceElementStack.add(element);
       var result = f();
       sourceInformationBuilder = oldSourceInformationBuilder;
       sourceElementStack.removeLast();
       return result;
     });
   }
 
   /**
    * Return null so it is simple to remove the optional parameters completely
    * from interop methods to match JavaScript semantics for omitted arguments.
@@ skipping 3023 matching lines @@
   void visitTopLevelFieldInvoke(ast.Send node, FieldElement field,
       ast.NodeList arguments, CallStructure callStructure, _) {
     generateStaticFieldGet(node, field);
     generateCallInvoke(node, pop(),
         sourceInformationBuilder.buildCall(node, node.argumentsNode));
   }
 
   @override
   void visitTopLevelFunctionInvoke(ast.Send node, MethodElement function,
       ast.NodeList arguments, CallStructure callStructure, _) {
-    if (backend.isForeign(closedWorld.commonElements, function)) {
+    if (closedWorld.commonElements.isForeign(function)) {
       handleForeignSend(node, function);
     } else {
       generateStaticFunctionInvoke(node, function, callStructure);
     }
   }
 
   @override
   void visitTopLevelFunctionIncompatibleInvoke(
       ast.Send node,
       MethodElement function,
@@ skipping 2774 matching lines @@
       ResolvedAst functionResolvedAst, List<HInstruction> compiledArguments,
       {ResolutionInterfaceType instanceType}) {
     AstInliningState state = new AstInliningState(
         function,
         returnLocal,
         returnType,
         resolvedAst,
         stack,
         localsHandler,
         inTryStatement,
-        isCalledOnce(function),
+        isCalledOnce(functionResolvedAst.element),
         elementInferenceResults);
     resolvedAst = functionResolvedAst;
-    elementInferenceResults = _resultOf(function);
+    elementInferenceResults = _resultOf(functionResolvedAst.element);
     inliningStack.add(state);
 
     // Setting up the state of the (AST) builder is performed even when the
     // inlined function is in IR, because the irInliner uses the [returnElement]
     // of the AST builder.
     setupStateForInlining(function, compiledArguments,
         instanceType: instanceType);
   }
 
   void leaveInlinedMethod() {
@@ skipping 349 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }