Turn compile time errors related to missing getters and setters into invocation

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 1265 matching lines @@
   return native_name;
 }
 
 
 // Resolve and return the dynamic function of the given name in the superclass.
 // 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,
+                                      ArgumentListNode* arguments,
                                       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) {
+  Function& super_func = Function::Handle(
+      Resolver::ResolveDynamicAnyArgs(super_class, name));
+  if (!super_func.IsNull() &&
+      !super_func.AreValidArguments(arguments->length(),
+                                    arguments->names(),
+                                    NULL)) {
+    super_func = Function::null();
+  } else 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());
@@ skipping 68 matching lines @@
       call_pos, function_name, function_args));
   return arguments;
 }
 
 
 AstNode* Parser::ParseSuperCall(const String& function_name) {
   TRACE_PARSER("ParseSuperCall");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const intptr_t supercall_pos = TokenPos();
 
+  // 'this' parameter is the first argument to super call.
+  ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
+  AstNode* receiver = LoadReceiver(supercall_pos);
+  arguments->Add(receiver);
+  ParseActualParameters(arguments, kAllowConst);
+
   const bool kResolveGetter = true;
   bool is_no_such_method = false;
   const Function& super_function = Function::ZoneHandle(
       GetSuperFunction(supercall_pos,
                        function_name,
+                       arguments,
                        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' is not passed as parameter to the closure.
+    ArgumentListNode* closure_arguments = new ArgumentListNode(supercall_pos);
+    for (int i = 1; i < arguments->length(); i++) {
+      closure_arguments->Add(arguments->NodeAt(i));
+    }
+    return new ClosureCallNode(supercall_pos, closure, 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(
         supercall_pos, function_name, *arguments);
   }
   return new StaticCallNode(supercall_pos, super_function, arguments);
 }
 
 
 // Simple test if a node is side effect free.
 static bool IsSimpleLocalOrLiteralNode(AstNode* node) {
   if (node->IsLiteralNode()) {
     return true;
   }
   if (node->IsLoadLocalNode() && !node->AsLoadLocalNode()->HasPseudo()) {
     return true;
   }
   return false;
 }
 
 
 AstNode* Parser::BuildUnarySuperOperator(Token::Kind op, PrimaryNode* super) {
   ASSERT(super->IsSuper());
   AstNode* super_op = NULL;
   const intptr_t super_pos = super->token_pos();
   if ((op == Token::kNEGATE) ||
       (op == Token::kBIT_NOT)) {
     // Resolve the operator function in the superclass.
     const String& operator_function_name =
         String::ZoneHandle(Symbols::New(Token::Str(op)));
+    ArgumentListNode* op_arguments = new ArgumentListNode(super_pos);
+    AstNode* receiver = LoadReceiver(super_pos);
+    op_arguments->Add(receiver);
     const bool kResolveGetter = false;
     bool is_no_such_method = false;
     const Function& super_operator = Function::ZoneHandle(
         GetSuperFunction(super_pos,
                          operator_function_name,
+                         op_arguments,
                          kResolveGetter,
                          &is_no_such_method));
-    ArgumentListNode* op_arguments = new ArgumentListNode(super_pos);
-    AstNode* receiver = LoadReceiver(super_pos);
-    op_arguments->Add(receiver);
     if (is_no_such_method) {
       op_arguments = BuildNoSuchMethodArguments(
           super_pos, operator_function_name, *op_arguments);
     }
     super_op = new StaticCallNode(super_pos, super_operator, op_arguments);
   } else {
     ErrorMsg(super_pos, "illegal super operator call");
   }
   return super_op;
 }
@@ skipping 17 matching lines @@
              (CurrentToken() == Token::kNE)) {
     Token::Kind op = CurrentToken();
     ConsumeToken();
 
     bool negate_result = false;
     if (op == Token::kNE) {
       op = Token::kEQ;
       negate_result = true;
     }
 
-    // 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);
 
+    // Resolve the operator function in the superclass.
+    const String& operator_function_name =
+        String::ZoneHandle(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,
+                         op_arguments,
+                         kResolveGetter,
+                         &is_no_such_method));
     if (is_no_such_method) {
       op_arguments = BuildNoSuchMethodArguments(
           operator_pos, operator_function_name, *op_arguments);
     }
     super_op = new StaticCallNode(operator_pos, super_operator, op_arguments);
     if (negate_result) {
       super_op = new UnaryOpNode(operator_pos, Token::kNOT, super_op);
     }
   }
   return super_op;
 }
 
 
 AstNode* Parser::CreateImplicitClosureNode(const Function& func,
                                            intptr_t token_pos,
                                            AstNode* receiver) {
   Function& implicit_closure_function =
       Function::ZoneHandle(func.ImplicitClosureFunction());
   if (receiver != NULL) {
     // If we create an implicit instance closure from inside a closure of a
     // parameterized class, make sure that the receiver is captured as
     // instantiator.
     if (current_block_->scope->function_level() > 0) {
-      const Class& signature_class = Class::Handle(func.signature_class());
+      const Class& signature_class = Class::Handle(
+          implicit_closure_function.signature_class());
       if (signature_class.NumTypeParameters() > 0) {
         CaptureInstantiator();
       }
     }
   }
   return new ClosureNode(token_pos, implicit_closure_function, receiver, NULL);
 }
 
 
 AstNode* Parser::ParseSuperFieldAccess(const String& field_name) {
@@ skipping 20 matching lines @@
           field_pos, implicit_argument, true, super_class, field_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(
         Resolver::ResolveDynamicAnyArgs(super_class, field_name));
-    if (super_function.IsNull()) {
-      ErrorMsg(field_pos, "field or getter '%s' not found in superclass",
-               field_name.ToCString());
+    if (!super_function.IsNull()) {
+      // In case CreateAssignmentNode is called later on this
+      // CreateImplicitClosureNode, it will be replaced by a StaticSetterNode.
+      return CreateImplicitClosureNode(super_function,
+                                       field_pos,
+                                       implicit_argument);
     }
-    return CreateImplicitClosureNode(super_function,
-                                     field_pos,
-                                     implicit_argument);
+    // No function or field exists of the specified field_name.
+    // Emit a StaticGetterNode anyway, so that noSuchMethod gets called.
   }
-
   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.
@@ skipping 5282 matching lines @@
     *expr = right_node;
     return left_node;
   }
   return *expr;
 }
 
 
 // Ensure that the expression temp is allocated for nodes that may need it.
 AstNode* Parser::CreateAssignmentNode(AstNode* original, AstNode* rhs) {
   AstNode* result = original->MakeAssignmentNode(rhs);
-  if ((result == NULL) && original->IsStaticGetterNode()) {
-    const String& setter_name = String::ZoneHandle(
-        Field::SetterSymbol(original->AsStaticGetterNode()->field_name()));
-    result = ThrowNoSuchMethodError(original->token_pos(), setter_name);
-  }
-  // TODO(hausner): if we decide to throw a no such method error on
-  // assignment to a final variable, we need to do the same as in the
-  // StaticGetterNode above.
   if ((result != NULL) &&
       (result->IsStoreIndexedNode() ||
        result->IsInstanceSetterNode() ||
        result->IsStaticSetterNode() ||
        result->IsStoreStaticFieldNode() ||
        result->IsStoreLocalNode())) {
     EnsureExpressionTemp();
   }
   return result;
 }
@@ skipping 2797 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart