Scope tree serialization and ScopeIterator cleanup.

src/scopes.cc

 // 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 139 matching lines @@
              Handle<SerializedScopeInfo> scope_info)
     : isolate_(Isolate::Current()),
       inner_scopes_(4),
       variables_(),
       temps_(4),
       params_(4),
       unresolved_(16),
       decls_(4),
       already_resolved_(true) {
   SetDefaults(type, NULL, scope_info);
-  if (!scope_info.is_null() && scope_info->HasHeapAllocatedLocals()) {
-    num_heap_slots_ = scope_info_->NumberOfContextSlots();
+  if (!scope_info.is_null()) {
+    if (scope_info->HasHeapAllocatedLocals()) {
+      num_heap_slots_ = scope_info_->NumberOfContextSlots();
+    }
+    source_beg_statement_pos_ = scope_info_->SourceBegStatementPos();
+    source_end_statement_pos_ = scope_info_->SourceEndStatementPos();
   }
   AddInnerScope(inner_scope);
 }
 
 
 Scope::Scope(Scope* inner_scope, Handle<String> catch_variable_name)
     : isolate_(Isolate::Current()),
       inner_scopes_(1),
       variables_(),
       temps_(0),
@@ skipping 29 matching lines @@
   scope_calls_eval_ = false;
   // Inherit the strict mode from the parent scope.
   strict_mode_ = (outer_scope != NULL) && outer_scope->strict_mode_;
   outer_scope_calls_non_strict_eval_ = false;
   inner_scope_calls_eval_ = false;
   force_eager_compilation_ = false;
   num_var_or_const_ = 0;
   num_stack_slots_ = 0;
   num_heap_slots_ = 0;
   scope_info_ = scope_info;
+  source_beg_statement_pos_ = RelocInfo::kNoPosition;

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

You could consider setting positions for all scopes.  On the one hand, and
invalid position clearly says we don't care and is better than an incorrect one.

On the other hand, it could be useful to have in general (e.g., to remove the
redundant positions from function literals and so forth).

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

It is set for all scopes during initial parsing, but not necessarily when
deserializing the outer scope chain. There we only get a SerializedScopeInfo for
function and block scopes, but not for with or catch scopes.
I removed the redundant positions from function literal. It now gets the
positions from the scope and which are always valid.
On 2011/10/05 08:43:36, Kevin Millikin wrote:

+  source_end_statement_pos_ = RelocInfo::kNoPosition;
 }
 
 
 Scope* Scope::DeserializeScopeChain(CompilationInfo* info,
                                     Scope* global_scope) {
   // Reconstruct the outer scope chain from a closure's context chain.
   ASSERT(!info->closure().is_null());
   Context* context = info->closure()->context();
   Scope* current_scope = NULL;
   Scope* innermost_scope = NULL;
@@ skipping 917 matching lines @@
   if (num_heap_slots_ == Context::MIN_CONTEXT_SLOTS &&
       !must_have_local_context) {
     num_heap_slots_ = 0;
   }
 
   // Allocation done.
   ASSERT(num_heap_slots_ == 0 || num_heap_slots_ >= Context::MIN_CONTEXT_SLOTS);
 }
 
 } }  // namespace v8::internal