Add missing test coverage for constructor kinds, generic function typedefs and generic mixin applic…

tests/lib/mirrors/generic_function_typedef_test.dart

Index: tests/lib/mirrors/generic_function_typedef_test.dart
diff --git a/tests/lib/mirrors/generic_function_typedef_test.dart b/tests/lib/mirrors/generic_function_typedef_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..051f25da35cd12134fea6a1d883ed1cc4f334f69
--- /dev/null
+++ b/tests/lib/mirrors/generic_function_typedef_test.dart
@@ -0,0 +1,113 @@
+// 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.
+
+library test.generic_function_typedef;
+
+import 'dart:mirrors';
+
+import 'package:expect/expect.dart';
+
+import 'generics_test.dart';
+
+typedef bool NonGenericPredicate(num);
+typedef bool GenericPredicate<T>(T);
+typedef S GenericTransform<S>(S);
+
+class C<R> {
+  GenericPredicate<num> predicateOfNum;
+  GenericTransform<String> transformOfString;
+  GenericTransform<R> transformOfR;
+}
+
+main() {
+  TypeMirror dynamicMirror = currentMirrorSystem().dynamicType;
+
+  TypedefMirror predicateOfNum = reflectClass(C).variables[#predicateOfNum].type;
+  TypedefMirror transformOfString = reflectClass(C).variables[#transformOfString].type;
+  TypedefMirror transformOfR = reflectClass(C).variables[#transformOfR].type;
+  TypedefMirror transformOfDouble = reflect(new C<double>()).type.variables[#transformOfR].type;
+
+  TypeVariableMirror rFromC = reflectClass(C).typeVariables[0];
+
+  // Typedefs.
+  typeParameters(reflectClass(NonGenericPredicate), []);
+  typeParameters(reflectClass(GenericPredicate), [#T]);
+  typeParameters(reflectClass(GenericTransform), [#S]);
+  typeParameters(predicateOfNum, [#T]);
+  typeParameters(transformOfString, [#S]);
+  typeParameters(transformOfR, [#R]);
+  typeParameters(transformOfDouble, [#R]);
+
+  typeArguments(reflectClass(NonGenericPredicate), []);
+  typeArguments(reflectClass(GenericPredicate), []);
+  typeArguments(reflectClass(GenericTransform), []);
+  typeArguments(predicateOfNum, [reflectClass(num)]);
+  typeArguments(transformOfString, [reflectClass(String)]);
+  typeArguments(transformOfR, [rFromC]);
+  typeArguments(transformOfDouble, [reflect(double)]);
+
+  Expect.isTrue(reflectClass(NonGenericPredicate).isOriginalDeclaration);
+  Expect.isTrue(reflectClass(GenericPredicate).isOriginalDeclaration);
+  Expect.isTrue(reflectClass(GenericTransform).isOriginalDeclaration);  
+  Expect.isFalse(predicateOfNum.isOriginalDeclaration);  
+  Expect.isFalse(transformOfString.isOriginalDeclaration);  
+  Expect.isFalse(transformOfR.isOriginalDeclaration);  
+  Expect.isFalse(transformOfDouble.isOriginalDeclaration);  
+
+  // Function types.
+  typeParameters(reflectClass(NonGenericPredicate).referent, []);
+  typeParameters(reflectClass(GenericPredicate).referent, []);
+  typeParameters(reflectClass(GenericTransform).referent, []);
+  typeParameters(predicateOfNum.referent, []);
+  typeParameters(transformOfString.referent, []);
+  typeParameters(transformOfR.referent, []);
+  typeParameters(transformOfDouble.referent, []);
+
+  typeArguments(reflectClass(NonGenericPredicate).referent, []);
+  typeArguments(reflectClass(GenericPredicate).referent, []);
+  typeArguments(reflectClass(GenericTransform).referent, []);
+  typeArguments(predicateOfNum.referent, []);
+  typeArguments(transformOfString.referent, []);
+  typeArguments(transformOfR.referent, []);
+  typeArguments(transformOfDouble.referent, []);
+
+  // Function types are always non-generic. Only the typedef is generic.
+  Expect.isTrue(reflectClass(NonGenericPredicate).referent.isOriginalDeclaration);
+  Expect.isTrue(reflectClass(GenericPredicate).referent.isOriginalDeclaration);
+  Expect.isTrue(reflectClass(GenericTransform).referent.isOriginalDeclaration);  
+  Expect.isTrue(predicateOfNum.referent.isOriginalDeclaration);  
+  Expect.isTrue(transformOfString.referent.isOriginalDeclaration); 
+  Expect.isTrue(transformOfR.referent.isOriginalDeclaration); // Er, but here we don't have concrete types...
+  Expect.isTrue(transformOfDouble.referent.isOriginalDeclaration); 
+
+  Expect.equals(reflectClass(num),
+                reflectClass(NonGenericPredicate).referent.parameters[0].type);
+  Expect.equals(dynamicMirror,
+                reflectClass(GenericPredicate).referent.parameters[0].type);
+  Expect.equals(dynamicMirror,
+                reflectClass(GenericTransform).referent.parameters[0].type);
+  Expect.equals(reflectClass(num),
+                predicateOfNum.referent.parameters[0].type);
+  Expect.equals(reflectClass(String),
+                transformOfString.referent.parameters[0].type);
+  Expect.equals(rFromC,
+                transformOfR.referent.parameters[0].type);
+  Expect.equals(reflectClass(double),
+                transformOfDouble.referent.parameters[0].type);
+
+  Expect.equals(reflectClass(bool),
+                reflectClass(NonGenericPredicate).referent.returnType);
+  Expect.equals(reflectClass(bool),
+                reflectClass(GenericPredicate).referent.returnType);
+  Expect.equals(dynamicMirror,
+                reflectClass(GenericTransform).referent.returnType);
+  Expect.equals(reflectClass(bool),
+                predicateOfNum.referent.returnType);
+  Expect.equals(reflectClass(String),
+                transformOfString.referent.returnType);
+  Expect.equals(rFromC,
+                transformOfR.referent.returnType);
+  Expect.equals(reflectClass(double),
+                transformOfDouble.referent.returnType);
+}