Classes: Fix issue with default constructor crash

src/ast.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_AST_H_
 #define V8_AST_H_
 
 #include "src/v8.h"
 
 #include "src/assembler.h"
@@ skipping 3604 matching lines @@
   ClassLiteral* NewClassLiteral(const AstRawString* name, Expression* extends,
                                 Expression* constructor,
                                 ZoneList<ObjectLiteral::Property*>* properties,
                                 int start_position, int end_position) {
     ClassLiteral* lit =
         new (zone_) ClassLiteral(zone_, name, extends, constructor, properties,
                                  start_position, end_position);
     VISIT_AND_RETURN(ClassLiteral, lit)
   }
 
+  FunctionLiteral* NewDefaultConstructor(const AstRawString* name,
+                                         AstValueFactory* ast_value_factory,
+                                         Scope* scope, int position) {
+    ZoneList<Statement*>* body = new(zone_) ZoneList<Statement*>(0, zone_);
+    int materialized_literal_count = 0;
+    int expected_property_count = 0;
+    int handler_count = 0;
+    int parameter_count = 0;
+
+    FunctionLiteral::FunctionType function_type =
+        FunctionLiteral::NAMED_EXPRESSION;
+    if (name == NULL) {
+      name = ast_value_factory->empty_string();
+      function_type = FunctionLiteral::ANONYMOUS_EXPRESSION;
+    }
+
+    return NewFunctionLiteral(name, ast_value_factory, scope, body,
+        materialized_literal_count, expected_property_count, handler_count,
+        parameter_count, FunctionLiteral::kNoDuplicateParameters,
+        FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::kIsFunction,
+        FunctionLiteral::kNotParenthesized, FunctionKind::kNormalFunction,
+        position);
+  }
+
+
   NativeFunctionLiteral* NewNativeFunctionLiteral(const AstRawString* name,
                                                   v8::Extension* extension,
                                                   int pos) {
     NativeFunctionLiteral* lit =
         new (zone_) NativeFunctionLiteral(zone_, name, extension, pos);
     VISIT_AND_RETURN(NativeFunctionLiteral, lit)
   }
 
   ThisFunction* NewThisFunction(int pos) {
     ThisFunction* fun = new (zone_) ThisFunction(zone_, pos);
@@ skipping 10 matching lines @@
  private:
   Zone* zone_;
   Visitor visitor_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_