Java PsiTypeParameter类代码示例

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
public SrcClass makeSrcClass( String fqn, PsiClass psiClass, ManModule module )
{
  SrcClass srcClass = new SrcClass( fqn, getKind( psiClass ) )
    .modifiers( getModifiers( psiClass.getModifierList() ) );
  for( PsiTypeParameter typeVar : psiClass.getTypeParameters() )
  {
    srcClass.addTypeVar( new SrcType( makeTypeVar( typeVar ) ) );
  }
  setSuperTypes( srcClass, psiClass );
  for( PsiMethod psiMethod : psiClass.getMethods() )
  {
    addMethod( srcClass, psiMethod );
  }
  for( PsiField psiField : psiClass.getFields() )
  {
    addField( srcClass, psiField );
  }
  for( PsiClass psiInnerClass : psiClass.getInnerClasses() )
  {
    addInnerClass( srcClass, psiInnerClass, module );
  }
  return srcClass;
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
public static String makeTypeVar( PsiTypeParameter typeVar )
{
  StringBuilder sb = new StringBuilder();
  sb.append( typeVar.getName() );

  PsiJavaCodeReferenceElement[] bounds = typeVar.getExtendsList().getReferenceElements();
  if( bounds.length > 0 )
  {
    sb.append( " extends " );
    for( int i = 0; i < bounds.length; i++ )
    {
      if( i > 0 )
      {
        sb.append( " & " );
      }
      sb.append( bounds[i].getCanonicalText() );
    }
  }
  return sb.toString();
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
public static PsiType makeDefaultParameterizedType( PsiType type )
{
  if( type != null && !isStructuralInterface( type ) &&
      !isParameterizedType( type ) && isGenericType( type ) )
  {
    PsiTypeParameter[] typeVars = type( type ).getTypeParameters();
    PsiType[] boundingTypes = new PsiType[typeVars.length];
    for( int i = 0; i < boundingTypes.length; i++ )
    {
      PsiTypeParameter typeVar = typeVars[i];
      boundingTypes[i] = type( getBoundingType( typeVar ) );
      if( isRecursiveType( (PsiClassType)type( typeVar ), boundingTypes[i] ) )
      {
        return type;
      }
    }

    if( boundingTypes.length == 0 )
    {
      return type;
    }

    type = parameterizeType( (PsiClassType)type, boundingTypes );
  }
  return type;
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
private static TypeVarToTypeMap mapActualTypeByVarName( PsiType ownersType )
{
  TypeVarToTypeMap actualParamByVarName = new TypeVarToTypeMap();
  PsiTypeParameter[] vars = type( ownersType ).getTypeParameters();
  if( vars != null )
  {
    PsiType[] paramArgs = ((PsiClassType)ownersType).getParameters();
    for( int i = 0; i < vars.length; i++ )
    {
      PsiClassType typeVar = (PsiClassType)type( vars[i] );
      if( paramArgs.length > i )
      {
        actualParamByVarName.put( typeVar, paramArgs[i] );
      }
    }
  }
  return actualParamByVarName;
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
@Override
public void visitClass(@NotNull PsiClass aClass) {
  if (aClass.isInterface() || aClass.isAnnotationType() || aClass.isEnum()) {
    return;
  }
  if (aClass instanceof PsiTypeParameter) {
    return;
  }
  if (!aClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
    return;
  }
  if (!InheritanceUtil.hasOneInheritor(aClass)) {
    return;
  }
  registerClassError(aClass);
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
@Override
public void visitClass(@NotNull PsiClass aClass) {
  if (aClass.isInterface() || aClass.isAnnotationType() || aClass instanceof PsiTypeParameter) {
    return;
  }
  if (!CloneUtils.isCloneable(aClass)) {
    return;
  }
  final PsiMethod[] methods = aClass.getMethods();
  for (final PsiMethod method : methods) {
    if (CloneUtils.isClone(method)) {
      if (ControlFlowUtils.methodAlwaysThrowsException(method)) {
        return;
      }
    }
  }
  registerClassError(aClass);
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
@Override
public void visitClass(@NotNull PsiClass aClass) {
  if (aClass.isInterface() || aClass.isAnnotationType() || aClass.isEnum()) {
    return;
  }
  if (aClass instanceof PsiTypeParameter || !SerializationUtils.isSerializable(aClass)) {
    return;
  }
  final PsiMethod[] methods = aClass.getMethods();
  for (final PsiMethod method : methods) {
    if (!SerializationUtils.isReadObject(method)) {
      continue;
    }
    if (ControlFlowUtils.methodAlwaysThrowsException(method)) {
      return;
    }
    else {
      break;
    }
  }
  if (ignoreThrowable && InheritanceUtil.isInheritor(aClass, false, "java.lang.Throwable")) {
    return;
  }
  registerClassError(aClass);
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
@Override
public void visitClass(@NotNull PsiClass aClass) {
  if (aClass.isInterface() || aClass.isAnnotationType() || aClass.isEnum()) {
    return;
  }
  if (aClass instanceof PsiTypeParameter || !SerializationUtils.isSerializable(aClass)) {
    return;
  }
  final PsiMethod[] methods = aClass.findMethodsByName("writeObject", true);
  for (final PsiMethod method : methods) {
    if (!SerializationUtils.isWriteObject(method)) {
      continue;
    }
    if (ControlFlowUtils.methodAlwaysThrowsException((PsiMethod)method.getNavigationElement())) {
      return;
    }
    else {
      break;
    }
  }
  if (ignoreThrowable && InheritanceUtil.isInheritor(aClass, false, "java.lang.Throwable")) {
    return;
  }
  registerClassError(aClass);
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
@Override
public void visitClass(@NotNull PsiClass aClass) {
  // no call to super, so it doesn't drill down into inner classes
  if (aClass instanceof PsiTypeParameter) {
    return;
  }
  final String className = aClass.getName();
  if (className == null) {
    return;
  }
  @NonNls final String exception = "Exception";
  if (className.endsWith(exception)) {
    return;
  }
  if (!InheritanceUtil.isInheritor(aClass,
                                   CommonClassNames.JAVA_LANG_EXCEPTION)) {
    return;
  }
  registerClassError(aClass);
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
@Override
public void visitClass(@NotNull PsiClass aClass) {
  if (aClass.isInterface() || aClass.isAnnotationType() || aClass.isEnum()) {
    return;
  }
  if (aClass instanceof PsiTypeParameter) {
    return;
  }
  if (aClass.hasModifierProperty(PsiModifier.ABSTRACT) && isInspectionEnabled("AbstractClassNamingConvention", aClass)) {
    return;
  }
  final String name = aClass.getName();
  if (name == null || isValid(name)) {
    return;
  }
  registerClassError(aClass, name);
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
@Override
public void visitTypeParameter(PsiTypeParameter parameter) {
  super.visitTypeParameter(parameter);
  final String name = parameter.getName();
  if (name == null) {
    return;
  }
  if (isValid(name)) {
    return;
  }
  final PsiIdentifier nameIdentifier = parameter.getNameIdentifier();
  if (nameIdentifier == null) {
    return;
  }
  registerError(nameIdentifier, name);
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
@Override
public void visitClass(@NotNull PsiClass aClass) {
  // no call to super, so it doesn't drill down
  if (aClass.isInterface() || aClass.isEnum() ||
      aClass.isAnnotationType()) {
    return;
  }
  if (aClass instanceof PsiTypeParameter) {
    return;
  }
  if (m_ignoreClassesWithNoConstructors &&
      !classHasConstructor(aClass)) {
    return;
  }
  if (classHasNoArgConstructor(aClass)) {
    return;
  }
  registerClassError(aClass);
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
@Override
public void visitClass(@NotNull PsiClass aClass) {
  // note: no call to super
  if (aClass.isEnum()) {
    return;
  }
  if (aClass instanceof PsiTypeParameter) {
    return;
  }
  final int inheritanceDepth =
    getInheritanceDepth(aClass, new HashSet<PsiClass>());
  if (inheritanceDepth <= getLimit()) {
    return;
  }
  registerClassError(aClass, Integer.valueOf(inheritanceDepth));
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
@Nullable
@Override
public PsiClass findClass(@NotNull PsiElement place) {
  if (place.getLanguage() == GroovyLanguage.INSTANCE) {
    PsiClass containingClass = PsiTreeUtil.getParentOfType(place, PsiClass.class, false);
    while (containingClass instanceof PsiTypeParameter) {
      containingClass = PsiTreeUtil.getParentOfType(containingClass, PsiClass.class);
    }
    if (containingClass != null) return containingClass;

    PsiFile file = place.getContainingFile();
    if (file instanceof GroovyFile && ((GroovyFile)file).isScript()) {
      return ((GroovyFile)file).getScriptClass();
    }
  }
  return null;
}
 

import com.intellij.psi.PsiTypeParameter; //导入依赖的package包/类
@Nullable
@Override
public GrTypeArgumentList findElementForParameterInfo(@NotNull CreateParameterInfoContext context) {
  final GrTypeArgumentList parameterList = ParameterInfoUtils.findParentOfType(context.getFile(), context.getOffset(), GrTypeArgumentList.class);

  if (parameterList != null) {
    if (!(parameterList.getParent() instanceof GrCodeReferenceElement)) return null;
    final GrCodeReferenceElement ref = ((GrCodeReferenceElement)parameterList.getParent());

    final PsiElement resolved = ref.resolve();
    if (!(resolved instanceof PsiTypeParameterListOwner)) return null;

    final PsiTypeParameter[] typeParams = ((PsiTypeParameterListOwner)resolved).getTypeParameters();
    if (typeParams.length == 0) return null;

    context.setItemsToShow(typeParams);
    return parameterList;
  }

  return null;
}