Reduce use of getClosureInfoForMember and cleanup closure_test

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 89 matching lines @@
       popLocalFunction();
     } else {
       super.visitFunctionExpression(node);
     }
   }
 
   @override
   String computeNodeValue(ast.Node node, [AstElement element]) {
     if (element != null && element.isLocal) {
       if (element.isFunction) {
-        return computeEntityValue(element);
+        return computeObjectValue(element);
       } else {
         LocalElement local = element;
         return computeLocalValue(local);
       }
     }
     // TODO(johnniwinther,efortuna): Collect data for other nodes?
     return null;
   }
 
   @override
   String computeElementValue(AstElement element) {
     // TODO(johnniwinther,efortuna): Collect data for the member
     // (has thisLocal, has box, etc.).
-    return computeEntityValue(element);
+    return computeObjectValue(element);
   }
 }
 
 /// Kernel IR visitor for computing closure data.
 class ClosureIrChecker extends IrDataExtractor with ComputeValueMixin<ir.Node> {
   final MemberEntity member;
   final ClosureDataLookup<ir.Node> closureDataLookup;
   final KernelToLocalsMap _localsMap;
   final bool verbose;
 
@@ skipping 16 matching lines @@
 
   visitFunctionDeclaration(ir.FunctionDeclaration node) {
     pushLocalFunction(node);
     super.visitFunctionDeclaration(node);
     popLocalFunction();
   }
 
   @override
   String computeNodeValue(ir.Node node) {
     if (node is ir.VariableDeclaration) {
+      if (node.parent is ir.FunctionDeclaration) {
+        return computeObjectValue(node.parent);
+      }
       Local local = _localsMap.getLocalVariable(node);
       return computeLocalValue(local);
+    } else if (node is ir.FunctionExpression) {
+      return computeObjectValue(node);
     }
-    // TODO(johnniwinther,efortuna): Collect data for other nodes?
     return null;
   }
 
   @override
   String computeMemberValue(ir.Member node) {
-    // TODO(johnniwinther,efortuna): Collect data for the member
-    // (has thisLocal, has box, etc.).
-    return computeEntityValue(member);
+    return computeObjectValue(member);
   }
 }
 
 abstract class ComputeValueMixin<T> {
   bool get verbose;
   ClosureDataLookup<T> get closureDataLookup;
   Link<ScopeInfo> scopeInfoStack = const Link<ScopeInfo>();
   ScopeInfo get scopeInfo => scopeInfoStack.head;
   CapturedScope capturedScope;
   Link<ClosureRepresentationInfo> closureRepresentationInfoStack =
       const Link<ClosureRepresentationInfo>();
   ClosureRepresentationInfo get closureRepresentationInfo =>
-      closureRepresentationInfoStack.head;
+      closureRepresentationInfoStack.isNotEmpty
+          ? closureRepresentationInfoStack.head
+          : null;
 
   void pushMember(MemberEntity member) {
     scopeInfoStack =
         scopeInfoStack.prepend(closureDataLookup.getScopeInfo(member));
     capturedScope = closureDataLookup.getCapturedScope(member);
-    closureRepresentationInfoStack = closureRepresentationInfoStack
-        .prepend(closureDataLookup.getClosureInfoForMemberTesting(member));
     dump(member);
   }
 
   void popMember() {
     scopeInfoStack = scopeInfoStack.tail;
-    closureRepresentationInfoStack = closureRepresentationInfoStack.tail;
   }
 
   void pushLocalFunction(T node) {
     closureRepresentationInfoStack = closureRepresentationInfoStack
-        .prepend(closureDataLookup.getClosureInfoForTesting(node));
+        .prepend(closureDataLookup.getClosureInfo(node));
     dump(node);
   }
 
   void popLocalFunction() {
     closureRepresentationInfoStack = closureRepresentationInfoStack.tail;
   }
 
   void dump(Object object) {
     if (!verbose) return;
 
@@ skipping 44 matching lines @@
         features.add('field');
       }
       if (closureRepresentationInfo.isVariableBoxed(local)) {
         features.add('variable-boxed');
       }
     }
     // TODO(johnniwinther,efortuna): Add more info?
     return (features.toList()..sort()).join(',');
   }
 
-  String computeEntityValue(Entity entity) {
+  String computeObjectValue(Object object) {
     Map<String, String> features = <String, String>{};
 
     void addLocals(String name, forEach(f(Local local, _))) {
       List<String> names = <String>[];
       forEach((Local local, _) {
         if (local is BoxLocal) {
           names.add('box');
         } else {
           names.add(local.name);
         }
       });
       String value = names.isEmpty ? null : '[${(names..sort()).join(',')}]';
       if (features.containsKey(name)) {
         Expect.equals(
-            features[name], value, "Inconsistent values for $name on $entity.");
+            features[name], value, "Inconsistent values for $name on $object.");
       }
       features[name] = value;
     }
 
-    if (scopeInfo.thisLocal != null) {
-      features['hasThis'] = '';
-    }
-    addLocals('boxed', scopeInfo.forEachBoxedVariable);
+    if (object is MemberEntity) {
+      if (scopeInfo.thisLocal != null) {
+        features['hasThis'] = '';
+      }
+      addLocals('boxed', scopeInfo.forEachBoxedVariable);
 
-    if (entity is MemberEntity) {
       if (capturedScope.requiresContextBox) {
         features['requiresBox'] = '';
       }
       addLocals('boxed', capturedScope.forEachBoxedVariable);
     }
 
     if (closureRepresentationInfo != null) {
       addLocals('boxed', closureRepresentationInfo.forEachBoxedVariable);
       addLocals('captured', closureRepresentationInfo.forEachCapturedVariable);
       addLocals('free', closureRepresentationInfo.forEachFreeVariable);
@@ skipping 11 matching lines @@
         if (value != '') {
           sb.write('=');
           sb.write(value);
         }
         needsComma = true;
       }
     }
     return sb.toString();
   }
 }