Non-format-changing kernel offset changes

pkg/kernel/lib/transformations/continuation.dart

 // Copyright (c) 2016, 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.
 
 library kernel.transformations.continuation;
 
 import 'dart:math' as math;
 
 import '../ast.dart';
 import '../visitor.dart';
@@ skipping 107 matching lines @@
       : super(helper, enclosingFunction);
 
   FunctionNode rewrite() {
     // :sync_body(:iterator) {
     //     modified <node.body>;
     // }
     final nestedClosureVariable = new VariableDeclaration(":sync_op");
     final function = new FunctionNode(buildClosureBody(),
         positionalParameters: [iteratorVariable],
         requiredParameterCount: 1,
-        asyncMarker: AsyncMarker.SyncYielding);
+        asyncMarker: AsyncMarker.SyncYielding)
+      ..fileOffset = enclosingFunction.fileOffset
+      ..fileEndOffset = enclosingFunction.fileEndOffset;
     final closureFunction =
-        new FunctionDeclaration(nestedClosureVariable, function);
+        new FunctionDeclaration(nestedClosureVariable, function)
+          ..fileOffset = enclosingFunction.parent.fileOffset;
 
     // return new _SyncIterable(:sync_body);
     final arguments = new Arguments([new VariableGet(nestedClosureVariable)]);
     final returnStatement = new ReturnStatement(
         new ConstructorInvocation(helper.syncIterableConstructor, arguments));
 
     enclosingFunction.body = new Block([]
       ..addAll(variableDeclarations())
       ..addAll([closureFunction, returnStatement]));
     enclosingFunction.body.parent = enclosingFunction;
@@ skipping 61 matching lines @@
     //     modified <node.body>;
     // }
     final parameters = <VariableDeclaration>[
       expressionRewriter.asyncResult,
       new VariableDeclaration(':exception'),
       new VariableDeclaration(':stack_trace'),
     ];
     final function = new FunctionNode(buildWrappedBody(),
         positionalParameters: parameters,
         requiredParameterCount: 0,
-        asyncMarker: AsyncMarker.SyncYielding);
+        asyncMarker: AsyncMarker.SyncYielding)
+      ..fileOffset = enclosingFunction.fileOffset
+      ..fileEndOffset = enclosingFunction.fileEndOffset;
 
     // The await expression lifter might have created a number of
     // [VariableDeclarations].
     // TODO(kustermann): If we didn't need any variables we should not emit
     // these.
     statements.addAll(variableDeclarations());
     statements.addAll(expressionRewriter.variables);
 
     // Now add the closure function itself.
     final closureFunction =
-        new FunctionDeclaration(nestedClosureVariable, function);
+        new FunctionDeclaration(nestedClosureVariable, function)
+          ..fileOffset = enclosingFunction.parent.fileOffset;
     statements.add(closureFunction);
 
     // :async_op_then = _asyncThenWrapperHelper(asyncBody);
     final boundThenClosure = new StaticInvocation(helper.asyncThenWrapper,
         new Arguments(<Expression>[new VariableGet(nestedClosureVariable)]));
     final thenClosureVariableAssign = new ExpressionStatement(
         new VariableSet(thenContinuationVariable, boundThenClosure));
     statements.add(thenClosureVariableAssign);
 
     // :async_op_error = _asyncErrorWrapperHelper(asyncBody);
@@ skipping 294 matching lines @@
       var iteratorVariable = new VariableDeclaration(':for-iterator',
           initializer: new ConstructorInvocation(
               helper.streamIteratorConstructor,
               new Arguments(<Expression>[stmt.iterable],
                   types: [const DynamicType()])));
 
       // await iterator.moveNext()
       var condition = new AwaitExpression(new MethodInvocation(
           new VariableGet(iteratorVariable),
           new Name('moveNext'),
-          new Arguments(<Expression>[])));
+          new Arguments(<Expression>[])))..fileOffset = stmt.fileOffset;
 
       // var <variable> = iterator.current;
       var valueVariable = stmt.variable;
       valueVariable.initializer = new PropertyGet(
           new VariableGet(iteratorVariable), new Name('current'));
       valueVariable.initializer.parent = valueVariable;
 
       var whileBody = new Block(<Statement>[valueVariable, stmt.body]);
       var tryBody = new WhileStatement(condition, whileBody);
 
@@ skipping 103 matching lines @@
 
     // var :controller;
     controllerVariable = new VariableDeclaration(":controller");
     statements.add(controllerVariable);
 
     setupAsyncContinuations(statements);
 
     // :controller = new _AsyncController(:async_op);
     var arguments =
         new Arguments(<Expression>[new VariableGet(nestedClosureVariable)]);
-    var buildController = new ConstructorInvocation(
-        helper.streamControllerConstructor, arguments);
+    var buildController =
+        new ConstructorInvocation(helper.streamControllerConstructor, arguments)
+          ..fileOffset = enclosingFunction.fileOffset;
     var setController = new ExpressionStatement(
         new VariableSet(controllerVariable, buildController));
     statements.add(setController);
 
     // return :controller.stream;
     var completerGet = new VariableGet(controllerVariable);
     var returnStatement = new ReturnStatement(
         new PropertyGet(completerGet, new Name('stream', helper.asyncLibrary)));
     statements.add(returnStatement);
 
@@ skipping 15 matching lines @@
 
   Statement buildReturn(Statement body) {
     // Async* functions cannot return a value.  The returns from the function
     // have been translated into breaks from the labeled body.
     return new Block(<Statement>[
       body,
       new ExpressionStatement(new MethodInvocation(
           new VariableGet(controllerVariable),
           new Name("close", helper.asyncLibrary),
           new Arguments(<Expression>[]))),
-      new ReturnStatement()
+      new ReturnStatement()..fileOffset = enclosingFunction.fileEndOffset
     ]);
   }
 
   TreeNode visitYieldStatement(YieldStatement stmt) {
     Expression expr = expressionRewriter.rewrite(stmt.expression, statements);
 
     var addExpression = new MethodInvocation(
         new VariableGet(controllerVariable),
         new Name(stmt.isYieldStar ? 'addStream' : 'add', helper.asyncLibrary),
-        new Arguments(<Expression>[expr]));
+        new Arguments(<Expression>[expr]))..fileOffset = stmt.fileOffset;
 
-    statements.add(new IfStatement(addExpression,
-        new ReturnStatement(new NullLiteral()), createContinuationPoint()));
+    statements.add(new IfStatement(
+        addExpression,
+        new ReturnStatement(new NullLiteral()),
+        createContinuationPoint()..fileOffset = stmt.fileOffset));
     return null;
   }
 
   TreeNode visitReturnStatement(ReturnStatement node) {
     // Async* functions cannot return a value.
     assert(node.expression == null || node.expression is NullLiteral);
     statements
         .add(new BreakStatement(labeledBody)..fileOffset = node.fileOffset);
     return null;
   }
 }
 
 class AsyncFunctionRewriter extends AsyncRewriterBase {
   VariableDeclaration completerVariable;
   VariableDeclaration returnVariable;
 
   AsyncFunctionRewriter(helper, enclosingFunction)
       : super(helper, enclosingFunction);
 
   FunctionNode rewrite() {
     var statements = <Statement>[];
 
     // var :completer = new Completer.sync();
     completerVariable = new VariableDeclaration(":completer",
         initializer: new StaticInvocation(helper.completerConstructor,
-            new Arguments([], types: [const DynamicType()])),
+            new Arguments([], types: [const DynamicType()]))
+          ..fileOffset = enclosingFunction.body.fileOffset,
         isFinal: true);
     statements.add(completerVariable);
 
     returnVariable = new VariableDeclaration(":return_value");
     statements.add(returnVariable);
 
     setupAsyncContinuations(statements);
 
     // new Future.microtask(:async_op);
     var newMicrotaskStatement = new ExpressionStatement(new StaticInvocation(
         helper.futureMicrotaskConstructor,
         new Arguments([new VariableGet(nestedClosureVariable)],
-            types: [const DynamicType()])));
+            types: [const DynamicType()]))
+      ..fileOffset = enclosingFunction.fileOffset);
     statements.add(newMicrotaskStatement);
 
     // return :completer.future;
     var completerGet = new VariableGet(completerVariable);
     var returnStatement = new ReturnStatement(
         new PropertyGet(completerGet, new Name('future', helper.asyncLibrary)));
     statements.add(returnStatement);
 
     enclosingFunction.body = new Block(statements);
     enclosingFunction.body.parent = enclosingFunction;
     enclosingFunction.asyncMarker = AsyncMarker.Sync;
+    enclosingFunction.debuggable = false;
     return enclosingFunction;
   }
 
   Statement buildCatchBody(exceptionVariable, stackTraceVariable) {
     return new ExpressionStatement(new MethodInvocation(
         new VariableGet(completerVariable),
         new Name("completeError", helper.asyncLibrary),
         new Arguments([
           new VariableGet(exceptionVariable),
           new VariableGet(stackTraceVariable)
         ])));
   }
 
   Statement buildReturn(Statement body) {
     // Returns from the body have all been translated into assignments to the
     // return value variable followed by a break from the labeled body.
     return new Block(<Statement>[
       body,
       new ExpressionStatement(new MethodInvocation(
           new VariableGet(completerVariable),
           new Name("complete", helper.asyncLibrary),
           new Arguments([new VariableGet(returnVariable)]))),
-      new ReturnStatement()
+      new ReturnStatement()..fileOffset = enclosingFunction.fileEndOffset
     ]);
   }
 
   visitReturnStatement(ReturnStatement node) {
     var expr = node.expression == null
         ? new NullLiteral()
         : expressionRewriter.rewrite(node.expression, statements);
     statements
         .add(new ExpressionStatement(new VariableSet(returnVariable, expr)));
     statements
@@ skipping 99 matching lines @@
         findFactoryConstructor(completerClass, 'sync'),
         findConstructor(syncIterableClass, ''),
         findConstructor(streamIteratorClass, ''),
         findFactoryConstructor(futureClass, 'microtask'),
         findConstructor(streamControllerClass, ''),
         findProcedure(asyncLibrary, '_asyncThenWrapperHelper'),
         findProcedure(asyncLibrary, '_asyncErrorWrapperHelper'),
         findProcedure(asyncLibrary, '_awaitHelper'));
   }
 }