Add closure_test for kernel based members

tests/compiler/dart2js/equivalence/id_equivalence.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 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/resolution/access_semantics.dart';
 import 'package:compiler/src/resolution/send_structure.dart';
 import 'package:compiler/src/resolution/tree_elements.dart';
 import 'package:compiler/src/tree/nodes.dart' as ast;
 import 'package:kernel/ast.dart' as ir;
 
-enum IdKind { element, node, local_variable, local_function }
+enum IdKind {
+  element,
+  node,
+}
 
 /// Id for a code point or element with type inference information.
 abstract class Id {
   IdKind get kind;
 }
 
 /// Id for an element with type inference information.
 // TODO(johnniwinther): Support local variables, functions and parameters.
 class ElementId implements Id {
   final String className;
@@ skipping 55 matching lines @@
     }
     String className = element.enclosingClass?.name;
     return new ElementId.internal(memberName, className);
   }
 
   NodeId computeAccessId(ast.Send node, AccessSemantics access) {
     switch (access.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return new NodeId(node.selector.getBeginToken().charOffset);
       default:
-        return new NodeId(node.getBeginToken().charOffset);
+        return null;
     }
   }
 
   NodeId computeNodeId(ast.Node node, AstElement element) {
     if (element != null && element.isLocal) {
       return new NodeId(node.getBeginToken().charOffset);
     } else if (node is ast.Send) {
       dynamic sendStructure = elements.getSendStructure(node);
       if (sendStructure == null) return null;
       switch (sendStructure.kind) {
         case SendStructureKind.GET:
         case SendStructureKind.INVOKE:
-        case SendStructureKind.INCOMPATIBLE_INVOKE:
           return computeAccessId(node, sendStructure.semantics);
         default:
-          return new NodeId(node.getBeginToken().charOffset);
       }
     }
-    return new NodeId(node.getBeginToken().charOffset);
+    return null;
   }
 }
 
 /// Visitor that finds the AST node or element corresponding to an [Id].
 class AstIdFinder extends ast.Visitor with AstEnumeratorMixin {
   Id soughtId;
   var /*AstElement|ast.Node*/ found;
   final TreeElements elements;
 
   AstIdFinder(this.elements);
@@ skipping 77 matching lines @@
     if (node.enclosingClass != null) {
       className = node.enclosingClass.name;
     }
     String memberName = node.name.name;
     if (node is ir.Procedure && node.kind == ir.ProcedureKind.Setter) {
       memberName += '=';
     }
     return new ElementId.internal(memberName, className);
   }
 
-  Id computeNodeId(ir.Node node) {
+  Id computeNodeId(ir.TreeNode node) {
     if (node is ir.MethodInvocation) {
       assert(node.fileOffset != ir.TreeNode.noOffset);
       return new NodeId(node.fileOffset);
     } else if (node is ir.PropertyGet) {
       assert(node.fileOffset != ir.TreeNode.noOffset);
       return new NodeId(node.fileOffset);
+    } else if (node is ir.VariableDeclaration) {
+      assert(node.fileOffset != ir.TreeNode.noOffset);
+      return new NodeId(node.fileOffset);
+    } else if (node is ir.FunctionDeclaration) {
+      assert(node.fileOffset != ir.TreeNode.noOffset);
+      return new NodeId(node.fileOffset);
     }
     return null;
   }
 }
 
 /// Visitor that finds the IR node corresponding to an [Id].
 class IrIdFinder extends ir.Visitor with IrEnumeratorMixin {
   Id soughtId;
   ir.Node found;
 
   /// Visits the subtree of [root] returns the [ir.Node] corresponding to [id].
   ir.Node find(ir.Node root, Id id) {
     soughtId = id;
     root.accept(this);
     var result = found;
     found = null;
     return result;
   }
 
-  defaultNode(ir.Node node) {
+  defaultTreeNode(ir.TreeNode node) {
     if (found == null) {
       Id id = computeNodeId(node);
       if (id == soughtId) {
         found = node;
         return;
       }
       node.visitChildren(this);
     }
   }
 
   defaultMember(ir.Member node) {
     if (found == null) {
       Id id = computeElementId(node);
       if (id == soughtId) {
         found = node;
         return;
       }
-      defaultNode(node);
+      defaultTreeNode(node);
     }
   }
 }