Fix Dart_GetType to get the correct number of type arguments.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
@@ skipping 3686 matching lines @@
 
   // Validate the input arguments.
   const Library& lib = Api::UnwrapLibraryHandle(isolate, library);
   if (lib.IsNull()) {
     RETURN_TYPE_ERROR(isolate, library, Library);
   }
   const String& name_str = Api::UnwrapStringHandle(isolate, class_name);
   if (name_str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, class_name, String);
   }
+  // Ensure all classes are finalized.
+  Dart_Handle state = Api::CheckIsolateState(isolate);
+  if (::Dart_IsError(state)) {
+    return state;
+  }
   const Class& cls =
       Class::Handle(isolate, lib.LookupClassAllowPrivate(name_str));
   if (cls.IsNull()) {
     const String& lib_name = String::Handle(isolate, lib.name());
     return Api::NewError("Type '%s' not found in library '%s'.",
                          name_str.ToCString(), lib_name.ToCString());
   }
-  intptr_t num_expected_type_arguments = cls.NumTypeParameters();
-  if (num_expected_type_arguments == 0) {
+  if (cls.NumTypeArguments() == 0) {
+    if (number_of_type_arguments != 0) {
+      return Api::NewError("Invalid number of type arguments specified, "
+                           "got %"Pd" expected 0", number_of_type_arguments);
+    }
     return Api::NewHandle(isolate, Type::NewNonParameterizedType(cls));
   }
+  intptr_t num_expected_type_arguments = cls.NumTypeParameters();
   TypeArguments& type_args_obj = TypeArguments::Handle();
   if (number_of_type_arguments > 0) {
     if (type_arguments == NULL) {
       RETURN_NULL_ERROR(type_arguments);
     }
     if (num_expected_type_arguments != number_of_type_arguments) {
       return Api::NewError("Invalid number of type arguments specified, "
                            "got %"Pd" expected %"Pd,
                            number_of_type_arguments,
                            num_expected_type_arguments);
@@ skipping 10 matching lines @@
     }
     // Set up the type arguments array.
     type_args_obj ^= TypeArguments::New(num_expected_type_arguments);
     AbstractType& type_arg = AbstractType::Handle();
     for (intptr_t i = 0; i < number_of_type_arguments; i++) {
       type_arg ^= array.At(i);
       type_args_obj.SetTypeAt(i, type_arg);
     }
   }
 
-  // Ensure all classes are finalized.
-  Dart_Handle state = Api::CheckIsolateState(isolate);
-  if (::Dart_IsError(state)) {
-    return state;
-  }
-
   // Construct the type object, canonicalize it and return.
   const Type& instantiated_type = Type::Handle(
       Type::New(cls, type_args_obj, Scanner::kDummyTokenIndex));
   ClassFinalizer::FinalizeType(cls,
                                instantiated_type,
                                ClassFinalizer::kCanonicalize);
   return Api::NewHandle(isolate, instantiated_type.raw());
 }
 
 
@@ skipping 221 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success();
 }
 
 }  // namespace dart