code: public static Map<Integer, String> getParameterSlotAndSignatures(boolean methodIsStatic, String methodSignature) {
  
          int start = methodSignature.indexOf('(') + 1;
          int limit = methodSignature.lastIndexOf(')');
  
          if ((limit - start) == 0) {
              return Collections.emptyMap();
          }
  
          Map<Integer, String> slotIndexToParms = new LinkedHashMap<>();
          int slot = methodIsStatic ? 0 : 1;
          int sigStart = start;
          for (int i = start; i < limit; i++) {
              if (!methodSignature.startsWith(Values.SIG_ARRAY_PREFIX, i)) {
                  String parmSignature = null;
                  if (methodSignature.startsWith(Values.SIG_QUALIFIED_CLASS_PREFIX, i)) {
                      int semiPos = methodSignature.indexOf(Values.SIG_QUALIFIED_CLASS_SUFFIX_CHAR, i + 1);
                      parmSignature = methodSignature.substring(sigStart, semiPos + 1);
                      slotIndexToParms.put(Integer.valueOf(slot), parmSignature);
                      i = semiPos;
                  } else if (isWonkyEclipseSignature(methodSignature, i)) {
                      sigStart++;
                      continue;
                  } else {
                      parmSignature = methodSignature.substring(sigStart, i + 1);
                      slotIndexToParms.put(Integer.valueOf(slot), parmSignature);
                  }
                  sigStart = i + 1;
                  slot += getSignatureSize(parmSignature);
              }
          }
  
          return slotIndexToParms;
      }
docs: returns a Map that represents the type of the parameter in slot x
  
  @param methodIsStatic
  if the method is static, causes where to start counting from, slot 0 or 1
  @param methodSignature
  the signature of the method to parse
  @return a map of parameter types (expect empty slots when doubles/longs are used