Revert of Remove redundant ParseInfo::scope_.

src/parsing/parser.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_PARSING_PARSER_H_
 #define V8_PARSING_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
@@ skipping 22 matching lines @@
   ParseInfo(Zone* zone, Handle<SharedFunctionInfo> shared);
 
   ~ParseInfo() {
     if (ast_value_factory_owned()) {
       delete ast_value_factory_;
       set_ast_value_factory_owned(false);
     }
     ast_value_factory_ = nullptr;
   }
 
-  Zone* zone() const { return zone_; }
+  Zone* zone() { return zone_; }
 
 // Convenience accessor methods for flags.
 #define FLAG_ACCESSOR(flag, getter, setter)     \
   bool getter() const { return GetFlag(flag); } \
   void setter() { SetFlag(flag); }              \
   void setter(bool val) { SetFlag(flag, val); }
 
   FLAG_ACCESSOR(kToplevel, is_toplevel, set_toplevel)
   FLAG_ACCESSOR(kLazy, is_lazy, set_lazy)
   FLAG_ACCESSOR(kEval, is_eval, set_eval)
@@ skipping 12 matching lines @@
 
   void set_parse_restriction(ParseRestriction restriction) {
     SetFlag(kParseRestriction, restriction != NO_PARSE_RESTRICTION);
   }
 
   ParseRestriction parse_restriction() const {
     return GetFlag(kParseRestriction) ? ONLY_SINGLE_FUNCTION_LITERAL
                                       : NO_PARSE_RESTRICTION;
   }
 
-  ScriptCompiler::ExternalSourceStream* source_stream() const {
+  ScriptCompiler::ExternalSourceStream* source_stream() {
     return source_stream_;
   }
   void set_source_stream(ScriptCompiler::ExternalSourceStream* source_stream) {
     source_stream_ = source_stream;
   }
 
-  ScriptCompiler::StreamedSource::Encoding source_stream_encoding() const {
+  ScriptCompiler::StreamedSource::Encoding source_stream_encoding() {
     return source_stream_encoding_;
   }
   void set_source_stream_encoding(
       ScriptCompiler::StreamedSource::Encoding source_stream_encoding) {
     source_stream_encoding_ = source_stream_encoding;
   }
 
   Utf16CharacterStream* character_stream() const { return character_stream_; }
   void set_character_stream(Utf16CharacterStream* character_stream) {
     character_stream_ = character_stream;
   }
 
-  v8::Extension* extension() const { return extension_; }
+  v8::Extension* extension() { return extension_; }
   void set_extension(v8::Extension* extension) { extension_ = extension; }
 
-  ScriptData** cached_data() const { return cached_data_; }
+  ScriptData** cached_data() { return cached_data_; }
   void set_cached_data(ScriptData** cached_data) { cached_data_ = cached_data; }
 
-  ScriptCompiler::CompileOptions compile_options() const {
-    return compile_options_;
-  }
+  ScriptCompiler::CompileOptions compile_options() { return compile_options_; }
   void set_compile_options(ScriptCompiler::CompileOptions compile_options) {
     compile_options_ = compile_options;
   }
 
-  DeclarationScope* script_scope() const { return script_scope_; }
+  DeclarationScope* script_scope() { return script_scope_; }
   void set_script_scope(DeclarationScope* script_scope) {
     script_scope_ = script_scope;
   }
 
-  AstValueFactory* ast_value_factory() const { return ast_value_factory_; }
+  AstValueFactory* ast_value_factory() { return ast_value_factory_; }
   void set_ast_value_factory(AstValueFactory* ast_value_factory) {
     ast_value_factory_ = ast_value_factory;
   }
 
-  FunctionLiteral* literal() const { return literal_; }
+  FunctionLiteral* literal() { return literal_; }
   void set_literal(FunctionLiteral* literal) { literal_ = literal; }
 
-  DeclarationScope* scope() const { return literal()->scope(); }
+  DeclarationScope* scope() { return scope_; }
+  void set_scope(DeclarationScope* scope) { scope_ = scope; }
 
-  UnicodeCache* unicode_cache() const { return unicode_cache_; }
+  UnicodeCache* unicode_cache() { return unicode_cache_; }
   void set_unicode_cache(UnicodeCache* unicode_cache) {
     unicode_cache_ = unicode_cache;
   }
 
-  uintptr_t stack_limit() const { return stack_limit_; }
+  uintptr_t stack_limit() { return stack_limit_; }
   void set_stack_limit(uintptr_t stack_limit) { stack_limit_ = stack_limit; }
 
-  uint32_t hash_seed() const { return hash_seed_; }
+  uint32_t hash_seed() { return hash_seed_; }
   void set_hash_seed(uint32_t hash_seed) { hash_seed_ = hash_seed; }
 
   int compiler_hints() const { return compiler_hints_; }
   void set_compiler_hints(int compiler_hints) {
     compiler_hints_ = compiler_hints;
   }
 
   int start_position() const { return start_position_; }
   void set_start_position(int start_position) {
     start_position_ = start_position;
   }
 
   int end_position() const { return end_position_; }
   void set_end_position(int end_position) { end_position_ = end_position; }
 
   // Getters for individual compiler hints.
   bool is_declaration() const;
   bool is_arrow() const;
   bool is_async() const;
   bool is_default_constructor() const;
   FunctionKind function_kind() const;
 
   //--------------------------------------------------------------------------
   // TODO(titzer): these should not be part of ParseInfo.
   //--------------------------------------------------------------------------
-  Isolate* isolate() const { return isolate_; }
-  Handle<SharedFunctionInfo> shared_info() const { return shared_; }
-  Handle<Script> script() const { return script_; }
-  Handle<Context> context() const { return context_; }
+  Isolate* isolate() { return isolate_; }
+  Handle<SharedFunctionInfo> shared_info() { return shared_; }
+  Handle<Script> script() { return script_; }
+  Handle<Context> context() { return context_; }
   void clear_script() { script_ = Handle<Script>::null(); }
   void set_isolate(Isolate* isolate) { isolate_ = isolate; }
   void set_shared_info(Handle<SharedFunctionInfo> shared) { shared_ = shared; }
   void set_context(Handle<Context> context) { context_ = context; }
   void set_script(Handle<Script> script) { script_ = script; }
   //--------------------------------------------------------------------------
 
-  LanguageMode language_mode() const {
+  LanguageMode language_mode() {
     return construct_language_mode(is_strict_mode());
   }
   void set_language_mode(LanguageMode language_mode) {
     STATIC_ASSERT(LANGUAGE_END == 3);
     set_strict_mode(is_strict(language_mode));
   }
 
   void ReopenHandlesInNewHandleScope() {
     shared_ = Handle<SharedFunctionInfo>(*shared_);
     script_ = Handle<Script>(*script_);
     context_ = Handle<Context>(*context_);
   }
 
 #ifdef DEBUG
-  bool script_is_native() const {
-    return script_->type() == Script::TYPE_NATIVE;
-  }
+  bool script_is_native() { return script_->type() == Script::TYPE_NATIVE; }
 #endif  // DEBUG
 
  private:
   // Various configuration flags for parsing.
   enum Flag {
     // ---------- Input flags ---------------------------
     kToplevel = 1 << 0,
     kLazy = 1 << 1,
     kEval = 1 << 2,
     kGlobal = 1 << 3,
@@ skipping 27 matching lines @@
   // TODO(titzer): Move handles and isolate out of ParseInfo.
   Isolate* isolate_;
   Handle<SharedFunctionInfo> shared_;
   Handle<Script> script_;
   Handle<Context> context_;
 
   //----------- Inputs+Outputs of parsing and scope analysis -----------------
   ScriptData** cached_data_;  // used if available, populated if requested.
   AstValueFactory* ast_value_factory_;  // used if available, otherwise new.
 
-  //----------- Output of parsing and scope analysis ------------------------
-  FunctionLiteral* literal_;
+  //----------- Outputs of parsing and scope analysis ------------------------
+  FunctionLiteral* literal_;  // produced by full parser.
+  DeclarationScope* scope_;   // produced by scope analysis.
 
   void SetFlag(Flag f) { flags_ |= f; }
   void SetFlag(Flag f, bool v) { flags_ = v ? flags_ | f : flags_ & ~f; }
   bool GetFlag(Flag f) const { return (flags_ & f) != 0; }
 };
 
 class FunctionEntry BASE_EMBEDDED {
  public:
   enum {
     kStartPositionIndex,
@@ skipping 1112 matching lines @@
 
 DoExpression* ParserTraits::ParseDoExpression(bool* ok) {
   return parser_->ParseDoExpression(ok);
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_