Scope tree serialization and ScopeIterator cleanup.

src/scopes.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 188 matching lines @@
   void RecordWithStatement() { scope_contains_with_ = true; }
 
   // Inform the scope that the corresponding code contains an eval call.
   void RecordEvalCall() { if (!is_global_scope()) scope_calls_eval_ = true; }
 
   // Enable strict mode for the scope (unless disabled by a global flag).
   void EnableStrictMode() {
     strict_mode_ = FLAG_strict_mode;
   }
 
+  // Statement position in the source where this scope begins.
+  int SourceBegStatementPos() const { return source_beg_statement_pos_; }

[Kevin Millikin (Chromium), 2011/10/05 08:43:36]

I don't like the name :)

First, it doesn't follow the hacker_style naming convention for simple accessors
from the style guide, and it doesn't follow the API naming convention for the
rest of the class.

Second, abbreviations like "beg" and "pos" don't read very well.  And "Source"
and "Statement" are just noise words, though should be implicit unless there's
some other kind of positions we care about.

Suggestion:

int start_position() const { return start_position_; }

[Steven, 2011/10/06 19:09:27]

Done.

+  void SetSourceBegStatementPos(int statement_pos) {
+    source_beg_statement_pos_ = statement_pos;
+  }
+
+  // Statement position in the source where this scope ends.
+  int SourceEndStatementPos() const { return source_end_statement_pos_; }

[Kevin Millikin (Chromium), 2011/10/05 08:43:36]

Likewise:

int end_position() const { return end_position_; }

[Steven, 2011/10/06 19:09:27]

Done.

+  void SetSourceEndStatementPos(int statement_pos) {
+    source_end_statement_pos_ = statement_pos;
+  }
+
   // ---------------------------------------------------------------------------
   // Predicates.
 
   // Specific scope types.
   bool is_eval_scope() const { return type_ == EVAL_SCOPE; }
   bool is_function_scope() const { return type_ == FUNCTION_SCOPE; }
   bool is_global_scope() const { return type_ == GLOBAL_SCOPE; }
   bool is_catch_scope() const { return type_ == CATCH_SCOPE; }
   bool is_block_scope() const { return type_ == BLOCK_SCOPE; }
   bool is_with_scope() const { return type_ == WITH_SCOPE; }
@@ skipping 18 matching lines @@
   bool inside_with() const { return scope_inside_with_; }
   // Does this scope contain a with statement.
   bool contains_with() const { return scope_contains_with_; }
 
   // The scope immediately surrounding this scope, or NULL.
   Scope* outer_scope() const { return outer_scope_; }
 
   // ---------------------------------------------------------------------------
   // Accessors.
 
+  // The type of this scope.
+  Type type() const { return type_; }
+
   // The variable corresponding the 'this' value.
   Variable* receiver() { return receiver_; }
 
   // The variable holding the function literal for named function
   // literals, or NULL.
   // Only valid for function scopes.
   VariableProxy* function() const {
     ASSERT(is_function_scope());
     return function_;
   }
 
   // Parameters. The left-most parameter has index 0.
   // Only valid for function scopes.
   Variable* parameter(int index) const {
     ASSERT(is_function_scope());
     return params_[index];
   }
 
   int num_parameters() const { return params_.length(); }
 
   // The local variable 'arguments' if we need to allocate it; NULL otherwise.
   Variable* arguments() const { return arguments_; }
 
   // Declarations list.
   ZoneList<Declaration*>* declarations() { return &decls_; }
 
+  // Inner scope list.
+  ZoneList<Scope*>* InnerScopes() { return &inner_scopes_; }

[Kevin Millikin (Chromium), 2011/10/05 08:43:36]

ZoneList<Scope*>* inner_scopes() { return &inner_scopes_; }

[Steven, 2011/10/06 19:09:27]

Done.

 
   // ---------------------------------------------------------------------------
   // Variable allocation.
 
   // Collect all used locals in this scope.
   template<class Allocator>
   void CollectUsedVariables(List<Variable*, Allocator>* locals);
 
   // Resolve and fill in the allocation information for all variables
   // in this scopes. Must be called *after* all scopes have been
@@ skipping 97 matching lines @@
   //
   // This scope is inside a 'with' of some outer scope.
   bool scope_inside_with_;
   // This scope contains a 'with' statement.
   bool scope_contains_with_;
   // 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.
   bool scope_calls_eval_;
   // This scope is a strict mode scope.
   bool strict_mode_;
+  // Source positions.
+  int source_beg_statement_pos_;
+  int source_end_statement_pos_;
 
   // Computed via PropagateScopeInfo.
   bool outer_scope_calls_non_strict_eval_;
   bool inner_scope_calls_eval_;
   bool force_eager_compilation_;
 
   // True if it doesn't need scope resolution (e.g., if the scope was
   // constructed based on a serialized scope info or a catch context).
   bool already_resolved_;
 
@@ skipping 102 matching lines @@
   }
 
   void SetDefaults(Type type,
                    Scope* outer_scope,
                    Handle<SerializedScopeInfo> scope_info);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCOPES_H_