Make multi-line comments not count when checking whether --> is first on a line.

src/scanner-base.cc

 // Copyright 2011 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 62 matching lines @@
 // ----------------------------------------------------------------------------
 // JavaScriptScanner
 
 JavaScriptScanner::JavaScriptScanner(UnicodeCache* scanner_contants)
   : Scanner(scanner_contants), octal_pos_(Location::invalid()) { }
 
 
 Token::Value JavaScriptScanner::Next() {
   current_ = next_;
   has_line_terminator_before_next_ = false;
+  next_is_first_on_line_ = false;

[William Hesse, 2011/06/21 11:37:41]

Could we call these things something more parallel, like:
has_line_terminator_before_next and
has_line_terminator_outside_comment_before_next
or
saw_line_terminator_outside_comment
saw_line_terminator_inside_comment?

The meanings and algorithm would be clearer.

Or better yet:
newline_before_current_token  and
multiline_comment_before_current_token.
The condition for handling --> would be newline_before...
and the condition for automatic semicolon insertion
would be newline_before... || multiline_comment_before...

   Scan();
   return current_.token;
 }
 
 
 static inline bool IsByteOrderMark(uc32 c) {
   // The Unicode value U+FFFE is guaranteed never to be assigned as a
   // Unicode character; this implies that in a Unicode context the
   // 0xFF, 0xFE byte pattern can only be interpreted as the U+FEFF
   // character expressed in little-endian byte order (since it could
   // not be a U+FFFE character expressed in big-endian byte
   // order). Nevertheless, we check for it to be compatible with
   // Spidermonkey.
   return c == 0xFEFF || c == 0xFFFE;
 }
 
 
 bool JavaScriptScanner::SkipWhiteSpace() {
   int start_position = source_pos();
 
   while (true) {
     // We treat byte-order marks (BOMs) as whitespace for better
     // compatibility with Spidermonkey and other JavaScript engines.
     while (unicode_cache_->IsWhiteSpace(c0_) || IsByteOrderMark(c0_)) {
       // IsWhiteSpace() includes line terminators!
       if (unicode_cache_->IsLineTerminator(c0_)) {
         // Ignore line terminators, but remember them. This is necessary
         // for automatic semicolon insertion.
         has_line_terminator_before_next_ = true;
+        next_is_first_on_line_ = true;
       }
       Advance();
     }
 
     // If there is an HTML comment end '-->' at the beginning of a
     // line (with only whitespace in front of it), we treat the rest
     // of the line as a comment. This is in line with the way
     // SpiderMonkey handles it.
-    if (c0_ == '-' && has_line_terminator_before_next_) {
+    if (c0_ == '-' && next_is_first_on_line_) {
       Advance();
       if (c0_ == '-') {
         Advance();
         if (c0_ == '>') {
           // Treat the rest of the line as a comment.
           SkipSingleLineComment();
           // Continue skipping white space after the comment.
           continue;
         }
         PushBack('-');  // undo Advance()
@@ skipping 29 matching lines @@
   while (c0_ >= 0) {
     char 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.
       has_line_terminator_before_next_ = true;
     }
     // If we have reached the end of the multi-line comment, we
     // consume the '/' and insert a whitespace. This way all
-    // multi-line comments are treated as whitespace.
+    // multi-line comments are treated as whitespace (except
+    // when checking whether there is non-whitespace before a
+    // --> comment).
     if (ch == '*' && c0_ == '/') {
       c0_ = ' ';
       return Token::WHITESPACE;
     }
   }
 
   // Unterminated multi-line comment.
   return Token::ILLEGAL;
 }
 
@@ skipping 23 matching lines @@
     switch (c0_) {
       case ' ':
       case '\t':
         Advance();
         token = Token::WHITESPACE;
         break;
 
       case '\n':
         Advance();
         has_line_terminator_before_next_ = true;
+        next_is_first_on_line_ = true;
         token = Token::WHITESPACE;
         break;
 
       case '"': case '\'':
         token = ScanString();
         break;
 
       case '<':
         // < <= << <<= <!--
         Advance();
@@ skipping 58 matching lines @@
         } else {
           token = Token::ADD;
         }
         break;
 
       case '-':
         // - -- --> -=
         Advance();
         if (c0_ == '-') {
           Advance();
-          if (c0_ == '>' && has_line_terminator_before_next_) {
+          if (c0_ == '>' && next_is_first_on_line_) {
             // For compatibility with SpiderMonkey, we skip lines that
             // start with an HTML comment end '-->'.
             token = SkipSingleLineComment();
           } else {
             token = Token::DEC;
           }
         } else if (c0_ == '=') {
           token = Select(Token::ASSIGN_SUB);
         } else {
           token = Token::SUB;
@@ skipping 640 matching lines @@
       if (MatchKeywordStart(input, "with", 1, Token::WITH)) return;
       break;
     case UNMATCHABLE:
       break;
   }
   // On fallthrough, it's a failure.
   state_ = UNMATCHABLE;
 }
 
 } }  // namespace v8::internal