Remove --experimental-classes flag and related dead code.

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 254 matching lines @@
 
 FunctionLiteral* Parser::DefaultConstructor(bool call_super, Scope* scope,
                                             int pos, int end_pos) {
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   int handler_count = 0;
   int parameter_count = 0;
   const AstRawString* name = ast_value_factory()->empty_string();
 
 
-  FunctionKind kind = call_super && !FLAG_experimental_classes
-                          ? FunctionKind::kDefaultBaseConstructor
-                          : FunctionKind::kDefaultSubclassConstructor;
+  FunctionKind kind = call_super ? FunctionKind::kDefaultSubclassConstructor
+                                 : FunctionKind::kDefaultBaseConstructor;
   Scope* function_scope = NewScope(scope, FUNCTION_SCOPE, kind);
   function_scope->SetLanguageMode(
       static_cast<LanguageMode>(scope->language_mode() | STRICT_BIT));
   // Set start and end position to the same value
   function_scope->set_start_position(pos);
   function_scope->set_end_position(pos);
   ZoneList<Statement*>* body = NULL;
 
   {
     AstNodeFactory function_factory(ast_value_factory());
     FunctionState function_state(&function_state_, &scope_, function_scope,
                                  kind, &function_factory);
 
     body = new (zone()) ZoneList<Statement*>(call_super ? 2 : 1, zone());
     AddAssertIsConstruct(body, pos);
     if (call_super) {
       ZoneList<Expression*>* args =
           new (zone()) ZoneList<Expression*>(0, zone());
-      if (FLAG_experimental_classes) {
-        CallRuntime* call = factory()->NewCallRuntime(
-            ast_value_factory()->empty_string(),
-            Runtime::FunctionForId(Runtime::kInlineDefaultConstructorCallSuper),
-            args, pos);
-        body->Add(factory()->NewReturnStatement(call, pos), zone());
-      } else {
-        CallRuntime* call = factory()->NewCallRuntime(
-            ast_value_factory()->empty_string(),
-            Runtime::FunctionForId(Runtime::kDefaultConstructorSuperCall), args,
-            pos);
-        body->Add(factory()->NewExpressionStatement(call, pos), zone());
-      }
+      CallRuntime* call = factory()->NewCallRuntime(
+          ast_value_factory()->empty_string(),
+          Runtime::FunctionForId(Runtime::kInlineDefaultConstructorCallSuper),
+          args, pos);
+      body->Add(factory()->NewReturnStatement(call, pos), zone());
       function_scope->RecordSuperConstructorCallUsage();
     }
 
     materialized_literal_count = function_state.materialized_literal_count();
     expected_property_count = function_state.expected_property_count();
     handler_count = function_state.handler_count();
   }
 
   FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
       name, ast_value_factory(), function_scope, body,
@@ skipping 2309 matching lines @@
   Expect(Token::RETURN, CHECK_OK);
   Scanner::Location loc = scanner()->location();
 
   Token::Value tok = peek();
   Statement* result;
   Expression* return_value;
   if (scanner()->HasAnyLineTerminatorBeforeNext() ||
       tok == Token::SEMICOLON ||
       tok == Token::RBRACE ||
       tok == Token::EOS) {
-    if (FLAG_experimental_classes &&
-        IsSubclassConstructor(function_state_->kind())) {
+    if (IsSubclassConstructor(function_state_->kind())) {
       return_value = ThisExpression(scope_, factory(), loc.beg_pos);
     } else {
       return_value = GetLiteralUndefined(position());
     }
   } else {
     return_value = ParseExpression(true, CHECK_OK);
   }
   ExpectSemicolon(CHECK_OK);
 
   if (is_generator()) {
@@ skipping 1265 matching lines @@
     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());
   }
 }
 
 
 void Parser::AddAssertIsConstruct(ZoneList<Statement*>* body, int pos) {
-  if (!FLAG_experimental_classes) return;
-
   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);
   CallRuntime* non_callable_error = factory()->NewCallRuntime(
       ast_value_factory()->empty_string(),
       Runtime::FunctionForId(Runtime::kThrowConstructorNonCallableError),
       arguments, pos);
   IfStatement* if_statement = factory()->NewIfStatement(
@@ skipping 56 matching lines @@
     VariableProxy* get_proxy = factory()->NewVariableProxy(
         function_state_->generator_object_variable());
     Expression* undefined =
         factory()->NewUndefinedLiteral(RelocInfo::kNoPosition);
     Yield* yield = factory()->NewYield(get_proxy, undefined, Yield::kFinal,
                                        RelocInfo::kNoPosition);
     body->Add(factory()->NewExpressionStatement(
         yield, RelocInfo::kNoPosition), zone());
   }
 
-  if (FLAG_experimental_classes && IsSubclassConstructor(kind)) {
+  if (IsSubclassConstructor(kind)) {
     body->Add(
         factory()->NewReturnStatement(
             this->ThisExpression(scope_, factory(), RelocInfo::kNoPosition),
             RelocInfo::kNoPosition),
         zone());
   }
 
   Expect(Token::RBRACE, CHECK_OK);
   scope_->set_end_position(scanner()->location().end_pos);
 
@@ skipping 1456 matching lines @@
     } else {
       const uc16* data = reinterpret_cast<const uc16*>(raw_string->raw_data());
       running_hash = StringHasher::ComputeRunningHash(running_hash, data,
                                                       raw_string->length());
     }
   }
 
   return running_hash;
 }
 } }  // namespace v8::internal