VM: Fix checked mode crash (issue 13831).

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 "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 763 matching lines @@
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceGetter(func);
       break;
     case RawFunction::kImplicitSetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceSetter(func);
       break;
     case RawFunction::kImplicitStaticFinalGetter:
       node_sequence = parser.ParseStaticFinalGetter(func);
       break;
+    case RawFunction::kStaticInitializer:
+      node_sequence = parser.ParseStaticInitializer(func);
+      break;
     case RawFunction::kMethodExtractor:
       node_sequence = parser.ParseMethodExtractor(func);
       break;
     case RawFunction::kNoSuchMethodDispatcher:
       node_sequence =
           parser.ParseNoSuchMethodDispatcher(func, default_parameter_values);
       break;
     case RawFunction::kInvokeFieldDispatcher:
       node_sequence =
           parser.ParseInvokeFieldDispatcher(func, default_parameter_values);
@@ skipping 106 matching lines @@
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   intptr_t ident_pos = TokenPos();
   const String& field_name = *ExpectIdentifier("field name expected");
   const Class& field_class = Class::Handle(func.Owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupStaticField(field_name));
 
-  if (!field.is_const() &&
-      (field.value() != Object::transition_sentinel().raw()) &&
-      (field.value() != Object::sentinel().raw())) {
-    // The field has already been initialized at compile time (this can
-    // happen, e.g., if we are recompiling for optimization).  There is no
-    // need to check for initialization and compile the potentially very
-    // large initialization code.  By skipping this code, the deoptimization
-    // ids will not line up with the original code, but this is safe because
-    // LoadStaticField does not deoptimize.
-    LoadStaticFieldNode* load_node = new LoadStaticFieldNode(ident_pos, field);
-    ReturnNode* return_node = new ReturnNode(ident_pos, load_node);
-    current_block_->statements->Add(return_node);
-    return CloseBlock();
-  }
-
-  // Static const fields must have an initializer.
+  // Static final fields must have an initializer.
   ExpectToken(Token::kASSIGN);
 
-  // We don't want to use ParseConstExpr() here because we don't want
-  // the constant folding code to create, compile and execute a code
-  // fragment to evaluate the expression. Instead, we just make sure
-  // the static const field initializer is a constant expression and
-  // leave the evaluation to the getter function.
   const intptr_t expr_pos = TokenPos();
-  AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
-
   if (field.is_const()) {
+    // We don't want to use ParseConstExpr() here because we don't want
+    // the constant folding code to create, compile and execute a code
+    // fragment to evaluate the expression. Instead, we just make sure
+    // the static const field initializer is a constant expression and
+    // leave the evaluation to the getter function.
+    AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
     // This getter will only be called once at compile time.
     if (expr->EvalConstExpr() == NULL) {
       ErrorMsg(expr_pos, "initializer is not a valid compile-time constant");
     }
     ReturnNode* return_node = new ReturnNode(ident_pos, expr);
     current_block_->statements->Add(return_node);
   } else {
     // This getter may be called each time the static field is accessed.
     // The following generated code lazily initializes the field:
     // if (field.value === transition_sentinel) {
@@ skipping 41 matching lines @@
     SequenceNode* initialize_field = new SequenceNode(ident_pos, NULL);
     initialize_field->Add(
         new StoreStaticFieldNode(
             ident_pos,
             field,
             new LiteralNode(ident_pos, Object::transition_sentinel())));
     // TODO(hausner): If evaluation of the field value throws an exception,
     // we leave the field value as 'transition_sentinel', which is wrong.
     // A second reference to the field later throws a circular dependency
     // exception. The field should instead be set to null after an exception.
-    initialize_field->Add(new StoreStaticFieldNode(ident_pos, field, expr));
+    const String& init_name =
+        String::Handle(Symbols::New(String::Handle(
+        String::Concat(Symbols::InitPrefix(), String::Handle(field.name())))));
+    const Function& init_function = Function::ZoneHandle(
+        field_class.LookupStaticFunction(init_name));
+    ASSERT(!init_function.IsNull());
+    ArgumentListNode* arguments = new ArgumentListNode(expr_pos);
+    StaticCallNode* init_call =
+        new StaticCallNode(expr_pos, init_function, arguments);
+
+    initialize_field->Add(new StoreStaticFieldNode(ident_pos,
+                                                   field,
+                                                   init_call));
     AstNode* uninitialized_check =
         new IfNode(ident_pos, compare_uninitialized, initialize_field, NULL);
     current_block_->statements->Add(uninitialized_check);
 
     // Generate code returning the field value.
     ReturnNode* return_node =
         new ReturnNode(ident_pos,
                        new LoadStaticFieldNode(ident_pos, field));
     current_block_->statements->Add(return_node);
   }
   return CloseBlock();
 }
 
 
+SequenceNode* Parser::ParseStaticInitializer(const Function& func) {
+  TRACE_PARSER("ParseStaticInitializer");
+  ParamList params;
+  ASSERT(func.num_fixed_parameters() == 0);  // static.
+  ASSERT(!func.HasOptionalParameters());
+  ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+
+  // Build local scope for function and populate with the formal parameters.
+  OpenFunctionBlock(func);
+  AddFormalParamsToScope(&params, current_block_->scope);
+
+  intptr_t expr_pos = func.token_pos();
+  AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
+  ReturnNode* return_node = new ReturnNode(expr_pos, expr);
+  current_block_->statements->Add(return_node);
+  return CloseBlock();
+}
+
+
 // Create AstNodes for an implicit instance getter method:
 //   LoadLocalNode 0 ('this');
 //   LoadInstanceFieldNode (field_name);
 //   ReturnNode (field's value);
 SequenceNode* Parser::ParseInstanceGetter(const Function& func) {
   TRACE_PARSER("ParseInstanceGetter");
   ParamList params;
   // func.token_pos() points to the name of the field.
   intptr_t ident_pos = func.token_pos();
   ASSERT(current_class().raw() == func.Owner());
@@ skipping 2223 matching lines @@
   if (field->has_factory) {
     ErrorMsg("keyword 'factory' not allowed in field declaration");
   }
   if (!field->has_static && field->has_const) {
     ErrorMsg(field->name_pos, "instance field may not be 'const'");
   }
   Function& getter = Function::Handle();
   Function& setter = Function::Handle();
   Field& class_field = Field::ZoneHandle();
   Instance& init_value = Instance::Handle();
+  intptr_t expr_pos = -1;
   while (true) {
     bool has_initializer = CurrentToken() == Token::kASSIGN;
     bool has_simple_literal = false;
     if (has_initializer) {
       ConsumeToken();
       init_value = Object::sentinel().raw();
       // For static const fields and static final non-const fields, the
       // initialization expression will be parsed through the
       // kImplicitStaticFinalGetter method invocation/compilation.
       // For instance fields, the expression is parsed when a constructor
       // is compiled.
       // For static const fields and static final non-const fields with very
       // simple initializer expressions (e.g. a literal number or string), we
       // optimize away the kImplicitStaticFinalGetter and initialize the field
       // here. However, the class finalizer will check the value type for
       // assignability once the declared field type can be resolved. If the
       // value is not assignable (assuming checked mode and disregarding actual
       // mode), the field value is reset and a kImplicitStaticFinalGetter is
       // created at finalization time.
 
       if (field->has_static && (field->has_const || field->has_final) &&
           (LookaheadToken(1) == Token::kSEMICOLON)) {
         has_simple_literal = IsSimpleLiteral(*field->type, &init_value);
       }
+      expr_pos = TokenPos();
       SkipExpr();
     } else {
       // Static const and static final fields must have an initializer.
       // Static const fields are implicitly final.
       if (field->has_static && field->has_final) {
         ErrorMsg(field->name_pos,
                  "static %s field '%s' must have an initializer expression",
                  field->has_const ? "const" : "final",
                  field->name->ToCString());
       }
@@ skipping 23 matching lines @@
         getter = Function::New(getter_name,
                                RawFunction::kImplicitStaticFinalGetter,
                                field->has_static,
                                field->has_const,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                current_class(),
                                field->name_pos);
         getter.set_result_type(*field->type);
         members->AddFunction(getter);
+
+        // Create initializer function.
+        const Function& init_function = Function::ZoneHandle(
+            Function::NewStaticInitializer(*field->name,
+                                           *field->type,
+                                           current_class(),
+                                           expr_pos));
+        members->AddFunction(init_function);
       }
     }
 
     // For instance fields, we create implicit getter and setter methods.
     if (!field->has_static) {
       String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
       getter = Function::New(getter_name, RawFunction::kImplicitGetter,
                              field->has_static,
                              field->has_final,
                              /* is_abstract = */ false,
@@ skipping 1089 matching lines @@
     if (metadata_pos >= 0) {
       library_.AddFieldMetadata(field, metadata_pos);
     }
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       Instance& field_value = Instance::Handle(Object::sentinel().raw());
       bool has_simple_literal = false;
       if ((is_const || is_final) && (LookaheadToken(1) == Token::kSEMICOLON)) {
         has_simple_literal = IsSimpleLiteral(type, &field_value);
       }
+      const intptr_t expr_pos = TokenPos();
       SkipExpr();
       field.set_value(field_value);
       if (!has_simple_literal) {
         // Create a static final getter.
         String& getter_name = String::Handle(Field::GetterSymbol(var_name));
         getter = Function::New(getter_name,
                                RawFunction::kImplicitStaticFinalGetter,
                                is_static,
                                is_const,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                current_class(),
                                name_pos);
         getter.set_result_type(type);
         top_level->functions.Add(getter);
+
+        // Create initializer function.
+        const Function& init_function = Function::ZoneHandle(
+            Function::NewStaticInitializer(var_name,
+                                           type,
+                                           current_class(),
+                                           expr_pos));
+        top_level->functions.Add(init_function);
       }
     } else if (is_final) {
       ErrorMsg(name_pos, "missing initializer for final or const variable");
     }
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
       break;
@@ skipping 6137 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart