Fix shift in source map positions.

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,
          CompilationUnitElement,
          ClassElement,
          AstElement;
 import 'package:compiler/src/io/source_file.dart' show SourceFile;
 
-validateSourceMap(Uri targetUri, [Compiler compiler]) {
+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(targetUri, mapUri, sourceMap);
+  checkIndexReferences(targetLines, mapUri, sourceMap);
   checkRedundancy(sourceMap);
   if (compiler != null) {
     checkNames(targetUri, mapUri, sourceMap, compiler);
   }
+  if (mainUri != null && mainPosition != null) {
+    checkMainPosition(targetUri, targetLines ,sourceMap, mainUri, mainPosition);
+  }
 }
 
-checkIndexReferences(Uri targetUri, Uri mapUri, SingleMapping sourceMap) {
-  List<String> target =
-      new File.fromUri(targetUri).readAsStringSync().split('\n');
+checkIndexReferences(List<String> targetLines,
+                     Uri mapUri,
+                     SingleMapping sourceMap) {
   int urlsLength = sourceMap.urls.length;
   List<List<String>> sources = new List(urlsLength);
   print('Reading sources');
   for (int i = 0; i < urlsLength; i++) {
     sources[i] = new File.fromUri(mapUri.resolve(sourceMap.urls[i])).
         readAsStringSync().split('\n');
   }
 
   sourceMap.lines.forEach((TargetLineEntry line) {
     Expect.isTrue(line.line >= 0);
-    Expect.isTrue(line.line < target.length);
+    Expect.isTrue(line.line < targetLines.length);
     for (TargetEntry entry in line.entries) {
       int urlIndex = entry.sourceUrlId;
 
       // TODO(zarah): Entry columns sometimes point one or more characters too
       // far. Incomment this check when this is fixed.
       //
       // Expect.isTrue(entry.column < target[line.line].length);
       Expect.isTrue(entry.column >= 0);
       Expect.isTrue(urlIndex == null ||
           (urlIndex >= 0 && urlIndex < urlsLength));
@@ skipping 101 matching lines @@
             classElement.forEachLocalMember(match);
           } else {
             match(element);
           }
         });
       }
     }
   });
 }
 
+RegExp mainSignaturePrefix = new RegExp(r'main: \[?function\(');
+
+// Check that the line pointing to by [mainPosition] in [mainUri] contains
+// the main function signature.
+checkMainPosition(Uri targetUri,
+                  List<String> targetLines,
+                  SingleMapping sourceMap,
+                  Uri mainUri,
+                  Position mainPosition) {
+  bool mainPositionFound = false;
+  sourceMap.lines.forEach((TargetLineEntry lineEntry) {
+    lineEntry.entries.forEach((TargetEntry entry) {
+      if (entry.sourceLine == null || entry.sourceUrlId == null) return;
+      Uri sourceUri = targetUri.resolve(sourceMap.urls[entry.sourceUrlId]);
+      if (sourceUri != mainUri) return;
+      if (entry.sourceLine + 1 == mainPosition.line &&
+          entry.sourceColumn + 1 == mainPosition.column) {
+        Expect.isNotNull(entry.sourceNameId,
+                         "Main position has no name.");
+        String name = sourceMap.names[entry.sourceNameId];
+        Expect.equals('main', name,
+                      "Main position name is not '$name', not 'main'.");
+        String line = targetLines[lineEntry.line];
+        Expect.isTrue(line.contains(mainSignaturePrefix),
+            "Line mapped to main position "
+            "([${lineEntry.line + 1},${entry.column + 1}]) "
+            "expected to contain '${mainSignaturePrefix.pattern}':\n$line\n");
+        mainPositionFound = true;
+      }
+    });
+  });
+  Expect.isTrue(mainPositionFound,
+                'No main position $mainPosition found in $mainUri');
+}
+
+
 sameSourcePoint(TargetEntry entry, TargetEntry otherEntry) {
   return
       (entry.sourceUrlId == otherEntry.sourceUrlId) &&
       (entry.sourceLine == otherEntry.sourceLine) &&
       (entry.sourceColumn == otherEntry.sourceColumn) &&
       (entry.sourceNameId == otherEntry.sourceNameId);
 }
 
 Uri getMapUri(Uri targetUri) {
   print('Accessing $targetUri');
@@ skipping 33 matching lines @@
       .createTemp('sourceMap_test-')
       .then((Directory dir) {
     return dir;
   });
 }
 
 class Position {
   final int line;
   final int column;
 
-  Position(this.line, this.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]';
 }
 
 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';
 }