Remove vestigial legacy const handling from parser

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 "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 1964 matching lines @@
   // bound during variable resolution time unless it was pre-bound
   // below.
   //
   // WARNING: This will lead to multiple declaration nodes for the
   // same variable if it is declared several times. This is not a
   // semantic issue as long as we keep the source order, but it may be
   // a performance issue since it may lead to repeated
   // RuntimeHidden_DeclareLookupSlot calls.
   declaration_scope->AddDeclaration(declaration);
 
-  if (mode == CONST_LEGACY && declaration_scope->is_script_scope()) {
-    // For global const variables we bind the proxy to a variable.
-    DCHECK(resolve);  // should be set by all callers
-    Variable::Kind kind = Variable::NORMAL;
-    var = new (zone()) Variable(declaration_scope, name, mode, kind,
-                                kNeedsInitialization, kNotAssigned);
-  }
-
   // If requested and we have a local variable, bind the proxy to the variable
   // at parse-time. This is used for functions (and consts) declared inside
   // statements: the corresponding function (or const) variable must be in the
   // function scope and not a statement-local scope, e.g. as provided with a
   // 'with' statement:
   //
   //   with (obj) {
   //     function f() {}
   //   }
   //
@@ skipping 356 matching lines @@
         if (parsing_result->descriptor.mode == CONST ||
             !pattern->IsVariableProxy()) {
           ParserTraits::ReportMessageAt(
               Scanner::Location(decl_pos, scanner()->location().end_pos),
               MessageTemplate::kDeclarationMissingInitializer,
               !pattern->IsVariableProxy() ? "destructuring" : "const");
           *ok = false;
           return nullptr;
         }
 
-        // 'let x' and (legacy) 'const x' initialize 'x' to undefined.
-        if (parsing_result->descriptor.mode == LET ||
-            parsing_result->descriptor.mode == CONST_LEGACY) {
+        // 'let x' initializes 'x' to undefined.
+        if (parsing_result->descriptor.mode == LET) {

[caitp (gmail), 2016/04/14 00:17:30]

This is not really the job of this CL, but this looks wrong, there shouldn't be
an implicit initializer for a let variable. Maybe a TODO() is in order?

[caitp (gmail), 2016/04/14 00:25:16]

eh, other vendors seem to behave the same, did the spec change? I thought these
were hole-y until assigned

[adamk, 2016/04/14 00:37:24]

Nope, nothing recent here. Let variables are hole-initialized when we enter the
scope (to throw TDZ errors as appropriate), and then undefined-initialized then
we reach the declaration. I would believe this changed during the genesis of
ES6, but this is definitely what the spec says now :)

           value = GetLiteralUndefined(position());
         }
       }
 
       // End position of the initializer is after the variable.
       initializer_position = position();
     }
 
     DeclarationParsingResult::Declaration decl(pattern, initializer_position,
                                                value);
@@ skipping 4477 matching lines @@
                         try_block, target);
     final_loop = target;
   }
 
   return final_loop;
 }
 
 
 }  // namespace internal
 }  // namespace v8