Non-format-changing kernel offset changes

pkg/kernel/lib/text/ast_to_text.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.ast_to_text;
 
 import '../ast.dart';
 import '../import_table.dart';
 import '../type_propagation/type_propagation.dart';
 
 class Namer<T> {
@@ skipping 163 matching lines @@
 
 /// A quick and dirty ambiguous text printer.
 class Printer extends Visitor<Null> {
   final NameSystem syntheticNames;
   final StringSink sink;
   final Annotator annotator;
   ImportTable importTable;
   int indentation = 0;
   int column = 0;
   bool showExternal;
+  bool showOffsets;
 
   static int SPACE = 0;
   static int WORD = 1;
   static int SYMBOL = 2;
   int state = SPACE;
 
   Printer(this.sink,
       {NameSystem syntheticNames,
       this.showExternal,
+      this.showOffsets,
       this.importTable,
       this.annotator: const InferredValueAnnotator()})
       : this.syntheticNames = syntheticNames ?? new NameSystem();
 
   Printer._inner(Printer parent, this.importTable)
       : sink = parent.sink,
         syntheticNames = parent.syntheticNames,
         annotator = parent.annotator,
-        showExternal = parent.showExternal;
+        showExternal = parent.showExternal,
+        showOffsets = parent.showOffsets;
 
   String getLibraryName(Library node) {
     return node.name ?? syntheticNames.nameLibrary(node);
   }
 
   String getLibraryReference(Library node) {
     if (node == null) return '<No Library>';
     if (importTable != null && importTable.getImportIndex(node) != -1) {
       return syntheticNames.nameLibraryPrefix(node);
     }
@@ skipping 174 matching lines @@
     if (state == WORD) {
       writeSpace();
     }
   }
 
   void writeIndentation() {
     writeSpace('  ' * indentation);
   }
 
   void writeNode(Node node) {
+    if (showOffsets && node is TreeNode) {
+      writeWord("[${node.fileOffset}]");
+    }
     node.accept(this);
   }
 
   void writeOptionalNode(Node node) {
     if (node != null) {
       node.accept(this);
     }
   }
 
   void writeAnnotatedType(DartType type, String annotation) {
@@ skipping 73 matching lines @@
       endLine();
       ++indentation;
       writeIndentation();
       writeComma(':');
       writeList(initializers, writeNode);
       --indentation;
     }
     if (function.asyncMarker != AsyncMarker.Sync) {
       writeSpaced(getAsyncMarkerKeyword(function.asyncMarker));
     }
+    if (!function.debuggable) writeSpaced("/* not debuggable */");
     if (function.body != null) {
       writeFunctionBody(function.body, terminateLine: terminateLine);
     } else if (terminateLine) {
       endLine(';');
     }
   }
 
   String getAsyncMarkerKeyword(AsyncMarker marker) {
     switch (marker) {
       case AsyncMarker.Sync:
@@ skipping 120 matching lines @@
 
   void writeVariableReference(VariableDeclaration variable) {
     writeWord(getVariableReference(variable));
   }
 
   void writeTypeParameterReference(TypeParameter node) {
     writeWord(getTypeParameterReference(node));
   }
 
   void writeExpression(Expression node, [int minimumPrecedence]) {
+    if (showOffsets) writeWord("[${node.fileOffset}]");
     bool needsParenteses = false;
     if (minimumPrecedence != null && getPrecedence(node) < minimumPrecedence) {
       needsParenteses = true;
       writeSymbol('(');
     }
     writeNode(node);
     if (needsParenteses) {
       writeSymbol(')');
     }
   }
@@ skipping 641 matching lines @@
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     writeIndentation();
     writeWord('function');
     writeFunction(node.function, name: getVariableName(node.variable));
   }
 
   void writeVariableDeclaration(VariableDeclaration node,
       {bool useVarKeyword: false}) {
+    if (showOffsets) writeWord("[${node.fileOffset}]");
     writeModifier(node.isFinal, 'final');
     writeModifier(node.isConst, 'const');
     if (node.type != null) {
       writeAnnotatedType(node.type, annotator?.annotateVariable(this, node));
     }
     if (useVarKeyword && !node.isFinal && !node.isConst && node.type == null) {
       writeWord('var');
     }
     writeWord(getVariableName(node));
     if (node.initializer != null) {
@@ skipping 235 matching lines @@
   }
   throw 'illegal ProcedureKind: $kind';
 }
 
 class ExpressionPrinter {
   final Printer writeer;
   final int minimumPrecedence;
 
   ExpressionPrinter(this.writeer, this.minimumPrecedence);
 }