Make VM accept function values in assert statements.

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 9157 matching lines @@
   arguments->Add(new(Z) LiteralNode(begin,
       Integer::ZoneHandle(Z, Integer::New(begin.value(), Heap::kOld))));
   arguments->Add(new(Z) LiteralNode(end,
       Integer::ZoneHandle(Z, Integer::New(end.value(), Heap::kOld))));
   return MakeStaticCall(Symbols::AssertionError(),
                         Library::PrivateCoreLibName(Symbols::ThrowNew()),
                         arguments);
 }
 
 
-AstNode* Parser::InsertClosureCallNodes(AstNode* condition) {
-  if (condition->IsClosureNode() ||
-      (condition->IsStoreLocalNode() &&
-       condition->AsStoreLocalNode()->value()->IsClosureNode())) {
-    // Function literal in assert implies a call.
-    const TokenPosition pos = condition->token_pos();
-    condition = BuildClosureCall(pos,
-                                 condition,
-                                 new(Z) ArgumentListNode(pos));
-  } else if (condition->IsConditionalExprNode()) {
-    ConditionalExprNode* cond_expr = condition->AsConditionalExprNode();
-    cond_expr->set_true_expr(InsertClosureCallNodes(cond_expr->true_expr()));
-    cond_expr->set_false_expr(InsertClosureCallNodes(cond_expr->false_expr()));
-  }
-  return condition;
+AstNode* Parser::HandleAssertCondition(AstNode* condition) {
+  const TokenPosition pos = condition->token_pos();
+  ArgumentListNode* arguments = new(Z) ArgumentListNode(pos);
+  arguments->Add(condition);
+  return MakeStaticCall(Symbols::AssertionError(),
+                        Library::PrivateCoreLibName(Symbols::HandleCondition()),
+                        arguments);
 }
 
 
 AstNode* Parser::ParseAssertStatement() {
   TRACE_PARSER("ParseAssertStatement");
   ConsumeToken();  // Consume assert keyword.
   ExpectToken(Token::kLPAREN);
   const TokenPosition condition_pos = TokenPos();
   if (!I->asserts()) {
     SkipExpr();
     ExpectToken(Token::kRPAREN);
     return NULL;
   }
   AstNode* condition = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
   const TokenPosition condition_end = TokenPos();
   ExpectToken(Token::kRPAREN);
-  condition = InsertClosureCallNodes(condition);
+  condition = HandleAssertCondition(condition);
   condition = new(Z) UnaryOpNode(condition_pos, Token::kNOT, condition);
   AstNode* assert_throw = MakeAssertCall(condition_pos, condition_end);
   return new(Z) IfNode(

[hausner, 2016/06/14 17:51:31]

Since you now call a Dart function to evaluate the assert condition, you might
as well move the if statement and throwing the exception in that same dart
function. That makes the generated code smaller. The only drawback is that you
have to pass two additional parameters. 

[Lasse Reichstein Nielsen, 2016/06/15 05:57:02]

I'm not particularly worried about passing two extra integer literals, but I
would prefer to let you do it, to ensure that the correct positions are
attributed to the nodes. So, yes, please :)

       condition_pos,
       condition,
       NodeAsSequenceNode(condition_pos, assert_throw, NULL),
       NULL);
 }
 
 
 // Populate local scope of the catch block with the catch parameters.
 void Parser::AddCatchParamsToScope(CatchParamDesc* exception_param,
                                    CatchParamDesc* stack_trace_param,
@@ skipping 5407 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME