Use a single Token::INIT for all variable initialization

src/preparser.h

 // 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.
 
 #ifndef V8_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/bailout-reason.h"
 #include "src/expression-classifier.h"
 #include "src/func-name-inferrer.h"
@@ skipping 2995 matching lines @@
   if (op == Token::ASSIGN && this->IsThisProperty(expression)) {
     function_state_->AddProperty();
   }
 
   this->CheckAssigningFunctionLiteralToProperty(expression, right);
 
   if (fni_ != NULL) {
     // Check if the right hand side is a call to avoid inferring a
     // name if we're dealing with "a = function(){...}();"-like
     // expression.
-    if ((op == Token::INIT_VAR
-         || op == Token::INIT_CONST_LEGACY
-         || op == Token::ASSIGN)
-        && (!right->IsCall() && !right->IsCallNew())) {
+    if ((op == Token::INIT || op == Token::ASSIGN) &&
+        (!right->IsCall() && !right->IsCallNew())) {
       fni_->Infer();
     } else {
       fni_->RemoveLastFunction();
     }
     fni_->Leave();
   }
 
   return factory()->NewAssignment(op, expression, right, pos);
 }
 
@@ skipping 292 matching lines @@
           args = Traits::PrepareSpreadArguments(args);
           result = Traits::SpreadCall(result, args, pos);
         } else {
           result = factory()->NewCall(result, args, pos);
         }
 
         // Explicit calls to the super constructor using super() perform an
         // implicit binding assignment to the 'this' variable.
         if (is_super_call) {
           ExpressionT this_expr = this->ThisExpression(scope_, factory(), pos);
-          result = factory()->NewAssignment(Token::INIT_CONST, this_expr,
-                                            result, pos);
+          result =
+              factory()->NewAssignment(Token::INIT, this_expr, result, pos);
         }
 
         if (fni_ != NULL) fni_->RemoveLastFunction();
         break;
       }
 
       case Token::PERIOD: {
         BindingPatternUnexpectedToken(classifier);
         ArrowFormalParametersUnexpectedToken(classifier);
         Consume(Token::PERIOD);
@@ skipping 266 matching lines @@
   if (spread_pos.IsValid()) {
     args = Traits::PrepareSpreadArguments(args);
     expr = Traits::SpreadCall(expr, args, pos);
   } else {
     expr = factory()->NewCall(expr, args, pos);
   }
 
   // Explicit calls to the super constructor using super() perform an implicit
   // binding assignment to the 'this' variable.
   ExpressionT this_expr = this->ThisExpression(scope_, factory(), pos);
-  return factory()->NewAssignment(Token::INIT_CONST, this_expr, expr, pos);
+  return factory()->NewAssignment(Token::INIT, this_expr, expr, pos);
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseSuperExpression(bool is_new,
                                          ExpressionClassifier* classifier,
                                          bool* ok) {
   int pos = position();
   Expect(Token::SUPER, CHECK_OK);
@@ skipping 568 matching lines @@
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PREPARSER_H