Compute better names for source maps.

tests/compiler/dart2js/source_map_validator_helper.dart

 // Copyright (c) 2014, 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';
 import 'dart:convert';
 import 'dart:async';
 
 import 'package:path/path.dart' as path;
 import 'package:expect/expect.dart';
 import 'package:source_maps/source_maps.dart' hide SourceFile;
 import 'package:compiler/src/apiimpl.dart';
 import 'package:compiler/src/elements/elements.dart'
-    show LibraryElement,
+    show AstElement,
+         ClassElement,
          CompilationUnitElement,
-         ClassElement,
-         AstElement;
+         Element,
+         FunctionElement,
+         LibraryElement,
+         MemberElement;
 import 'package:compiler/src/io/source_file.dart' show SourceFile;
+import 'package:compiler/src/io/source_information.dart'
+    show computeElementNameForSourceMaps;
 
 validateSourceMap(Uri targetUri,
                   {Uri mainUri,
                    Position mainPosition,
                    Compiler compiler}) {
   Uri mapUri = getMapUri(targetUri);
   List<String> targetLines = new File.fromUri(targetUri).readAsLinesSync();
   SingleMapping sourceMap = getSourceMap(mapUri);
   checkFileReferences(targetUri, mapUri, sourceMap);
   checkIndexReferences(targetLines, mapUri, sourceMap);
@@ skipping 107 matching lines @@
         Interval intervalFromElement(AstElement element) {
           if (!element.hasNode) return null;
 
           var begin = element.node.getBeginToken().charOffset;
           var end = element.node.getEndToken();
           end = end.charOffset + end.charCount;
           return new Interval(positionFromOffset(begin),
                               positionFromOffset(end));
         }
 
+        AstElement findInnermost(AstElement element) {
+          bool isInsideElement(FunctionElement closure) {
+            Element enclosing = closure;
+            while (enclosing != null) {
+              if (enclosing == element) return true;
+              enclosing = enclosing.enclosingElement;
+            }
+            return false;
+          }
+
+          if (element is MemberElement) {
+            MemberElement member = element;
+            member.nestedClosures.forEach((closure) {
+              var localFunction = closure.expression;
+              Interval interval = intervalFromElement(localFunction);
+              if (interval != null &&
+                  interval.contains(sourcePosition) &&
+                  isInsideElement(localFunction)) {
+                element = localFunction;
+              }
+            });
+          }
+          return element;
+        }
+
         void match(AstElement element) {
           Interval interval = intervalFromElement(element);
           if (interval != null && interval.contains(sourcePosition)) {
-            if (name != 'call') {
-              // TODO(johnniwinther): Check closures.
-              Expect.equals(element.name, name);
-            } else if (name != element.name) {
-              print("${targetUri}$targetPosition:\n"
-                    "Name '$name' does not match element $element in "
-                    "${sourceFile.filename}$sourcePosition.");
+            AstElement innerElement = findInnermost(element);
+            String expectedName =
+                computeElementNameForSourceMaps(innerElement);
+            if (name != expectedName) {
+              // For the code
+              //    (){}();
+              //    ^
+              // the indicated position is within the scope of the local
+              // function but it is also the position for the invocation of it.
+              // Allow name to be either from the local or from its calling
+              // context.
+              if (innerElement.isLocal && innerElement.isFunction) {
+                var enclosingElement = innerElement.enclosingElement;
+                String expectedName2 =
+                    computeElementNameForSourceMaps(enclosingElement);
+                Expect.isTrue(name == expectedName2,
+                    "Unexpected name '${name}', "
+                    "expected '${expectedName}' for $innerElement "
+                    "or '${expectedName2}' for $enclosingElement.");
+              } else {
+                Expect.equals(expectedName, name,
+                    "Unexpected name '${name}', "
+                    "expected '${expectedName}' or for $innerElement.");
+              }
             }
           }
         }
 
         compilationUnit.forEachLocalMember((AstElement element) {
           if (element.isClass) {
             ClassElement classElement = element;
             classElement.forEachLocalMember(match);
           } else {
             match(element);
@@ skipping 93 matching lines @@
   final int line;
   final int column;
 
   const Position(this.line, this.column);
 
   bool operator <=(Position other) {
     return line < other.line ||
            line == other.line && column <= other.column;
   }
 
-  String toString() => '[$line,$column]';
+  String toString() => '[${line + 1},${column + 1}]';
 }
 
 class Interval {
   final Position begin;
   final Position end;
 
   Interval(this.begin, this.end);
 
   bool contains(Position other) {
     return begin <= other && other <= end;
   }
 
   String toString() => '$begin-$end';
 }