dartfmt pkg/compiler

pkg/compiler/lib/src/dart_backend/backend_ast_nodes.dart

 // Copyright (c) 2014, 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 backend_ast_nodes;
 
 import '../constants/values.dart' as values;
 import '../dart_types.dart' as types;
 import '../elements/elements.dart' as elements;
 import '../tree/tree.dart' as tree;
@@ skipping 50 matching lines @@
   final String name;
   final List<TypeAnnotation> typeArguments;
 
   types.DartType dartType;
 
   TypeAnnotation(this.name, [this.typeArguments = const <TypeAnnotation>[]]);
 }
 
 // STATEMENTS
 
-
 class Block extends Statement {
   final List<Statement> statements;
 
   Block(this.statements);
 }
 
 class Break extends Statement {
   final String label;
 
   Break([this.label]);
@@ skipping 19 matching lines @@
 }
 
 class For extends Statement {
   final Node initializer;
   final Expression condition;
   final List<Expression> updates;
   final Statement body;
 
   /// Initializer must be [VariableDeclarations] or [Expression] or null.
   For(this.initializer, this.condition, this.updates, this.body) {
-    assert(initializer == null
-        || initializer is VariableDeclarations
-        || initializer is Expression);
+    assert(initializer == null ||
+        initializer is VariableDeclarations ||
+        initializer is Expression);
   }
 }
 
 class ForIn extends Statement {
   final Node leftHandValue;
   final Expression expression;
   final Statement body;
 
   /// [leftHandValue] must be [Identifier] or [VariableDeclarations] with
   /// exactly one definition, and that variable definition must have no
   /// initializer.
   ForIn(Node leftHandValue, this.expression, this.body)
       : this.leftHandValue = leftHandValue {
-    assert(leftHandValue is Identifier
-        || (leftHandValue is VariableDeclarations
-            && leftHandValue.declarations.length == 1
-            && leftHandValue.declarations[0].initializer == null));
+    assert(leftHandValue is Identifier ||
+        (leftHandValue is VariableDeclarations &&
+            leftHandValue.declarations.length == 1 &&
+            leftHandValue.declarations[0].initializer == null));
   }
 }
 
 class While extends Statement {
   final Expression condition;
   final Statement body;
 
   While(this.condition, this.body);
 }
 
@@ skipping 12 matching lines @@
   If(this.condition, this.thenStatement, [this.elseStatement]);
 }
 
 class LabeledStatement extends Statement {
   final String label;
   final Statement statement;
 
   LabeledStatement(this.label, this.statement);
 }
 
-class Rethrow extends Statement {
-}
+class Rethrow extends Statement {}
 
 class Return extends Statement {
   final Expression expression;
 
   Return([this.expression]);
 }
 
 class Switch extends Statement {
   final Expression expression;
   final List<SwitchCase> cases;
@@ skipping 47 matching lines @@
   }
 }
 
 class VariableDeclarations extends Statement {
   final TypeAnnotation type;
   final bool isFinal;
   final bool isConst;
   final List<VariableDeclaration> declarations;
 
   VariableDeclarations(this.declarations,
-                      { this.type,
-                        this.isFinal: false,
-                        this.isConst: false }) {
+      {this.type, this.isFinal: false, this.isConst: false}) {
     // Cannot be both final and const.
     assert(!isFinal || !isConst);
   }
 }
 
 class VariableDeclaration extends Node {
   final String name;
   final Expression initializer;
 
   elements.Element element;
 
   VariableDeclaration(this.name, [this.initializer]);
 }
 
-
 class FunctionDeclaration extends Statement {
   final FunctionExpression function;
 
   TypeAnnotation get returnType => function.returnType;
   Parameters get parameters => function.parameters;
   String get name => function.name;
   Statement get body => function.body;
 
   FunctionDeclaration(this.function);
 }
 
 class Parameters extends Node {
   final List<Parameter> requiredParameters;
   final List<Parameter> optionalParameters;
   final bool hasNamedParameters;
 
   Parameters(this.requiredParameters,
-             [ this.optionalParameters,
-               this.hasNamedParameters = false ]);
+      [this.optionalParameters, this.hasNamedParameters = false]);
 
   Parameters.named(this.requiredParameters, this.optionalParameters)
       : hasNamedParameters = true;
 
   Parameters.positional(this.requiredParameters, this.optionalParameters)
-        : hasNamedParameters = false;
+      : hasNamedParameters = false;
 
   bool get hasOptionalParameters =>
       optionalParameters != null && optionalParameters.length > 0;
 }
 
 class Parameter extends Node {
   final String name;
 
   /// Type of parameter, or return type of function parameter.
   final TypeAnnotation type;
 
   Expression defaultValue;
 
   /// Parameters to function parameter. Null for non-function parameters.
   final Parameters parameters;
 
   elements.FormalElement element;
 
-  Parameter(this.name, {this.type, this.defaultValue})
-      : parameters = null;
+  Parameter(this.name, {this.type, this.defaultValue}) : parameters = null;
 
-  Parameter.function(this.name,
-                     TypeAnnotation returnType,
-                     this.parameters,
-                     [ this.defaultValue ]) : type = returnType {
+  Parameter.function(this.name, TypeAnnotation returnType, this.parameters,
+      [this.defaultValue])
+      : type = returnType {
     assert(parameters != null);
   }
 
   /// True if this is a function parameter.
   bool get isFunction => parameters != null;
 }
 
 // EXPRESSIONS
 
 abstract class Initializer extends Expression {}
@@ skipping 15 matching lines @@
 class FunctionExpression extends Expression implements RootNode {
   final TypeAnnotation returnType;
   String name;
   final Parameters parameters;
   final Statement body;
   final bool isGetter;
   final bool isSetter;
 
   elements.FunctionElement element;
 
-  FunctionExpression(this.parameters,
-                     this.body,
-                     { this.name,
-                       this.returnType,
-                       this.isGetter: false,
-                       this.isSetter: false }) {
+  FunctionExpression(this.parameters, this.body,
+      {this.name,
+      this.returnType,
+      this.isGetter: false,
+      this.isSetter: false}) {
     // Function must have a name if it has a return type
     assert(returnType == null || name != null);
   }
 }
 
 class ConstructorDefinition extends FunctionExpression {
   final List<Initializer> initializers;
   final bool isConst;
 
   ConstructorDefinition(Parameters parameters, Statement body,
-                        this.initializers, String name, this.isConst)
+      this.initializers, String name, this.isConst)
       : super(parameters, body, name: name);
 }
 
 class Conditional extends Expression {
   final Expression condition;
   final Expression thenExpression;
   final Expression elseExpression;
 
   Conditional(this.condition, this.thenExpression, this.elseExpression);
 }
@@ skipping 20 matching lines @@
   final values.PrimitiveConstantValue value;
 
   Literal(this.value);
 }
 
 class LiteralList extends Expression {
   final bool isConst;
   final TypeAnnotation typeArgument;
   final List<Expression> values;
 
-  LiteralList(this.values, { this.typeArgument, this.isConst: false });
+  LiteralList(this.values, {this.typeArgument, this.isConst: false});
 }
 
 class LiteralMap extends Expression {
   final bool isConst;
   final List<TypeAnnotation> typeArguments;
   final List<LiteralMapEntry> entries;
 
-  LiteralMap(this.entries, { this.typeArguments, this.isConst: false }) {
-    assert(this.typeArguments == null
-        || this.typeArguments.length == 0
-        || this.typeArguments.length == 2);
+  LiteralMap(this.entries, {this.typeArguments, this.isConst: false}) {
+    assert(this.typeArguments == null ||
+        this.typeArguments.length == 0 ||
+        this.typeArguments.length == 2);
   }
 }
 
 class LiteralMapEntry extends Node {
   final Expression key;
   final Expression value;
 
   LiteralMapEntry(this.key, this.value);
 }
 
@@ skipping 83 matching lines @@
 /// or `const T.f(..)`.
 class CallNew extends Expression {
   final bool isConst;
   final TypeAnnotation type;
   final String constructorName;
   final List<Argument> arguments;
 
   elements.FunctionElement constructor;
   types.DartType dartType;
 
-  CallNew(this.type,
-          this.arguments,
-         { this.constructorName,
-           this.isConst: false });
+  CallNew(this.type, this.arguments,
+      {this.constructorName, this.isConst: false});
 }
 
 /// Expression of form `T.f(..)`.
 class CallStatic extends Expression {
   final String className;
   final String methodName;
   final List<Argument> arguments;
 
   elements.Element element;
 
@@ skipping 22 matching lines @@
   }
 }
 
 /// Expression of form `e is T` or `e is! T` or `e as T`.
 class TypeOperator extends Expression {
   final Expression expression;
   final String operator;
   final TypeAnnotation type;
 
   TypeOperator(this.expression, this.operator, this.type) {
-    assert(operator == 'is'
-        || operator == 'as'
-        || operator == 'is!');
+    assert(operator == 'is' || operator == 'as' || operator == 'is!');
   }
 }
 
 class Increment extends Expression {
   final Expression expression;
   final String operator;
   final bool isPrefix;
 
   Increment(this.expression, this.operator, this.isPrefix) {
     assert(operator == '++' || operator == '--');
     assert(expression.assignable);
   }
 
   Increment.prefix(Expression expression, String operator)
       : this(expression, operator, true);
 
   Increment.postfix(Expression expression, String operator)
       : this(expression, operator, false);
 }
 
 class Assignment extends Expression {
-  static final _operators =
-      new Set.from(['=', '|=', '^=', '&=', '<<=', '>>=',
-                    '+=', '-=', '*=', '/=', '%=', '~/=']);
+  static final _operators = new Set.from([
+    '=',
+    '|=',
+    '^=',
+    '&=',
+    '<<=',
+    '>>=',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '%=',
+    '~/='
+  ]);
 
   final Expression left;
   final String operator;
   final Expression right;
 
   Assignment(this.left, this.operator, this.right) {
     assert(_operators.contains(operator));
     assert(left.assignable);
   }
 }
 
 class Throw extends Expression {
   final Expression expression;
 
   Throw(this.expression);
 }
 
 class This extends Expression {
   static final This _instance = new This._create();
 
   factory This() => _instance;
   This._create();
 }
 
 // UNPARSER
 
 bool isUnaryOperator(String op) {
   return op == '!' || op == '-' || op == '~';
 }
+
 bool isBinaryOperator(String op) {
   return BINARY_PRECEDENCE.containsKey(op);
 }
+
 /// True if the given operator can be converted to a compound assignment.
 bool isCompoundableOperator(String op) {
   switch (BINARY_PRECEDENCE[op]) {
     case BITWISE_OR:
     case BITWISE_XOR:
     case BITWISE_AND:
     case SHIFT:
     case ADDITIVE:
     case MULTIPLICATIVE:
       return true;
     default:
       return false;
   }
 }
 
-
 // Precedence levels
 const int EXPRESSION = 1;
 const int CONDITIONAL = 2;
 const int LOGICAL_OR = 3;
 const int LOGICAL_AND = 4;
 const int EQUALITY = 6;
 const int RELATIONAL = 7;
 const int BITWISE_OR = 8;
 const int BITWISE_XOR = 9;
 const int BITWISE_AND = 10;
 const int SHIFT = 11;
 const int ADDITIVE = 12;
 const int MULTIPLICATIVE = 13;
 const int UNARY = 14;
 const int POSTFIX_INCREMENT = 15;
 const int TYPE_LITERAL = 19;
 const int PRIMARY = 20;
 
 /// Precedence level required for the callee in a [FunctionCall].
 const int CALLEE = 21;
 
-const Map<String,int> BINARY_PRECEDENCE = const {
+const Map<String, int> BINARY_PRECEDENCE = const {
   '&&': LOGICAL_AND,
   '||': LOGICAL_OR,
-
   '==': EQUALITY,
   '!=': EQUALITY,
-
   '>': RELATIONAL,
   '>=': RELATIONAL,
   '<': RELATIONAL,
   '<=': RELATIONAL,
-
   '|': BITWISE_OR,
   '^': BITWISE_XOR,
   '&': BITWISE_AND,
-
   '>>': SHIFT,
   '<<': SHIFT,
-
   '+': ADDITIVE,
   '-': ADDITIVE,
-
   '*': MULTIPLICATIVE,
   '%': MULTIPLICATIVE,
   '/': MULTIPLICATIVE,
   '~/': MULTIPLICATIVE,
 };
 
 /// Return true if binary operators with the given precedence level are
 /// (left) associative. False if they are non-associative.
 bool isAssociativeBinaryOperator(int precedence) {
   return precedence != EQUALITY && precedence != RELATIONAL;
 }
 
 /// True if [x] is a letter, digit, or underscore.
 /// Such characters may not follow a shorthand string interpolation.
 bool isIdentifierPartNoDollar(dynamic x) {
   if (x is! int) {
     return false;
   }
   return (characters.$0 <= x && x <= characters.$9) ||
-         (characters.$A <= x && x <= characters.$Z) ||
-         (characters.$a <= x && x <= characters.$z) ||
-         (x == characters.$_);
+      (characters.$A <= x && x <= characters.$Z) ||
+      (characters.$a <= x && x <= characters.$z) ||
+      (x == characters.$_);
 }
 
 /// The unparser will apply the following syntactic rewritings:
 ///   Use short-hand function returns:
 ///     foo(){return E} ==> foo() => E;
 ///   Remove empty else branch:
 ///     if (E) S else ; ==> if (E) S
 ///   Flatten nested blocks:
 ///     {S; {S; S}; S} ==> {S; S; S; S}
 ///   Remove empty statements from block:
@@ skipping 17 matching lines @@
 ///
 /// The following transformations might be applied here in the future:
 ///   Use implicit dynamic types:
 ///     dynamic x = E ==> var x = E
 ///     <dynamic>[]   ==> []
 class Unparser {
   StringSink output;
 
   Unparser(this.output);
 
-
   void write(String s) {
     output.write(s);
   }
 
   /// Outputs each element from [items] separated by [separator].
   /// The actual printing must be performed by the [callback].
   void writeEach(String separator, Iterable items, void callback(any)) {
     bool first = true;
     for (var x in items) {
       if (first) {
@@ skipping 38 matching lines @@
 
   /// Prints the expression [e].
   void writeExpression(Expression e) {
     writeExp(e, EXPRESSION);
   }
 
   /// Prints [e] as an expression with precedence of at least [minPrecedence],
   /// using parentheses if necessary to raise the precedence level.
   /// Abusing terminology slightly, the function accepts a [Receiver] which
   /// may also be the [SuperReceiver] object.
-  void writeExp(Receiver e, int minPrecedence, {beginStmt:false}) {
+  void writeExp(Receiver e, int minPrecedence, {beginStmt: false}) {
     void withPrecedence(int actual, void action()) {
       if (actual < minPrecedence) {
         write("(");
         beginStmt = false;
         action();
         write(")");
       } else {
         action();
       }
     }
@@ skipping 35 matching lines @@
         write(' ? ');
         writeExp(e.thenExpression, EXPRESSION);
         write(' : ');
         writeExp(e.elseExpression, EXPRESSION);
       });
     } else if (e is Identifier) {
       write(e.name);
     } else if (e is Literal) {
       if (e.value.isString) {
         writeStringLiteral(e);
-      }
-      else if (e.value.isDouble) {
+      } else if (e.value.isDouble) {
         double v = e.value.primitiveValue;
         if (v == double.INFINITY) {
           withPrecedence(MULTIPLICATIVE, () {
             write('1/0.0');
           });
         } else if (v == double.NEGATIVE_INFINITY) {
           withPrecedence(MULTIPLICATIVE, () {
             write('-1/0.0');
           });
         } else if (v.isNaN) {
@@ skipping 11 matching lines @@
         write(' const ');
       }
       if (e.typeArgument != null) {
         write('<');
         writeType(e.typeArgument);
         write('>');
       }
       write('[');
       writeEach(',', e.values, writeExpression);
       write(']');
-    }
-    else if (e is LiteralMap) {
+    } else if (e is LiteralMap) {
       // The curly brace can be mistaken for a block statement if we
       // are at the beginning of a statement.
       bool needParen = beginStmt;
       if (e.isConst) {
         write(' const ');
         needParen = false;
       }
       if (e.typeArguments.length > 0) {
         write('<');
         writeEach(',', e.typeArguments, writeType);
@@ skipping 23 matching lines @@
     } else if (e is ReifyTypeVar) {
       withPrecedence(PRIMARY, () {
         write(e.name);
       });
     } else if (e is StringConcat) {
       writeStringLiteral(e);
     } else if (e is UnaryOperator) {
       Receiver operand = e.operand;
       // !(x == y) ==> x != y.
       if (e.operatorName == '!' &&
-          operand is BinaryOperator && operand.operator == '==') {
+          operand is BinaryOperator &&
+          operand.operator == '==') {
         withPrecedence(EQUALITY, () {
           writeExp(operand.left, RELATIONAL);
           writeOperator('!=');
           writeExp(operand.right, RELATIONAL);
         });
       }
       // !(x is T) ==> x is!T
       else if (e.operatorName == '!' &&
-          operand is TypeOperator && operand.operator == 'is') {
+          operand is TypeOperator &&
+          operand.operator == 'is') {
         withPrecedence(RELATIONAL, () {
           writeExp(operand.expression, BITWISE_OR, beginStmt: beginStmt);
           write(' is!');
           writeType(operand.type);
         });
-      }
-      else {
+      } else {
         withPrecedence(UNARY, () {
           writeOperator(e.operatorName);
           writeExp(e.operand, UNARY);
         });
       }
     } else if (e is BinaryOperator) {
       int precedence = BINARY_PRECEDENCE[e.operator];
       withPrecedence(precedence, () {
         // All binary operators are left-associative or non-associative.
         // For each operand, we use either the same precedence level as
@@ skipping 143 matching lines @@
     } else if (stmt is Continue) {
       write('continue');
       if (stmt.label != null) {
         write(' ');
         write(stmt.label);
       }
       write(';');
     } else if (stmt is EmptyStatement) {
       write(';');
     } else if (stmt is ExpressionStatement) {
-      writeExp(stmt.expression, EXPRESSION, beginStmt:true);
+      writeExp(stmt.expression, EXPRESSION, beginStmt: true);
       write(';');
     } else if (stmt is For) {
       write('for(');
       Node init = stmt.initializer;
       if (init is Expression) {
         writeExp(init, EXPRESSION);
       } else if (init is VariableDeclarations) {
         writeVariableDefinitions(init);
       }
       write(';');
@@ skipping 125 matching lines @@
       }
     } else {
       throw "Unexpected statement: $stmt";
     }
   }
 
   /// Writes a variable definition statement without the trailing semicolon
   void writeVariableDefinitions(VariableDeclarations vds) {
     if (vds.isConst)
       write('const ');
-    else if (vds.isFinal)
-      write('final ');
+    else if (vds.isFinal) write('final ');
     if (vds.type != null) {
       writeType(vds.type);
       write(' ');
     }
     if (!vds.isConst && !vds.isFinal && vds.type == null) {
       write('var ');
     }
     writeEach(',', vds.declarations, (VariableDeclaration vd) {
       write(vd.name);
       if (vd.initializer != null) {
@@ skipping 39 matching lines @@
       write('<');
       writeEach(',', type.typeArguments, writeType);
       write('>');
     }
   }
 
   /// A list of string quotings that the printer may use to quote strings.
   // Ignore multiline quotings for now. Would need to make sure that no
   // newline (potentially prefixed by whitespace) follows the quoting.
   static const _QUOTINGS = const <tree.StringQuoting>[
-      const tree.StringQuoting(characters.$DQ, raw: false, leftQuoteLength: 1),
-      const tree.StringQuoting(characters.$DQ, raw: true, leftQuoteLength: 1),
-      const tree.StringQuoting(characters.$SQ, raw: false, leftQuoteLength: 1),
-      const tree.StringQuoting(characters.$SQ, raw: true, leftQuoteLength: 1),
+    const tree.StringQuoting(characters.$DQ, raw: false, leftQuoteLength: 1),
+    const tree.StringQuoting(characters.$DQ, raw: true, leftQuoteLength: 1),
+    const tree.StringQuoting(characters.$SQ, raw: false, leftQuoteLength: 1),
+    const tree.StringQuoting(characters.$SQ, raw: true, leftQuoteLength: 1),
   ];
 
   static StringLiteralOutput analyzeStringLiteral(Expression node) {
     // Flatten the StringConcat tree.
     List parts = []; // Expression or int (char node)
     void collectParts(Expression e) {
       if (e is StringConcat) {
         e.expressions.forEach(collectParts);
       } else if (e is Literal && e.value.isString) {
         for (int char in e.value.primitiveValue) {
@@ skipping 40 matching lines @@
       } else {
         nonRaws.add(index);
       }
       if (q.quote == characters.$SQ) {
         sqs.add(index);
       } else {
         dqs.add(index);
       }
     }
 
-
     /// Applies additional cost to each track in [penalized], and considers
     /// switching from each [penalized] to a [nonPenalized] track.
-    void penalize(List<int> penalized,
-                  List<int> nonPenalized,
-                  int endIndex,
-                  num cost(tree.StringQuoting q)) {
+    void penalize(List<int> penalized, List<int> nonPenalized, int endIndex,
+        num cost(tree.StringQuoting q)) {
       for (int j in penalized) {
         // Check if another track can benefit from switching from this track.
         for (int k in nonPenalized) {
-          num newCost = best[j].cost
-                      + 1             // Whitespace in string juxtaposition
-                      + getQuoteCost(best[k].quoting);
+          num newCost = best[j].cost +
+              1 // Whitespace in string juxtaposition
+              +
+              getQuoteCost(best[k].quoting);
           if (newCost < best[k].cost) {
             best[k] = new OpenStringChunk(
-                best[j].end(endIndex),
-                best[k].quoting,
-                newCost);
+                best[j].end(endIndex), best[k].quoting, newCost);
           }
         }
         best[j].cost += cost(best[j].quoting);
       }
     }
 
     // Iterate through the string and update the score for each StringQuoting.
     for (int i = 0; i < parts.length; i++) {
       var part = parts[i];
       if (part is int) {
@@ skipping 24 matching lines @@
         penalize(raws, nonRaws, i, (q) => double.INFINITY);
 
         // Splitting a string can sometimes allow us to use a shorthand
         // string interpolation that would otherwise be illegal.
         // E.g. "...${foo}x..." -> "...$foo" 'x...'
         // If are other factors that make splitting advantageous,
         // we can gain even more by doing the split here.
         if (part is Identifier &&
             !part.name.contains(r'$') &&
             i + 1 < parts.length &&
-            isIdentifierPartNoDollar(parts[i+1])) {
+            isIdentifierPartNoDollar(parts[i + 1])) {
           for (int j in nonRaws) {
             for (int k = 0; k < best.length; k++) {
-              num newCost = best[j].cost
-                          + 1             // Whitespace in string juxtaposition
-                          - 2             // Save two curly braces
-                          + getQuoteCost(best[k].quoting);
+              num newCost = best[j].cost +
+                  1 // Whitespace in string juxtaposition
+                  -
+                  2 // Save two curly braces
+                  +
+                  getQuoteCost(best[k].quoting);
               if (newCost < best[k].cost) {
                 best[k] = new OpenStringChunk(
-                    best[j].end(i+1),
-                    best[k].quoting,
-                    newCost);
+                    best[j].end(i + 1), best[k].quoting, newCost);
               }
             }
           }
         }
       }
     }
 
     // Select the cheapest strategy
     OpenStringChunk bestChunk = best[0];
     for (OpenStringChunk chunk in best) {
@@ skipping 16 matching lines @@
         startIndex = chunk.previous.endIndex;
       } else {
         startIndex = 0;
       }
       if (chunk.quoting.raw) {
         write('r');
       }
       write(chunk.quoting.quoteChar);
       bool raw = chunk.quoting.raw;
       int quoteCode = chunk.quoting.quote;
-      for (int i=startIndex; i<chunk.endIndex; i++) {
+      for (int i = startIndex; i < chunk.endIndex; i++) {
         var part = parts[i];
         if (part is int) {
           int char = part;
           write(getEscapedCharacter(char, quoteCode, raw));
         } else if (part is Identifier &&
-                   !part.name.contains(r'$') &&
-                   (i == chunk.endIndex - 1 ||
-                    !isIdentifierPartNoDollar(parts[i+1]))) {
+            !part.name.contains(r'$') &&
+            (i == chunk.endIndex - 1 ||
+                !isIdentifierPartNoDollar(parts[i + 1]))) {
           write(r'$');
           write(part.name);
         } else {
           write(r'${');
           writeExpression(part);
           write('}');
         }
       }
       write(chunk.quoting.quoteChar);
     }
@@ skipping 21 matching lines @@
       case characters.$TAB:
         return r'\t';
       case characters.$VTAB:
         return r'\v';
       case characters.$EOF:
         return r'\x00';
       default:
         return new String.fromCharCode(char);
     }
   }
-
 }
 
 /// The contents of a string literal together with a strategy for printing it.
 class StringLiteralOutput {
   /// Mix of [Expression] and `int`. Each expression is a string interpolation,
   /// and each `int` is the character code of a character in a string literal.
   final List parts;
   final StringChunk chunk;
 
   StringLiteralOutput(this.parts, this.chunk);
 }
 
-
 /// Strategy for printing a prefix of a string literal.
 /// A chunk represents the substring going from [:previous.endIndex:] to
 /// [endIndex] (or from 0 to [endIndex] if [previous] is null).
 class StringChunk {
   final StringChunk previous;
   final tree.StringQuoting quoting;
   final int endIndex;
 
   StringChunk(this.previous, this.quoting, this.endIndex);
 }
 
 /// [StringChunk] that has not yet been assigned an [endIndex].
 /// It additionally has a [cost] denoting the number of auxilliary characters
 /// (quotes, spaces, etc) needed to print the literal using this strategy
 class OpenStringChunk {
   final StringChunk previous;
   final tree.StringQuoting quoting;
   num cost;
 
   OpenStringChunk(this.previous, this.quoting, this.cost);
 
   StringChunk end(int endIndex) {
     return new StringChunk(previous, quoting, endIndex);
   }
 }