A question to those who are interested in multiple round processing, and are using auto/common BasicAnnotationProcessor for multiple round in Java:
In auto/common on each round BasicAnnotationProcessor will do a traverse on the input elements and defer any invalid elements (found with Error) to next round. The logic for determining if an element is valid or not is an extensive look into the elements’ enclosed scope and check if types can be resolved. It looks to me that at least some of the checks are not necessary depending on the use case. For example, inner class vs nested class (nested class and static nested class in Java), an annotation processor might not be interested in nested class since it does not have a pointer to its enclosing class, and its enclosing class served merely as a namespace, in that case it make sense to skip checking such symbol for validating, given kotlin type resolution can be expensive. I am thinking about providing a similar validation API, but with more flexibility to reduce searching amount and therefore provide best performance, wonder if you will be interested in implementing such flexible search on your side as well?