Use newline tokens when generating source from tokenstream.

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 5657 matching lines @@
   return raw_ptr()->private_key_;
 }
 
 
 void TokenStream::SetPrivateKey(const String& value) const {
   StorePointer(&raw_ptr()->private_key_, value.raw());
 }
 
 
 RawString* TokenStream::GenerateSource() const {
-  Iterator iterator(*this, 0);
+  Iterator iterator(*this, 0, Iterator::kAllTokens);
   const ExternalTypedData& data = ExternalTypedData::Handle(GetStream());
   const GrowableObjectArray& literals =
       GrowableObjectArray::Handle(GrowableObjectArray::New(data.Length()));
   const String& private_key = String::Handle(PrivateKey());
   intptr_t private_len = private_key.Length();
 
   Token::Kind curr = iterator.CurrentTokenKind();
   Token::Kind prev = Token::kILLEGAL;
   // Handles used in the loop.
   Object& obj = Object::Handle();
@@ skipping 40 matching lines @@
         literal = String::SubString(literal, 0, literal.Length() - private_len);
       }
       literals.Add(literal);
     } else {
       literals.Add(literal);
     }
     // Determine the separation text based on this current token.
     const String* separator = NULL;
     switch (curr) {
       case Token::kLBRACE:
-        indent++;
-        separator = &Symbols::NewLine();
-        break;
       case Token::kRBRACE:
-        if (indent == 0) {
-          separator = &Symbols::TwoNewlines();
-        } else {
-          separator = &Symbols::NewLine();
-        }
-        break;
-      case Token::kSEMICOLON:
-        separator = &Symbols::NewLine();
-        break;
       case Token::kPERIOD:
-      case Token::kLPAREN:
       case Token::kLBRACK:
       case Token::kINTERPOL_VAR:
       case Token::kINTERPOL_START:
       case Token::kINTERPOL_END:
+      case Token::kBIT_NOT:
+        break;
+      case Token::kLPAREN:
+        indent += 2;

[Ivan Posva, 2013/09/19 23:42:00]

Please add comment explaining why this indent is useful. Maybe even add a simple
example.

[Michael Lippautz (Google), 2013/09/20 16:36:29]

Done.

+        break;
+      case Token::kRPAREN:
+        indent -= 2;
+        separator = &Symbols::Blank();
+        break;
+      case Token::kNEWLINE:
+        if (prev == Token::kLBRACE) {
+          indent++;
+        }
+        if (next == Token::kRBRACE) {
+          indent--;
+        }
         break;
       default:
         separator = &Symbols::Blank();
         break;
     }
+
     // Determine whether the separation text needs to be updated based on the
     // next token.
     switch (next) {
       case Token::kRBRACE:
-        indent--;
         break;
       case Token::kSEMICOLON:
       case Token::kPERIOD:
       case Token::kCOMMA:
       case Token::kLPAREN:
       case Token::kRPAREN:
       case Token::kLBRACK:
       case Token::kRBRACK:
       case Token::kINTERPOL_VAR:
       case Token::kINTERPOL_START:
       case Token::kINTERPOL_END:
         separator = NULL;
         break;
       case Token::kELSE:
         separator = &Symbols::Blank();
+        break;
       default:
         // Do nothing.
         break;
     }
+
     // Update the few cases where both tokens need to be taken into account.
     if (((curr == Token::kIF) || (curr == Token::kFOR)) &&
         (next == Token::kLPAREN)) {
       separator = &Symbols::Blank();
     } else if ((curr == Token::kASSIGN) && (next == Token::kLPAREN)) {
       separator = &Symbols::Blank();
+    } else if ((curr == Token::kRETURN  ||
+                curr == Token::kCONDITIONAL ||
+                Token::IsBinaryOperator(curr) ||
+                Token::IsEqualityOperator(curr)) && (next == Token::kLPAREN)) {
+      separator = &Symbols::Blank();
     } else if ((curr == Token::kLBRACE) && (next == Token::kRBRACE)) {
       separator = NULL;
+    } else if ((curr == Token::kSEMICOLON) && (next != Token::kNEWLINE)) {
+      separator = &Symbols::Blank();
     }
+
+    // Add the separator.
     if (separator != NULL) {
       literals.Add(*separator);
-      if (separator == &Symbols::NewLine()) {
+    }
+
+    // Account for indentation in case we printed a newline.
+    if (curr == Token::kNEWLINE) {
         for (int i = 0; i < indent; i++) {
           literals.Add(Symbols::TwoSpaces());
         }
-      }
     }
+
     // Setup for next iteration.
     prev = curr;
     curr = next;
   }
   const Array& source = Array::Handle(Array::MakeArray(literals));
   return String::ConcatAll(source);
 }
 
 
 intptr_t TokenStream::ComputeSourcePosition(intptr_t tok_pos) const {
@@ skipping 9123 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart