Look up getter in super call (issue 3621).

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 1238 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());
   }
 }
 
 
 // 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.
+// If it is not found, and resolve_getter is true, try to resolve a getter of
+// the same name. If it is still not found, return noSuchMethod and
+// set is_no_such_method to true..
 RawFunction* Parser::GetSuperFunction(intptr_t token_pos,
                                       const String& name,
+                                      bool resolve_getter,
                                       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(Resolver::ResolveDynamicAnyArgs(super_class, name));
+  if (super_func.IsNull() && resolve_getter) {
+    const String& getter_name = String::ZoneHandle(Field::GetterName(name));
+    super_func = Resolver::ResolveDynamicAnyArgs(super_class, getter_name);
+    ASSERT(super_func.IsNull() ||
+           (super_func.kind() != RawFunction::kConstImplicitGetter));
+  }
   if (super_func.IsNull()) {
     const String& no_such_method_name = String::Handle(Symbols::NoSuchMethod());
     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);
@@ skipping 42 matching lines @@
   arguments->Add(args_array);
   return arguments;
 }
 
 
 AstNode* Parser::ParseSuperCall(const String& function_name) {
   TRACE_PARSER("ParseSuperCall");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const intptr_t supercall_pos = TokenPos();
 
+  const bool kResolveGetter = true;
   bool is_no_such_method = false;
   const Function& super_function = Function::ZoneHandle(
-      GetSuperFunction(supercall_pos, function_name, &is_no_such_method));
-
+      GetSuperFunction(supercall_pos,
+                       function_name,
+                       kResolveGetter,
+                       &is_no_such_method));
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
+  if (super_function.IsGetterFunction() ||
+      super_function.IsImplicitGetterFunction()) {
+    // 'this' is not passed as parameter to the closure.
+    ParseActualParameters(arguments, kAllowConst);
+    const Class& super_class = Class::ZoneHandle(current_class().SuperClass());
+    AstNode* closure = new StaticGetterNode(supercall_pos,
+                                            LoadReceiver(supercall_pos),
+                                            /* is_super_getter */ true,
+                                            super_class,
+                                            function_name);
+    EnsureExpressionTemp();
+    return new ClosureCallNode(supercall_pos, closure, arguments);
+  }
   // 'this' parameter is the first argument to super call.
   AstNode* receiver = LoadReceiver(supercall_pos);
   arguments->Add(receiver);
   ParseActualParameters(arguments, kAllowConst);
   if (is_no_such_method) {
     arguments = BuildNoSuchMethodArguments(function_name, *arguments);
   }
   return new StaticCallNode(supercall_pos, super_function, arguments);
 }
 
@@ skipping 30 matching lines @@
             CreateTempConstVariable(operator_pos, "lix");
         AstNode* save = new StoreLocalNode(operator_pos, temp, index_expr);
         current_block_->statements->Add(save);
         index_expr = new LoadLocalNode(operator_pos, temp);
       }
     }
 
     // Resolve the [] operator function in the superclass.
     const String& index_operator_name =
         String::ZoneHandle(Symbols::IndexToken());
+    const bool kResolveGetter = false;
     bool is_no_such_method = false;
     const Function& index_operator = Function::ZoneHandle(
         GetSuperFunction(operator_pos,
                          index_operator_name,
+                         kResolveGetter,
                          &is_no_such_method));
 
     ArgumentListNode* index_op_arguments = new ArgumentListNode(operator_pos);
     AstNode* receiver = LoadReceiver(operator_pos);
     index_op_arguments->Add(receiver);
     index_op_arguments->Add(index_expr);
 
     if (is_no_such_method) {
       index_op_arguments = BuildNoSuchMethodArguments(index_operator_name,
                                                       *index_op_arguments);
     }
     super_op = new StaticCallNode(
         operator_pos, index_operator, index_op_arguments);
 
     if (Token::IsAssignmentOperator(CurrentToken())) {
       Token::Kind assignment_op = CurrentToken();
       ConsumeToken();
       AstNode* value = ParseExpr(kAllowConst, kConsumeCascades);
 
       value = ExpandAssignableOp(operator_pos, assignment_op, super_op, value);
 
       // Resolve the []= operator function in the superclass.
       const String& assign_index_operator_name =
           String::ZoneHandle(Symbols::AssignIndexToken());
+      const bool kResolveGetter = false;
       bool is_no_such_method = false;
       const Function& assign_index_operator = Function::ZoneHandle(
           GetSuperFunction(operator_pos,
                            assign_index_operator_name,
+                           kResolveGetter,
                            &is_no_such_method));
 
       ArgumentListNode* operator_args = new ArgumentListNode(operator_pos);
       operator_args->Add(LoadReceiver(operator_pos));
       operator_args->Add(index_expr);
       operator_args->Add(value);
 
       if (is_no_such_method) {
         operator_args = BuildNoSuchMethodArguments(assign_index_operator_name,
                                                    *operator_args);
       }
       super_op = new StaticCallNode(
           operator_pos, assign_index_operator, operator_args);
     }
   } else if (Token::CanBeOverloaded(CurrentToken())) {
     Token::Kind op = CurrentToken();
     ConsumeToken();
 
     // Resolve the operator function in the superclass.
     const String& operator_function_name =
         String::Handle(Symbols::New(Token::Str(op)));
+    const bool kResolveGetter = false;
     bool is_no_such_method = false;
     const Function& super_operator = Function::ZoneHandle(
         GetSuperFunction(operator_pos,
                          operator_function_name,
+                         kResolveGetter,
                          &is_no_such_method));
 
     ASSERT(Token::Precedence(op) >= Token::Precedence(Token::kBIT_OR));
     AstNode* other_operand = ParseBinaryExpr(Token::Precedence(op) + 1);
 
     ArgumentListNode* op_arguments = new ArgumentListNode(operator_pos);
     AstNode* receiver = LoadReceiver(operator_pos);
     op_arguments->Add(receiver);
     op_arguments->Add(other_operand);
 
@@ skipping 3231 matching lines @@
   LocalVariable* param = LookupTypeArgumentsParameter(current_block_->scope,
                                                       kTestOnly);
   ASSERT(param != NULL);
   return new LoadLocalNode(TokenPos(), param);
 }
 
 
 AstNode* Parser::CallGetter(intptr_t token_pos,
                             AstNode* object,
                             const String& name) {
-  return new InstanceGetterNode(TokenPos(), object, name);
+  return new InstanceGetterNode(token_pos, object, name);
 }
 
 
 // Returns ast nodes of the variable initialization.
 AstNode* Parser::ParseVariableDeclaration(const AbstractType& type,
                                           bool is_final,
                                           bool is_const) {
   TRACE_PARSER("ParseVariableDeclaration");
   ASSERT(IsIdentifier());
   const intptr_t ident_pos = TokenPos();
@@ skipping 4985 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart