Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(109)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: pkg/compiler/lib/src/js/printer.dart

Issue 693183006: Revert "Move dart2js from sdk/lib/_internal/compiler to pkg/compiler" (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Created 6 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « pkg/compiler/lib/src/js/precedence.dart ('k') | pkg/compiler/lib/src/js/template.dart » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: pkg/compiler/lib/src/js/printer.dart
diff --git a/pkg/compiler/lib/src/js/printer.dart b/pkg/compiler/lib/src/js/printer.dart
deleted file mode 100644
index 1a512cf8dd48fc96ae617c9ba241b031bba77a1b..0000000000000000000000000000000000000000
--- a/pkg/compiler/lib/src/js/printer.dart
+++ /dev/null
@@ -1,1177 +0,0 @@
-// Copyright (c) 2012, 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.
-
-part of js;
-
-class Printer extends Indentation implements NodeVisitor {
- final bool shouldCompressOutput;
- leg.Compiler compiler;
- leg.CodeBuffer outBuffer;
- bool inForInit = false;
- bool atStatementBegin = false;
- final DanglingElseVisitor danglingElseVisitor;
- final LocalNamer localNamer;
- bool pendingSemicolon = false;
- bool pendingSpace = false;
- DumpInfoTask monitor = null;
-
- static final identifierCharacterRegExp = new RegExp(r'^[a-zA-Z_0-9$]');
- static final expressionContinuationRegExp = new RegExp(r'^[-+([]');
-
- Printer(leg.Compiler compiler, DumpInfoTask monitor,
- { allowVariableMinification: true })
- : shouldCompressOutput = compiler.enableMinification,
- monitor = monitor,
- this.compiler = compiler,
- outBuffer = new leg.CodeBuffer(),
- danglingElseVisitor = new DanglingElseVisitor(compiler),
- localNamer = determineRenamer(compiler.enableMinification,
- allowVariableMinification);
-
- static LocalNamer determineRenamer(bool shouldCompressOutput,
- bool allowVariableMinification) {
- return (shouldCompressOutput && allowVariableMinification)
- ? new MinifyRenamer() : new IdentityNamer();
- }
-
- /// Always emit a newline, even under `enableMinification`.
- void forceLine() {
- out("\n");
- }
- /// Emits a newline for readability.
- void lineOut() {
- if (!shouldCompressOutput) forceLine();
- }
- void spaceOut() {
- if (!shouldCompressOutput) out(" ");
- }
-
- String lastAddedString = null;
- int get lastCharCode {
- if (lastAddedString == null) return 0;
- assert(lastAddedString.length != "");
- return lastAddedString.codeUnitAt(lastAddedString.length - 1);
- }
-
- void out(String str) {
- if (str != "") {
- if (pendingSemicolon) {
- if (!shouldCompressOutput) {
- outBuffer.add(";");
- } else if (str != "}") {
- // We want to output newline instead of semicolon because it makes
- // the raw stack traces much easier to read and it also makes line-
- // based tools like diff work much better. JavaScript will
- // automatically insert the semicolon at the newline if it means a
- // parsing error is avoided, so we can only do this trick if the
- // next line is not something that can be glued onto a valid
- // expression to make a new valid expression.
-
- // If we're using the new emitter where most pretty printed code
- // is escaped in strings, it is a lot easier to deal with semicolons
- // than newlines because the former doesn't need escaping.
- if (USE_NEW_EMITTER || expressionContinuationRegExp.hasMatch(str)) {
- outBuffer.add(";");
- } else {
- outBuffer.add("\n");
- }
- }
- }
- if (pendingSpace &&
- (!shouldCompressOutput || identifierCharacterRegExp.hasMatch(str))) {
- outBuffer.add(" ");
- }
- pendingSpace = false;
- pendingSemicolon = false;
- outBuffer.add(str);
- lastAddedString = str;
- }
- }
-
- void outLn(String str) {
- out(str);
- lineOut();
- }
-
- void outSemicolonLn() {
- if (shouldCompressOutput) {
- pendingSemicolon = true;
- } else {
- out(";");
- forceLine();
- }
- }
-
- void outIndent(String str) { indent(); out(str); }
- void outIndentLn(String str) { indent(); outLn(str); }
- void indent() {
- if (!shouldCompressOutput) {
- out(indentation);
- }
- }
-
- void beginSourceRange(Node node) {
- if (node.sourcePosition != null) {
- outBuffer.beginMappedRange();
- outBuffer.setSourceLocation(node.sourcePosition);
- }
- }
-
- void endSourceRange(Node node) {
- if (node.endSourcePosition != null) {
- outBuffer.setSourceLocation(node.endSourcePosition);
- }
- if (node.sourcePosition != null) {
- outBuffer.endMappedRange();
- }
- }
-
- visit(Node node) {
- beginSourceRange(node);
- if (monitor != null) monitor.enteringAst(node, outBuffer.length);
-
- node.accept(this);
-
- if (monitor != null) monitor.exitingAst(node, outBuffer.length);
- endSourceRange(node);
- }
-
- visitCommaSeparated(List<Node> nodes, int hasRequiredType,
- {bool newInForInit, bool newAtStatementBegin}) {
- for (int i = 0; i < nodes.length; i++) {
- if (i != 0) {
- atStatementBegin = false;
- out(",");
- spaceOut();
- }
- visitNestedExpression(nodes[i], hasRequiredType,
- newInForInit: newInForInit,
- newAtStatementBegin: newAtStatementBegin);
- }
- }
-
- visitAll(List<Node> nodes) {
- nodes.forEach(visit);
- }
-
- visitProgram(Program program) {
- visitAll(program.body);
- }
-
- visitBlob(Blob node) {
- outBuffer.addBuffer(node.buffer);
- }
-
- bool blockBody(Node body, {bool needsSeparation, bool needsNewline}) {
- if (body is Block) {
- spaceOut();
- blockOut(body, false, needsNewline);
- return true;
- }
- if (shouldCompressOutput && needsSeparation) {
- // If [shouldCompressOutput] is false, then the 'lineOut' will insert
- // the separation.
- out(" ");
- } else {
- lineOut();
- }
- indentBlock(() => visit(body));
- return false;
- }
-
- void blockOutWithoutBraces(Node node) {
- if (node is Block) {
- beginSourceRange(node);
- Block block = node;
- block.statements.forEach(blockOutWithoutBraces);
- endSourceRange(node);
- } else {
- visit(node);
- }
- }
-
- void blockOut(Block node, bool shouldIndent, bool needsNewline) {
- if (shouldIndent) indent();
- beginSourceRange(node);
- out("{");
- lineOut();
- indentBlock(() => node.statements.forEach(blockOutWithoutBraces));
- indent();
- out("}");
- endSourceRange(node);
- if (needsNewline) lineOut();
- }
-
- visitBlock(Block block) {
- blockOut(block, true, true);
- }
-
- visitExpressionStatement(ExpressionStatement expressionStatement) {
- indent();
- visitNestedExpression(expressionStatement.expression, EXPRESSION,
- newInForInit: false, newAtStatementBegin: true);
- outSemicolonLn();
- }
-
- visitEmptyStatement(EmptyStatement nop) {
- outIndentLn(";");
- }
-
- void ifOut(If node, bool shouldIndent) {
- Node then = node.then;
- Node elsePart = node.otherwise;
- bool hasElse = node.hasElse;
-
- // Handle dangling elses and a work-around for Android 4.0 stock browser.
- // Android 4.0 requires braces for a single do-while in the `then` branch.
- // See issue 10923.
- if (hasElse) {
- bool needsBraces = node.then.accept(danglingElseVisitor) || then is Do;
- if (needsBraces) {
- then = new Block(<Statement>[then]);
- }
- }
- if (shouldIndent) indent();
- out("if");
- spaceOut();
- out("(");
- visitNestedExpression(node.condition, EXPRESSION,
- newInForInit: false, newAtStatementBegin: false);
- out(")");
- bool thenWasBlock =
- blockBody(then, needsSeparation: false, needsNewline: !hasElse);
- if (hasElse) {
- if (thenWasBlock) {
- spaceOut();
- } else {
- indent();
- }
- out("else");
- if (elsePart is If) {
- pendingSpace = true;
- ifOut(elsePart, false);
- } else {
- blockBody(elsePart, needsSeparation: true, needsNewline: true);
- }
- }
- }
-
- visitIf(If node) {
- ifOut(node, true);
- }
-
- visitFor(For loop) {
- outIndent("for");
- spaceOut();
- out("(");
- if (loop.init != null) {
- visitNestedExpression(loop.init, EXPRESSION,
- newInForInit: true, newAtStatementBegin: false);
- }
- out(";");
- if (loop.condition != null) {
- spaceOut();
- visitNestedExpression(loop.condition, EXPRESSION,
- newInForInit: false, newAtStatementBegin: false);
- }
- out(";");
- if (loop.update != null) {
- spaceOut();
- visitNestedExpression(loop.update, EXPRESSION,
- newInForInit: false, newAtStatementBegin: false);
- }
- out(")");
- blockBody(loop.body, needsSeparation: false, needsNewline: true);
- }
-
- visitForIn(ForIn loop) {
- outIndent("for");
- spaceOut();
- out("(");
- visitNestedExpression(loop.leftHandSide, EXPRESSION,
- newInForInit: true, newAtStatementBegin: false);
- out(" in");
- pendingSpace = true;
- visitNestedExpression(loop.object, EXPRESSION,
- newInForInit: false, newAtStatementBegin: false);
- out(")");
- blockBody(loop.body, needsSeparation: false, needsNewline: true);
- }
-
- visitWhile(While loop) {
- outIndent("while");
- spaceOut();
- out("(");
- visitNestedExpression(loop.condition, EXPRESSION,
- newInForInit: false, newAtStatementBegin: false);
- out(")");
- blockBody(loop.body, needsSeparation: false, needsNewline: true);
- }
-
- visitDo(Do loop) {
- outIndent("do");
- if (blockBody(loop.body, needsSeparation: true, needsNewline: false)) {
- spaceOut();
- } else {
- indent();
- }
- out("while");
- spaceOut();
- out("(");
- visitNestedExpression(loop.condition, EXPRESSION,
- newInForInit: false, newAtStatementBegin: false);
- out(")");
- outSemicolonLn();
- }
-
- visitContinue(Continue node) {
- if (node.targetLabel == null) {
- outIndent("continue");
- } else {
- outIndent("continue ${node.targetLabel}");
- }
- outSemicolonLn();
- }
-
- visitBreak(Break node) {
- if (node.targetLabel == null) {
- outIndent("break");
- } else {
- outIndent("break ${node.targetLabel}");
- }
- outSemicolonLn();
- }
-
- visitReturn(Return node) {
- if (node.value == null) {
- outIndent("return");
- } else {
- outIndent("return");
- pendingSpace = true;
- visitNestedExpression(node.value, EXPRESSION,
- newInForInit: false, newAtStatementBegin: false);
- }
- outSemicolonLn();
- }
-
- visitThrow(Throw node) {
- outIndent("throw");
- pendingSpace = true;
- visitNestedExpression(node.expression, EXPRESSION,
- newInForInit: false, newAtStatementBegin: false);
- outSemicolonLn();
- }
-
- visitTry(Try node) {
- outIndent("try");
- blockBody(node.body, needsSeparation: true, needsNewline: false);
- if (node.catchPart != null) {
- visit(node.catchPart);
- }
- if (node.finallyPart != null) {
- spaceOut();
- out("finally");
- blockBody(node.finallyPart, needsSeparation: true, needsNewline: true);
- } else {
- lineOut();
- }
- }
-
- visitCatch(Catch node) {
- spaceOut();
- out("catch");
- spaceOut();
- out("(");
- visitNestedExpression(node.declaration, EXPRESSION,
- newInForInit: false, newAtStatementBegin: false);
- out(")");
- blockBody(node.body, needsSeparation: false, needsNewline: true);
- }
-
- visitSwitch(Switch node) {
- outIndent("switch");
- spaceOut();
- out("(");
- visitNestedExpression(node.key, EXPRESSION,
- newInForInit: false, newAtStatementBegin: false);
- out(")");
- spaceOut();
- outLn("{");
- indentBlock(() => visitAll(node.cases));
- outIndentLn("}");
- }
-
- visitCase(Case node) {
- outIndent("case");
- pendingSpace = true;
- visitNestedExpression(node.expression, EXPRESSION,
- newInForInit: false, newAtStatementBegin: false);
- outLn(":");
- if (!node.body.statements.isEmpty) {
- indentBlock(() => blockOutWithoutBraces(node.body));
- }
- }
-
- visitDefault(Default node) {
- outIndentLn("default:");
- if (!node.body.statements.isEmpty) {
- indentBlock(() => blockOutWithoutBraces(node.body));
- }
- }
-
- visitLabeledStatement(LabeledStatement node) {
- outIndent("${node.label}:");
- blockBody(node.body, needsSeparation: false, needsNewline: true);
- }
-
- void functionOut(Fun fun, Node name, VarCollector vars) {
- out("function");
- if (name != null) {
- out(" ");
- // Name must be a [Decl]. Therefore only test for primary expressions.
- visitNestedExpression(name, PRIMARY,
- newInForInit: false, newAtStatementBegin: false);
- }
- localNamer.enterScope(vars);
- out("(");
- if (fun.params != null) {
- visitCommaSeparated(fun.params, PRIMARY,
- newInForInit: false, newAtStatementBegin: false);
- }
- out(")");
- blockBody(fun.body, needsSeparation: false, needsNewline: false);
- localNamer.leaveScope();
- }
-
- visitFunctionDeclaration(FunctionDeclaration declaration) {
- VarCollector vars = new VarCollector();
- vars.visitFunctionDeclaration(declaration);
- indent();
- functionOut(declaration.function, declaration.name, vars);
- lineOut();
- }
-
- visitNestedExpression(Expression node, int requiredPrecedence,
- {bool newInForInit, bool newAtStatementBegin}) {
- bool needsParentheses =
- // a - (b + c).
- (requiredPrecedence != EXPRESSION &&
- node.precedenceLevel < requiredPrecedence) ||
- // for (a = (x in o); ... ; ... ) { ... }
- (newInForInit && node is Binary && node.op == "in") ||
- // (function() { ... })().
- // ({a: 2, b: 3}.toString()).
- (newAtStatementBegin && (node is NamedFunction ||
- node is Fun ||
- node is ObjectInitializer));
- if (needsParentheses) {
- inForInit = false;
- atStatementBegin = false;
- out("(");
- visit(node);
- out(")");
- } else {
- inForInit = newInForInit;
- atStatementBegin = newAtStatementBegin;
- visit(node);
- }
- }
-
- visitVariableDeclarationList(VariableDeclarationList list) {
- out("var ");
- visitCommaSeparated(list.declarations, ASSIGNMENT,
- newInForInit: inForInit, newAtStatementBegin: false);
- }
-
- visitAssignment(Assignment assignment) {
- visitNestedExpression(assignment.leftHandSide, LEFT_HAND_SIDE,
- newInForInit: inForInit,
- newAtStatementBegin: atStatementBegin);
- if (assignment.value != null) {
- spaceOut();
- String op = assignment.op;
- if (op != null) out(op);
- out("=");
- spaceOut();
- visitNestedExpression(assignment.value, ASSIGNMENT,
- newInForInit: inForInit,
- newAtStatementBegin: false);
- }
- }
-
- visitVariableInitialization(VariableInitialization initialization) {
- visitAssignment(initialization);
- }
-
- visitConditional(Conditional cond) {
- visitNestedExpression(cond.condition, LOGICAL_OR,
- newInForInit: inForInit,
- newAtStatementBegin: atStatementBegin);
- spaceOut();
- out("?");
- spaceOut();
- // The then part is allowed to have an 'in'.
- visitNestedExpression(cond.then, ASSIGNMENT,
- newInForInit: false, newAtStatementBegin: false);
- spaceOut();
- out(":");
- spaceOut();
- visitNestedExpression(cond.otherwise, ASSIGNMENT,
- newInForInit: inForInit, newAtStatementBegin: false);
- }
-
- visitNew(New node) {
- out("new ");
- visitNestedExpression(node.target, CALL,
- newInForInit: inForInit, newAtStatementBegin: false);
- out("(");
- visitCommaSeparated(node.arguments, ASSIGNMENT,
- newInForInit: false, newAtStatementBegin: false);
- out(")");
- }
-
- visitCall(Call call) {
- visitNestedExpression(call.target, LEFT_HAND_SIDE,
- newInForInit: inForInit,
- newAtStatementBegin: atStatementBegin);
- out("(");
- visitCommaSeparated(call.arguments, ASSIGNMENT,
- newInForInit: false, newAtStatementBegin: false);
- out(")");
- }
-
- visitBinary(Binary binary) {
- Expression left = binary.left;
- Expression right = binary.right;
- String op = binary.op;
- int leftPrecedenceRequirement;
- int rightPrecedenceRequirement;
- bool leftSpace = true; // left<HERE>op right
- switch (op) {
- case ',':
- // x, (y, z) <=> (x, y), z.
- leftPrecedenceRequirement = EXPRESSION;
- rightPrecedenceRequirement = EXPRESSION;
- leftSpace = false;
- break;
- case "||":
- leftPrecedenceRequirement = LOGICAL_OR;
- // x || (y || z) <=> (x || y) || z.
- rightPrecedenceRequirement = LOGICAL_OR;
- break;
- case "&&":
- leftPrecedenceRequirement = LOGICAL_AND;
- // x && (y && z) <=> (x && y) && z.
- rightPrecedenceRequirement = LOGICAL_AND;
- break;
- case "|":
- leftPrecedenceRequirement = BIT_OR;
- // x | (y | z) <=> (x | y) | z.
- rightPrecedenceRequirement = BIT_OR;
- break;
- case "^":
- leftPrecedenceRequirement = BIT_XOR;
- // x ^ (y ^ z) <=> (x ^ y) ^ z.
- rightPrecedenceRequirement = BIT_XOR;
- break;
- case "&":
- leftPrecedenceRequirement = BIT_AND;
- // x & (y & z) <=> (x & y) & z.
- rightPrecedenceRequirement = BIT_AND;
- break;
- case "==":
- case "!=":
- case "===":
- case "!==":
- leftPrecedenceRequirement = EQUALITY;
- rightPrecedenceRequirement = RELATIONAL;
- break;
- case "<":
- case ">":
- case "<=":
- case ">=":
- case "instanceof":
- case "in":
- leftPrecedenceRequirement = RELATIONAL;
- rightPrecedenceRequirement = SHIFT;
- break;
- case ">>":
- case "<<":
- case ">>>":
- leftPrecedenceRequirement = SHIFT;
- rightPrecedenceRequirement = ADDITIVE;
- break;
- case "+":
- case "-":
- leftPrecedenceRequirement = ADDITIVE;
- // We cannot remove parenthesis for "+" because
- // x + (y + z) <!=> (x + y) + z:
- // Example:
- // "a" + (1 + 2) => "a3";
- // ("a" + 1) + 2 => "a12";
- rightPrecedenceRequirement = MULTIPLICATIVE;
- break;
- case "*":
- case "/":
- case "%":
- leftPrecedenceRequirement = MULTIPLICATIVE;
- // We cannot remove parenthesis for "*" because of precision issues.
- rightPrecedenceRequirement = UNARY;
- break;
- default:
- compiler.internalError(NO_LOCATION_SPANNABLE, "Forgot operator: $op");
- }
-
- visitNestedExpression(left, leftPrecedenceRequirement,
- newInForInit: inForInit,
- newAtStatementBegin: atStatementBegin);
-
- if (op == "in" || op == "instanceof") {
- // There are cases where the space is not required but without further
- // analysis we cannot know.
- out(" ");
- out(op);
- out(" ");
- } else {
- if (leftSpace) spaceOut();
- out(op);
- spaceOut();
- }
- visitNestedExpression(right, rightPrecedenceRequirement,
- newInForInit: inForInit,
- newAtStatementBegin: false);
- }
-
- visitPrefix(Prefix unary) {
- String op = unary.op;
- switch (op) {
- case "delete":
- case "void":
- case "typeof":
- // There are cases where the space is not required but without further
- // analysis we cannot know.
- out(op);
- out(" ");
- break;
- case "+":
- case "++":
- if (lastCharCode == charCodes.$PLUS) out(" ");
- out(op);
- break;
- case "-":
- case "--":
- if (lastCharCode == charCodes.$MINUS) out(" ");
- out(op);
- break;
- default:
- out(op);
- }
- visitNestedExpression(unary.argument, UNARY,
- newInForInit: inForInit, newAtStatementBegin: false);
- }
-
- visitPostfix(Postfix postfix) {
- visitNestedExpression(postfix.argument, LEFT_HAND_SIDE,
- newInForInit: inForInit,
- newAtStatementBegin: atStatementBegin);
- out(postfix.op);
- }
-
- visitVariableUse(VariableUse ref) {
- out(localNamer.getName(ref.name));
- }
-
- visitThis(This node) {
- out("this");
- }
-
- visitVariableDeclaration(VariableDeclaration decl) {
- out(localNamer.getName(decl.name));
- }
-
- visitParameter(Parameter param) {
- out(localNamer.getName(param.name));
- }
-
- bool isDigit(int charCode) {
- return charCodes.$0 <= charCode && charCode <= charCodes.$9;
- }
-
- bool isValidJavaScriptId(String field) {
- if (field.length < 3) return false;
- // Ignore the leading and trailing string-delimiter.
- for (int i = 1; i < field.length - 1; i++) {
- // TODO(floitsch): allow more characters.
- int charCode = field.codeUnitAt(i);
- if (!(charCodes.$a <= charCode && charCode <= charCodes.$z ||
- charCodes.$A <= charCode && charCode <= charCodes.$Z ||
- charCode == charCodes.$$ ||
- charCode == charCodes.$_ ||
- i != 1 && isDigit(charCode))) {
- return false;
- }
- }
- // TODO(floitsch): normally we should also check that the field is not a
- // reserved word. We don't generate fields with reserved word names except
- // for 'super'.
- if (field == '"super"') return false;
- return true;
- }
-
- visitAccess(PropertyAccess access) {
- visitNestedExpression(access.receiver, CALL,
- newInForInit: inForInit,
- newAtStatementBegin: atStatementBegin);
- Node selector = access.selector;
- if (selector is LiteralString) {
- LiteralString selectorString = selector;
- String fieldWithQuotes = selectorString.value;
- if (isValidJavaScriptId(fieldWithQuotes)) {
- if (access.receiver is LiteralNumber) out(" ");
- out(".");
- out(fieldWithQuotes.substring(1, fieldWithQuotes.length - 1));
- return;
- }
- }
- out("[");
- visitNestedExpression(selector, EXPRESSION,
- newInForInit: false, newAtStatementBegin: false);
- out("]");
- }
-
- visitNamedFunction(NamedFunction namedFunction) {
- VarCollector vars = new VarCollector();
- vars.visitNamedFunction(namedFunction);
- functionOut(namedFunction.function, namedFunction.name, vars);
- }
-
- visitFun(Fun fun) {
- VarCollector vars = new VarCollector();
- vars.visitFun(fun);
- functionOut(fun, null, vars);
- }
-
- visitLiteralBool(LiteralBool node) {
- out(node.value ? "true" : "false");
- }
-
- visitLiteralString(LiteralString node) {
- out(node.value);
- }
-
- visitLiteralNumber(LiteralNumber node) {
- int charCode = node.value.codeUnitAt(0);
- if (charCode == charCodes.$MINUS && lastCharCode == charCodes.$MINUS) {
- out(" ");
- }
- out(node.value);
- }
-
- visitLiteralNull(LiteralNull node) {
- out("null");
- }
-
- visitArrayInitializer(ArrayInitializer node) {
- out("[");
- List<ArrayElement> elements = node.elements;
- int elementIndex = 0;
- for (int i = 0; i < node.length; i++) {
- if (elementIndex < elements.length &&
- elements[elementIndex].index == i) {
- visitNestedExpression(elements[elementIndex].value, ASSIGNMENT,
- newInForInit: false, newAtStatementBegin: false);
- elementIndex++;
- // We can avoid a trailing "," if there was an element just before. So
- // `[1]` and `[1,]` are the same, but `[,]` and `[]` are not.
- if (i != node.length - 1) {
- out(",");
- spaceOut();
- }
- } else {
- out(",");
- }
- }
- out("]");
- }
-
- visitArrayElement(ArrayElement node) {
- throw "Unreachable";
- }
-
- visitObjectInitializer(ObjectInitializer node) {
- // Print all the properties on one line until we see a function-valued
- // property. Ideally, we would use a proper pretty-printer to make the
- // decision based on layout.
- List<Property> properties = node.properties;
- out("{");
- indentMore();
- for (int i = 0; i < properties.length; i++) {
- Expression value = properties[i].value;
- if (i != 0) {
- out(",");
- if (node.isOneLiner) spaceOut();
- }
- if (!node.isOneLiner) {
- forceLine();
- indent();
- }
- visit(properties[i]);
- }
- indentLess();
- if (!node.isOneLiner && !properties.isEmpty) {
- lineOut();
- indent();
- }
- out("}");
- }
-
- visitProperty(Property node) {
- if (node.name is LiteralString) {
- LiteralString nameString = node.name;
- String name = nameString.value;
- if (isValidJavaScriptId(name)) {
- out(name.substring(1, name.length - 1));
- } else {
- out(name);
- }
- } else {
- assert(node.name is LiteralNumber);
- LiteralNumber nameNumber = node.name;
- out(nameNumber.value);
- }
- out(":");
- spaceOut();
- visitNestedExpression(node.value, ASSIGNMENT,
- newInForInit: false, newAtStatementBegin: false);
- }
-
- visitRegExpLiteral(RegExpLiteral node) {
- out(node.pattern);
- }
-
- visitLiteralExpression(LiteralExpression node) {
- String template = node.template;
- List<Expression> inputs = node.inputs;
-
- List<String> parts = template.split('#');
- int inputsLength = inputs == null ? 0 : inputs.length;
- if (parts.length != inputsLength + 1) {
- compiler.internalError(NO_LOCATION_SPANNABLE,
- 'Wrong number of arguments for JS: $template');
- }
- // Code that uses JS must take care of operator precedences, and
- // put parenthesis if needed.
- out(parts[0]);
- for (int i = 0; i < inputsLength; i++) {
- visit(inputs[i]);
- out(parts[i + 1]);
- }
- }
-
- visitLiteralStatement(LiteralStatement node) {
- outLn(node.code);
- }
-
- visitInterpolatedNode(InterpolatedNode node) {
- out('#${node.name}');
- }
-
- visitInterpolatedExpression(InterpolatedExpression node) =>
- visitInterpolatedNode(node);
-
- visitInterpolatedLiteral(InterpolatedLiteral node) =>
- visitInterpolatedNode(node);
-
- visitInterpolatedParameter(InterpolatedParameter node) =>
- visitInterpolatedNode(node);
-
- visitInterpolatedSelector(InterpolatedSelector node) =>
- visitInterpolatedNode(node);
-
- visitInterpolatedStatement(InterpolatedStatement node) {
- outLn('#${node.name}');
- }
-
- void visitComment(Comment node) {
- if (shouldCompressOutput) return;
- String comment = node.comment.trim();
- if (comment.isEmpty) return;
- for (var line in comment.split('\n')) {
- if (comment.startsWith('//')) {
- outIndentLn(line.trim());
- } else {
- outIndentLn('// ${line.trim()}');
- }
- }
- }
-}
-
-
-class OrderedSet<T> {
- final Set<T> set;
- final List<T> list;
-
- OrderedSet() : set = new Set<T>(), list = <T>[];
-
- void add(T x) {
- if (!set.contains(x)) {
- set.add(x);
- list.add(x);
- }
- }
-
- void forEach(void fun(T x)) {
- list.forEach(fun);
- }
-}
-
-// Collects all the var declarations in the function. We need to do this in a
-// separate pass because JS vars are lifted to the top of the function.
-class VarCollector extends BaseVisitor {
- bool nested;
- final OrderedSet<String> vars;
- final OrderedSet<String> params;
-
- VarCollector() : nested = false,
- vars = new OrderedSet<String>(),
- params = new OrderedSet<String>();
-
- void forEachVar(void fn(String v)) => vars.forEach(fn);
- void forEachParam(void fn(String p)) => params.forEach(fn);
-
- void collectVarsInFunction(Fun fun) {
- if (!nested) {
- nested = true;
- if (fun.params != null) {
- for (int i = 0; i < fun.params.length; i++) {
- params.add(fun.params[i].name);
- }
- }
- visitBlock(fun.body);
- nested = false;
- }
- }
-
- void visitFunctionDeclaration(FunctionDeclaration declaration) {
- // Note that we don't bother collecting the name of the function.
- collectVarsInFunction(declaration.function);
- }
-
- void visitNamedFunction(NamedFunction namedFunction) {
- // Note that we don't bother collecting the name of the function.
- collectVarsInFunction(namedFunction.function);
- }
-
- void visitFun(Fun fun) {
- collectVarsInFunction(fun);
- }
-
- void visitThis(This node) {}
-
- void visitVariableDeclaration(VariableDeclaration decl) {
- if (decl.allowRename) vars.add(decl.name);
- }
-}
-
-
-/**
- * Returns true, if the given node must be wrapped into braces when used
- * as then-statement in an [If] that has an else branch.
- */
-class DanglingElseVisitor extends BaseVisitor<bool> {
- leg.Compiler compiler;
-
- DanglingElseVisitor(this.compiler);
-
- bool visitProgram(Program node) => false;
-
- bool visitNode(Statement node) {
- compiler.internalError(NO_LOCATION_SPANNABLE, "Forgot node: $node");
- return null;
- }
-
- bool visitBlock(Block node) => false;
- bool visitExpressionStatement(ExpressionStatement node) => false;
- bool visitEmptyStatement(EmptyStatement node) => false;
- bool visitIf(If node) {
- if (!node.hasElse) return true;
- return node.otherwise.accept(this);
- }
- bool visitFor(For node) => node.body.accept(this);
- bool visitForIn(ForIn node) => node.body.accept(this);
- bool visitWhile(While node) => node.body.accept(this);
- bool visitDo(Do node) => false;
- bool visitContinue(Continue node) => false;
- bool visitBreak(Break node) => false;
- bool visitReturn(Return node) => false;
- bool visitThrow(Throw node) => false;
- bool visitTry(Try node) {
- if (node.finallyPart != null) {
- return node.finallyPart.accept(this);
- } else {
- return node.catchPart.accept(this);
- }
- }
- bool visitCatch(Catch node) => node.body.accept(this);
- bool visitSwitch(Switch node) => false;
- bool visitCase(Case node) => false;
- bool visitDefault(Default node) => false;
- bool visitFunctionDeclaration(FunctionDeclaration node) => false;
- bool visitLabeledStatement(LabeledStatement node)
- => node.body.accept(this);
- bool visitLiteralStatement(LiteralStatement node) => true;
-
- bool visitExpression(Expression node) => false;
-}
-
-
-leg.CodeBuffer prettyPrint(Node node, leg.Compiler compiler,
- {DumpInfoTask monitor,
- allowVariableMinification: true}) {
- Printer printer =
- new Printer(compiler, monitor,
- allowVariableMinification: allowVariableMinification);
- printer.visit(node);
- return printer.outBuffer;
-}
-
-
-abstract class LocalNamer {
- String getName(String oldName);
- String declareVariable(String oldName);
- String declareParameter(String oldName);
- void enterScope(VarCollector vars);
- void leaveScope();
-}
-
-
-class IdentityNamer implements LocalNamer {
- String getName(String oldName) => oldName;
- String declareVariable(String oldName) => oldName;
- String declareParameter(String oldName) => oldName;
- void enterScope(VarCollector vars) {}
- void leaveScope() {}
-}
-
-
-class MinifyRenamer implements LocalNamer {
- final List<Map<String, String>> maps = [];
- final List<int> parameterNumberStack = [];
- final List<int> variableNumberStack = [];
- int parameterNumber = 0;
- int variableNumber = 0;
-
- MinifyRenamer();
-
- void enterScope(VarCollector vars) {
- maps.add(new Map<String, String>());
- variableNumberStack.add(variableNumber);
- parameterNumberStack.add(parameterNumber);
- vars.forEachVar(declareVariable);
- vars.forEachParam(declareParameter);
- }
-
- void leaveScope() {
- maps.removeLast();
- variableNumber = variableNumberStack.removeLast();
- parameterNumber = parameterNumberStack.removeLast();
- }
-
- String getName(String oldName) {
- // Go from inner scope to outer looking for mapping of name.
- for (int i = maps.length - 1; i >= 0; i--) {
- var map = maps[i];
- var replacement = map[oldName];
- if (replacement != null) return replacement;
- }
- return oldName;
- }
-
- static const LOWER_CASE_LETTERS = 26;
- static const LETTERS = LOWER_CASE_LETTERS;
- static const DIGITS = 10;
-
- static int nthLetter(int n) {
- return (n < LOWER_CASE_LETTERS) ?
- charCodes.$a + n :
- charCodes.$A + n - LOWER_CASE_LETTERS;
- }
-
- // Parameters go from a to z and variables go from z to a. This makes each
- // argument list and each top-of-function var declaration look similar and
- // helps gzip compress the file. If we have more than 26 arguments and
- // variables then we meet somewhere in the middle of the alphabet. After
- // that we give up trying to be nice to the compression algorithm and just
- // use the same namespace for arguments and variables, starting with A, and
- // moving on to a0, a1, etc.
- String declareVariable(String oldName) {
- if (avoidRenaming(oldName)) return oldName;
- var newName;
- if (variableNumber + parameterNumber < LOWER_CASE_LETTERS) {
- // Variables start from z and go backwards, for better gzipability.
- newName = getNameNumber(oldName, LOWER_CASE_LETTERS - 1 - variableNumber);
- } else {
- // After 26 variables and parameters we allocate them in the same order.
- newName = getNameNumber(oldName, variableNumber + parameterNumber);
- }
- variableNumber++;
- return newName;
- }
-
- String declareParameter(String oldName) {
- if (avoidRenaming(oldName)) return oldName;
- var newName;
- if (variableNumber + parameterNumber < LOWER_CASE_LETTERS) {
- newName = getNameNumber(oldName, parameterNumber);
- } else {
- newName = getNameNumber(oldName, variableNumber + parameterNumber);
- }
- parameterNumber++;
- return newName;
- }
-
- bool avoidRenaming(String oldName) {
- // Variables of this $form$ are used in pattern matching the message of JS
- // exceptions, so should not be renamed.
- // TODO(sra): Introduce a way for indicating in the JS text which variables
- // should not be renamed.
- return oldName.startsWith(r'$') && oldName.endsWith(r'$');
- }
-
- String getNameNumber(String oldName, int n) {
- if (maps.isEmpty) return oldName;
-
- String newName;
- if (n < LETTERS) {
- // Start naming variables a, b, c, ..., z, A, B, C, ..., Z.
- newName = new String.fromCharCodes([nthLetter(n)]);
- } else {
- // Then name variables a0, a1, a2, ..., a9, b0, b1, ..., Z9, aa0, aa1, ...
- // For all functions with fewer than 500 locals this is just as compact
- // as using aa, ab, etc. but avoids clashes with keywords.
- n -= LETTERS;
- int digit = n % DIGITS;
- n ~/= DIGITS;
- int alphaChars = 1;
- int nameSpaceSize = LETTERS;
- // Find out whether we should use the 1-character namespace (size 52), the
- // 2-character namespace (size 52*52), etc.
- while (n >= nameSpaceSize) {
- n -= nameSpaceSize;
- alphaChars++;
- nameSpaceSize *= LETTERS;
- }
- var codes = <int>[];
- for (var i = 0; i < alphaChars; i++) {
- nameSpaceSize ~/= LETTERS;
- codes.add(nthLetter((n ~/ nameSpaceSize) % LETTERS));
- }
- codes.add(charCodes.$0 + digit);
- newName = new String.fromCharCodes(codes);
- }
- assert(new RegExp(r'[a-zA-Z][a-zA-Z0-9]*').hasMatch(newName));
- maps.last[oldName] = newName;
- return newName;
- }
-}
« no previous file with comments | « pkg/compiler/lib/src/js/precedence.dart ('k') | pkg/compiler/lib/src/js/template.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698