Compile an instance setter call when a static getter is declared, but no field

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 732 matching lines @@
   }
   parsed_function->SetNodeSequence(node_sequence);
 
   // The instantiator may be required at run time for generic type checks or
   // allocation of generic types.
   if (parser.IsInstantiatorRequired()) {
     // In the case of a local function, only set the instantiator if the
     // receiver was captured.
     const bool kTestOnly = true;
     LocalVariable* receiver =
-        parser.LookupReceiver(node_sequence->scope(),
-                              kTestOnly);
+        parser.LookupReceiver(node_sequence->scope(), kTestOnly);
     if (!parser.current_function().IsLocalFunction() ||
         ((receiver != NULL) && receiver->is_captured())) {
       parsed_function->set_instantiator(
           new LoadLocalNode(node_sequence->token_pos(), *receiver));
     }
   }
 
   parsed_function->set_default_parameter_values(default_parameter_values);
   isolate->set_ast_node_id(prev_ast_node_id);
 }
@@ skipping 3255 matching lines @@
   if (native_function == NULL) {
     ErrorMsg(native_pos, "native function '%s' cannot be found",
         native_name.ToCString());
   }
 
   const bool has_opt_params = (params->num_optional_parameters > 0);
 
   // Now add the NativeBodyNode and return statement.
   current_block_->statements->Add(
       new ReturnNode(TokenPos(), new NativeBodyNode(TokenPos(),
-                                                      native_name,
-                                                      native_function,
-                                                      num_parameters,
-                                                      has_opt_params,
-                                                      is_instance_closure)));
+                                                    native_name,
+                                                    native_function,
+                                                    num_parameters,
+                                                    has_opt_params,
+                                                    is_instance_closure)));
 }
 
 
-LocalVariable* Parser::LookupReceiver(LocalScope* from_scope,
-                                      bool test_only) {
+LocalVariable* Parser::LookupReceiver(LocalScope* from_scope, bool test_only) {
   const String& this_name = String::Handle(String::NewSymbol(kThisName));
   return from_scope->LookupVariable(this_name, test_only);
 }
 
 
 LocalVariable* Parser::LookupPhaseParameter() {
   const String& phase_name =
       String::Handle(String::NewSymbol(kPhaseParameterName));
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(phase_name, kTestOnly);
@@ skipping 2353 matching lines @@
       const Array& kNoArgumentNames = Array::Handle();
       func = Resolver::ResolveStatic(cls,
                                      getter_name,
                                      kNumArguments,
                                      kNoArgumentNames,
                                      Resolver::kIsQualified);
       if (!func.IsNull()) {
         ASSERT(func.kind() != RawFunction::kConstImplicitGetter);
         EnsureExpressionTemp();
         closure = new StaticGetterNode(call_pos,
+                                       NULL,
                                        Class::ZoneHandle(cls.raw()),
                                        func_name);
         return new ClosureCallNode(call_pos, closure, arguments);
       }
     } else {
       EnsureExpressionTemp();
       closure = GenerateStaticFieldLookup(field, call_pos);
       return new ClosureCallNode(call_pos, closure, arguments);
     }
     // Could not resolve static method: throw an exception if the arguments
@@ skipping 116 matching lines @@
     AstNode* value = ParseExpr(kAllowConst);
     AstNode* load_access = NULL;
     if (field.IsNull()) {
       // No field found, we must have at least a setter function defined.
       ASSERT(!func.IsNull());
       // Explicit setter function for the field found, field does not exist.
       // Create a getter node first in case it is needed. If getter node
       // is used as part of, e.g., "+=", and the explicit getter does not
       // exist, and error will be reported by the code generator.
       load_access = new StaticGetterNode(call_pos,
+                                         NULL,
                                          Class::ZoneHandle(cls.raw()),
                                          String::ZoneHandle(field_name.raw()));
     } else {
       // Field exists.
       if (field.is_final()) {
         // Field has been marked as final, report an error as the field
         // is not settable.
         ErrorMsg(ident_pos,
                  "field '%s' is const static, cannot assign to it",
                  field_name.ToCString());
@@ skipping 22 matching lines @@
         if (func.IsNull()) {
           // No field or explicit getter function, this is an error.
           ErrorMsg(ident_pos,
                    "unknown static field '%s'", field_name.ToCString());
           return access;
         }
         access = CreateImplicitClosureNode(func, call_pos, NULL);
       } else {
         ASSERT(func.kind() != RawFunction::kConstImplicitGetter);
         access = new StaticGetterNode(call_pos,
+                                      NULL,
                                       Class::ZoneHandle(cls.raw()),
                                       field_name);
       }
     } else {
       return GenerateStaticFieldLookup(field, TokenPos());
     }
   }
   return access;
 }
 
@@ skipping 356 matching lines @@
 AstNode* Parser::RunStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
   const Instance& value = Instance::Handle(field.value());
   if (value.raw() == Object::transition_sentinel()) {
     if (field.is_const()) {
       ErrorMsg("circular dependency while initializing static field '%s'",
                String::Handle(field.name()).ToCString());
     } else {
       // The implicit static getter will throw the exception if necessary.
       return new StaticGetterNode(TokenPos(),
+                                  NULL,
                                   Class::ZoneHandle(field.owner()),
                                   String::ZoneHandle(field.name()));
     }
   } else if (value.raw() == Object::sentinel()) {
     // This field has not been referenced yet and thus the value has
     // not been evaluated. If the field is const, call the static getter method
     // to evaluate the expression and canonicalize the value.
     if (field.is_const()) {
       field.set_value(Instance::Handle(Object::transition_sentinel()));
       const String& field_name = String::Handle(field.name());
@@ skipping 28 matching lines @@
       }
       ASSERT(const_value.IsNull() || const_value.IsInstance());
       Instance& instance = Instance::Handle();
       instance ^= const_value.raw();
       if (!instance.IsNull()) {
         instance ^= instance.Canonicalize();
       }
       field.set_value(instance);
     } else {
       return new StaticGetterNode(TokenPos(),
+                                  NULL,
                                   Class::ZoneHandle(field.owner()),
                                   String::ZoneHandle(field.name()));
     }
   }
   return NULL;
 }
 
 
 RawObject* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
@@ skipping 103 matching lines @@
     if (func.IsDynamicFunction()) {
       if (node != NULL) {
         CheckInstanceFieldAccess(ident_pos, ident);
         ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
       return true;
     } else if (func.IsStaticFunction()) {
       if (node != NULL) {
         ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
+        // The static getter may be changed later into an instance setter.
+        AstNode* receiver = NULL;
+        const bool kTestOnly = true;
+        if ((!current_function().is_static() ||
+             current_function().IsInFactoryScope()) &&
+            (LookupReceiver(current_block_->scope, kTestOnly) != NULL)) {
+          receiver = LoadReceiver(ident_pos);
+        }
         *node = new StaticGetterNode(ident_pos,
+                                     receiver,
                                      Class::ZoneHandle(isolate, cls.raw()),
                                      ident);
       }
       return true;
     }
   }
   func = cls.LookupSetterFunction(ident);
   if (!func.IsNull()) {
     if (func.IsDynamicFunction()) {
       if (node != NULL) {
         // We create a getter node even though a getter doesn't exist as
         // it could be followed by an assignment which will convert it to
         // a setter node. If there is no assignment we will get an error
         // when we try to invoke the getter.
         CheckInstanceFieldAccess(ident_pos, ident);
         ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
         *node = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
       return true;
     } else if (func.IsStaticFunction()) {
       if (node != NULL) {
         // We create a getter node even though a getter doesn't exist as
         // it could be followed by an assignment which will convert it to
         // a setter node. If there is no assignment we will get an error
         // when we try to invoke the getter.
         *node = new StaticGetterNode(ident_pos,
+                                     NULL,
                                      Class::ZoneHandle(isolate, cls.raw()),
                                      ident);
       }
       return true;
     }
   }
 
   // Nothing found in scope of current class.
   if (node != NULL) {
     *node = NULL;
@@ skipping 51 matching lines @@
     } else {
       obj = lib.LookupObject(accessor_name);
     }
   }
   if (!obj.IsNull()) {
     ASSERT(obj.IsFunction());
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
     return new StaticGetterNode(qual_ident.ident_pos,
+                                NULL,
                                 Class::ZoneHandle(func.owner()),
                                 *qual_ident.ident);
   }
   if (qual_ident.lib_prefix != NULL) {
     return NULL;
   }
   // Lexically unresolved primary identifiers are referenced by their name.
   return new PrimaryNode(qual_ident.ident_pos, *qual_ident.ident);
 }
 
@@ skipping 1374 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart