- Improve generated sources:

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/bigint_operations.h"
@@ skipping 4575 matching lines @@
 void TokenStream::SetTokenObjects(const Array& value) const {
   StorePointer(&raw_ptr()->token_objects_, value.raw());
 }
 
 
 void TokenStream::SetLength(intptr_t value) const {
   raw_ptr()->length_ = Smi::New(value);
 }
 
 
+RawString* TokenStream::PrivateKey() const {
+  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);
-  GrowableObjectArray& literals =
+  const GrowableObjectArray& literals =
       GrowableObjectArray::Handle(GrowableObjectArray::New(Length()));
-  String& literal = String::Handle();
+  const String& private_key = String::Handle(PrivateKey());
+  intptr_t private_len = private_key.Length();
+
   String& blank = String::Handle(String::New(" "));
   String& newline = String::Handle(String::New("\n"));
   String& two_newlines = String::Handle(String::New("\n\n"));
   String& double_quotes = String::Handle(String::New("\""));
   String& dollar = String::Handle(String::New("$"));
   String& two_spaces = String::Handle(String::New("  "));
+
+  Token::Kind curr = iterator.CurrentTokenKind();
+  Token::Kind prev = Token::kILLEGAL;
+  // Handles used in the loop.
   Object& obj = Object::Handle();
-  Token::Kind kind = iterator.CurrentTokenKind();
+  String& literal = String::Handle();
+  // Current indentation level.
   int indent = 0;
-  while (kind != Token::kEOS) {
+
+  while (curr != Token::kEOS) {
+    // Remember current values for this token.
     obj = iterator.CurrentToken();
     literal = iterator.MakeLiteralToken(obj);
-    if (kind == Token::kSTRING) {
+    // Advance to be able to use next token kind.
+    iterator.Advance();
+    Token::Kind next = iterator.CurrentTokenKind();
+
+    // Handle the current token.
+    if (curr == Token::kSTRING) {
       bool escape_quotes = false;
       for (intptr_t i = 0; i < literal.Length(); i++) {
         if (literal.CharAt(i) == '"') {
           escape_quotes = true;
           break;
         }
       }
-      literals.Add(double_quotes);
+      if ((prev != Token::kINTERPOL_VAR) && (prev != Token::kINTERPOL_END)) {
+        literals.Add(double_quotes);
+      }
       if (escape_quotes) {
         literal = String::EscapeDoubleQuotes(literal);
         literals.Add(literal);
       } else {
         literals.Add(literal);
       }
-      literals.Add(double_quotes);
-    } else if (kind == Token::kINTERPOL_VAR) {
-      literals.Add(double_quotes);
+      if ((next != Token::kINTERPOL_VAR) && (next != Token::kINTERPOL_START)) {
+        literals.Add(double_quotes);
+      }
+    } else if (curr == Token::kINTERPOL_VAR) {
       literals.Add(dollar);
       literals.Add(literal);
-      literals.Add(double_quotes);
-    } else if (kind == Token::kINTERPOL_START) {
-      literals.Add(double_quotes);
+    } else if (curr == Token::kIDENT) {
+      if (literal.CharAt(0) == Scanner::kPrivateIdentifierStart) {
+        literal = String::SubString(literal, 0, literal.Length() - private_len);
+      }
       literals.Add(literal);
-    } else if (kind == Token::kINTERPOL_END) {
-      literals.Add(literal);
-      literals.Add(double_quotes);
     } else {
       literals.Add(literal);
     }
     // Determine the separation text based on this current token.
     const String* separator = NULL;
-    switch (kind) {
+    switch (curr) {
       case Token::kLBRACE:
         indent++;
         separator = &newline;
         break;
       case Token::kRBRACE:
         if (indent == 0) {
           separator = &two_newlines;
         } else {
           separator = &newline;
         }
         break;
       case Token::kSEMICOLON:
         separator = &newline;
         break;
       case Token::kPERIOD:
       case Token::kLPAREN:
+      case Token::kLBRACK:
+      case Token::kTIGHTADD:
+      case Token::kINTERPOL_VAR:
+      case Token::kINTERPOL_START:
+      case Token::kINTERPOL_END:
         break;
       default:
         separator = &blank;
         break;
     }
-    // Advance the iterator.
-    iterator.Advance();
-    kind = iterator.CurrentTokenKind();
     // Determine whether the separation text needs to be updated based on the
     // next token.
-    switch (kind) {
+    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 = &blank;
       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 = &blank;
+    } else if ((curr == Token::kASSIGN) && (next == Token::kLPAREN)) {
+      separator = & blank;
+    } else if ((curr == Token::kLBRACE) && (next == Token::kRBRACE)) {
+      separator = NULL;
+    }
     if (separator != NULL) {
       literals.Add(*separator);
       if (separator == &newline) {
         for (int i = 0; i < indent; i++) {
           literals.Add(two_spaces);
         }
       }
     }
+    // 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 {
   Iterator iterator(*this, 0);
   intptr_t src_pos = 0;
   Token::Kind kind = iterator.CurrentTokenKind();
@@ skipping 167 matching lines @@
   GrowableArray<intptr_t> literal_table_[kTableSize];
   const GrowableObjectArray& token_objects_;
   Object& token_obj_;
   LiteralToken& literal_token_;
   String& literal_str_;
 
   DISALLOW_COPY_AND_ASSIGN(CompressedTokenStreamData);
 };
 
 
-RawTokenStream* TokenStream::New(const Scanner::GrowableTokenStream& tokens) {
+RawTokenStream* TokenStream::New(const Scanner::GrowableTokenStream& tokens,
+                                 const String& private_key) {
   // Copy the relevant data out of the scanner into a compressed stream of
   // tokens.
   CompressedTokenStreamData data;
   intptr_t len = tokens.length();
   for (intptr_t i = 0; i < len; i++) {
     Scanner::TokenDescriptor token = tokens[i];
     if (token.kind == Token::kIDENT) {  // Identifier token.
       if (FLAG_compiler_stats) {
         CompilerStats::num_ident_tokens_total += 1;
       }
       data.AddIdentToken(token.literal);
     } else if (Token::NeedsLiteralToken(token.kind)) {  // Literal token.
       if (FLAG_compiler_stats) {
         CompilerStats::num_literal_tokens_total += 1;
       }
       data.AddLiteralToken(token.kind, token.literal);
     } else {  // Keyword, pseudo keyword etc.
       ASSERT(token.kind < Token::kNumTokens);
       data.AddSimpleToken(token.kind);
     }
   }
   if (FLAG_compiler_stats) {
     CompilerStats::num_tokens_total += len;
   }
   data.AddSimpleToken(Token::kEOS);  // End of stream.
 
   // Create and setup the token stream object.
   const TokenStream& result = TokenStream::Handle(New(data.Length()));
+  result.SetPrivateKey(private_key);
   {
     NoGCScope no_gc;
     memmove(result.EntryAddr(0), data.GetStream(), data.Length());
     const Array& tokens = Array::Handle(Array::MakeArray(data.TokenObjects()));
     result.SetTokenObjects(tokens);
   }
   return result.raw();
 }
 
 
@@ skipping 183 matching lines @@
   const TokenStream& tkns = TokenStream::Handle(tokens());
   if (!tkns.IsNull()) {
     // Already tokenized.
     return;
   }
 
   // Get the source, scan and allocate the token stream.
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::scanner_timer);
   const String& src = String::Handle(Source());
   Scanner scanner(src, private_key);
-  set_tokens(TokenStream::Handle(TokenStream::New(scanner.GetStream())));
+  set_tokens(TokenStream::Handle(TokenStream::New(scanner.GetStream(),
+                                                  private_key)));
   if (FLAG_compiler_stats) {
     CompilerStats::src_length += src.Length();
   }
 }
 
 
 void Script::GetTokenLocation(intptr_t token_pos,
                               intptr_t* line,
                               intptr_t* column) const {
   const String& src = String::Handle(Source());
@@ skipping 5920 matching lines @@
 const char* JSRegExp::ToCString() const {
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart