Report correct error message in case of super invocation (fix issue 8208).

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 "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 1180 matching lines @@
   BuildDispatcherScope(func, desc, default_values);
 
   // Receiver is local 0.
   LocalScope* scope = current_block_->scope;
   ArgumentListNode* func_args = new ArgumentListNode(token_pos);
   for (intptr_t i = 0; i < desc.Count(); ++i) {
     func_args->Add(new LoadLocalNode(token_pos, scope->VariableAt(i)));
   }
 
   if (desc.NamedCount() > 0) {
-    const Array& arg_names =
-        Array::ZoneHandle(Array::New(desc.NamedCount()));
+    const Array& arg_names = Array::ZoneHandle(Array::New(desc.NamedCount()));
     for (intptr_t i = 0; i < arg_names.Length(); ++i) {
       arg_names.SetAt(i, String::Handle(desc.NameAt(i)));
     }
     func_args->set_names(arg_names);
   }
 
   const String& func_name = String::ZoneHandle(func.name());
-  ArgumentListNode* arguments = BuildNoSuchMethodArguments(token_pos,
-                                                           func_name,
-                                                           *func_args);
+  ArgumentListNode* arguments = BuildNoSuchMethodArguments(
+      token_pos, func_name, *func_args, NULL, false);
   const Function& no_such_method = Function::ZoneHandle(
-        Resolver::ResolveDynamicAnyArgs(Class::Handle(func.Owner()),
-                                        Symbols::NoSuchMethod()));
+      Resolver::ResolveDynamicAnyArgs(Class::Handle(func.Owner()),
+                                      Symbols::NoSuchMethod()));
   StaticCallNode* call =
       new StaticCallNode(token_pos, no_such_method, arguments);
 
-
   ReturnNode* return_node = new ReturnNode(token_pos, call);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
 
 SequenceNode* Parser::ParseInvokeFieldDispatcher(const Function& func,
                                                  Array& default_values) {
   TRACE_PARSER("ParseInvokeFieldDispatcher");
 
@@ skipping 412 matching lines @@
     *is_no_such_method = false;
   }
   return super_func.raw();
 }
 
 
 StaticCallNode* Parser::BuildInvocationMirrorAllocation(
     intptr_t call_pos,
     const String& function_name,
     const ArgumentListNode& function_args,
-    const LocalVariable* temp_for_last_arg) {
+    const LocalVariable* temp_for_last_arg,
+    bool is_super_invocation) {
   const intptr_t args_pos = function_args.token_pos();
   // Build arguments to the call to the static
   // InvocationMirror._allocateInvocationMirror method.
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   // The first argument is the original function name.
   arguments->Add(new LiteralNode(args_pos, function_name));
   // The second argument is the arguments descriptor of the original function.
   const Array& args_descriptor =
       Array::ZoneHandle(ArgumentsDescriptor::New(function_args.length(),
                                                  function_args.names()));
@@ skipping 10 matching lines @@
                                            temp_for_last_arg,
                                            arg));
       store_arg->AddNode(new LoadLocalNode(arg->token_pos(),
                                            temp_for_last_arg));
       args_array->AddElement(store_arg);
     } else {
       args_array->AddElement(arg);
     }
   }
   arguments->Add(args_array);
+  arguments->Add(new LiteralNode(args_pos, Bool::Get(is_super_invocation)));
   // Lookup the static InvocationMirror._allocateInvocationMirror method.
   const Class& mirror_class =
       Class::Handle(Library::LookupCoreClass(Symbols::InvocationMirror()));
   ASSERT(!mirror_class.IsNull());
   const Function& allocation_function = Function::ZoneHandle(
       mirror_class.LookupStaticFunction(
           Library::PrivateCoreLibName(Symbols::AllocateInvocationMirror())));
   ASSERT(!allocation_function.IsNull());
   return new StaticCallNode(call_pos, allocation_function, arguments);
 }
 
 
 ArgumentListNode* Parser::BuildNoSuchMethodArguments(
     intptr_t call_pos,
     const String& function_name,
     const ArgumentListNode& function_args,
-    const LocalVariable* temp_for_last_arg) {
+    const LocalVariable* temp_for_last_arg,
+    bool is_super_invocation) {
   ASSERT(function_args.length() >= 1);  // The receiver is the first argument.
   const intptr_t args_pos = function_args.token_pos();
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   arguments->Add(function_args.NodeAt(0));
   // The second argument is the invocation mirror.
-  arguments->Add(BuildInvocationMirrorAllocation(
-      call_pos, function_name, function_args, temp_for_last_arg));
+  arguments->Add(BuildInvocationMirrorAllocation(call_pos,
+                                                 function_name,
+                                                 function_args,
+                                                 temp_for_last_arg,
+                                                 is_super_invocation));
   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.
@@ skipping 21 matching lines @@
     EnsureSavedCurrentContext();
     // '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);
   }
   if (is_no_such_method) {
     arguments = BuildNoSuchMethodArguments(
-        supercall_pos, function_name, *arguments);
+        supercall_pos, function_name, *arguments, NULL, true);
   }
   return new StaticCallNode(supercall_pos, super_function, arguments);
 }
 
 
 // Simple test if a node is side effect free.
 static bool IsSimpleLocalOrLiteralNode(AstNode* node) {
   return node->IsLiteralNode() || node->IsLoadLocalNode();
 }
 
@@ skipping 13 matching lines @@
     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));
     if (is_no_such_method) {
       op_arguments = BuildNoSuchMethodArguments(
-          super_pos, operator_function_name, *op_arguments);
+          super_pos, operator_function_name, *op_arguments, NULL, true);
     }
     super_op = new StaticCallNode(super_pos, super_operator, op_arguments);
   } else {
     ErrorMsg(super_pos, "illegal super operator call");
   }
   return super_op;
 }
 
 
 AstNode* Parser::ParseSuperOperator() {
@@ skipping 36 matching lines @@
     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);
+          operator_pos, operator_function_name, *op_arguments, NULL, true);
     }
     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;
 }
 
 
@@ skipping 8718 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart