src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.core.match.processor/src/org/graalvm/compiler/core/match/processor/MatchProcessor.java

*** 25,40 ****
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.util.ArrayList;
  import java.util.Arrays;
- import java.util.HashMap;
  import java.util.HashSet;
- import java.util.LinkedHashMap;
- import java.util.LinkedHashSet;
  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.AbstractProcessor;
--- 25,36 ----
*** 72,81 ****
--- 68,80 ----
  import org.graalvm.compiler.core.match.MatchableNodes;
  import org.graalvm.compiler.debug.GraalError;
  import org.graalvm.compiler.graph.Position;
  import org.graalvm.compiler.nodes.ValueNode;
  import org.graalvm.compiler.serviceprovider.ServiceProvider;
+ import org.graalvm.util.Equivalence;
+ import org.graalvm.util.EconomicMap;
+ import org.graalvm.util.EconomicSet;
  
  /**
   * Processes classes annotated with {@link MatchRule}. A {@link MatchStatementSet} service is
   * generated for each top level class containing at least one such field. These service objects can
   * be retrieved as follows:
*** 204,220 ****
                  if (peek("=").equals("=")) {
                      next();
                      name = next();
                  }
                  originatingElements.addAll(type.originatingElements);
-                 requiredPackages.add(type.nodePackage);
              } 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));
              }
              if (name != null) {
                  if (!capturedNames.contains(name)) {
                      capturedNames.add(name);
                      capturedTypes.add(type);
                  } else {
--- 203,219 ----
                  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 {
*** 232,242 ****
          }
  
          /**
           * Recursively accumulate any required Position declarations.
           */
!         void generatePositionDeclarations(Set<String> declarations) {
              matchDescriptor.generatePositionDeclarations(declarations);
          }
  
          /**
           *
--- 231,241 ----
          }
  
          /**
           * Recursively accumulate any required Position declarations.
           */
!         void generatePositionDeclarations(EconomicSet<String> declarations) {
              matchDescriptor.generatePositionDeclarations(declarations);
          }
  
          /**
           *
*** 364,374 ****
      }
  
      /**
       * The types which are know for purpose of parsing MatchRule expressions.
       */
!     Map<String, TypeDescriptor> knownTypes = new HashMap<>();
  
      private TypeDescriptor valueType;
  
      private TypeMirror matchRulesTypeMirror;
  
--- 363,373 ----
      }
  
      /**
       * The types which are know for purpose of parsing MatchRule expressions.
       */
!     EconomicMap<String, TypeDescriptor> knownTypes = EconomicMap.create(Equivalence.DEFAULT);
  
      private TypeDescriptor valueType;
  
      private TypeMirror matchRulesTypeMirror;
  
*** 405,415 ****
              } else {
                  this.inputs = new MatchDescriptor[0];
              }
          }
  
!         public void generatePositionDeclarations(Set<String> declarations) {
              if (inputs.length == 0) {
                  return;
              }
              declarations.add(generatePositionDeclaration());
              for (MatchDescriptor desc : inputs) {
--- 404,414 ----
              } else {
                  this.inputs = new MatchDescriptor[0];
              }
          }
  
!         public void generatePositionDeclarations(EconomicSet<String> declarations) {
              if (inputs.length == 0) {
                  return;
              }
              declarations.add(generatePositionDeclaration());
              for (MatchDescriptor desc : inputs) {
*** 530,540 ****
              out.println("public class " + matchStatementClassName + " implements " + MatchStatementSet.class.getSimpleName() + " {");
  
              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) {
--- 529,539 ----
              out.println("public class " + matchStatementClassName + " implements " + MatchStatementSet.class.getSimpleName() + " {");
  
              out.println();
  
              // Generate declarations for the wrapper class to invoke the code generation methods.
!             for (MethodInvokerItem invoker : info.invokers.getValues()) {
                  StringBuilder args = new StringBuilder();
                  StringBuilder types = new StringBuilder();
                  int count = invoker.fields.size();
                  int index = 0;
                  for (VariableElement arg : invoker.fields) {
*** 661,678 ****
  
      static class MatchRuleDescriptor {
  
          final TypeElement topDeclaringType;
          final List<MatchRuleItem> matchRules = new ArrayList<>();
!         private final Set<Element> originatingElements = new HashSet<>();
!         public Set<String> positionDeclarations = new LinkedHashSet<>();
  
          /**
           * The mapping between elements with MatchRules and the wrapper class used invoke the code
           * generation after the match.
           */
!         Map<String, MethodInvokerItem> invokers = new LinkedHashMap<>();
  
          /**
           * The set of packages which must be imported to refer the classes mention in matchRules.
           */
          Set<String> requiredPackages = new HashSet<>();
--- 660,677 ----
  
      static class MatchRuleDescriptor {
  
          final TypeElement topDeclaringType;
          final List<MatchRuleItem> matchRules = new ArrayList<>();
!         private final EconomicSet<Element> originatingElements = EconomicSet.create(Equivalence.DEFAULT);
!         public EconomicSet<String> positionDeclarations = EconomicSet.create(Equivalence.DEFAULT);
  
          /**
           * The mapping between elements with MatchRules and the wrapper class used invoke the code
           * generation after the match.
           */
!         EconomicMap<String, MethodInvokerItem> invokers = EconomicMap.create(Equivalence.DEFAULT);
  
          /**
           * The set of packages which must be imported to refer the classes mention in matchRules.
           */
          Set<String> requiredPackages = new HashSet<>();
*** 726,736 ****
              // 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 = processingEnv.getElementUtils().getTypeElement(ValueNode.class.getName()).asType();
              valueType = new TypeDescriptor(valueTypeMirror, "Value", ValueNode.class.getSimpleName(), ValueNode.class.getPackage().getName(), new String[0], false, false);
  
!             Map<TypeElement, MatchRuleDescriptor> map = new LinkedHashMap<>();
  
              for (Element element : roundEnv.getElementsAnnotatedWith(MatchRule.class)) {
                  currentElement = element;
                  processMatchRule(map, element, findAnnotationMirror(element, matchRuleTypeMirror));
              }
--- 725,735 ----
              // 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 = processingEnv.getElementUtils().getTypeElement(ValueNode.class.getName()).asType();
              valueType = new TypeDescriptor(valueTypeMirror, "Value", ValueNode.class.getSimpleName(), ValueNode.class.getPackage().getName(), new String[0], false, false);
  
!             EconomicMap<TypeElement, MatchRuleDescriptor> map = EconomicMap.create(Equivalence.DEFAULT);
  
              for (Element element : roundEnv.getElementsAnnotatedWith(MatchRule.class)) {
                  currentElement = element;
                  processMatchRule(map, element, findAnnotationMirror(element, matchRuleTypeMirror));
              }
*** 738,748 ****
                  currentElement = element;
                  processMatchRule(map, element, findAnnotationMirror(element, matchRulesTypeMirror));
              }
  
              currentElement = null;
!             for (MatchRuleDescriptor info : map.values()) {
                  createFiles(info);
              }
  
          } catch (Throwable t) {
              reportExceptionThrow(currentElement, t);
--- 737,747 ----
                  currentElement = element;
                  processMatchRule(map, element, findAnnotationMirror(element, matchRulesTypeMirror));
              }
  
              currentElement = null;
!             for (MatchRuleDescriptor info : map.getValues()) {
                  createFiles(info);
              }
  
          } catch (Throwable t) {
              reportExceptionThrow(currentElement, t);
*** 832,842 ****
          }
  
          declareType(nodeClassMirror, shortName, nodeClass, nodePackage, matchable.inputs(), matchable.commutative(), matchable.shareable(), element);
      }
  
!     private void processMatchRule(Map<TypeElement, MatchRuleDescriptor> map, Element element, AnnotationMirror mirror) {
          if (!processedMatchRule.contains(element)) {
              try {
                  processedMatchRule.add(element);
  
                  // The annotation element type should ensure this is true.
--- 831,841 ----
          }
  
          declareType(nodeClassMirror, shortName, nodeClass, nodePackage, matchable.inputs(), matchable.commutative(), matchable.shareable(), element);
      }
  
!     private void processMatchRule(EconomicMap<TypeElement, MatchRuleDescriptor> map, Element element, AnnotationMirror mirror) {
          if (!processedMatchRule.contains(element)) {
              try {
                  processedMatchRule.add(element);
  
                  // The annotation element type should ensure this is true.
*** 959,969 ****
              }
  
              Element enclosing = method.getEnclosingElement();
              String declaringClass = "";
              String separator = "";
!             Set<Element> originatingElementsList = info.originatingElements;
              originatingElementsList.add(method);
              while (enclosing != null) {
                  if (enclosing.getKind() == ElementKind.CLASS || enclosing.getKind() == ElementKind.INTERFACE) {
                      if (enclosing.getModifiers().contains(Modifier.PRIVATE)) {
                          errorMessage(method, "MatchRule cannot be declared in a private %s %s", enclosing.getKind().name().toLowerCase(), enclosing);
--- 958,968 ----
              }
  
              Element enclosing = method.getEnclosingElement();
              String declaringClass = "";
              String separator = "";
!             EconomicSet<Element> originatingElementsList = info.originatingElements;
              originatingElementsList.add(method);
              while (enclosing != null) {
                  if (enclosing.getKind() == ElementKind.CLASS || enclosing.getKind() == ElementKind.INTERFACE) {
                      if (enclosing.getModifiers().contains(Modifier.PRIVATE)) {
                          errorMessage(method, "MatchRule cannot be declared in a private %s %s", enclosing.getKind().name().toLowerCase(), enclosing);