Make hidden initializing formal parameters invisible to the debugger

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 "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 415 matching lines @@
 };
 
 
 struct ParamDesc {
   ParamDesc()
       : type(NULL),
         name_pos(0),
         name(NULL),
         default_value(NULL),
         metadata(NULL),
+        var(NULL),
         is_final(false),
         is_field_initializer(false) { }
   const AbstractType* type;
   intptr_t name_pos;
   const String* name;
   const Object* default_value;  // NULL if not an optional parameter.
   const Object* metadata;  // NULL if no metadata or metadata not evaluated.
+  LocalVariable* var;  // Scope variable allocated for this parameter.
   bool is_final;
   bool is_field_initializer;
 };
 
 
 struct ParamList {
   ParamList() {
     Clear();
   }
 
@@ skipping 18 matching lines @@
     param.is_final = true;
     param.type = type;
     this->parameters->Add(param);
   }
 
   void AddReceiver(const AbstractType* receiver_type, intptr_t token_pos) {
     ASSERT(this->parameters->is_empty());
     AddFinalParameter(token_pos, &Symbols::This(), receiver_type);
   }
 
+
+  // Make the parameter variables visible/invisible.
+  // Field initializer parameters are always invisible.
+  void SetInvisible(bool invisible) {
+    const intptr_t num_params = parameters->length();
+    for (int i = 0; i < num_params; i++) {
+      ParamDesc& param = (*parameters)[i];
+      ASSERT(param.var != NULL);
+      if (!param.is_field_initializer) {
+        param.var->set_invisible(invisible);
+      }
+    }
+  }
+
   void SetImplicitlyFinal() {
     implicitly_final = true;
   }
 
   int num_fixed_parameters;
   int num_optional_parameters;
   bool has_optional_positional_parameters;
   bool has_optional_named_parameters;
   bool has_field_initializer;
   bool implicitly_final;
@@ skipping 1985 matching lines @@
 
   GenerateSuperConstructorCall(current_class(), receiver, forwarding_args);
   CheckConstFieldsInitialized(current_class());
 
   // 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);
-  }
-}
-
-
 void Parser::CheckRecursiveInvocation() {
   const GrowableObjectArray& pending_functions =
       GrowableObjectArray::Handle(
           isolate()->object_store()->pending_functions());
   for (int i = 0; i < pending_functions.Length(); i++) {
     if (pending_functions.At(i) == current_function().raw()) {
       const String& fname =
           String::Handle(current_function().UserVisibleName());
       ErrorMsg("circular dependency for function %s", fname.ToCString());
     }
@@ skipping 55 matching lines @@
 
   // 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);
+  params.SetInvisible(true);
   GrowableArray<Field*> initialized_fields;
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   OpenBlock();
   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);
+  params.SetInvisible(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()) {
           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);
+        // 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);
         current_block_->statements->Add(initializer);
       }
     }
   }
 
   // Now parse the explicit initializer list or constructor redirection.
@@ skipping 2552 matching lines @@
     ParamDesc& param_desc = (*params->parameters)[i];
     ASSERT(!is_top_level_ || param_desc.type->IsResolved());
     const String* name = param_desc.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());
     }
+    param_desc.var = parameter;
     if (param_desc.is_final) {
       parameter->set_is_final();
     }
+    if (param_desc.is_field_initializer) {
+      parameter->set_invisible(true);
+    }
   }
 }
 
 
 // Builds ReturnNode/NativeBodyNode for a native function.
 void Parser::ParseNativeFunctionBlock(const ParamList* params,
                                       const Function& func) {
   func.set_is_native(true);
   TRACE_PARSER("ParseNativeFunctionBlock");
   const Class& cls = Class::Handle(func.Owner());
@@ skipping 5227 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart