This is in the package java.lang.reflect (comments have been edited out):

public interface TypeVariable<D extends GenericDeclaration> extends Type {
    Type[] getBounds();
    D getGenericDeclaration();
    String getName();
}

Why is this curious? A generic parameter "erases to its first bound," which means that the compiler effectively replaces the parameter with its first bound. In this case, that bound is simply GenericDeclaration.

But if you look at the code, you'll see that there is no need for generics to be used here. You can just say that the return type of getGenericDeclaration() is GenericDeclaration, and skip the use of generics. So I think it should look like this, instead:

public interface TypeVariable extends Type {
    Type[] getBounds();
    GenericDeclaration getGenericDeclaration();
    String getName();
}

That's my take on it, anyway. Perhaps you can see something that I havent.

Here is the Python program I used to hunt for generic declarations. It has a serious flaw in that it will only find such declarations where a '<' and '>' appear on the same line (I know it's possible to write a regular expression that deals with all the possibilities of multiple lines and nested angle brackets, but I just wanted to do a quick scan, and regular expressions like that hurt my brain. Please feel free to suggest a correction).

The program attempts to remove any generic argument list that looks "complex enough to be justified," and just tries to find the ones that might be "too simple."

'''Searches through standard Java source code files'''
# Uses Python 2.4
import os, re

src = r"C:\ProgTools\Java\src" # Your Java source directory
output = file("GenericArgumentLists.txt", 'w')

# Limit: only matches when they're all on one line:
genericArglist = re.compile('<.*?>')

# Walk the directory tree looking for appropriate Java files
for javaFile in (os.path.join(root, name)
        for root, dirs, files in os.walk(src)
        for name in files if name.endswith(".java")):
    lines = file(javaFile).readlines()
    for index, line in enumerate(lines):
        methodArgs = genericArglist.search(line)
        if methodArgs:
            match = methodArgs.group(0)
            if match.find("?") == -1 \
            and match.find("extends") != -1 \
            and line.find("Class<") == -1 \
            and match[1:].find("<") == -1:
                print>>output, javaFile, "(" + str(index) + "):\n\t", line.rstrip()

interface GenericDeclaration { TypeVariable<?>[] getTypeParameters(); }

class Method { public TypeVariable<Method>[] getTypeParameters(); }

package findgenerics; // Finds generic declarations but ignores generic useage, comments, etc.
 
import java.io.*;
import static java.io.StreamTokenizer.*;
import static java.lang.System.*;
import java.util.StringTokenizer;
 
public class Main {
    private static final String input =           // test input
            // should be found
            "class Foo< T1 > { ... }\n" +         // standard class
            "interface Foo\n< T2\n>\n{ ... }" +   // interface with line break
            "class Foo< /* comment1 */ T3 // comment2\n> { ... }\n" + // class with comments
            "{\n< T4 > void bar() { ... }\n" +    // genetic method first thing in body
            ";\n< T5 > void bar() { ... }\n" +    // genetic method following a field etc.
            "}\n< T6 > void bar() { ... }\n" +    // genetic method following another method etc.
            "class Foo< T7 extends Comparable< Foo > > { ... }\n" + // embedded generic
            // shouldn't be found
            "\"class Foo< T8 > { ... }\"\n" +     // string
            "if ( x < T9 ) { ... }\n" +           // if with <
            "new List< T10 >() { ... }\n" +       // generic inner class (usage)
            "List< T11 > l = new ArrayList< T11 >() {};\n" + // use of generics (difficult case!)
            "class Foo { ... }";                  // no generics
    private static final StreamTokenizer st = new StreamTokenizer( new StringReader( input ) ); // tokenize the input
    private static boolean isPossibleGeneric = false; // start of generic declaration possibly found
    private static boolean braceFound = false;    // the < of the generic is found
    private static StringBuffer generic = null;   // the possible generic declaration for printing
    
    public static void main( final String[] notUsed ) throws IOException {
        st.resetSyntax();                         // start of setup of parser
        st.whitespaceChars( '\u0000', '\u0020' ); // normal def. of whitespace
        st.wordChars( '\u0020', '\u00FF' );       // make every other char a word - i.e. no chars are significant for parsing!
        st.slashSlashComments( true );            // ignore // comments
        st.slashStarComments( true );             // ignore /* comments
        st.quoteChar( '\'' );                     // ignore things between 's - probably doesn't matter!
        st.quoteChar( '"' );                      // ignore things between "s
        st.eolIsSignificant( true );              // seperate line breaks - helps to display // comments
        st.ordinaryChar( '<' );                   // break input at < - significant characters
        st.ordinaryChar( '}' );                   // break input at }
        st.ordinaryChar( '{' );                   // break input at {
        st.ordinaryChar( ';' );                   // break input at ;
        while ( st.nextToken() != TT_EOF ) {
            // out.println( st + ", isPossibleGeneric = " + isPossibleGeneric + ", braceFound = " + braceFound );
            switch ( st.ttype ) {
                case TT_WORD:
                    if ( st.sval.startsWith( "class" ) || st.sval.startsWith( "interface" ) ) start(); // start of a new possible generic
                    else if ( isPossibleGeneric ) generic.append( st.sval ); // make the posssible generic
                    break;                        // not inside a possible generic
                case '<':
                    if ( isPossibleGeneric ) {
                        generic.append( '<' );    // make the posssible generic
                        braceFound = true;
                    }
                    break;                        // not inside a possible generic
                case TT_EOL:
                    if ( isPossibleGeneric ) generic.append( '\n' ); // make the posssible generic
                    break;                        // not inside a possible generic
                case '\'':
                    isPossibleGeneric = false;    // reset - generics can't contain char constants
                    break;
                case '"':
                    isPossibleGeneric = false;    // reset - generics can't contain string constants
                    break;
                case '{':
                    if ( isPossibleGeneric && braceFound ) { // generic possibly found
                        newCheck: {               // check if a 'new' keyword is present
                            final String gs = generic.toString().trim();
                            for ( final StringTokenizer nc = new StringTokenizer( gs, " \t\n\r\f};=" ); nc.hasMoreElements(); )
                                if ( nc.nextToken().equals( "new" ) ) break newCheck;
                            out.println( "line " + st.lineno() + ": " + gs ); // print the generic
                            isPossibleGeneric = false; // reset for next generic
                        }
                    } else startNoKeyword();      // start of a new possible generic - generic method as 1st method in class
                    break;
                case '}':
                    startNoKeyword();             // start of a new possible generic - generic method following another method etc.
                    break;
                case ';':
                    startNoKeyword();             // start of a new possible generic - generic method following a field etc.
                    break;
                default:
                    throw new IllegalStateException( "Parsing error: " + st );
            }
        }
    }
    
    private static void start() { // start of possible new generic that is introduced by a keyword
        isPossibleGeneric = true;
        braceFound = false;
        generic = new StringBuffer( st.sval );
    }
    
    private static void startNoKeyword() { // start of possible new generic with no intro. keyword
        st.sval = "";
        start();
    }
}

line 1: class Foo<T1 >
line 5: interface Foo
<T2
>
line 6: class Foo</* comment1 */ T3 // comment2
>
line 8: <T4 > void bar()
line 10: <T5 > void bar()
line 12: <T6 > void bar()
line 13: class Foo<T7 extends Comparable<Foo > >