Insert closure calls in conditional expression of assert (issue 1584).

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/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 4969 matching lines @@
 AstNode* Parser::MakeAssertCall(intptr_t begin, intptr_t end) {
   ArgumentListNode* arguments = new ArgumentListNode(begin);
   arguments->Add(new LiteralNode(begin,
       Integer::ZoneHandle(Integer::New(begin))));
   arguments->Add(new LiteralNode(end,
       Integer::ZoneHandle(Integer::New(end))));
   return MakeStaticCall(kAssertionErrorName, kThrowNewName, arguments);
 }
 
 
+AstNode* Parser::InsertClosureCallNodes(AstNode* condition) {
+  if (condition->IsClosureNode() ||
+      (condition->IsStoreLocalNode() &&
+       condition->AsStoreLocalNode()->value()->IsClosureNode())) {
+    EnsureExpressionTemp();
+    // Function literal in assert implies a call.
+    const intptr_t pos = condition->token_index();
+    condition = new ClosureCallNode(pos, condition, new 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::ParseAssertStatement() {
   TRACE_PARSER("ParseAssertStatement");
   ConsumeToken();  // Consume assert keyword.
   ExpectToken(Token::kLPAREN);
   const intptr_t condition_pos = token_index_;
   if (!FLAG_enable_asserts && !FLAG_enable_type_checks) {
     SkipExpr();
     ExpectToken(Token::kRPAREN);
     return NULL;
   }
   AstNode* condition = ParseExpr(kAllowConst);
   const intptr_t condition_end = token_index_;
   ExpectToken(Token::kRPAREN);
-  if (condition->IsClosureNode()) {
-    EnsureExpressionTemp();
-    // Function literal in assert implies a call.
-    condition =
-        new ClosureCallNode(condition_pos,
-                            condition,
-                            new ArgumentListNode(condition_pos));
-  }
+  condition = InsertClosureCallNodes(condition);
   condition = new UnaryOpNode(condition_pos, Token::kNOT, condition);
   AstNode* assert_throw = MakeAssertCall(condition_pos, condition_end);
   return new IfNode(condition_pos,
                     condition,
                     NodeAsSequenceNode(condition_pos, assert_throw, NULL),
                     NULL);
 }
 
 
 struct CatchParamDesc {
@@ skipping 3495 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart