Implement assert in initializer list in VM.

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 34 matching lines @@
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
 DEFINE_FLAG(bool, warn_mixin_typedef, true, "Warning on legacy mixin typedef.");
 // TODO(floitsch): remove the conditional-directive flag, once we publicly
 // committed to the current version.
 DEFINE_FLAG(bool, conditional_directives, true,
     "Enable conditional directives");
 DEFINE_FLAG(bool, warn_super, false,
     "Warning if super initializer not last in initializer list.");
 DEFINE_FLAG(bool, await_is_keyword, false,
     "await and yield are treated as proper keywords in synchronous code.");
+DEFINE_FLAG(bool, assert_initializer, false,
+    "Allow asserts in initializer lists.");
 
 DECLARE_FLAG(bool, profile_vm);
 DECLARE_FLAG(bool, trace_service);
 
 // Quick access to the current thread, isolate and zone.
 #define T (thread())
 #define I (isolate())
 #define Z (zone())
 
 // Quick synthetic token position.
@@ skipping 2519 matching lines @@
   }
   return new StaticCallNode(supercall_pos, super_ctor, arguments);
 }
 
 
 AstNode* Parser::ParseInitializer(const Class& cls,
                                   LocalVariable* receiver,
                                   GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializer");
   const TokenPosition field_pos = TokenPos();
+  if (FLAG_assert_initializer && CurrentToken() == Token::kASSERT) {

[hausner, 2016/08/15 20:54:26]

Extra parens around the == expression.

+    return ParseAssertStatement(current_function().is_const());
+  }
   if (CurrentToken() == Token::kTHIS) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
   }
   const String& field_name = *ExpectIdentifier("field name expected");
   ExpectToken(Token::kASSIGN);
 
   const bool saved_mode = SetAllowFunctionLiterals(false);
   // "this" must not be accessible in initializer expressions.
   receiver->set_invisible(true);
@@ skipping 269 matching lines @@
           ReportError("duplicate call to super constructor");
         }
         super_init_call = ParseSuperInitializer(cls, receiver);
         super_init_index = current_block_->statements->length();
         current_block_->statements->Add(super_init_call);
         super_init_is_last = true;
       } else {
         AstNode* init_statement =
             ParseInitializer(cls, receiver, initialized_fields);
         super_init_is_last = false;
-        current_block_->statements->Add(init_statement);
+        if (init_statement != NULL) {
+          current_block_->statements->Add(init_statement);
+        }
       }
     } while (CurrentToken() == Token::kCOMMA);
   }
   if (super_init_call == NULL) {
     // Generate implicit super() if we haven't seen an explicit super call
     // or constructor redirection.
     super_init_call =
         GenerateSuperConstructorCall(cls, TokenPos(), receiver, NULL);
     if (super_init_call != NULL) {
       super_init_index = current_block_->statements->length();
@@ skipping 690 matching lines @@
   do {
     ConsumeToken();  // Colon or comma.
     if (CurrentToken() == Token::kSUPER) {
       ConsumeToken();
       if (CurrentToken() == Token::kPERIOD) {
         ConsumeToken();
         ExpectIdentifier("identifier expected");
       }
       CheckToken(Token::kLPAREN);
       SkipToMatchingParenthesis();
+    } else if (FLAG_assert_initializer && CurrentToken() == Token::kASSERT) {

[hausner, 2016/08/15 20:54:26]

Extra parens around the == expression.

[Lasse Reichstein Nielsen, 2016/08/23 07:05:30]

Done.

+      ConsumeToken();
+      CheckToken(Token::kLPAREN);
+      SkipToMatchingParenthesis();
     } else {
       SkipIf(Token::kTHIS);
       SkipIf(Token::kPERIOD);
       ExpectIdentifier("identifier expected");
       ExpectToken(Token::kASSIGN);
       SetAllowFunctionLiterals(false);
       SkipExpr();
       SetAllowFunctionLiterals(true);
     }
   } while (CurrentToken() == Token::kCOMMA);
@@ skipping 5583 matching lines @@
   const Function& func = Function::ZoneHandle(Z,
       Resolver::ResolveStatic(cls,
                               func_name,
                               arguments->length(),
                               arguments->names()));
   ASSERT(!func.IsNull());
   return new(Z) StaticCallNode(arguments->token_pos(), func, arguments);
 }
 
 
-AstNode* Parser::ParseAssertStatement() {
+AstNode* Parser::ParseAssertStatement(bool is_const) {
   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);
+  if (is_const && !condition->IsPotentiallyConst()) {
+    ReportError(condition_pos,
+                "initializer assert expression must be compile time constant.");
+  }
   const TokenPosition condition_end = TokenPos();
   ExpectToken(Token::kRPAREN);
 
+  // Reuse the _AssertionError._checkAssertion function for const calls as well,
+  // but ensure that the value is a bool.

[Lasse Reichstein Nielsen, 2016/07/07 12:48:41]

Another option is to have a separate function that only does the throwing.

A third option is to replace the condition with `!!condition` before calling 
the function instead of using an if, which enforces booleanness at the call
point and lets the function call work as usual on that bool value.

[hausner, 2016/08/15 20:54:26]

Maybe option 2 is cleaner. I'd prefer a separate function for the const case.

[Lasse Reichstein Nielsen, 2016/08/23 07:05:31]

Will do.

   ArgumentListNode* arguments = new(Z) ArgumentListNode(condition_pos);
-  arguments->Add(condition);
+  if (is_const) {
+    arguments->Add(new(Z) LiteralNode(condition_pos, Bool::False()));

[hausner, 2016/08/15 20:54:26]

I don't see a bool parameter in _AssertionError._checkAssertion()


  static void _checkAssertion(condition, int start, int end) {
    if (condition is Function) {
      condition = condition();
    }
    if (!condition) {
      _throwNew(start, end);
    }
  }

[Lasse Reichstein Nielsen, 2016/08/23 07:05:31]

Since I already checked the condition in the `IfNode`, I don't pass the
condition to the helper function, just a `false` value. It's still the
"condition" parameter. 
That also means that I don't use the condition expression twice.
(Moot now, since I changed it to just call a different function).

+  } else {
+    arguments->Add(condition);
+  }
   arguments->Add(new(Z) LiteralNode(condition_pos,
       Integer::ZoneHandle(Z, Integer::New(condition_pos.value(), Heap::kOld))));
   arguments->Add(new(Z) LiteralNode(condition_end,
       Integer::ZoneHandle(Z, Integer::New(condition_end.value(), Heap::kOld))));
-  return MakeStaticCall(Symbols::AssertionError(),
-                        Library::PrivateCoreLibName(Symbols::CheckAssertion()),
-                        arguments);
+  AstNode* assert_throw = MakeStaticCall(Symbols::AssertionError(),
+      Library::PrivateCoreLibName(Symbols::CheckAssertion()),
+      arguments);
+
+  if (!is_const) return assert_throw;
+  condition = new(Z) UnaryOpNode(condition_pos, Token::kNOT, condition);
+  return new(Z) IfNode(
+       condition_pos,
+       condition,

[hausner, 2016/08/15 20:54:26]

I don't think you can use the 'condition' expression twice (once as a parameter
to checkAssertion(), and once negated in the if-condition.) You need to use a
temporary variable to hold the evaluated expression.

[Lasse Reichstein Nielsen, 2016/08/23 07:05:31]

I don't, as explained above.

+       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,
                                    LocalScope* scope) {
   if (exception_param->name != NULL) {
     LocalVariable* var = new(Z) LocalVariable(
         exception_param->token_pos,
@@ skipping 5406 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