Skip to content

Replacing CommonClassNames with JavaClassNames (part 4). Refactoring #172

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
VISTALL merged 1 commit into from
May 9, 2025
Merged

Replacing CommonClassNames with JavaClassNames (part 4). Refactoring #172

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
73 changes: 36 additions & 37 deletions ...a/analysis/impl/codeInsight/daemon/impl/quickfix/WrapObjectWithOptionalOfNullableFix.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,8 +20,10 @@
import com.intellij.java.language.psi.*;
import com.intellij.java.language.psi.util.PsiUtil;
import com.intellij.java.language.psi.util.TypeConversionUtil;
import consulo.annotation.access.RequiredReadAction;
import consulo.codeEditor.Editor;
import consulo.java.analysis.impl.JavaQuickFixBundle;
import consulo.java.analysis.impl.localize.JavaQuickFixLocalize;
import consulo.java.language.module.util.JavaClassNames;
import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement;
import consulo.language.editor.intention.BaseIntentionAction;
import consulo.language.editor.intention.HighPriorityAction;
Expand All @@ -31,8 +33,6 @@
import consulo.language.util.IncorrectOperationException;
import consulo.project.Project;
import consulo.util.collection.ContainerUtil;
import org.jetbrains.annotations.Nls;

import jakarta.annotation.Nonnull;
import jakarta.annotation.Nullable;

Expand All @@ -45,10 +45,10 @@ public class WrapObjectWithOptionalOfNullableFix extends MethodArgumentFix imple
public static final ArgumentFixerActionFactory REGISTAR = new MyFixerActionFactory();

protected WrapObjectWithOptionalOfNullableFix(
final @Nonnull PsiExpressionList list,
final int i,
final @Nonnull PsiType toType,
final @Nonnull ArgumentFixerActionFactory fixerActionFactory
@Nonnull PsiExpressionList list,
int i,
@Nonnull PsiType toType,
@Nonnull ArgumentFixerActionFactory fixerActionFactory
) {
super(list, i, toType, fixerActionFactory);
}
Expand All @@ -57,14 +57,15 @@ protected WrapObjectWithOptionalOfNullableFix(
@Override
public String getText() {
if (myArgList.getExpressionCount() == 1) {
return JavaQuickFixBundle.message("wrap.with.optional.single.parameter.text");
return JavaQuickFixLocalize.wrapWithOptionalSingleParameterText().get();
}
else {
return JavaQuickFixBundle.message("wrap.with.optional.parameter.text", myIndex + 1);
return JavaQuickFixLocalize.wrapWithOptionalParameterText(myIndex + 1).get();
}
}

@Override
@RequiredReadAction
public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) {
return PsiUtil.isLanguageLevel8OrHigher(file) && super.isAvailable(project, editor, file);
}
Expand All @@ -75,13 +76,13 @@ protected MyFix(@Nullable PsiElement element) {
super(element);
}

@Nls
@Nonnull
@Override
public String getFamilyName() {
return JavaQuickFixBundle.message("wrap.with.optional.single.parameter.text");
return JavaQuickFixLocalize.wrapWithOptionalSingleParameterText().get();
}

@RequiredReadAction
@Override
public void invoke(
@Nonnull Project project,
Expand All @@ -94,14 +95,16 @@ public void invoke(
}

@Override
@RequiredReadAction
public boolean isAvailable(
@Nonnull Project project,
@Nonnull PsiFile file,
@Nonnull PsiElement startElement,
@Nonnull PsiElement endElement
) {
return BaseIntentionAction.canModify(startElement) &&
PsiUtil.isLanguageLevel8OrHigher(startElement) && areConvertible(((PsiExpression)startElement).getType(), type);
return BaseIntentionAction.canModify(startElement)
&& PsiUtil.isLanguageLevel8OrHigher(startElement)
&& areConvertible(((PsiExpression)startElement).getType(), type);
}

@Nonnull
Expand All @@ -117,61 +120,57 @@ public static class MyFixerActionFactory extends ArgumentFixerActionFactory {

@Nullable
@Override
protected PsiExpression getModifiedArgument(
final PsiExpression expression,
final PsiType toType
) throws IncorrectOperationException {
@RequiredReadAction
protected PsiExpression getModifiedArgument(PsiExpression expression, PsiType toType) throws IncorrectOperationException {
return getModifiedExpression(expression);
}

@Override
public boolean areTypesConvertible(
@Nonnull final PsiType exprType,
@Nonnull final PsiType parameterType,
@Nonnull final PsiElement context
@Nonnull PsiType exprType,
@Nonnull PsiType parameterType,
@Nonnull PsiElement context
) {
return parameterType.isConvertibleFrom(exprType) || areConvertible(exprType, parameterType);
}

@Override
public MethodArgumentFix createFix(final PsiExpressionList list, final int i, final PsiType toType) {
public MethodArgumentFix createFix(PsiExpressionList list, int i, PsiType toType) {
return new WrapObjectWithOptionalOfNullableFix(list, i, toType, this);
}
}

private static boolean areConvertible(@Nullable PsiType exprType, @Nullable PsiType parameterType) {
if (exprType == null ||
!exprType.isValid() ||
!(parameterType instanceof PsiClassType) ||
!parameterType.isValid()) {
if (exprType == null
|| !exprType.isValid()
|| !(parameterType instanceof PsiClassType)
|| !parameterType.isValid()) {
return false;
}
final PsiClassType.ClassResolveResult resolve = ((PsiClassType)parameterType).resolveGenerics();
final PsiClass resolvedClass = resolve.getElement();
if (resolvedClass == null || !CommonClassNames.JAVA_UTIL_OPTIONAL.equals(resolvedClass.getQualifiedName())) {
PsiClassType.ClassResolveResult resolve = ((PsiClassType)parameterType).resolveGenerics();
PsiClass resolvedClass = resolve.getElement();
if (resolvedClass == null || !JavaClassNames.JAVA_UTIL_OPTIONAL.equals(resolvedClass.getQualifiedName())) {
return false;
}

final Collection<PsiType> values = resolve.getSubstitutor().getSubstitutionMap().values();
Collection<PsiType> values = resolve.getSubstitutor().getSubstitutionMap().values();
if (values.isEmpty()) {
return true;
}
if (values.size() > 1) {
return false;
}
final PsiType optionalTypeParameter = ContainerUtil.getFirstItem(values);
if (optionalTypeParameter == null) {
return false;
}
return TypeConversionUtil.isAssignable(optionalTypeParameter, exprType);
PsiType optionalTypeParameter = ContainerUtil.getFirstItem(values);
return optionalTypeParameter != null && TypeConversionUtil.isAssignable(optionalTypeParameter, exprType);
}

@Nonnull
@RequiredReadAction
private static PsiExpression getModifiedExpression(PsiExpression expression) {
final Project project = expression.getProject();
final Nullability nullability = NullabilityUtil.getExpressionNullability(expression, true);
Project project = expression.getProject();
Nullability nullability = NullabilityUtil.getExpressionNullability(expression, true);
String methodName = nullability == Nullability.NOT_NULL ? "of" : "ofNullable";
final String newExpressionText = CommonClassNames.JAVA_UTIL_OPTIONAL + "." + methodName + "(" + expression.getText() + ")";
String newExpressionText = JavaClassNames.JAVA_UTIL_OPTIONAL + "." + methodName + "(" + expression.getText() + ")";
return JavaPsiFacade.getElementFactory(project).createExpressionFromText(newExpressionText, expression);
}
}
Loading
Loading