import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
public SingleCheckboxOptionsPanel(@NotNull String label,
                                  @NotNull InspectionProfileEntry owner,
                                  @NonNls String property) {
    super(new GridBagLayout());
    final boolean selected = getPropertyValue(owner, property);
    final JCheckBox checkBox = new JCheckBox(label, selected);
    final ButtonModel model = checkBox.getModel();
    final SingleCheckboxChangeListener listener =
            new SingleCheckboxChangeListener(owner, property, model);
    model.addChangeListener(listener);

    final GridBagConstraints constraints = new GridBagConstraints();
    constraints.gridx = 0;
    constraints.gridy = 0;
    constraints.weightx = 1.0;
    constraints.weighty = 1.0;
    constraints.anchor = GridBagConstraints.FIRST_LINE_START;
    constraints.fill = GridBagConstraints.HORIZONTAL;
    add(checkBox, constraints);
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
public SingleIntegerFieldOptionsPanel(String labelString,
                                      final InspectionProfileEntry owner,
                                      @NonNls final String property,
                                      int integerFieldColumns) {
    super(new GridBagLayout());
    final JLabel label = new JLabel(labelString);
    final JFormattedTextField valueField = createIntegerFieldTrackingValue(owner, property, integerFieldColumns);
    final GridBagConstraints constraints = new GridBagConstraints();
    constraints.gridx = 0;
    constraints.gridy = 0;
    constraints.insets.right = UIUtil.DEFAULT_HGAP;
    constraints.weightx = 0.0;
    constraints.anchor = GridBagConstraints.BASELINE_LEADING;
    constraints.fill = GridBagConstraints.NONE;
    add(label, constraints);
    constraints.gridx = 1;
    constraints.gridy = 0;
    constraints.weightx = 1.0;
    constraints.weighty = 1.0;
    constraints.insets.right = 0;
    constraints.anchor = GridBagConstraints.BASELINE_LEADING;
    constraints.fill = GridBagConstraints.NONE;
    add(valueField, constraints);
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
@Override
protected Ref<UnusedDeclarationInspectionBase> compute(PsiFile file, RefManagerImpl refManager) {
  Tools tools = ((GlobalInspectionContextBase)refManager.getContext()).getTools().get(UnusedDeclarationInspectionBase.SHORT_NAME);
  InspectionToolWrapper toolWrapper = tools == null ? null : tools.getEnabledTool(file);
  InspectionProfileEntry tool = toolWrapper == null ? null : toolWrapper.getTool();
  return Ref.create(tool instanceof UnusedDeclarationInspectionBase ? (UnusedDeclarationInspectionBase)tool : null);
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
@Nullable
@Override
protected InspectionProfileEntry getInspection() {
  final LambdaParameterNamingConventionInspection inspection = new LambdaParameterNamingConventionInspection();
  inspection.m_minLength = 2;
  return inspection;
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
protected void enableInspectionToolsFromProvider(InspectionToolProvider toolProvider){
  try {
    for (Class c : toolProvider.getInspectionClasses()) {
      enableInspectionTool((InspectionProfileEntry)c.newInstance());
    }
  }
  catch (Exception e) {
    throw new RuntimeException(e);
  }
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
  super.setUp();

  for (String environmentClass : getEnvironmentClasses()) {
    myFixture.addClass(environmentClass);
  }
  final InspectionProfileEntry inspection = getInspection();
  if (inspection != null) {
    myFixture.enableInspections(inspection);
  }
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
private static int getPropertyValue(InspectionProfileEntry owner,
                                    String property) {
    try {
        return owner.getClass().getField(property).getInt(owner);
    } catch (Exception e) {
        return 0;
    }
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
@Nullable
@Override
protected InspectionProfileEntry getInspection() {
  final TypeMayBeWeakenedInspection inspection = new TypeMayBeWeakenedInspection();
  inspection.doNotWeakenToJavaLangObject = false;
  inspection.onlyWeakentoInterface = false;
  return inspection;
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
public CheckBox(@NotNull String label,
                @NotNull InspectionProfileEntry owner,
                @NonNls String property) {
    super(label, getPropertyValue(owner, property));
    final ButtonModel model = getModel();
    final SingleCheckboxChangeListener listener =
            new SingleCheckboxChangeListener(owner, property, model);
    model.addChangeListener(listener);
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
public static boolean isToCheckFile(PsiFile file, @NotNull InspectionProfileEntry tool, Tools tools, ProfileManager profileManager) {
  if (tools != null && file != null) {
    for (ScopeToolState state : tools.getTools()) {
      final NamedScope namedScope = state.getScope(file.getProject());
      if (namedScope == null || namedScope.getValue().contains(file, profileManager.getScopesManager())) {
        if (state.isEnabled()) {
          InspectionToolWrapper toolWrapper = state.getTool();
          if (toolWrapper.getTool() == tool) return true;
        }
        return false;
      }
    }
  }
  return false;
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
@Override
public <T extends InspectionProfileEntry> void modifyToolSettings(@NotNull final Key<T> shortNameKey,
                                                                  @NotNull final PsiElement psiElement,
                                                                  @NotNull final Consumer<T> toolConsumer) {
  modifyProfile(new Consumer<ModifiableModel>() {
    @Override
    public void consume(@NotNull ModifiableModel model) {
      InspectionProfileEntry tool = model.getUnwrappedTool(shortNameKey.toString(), psiElement);
      //noinspection unchecked
      toolConsumer.consume((T) tool);
    }
  });
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
@Nullable
@Override
protected InspectionProfileEntry getInspection() {
  final MalformedFormatStringInspection inspection = new MalformedFormatStringInspection();
  inspection.classNames.add("com.siyeh.igtest.bugs.malformed_format_string.MalformedFormatString.SomeOtherLogger");
  inspection.methodNames.add("d");
  return inspection;
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
@Nullable
@Override
protected InspectionProfileEntry getInspection() {
  final ParameterNamingConventionInspection inspection = new ParameterNamingConventionInspection();
  inspection.m_minLength = 3;
  inspection.m_maxLength = 5;
  return inspection;
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
public static void configureInspections(@NotNull InspectionProfileEntry[] tools,
                                        @NotNull final Project project,
                                        @NotNull final Collection<String> disabledInspections,
                                        @NotNull Disposable parentDisposable) {
  InspectionToolWrapper[] wrapped =
    ContainerUtil.map2Array(tools, InspectionToolWrapper.class, new Function<InspectionProfileEntry, InspectionToolWrapper>() {
      @Override
      public InspectionToolWrapper fun(InspectionProfileEntry tool) {
        return InspectionToolRegistrar.wrapTool(tool);
      }
    });

  final InspectionProfileImpl profile = InspectionProfileImpl.createSimple(LightPlatformTestCase.PROFILE, project, wrapped);
  profile.disableToolByDefault(new ArrayList<String>(disabledInspections), project);

  final InspectionProfileManager inspectionProfileManager = InspectionProfileManager.getInstance();
  final Profile oldRootProfile = inspectionProfileManager.getRootProfile();
  inspectionProfileManager.addProfile(profile);
  Disposer.register(parentDisposable, new Disposable() {
    @Override
    public void dispose() {
      inspectionProfileManager.deleteProfile(profile.getName());
      inspectionProfileManager.setRootProfile(oldRootProfile.getName());
      clearAllToolsIn(InspectionProfileImpl.getDefaultProfile(), project);
    }
  });
  inspectionProfileManager.setRootProfile(profile.getName());
  InspectionProfileImpl.initAndDo(new Computable() {
    @Override
    public Object compute() {
      InspectionProjectProfileManager.getInstance(project).updateProfile(profile);
      InspectionProjectProfileManager.getInstance(project).setProjectProfile(profile.getName());
      return null;
    }
  });
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
private static boolean isAvailable(PyCallExpression node) {
  final InspectionProfile profile = InspectionProjectProfileManager.getInstance(node.getProject()).getInspectionProfile();
  final InspectionToolWrapper inspectionTool = profile.getInspectionTool("PyCompatibilityInspection", node.getProject());
  if (inspectionTool != null) {
    final InspectionProfileEntry inspection = inspectionTool.getTool();
    if (inspection instanceof PyCompatibilityInspection) {
      final JDOMExternalizableStringList versions = ((PyCompatibilityInspection)inspection).ourVersions;
      for (String s : versions) {
        if (!LanguageLevel.fromPythonVersion(s).supportsSetLiterals()) return false;
      }
    }
  }
  return LanguageLevel.forElement(node).supportsSetLiterals();
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
@Nullable
private static DomElementsInspection getSuitableInspection(InspectionProfileEntry entry, Class rootType) {
  if (entry instanceof DomElementsInspection) {
    if (((DomElementsInspection)entry).getDomClasses().contains(rootType)) {
      return (DomElementsInspection) entry;
    }
  }
  return null;
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
public TextField(@NotNull InspectionProfileEntry owner,
                 @NonNls String property) {
  super(getPropertyValue(owner, property));
  final DocumentListener documentListener =
    new TextFieldDocumentListener(owner, property);
  getDocument().addDocumentListener(documentListener);
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
@Nullable
@Override
protected InspectionProfileEntry getInspection() {
  RefusedBequestInspection inspection = new RefusedBequestInspection();
  inspection.onlyReportWhenAnnotated = false;
  return inspection;
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
@Override
protected InspectionProfileEntry getInspection() {
  final MagicNumberInspection tool = new MagicNumberInspection();
  tool.ignoreInHashCode = true;
  tool.ignoreInAnnotations = true;
  tool.ignoreInitialCapacity = true;
  return tool;
}
 

import com.intellij.codeInspection.InspectionProfileEntry; //导入依赖的package包/类
protected void enableInspectionTool(@NotNull InspectionProfileEntry tool) {
  InspectionToolWrapper toolWrapper = InspectionToolRegistrar.wrapTool(tool);
  LightPlatformTestCase.enableInspectionTool(getProject(), toolWrapper);
}