Properly resolve top-level setters

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 "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 3894 matching lines @@
     // and rules out many fields from being unnecessary unboxing candidates.
     if (!field->has_static && has_initializer && has_simple_literal) {
       class_field.RecordStore(init_value);
     }
 
     // For static final fields (this includes static const fields), set value to
     // "uninitialized" and create a kImplicitStaticFinalGetter getter method.
     if (field->has_static && has_initializer) {
       class_field.set_value(init_value);
       if (!has_simple_literal) {
-        String& getter_name = String::Handle(Z,
-                                             Field::GetterSymbol(*field->name));
+        String& getter_name =
+            String::Handle(Z, Field::GetterSymbol(*field->name));
         getter = Function::New(getter_name,
                                RawFunction::kImplicitStaticFinalGetter,
                                field->has_static,
                                field->has_const,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                /* is_native = */ false,
                                current_class(),
                                field->name_pos);
         getter.set_result_type(*field->type);
         getter.set_is_debuggable(false);
         if (library_.is_dart_scheme() && library_.IsPrivate(*field->name)) {
           getter.set_is_reflectable(false);
         }
         members->AddFunction(getter);
       }
     }
 
     // For instance fields, we create implicit getter and setter methods.
     if (!field->has_static) {
-      String& getter_name = String::Handle(Z,
-                                           Field::GetterSymbol(*field->name));
+      String& getter_name =
+          String::Handle(Z, Field::GetterSymbol(*field->name));
       getter = Function::New(getter_name, RawFunction::kImplicitGetter,
                              field->has_static,
                              field->has_final,
                              /* is_abstract = */ false,
                              /* is_external = */ false,
                              /* is_native = */ false,
                              current_class(),
                              field->name_pos);
       ParamList params;
       ASSERT(current_class().raw() == getter.Owner());
       params.AddReceiver(ReceiverType(current_class()), field->name_pos);
       getter.set_result_type(*field->type);
       getter.set_is_debuggable(false);
       AddFormalParamsToFunction(&params, getter);
       members->AddFunction(getter);
       if (!field->has_final) {
         // Build a setter accessor for non-const fields.
-        String& setter_name = String::Handle(Z,
-                                             Field::SetterSymbol(*field->name));
+        String& setter_name =
+            String::Handle(Z, Field::SetterSymbol(*field->name));
         setter = Function::New(setter_name, RawFunction::kImplicitSetter,
                                field->has_static,
                                field->has_final,
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                /* is_native = */ false,
                                current_class(),
                                field->name_pos);
         ParamList params;
         ASSERT(current_class().raw() == setter.Owner());
@@ skipping 6554 matching lines @@
   // sequence followed by the (value of the) receiver temp variable load.
   cascade->AddNode(new(Z) LoadLocalNode(cascade_pos, cascade_receiver_var));
   return cascade;
 }
 
 
 // Convert loading of a static const field into a literal node.
 static AstNode* LiteralIfStaticConst(Zone* zone, AstNode* expr) {
   if (expr->IsLoadStaticFieldNode()) {
     const Field& field = expr->AsLoadStaticFieldNode()->field();
-    if (field.is_const()) {
+    if (field.is_const() &&
+        !expr->AsLoadStaticFieldNode()->is_deferred_reference()) {
       ASSERT(field.value() != Object::sentinel().raw());
       ASSERT(field.value() != Object::transition_sentinel().raw());
       return new(zone) LiteralNode(expr->token_pos(),
                                    Instance::ZoneHandle(zone, field.value()));
     }
   }
   return expr;
 }
 
 
@@ skipping 348 matching lines @@
   } else {
     ASSERT(getter.kind() == RawFunction::kImplicitStaticFinalGetter);
     return new(Z) StaticGetterNode(ident_pos,
                                    NULL,  // Receiver.
                                    field_owner,
                                    field_name);
   }
 }
 
 
-AstNode* Parser::ParseStaticFieldAccess(const Class& cls,
-                                        const String& field_name,
-                                        intptr_t ident_pos,
-                                        bool consume_cascades) {
-  TRACE_PARSER("ParseStaticFieldAccess");
+// Reference to 'field_name' with explicit class as primary.
+AstNode* Parser::GenerateStaticFieldAccess(const Class& cls,
+                                           const String& field_name,
+                                           intptr_t ident_pos) {
   AstNode* access = NULL;
   const Field& field = Field::ZoneHandle(Z, cls.LookupStaticField(field_name));
   Function& func = Function::ZoneHandle(Z);
   if (field.IsNull()) {
     // No field, check if we have an explicit getter function.
-    const String& getter_name =
-        String::ZoneHandle(Z, Field::GetterName(field_name));
-    const int kNumArguments = 0;  // no arguments.
-    func = Resolver::ResolveStatic(cls,
-                                   getter_name,
-                                   kNumArguments,
-                                   Object::empty_array());
-    if (func.IsNull()) {
+    func = cls.LookupGetterFunction(field_name);
+    if (func.IsNull() || func.IsDynamicFunction()) {
       // We might be referring to an implicit closure, check to see if
       // there is a function of the same name.
       func = cls.LookupStaticFunction(field_name);
       if (!func.IsNull()) {
         access = CreateImplicitClosureNode(func, ident_pos, NULL);
       } else {
         // No function to closurize found found.
         // This field access may turn out to be a call to the setter.
         // Create a getter call, which may later be turned into
         // a setter call, or else the backend will generate
@@ skipping 120 matching lines @@
             left->AsPrimaryNode()->primary().IsClass()) {
           // Static method call prefixed with class name.
           const Class& cls = Class::Cast(left->AsPrimaryNode()->primary());
           selector = ParseStaticCall(cls, *ident, ident_pos);
         } else {
           selector = ParseInstanceCall(left, *ident, ident_pos);
         }
       } else {
         // Field access.
         Class& cls = Class::Handle(Z);
+        bool is_deferred = false;
         if (left->IsPrimaryNode()) {
           PrimaryNode* primary_node = left->AsPrimaryNode();
           if (primary_node->primary().IsClass()) {
             // If the primary node referred to a class we are loading a
             // qualified static field.
             cls ^= primary_node->primary().raw();
+            is_deferred = primary_node->is_deferred_reference();
           }
         }
         if (cls.IsNull()) {
           // Instance field access.
           selector = CallGetter(ident_pos, left, *ident);
         } else {
           // Static field access.
-          selector =
-              ParseStaticFieldAccess(cls, *ident, ident_pos, !is_cascade);
+          selector = GenerateStaticFieldAccess(cls, *ident, ident_pos);
+          ASSERT(selector != NULL);
+          if (selector->IsLoadStaticFieldNode()) {
+            selector->AsLoadStaticFieldNode()->set_is_deferred(is_deferred);
+          } else if (selector->IsStaticGetterNode()) {
+            selector->AsStaticGetterNode()->set_is_deferred(is_deferred);
+          }
         }
       }
     } else if (CurrentToken() == Token::kLBRACK) {
       // Super index operator handled in ParseSuperOperator().
       ASSERT(!left->IsPrimaryNode() || !left->AsPrimaryNode()->IsSuper());
 
       const intptr_t bracket_pos = TokenPos();
       ConsumeToken();
       left = LoadFieldIfUnresolved(left);
       const bool saved_mode = SetAllowFunctionLiterals(true);
@@ skipping 375 matching lines @@
   if (result.IsNull()) {
     ReportError(token_pos, "Invalid const object %s", error_str);
   }
   return result.raw();
 }
 
 
 // If the field is already initialized, return no ast (NULL).
 // Otherwise, if the field is constant, initialize the field and return no ast.
 // If the field is not initialized and not const, return the ast for the getter.
-AstNode* Parser::RunStaticFieldInitializer(const Field& field,
-                                           intptr_t field_ref_pos) {
+StaticGetterNode* Parser::RunStaticFieldInitializer(const Field& field,
+                                                    intptr_t field_ref_pos) {
   ASSERT(field.is_static());
   const Class& field_owner = Class::ZoneHandle(Z, field.owner());
   const String& field_name = String::ZoneHandle(Z, field.name());
   const String& getter_name = String::Handle(Z, Field::GetterName(field_name));
   const Function& getter = Function::Handle(Z,
       field_owner.LookupStaticFunction(getter_name));
   const Instance& value = Instance::Handle(Z, field.value());
   if (value.raw() == Object::transition_sentinel().raw()) {
     if (field.is_const()) {
       ReportError("circular dependency while initializing static field '%s'",
@@ skipping 264 matching lines @@
                                                    const String& ident) {
   TRACE_PARSER("ResolveIdentInCurrentLibraryScope");
   HANDLESCOPE(I);
   const Object& obj = Object::Handle(Z, library_.ResolveName(ident));
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
     return new(Z) PrimaryNode(ident_pos, Class::ZoneHandle(Z, cls.raw()));
   } else if (obj.IsField()) {
     const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
-    return GenerateStaticFieldLookup(field, ident_pos);
+    AstNode* get_field = GenerateStaticFieldLookup(field, ident_pos);
+    if (get_field->IsStaticGetterNode()) {
+      get_field->AsStaticGetterNode()->set_owner(library_);
+    }
+    return get_field;
   } else if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     if (func.IsGetterFunction() || func.IsSetterFunction()) {
-      return new(Z) StaticGetterNode(ident_pos,
-                                     /* receiver */ NULL,
-                                     Class::ZoneHandle(Z, func.Owner()),
-                                     ident);
-
+      StaticGetterNode* getter =
+          new(Z) StaticGetterNode(ident_pos,
+                                  /* receiver */ NULL,
+                                  Class::ZoneHandle(Z, func.Owner()),
+                                  ident);
+      getter->set_owner(library_);
+      return getter;
     } else {
       return new(Z) PrimaryNode(ident_pos, Function::ZoneHandle(Z, func.raw()));
     }
   } else {
     ASSERT(obj.IsNull() || obj.IsLibraryPrefix());
   }
   // Lexically unresolved primary identifiers are referenced by their name.
   return new(Z) PrimaryNode(ident_pos, ident);
 }
 
@@ skipping 14 matching lines @@
 // libraries present in the library prefix.
 AstNode* Parser::ResolveIdentInPrefixScope(intptr_t ident_pos,
                                            const LibraryPrefix& prefix,
                                            const String& ident) {
   TRACE_PARSER("ResolveIdentInPrefixScope");
   HANDLESCOPE(I);
   if (ident.CharAt(0) == Library::kPrivateIdentifierStart) {
     // Private names are not exported by libraries. The name mangling
     // of private names with a library-specific suffix usually ensures
     // that _x in library A is not found when looked up from library B.
-    // In the pathological case where a library includes itself with
+    // In the pathological case where a library imports itself with
     // a prefix, the name mangling would not help in hiding the private
     // name, so we need to explicitly reject private names here.
     return NULL;
   }
   Object& obj = Object::Handle(Z);
   if (prefix.is_loaded()) {
     obj = prefix.LookupObject(ident);
   } else {
     // Remember that this function depends on an import prefix of an
     // unloaded deferred library. Note that parsed_function() can be
@@ skipping 16 matching lines @@
     const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
     AstNode* get_field = GenerateStaticFieldLookup(field, ident_pos);
     ASSERT(get_field != NULL);
     ASSERT(get_field->IsLoadStaticFieldNode() ||
            get_field->IsStaticGetterNode());
     if (get_field->IsLoadStaticFieldNode()) {
       get_field->AsLoadStaticFieldNode()->set_is_deferred(is_deferred);
     } else if (get_field->IsStaticGetterNode()) {
       get_field->AsStaticGetterNode()->set_is_deferred(is_deferred);
+      get_field->AsStaticGetterNode()->set_owner(prefix);
     }
     return get_field;
   } else if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
     if (func.IsGetterFunction() || func.IsSetterFunction()) {
       StaticGetterNode* getter = new(Z) StaticGetterNode(
-          ident_pos,
-          /* receiver */ NULL,
-          Class::ZoneHandle(Z, func.Owner()),
-          ident);
+         ident_pos,
+         /* receiver */ NULL,
+         Class::ZoneHandle(Z, func.Owner()),
+         ident);
       getter->set_is_deferred(is_deferred);
+      getter->set_owner(prefix);
       return getter;
     } else {
       PrimaryNode* primary = new(Z) PrimaryNode(
            ident_pos, Function::ZoneHandle(Z, func.raw()));
       primary->set_is_deferred(is_deferred);
       return primary;
     }
   }
   // All possible object types are handled above.
   UNREACHABLE();
@@ skipping 1654 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart