Make the Scope constructors less reliant on SetDefaults to magically set flags

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 106 matching lines @@
 
   // Inserts outer_scope into this scope's scope chain (and removes this
   // from the current outer_scope_'s inner_scopes_).
   // 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 zone_; }
+  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
@@ skipping 467 matching lines @@
 #endif
 
   // ---------------------------------------------------------------------------
   // Implementation.
  private:
   // Scope tree.
   Scope* outer_scope_;  // the immediately enclosing outer scope, or NULL
   ZoneList<Scope*> inner_scopes_;  // the immediately enclosed inner scopes
 
   // The scope type.
-  ScopeType scope_type_;
+  const ScopeType scope_type_;
   // If the scope is a function scope, this is the function kind.
-  FunctionKind function_kind_;
+  const FunctionKind function_kind_;
 
   // Debugging support.
   const AstRawString* scope_name_;
 
   // 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_;
@@ skipping 176 matching lines @@
   // Construct a scope based on the scope info.
   Scope(Zone* zone, Scope* inner_scope, ScopeType type,
         Handle<ScopeInfo> scope_info);
 
   // Construct a catch scope with a binding for the name.
   Scope(Zone* zone, Scope* inner_scope,
         const AstRawString* catch_variable_name);
 
   void AddInnerScope(Scope* inner_scope) {
     if (inner_scope != NULL) {
-      inner_scopes_.Add(inner_scope, zone_);
+      inner_scopes_.Add(inner_scope, zone());
       inner_scope->outer_scope_ = this;
     }
   }
 
   void RemoveInnerScope(Scope* inner_scope) {
     DCHECK_NOT_NULL(inner_scope);
     for (int i = 0; i < inner_scopes_.length(); i++) {
       if (inner_scopes_[i] == inner_scope) {
         inner_scopes_.Remove(i);
         break;
       }
     }
   }
 
-  void SetDefaults(ScopeType type, Scope* outer_scope,
-                   Handle<ScopeInfo> scope_info,
-                   FunctionKind function_kind = kNormalFunction);
-
-  Zone* zone_;
+  void SetDefaults();
 
   PendingCompilationErrorHandler pending_error_handler_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_