Treat a '!' preceding a function literal as eager-compile hint.

src/parsing/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/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 406 matching lines @@
   // The same idea for '-foo' => 'foo*(-1)'.
   if (op == Token::SUB) {
     return factory()->NewBinaryOperation(
         Token::MUL, expression, factory()->NewNumberLiteral(-1, pos), pos);
   }
   // ...and one more time for '~foo' => 'foo^(~0)'.
   if (op == Token::BIT_NOT) {
     return factory()->NewBinaryOperation(
         Token::BIT_XOR, expression, factory()->NewNumberLiteral(~0, pos), pos);
   }
+
   return factory()->NewUnaryOperation(op, expression, pos);
 }
 
 Expression* Parser::BuildIteratorResult(Expression* value, bool done) {
   int pos = kNoSourcePosition;
 
   if (value == nullptr) value = factory()->NewUndefinedLiteral(pos);
 
   auto args = new (zone()) ZoneList<Expression*>(2, zone());
   args->Add(value, zone());
@@ skipping 2087 matching lines @@
   // handle as the function name.  Remember if we were passed a non-empty
   // handle to decide whether to invoke function name inference.
   bool should_infer_name = function_name == NULL;
 
   // We want a non-null handle as the function name.
   if (should_infer_name) {
     function_name = ast_value_factory()->empty_string();
   }
 
   FunctionLiteral::EagerCompileHint eager_compile_hint =
-      function_state_->next_function_is_parenthesized()
+      (function_state_->next_function_is_parenthesized() ||
+       function_state_->next_function_is_exclaimed())
           ? FunctionLiteral::kShouldEagerCompile
           : default_eager_compile_hint();
 
   // Determine if the function can be parsed lazily. Lazy parsing is
   // different from lazy compilation; we need to parse more eagerly than we
   // compile.
 
   // We can only parse lazily if we also compile lazily. The heuristics for lazy
   // compilation are:
   // - It must not have been prohibited by the caller to Parse (some callers
@@ skipping 2890 matching lines @@
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8