JavaTemplate matching on parameterized types

[jkschneider]

Adding support for parameterized types in the grammar of the template parser and for matching as performed by JavaTemplate#matches().

[knutwannheden]

I think now it is basically working. I had to change the internal representation we use for template parameters to use a JavaType rather than a plain String for the parameter type, otherwise we can't match parameterized types.

In this area there is still some performance improvements that can be made: We should change the JavaTemplate#matcher() instance method so that it caches the matcher in a precompiled form (like Pattern#compile() basically). That would then end up caching the template parameters we create in JavaTemplateSemanticallyEqual#createTemplateParameters():

rewrite/rewrite-java/src/main/java/org/openrewrite/java/JavaTemplateSemanticallyEqual.java

Lines 65 to 124 in 6acddbf

	private static J[] createTemplateParameters(String code) {
	PropertyPlaceholderHelper propertyPlaceholderHelper = new PropertyPlaceholderHelper(
	"#{", "}", null);
	List<J> parameters = new ArrayList<>();
	String substituted = code;
	Map<String, String> typedPatternByName = new HashMap<>();
	while (true) {
	String previous = substituted;
	substituted = propertyPlaceholderHelper.replacePlaceholders(substituted, key -> {
	String s;
	if (!key.isEmpty()) {
	TemplateParameterParser parser = new TemplateParameterParser(new CommonTokenStream(new TemplateParameterLexer(
	CharStreams.fromString(key))));
	parser.removeErrorListeners();
	parser.addErrorListener(new BaseErrorListener() {
	@Override
	public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol,
	int line, int charPositionInLine, String msg, RecognitionException e) {
	throw new IllegalArgumentException(
	String.format("Syntax error at line %d:%d %s.", line, charPositionInLine, msg), e);
	}
	});
	TemplateParameterParser.MatcherPatternContext ctx = parser.matcherPattern();
	if (ctx.typedPattern() == null) {
	String paramName = ctx.parameterName().Identifier().getText();
	s = typedPatternByName.get(paramName);
	if (s == null) {
	throw new IllegalArgumentException("The parameter " + paramName + " must be defined before it is referenced.");
	}
	} else {
	TypedPatternContext typedPattern = ctx.typedPattern();
	JavaType type = typedParameter(key, typedPattern);
	s = TypeUtils.toString(type);
	String name = null;
	if (typedPattern.parameterName() != null) {
	name = typedPattern.parameterName().Identifier().getText();
	typedPatternByName.put(name, s);
	}
	Markers markers = Markers.build(Collections.singleton(new TemplateParameter(randomId(), type, name)));
	parameters.add(new J.Empty(randomId(), Space.EMPTY, markers));
	}
	} else {
	throw new IllegalArgumentException("Only typed placeholders are allowed.");
	}
	return s;
	});
	if (previous.equals(substituted)) {
	break;
	}
	}
	return parameters.toArray(new J[0]);
	}

But I will leave this optimization for another PR.

Further, I am quite sure there are still bugs in the area of TypeUtils#isAssignableTo() (which has grown very organically), but also that I will leave for another day.

[knutwannheden]

LGTM.