A decimal integer literal with a leading 0 is now an error in strict mode.

src/messages.h

 // Copyright 2006-2008 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.
 
 // The infrastructure used for (localized) message reporting in V8.
 //
 // Note: there's a big unresolved issue about ownership of the data
 // structures used by this framework.
 
 #ifndef V8_MESSAGES_H_
@@ skipping 576 matching lines @@
   T(SloppyFunction,                                                            \
     "In non-strict mode code, functions can only be declared at top level, "   \
     "inside a block, or as the body of an if statement.")                      \
   T(SpeciesNotConstructor,                                                     \
     "object.constructor[Symbol.species] is not a constructor")                 \
   T(StrictDelete, "Delete of an unqualified identifier in strict mode.")       \
   T(StrictEvalArguments, "Unexpected eval or arguments in strict mode")        \
   T(StrictFunction,                                                            \
     "In strict mode code, functions can only be declared at top level or "     \
     "inside a block.")                                                         \
-  T(StrictOctalLiteral, "Octal literals are not allowed in strict mode.")      \
+  T(StrictOctalLiteral,                                                        \
+    "Number literals must not have a '0' prefix in strict mode.")              \

[Dan Ehrenberg, 2016/11/18 17:13:51]

This isn't quite right. 0b1 is a number literal allowed in strict mode, for
example...

+  T(StrictOctalEscape,                                                         \
+    "Octal escape sequences are not allowed in strict mode.")                  \
   T(StrictWith, "Strict mode code may not include a with statement")           \
   T(TemplateOctalLiteral,                                                      \
-    "Octal literals are not allowed in template strings.")                     \
+    "Octal escape sequences are not allowed in template strings.")             \
   T(ThisFormalParameter, "'this' is not a valid formal parameter name")        \
   T(AwaitBindingIdentifier,                                                    \
     "'await' is not a valid identifier name in an async function")             \
   T(AwaitExpressionFormalParameter,                                            \
     "Illegal await-expression in formal parameters of async function")         \
   T(TooManyArguments,                                                          \
     "Too many arguments in function call (only 65535 allowed)")                \
   T(TooManyParameters,                                                         \
     "Too many parameters in function definition (only 65535 allowed)")         \
   T(TooManySpreads,                                                            \
@@ skipping 93 matching lines @@
   static Handle<String> GetMessage(Isolate* isolate, Handle<Object> data);
   static std::unique_ptr<char[]> GetLocalizedMessage(Isolate* isolate,
                                                      Handle<Object> data);
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_MESSAGES_H_