docs: public MethodParameterInfo[] getParameterInfo() {
          if (parameterInfo == null) {
              // Get params from the type descriptor, and from the type signature if available
              final List<TypeSignature> paramTypeDescriptors = getTypeDescriptor().getParameterTypeSignatures();
              final List<TypeSignature> paramTypeSignatures = getTypeSignature() != null
                      ? getTypeSignature().getParameterTypeSignatures()
                      : null;
  
              // Figure out the number of params in the alignment (should be num params in type descriptor)
              final int numParams = paramTypeDescriptors.size();
              if (paramTypeSignatures != null && paramTypeSignatures.size() > numParams) {
                  // Should not happen
                  throw ClassGraphException.newClassGraphException(
                          "typeSignatureParamTypes.size() > typeDescriptorParamTypes.size() for method "
                                  + declaringClassName + "." + name);
              }
  
              // Figure out number of other fields that need alignment, and check length for consistency 
              final int otherParamMax = Math.max(parameterNames == null ? 0 : parameterNames.length,
                      Math.max(parameterModifiers == null ? 0 : parameterModifiers.length,
                              parameterAnnotationInfo == null ? 0 : parameterAnnotationInfo.length));
              if (otherParamMax > numParams) {
                  // Should not happen
                  throw ClassGraphException.newClassGraphException("Type descriptor for method " + declaringClassName
                          + "." + name + " has insufficient parameters");
              }
  
              // Kotlin is very inconsistent about the arity of each of the parameter metadata types, see:
              // https://github.com/classgraph/classgraph/issues/175#issuecomment-363031510
              // As a workaround, we assume that any synthetic / mandated parameters must come first in the
              // parameter list, when the arities don't match, and we right-align the metadata fields.
              // This is probably the safest assumption across JVM languages, even though this convention
              // is by no means the only possibility. (Unfortunately we can't just rely on the modifier
              // bits to find synthetic / mandated parameters, because these bits are not always available,
              // and even when they are, they don't always give the right alignment, at least for Kotlin-
              // generated code).
  
              String[] paramNamesAligned = null;
              if (parameterNames != null && numParams > 0) {
                  if (parameterNames.length == numParams) {
                      // No alignment necessary
                      paramNamesAligned = parameterNames;
                  } else {
                      // Right-align when not the right length
                      paramNamesAligned = new String[numParams];
                      for (int i = 0, lenDiff = numParams - parameterNames.length; i < parameterNames.length; i++) {
                          paramNamesAligned[lenDiff + i] = parameterNames[i];
                      }
                  }
              }
              int[] paramModifiersAligned = null;
              if (parameterModifiers != null && numParams > 0) {
                  if (parameterModifiers.length == numParams) {
                      // No alignment necessary
                      paramModifiersAligned = parameterModifiers;
                  } else {
                      // Right-align when not the right length
                      paramModifiersAligned = new int[numParams];
                      for (int i = 0, lenDiff = numParams
                              - parameterModifiers.length; i < parameterModifiers.length; i++) {
                          paramModifiersAligned[lenDiff + i] = parameterModifiers[i];
                      }
                  }
              }
              AnnotationInfo[][] paramAnnotationInfoAligned = null;
              if (parameterAnnotationInfo != null && numParams > 0) {
                  if (parameterAnnotationInfo.length == numParams) {
                      // No alignment necessary
                      paramAnnotationInfoAligned = parameterAnnotationInfo;
                  } else {
                      // Right-align when not the right length
                      paramAnnotationInfoAligned = new AnnotationInfo[numParams][];
                      for (int i = 0, lenDiff = numParams
                              - parameterAnnotationInfo.length; i < parameterAnnotationInfo.length; i++) {
                          paramAnnotationInfoAligned[lenDiff + i] = parameterAnnotationInfo[i];
                      }
                  }
              }
              List<TypeSignature> paramTypeSignaturesAligned = null;
              if (paramTypeSignatures != null && numParams > 0) {
                  if (paramTypeSignatures.size() == paramTypeDescriptors.size()) {
                      // No alignment necessary
                      paramTypeSignaturesAligned = paramTypeSignatures;
                  } else {
                      // Right-align when not the right length
                      paramTypeSignaturesAligned = new ArrayList<>(numParams);
                      for (int i = 0, n = numParams - paramTypeSignatures.size(); i < n; i++) {
                          // Left-pad with nulls
                          paramTypeSignaturesAligned.add(null);
                      }
                      paramTypeSignaturesAligned.addAll(paramTypeSignatures);
                  }
              }
  
              // Generate MethodParameterInfo entries
              parameterInfo = new MethodParameterInfo[numParams];
              for (int i = 0; i < numParams; i++) {
                  parameterInfo[i] = new MethodParameterInfo(this,
                          paramAnnotationInfoAligned == null ? null : paramAnnotationInfoAligned[i],
                          paramModifiersAligned == null ? 0 : paramModifiersAligned[i], paramTypeDescriptors.get(i),
                          paramTypeSignaturesAligned == null ? null : paramTypeSignaturesAligned.get(i),
                          paramNamesAligned == null ? null : paramNamesAligned[i]);
                  parameterInfo[i].setScanResult(scanResult);
              }
          }
          return parameterInfo;
      }