Change inference element invariants

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 70 matching lines @@
       MemberElement analyzedElement,
       this.resolvedAst,
       this.outermostElement,
       InferrerEngine inferrer,
       this.compiler,
       this.locals)
       : this.analyzedElement = analyzedElement,
         this.inferrer = inferrer,
         this.types = inferrer.types,
         this.memberData = inferrer.dataOfMember(analyzedElement.memberContext) {
+    assert(analyzedElement.isDeclaration);
     assert(outermostElement != null);
+    assert(outermostElement.isDeclaration);
     if (locals != null) return;
     ast.Node node;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       node = resolvedAst.node;
     }
     FieldInitializationScope fieldScope =
         analyzedElement.isGenerativeConstructor
             ? new FieldInitializationScope(types)
             : null;
     locals =
         new LocalsHandler(inferrer, types, compiler.options, node, fieldScope);
   }
 
   ElementGraphBuilder(MemberElement element, ResolvedAst resolvedAst,
       Compiler compiler, InferrerEngine inferrer, [LocalsHandler handler])
-      : this.internal(element, resolvedAst, element.memberContext, inferrer,
-            compiler, handler);
+      : this.internal(element, resolvedAst, element.memberContext.declaration,
+            inferrer, compiler, handler);
 
   TreeElements get elements => resolvedAst.elements;
 
   bool accumulateIsChecks = false;
   bool conditionIsSimple = false;
   List<ast.Send> isChecks;
   int loopLevel = 0;
 
   bool get inLoop => loopLevel > 0;
   bool get isThisExposed {
@@ skipping 797 matching lines @@
     closureData.forEachCapturedVariable((variable, field) {
       locals.setCaptured(variable, field);
     });
     closureData.forEachBoxedVariable((variable, field) {
       locals.setCapturedAndBoxed(variable, field);
     });
     if (analyzedElement.isField) {
       return visit(initializer);
     }
 
-    MethodElement function = analyzedElement;
+    MethodElement function = analyzedElement.implementation;
     FunctionSignature signature = function.functionSignature;
     signature.forEachOptionalParameter((FormalElement _element) {
-      ParameterElement element = _element;
-      ast.Expression defaultValue = element.initializer;
+      ParameterElement parameter = _element;
+      ast.Expression defaultValue = parameter.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 (inferrer.hasAlreadyComputedTypeOfParameterDefault(parameter)) return;
 
-      FunctionElement declaration = element.functionDeclaration;
+      FunctionElement declaration = parameter.functionDeclaration.declaration;
       MethodElement declarationMethod = declaration is LocalFunctionElement
           ? declaration.callMethod
           : declaration;
       bool needNewContext = declarationMethod != analyzedElement;
       if (needNewContext) {
         assert(
             declarationMethod is ConstructorElement,
             failedAt(
-                element,
+                parameter,
                 "Unexpected function declaration "
                 "${declarationMethod}, expected ${analyzedElement}."));
         visitor = new ElementGraphBuilder(declarationMethod,
-            element.functionDeclaration.resolvedAst, compiler, inferrer);
+            parameter.functionDeclaration.resolvedAst, compiler, inferrer);
       }
       TypeInformation type =
           (defaultValue == null) ? types.nullType : visitor.visit(defaultValue);
-      inferrer.setDefaultTypeOfParameter(element, type);
+      inferrer.setDefaultTypeOfParameter(parameter, type);
     });
 
     if (closedWorld.nativeData.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;
@@ skipping 1338 matching lines @@
         analyzeSuperConstructorCall(constructor, arguments);
       }
     }
     // If we are looking at a new expression on a forwarding factory, we have to
     // forward the call to the effective target of the factory.
     // TODO(herhut): Remove the loop once effectiveTarget forwards to patches.
     while (target.isFactoryConstructor) {
       if (!target.isRedirectingFactory) break;
       target = target.effectiveTarget.implementation;
     }
-    if (compiler.backend.isForeign(closedWorld.commonElements, target)) {
+    if (closedWorld.commonElements.isForeign(target)) {
       return handleForeignSend(node, target);
     }
     Selector selector = elements.getSelector(node);
     CallStructure callStructure = selector.callStructure;
     TypeMask mask = memberData.typeOfSend(node);
     // In erroneous code the number of arguments in the selector might not
     // match the function element.
     // TODO(polux): return nonNullEmpty and check it doesn'TypeInformation break anything
     if (target.isMalformed ||
         !callStructure.signatureApplies(target.parameterStructure)) {
       return types.dynamicType;
     }
 
     TypeInformation returnType =
-        handleStaticSend(node, selector, mask, target, arguments);
+        handleStaticSend(node, selector, mask, target.declaration, arguments);
     if (Elements.isGrowableListConstructorCall(
         constructor, node, closedWorld.commonElements)) {
       return inferrer.concreteTypes.putIfAbsent(
           node,
           () => types.allocateList(types.growableListType, node,
               outermostElement, types.nonNullEmpty(), 0));
     } else if (Elements.isFixedListConstructorCall(
             constructor, node, closedWorld.commonElements) ||
         Elements.isFilledListConstructorCall(
             constructor, node, closedWorld.commonElements)) {
@@ skipping 52 matching lines @@
         inferrer.typeOfMember(element),
         outermostElement,
         arguments,
         sideEffects,
         inLoop);
   }
 
   /// Handle invocation of a top level or static [function].
   TypeInformation handleStaticFunctionInvoke(
       ast.Send node, MethodElement function) {
-    if (compiler.backend.isForeign(closedWorld.commonElements, function)) {
+    if (closedWorld.commonElements.isForeign(function)) {
       return handleForeignSend(node, function);
     }
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
     TypeMask mask = memberData.typeOfSend(node);
     return handleStaticSend(node, selector, mask, function, arguments);
   }
 
   /// Handle an static invocation of an unresolved target or with incompatible
   /// arguments to a resolved target.
@@ skipping 299 matching lines @@
       LocalFunctionElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     analyzeArguments(node.arguments);
     return types.dynamicType;
   }
 
   TypeInformation handleStaticSend(ast.Node node, Selector selector,
       TypeMask mask, MemberElement element, ArgumentsTypes arguments) {
+    assert(element.isDeclaration);
     assert(!element.isFactoryConstructor ||
         !(element as ConstructorElement).isRedirectingFactory);
     // Erroneous elements may be unresolved, for example missing getters.
     if (Elements.isUnresolved(element)) return types.dynamicType;
     // TODO(herhut): should we follow redirecting constructors here? We would
     // need to pay attention if the constructor is pointing to an erroneous
     // element.
     return inferrer.registerCalledMember(node, selector, mask, outermostElement,
         element, arguments, sideEffects, inLoop);
   }
@@ skipping 71 matching lines @@
     return handleDynamicSend(node, selector, mask, receiverType, arguments);
   }
 
   void recordReturnType(TypeInformation type) {
     returnType =
         inferrer.addReturnTypeForMethod(analyzedElement, returnType, type);
   }
 
   TypeInformation synthesizeForwardingCall(
       Spannable node, ConstructorElement element) {
-    element = element.implementation;
-    MethodElement function = analyzedElement;
+    assert(element.isDeclaration);
+    MethodElement function = analyzedElement.implementation;
     FunctionSignature signature = function.functionSignature;
     FunctionSignature calleeSignature = element.functionSignature;
     if (!calleeSignature.isCompatibleWith(signature)) {
       return types.nonNullEmpty();
     }
 
     List<TypeInformation> unnamed = <TypeInformation>[];
     signature.forEachRequiredParameter((FormalElement _element) {
       ParameterElement element = _element;
       assert(locals.use(element) != null);
@@ skipping 110 matching lines @@
     Selector moveNextSelector = Selectors.moveNext;
     TypeMask moveNextMask = memberData.typeOfIteratorMoveNext(node);
 
     TypeInformation iteratorType = handleDynamicSend(node, iteratorSelector,
         iteratorMask, expressionType, new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }