Classes: Partial fix for constructor not calling super

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 257 matching lines @@
 
 Scope* Parser::NewScope(Scope* parent, ScopeType scope_type) {
   DCHECK(ast_value_factory());
   Scope* result =
       new (zone()) Scope(parent, scope_type, ast_value_factory(), zone());
   result->Initialize();
   return result;
 }
 
 
+FunctionLiteral* Parser::DefaultConstructor(bool call_super, Scope* scope) {
+  int materialized_literal_count = -1;
+  int expected_property_count = -1;
+  int handler_count = 0;
+  int parameter_count = 0;
+  AstProperties ast_properties;
+  BailoutReason dont_optimize_reason = kNoReason;
+  const AstRawString* name = ast_value_factory()->empty_string();
+  FunctionKind kind = call_super ? FunctionKind::kDefaultConstructorCallSuper
+                                 : FunctionKind::kDefaultConstructor;
+
+  Scope* function_scope = NewScope(scope, FUNCTION_SCOPE);
+  function_scope->SetStrictMode(STRICT);
+  ZoneList<Statement*>* body = NULL;
+  int pos = RelocInfo::kNoPosition;
+
+  {
+    AstNodeFactory<AstConstructionVisitor> function_factory(
+        ast_value_factory());
+    FunctionState function_state(&function_state_, &scope_, function_scope,
+                                 &function_factory);
+
+    body = new (zone()) ZoneList<Statement*>(1, zone());
+    if (call_super) {
+      Expression* prop = SuperReference(function_scope, factory(), pos);
+      ZoneList<Expression*>* args =
+          new (zone()) ZoneList<Expression*>(0, zone());
+      Call* call = factory()->NewCall(prop, args, pos);
+
+      DCHECK(call->GetCallType(isolate()) == Call::SUPER_CALL);
+
+      body->Add(factory()->NewExpressionStatement(call, pos), zone());
+    }
+
+    materialized_literal_count = function_state.materialized_literal_count();
+    expected_property_count = function_state.expected_property_count();
+    handler_count = function_state.handler_count();
+
+    ast_properties = *factory()->visitor()->ast_properties();
+    dont_optimize_reason = factory()->visitor()->dont_optimize_reason();
+  }
+
+  FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
+      name, ast_value_factory(), function_scope, body,
+      materialized_literal_count, expected_property_count, handler_count,
+      parameter_count, FunctionLiteral::kNoDuplicateParameters,
+      FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::kIsFunction,
+      FunctionLiteral::kNotParenthesized, kind, pos);
+
+  function_literal->set_ast_properties(&ast_properties);
+  function_literal->set_dont_optimize_reason(dont_optimize_reason);
+
+  return function_literal;
+}
+
+
 // ----------------------------------------------------------------------------
 // Target is a support class to facilitate manipulation of the
 // Parser's target_stack_ (the stack of potential 'break' and
 // 'continue' statement targets). Upon construction, a new target is
 // added; it is removed upon destruction.
 
 class Target BASE_EMBEDDED {
  public:
   Target(Target** variable, AstNode* node)
       : variable_(variable), node_(node), previous_(*variable) {
@@ skipping 353 matching lines @@
 }
 
 Expression* ParserTraits::ClassExpression(
     const AstRawString* name, Expression* extends, Expression* constructor,
     ZoneList<ObjectLiteral::Property*>* properties, int start_position,
     int end_position, AstNodeFactory<AstConstructionVisitor>* factory) {
   return factory->NewClassLiteral(name, extends, constructor, properties,
                                   start_position, end_position);
 }
 
+
+Expression* ParserTraits::DefaultConstructor(bool call_super, Scope* scope) {
+  return parser_->DefaultConstructor(call_super, scope);
+}
+
+
 Literal* ParserTraits::ExpressionFromLiteral(
     Token::Value token, int pos,
     Scanner* scanner,
     AstNodeFactory<AstConstructionVisitor>* factory) {
   switch (token) {
     case Token::NULL_LITERAL:
       return factory->NewNullLiteral(pos);
     case Token::TRUE_LITERAL:
       return factory->NewBooleanLiteral(true, pos);
     case Token::FALSE_LITERAL:
@@ skipping 267 matching lines @@
   // the main thread.
   HistogramTimerScope timer_scope(isolate()->counters()->parse_lazy());
   Handle<String> source(String::cast(script()->source()));
   isolate()->counters()->total_parse_size()->Increment(source->length());
   base::ElapsedTimer timer;
   if (FLAG_trace_parse) {
     timer.Start();
   }
   Handle<SharedFunctionInfo> shared_info = info()->shared_info();
 
-  // Initialize parser state.
-  source = String::Flatten(source);
   FunctionLiteral* result;
-  if (source->IsExternalTwoByteString()) {
-    ExternalTwoByteStringUtf16CharacterStream stream(
-        Handle<ExternalTwoByteString>::cast(source),
-        shared_info->start_position(),
-        shared_info->end_position());
-    result = ParseLazy(&stream);
+  if (shared_info->is_default_constructor() ||
+      shared_info->is_default_constructor_call_super()) {
+    ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
+    Scope* scope = NewScope(scope_, GLOBAL_SCOPE);
+    info()->SetGlobalScope(scope);
+    if (!info()->closure().is_null()) {
+      scope = Scope::DeserializeScopeChain(info()->closure()->context(), scope,
+                                           zone());
+    }
+    original_scope_ = scope;
+    AstNodeFactory<AstConstructionVisitor> function_factory(
+        ast_value_factory());
+    FunctionState function_state(&function_state_, &scope_, scope,
+                                 &function_factory);
+    result = DefaultConstructor(
+        shared_info->is_default_constructor_call_super(), scope);

[Dmitry Lomov (no reviews), 2014/11/07 07:01:11]

I believe if you set positions correctly all this can be handled downstream in
ParseLazy(&stream) so that you do not need to duplicate all this set-up.

   } else {
-    GenericStringUtf16CharacterStream stream(source,
-                                             shared_info->start_position(),
-                                             shared_info->end_position());
-    result = ParseLazy(&stream);
+    // Initialize parser state.
+    source = String::Flatten(source);
+    if (source->IsExternalTwoByteString()) {
+      ExternalTwoByteStringUtf16CharacterStream stream(
+          Handle<ExternalTwoByteString>::cast(source),
+          shared_info->start_position(), shared_info->end_position());
+      result = ParseLazy(&stream);
+    } else {
+      GenericStringUtf16CharacterStream stream(
+          source, shared_info->start_position(), shared_info->end_position());
+      result = ParseLazy(&stream);
+    }
   }
 
   if (FLAG_trace_parse && result != NULL) {
     double ms = timer.Elapsed().InMillisecondsF();
     SmartArrayPointer<char> name_chars = result->debug_name()->ToCString();
     PrintF("[parsing function: %s - took %0.3f ms]\n", name_chars.get(), ms);
   }
   return result;
 }
 
@@ skipping 3993 matching lines @@
 
   // We cannot internalize on a background thread; a foreground task will take
   // care of calling Parser::Internalize just before compilation.
 
   if (compile_options() == ScriptCompiler::kProduceParserCache) {
     if (result != NULL) *info_->cached_data() = recorder.GetScriptData();
     log_ = NULL;
   }
 }
 } }  // namespace v8::internal