Fix super call invocation (issue 2028).

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 36 matching lines @@
 static const char* kListLiteralFactoryName = "List.fromLiteral";
 static const char* kMapLiteralFactoryClassName = "_MapLiteralFactory";
 static const char* kMapLiteralFactoryName = "Map.fromLiteral";
 static const char* kImmutableMapName = "ImmutableMap";
 static const char* kImmutableMapConstructorName = "ImmutableMap._create";
 static const char* kStringClassName = "StringBase";
 static const char* kInterpolateName = "_interpolate";
 static const char* kThisName = "this";
 static const char* kPhaseParameterName = ":phase";
 static const char* kGetIteratorName = "iterator";
+static const char* kNoSuchMethodName = "noSuchMethod";
 
 #if defined(DEBUG)
 
 class TraceParser : public ValueObject {
  public:
   TraceParser(intptr_t token_index, const Script& script, const char* msg) {
     if (FLAG_trace_parser) {
       intptr_t line, column;
       script.GetTokenLocation(token_index, &line, &column);
       PrintIndent();
@@ skipping 1137 matching lines @@
       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) {
+                                      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());
   }
 
-  const Function& super_func =
+  Function& super_func =
       Function::Handle(ResolveDynamicFunction(super_class, name));
   if (super_func.IsNull()) {
-    ErrorMsg(token_pos, "function '%s' not found in super class",
-             name.ToCString());
+    const String& no_such_method_name =
+        String::ZoneHandle(String::NewSymbol(kNoSuchMethodName));
+    super_func = ResolveDynamicFunction(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();
 }
 
 
+// Lookup class in the corelib implementation which contains various VM
+// helper methods and classes.
+static RawClass* LookupImplClass(const String& class_name) {
+  return Library::Handle(Library::CoreImplLibrary()).LookupClass(class_name);
+}
+
+
+// Lookup class in the corelib which also contains various VM
+// helper methods and classes. Allow look up of private classes.
+static RawClass* LookupCoreClass(const String& class_name) {
+  const Library& core_lib = Library::Handle(Library::CoreLibrary());
+  String& name = String::Handle(class_name.raw());
+  if (class_name.CharAt(0) == Scanner::kPrivateIdentifierStart) {
+    // Private identifiers are mangled on a per script basis.
+    name = String::Concat(name, String::Handle(core_lib.private_key()));
+    name = String::NewSymbol(name);
+  }
+  return core_lib.LookupClass(name);
+}
+
+
+ArgumentListNode* Parser::BuildNoSuchMethodArguments(
+    const String& function_name,
+    const ArgumentListNode& function_args) {
+  ASSERT(function_args.length() >= 1);  // The receiver is the first argument.
+  const intptr_t args_pos = function_args.token_index();
+  ArgumentListNode* arguments = new ArgumentListNode(args_pos);
+  arguments->Add(function_args.NodeAt(0));
+  // The second argument is the original function name.
+  // TODO(regis): This will change once mirrors are supported.
+  arguments->Add(new LiteralNode(args_pos, function_name));
+  // The third argument is an array containing the original function arguments.
+  ArrayNode* args_array = new ArrayNode(args_pos, TypeArguments::ZoneHandle());
+  for (intptr_t i = 1; i < function_args.length(); i++) {
+    args_array->AddElement(function_args.NodeAt(i));
+  }
+  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 = token_index_;
 
+  bool is_no_such_method = false;
   const Function& super_function = Function::ZoneHandle(
-      GetSuperFunction(supercall_pos, function_name));
+      GetSuperFunction(supercall_pos, function_name, &is_no_such_method));
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // '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);
 }
 
 
 // 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()) {
@@ skipping 24 matching lines @@
         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(String::NewSymbol(Token::Str(Token::kINDEX)));
+    bool is_no_such_method = false;
     const Function& index_operator = Function::ZoneHandle(
-        GetSuperFunction(operator_pos, index_operator_name));
+        GetSuperFunction(operator_pos,
+                         index_operator_name,
+                         &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);
 
       value = ExpandAssignableOp(operator_pos, assignment_op, super_op, value);
 
       // Resolve the []= operator function in the superclass.
       const String& assign_index_operator_name = String::ZoneHandle(
           String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
+      bool is_no_such_method = false;
       const Function& assign_index_operator = Function::ZoneHandle(
-          GetSuperFunction(operator_pos, assign_index_operator_name));
+          GetSuperFunction(operator_pos,
+                           assign_index_operator_name,
+                           &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(String::NewSymbol(Token::Str(op)));
+    bool is_no_such_method = false;
     const Function& super_operator = Function::ZoneHandle(
-        GetSuperFunction(operator_pos, operator_function_name));
+        GetSuperFunction(operator_pos,
+                         operator_function_name,
+                         &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);
 
     CheckFunctionIsCallable(operator_pos, super_operator);
+    if (is_no_such_method) {
+      op_arguments = BuildNoSuchMethodArguments(operator_function_name,
+                                                *op_arguments);
+    }
     super_op = new StaticCallNode(operator_pos, super_operator, op_arguments);
   }
   return super_op;
 }
 
 
 AstNode* Parser::CreateImplicitClosureNode(const Function& func,
                                            intptr_t token_pos,
                                            AstNode* receiver) {
   Function& implicit_closure_function =
@@ skipping 3575 matching lines @@
   CloseBlock();
   return new ForNode(for_pos,
                      label,
                      NodeAsSequenceNode(init_pos, initializer, init_scope),
                      condition,
                      NodeAsSequenceNode(incr_pos, increment, incr_scope),
                      body);
 }
 
 
-// Lookup class in the corelib implementation which contains various VM
-// helper methods and classes.
-static RawClass* LookupImplClass(const String& class_name) {
-  return Library::Handle(Library::CoreImplLibrary()).LookupClass(class_name);
-}
-
-
-// Lookup class in the corelib which also contains various VM
-// helper methods and classes. Allow look up of private classes.
-static RawClass* LookupCoreClass(const String& class_name) {
-  const Library& core_lib = Library::Handle(Library::CoreLibrary());
-  String& name = String::Handle(class_name.raw());
-  if (class_name.CharAt(0) == Scanner::kPrivateIdentifierStart) {
-    // Private identifiers are mangled on a per script basis.
-    name = String::Concat(name, String::Handle(core_lib.private_key()));
-    name = String::NewSymbol(name);
-  }
-  return core_lib.LookupClass(name);
-}
-
-
 // Calling VM-internal helpers, uses implementation core library.
 AstNode* Parser::MakeStaticCall(const char* class_name,
                                 const char* function_name,
                                 ArgumentListNode* arguments) {
   const String& cls_name =
       String::Handle(String::NewSymbol(class_name));
   const Class& cls = Class::Handle(LookupImplClass(cls_name));
   ASSERT(!cls.IsNull());
   const String& func_name =
       String::ZoneHandle(String::NewSymbol(function_name));
@@ skipping 3566 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart