Handle "//# sourceURL" comments in the Parser instead of the JS.

src/scanner.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Features shared by parsing and pre-parsing scanners.
 
 #include <cmath>
 
 #include "src/scanner.h"
 
 #include "include/v8stdint.h"
 #include "src/char-predicates-inl.h"
 #include "src/conversions-inl.h"
 #include "src/list-inl.h"
 #include "src/v8.h"
 #include "src/parser.h"
 
 namespace v8 {
 namespace internal {
 
+
+Handle<String> LiteralBuffer::Internalize(Isolate* isolate) const {
+  if (is_one_byte()) {
+    return isolate->factory()->InternalizeOneByteString(one_byte_literal());
+  }
+  return isolate->factory()->InternalizeTwoByteString(two_byte_literal());
+}
+
+
 // ----------------------------------------------------------------------------
 // Scanner
 
 Scanner::Scanner(UnicodeCache* unicode_cache)
     : unicode_cache_(unicode_cache),
       octal_pos_(Location::invalid()),
       harmony_scoping_(false),
       harmony_modules_(false),
       harmony_numeric_literals_(false) { }
 
@@ skipping 256 matching lines @@
   // stream of input elements for the syntactic grammar (see
   // ECMA-262, section 7.4).
   while (c0_ >= 0 && !unicode_cache_->IsLineTerminator(c0_)) {
     Advance();
   }
 
   return Token::WHITESPACE;
 }
 
 
+Token::Value Scanner::SkipMagicComment() {
+  TryToParseMagicComment();
+  while (c0_ >= 0 && !unicode_cache_->IsLineTerminator(c0_)) {
+    Advance();
+  }
+
+  return Token::WHITESPACE;
+}
+
+
+void Scanner::TryToParseMagicComment() {
+  // Magic comments are of the form: //[#@]\s<name>=\s*<value>\s*.* and this
+  // function will just return if it cannot parse a magic comment.
+  if (!unicode_cache_->IsWhiteSpace(c0_))
+    return;
+  Advance();
+  LiteralBuffer name;
+  while (c0_ >= 0 && !unicode_cache_->IsWhiteSpaceOrLineTerminator(c0_) &&
+         c0_ != '=') {
+    name.AddChar(c0_);
+    Advance();
+  }
+  if (!name.is_one_byte()) return;
+  Vector<const uint8_t> name_literal = name.one_byte_literal();
+  LiteralBuffer* value;
+  if (name_literal.IsEqualTo(STATIC_ASCII_VECTOR("sourceURL"))) {
+    value = &source_url_;
+  } else if (name_literal.IsEqualTo(STATIC_ASCII_VECTOR("sourceMappingURL"))) {
+    value = &source_mapping_url_;
+  } else {
+    return;
+  }
+  if (c0_ != '=')
+    return;
+  Advance();
+  value->Reset();
+  while (c0_ >= 0 && unicode_cache_->IsWhiteSpace(c0_)) {
+    Advance();
+  }
+  while (c0_ >= 0 && !unicode_cache_->IsWhiteSpaceOrLineTerminator(c0_)) {

[yurys, 2014/06/10 14:41:04]

This will stop at first whitepace while ContentSearchUtils.cpp would parse till
the end of line. Not sure which one we should prefer though.

//# sourceURL=foo bar \n

[yurys, 2014/06/10 14:46:53]

As Vsevolod pointed out sourceURLs that contain whitspaces will be ignored by
current implementation. So we should probably preserve this behavior.

https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

+    value->AddChar(c0_);
+    Advance();
+  }
+}
+
+
 Token::Value Scanner::SkipMultiLineComment() {
   ASSERT(c0_ == '*');
   Advance();
 
   while (c0_ >= 0) {
     uc32 ch = c0_;
     Advance();
     if (unicode_cache_->IsLineTerminator(ch)) {
       // Following ECMA-262, section 7.4, a comment containing
       // a newline will make the comment count as a line-terminator.
@@ skipping 144 matching lines @@
 
       case '%':
         // % %=
         token = Select('=', Token::ASSIGN_MOD, Token::MOD);
         break;
 
       case '/':
         // /  // /* /=
         Advance();
         if (c0_ == '/') {
-          token = SkipSingleLineComment();
+          Advance();
+          if (c0_ == '@' || c0_ == '#') {
+            Advance();
+            token = SkipMagicComment();
+          } else {
+            PushBack(c0_);
+            token = SkipSingleLineComment();
+          }
         } else if (c0_ == '*') {
           token = SkipMultiLineComment();
         } else if (c0_ == '=') {
           token = Select(Token::ASSIGN_DIV);
         } else {
           token = Token::DIV;
         }
         break;
 
       case '&':
@@ skipping 627 matching lines @@
     return isolate->factory()->NewStringFromOneByte(
         next_literal_one_byte_string(), tenured).ToHandleChecked();
   } else {
     return isolate->factory()->NewStringFromTwoByte(
         next_literal_two_byte_string(), tenured).ToHandleChecked();
   }
 }
 
 
 Handle<String> Scanner::AllocateInternalizedString(Isolate* isolate) {
-  if (is_literal_one_byte()) {
-    return isolate->factory()->InternalizeOneByteString(
-        literal_one_byte_string());
-  } else {
-    return isolate->factory()->InternalizeTwoByteString(
-        literal_two_byte_string());
-  }
+  return current_.literal_chars->Internalize(isolate);
 }
 
 
 double Scanner::DoubleValue() {
   ASSERT(is_literal_one_byte());
   return StringToDouble(
       unicode_cache_,
       literal_one_byte_string(),
       ALLOW_HEX | ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL | ALLOW_BINARY);
 }
@@ skipping 145 matching lines @@
     }
     backing_store_.Add(static_cast<uint8_t>((one_byte_length >> 7) | 0x80u));
   }
   backing_store_.Add(static_cast<uint8_t>(one_byte_length & 0x7f));
 
   backing_store_.AddBlock(bytes);
   return backing_store_.EndSequence().start();
 }
 
 } }  // namespace v8::internal