Reintroducing parser changes to cause compile-time errors when trying to reinitialize a final field…

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 3004 matching lines @@
 
 
 AstNode* Parser::CheckDuplicateFieldInit(
     TokenPosition init_pos,
     GrowableArray<Field*>* initialized_fields,
     AstNode* instance,
     Field* field,
     AstNode* init_value) {
   ASSERT(!field->is_static());
   AstNode* result = NULL;
+  const String& field_name = String::Handle(field->name());
+  String& initialized_name = String::Handle(Z);
 
   // 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;
     }
+
+    initialized_name ^= initialized_field->name();
+    if (initialized_name.Equals(field_name) && field->has_initializer()) {
+      ReportError(init_pos, "final field '%s' is already initialized.",
+                  field_name.ToCString());
+    }
+
     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,
@@ skipping 2200 matching lines @@
   AddFormalParamsToFunction(&params, ctor);
   ctor.set_result_type(Object::dynamic_type());
   ResolveSignature(ctor);
   // The body of the constructor cannot modify the type of the constructed
   // instance, which is passed in as the receiver.
   ctor.set_result_type(*receiver_type);
   cls.AddFunction(ctor);
 }
 
 
+void Parser::CheckFinalInitializationConflicts(const ClassDesc* class_desc,
+                                               const MemberDesc* member) {
+  const ParamList* params = &member->params;
+  if (!params->has_field_initializer) {
+    return;
+  }
+
+  const ZoneGrowableArray<ParamDesc>& parameters = *params->parameters;
+  const GrowableArray<const Field*>& fields = class_desc->fields();
+  String& field_name = String::Handle(Z);
+
+  for (intptr_t p = 0; p < parameters.length(); p++) {
+    const ParamDesc& current_param = parameters[p];
+    if (!current_param.is_field_initializer) {
+      continue;
+    }
+
+    const String& param_name = *current_param.name;
+    for (intptr_t i = 0; i < fields.length(); i++) {
+      const Field* current_field = fields.At(i);
+      if (!current_field->is_final() || !current_field->has_initializer()) {
+        continue;
+      }
+
+      field_name ^= current_field->name();
+      if (param_name.Equals(field_name)) {
+        ReportError(current_param.name_pos,
+                    "final field '%s' is already initialized.",
+                    param_name.ToCString());
+      }
+    }
+  }
+}
+
+
 // Check for cycles in constructor redirection.
 void Parser::CheckConstructors(ClassDesc* class_desc) {
   // Check for cycles in constructor redirection.
   const GrowableArray<MemberDesc>& members = class_desc->members();
   for (int i = 0; i < members.length(); i++) {
     MemberDesc* member = &members[i];
+    if (member->IsConstructor()) {
+      // Check that our constructors don't try and reinitialize an initialized
+      // final variable.
+      CheckFinalInitializationConflicts(class_desc, member);
+    }
     if (member->redirect_name == NULL) {
       continue;
     }
     GrowableArray<MemberDesc*> ctors;
     while ((member != NULL) && (member->redirect_name != NULL)) {
       ASSERT(member->IsConstructor());
       // Check whether we have already seen this member.
       for (int i = 0; i < ctors.length(); i++) {
         if (ctors[i] == member) {
           ReportError(member->name_pos,
@@ skipping 10072 matching lines @@
                                                 TokenPosition* start,
                                                 TokenPosition* end) {
   UNREACHABLE();
   return false;
 }
 
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME