add UseCounters for NonOctalDecimalIntegerLiteral in strict mode

src/parsing/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 "src/parsing/scanner.h"
 
 #include <stdint.h>
 
@@ skipping 958 matching lines @@
 void Scanner::ScanDecimalDigits() {
   while (IsDecimalDigit(c0_))
     AddLiteralCharAdvance();
 }
 
 
 Token::Value Scanner::ScanNumber(bool seen_period) {
   DCHECK(IsDecimalDigit(c0_));  // the first digit of the number or the fraction
 
   enum { DECIMAL, HEX, OCTAL, IMPLICIT_OCTAL, BINARY } kind = DECIMAL;
+  bool decimal_that_looks_like_octal = false;
 
   LiteralScope literal(this);
   bool at_start = !seen_period;
+  int start_pos = source_pos();  // For reporting octal positions.
   if (seen_period) {
     // we have already seen a decimal point of the float
     AddLiteralChar('.');
     ScanDecimalDigits();  // we know we have at least one digit
 
   } else {
     // if the first character is '0' we must check for octals and hex
     if (c0_ == '0') {
-      int start_pos = source_pos();  // For reporting octal positions.

[caitp (gmail), 2016/05/05 18:25:02]

This change seems not to be needed, since it's irrelevant when the number
doesn't begin with 0

[jwolfe, 2016/05/05 18:42:02]

I can leave the local variable uninitialized until this line. I just need to
declare it out where the later code can see it.

I would have loved to have dealt with `octal_pos_` inside the `c0_ == '0'`
block, but I didn't know where the end of the token was going to be yet.

       AddLiteralCharAdvance();
 
       // either 0, 0exxx, 0Exxx, 0.xxx, a hex number, a binary number or
       // an octal number.
       if (c0_ == 'x' || c0_ == 'X') {
         // hex number
         kind = HEX;
         AddLiteralCharAdvance();
         if (!IsHexDigit(c0_)) {
           // we must have at least one hex digit after 'x'/'X'
@@ skipping 22 matching lines @@
         while (IsBinaryDigit(c0_)) {
           AddLiteralCharAdvance();
         }
       } else if ('0' <= c0_ && c0_ <= '7') {
         // (possible) octal number
         kind = IMPLICIT_OCTAL;
         while (true) {
           if (c0_ == '8' || c0_ == '9') {
             at_start = false;
             kind = DECIMAL;
+            decimal_that_looks_like_octal = true;

[caitp (gmail), 2016/05/05 18:21:08]

'8' and '9' are decidedly not octal digits --- why are we saying this looks
octal? Just confused about what problem this solves

             break;
           }
           if (c0_  < '0' || '7'  < c0_) {
             // Octal literal finished.
             octal_pos_ = Location(start_pos, source_pos());
             break;
           }
           AddLiteralCharAdvance();
         }
+      } else if (c0_ == '8' || c0_ == '9') {
+        decimal_that_looks_like_octal = true;
       }
     }
 
     // Parse decimal digits and allow trailing fractional part.
     if (kind == DECIMAL) {
       if (at_start) {
         uint64_t value = 0;
         while (IsDecimalDigit(c0_)) {
           value = 10 * value + (c0_ - '0');
 
           uc32 first_char = c0_;
           Advance<false, false>();
           AddLiteralChar(first_char);
         }
 
         if (next_.literal_chars->one_byte_literal().length() <= 10 &&
             value <= Smi::kMaxValue && c0_ != '.' && c0_ != 'e' && c0_ != 'E') {
           next_.smi_value_ = static_cast<int>(value);
           literal.Complete();
           HandleLeadSurrogate();
 
+          if (decimal_that_looks_like_octal)

[caitp (gmail), 2016/05/05 18:25:02]

`decimal_that_looks_like_octal` is always false unless the `c0_ == '0'` branch
is taken on line 991 --- these should be safe to get rid of, AFAIK?

[jwolfe, 2016/05/05 18:42:01]

I was surprised by needing two different checks in this function. This check is
for `09`, and the one on line 1107 is for `019`. I don't know why `019` isn't
reported as a SMI token by this function. Perhaps it's a mistake?

+            octal_pos_ = Location(start_pos, source_pos());
           return Token::SMI;
         }
         HandleLeadSurrogate();
       }
 
       ScanDecimalDigits();  // optional
       if (c0_ == '.') {
         AddLiteralCharAdvance();
         ScanDecimalDigits();  // optional
       }
@@ skipping 18 matching lines @@
   // The source character immediately following a numeric literal must
   // not be an identifier start or a decimal digit; see ECMA-262
   // section 7.8.3, page 17 (note that we read only one decimal digit
   // if the value is 0).
   if (IsDecimalDigit(c0_) ||
       (c0_ >= 0 && unicode_cache_->IsIdentifierStart(c0_)))
     return Token::ILLEGAL;
 
   literal.Complete();
 
+  if (decimal_that_looks_like_octal)
+    octal_pos_ = Location(start_pos, source_pos());

[caitp (gmail), 2016/05/06 21:08:03]

So, if we want to have a different error message for this, we could save it as
`decimal_leading_zero_pos_` or something, and  pick which one to report in
CheckOctalLiteral()

   return Token::NUMBER;
 }
 
 
 uc32 Scanner::ScanIdentifierUnicodeEscape() {
   Advance();
   if (c0_ != 'u') return -1;
   Advance();
   return ScanUnicodeEscape<false>();
 }
@@ skipping 576 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 internal
 }  // namespace v8