- Ensure that the token stream from generated source matches the

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 6215 matching lines @@
     // 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);
+  Iterator iterator(*this, 0, Iterator::kAllTokens);
   intptr_t src_pos = 0;
   Token::Kind kind = iterator.CurrentTokenKind();
   while (iterator.CurrentPosition() < tok_pos && kind != Token::kEOS) {
     iterator.Advance();
     kind = iterator.CurrentTokenKind();
     src_pos += 1;
   }
   return src_pos;
 }
 
 
-intptr_t TokenStream::ComputeTokenPosition(intptr_t src_pos) const {
-  Iterator iterator(*this, 0);
-  intptr_t index = 0;
-  Token::Kind kind = iterator.CurrentTokenKind();
-  while (index < src_pos && kind != Token::kEOS) {
-    iterator.Advance();
-    kind = iterator.CurrentTokenKind();
-    index += 1;
-  }
-  return iterator.CurrentPosition();
-}
-
-
 RawTokenStream* TokenStream::New() {
   ASSERT(Object::token_stream_class() != Class::null());
   RawObject* raw = Object::Allocate(TokenStream::kClassId,
                                     TokenStream::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawTokenStream*>(raw);
 }
 
 
 RawTokenStream* TokenStream::New(intptr_t len) {
@@ skipping 24 matching lines @@
           GrowableObjectArray::New(kInitialTokenCount, Heap::kOld))),
       token_obj_(Object::Handle()),
       literal_token_(LiteralToken::Handle()),
       literal_str_(String::Handle()) {
     token_objects_.Add(Object::null_string());
   }
   ~CompressedTokenStreamData() {
   }
 
   // Add an IDENT token into the stream and the token objects array.
-  void AddIdentToken(String* ident) {
+  void AddIdentToken(const String* ident) {
     if (ident != NULL) {
       // If the IDENT token is already in the tokens object array use the
       // same index instead of duplicating it.
       intptr_t index = FindIdentIndex(ident);
       if (index == -1) {
         WriteIndex(token_objects_.Length());
         ASSERT(ident != NULL);
         token_objects_.Add(*ident);
       } else {
         WriteIndex(index);
       }
     } else {
       WriteIndex(0);
     }
   }
 
   // Add a LITERAL token into the stream and the token objects array.
-  void AddLiteralToken(Token::Kind kind, String* literal) {
+  void AddLiteralToken(Token::Kind kind, const String* literal) {
     if (literal != NULL) {
       // If the literal token is already in the tokens object array use the
       // same index instead of duplicating it.
       intptr_t index = FindLiteralIndex(kind, literal);
       if (index == -1) {
         WriteIndex(token_objects_.Length());
         ASSERT(literal != NULL);
         literal_token_ = LiteralToken::New(kind, *literal);
         token_objects_.Add(literal_token_);
       } else {
@@ skipping 14 matching lines @@
 
   // Return the compressed token stream length.
   intptr_t Length() const { return stream_.bytes_written(); }
 
   // Return the token objects array.
   const GrowableObjectArray& TokenObjects() const {
     return token_objects_;
   }
 
  private:
-  intptr_t FindIdentIndex(String* ident) {
+  intptr_t FindIdentIndex(const String* ident) {
     ASSERT(ident != NULL);
     intptr_t hash_value = ident->Hash() % kTableSize;
     GrowableArray<intptr_t>& value = ident_table_[hash_value];
     for (intptr_t i = 0; i < value.length(); i++) {
       intptr_t index = value[i];
       token_obj_ = token_objects_.At(index);
       if (token_obj_.IsString()) {
         const String& ident_str = String::Cast(token_obj_);
         if (ident->Equals(ident_str)) {
           return index;
         }
       }
     }
     value.Add(token_objects_.Length());
     return -1;
   }
 
-  intptr_t FindLiteralIndex(Token::Kind kind, String* literal) {
+  intptr_t FindLiteralIndex(Token::Kind kind, const String* literal) {
     ASSERT(literal != NULL);
     intptr_t hash_value = literal->Hash() % kTableSize;
     GrowableArray<intptr_t>& value = literal_table_[hash_value];
     for (intptr_t i = 0; i < value.length(); i++) {
       intptr_t index = value[i];
       token_obj_ = token_objects_.At(index);
       if (token_obj_.IsLiteralToken()) {
         const LiteralToken& token = LiteralToken::Cast(token_obj_);
         literal_str_ = token.literal();
         if (kind == token.kind() && literal->Equals(literal_str_)) {
@@ skipping 9180 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart