Using Java Compiler Tree API to Extract Generics Types

i was looking for some way to extract information about types of elements in java collections/maps using generics (list<string>, map<string, mybean>) so that the users of the static jsf expression validator wouldn’t need to declare the type of the elements manually. one possible way to get this information is to process the source codes with the sun compiler tree api, available since jdk 6.

it might be best to go and check the resulting 263 lines of collectiongenericstypeexctractor.java now. the code is little ugly, largely due to the api being ugly.

overview

1. javacompiler (compiler api) is used to compile the source codes that should be searched for generics
2. a custom annotation provider (java annotation api) is used during the compilation to process the sources
3. the processor only delegates to a custom treepathscanner (sun compiler tree api) whose visitmethod extracts all the information from the methodtree, using some dark magic to get fully qualified type names of the class and return type

limitations

1. the compiler must be able to resolve all dependencies (imports) to be able to process the files
2. it only works with sun jdk and its tools.jar must be on the class path (the compiler and annotation apis are a part of java specification but the compiler tree api is not and is thus vendor-specific)
3. the code currently doesn’t handle getters inside nested/inner classes (it would need to check that it is such a class and replace the last . with $ in the name)

you’d better check the complete (short) code at github but if it’s too far for you , here is the crucial piece:

@override
public object visitmethod(methodtree methodtree, trees trees) {
	string typenamequalified = getenclosingclassnameifavailable(trees);

	// skip or bad stuff happens (case: inside anonymous inner class)
	if (typenamequalified == null) {
		return super.visitmethod(methodtree, trees);
	}

	tree returntype = methodtree.getreturntype();   // null for void method
	if (getter(methodtree) && returntype instanceof parameterizedtypetree) {
		assert tree.kind.parameterized_type == returntype.getkind();
		parameterizedtypetree parametrizedreturntype = (parameterizedtypetree) returntype;

		typecategory category = detecttypecategory(parametrizedreturntype);
		if (category.iscollectionormap()) {
			tree valuetypeargument = parametrizedreturntype.gettypearguments().get(category.getvaluetypeargumentidx());
			final string qualifiedgenerictypename = getqualifiedtype(valuetypeargument);

			string methodjsfname = getmethodjsfname(methodtree);
			system.out.println("found " + typenamequalified + "." + methodjsfname + ".*=" + qualifiedgenerictypename);
			// unqualified name: ((identifiertree) valuetypeargument).getname().tostring();
		}
	}
	return super.visitmethod(methodtree, trees);
}

most of the code has been copied from the article source code analysis using java 6 apis by seema richard (4/2008).

conclusion

it’s possible to use the java compiler tree api to get the desired information but it is not exactly easy because the api os overly complex and undocumented. it would likely be better to use some decent open-source java parser.

from http://theholyjava.wordpress.com/2012/02/07/using-java-compiler-tree-api-to-extract-generics-types/