Add check for duplicate field initialization

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/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 1591 matching lines @@
     ErrorMsg(supercall_pos,
              "invalid arguments passed to super class constructor '%s': %s",
              ctor_name.ToCString(),
              error_message.ToCString());
   }
   CheckFunctionIsCallable(supercall_pos, super_ctor);
   return new StaticCallNode(supercall_pos, super_ctor, arguments);
 }
 
 
-AstNode* Parser::ParseInitializer(const Class& cls, LocalVariable* receiver) {
+AstNode* Parser::ParseInitializer(const Class& cls,
+                                  LocalVariable* receiver,
+                                  GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializer");
   const intptr_t field_pos = TokenPos();
   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);
   AstNode* init_expr = ParseConditionalExpr();
   receiver->set_invisible(false);
   SetAllowFunctionLiterals(saved_mode);
   Field& field = Field::ZoneHandle(cls.LookupInstanceField(field_name));
   if (field.IsNull()) {
     ErrorMsg(field_pos, "unresolved reference to instance field '%s'",
              field_name.ToCString());
   }
+  CheckDuplicateFieldInit(field_pos, initialized_fields, &field);
   AstNode* instance = new LoadLocalNode(field_pos, *receiver);
   return new StoreInstanceFieldNode(field_pos, instance, field, init_expr);
 }
 
 
 void Parser::CheckConstFieldsInitialized(const Class& cls) {
   const Array& fields = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   SequenceNode* initializers = current_block_->statements;
   for (int field_num = 0; field_num < fields.Length(); field_num++) {
@@ skipping 21 matching lines @@
 }
 
 
 struct FieldInitExpression {
   Field* inst_field;
   AstNode* expr;
 };
 
 
 void Parser::ParseInitializedInstanceFields(const Class& cls,
-                 GrowableArray<FieldInitExpression>* initializers) {
+                 GrowableArray<FieldInitExpression>* initializers,
+                 GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializedInstanceFields");
   const Array& fields = Array::Handle(cls.fields());
   Field& f = Field::Handle();
   const intptr_t saved_pos = TokenPos();
   for (int i = 0; i < fields.Length(); i++) {
     f ^= fields.At(i);
     if (!f.is_static() && f.has_initializer()) {
       Field& field = Field::ZoneHandle();
       field ^= fields.At(i);
+      if (field.is_final()) {
+        // Final fields with initializer expression may not be initialized
+        // again by constructors. Remember that this field is already
+        // initialized.
+        initialized_fields->Add(&field);
+      }
       intptr_t field_pos = field.token_pos();
       SetPosition(field_pos);
       ASSERT(IsIdentifier());
       ConsumeToken();
       ExpectToken(Token::kASSIGN);
+      // TODO(hausner): Allow non-const expressions here for final fields.
       AstNode* init_expr = ParseConstExpr();
       ASSERT(init_expr != NULL);
       FieldInitExpression initializer;
       initializer.inst_field = &field;
       initializer.expr = init_expr;
       initializers->Add(initializer);
     }
   }
   SetPosition(saved_pos);
 }
 
 
-void Parser::ParseInitializers(const Class& cls, LocalVariable* receiver) {
+void Parser::CheckDuplicateFieldInit(intptr_t init_pos,
+                                    GrowableArray<Field*>* initialized_fields,
+                                    Field* field) {
+  ASSERT(!field->is_static());
+  for (int i = 0; i < initialized_fields->length(); i++) {
+    Field* initialized_field = (*initialized_fields)[i];
+    if (initialized_field->raw() == field->raw()) {
+      ErrorMsg(init_pos,
+               "duplicate initialization for field %s",
+               String::Handle(field->name()).ToCString());
+    }
+  }
+  initialized_fields->Add(field);
+}
+
+
+void Parser::ParseInitializers(const Class& cls,
+                               LocalVariable* receiver,
+                               GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializers");
   bool super_init_seen = false;
   if (CurrentToken() == Token::kCOLON) {
     if ((LookaheadToken(1) == Token::kTHIS) &&
         ((LookaheadToken(2) == Token::kLPAREN) ||
         ((LookaheadToken(2) == Token::kPERIOD) &&
             (LookaheadToken(4) == Token::kLPAREN)))) {
       // Either we see this(...) or this.xxx(...) which is a
       // redirected constructor. We don't need to check whether
       // const fields are initialized. The other constructor will
       // guarantee that.
       ConsumeToken();  // Colon.
       ParseConstructorRedirection(cls, receiver);
       return;
     }
     do {
       ConsumeToken();  // Colon or comma.
       AstNode* init_statement;
       if (CurrentToken() == Token::kSUPER) {
         if (super_init_seen) {
           ErrorMsg("duplicate call to super constructor");
         }
         init_statement = ParseSuperInitializer(cls, receiver);
         super_init_seen = true;
       } else {
-        init_statement = ParseInitializer(cls, receiver);
+        init_statement = ParseInitializer(cls, receiver, initialized_fields);
       }
       current_block_->statements->Add(init_statement);
     } while (CurrentToken() == Token::kCOMMA);
   }
   if (!super_init_seen) {
     // Generate implicit super() if we haven't seen an explicit super call
     // or constructor redirection.
     GenerateSuperConstructorCall(cls, receiver);
   }
   CheckConstFieldsInitialized(cls);
@@ skipping 54 matching lines @@
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsConstructor());
   const intptr_t ctor_pos = TokenPos();
 
   // Implicit 'this' is the only parameter/local variable.
   OpenFunctionBlock(func);
 
   // Parse expressions of instance fields that have an explicit
   // initializers.
   GrowableArray<FieldInitExpression> initializers;
+  GrowableArray<Field*> initialized_fields;
   Class& cls = Class::Handle(func.owner());
-  ParseInitializedInstanceFields(cls, &initializers);
+  ParseInitializedInstanceFields(cls, &initializers, &initialized_fields);
 
   LocalVariable* receiver = new LocalVariable(
       ctor_pos,
       String::ZoneHandle(Symbols::This()),
       Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(receiver);
 
   LocalVariable* phase_parameter = new LocalVariable(
        ctor_pos,
        String::ZoneHandle(Symbols::PhaseParameter()),
@@ skipping 70 matching lines @@
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
   ASSERT(func.NumberOfParameters() == params.parameters->length());
 
   // Initialize instance fields that have an explicit initializer expression.
   // This has to be done before code for field initializer parameters
   // is generated.
   // NB: the instance field initializers have to be compiled before
   // the parameters are added to the scope, so that a parameter
   // name cannot shadow a name used in the field initializer expression.
   GrowableArray<FieldInitExpression> initializers;
-  ParseInitializedInstanceFields(cls, &initializers);
+  GrowableArray<Field*> initialized_fields;
+  ParseInitializedInstanceFields(cls, &initializers, &initialized_fields);
 
   // Now populate function scope with the formal parameters.
   AddFormalParamsToScope(&params, current_block_->scope);
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
 
   // Now that the "this" parameter is in scope, we can generate the code
   // to store the initializer expressions in the respective instance fields.
   // We do this before the field parameters and the initializers from the
   // constructor's initializer list get compiled.
   OpenBlock();
@@ skipping 14 matching lines @@
     for (int i = 0; i < params.parameters->length(); i++) {
       ParamDesc& param = (*params.parameters)[i];
       if (param.is_field_initializer) {
         const String& field_name = *param.name;
         Field& field = Field::ZoneHandle(cls.LookupInstanceField(field_name));
         if (field.IsNull()) {
           ErrorMsg(param.name_pos,
                    "unresolved reference to instance field '%s'",
                    field_name.ToCString());
         }
+        CheckDuplicateFieldInit(param.name_pos, &initialized_fields, &field);
         AstNode* instance = new LoadLocalNode(param.name_pos, *receiver);
         LocalVariable* p =
             current_block_->scope->LookupVariable(*param.name, false);
         ASSERT(p != NULL);
         // Initializing formals cannot be used in the explicit initializer
         // list, nor can they be used in the constructor body.
         // Thus, make the parameter invisible.
         p->set_invisible(true);
         AstNode* value = new LoadLocalNode(param.name_pos, *p);
         AstNode* initializer = new StoreInstanceFieldNode(
             param.name_pos, instance, field, value);
         current_block_->statements->Add(initializer);
       }
     }
   }
 
   // Now parse the explicit initializer list or constructor redirection.
-  ParseInitializers(cls, receiver);
+  ParseInitializers(cls, receiver, &initialized_fields);
 
   SequenceNode* init_statements = CloseBlock();
   if (init_statements->length() > 0) {
     // Generate guard around the initializer code.
     LocalVariable* phase_param = LookupPhaseParameter();
     AstNode* phase_value = new LoadLocalNode(TokenPos(), *phase_param);
     AstNode* phase_check = new BinaryOpNode(
         TokenPos(), Token::kBIT_AND, phase_value,
         new LiteralNode(TokenPos(),
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
@@ skipping 6884 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart