com.intellij.psi.PsiExpression Java Examples

@Override
public IntroduceVariableSettings getSettings(Project project, Editor editor, PsiExpression expr,
                                             PsiExpression[] occurrences, TypeSelectorManagerImpl typeSelectorManager,
                                             boolean declareFinalIfAll, boolean anyAssignmentLHS, InputValidator validator,
                                             PsiElement anchor, JavaReplaceChoice replaceChoice) {
  final IntroduceVariableSettings variableSettings;

  if (ApplicationManager.getApplication().isUnitTestMode()) {
    variableSettings = new UnitTestMockVariableSettings(expr);
  } else {
    variableSettings = super.getSettings(project, editor, expr, occurrences, typeSelectorManager, declareFinalIfAll,
      anyAssignmentLHS, validator, anchor, replaceChoice);
  }

  return getIntroduceVariableSettings(project, variableSettings);
}
 

private void visitPsiFields(final PsiField psiField) {
    if (!ClassUtils.isPrimitive(psiField.getType())) {
        String type = removeSpecialSymbols(psiField.getType().getCanonicalText());
        if (psiField.getInitializer() != null) {
            PsiExpression psiExpression = psiField.getInitializer();
            if (psiExpression != null) {
                PsiType psiType = psiExpression.getType();
                if (psiType != null && !ClassUtils.isPrimitive(psiType)) {
                    String psiFieldInitializer =
                            removeSpecialSymbols(psiType.getCanonicalText());
                    addInMap(psiFieldInitializer, emptySet);
                }
            }
        }
        addInMap(type, emptySet);
    }
}
 

@Test
public void createMethodChain() {
  testHelper.runInReadAction(
      project -> {
        List<String> names = new ArrayList<>(2);
        names.add("methodName1");
        names.add("otherName");

        PsiExpression methodChain =
            MethodChainLookupElement.createMethodChain(project, "methodNameBase", names);
        assertEquals(
            "methodNameBase(insert_placeholder_c)\n"
                + ".methodName1(insert_placeholder)\n"
                + ".otherName(insert_placeholder)",
            methodChain.getText());
      });
}
 

@VisibleForTesting
static PsiExpression createMethodChain(
    Project project, String firstName, List<? extends String> methodNames) {
  PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);
  StringBuilder expressionText =
      new StringBuilder(firstName + "(" + TEMPLATE_INSERT_PLACEHOLDER_C + ")");
  methodNames.forEach(
      methodName ->
          expressionText
              .append("\n.")
              .append(methodName)
              .append("(")
              .append(TEMPLATE_INSERT_PLACEHOLDER)
              .append(")"));
  return factory.createExpressionFromText(expressionText.toString(), null);
}
 

public String toString() {
    PsiExpression expression = getExpression();
    if (expression == null || expression.getType() == null) {
        return "";
    } else {
        return expression.getType().getCanonicalText();
    }
}
 

@Override
public void invoke(@NotNull Project project, @NotNull PsiFile psiFile, @NotNull PsiElement startElement, @NotNull PsiElement endElement) {
  final PsiClass myClass = (PsiClass) startElement;
  final Editor editor = CodeInsightUtil.positionCursor(project, psiFile, myClass.getLBrace());
  if (editor != null) {
    WriteCommandAction.writeCommandAction(project, psiFile).run(() ->
      {
        final PsiElementFactory psiElementFactory = JavaPsiFacade.getElementFactory(project);
        final PsiField psiField = psiElementFactory.createField(myName, myType);

        final PsiModifierList modifierList = psiField.getModifierList();
        if (null != modifierList) {
          for (String modifier : myModifiers) {
            modifierList.setModifierProperty(modifier, true);
          }
        }
        if (null != myInitializerText) {
          PsiExpression psiInitializer = psiElementFactory.createExpressionFromText(myInitializerText, psiField);
          psiField.setInitializer(psiInitializer);
        }

        final List<PsiGenerationInfo<PsiField>> generationInfos = GenerateMembersUtil.insertMembersAtOffset(myClass.getContainingFile(), editor.getCaretModel().getOffset(),
          Collections.singletonList(new PsiGenerationInfo<>(psiField)));
        if (!generationInfos.isEmpty()) {
          PsiField psiMember = generationInfos.iterator().next().getPsiMember();
          editor.getCaretModel().moveToOffset(psiMember.getTextRange().getEndOffset());
        }

        UndoUtil.markPsiFileForUndo(psiFile);
      }
    );
  }
}
 

public static void translate(PsiPolyadicExpression element, TranslationContext ctx) {
    for (PsiExpression expression : element.getOperands()) {
        PsiJavaToken token = element.getTokenBeforeOperand(expression);
        if (token != null) {
            ctx.append(' ');
            JavaTokenTranslator.translate(token, ctx);
            ctx.append(' ');
        }
        ExpressionTranslator.translate(expression, ctx);
    }
}
 

public static void translate(PsiExpressionList element, TranslationContext ctx) {
    PsiExpression[] arguments = element.getExpressions();
    for (int i = 0; i < arguments.length; i++) {
        ExpressionTranslator.translate(arguments[i], ctx);
        if (i != arguments.length - 1) {
            ctx.append(", ");
        }
    }
}
 

private void visitPsiReturnStatement(final PsiReturnStatement element) {
    PsiExpression returnValue = element.getReturnValue();
    if (returnValue != null) {
        PsiType returnType = returnValue.getType();
        if (returnType != null) {
            String qualifiedName = removeSpecialSymbols(returnType.getCanonicalText());
            addInMap(qualifiedName, emptySet);
        }
    }
}
 

private void visitPsiReferenceExpression(final PsiReferenceExpression element) {
    PsiExpression psiExpression = element.getQualifierExpression();
    if (psiExpression != null) {
        PsiType psiType = psiExpression.getType();
        if (psiType != null) {
            String qualifiedName = removeSpecialSymbols(psiType.getCanonicalText());
            addInMap(qualifiedName, emptySet);
        }
    }
}
 

/**
 * Returns the first operand from a {@link PsiPolyadicExpression}
 *
 * @param psiLiteralExpression the {@link PsiLiteralExpression} that is part of a {@link PsiPolyadicExpression}
 * @return the first {@link PsiExpression} if the given {@link PsiLiteralExpression} is part of a {@link PsiPolyadicExpression}, null otherwise
 */
@Nullable
private static PsiExpression getFirstExpressionFromPolyadicExpression(PsiLiteralExpression psiLiteralExpression) {
    if (isPartOfPolyadicExpression(psiLiteralExpression)) {
        PsiPolyadicExpression psiPolyadicExpression = PsiTreeUtil.getParentOfType(psiLiteralExpression, PsiPolyadicExpression.class);
        if (psiPolyadicExpression != null) {
            return psiPolyadicExpression.getOperands()[0];
        }
    }
    return null;
}
 

@Nullable
@Override
public String getQuickNavigateInfo(PsiElement element, PsiElement originalElement) {
    if (ServiceManager.getService(element.getProject(), CamelService.class).isCamelPresent()) {
        PsiExpressionList exps = PsiTreeUtil.getNextSiblingOfType(originalElement, PsiExpressionList.class);
        if (exps != null) {
            if (exps.getExpressions().length >= 1) {
                // grab first string parameter (as the string would contain the camel endpoint uri
                final PsiClassType stringType = PsiType.getJavaLangString(element.getManager(), element.getResolveScope());
                PsiExpression exp = Arrays.stream(exps.getExpressions()).filter(
                    e -> e.getType() != null && stringType.isAssignableFrom(e.getType()))
                    .findFirst().orElse(null);
                if (exp instanceof PsiLiteralExpression) {
                    Object o = ((PsiLiteralExpression) exp).getValue();
                    String val = o != null ? o.toString() : null;
                    // okay only allow this popup to work when its from a RouteBuilder class
                    PsiClass clazz = PsiTreeUtil.getParentOfType(originalElement, PsiClass.class);
                    if (clazz != null) {
                        PsiClassType[] types = clazz.getExtendsListTypes();
                        boolean found = Arrays.stream(types).anyMatch(p -> p.getClassName().equals("RouteBuilder"));
                        if (found) {
                            String componentName = asComponentName(val);
                            if (componentName != null) {
                                // the quick info cannot be so wide so wrap at 120 chars
                                return generateCamelComponentDocumentation(componentName, val, 120, element.getProject());
                            }
                        }
                    }
                }
            }
        }
    }

    return null;
}
 

private static void handleMethodCall(
    PsiMethodCallExpression currentMethodCall,
    Set<String> methodNamesCalled,
    BiConsumer<Collection<String>, PsiReferenceExpression> errorHandler,
    Function<PsiMethodCallExpression, PsiClass> generatedClassResolver) {
  PsiReferenceExpression methodExpression = currentMethodCall.getMethodExpression();
  methodNamesCalled.add(methodExpression.getReferenceName());

  // Assumption to find next method in a call chain
  PsiMethodCallExpression nextMethodCall =
      PsiTreeUtil.getChildOfType(methodExpression, PsiMethodCallExpression.class);
  if (nextMethodCall != null) {
    handleMethodCall(nextMethodCall, methodNamesCalled, errorHandler, generatedClassResolver);
  } else if ("create".equals(methodExpression.getReferenceName())) {
    // Finish call chain
    // TODO T47712852: allow setting required prop in another statement
    Optional.ofNullable(generatedClassResolver.apply(currentMethodCall))
        .map(generatedCls -> collectMissingRequiredProps(generatedCls, methodNamesCalled))
        .filter(result -> !result.isEmpty())
        .ifPresent(
            missingRequiredProps -> errorHandler.accept(missingRequiredProps, methodExpression));
  }

  PsiExpressionList argumentList = currentMethodCall.getArgumentList();
  for (PsiExpression argument : argumentList.getExpressions()) {
    handleIfMethodCall(argument, errorHandler, generatedClassResolver);
  }
}
 

private static void handleIfMethodCall(
    @Nullable PsiExpression expression,
    BiConsumer<Collection<String>, PsiReferenceExpression> errorHandler,
    Function<PsiMethodCallExpression, PsiClass> generatedClassResolver) {
  if (expression instanceof PsiMethodCallExpression) {
    PsiMethodCallExpression rootMethodCall = (PsiMethodCallExpression) expression;
    handleMethodCall(rootMethodCall, new HashSet<>(), errorHandler, generatedClassResolver);
  }
}
 

private void processExpression(PsiExpression expression) {
    ExpressionExtractor expressionExtractor = new ExpressionExtractor();
    List<PsiExpression> assignments = expressionExtractor.getAssignments(expression);
    List<PsiExpression> postfixExpressions = expressionExtractor.getPostfixExpressions(expression);
    List<PsiExpression> prefixExpressions = expressionExtractor.getPrefixExpressions(expression);
    processVariables(expressionExtractor.getVariableInstructions(expression), assignments, postfixExpressions, prefixExpressions);
    processMethodInvocations(expressionExtractor.getMethodInvocations(expression));
    processClassInstanceCreations(expressionExtractor.getClassInstanceCreations(expression));
    processArrayCreations(expressionExtractor.getArrayCreations(expression));
    processLiterals(expressionExtractor.getLiterals(expression));
}
 

public boolean instanceOf(PsiExpression expression) {
    return expression instanceof PsiMethodCallExpression;
}
 

@Override
protected void expandForChooseExpression(@NotNull PsiElement expression, @NotNull Editor editor) {
  IntroduceVariableHandler handler = new IntroduceLombokVariableHandler(selectedTypeFQN);
  handler.invoke(expression.getProject(), editor, (PsiExpression) expression);
}
 

UnitTestMockVariableSettings(PsiExpression expr) {
  this.expr = expr;
}
 

public boolean instanceOf(PsiExpression expression) {
    return expression instanceof PsiPostfixExpression;
}
 

public boolean instanceOf(PsiExpression expression) {
	return expression instanceof PsiBinaryExpression;
}
 

public static void translate(PsiArrayInitializerExpression element, TranslationContext ctx) {
    boolean hasToBeClosed, isByteArray = false;
    if (ctx.NATIVE_ARRAY && element.getType() != null && element.getType().equalsToText("int[]")) {
        ctx.append("new Int32Array([");
        hasToBeClosed = true;
    } else if (ctx.NATIVE_ARRAY && element.getType() != null && element.getType().equalsToText("double[]")) {
        ctx.append("new Float64Array([");
        hasToBeClosed = true;
    } else if (ctx.NATIVE_ARRAY && element.getType() != null && element.getType().equalsToText("long[]")) {
        ctx.append("new Float64Array([");
        hasToBeClosed = true;
    } else if (ctx.NATIVE_ARRAY && element.getType() != null && element.getType().equalsToText("byte[]")) {
        ctx.append("new Int8Array([");
        hasToBeClosed = true;
    } else {
        ctx.append("[");
        hasToBeClosed = false;
    }
    PsiExpression[] initializers = element.getInitializers();
    if (element.getType() != null &&
            element.getType().getPresentableText().equals("byte[]")) {
        isByteArray = true;
    }
    if (initializers.length > 0) {
        for (int i = 0; i < initializers.length; i++) {
            ExpressionTranslator.translate(initializers[i], ctx);
            if (isByteArray &&
                    initializers[i].getType() != null &&
                    initializers[i].getType().getPresentableText().equals("char")) {
                ctx.append(".charCodeAt(0)");
            }
            if (i != initializers.length - 1) {
                ctx.append(", ");
            }
        }
    }
    ctx.append("]");
    if (hasToBeClosed) {
        ctx.append(")");
    }
}
 

@Override
public boolean value(PsiElement element) {
    return InheritanceUtil.isInheritor(((PsiExpression) element).getType(), "java.lang.CharSequence") && !AndroidPostfixTemplatesUtils.isAnnotatedNullable(element);
}
 

public boolean instanceOf(PsiExpression expression) {
    return expression instanceof PsiPrefixExpression;
}
 

public boolean instanceOf(PsiExpression expression) {
	return expression instanceof PsiSuperExpression;
}
 

public boolean instanceOf(PsiExpression expression) {
	return expression instanceof PsiTypeCastExpression;
}
 

public boolean instanceOf(PsiExpression expression) {
	return expression instanceof PsiNewExpression;
}
 

public boolean instanceOf(PsiExpression expression) {
	return expression instanceof PsiSuperExpression;
}
 

public boolean instanceOf(PsiExpression expression) {
	return expression instanceof PsiAssignmentExpression;
}
 

public boolean instanceOf(PsiExpression expression) {
    return (expression instanceof PsiReferenceExpression &&
            ((PsiReferenceExpression) expression).resolve() instanceof PsiVariable);
}
 

public boolean instanceOf(PsiExpression expression) {
	return expression instanceof PsiNewExpression;
}