com.intellij.codeInspection.LocalInspectionTool Java Examples

public static InspectionToolWrapper findTool2RunInBatch(@Nonnull Project project, @Nullable PsiElement element, @Nonnull String name) {
  final InspectionProfile inspectionProfile = InspectionProjectProfileManager.getInstance(project).getInspectionProfile();
  final InspectionToolWrapper toolWrapper = element == null
                                            ? inspectionProfile.getInspectionTool(name, project)
                                            : inspectionProfile.getInspectionTool(name, element);
  if (toolWrapper instanceof LocalInspectionToolWrapper && ((LocalInspectionToolWrapper)toolWrapper).isUnfair()) {
    final LocalInspectionTool inspectionTool = ((LocalInspectionToolWrapper)toolWrapper).getTool();
    if (inspectionTool instanceof PairedUnfairLocalInspectionTool) {
      final String oppositeShortName = ((PairedUnfairLocalInspectionTool)inspectionTool).getInspectionForBatchShortName();
      return element == null
             ? inspectionProfile.getInspectionTool(oppositeShortName, project)
             : inspectionProfile.getInspectionTool(oppositeShortName, element);
    }
    return null;
  }
  return toolWrapper;
}
 

/**
 * Returns the equivalent file modifier that could be applied to the
 * non-physical copy of the file used to preview the modification.
 * May return itself if the action doesn't depend on the file.
 *
 * @param target target non-physical file
 * @return the action that could be applied to the non-physical copy of the file.
 * Returns null if operation is not supported.
 */
@Nullable
default FileModifier getFileModifierForPreview(@Nonnull PsiFile target) {
  if (!startInWriteAction()) return null;
  for (Field field : ReflectionUtil.collectFields(((Object)this).getClass())) {
    if (Modifier.isStatic(field.getModifiers())) continue;
    Class<?> type = field.getType();
    if (field.getAnnotation(SafeFieldForPreview.class) != null) continue;
    while (type.isArray()) type = type.getComponentType();
    if (type.isPrimitive() || type.isEnum() || type.equals(String.class) || type.equals(Class.class) || type.equals(Integer.class) || type.equals(Boolean.class) ||
        // Back-link to the parent inspection looks safe, as inspection should not depend on the file
        (field.isSynthetic() && field.getName().equals("this$0") && LocalInspectionTool.class.isAssignableFrom(type))) {
      continue;
    }
    return null;
  }
  // No PSI-specific state: it's safe to apply this action to a file copy
  return this;
}
 

@Nullable
protected QualityToolConfiguration getConfiguration(@NotNull Project project, @NotNull LocalInspectionTool inspection) {
    try {
        return PhpStanValidatorProjectConfiguration.getInstance(project).findSelectedConfiguration(project);
    } catch (QualityToolValidationException e) {
        return null;
    }
}
 

@javax.annotation.Nullable
public LocalInspectionToolWrapper getSharedLocalInspectionToolWrapper() {
  final LocalInspectionTool sharedTool = getTool().getSharedLocalInspectionTool();
  if (sharedTool == null) {
    return null;
  }
  return new LocalInspectionToolWrapper(sharedTool);
}
 

@Override
public void setUp() throws Exception {
  super.setUp();

  ApplicationStarter application = LightPlatformTestCase.initApplication();
  LightPlatformTestCase.doSetup(myProjectDescriptor, LocalInspectionTool.EMPTY_ARRAY, new THashMap<String, InspectionToolWrapper>());
  InjectedLanguageManagerImpl.pushInjectors(getProject());

 // application.setDataProvider(new TestDataProvider(getProject()));
}
 

private void executeTest(String filename) {
    Collection<Class<? extends LocalInspectionTool>> inspections = new ArrayList<Class<? extends
            LocalInspectionTool>>();
    inspections.add(NamespacePrefixFromFileName.class);
    myFixture.enableInspections(inspections);

    myFixture.testHighlighting(true, false, false, filename);
}
 

public void testRemoveUnusedNamespaceDeclarationQuickFix() {
    final String testName = getTestName();

    Collection<Class<? extends LocalInspectionTool>> inspections = new ArrayList<Class<? extends LocalInspectionTool>>();
    inspections.add(UnusedNamespaceDeclarationInspection.class);
    myFixture.enableInspections(inspections);
    myFixture.configureByFile(String.format("%s.xq", testName));

    List<IntentionAction> availableIntentions = myFixture.filterAvailableIntentions(REMOVE_UNUSED_NAMESPACE_DECLARATION_QUICKFIX_NAME);
    IntentionAction action = ContainerUtil.getFirstItem(availableIntentions);
    assertNotNull(action);
    myFixture.launchAction(action);

    myFixture.checkResultByFile(String.format("%s_after.xq", testName));
}
 

private void executeTest(String filename) {
    Collection<Class<? extends LocalInspectionTool>> inspections = new ArrayList<Class<? extends
            LocalInspectionTool>>();
    inspections.add(DefaultFunctionNamespaceSameAsModuleNamespace.class);
    myFixture.enableInspections(inspections);

    myFixture.testHighlighting(true, false, false, filename);
}
 

public void testRemoveUnusedImportQuickFix() {
    final String testName = getTestName();

    Collection<Class<? extends LocalInspectionTool>> inspections = new ArrayList<Class<? extends LocalInspectionTool>>();
    inspections.add(UnusedImportsInspection.class);
    myFixture.enableInspections(inspections);
    myFixture.configureByFile(String.format("%s.xq", testName));

    List<IntentionAction> availableIntentions = myFixture.filterAvailableIntentions(UnusedImportsInspection.REMOVE_UNUSED_IMPORT_QUICKFIX_NAME);
    IntentionAction action = ContainerUtil.getFirstItem(availableIntentions);
    assertNotNull(action);
    myFixture.launchAction(action);

    myFixture.checkResultByFile(String.format("%s_after.xq", testName));
}
 

private void executeTest(String filename) {
    Collection<Class<? extends LocalInspectionTool>> inspections = new ArrayList<Class<? extends
            LocalInspectionTool>>();
    inspections.add(MarklogicExtendedSyntaxInspection.class);
    myFixture.enableInspections(inspections);

    myFixture.testHighlighting(true, false, false, filename);
}
 

private void executeTest(String filename) {
    Collection<Class<? extends LocalInspectionTool>> inspections = new ArrayList<Class<? extends
            LocalInspectionTool>>();
    inspections.add(UnusedVariableInspection.class);
    myFixture.enableInspections(inspections);

    myFixture.testHighlighting(true, false, false, filename);
}
 

private void executeTest(String filename) {
    Collection<Class<? extends LocalInspectionTool>> inspections = new ArrayList<Class<? extends
            LocalInspectionTool>>();
    inspections.add(InvalidVersionInspection.class);
    myFixture.enableInspections(inspections);

    myFixture.testHighlighting(false, false, true, filename);
}
 

public static InspectionProfileEntry findInspectionProfileEntry(Class<? extends LocalInspectionTool> clazz) {
    LocalInspectionEP[] extensions = Extensions.getExtensions(LocalInspectionEP.LOCAL_INSPECTION);
    for (LocalInspectionEP extension : extensions) {
        if (extension.implementationClass.equals(clazz.getCanonicalName())) {
            extension.enabledByDefault = true;

            return extension.instantiateTool();
        }
    }

    throw new IllegalStateException("Unable to find inspection profile entry for " + clazz);
}
 

@Nullable
protected QualityToolConfiguration getConfiguration(@NotNull Project project, @NotNull LocalInspectionTool inspection) {
    try {
        return PsalmValidatorProjectConfiguration.getInstance(project).findSelectedConfiguration(project);
    } catch (QualityToolValidationException e) {
        return null;
    }
}
 

public EditInspectionToolsSettingsAction(@Nonnull LocalInspectionTool tool) {
  myShortName = tool.getShortName();
}
 

public DisableInspectionToolAction(LocalInspectionTool tool) {
  myToolId = tool.getShortName();
}
 

/** This should be used in tests primarily */
@TestOnly
public LocalInspectionToolWrapper(@Nonnull LocalInspectionTool tool) {
  super(tool, ourEPMap.getValue().get(tool.getShortName()));
}
 

@NotNull
@Override
protected LocalInspectionTool[] configureLocalInspectionTools() {
  return new LocalInspectionTool[] {new YamlReferenceInspection(indexFacade)};
}
 

public void doTest(@NonNls String folderName, LocalInspectionTool tool) throws Exception {
  doTest(folderName, new LocalInspectionToolWrapper(tool));
}
 

@NotNull
@Override
protected LocalInspectionTool[] configureLocalInspectionTools() {
  return new LocalInspectionTool[] {new JsonReferenceInspection(indexFacade)};
}
 

@Nonnull
protected LocalInspectionTool[] configureLocalInspectionTools() {
  return LocalInspectionTool.EMPTY_ARRAY;
}
 

@Override
protected Set<Class<? extends LocalInspectionTool>> provideInspectionClasses() {
    return singleton(CypherFunctionCallInspection.class);
}
 

@Override
protected Set<Class<? extends LocalInspectionTool>> provideInspectionClasses() {
    return singleton(CypherExplainWarningInspection.class);
}
 

private void executeInspectionTest(String filename) {
    Collection<Class<? extends LocalInspectionTool>> inspections = new ArrayList<Class<? extends LocalInspectionTool>>();
    inspections.add(UnusedNamespaceDeclarationInspection.class);
    myFixture.enableInspections(inspections);
    myFixture.testHighlighting(true, false, false, filename);
}
 

private void executeInspectionTest(String filename) {
    Collection<Class<? extends LocalInspectionTool>> inspections = new ArrayList<Class<? extends LocalInspectionTool>>();
    inspections.add(UnusedImportsInspection.class);
    myFixture.enableInspections(inspections);
    myFixture.testHighlighting(true, false, false, filename, "file1.xq", "file3.xq");
}
 

void enableInspections(@Nonnull Collection<Class<? extends LocalInspectionTool>> inspections); 

void enableInspections(@Nonnull Class<? extends LocalInspectionTool>... inspections); 

protected abstract Set<Class<? extends LocalInspectionTool>> provideInspectionClasses();