[es6] super.prop, eval and lazy functions

src/parser.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 4085 matching lines @@
 
       scope_->set_end_position(entry.end_pos());
       Expect(Token::RBRACE, ok);
       if (!*ok) {
         return;
       }
       total_preparse_skipped_ += scope_->end_position() - function_block_pos;
       *materialized_literal_count = entry.literal_count();
       *expected_property_count = entry.property_count();
       scope_->SetLanguageMode(entry.language_mode());
-      if (entry.uses_super_property()) scope_->RecordSuperPropertyUsage();
+      if (entry.needs_home_object()) scope_->RecordSuperPropertyUsage();

[adamk, 2015/06/04 20:02:33]

Maybe rename RecordSuperPropertyUsage() to something about HomeObject? I'll
admit "RecordNeedsHomeObject" doesn't sound great, though.

[arv (Not doing code reviews), 2015/06/04 20:15:57]

Yeah. This could be improved.

The Scope keeps track of both super.property and eval but the logging does not
keep 2 flags. So, when we recreate the Scope from the log we lost the calls_eval
flag (it gets set again in the eager parsing)

[arv (Not doing code reviews), 2015/06/04 20:48:26]

I changed it to use 2 fields in the logger instead. It is not required but it is
cleaner and straightforward.

       return;
     }
     cached_parse_data_->Reject();
   }
   // With no cached data, we partially parse the function, without building an
   // AST. This gathers the data needed to build a lazy function.
   SingletonLogger logger;
   PreParser::PreParseResult result =
       ParseLazyFunctionBodyWithPreParser(&logger, bookmark);
   if (bookmark && bookmark->HasBeenReset()) {
@@ skipping 14 matching lines @@
   }
   scope_->set_end_position(logger.end());
   Expect(Token::RBRACE, ok);
   if (!*ok) {
     return;
   }
   total_preparse_skipped_ += scope_->end_position() - function_block_pos;
   *materialized_literal_count = logger.literals();
   *expected_property_count = logger.properties();
   scope_->SetLanguageMode(logger.language_mode());
-  if (logger.scope_uses_super_property()) {
+  if (logger.needs_home_object()) {
     scope_->RecordSuperPropertyUsage();
   }
   if (produce_cached_parse_data()) {
     DCHECK(log_);
     // Position right after terminal '}'.
     int body_end = scanner()->location().end_pos;
     log_->LogFunction(function_block_pos, body_end, *materialized_literal_count,
                       *expected_property_count, scope_->language_mode(),
-                      scope_->uses_super_property());
+                      scope_->NeedsHomeObject());
   }
 }
 
 
 void Parser::AddAssertIsConstruct(ZoneList<Statement*>* body, int pos) {
   ZoneList<Expression*>* arguments =
       new (zone()) ZoneList<Expression*>(0, zone());
   CallRuntime* construct_check = factory()->NewCallRuntime(
       ast_value_factory()->is_construct_call_string(),
       Runtime::FunctionForId(Runtime::kInlineIsConstructCall), arguments, pos);
@@ skipping 1657 matching lines @@
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(
       ast_value_factory()->reflect_construct_string(), NULL, args, pos);
 }
 }  // namespace internal
 }  // namespace v8