Add closure_test

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 }
+enum IdKind { element, node, local_variable, local_function }
 
 /// 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 35 matching lines @@
   int get hashCode => value.hashCode;
 
   bool operator ==(other) {
     if (identical(this, other)) return true;
     if (other is! NodeId) return false;
     return value == other.value;
   }
 
   IdKind get kind => IdKind.node;
 
-  String toString() => value.toString();
+  String toString() => '$kind:$value';
 }
 
 abstract class AstEnumeratorMixin {
   TreeElements get elements;
 
   ElementId computeElementId(AstElement element) {
     String memberName = element.name;
     if (element.isSetter) {
       memberName += '=';
     }
     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);
     }
   }
 
-  NodeId computeNodeId(ast.Send node) {
-    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);
+  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);
   }
 }
 
 /// 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 16 matching lines @@
 
   visitNode(ast.Node node) {
     if (found == null) {
       node.visitChildren(this);
     }
   }
 
   visitSend(ast.Send node) {
     if (found == null) {
       visitNode(node);
-      Id id = computeNodeId(node);
+      Id id = computeNodeId(node, null);
       if (id == soughtId) {
         found = node;
       }
     }
   }
 
   visitVariableDefinitions(ast.VariableDefinitions node) {
     if (found == null) {
       for (ast.Node child in node.definitions) {
         AstElement element = elements[child];
         if (element != null) {
-          Id id = computeElementId(element);
+          Id id;
+          if (element is FieldElement) {
+            id = computeElementId(element);
+          } else {
+            id = computeNodeId(child, element);
+          }
           if (id == soughtId) {
             found = element;
             return;
           }
         }
       }
       visitNode(node);
     }
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     if (found == null) {
       AstElement element = elements.getFunctionDefinition(node);
       if (element != null) {
-        Id id = computeElementId(element);
+        Id id;
+        if (element is LocalFunctionElement) {
+          id = computeNodeId(node, element);
+        } else {
+          id = computeElementId(element);
+        }
         if (id == soughtId) {
           found = element;
           return;
         }
       }
       visitNode(node);
     }
   }
 }
 
@@ skipping 51 matching lines @@
     if (found == null) {
       Id id = computeElementId(node);
       if (id == soughtId) {
         found = node;
         return;
       }
       defaultNode(node);
     }
   }
 }