Java JavaPsiFacade.getInstance方法代码示例

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
protected MultiMap<PsiFile, T> computeChildren(@Nullable PsiFile psiFile) {
    MultiMap<PsiFile, T> children = new MultiMap<>();
    Project project = getProject();
    if (project != null) {
        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
        PsiClass serviceAnnotation = javaPsiFacade.findClass(getAnnotationQName(), GlobalSearchScope.allScope(project));
        if (serviceAnnotation != null) {
            AnnotatedElementsSearch.searchPsiClasses(serviceAnnotation, GlobalSearchScope.allScope(project)).forEach(psiClass -> {
                if (psiClass.isInterface() && isSatisfying(psiClass)) {
                    children.putValue(psiClass.getContainingFile(), createChild(psiClass));
                }
                return true;
            });
        }
    }
    return children;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
protected MultiMap<PsiFile, ClassNode> computeChildren(@Nullable PsiFile psiFile) {
    MultiMap<PsiFile, ClassNode> children = new MultiMap<>();
    children.putValue(aggregateRoot.getContainingFile(), new AggregateRootNode(this, aggregateRoot));
    Project project = getProject();
    if (project != null) {
        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
        PsiClass entityInterface = javaPsiFacade.findClass(ENTITY_INTERFACE, GlobalSearchScope.allScope(project));
        PsiClass valueObjectInterface = javaPsiFacade.findClass(VO_INTERFACE, GlobalSearchScope.allScope(project));
        if (entityInterface != null && valueObjectInterface != null) {
            for (PsiClass psiClass : psiPackage.getClasses(GlobalSearchScope.allScope(project))) {
                if (psiClass.isInheritor(entityInterface, true) && !psiClass.equals(aggregateRoot)) {
                    children.putValue(psiClass.getContainingFile(), new EntityNode(this, psiClass));
                } else if (psiClass.isInheritor(valueObjectInterface, true)) {
                    children.putValue(psiClass.getContainingFile(), new ValueObjectNode(this, psiClass));
                }
            }
        }
    }
    return children;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
protected MultiMap computeChildren(@Nullable PsiFile psiFile) {
    MultiMap<PsiFile, AggregateNode> children = new MultiMap<>();
    Project project = getProject();
    if (project != null) {
        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
        PsiClass psiClass = javaPsiFacade.findClass(AGGREGATE_ROOT_INTERFACE, GlobalSearchScope.allScope(project));
        if (psiClass != null) {
            ClassInheritorsSearch.search(psiClass, GlobalSearchScope.allScope(project), true).forEach(candidate -> {
                String qualifiedName = candidate.getQualifiedName();
                if (qualifiedName != null && !qualifiedName.startsWith(BUSINESS_PACKAGE) && !isAbstract(candidate)) {
                    children.putValue(candidate.getContainingFile(), new AggregateNode(this, candidate));
                }
            });
        }

    }
    return children;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
public MultiMap<PsiFile, ResourceNode> computeChildren(PsiFile psiFile) {
    Project project = getProject();
    MultiMap<PsiFile, ResourceNode> children = new MultiMap<>();
    if (project != null) {
        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
        PsiClass pathAnnotation = javaPsiFacade.findClass(PATH_ANNOTATION, GlobalSearchScope.allScope(project));
        if (pathAnnotation != null) {
            AnnotatedElementsSearch.searchPsiClasses(pathAnnotation, GlobalSearchScope.allScope(project)).forEach(psiClass -> {
                if (!psiClass.isInterface() && !NavigatorUtil.isAbstract(psiClass)) {
                    children.putValue(psiClass.getContainingFile(), new ResourceNode(ResourcesNode.this, pathAnnotation, psiClass));
                }
                return true;
            });
        }
    }
    return children;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
public static boolean isJarAttached(@NotNull Location location,
                                    final String fqn,
                                    final PsiDirectory[] directories) {
  final JavaPsiFacade facade = JavaPsiFacade.getInstance(location.getProject());
  boolean testngJarFound = false;
  final Module locationModule = location.getModule();
  if (locationModule != null) {
    testngJarFound = facade.findClass(fqn, GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(locationModule, true)) != null;
  }
  else {
    for (PsiDirectory directory : directories) {
      final Module module = ModuleUtilCore.findModuleForFile(directory.getVirtualFile(), location.getProject());
      if (module != null) {
        if (facade.findClass(fqn, GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module, true)) != null) {
          testngJarFound = true;
          break;
        }
      }
    }
  }
  return testngJarFound;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
public void setUp() throws Exception {
  super.setUp();
  final IdeaTestFixtureFactory fixtureFactory = IdeaTestFixtureFactory.getFixtureFactory();
  final TestFixtureBuilder<IdeaProjectTestFixture> testFixtureBuilder = fixtureFactory.createFixtureBuilder(getName());
  myFixture = JavaTestFixtureFactory.getFixtureFactory().createCodeInsightFixture(testFixtureBuilder.getFixture());
  myFixture.setTestDataPath(PathManagerEx.getTestDataPath() + "/codeInsight/externalAnnotations");
  final JavaModuleFixtureBuilder builder = testFixtureBuilder.addModule(JavaModuleFixtureBuilder.class);
  new File(myFixture.getTempDirPath() + "/src/").mkdir();
  builder.addContentRoot(myFixture.getTempDirPath()).addSourceRoot("src");
  builder.setMockJdkLevel(JavaModuleFixtureBuilder.MockJdkLevel.jdk15);
  myFixture.setUp();
  myFixture.enableInspections(new SillyAssignmentInspection());

  addAnnotationsModuleRoot();

  final JavaPsiFacade facade = JavaPsiFacade.getInstance(myFixture.getProject());
  myLanguageLevel = LanguageLevelProjectExtension.getInstance(facade.getProject()).getLanguageLevel();
  LanguageLevelProjectExtension.getInstance(facade.getProject()).setLanguageLevel(LanguageLevel.JDK_1_5);
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
public List<? extends RatedResolveResult> resolveMember(@NotNull String name,
                                                        @Nullable PyExpression location,
                                                        @NotNull AccessDirection direction,
                                                        @NotNull PyResolveContext resolveContext) {
  Project project = myPackage.getProject();
  JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
  String childName = myPackage.getQualifiedName() + "." + name;
  GlobalSearchScope scope = getScope(project);
  ResolveResultList result = new ResolveResultList();
  final PsiClass[] classes = facade.findClasses(childName, scope);
  for (PsiClass aClass : classes) {
    result.poke(aClass, RatedResolveResult.RATE_NORMAL);
  }
  final PsiPackage psiPackage = facade.findPackage(childName);
  if (psiPackage != null) {
    result.poke(psiPackage, RatedResolveResult.RATE_NORMAL);
  }
  return result;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
public int getContentType() {
  if (myDeclarationClass != null) {
    final GlobalSearchScope scope = myDeclarationClass.getResolveScope();
    final JavaPsiFacade facade = JavaPsiFacade.getInstance(myDeclarationClass.getProject());
    final PsiClass view = facade.findClass(SdkConstants.CLASS_VIEW, scope);

    if (view != null && myDeclarationClass.isInheritor(view, true)) {
      final PsiClass viewGroup = facade.findClass(SdkConstants.CLASS_VIEWGROUP, scope);

      if (viewGroup != null) {
        return myDeclarationClass.isInheritor(viewGroup, true) ? CONTENT_TYPE_MIXED : CONTENT_TYPE_EMPTY;
      }
    }
  }
  return myParentDescriptor.getContentType();
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
public PositionManager createPositionManager(@NotNull final DebugProcess process) {
  AccessToken accessToken = ApplicationManager.getApplication().acquireReadActionLock();
  try {
    JavaPsiFacade facade = JavaPsiFacade.getInstance(process.getProject());
    if (facade.findPackage("com.springsource.loaded") != null || facade.findPackage("org.springsource.loaded") != null) {
      return new SpringLoadedPositionManager(process);
    }
  }
  finally {
    accessToken.finish();
  }

  try {
    // Check spring loaded for remote process
    if (!process.getVirtualMachineProxy().classesByName("com.springsource.loaded.agent.SpringLoadedAgent").isEmpty()
        || !process.getVirtualMachineProxy().classesByName("org.springsource.loaded.agent.SpringLoadedAgent").isEmpty()) {
      return new SpringLoadedPositionManager(process);
    }
  }
  catch (Exception ignored) {
    // Some problem with virtual machine.
  }

  return null;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Nullable
private static PsiClass getActivityClass(Location location, ConfigurationContext context) {
  final Module module = context.getModule();
  if (module == null) return null;
  location = JavaExecutionUtil.stepIntoSingleClass(location);
  if (location == null) {
    return null;
  }
  PsiElement element = location.getPsiElement();
  JavaPsiFacade facade = JavaPsiFacade.getInstance(element.getProject());
  GlobalSearchScope scope = module.getModuleWithDependenciesAndLibrariesScope(true);
  PsiClass activityClass = facade.findClass(AndroidUtils.ACTIVITY_BASE_CLASS_NAME, scope);
  if (activityClass == null) return null;

  PsiClass elementClass = PsiTreeUtil.getParentOfType(element, PsiClass.class, false);
  while (elementClass != null) {
    if (elementClass.isInheritor(activityClass, true)) {
      return elementClass;
    }
    elementClass = PsiTreeUtil.getParentOfType(elementClass, PsiClass.class);
  }
  return null;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
protected String showDialog() {
  Project project = getProject();
  final JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
  Module module = myModuleSelector.getModule();
  if (module == null) {
    Messages.showErrorDialog(project, ExecutionBundle.message("module.not.specified.error.text"), CommonBundle.getErrorTitle());
    return null;
  }
  GlobalSearchScope scope =
    myIncludeLibraryClasses ? module.getModuleWithDependenciesAndLibrariesScope(true) : module.getModuleWithDependenciesScope();
  PsiClass initialSelection = facade.findClass(getText(), scope);
  TreeClassChooser chooser = createTreeClassChooser(project, scope, initialSelection, new ClassFilter() {
    @Override
    public boolean isAccepted(PsiClass aClass) {
      if (aClass.isInterface()) return false;
      final PsiModifierList modifierList = aClass.getModifierList();
      return modifierList == null || !modifierList.hasModifierProperty(PsiModifier.ABSTRACT);
    }
  });
  if (chooser == null) return null;
  chooser.showDialog();
  PsiClass selClass = chooser.getSelected();
  return selClass != null ? selClass.getQualifiedName() : null;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
@Override
protected void doFix(Project project, ProblemDescriptor descriptor)
  throws IncorrectOperationException {
  final PsiElement element = descriptor.getPsiElement();
  final String text = element.getText();
  final int max = text.length() - 1;
  if (max < 1) {
    return;
  }
  int index = 0;
  while (index < max && (text.charAt(index) == '0' || text.charAt(index) == '_')) {
    index++;
  }
  final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
  final PsiElementFactory factory = psiFacade.getElementFactory();
  final String textWithoutLeadingZeros = text.substring(index);
  final PsiExpression decimalNumber =
    factory.createExpressionFromText(textWithoutLeadingZeros,
                                     element);
  element.replace(decimalNumber);
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
public SrcClass make( String fqn, ManModule module )
{
   JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance( module.getIjProject() );
   PsiClass psiClass = javaPsiFacade.findClass( fqn, GlobalSearchScope.moduleScope( module.getIjModule() ) );
   if( psiClass == null )
   {
     psiClass = javaPsiFacade.findClass( fqn, GlobalSearchScope.allScope( module.getIjProject() ) );
   }
  return makeSrcClass( fqn, psiClass, module );
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
/**
 * Initiates a migrate refactoring. The refactoring is finished when
 * {@link com.intellij.psi.PsiMigration#finish()} is called.
 *
 * @return the migrate operation object.
 */
@NotNull
public PsiMigration startMigration() {
  LOG.assertTrue(myCurrentMigration == null);
  myCurrentMigration = new PsiMigrationImpl(this, JavaPsiFacade.getInstance(myProject),
                                            (PsiManagerImpl)PsiManager.getInstance(myProject));
  return myCurrentMigration;
}
 

import com.intellij.psi.JavaPsiFacade; //导入方法依赖的package包/类
private static boolean isFqnsOk(Project project, List<String> fqns) {
  if (fqns.isEmpty()) return false;
  final JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
  final GlobalSearchScope scope = GlobalSearchScope.allScope(project);
  for (String fqn : fqns) {
    if (facade.findClass(fqn, scope) != null) return false;
  }
  return true;
}