Separate Scope into DeclarationScope and Scope

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 66 matching lines @@
 
 // Global invariants after AST construction: Each reference (i.e. identifier)
 // to a JavaScript variable (including global properties) is represented by a
 // VariableProxy node. Immediately after AST construction and before variable
 // allocation, most VariableProxy nodes are "unresolved", i.e. not bound to a
 // corresponding variable (though some are bound during parse time). Variable
 // allocation binds each unresolved VariableProxy to one Variable and assigns
 // a location. Note that many VariableProxy nodes may refer to the same Java-
 // Script variable.
 
+class DeclarationScope;
+
 class Scope: public ZoneObject {
  public:
   // ---------------------------------------------------------------------------
   // Construction
 
-  Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type,
-        FunctionKind function_kind = kNormalFunction);
+  Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type);
+
+#ifdef DEBUG
+  // The scope name is only used for printing/debugging.
+  void SetScopeName(const AstRawString* scope_name) {
+    scope_name_ = scope_name;
+  }
+#endif
+
+  // TODO(verwaest): Is this needed on Scope?
+  int num_parameters() const;
+
+  DeclarationScope* AsDeclarationScope();
+  const DeclarationScope* AsDeclarationScope() const;
 
   class Snapshot final BASE_EMBEDDED {
    public:
-    explicit Snapshot(Scope* scope)
-        : outer_scope_(scope),
-          top_inner_scope_(scope->inner_scope_),
-          top_unresolved_(scope->unresolved_),
-          top_temp_(scope->ClosureScope()->temps_.length()) {}
+    explicit Snapshot(Scope* scope);
 
-    void Reparent(Scope* new_parent) const;
+    void Reparent(DeclarationScope* new_parent) const;
 
    private:
     Scope* outer_scope_;
     Scope* top_inner_scope_;
     VariableProxy* top_unresolved_;
     int top_temp_;
   };
 
   // Compute top scope and allocate variables. For lazy compilation the top
   // scope only contains the single lazily compiled function, so this
   // doesn't re-allocate variables repeatedly.
   static bool Analyze(ParseInfo* info);
 
   static Scope* DeserializeScopeChain(Isolate* isolate, Zone* zone,
                                       Context* context, Scope* script_scope,
                                       AstValueFactory* ast_value_factory);
 
-#ifdef DEBUG
-  // The scope name is only used for printing/debugging.
-  void SetScopeName(const AstRawString* scope_name) {
-    scope_name_ = scope_name;
-  }
-#endif
-
-  void DeclareThis(AstValueFactory* ast_value_factory);
-  void DeclareDefaultFunctionVariables(AstValueFactory* ast_value_factory);
-
   // Checks if the block scope is redundant, i.e. it does not contain any
   // block scoped declarations. In that case it is removed from the scope
   // tree and its children are reparented.
   Scope* FinalizeBlockScope();
 
   // Inserts outer_scope into this scope's scope chain (and removes this
   // from the current outer_scope_'s inner scope list).
   // Assumes outer_scope_ is non-null.
   void ReplaceOuterScope(Scope* outer_scope);
 
   // Propagates any eagerly-gathered scope usage flags (such as calls_eval())
   // to the passed-in scope.
   void PropagateUsageFlagsToScope(Scope* other);
 
   Zone* zone() const { return variables_.zone(); }
 
   // ---------------------------------------------------------------------------
   // Declarations
 
   // Lookup a variable in this scope. Returns the variable or NULL if not found.
   Variable* LookupLocal(const AstRawString* name);
 
-  // This lookup corresponds to a lookup in the "intermediate" scope sitting
-  // between this scope and the outer scope. (ECMA-262, 3rd., requires that
-  // the name of named function literal is kept in an intermediate scope
-  // in between this scope and the next outer scope.)
-  Variable* LookupFunctionVar(const AstRawString* name,
-                              AstNodeFactory* factory);
-
   // Lookup a variable in this scope or outer scopes.
   // Returns the variable or NULL if not found.
   Variable* Lookup(const AstRawString* name);
 
-  // Declare the function variable for a function literal. This variable
-  // is in an intermediate scope between this function scope and the the
-  // outer scope. Only possible for function scopes; at most one variable.
-  void DeclareFunctionVar(VariableDeclaration* declaration) {
-    DCHECK(is_function_scope());
-    // Handle implicit declaration of the function name in named function
-    // expressions before other declarations.
-    decls_.InsertAt(0, declaration, zone());
-    function_ = declaration;
-  }
-
-  // Declare a parameter in this scope.  When there are duplicated
-  // parameters the rightmost one 'wins'.  However, the implementation
-  // expects all parameters to be declared and from left to right.
-  Variable* DeclareParameter(const AstRawString* name, VariableMode mode,
-                             bool is_optional, bool is_rest, bool* is_duplicate,
-                             AstValueFactory* ast_value_factory);
-
   // Declare a local variable in this scope. If the variable has been
   // declared before, the previously declared variable is returned.
   Variable* DeclareLocal(const AstRawString* name, VariableMode mode,
                          InitializationFlag init_flag, Variable::Kind kind,
                          MaybeAssignedFlag maybe_assigned_flag = kNotAssigned);
 
-  // Declare an implicit global variable in this scope which must be a
-  // script scope.  The variable was introduced (possibly from an inner
-  // scope) by a reference to an unresolved variable with no intervening
-  // with statements or eval calls.
-  Variable* DeclareDynamicGlobal(const AstRawString* name);
+  // Declarations list.
+  ZoneList<Declaration*>* declarations() { return &decls_; }

[marja, 2016/08/04 07:58:08]

Why is this in Scope, not in DeclarationScope?

 
   // Create a new unresolved variable.
   VariableProxy* NewUnresolved(AstNodeFactory* factory,
                                const AstRawString* name,
                                Variable::Kind kind = Variable::NORMAL,
                                int start_position = kNoSourcePosition,
                                int end_position = kNoSourcePosition) {
     // Note that we must not share the unresolved variables with
     // the same name because they may be removed selectively via
     // RemoveUnresolved().
@@ skipping 19 matching lines @@
   // addition introduced a new unresolved variable which may end up being
   // allocated globally as a "ghost" variable. RemoveUnresolved removes
   // such a variable again if it was added; otherwise this is a no-op.
   bool RemoveUnresolved(VariableProxy* var);
 
   // Creates a new temporary variable in this scope's TemporaryScope.  The
   // name is only used for printing and cannot be used to find the variable.
   // In particular, the only way to get hold of the temporary is by keeping the
   // Variable* around.  The name should not clash with a legitimate variable
   // names.
+  // TODO(verwaest): Move to DeclarationScope?
   Variable* NewTemporary(const AstRawString* name);
 
-  // Remove a temporary variable. This is for adjusting the scope of
-  // temporaries used when desugaring parameter initializers.
-  // Returns the index at which it was found in this scope, or -1 if
-  // it was not found.
-  int RemoveTemporary(Variable* var);
-
-  // Adds a temporary variable in this scope's TemporaryScope. This is for
-  // adjusting the scope of temporaries used when desugaring parameter
-  // initializers.
-  void AddTemporary(Variable* var) {
-    // Temporaries are only placed in ClosureScopes.
-    DCHECK_EQ(ClosureScope(), this);
-    temps_.Add(var, zone());
-  }
-
   // Adds the specific declaration node to the list of declarations in
   // this scope. The declarations are processed as part of entering
   // the scope; see codegen.cc:ProcessDeclarations.
   void AddDeclaration(Declaration* declaration);
 
   // ---------------------------------------------------------------------------
   // Illegal redeclaration support.
 
   // Check if the scope has conflicting var
   // declarations, i.e. a var declaration that has been hoisted from a nested
@@ skipping 89 matching lines @@
   // Predicates.
 
   // Specific scope types.
   bool is_eval_scope() const { return scope_type_ == EVAL_SCOPE; }
   bool is_function_scope() const { return scope_type_ == FUNCTION_SCOPE; }
   bool is_module_scope() const { return scope_type_ == MODULE_SCOPE; }
   bool is_script_scope() const { return scope_type_ == SCRIPT_SCOPE; }
   bool is_catch_scope() const { return scope_type_ == CATCH_SCOPE; }
   bool is_block_scope() const { return scope_type_ == BLOCK_SCOPE; }
   bool is_with_scope() const { return scope_type_ == WITH_SCOPE; }
-  bool is_arrow_scope() const {
-    return is_function_scope() && IsArrowFunction(function_kind_);
-  }
   bool is_declaration_scope() const { return is_declaration_scope_; }
 
-  void set_is_declaration_scope() { is_declaration_scope_ = true; }
-
   // Information about which scopes calls eval.
   bool calls_eval() const { return scope_calls_eval_; }
   bool calls_sloppy_eval() const {
     return scope_calls_eval_ && is_sloppy(language_mode_);
   }
   bool outer_scope_calls_sloppy_eval() const {
     return outer_scope_calls_sloppy_eval_;
   }
   bool asm_module() const { return asm_module_; }
   bool asm_function() const { return asm_function_; }
 
   // Is this scope inside a with statement.
   bool inside_with() const { return scope_inside_with_; }
 
   // Does this scope access "super" property (super.foo).
   bool uses_super_property() const { return scope_uses_super_property_; }
   // Does this scope have the potential to execute declarations non-linearly?
   bool is_nonlinear() const { return scope_nonlinear_; }
 
   // Whether this needs to be represented by a runtime context.
   bool NeedsContext() const {
     // Catch and module scopes always have heap slots.
     DCHECK(!is_catch_scope() || num_heap_slots() > 0);
     DCHECK(!is_module_scope() || num_heap_slots() > 0);
     return is_with_scope() || num_heap_slots() > 0;
   }
 
-  bool NeedsHomeObject() const {
-    return scope_uses_super_property_ ||
-           ((scope_calls_eval_ || inner_scope_calls_eval_) &&
-            (IsConciseMethod(function_kind()) ||
-             IsAccessorFunction(function_kind()) ||
-             IsClassConstructor(function_kind())));
-  }
-
   // ---------------------------------------------------------------------------
   // Accessors.
 
   // The type of this scope.
   ScopeType scope_type() const { return scope_type_; }
 
-  FunctionKind function_kind() const { return function_kind_; }
-
   // The language mode of this scope.
   LanguageMode language_mode() const { return language_mode_; }
 
-  // The variable corresponding to the 'this' value.
-  Variable* receiver() {
-    DCHECK(has_this_declaration());
-    DCHECK_NOT_NULL(receiver_);
-    return receiver_;
-  }
-
-  // TODO(wingo): Add a GLOBAL_SCOPE scope type which will lexically allocate
-  // "this" (and no other variable) on the native context.  Script scopes then
-  // will not have a "this" declaration.
-  bool has_this_declaration() const {
-    return (is_function_scope() && !is_arrow_scope()) || is_module_scope();
-  }
-
-  // The variable corresponding to the 'new.target' value.
-  Variable* new_target_var() { return new_target_; }
-
-  // The variable holding the function literal for named function
-  // literals, or NULL.  Only valid for function scopes.
-  VariableDeclaration* function() const {
-    DCHECK(is_function_scope());
-    return function_;
-  }
-
-  // Parameters. The left-most parameter has index 0.
-  // Only valid for function scopes.
-  Variable* parameter(int index) const {
-    DCHECK(is_function_scope());
-    return params_[index];
-  }
-
-  // Returns the default function arity excluding default or rest parameters.
-  int default_function_length() const { return arity_; }
-
-  // Returns the number of formal parameters, up to but not including the
-  // rest parameter index (if the function has rest parameters), i.e. it
-  // says 2 for
-  //
-  //   function foo(a, b) { ... }
-  //
-  // and
-  //
-  //   function foo(a, b, ...c) { ... }
-  //
-  // but for
-  //
-  //   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 NULL;
-    return rest_parameter_;
-  }
-
-  bool has_rest_parameter() const { return rest_index_ >= 0; }
-
-  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());
-    has_simple_parameters_ = false;
-  }
-
-  // Retrieve `IsSimpleParameterList` of current or outer function.
-  bool HasSimpleParameters() {
-    Scope* scope = ClosureScope();
-    return !scope->is_function_scope() || scope->has_simple_parameters();
-  }
-
-  // The local variable 'arguments' if we need to allocate it; NULL otherwise.
-  Variable* arguments() const {
-    DCHECK(!is_arrow_scope() || arguments_ == nullptr);
-    return arguments_;
-  }
-
-  Variable* this_function_var() const {
-    // This is only used in derived constructors atm.
-    DCHECK(this_function_ == nullptr ||
-           (is_function_scope() && (IsClassConstructor(function_kind()) ||
-                                    IsConciseMethod(function_kind()) ||
-                                    IsAccessorFunction(function_kind()))));
-    return this_function_;
-  }
-
-  // Declarations list.
-  ZoneList<Declaration*>* declarations() { return &decls_; }
-
   // inner_scope() and sibling() together implement the inner scope list of a
   // scope. Inner scope points to the an inner scope of the function, and
   // "sibling" points to a next inner scope of the outer scope of this scope.
   Scope* inner_scope() const { return inner_scope_; }
   Scope* sibling() const { return sibling_; }
 
   // The scope immediately surrounding this scope, or NULL.
   Scope* outer_scope() const { return outer_scope_; }
 
-  // The ModuleDescriptor for this scope; only for module scopes.
-  ModuleDescriptor* module() const { return module_descriptor_; }
-
   const AstRawString* catch_variable_name() const {
     DCHECK(is_catch_scope());
     DCHECK_EQ(1, num_var());
     return static_cast<AstRawString*>(variables_.Start()->key);
   }
 
   // ---------------------------------------------------------------------------
   // Variable allocation.
 
   // Collect stack and context allocated local variables in this scope. Note
@@ skipping 29 matching lines @@
 
   // The number of contexts between this and scope; zero if this == scope.
   int ContextChainLength(Scope* scope);
 
   // The maximum number of nested contexts required for this scope and any inner
   // scopes.
   int MaxNestedContextChainLength();
 
   // Find the first function, script, eval or (declaration) block scope. This is
   // the scope where var declarations will be hoisted to in the implementation.
-  Scope* DeclarationScope();
+  DeclarationScope* GetDeclarationScope();
 
   // Find the first non-block declaration scope. This should be either a script,
-  // function, or eval scope. Same as DeclarationScope(), but skips
-  // declaration "block" scopes. Used for differentiating associated
-  // function objects (i.e., the scope for which a function prologue allocates
-  // a context) or declaring temporaries.
-  Scope* ClosureScope();
+  // function, or eval scope. Same as DeclarationScope(), but skips declaration
+  // "block" scopes. Used for differentiating associated function objects (i.e.,
+  // the scope for which a function prologue allocates a context) or declaring
+  // temporaries.
+  DeclarationScope* GetClosureScope();
 
   // Find the first (non-arrow) function or script scope.  This is where
   // 'this' is bound, and what determines the function kind.
-  Scope* ReceiverScope();
+  DeclarationScope* GetReceiverScope();
 
   Handle<ScopeInfo> GetScopeInfo(Isolate* isolate);
 
   Handle<StringSet> CollectNonLocals(Handle<StringSet> non_locals);
 
   // ---------------------------------------------------------------------------
   // Strict mode support.
   bool IsDeclared(const AstRawString* name) {
     // During formal parameter list parsing the scope only contains
     // two variables inserted at initialization: "this" and "arguments".
     // "this" is an invalid parameter name and "arguments" is invalid parameter
     // name in strict mode. Therefore looking up with the map which includes
     // "this" and "arguments" in addition to all formal parameters is safe.
     return variables_.Lookup(name) != NULL;
   }
 
-  bool IsDeclaredParameter(const AstRawString* name) {
-    // If IsSimpleParameterList is false, duplicate parameters are not allowed,
-    // however `arguments` may be allowed if function is not strict code. Thus,
-    // the assumptions explained above do not hold.
-    return params_.Contains(variables_.Lookup(name));
-  }
-
   int num_var() const { return variables_.occupancy(); }
 
-  SloppyBlockFunctionMap* sloppy_block_function_map() {
-    return &sloppy_block_function_map_;
-  }
-
   // To be called during parsing. Do just enough scope analysis that we can
   // discard the Scope for lazily compiled functions. In particular, this
   // records variables which cannot be resolved inside the Scope (we don't yet
   // know what they will resolve to since the outer Scopes are incomplete) and
   // migrates them into migrate_to.
   void AnalyzePartially(Scope* migrate_to, AstNodeFactory* ast_node_factory);
 
   // ---------------------------------------------------------------------------
   // Debugging.
 
 #ifdef DEBUG
   void Print(int n = 0);  // n = indentation; n < 0 => don't print recursively
 
   // Check that the scope has positions assigned.
   void CheckScopePositions();
 
   // Check that all Scopes in the scope tree use the same Zone.
   void CheckZones();
 #endif
 
-  // ---------------------------------------------------------------------------
-  // Implementation.
+  // Retrieve `IsSimpleParameterList` of current or outer function.
+  bool HasSimpleParameters();
+
  private:
   // Scope tree.
   Scope* outer_scope_;  // the immediately enclosing outer scope, or NULL
   Scope* inner_scope_;  // an inner scope of this scope
   Scope* sibling_;  // a sibling inner scope of the outer scope of this scope.
 
-  // Debugging support.
-#ifdef DEBUG
-  const AstRawString* scope_name_;
-#endif
-
   // The variables declared in this scope:
   //
   // All user-declared variables (incl. parameters).  For script scopes
   // variables may be implicitly 'declared' by being used (possibly in
   // an inner scope) with no intervening with statements or eval calls.
   VariableMap variables_;
-  // Compiler-allocated (user-invisible) temporaries. Due to the implementation
-  // of RemoveTemporary(), may contain nulls, which must be skipped-over during
-  // allocation and printing.
-  ZoneList<Variable*> temps_;
-  // Parameter list in source order.
-  ZoneList<Variable*> params_;
   // Variables that must be looked up dynamically.
   DynamicScopePart* dynamics_;
   // Unresolved variables referred to from this scope. The proxies themselves
   // form a linked list of all unresolved proxies.
   VariableProxy* unresolved_;
   // Declarations.
   ZoneList<Declaration*> decls_;
-  // Convenience variable.
-  Variable* receiver_;
-  // Function variable, if any; function scopes only.
-  VariableDeclaration* function_;
-  // new.target variable, function scopes only.
-  Variable* new_target_;
-  // Convenience variable; function scopes only.
-  Variable* arguments_;
-  // Convenience variable; Subclass constructor only
-  Variable* this_function_;
-  // Module descriptor; module scopes only.
-  ModuleDescriptor* module_descriptor_;
-
-  // Map of function names to lists of functions defined in sloppy blocks
-  SloppyBlockFunctionMap sloppy_block_function_map_;
 
   // The scope type.
   const ScopeType scope_type_;
-  // If the scope is a function scope, this is the function kind.
-  const FunctionKind function_kind_;
 
   // Scope-specific information computed during parsing.
   //
   // The language mode of this scope.
   STATIC_ASSERT(LANGUAGE_END == 3);
   LanguageMode language_mode_ : 2;
   // This scope is inside a 'with' of some outer scope.
   bool scope_inside_with_ : 1;
   // This scope or a nested catch scope or with scope contain an 'eval' call. At
   // the 'eval' call site this scope is the declaration scope.
@@ skipping 27 matching lines @@
 
   // Source positions.
   int start_position_;
   int end_position_;
 
   // Computed via AllocateVariables; function, block and catch scopes only.
   int num_stack_slots_;
   int num_heap_slots_;
   int num_global_slots_;
 
-  // Info about the parameter list of a function.
-  int arity_;
-  int rest_index_;
-  Variable* rest_parameter_;
-
   // Serialized scope info support.
   Handle<ScopeInfo> scope_info_;
 
   // Create a non-local variable with a given name.
   // These variables are looked up dynamically at runtime.
   Variable* NonLocal(const AstRawString* name, VariableMode mode);
 
+// Debugging support.
+#ifdef DEBUG
+  const AstRawString* scope_name_;
+#endif
+
   // Variable resolution.
   // Possible results of a recursive variable lookup telling if and how a
   // variable is bound. These are returned in the output parameter *binding_kind
   // of the LookupRecursive function.
   enum BindingKind {
     // The variable reference could be statically resolved to a variable binding
     // which is returned. There is no 'with' statement between the reference and
     // the binding and no scope between the reference scope (inclusive) and
     // binding scope (exclusive) makes a sloppy 'eval' call.
     BOUND,
@@ skipping 55 matching lines @@
   void PropagateScopeInfo(bool outer_scope_calls_sloppy_eval);
   bool HasTrivialContext() const;
 
   // Predicates.
   bool MustAllocate(Variable* var);
   bool MustAllocateInContext(Variable* var);
 
   // Variable allocation.
   void AllocateStackSlot(Variable* var);
   void AllocateHeapSlot(Variable* var);
-  void AllocateParameterLocals();
   void AllocateNonParameterLocal(Variable* var,
                                  AstValueFactory* ast_value_factory);
   void AllocateDeclaredGlobal(Variable* var,
                               AstValueFactory* ast_value_factory);
   void AllocateNonParameterLocalsAndDeclaredGlobals(
       AstValueFactory* ast_value_factory);
   void AllocateVariablesRecursively(AstValueFactory* ast_value_factory);
-  void AllocateParameter(Variable* var, int index);
-  void AllocateReceiver();
 
   // Resolve and fill in the allocation information for all variables
   // in this scopes. Must be called *after* all scopes have been
   // processed (parsed) to ensure that unresolved variables can be
   // resolved properly.
   //
   // In the case of code compiled and run using 'eval', the context
   // parameter is the context in which eval was called.  In all other
   // cases the context parameter is an empty handle.
   MUST_USE_RESULT
@@ skipping 26 matching lines @@
       if (scope->sibling_ == inner_scope) {
         scope->sibling_ = scope->sibling_->sibling_;
         return;
       }
     }
   }
 
   void SetDefaults();
 
   PendingCompilationErrorHandler pending_error_handler_;
+
+  friend class DeclarationScope;
 };
 
+class DeclarationScope : public Scope {

[adamk, 2016/08/04 00:18:51]

Please give this a class comment. "DeclarationScope" is a name that I know
causes initial confusion to anyone encountering it, and it seems like this CL
actually increases that confusion, since there's stuff in DeclarationScope that
has nothing to do with the essential thing about DeclarationScopes, which is
that they host "var" declarations.

For that matter, I think this means that Scope now needs a comment, explaining
which scopes can be represented by a Scope and which need a DeclarationScope.

[Toon Verwaest, 2016/08/04 12:01:17]

Acknowledged.

[Toon Verwaest, 2016/08/04 12:01:17]

I don't think it increases confusion. All scopes covered by this class are
declaration scopes, and are not scopes. DeclarationScope specializes (reduces
the scope of) those scopes, hence it's more clear when we could be in such
scopes (only when it's a declaration scope) and when not (not declaration
scope). This gives clients more static guarantees about being in such scopes;
reducing the error-potential.

We should probably create more subclasses of DeclarationScope though. (One for
each of the constructor wrappers; NewScriptScope, NewModuleScope, NewEvalScope,
NewVarblockScope, NewFunctionScope.)

[adamk, 2016/08/04 16:31:28]

I think this last paragraph is what makes me feel like this is going in the
right direction, even if this intermediate step looks weird to me. If folks
asking for a receiver had to check for some subclass of scopes _all of which_
had a receiver, or all of which have parameters, then I think this new layout
does provide nice understandable static guarantees.

+ public:
+  DeclarationScope(Zone* zone, Scope* outer_scope, ScopeType scope_type,
+                   FunctionKind function_kind = kNormalFunction);
+  DeclarationScope(Zone* zone, Scope* inner_scope, ScopeType scope_type,
+                   Handle<ScopeInfo> scope_info);
+
+  bool IsDeclaredParameter(const AstRawString* name) {
+    // If IsSimpleParameterList is false, duplicate parameters are not allowed,
+    // however `arguments` may be allowed if function is not strict code. Thus,
+    // the assumptions explained above do not hold.
+    return params_.Contains(variables_.Lookup(name));
+  }
+
+  FunctionKind function_kind() const { return function_kind_; }
+
+  bool is_arrow_scope() const {
+    return is_function_scope() && IsArrowFunction(function_kind_);
+  }
+
+  bool NeedsHomeObject() const {
+    return scope_uses_super_property_ ||
+           ((scope_calls_eval_ || inner_scope_calls_eval_) &&
+            (IsConciseMethod(function_kind()) ||
+             IsAccessorFunction(function_kind()) ||
+             IsClassConstructor(function_kind())));
+  }
+
+  // The ModuleDescriptor for this scope; only for module scopes.
+  // TODO(verwaest): Move to ModuleScope?
+  ModuleDescriptor* module() const { return module_descriptor_; }
+
+  void DeclareThis(AstValueFactory* ast_value_factory);
+  void DeclareDefaultFunctionVariables(AstValueFactory* ast_value_factory);
+
+  // This lookup corresponds to a lookup in the "intermediate" scope sitting
+  // between this scope and the outer scope. (ECMA-262, 3rd., requires that
+  // the name of named function literal is kept in an intermediate scope
+  // in between this scope and the next outer scope.)
+  Variable* LookupFunctionVar(const AstRawString* name,
+                              AstNodeFactory* factory);
+
+  // Declare the function variable for a function literal. This variable
+  // is in an intermediate scope between this function scope and the the
+  // outer scope. Only possible for function scopes; at most one variable.
+  void DeclareFunctionVar(VariableDeclaration* declaration) {
+    DCHECK(is_function_scope());
+    // Handle implicit declaration of the function name in named function
+    // expressions before other declarations.
+    declarations()->InsertAt(0, declaration, zone());
+    function_ = declaration;
+  }
+
+  // Declare a parameter in this scope.  When there are duplicated
+  // parameters the rightmost one 'wins'.  However, the implementation
+  // expects all parameters to be declared and from left to right.
+  Variable* DeclareParameter(const AstRawString* name, VariableMode mode,
+                             bool is_optional, bool is_rest, bool* is_duplicate,
+                             AstValueFactory* ast_value_factory);
+
+  // Declare an implicit global variable in this scope which must be a
+  // script scope.  The variable was introduced (possibly from an inner
+  // scope) by a reference to an unresolved variable with no intervening
+  // with statements or eval calls.
+  Variable* DeclareDynamicGlobal(const AstRawString* name);
+
+  // The variable corresponding to the 'this' value.
+  Variable* receiver() {
+    DCHECK(has_this_declaration());
+    DCHECK_NOT_NULL(receiver_);
+    return receiver_;
+  }
+
+  // TODO(wingo): Add a GLOBAL_SCOPE scope type which will lexically allocate
+  // "this" (and no other variable) on the native context.  Script scopes then
+  // will not have a "this" declaration.
+  bool has_this_declaration() const {
+    return (is_function_scope() && !is_arrow_scope()) || is_module_scope();
+  }
+
+  // The variable corresponding to the 'new.target' value.
+  Variable* new_target_var() { return new_target_; }
+
+  // The variable holding the function literal for named function
+  // literals, or NULL.  Only valid for function scopes.
+  VariableDeclaration* function() const {
+    DCHECK(is_function_scope());
+    return function_;
+  }
+
+  // Parameters. The left-most parameter has index 0.
+  // Only valid for function scopes.
+  Variable* parameter(int index) const {
+    DCHECK(is_function_scope());
+    return params_[index];
+  }
+
+  // Returns the default function arity excluding default or rest parameters.
+  int default_function_length() const { return arity_; }
+
+  // Returns the number of formal parameters, up to but not including the
+  // rest parameter index (if the function has rest parameters), i.e. it
+  // says 2 for
+  //
+  //   function foo(a, b) { ... }
+  //
+  // and
+  //
+  //   function foo(a, b, ...c) { ... }
+  //
+  // but for
+  //
+  //   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 NULL;
+    return rest_parameter_;
+  }
+
+  bool has_rest_parameter() const { return rest_index_ >= 0; }
+
+  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());
+    has_simple_parameters_ = false;
+  }
+
+  // The local variable 'arguments' if we need to allocate it; NULL otherwise.
+  Variable* arguments() const {
+    DCHECK(!is_arrow_scope() || arguments_ == nullptr);
+    return arguments_;
+  }
+
+  Variable* this_function_var() const {
+    // This is only used in derived constructors atm.
+    DCHECK(this_function_ == nullptr ||
+           (is_function_scope() && (IsClassConstructor(function_kind()) ||
+                                    IsConciseMethod(function_kind()) ||
+                                    IsAccessorFunction(function_kind()))));
+    return this_function_;
+  }
+
+  // Remove a temporary variable. This is for adjusting the scope of
+  // temporaries used when desugaring parameter initializers.
+  // Returns the index at which it was found in this scope, or -1 if
+  // it was not found.
+  int RemoveTemporary(Variable* var);
+
+  // Adds a temporary variable in this scope's TemporaryScope. This is for
+  // adjusting the scope of temporaries used when desugaring parameter
+  // initializers.
+  void AddTemporary(Variable* var) {
+    // Temporaries are only placed in ClosureScopes.
+    DCHECK_EQ(GetClosureScope(), this);
+    temps_.Add(var, zone());
+  }
+
+  ZoneList<Variable*>* temps() { return &temps_; }
+
+  SloppyBlockFunctionMap* sloppy_block_function_map() {
+    return &sloppy_block_function_map_;
+  }
+
+#ifdef DEBUG
+  void PrintParameters();
+#endif
+
+  void AllocateLocals(AstValueFactory* ast_value_factory);
+  void AllocateParameterLocals();
+  void AllocateReceiver();
+
+ private:
+  void AllocateParameter(Variable* var, int index);
+
+  void SetDefaults();
+
+  // If the scope is a function scope, this is the function kind.
+  const FunctionKind function_kind_;
+
+  // Info about the parameter list of a function.
+  int arity_;
+  int rest_index_;
+  Variable* rest_parameter_;
+  // Compiler-allocated (user-invisible) temporaries. Due to the implementation
+  // of RemoveTemporary(), may contain nulls, which must be skipped-over during
+  // allocation and printing.
+  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.
+  VariableDeclaration* function_;
+  // new.target variable, function scopes only.
+  Variable* new_target_;
+  // Convenience variable; function scopes only.
+  Variable* arguments_;
+  // Convenience variable; Subclass constructor only
+  Variable* this_function_;
+  // Module descriptor; module scopes only.
+  ModuleDescriptor* module_descriptor_;
+};
+
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_