Replace rest_index_ with has_rest_

src/ast/scopes.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_AST_SCOPES_H_
 #define V8_AST_SCOPES_H_
 
 #include "src/ast/ast.h"
 #include "src/base/hashmap.h"
 #include "src/globals.h"
@@ skipping 712 matching lines @@
   //
   //   function foo(a, b, c = 1) { ... }
   //
   // we return 3 here.
   int num_parameters() const {
     return has_rest_parameter() ? params_.length() - 1 : params_.length();
   }
 
   // A function can have at most one rest parameter. Returns Variable* or NULL.
   Variable* rest_parameter(int* index) const {
-    *index = rest_index_;
-    if (rest_index_ < 0) return nullptr;
-    return params_[rest_index_];
+    if (!has_rest_parameter()) return nullptr;
+    *index = params_.length() - 1;
+    return rest_parameter();
+  }
+  Variable* rest_parameter() const {
+    DCHECK(has_rest_parameter());
+    return params_[params_.length() - 1];
   }
 
-  bool has_rest_parameter() const { return rest_index_ >= 0; }
+  bool has_rest_parameter() const { return has_rest_; }
 
   bool has_simple_parameters() const { return has_simple_parameters_; }
 
   // TODO(caitp): manage this state in a better way. PreParser must be able to
   // communicate that the scope is non-simple, without allocating any parameters
   // as the Parser does. This is necessary to ensure that TC39's proposed early
   // error can be reported consistently regardless of whether lazily parsed or
   // not.
   void SetHasNonSimpleParameters() {
     DCHECK(is_function_scope());
@@ skipping 87 matching lines @@
 
   // If the scope is a function scope, this is the function kind.
   const FunctionKind function_kind_;
 
   bool has_simple_parameters_ : 1;
   // This scope contains an "use asm" annotation.
   bool asm_module_ : 1;
   // This scope's outer context is an asm module.
   bool asm_function_ : 1;
   bool force_eager_compilation_ : 1;
+  // This function scope has a rest parameter.
+  bool has_rest_ : 1;
   // This scope has a parameter called "arguments".
   bool has_arguments_parameter_ : 1;
   // This scope uses "super" property ('super.foo').
   bool scope_uses_super_property_ : 1;
 
   // Info about the parameter list of a function.
   int arity_;
-  int rest_index_;
   // Compiler-allocated (user-invisible) temporaries.
   ZoneList<Variable*> temps_;
   // Parameter list in source order.
   ZoneList<Variable*> params_;
   // Map of function names to lists of functions defined in sloppy blocks
   SloppyBlockFunctionMap sloppy_block_function_map_;
   // Convenience variable.
   Variable* receiver_;
   // Function variable, if any; function scopes only.
   Variable* function_;
@@ skipping 20 matching lines @@
   void AllocateModuleVariables();
 
  private:
   ModuleDescriptor* module_descriptor_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_