dartfmt pkg/compiler

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 '../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 '../tree/tree.dart' show FunctionExpression, Node, Send;
 
-import 'code_output.dart' show
-    CodeBuffer;
+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.
 class PositionSourceInformation extends SourceInformation {
   @override
   final SourceLocation startPosition;
 
   @override
   final SourceLocation closingPosition;
 
-  PositionSourceInformation(this.startPosition,
-                            [this.closingPosition]);
+  PositionSourceInformation(this.startPosition, [this.closingPosition]);
 
   @override
   List<SourceLocation> get sourceLocations {
     List<SourceLocation> list = <SourceLocation>[];
     if (startPosition != null) {
       list.add(startPosition);
     }
     if (closingPosition != null) {
       list.add(closingPosition);
     }
     return list;
   }
 
   @override
   SourceSpan get sourceSpan {
     SourceLocation location =
         startPosition != null ? startPosition : closingPosition;
     Uri uri = location.sourceUri;
     int offset = location.offset;
     return new SourceSpan(uri, offset, offset);
   }
 
   int get hashCode {
     return 0x7FFFFFFF &
-           (startPosition.hashCode * 17 + closingPosition.hashCode * 19);
+        (startPosition.hashCode * 17 + closingPosition.hashCode * 19);
   }
 
   bool operator ==(other) {
     if (identical(this, other)) return true;
     if (other is! PositionSourceInformation) return false;
     return startPosition == other.startPosition &&
-           closingPosition == other.closingPosition;
+        closingPosition == other.closingPosition;
   }
 
   /// Create a textual representation of the source information using [uriText]
   /// as the Uri representation.
   String _computeText(String uriText) {
     StringBuffer sb = new StringBuffer();
     sb.write('$uriText:');
     // Use 1-based line/column info to match usual dart tool output.
     if (startPosition != null) {
       sb.write('[${startPosition.line + 1},'
-                '${startPosition.column + 1}]');
+          '${startPosition.column + 1}]');
     }
     if (closingPosition != null) {
       sb.write('-[${closingPosition.line + 1},'
-                 '${closingPosition.column + 1}]');
+          '${closingPosition.column + 1}]');
     }
     return sb.toString();
   }
 
   String get shortText {
     if (startPosition != null) {
       return _computeText(startPosition.sourceUri.pathSegments.last);
     } else {
       return _computeText(closingPosition.sourceUri.pathSegments.last);
     }
@@ skipping 55 matching lines @@
   final String name;
   final AstElement element;
 
   PositionSourceInformationBuilder(AstElement element)
       : 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));
+      return new PositionSourceInformation(new OffsetSourceLocation(
+          sourceFile, element.position.charOffset, name));
     } else {
       return new PositionSourceInformation(
           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));
   }
 
   @override
   SourceInformation buildGeneric(Node node) => buildBegin(node);
 
   @override
   SourceInformation buildCreate(Node node) => buildBegin(node);
 
   @override
   SourceInformation buildReturn(Node node) => buildBegin(node);
 
   @override
   SourceInformation buildImplicitReturn(AstElement element) {
     if (element.isSynthesized) {
-      return new PositionSourceInformation(
-          new OffsetSourceLocation(
-              sourceFile, element.position.charOffset, name));
+      return new PositionSourceInformation(new OffsetSourceLocation(
+          sourceFile, element.position.charOffset, name));
     } else {
-      return new PositionSourceInformation(
-          new OffsetSourceLocation(sourceFile,
-              element.resolvedAst.node.getEndToken().charOffset, name));
+      return new PositionSourceInformation(new OffsetSourceLocation(
+          sourceFile, element.resolvedAst.node.getEndToken().charOffset, name));
     }
- }
-
+  }
 
   @override
   SourceInformation buildLoop(Node node) => buildBegin(node);
 
   @override
   SourceInformation buildGet(Node node) {
     Node left = node;
     Node right = node;
     Send send = node.asSend();
     if (send != null) {
@@ skipping 115 matching lines @@
         return startPosition;
       case CodePositionKind.END:
         return endPosition;
       case CodePositionKind.CLOSING:
         return closingPosition;
     }
   }
 
   String toString() {
     return 'CodePosition(start=$startPosition,'
-           'end=$endPosition,closing=$closingPosition)';
+        'end=$endPosition,closing=$closingPosition)';
   }
 }
 
 /// A map from a [js.Node] to its [CodePosition].
 abstract class CodePositionMap {
   CodePosition operator [](js.Node node);
 }
 
 /// Registry for mapping [js.Node]s to their [CodePosition].
 class CodePositionRecorder implements CodePositionMap {
   Map<js.Node, CodePosition> _codePositionMap =
       new Map<js.Node, CodePosition>.identity();
 
-  void registerPositions(js.Node node,
-                         int startPosition,
-                         int endPosition,
-                         int closingPosition) {
-    registerCodePosition(node,
-        new CodePosition(startPosition, endPosition, closingPosition));
+  void registerPositions(
+      js.Node node, int startPosition, int endPosition, int closingPosition) {
+    registerCodePosition(
+        node, new CodePosition(startPosition, endPosition, closingPosition));
   }
 
   void registerCodePosition(js.Node node, CodePosition codePosition) {
     _codePositionMap[node] = codePosition;
   }
 
   CodePosition operator [](js.Node node) => _codePositionMap[node];
 }
 
 /// Enum values for the part of a Dart node used for the source location offset.
@@ skipping 23 matching lines @@
   /// For function expressions the inner position is the closing brace or the
   /// arrow:
   ///
   ///     foo() => () {}
   ///           ^                 // the inner position of the 'foo' function
   ///                  ^          // the inner position of the closure
   ///
   INNER,
 }
 
-SourceLocation getSourceLocation(
-    SourceInformation sourceInformation,
+SourceLocation getSourceLocation(SourceInformation sourceInformation,
     [SourcePositionKind sourcePositionKind = SourcePositionKind.START]) {
   if (sourceInformation == null) return null;
   switch (sourcePositionKind) {
     case SourcePositionKind.START:
       return sourceInformation.startPosition;
     case SourcePositionKind.INNER:
       return sourceInformation.closingPosition;
   }
 }
 
@@ skipping 31 matching lines @@
   END,
 }
 
 /// Processor that associates [SourceLocation]s from [SourceInformation] on
 /// [js.Node]s with the target offsets in a [SourceMapper].
 class PositionSourceInformationProcessor implements SourceInformationProcessor {
   final CodePositionRecorder codePositionRecorder = new CodePositionRecorder();
   CodePositionMap codePositionMap;
   List<TraceListener> traceListeners;
 
-  PositionSourceInformationProcessor(
-      SourceMapper sourceMapper,
+  PositionSourceInformationProcessor(SourceMapper sourceMapper,
       [Coverage coverage]) {
     codePositionMap = coverage != null
-              ? new CodePositionCoverage(codePositionRecorder, coverage)
-              : codePositionRecorder;
+        ? new CodePositionCoverage(codePositionRecorder, coverage)
+        : codePositionRecorder;
     traceListeners = [new PositionTraceListener(sourceMapper)];
     if (coverage != null) {
       traceListeners.add(new CoverageListener(coverage));
     }
   }
 
   void process(js.Node node, CodeBuffer codeBuffer) {
     new JavaScriptTracer(codePositionMap, traceListeners).apply(node);
   }
 
   @override
-  void onPositions(js.Node node,
-                   int startPosition,
-                   int endPosition,
-                   int closingPosition) {
+  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();
 
@@ skipping 34 matching lines @@
     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 with
-    NodeToSourceInformationMixin {
+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;
@@ skipping 60 matching lines @@
           pureAccess = true;
           break;
         } else {
           target = targetAccess.receiver;
         }
       }
       if (pureAccess) {
         // a.m()   this.m()  a.b.c.d.m()
         // ^       ^         ^
         return new CallPosition(
-            node,
-            CodePositionKind.START,
-            SourcePositionKind.START);
+            node, CodePositionKind.START, SourcePositionKind.START);
       } else {
         // *.m()  *.a.b.c.d.m()
         //   ^              ^
         return new CallPosition(
-            access.selector,
-            CodePositionKind.START,
-            SourcePositionKind.INNER);
+            access.selector, CodePositionKind.START, SourcePositionKind.INNER);
       }
     } else if (node.target is js.VariableUse) {
       // m()
       // ^
       return new CallPosition(
-          node,
-          CodePositionKind.START,
-          SourcePositionKind.START);
+          node, CodePositionKind.START, SourcePositionKind.START);
     } else if (node.target is js.Fun || node.target is js.New) {
       // function(){}()  new Function("...")()
       //             ^                      ^
       return new CallPosition(
-          node.target,
-          CodePositionKind.END,
-          SourcePositionKind.INNER);
+          node.target, CodePositionKind.END, SourcePositionKind.INNER);
     } else if (node.target is js.Binary || node.target is js.Call) {
       // (0,a)()   m()()
       //      ^       ^
       return new CallPosition(
-          node.target,
-          CodePositionKind.END,
-          SourcePositionKind.INNER);
+          node.target, CodePositionKind.END, SourcePositionKind.INNER);
     } else {
       assert(invariant(NO_LOCATION_SPANNABLE, false,
           message: "Unexpected property access ${nodeToString(node)}:\n"
-                   "${DebugPrinter.prettyPrint(node)}"));
+              "${DebugPrinter.prettyPrint(node)}"));
       // Don't know....
       return new CallPosition(
-          node,
-          CodePositionKind.START,
-          SourcePositionKind.START);
+          node, CodePositionKind.START, SourcePositionKind.START);
     }
   }
 }
 
 class Offset {
   /// The offset of the enclosing statement relative to the beginning of the
   /// file.
   ///
   /// For instance:
   ///
@@ skipping 30 matching lines @@
   ///     foo().bar(baz());
   ///     ^                   // the left-to-right offset of the `foo()` call
   ///           ^             // the left-to-right offset of the `*.bar()` call
   ///     ^                   // the left-to-right offset of the `baz()` call
   ///
   /// Here, `baz()` is executed before `foo()` so we need to use 'f' as its best
   /// position under the restriction.
   ///
   final int leftToRightOffset;
 
-  Offset(this.statementOffset, this.leftToRightOffset, this.subexpressionOffset);
+  Offset(
+      this.statementOffset, this.leftToRightOffset, this.subexpressionOffset);
 
   String toString() {
     return 'Offset[statementOffset=$statementOffset,'
         'leftToRightOffset=$leftToRightOffset,'
         'subexpressionOffset=$subexpressionOffset]';
   }
 }
 
-enum BranchKind {
-  CONDITION,
-  LOOP,
-  CATCH,
-  FINALLY,
-  CASE,
-}
+enum BranchKind { CONDITION, LOOP, CATCH, FINALLY, CASE, }
 
 enum StepKind {
   FUN_ENTRY,
   FUN_EXIT,
   CALL,
   NEW,
   RETURN,
   BREAK,
   CONTINUE,
   THROW,
@@ skipping 23 matching lines @@
   /// Called when the current branch ends.
   void popBranch() {}
 
   /// Called when [node] defines a step of the given [kind] at the given
   /// [offset] when the generated JavaScript code.
   void onStep(js.Node node, Offset offset, StepKind kind) {}
 }
 
 /// Visitor that computes the [js.Node]s the are part of the JavaScript
 /// steppable execution and thus needs source mapping locations.
-class JavaScriptTracer extends js.BaseVisitor  {
+class JavaScriptTracer extends js.BaseVisitor {
   final CodePositionMap codePositions;
   final List<TraceListener> listeners;
 
   /// The steps added by subexpressions.
   List steps = [];
 
   /// The offset of the current statement.
   int statementOffset;
 
   /// The current offset in left-to-right progression.
   int leftToRightOffset;
 
   /// The offset of the surrounding statement, used for the first subexpression.
   int offsetPosition;
 
   bool active;
 
-  JavaScriptTracer(this.codePositions,
-           this.listeners,
-           {this.active: false});
+  JavaScriptTracer(this.codePositions, this.listeners, {this.active: false});
 
   void notifyStart(js.Node node) {
     listeners.forEach((listener) => listener.onStart(node));
   }
 
   void notifyEnd(js.Node node) {
     listeners.forEach((listener) => listener.onEnd(node));
   }
 
   void notifyPushBranch(BranchKind kind, [value]) {
@@ skipping 44 matching lines @@
       }
     }
   }
 
   @override
   visitFun(js.Fun node) {
     bool activeBefore = active;
     if (!active) {
       active = node.sourceInformation != null;
     }
-    leftToRightOffset = statementOffset =
-        getSyntaxOffset(node, kind: CodePositionKind.START);
+    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);
+    leftToRightOffset =
+        statementOffset = getSyntaxOffset(node, kind: CodePositionKind.CLOSING);
     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);
     }
   }
 
   int getSyntaxOffset(js.Node node,
-                      {CodePositionKind kind: CodePositionKind.START}) {
+      {CodePositionKind kind: CodePositionKind.START}) {
     CodePosition codePosition = codePositions[node];
     if (codePosition != null) {
       return codePosition.getPosition(kind);
     }
     return null;
   }
 
-  visitSubexpression(js.Node parent,
-                     js.Expression child,
-                     int codeOffset,
-                     StepKind kind) {
+  visitSubexpression(
+      js.Node parent, js.Expression child, int codeOffset, StepKind kind) {
     var oldSteps = steps;
     steps = [];
     offsetPosition = codeOffset;
     visit(child);
     if (steps.isEmpty) {
-      notifyStep(parent,
-          getOffsetForNode(parent, offsetPosition),
-          kind);
+      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);
+        node, node.expression, statementOffset, StepKind.EXPRESSION_STATEMENT);
     statementOffset = null;
     leftToRightOffset = null;
   }
 
   @override
   visitEmptyStatement(js.EmptyStatement node) {}
 
   @override
   visitCall(js.Call node) {
     visit(node.target);
     int oldPosition = offsetPosition;
     offsetPosition = null;
     visitList(node.arguments);
     offsetPosition = oldPosition;
-    CallPosition callPosition =
-        CallPosition.getSemanticPositionForCall(node);
+    CallPosition callPosition = CallPosition.getSemanticPositionForCall(node);
     js.Node positionNode = callPosition.node;
-    int callOffset = getSyntaxOffset(
-        positionNode, kind: callPosition.codePositionKind);
+    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, offsetPosition), StepKind.NEW);
+    notifyStep(node, getOffsetForNode(node, offsetPosition), StepKind.NEW);
     steps.add(node);
     offsetPosition = null;
   }
 
   @override
   visitAccess(js.PropertyAccess node) {
     visit(node.receiver);
     visit(node.selector);
   }
 
@@ skipping 31 matching lines @@
 
   @override
   visitAssignment(js.Assignment node) {
     visit(node.leftHandSide);
     visit(node.value);
   }
 
   @override
   visitIf(js.If node) {
     statementOffset = getSyntaxOffset(node);
-    visitSubexpression(node, node.condition, statementOffset,
-        StepKind.IF_CONDITION);
+    visitSubexpression(
+        node, node.condition, statementOffset, StepKind.IF_CONDITION);
     statementOffset = null;
     visit(node.then, BranchKind.CONDITION, true);
     visit(node.otherwise, BranchKind.CONDITION, false);
   }
 
   @override
   visitFor(js.For node) {
     int offset = statementOffset = getSyntaxOffset(node);
     statementOffset = offset;
     leftToRightOffset = null;
     if (node.init != null) {
-      visitSubexpression(node, node.init, getSyntaxOffset(node),
-          StepKind.FOR_INITIALIZER);
+      visitSubexpression(
+          node, node.init, getSyntaxOffset(node), StepKind.FOR_INITIALIZER);
     }
 
     if (node.condition != null) {
       visitSubexpression(node, node.condition, getSyntaxOffset(node.condition),
           StepKind.FOR_CONDITION);
     }
 
     notifyPushBranch(BranchKind.LOOP);
     visit(node.body);
 
     statementOffset = offset;
     if (node.update != null) {
-      visitSubexpression(node, node.update, getSyntaxOffset(node.update),
-          StepKind.FOR_UPDATE);
+      visitSubexpression(
+          node, node.update, getSyntaxOffset(node.update), StepKind.FOR_UPDATE);
     }
 
     notifyPopBranch();
   }
 
   @override
   visitWhile(js.While node) {
     statementOffset = getSyntaxOffset(node);
     if (node.condition != null) {
       visitSubexpression(node, node.condition, getSyntaxOffset(node),
@@ skipping 105 matching lines @@
     visit(node.name);
     visit(node.value);
   }
 
   @override
   visitRegExpLiteral(js.RegExpLiteral node) {}
 
   @override
   visitSwitch(js.Switch node) {
     statementOffset = getSyntaxOffset(node);
-    visitSubexpression(node, node.key, getSyntaxOffset(node),
-        StepKind.SWITCH_EXPRESSION);
+    visitSubexpression(
+        node, node.key, getSyntaxOffset(node), StepKind.SWITCH_EXPRESSION);
     statementOffset = null;
     leftToRightOffset = null;
     for (int i = 0; i < node.cases.length; i++) {
       visit(node.cases[i], BranchKind.CASE, i);
     }
   }
 
   @override
   visitCase(js.Case node) {
     visit(node.expression);
@@ skipping 30 matching lines @@
     if (leftToRightOffset != null && leftToRightOffset < codeOffset) {
       leftToRightOffset = codeOffset;
     }
     if (leftToRightOffset == null) {
       leftToRightOffset = statementOffset;
     }
     return new Offset(statementOffset, leftToRightOffset, codeOffset);
   }
 }
 
-
 class Coverage {
   Set<js.Node> _nodesWithInfo = new Set<js.Node>();
   int _nodesWithInfoCount = 0;
   Set<js.Node> _nodesWithoutInfo = new Set<js.Node>();
   int _nodesWithoutInfoCount = 0;
   Map<Type, int> _nodesWithoutInfoCountByType = <Type, int>{};
   Set<js.Node> _nodesWithoutOffset = new Set<js.Node>();
   int _nodesWithoutOffsetCount = 0;
 
   void registerNodeWithInfo(js.Node node) {
@@ skipping 14 matching lines @@
     _nodesWithoutOffsetCount += _nodesWithoutOffset.length;
     _nodesWithoutOffset.clear();
 
     _nodesWithoutInfoCount += _nodesWithoutInfo.length;
     for (js.Node node in _nodesWithoutInfo) {
       if (node is js.ExpressionStatement) {
         _nodesWithoutInfoCountByType.putIfAbsent(
             node.expression.runtimeType, () => 0);
         _nodesWithoutInfoCountByType[node.expression.runtimeType]++;
       } else {
-        _nodesWithoutInfoCountByType.putIfAbsent(
-            node.runtimeType, () => 0);
+        _nodesWithoutInfoCountByType.putIfAbsent(node.runtimeType, () => 0);
         _nodesWithoutInfoCountByType[node.runtimeType]++;
       }
     }
     _nodesWithoutInfo.clear();
   }
 
   String getCoverageReport() {
     collapse();
     StringBuffer sb = new StringBuffer();
     int total = _nodesWithInfoCount + _nodesWithoutInfoCount;
@@ skipping 15 matching lines @@
         sb.write('s');
       }
       sb.write(' without offset.');
     }
     if (_nodesWithoutInfoCount > 0) {
       sb.write('\nNodes without info (');
       sb.write(_nodesWithoutInfoCount);
       sb.write(') by runtime type:');
       List<Type> types = _nodesWithoutInfoCountByType.keys.toList();
       types.sort((a, b) {
-        return -_nodesWithoutInfoCountByType[a].compareTo(
-            _nodesWithoutInfoCountByType[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) {
@@ skipping 35 matching lines @@
   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;
   }
-}
+}