Lookup getClosureScope by member instead of node

pkg/compiler/lib/src/closure.dart

 // Copyright (c) 2012, 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 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show ParsingContext, Resolution;
 import 'common/tasks.dart' show CompilerTask, Measurer;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'constants/expressions.dart';
@@ skipping 37 matching lines @@
   /// This returns the same information as ScopeInfo, but can be called in
   /// situations when you are sure you are dealing with a closure specifically.
   ClosureRepresentationInfo getClosureRepresentationInfo(
       covariant Entity member);
 
   /// Look up information about a loop, in case any variables it declares need
   /// to be boxed/snapshotted.
   LoopClosureScope getLoopClosureScope(T loopNode);
 
   /// Accessor to the information about closures that the SSA builder will use.
-  ClosureScope getClosureScope(T node);
+  ClosureScope getClosureScope(MemberEntity entity);
 }
 
 /// Class that represents one level of scoping information, whether this scope
 /// is a closure or not. This is specifically used to store information
 /// about the usage of variables in try or sync blocks, because they need to be
 /// boxed.
 ///
 /// Variables that are used in a try must be treated as boxed because the
 /// control flow can be non-linear. Also parameters to a `sync*` generator must
 /// be boxed, because of the way we rewrite sync* functions. See also comments
@@ skipping 191 matching lines @@
 
   String get name => "Closure Simplifier";
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   void convertClosures(Iterable<MemberEntity> processedEntities,
       ClosedWorldRefiner closedWorldRefiner) {
     createClosureClasses(closedWorldRefiner);
   }
 
-  ClosureScope getClosureScope(Node node) {
+  ClosureScope _getClosureScope(Node node) {
     var value = _closureInfoMap[node];
     return value == null ? const ClosureScope() : value;
   }
 
+  ClosureScope getClosureScope(covariant MemberElement member) {
+    ResolvedAst resolvedAst = member.resolvedAst;
+    if (resolvedAst.kind != ResolvedAstKind.PARSED) return const ClosureScope();
+    return _getClosureScope(resolvedAst.node);
+  }
+
   ScopeInfo getScopeInfo(Element member) {
     return getClosureToClassMapping(member);
   }
 
   ClosureRepresentationInfo getClosureRepresentationInfo(Element member) {
     return getClosureToClassMapping(member);
   }
 
   LoopClosureScope getLoopClosureScope(Node loopNode) {
     var value = _closureInfoMap[loopNode];
@@ skipping 1247 matching lines @@
 ///
 /// Move the below classes to a JS model eventually.
 ///
 abstract class JSEntity implements MemberEntity {
   Local get declaredEntity;
 }
 
 abstract class PrivatelyNamedJSEntity implements JSEntity {
   Entity get rootOfScope;
 }