Use entities as keys rather than IR nodes

pkg/compiler/lib/src/ssa/kernel_ast_adapter.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:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart';
@@ skipping 16 matching lines @@
 import '../universe/selector.dart';
 import '../world.dart';
 import 'graph_builder.dart';
 import 'jump_handler.dart' show SwitchCaseJumpHandler;
 import 'locals_handler.dart';
 import 'types.dart';
 
 /// A helper class that abstracts all accesses of the AST from Kernel nodes.
 ///
 /// The goal is to remove all need for the AST from the Kernel SSA builder.
 class KernelAstAdapter extends KernelToElementMapMixin {

[Siggi Cherem (dart-lang), 2017/06/01 22:08:48]

one possiblity here is to subdivide this class in 2:
 - the implementation of kerneltoElementMap
 - anything that is only needed for ssa building (like the current element
stack)

[Johnni Winther, 2017/06/02 09:25:04]

They are tied together through TreeElements!

   final Kernel kernel;
   final JavaScriptBackend _backend;
   final Map<ir.Node, ast.Node> _nodeToAst;
   final Map<ir.Node, Element> _nodeToElement;
   final Map<ir.VariableDeclaration, SyntheticLocal> _syntheticLocals =
       <ir.VariableDeclaration, SyntheticLocal>{};
   // TODO(efortuna): In an ideal world the TreeNodes should be some common
   // interface we create for both ir.Statements and ir.SwitchCase (the
   // ContinueSwitchStatement's target is a SwitchCase) rather than general
   // TreeNode. Talking to Asger about this.
@@ skipping 71 matching lines @@
   }
 
   @override
   CommonElements get commonElements => _compiler.commonElements;
 
   @override
   ElementEnvironment get elementEnvironment => _compiler.elementEnvironment;
 
   /// Push the existing resolved AST on the stack and shift the current resolved
   /// AST to the AST that this kernel node points to.
-  void pushResolvedAst(ir.Node node) {
+  void enterInlinedMember(MemberElement member) {
     _resolvedAstStack.add(_resolvedAst);
-    _resolvedAst = (getElement(node) as AstElement).resolvedAst;
+    _resolvedAst = member.resolvedAst;
   }
 
   /// Pop the resolved AST stack to reset it to the previous resolved AST node.
-  void popResolvedAstStack() {
+  void leaveInlinedMember(MemberElement member) {
     assert(_resolvedAstStack.isNotEmpty);
+    assert(_resolvedAst.element == member);
     _resolvedAst = _resolvedAstStack.removeLast();
   }
 
   void assertAtResolvedAstFor(ir.Node node) {
     assert(invariant(getElement(node),
         _resolvedAst.element == getElement(node).declaration));
   }
 
   Compiler get _compiler => _backend.compiler;
   TreeElements get elements => _resolvedAst.elements;
@@ skipping 72 matching lines @@
       return _syntheticLocals.putIfAbsent(
           variable, () => new SyntheticLocal("x", null, null));
     }
     return getElement(variable) as LocalElement;
   }
 
   FunctionSignature getFunctionSignature(ir.FunctionNode function) {
     return getElement(function).asFunctionElement().functionSignature;
   }
 
-  ir.Field getFieldFromElement(FieldElement field) {
-    return kernel.fields[field];
-  }
-
-  bool isFixedLength(TypeMask mask, ClosedWorld closedWorld) {
-    if (mask.isContainer && (mask as ContainerTypeMask).length != null) {
-      // A container on which we have inferred the length.
-      return true;
-    }
-    // TODO(sra): Recognize any combination of fixed length indexables.
-    if (mask.containsOnly(closedWorld.commonElements.jsFixedArrayClass) ||
-        mask.containsOnly(
-            closedWorld.commonElements.jsUnmodifiableArrayClass) ||
-        mask.containsOnlyString(closedWorld) ||
-        closedWorld.commonMasks.isTypedArray(mask)) {
-      return true;
-    }
-    return false;
-  }
-
   ConstantValue getConstantFor(ir.Node node) {
     // Some `null`s are not mapped when they correspond to errors, e.g. missing
     // `const` initializers.
     if (node is ir.NullLiteral) return new NullConstantValue();
 
     ConstantValue constantValue =
         _backend.constants.getConstantValueForNode(getNode(node), elements);
     assert(invariant(getNode(node), constantValue != null,
         message: 'No constant computed for $node'));
     return constantValue;
@@ skipping 74 matching lines @@
         }
       }
     }
     return null;
   }
 
   ResolutionDartType getDartType(ir.DartType type) {
     return _typeConverter.convert(type);
   }
 
-  ResolutionDartType getDartTypeIfValid(ir.DartType type) {
-    if (type is ir.InvalidType) return null;
-    return _typeConverter.convert(type);
-  }
-
   List<ResolutionDartType> getDartTypes(List<ir.DartType> types) {
     return types.map(getDartType).toList();
   }
 
   ResolutionInterfaceType getDartTypeOfListLiteral(ir.ListLiteral list) {
     ast.Node node = getNodeOrNull(list);
     if (node != null) return elements.getType(node);
     assertNodeIsSynthetic(list);
     return _compiler.commonElements.listType(getDartType(list.typeArgument));
   }
@@ skipping 323 matching lines @@
   bool isJsIndexableIterator(
       ir.ForInStatement forInStatement, ClosedWorld closedWorld) {
     TypeMask mask = typeOfIterator(forInStatement);
     return mask != null &&
         mask.satisfies(
             closedWorld.commonElements.jsIndexableClass, closedWorld) &&
         // String is indexable but not iterable.
         !mask.satisfies(closedWorld.commonElements.jsStringClass, closedWorld);
   }
 
+  bool isFixedLength(TypeMask mask, ClosedWorld closedWorld) {
+    if (mask.isContainer && (mask as ContainerTypeMask).length != null) {
+      // A container on which we have inferred the length.
+      return true;
+    }
+    // TODO(sra): Recognize any combination of fixed length indexables.
+    if (mask.containsOnly(closedWorld.commonElements.jsFixedArrayClass) ||
+        mask.containsOnly(
+            closedWorld.commonElements.jsUnmodifiableArrayClass) ||
+        mask.containsOnlyString(closedWorld) ||
+        closedWorld.commonMasks.isTypedArray(mask)) {
+      return true;
+    }
+    return false;
+  }
+
   TypeMask inferredIndexType(ir.ForInStatement forInStatement) {
     return TypeMaskFactory.inferredTypeForSelector(new Selector.index(),
         typeOfIterator(forInStatement), _globalInferenceResults);
   }
 
   TypeMask getInferredTypeOf(MemberEntity member) {
     return TypeMaskFactory.inferredTypeForMember(
         member, _globalInferenceResults);
   }
 
   TypeMask selectorTypeOf(Selector selector, TypeMask mask) {
     return TypeMaskFactory.inferredTypeForSelector(
         selector, mask, _globalInferenceResults);
   }
 
   TypeMask typeFromNativeBehavior(
       native.NativeBehavior nativeBehavior, ClosedWorld closedWorld) {
     return TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
   }
 }