com.intellij.psi.PsiClass#getContainingFile ( )源码实例Demo

public AbstractTypeCheckRefactoring(TypeCheckElimination typeCheckElimination) {
    PsiClass sourceTypeDeclaration = typeCheckElimination.getTypeCheckClass();
    PsiFile sourceFile = sourceTypeDeclaration.getContainingFile();
    QuadriFunction<PsiFile, Project, PsiClass, TypeCheckElimination, PolymorphismRefactoring> constructor;
    if (typeCheckElimination.getExistingInheritanceTree() == null) {
        constructor = ReplaceTypeCodeWithStateStrategy::new;
    } else {
        constructor = ReplaceConditionalWithPolymorphism::new;
    }

    refactoring = constructor.apply(
            sourceFile,
            scope.getProject(),
            sourceTypeDeclaration,
            typeCheckElimination
    );
}
 

private Entity buildClassEntity(PsiClass psiClass) {
    PsiFile psiFile = psiClass.getContainingFile();
    String className = psiClass.getName();
    String packageName = ((PsiClassOwner) psiFile).getPackageName();

    List<Field> fields = Arrays.stream(psiClass.getAllFields()).map(field -> {
        String fieldType = field.getType().getPresentableText();
        String fieldName = field.getName();
        return new Field(fieldType, fieldName);
    }).collect(Collectors.toList());

    return Entity.builder()
        .name(className)
        .packageName(packageName)
        .fields(fields).build();
}
 

@Nullable
private String calculateCanonicalPath(@NotNull PsiClass psiClass) {
  String canonicalPath = null;
  final PsiFile psiFile;
  if (psiClass instanceof LombokLightClassBuilder) {
    // Use containing class for all LombokLightClasses
    final PsiClass containingClass = psiClass.getContainingClass();
    if (null != containingClass) {
      psiFile = containingClass.getContainingFile();
    } else {
      psiFile = null;
    }
  } else {
    psiFile = psiClass.getContainingFile();
  }

  if (null != psiFile) {
    canonicalPath = getDirectoryCanonicalPath(psiFile);
    if (null == canonicalPath) {
      canonicalPath = getDirectoryCanonicalPath(psiFile.getOriginalFile());
    }
  }
  return PathUtil.toSystemIndependentName(canonicalPath);
}
 

private static PolymorphismRefactoring createRefactoring(TypeCheckElimination typeCheckElimination,
                                                         Project project) {
    PsiClass sourceTypeDeclaration = typeCheckElimination.getTypeCheckClass();
    PsiFile sourceFile = sourceTypeDeclaration.getContainingFile();
    QuadriFunction<PsiFile, Project, PsiClass, TypeCheckElimination, PolymorphismRefactoring> constructor;
    if (typeCheckElimination.getExistingInheritanceTree() == null) {
        constructor = ReplaceTypeCodeWithStateStrategy::new;
    } else {
        constructor = ReplaceConditionalWithPolymorphism::new;
    }

    return constructor.apply(sourceFile, project, sourceTypeDeclaration, typeCheckElimination);
}
 

@Nullable
@Override
public PsiFileAndName toPsiFileAndName(BlazeProjectData projectData, ProjectViewNode<?> node) {
  if (!(node instanceof ClassTreeNode)) {
    return null;
  }
  PsiClass psiClass = ((ClassTreeNode) node).getPsiClass();
  if (psiClass == null) {
    return null;
  }
  PsiFile file = psiClass.getContainingFile();
  return file != null ? new PsiFileAndName(file, psiClass.getName()) : null;
}
 

/**
 * Returns an instance of {@link java.io.File} related to the containing file of the given class.
 * It returns {@code null} if the given class is not contained in a file and only exists in
 * memory.
 */
@Nullable
public static File getFileForClass(PsiClass aClass) {
  PsiFile containingFile = aClass.getContainingFile();
  if (containingFile == null) {
    return null;
  }

  VirtualFile virtualFile = containingFile.getVirtualFile();
  if (virtualFile == null) {
    return null;
  }

  return new File(virtualFile.getPath());
}
 

@Nullable
@Override
public PsiFileAndName toPsiFileAndName(BlazeProjectData projectData, ProjectViewNode<?> node) {
  if (!(node instanceof ClassTreeNode)) {
    return null;
  }
  PsiClass psiClass = ((ClassTreeNode) node).getPsiClass();
  if (psiClass == null) {
    return null;
  }
  PsiFile file = psiClass.getContainingFile();
  return file != null ? new PsiFileAndName(file, psiClass.getName()) : null;
}
 

protected void modify(@NonNls @NotNull String qualifiedName) {
  final PsiClass psiClass = findClassAndAssert(qualifiedName);
  final PsiFile psiFile = psiClass.getContainingFile();
  final PsiParserFacade parserFacade = PsiParserFacade.SERVICE.getInstance(myProject);
  final PsiComment comment = parserFacade.createBlockCommentFromText(psiFile.getLanguage(), "Foo");
  WriteCommandAction.runWriteCommandAction(
    myProject,
    ((Runnable) () -> psiFile.add(comment))
  );
  FileDocumentManager manager = FileDocumentManager.getInstance();
  manager.saveAllDocuments();
}
 

public static Range toNameRange(PsiClass type, IPsiUtils utils) {
	PsiFile openable = type.getContainingFile();
	TextRange sourceRange = type.getNameIdentifier().getTextRange();
	return utils.toRange(openable, sourceRange.getStartOffset(), sourceRange.getLength());
}
 

private static AnActionEvent createEvent(PsiClass content) {
  PsiFile containingFile = content.getContainingFile();
  AnActionEvent mock = mock(AnActionEvent.class);
  Mockito.when(mock.getData(CommonDataKeys.PSI_FILE)).thenReturn(containingFile);
  return mock;
}
 

private static LightVirtualFile createVirtualFile(PsiClass cls) {
  final PsiFile psiFile = cls.getContainingFile();
  return new LightVirtualFile(psiFile.getName(), psiFile.getFileType(), psiFile.getText());
}
 

@Nullable
@Override
public VirtualFile findClassFile(String fqcn) {
  GlobalSearchScope searchScope = module.getModuleRuntimeScope(false);

  PsiClass[] psiClasses =
      ReadAction.compute(
          () ->
              JavaPsiFacade.getInstance(project)
                  .findClasses(getContainingClassName(fqcn), searchScope));
  if (psiClasses.length == 0) {
    return null;
  }

  BlazeProjectData projectData =
      BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
  if (projectData == null) {
    return null;
  }

  // It's possible that there's more than one source file in the project corresponding to
  // the same fully-qualified class name, with Blaze choosing the appropriate source to use
  // according to some configuration flags. Here we check each of them until we find the one
  // that was chosen during Blaze sync.
  for (PsiClass psiClass : psiClasses) {
    PsiFile psiFile = psiClass.getContainingFile();
    if (psiFile == null) {
      continue;
    }

    VirtualFile virtualFile = psiFile.getVirtualFile();
    if (virtualFile == null) {
      continue;
    }

    FileType fileType = psiFile.getFileType();
    VirtualFile classFile = null;

    if (fileType == StdFileTypes.JAVA) {
      classFile =
          findClassFileForSourceAndRegisterResourcePackage(projectData, virtualFile, fqcn);
    } else if (fileType == StdFileTypes.CLASS) {
      classFile = findClassFileForIJarClass(projectData, virtualFile, fqcn);
    }

    if (classFile != null) {
      return classFile;
    }
  }

  return null;
}