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 37 matching lines @@
 // committed to the current version.
 DEFINE_FLAG(bool, conditional_directives, true,
     "Enable conditional directives");
 DEFINE_FLAG(bool, initializing_formal_access, false,
     "Make initializing formal parameters visible in initializer list.");
 DEFINE_FLAG(bool, warn_super, false,
     "Warning if super initializer not last in initializer list.");
 DEFINE_FLAG(bool, warn_patch, false, "Warn on old-style patch syntax.");
 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 2593 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) {
+    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 681 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)) {
+      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 5609 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);
 
   ArgumentListNode* arguments = new(Z) ArgumentListNode(condition_pos);
   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(is_const ? Symbols::CheckConstAssertion()
+                                           : Symbols::CheckAssertion()),
+      arguments);
+
+  return assert_throw;
 }
 
 
 // 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 5417 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