Split getClosureRepresentationInfo into MemberEntity and (ir/ast) nodes

tests/compiler/dart2js/closure/closure_test.dart

 // Copyright (c) 2017, 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:io' hide Link;
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/closure.dart';
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/diagnostics/diagnostic_listener.dart';
@@ skipping 72 matching lines @@
 /// Ast visitor for computing closure data.
 class ClosureAstComputer extends AbstractResolvedAstComputer
     with ComputeValueMixin {
   final ClosureDataLookup<ast.Node> closureDataLookup;
   final bool verbose;
 
   ClosureAstComputer(DiagnosticReporter reporter, Map<Id, ActualData> actualMap,
       ResolvedAst resolvedAst, this.closureDataLookup,
       {this.verbose: false})
       : super(reporter, actualMap, resolvedAst) {
-    push(resolvedAst.element);
+    pushMember(resolvedAst.element as MemberElement);
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     Entity localFunction = resolvedAst.elements.getFunctionDefinition(node);
     if (localFunction is LocalFunctionElement) {
-      push(localFunction);
+      pushLocalFunction(node);
       super.visitFunctionExpression(node);
-      pop();
+      popLocalFunction();
     } else {
       super.visitFunctionExpression(node);
     }
   }
 
   @override
   String computeNodeValue(ast.Node node, [AstElement element]) {
     if (element != null && element.isLocal) {
       if (element.isFunction) {
         return computeEntityValue(element);
@@ skipping 10 matching lines @@
   String computeElementValue(AstElement element) {
     // TODO(johnniwinther,efortuna): Collect data for the member
     // (has thisLocal, has box, etc.).
     return computeEntityValue(element);
   }
 }
 
 /// Kernel IR visitor for computing closure data.
 class ClosureIrChecker extends AbstractIrComputer
     with ComputeValueMixin<ir.Node> {
+  final MemberEntity member;
   final ClosureDataLookup<ir.Node> closureDataLookup;
   final KernelToLocalsMap _localsMap;
   final bool verbose;
 
   ClosureIrChecker(
       Map<Id, ActualData> actualMap,
       KernelToElementMapForBuilding elementMap,
-      MemberEntity member,
+      this.member,
       this._localsMap,
       this.closureDataLookup,
       {this.verbose: false})
       : super(actualMap) {
-    push(member);
+    pushMember(member);
   }
 
   visitFunctionExpression(ir.FunctionExpression node) {
-    Local localFunction = _localsMap.getLocalFunction(node);
-    push(localFunction);
+    pushLocalFunction(node);
     super.visitFunctionExpression(node);
-    pop();
+    popLocalFunction();
   }
 
   visitFunctionDeclaration(ir.FunctionDeclaration node) {
-    Local localFunction = _localsMap.getLocalFunction(node);
-    push(localFunction);
+    pushLocalFunction(node);
     super.visitFunctionDeclaration(node);
-    pop();
+    popLocalFunction();
   }
 
   @override
   String computeNodeValue(ir.Node node) {
     if (node is ir.VariableDeclaration) {
       Local local = _localsMap.getLocalVariable(node);
       return computeLocalValue(local);
     }
     // TODO(johnniwinther,efortuna): Collect data for other nodes?
     return null;
   }
 
   @override
-  String computeMemberValue(ir.Member member) {
+  String computeMemberValue(ir.Member node) {
     // TODO(johnniwinther,efortuna): Collect data for the member
     // (has thisLocal, has box, etc.).
-    return computeEntityValue(entity);
+    return computeEntityValue(member);
   }
 }
 
 abstract class ComputeValueMixin<T> {
   bool get verbose;
   ClosureDataLookup<T> get closureDataLookup;
-  Entity get entity => entityStack.head;
-  Link<Entity> entityStack = const Link<Entity>();
   Link<ScopeInfo> scopeInfoStack = const Link<ScopeInfo>();
   ScopeInfo get scopeInfo => scopeInfoStack.head;
   CapturedScope capturedScope;
   Link<ClosureRepresentationInfo> closureRepresentationInfoStack =
       const Link<ClosureRepresentationInfo>();
   ClosureRepresentationInfo get closureRepresentationInfo =>
       closureRepresentationInfoStack.head;
 
-  void push(Entity entity) {
-    entityStack = entityStack.prepend(entity);
+  void pushMember(MemberEntity member) {
     scopeInfoStack =
-        scopeInfoStack.prepend(closureDataLookup.getScopeInfo(entity));
-    if (entity is MemberEntity) {
-      capturedScope = closureDataLookup.getCapturedScope(entity);
-    }
-    closureRepresentationInfoStack = closureRepresentationInfoStack.prepend(
-        closureDataLookup.getClosureRepresentationInfoForTesting(entity));
-    dump(entity);
+        scopeInfoStack.prepend(closureDataLookup.getScopeInfo(member));
+    capturedScope = closureDataLookup.getCapturedScope(member);
+    closureRepresentationInfoStack = closureRepresentationInfoStack
+        .prepend(closureDataLookup.getClosureInfoForMemberTesting(member));
+    dump(member);
   }
 
-  void pop() {
-    entityStack = entityStack.tail;
+  void popMember() {
     scopeInfoStack = scopeInfoStack.tail;
     closureRepresentationInfoStack = closureRepresentationInfoStack.tail;
   }
 
-  void dump(Entity entity) {
+  void pushLocalFunction(T node) {
+    closureRepresentationInfoStack = closureRepresentationInfoStack
+        .prepend(closureDataLookup.getClosureInfoForTesting(node));
+    dump(node);
+  }
+
+  void popLocalFunction() {
+    closureRepresentationInfoStack = closureRepresentationInfoStack.tail;
+  }
+
+  void dump(Object object) {
     if (!verbose) return;
 
-    print('entity: $entity');
-    print(' scopeInfo (${scopeInfo.runtimeType})');
-    scopeInfo.forEachBoxedVariable((a, b) => print('  boxed1: $a->$b'));
-    print(' capturedScope (${capturedScope.runtimeType})');
-    capturedScope.forEachBoxedVariable((a, b) => print('  boxed2: $a->$b'));
+    print('object: $object');
+    if (object is MemberEntity) {
+      print(' scopeInfo (${scopeInfo.runtimeType})');
+      scopeInfo.forEachBoxedVariable((a, b) => print('  boxed1: $a->$b'));
+      print(' capturedScope (${capturedScope.runtimeType})');
+      capturedScope.forEachBoxedVariable((a, b) => print('  boxed2: $a->$b'));
+    }
     print(
         ' closureRepresentationInfo (${closureRepresentationInfo.runtimeType})');
     closureRepresentationInfo
         ?.forEachCapturedVariable((a, b) => print('  captured: $a->$b'));
     closureRepresentationInfo
         ?.forEachFreeVariable((a, b) => print('  free3: $a->$b'));
     closureRepresentationInfo
         ?.forEachBoxedVariable((a, b) => print('  boxed3: $a->$b'));
   }
 
@@ skipping 84 matching lines @@
         if (value != '') {
           sb.write('=');
           sb.write(value);
         }
         needsComma = true;
       }
     }
     return sb.toString();
   }
 }