Add no-info mappings at start of out.js and after mapped functions

pkg/compiler/lib/src/io/position_information.dart

 // Copyright (c) 2015, 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.
 
 /// Source information system mapping that attempts a semantic mapping between
 /// offsets of JavaScript code points to offsets of Dart code points.
 
 library dart2js.source_information.position;
 
 import '../common.dart';
@@ skipping 502 matching lines @@
 
 /// [TraceListener] that register [SourceLocation]s with a [SourceMapper].
 class PositionTraceListener extends TraceListener
     with NodeToSourceInformationMixin {
   final SourceMapper sourceMapper;
 
   PositionTraceListener(this.sourceMapper);
 
   @override
   void onStep(js.Node node, Offset offset, StepKind kind) {
+    int codeLocation = offset.value;
+    if (codeLocation == null) return;
+
+    if (kind == StepKind.NO_INFO) {
+      sourceMapper.register(node, codeLocation, const NoSourceLocationMarker());
+      return;
+    }
+
     SourceInformation sourceInformation = computeSourceInformation(node);
     if (sourceInformation == null) return;
-    int codeLocation = offset.value;
-    if (codeLocation == null) return;
 
     void registerPosition(SourcePositionKind sourcePositionKind) {
       SourceLocation sourceLocation =
           getSourceLocation(sourceInformation, sourcePositionKind);
       if (sourceLocation != null) {
         sourceMapper.register(node, codeLocation, sourceLocation);
       }
     }
 
     switch (kind) {
@@ skipping 18 matching lines @@
       case StepKind.EXPRESSION_STATEMENT:
       case StepKind.IF_CONDITION:
       case StepKind.FOR_INITIALIZER:
       case StepKind.FOR_CONDITION:
       case StepKind.FOR_UPDATE:
       case StepKind.WHILE_CONDITION:
       case StepKind.DO_CONDITION:
       case StepKind.SWITCH_EXPRESSION:
         registerPosition(SourcePositionKind.START);
         break;
+      case StepKind.NO_INFO:
+        break;
     }
   }
 }
 
 /// The position of a [js.Call] node.
 class CallPosition {
   final js.Node node;
   final CodePositionKind codePositionKind;
   final SourcePositionKind sourcePositionKind;
 
@@ skipping 128 matching lines @@
   CONTINUE,
   THROW,
   EXPRESSION_STATEMENT,
   IF_CONDITION,
   FOR_INITIALIZER,
   FOR_CONDITION,
   FOR_UPDATE,
   WHILE_CONDITION,
   DO_CONDITION,
   SWITCH_EXPRESSION,
+  NO_INFO,
 }
 
 /// Listener for the [JavaScriptTracer].
 abstract class TraceListener {
   /// Called before [root] node is procesed by the [JavaScriptTracer].
   void onStart(js.Node root) {}
 
   /// Called after [root] node has been procesed by the [JavaScriptTracer].
   void onEnd(js.Node root) {}
 
@@ skipping 45 matching lines @@
       listeners.forEach((listener) => listener.pushBranch(kind, value));
     }
   }
 
   void notifyPopBranch() {
     if (active) {
       listeners.forEach((listener) => listener.popBranch());
     }
   }
 
-  void notifyStep(js.Node node, Offset offset, StepKind kind) {
-    if (active) {
+  void notifyStep(js.Node node, Offset offset, StepKind kind,
+      {bool force: false}) {
+    if (active || force) {
       listeners.forEach((listener) => listener.onStep(node, offset, kind));
     }
   }
 
   void apply(js.Node node) {
     notifyStart(node);
+
+    int startPosition = getSyntaxOffset(node, kind: CodePositionKind.START);
+    Offset startOffset = getOffsetForNode(node, startPosition);
+    notifyStep(node, startOffset, StepKind.NO_INFO, force: true);
+
     node.accept(this);
     notifyEnd(node);
   }
 
   @override
   visitNode(js.Node node) {
     node.visitChildren(this);
   }
 
   visit(js.Node node, [BranchKind branch, value]) {
@@ skipping 26 matching lines @@
         statementOffset = getSyntaxOffset(node, kind: CodePositionKind.START);
     Offset entryOffset = getOffsetForNode(node, statementOffset);
     notifyStep(node, entryOffset, StepKind.FUN_ENTRY);
 
     visit(node.body);
 
     leftToRightOffset =
         statementOffset = getSyntaxOffset(node, kind: CodePositionKind.CLOSING);
     Offset exitOffset = getOffsetForNode(node, statementOffset);
     notifyStep(node, exitOffset, StepKind.FUN_EXIT);
+    if (active && !activeBefore) {
+      int endPosition = getSyntaxOffset(node, kind: CodePositionKind.END);
+      Offset endOffset = getOffsetForNode(node, endPosition);
+      notifyStep(node, endOffset, StepKind.NO_INFO);
+    }
     active = activeBefore;
   }
 
   @override
   visitBlock(js.Block node) {
     for (js.Statement statement in node.statements) {
       visit(statement);
     }
   }
 
@@ skipping 443 matching lines @@
 
   @override
   CodePosition operator [](js.Node node) {
     CodePosition codePosition = codePositions[node];
     if (codePosition == null) {
       coverage.registerNodesWithoutOffset(node);
     }
     return codePosition;
   }
 }