Use entities as keys rather than IR nodes

pkg/compiler/lib/src/ssa/builder_kernel.dart

 // Copyright (c) 2016, 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 '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry;
 import '../common/names.dart';
@@ skipping 100 matching lines @@
       this.functionNode,
       {bool targetIsConstructorBody: false})
       : this._targetIsConstructorBody = targetIsConstructorBody {
     this.loopHandler = new KernelLoopHandler(this);
     typeBuilder = new TypeBuilder(this);
     graph.element = targetElement;
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     this.localsHandler = new LocalsHandler(this, targetElement, targetElement,
         contextClass, null, nativeData, interceptorData);
-    _targetStack.add(target);
+    _targetStack.add(targetElement);
   }
 
   @deprecated // Use [_elementMap] instead.
   KernelAstAdapter get astAdapter => _elementMap;
 
   CommonElements get _commonElements => _elementMap.commonElements;
 
   HGraph build() {
     // TODO(het): no reason to do this here...
     HInstruction.idCounter = 0;
@@ skipping 20 matching lines @@
     assert(graph.isValid());
     return graph;
   }
 
   void buildField(ir.Field field) {
     openFunction();
     if (field.initializer != null) {
       field.initializer.accept(this);
       HInstruction fieldValue = pop();
       HInstruction checkInstruction = typeBuilder.potentiallyCheckOrTrustType(
-          fieldValue, astAdapter.getDartTypeIfValid(field.type));
+          fieldValue, _getDartTypeIfValid(field.type));
       stack.add(checkInstruction);
     } else {
       stack.add(graph.addConstantNull(closedWorld));
     }
     HInstruction value = pop();
     closeAndGotoExit(new HReturn(value, null));
     closeFunction();
   }
 
+  DartType _getDartTypeIfValid(ir.DartType type) {
+    if (type is ir.InvalidType) return null;
+    return _elementMap.getDartType(type);
+  }
+
   /// Pops the most recent instruction from the stack and 'boolifies' it.
   ///
   /// Boolification is checking if the value is '=== true'.
   @override
   HInstruction popBoolified() {
     HInstruction value = pop();
     if (typeBuilder.checkOrTrustTypes) {
       ResolutionInterfaceType type = commonElements.boolType;
       return typeBuilder.potentiallyCheckOrTrustType(value, type,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
@@ skipping 62 matching lines @@
     ir.Class constructedClass = constructor.enclosingClass;
 
     openFunction();
     _addClassTypeVariablesIfNeeded(constructor);
 
     // TODO(sra): Type parameter constraint checks.
 
     // TODO(sra): Checked mode parameter checks.
 
     // Collect field values for the current class.
-    Map<ir.Field, HInstruction> fieldValues =
+    Map<FieldEntity, HInstruction> fieldValues =
         _collectFieldValues(constructedClass);
     List<ir.Constructor> constructorChain = <ir.Constructor>[];
     _buildInitializers(constructor, constructorChain, fieldValues);
 
     final constructorArguments = <HInstruction>[];
     // Doing this instead of fieldValues.forEach because we haven't defined the
     // order of the arguments here. We can define that with JElements.
     ClassElement cls = _elementMap.getClass(constructedClass);
     cls.forEachInstanceField(
         (ClassElement enclosingClass, FieldElement member) {
-      var value = fieldValues[astAdapter.getFieldFromElement(member)];
-      assert(value != null,
-          'No value for field ${member} aka ${astAdapter.getFieldFromElement(member)}');
+      var value = fieldValues[member];
+      assert(value != null, 'No value for field ${member}');
       constructorArguments.add(value);
     }, includeSuperAndInjectedMembers: true);
 
     // Create the runtime type information, if needed.
     bool hasRtiInput = backend.rtiNeed
         .classNeedsRtiField(_elementMap.getClass(constructedClass));
     if (hasRtiInput) {
       // Read the values of the type arguments and create a HTypeInfoExpression
       // to set on the newly create object.
       List<HInstruction> typeArguments = <HInstruction>[];
@@ skipping 30 matching lines @@
 
     for (ir.Constructor body in constructorChain.reversed) {
       if (_isEmptyStatement(body.function.body)) continue;
 
       List<HInstruction> bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
 
       // Pass uncaptured arguments first, captured arguments in a box, then type
       // arguments.
 
-      ConstructorElement constructorElement = astAdapter.getElement(body);
+      ConstructorElement constructorElement = astAdapter.getConstructor(body);
       ClosureClassMap parameterClosureData =
           closureToClassMapper.getMemberMap(constructorElement);
 
       var functionSignature = astAdapter.getFunctionSignature(body.function);
       // Provide the parameters to the generative constructor body.
       functionSignature.orderedForEachParameter((ParameterElement parameter) {
         // If [parameter] is boxed, it will be a field in the box passed as the
         // last parameter. So no need to directly pass it.
         if (!localsHandler.isBoxed(parameter)) {
           bodyCallInputs.add(localsHandler.readLocal(parameter));
@@ skipping 35 matching lines @@
   void _invokeConstructorBody(
       ir.Constructor constructor, List<HInstruction> inputs) {
     // TODO(sra): Inline the constructor body.
     MemberEntity constructorBody =
         astAdapter.getConstructorBodyEntity(constructor);
     HInvokeConstructorBody invoke = new HInvokeConstructorBody(
         constructorBody, inputs, commonMasks.nonNullType);
     add(invoke);
   }
 
-  withCurrentIrNode(ir.Node node, f()) {
-    reporter.withCurrentElement(astAdapter.getElement(node), f);
-  }
-
   /// Sets context for generating code that is the result of inlining
   /// [inlinedTarget].
-  inlinedFrom(ir.TreeNode inlinedTarget, f()) {
-    withCurrentIrNode(inlinedTarget, () {
+  inlinedFrom(MemberEntity inlinedTarget, f()) {
+    reporter.withCurrentElement(inlinedTarget, () {
       SourceInformationBuilder oldSourceInformationBuilder =
           sourceInformationBuilder;
       // TODO(sra): Update sourceInformationBuilder to Kernel.
       // sourceInformationBuilder =
       //   sourceInformationBuilder.forContext(resolvedAst);
+
+      _elementMap.enterInlinedMember(inlinedTarget);
       _targetStack.add(inlinedTarget);
       var result = f();
       sourceInformationBuilder = oldSourceInformationBuilder;
       _targetStack.removeLast();
+      _elementMap.leaveInlinedMember(inlinedTarget);
       return result;
     });
   }
 
   /// Maps the instance fields of a class to their SSA values.
-  Map<ir.Field, HInstruction> _collectFieldValues(ir.Class clazz) {
-    final fieldValues = <ir.Field, HInstruction>{};
+  Map<FieldEntity, HInstruction> _collectFieldValues(ir.Class clazz) {
+    Map<FieldEntity, HInstruction> fieldValues = <FieldEntity, HInstruction>{};
 
-    for (var field in clazz.fields) {
-      if (field.isInstanceMember) {
-        if (field.initializer == null) {
+    for (ir.Field node in clazz.fields) {
+      if (node.isInstanceMember) {
+        FieldEntity field = _elementMap.getField(node);
+        if (node.initializer == null) {
           fieldValues[field] = graph.addConstantNull(closedWorld);
         } else {
           // Gotta update the resolvedAst when we're looking at field values
           // outside the constructor.
-          astAdapter.pushResolvedAst(field);
           inlinedFrom(field, () {
-            field.initializer.accept(this);
+            node.initializer.accept(this);
             fieldValues[field] = pop();
           });
-          astAdapter.popResolvedAstStack();
         }
       }
     }
 
     return fieldValues;
   }
 
   /// Collects field initializers all the way up the inheritance chain.
   void _buildInitializers(
       ir.Constructor constructor,
       List<ir.Constructor> constructorChain,
-      Map<ir.Field, HInstruction> fieldValues) {
+      Map<FieldEntity, HInstruction> fieldValues) {
     astAdapter.assertAtResolvedAstFor(constructor);
     constructorChain.add(constructor);
 
     var foundSuperOrRedirectCall = false;
     for (var initializer in constructor.initializers) {
       if (initializer is ir.FieldInitializer) {
         initializer.value.accept(this);
-        fieldValues[initializer.field] = pop();
+        fieldValues[_elementMap.getField(initializer.field)] = pop();
       } else if (initializer is ir.SuperInitializer) {
         assert(!foundSuperOrRedirectCall);
         foundSuperOrRedirectCall = true;
         _inlineSuperInitializer(
             initializer, constructorChain, fieldValues, constructor);
       } else if (initializer is ir.RedirectingInitializer) {
         assert(!foundSuperOrRedirectCall);
         foundSuperOrRedirectCall = true;
         _inlineRedirectingInitializer(
             initializer, constructorChain, fieldValues, constructor);
@@ skipping 60 matching lines @@
     var parameters = cls.typeParameters;
     var arguments = supertype.typeArguments;
     assert(arguments.length == parameters.length);
 
     for (int i = 0; i < parameters.length; i++) {
       ir.DartType argument = arguments[i];
       ir.TypeParameter parameter = parameters[i];
 
       localsHandler.updateLocal(
           localsHandler.getTypeVariableAsLocal(
-              astAdapter.getDartType(new ir.TypeParameterType(parameter))),
+              _elementMap.getDartType(new ir.TypeParameterType(parameter))),
           typeBuilder.analyzeTypeArgument(
-              astAdapter.getDartType(argument), sourceElement));
+              _elementMap.getDartType(argument), sourceElement));
     }
   }
 
   /// Inlines the given redirecting [constructor]'s initializers by collecting
   /// its field values and building its constructor initializers. We visit super
   /// constructors all the way up to the [Object] constructor.
   void _inlineRedirectingInitializer(
       ir.RedirectingInitializer initializer,
       List<ir.Constructor> constructorChain,
-      Map<ir.Field, HInstruction> fieldValues,
+      Map<FieldEntity, HInstruction> fieldValues,
       ir.Constructor caller) {
     var superOrRedirectConstructor = initializer.target;
     var arguments = _normalizeAndBuildArguments(
         superOrRedirectConstructor.function, initializer.arguments);
 
     // Redirecting initializer already has [localsHandler] bindings for type
     // parameters from the redirecting constructor.
 
     // For redirecting constructors, the fields will be initialized later by the
     // effective target, so we don't do it here.
 
     _inlineSuperOrRedirectCommon(initializer, superOrRedirectConstructor,
         arguments, constructorChain, fieldValues, caller);
   }
 
   /// Inlines the given super [constructor]'s initializers by collecting its
   /// field values and building its constructor initializers. We visit super
   /// constructors all the way up to the [Object] constructor.
   void _inlineSuperInitializer(
       ir.SuperInitializer initializer,
       List<ir.Constructor> constructorChain,
-      Map<ir.Field, HInstruction> fieldValues,
+      Map<FieldEntity, HInstruction> fieldValues,
       ir.Constructor caller) {
     var target = initializer.target;
     var arguments =
         _normalizeAndBuildArguments(target.function, initializer.arguments);
 
     ir.Class callerClass = caller.enclosingClass;
     _bindSupertypeTypeParameters(callerClass.supertype);
     if (callerClass.mixedInType != null) {
       _bindSupertypeTypeParameters(callerClass.mixedInType);
     }
 
     ir.Class cls = target.enclosingClass;
 
-    inlinedFrom(target, () {
+    inlinedFrom(_elementMap.getConstructor(target), () {
       fieldValues.addAll(_collectFieldValues(cls));
     });
 
     _inlineSuperOrRedirectCommon(
         initializer, target, arguments, constructorChain, fieldValues, caller);
   }
 
   void _inlineSuperOrRedirectCommon(
       ir.Initializer initializer,
       ir.Constructor constructor,
       List<HInstruction> arguments,
       List<ir.Constructor> constructorChain,
-      Map<ir.Field, HInstruction> fieldValues,
+      Map<FieldEntity, HInstruction> fieldValues,
       ir.Constructor caller) {
     var signature = astAdapter.getFunctionSignature(constructor.function);
     var index = 0;
     signature.orderedForEachParameter((ParameterElement parameter) {
       HInstruction argument = arguments[index++];
       // Because we are inlining the initializer, we must update
       // what was given as parameter. This will be used in case
       // there is a parameter check expression in the initializer.
       parameters[parameter] = argument;
       localsHandler.updateLocal(parameter, argument);
     });
 
     // Set the locals handler state as if we were inlining the constructor.
-    astAdapter.pushResolvedAst(constructor);
-    ConstructorElement astElement = astAdapter.getElement(constructor);
+    ConstructorElement astElement = _elementMap.getConstructor(constructor);
     ResolvedAst resolvedAst = astElement.resolvedAst;
     ClosureClassMap oldClosureData = localsHandler.closureData;
     ClosureClassMap newClosureData =
         closureToClassMapper.getMemberMap(astElement);
     localsHandler.closureData = newClosureData;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       localsHandler.enterScope(resolvedAst.node,
           forGenerativeConstructorBody: astElement.isGenerativeConstructorBody);
     }
-    inlinedFrom(constructor, () {
+    inlinedFrom(astElement, () {
       _buildInitializers(constructor, constructorChain, fieldValues);
     });
     localsHandler.closureData = oldClosureData;
-    astAdapter.popResolvedAstStack();
   }
 
   /// Builds generative constructor body.
   void buildConstructorBody(ir.Constructor constructor) {
     openFunction();
     _addClassTypeVariablesIfNeeded(constructor);
     constructor.function.body.accept(this);
     closeFunction();
   }
 
   /// Builds a SSA graph for FunctionNodes, found in FunctionExpressions and
   /// Procedures.
   void buildFunctionNode(ir.FunctionNode functionNode) {
     openFunction();
     ir.TreeNode parent = functionNode.parent;
     if (parent is ir.Procedure && parent.kind == ir.ProcedureKind.Factory) {
       _addClassTypeVariablesIfNeeded(functionNode.parent);
     }
 
     // If [functionNode] is `operator==` we explicitly add a null check at the
     // beginning of the method. This is to avoid having call sites do the null
     // check.
     if (parent is ir.Procedure &&
         parent.kind == ir.ProcedureKind.Operator &&
         parent.name.name == '==') {
-      if (!backend
-          .operatorEqHandlesNullArgument(_elementMap.getMethod(parent))) {
+      MethodElement method = _elementMap.getMethod(parent);
+      if (!backend.operatorEqHandlesNullArgument(method)) {
         handleIf(
           visitCondition: () {
             HParameterValue parameter = parameters.values.first;
             push(new HIdentity(parameter, graph.addConstantNull(closedWorld),
                 null, commonMasks.boolType));
           },
           visitThen: () {
             closeAndGotoExit(new HReturn(
                 graph.addConstantBool(false, closedWorld),
-                sourceInformationBuilder
-                    .buildImplicitReturn(astAdapter.getElement(parent))));
+                sourceInformationBuilder.buildImplicitReturn(method)));
           },
           visitElse: null,
           // TODO(27394): Add sourceInformation via
           // `sourceInformationBuilder.buildIf(?)`.
         );
       }
     }
     functionNode.body.accept(this);
     closeFunction();
   }
@@ skipping 55 matching lines @@
     push(trap);
   }
 
   /// Returns the current source element. This is used by the type builder.
   ///
   /// The returned element is a declaration element.
   // TODO(efortuna): Update this when we implement inlining.
   // TODO(sra): Re-implement type builder using Kernel types and the
   // `target` for context.
   @override
-  Element get sourceElement => _sourceElementForTarget(_targetStack.last);
+  MemberElement get sourceElement => _targetStack.last;
 
-  List<ir.Node> _targetStack = <ir.Node>[];
-
-  Element _sourceElementForTarget(ir.Node target) {
-    // For closure-converted (i.e. local functions) the source element is the
-    // 'call' method of the class that represents the closure.
-    Element callMethodOfClosureClass() {
-      LocalFunctionElement element = astAdapter.getElement(target);
-      ClosureClassMap classMap =
-          closureToClassMapper.getLocalFunctionMap(element);
-      return classMap.callElement;
-    }
-
-    if (target is ir.FunctionExpression) {
-      return callMethodOfClosureClass();
-    }
-    if (target is ir.FunctionDeclaration) {
-      return callMethodOfClosureClass();
-    }
-    Element element = astAdapter.getElement(target);
-    return element;
-  }
+  List<MemberEntity> _targetStack = <MemberEntity>[];
 
   @override
   void visitCheckLibraryIsLoaded(ir.CheckLibraryIsLoaded checkLoad) {
     HInstruction prefixConstant =
         graph.addConstantString(checkLoad.import.name, closedWorld);
     var prefixElement = astAdapter.getElement(checkLoad.import);
     HInstruction uriConstant = graph.addConstantString(
         prefixElement.deferredImport.uri.toString(), closedWorld);
     _pushStaticInvocation(
         _commonElements.checkDeferredIsLoaded,
@@ skipping 193 matching lines @@
           _commonElements.checkConcurrentModificationError,
           [pop(), array],
           _typeInferenceMap.getReturnTypeOf(
               _commonElements.checkConcurrentModificationError));
       pop();
     }
 
     void buildInitializer() {
       forInStatement.iterable.accept(this);
       array = pop();
-      isFixed = astAdapter.isFixedLength(array.instructionType, closedWorld);
+      isFixed =
+          _typeInferenceMap.isFixedLength(array.instructionType, closedWorld);
       localsHandler.updateLocal(
           indexVariable, graph.addConstantInt(0, closedWorld));
       originalLength = buildGetLength();
     }
 
     HInstruction buildCondition() {
       HInstruction index = localsHandler.readLocal(indexVariable);
       HInstruction length = buildGetLength();
       HInstruction compare =
           new HLess(index, length, null, commonMasks.boolType);
@@ skipping 1078 matching lines @@
     if (staticTarget is ir.Procedure) {
       FunctionEntity setter = _elementMap.getMember(staticTarget);
       // Invoke the setter
       _pushStaticInvocation(setter, <HInstruction>[value],
           _typeInferenceMap.getReturnTypeOf(setter));
       pop();
     } else {
       add(new HStaticStore(
           _elementMap.getMember(staticTarget),
           typeBuilder.potentiallyCheckOrTrustType(
-              value, astAdapter.getDartTypeIfValid(staticTarget.setterType))));
+              value, _getDartTypeIfValid(staticTarget.setterType))));
     }
     stack.add(value);
   }
 
   @override
   void visitPropertyGet(ir.PropertyGet propertyGet) {
     propertyGet.receiver.accept(this);
     HInstruction receiver = pop();
 
     _pushDynamicInvocation(propertyGet,
@@ skipping 66 matching lines @@
       HInstruction initialValue = pop();
 
       _visitLocalSetter(declaration, initialValue);
 
       // Ignore value
       pop();
     }
   }
 
   void _visitLocalSetter(ir.VariableDeclaration variable, HInstruction value) {
-    LocalElement local = astAdapter.getElement(variable);
+    LocalElement local = astAdapter.getLocal(variable);
 
     // Give the value a name if it doesn't have one already.
     if (value.sourceElement == null) {
       value.sourceElement = local;
     }
 
     stack.add(value);
     localsHandler.updateLocal(
         local,
         typeBuilder.potentiallyCheckOrTrustType(
-            value, astAdapter.getDartTypeIfValid(variable.type)));
+            value, _getDartTypeIfValid(variable.type)));
   }
 
   @override
   void visitLet(ir.Let let) {
     ir.VariableDeclaration variable = let.variable;
     variable.initializer.accept(this);
     HInstruction initializedValue = pop();
     // TODO(sra): Apply inferred type information.
     letBindings[variable] = initializedValue;
     let.body.accept(this);
@@ skipping 613 matching lines @@
     } else if (selector.isSetter) {
       push(new HInvokeDynamicSetter(selector, mask, null, inputs, type));
     } else {
       push(new HInvokeDynamicMethod(
           selector, mask, inputs, type, isIntercepted));
     }
   }
 
   @override
   visitFunctionNode(ir.FunctionNode node) {
-    LocalFunctionElement methodElement = astAdapter.getElement(node);
+    Local methodElement = _elementMap.getLocalFunction(node);
     ClosureClassMap nestedClosureData =
         closureToClassMapper.getLocalFunctionMap(methodElement);
     assert(nestedClosureData != null);
     assert(nestedClosureData.closureClassElement != null);
     ClosureClassElement closureClassElement =
         nestedClosureData.closureClassElement;
     MethodElement callElement = nestedClosureData.callElement;
 
     List<HInstruction> capturedVariables = <HInstruction>[];
     closureClassElement.closureFields.forEach((ClosureFieldElement field) {
       Local capturedLocal =
           nestedClosureData.getLocalVariableForClosureField(field);
       assert(capturedLocal != null);
       capturedVariables.add(localsHandler.readLocal(capturedLocal));
     });
 
     TypeMask type = new TypeMask.nonNullExact(closureClassElement, closedWorld);
     // TODO(efortuna): Add source information here.
     push(new HCreate(closureClassElement, capturedVariables, type,
         callMethod: callElement, localFunction: methodElement));
   }
 
   @override
   visitFunctionDeclaration(ir.FunctionDeclaration declaration) {
     assert(isReachable);
     declaration.function.accept(this);
-    LocalFunctionElement localFunction =
-        astAdapter.getElement(declaration.function);
+    Local localFunction = _elementMap.getLocalFunction(declaration.function);
     localsHandler.updateLocal(localFunction, pop());
   }
 
   @override
   void visitFunctionExpression(ir.FunctionExpression funcExpression) {
     funcExpression.function.accept(this);
   }
 
   // TODO(het): Decide when to inline
   @override
@@ skipping 531 matching lines @@
       // `guard` is often `dynamic`, which generates `true`.
       kernelBuilder.pushIsTest(
           catchBlock.exception, catchBlock.guard, unwrappedException);
     }
 
     void visitThen() {
       ir.Catch catchBlock = tryCatch.catches[catchesIndex];
       catchesIndex++;
       if (catchBlock.exception != null) {
         LocalVariableElement exceptionVariable =
-            kernelBuilder.astAdapter.getElement(catchBlock.exception);
+            kernelBuilder.astAdapter.getLocal(catchBlock.exception);
         kernelBuilder.localsHandler
             .updateLocal(exceptionVariable, unwrappedException);
       }
       if (catchBlock.stackTrace != null) {
         kernelBuilder._pushStaticInvocation(
             kernelBuilder._commonElements.traceFromException,
             [exception],
             kernelBuilder._typeInferenceMap.getReturnTypeOf(
                 kernelBuilder._commonElements.traceFromException));
         HInstruction traceInstruction = kernelBuilder.pop();
         LocalVariableElement traceVariable =
-            kernelBuilder.astAdapter.getElement(catchBlock.stackTrace);
+            kernelBuilder.astAdapter.getLocal(catchBlock.stackTrace);
         kernelBuilder.localsHandler
             .updateLocal(traceVariable, traceInstruction);
       }
       catchBlock.body.accept(kernelBuilder);
     }
 
     void visitElse() {
       if (catchesIndex >= tryCatch.catches.length) {
         kernelBuilder.closeAndGotoExit(new HThrow(
             exception, exception.sourceInformation,
@@ skipping 39 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }