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

src/parsing/parser.cc

Index: src/parsing/parser.cc
diff --git a/src/parsing/parser.cc b/src/parsing/parser.cc
index 262ce278cf94cf256b5424a5261faa3f2f3cb121..900f87401d205d88cc47f49671f50b6004644c2c 100644
--- a/src/parsing/parser.cc
+++ b/src/parsing/parser.cc
@@ -2531,7 +2531,8 @@ FunctionLiteral* Parser::ParseFunctionLiteral(
   }
 
   FunctionLiteral::EagerCompileHint eager_compile_hint =
-      function_state_->next_function_is_parenthesized()
+      (function_state_->next_function_is_parenthesized() ||

[Toon Verwaest, 2016/11/17 13:56:48]

What about just something like: next_function_is_likely_called?

[vogelheim, 2016/11/17 14:56:31]

I thought about it... the reason why I prefer it this way is that at least this
keeps the decision in one place.

We've had a bunch of difficulties with parse decisions being made all over the
place. If we give FunctionState a next_function_is_likely_called member, then
anyone with access to FunctionState can make this eager/lazy-parse decision.
This way, the FunctionState records only clearly defined "facts" (as in: was
there an opening parenthesis/an exclamation point?), and we make the decision
here.

That is, admittedly, semantic nitpicking and hair splitting, since... in either
case we're passing booleans around, and the only actual difference would be that
we execute the || operator sooner (rather than later).

I'm not really sure.... If you have a strong opinion, I'll gladly follow it.
Otherwise, I'd leave this as-is.

+       function_state_->next_function_is_exclaimed())
           ? FunctionLiteral::kShouldEagerCompile
           : default_eager_compile_hint();