Initializing a final instance is a runtime error

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 2175 matching lines @@
   SetAllowFunctionLiterals(saved_mode);
   if (current_function().is_const() && !init_expr->IsPotentiallyConst()) {
     ReportError(field_pos,
                 "initializer expression must be compile time constant.");
   }
   Field& field = Field::ZoneHandle(I, cls.LookupInstanceField(field_name));
   if (field.IsNull()) {
     ReportError(field_pos, "unresolved reference to instance field '%s'",
                 field_name.ToCString());
   }
-  CheckDuplicateFieldInit(field_pos, initialized_fields, &field);
-  AstNode* instance = new LoadLocalNode(field_pos, receiver);
   EnsureExpressionTemp();
-  return new StoreInstanceFieldNode(field_pos, instance, field, init_expr);
+  AstNode* instance = new(I) LoadLocalNode(field_pos, receiver);
+  AstNode* initializer = CheckDuplicateFieldInit(field_pos,
+      initialized_fields, instance, &field, init_expr);
+  if (initializer == NULL) {
+    initializer =
+        new(I) StoreInstanceFieldNode(field_pos, instance, field, init_expr);
+  }
+  return initializer;
 }
 
 
 void Parser::CheckFieldsInitialized(const Class& cls) {
   const Array& fields = Array::Handle(I, cls.fields());
   Field& field = Field::Handle(I);
   SequenceNode* initializers = current_block_->statements;
   for (int field_num = 0; field_num < fields.Length(); field_num++) {
     field ^= fields.At(field_num);
     if (field.is_static()) {
@@ skipping 100 matching lines @@
       AstNode* instance = new LoadLocalNode(field.token_pos(), receiver);
       EnsureExpressionTemp();
       AstNode* field_init =
           new StoreInstanceFieldNode(field.token_pos(),
                                      instance,
                                      field,
                                      init_expr);
       current_block_->statements->Add(field_init);
     }
   }
+  initialized_fields->Add(NULL);  // End of inline initializers.
   SetPosition(saved_pos);
 }
 
 
-void Parser::CheckDuplicateFieldInit(intptr_t init_pos,
-                                    GrowableArray<Field*>* initialized_fields,
-                                    Field* field) {
+AstNode* Parser::CheckDuplicateFieldInit(
+    intptr_t init_pos,
+    GrowableArray<Field*>* initialized_fields,
+    AstNode* instance,
+    Field* field,
+    AstNode* init_value) {
   ASSERT(!field->is_static());
-  for (int i = 0; i < initialized_fields->length(); i++) {
-    Field* initialized_field = (*initialized_fields)[i];
+  AstNode* result = NULL;
+
+  // The initializer_list is divided into two sections. The sections
+  // are separated by a NULL entry: [f0, ... fn, NULL, fn+1, ...]
+  // The first fields f0 .. fn are final fields of the class that
+  // have an initializer expression inlined in the class declaration.
+  // The remaining fields are those initialized by the constructor's
+  // initializing formals and initializer list
+  int initializer_idx = 0;
+  while (initializer_idx < initialized_fields->length()) {
+    Field* initialized_field = (*initialized_fields)[initializer_idx];
+    initializer_idx++;
+    if (initialized_field == NULL) {
+      break;
+    }
+    if (initialized_field->raw() == field->raw()) {
+      // This final field has been initialized by an inlined
+      // initializer expression. This is a runtime error.
+      // Throw a NoSuchMethodError for the missing setter.
+      ASSERT(field->is_final());
+
+      // Build a call to NoSuchMethodError::_throwNew(
+      //     Object receiver,
+      //     String memberName,
+      //     int invocation_type,
+      //     List arguments,
+      //     List argumentNames,
+      //     List existingArgumentNames);
+
+      ArgumentListNode* nsm_args = new(I) ArgumentListNode(init_pos);
+      // Object receiver.
+      nsm_args->Add(instance);
+
+      // String memberName.
+      String& setter_name = String::ZoneHandle(field->name());
+      setter_name = Field::SetterSymbol(setter_name);
+      nsm_args->Add(new(I) LiteralNode(init_pos, setter_name));
+
+      // Smi invocation_type.
+      const int invocation_type =
+          InvocationMirror::EncodeType(InvocationMirror::kDynamic,
+                                       InvocationMirror::kSetter);
+      nsm_args->Add(new(I) LiteralNode(
+          init_pos, Smi::ZoneHandle(I, Smi::New(invocation_type))));
+
+      // List arguments.
+      GrowableArray<AstNode*> setter_args;
+      setter_args.Add(init_value);
+      ArrayNode* setter_args_array = new(I) ArrayNode(
+          init_pos,
+          Type::ZoneHandle(I, Type::ArrayType()),
+          setter_args);
+      nsm_args->Add(setter_args_array);
+
+      // List argumentNames.
+      // The missing implicit setter of the field has no argument names.
+      nsm_args->Add(new(I) LiteralNode(init_pos, Array::ZoneHandle(I)));
+
+      // List existingArgumentNames.
+      // There is no setter for the final field, thus there are
+      // no existing names.
+      nsm_args->Add(new(I) LiteralNode(init_pos, Array::ZoneHandle(I)));
+
+      AstNode* nsm_call =
+          MakeStaticCall(Symbols::NoSuchMethodError(),
+          Library::PrivateCoreLibName(Symbols::ThrowNew()),
+          nsm_args);
+
+      LetNode* let = new(I) LetNode(init_pos);
+      let->AddNode(init_value);
+      let->AddNode(nsm_call);
+      result = let;
+    }
+  }
+  // The remaining elements in initialized_fields are fields that
+  // are initialized through initializing formal parameters, or
+  // in the constructor's initializer list. If there is a duplicate,
+  // it is a compile time error.
+  while (initializer_idx < initialized_fields->length()) {
+    Field* initialized_field = (*initialized_fields)[initializer_idx];
+    initializer_idx++;
     if (initialized_field->raw() == field->raw()) {
       ReportError(init_pos,
-                  "duplicate initialization for field %s",
+                  "duplicate initializer for field %s",
                   String::Handle(I, field->name()).ToCString());
     }
   }
   initialized_fields->Add(field);
+  return result;
 }
 
 
 void Parser::ParseInitializers(const Class& cls,
                                LocalVariable* receiver,
                                GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializers");
   bool super_init_seen = false;
   if (CurrentToken() == Token::kCOLON) {
     do {
@@ skipping 256 matching lines @@
         if (field.IsNull()) {
           ReportError(param.name_pos,
                       "unresolved reference to instance field '%s'",
                       field_name.ToCString());
         }
         if (is_redirecting_constructor) {
           ReportError(param.name_pos,
                       "redirecting constructors may not have "
                       "initializing formal parameters");
         }
-        CheckDuplicateFieldInit(param.name_pos, &initialized_fields, &field);
 
         if (!param.has_explicit_type) {
           const AbstractType& field_type =
               AbstractType::ZoneHandle(I, field.type());
           param.type = &field_type;
           // Parameter type was already set to dynamic when parsing the class
           // declaration: fix it.
           func.SetParameterTypeAt(i, field_type);
         }
 
         AstNode* instance = new LoadLocalNode(param.name_pos, receiver);
         // Initializing formals cannot be used in the explicit initializer
         // list, nor can they be used in the constructor body.
         // Thus, they are set to be invisible when added to the scope.
         LocalVariable* p = param.var;
         ASSERT(p != NULL);
         ASSERT(p->is_invisible());
         AstNode* value = new LoadLocalNode(param.name_pos, p);
         EnsureExpressionTemp();
-        AstNode* initializer = new StoreInstanceFieldNode(
-            param.name_pos, instance, field, value);
+        AstNode* initializer =
+            CheckDuplicateFieldInit(param.name_pos,
+                                    &initialized_fields,
+                                    instance,
+                                    &field,
+                                    value);
+        if (initializer == NULL) {
+          initializer = new(I) StoreInstanceFieldNode(
+              param.name_pos, instance, field, value);
+        }
         current_block_->statements->Add(initializer);
       }
     }
   }
 
   if (is_redirecting_constructor) {
     ParseConstructorRedirection(cls, receiver);
   } else {
     ParseInitializers(cls, receiver, &initialized_fields);
   }
@@ skipping 8742 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart