/* * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package org.graalvm.compiler.core.match.processor; import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.annotation.processing.Filer; import javax.annotation.processing.RoundEnvironment; import javax.annotation.processing.SupportedAnnotationTypes; import javax.lang.model.SourceVersion; import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.Element; import javax.lang.model.element.ElementKind; import javax.lang.model.element.ExecutableElement; import javax.lang.model.element.Modifier; import javax.lang.model.element.Name; import javax.lang.model.element.PackageElement; import javax.lang.model.element.TypeElement; import javax.lang.model.element.VariableElement; import javax.lang.model.type.TypeMirror; import javax.lang.model.util.ElementFilter; import javax.lang.model.util.Types; import javax.tools.Diagnostic.Kind; import javax.tools.FileObject; import javax.tools.JavaFileObject; import javax.tools.StandardLocation; import org.graalvm.compiler.processor.AbstractProcessor; /** * Processes classes annotated with {@code MatchRule}. A {@code MatchStatementSet} service is * generated for each top level class containing at least one such field. These service objects can * be retrieved as follows: * *
 *     Iterable sl = GraalServices.load(MatchStatementSet.class);
 *     for (MatchStatementSet rules : sl) {
 *         ...
 *     }
 * 
*/ @SupportedAnnotationTypes({"org.graalvm.compiler.core.match.MatchRule", "org.graalvm.compiler.core.match.MatchRules", "org.graalvm.compiler.core.match.MatchableNode", "org.graalvm.compiler.core.match.MatchableNodes"}) public class MatchProcessor extends AbstractProcessor { private static final String VALUE_NODE_CLASS_NAME = "org.graalvm.compiler.nodes.ValueNode"; private static final String COMPLEX_MATCH_RESULT_CLASS_NAME = "org.graalvm.compiler.core.match.ComplexMatchResult"; private static final String MATCHABLE_NODES_CLASS_NAME = "org.graalvm.compiler.core.match.MatchableNodes"; private static final String MATCHABLE_NODE_CLASS_NAME = "org.graalvm.compiler.core.match.MatchableNode"; private static final String MATCH_RULE_CLASS_NAME = "org.graalvm.compiler.core.match.MatchRule"; private static final String MATCH_RULES_CLASS_NAME = "org.graalvm.compiler.core.match.MatchRules"; public MatchProcessor() { } @Override public SourceVersion getSupportedSourceVersion() { return SourceVersion.latest(); } private final Set processedMatchRules = new HashSet<>(); private final Set processedMatchableNodes = new HashSet<>(); private static class RuleParseError extends RuntimeException { private static final long serialVersionUID = 6456128283609257490L; RuleParseError(String format, Object... args) { super(String.format(format, args)); } } private static final Pattern tokenizer = Pattern.compile("\\s*([()=]|[A-Za-z][A-Za-z0-9]*)\\s*"); private class RuleParser { private ArrayList capturedTypes = new ArrayList<>(); private ArrayList capturedNames = new ArrayList<>(); private final String[] tokens; private int current; private MatchDescriptor matchDescriptor; private final Set originatingElements = new HashSet<>(); private Set requiredPackages = new HashSet<>(); RuleParser(String rule) { Matcher m = tokenizer.matcher(rule); List list = new ArrayList<>(); int end = 0; while (m.lookingAt()) { list.add(m.group(1)); end = m.end(); m.region(m.end(), m.regionEnd()); } if (end != m.regionEnd()) { throw new RuleParseError("Unexpected tokens :" + rule.substring(m.end(), m.regionEnd())); } tokens = list.toArray(new String[0]); matchDescriptor = parseExpression(); if (!done()) { throw new RuleParseError("didn't consume all tokens"); } capturedNames.add(0, "root"); capturedTypes.add(0, matchDescriptor.nodeType); } String next() { return tokens[current++]; } String peek(String name) { if (current >= tokens.length) { if (name == null) { throw new RuleParseError("Out of tokens"); } throw new RuleParseError("Out of tokens looking for %s", name); } return tokens[current]; } boolean done() { return current == tokens.length; } private MatchDescriptor parseExpression() { if (peek("(").equals("(")) { next(); MatchDescriptor descriptor = parseType(true); for (int n = 0; n < descriptor.nodeType.inputs.size(); n++) { if (peek("(").equals("(")) { descriptor.inputs[n] = parseExpression(); } else { descriptor.inputs[n] = parseType(false); } } for (int n = 0; n < descriptor.nodeType.inputs.size(); n++) { if (descriptor.inputs[n] == null) { throw new RuleParseError("not enough inputs for " + descriptor.name); } } if (peek(")").equals(")")) { next(); return descriptor; } throw new RuleParseError("Too many arguments to " + descriptor.nodeType.nodeClass); } throw new RuleParseError("Extra tokens following match pattern: " + peek(null)); } private MatchDescriptor parseType(boolean forExpression) { TypeDescriptor type = null; String name = null; if (Character.isUpperCase(peek("node type or name").charAt(0))) { String token = next(); type = knownTypes.get(token); if (type == null) { throw new RuleParseError("Unknown node type: " + token); } if (peek("=").equals("=")) { next(); name = next(); } originatingElements.addAll(type.originatingElements); } else if (Character.isLowerCase(peek("name").charAt(0))) { name = next(); type = valueType; } else { throw new RuleParseError("Unexpected token \"%s\" when looking for name or node type", peek(null)); } requiredPackages.add(type.nodePackage); if (name != null) { if (!capturedNames.contains(name)) { capturedNames.add(name); capturedTypes.add(type); } else { int index = capturedNames.indexOf(name); if (capturedTypes.get(index) != type) { throw new RuleParseError("Captured node \"%s\" has differing types", name); } } } return new MatchDescriptor(type, name, forExpression); } List generateVariants() { return matchDescriptor.generateVariants(); } /** * Recursively accumulate any required Position declarations. */ void generatePositionDeclarations(Set declarations) { matchDescriptor.generatePositionDeclarations(declarations); } /** * * @return the list of node types which are captured by name */ public ArrayList capturedTypes() { return capturedTypes; } public ArrayList capturedNames() { return capturedNames; } } /** * Set to true to enable logging during annotation processing. There's no normal channel for any * debug messages and debugging annotation processors requires some special setup. */ private static final boolean DEBUG = false; private PrintWriter log; /** * Logging facility for debugging the annotation processor. */ private PrintWriter getLog() { if (log == null) { if (processingEnv.getClass().getName().contains(".javac.")) { // For javac, just log to System.err log = new PrintWriter(System.err); } else { try { // Create the log file within the generated source directory so it's easy to // find. // /tmp isn't platform independent and java.io.tmpdir can map anywhere, // particularly // on the mac. FileObject file = processingEnv.getFiler().createResource(StandardLocation.SOURCE_OUTPUT, "", getClass().getSimpleName() + "log"); log = new PrintWriter(new FileWriter(file.toUri().getPath(), true)); } catch (IOException e) { // Do nothing } } } return log; } private void logMessage(String format, Object... args) { if (!DEBUG) { return; } PrintWriter bw = getLog(); if (bw != null) { bw.printf(format, args); bw.flush(); } } private void logException(Throwable t) { if (!DEBUG) { return; } PrintWriter bw = getLog(); if (bw != null) { t.printStackTrace(bw); bw.flush(); } } /** * Bugs in an annotation processor can cause silent failure so try to report any exception * throws as errors. */ private void reportExceptionThrow(Element element, Throwable t) { if (element != null) { logMessage("throw for %s:\n", element); } logException(t); printError(element, "Exception throw during processing: %s %s", t, Arrays.toString(Arrays.copyOf(t.getStackTrace(), 4))); } static class TypeDescriptor { final TypeMirror mirror; /** * The name uses in match expressions to refer to this type. */ final String shortName; /** * The simple name of the {@code ValueNode} class represented by this type. */ final String nodeClass; /** * The package of {@code ValueNode} class represented by this type. */ final String nodePackage; /** * The matchable inputs of the node. */ final List inputs; /** * Should swapped variants of this match be generated. The user of the match is expected to * compensate for any ordering differences in compare which are commutative but require * reinterpreting the condition in that case. */ final boolean commutative; /** * Can multiple users of this node subsume it. Constants can be swallowed into a match even * if there are multiple users. */ final boolean shareable; final Set originatingElements = new HashSet<>(); TypeDescriptor(TypeMirror mirror, String shortName, String nodeClass, String nodePackage, List inputs, boolean commutative, boolean shareable) { this.mirror = mirror; this.shortName = shortName; this.nodeClass = nodeClass; this.nodePackage = nodePackage; this.inputs = inputs; this.commutative = commutative; this.shareable = shareable; assert !commutative || inputs.size() == 2; } } /** * The types which are know for purpose of parsing MatchRule expressions. */ Map knownTypes = new HashMap<>(); private TypeDescriptor valueType; private void declareType(TypeMirror mirror, String shortName, String nodeClass, String nodePackage, List inputs, boolean commutative, boolean shareable, Element element) { TypeDescriptor descriptor = new TypeDescriptor(mirror, shortName, nodeClass, nodePackage, inputs, commutative, shareable); descriptor.originatingElements.add(element); knownTypes.put(shortName, descriptor); } private String findPackage(Element type) { PackageElement p = processingEnv.getElementUtils().getPackageOf(type); if (p != null) { return p.getQualifiedName().toString(); } throw new InternalError("Can't find package for " + type); } class MatchDescriptor { TypeDescriptor nodeType; String name; MatchDescriptor[] inputs; MatchDescriptor(TypeDescriptor nodeType, String name, boolean forExpression) { this.nodeType = nodeType; this.name = name; if (forExpression) { this.inputs = new MatchDescriptor[nodeType.inputs.size()]; } else { this.inputs = new MatchDescriptor[0]; } } public void generatePositionDeclarations(Set declarations) { if (inputs.length == 0) { return; } declarations.add(generatePositionDeclaration()); for (MatchDescriptor desc : inputs) { desc.generatePositionDeclarations(declarations); } } List recurseVariants(int index) { if (inputs.length == 0) { return new ArrayList<>(); } List currentVariants = inputs[index].generateVariants(); if (index == inputs.length - 1) { return currentVariants; } List subVariants = recurseVariants(index + 1); List result = new ArrayList<>(); for (String current : currentVariants) { for (String sub : subVariants) { result.add(current + ", " + sub); if (nodeType.commutative) { result.add(sub + ", " + current); } } } return result; } /** * Recursively generate all the variants of this rule pattern. Currently that just means to * swap the inputs for commutative rules, producing all possible permutations. * * @return a list of Strings which will construct pattern matchers for this rule. */ List generateVariants() { String prefix = formatPrefix(); String suffix = formatSuffix(); ArrayList variants = new ArrayList<>(); if (inputs.length > 0) { for (String var : recurseVariants(0)) { variants.add(prefix + ", " + var + suffix); } } else { assert inputs.length == 0; variants.add(prefix + suffix); } return variants; } private String formatPrefix() { if (nodeType == valueType) { return String.format("new MatchPattern(%s, false", name != null ? ("\"" + name + "\"") : "null"); } else { return String.format("new MatchPattern(%s.class, %s", nodeType.nodeClass, name != null ? ("\"" + name + "\"") : "null"); } } private String formatSuffix() { if (nodeType != null) { if (inputs.length != nodeType.inputs.size()) { return ", true)"; } else { if (nodeType.inputs.size() > 0) { return ", " + nodeType.nodeClass + "_positions, " + !nodeType.shareable + ")"; } if (nodeType.shareable) { return ", false)"; } } } return ")"; } String generatePositionDeclaration() { return String.format("Position[] %s_positions = MatchRuleRegistry.findPositions(%s.TYPE, new String[]{\"%s\"});", nodeType.nodeClass, nodeType.nodeClass, String.join("\", \"", nodeType.inputs)); } } /** * Strip the package off a class name leaving the full class name including any outer classes. */ private String fullClassName(Element element) { assert element.getKind() == ElementKind.CLASS || element.getKind() == ElementKind.INTERFACE : element; String pkg = findPackage(element); return ((TypeElement) element).getQualifiedName().toString().substring(pkg.length() + 1); } private void createFiles(MatchRuleDescriptor info) { String pkg = ((PackageElement) info.topDeclaringType.getEnclosingElement()).getQualifiedName().toString(); Name topDeclaringClass = info.topDeclaringType.getSimpleName(); String matchStatementClassName = topDeclaringClass + "_MatchStatementSet"; Element[] originatingElements = info.originatingElements.toArray(new Element[info.originatingElements.size()]); Types typeUtils = typeUtils(); Filer filer = processingEnv.getFiler(); try (PrintWriter out = createSourceFile(pkg, matchStatementClassName, filer, originatingElements)) { out.println("// CheckStyle: stop header check"); out.println("// CheckStyle: stop line length check"); out.println("// GENERATED CONTENT - DO NOT EDIT"); out.println("// Source: " + topDeclaringClass + ".java"); out.println("package " + pkg + ";"); out.println(""); out.println("import java.util.*;"); out.println("import org.graalvm.compiler.core.match.*;"); out.println("import org.graalvm.compiler.core.gen.NodeMatchRules;"); out.println("import org.graalvm.compiler.graph.Position;"); for (String p : info.requiredPackages) { out.println("import " + p + ".*;"); } out.println(""); out.println("public class " + matchStatementClassName + " implements MatchStatementSet {"); out.println(); // Generate declarations for the wrapper class to invoke the code generation methods. for (MethodInvokerItem invoker : info.invokers.values()) { StringBuilder args = new StringBuilder(); StringBuilder types = new StringBuilder(); int count = invoker.fields.size(); int index = 0; for (VariableElement arg : invoker.fields) { args.append('"'); args.append(arg.getSimpleName()); args.append('"'); types.append(String.format("(%s) args[%s]", fullClassName(typeUtils.asElement(arg.asType())), index++)); if (count-- > 1) { args.append(", "); types.append(", "); } } out.printf(" private static final String[] %s = new String[] {%s};\n", invoker.argumentsListName(), args); out.printf(" private static final class %s implements MatchGenerator {\n", invoker.wrapperClass()); out.printf(" static MatchGenerator instance = new %s();\n", invoker.wrapperClass()); out.printf(" @Override\n"); out.printf(" public ComplexMatchResult match(NodeMatchRules nodeMatchRules, Object...args) {\n"); out.printf(" return ((%s) nodeMatchRules).%s(%s);\n", invoker.nodeLIRBuilderClass, invoker.methodName, types); out.printf(" }\n"); out.printf(" @Override\n"); out.printf(" public String getName() {\n"); out.printf(" return \"%s\";\n", invoker.methodName); out.printf(" }\n"); out.printf(" }\n"); out.println(); } String desc = "MatchStatement"; out.println(" @Override"); out.println(" public Class forClass() {"); out.println(" return " + topDeclaringClass + ".class;"); out.println(" }"); out.println(); out.println(" @Override"); out.println(" public List<" + desc + "> statements() {"); out.println(" // Checkstyle: stop "); for (String positionDeclaration : info.positionDeclarations) { out.println(" " + positionDeclaration); } out.println(); out.println(" List<" + desc + "> statements = Collections.unmodifiableList(Arrays.asList("); int i = 0; for (MatchRuleItem matchRule : info.matchRules) { String comma = i == info.matchRules.size() - 1 ? "" : ","; out.printf(" %s%s\n", matchRule.ruleBuilder(), comma); i++; } out.println(" ));"); out.println(" // Checkstyle: resume"); out.println(" return statements;"); out.println(" }"); out.println(); out.println("}"); } this.createProviderFile(pkg + "." + matchStatementClassName, "org.graalvm.compiler.core.match.MatchStatementSet", originatingElements); } protected PrintWriter createSourceFile(String pkg, String relativeName, Filer filer, Element... originatingElements) { try { // Ensure Unix line endings to comply with Graal code style guide checked by Checkstyle JavaFileObject sourceFile = filer.createSourceFile(pkg + "." + relativeName, originatingElements); return new PrintWriter(sourceFile.openWriter()) { @Override public void println() { print("\n"); } }; } catch (IOException e) { throw new RuntimeException(e); } } /** * Used to generate the MatchStatement constructor invocation. */ static class MatchRuleItem { private final String matchPattern; private final MethodInvokerItem invoker; MatchRuleItem(String matchPattern, MethodInvokerItem invoker) { this.matchPattern = matchPattern; this.invoker = invoker; } /** * @return a string which will construct the MatchStatement instance to match this pattern. */ public String ruleBuilder() { return String.format("new MatchStatement(\"%s\", %s, %s.instance, %s)", invoker.methodName, matchPattern, invoker.wrapperClass(), invoker.argumentsListName()); } } /** * Used to generate the wrapper class to invoke the code generation method. */ static class MethodInvokerItem { final String methodName; final String nodeLIRBuilderClass; final ExecutableElement method; final List fields; MethodInvokerItem(String methodName, String nodeLIRBuilderClass, ExecutableElement method, List fields) { this.methodName = methodName; this.nodeLIRBuilderClass = nodeLIRBuilderClass; this.method = method; this.fields = fields; } String wrapperClass() { return "MatchGenerator_" + methodName; } String argumentsListName() { return methodName + "_arguments"; } } static class MatchRuleDescriptor { final TypeElement topDeclaringType; final List matchRules = new ArrayList<>(); private final Set originatingElements = new HashSet<>(); public Set positionDeclarations = new HashSet<>(); /** * The mapping between elements with MatchRules and the wrapper class used invoke the code * generation after the match. */ Map invokers = new HashMap<>(); /** * The set of packages which must be imported to refer the classes mentioned in matchRules. */ Set requiredPackages = new HashSet<>(); MatchRuleDescriptor(TypeElement topDeclaringType) { this.topDeclaringType = topDeclaringType; } } private static TypeElement topDeclaringType(Element element) { Element enclosing = element.getEnclosingElement(); if (enclosing == null || enclosing.getKind() == ElementKind.PACKAGE) { assert element.getKind() == ElementKind.CLASS || element.getKind() == ElementKind.INTERFACE; return (TypeElement) element; } return topDeclaringType(enclosing); } /** * The element currently being processed. */ private Element currentElement; /** * The current processing round. */ private RoundEnvironment currentRound; @Override public boolean doProcess(Set annotations, RoundEnvironment roundEnv) { if (roundEnv.processingOver()) { return true; } logMessage("Starting round %s\n", roundEnv); TypeElement matchRulesTypeElement = getTypeElement(MATCH_RULES_CLASS_NAME); TypeElement matchRuleTypeElement = getTypeElement(MATCH_RULE_CLASS_NAME); TypeMirror matchRulesTypeMirror = matchRulesTypeElement.asType(); TypeMirror matchRuleTypeMirror = matchRuleTypeElement.asType(); TypeElement matchableNodeTypeElement = getTypeElement(MATCHABLE_NODE_CLASS_NAME); TypeElement matchableNodesTypeElement = getTypeElement(MATCHABLE_NODES_CLASS_NAME); currentRound = roundEnv; try { for (Element element : roundEnv.getElementsAnnotatedWith(matchableNodeTypeElement)) { currentElement = element; logMessage("%s\n", element); processMatchableNodes(element); } for (Element element : roundEnv.getElementsAnnotatedWith(matchableNodesTypeElement)) { currentElement = element; logMessage("%s\n", element); processMatchableNodes(element); } // Define a TypeDescriptor for the generic node but don't enter it into the nodeTypes // table since it shouldn't be mentioned in match rules. TypeMirror valueTypeMirror = getTypeElement(VALUE_NODE_CLASS_NAME).asType(); valueType = new TypeDescriptor(valueTypeMirror, "Value", "ValueNode", "org.graalvm.compiler.nodes", Collections.emptyList(), false, false); Map map = new HashMap<>(); for (Element element : roundEnv.getElementsAnnotatedWith(matchRuleTypeElement)) { currentElement = element; AnnotationMirror matchRule = getAnnotation(element, matchRuleTypeMirror); List matchRuleAnnotations = Collections.singletonList(matchRule); processMatchRules(map, element, matchRuleAnnotations); } for (Element element : roundEnv.getElementsAnnotatedWith(matchRulesTypeElement)) { currentElement = element; AnnotationMirror matchRules = getAnnotation(element, matchRulesTypeMirror); List matchRuleAnnotations = getAnnotationValueList(matchRules, "value", AnnotationMirror.class); processMatchRules(map, element, matchRuleAnnotations); } currentElement = null; for (MatchRuleDescriptor info : map.values()) { createFiles(info); } } catch (Throwable t) { reportExceptionThrow(currentElement, t); } finally { currentElement = null; currentRound = null; } return true; } /** * Build up the type table to be used during parsing of the MatchRule. */ private void processMatchableNodes(Element element) { if (!processedMatchableNodes.contains(element)) { try { processedMatchableNodes.add(element); List matchableNodeAnnotations; AnnotationMirror mirror = getAnnotation(element, getType(MATCHABLE_NODES_CLASS_NAME)); if (mirror != null) { matchableNodeAnnotations = getAnnotationValueList(mirror, "value", AnnotationMirror.class); } else { mirror = getAnnotation(element, getType(MATCHABLE_NODES_CLASS_NAME)); if (mirror != null) { matchableNodeAnnotations = Collections.singletonList(mirror); } else { return; } } TypeElement topDeclaringType = topDeclaringType(element); for (AnnotationMirror matchableNode : matchableNodeAnnotations) { processMatchableNode(element, topDeclaringType, matchableNode); } } catch (Throwable t) { reportExceptionThrow(element, t); } } } private void processMatchableNode(Element element, TypeElement topDeclaringType, AnnotationMirror matchable) { logMessage("processMatchableNode %s %s %s\n", topDeclaringType, element, matchable); String nodeClass; String nodePackage; TypeMirror nodeClassMirror = getAnnotationValue(matchable, "nodeClass", TypeMirror.class); if (nodeClassMirror == null) { throw new InternalError("Can't get mirror for node class " + element); } if (nodeClassMirror.toString().equals(MATCHABLE_NODE_CLASS_NAME)) { nodeClass = topDeclaringType.getQualifiedName().toString(); } else { nodeClass = nodeClassMirror.toString(); } TypeElement typeElement = processingEnv.getElementUtils().getTypeElement(nodeClass); if (typeElement == null) { printError(element, matchable, "Class \"%s\" cannot be resolved to a type", nodeClass); return; } nodePackage = findPackage(typeElement); assert nodeClass.startsWith(nodePackage); nodeClass = nodeClass.substring(nodePackage.length() + 1); assert nodeClass.endsWith("Node"); String shortName = nodeClass.substring(0, nodeClass.length() - 4); Types typeUtils = processingEnv.getTypeUtils(); TypeElement nodeClassElement = (TypeElement) typeUtils.asElement(nodeClassMirror); List inputs = getAnnotationValueList(matchable, "inputs", String.class); for (String input : inputs) { boolean ok = false; TypeElement current = nodeClassElement; while (!ok && current != null) { for (Element fieldElement : ElementFilter.fieldsIn(current.getEnclosedElements())) { if (fieldElement.getSimpleName().toString().equals(input)) { ok = true; break; } } TypeMirror theSuper = current.getSuperclass(); current = (TypeElement) typeUtils.asElement(theSuper); } if (!ok) { printError(element, matchable, "Input named \"%s\" doesn't exist in %s", input, nodeClassElement.getSimpleName()); } } boolean commutative = getAnnotationValue(matchable, "commutative", Boolean.class); boolean shareable = getAnnotationValue(matchable, "shareable", Boolean.class); declareType(nodeClassMirror, shortName, nodeClass, nodePackage, inputs, commutative, shareable, element); } private void processMatchRules(Map map, Element element, List matchRules) { if (!processedMatchRules.contains(element)) { try { processedMatchRules.add(element); // The annotation element type should ensure this is true. assert element instanceof ExecutableElement; findMatchableNodes(element); TypeElement topDeclaringType = topDeclaringType(element); MatchRuleDescriptor info = map.get(topDeclaringType); if (info == null) { info = new MatchRuleDescriptor(topDeclaringType); map.put(topDeclaringType, info); } for (AnnotationMirror matchRule : matchRules) { processMatchRule((ExecutableElement) element, info, matchRule); } } catch (Throwable t) { reportExceptionThrow(element, t); } } } /** * Search the super types of element for MatchableNode definitions. Any superclass or super * interface can contain definitions of matchable nodes. * * @param element */ private void findMatchableNodes(Element element) { processMatchableNodes(element); Element enclosing = element.getEnclosingElement(); while (enclosing != null) { if (enclosing.getKind() == ElementKind.CLASS || enclosing.getKind() == ElementKind.INTERFACE) { TypeElement current = (TypeElement) enclosing; while (current != null) { processMatchableNodes(current); for (TypeMirror intf : current.getInterfaces()) { Element interfaceElement = typeUtils().asElement(intf); processMatchableNodes(interfaceElement); // Recurse findMatchableNodes(interfaceElement); } TypeMirror theSuper = current.getSuperclass(); current = (TypeElement) typeUtils().asElement(theSuper); } } enclosing = enclosing.getEnclosingElement(); } } private Types typeUtils() { return processingEnv.getTypeUtils(); } private void processMatchRule(ExecutableElement method, MatchRuleDescriptor info, AnnotationMirror matchRule) { logMessage("processMatchRule %s\n", method); Types typeUtils = typeUtils(); if (!method.getModifiers().contains(Modifier.PUBLIC)) { printError(method, "MatchRule method %s must be public", method.getSimpleName()); return; } if (method.getModifiers().contains(Modifier.STATIC)) { printError(method, "MatchRule method %s must be non-static", method.getSimpleName()); return; } try { TypeMirror returnType = method.getReturnType(); if (!typeUtils.isSameType(returnType, processingEnv.getElementUtils().getTypeElement(COMPLEX_MATCH_RESULT_CLASS_NAME).asType())) { printError(method, "MatchRule method return type must be %s", COMPLEX_MATCH_RESULT_CLASS_NAME); return; } String rule = getAnnotationValue(matchRule, "value", String.class); RuleParser parser = new RuleParser(rule); ArrayList expectedTypes = parser.capturedTypes(); ArrayList expectedNames = parser.capturedNames(); List actualParameters = method.getParameters(); if (expectedTypes.size() + 1 < actualParameters.size()) { printError(method, "Too many arguments for match method %s != %s", expectedTypes.size() + 1, actualParameters.size()); return; } // Walk through the parameters to the method and see if they exist in the match rule. // The order doesn't matter but only names mentioned in the rule can be used and they // must be assignment compatible. for (VariableElement parameter : actualParameters) { String name = parameter.getSimpleName().toString(); int nameIndex = expectedNames.indexOf(name); if (nameIndex == -1) { printError(method, "Argument \"%s\" isn't captured in the match rule", name); return; } TypeMirror type = parameter.asType(); if (!typeUtils.isAssignable(expectedTypes.get(nameIndex).mirror, type)) { printError(method, "Captured value \"%s\" of type %s is not assignable to argument of type %s", name, expectedTypes.get(nameIndex).mirror, type); return; } } String methodName = method.getSimpleName().toString(); MethodInvokerItem invoker = info.invokers.get(methodName); if (invoker == null) { invoker = new MethodInvokerItem(methodName, topDeclaringType(method).getSimpleName().toString(), method, actualParameters); info.invokers.put(methodName, invoker); } else if (invoker.method != method) { // This could be supported but it's easier if they are unique since the names // are used in log output and snippet counters. printError(method, "Use unique method names for match methods: %s.%s != %s.%s", method.getReceiverType(), method.getSimpleName(), invoker.method.getReceiverType(), invoker.method.getSimpleName()); return; } Element enclosing = method.getEnclosingElement(); String declaringClass = ""; String separator = ""; Set originatingElementsList = info.originatingElements; originatingElementsList.add(method); while (enclosing != null) { if (enclosing.getKind() == ElementKind.CLASS || enclosing.getKind() == ElementKind.INTERFACE) { if (enclosing.getModifiers().contains(Modifier.PRIVATE)) { printError(method, "MatchRule cannot be declared in a private %s %s", enclosing.getKind().name().toLowerCase(), enclosing); return; } originatingElementsList.add(enclosing); declaringClass = enclosing.getSimpleName() + separator + declaringClass; separator = "."; } else { assert enclosing.getKind() == ElementKind.PACKAGE; } enclosing = enclosing.getEnclosingElement(); } originatingElementsList.addAll(parser.originatingElements); info.requiredPackages.addAll(parser.requiredPackages); // Accumulate any position declarations. parser.generatePositionDeclarations(info.positionDeclarations); List matches = parser.generateVariants(); for (String match : matches) { info.matchRules.add(new MatchRuleItem(match, invoker)); } } catch (RuleParseError e) { printError(method, matchRule, e.getMessage()); } } private Element elementForMessage(Element e) { if (currentRound != null && !currentRound.getRootElements().contains(e) && currentElement != null) { return currentElement; } return e; } private void printError(Element annotatedElement, String format, Object... args) { Element e = elementForMessage(annotatedElement); String prefix = e == annotatedElement ? "" : annotatedElement + ": "; processingEnv.getMessager().printMessage(Kind.ERROR, prefix + String.format(format, args), e); } private void printError(Element annotatedElement, AnnotationMirror annotation, String format, Object... args) { Element e = elementForMessage(annotatedElement); String prefix = e == annotatedElement ? "" : annotation + " on " + annotatedElement + ": "; processingEnv.getMessager().printMessage(Kind.ERROR, prefix + String.format(format, args), e, annotation); } }