Fix super getter/setter

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 1174 matching lines @@
 
 void Parser::CheckFunctionIsCallable(intptr_t token_pos,
                                      const Function& function) {
   if (Class::Handle(function.owner()).is_interface()) {
     ErrorMsg(token_pos, "cannot call function of interface '%s'",
         function.ToFullyQualifiedCString());
   }
 }
 
 
-static RawFunction* ResolveDynamicFunction(const Class& cls,
-                                           const String& name) {
-  Function& func = Function::Handle(cls.LookupDynamicFunction(name));
-  if (func.IsNull()) {
-    Class& super_cls = Class::Handle(cls.SuperClass());
-    while (!super_cls.IsNull()) {
-      func = super_cls.LookupDynamicFunction(name);
-      if (!func.IsNull()) {
-        return func.raw();
-      }
-      super_cls = super_cls.SuperClass();
-    }
-  }
-  return func.raw();
-}
-
 // Resolve and return the dynamic function of the given name in the superclass.
 // If it is not found, return noSuchMethod and set is_no_such_method to true.
 RawFunction* Parser::GetSuperFunction(intptr_t token_pos,
                                       const String& name,
                                       bool* is_no_such_method) {
   const Class& super_class = Class::Handle(current_class().SuperClass());
   if (super_class.IsNull()) {
     ErrorMsg(token_pos, "class '%s' does not have a superclass",
              String::Handle(current_class().Name()).ToCString());
   }
 
   Function& super_func =
-      Function::Handle(ResolveDynamicFunction(super_class, name));
+      Function::Handle(Resolver::ResolveDynamicAnyArgs(super_class, name));
   if (super_func.IsNull()) {
     const String& no_such_method_name = String::Handle(Symbols::NoSuchMethod());
-    super_func = ResolveDynamicFunction(super_class, no_such_method_name);
+    super_func =
+        Resolver::ResolveDynamicAnyArgs(super_class, no_such_method_name);
     ASSERT(!super_func.IsNull());
     *is_no_such_method = true;
   } else {
     *is_no_such_method = false;
   }
   CheckFunctionIsCallable(token_pos, super_func);
   return super_func.raw();
 }
 
 
@@ skipping 192 matching lines @@
       }
     }
   }
   return new ClosureNode(token_pos, implicit_closure_function, receiver, NULL);
 }
 
 
 AstNode* Parser::ParseSuperFieldAccess(const String& field_name) {
   TRACE_PARSER("ParseSuperFieldAccess");
   const intptr_t field_pos = TokenPos();
-  const Class& super_class = Class::Handle(current_class().SuperClass());
+  const Class& super_class = Class::ZoneHandle(current_class().SuperClass());
   if (super_class.IsNull()) {
     ErrorMsg("class '%s' does not have a superclass",
              String::Handle(current_class().Name()).ToCString());
   }
   AstNode* implicit_argument = LoadReceiver(field_pos);
 
   const String& getter_name =
       String::ZoneHandle(Field::GetterName(field_name));
   const Function& super_getter = Function::ZoneHandle(
-      ResolveDynamicFunction(super_class, getter_name));
+      Resolver::ResolveDynamicAnyArgs(super_class, getter_name));
   if (super_getter.IsNull()) {
     // Check if this is an access to an implicit closure using 'super'.
     // If a function exists of the specified field_name then try
     // accessing it as a getter, at runtime we will handle this by
     // creating an implicit closure of the function and returning it.
     const Function& super_function = Function::ZoneHandle(
-        ResolveDynamicFunction(super_class, field_name));
+        Resolver::ResolveDynamicAnyArgs(super_class, field_name));
     if (super_function.IsNull()) {
       ErrorMsg(field_pos, "field or getter '%s' not found in superclass",
                field_name.ToCString());
     }
     return CreateImplicitClosureNode(super_function,
                                      field_pos,
                                      implicit_argument);
   }
-  // All dynamic getters take one argument and no named arguments.
-  ASSERT(super_getter.AreValidArgumentCounts(1, 0, NULL));
-  ArgumentListNode* getter_arguments = new ArgumentListNode(field_pos);
-  getter_arguments->Add(implicit_argument);
-  AstNode* super_field =
-      new StaticCallNode(field_pos, super_getter, getter_arguments);
 
-  if (Token::IsAssignmentOperator(CurrentToken())) {
-    const String& setter_name =
-        String::ZoneHandle(Field::SetterName(field_name));
-    const Function& super_setter = Function::ZoneHandle(
-        ResolveDynamicFunction(super_class, setter_name));
-    if (super_setter.IsNull()) {
-      ErrorMsg(field_pos,
-               "field '%s' not assignable in superclass",
-               field_name.ToCString());
-    }
-    // All dynamic setters take two arguments and no named arguments.
-    ASSERT(super_setter.AreValidArgumentCounts(2, 0, NULL));
-
-    Token::Kind assignment_op = CurrentToken();
-    ConsumeToken();
-    AstNode* value = ParseExpr(kAllowConst, kConsumeCascades);
-    value = ExpandAssignableOp(field_pos, assignment_op, super_field, value);
-
-    ArgumentListNode* setter_arguments = new ArgumentListNode(field_pos);
-    setter_arguments->Add(implicit_argument);
-    setter_arguments->Add(value);
-    super_field = new StaticCallNode(field_pos, super_setter, setter_arguments);
-  }
-  return super_field;
+  return new StaticGetterNode(
+                 field_pos, implicit_argument, true, super_class, field_name);
 }
 
 
 void Parser::GenerateSuperConstructorCall(const Class& cls,
                                           LocalVariable* receiver) {
   const intptr_t supercall_pos = TokenPos();
   const Class& super_class = Class::Handle(cls.SuperClass());
   // Omit the implicit super() if there is no super class (i.e.
   // we're not compiling class Object), or if the super class is an
   // artificially generated "wrapper class" that has no constructor.
@@ skipping 5246 matching lines @@
       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,
+                                       false,
                                        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 89 matching lines @@
         ErrorMsg(ident_pos, "unknown static field '%s'",
                  field_name.ToCString());
       }
 
       // 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.
       access = new StaticGetterNode(call_pos,
                                     NULL,
+                                    false,
                                     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 19 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());
         }
         access = CreateImplicitClosureNode(func, call_pos, NULL);
       } else {
         ASSERT(func.kind() != RawFunction::kConstImplicitGetter);
         access = new StaticGetterNode(call_pos,
                                       NULL,
+                                      false,
                                       Class::ZoneHandle(cls.raw()),
                                       field_name);
       }
     } else {
       access = GenerateStaticFieldLookup(field, TokenPos());
     }
   }
   return access;
 }
 
@@ skipping 380 matching lines @@
   if (value.raw() == Object::transition_sentinel()) {
     // TODO(hausner): Remove the check for is_final() once we support
     // non-const final fields.
     if (field.is_const() || field.is_final()) {
       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,
+                                  false,
                                   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.
     // TODO(hausner): Remove the check for is_final() once we support
     // non-const final fields.
     if (field.is_const() || field.is_final()) {
@@ skipping 31 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,
+                                  false,
                                   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.
+        // The static getter may later be changed into a dynamically
+        // resolved instance setter if no static setter can
+        // be found.
         AstNode* receiver = NULL;
         const bool kTestOnly = true;
         ASSERT(!current_function().IsInFactoryScope());
         if (!current_function().is_static() &&
             (LookupReceiver(current_block_->scope, kTestOnly) != NULL)) {
           receiver = LoadReceiver(ident_pos);
         }
         *node = new StaticGetterNode(ident_pos,
                                      receiver,
+                                     false,
                                      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,
+                                     false,
                                      Class::ZoneHandle(isolate, cls.raw()),
                                      ident);
       }
       return true;
     }
   }
 
   // Nothing found in scope of current class.
   if (node != NULL) {
     *node = NULL;
@@ skipping 52 matching lines @@
       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,
+                                false,
                                 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 1393 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart