Skip to content

CommonClassNames elimination (part 1) #167

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 2 commits into from
May 8, 2025
Merged

CommonClassNames elimination (part 1) #167

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
ffd7f00
Reformatting users of CommonClassNames.
unv-unv May 7, 2025
c32c881
Replacing CommonClassNames with JavaClassNames (part 1). Refactoring.
unv-unv May 8, 2025
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
448 changes: 228 additions & 220 deletions ...n/java/com/intellij/java/analysis/impl/codeInsight/DefaultInferredAnnotationProvider.java
View file
Open in desktop

Large diffs are not rendered by default.

225 changes: 120 additions & 105 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 @@ -35,128 +35,143 @@

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

import java.util.Collection;

/**
* @author Dmitry Batkovich
*/
public class WrapObjectWithOptionalOfNullableFix extends MethodArgumentFix implements HighPriorityAction {
public static final ArgumentFixerActionFactory REGISTAR = new MyFixerActionFactory();

protected WrapObjectWithOptionalOfNullableFix(final @Nonnull PsiExpressionList list,
final int i,
final @Nonnull PsiType toType,
final @Nonnull ArgumentFixerActionFactory fixerActionFactory) {
super(list, i, toType, fixerActionFactory);
}

@Nonnull
@Override
public String getText() {
if (myArgList.getExpressionCount() == 1) {
return JavaQuickFixBundle.message("wrap.with.optional.single.parameter.text");
} else {
return JavaQuickFixBundle.message("wrap.with.optional.parameter.text", myIndex + 1);
}
}

@Override
public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) {
return PsiUtil.isLanguageLevel8OrHigher(file) && super.isAvailable(project, editor, file);
}

public static IntentionAction createFix(@Nullable PsiType type, @Nonnull PsiExpression expression) {
class MyFix extends LocalQuickFixAndIntentionActionOnPsiElement implements HighPriorityAction {
protected MyFix(@Nullable PsiElement element) {
super(element);
}

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

@Override
public void invoke(@Nonnull Project project,
@Nonnull PsiFile file,
@Nullable Editor editor,
@Nonnull PsiElement startElement,
@Nonnull PsiElement endElement) {
startElement.replace(getModifiedExpression((PsiExpression) getStartElement()));
}

@Override
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);
}

@Nonnull
@Override
public String getText() {
return getFamilyName();
}
public static final ArgumentFixerActionFactory REGISTAR = new MyFixerActionFactory();

protected WrapObjectWithOptionalOfNullableFix(
final @Nonnull PsiExpressionList list,
final int i,
final @Nonnull PsiType toType,
final @Nonnull ArgumentFixerActionFactory fixerActionFactory
) {
super(list, i, toType, fixerActionFactory);
}
return new MyFix(expression);
}

public static class MyFixerActionFactory extends ArgumentFixerActionFactory {

@Nullable
@Nonnull
@Override
protected PsiExpression getModifiedArgument(final PsiExpression expression, final PsiType toType) throws IncorrectOperationException {
return getModifiedExpression(expression);
public String getText() {
if (myArgList.getExpressionCount() == 1) {
return JavaQuickFixBundle.message("wrap.with.optional.single.parameter.text");
}
else {
return JavaQuickFixBundle.message("wrap.with.optional.parameter.text", myIndex + 1);
}
}

@Override
public boolean areTypesConvertible(@Nonnull final PsiType exprType, @Nonnull final PsiType parameterType, @Nonnull final PsiElement context) {
return parameterType.isConvertibleFrom(exprType) || areConvertible(exprType, parameterType);
public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) {
return PsiUtil.isLanguageLevel8OrHigher(file) && super.isAvailable(project, editor, file);
}

@Override
public MethodArgumentFix createFix(final PsiExpressionList list, final int i, final 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()) {
return false;
}
final PsiClassType.ClassResolveResult resolve = ((PsiClassType) parameterType).resolveGenerics();
final PsiClass resolvedClass = resolve.getElement();
if (resolvedClass == null || !CommonClassNames.JAVA_UTIL_OPTIONAL.equals(resolvedClass.getQualifiedName())) {
return false;
public static IntentionAction createFix(@Nullable PsiType type, @Nonnull PsiExpression expression) {
class MyFix extends LocalQuickFixAndIntentionActionOnPsiElement implements HighPriorityAction {
protected MyFix(@Nullable PsiElement element) {
super(element);
}

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

@Override
public void invoke(
@Nonnull Project project,
@Nonnull PsiFile file,
@Nullable Editor editor,
@Nonnull PsiElement startElement,
@Nonnull PsiElement endElement
) {
startElement.replace(getModifiedExpression((PsiExpression)getStartElement()));
}

@Override
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);
}

@Nonnull
@Override
public String getText() {
return getFamilyName();
}
}
return new MyFix(expression);
}

final Collection<PsiType> values = resolve.getSubstitutor().getSubstitutionMap().values();
if (values.isEmpty()) {
return true;
public static class MyFixerActionFactory extends ArgumentFixerActionFactory {

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

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

@Override
public MethodArgumentFix createFix(final PsiExpressionList list, final int i, final PsiType toType) {
return new WrapObjectWithOptionalOfNullableFix(list, i, toType, this);
}
}
if (values.size() > 1) {
return false;

private static boolean areConvertible(@Nullable PsiType exprType, @Nullable PsiType parameterType) {
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())) {
return false;
}

final 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);
}
final PsiType optionalTypeParameter = ContainerUtil.getFirstItem(values);
if (optionalTypeParameter == null) {
return false;

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

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