Check for a passed-in type argument vector in the prolog of generic functions.

runtime/vm/dart_entry.cc

 // Copyright (c) 2011, 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/dart_entry.h"
 
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/debugger.h"
 #include "vm/object_store.h"
@@ skipping 78 matching lines @@
                                      const Array& arguments,
                                      const Array& arguments_descriptor,
                                      uword current_sp) {
   // Get the entrypoint corresponding to the function specified, this
   // will result in a compilation of the function if it is not already
   // compiled.
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   ASSERT(thread->IsMutatorThread());
   ScopedIsolateStackLimits stack_limit(thread, current_sp);
+  if (ArgumentsDescriptor(arguments_descriptor).TypeArgsLen() > 0) {
+    const String& message = String::Handle(String::New(
+        "Unsupported invocation of Dart generic function with type arguments"));
+    return ApiError::New(message);
+  }
   if (!function.HasCode()) {
     const Object& result =
         Object::Handle(zone, Compiler::CompileFunction(thread, function));
     if (result.IsError()) {
       return Error::Cast(result).raw();
     }
   }
 // Now Call the invoke stub which will invoke the dart function.
 #if !defined(TARGET_ARCH_DBC)
   invokestub entrypoint = reinterpret_cast<invokestub>(
@@ skipping 24 matching lines @@
   const Array& arguments_descriptor =
       Array::Handle(ArgumentsDescriptor::New(kTypeArgsLen, arguments.Length()));
   return InvokeClosure(arguments, arguments_descriptor);
 }
 
 
 RawObject* DartEntry::InvokeClosure(const Array& arguments,
                                     const Array& arguments_descriptor) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
+  const ArgumentsDescriptor args_desc(arguments_descriptor);
+  const intptr_t instance_index = args_desc.TypeArgsLen() == 0 ? 0 : 1;
   Instance& instance = Instance::Handle(zone);
-  instance ^= arguments.At(0);
+  instance ^= arguments.At(instance_index);
   // Get the entrypoint corresponding to the closure function or to the call
   // method of the instance. This will result in a compilation of the function
   // if it is not already compiled.
   Function& function = Function::Handle(zone);
   if (instance.IsCallable(&function)) {
     // Only invoke the function if its arguments are compatible.
-    const ArgumentsDescriptor args_desc(arguments_descriptor);
     if (function.AreValidArgumentCounts(args_desc.TypeArgsLen(),
                                         args_desc.Count(),
                                         args_desc.NamedCount(), NULL)) {
       // The closure or non-closure object (receiver) is passed as implicit
       // first argument. It is already included in the arguments array.
       return InvokeFunction(function, arguments, arguments_descriptor);
     }
   }
 
   // There is no compatible 'call' method, see if there's a getter.
@@ skipping 222 matching lines @@
   descriptor ^= descriptor.CheckAndCanonicalize(thread, NULL);
   ASSERT(!descriptor.IsNull());
   return descriptor.raw();
 }
 
 
 RawArray* ArgumentsDescriptor::New(intptr_t type_args_len,
                                    intptr_t num_arguments) {
   ASSERT(type_args_len >= 0);
   ASSERT(num_arguments >= 0);
-  if (num_arguments < kCachedDescriptorCount) {
+  if ((type_args_len == 0) && (num_arguments < kCachedDescriptorCount)) {
     return cached_args_descriptors_[num_arguments];
   }
-  return NewNonCached(num_arguments);
+  return NewNonCached(type_args_len, num_arguments);
 }
 
 
-RawArray* ArgumentsDescriptor::NewNonCached(intptr_t num_arguments,
+RawArray* ArgumentsDescriptor::NewNonCached(intptr_t type_args_len,
+                                            intptr_t num_arguments,
                                             bool canonicalize) {
-  // Build the arguments descriptor array, which consists of the zero length
+  // Build the arguments descriptor array, which consists of the length of the
   // type argument vector, total argument count; the positional argument count;
   // and a terminating null to simplify iterating in generated code.
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const intptr_t descriptor_len = LengthFor(0);
   Array& descriptor =
       Array::Handle(zone, Array::New(descriptor_len, Heap::kOld));
   const Smi& arg_count = Smi::Handle(zone, Smi::New(num_arguments));
 
-  // Set zero length type argument vector.
-  descriptor.SetAt(kTypeArgsLenIndex, Smi::Handle(zone, Smi::New(0)));
+  // Set type argument vector length.
+  descriptor.SetAt(kTypeArgsLenIndex,
+                   Smi::Handle(zone, Smi::New(type_args_len)));
 
   // Set total number of passed arguments.
   descriptor.SetAt(kCountIndex, arg_count);
 
   // Set number of positional arguments.
   descriptor.SetAt(kPositionalCountIndex, arg_count);
 
   // Set terminating null.
   descriptor.SetAt((descriptor_len - 1), Object::null_object());
 
   // Share the immutable descriptor when possible by canonicalizing it.
   descriptor.MakeImmutable();
   if (canonicalize) {
     descriptor ^= descriptor.CheckAndCanonicalize(thread, NULL);
   }
   ASSERT(!descriptor.IsNull());
   return descriptor.raw();
 }
 
 
 void ArgumentsDescriptor::InitOnce() {
   for (int i = 0; i < kCachedDescriptorCount; i++) {
-    cached_args_descriptors_[i] = ArgumentsDescriptor::NewNonCached(i, false);
+    cached_args_descriptors_[i] =
+        ArgumentsDescriptor::NewNonCached(/*type_args_len=*/0, i, false);
   }
 }
 
 
 RawObject* DartLibraryCalls::InstanceCreate(const Library& lib,
                                             const String& class_name,
                                             const String& constructor_name,
                                             const Array& arguments) {
   const Class& cls = Class::Handle(lib.LookupClassAllowPrivate(class_name));
   ASSERT(!cls.IsNull());
@@ skipping 171 matching lines @@
   const Array& args = Array::Handle(Array::New(kNumArguments));
   args.SetAt(0, map);
   args.SetAt(1, key);
   args.SetAt(2, value);
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(function, args));
   return result.raw();
 }
 
 }  // namespace dart