Java AnonymousCanBeLambdaInspection类代码示例

import com.intellij.codeInspection.AnonymousCanBeLambdaInspection; //导入依赖的package包/类
@NotNull
public static String convertFunctionOrPredicateParameter(final @NotNull PsiExpression expression,
                                                         final boolean role) {
  if (role) {
    final String pattern = expression instanceof PsiMethodCallExpression || expression instanceof PsiReferenceExpression
                           ? "%s::isInstance"
                           : "(%s)::isInstance";
    return String.format(pattern, expression.getText());
  }
  if (expression instanceof PsiNewExpression) {
    final PsiAnonymousClass anonymousClass = ((PsiNewExpression)expression).getAnonymousClass();
    if (anonymousClass != null && AnonymousCanBeLambdaInspection.canBeConvertedToLambda(anonymousClass, true)) {
      final PsiExpression lambdaExpression = AnonymousCanBeLambdaInspection.replacePsiElementWithLambda(expression, true);
      LOG.assertTrue(lambdaExpression != null);
      return lambdaExpression.getText();
    }
  }
  String qualifierText = expression.getText();
  if (!(expression instanceof PsiMethodCallExpression) && !(expression instanceof PsiReferenceExpression)) {
    qualifierText = "(" + qualifierText + ")";
  }
  return qualifierText + "::apply";
}
 

import com.intellij.codeInspection.AnonymousCanBeLambdaInspection; //导入依赖的package包/类
protected void doAction() {
  final JavaRefactoringSettings settings = JavaRefactoringSettings.getInstance();
  settings.INTRODUCE_PARAMETER_REPLACE_FIELDS_WITH_GETTERS =
          myPanel.getReplaceFieldsWithGetters();
  if (myCbDeclareFinal != null && myCbDeclareFinal.isEnabled()) {
    settings.INTRODUCE_PARAMETER_CREATE_FINALS = Boolean.valueOf(myCbDeclareFinal.isSelected());
  }
  if (myCbCollapseToLambda.isVisible()) {
    PropertiesComponent.getInstance(myProject).setValue(INTRODUCE_PARAMETER_LAMBDA, myCbCollapseToLambda.isSelected());
  }

  myPanel.saveSettings(settings);

  myNameSuggestionsManager.nameSelected();

  boolean isDeleteLocalVariable = false;

  PsiExpression parameterInitializer = myExpression;
  if (myLocalVar != null) {
    if (myPanel.isUseInitializer()) {
      parameterInitializer = myLocalVar.getInitializer();    
    }
    isDeleteLocalVariable = myPanel.isDeleteLocalVariable();
  }

  final IntroduceParameterProcessor processor = new IntroduceParameterProcessor(
    myProject, myMethodToReplaceIn, myMethodToSearchFor,
    parameterInitializer, myExpression,
    myLocalVar, isDeleteLocalVariable,
    getParameterName(), myPanel.isReplaceAllOccurences(),
    myPanel.getReplaceFieldsWithGetters(), isDeclareFinal(), myPanel.isGenerateDelegate(), getSelectedType(), myPanel.getParametersToRemove());
  if (myCbCollapseToLambda.isVisible() && myCbCollapseToLambda.isSelected() && parameterInitializer != null) {
    PsiExpression lambda = AnonymousCanBeLambdaInspection.replaceAnonymousWithLambda(parameterInitializer, getSelectedType());
    if (lambda != null) {
      processor.setParameterInitializer(lambda);
    }
  }
  invokeRefactoring(processor);
}
 

import com.intellij.codeInspection.AnonymousCanBeLambdaInspection; //导入依赖的package包/类
@NotNull
@Override
protected LocalInspectionTool[] configureLocalInspectionTools() {
  return new LocalInspectionTool[]{
    new AnonymousCanBeLambdaInspection(),
  };
}
 

import com.intellij.codeInspection.AnonymousCanBeLambdaInspection; //导入依赖的package包/类
private static boolean perform(boolean replaceAllOccurrences,
                               int replaceFieldsWithGetters,
                               @NonNls String parameterName,
                               boolean searchForSuper,
                               boolean declareFinal,
                               boolean removeUnusedParameters,
                               boolean generateDelegate,
                               int enclosingLevel,
                               final boolean replaceDuplicates) {
  final ElementToWorkOn[] elementToWorkOn = new ElementToWorkOn[1];
  ElementToWorkOn.processElementToWorkOn(myEditor, myFile, "INtr param", HelpID.INTRODUCE_PARAMETER, getProject(),
                                         new ElementToWorkOn.ElementsProcessor<ElementToWorkOn>() {
                                           @Override
                                           public boolean accept(ElementToWorkOn el) {
                                             return true;
                                           }

                                           @Override
                                           public void pass(final ElementToWorkOn e) {
                                             if (e != null) {
                                               elementToWorkOn[0] = e;
                                             }
                                           }
                                         });

  final PsiExpression expr = elementToWorkOn[0].getExpression();
  final PsiLocalVariable localVar = elementToWorkOn[0].getLocalVariable();

  PsiElement context = expr == null ? localVar : expr;
  PsiMethod method = Util.getContainingMethod(context);
  if (method == null) return false;

  final List<PsiMethod> methods = com.intellij.refactoring.introduceParameter.IntroduceParameterHandler.getEnclosingMethods(method);
  assertTrue(methods.size() > enclosingLevel);
  method = methods.get(enclosingLevel);

  final PsiMethod methodToSearchFor;
  if (searchForSuper) {
    methodToSearchFor = method.findDeepestSuperMethods()[0];
  }
  else {
    methodToSearchFor = method;
  }
  PsiExpression[] occurrences;
  PsiExpression initializer;
  if (expr == null) {
    initializer = localVar.getInitializer();
    assertNotNull(initializer);
    occurrences = CodeInsightUtil.findReferenceExpressions(method, localVar);
  }
  else {
    initializer = expr;
    occurrences = new ExpressionOccurrenceManager(expr, method, null).findExpressionOccurrences();
  }
  TIntArrayList parametersToRemove = removeUnusedParameters ? Util.findParametersToRemove(method, initializer, occurrences)
                                                            : new TIntArrayList();
  IntroduceParameterProcessor processor = new IntroduceParameterProcessor(
    getProject(), method, methodToSearchFor, initializer, expr, localVar, true, parameterName, replaceAllOccurrences,
    replaceFieldsWithGetters, declareFinal, generateDelegate, null, parametersToRemove
  ) {
    @Override
    protected boolean isReplaceDuplicates() {
      return replaceDuplicates;
    }
  };
  PsiType initializerType = initializer.getType();
  if (initializerType != null && initializerType != PsiType.NULL) {
    PsiExpression lambda = AnonymousCanBeLambdaInspection.replaceAnonymousWithLambda(initializer, initializerType);
    if (lambda != null) {
      processor.setParameterInitializer(lambda);
    }
  }
  processor.run();

  myEditor.getSelectionModel().removeSelection();
  return true;
}