Lolcode candidate: Both Expression and FunctionLiteral define the same accessor

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 360 matching lines @@
     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,
       materialized_literal_count, expected_property_count, handler_count,
       parameter_count, FunctionLiteral::kNoDuplicateParameters,
       FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::kIsFunction,
-      FunctionLiteral::kNotParenthesized, kind, pos);
+      FunctionLiteral::kShouldLazyCompile, kind, pos);
 
   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.
@@ skipping 640 matching lines @@
     }
 
     if (ok) {
       result = factory()->NewFunctionLiteral(
           ast_value_factory()->empty_string(), ast_value_factory(), scope_,
           body, function_state.materialized_literal_count(),
           function_state.expected_property_count(),
           function_state.handler_count(), 0,
           FunctionLiteral::kNoDuplicateParameters,
           FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::kGlobalOrEval,
-          FunctionLiteral::kNotParenthesized, FunctionKind::kNormalFunction, 0);
+          FunctionLiteral::kShouldLazyCompile, FunctionKind::kNormalFunction,
+          0);
     }
   }
 
   // Make sure the target stack is empty.
   DCHECK(target_stack_ == NULL);
 
   return result;
 }
 
 
@@ skipping 2773 matching lines @@
   // need to match the pre-parser's behavior.
   if (expr->IsBinaryOperation()) {
     BinaryOperation* binop = expr->AsBinaryOperation();
     if (binop->op() != Token::COMMA) {
       ReportMessageAt(params_loc, "malformed_arrow_function_parameter_list");
       *ok = false;
       return;
     }
     Expression* left = binop->left();
     Expression* right = binop->right();
-    if (left->is_parenthesized() || right->is_parenthesized()) {
+    if (left->is_single_parenthesized() || right->is_single_parenthesized()) {
       ReportMessageAt(params_loc, "malformed_arrow_function_parameter_list");
       *ok = false;
       return;
     }
     DeclareArrowFunctionParameters(scope, left, params_loc, error_locs, ok);
     if (!*ok) return;
     // LHS of comma expression should be unparenthesized.
     expr = right;
   }
 
@@ skipping 121 matching lines @@
                          is_sloppy(language_mode()) &&
                          (original_scope_ == original_declaration_scope ||
                           declaration_scope != original_declaration_scope)
                      ? NewScope(declaration_scope, FUNCTION_SCOPE, kind)
                      : NewScope(scope_, FUNCTION_SCOPE, kind);
   ZoneList<Statement*>* body = NULL;
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   int handler_count = 0;
   FormalParameterErrorLocations error_locs;
-  FunctionLiteral::IsParenthesizedFlag parenthesized = parenthesized_function_
-      ? FunctionLiteral::kIsParenthesized
-      : FunctionLiteral::kNotParenthesized;
+  FunctionLiteral::EagerCompileHint eager_compile_hint =
+      parenthesized_function_ ? FunctionLiteral::kShouldEagerCompile
+                              : FunctionLiteral::kShouldLazyCompile;
   // Parse function body.
   {
     AstNodeFactory function_factory(ast_value_factory());
     FunctionState function_state(&function_state_, &scope_, scope, kind,
                                  &function_factory);
     scope_->SetScopeName(function_name);
 
     if (is_generator) {
       // For generators, allocating variables in contexts is currently a win
       // because it minimizes the work needed to suspend and resume an
@@ skipping 125 matching lines @@
   }
 
   FunctionLiteral::ParameterFlag duplicate_parameters =
       error_locs.duplicate.IsValid() ? FunctionLiteral::kHasDuplicateParameters
                                      : FunctionLiteral::kNoDuplicateParameters;
 
   FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
       function_name, ast_value_factory(), scope, body,
       materialized_literal_count, expected_property_count, handler_count,
       num_parameters, duplicate_parameters, function_type,
-      FunctionLiteral::kIsFunction, parenthesized, kind, pos);
+      FunctionLiteral::kIsFunction, eager_compile_hint, kind, pos);
   function_literal->set_function_token_position(function_token_pos);
 
   if (scope->has_rest_parameter()) {
     // TODO(caitp): enable optimization of functions with rest params
     function_literal->set_dont_optimize_reason(kRestParameter);
   }
 
   if (fni_ != NULL && should_infer_name) fni_->AddFunction(function_literal);
   return function_literal;
 }
@@ skipping 1694 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 v8::internal