Java JavaFileType类代码示例

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
private void createUIComponents() {
    final EditorFactory editorFactory = EditorFactory.getInstance();
    previewDocument = editorFactory.createDocument(EMPTY_TEXT);
    previewEditor = editorFactory.createEditor(previewDocument, null, JavaFileType.INSTANCE, true);

    final EditorSettings settings = previewEditor.getSettings();
    settings.setWhitespacesShown(true);
    settings.setLineMarkerAreaShown(false);
    settings.setIndentGuidesShown(false);
    settings.setLineNumbersShown(false);
    settings.setFoldingOutlineShown(false);
    settings.setRightMarginShown(false);
    settings.setVirtualSpace(false);
    settings.setWheelFontChangeEnabled(false);
    settings.setUseSoftWraps(false);
    settings.setAdditionalColumnsCount(0);
    settings.setAdditionalLinesCount(1);

    previewPanel = (JPanel) previewEditor.getComponent();
    previewPanel.setName(PREVIEW_PANEL_NAME);
    previewPanel.setPreferredSize(new Dimension(PREFERRED_PREVIEW_WIDTH, PREFERRED_PREVIEW_HEIGHT));
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
@Override
protected void run(@NotNull Result<PsiFile> result) throws Throwable {
    final PsiPackage packageElement = directoryService.getPackage(directory);
    if (packageElement == null) {
        throw new InvalidDirectoryException("Target directory does not provide a package");
    }

    final String fileName = Extensions.append(name, StdFileTypes.JAVA);
    final PsiFile found = directory.findFile(fileName);
    if (found != null) {
        throw new ClassAlreadyExistsException("Class '" + name + "'already exists in " + packageElement.getName());
    }

    final String packageName = packageElement.getQualifiedName();
    final String className = Extensions.remove(this.name, StdFileTypes.JAVA);
    try {
        final String java = converter.convert(packageName, className, json);
        final PsiFile classFile = fileFactory.createFileFromText(fileName, JavaFileType.INSTANCE, java);
        CodeStyleManager.getInstance(classFile.getProject()).reformat(classFile);
        JavaCodeStyleManager.getInstance(classFile.getProject()).optimizeImports(classFile);
        final PsiFile created = (PsiFile) directory.add(classFile);
        result.setResult(created);
    } catch (IOException e) {
        throw new ClassCreationException("Failed to create new class from JSON", e);
    }
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
private PsiClass createJavaFile(String javaFileName, @NonNls String text) {
    PsiJavaFile psiJavaFile = (PsiJavaFile) PsiFileFactory.getInstance(mPsiClass.getProject()).createFileFromText(
            javaFileName + "." + JavaFileType.INSTANCE.getDefaultExtension(),
            JavaFileType.INSTANCE, text);
    PsiClass[] classes = psiJavaFile.getClasses();
    if (classes.length != 1) {
        throw new IncorrectOperationException("Incorrect class '" + text + "'");
    } else {
        PsiClass pc = classes[0];
        if (pc == null) {
            throw new IllegalStateException(String.format("@NotNull method %s.%s must not return null",
                    "com/intellij/psi/impl/PsiJavaParserFacadeImpl", "createJavaFile"));
        } else {
            return pc;
        }
    }
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
public static PsiFile postProcessSelectedMainSketchClass(@NotNull Project project,
                                                         @NotNull PsiClass selectedMainClass,
                                                         @NotNull PsiImportList correspondingImportList) {
    // Construct a valid Java class from the selected main sketch class.
    selectedMainClass.getModifierList().setModifierProperty(PsiModifier.PUBLIC, true);

    PsiJavaCodeReferenceElement pAppletReference = JavaPsiFacade.getElementFactory(project)
            .createFQClassNameReferenceElement("processing.core.PApplet", GlobalSearchScope.projectScope(project));
    selectedMainClass.getExtendsList().add(pAppletReference);

    PsiFileFactory psiFileFactory = PsiFileFactory.getInstance(project);

    StringJoiner mainFileJoiner = new StringJoiner("\n\n");
    StringJoiner importStatementJoiner = new StringJoiner("\n");

    for (PsiImportStatementBase importStatement : correspondingImportList.getAllImportStatements()) {
        importStatementJoiner.add(importStatement.getText());
    }

    mainFileJoiner.add(importStatementJoiner.toString());
    mainFileJoiner.add(selectedMainClass.getText());

    return psiFileFactory.createFileFromText(selectedMainClass.getName() + ".java", JavaFileType.INSTANCE, mainFileJoiner.toString());
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
public static List<PsiMethodCallExpression> findMethodLikeCalls(SmcMethodLikeElement psiMethodLike) {
    SmcFile containingFile = (SmcFile) psiMethodLike.getContainingFile().getContainingFile();
    PsiClass fsmClass = containingFile.getFsmClass();
    Project project = psiMethodLike.getProject();
    if (fsmClass == null) return Collections.emptyList();
    Collection<VirtualFile> virtualFiles = FileBasedIndex.getInstance().getContainingFiles(FileTypeIndex.NAME, JavaFileType.INSTANCE,
            GlobalSearchScope.projectScope(project));
    List<PsiMethodCallExpression> result = new ArrayList<>();
    for (VirtualFile virtualFile : virtualFiles) {
        PsiJavaFile psiJavaFile = (PsiJavaFile) PsiManager.getInstance(project).findFile(virtualFile);
        if (psiJavaFile != null) {
            Collection<PsiMethodCallExpression> methodCallExpressions = PsiTreeUtil.findChildrenOfType(psiJavaFile, PsiMethodCallExpression.class);
            for (PsiMethodCallExpression methodCall : methodCallExpressions) {
                PsiMethod psiMethod = methodCall.resolveMethod();
                if (psiMethod != null && psiMethodLike.matches(psiMethod)) {
                    result.add(methodCall);
                }
            }
        }
    }
    return result;
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
public static List<PsiMethod> findJavaMethod(Project project, String name) {
    List<PsiMethod> result = null;
    Collection<VirtualFile> virtualFiles = FileBasedIndex.getInstance().getContainingFiles(FileTypeIndex.NAME, JavaFileType.INSTANCE,
            GlobalSearchScope.projectScope(project));
    for (VirtualFile virtualFile : virtualFiles) {
        PsiJavaFile javaFile = (PsiJavaFile) PsiManager.getInstance(project).findFile(virtualFile);
        if (javaFile != null) {
            Collection<PsiMethod> properties = PsiTreeUtil.findChildrenOfType(javaFile, PsiMethod.class);
            for (PsiMethod javaMethod : properties) {
                if (name.equals(javaMethod.getName())) {
                    if (result == null) {
                        result = new ArrayList<PsiMethod>();
                    }
                    result.add(javaMethod);
                }
            }
        }
    }
    return result != null ? result : Collections.<PsiMethod>emptyList();
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
public void testGenerateDoc() throws Exception {
    myFixture.configureByText(JavaFileType.INSTANCE, getJavaTestDataWithCursorAfterQuestionMark());

    PsiElement element = myFixture.findElementByText("\"file:inbox?\"", PsiLiteralExpression.class);
    String componentName = "file";
    String lookup = componentName + ":inbox?delete";
    PsiManager manager = myFixture.getPsiManager();

    PsiElement docInfo = new CamelDocumentationProvider().getDocumentationElementForLookupItem(manager, lookup, element);

    String doc = new CamelDocumentationProvider().generateDoc(docInfo, null);
    assertEquals(readExpectedFile(), doc);

    String documentation = new CamelDocumentationProvider().generateDoc(element, null);
    assertNotNull(documentation);
    assertTrue(documentation.startsWith("<b>File Component</b><br/>The file component is used for reading or writing files.<br/>"));
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
/**
 * Computes indentation of PsiClass, PsiMethod and PsiField elements after formatting
 * @param element PsiClass or PsiMethod or PsiField
 * @return indentation size
 */
private int getIndentSpecial(@NotNull PsiElement element) {
  if (element instanceof PsiDocComment) {
    return 0;
  }
  LOG.assertTrue(element instanceof PsiClass ||
                 element instanceof PsiField ||
                 element instanceof PsiMethod);

  int indentSize = mySettings.getIndentSize(JavaFileType.INSTANCE);
  boolean doNotIndentTopLevelClassMembers = mySettings.getCommonSettings(JavaLanguage.INSTANCE).DO_NOT_INDENT_TOP_LEVEL_CLASS_MEMBERS;

  int indent = 0;
  PsiClass top = PsiUtil.getTopLevelClass(element);
  while (top != null && !element.isEquivalentTo(top)) {
    if (doNotIndentTopLevelClassMembers && element.getParent().isEquivalentTo(top)) {
      break;
    }
    element = element.getParent();
    indent += indentSize;
  }

  return indent;
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
@Override
public SearchScope getAdditionalResolveScope(@NotNull VirtualFile file, Project project) {
  ProjectFileIndex index = ProjectFileIndex.SERVICE.getInstance(project);
  if (index.isInLibraryClasses(file) || index.isInContent(file)) {
    return null;
  }

  String fileExtension = file.getExtension();
  if ("class".equals(fileExtension) || JavaFileType.DEFAULT_EXTENSION.equals(fileExtension)) {
    for (PsiElementFinder finder : Extensions.getExtensions(PsiElementFinder.EP_NAME, project)) {
      if (finder instanceof NonClasspathClassFinder) {
        final List<VirtualFile> roots = ((NonClasspathClassFinder)finder).getClassRoots();
        for (VirtualFile root : roots) {
          if (VfsUtilCore.isAncestor(root, file, true)) {
            return NonClasspathDirectoriesScope.compose(roots);
          }
        }
      }
    }
  }
  return null;
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
public void testPointersRefCount() throws Exception {
  PsiFile file = configureByText(JavaFileType.INSTANCE, "class X{}");
  PsiClass aClass = ((PsiClassOwner)file).getClasses()[0];
  SmartPointerManagerImpl smartPointerManager = getPointerManager();
  SmartPsiElementPointer pointer1 = createPointer(aClass);
  SmartPsiElementPointer pointer2 = createPointer(aClass);
  assertSame(pointer1, pointer2);

  assertNotNull(pointer1.getRange());

  boolean removed2 = smartPointerManager.removePointer(pointer2);
  assertFalse(removed2);
  assertNotNull(pointer1.getRange());

  boolean removed1 = smartPointerManager.removePointer(pointer1);
  assertTrue(removed1);
  assertNull(pointer1.getRange());
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
public void testPointersRefCountSaturated() throws Exception {
  PsiFile file = configureByText(JavaFileType.INSTANCE, "class X{}");
  PsiClass aClass = ((PsiClassOwner)file).getClasses()[0];
  SmartPointerManagerImpl smartPointerManager = getPointerManager();
  SmartPsiElementPointerImpl pointer1 = (SmartPsiElementPointerImpl)createPointer(aClass);
  for (int i=0; i<1000; i++) {
    SmartPsiElementPointer<PsiClass> pointer2 = createPointer(aClass);
    assertSame(pointer1, pointer2);
  }

  assertNotNull(pointer1.getRange());
  assertEquals(Byte.MAX_VALUE, pointer1.incrementAndGetReferenceCount(0));

  for (int i=0; i<1100; i++) {
    boolean removed1 = smartPointerManager.removePointer(pointer1);
    assertFalse(removed1);
    Assert.assertNotNull(pointer1.getRange());
  }
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
public void testInsertImport() {
  final PsiFile file = configureByText(JavaFileType.INSTANCE,
                                       "class S {\n" +
                                       "}");

  PsiClass aClass = ((PsiJavaFile)file).getClasses()[0];

  WriteCommandAction.runWriteCommandAction(getProject(), new Runnable() {
    @Override
    public void run() {
      getEditor().getDocument().insertString(0, "import java.util.Map;\n");
    }
  });

  PsiDocumentManager.getInstance(getProject()).commitAllDocuments();

  PsiClass aClass2 = ((PsiJavaFile)file).getClasses()[0];
  assertSame(aClass, aClass2);
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
public void testEqualPointerRangesWhenCreatedFromStubAndAST() {
  final PsiFile file = configureByText(JavaFileType.INSTANCE,
                                       "class S {\n" +
                                       "}");

  PsiClass aClass = ((PsiJavaFile)file).getClasses()[0];
  assertNotNull(((PsiFileImpl)file).getStubTree());

  final SmartPointerManager manager = getPointerManager();
  final SmartPsiElementPointer<PsiClass> pointer1 = createPointer(aClass);
  Segment range1 = pointer1.getRange();
  manager.removePointer(pointer1);

  final FileASTNode node = file.getNode();
  final SmartPsiElementPointer<PsiClass> pointer2 = createPointer(aClass);
  assertEquals(range1, pointer2.getRange());
  assertNotNull(node);
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
public void testMoveText() {
  PsiJavaFile file = (PsiJavaFile)configureByText(JavaFileType.INSTANCE, "class C1{}\nclass C2 {}");
  DocumentEx document = (DocumentEx)file.getViewProvider().getDocument();

  SmartPsiElementPointer<PsiClass> pointer1 =
    createPointer(file.getClasses()[0]);
  SmartPsiElementPointer<PsiClass> pointer2 =
    createPointer(file.getClasses()[1]);
  assertEquals("C1", pointer1.getElement().getName());
  assertEquals("C2", pointer2.getElement().getName());

  PlatformTestUtil.tryGcSoftlyReachableObjects();
  assertNull(((SmartPointerEx) pointer1).getCachedElement());
  assertNull(((SmartPointerEx) pointer2).getCachedElement());

  TextRange range = file.getClasses()[1].getTextRange();
  document.moveText(range.getStartOffset(), range.getEndOffset(), 0);

  System.out.println(pointer1.getRange());
  System.out.println(pointer2.getRange());

  PsiDocumentManager.getInstance(myProject).commitAllDocuments();

  assertEquals("C1", pointer1.getElement().getName());
  assertEquals("C2", pointer2.getElement().getName());
}
 

import com.intellij.ide.highlighter.JavaFileType; //导入依赖的package包/类
public void testPointerToEmptyElement2() {
  PsiFile file = configureByText(JavaFileType.INSTANCE, "class Foo {\n" +
                                                           "  void foo() {}\n" +
                                                           "}");
  PsiMethod method = PsiTreeUtil.findElementOfClassAtOffset(file, file.getText().indexOf("void"), PsiMethod.class, false);
  SmartPointerEx pointer1 = (SmartPointerEx)createPointer(method.getModifierList());
  SmartPointerEx pointer2 = (SmartPointerEx)createPointer(method.getTypeParameterList());
  method = null;

  PlatformTestUtil.tryGcSoftlyReachableObjects();
  assertNull(pointer1.getCachedElement());
  assertNull(pointer2.getCachedElement());

  assertInstanceOf(pointer1.getElement(), PsiModifierList.class);
  assertInstanceOf(pointer2.getElement(), PsiTypeParameterList.class);
}