Do not emit some unnecessary whitespaces in unparser.

lib/compiler/implementation/tree/unparser.dart

 // 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.
 
 // Returns null if no need to rename a node.
 typedef String Renamer(Node node);
 
 class Unparser implements Visitor {
   Renamer rename;
   StringBuffer sb;
@@ skipping 150 matching lines @@
 
   visitIdentifier(Identifier node) {
     add(node.token.value);
   }
 
   visitIf(If node) {
     add(node.ifToken.value);
     visit(node.condition);
     visit(node.thenPart);
     if (node.hasElsePart) {
-      addToken(node.elseToken);
+      add(node.elseToken.value);
+      if (node.elsePart is !Block) sb.add(' ');
       visit(node.elsePart);
     }
   }
 
   visitLiteralBool(LiteralBool node) {
     add(node.token.value);
   }
 
   visitLiteralDouble(LiteralDouble node) {
     add(node.token.value);
@@ skipping 20 matching lines @@
   visitLiteralNull(LiteralNull node) {
     add(node.token.value);
   }
 
   visitNewExpression(NewExpression node) {
     addToken(node.newToken);
     visit(node.send);
   }
 
   visitLiteralList(LiteralList node) {
-    addToken(node.constKeyword);
+    if (node.constKeyword !== null) add(node.constKeyword.value);
     visit(node.typeArguments);
     visit(node.elements);
   }
 
   visitModifiers(Modifiers node) => node.visitChildren(this);
 
   /**
    * Unparses given NodeList starting from specific node.
    */
   unparseNodeListFrom(NodeList node, Link<Node> from) {
     if (from.isEmpty()) return;
-    String delimiter = (node.delimiter === null) ? " " : "${node.delimiter}";
+    String delimiter = (node.delimiter === null) ? "" : "${node.delimiter}";
     visit(from.head);
     for (Link link = from.tail; !link.isEmpty(); link = link.tail) {
       sb.add(delimiter);
       visit(link.head);
     }
   }
 
   visitNodeList(NodeList node) {
-    if (node.beginToken !== null) addToken(node.beginToken);
+    addToken(node.beginToken);
     if (node.nodes !== null) {
       unparseNodeListFrom(node, node.nodes);
     }
     if (node.endToken !== null) add(node.endToken.value);
   }
 
   visitOperator(Operator node) {
     visitIdentifier(node);
   }
 
   visitReturn(Return node) {
     add(node.beginToken.value);
-    if (node.hasExpression) {
+    if (node.hasExpression && node.beginToken.stringValue != '=>') {
       sb.add(' ');
-      visit(node.expression);
     }
+    visit(node.expression);
     if (node.endToken !== null) add(node.endToken.value);
   }
 
   unparseSendReceiver(Send node, [bool spacesNeeded=false]) {
     // TODO(smok): Remove ugly hack for library preferences.
     // Check that renamer does not want to omit receiver at all,
     // in that case we don't need spaces or dot.
     if (node.receiver !== null && rename(node.receiver) != '') {
       visit(node.receiver);
       CascadeReceiver asCascadeReceiver = node.receiver.asCascadeReceiver();
@@ skipping 72 matching lines @@
       visit(node.type);
       sb.add(' ');
     }
     visit(node.definitions);
     if (node.endToken.value == const SourceString(';')) {
       add(node.endToken.value);
     }
   }
 
   visitDoWhile(DoWhile node) {
-    addToken(node.doKeyword);
+    add(node.doKeyword.value);
+    if (node.body is !Block) sb.add(' ');
     visit(node.body);
-    sb.add(' ');
-    addToken(node.whileKeyword);
+    add(node.whileKeyword.value);
     visit(node.condition);
     sb.add(node.endToken.value);
   }
 
   visitWhile(While node) {
     addToken(node.whileKeyword);
     visit(node.condition);
-    sb.add(' ');
     visit(node.body);
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     add(node.getBeginToken().value);
     visit(node.expression);
     add(node.getEndToken().value);
   }
 
   visitStringInterpolation(StringInterpolation node) {
@@ skipping 24 matching lines @@
   visitBreakStatement(BreakStatement node) {
     visitGotoStatement(node);
   }
 
   visitContinueStatement(ContinueStatement node) {
     visitGotoStatement(node);
   }
 
   visitForIn(ForIn node) {
     add(node.forToken.value);
-    sb.add(' (');
+    sb.add('(');
     visit(node.declaredIdentifier);
     sb.add(' ');
     addToken(node.inToken);
     visit(node.expression);
-    sb.add(') ');
+    sb.add(')');
     visit(node.body);
   }
 
   visitLabel(Label node) {
     visit(node.identifier);
     add(node.colonToken.value);
    }
 
   visitLabeledStatement(LabeledStatement node) {
     visit(node.labels);
     visit(node.statement);
   }
 
   visitLiteralMap(LiteralMap node) {
-    if (node.constKeyword !== null) {
-      add(node.constKeyword.value);
-    }
+    if (node.constKeyword !== null) add(node.constKeyword.value);
     if (node.typeArguments !== null) visit(node.typeArguments);
     visit(node.entries);
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     visit(node.key);
     add(node.colonToken.value);
-    sb.add(' ');
     visit(node.value);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.name);
     add(node.colonToken.value);
-    sb.add(' ');
     visit(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
     addToken(node.switchKeyword);
     visit(node.parenthesizedExpression);
-    sb.add(' ');
     visit(node.cases);
   }
 
   visitSwitchCase(SwitchCase node) {
     visit(node.labelsAndCases);
     if (node.isDefaultCase) {
       sb.add('default:');
     }
     visit(node.statements);
   }
 
   visitScriptTag(ScriptTag node) {
     add(node.beginToken.value);
     visit(node.tag);
     sb.add('(');
     visit(node.argument);
     if (node.prefixIdentifier !== null) {
       visit(node.prefixIdentifier);
-      sb.add(': ');
+      sb.add(':');
       visit(node.prefix);
     }
     sb.add(')');
     add(node.endToken.value);
   }
 
   visitTryStatement(TryStatement node) {
-    addToken(node.tryKeyword);
+    add(node.tryKeyword.value);
     visit(node.tryBlock);
     visit(node.catchBlocks);
     if (node.finallyKeyword !== null) {
-      sb.add(' ');
       addToken(node.finallyKeyword);
       visit(node.finallyBlock);
     }
   }
 
   visitCaseMatch(CaseMatch node) {
     add(node.caseKeyword.value);
     sb.add(" ");
     visit(node.expression);
     add(node.colonToken.value);
   }
 
   visitCatchBlock(CatchBlock node) {
     addToken(node.onKeyword);
-    visit(node.type);
-    sb.add(' ');
-    addToken(node.catchKeyword);
+    if (node.type !== null) {
+      visit(node.type);
+      sb.add(' ');
+    }
+    add(node.catchKeyword.value);
     visit(node.formals);
-    sb.add(' ');
     visit(node.block);
   }
 
   visitTypedef(Typedef node) {
     addToken(node.typedefKeyword);
     if (node.returnType !== null) {
       visit(node.returnType);
       sb.add(' ');
     }
     visit(node.name);
     if (node.typeParameters !== null) {
       visit(node.typeParameters);
     }
     visit(node.formals);
     add(node.endToken.value);
   }
 }