Remove CONST_LEGACY VariableMode

src/parsing/parser.cc

 // Copyright 2012 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.
 
 #include "src/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast.h"
@@ skipping 1970 matching lines @@
   Declaration* declaration =
       factory()->NewVariableDeclaration(proxy, scope(), pos);
   Declare(declaration, DeclarationDescriptor::NORMAL, mode, init, CHECK_OK);
   return declaration;
 }
 
 Variable* Parser::Declare(Declaration* declaration,
                           DeclarationDescriptor::Kind declaration_kind,
                           VariableMode mode, InitializationFlag init, bool* ok,
                           Scope* scope) {
-  DCHECK(IsDeclaredVariableMode(mode) && mode != CONST_LEGACY);
+  DCHECK(IsDeclaredVariableMode(mode));
 
   VariableProxy* proxy = declaration->proxy();
   DCHECK(proxy->raw_name() != NULL);
   const AstRawString* name = proxy->raw_name();
 
   if (scope == nullptr) scope = this->scope();
   if (mode == VAR) scope = scope->GetDeclarationScope();
   DCHECK(!scope->is_catch_scope());
   DCHECK(!scope->is_with_scope());
   DCHECK(scope->is_declaration_scope() ||
@@ skipping 40 matching lines @@
                 const_cast<AstRawString*>(name), name->hash()) != nullptr &&
             !IsAsyncFunction(function_kind) &&
             !(allow_harmony_restrictive_generators() &&
               IsGeneratorFunction(function_kind));
       }
       if (duplicate_allowed) {
         ++use_counts_[v8::Isolate::kSloppyModeBlockScopedFunctionRedefinition];
       } else {
         // The name was declared in this scope before; check for conflicting
         // re-declarations. We have a conflict if either of the declarations
-        // is not a var (in script scope, we also have to ignore legacy const
-        // for compatibility). There is similar code in runtime.cc in the
+        // is not a var. There is similar code in runtime.cc in the
         // Declare functions. The function CheckConflictingVarDeclarations
         // checks for var and let bindings from different scopes whereas this
         // is a check for conflicting declarations within the same scope. This
         // check also covers the special case
         //
         // function () { let x; { var x; } }
         //
         // because the var declaration is hoisted to the function scope where
         // 'x' is already bound.
         DCHECK(IsDeclaredVariableMode(var->mode()));
@@ skipping 5019 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8