Experimental parser: fix two byte to one byte allocation

src/lexer/lexer.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 690 matching lines @@
 }
 
 
 template<class Char>
 Handle<String> Lexer<Char>::AllocateInternalizedString(
     Isolate* isolate) {
   Factory* factory = isolate->factory();
   LiteralDesc* literal = current_literal_;
   const TokenDesc& token = current_;
   // TODO(dcarney): handle utf8 directly.
-  if (source_handle_.is_null()  || MustBeInBuffer(token)) {
+  if (source_handle_.is_null()  || MustBeInBufferForAllocation(token)) {
     EnsureLiteralIsValid(token, literal);
     return literal->is_one_byte() ?
         factory->InternalizeOneByteString(literal->one_byte_string()) :
         factory->InternalizeTwoByteString(literal->two_byte_string());
   }
   int offset = 0, length = 0;
   LiteralOffsetAndLength<Char>(buffer_, token, &offset, &length);
   if (sizeof(Char) == 1) {
     SubStringKey<uint8_t> key(source_handle_, offset, length);
     return factory->InternalizeStringWithKey(&key);
   } else {
     SubStringKey<uint16_t> key(source_handle_, offset, length);
     return factory->InternalizeStringWithKey(&key);
   }
 }
 
 
 template<class Char>
 Handle<String> Lexer<Char>::AllocateNextLiteralString(Isolate* isolate,
                                                       PretenureFlag tenured) {
   Factory* factory = isolate->factory();
   LiteralDesc* literal = next_literal_;
   const TokenDesc& token = next_;
   // TODO(dcarney): handle utf8 directly.
-  if (source_handle_.is_null()  || MustBeInBuffer(token)) {
+  if (source_handle_.is_null()  || MustBeInBufferForAllocation(token)) {
     EnsureLiteralIsValid(token, literal);
     return literal->is_one_byte() ?
         factory->NewStringFromOneByte(literal->one_byte_string(), tenured) :
         factory->NewStringFromTwoByte(
             literal->two_byte_string(), false, tenured);
   }
   int offset = 0, length = 0;
   LiteralOffsetAndLength<Char>(buffer_, token, &offset, &length);
   return factory->NewSubString(source_handle_, offset, offset + length);
 }
 
 
 template class Lexer<uint8_t>;
 template class Lexer<uint16_t>;
 template class Lexer<int8_t>;
 
 } }  // v8::internal