Fully deserialize the scope chain after parsing, not before

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/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/parsing/parser-base.h"
@@ skipping 164 matching lines @@
     cached_parse_data_ = NULL;
   }
 
   // Parses the source code represented by the compilation info and sets its
   // function literal.  Returns false (and deallocates any allocated AST
   // nodes) if parsing failed.
   static bool ParseStatic(ParseInfo* info);
   bool Parse(ParseInfo* info);
   void ParseOnBackground(ParseInfo* info);
 
-  void DeserializeScopeChain(ParseInfo* info, Handle<Context> context,
-                             Scope::DeserializationMode deserialization_mode);
+  // Inspect the scope chain prior to parsing in which the script is going to
+  // be executed. If the script is a top-level script, or the scope chain
+  // consists of only a native context, scope_info should be an empty handle.
+  //
+  // This only stores information in the parser about the general shape of the
+  // scope chain, such as the type of the declaration context it contains, but
+  // doesn't yet deserialize the scope chain.
+  void InspectScopeChain(ParseInfo* info, MaybeHandle<ScopeInfo> scope_info);

[adamk, 2016/09/12 16:57:47]

"Inspect" in this function name isn't helpful at all to understanding what it
does (also, "inspect" is normally an idempotent operation). This makes it hard
to know what bits it's going to set, and what logic belongs (or doesn't belong)
inside it. In fact, it already seems to do two different things: one is setting
up  ParseInfo::script_scope(), and the other is setting this ReceiverScope info.

Some names I don't love but like more than InspectScopeChain:

- InitializeScriptAndReceiverScopeInfo
- InitializeOuterScopeData
- InitiatizeScopeChain

Also please rename "scope_info" to "outer_scope_info"

[jochen (gone - plz use gerrit), 2016/09/12 19:00:43]

done

 
   // Handle errors detected during parsing, move statistics to Isolate,
   // internalize strings (move them to the heap).
   void Internalize(Isolate* isolate, Handle<Script> script, bool error);
   void HandleSourceURLComments(Isolate* isolate, Handle<Script> script);
 
  private:
   friend class ParserBase<Parser>;
   friend class v8::internal::ExpressionClassifier<ParserTypes<Parser>>;
 
@@ skipping 244 matching lines @@
   //
   // The var declarations are hoisted to the function scope, but originate from
   // a scope where the name has also been let bound or the var declaration is
   // hoisted over such a scope.
   void CheckConflictingVarDeclarations(Scope* scope, bool* ok);
 
   // Insert initializer statements for var-bindings shadowing parameter bindings
   // from a non-simple parameter list.
   void InsertShadowingVarBindingInitializers(Block* block);
 
-  // Implement sloppy block-scoped functions, ES2015 Annex B 3.3
-  void InsertSloppyBlockFunctionVarBindings(DeclarationScope* scope,
-                                            bool* ok);
-
   VariableProxy* NewUnresolved(const AstRawString* name, int begin_pos,
                                int end_pos = kNoSourcePosition,
                                VariableKind kind = NORMAL_VARIABLE);
   VariableProxy* NewUnresolved(const AstRawString* name);
   Variable* Declare(Declaration* declaration,
                     DeclarationDescriptor::Kind declaration_kind,
                     VariableMode mode, InitializationFlag init, bool* ok,
                     Scope* declaration_scope = nullptr);
   Declaration* DeclareVariable(const AstRawString* name, VariableMode mode,
                                int pos, bool* ok);
@@ skipping 568 matching lines @@
   }
 
   V8_INLINE void CountUsage(v8::Isolate::UseCounterFeature feature) {
     ++use_counts_[feature];
   }
 
   // Parser's private field members.
 
   Scanner scanner_;
   PreParser* reusable_preparser_;
-  Scope* original_scope_;  // for ES5 function declarations in sloppy eval
-
   friend class ParserTarget;
   friend class ParserTargetScope;
   ParserTarget* target_stack_;  // for break, continue statements
-
   ScriptCompiler::CompileOptions compile_options_;
   ParseData* cached_parse_data_;
 
   PendingCompilationErrorHandler pending_error_handler_;
 
   // Other information which will be stored in Parser and moved to Isolate after
   // parsing.
   int use_counts_[v8::Isolate::kUseCounterFeatureCount];
   int total_preparse_skipped_;
   HistogramTimer* pre_parse_timer_;
 
   bool parsing_on_main_thread_;
 
 #ifdef DEBUG
   void Print(AstNode* node);
 #endif  // DEBUG
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_