docs: public static Collection<TypeQualifierValue<?>> getRelevantTypeQualifiers(MethodDescriptor methodDescriptor, CFG cfg)
              throws CheckedAnalysisException {
  
          final HashSet<TypeQualifierValue<?>> result = new HashSet<>();
  
          XMethod xmethod = XFactory.createXMethod(methodDescriptor);
  
          if (FIND_EFFECTIVE_RELEVANT_QUALIFIERS) {
              if (DEBUG_FIND_EFFECTIVE_RELEVANT_QUALIFIERS) {
                  System.out.println("**** Finding effective type qualifiers for " + xmethod);
              }
  
              //
              // This will take care of methods using fields annotated with
              // a type qualifier.
              //
              getDirectlyRelevantTypeQualifiers(xmethod, result);
  
              // For all known type qualifiers, find the effective (direct,
              // inherited,
              // or default) type qualifier annotations
              // on the method and all methods directly called by the method.
              //
  
              addEffectiveRelevantQualifiers(result, xmethod);
  
              IAnalysisCache analysisCache = Global.getAnalysisCache();
              ConstantPoolGen cpg = analysisCache.getClassAnalysis(ConstantPoolGen.class, methodDescriptor.getClassDescriptor());
              for (Iterator<Location> i = cfg.locationIterator(); i.hasNext();) {
                  Location location = i.next();
                  Instruction ins = location.getHandle().getInstruction();
                  if (ins instanceof InvokeInstruction) {
                      if (ins instanceof INVOKEDYNAMIC) {
                          // TODO handle INVOKEDYNAMIC
                      } else {
                          XMethod called = XFactory.createXMethod((InvokeInstruction) ins, cpg);
                          addEffectiveRelevantQualifiers(result, called);
                      }
                  }
  
                  if (DEBUG_FIND_EFFECTIVE_RELEVANT_QUALIFIERS) {
                      System.out.println("===> result: " + result);
                  }
              }
  
              //
              // XXX: this code can go away eventually
              //
  
              if (!methodDescriptor.isStatic()) {
                  // Instance method - must consider type qualifiers inherited
                  // from superclasses
  
                  SupertypeTraversalVisitor visitor = new OverriddenMethodsVisitor(xmethod) {
                      /*
                       * (non-Javadoc)
                       *
                       * @see edu.umd.cs.findbugs.ba.ch.OverriddenMethodsVisitor#
                       * visitOverriddenMethod(edu.umd.cs.findbugs.ba.XMethod)
                       */
  
                      @Override
                      protected boolean visitOverriddenMethod(XMethod xmethod) {
                          getDirectlyRelevantTypeQualifiers(xmethod, result);
                          return true;
                      }
                  };
  
                  try {
                      AnalysisContext.currentAnalysisContext().getSubtypes2()
                      .traverseSupertypesDepthFirst(xmethod.getClassDescriptor(), visitor);
                  } catch (ClassNotFoundException e) {
                      AnalysisContext.currentAnalysisContext().getLookupFailureCallback().reportMissingClass(e);
                      return Collections.<TypeQualifierValue<?>> emptySet();
                  } catch (UncheckedAnalysisException e) {
                      AnalysisContext.currentAnalysisContext().getLookupFailureCallback()
                      .logError("Error getting relevant type qualifiers for " + xmethod.toString(), e);
                      return Collections.<TypeQualifierValue<?>> emptySet();
                  }
              }
          }
  
          return result;
  
      }