docs: private static TypeQualifierAnnotation computeEffectiveTypeQualifierAnnotation(TypeQualifierValue<?> typeQualifierValue,
              XMethod xmethod, int parameter) {
          if (DEBUG) {
              // System.out.println("XX: "
              // +System.identityHashCode(typeQualifierValue));
              if (typeQualifierValue.value != null) {
                  System.out.println("  Value is " + typeQualifierValue.value + "("
                          + typeQualifierValue.value.getClass().toString() + ")");
              }
          }
          Map<TypeQualifierValue<?>, DualKeyHashMap<XMethod, Integer, TypeQualifierAnnotation>> effectiveParameterAnnotations = getEffectiveParameterAnnotations();
          DualKeyHashMap<XMethod, Integer, TypeQualifierAnnotation> map = effectiveParameterAnnotations.get(typeQualifierValue);
          if (map == null) {
              if (DEBUG) {
                  System.out.println("computeEffectiveTypeQualifierAnnotation: Creating map for " + typeQualifierValue);
              }
              map = new DualKeyHashMap<>();
              effectiveParameterAnnotations.put(typeQualifierValue, map);
          }
  
          // Check cached answer
          TypeQualifierAnnotation result;
          if (map.containsKey(xmethod, parameter)) {
              result = map.get(xmethod, parameter);
          } else {
              if (DEBUG) {
                  System.out.println("Looking up application of " + typeQualifierValue + " on " + xmethod + " parameter "
                          + parameter);
              }
  
              // String desc =
              // xmethod.toString()+":"+parameter+":"+typeQualifierValue;
              // if (checked.containsKey(desc)) {
              // //throw new IllegalStateException("Repeating computation of " +
              // desc, checked.get(desc));
              // System.out.println("Repeating computation of " + desc);
              // System.out.println("Previously computed:");
              // checked.get(desc).printStackTrace(System.out);
              // throw new IllegalStateException();
              // }
              // checked.put(desc, new Throwable().fillInStackTrace());
  
              // Compute answer
              TypeQualifierAnnotation tqa;
  
              if (xmethod.isVarArgs() && parameter == xmethod.getNumParams()-1) {
                  tqa = null;
                  if (DEBUG) {
                      System.out.print("  vararg parameters don't get type qualifiers");
                  }
              }
              else {
                  // Check direct application
                  if (DEBUG) {
                      System.out.print("  (1) Checking direct application...");
                  }
                  tqa = getDirectTypeQualifierAnnotation(xmethod, parameter, typeQualifierValue);
                  if (DEBUG) {
                      System.out.println(tqa != null ? "FOUND" : "none");
                  }
  
                  // If it's an instance method, check for inherited annotation
                  if (tqa == null && !xmethod.isStatic() && !xmethod.isPrivate() && !"<init>".equals(xmethod.getName())) {
                      if (DEBUG) {
                          System.out.print("  (2) Checking inherited...");
                      }
                      tqa = getInheritedTypeQualifierAnnotation(xmethod, parameter, typeQualifierValue);
                      if (DEBUG) {
                          if (tqa == TypeQualifierAnnotation.OVERRIDES_BUT_NO_ANNOTATION) {
                              System.out.println("Overrides, no annotation inherited");
                          } else if (tqa != null) {
                              System.out.println("Inherited " + tqa.when);
                          } else {
                              System.out.println("Nothing inherited");
                          }
                      }
                  }
                  boolean overriddenMethod = false;
                  if (tqa == TypeQualifierAnnotation.OVERRIDES_BUT_NO_ANNOTATION) {
                      overriddenMethod = true;
                      tqa = null;
                  }
                  // Check for default (outer scope) annotation
                  if (tqa == null) {
                      if (xmethod.isVariableSynthetic((xmethod.isStatic() ? 0 : 1) + parameter)) {
                          if (DEBUG) {
                              System.out.print("  (3) Skipping default for synthetic parameter");
                          }
                      } else {
                          if (DEBUG) {
                              System.out.print("  (3) Checking default...");
                          }
  
                          tqa = getDefaultTypeQualifierAnnotationForParameters(xmethod, typeQualifierValue, overriddenMethod);
  
                          if (DEBUG) {
                              System.out.println(tqa != null ? "FOUND" : "none");
                          }
                      }
                  }
              }
  
              // Cache answer
              result = tqa;
              map.put(xmethod, parameter, result);
  
              if (DEBUG) {
                  if (result == null) {
                      System.out.println("  => Answer: no annotation on parameter " + parameter + " of " + xmethod);
                  } else {
                      System.out.println("  => Answer: " + result.when + " on parameter " + parameter + " of " + xmethod);
                  }
              }
          }
  
          if (!map.containsKey(xmethod, parameter)) {
              throw new IllegalStateException("Did not populate cache?");
          }
  
          // Return cached answer
          return result;
      }