下面列出了怎么用com.intellij.psi.PsiExpressionList的API类实例代码及写法,或者点击链接到github查看源代码。
/** Creates new fix, that adds static method call as an argument to the originalMethodCall. */
static IntentionAction createAddMethodCallFix(
PsiMethodCallExpression originalMethodCall,
String clsName,
String methodName,
PsiElementFactory elementFactory) {
PsiExpressionList newArgumentList =
createArgumentList(originalMethodCall.getContext(), clsName, methodName, elementFactory);
String fixDescription =
"Add ." + methodName + "() " + getCapitalizedMethoName(originalMethodCall);
return new AddArgumentFix(originalMethodCall, newArgumentList, fixDescription);
}
static PsiExpressionList createArgumentList(
PsiElement context, String clsName, String methodName, PsiElementFactory elementFactory) {
final PsiMethodCallExpression stub =
(PsiMethodCallExpression)
elementFactory.createExpressionFromText(
"methodName(" + clsName + "." + methodName + "())", context);
return stub.getArgumentList();
}
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);
}
}
@Override
public JavaElementVisitor createPsiVisitor(@NonNull final JavaContext context) {
return new JavaElementVisitor() {
@Override
public void visitLambdaExpression(PsiLambdaExpression expression) {
if (!(expression.getParent() instanceof PsiExpressionList)) {
return;
}
PsiExpressionList exprList = (PsiExpressionList) expression.getParent();
if (!(exprList.getParent() instanceof PsiMethodCallExpression)) {
return;
}
PsiMethodCallExpression call = (PsiMethodCallExpression) exprList.getParent();
if (call.getType() == null) {
return;
}
String callType = call.getType().getCanonicalText();
if (!callType.startsWith("de.mobilej.thinr.Thinr")) {
return;
}
markLeakSuspects(expression, expression, context);
}
};
}
@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;
}
@Override
public PsiElement getPsiElementForCamelBeanMethod(PsiElement element) {
if (element instanceof PsiLiteral || element.getParent() instanceof PsiLiteralExpression) {
final PsiExpressionList expressionList = PsiTreeUtil.getParentOfType(element, PsiExpressionList.class);
if (expressionList != null) {
final PsiIdentifier identifier = PsiTreeUtil.getChildOfType(expressionList.getPrevSibling(), PsiIdentifier.class);
if (identifier != null && identifier.getNextSibling() == null && ("method" .equals(identifier.getText()) || "bean" .equals(identifier.getText()))) {
return expressionList;
}
}
}
return null;
}
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 AddArgumentFix(
PsiCall originalCall, PsiExpressionList newArgumentList, String description) {
this.originalCall = originalCall;
this.newArgumentList = newArgumentList;
setText(description);
}
@Override
public void annotate(PsiElement element, AnnotationHolder holder) {
DEBUG_LOGGER.logStep("start " + element);
// Implementation similar to {@link HighlightMethodUtil#checkMethodCall}
if (!(element instanceof PsiMethodCallExpression)) {
return;
}
// MethodCall == method usage
final PsiMethodCallExpression eventHandlerSetter = (PsiMethodCallExpression) element;
final PsiExpressionList list = eventHandlerSetter.getArgumentList();
if (!list.isEmpty()) {
return;
}
final String eventQualifiedName = resolveEventName(eventHandlerSetter);
if (eventQualifiedName == null) {
return;
}
final PsiClass parentCls =
(PsiClass) PsiTreeUtil.findFirstParent(eventHandlerSetter, PsiClass.class::isInstance);
if (parentCls == null) {
return;
}
final LayoutSpecModel parentLayoutModel = ComponentGenerateUtils.createLayoutModel(parentCls);
if (parentLayoutModel == null) {
return;
}
final ImmutableList<SpecMethodModel<EventMethod, EventDeclarationModel>>
implementedEventHandlers = parentLayoutModel.getEventMethods();
final String componentQualifiedName = parentLayoutModel.getComponentTypeName().toString();
final Project project = eventHandlerSetter.getProject();
final PsiElementFactory elementFactory = JavaPsiFacade.getInstance(project).getElementFactory();
final String message = "Add " + AddArgumentFix.getCapitalizedMethoName(eventHandlerSetter);
final SpecModelValidationError error = new SpecModelValidationError(list, message);
final List<IntentionAction> fixes =
implementedEventHandlers.stream()
.filter(handler -> eventQualifiedName.equals(handler.typeModel.name.reflectionName()))
.map(handler -> handler.name.toString())
.distinct()
.map(
methodName ->
AddArgumentFix.createAddMethodCallFix(
eventHandlerSetter, componentQualifiedName, methodName, elementFactory))
.collect(Collectors.toList());
final PsiClass event = PsiSearchUtils.findClass(project, eventQualifiedName);
if (event != null) {
fixes.add(
AddArgumentFix.createNewMethodCallFix(
eventHandlerSetter, componentQualifiedName, event, parentCls));
}
AnnotatorUtils.addError(holder, error, fixes);
DEBUG_LOGGER.logStep("end " + element);
}
@Nullable
@Override
public PsiExpressionList getArgumentList() {
return null;
}