Allow non-const field initializers

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 1599 matching lines @@
       }
     }
     if (!found) {
       ErrorMsg("final field '%s' not initialized",
                String::Handle(field.name()).ToCString());
     }
   }
 }
 
 
-struct FieldInitExpression {
-  Field* inst_field;
-  AstNode* expr;
-};
-
-
 void Parser::ParseInitializedInstanceFields(const Class& cls,
-                 GrowableArray<FieldInitExpression>* initializers,
+                 LocalVariable* receiver,
                  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();
+
+      AstNode* init_expr = NULL;
+      if (field.is_const()) {
+        init_expr = ParseConstExpr();
+      } else {
+        init_expr = ParseExpr(kAllowConst, kConsumeCascades);
+        if (init_expr->EvalConstExpr() != NULL) {
+          init_expr = new LiteralNode(field_pos, EvaluateConstExpr(init_expr));
+        }
+      }
       ASSERT(init_expr != NULL);
-      FieldInitExpression initializer;
-      initializer.inst_field = &field;
-      initializer.expr = init_expr;
-      initializers->Add(initializer);
+      AstNode* instance = new LoadLocalNode(field.token_pos(), receiver);
+      AstNode* field_init =
+          new StoreInstanceFieldNode(field.token_pos(),
+                                     instance,
+                                     field,
+                                     init_expr);
+      current_block_->statements->Add(field_init);
     }
   }
   SetPosition(saved_pos);
 }
 
 
 void Parser::CheckDuplicateFieldInit(intptr_t init_pos,
                                     GrowableArray<Field*>* initialized_fields,
                                     Field* field) {
   ASSERT(!field->is_static());
@@ skipping 98 matching lines @@
   }
   CheckFunctionIsCallable(call_pos, redirect_ctor);
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
 
 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, &initialized_fields);
-
+  const Class& cls = Class::Handle(func.owner());
   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()),
        Type::ZoneHandle(Type::IntInterface()));
   current_block_->scope->AddVariable(phase_parameter);
 
-  // Now that the "this" parameter is in scope, we can generate the code
-  // to strore the initializer expressions in the respective instance fields.
-  for (int i = 0; i < initializers.length(); i++) {
-    const Field* field = initializers[i].inst_field;
-    AstNode* instance = new LoadLocalNode(field->token_pos(), receiver);
-    AstNode* field_init =
-        new StoreInstanceFieldNode(field->token_pos(),
-                                   instance,
-                                   *field,
-                                   initializers[i].expr);
-    current_block_->statements->Add(field_init);
-  }
+  // Parse expressions of instance fields that have an explicit
+  // initializer expression.
+  // The receiver must not be visible to field initializer expressions.
+  receiver->set_invisible(true);
+  GrowableArray<Field*> initialized_fields;
+  ParseInitializedInstanceFields(cls, receiver, &initialized_fields);
+  receiver->set_invisible(false);
 
   GenerateSuperConstructorCall(cls, receiver);
   CheckConstFieldsInitialized(cls);
 
   // Empty constructor body.
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
+// Helper function to make the first num_variables variables in the
+// given scope visible/invisible.
+static void SetInvisible(LocalScope* scope, int num_variables, bool invisible) {
+  ASSERT(num_variables <= scope->num_variables());
+  for (int i = 0; i < num_variables; i++) {
+    scope->VariableAt(i)->set_invisible(invisible);
+  }
+}
+
+
 // Parser is at the opening parenthesis of the formal parameter declaration
 // of function. Parse the formal parameters, initializers and code.
 SequenceNode* Parser::ParseConstructor(const Function& func,
                                        Array& default_parameter_values) {
   TRACE_PARSER("ParseConstructor");
   ASSERT(func.IsConstructor());
   ASSERT(!func.IsFactory());
   ASSERT(!func.is_static());
   ASSERT(!func.IsLocalFunction());
   const Class& cls = Class::Handle(func.owner());
@@ skipping 29 matching lines @@
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
   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;
-  GrowableArray<Field*> initialized_fields;
-  ParseInitializedInstanceFields(cls, &initializers, &initialized_fields);
-
   // Now populate function scope with the formal parameters.
   AddFormalParamsToScope(&params, current_block_->scope);
+
+  // Initialize instance fields that have an explicit initializer expression.
+  // The formal parameter names must not be visible to the instance
+  // field initializer expressions, yet the parameters must be added to
+  // the scope so the expressions use the correct offsets for 'this' when
+  // storing values. We make the formal parameters temporarily invisible
+  // while parsing the instance field initializer expressions.
+  SetInvisible(current_block_->scope, params.parameters->length(), true);
+  GrowableArray<Field*> initialized_fields;
   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();
-  for (int i = 0; i < initializers.length(); i++) {
-    const Field* field = initializers[i].inst_field;
-    AstNode* instance = new LoadLocalNode(field->token_pos(), receiver);
-    AstNode* field_init =
-        new StoreInstanceFieldNode(field->token_pos(),
-                                   instance,
-                                   *field,
-                                   initializers[i].expr);
-    current_block_->statements->Add(field_init);
-  }
+  ParseInitializedInstanceFields(cls, receiver, &initialized_fields);
+  // Make the parameters (which are in the outer scope) visible again.
+  SetInvisible(current_block_->scope->parent(),
+               params.parameters->length(), false);
 
   // Turn formal field parameters into field initializers or report error
   // if the function is not a constructor.
   if (params.has_field_initializer) {
     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()) {
@@ skipping 7147 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart