Linter Demo

Errors: 1

Warnings: 10

File: /home/fstrocco/Dart/dart/benchmark/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; import '../util/characters.dart' as characters; /// The following nodes correspond to [tree.Send] expressions: /// [FieldExpression], [IndexExpression], [Assignment], [Increment], /// [CallFunction], [CallMethod], [CallNew], [CallStatic], [UnaryOperator], /// [BinaryOperator], and [TypeOperator]. abstract class Node {} /// Receiver is an [Expression] or the [SuperReceiver]. abstract class Receiver extends Node {} /// Argument is an [Expression] or a [NamedArgument]. abstract class Argument extends Node {} abstract class Expression extends Node implements Receiver, Argument { bool get assignable => false; } abstract class RootNode extends Node { elements.Element get element; } class FieldDefinition extends RootNode { final elements.Element element; final Expression initializer; FieldDefinition(this.element, this.initializer); } abstract class Statement extends Node {} /// Used as receiver in expressions that dispatch to the super class. /// For instance, an expression such as `super.f()` is represented /// by a [CallMethod] node with [SuperReceiver] as its receiver. class SuperReceiver extends Receiver { static final SuperReceiver _instance = new SuperReceiver._create(); factory SuperReceiver() => _instance; SuperReceiver._create(); } /// Named arguments may occur in the argument list of /// [CallFunction], [CallMethod], [CallNew], and [CallStatic]. class NamedArgument extends Argument { final String name; final Expression expression; NamedArgument(this.name, this.expression); } class TypeAnnotation extends Node { 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]); } class Continue extends Statement { final String label; Continue([this.label]); } class EmptyStatement extends Statement { static final EmptyStatement _instance = new EmptyStatement._create(); factory EmptyStatement() => _instance; EmptyStatement._create(); } class ExpressionStatement extends Statement { final Expression expression; ExpressionStatement(this.expression); } 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); } } 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)); } } class While extends Statement { final Expression condition; final Statement body; While(this.condition, this.body); } class DoWhile extends Statement { final Statement body; final Expression condition; DoWhile(this.body, this.condition); } class If extends Statement { final Expression condition; final Statement thenStatement; final Statement elseStatement; 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 Return extends Statement { final Expression expression; Return([this.expression]); } class Switch extends Statement { final Expression expression; final List<SwitchCase> cases; Switch(this.expression, this.cases); } /// A sequence of case clauses followed by a sequence of statements. /// Represents the default case if [expressions] is null. /// /// NOTE: /// Control will never fall through to the following SwitchCase, even if /// the list of statements is empty. An empty list of statements will be /// unparsed to a semicolon to guarantee this behaviour. class SwitchCase extends Node { final List<Expression> expressions; final List<Statement> statements; SwitchCase(this.expressions, this.statements); SwitchCase.defaultCase(this.statements) : expressions = null; bool get isDefaultCase => expressions == null; } /// A try statement. The try, catch and finally blocks will automatically /// be printed inside a block statement if necessary. class Try extends Statement { final Statement tryBlock; final List<CatchBlock> catchBlocks; final Statement finallyBlock; Try(this.tryBlock, this.catchBlocks, [this.finallyBlock]) { assert(catchBlocks.length > 0 || finallyBlock != null); } } class CatchBlock extends Node { final TypeAnnotation onType; final VariableDeclaration exceptionVar; final VariableDeclaration stackVar; final Statement body; /// At least onType or exceptionVar must be given. /// stackVar may only be given if exceptionVar is also given. CatchBlock(this.body, {this.onType, this.exceptionVar, this.stackVar}) { // Must specify at least a type or an exception binding. assert(onType != null || exceptionVar != null); // We cannot bind the stack trace without binding the exception too. assert(stackVar == null || exceptionVar != null); } } 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 }) { // 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 ]); Parameters.named(this.requiredParameters, this.optionalParameters) : hasNamedParameters = true; Parameters.positional(this.requiredParameters, this.optionalParameters) : 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.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 {} class FieldInitializer extends Initializer { final elements.FieldElement element; final Expression body; FieldInitializer(this.element, this.body); } class SuperInitializer extends Initializer { final elements.ConstructorElement target; final List<Argument> arguments; SuperInitializer(this.target, this.arguments); } 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 }) { // 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) : 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); } /// An identifier expression. /// The unparser does not concern itself with scoping rules, and it is the /// responsibility of the AST creator to ensure that the identifier resolves /// to the proper definition. /// For the time being, this class is also used to reference static fields and /// top-level variables that are qualified with a class and/or library name, /// assuming the [element] is set. This is likely to change when the old backend /// is replaced. class Identifier extends Expression { final String name; elements.Element element; Identifier(this.name); bool get assignable => true; } class Literal extends Expression { 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 }); } 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); } } class LiteralMapEntry extends Node { final Expression key; final Expression value; LiteralMapEntry(this.key, this.value); } class LiteralSymbol extends Expression { final String id; /// [id] should not include the # symbol LiteralSymbol(this.id); } /// A type literal. This is distinct from [Identifier] since the unparser /// needs to this distinguish a static invocation from a method invocation /// on a type literal. class LiteralType extends Expression { final String name; types.DartType type; LiteralType(this.name); } /// Reference to a type variable. /// This is distinct from [Identifier] since the unparser needs to this /// distinguish a function invocation `T()` from a type variable invocation /// `(T)()` (the latter is invalid, but must be generated anyway). class ReifyTypeVar extends Expression { final String name; elements.TypeVariableElement element; ReifyTypeVar(this.name); } /// StringConcat is used in place of string interpolation and juxtaposition. /// Semantically, each subexpression is evaluated and converted to a string /// by `toString()`. These string are then concatenated and returned. /// StringConcat unparses to a string literal, possibly with interpolations. /// The unparser will flatten nested StringConcats. /// A StringConcat node may have any number of children, including zero and one. class StringConcat extends Expression { final List<Expression> expressions; StringConcat(this.expressions); } /// Expression of form `e.f`. class FieldExpression extends Expression { final Receiver object; final String fieldName; FieldExpression(this.object, this.fieldName); bool get assignable => true; } /// Expression of form `e1[e2]`. class IndexExpression extends Expression { final Receiver object; final Expression index; IndexExpression(this.object, this.index); bool get assignable => true; } /// Expression of form `e(..)` /// Note that if [callee] is a [FieldExpression] this will translate into /// `(e.f)(..)` and not `e.f(..)`. Use a [CallMethod] to generate /// the latter type of expression. class CallFunction extends Expression { final Expression callee; final List<Argument> arguments; CallFunction(this.callee, this.arguments); } /// Expression of form `e.f(..)`. class CallMethod extends Expression { final Receiver object; final String methodName; final List<Argument> arguments; CallMethod(this.object, this.methodName, this.arguments); } /// Expression of form `new T(..)`, `new T.f(..)`, `const T(..)`, /// 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 }); } /// Expression of form `T.f(..)`. class CallStatic extends Expression { final String className; final String methodName; final List<Argument> arguments; elements.Element element; CallStatic(this.className, this.methodName, this.arguments); } /// Expression of form `!e` or `-e` or `~e`. class UnaryOperator extends Expression { final String operatorName; final Receiver operand; UnaryOperator(this.operatorName, this.operand) { assert(isUnaryOperator(operatorName)); } } /// Expression of form `e1 + e2`, `e1 - e2`, etc. /// This node also represents application of the logical operators && and ||. class BinaryOperator extends Expression { final Receiver left; final String operator; final Expression right; BinaryOperator(this.left, this.operator, this.right) { assert(isBinaryOperator(operator)); } } /// 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!'); } } 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(['=', '|=', '^=', '&=', '<<=', '>>=', '+=', '-=', '*=', '/=', '%=', '~/=']); 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 { '&&': 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.$_); } /// 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: /// {S; ; S} ==> {S; S} /// Unfold singleton blocks: /// {S} ==> S /// Empty block to empty statement: /// {} ==> ; /// Introduce not-equals operator: /// !(E == E) ==> E != E /// Introduce is-not operator: /// !(E is T) ==> E is!T /// /// The following transformations will NOT be applied here: /// Use implicit this: /// this.foo ==> foo (preconditions too complex for unparser) /// Merge adjacent variable definitions: /// var x; var y ==> var x,y; (hoisting will be done elsewhere) /// Merge adjacent labels: /// foo: bar: S ==> foobar: S (scoping is categorically ignored) /// /// 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) { first = false; } else { write(separator); } callback(x); } } void writeOperator(String operator) { write(" "); // TODO(sigurdm,kmillikin): Minimize use of whitespace. write(operator); write(" "); } /// Unfolds singleton blocks and returns the inner statement. /// If an empty block is found, the [EmptyStatement] is returned instead. Statement unfoldBlocks(Statement stmt) { while (stmt is Block && stmt.statements.length == 1) { Statement inner = (stmt as Block).statements[0]; if (definesVariable(inner)) { return stmt; // Do not unfold block with lexical scope. } stmt = inner; } if (stmt is Block && stmt.statements.length == 0) return new EmptyStatement(); return stmt; } void writeArgument(Argument arg) { if (arg is NamedArgument) { write(arg.name); write(':'); writeExpression(arg.expression); } else { writeExpression(arg); } } /// 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}) { // TODO(kmillikin,sigurdm): it might be faster to use a Visitor. void withPrecedence(int actual, void action()) { if (actual < minPrecedence) { write("("); beginStmt = false; action(); write(")"); } else { action(); } } if (e is SuperReceiver) { write('super'); } else if (e is FunctionExpression) { assert(!e.isGetter && !e.isSetter); Statement stmt = unfoldBlocks(e.body); int precedence = stmt is Return ? EXPRESSION : PRIMARY; withPrecedence(precedence, () { // A named function expression at the beginning of a statement // can be mistaken for a function declaration. // (Note: Functions with a return type also have a name) bool needParen = beginStmt && e.name != null; if (needParen) { write('('); } if (e.returnType != null) { writeType(e.returnType); write(' '); } if (e.name != null) { write(e.name); } writeParameters(e.parameters); // TODO(sigurdm,kmillikin): Print {} for "return null;" if (stmt is Return) { write('=> '); writeExp(stmt.expression, EXPRESSION); } else { writeBlock(stmt); } if (needParen) { write(')'); } }); } else if (e is Conditional) { withPrecedence(CONDITIONAL, () { writeExp(e.condition, LOGICAL_OR, beginStmt: beginStmt); 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) { 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) { withPrecedence(MULTIPLICATIVE, () { write('0/0.0'); }); } else { write(v.toString()); } } else { // TODO(sigurdm): Use [ConstExp] to generate valid code for any // constant. write(e.value.unparse()); } } else if (e is LiteralList) { if (e.isConst) { write(' const '); } if (e.typeArgument != null) { write('<'); writeType(e.typeArgument); write('>'); } write('['); writeEach(',', e.values, writeExpression); write(']'); } 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); write('>'); needParen = false; } if (needParen) { write('('); } write('{'); writeEach(',', e.entries, (LiteralMapEntry en) { writeExp(en.key, EXPRESSION); write(' : '); writeExp(en.value, EXPRESSION); }); write('}'); if (needParen) { write(')'); } } else if (e is LiteralSymbol) { write('#'); write(e.id); } else if (e is LiteralType) { withPrecedence(TYPE_LITERAL, () { write(e.name); }); } 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 == '==') { 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') { withPrecedence(RELATIONAL, () { writeExp(operand.expression, BITWISE_OR, beginStmt: beginStmt); write(' is!'); writeType(operand.type); }); } 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 // the current operator, or one higher. int deltaLeft = isAssociativeBinaryOperator(precedence) ? 0 : 1; writeExp(e.left, precedence + deltaLeft, beginStmt: beginStmt); writeOperator(e.operator); writeExp(e.right, precedence + 1); }); } else if (e is TypeOperator) { withPrecedence(RELATIONAL, () { writeExp(e.expression, BITWISE_OR, beginStmt: beginStmt); write(' '); write(e.operator); write(' '); writeType(e.type); }); } else if (e is Assignment) { withPrecedence(EXPRESSION, () { writeExp(e.left, PRIMARY, beginStmt: beginStmt); writeOperator(e.operator); writeExp(e.right, EXPRESSION); }); } else if (e is FieldExpression) { withPrecedence(PRIMARY, () { writeExp(e.object, PRIMARY, beginStmt: beginStmt); write('.'); write(e.fieldName); }); } else if (e is IndexExpression) { withPrecedence(CALLEE, () { writeExp(e.object, PRIMARY, beginStmt: beginStmt); write('['); writeExp(e.index, EXPRESSION); write(']'); }); } else if (e is CallFunction) { withPrecedence(CALLEE, () { writeExp(e.callee, CALLEE, beginStmt: beginStmt); write('('); writeEach(',', e.arguments, writeArgument); write(')'); }); } else if (e is CallMethod) { withPrecedence(CALLEE, () { writeExp(e.object, PRIMARY, beginStmt: beginStmt); write('.'); write(e.methodName); write('('); writeEach(',', e.arguments, writeArgument); write(')'); }); } else if (e is CallNew) { withPrecedence(CALLEE, () { write(' '); write(e.isConst ? 'const ' : 'new '); writeType(e.type); if (e.constructorName != null) { write('.'); write(e.constructorName); } write('('); writeEach(',', e.arguments, writeArgument); write(')'); }); } else if (e is CallStatic) { withPrecedence(CALLEE, () { write(e.className); write('.'); write(e.methodName); write('('); writeEach(',', e.arguments, writeArgument); write(')'); }); } else if (e is Increment) { int precedence = e.isPrefix ? UNARY : POSTFIX_INCREMENT; withPrecedence(precedence, () { if (e.isPrefix) { write(e.operator); writeExp(e.expression, PRIMARY); } else { writeExp(e.expression, PRIMARY, beginStmt: beginStmt); write(e.operator); } }); } else if (e is Throw) { withPrecedence(EXPRESSION, () { write('throw '); writeExp(e.expression, EXPRESSION); }); } else if (e is This) { write('this'); } else { throw "Unexpected expression: $e"; } } void writeParameters(Parameters params) { write('('); bool first = true; writeEach(',', params.requiredParameters, (Parameter p) { if (p.type != null) { writeType(p.type); write(' '); } write(p.name); if (p.parameters != null) { writeParameters(p.parameters); } }); if (params.hasOptionalParameters) { if (params.requiredParameters.length > 0) { write(','); } write(params.hasNamedParameters ? '{' : '['); writeEach(',', params.optionalParameters, (Parameter p) { if (p.type != null) { writeType(p.type); write(' '); } write(p.name); if (p.parameters != null) { writeParameters(p.parameters); } if (p.defaultValue != null) { write(params.hasNamedParameters ? ':' : '='); writeExp(p.defaultValue, EXPRESSION); } }); write(params.hasNamedParameters ? '}' : ']'); } write(')'); } void writeStatement(Statement stmt, {bool shortIf: true}) { stmt = unfoldBlocks(stmt); if (stmt is Block) { write('{'); stmt.statements.forEach(writeBlockMember); write('}'); } else if (stmt is Break) { write('break'); if (stmt.label != null) { write(' '); write(stmt.label); } write(';'); } 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); 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(';'); if (stmt.condition != null) { writeExp(stmt.condition, EXPRESSION); } write(';'); writeEach(',', stmt.updates, writeExpression); write(')'); writeStatement(stmt.body, shortIf: shortIf); } else if (stmt is ForIn) { write('for('); Node lhv = stmt.leftHandValue; if (lhv is Identifier) { write(lhv.name); } else { writeVariableDefinitions(lhv as VariableDeclarations); } write(' in '); writeExp(stmt.expression, EXPRESSION); write(')'); writeStatement(stmt.body, shortIf: shortIf); } else if (stmt is While) { write('while('); writeExp(stmt.condition, EXPRESSION); write(')'); writeStatement(stmt.body, shortIf: shortIf); } else if (stmt is DoWhile) { write('do '); writeStatement(stmt.body); write('while('); writeExp(stmt.condition, EXPRESSION); write(');'); } else if (stmt is If) { // if (E) S else ; ==> if (E) S Statement elsePart = unfoldBlocks(stmt.elseStatement); if (elsePart is EmptyStatement) { elsePart = null; } if (!shortIf && elsePart == null) { write('{'); } write('if('); writeExp(stmt.condition, EXPRESSION); write(')'); writeStatement(stmt.thenStatement, shortIf: elsePart == null); if (elsePart != null) { write('else '); writeStatement(elsePart, shortIf: shortIf); } if (!shortIf && elsePart == null) { write('}'); } } else if (stmt is LabeledStatement) { write(stmt.label); write(':'); writeStatement(stmt.statement, shortIf: shortIf); } else if (stmt is Rethrow) { write('rethrow;'); } else if (stmt is Return) { write('return'); if (stmt.expression != null) { write(' '); writeExp(stmt.expression, EXPRESSION); } write(';'); } else if (stmt is Switch) { write('switch('); writeExp(stmt.expression, EXPRESSION); write('){'); for (SwitchCase caze in stmt.cases) { if (caze.isDefaultCase) { write('default:'); } else { for (Expression exp in caze.expressions) { write('case '); writeExp(exp, EXPRESSION); write(':'); } } if (caze.statements.isEmpty) { write(';'); // Prevent fall-through. } else { caze.statements.forEach(writeBlockMember); } } write('}'); } else if (stmt is Try) { write('try'); writeBlock(stmt.tryBlock); for (CatchBlock block in stmt.catchBlocks) { if (block.onType != null) { write('on '); writeType(block.onType); } if (block.exceptionVar != null) { write('catch('); write(block.exceptionVar.name); if (block.stackVar != null) { write(','); write(block.stackVar.name); } write(')'); } writeBlock(block.body); } if (stmt.finallyBlock != null) { write('finally'); writeBlock(stmt.finallyBlock); } } else if (stmt is VariableDeclarations) { writeVariableDefinitions(stmt); write(';'); } else if (stmt is FunctionDeclaration) { assert(!stmt.function.isGetter && !stmt.function.isSetter); if (stmt.returnType != null) { writeType(stmt.returnType); write(' '); } write(stmt.name); writeParameters(stmt.parameters); Statement body = unfoldBlocks(stmt.body); if (body is Return) { write('=> '); writeExp(body.expression, EXPRESSION); write(';'); } else { writeBlock(body); } } 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 '); 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) { write('='); writeExp(vd.initializer, EXPRESSION); } }); } /// True of statements that introduce variables in the scope of their /// surrounding block. Blocks containing such statements cannot be unfolded. static bool definesVariable(Statement s) { return s is VariableDeclarations || s is FunctionDeclaration; } /// Writes the given statement in a context where only blocks are allowed. void writeBlock(Statement stmt) { if (stmt is Block) { writeStatement(stmt); } else { write('{'); writeBlockMember(stmt); write('}'); } } /// Outputs a statement that is a member of a block statement (or a similar /// sequence of statements, such as in switch statement). /// This will flatten blocks and skip empty statement. void writeBlockMember(Statement stmt) { if (stmt is Block && !stmt.statements.any(definesVariable)) { stmt.statements.forEach(writeBlockMember); } else if (stmt is EmptyStatement) { // do nothing } else { writeStatement(stmt); } } void writeType(TypeAnnotation type) { write(type.name); if (type.typeArguments != null && type.typeArguments.length > 0) { 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. // TODO(sigurdm,kmillikin): Include multiline quotation schemes. 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), ]; static StringLiteralOutput analyzeStringLiteral(Expression node) { // TODO(sigurdm,kmillikin): This might be a bit too expensive. Benchmark. // 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) { parts.add(char); } } else { parts.add(e); } } collectParts(node); // We use a dynamic algorithm to compute the optimal way of printing // the string literal. // // Using string juxtapositions, it is possible to switch from one quoting // to another, e.g. the constant "''''" '""""' uses this trick. // // As we move through the string from left to right, we maintain a strategy // for each StringQuoting Q, denoting the best way to print the current // prefix so that we end with a string literal quoted with Q. // At every step, each strategy is either: // 1) Updated to include the cost of printing the next character. // 2) Abandoned because it is cheaper to use another strategy as prefix, // and then switching quotation using a juxtaposition. int getQuoteCost(tree.StringQuoting quot) { return quot.leftQuoteLength + quot.rightQuoteLength; } // Create initial scores for each StringQuoting and index them // into raw/non-raw and single-quote/double-quote. List<OpenStringChunk> best = <OpenStringChunk>[]; List<int> raws = <int>[]; List<int> nonRaws = <int>[]; List<int> sqs = <int>[]; List<int> dqs = <int>[]; for (tree.StringQuoting q in _QUOTINGS) { OpenStringChunk chunk = new OpenStringChunk(null, q, getQuoteCost(q)); int index = best.length; best.add(chunk); if (q.raw) { raws.add(index); } 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)) { 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); if (newCost < best[k].cost) { best[k] = new OpenStringChunk( 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) { int char = part; switch (char) { case characters.$$: case characters.$BACKSLASH: penalize(nonRaws, raws, i, (q) => 1); break; case characters.$DQ: penalize(dqs, sqs, i, (q) => q.raw ? double.INFINITY : 1); break; case characters.$SQ: penalize(sqs, dqs, i, (q) => q.raw ? double.INFINITY : 1); break; case characters.$LF: case characters.$CR: case characters.$FF: case characters.$BS: case characters.$VTAB: case characters.$TAB: case characters.$EOF: penalize(raws, nonRaws, i, (q) => double.INFINITY); break; } } else { // Penalize raw literals for string interpolation. 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])) { 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); if (newCost < best[k].cost) { best[k] = new OpenStringChunk( best[j].end(i+1), best[k].quoting, newCost); } } } } } } // Select the cheapest strategy OpenStringChunk bestChunk = best[0]; for (OpenStringChunk chunk in best) { if (chunk.cost < bestChunk.cost) { bestChunk = chunk; } } return new StringLiteralOutput(parts, bestChunk.end(parts.length)); } void writeStringLiteral(Expression node) { StringLiteralOutput output = analyzeStringLiteral(node); List parts = output.parts; void printChunk(StringChunk chunk) { int startIndex; if (chunk.previous != null) { printChunk(chunk.previous); write(' '); // String juxtaposition requires a space between literals. 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++) { 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]))) { write(r'$'); write(part.name); } else { write(r'${'); writeExpression(part); write('}'); } } write(chunk.quoting.quoteChar); } printChunk(output.chunk); } static String getEscapedCharacter(int char, int quoteCode, bool raw) { switch (char) { case characters.$$: return raw ? r'$' : r'\$'; case characters.$BACKSLASH: return raw ? r'\' : r'\\'; case characters.$DQ: return quoteCode == char ? r'\"' : r'"'; case characters.$SQ: return quoteCode == char ? r"\'" : r"'"; case characters.$LF: return r'\n'; case characters.$CR: return r'\r'; case characters.$FF: return r'\f'; case characters.$BS: return r'\b'; 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); } }