Lolcode candidate: Both Expression and FunctionLiteral define the same accessor

src/preparser.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_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/bailout-reason.h"
@@ skipping 885 matching lines @@
 
   static PreParserExpression FromIdentifier(PreParserIdentifier id) {
     return PreParserExpression(TypeField::encode(kIdentifierExpression) |
                                IdentifierTypeField::encode(id.type_));
   }
 
   static PreParserExpression BinaryOperation(PreParserExpression left,
                                              Token::Value op,
                                              PreParserExpression right) {
     ValidArrowParam valid_arrow_param_list =
-        (op == Token::COMMA && !left.is_parenthesized() &&
-         !right.is_parenthesized()) ?
-             std::min(left.ValidateArrowParams(), right.ValidateArrowParams())
-             : kInvalidArrowParam;
+        (op == Token::COMMA && !left.is_single_parenthesized() &&
+         !right.is_single_parenthesized())
+            ? std::min(left.ValidateArrowParams(), right.ValidateArrowParams())
+            : kInvalidArrowParam;
     return PreParserExpression(
         TypeField::encode(kBinaryOperationExpression) |
         IsValidArrowParamListField::encode(valid_arrow_param_list));
   }
 
   static PreParserExpression StringLiteral() {
     return PreParserExpression(TypeField::encode(kStringLiteralExpression));
   }
 
   static PreParserExpression UseStrictStringLiteral() {
@@ skipping 118 matching lines @@
   bool IsSpreadExpression() const {
     return TypeField::decode(code_) == kSpreadExpression;
   }
 
   PreParserExpression AsFunctionLiteral() { return *this; }
 
   bool IsBinaryOperation() const {
     return TypeField::decode(code_) == kBinaryOperationExpression;
   }
 
-  bool is_parenthesized() const {
+  bool is_single_parenthesized() const {
     return ParenthesizationField::decode(code_) != kNotParenthesized;
   }
 
   void increase_parenthesization_level() {
     code_ = ParenthesizationField::update(
-        code_, is_parenthesized() ? kMultiParenthesizedExpression
-                                  : kParanthesizedExpression);
+        code_, is_single_parenthesized() ? kMultiParenthesizedExpression
+                                         : kParanthesizedExpression);
   }
 
   // Dummy implementation for making expression->somefunc() work in both Parser
   // and PreParser.
   PreParserExpression* operator->() { return this; }
 
   // More dummy implementations of things PreParser doesn't need to track:
   void set_index(int index) {}  // For YieldExpressions
-  void set_parenthesized() {}
+  void set_should_eager_compile() {}
 
   int position() const { return RelocInfo::kNoPosition; }
   void set_function_token_position(int position) {}
 
  private:
   enum Type {
     kExpression,
     kIdentifierExpression,
     kStringLiteralExpression,
     kBinaryOperationExpression,
@@ skipping 267 matching lines @@
                                         int pos) {
     return PreParserStatement::Default();
   }
   PreParserExpression NewFunctionLiteral(
       PreParserIdentifier name, AstValueFactory* ast_value_factory,
       Scope* scope, PreParserStatementList body, int materialized_literal_count,
       int expected_property_count, int handler_count, int parameter_count,
       FunctionLiteral::ParameterFlag has_duplicate_parameters,
       FunctionLiteral::FunctionType function_type,
       FunctionLiteral::IsFunctionFlag is_function,
-      FunctionLiteral::IsParenthesizedFlag is_parenthesized, FunctionKind kind,
+      FunctionLiteral::EagerCompileHint eager_compile_hint, FunctionKind kind,
       int position) {
     return PreParserExpression::Default();
   }
 
   PreParserExpression NewSpread(PreParserExpression expression, int pos) {
     return PreParserExpression::Spread(expression);
   }
 
   // Return the object itself as AstVisitor and implement the needed
   // dummy method right in this class.
@@ skipping 1593 matching lines @@
           // For other kinds of calls we record position of the parenthesis as
           // position of the call. Note that this is extremely important for
           // expressions of the form function(){...}() for which call position
           // should not point to the closing brace otherwise it will intersect
           // with positions recorded for function literal and confuse debugger.
           pos = peek_position();
           // Also the trailing parenthesis are a hint that the function will
           // be called immediately. If we happen to have parsed a preceding
           // function literal eagerly, we can also compile it eagerly.
           if (result->IsFunctionLiteral() && mode() == PARSE_EAGERLY) {
-            result->AsFunctionLiteral()->set_parenthesized();
+            result->AsFunctionLiteral()->set_should_eager_compile();
           }
         }
         Scanner::Location spread_pos;
         typename Traits::Type::ExpressionList args =
             ParseArguments(&spread_pos, classifier, CHECK_OK);
 
         // Keep track of eval() calls since they disable all local variable
         // optimizations.
         // The calls that need special treatment are the
         // direct eval calls. These calls are all of the form eval(...), with
@@ skipping 341 matching lines @@
       case Token::TEMPLATE_SPAN:
       case Token::TEMPLATE_TAIL: {
         int pos;
         if (scanner()->current_token() == Token::IDENTIFIER) {
           pos = position();
         } else {
           pos = peek_position();
           if (expression->IsFunctionLiteral() && mode() == PARSE_EAGERLY) {
             // If the tag function looks like an IIFE, set_parenthesized() to
             // force eager compilation.
-            expression->AsFunctionLiteral()->set_parenthesized();
+            expression->AsFunctionLiteral()->set_should_eager_compile();
           }
         }
         expression =
             ParseTemplateLiteral(expression, pos, classifier, CHECK_OK);
         break;
       }
       default:
         return expression;
     }
   }
@@ skipping 174 matching lines @@
                               scanner()->location().end_pos, CHECK_OK);
       this->CheckConflictingVarDeclarations(scope, CHECK_OK);
     }
   }
 
   FunctionLiteralT function_literal = factory()->NewFunctionLiteral(
       this->EmptyIdentifierString(), ast_value_factory(), scope, body,
       materialized_literal_count, expected_property_count, handler_count,
       num_parameters, FunctionLiteral::kNoDuplicateParameters,
       FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::kIsFunction,
-      FunctionLiteral::kNotParenthesized, FunctionKind::kArrowFunction,
+      FunctionLiteral::kShouldLazyCompile, FunctionKind::kArrowFunction,
       scope->start_position());
 
   function_literal->set_function_token_position(scope->start_position());
   if (super_loc.IsValid()) function_state_->set_super_location(super_loc);
 
   if (fni_ != NULL) this->InferFunctionName(fni_, function_literal);
 
   return function_literal;
 }
 
@@ skipping 179 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H