Allows turning on checked mode on a per-isolate basis

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 "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 3107 matching lines @@
         ParamDesc& param = (*params.parameters)[i];
         if (param.is_field_initializer) {
           ReportError(param.name_pos,
                       "field initializer only allowed in constructors");
         }
       }
     }
     // Populate function scope with the formal parameters.
     AddFormalParamsToScope(&params, current_block_->scope);
 
-    if (FLAG_enable_type_checks &&
+    if (I->TypeChecksEnabled() &&
         (current_block_->scope->function_level() > 0)) {
       // We are parsing, but not compiling, a local function.
       // The instantiator may be required at run time for generic type checks.
       if (IsInstantiatorRequired()) {
         // Make sure that the receiver of the enclosing instance function
         // (or implicit first parameter of an enclosing factory) is marked as
         // captured if type checks are enabled, because they may access it to
         // instantiate types.
         CaptureInstantiator();
       }
@@ skipping 3415 matching lines @@
 
 // Returns ast nodes of the variable initialization. Variables without an
 // explicit initializer are initialized to null. If several variables are
 // declared, the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
   TRACE_PARSER("ParseVariableDeclarationList");
   SkipMetadata();
   bool is_final = (CurrentToken() == Token::kFINAL);
   bool is_const = (CurrentToken() == Token::kCONST);
   const AbstractType& type = AbstractType::ZoneHandle(Z,
-      ParseConstFinalVarOrType(FLAG_enable_type_checks ?
+      ParseConstFinalVarOrType(I->TypeChecksEnabled() ?
           ClassFinalizer::kCanonicalize : ClassFinalizer::kIgnore));
   if (!IsIdentifier()) {
     ReportError("identifier expected");
   }
 
   SequenceNode* preamble = NULL;
   AstNode* initializers =
       ParseVariableDeclaration(type, is_final, is_const, &preamble);
   ASSERT(initializers != NULL);
   if (preamble != NULL) {
@@ skipping 967 matching lines @@
     ReportError("Loop variable cannot be 'const'");
   }
   bool new_loop_var = false;
   AbstractType& loop_var_type =  AbstractType::ZoneHandle(Z);
   if (LookaheadToken(1) != Token::kIN) {
     // Declaration of a new loop variable.
     // Delay creation of the local variable until we know its actual
     // position, which is inside the loop body.
     new_loop_var = true;
     loop_var_type = ParseConstFinalVarOrType(
-       FLAG_enable_type_checks ? ClassFinalizer::kCanonicalize :
-                                 ClassFinalizer::kIgnore);
+       I->TypeChecksEnabled() ? ClassFinalizer::kCanonicalize :
+                                ClassFinalizer::kIgnore);
   }
   intptr_t loop_var_pos = TokenPos();
   const String* loop_var_name = ExpectIdentifier("variable name expected");
 
   // Parse stream expression.
   ExpectToken(Token::kIN);
   const intptr_t stream_pos = TokenPos();
   AstNode* stream_expr =
       ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
   ExpectToken(Token::kRPAREN);
@@ skipping 121 matching lines @@
   AbstractType& loop_var_type =  AbstractType::ZoneHandle(Z);
   if (LookaheadToken(1) == Token::kIN) {
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
   } else {
     // The case without a type is handled above, so require a type here.
     // Delay creation of the local variable until we know its actual
     // position, which is inside the loop body.
     new_loop_var = true;
     loop_var_type = ParseConstFinalVarOrType(
-        FLAG_enable_type_checks ? ClassFinalizer::kCanonicalize :
-                                  ClassFinalizer::kIgnore);
+        I->TypeChecksEnabled() ? ClassFinalizer::kCanonicalize :
+                                 ClassFinalizer::kIgnore);
     loop_var_name = ExpectIdentifier("variable name expected");
   }
   ExpectToken(Token::kIN);
   const intptr_t collection_pos = TokenPos();
   AstNode* collection_expr =
       ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
   ExpectToken(Token::kRPAREN);
 
   OpenBlock();  // Implicit block around while loop.
 
@@ skipping 197 matching lines @@
   }
   return condition;
 }
 
 
 AstNode* Parser::ParseAssertStatement() {
   TRACE_PARSER("ParseAssertStatement");
   ConsumeToken();  // Consume assert keyword.
   ExpectToken(Token::kLPAREN);
   const intptr_t condition_pos = TokenPos();
-  if (!FLAG_enable_asserts && !FLAG_enable_type_checks) {
+  if (!I->AssertsEnabled() && !I->TypeChecksEnabled()) {
     SkipExpr();
     ExpectToken(Token::kRPAREN);
     return NULL;
   }
   AstNode* condition = ParseExpr(kAllowConst, kConsumeCascades);
   const intptr_t condition_end = TokenPos();
   ExpectToken(Token::kRPAREN);
   condition = InsertClosureCallNodes(condition);
   condition = new(Z) UnaryOpNode(condition_pos, Token::kNOT, condition);
   AstNode* assert_throw = MakeAssertCall(condition_pos, condition_end);
@@ skipping 2889 matching lines @@
       ASSERT(!element_type.IsMalformed());  // Would be mapped to dynamic.
       ASSERT(!element_type.IsMalbounded());  // No declared bound in List.
       if (element_type.IsDynamicType()) {
         list_type_arguments = TypeArguments::null();
       } else if (is_const && !element_type.IsInstantiated()) {
         ReportError(type_pos,
                     "the type argument of a constant list literal cannot "
                     "include a type variable");
       }
     } else {
-      if (FLAG_error_on_bad_type) {
+      if (I->ErrorOnBadTypeEnabled()) {
         ReportError(type_pos,
                     "a list literal takes one type argument specifying "
                     "the element type");
       }
       // Ignore type arguments.
       list_type_arguments = TypeArguments::null();
     }
   }
   ASSERT(list_type_arguments.IsNull() || (list_type_arguments.Length() == 1));
   const Class& array_class = Class::Handle(Z, I->object_store()->array_class());
   Type& type = Type::ZoneHandle(Z,
       Type::New(array_class, list_type_arguments, type_pos));
   type ^= ClassFinalizer::FinalizeType(
       current_class(), type, ClassFinalizer::kCanonicalize);
   GrowableArray<AstNode*> element_list;
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     while (CurrentToken() != Token::kRBRACK) {
       const intptr_t element_pos = TokenPos();
       AstNode* element = ParseExpr(is_const, kConsumeCascades);
-      if (FLAG_enable_type_checks &&
+      if (I->TypeChecksEnabled() &&
           !is_const &&
           !element_type.IsDynamicType()) {
         element = new(Z) AssignableNode(element_pos,
                                         element,
                                         element_type,
                                         Symbols::ListLiteralElement());
       }
       element_list.Add(element);
       if (CurrentToken() == Token::kCOMMA) {
         ConsumeToken();
@@ skipping 10 matching lines @@
     Array& const_list =
         Array::ZoneHandle(Z, Array::New(element_list.length(), Heap::kOld));
     const_list.SetTypeArguments(
         TypeArguments::Handle(Z, list_type_arguments.Canonicalize()));
     Error& malformed_error = Error::Handle(Z);
     for (int i = 0; i < element_list.length(); i++) {
       AstNode* elem = element_list[i];
       // Arguments have been evaluated to a literal value already.
       ASSERT(elem->IsLiteralNode());
       ASSERT(!is_top_level_);  // We cannot check unresolved types.
-      if (FLAG_enable_type_checks &&
+      if (I->TypeChecksEnabled() &&
           !element_type.IsDynamicType() &&
           (!elem->AsLiteralNode()->literal().IsNull() &&
            !elem->AsLiteralNode()->literal().IsInstanceOf(
                element_type,
                TypeArguments::Handle(Z),
                &malformed_error))) {
         // If the failure is due to a malformed type error, display it instead.
         if (!malformed_error.IsNull()) {
           ReportError(malformed_error);
         } else {
@@ skipping 122 matching lines @@
       // No declared bounds in Map.
       ASSERT(!key_type.IsMalbounded() && !value_type.IsMalbounded());
       if (key_type.IsDynamicType() && value_type.IsDynamicType()) {
         map_type_arguments = TypeArguments::null();
       } else if (is_const && !type_arguments.IsInstantiated()) {
         ReportError(type_pos,
                     "the type arguments of a constant map literal cannot "
                     "include a type variable");
       }
     } else {
-      if (FLAG_error_on_bad_type) {
+      if (I->ErrorOnBadTypeEnabled()) {
         ReportError(type_pos,
                     "a map literal takes two type arguments specifying "
                     "the key type and the value type");
       }
       // Ignore type arguments.
       map_type_arguments = TypeArguments::null();
     }
   }
   ASSERT(map_type_arguments.IsNull() || (map_type_arguments.Length() == 2));
   map_type_arguments ^= map_type_arguments.Canonicalize();
 
   GrowableArray<AstNode*> kv_pairs_list;
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   while (CurrentToken() != Token::kRBRACE) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     const intptr_t key_pos = TokenPos();
     AstNode* key = ParseExpr(is_const, kConsumeCascades);
-    if (FLAG_enable_type_checks &&
+    if (I->TypeChecksEnabled() &&
         !is_const &&
         !key_type.IsDynamicType()) {
       key = new(Z) AssignableNode(
           key_pos, key, key_type, Symbols::ListLiteralElement());
     }
     if (is_const) {
       ASSERT(key->IsLiteralNode());
       const Instance& key_value = key->AsLiteralNode()->literal();
       if (key_value.IsDouble()) {
         ReportError(key_pos, "key value must not be of type double");
       }
       if (!key_value.IsInteger() &&
           !key_value.IsString() &&
           (key_value.clazz() != I->object_store()->symbol_class()) &&
           ImplementsEqualOperator(key_value)) {
         ReportError(key_pos, "key value must not implement operator ==");
       }
     }
     ExpectToken(Token::kCOLON);
     const intptr_t value_pos = TokenPos();
     AstNode* value = ParseExpr(is_const, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
-    if (FLAG_enable_type_checks &&
+    if (I->TypeChecksEnabled() &&
         !is_const &&
         !value_type.IsDynamicType()) {
       value = new(Z) AssignableNode(
           value_pos, value, value_type, Symbols::ListLiteralElement());
     }
     AddKeyValuePair(&kv_pairs_list, is_const, key, value);
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() != Token::kRBRACE) {
@@ skipping 11 matching lines @@
     // First, create the canonicalized key-value pair array.
     Array& key_value_array =
         Array::ZoneHandle(Z, Array::New(kv_pairs_list.length(), Heap::kOld));
     AbstractType& arg_type = Type::Handle(Z);
     Error& malformed_error = Error::Handle(Z);
     for (int i = 0; i < kv_pairs_list.length(); i++) {
       AstNode* arg = kv_pairs_list[i];
       // Arguments have been evaluated to a literal value already.
       ASSERT(arg->IsLiteralNode());
       ASSERT(!is_top_level_);  // We cannot check unresolved types.
-      if (FLAG_enable_type_checks) {
+      if (I->TypeChecksEnabled()) {
         if ((i % 2) == 0) {
           // Check key type.
           arg_type = key_type.raw();
         } else {
           // Check value type.
           arg_type = value_type.raw();
         }
         if (!arg_type.IsDynamicType() &&
             (!arg->AsLiteralNode()->literal().IsNull() &&
              !arg->AsLiteralNode()->literal().IsInstanceOf(
@@ skipping 304 matching lines @@
               "redirecting factory type '%s' cannot be instantiated",
               String::Handle(Z, redirect_type.UserVisibleName()).ToCString());
         }
       }
       if (redirect_type.IsMalformedOrMalbounded()) {
         if (is_const) {
           ReportError(Error::Handle(Z, redirect_type.error()));
         }
         return ThrowTypeError(redirect_type.token_pos(), redirect_type);
       }
-      if (FLAG_enable_type_checks && !redirect_type.IsSubtypeOf(type, NULL)) {
+      if (I->TypeChecksEnabled() && !redirect_type.IsSubtypeOf(type, NULL)) {
         // Additional type checking of the result is necessary.
         type_bound = type.raw();
       }
       type = redirect_type.raw();
       type_class = type.type_class();
       type_class_name = type_class.Name();
       type_arguments = type.arguments();
       constructor = constructor.RedirectionTarget();
       constructor_name = constructor.name();
       ASSERT(!constructor.IsNull());
@@ skipping 801 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart