Allow optional initializing formals again

runtime/vm/parser.cc

 // Copyright (c) 2011, 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 820 matching lines @@
     parameter.is_field_initializer = true;
   }
   // At this point, we must see an identifier for the parameter name.
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("parameter name expected");
   }
   parameter.name = CurrentLiteral();
   parameter.name_pos = token_index_;
   ConsumeToken();
   if (parameter.is_field_initializer) {
-    if (params->has_named_optional_parameters) {
-      ErrorMsg(parameter.name_pos,
-               "initializing formal parameter cannot be optional");
-    }
     params->has_field_initializer = true;
   }
 
   if (CurrentToken() == Token::kLPAREN) {
     // This parameter is probably a closure. If we saw the keyword 'var'
     // or 'final', a closure is not legal here and we ignore the
     // opening parens.
     if (!var_seen && !parameter.is_final) {
       // The parsed parameter type is actually the function result type.
       const Type& result_type = Type::Handle(parameter.type->raw());
@@ skipping 740 matching lines @@
     AstNode* instance = new LoadLocalNode(field->token_index(), *receiver);
     AstNode* field_init =
         new StoreInstanceFieldNode(field->token_index(),
                                    instance,
                                    *field,
                                    initializers[i].expr);
     current_block_->statements->Add(field_init);
   }
 
   // Turn formal field parameters into field initializers or report error
-  // if the function is not a constructor
+  // 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()) {
           ErrorMsg(param.name_pos,
                    "unresolved reference to instance field '%s'",
                    field_name.ToCString());
         }
-        const String& mangled_name =
-            String::ZoneHandle(MangledInitParamName(field_name));
         AstNode* instance = new LoadLocalNode(param.name_pos, *receiver);
         LocalVariable* p =
-            current_block_->scope->LookupVariable(mangled_name, false);
+            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);
@@ skipping 1752 matching lines @@
 // Populate local scope with the formal parameters.
 void Parser::AddFormalParamsToScope(const ParamList* params,
                                     LocalScope* scope) {
   ASSERT((params != NULL) && (params->parameters != NULL));
   ASSERT(scope != NULL);
   const int num_parameters = params->parameters->length();
   for (int i = 0; i < num_parameters; i++) {
     ParamDesc& param_desc = (*params->parameters)[i];
     ASSERT(!is_top_level_ || param_desc.type->IsResolved());
     const String* name = param_desc.name;
-    if (param_desc.is_field_initializer) {
-      name = &String::ZoneHandle(MangledInitParamName(*name));
-    }
     LocalVariable* parameter = new LocalVariable(
         param_desc.name_pos, *name, *param_desc.type);
     if (!scope->AddVariable(parameter)) {
       ErrorMsg(param_desc.name_pos,
                "name '%s' already exists in scope",
                param_desc.name->ToCString());
     }
     if (param_desc.is_final) {
       parameter->set_is_final();
     }
@@ skipping 4126 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart