Add Dart code to diff_view

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';
 import '../elements/elements.dart' show
     AstElement,
+    FieldElement,
     LocalElement;
 import '../js/js.dart' as js;
 import '../js/js_source_mapping.dart';
 import '../js/js_debug.dart';
 import '../tree/tree.dart' show
+    FunctionExpression,
     Node,
     Send;
 
 import 'code_output.dart' show
     CodeBuffer;
 import 'source_file.dart';
 import 'source_information.dart';
 
 /// [SourceInformation] that consists of an offset position into the source
 /// code.
@@ skipping 112 matching lines @@
   List<SourceLocation> get sourceLocations => const <SourceLocation>[];
 
   @override
   SourceSpan get sourceSpan => new SourceSpan(null, null, null);
 }
 
 /// [SourceInformationBuilder] that generates [PositionSourceInformation].
 class PositionSourceInformationBuilder implements SourceInformationBuilder {
   final SourceFile sourceFile;
   final String name;
+  final AstElement element;
 
   PositionSourceInformationBuilder(AstElement element)
-      : sourceFile = element.implementation.compilationUnit.script.file,
+      : this.element = element,
+        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,
@@ skipping 71 matching lines @@
   @override
   SourceInformation buildIf(Node node) => buildBegin(node);
 
   @override
   SourceInformation buildThrow(Node node) => buildBegin(node);
 
   @override
   SourceInformation buildAssignment(Node node) => buildBegin(node);
 
   @override
+  SourceInformation buildVariableDeclaration() {
+    if (element.hasNode) {
+      Node node = element.node;
+      FunctionExpression functionExpression = node.asFunctionExpression();
+      if (functionExpression != null) {

[Siggi Cherem (dart-lang), 2016/02/08 22:31:53]

nit: I'd remove the call to `asFunctionExpression` method, and simply do an
instance check here. Then we get advantage of the type strengthening in branches
without having to add explicit typed variables:

if (node is FunctionExpression) {
  return buildBegin(node.body);
} else if (element is FieldElement && element.initializer != null) {
  return buildBegin(element.initializer);
}

[Johnni Winther, 2016/02/10 09:19:27]

Done for FunctionExpression. Type promotion is not strong enough to handle the
latter case.

+        return buildBegin(functionExpression.body);
+      } else {
+        if (element.isField) {
+          FieldElement field = element;
+          if (field.initializer != null) {
+            return buildBegin(field.initializer);
+          }
+        }
+        // TODO(johnniwinther): Are there other cases?
+      }
+    }
+    return null;
+  }
+
+  @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }
 
 /// The start, end and closing offsets for a [js.Node].
 class CodePosition {
   final int startPosition;
   final int endPosition;
   final int closingPosition;
@@ skipping 148 matching lines @@
   @override
   void onPositions(js.Node node,
                    int startPosition,
                    int endPosition,
                    int closingPosition) {
     codePositionRecorder.registerPositions(
         node, startPosition, endPosition, closingPosition);
   }
 }
 
+/// Visitor that computes [SourceInformation] for a [js.Node] using information
+/// attached to the node itself or alternatively from child nodes.
+class NodeSourceInformation extends js.BaseVisitor<SourceInformation> {
+  const NodeSourceInformation();
+
+  SourceInformation visit(js.Node node) => node?.accept(this);
+
+  @override
+  SourceInformation visitNode(js.Node node) => node.sourceInformation;
+
+  @override
+  SourceInformation visitExpressionStatement(js.ExpressionStatement node) {
+    if (node.sourceInformation != null) {
+      return node.sourceInformation;
+    }
+    return visit(node.expression);
+  }
+
+  @override
+  SourceInformation visitVariableDeclarationList(
+      js.VariableDeclarationList node) {
+    if (node.sourceInformation != null) {
+      return node.sourceInformation;
+    }
+    for (js.Node declaration in node.declarations) {
+      SourceInformation sourceInformation = visit(declaration);
+      if (sourceInformation != null) {
+        return sourceInformation;
+      }
+    }
+    return null;
+  }
+
+  @override
+  SourceInformation visitVariableInitialization(
+      js.VariableInitialization node) {
+    if (node.sourceInformation != null) {
+      return node.sourceInformation;
+    }
+    return visit(node.value);
+  }
+
+  @override
+  SourceInformation visitAssignment(js.Assignment node) {
+    if (node.sourceInformation != null) {
+      return node.sourceInformation;
+    }
+    return visit(node.value);
+  }
+
+}
+
+/// Mixin that add support for computing [SourceInformation] for a [js.Node].
+class NodeToSourceInformationMixin {
+  SourceInformation computeSourceInformation(js.Node node) {
+    return const NodeSourceInformation().visit(node);
+  }
+}
+
 /// [TraceListener] that register [SourceLocation]s with a [SourceMapper].
-class PositionTraceListener extends TraceListener {
+class PositionTraceListener extends TraceListener with
+    NodeToSourceInformationMixin {
   final SourceMapper sourceMapper;
 
   PositionTraceListener(this.sourceMapper);
 
   @override
   void onStep(js.Node node, Offset offset, StepKind kind) {
-    SourceInformation sourceInformation = node.sourceInformation;
+    SourceInformation sourceInformation = computeSourceInformation(node);
     if (sourceInformation == null) return;
 
     SourcePositionKind sourcePositionKind = SourcePositionKind.START;
     switch (kind) {
       case StepKind.FUN:
         sourcePositionKind = SourcePositionKind.INNER;
         break;
       case StepKind.CALL:
         CallPosition callPosition =
             CallPosition.getSemanticPositionForCall(node);
@@ skipping 314 matching lines @@
                      int codeOffset,
                      StepKind kind) {
     var oldSteps = steps;
     steps = [];
     offsetPosition = codeOffset;
     visit(child);
     if (steps.isEmpty) {
       notifyStep(parent,
           getOffsetForNode(parent, offsetPosition),
           kind);
+      // The [offsetPosition] should only be used by the first subexpression.
+      offsetPosition = null;
     }
     steps = oldSteps;
   }
 
   @override
   visitExpressionStatement(js.ExpressionStatement node) {
     statementOffset = getSyntaxOffset(node);
     visitSubexpression(
         node, node.expression, statementOffset,
         StepKind.EXPRESSION_STATEMENT);
@@ skipping 10 matching lines @@
     int oldPosition = offsetPosition;
     offsetPosition = null;
     visitList(node.arguments);
     offsetPosition = oldPosition;
     CallPosition callPosition =
         CallPosition.getSemanticPositionForCall(node);
     js.Node positionNode = callPosition.node;
     int callOffset = getSyntaxOffset(
         positionNode, kind: callPosition.codePositionKind);
     if (offsetPosition == null) {
+      // Use the call offset if this is not the first subexpression.
       offsetPosition = callOffset;
     }
     Offset offset = getOffsetForNode(positionNode, offsetPosition);
     notifyStep(node, offset, StepKind.CALL);
     steps.add(node);
     offsetPosition = null;
   }
 
   @override
   visitNew(js.New node) {
     visit(node.target);
     visitList(node.arguments);
+    if (offsetPosition == null) {
+      // Use the syntax offset if this is not the first subexpression.
+      offsetPosition = getSyntaxOffset(node);
+    }
     notifyStep(
-        node, getOffsetForNode(node, getSyntaxOffset(node)), StepKind.NEW);
+        node, getOffsetForNode(node, offsetPosition), StepKind.NEW);
     steps.add(node);
     offsetPosition = null;
   }
 
   @override
   visitAccess(js.PropertyAccess node) {
     visit(node.receiver);
     visit(node.selector);
   }
 
@@ skipping 69 matching lines @@
           StepKind.FOR_UPDATE);
     }
 
     notifyPopBranch();
   }
 
   @override
   visitWhile(js.While node) {
     statementOffset = getSyntaxOffset(node);
     if (node.condition != null) {
-      visitSubexpression(node, node.condition, getSyntaxOffset(node.condition),
+      visitSubexpression(node, node.condition, getSyntaxOffset(node),
           StepKind.WHILE_CONDITION);
     }
     statementOffset = null;
     leftToRightOffset = null;
 
     visit(node.body, BranchKind.LOOP);
   }
 
   @override
   visitDo(js.Do node) {
@@ skipping 22 matching lines @@
     visit(node.value);
     notifyStep(
         node, getOffsetForNode(node, getSyntaxOffset(node)), StepKind.RETURN);
     statementOffset = null;
     leftToRightOffset = null;
   }
 
   @override
   visitThrow(js.Throw node) {
     statementOffset = getSyntaxOffset(node);
+    // Do not use [offsetPosition] for the subexpression.
+    offsetPosition = null;
     visit(node.expression);
     notifyStep(
         node, getOffsetForNode(node, getSyntaxOffset(node)), StepKind.THROW);
     statementOffset = null;
     leftToRightOffset = null;
   }
 
   @override
   visitContinue(js.Continue node) {
     statementOffset = getSyntaxOffset(node);
@@ skipping 151 matching lines @@
       }
     }
     _nodesWithoutInfo.clear();
   }
 
   String getCoverageReport() {
     collapse();
     StringBuffer sb = new StringBuffer();
     int total = _nodesWithInfoCount + _nodesWithoutInfoCount;
     if (total > 0) {
-      sb.write(_nodesWithoutInfoCount);
+      sb.write(_nodesWithInfoCount);
       sb.write('/');
       sb.write(total);
       sb.write(' (');
       sb.write((100.0 * _nodesWithInfoCount / total).toStringAsFixed(2));
       sb.write('%) nodes with info.');
     } else {
       sb.write('No nodes.');
     }
     if (_nodesWithoutOffsetCount > 0) {
       sb.write(' ');
       sb.write(_nodesWithoutOffsetCount);
       sb.write(' node');
       if (_nodesWithoutOffsetCount > 1) {
         sb.write('s');
       }
       sb.write(' without offset.');
     }
     if (_nodesWithoutInfoCount > 0) {
       sb.write('\nNodes without info (');
       sb.write(_nodesWithoutInfoCount);
       sb.write(') by runtime type:');
-      _nodesWithoutInfoCountByType.forEach((Type type, int count) {
+      List<Type> types = _nodesWithoutInfoCountByType.keys.toList();
+      types.sort((a, b) {
+        return -_nodesWithoutInfoCountByType[a].compareTo(
+            _nodesWithoutInfoCountByType[b]);
+      });
+
+      types.forEach((Type type) {
+        int count = _nodesWithoutInfoCountByType[type];
         sb.write('\n ');
         sb.write(count);
         sb.write(' ');
         sb.write(type);
         sb.write(' node');
         if (count > 1) {
           sb.write('s');
         }
       });
       sb.write('\n');
     }
     return sb.toString();
   }
 
   String toString() => getCoverageReport();
 }
 
 /// [TraceListener] that registers [onStep] callbacks with [coverage].
-class CoverageListener extends TraceListener {
+class CoverageListener extends TraceListener with NodeToSourceInformationMixin {
   final Coverage coverage;
 
   CoverageListener(this.coverage);
 
   @override
   void onStep(js.Node node, Offset offset, StepKind kind) {
-    SourceInformation sourceInformation = node.sourceInformation;
+    SourceInformation sourceInformation = computeSourceInformation(node);
     if (sourceInformation != null) {
       coverage.registerNodeWithInfo(node);
     } else {
       coverage.registerNodeWithoutInfo(node);
     }
   }
 
   @override
   void onEnd(js.Node node) {
     coverage.collapse();
   }
 }
 
 /// [CodePositionMap] that registers calls with [Coverage].
 class CodePositionCoverage implements CodePositionMap {
   final CodePositionMap codePositions;
   final Coverage coverage;
 
   CodePositionCoverage(this.codePositions, this.coverage);
 
   @override
   CodePosition operator [](js.Node node) {
     CodePosition codePosition = codePositions[node];
     if (codePosition == null) {
       coverage.registerNodesWithoutOffset(node);
    }
     return codePosition;
   }
 }