Skip to content

Commit ffd7f00

Browse files
unv-unvunv-unv
committed
Reformatting users of CommonClassNames.
1 parent 1b6904b commit ffd7f00

45 files changed

Lines changed: 15879 additions & 15040 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/DefaultInferredAnnotationProvider.java‎

Lines changed: 228 additions & 220 deletions
Large diffs are not rendered by default.

‎java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/quickfix/WrapObjectWithOptionalOfNullableFix.java‎

Lines changed: 120 additions & 105 deletions
Original file line numberDiff line numberDiff line change
@@ -35,128 +35,143 @@
3535

3636
import jakarta.annotation.Nonnull;
3737
import jakarta.annotation.Nullable;
38+
3839
import java.util.Collection;
3940

4041
/**
4142
* @author Dmitry Batkovich
4243
*/
4344
public class WrapObjectWithOptionalOfNullableFix extends MethodArgumentFix implements HighPriorityAction {
44-
public static final ArgumentFixerActionFactory REGISTAR = new MyFixerActionFactory();
45-
46-
protected WrapObjectWithOptionalOfNullableFix(final @Nonnull PsiExpressionList list,
47-
final int i,
48-
final @Nonnull PsiType toType,
49-
final @Nonnull ArgumentFixerActionFactory fixerActionFactory) {
50-
super(list, i, toType, fixerActionFactory);
51-
}
52-
53-
@Nonnull
54-
@Override
55-
public String getText() {
56-
if (myArgList.getExpressionCount() == 1) {
57-
return JavaQuickFixBundle.message("wrap.with.optional.single.parameter.text");
58-
} else {
59-
return JavaQuickFixBundle.message("wrap.with.optional.parameter.text", myIndex + 1);
60-
}
61-
}
62-
63-
@Override
64-
public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) {
65-
return PsiUtil.isLanguageLevel8OrHigher(file) && super.isAvailable(project, editor, file);
66-
}
67-
68-
public static IntentionAction createFix(@Nullable PsiType type, @Nonnull PsiExpression expression) {
69-
class MyFix extends LocalQuickFixAndIntentionActionOnPsiElement implements HighPriorityAction {
70-
protected MyFix(@Nullable PsiElement element) {
71-
super(element);
72-
}
73-
74-
@Nls
75-
@Nonnull
76-
@Override
77-
public String getFamilyName() {
78-
return JavaQuickFixBundle.message("wrap.with.optional.single.parameter.text");
79-
}
80-
81-
@Override
82-
public void invoke(@Nonnull Project project,
83-
@Nonnull PsiFile file,
84-
@Nullable Editor editor,
85-
@Nonnull PsiElement startElement,
86-
@Nonnull PsiElement endElement) {
87-
startElement.replace(getModifiedExpression((PsiExpression) getStartElement()));
88-
}
89-
90-
@Override
91-
public boolean isAvailable(@Nonnull Project project,
92-
@Nonnull PsiFile file,
93-
@Nonnull PsiElement startElement,
94-
@Nonnull PsiElement endElement) {
95-
return BaseIntentionAction.canModify(startElement) &&
96-
PsiUtil.isLanguageLevel8OrHigher(startElement) && areConvertible(((PsiExpression) startElement).getType(), type);
97-
}
98-
99-
@Nonnull
100-
@Override
101-
public String getText() {
102-
return getFamilyName();
103-
}
45+
public static final ArgumentFixerActionFactory REGISTAR = new MyFixerActionFactory();
46+
47+
protected WrapObjectWithOptionalOfNullableFix(
48+
final @Nonnull PsiExpressionList list,
49+
final int i,
50+
final @Nonnull PsiType toType,
51+
final @Nonnull ArgumentFixerActionFactory fixerActionFactory
52+
) {
53+
super(list, i, toType, fixerActionFactory);
10454
}
105-
return new MyFix(expression);
106-
}
10755

108-
public static class MyFixerActionFactory extends ArgumentFixerActionFactory {
109-
110-
@Nullable
56+
@Nonnull
11157
@Override
112-
protected PsiExpression getModifiedArgument(final PsiExpression expression, final PsiType toType) throws IncorrectOperationException {
113-
return getModifiedExpression(expression);
58+
public String getText() {
59+
if (myArgList.getExpressionCount() == 1) {
60+
return JavaQuickFixBundle.message("wrap.with.optional.single.parameter.text");
61+
}
62+
else {
63+
return JavaQuickFixBundle.message("wrap.with.optional.parameter.text", myIndex + 1);
64+
}
11465
}
11566

11667
@Override
117-
public boolean areTypesConvertible(@Nonnull final PsiType exprType, @Nonnull final PsiType parameterType, @Nonnull final PsiElement context) {
118-
return parameterType.isConvertibleFrom(exprType) || areConvertible(exprType, parameterType);
68+
public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) {
69+
return PsiUtil.isLanguageLevel8OrHigher(file) && super.isAvailable(project, editor, file);
11970
}
12071

121-
@Override
122-
public MethodArgumentFix createFix(final PsiExpressionList list, final int i, final PsiType toType) {
123-
return new WrapObjectWithOptionalOfNullableFix(list, i, toType, this);
124-
}
125-
}
126-
127-
private static boolean areConvertible(@Nullable PsiType exprType, @Nullable PsiType parameterType) {
128-
if (exprType == null ||
129-
!exprType.isValid() ||
130-
!(parameterType instanceof PsiClassType) ||
131-
!parameterType.isValid()) {
132-
return false;
133-
}
134-
final PsiClassType.ClassResolveResult resolve = ((PsiClassType) parameterType).resolveGenerics();
135-
final PsiClass resolvedClass = resolve.getElement();
136-
if (resolvedClass == null || !CommonClassNames.JAVA_UTIL_OPTIONAL.equals(resolvedClass.getQualifiedName())) {
137-
return false;
72+
public static IntentionAction createFix(@Nullable PsiType type, @Nonnull PsiExpression expression) {
73+
class MyFix extends LocalQuickFixAndIntentionActionOnPsiElement implements HighPriorityAction {
74+
protected MyFix(@Nullable PsiElement element) {
75+
super(element);
76+
}
77+
78+
@Nls
79+
@Nonnull
80+
@Override
81+
public String getFamilyName() {
82+
return JavaQuickFixBundle.message("wrap.with.optional.single.parameter.text");
83+
}
84+
85+
@Override
86+
public void invoke(
87+
@Nonnull Project project,
88+
@Nonnull PsiFile file,
89+
@Nullable Editor editor,
90+
@Nonnull PsiElement startElement,
91+
@Nonnull PsiElement endElement
92+
) {
93+
startElement.replace(getModifiedExpression((PsiExpression)getStartElement()));
94+
}
95+
96+
@Override
97+
public boolean isAvailable(
98+
@Nonnull Project project,
99+
@Nonnull PsiFile file,
100+
@Nonnull PsiElement startElement,
101+
@Nonnull PsiElement endElement
102+
) {
103+
return BaseIntentionAction.canModify(startElement) &&
104+
PsiUtil.isLanguageLevel8OrHigher(startElement) && areConvertible(((PsiExpression)startElement).getType(), type);
105+
}
106+
107+
@Nonnull
108+
@Override
109+
public String getText() {
110+
return getFamilyName();
111+
}
112+
}
113+
return new MyFix(expression);
138114
}
139115

140-
final Collection<PsiType> values = resolve.getSubstitutor().getSubstitutionMap().values();
141-
if (values.isEmpty()) {
142-
return true;
116+
public static class MyFixerActionFactory extends ArgumentFixerActionFactory {
117+
118+
@Nullable
119+
@Override
120+
protected PsiExpression getModifiedArgument(
121+
final PsiExpression expression,
122+
final PsiType toType
123+
) throws IncorrectOperationException {
124+
return getModifiedExpression(expression);
125+
}
126+
127+
@Override
128+
public boolean areTypesConvertible(
129+
@Nonnull final PsiType exprType,
130+
@Nonnull final PsiType parameterType,
131+
@Nonnull final PsiElement context
132+
) {
133+
return parameterType.isConvertibleFrom(exprType) || areConvertible(exprType, parameterType);
134+
}
135+
136+
@Override
137+
public MethodArgumentFix createFix(final PsiExpressionList list, final int i, final PsiType toType) {
138+
return new WrapObjectWithOptionalOfNullableFix(list, i, toType, this);
139+
}
143140
}
144-
if (values.size() > 1) {
145-
return false;
141+
142+
private static boolean areConvertible(@Nullable PsiType exprType, @Nullable PsiType parameterType) {
143+
if (exprType == null ||
144+
!exprType.isValid() ||
145+
!(parameterType instanceof PsiClassType) ||
146+
!parameterType.isValid()) {
147+
return false;
148+
}
149+
final PsiClassType.ClassResolveResult resolve = ((PsiClassType)parameterType).resolveGenerics();
150+
final PsiClass resolvedClass = resolve.getElement();
151+
if (resolvedClass == null || !CommonClassNames.JAVA_UTIL_OPTIONAL.equals(resolvedClass.getQualifiedName())) {
152+
return false;
153+
}
154+
155+
final Collection<PsiType> values = resolve.getSubstitutor().getSubstitutionMap().values();
156+
if (values.isEmpty()) {
157+
return true;
158+
}
159+
if (values.size() > 1) {
160+
return false;
161+
}
162+
final PsiType optionalTypeParameter = ContainerUtil.getFirstItem(values);
163+
if (optionalTypeParameter == null) {
164+
return false;
165+
}
166+
return TypeConversionUtil.isAssignable(optionalTypeParameter, exprType);
146167
}
147-
final PsiType optionalTypeParameter = ContainerUtil.getFirstItem(values);
148-
if (optionalTypeParameter == null) {
149-
return false;
168+
169+
@Nonnull
170+
private static PsiExpression getModifiedExpression(PsiExpression expression) {
171+
final Project project = expression.getProject();
172+
final Nullability nullability = NullabilityUtil.getExpressionNullability(expression, true);
173+
String methodName = nullability == Nullability.NOT_NULL ? "of" : "ofNullable";
174+
final String newExpressionText = CommonClassNames.JAVA_UTIL_OPTIONAL + "." + methodName + "(" + expression.getText() + ")";
175+
return JavaPsiFacade.getElementFactory(project).createExpressionFromText(newExpressionText, expression);
150176
}
151-
return TypeConversionUtil.isAssignable(optionalTypeParameter, exprType);
152-
}
153-
154-
@Nonnull
155-
private static PsiExpression getModifiedExpression(PsiExpression expression) {
156-
final Project project = expression.getProject();
157-
final Nullability nullability = NullabilityUtil.getExpressionNullability(expression, true);
158-
String methodName = nullability == Nullability.NOT_NULL ? "of" : "ofNullable";
159-
final String newExpressionText = CommonClassNames.JAVA_UTIL_OPTIONAL + "." + methodName + "(" + expression.getText() + ")";
160-
return JavaPsiFacade.getElementFactory(project).createExpressionFromText(newExpressionText, expression);
161-
}
162177
}

0 commit comments

Comments
 (0)