Address Regis' review feedback

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 1213 matching lines @@
   if (super_class.IsNull() || (super_class.num_native_fields() > 0)) {
     return;
   }
   String& ctor_name = String::Handle(super_class.Name());
   String& ctor_suffix = String::Handle(String::NewSymbol("."));
   ctor_name = String::Concat(ctor_name, ctor_suffix);
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // Implicit 'this' parameter is the first argument.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, *receiver);
   arguments->Add(implicit_argument);
-  // Implicit constructor phase parameter is second argument.
+  // Implicit construction phase parameter is second argument.
   AstNode* phase_parameter =
       new LiteralNode(supercall_pos,
                       Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   arguments->Add(phase_parameter);
   const Function& super_ctor = Function::ZoneHandle(
       super_class.LookupConstructor(ctor_name));
   if (super_ctor.IsNull() ||
       !super_ctor.AreValidArguments(arguments->length(),
                                     arguments->names())) {
     ErrorMsg(supercall_pos,
@@ skipping 23 matching lines @@
   }
   ctor_name = String::Concat(ctor_name, ctor_suffix);
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("parameter list expected");
   }
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // 'this' parameter is the first argument to super class constructor.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, *receiver);
   arguments->Add(implicit_argument);
-  // Second implicit parameter is the constructor phase. We optimistically
+  // Second implicit parameter is the construction phase. We optimistically
   // assume that we can execute both the super initializer and the super
   // constructor body. We may later change this to only execute the
   // super initializer.
   AstNode* phase_parameter =
       new LiteralNode(supercall_pos,
                       Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   arguments->Add(phase_parameter);
   // 'this' parameter must not be accessible to the other super call arguments.
   receiver->set_invisible(true);
   ParseActualParameters(arguments, kAllowConst);
@@ skipping 157 matching lines @@
   }
   ctor_name = String::Concat(ctor_name, ctor_suffix);
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("parameter list expected");
   }
 
   ArgumentListNode* arguments = new ArgumentListNode(call_pos);
   // 'this' parameter is the first argument to constructor.
   AstNode* implicit_argument = new LoadLocalNode(call_pos, *receiver);
   arguments->Add(implicit_argument);
-  // Constructor phase parameter is second argument.
+  // Construction phase parameter is second argument.
   LocalVariable* phase_param = LookupPhaseParameter();
   ASSERT(phase_param != NULL);
   AstNode* phase_argument = new LoadLocalNode(call_pos, *phase_param);
   arguments->Add(phase_argument);
   ParseActualParameters(arguments, kAllowConst);
 
   // Resolve the constructor.
   const Function& redirect_ctor = Function::ZoneHandle(
       cls.LookupConstructor(ctor_name));
   if (redirect_ctor.IsNull() ||
@@ skipping 60 matching lines @@
 SequenceNode* Parser::ParseConstructor(const Function& func,
                                        Array& default_parameter_values) {
   ASSERT(func.IsConstructor());
   ASSERT(!func.IsFactory());
   ASSERT(!func.is_static());
   ASSERT(!func.IsLocalFunction());
   const Class& cls = Class::Handle(func.owner());
   ASSERT(!cls.IsNull());
 
   if (IsLiteral("class")) {
-    // Special case: implicit constructor. There is no source text to
-    // parse. We just build the sequence node by hand.
+    // Special case: implicit constructor.
+    // The parser adds an implicit default constructor when a class
+    // does not have any explicit constructor or factory (see
+    // Parser::CheckConstructors). The token position of this implicit
+    // constructor points to the 'class' keyword, which is followed
+    // by the name of the class (which is also the constructor name).
+    // There is no source text to parse. We just build the
+    // sequence node by hand.
     return MakeImplicitConstructor(func);
   }
 
   OpenFunctionBlock(func);
   ParamList params;
   const bool allow_explicit_default_values = true;
   ASSERT(CurrentToken() == Token::kLPAREN);
 
   // Add implicit receiver parameter which is passed the allocated
   // but uninitialized instance to construct.
   params.AddReceiver(token_index_);
 
-  // Add implicit parameter for constructor phase.
+  // Add implicit parameter for construction phase.
   params.AddFinalParameter(token_index_, kPhaseParameterName,
                            &Type::ZoneHandle(Type::DynamicType()));
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
   ASSERT(Type::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
-  // are is generated.
+  // 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);
 
   // 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 strore the initializer expressions in the respective instance fields.
+  // 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_index(), *receiver);
     AstNode* field_init =
         new StoreInstanceFieldNode(field->token_index(),
                                    instance,
                                    *field,
@@ skipping 44 matching lines @@
         new ComparisonNode(token_index_, Token::kNE_STRICT,
                            phase_check,
                            new LiteralNode(token_index_,
                                            Smi::ZoneHandle(Smi::New(0))));
     AstNode* guarded_init_statements =
         new IfNode(token_index_, comparison, init_statements, NULL);
     current_block_->statements->Add(guarded_init_statements);
   }
 
   // Parsing of initializers done. Now we parse the constructor body
-  // and add the implicit super call to the super construcotr's body
+  // and add the implicit super call to the super constructor's body
   // if necessary.
   StaticCallNode* super_call = NULL;
   // Look for the super initializer call in the sequence of initializer
   // statements. If it exists and is not the last initializer statement,
   // we need to create an implicit super call to the super constructor's
   // body.
   // Thus, iterate over all but the last initializer to see whether
   // it's a super constructor call.
   for (int i = 0; i < init_statements->length() - 1; i++) {
     if (init_statements->NodeAt(i)->IsStaticCallNode()) {
       StaticCallNode* static_call =
       init_statements->NodeAt(i)->AsStaticCallNode();
       if (static_call->function().IsConstructor()) {
         super_call = static_call;
         break;
       }
     }
   }
   if (super_call != NULL) {
     // Generate an implicit call to the super constructor's body.
     // We need to patch the super _initializer_ call so that it
     // saves the evaluated actual arguments in temporary variables.
     // The temporary variables are necessary so that the argument
     // expressions are not evaluated twice.
     ArgumentListNode* ctor_args = super_call->arguments();
     // The super initializer call has at least 2 arguments: the
-    // implicit receiver, and the hidden constructor phase.
+    // implicit receiver, and the hidden construction phase.
     ASSERT(ctor_args->length() >= 2);
     for (int i = 2; i < ctor_args->length(); i++) {
       AstNode* arg = ctor_args->NodeAt(i);
       if (!arg->IsLoadLocalNode() && !arg->IsLiteralNode()) {
         LocalVariable* temp =
         CreateTempConstVariable(arg->token_index(), arg->id(), "sca");
         AstNode* save_temp =
         new StoreLocalNode(arg->token_index(), *temp, arg);
         ctor_args->SetNodeAt(i, save_temp);
       }
     }
   }
   OpenBlock();  // Block to collect constructor body nodes.
 
   // Insert the implicit super call to the super constructor body.
   if (super_call != NULL) {
     ArgumentListNode* initializer_args = super_call->arguments();
     const Function& super_ctor = super_call->function();
-    // Patch the initializer call so it only executes the super
-    // initializer.
+    // Patch the initializer call so it only executes the super initializer.
     initializer_args->SetNodeAt(1,
         new LiteralNode(token_index_,
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
 
     ArgumentListNode* super_call_args = new ArgumentListNode(token_index_);
     // First argument is the receiver.
     super_call_args->Add(new LoadLocalNode(token_index_, *receiver));
-    // Second argument is the constructor phase argument.
+    // Second argument is the construction phase argument.
     AstNode* phase_parameter =
     new LiteralNode(token_index_,
                     Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody)));
     super_call_args->Add(phase_parameter);
     super_call_args->set_names(initializer_args->names());
     for (int i = 2; i < initializer_args->length(); i++) {
       AstNode* arg = initializer_args->NodeAt(i);
       if (arg->IsLiteralNode()) {
         LiteralNode* lit = arg->AsLiteralNode();
         super_call_args->Add(new LiteralNode(token_index_, lit->literal()));
@@ skipping 274 matching lines @@
   const bool has_this_param =
       !method->has_static || method->IsConstructor() || method->has_factory;
   const bool are_implicitly_final = method->has_const;
   const bool allow_explicit_default_values =
       (!method->has_abstract && !members->is_interface());
   const intptr_t formal_param_pos = token_index_;
   method->params.Clear();
   if (has_this_param) {
     method->params.AddReceiver(formal_param_pos);
   }
-  // Constructors have an implicit parameter for the constructor phase.
+  // Constructors have an implicit parameter for the construction phase.
   if (method->IsConstructor()) {
     method->params.AddFinalParameter(token_index_, kPhaseParameterName,
                                      &Type::ZoneHandle(Type::DynamicType()));
   }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
   ParseFormalParameterList(allow_explicit_default_values, &method->params);
   if (method->IsGetter() || method->IsSetter()) {
     int expected_num_parameters = 0;
@@ skipping 501 matching lines @@
 // 2. Check for cycles in constructor redirection.
 void Parser::CheckConstructors(ClassDesc* class_desc) {
   // Add an implicit constructor if no explicit constructor is present.
   if (!class_desc->has_constructor()) {
     // The implicit constructor is unnamed, has no explicit parameter,
     // and contains a supercall in the initializer list.
     String& ctor_name = String::ZoneHandle(
         String::Concat(class_desc->class_name(),
                        String::Handle(String::NewSymbol("."))));
     ctor_name = String::NewSymbol(ctor_name);
+    // The token position for the implicit constructor is the 'class'
+    // keyword of the constructor's class.
     Function& ctor = Function::ZoneHandle(
         Function::New(ctor_name,
                       RawFunction::kConstructor,
                       /* is_static = */ false,
                       /* is_const = */ false,
                       class_desc->token_pos()));
     ParamList params;
     // Add implicit 'this' parameter.
     params.AddReceiver(token_index_);
-    // Add implicit parameter for constructor phase.
+    // Add implicit parameter for construction phase.
     params.AddFinalParameter(token_index_, kPhaseParameterName,
                              &Type::ZoneHandle(Type::DynamicType()));
 
     AddFormalParamsToFunction(&params, ctor);
     // TODO(regis): What are the type arguments?
     Type& result_type = Type::ZoneHandle(
         Type::NewRawType(Class::Handle(class_desc->clazz())));
     ctor.set_result_type(result_type);
     class_desc->AddFunction(&ctor);
   }
@@ skipping 3485 matching lines @@
     field.set_value(const_value);
   }
 }
 
 
 RawInstance* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
-  // +2 for implicit receiver and constructor phase arguments.
+  // +2 for implicit receiver and construction phase arguments.
   GrowableArray<const Object*> arg_values(arguments->length() + 2);
   Instance& instance = Instance::Handle();
   if (!constructor.IsFactory()) {
     instance = Instance::New(type_class);
     if (!type_arguments.IsNull()) {
       // TODO(regis): Where should we check the constraints on type parameters?
       if (!type_arguments.IsInstantiated()) {
         ErrorMsg("type must be constant in const constructor");
       }
       instance.SetTypeArguments(type_arguments);
@@ skipping 1206 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart