public static ImmutableList<TypeVariableName> getTypeVariables(PsiClass psiClass) {
  PsiTypeParameter[] psiTypeParameters = psiClass.getTypeParameters();

  final List<TypeVariableName> typeVariables = new ArrayList<>(psiTypeParameters.length);
  for (PsiTypeParameter psiTypeParameter : psiTypeParameters) {
    final PsiReferenceList extendsList = psiTypeParameter.getExtendsList();
    final PsiClassType[] psiClassTypes = extendsList.getReferencedTypes();

    final TypeName[] boundsTypeNames = new TypeName[psiClassTypes.length];
    for (int i = 0, size = psiClassTypes.length; i < size; i++) {
      boundsTypeNames[i] = PsiTypeUtils.getTypeName(psiClassTypes[i]);
    }

    final TypeVariableName typeVariable =
        TypeVariableName.get(psiTypeParameter.getName(), boundsTypeNames);
    typeVariables.add(typeVariable);
  }

  return ImmutableList.copyOf(typeVariables);
}
 

public static String print(PsiTypeParameter[] parameters, TranslationContext ctx) {
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < parameters.length; i++) {
        PsiTypeParameter p = parameters[i];
        builder.append(p.getName());
        PsiClassType[] extensions = p.getExtendsList().getReferencedTypes();
        if (extensions.length > 0) {
            builder.append(" extends ");
            for (PsiClassType ext : extensions) {
                builder.append(TypeHelper.printType(ext, ctx));
            }
        }
        if (i != parameters.length - 1) {
            builder.append(", ");
        }
    }
    return builder.toString();
}
 

/**
 * 获取方法内部的变量
 *
 * @param psiMethod psi方法
 * @return {@link java.util.Map<java.lang.String,java.lang.Object>}
 */
private Map<String, Object> getMethodInnerVariable(PsiMethod psiMethod) {
    Map<String, Object> map = Maps.newHashMap();
    map.put("author", config.getAuthor());
    map.put("methodName", psiMethod.getName());
    map.put("methodReturnType", psiMethod.getReturnType() == null ? "" : psiMethod.getReturnType().getPresentableText());
    map.put("methodParamTypes",
        Arrays.stream(psiMethod.getTypeParameters()).map(PsiTypeParameter::getQualifiedName).toArray(String[]::new));
    map.put("methodParamNames",
        Arrays.stream(psiMethod.getParameterList().getParameters()).map(PsiParameter::getName).toArray(String[]::new));
    return map;
}
 

private static TypeVariableName toTypeVariableName(PsiTypeParameter psiTypeParameter) {
  String typeName = psiTypeParameter.getName();
  TypeName[] typeBounds =
      Arrays.stream(psiTypeParameter.getBounds())
          .filter(PsiType.class::isInstance)
          .map(bound -> PsiTypeUtils.getTypeName((PsiType) bound))
          .toArray(TypeName[]::new);
  return TypeVariableName.get(typeName, typeBounds);
}
 

@Nullable
public static Map<PsiTypeParameter, PsiType> getTypeParameters(PsiType type) {
  if (type instanceof PsiArrayType) {
    return getTypeParameters(((PsiArrayType) type).getComponentType());
  } else if (type instanceof PsiPrimitiveType) {
    return null;
  } else if (type instanceof PsiClassType) {
    PsiClassType.ClassResolveResult resolveResult =
        PsiClassType.class.cast(type).resolveGenerics();
    if (resolveResult.isValidResult()) {
      return resolveResult.getSubstitutor().getSubstitutionMap();
    }
  }
  return null;
}
 

@Override
public int getTypeParameterIndex(PsiTypeParameter typeParameter) {
  PsiTypeParameter[] params = getTypeParameters();
  int i = 0;
  for (; i < params.length; ++i) {
    if (typeParameter == params[i]) {
      break;
    }
  }
  return i < params.length ? i : -1;
}
 

@Nullable
public static Map<PsiTypeParameter, PsiType> getTypeParameters(@NotNull PsiElement psiElement) {
  PsiType psiType = getReferredPsiType(psiElement);
  return getTypeParameters(psiType);
}
 

@Override
public PsiTypeParameter[] getTypeParameters() {
  HaxeTypeList list = (HaxeTypeList) UsefulPsiTreeUtil.getChildOfType(this, HaxeTokenTypes.TYPE_LIST);
  HaxeTypeListPart[] parts = UsefulPsiTreeUtil.getChildrenOfType(list, HaxeTypeListPart.class, null);
  return null != parts ? parts : new PsiTypeParameter[0];
}
 

public LombokLightClassBuilder withParameterType(@NotNull PsiTypeParameter psiTypeParameter) {
  getTypeParameterList().addParameter(psiTypeParameter);
  return this;
}