Add source location to function declarations.

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 145 matching lines @@
         sourceFile = element.implementation.compilationUnit.script.file,
         name = computeElementNameForSourceMaps(element);
 
   SourceInformation buildDeclaration(AstElement element) {
     if (element.isSynthesized) {
       return new PositionSourceInformation(
           new OffsetSourceLocation(
               sourceFile, element.position.charOffset, name));
     } else {
       return new PositionSourceInformation(
-          null,
+          new OffsetSourceLocation(sourceFile,
+              element.resolvedAst.node.getBeginToken().charOffset, name),
           new OffsetSourceLocation(sourceFile,
               element.resolvedAst.node.getEndToken().charOffset, name));
     }
   }
 
   /// Builds a source information object pointing the start position of [node].
   SourceInformation buildBegin(Node node) {
     return new PositionSourceInformation(new OffsetSourceLocation(
         sourceFile, node.getBeginToken().charOffset, name));
   }
@@ skipping 316 matching lines @@
 class PositionTraceListener extends TraceListener with
     NodeToSourceInformationMixin {
   final SourceMapper sourceMapper;
 
   PositionTraceListener(this.sourceMapper);
 
   @override
   void onStep(js.Node node, Offset offset, StepKind kind) {
     SourceInformation sourceInformation = computeSourceInformation(node);
     if (sourceInformation == null) return;
+    int codeLocation = offset.subexpressionOffset;
+    if (codeLocation == null) return;
 
-    SourcePositionKind sourcePositionKind = SourcePositionKind.START;
+    void registerPosition(SourcePositionKind sourcePositionKind) {
+      SourceLocation sourceLocation =
+          getSourceLocation(sourceInformation, sourcePositionKind);
+      if (sourceLocation != null) {
+        sourceMapper.register(node, codeLocation, sourceLocation);
+      }
+    }
+
     switch (kind) {
-      case StepKind.FUN:
-        sourcePositionKind = SourcePositionKind.INNER;
+      case StepKind.FUN_ENTRY:
+        // TODO(johnniwinther): Remove this when fully transitioned to the
+        // new source info system.
+        registerPosition(SourcePositionKind.START);
+        break;
+      case StepKind.FUN_EXIT:
+        registerPosition(SourcePositionKind.INNER);
         break;
       case StepKind.CALL:
         CallPosition callPosition =
             CallPosition.getSemanticPositionForCall(node);
-        sourcePositionKind = callPosition.sourcePositionKind;
+        registerPosition(callPosition.sourcePositionKind);
         break;
       case StepKind.NEW:
       case StepKind.RETURN:
       case StepKind.BREAK:
       case StepKind.CONTINUE:
       case StepKind.THROW:
       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;
     }
-    int codeLocation = offset.subexpressionOffset;
-    SourceLocation sourceLocation =
-        getSourceLocation(sourceInformation, sourcePositionKind);
-    if (codeLocation != null && sourceLocation != null) {
-      sourceMapper.register(node, codeLocation, sourceLocation);
-    }
   }
 }
 
 /// The position of a [js.Call] node.
 class CallPosition {
   final js.Node node;
   final CodePositionKind codePositionKind;
   final SourcePositionKind sourcePositionKind;
 
   CallPosition(this.node, this.codePositionKind, this.sourcePositionKind);
@@ skipping 120 matching lines @@
 
 enum BranchKind {
   CONDITION,
   LOOP,
   CATCH,
   FINALLY,
   CASE,
 }
 
 enum StepKind {
-  FUN,
+  FUN_ENTRY,
+  FUN_EXIT,
   CALL,
   NEW,
   RETURN,
   BREAK,
   CONTINUE,
   THROW,
   EXPRESSION_STATEMENT,
   IF_CONDITION,
   FOR_INITIALIZER,
   FOR_CONDITION,
@@ skipping 104 matching lines @@
       }
     }
   }
 
   @override
   visitFun(js.Fun node) {
     bool activeBefore = active;
     if (!active) {
       active = node.sourceInformation != null;
     }
+    leftToRightOffset = 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 offset = getOffsetForNode(node, statementOffset);
-    notifyStep(node, offset, StepKind.FUN);
+    Offset exitOffset = getOffsetForNode(node, statementOffset);
+    notifyStep(node, exitOffset, StepKind.FUN_EXIT);
     active = activeBefore;
   }
 
   @override
   visitBlock(js.Block node) {
     for (js.Statement statement in node.statements) {
       visit(statement);
     }
   }
 
@@ skipping 452 matching lines @@
 
   @override
   CodePosition operator [](js.Node node) {
     CodePosition codePosition = codePositions[node];
     if (codePosition == null) {
       coverage.registerNodesWithoutOffset(node);
    }
     return codePosition;
   }
 }