@Override
public void invoke(@NotNull Project project, Editor editor, @NotNull PsiElement element)
throws IncorrectOperationException {
final PsiNewExpression expression =
PsiTreeUtil.getParentOfType(element, PsiNewExpression.class, false);
if (expression == null) {
return;
}
final PsiExpressionList arguments = expression.getArgumentList();
if (arguments == null) {
return;
}
final PsiMethod constructor = expression.resolveConstructor();
if (constructor == null) {
return;
}
final PsiExpressionList newArguments =
createNewArguments(
JavaPsiFacade.getElementFactory(project),
constructor.getParameterList().getParameters(),
arguments.getExpressions());
if (newArguments == null) {
return;
}
arguments.replace(newArguments);
}
public InspectionGadgetsFix buildFix(Object... infos) {
final PsiNewExpression expression = (PsiNewExpression) infos[0];
final PsiJavaCodeReferenceElement classReference = expression.getClassReference();
assert classReference != null;
final String className = classReference.getText();
return new CachedNumberConstructorCallFix(className);
}
@Override
public void visitNewExpression(PsiNewExpression expression) {
super.visitNewExpression(expression);
final PsiJavaCodeReferenceElement classReference = expression.getClassReference();
if (classReference == null) {
return;
}
final String name = classReference.getReferenceName();
if (!"BigDecimal".equals(name)) {
return;
}
final PsiMethod constructor = expression.resolveConstructor();
if (constructor == null) {
return;
}
final PsiParameterList parameterList = constructor.getParameterList();
final int length = parameterList.getParametersCount();
if (length != 1 && length != 2) {
return;
}
final PsiParameter[] parameters = parameterList.getParameters();
final PsiParameter firstParameter = parameters[0];
final PsiType type = firstParameter.getType();
if (type != PsiType.DOUBLE) {
return;
}
registerNewExpressionError(expression);
}
@Nullable
private static PsiClass findClass(PsiNewExpression newExpression) {
final PsiJavaCodeReferenceElement classReference =
newExpression.getClassOrAnonymousClassReference();
if (classReference != null) {
final String text = classReference.getReferenceName();
if (text != null) {
final Project project = newExpression.getProject();
final JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
final PsiResolveHelper resolveHelper = facade.getResolveHelper();
final PsiExpression newExpressionQualifier = newExpression.getQualifier();
final PsiElement qualifierElement = classReference.getQualifier();
final String qualifier = qualifierElement != null ? qualifierElement.getText() : "";
final String qualifiedName = StringUtil.getQualifiedName(qualifier, text);
if (newExpressionQualifier != null) {
final PsiClass aClass =
PsiUtil.resolveClassInClassTypeOnly(newExpressionQualifier.getType());
if (aClass != null) {
return aClass.findInnerClassByName(qualifiedName, false);
}
}
return resolveHelper.resolveReferencedClass(qualifiedName, newExpression);
} else {
return null;
}
}
return null;
}
public static boolean checkSideEffects(
PsiElement element, PsiVariable variable, List<PsiElement> sideEffects) {
if (sideEffects == null || element == null) return false;
if (element instanceof PsiMethodCallExpression) {
final PsiMethod psiMethod = ((PsiMethodCallExpression) element).resolveMethod();
if (psiMethod == null
|| !PropertyUtil.isSimpleGetter(psiMethod) && !PropertyUtil.isSimpleSetter(psiMethod)) {
sideEffects.add(element);
return true;
}
}
if (element instanceof PsiNewExpression) {
PsiNewExpression newExpression = (PsiNewExpression) element;
if (newExpression.getArrayDimensions().length == 0
&& newExpression.getArrayInitializer() == null
&& !isSideEffectFreeConstructor(newExpression)) {
sideEffects.add(element);
return true;
}
}
if (element instanceof PsiAssignmentExpression
&& !(((PsiAssignmentExpression) element).getLExpression() instanceof PsiReferenceExpression
&& ((PsiReferenceExpression) ((PsiAssignmentExpression) element).getLExpression())
.resolve()
== variable)) {
sideEffects.add(element);
return true;
}
PsiElement[] children = element.getChildren();
for (PsiElement child : children) {
checkSideEffects(child, variable, sideEffects);
}
return !sideEffects.isEmpty();
}
@Override
public void visitNewExpression(@NotNull PsiNewExpression expression) {
if (!PsiUtil.isLanguageLevel5OrHigher(expression)) {
return;
}
super.visitNewExpression(expression);
final PsiType type = expression.getType();
if (type == null) {
return;
}
final String canonicalText = type.getCanonicalText();
if (!cachedNumberTypes.contains(canonicalText)) {
return;
}
final PsiClass aClass = ClassUtils.getContainingClass(expression);
if (aClass != null && cachedNumberTypes.contains(aClass.getQualifiedName())) {
return;
}
final PsiExpressionList argumentList = expression.getArgumentList();
if (argumentList == null) {
return;
}
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length != 1) {
return;
}
final PsiExpression argument = arguments[0];
final PsiType argumentType = argument.getType();
if (argumentType == null || argumentType.equalsToText("java.lang.String")) {
return;
}
registerError(expression, expression);
}
@Override
protected void invokeImpl(final PsiClass targetClass) {
PsiNewExpression newExpression = getNewExpression();
PsiJavaCodeReferenceElement ref = newExpression.getClassOrAnonymousClassReference();
assert ref != null;
String refName = ref.getReferenceName();
LOG.assertTrue(refName != null);
PsiElementFactory elementFactory =
JavaPsiFacade.getInstance(newExpression.getProject()).getElementFactory();
PsiClass created = elementFactory.createClass(refName);
final PsiModifierList modifierList = created.getModifierList();
LOG.assertTrue(modifierList != null);
if (PsiTreeUtil.isAncestor(targetClass, newExpression, true)) {
if (targetClass.isInterface()) {
modifierList.setModifierProperty(PsiModifier.PACKAGE_LOCAL, true);
} else {
modifierList.setModifierProperty(PsiModifier.PRIVATE, true);
}
}
if (!PsiTreeUtil.isAncestor(targetClass, newExpression, true)
|| PsiUtil.getEnclosingStaticElement(newExpression, targetClass) != null
|| isInThisOrSuperCall(newExpression)) {
modifierList.setModifierProperty(PsiModifier.STATIC, true);
}
created = (PsiClass) targetClass.add(created);
setupClassFromNewExpression(created, newExpression);
setupGenericParameters(created, ref);
}
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
return myType.isValid()
&& myExpression.isValid()
&& myExpression.getManager().isInProject(myExpression)
&& !TypeConversionUtil.isPrimitiveAndNotNull(myType)
&& (myType instanceof PsiArrayType || myExpression.getArgumentList() != null);
}
public void doFix(Project project, ProblemDescriptor descriptor)
throws IncorrectOperationException {
final PsiNewExpression expression = (PsiNewExpression) descriptor.getPsiElement();
final PsiExpressionList argList = expression.getArgumentList();
assert argList != null;
final PsiExpression[] args = argList.getExpressions();
final PsiExpression arg = args[0];
final String text = arg.getText();
replaceExpression(expression, className + ".valueOf(" + text + ')');
}
public static DiamondInferenceResult resolveInferredTypesNoCheck(
final PsiNewExpression newExpression, final PsiElement context) {
final PsiClass psiClass = findClass(newExpression);
if (psiClass == null) return DiamondInferenceResult.NULL_RESULT;
final PsiExpressionList argumentList = newExpression.getArgumentList();
if (argumentList == null) return DiamondInferenceResult.NULL_RESULT;
final Ref<PsiMethod> staticFactoryRef = new Ref<PsiMethod>();
final PsiSubstitutor inferredSubstitutor =
ourDiamondGuard.doPreventingRecursion(
context,
false,
new Computable<PsiSubstitutor>() {
@Override
public PsiSubstitutor compute() {
final PsiMethod constructor = findConstructor(psiClass, newExpression);
PsiTypeParameter[] params = getAllTypeParams(constructor, psiClass);
final PsiMethod staticFactory =
generateStaticFactory(
constructor, psiClass, params, newExpression.getClassReference());
if (staticFactory == null) {
return null;
}
staticFactoryRef.set(staticFactory);
return inferTypeParametersForStaticFactory(
staticFactory, newExpression, context, false);
}
});
if (inferredSubstitutor == null) {
return DiamondInferenceResult.NULL_RESULT;
}
final PsiMethod staticFactory = staticFactoryRef.get();
if (staticFactory == null) {
LOG.error(inferredSubstitutor);
return DiamondInferenceResult.NULL_RESULT;
}
final PsiTypeParameter[] parameters = staticFactory.getTypeParameters();
final PsiTypeParameter[] classParameters = psiClass.getTypeParameters();
final PsiJavaCodeReferenceElement classOrAnonymousClassReference =
newExpression.getClassOrAnonymousClassReference();
LOG.assertTrue(classOrAnonymousClassReference != null);
final DiamondInferenceResult result =
new DiamondInferenceResult(classOrAnonymousClassReference.getReferenceName() + "<>");
for (PsiTypeParameter parameter : parameters) {
for (PsiTypeParameter classParameter : classParameters) {
if (Comparing.strEqual(classParameter.getName(), parameter.getName())) {
result.addInferredType(inferredSubstitutor.substitute(parameter));
break;
}
}
}
return result;
}
static boolean isComplexArrayExpression(PsiExpression expression) {
expression = ParenthesesUtils.stripParentheses(expression);
if (expression == null) {
return false;
}
if (expression instanceof PsiNewExpression) {
final PsiNewExpression newExpression = (PsiNewExpression) expression;
final PsiArrayInitializerExpression arrayInitializer = newExpression.getArrayInitializer();
return isComplexArrayExpression(arrayInitializer);
} else if (expression instanceof PsiArrayInitializerExpression) {
final PsiArrayInitializerExpression arrayInitializerExpression =
(PsiArrayInitializerExpression) expression;
for (PsiExpression initializer : arrayInitializerExpression.getInitializers()) {
if (isComplexArrayExpression(initializer)) {
return true;
}
}
return false;
} else if (expression instanceof PsiReferenceExpression) {
return expression.getType() instanceof PsiArrayType;
} else if (expression instanceof PsiArrayAccessExpression) {
return true;
} else if (expression instanceof PsiTypeCastExpression) {
final PsiTypeCastExpression typeCastExpression = (PsiTypeCastExpression) expression;
return isComplexArrayExpression(typeCastExpression.getOperand());
} else if (expression instanceof PsiConditionalExpression) {
final PsiConditionalExpression conditionalExpression =
(PsiConditionalExpression) expression;
return isComplexArrayExpression(conditionalExpression.getThenExpression())
|| isComplexArrayExpression(conditionalExpression.getElseExpression());
} else if (expression instanceof PsiMethodCallExpression) {
final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) expression;
final PsiMethod method = methodCallExpression.resolveMethod();
if (method == null) {
return true;
}
if (CloneUtils.isClone(method)) {
return false;
}
@NonNls final String name = method.getName();
if ("copyOf".equals(name) || "copyOfRange".equals(name)) {
final PsiClass aClass = method.getContainingClass();
if (aClass != null
&& CommonClassNames.JAVA_UTIL_ARRAYS.equals(aClass.getQualifiedName())) {
return false;
}
} else if ("toArray".equals(name)
&& InheritanceUtil.isInheritor(method.getContainingClass(), "java.util.Collection")) {
return false;
}
return true;
}
return true;
}
@Nullable
private static PsiMethod findConstructor(
PsiClass containingClass, PsiNewExpression newExpression) {
final PsiExpressionList argumentList = newExpression.getArgumentList();
final Project project = newExpression.getProject();
final JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
final PsiResolveHelper resolveHelper = facade.getResolveHelper();
final JavaResolveResult result =
resolveHelper.resolveConstructor(
facade.getElementFactory().createType(containingClass), argumentList, argumentList);
return (PsiMethod) result.getElement();
}
static boolean isSimpleArrayExpression(PsiExpression initializer) {
if (initializer == null) {
return true;
}
if (initializer instanceof PsiNewExpression) {
final PsiNewExpression newExpression = (PsiNewExpression) initializer;
final PsiArrayInitializerExpression arrayInitializer = newExpression.getArrayInitializer();
return arrayInitializer == null || isSimpleArrayExpression(arrayInitializer);
}
if (initializer instanceof PsiArrayInitializerExpression) {
final PsiArrayInitializerExpression arrayInitializerExpression =
(PsiArrayInitializerExpression) initializer;
final PsiExpression[] initializers = arrayInitializerExpression.getInitializers();
return initializers.length == 0;
}
return false;
}
protected final void registerNewExpressionError(
@NotNull PsiNewExpression expression, Object... infos) {
final PsiJavaCodeReferenceElement classReference =
expression.getClassOrAnonymousClassReference();
if (classReference == null) {
registerError(expression, infos);
} else {
registerError(classReference, infos);
}
}
protected void changeInternalUsage(InternalUsageInfo usage, PsiElementFactory factory)
throws IncorrectOperationException {
if (!mySettings.isChangeSignature()) return;
PsiElement element = usage.getElement();
if (element instanceof PsiReferenceExpression) {
PsiReferenceExpression newRef = null;
if (mySettings.isMakeFieldParameters()) {
PsiElement resolved = ((PsiReferenceExpression) element).resolve();
if (resolved instanceof PsiField) {
String name = mySettings.getNameForField((PsiField) resolved);
if (name != null) {
newRef = (PsiReferenceExpression) factory.createExpressionFromText(name, null);
}
}
}
if (newRef == null && mySettings.isMakeClassParameter()) {
newRef =
(PsiReferenceExpression)
factory.createExpressionFromText(
mySettings.getClassParameterName() + "." + element.getText(), null);
}
if (newRef != null) {
CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(myProject);
newRef = (PsiReferenceExpression) codeStyleManager.reformat(newRef);
element.replace(newRef);
}
} else if (element instanceof PsiThisExpression && mySettings.isMakeClassParameter()) {
element.replace(factory.createExpressionFromText(mySettings.getClassParameterName(), null));
} else if (element instanceof PsiSuperExpression && mySettings.isMakeClassParameter()) {
element.replace(factory.createExpressionFromText(mySettings.getClassParameterName(), null));
} else if (element instanceof PsiNewExpression && mySettings.isMakeClassParameter()) {
final PsiNewExpression newExpression = ((PsiNewExpression) element);
LOG.assertTrue(newExpression.getQualifier() == null);
final String newText = mySettings.getClassParameterName() + "." + newExpression.getText();
final PsiExpression expr = factory.createExpressionFromText(newText, null);
element.replace(expr);
}
}
private static boolean newExpressionsAreEquivalent(
@NotNull PsiNewExpression newExpression1, @NotNull PsiNewExpression newExpression2) {
final PsiJavaCodeReferenceElement classReference1 = newExpression1.getClassReference();
final PsiJavaCodeReferenceElement classReference2 = newExpression2.getClassReference();
if (classReference1 == null || classReference2 == null) {
return false;
}
final String text = classReference1.getText();
if (!text.equals(classReference2.getText())) {
return false;
}
final PsiExpression[] arrayDimensions1 = newExpression1.getArrayDimensions();
final PsiExpression[] arrayDimensions2 = newExpression2.getArrayDimensions();
if (!expressionListsAreEquivalent(arrayDimensions1, arrayDimensions2)) {
return false;
}
final PsiArrayInitializerExpression arrayInitializer1 = newExpression1.getArrayInitializer();
final PsiArrayInitializerExpression arrayInitializer2 = newExpression2.getArrayInitializer();
if (!expressionsAreEquivalent(arrayInitializer1, arrayInitializer2)) {
return false;
}
final PsiExpression qualifier1 = newExpression1.getQualifier();
final PsiExpression qualifier2 = newExpression2.getQualifier();
if (!expressionsAreEquivalent(qualifier1, qualifier2)) {
return false;
}
final PsiExpressionList argumentList1 = newExpression1.getArgumentList();
final PsiExpression[] args1;
if (argumentList1 == null) {
args1 = null;
} else {
args1 = argumentList1.getExpressions();
}
final PsiExpressionList argumentList2 = newExpression2.getArgumentList();
final PsiExpression[] args2;
if (argumentList2 == null) {
args2 = null;
} else {
args2 = argumentList2.getExpressions();
}
return expressionListsAreEquivalent(args1, args2);
}
@Override
public void visitNewExpression(PsiNewExpression expression) {
PsiAnonymousClass anonymousClass = expression.getAnonymousClass();
if (anonymousClass == null) {
return;
}
JavaElementArrangementEntry entry =
createNewEntry(
anonymousClass, anonymousClass.getTextRange(), CLASS, anonymousClass.getName(), false);
processEntry(entry, null, anonymousClass);
}
@Override
public void visitNewExpression(PsiNewExpression expression) {
if (FileTypeUtils.isInServerPageFile(expression)) {
return;
}
super.visitNewExpression(expression);
final PsiClass containingClass = getContainingContextClass(expression);
if (containingClass == null) {
return;
}
final PsiMethod constructor = expression.resolveConstructor();
if (constructor == null) {
final PsiJavaCodeReferenceElement classReference =
expression.getClassOrAnonymousClassReference();
if (classReference == null) {
return;
}
final PsiElement target = classReference.resolve();
if (!(target instanceof PsiClass)) {
return;
}
final PsiClass aClass = (PsiClass) target;
if (!aClass.hasModifierProperty(PsiModifier.PRIVATE)) {
return;
}
if (aClass.equals(containingClass)) {
return;
}
registerNewExpressionError(expression, aClass);
} else {
if (!constructor.hasModifierProperty(PsiModifier.PRIVATE)) {
return;
}
final PsiClass aClass = constructor.getContainingClass();
if (containingClass.equals(aClass)) {
return;
}
registerNewExpressionError(expression, aClass);
}
}
private static void removeParensFromNewExpression(
@NotNull PsiNewExpression newExpression, boolean ignoreClarifyingParentheses) {
final PsiExpression[] dimensions = newExpression.getArrayDimensions();
for (PsiExpression dimension : dimensions) {
removeParentheses(dimension, ignoreClarifyingParentheses);
}
final PsiExpression qualifier = newExpression.getQualifier();
if (qualifier != null) {
removeParentheses(qualifier, ignoreClarifyingParentheses);
}
final PsiExpression arrayInitializer = newExpression.getArrayInitializer();
if (arrayInitializer != null) {
removeParentheses(arrayInitializer, ignoreClarifyingParentheses);
}
final PsiExpressionList argumentList = newExpression.getArgumentList();
if (argumentList != null) {
final PsiExpression[] arguments = argumentList.getExpressions();
for (PsiExpression argument : arguments) {
removeParentheses(argument, ignoreClarifyingParentheses);
}
}
}
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
if (!super.isAvailable(project, editor, element)) {
return false;
}
final PsiNewExpression expression =
PsiTreeUtil.getParentOfType(element, PsiNewExpression.class, false);
if (expression == null) {
return false;
}
final PsiExpressionList arguments = expression.getArgumentList();
if (arguments == null) {
return false;
}
final PsiMethod constructor = expression.resolveConstructor();
if (constructor == null) {
return false;
}
final PsiExpressionList newArguments =
createNewArguments(
JavaPsiFacade.getElementFactory(project),
constructor.getParameterList().getParameters(),
arguments.getExpressions());
if (newArguments == null) {
return false;
}
setText(
CodeInsightBundle.message(
"intention.convert.color.representation.text", newArguments.getText()));
return true;
}
private static void makeConstructorPackageLocal(Project project, PsiElement element) {
final PsiNewExpression newExpression =
PsiTreeUtil.getParentOfType(element, PsiNewExpression.class);
if (newExpression == null) {
return;
}
final PsiMethod constructor = newExpression.resolveConstructor();
if (constructor != null) {
final PsiModifierList modifierList = constructor.getModifierList();
modifierList.setModifierProperty(PsiModifier.PRIVATE, false);
return;
}
final PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement) element;
final PsiElement target = referenceElement.resolve();
if (!(target instanceof PsiClass)) {
return;
}
final PsiClass aClass = (PsiClass) target;
final PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(project);
final PsiMethod newConstructor = elementFactory.createConstructor();
final PsiModifierList modifierList = newConstructor.getModifierList();
modifierList.setModifierProperty(PsiModifier.PACKAGE_LOCAL, true);
aClass.add(newConstructor);
}
private static PsiSubstitutor inferTypeParametersForStaticFactory(
@NotNull PsiMethod staticFactoryMethod, PsiNewExpression expression, PsiElement parent) {
final JavaPsiFacade facade = JavaPsiFacade.getInstance(staticFactoryMethod.getProject());
final PsiResolveHelper resolveHelper = facade.getResolveHelper();
final PsiParameter[] parameters = staticFactoryMethod.getParameterList().getParameters();
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] expressions = argumentList.getExpressions();
return resolveHelper.inferTypeArguments(
staticFactoryMethod.getTypeParameters(),
parameters,
expressions,
PsiSubstitutor.EMPTY,
parent,
DefaultParameterTypeInferencePolicy.INSTANCE);
}
private static PsiSubstitutor inferTypeParametersForStaticFactory(
@NotNull PsiMethod staticFactoryMethod,
PsiNewExpression expression,
final PsiElement parent,
final boolean varargs) {
final PsiExpressionList argumentList = expression.getArgumentList();
if (argumentList != null) {
final MethodCandidateInfo staticFactoryCandidateInfo =
new MethodCandidateInfo(
staticFactoryMethod,
PsiSubstitutor.EMPTY,
false,
false,
argumentList,
parent,
argumentList.getExpressionTypes(),
null) {
@Override
public boolean isVarargs() {
return varargs;
}
@Override
protected PsiElement getParent() {
return parent;
}
@Override
protected PsiElement getMarkerList() {
return parent instanceof PsiNewExpression
? ((PsiNewExpression) parent).getArgumentList()
: super.getMarkerList();
}
};
if (!varargs
&& staticFactoryMethod.isVarArgs()
&& staticFactoryCandidateInfo.getPertinentApplicabilityLevel()
< MethodCandidateInfo.ApplicabilityLevel.FIXED_ARITY) {
return inferTypeParametersForStaticFactory(staticFactoryMethod, expression, parent, true);
}
return staticFactoryCandidateInfo.getSubstitutor();
} else {
return PsiSubstitutor.EMPTY;
}
}
public static DiamondInferenceResult resolveInferredTypes(
PsiNewExpression newExpression, PsiElement context) {
final PsiAnonymousClass anonymousClass = newExpression.getAnonymousClass();
if (anonymousClass != null) {
final PsiElement resolve = anonymousClass.getBaseClassReference().resolve();
if (resolve instanceof PsiClass) {
return PsiDiamondTypeImpl.DiamondInferenceResult.ANONYMOUS_INNER_RESULT;
}
}
final PsiReferenceParameterList referenceParameterList =
PsiTreeUtil.getChildOfType(newExpression, PsiReferenceParameterList.class);
if (referenceParameterList != null
&& referenceParameterList.getTypeParameterElements().length > 0) {
return DiamondInferenceResult.EXPLICIT_CONSTRUCTOR_TYPE_ARGS;
}
return resolveInferredTypesNoCheck(newExpression, context);
}
@Override
public void visitNewExpression(@NotNull PsiNewExpression newExpression) {
if (read || written) {
return;
}
super.visitNewExpression(newExpression);
final PsiExpressionList argumentList = newExpression.getArgumentList();
if (argumentList == null) {
return;
}
final PsiExpression[] arguments = argumentList.getExpressions();
for (final PsiExpression argument : arguments) {
final VariableUsedVisitor visitor = new VariableUsedVisitor(variable);
argument.accept(visitor);
if (visitor.isUsed()) {
read = true;
reference = visitor.getReference();
return;
}
}
}
static boolean isSideEffectFreeConstructor(PsiNewExpression newExpression) {
PsiJavaCodeReferenceElement classReference = newExpression.getClassReference();
PsiClass aClass = classReference == null ? null : (PsiClass) classReference.resolve();
String qualifiedName = aClass == null ? null : aClass.getQualifiedName();
if (qualifiedName == null) return false;
if (ourSideEffectFreeClasses.contains(qualifiedName)) return true;
PsiFile file = aClass.getContainingFile();
PsiDirectory directory = file.getContainingDirectory();
PsiPackage classPackage = JavaDirectoryService.getInstance().getPackage(directory);
String packageName = classPackage == null ? null : classPackage.getQualifiedName();
// all Throwable descendants from java.lang are side effects free
if ("java.lang".equals(packageName) || "java.io".equals(packageName)) {
PsiClass throwableClass =
JavaPsiFacade.getInstance(aClass.getProject())
.findClass("java.lang.Throwable", aClass.getResolveScope());
if (throwableClass != null
&& InheritanceUtil.isInheritorOrSelf(aClass, throwableClass, true)) {
return true;
}
}
return false;
}
@Override
public JComponent getPreviewComponent(@NotNull PsiElement element) {
final PsiNewExpression psiNewExpression =
PsiTreeUtil.getParentOfType(element, PsiNewExpression.class);
if (psiNewExpression != null) {
final PsiJavaCodeReferenceElement referenceElement =
PsiTreeUtil.getChildOfType(psiNewExpression, PsiJavaCodeReferenceElement.class);
if (referenceElement != null) {
final PsiReference reference = referenceElement.getReference();
if (reference != null) {
final PsiElement psiElement = reference.resolve();
if (psiElement instanceof PsiClass
&& "java.awt.Color".equals(((PsiClass) psiElement).getQualifiedName())) {
final PsiExpressionList argumentList = psiNewExpression.getArgumentList();
if (argumentList != null) {
final PsiExpression[] expressions = argumentList.getExpressions();
int[] values = ArrayUtil.newIntArray(expressions.length);
float[] values2 = new float[expressions.length];
int i = 0;
int j = 0;
final PsiConstantEvaluationHelper helper =
JavaPsiFacade.getInstance(element.getProject()).getConstantEvaluationHelper();
for (final PsiExpression each : expressions) {
final Object o = helper.computeConstantExpression(each);
if (o instanceof Integer) {
values[i] = ((Integer) o).intValue();
if (expressions.length != 1) {
values[i] = values[i] > 255 ? 255 : values[i] < 0 ? 0 : values[i];
}
i++;
} else if (o instanceof Float) {
values2[j] = ((Float) o).floatValue();
values2[j] = values2[j] > 1 ? 1 : values2[j] < 0 ? 0 : values2[j];
j++;
}
}
Color c = null;
if (i == expressions.length) {
if (i == 1 && values[0] > 255) {
c = new Color(values[0]);
} else {
switch (values.length) {
case 1:
c = new Color(values[0]);
break;
case 3:
c = new Color(values[0], values[1], values[2]);
break;
case 4:
c = new Color(values[0], values[1], values[2], values[3]);
break;
default:
break;
}
}
} else if (j == expressions.length) {
switch (values2.length) {
case 3:
c = new Color(values2[0], values2[1], values2[2]);
break;
case 4:
c = new Color(values2[0], values2[1], values2[2], values2[3]);
break;
default:
break;
}
}
if (c != null) {
return new ColorPreviewComponent(c);
}
}
}
}
}
}
if (ColorChooserIntentionAction.isInsideDecodeOrGetColorMethod(element)) {
final String color = StringUtil.unquoteString(element.getText());
try {
return new ColorPreviewComponent(Color.decode(color));
} catch (NumberFormatException ignore) {
}
}
if (PlatformPatterns.psiElement(PsiIdentifier.class)
.withParent(PlatformPatterns.psiElement(PsiReferenceExpression.class))
.accepts(element)) {
final PsiReference reference = element.getParent().getReference();
if (reference != null) {
final PsiElement psiElement = reference.resolve();
if (psiElement instanceof PsiField) {
if ("java.awt.Color"
.equals(((PsiField) psiElement).getContainingClass().getQualifiedName())) {
final String colorName =
((PsiField) psiElement).getName().toLowerCase().replace("_", "");
final String hex = ColorSampleLookupValue.getHexCodeForColorName(colorName);
return new ColorPreviewComponent(Color.decode("0x" + hex.substring(1)));
}
}
}
}
if (PlatformPatterns.psiElement()
.withParent(PlatformPatterns.psiElement(PsiLiteralExpression.class))
.accepts(element)) {
final PsiLiteralExpression psiLiteralExpression = (PsiLiteralExpression) element.getParent();
if (psiLiteralExpression != null) {
return ImagePreviewComponent.getPreviewComponent(psiLiteralExpression);
}
}
return null;
}
// This methods works equally well for primary usages as well as for propagated callers' usages
private static void fixActualArgumentsList(
PsiExpressionList list,
JavaChangeInfo changeInfo,
boolean toInsertDefaultValue,
PsiSubstitutor substitutor)
throws IncorrectOperationException {
final PsiElementFactory factory =
JavaPsiFacade.getInstance(list.getProject()).getElementFactory();
if (changeInfo.isParameterSetOrOrderChanged()) {
if (changeInfo instanceof JavaChangeInfoImpl
&& ((JavaChangeInfoImpl) changeInfo).isPropagationEnabled) {
final ParameterInfoImpl[] createdParmsInfo =
((JavaChangeInfoImpl) changeInfo).getCreatedParmsInfoWithoutVarargs();
for (ParameterInfoImpl info : createdParmsInfo) {
PsiExpression newArg;
if (toInsertDefaultValue) {
newArg = createDefaultValue(changeInfo, factory, info, list);
} else {
newArg = factory.createExpressionFromText(info.getName(), list);
}
JavaCodeStyleManager.getInstance(list.getProject())
.shortenClassReferences(list.add(newArg));
}
} else {
final PsiExpression[] args = list.getExpressions();
final int nonVarargCount = getNonVarargCount(changeInfo, args);
final int varargCount = args.length - nonVarargCount;
if (varargCount < 0) return;
PsiExpression[] newVarargInitializers = null;
final int newArgsLength;
final int newNonVarargCount;
final JavaParameterInfo[] newParms = changeInfo.getNewParameters();
if (changeInfo.isArrayToVarargs()) {
newNonVarargCount = newParms.length - 1;
final JavaParameterInfo lastNewParm = newParms[newParms.length - 1];
final PsiExpression arrayToConvert = args[lastNewParm.getOldIndex()];
if (arrayToConvert instanceof PsiNewExpression) {
final PsiNewExpression expression = (PsiNewExpression) arrayToConvert;
final PsiArrayInitializerExpression arrayInitializer = expression.getArrayInitializer();
if (arrayInitializer != null) {
newVarargInitializers = arrayInitializer.getInitializers();
}
}
newArgsLength =
newVarargInitializers == null
? newParms.length
: newNonVarargCount + newVarargInitializers.length;
} else if (changeInfo.isRetainsVarargs()) {
newNonVarargCount = newParms.length - 1;
newArgsLength = newNonVarargCount + varargCount;
} else if (changeInfo.isObtainsVarags()) {
newNonVarargCount = newParms.length - 1;
newArgsLength = newNonVarargCount;
} else {
newNonVarargCount = newParms.length;
newArgsLength = newParms.length;
}
String[] oldVarargs = null;
if (changeInfo.wasVararg() && !changeInfo.isRetainsVarargs()) {
oldVarargs = new String[varargCount];
for (int i = nonVarargCount; i < args.length; i++) {
oldVarargs[i - nonVarargCount] = args[i].getText();
}
}
final PsiExpression[] newArgs = new PsiExpression[newArgsLength];
for (int i = 0; i < newNonVarargCount; i++) {
if (newParms[i].getOldIndex() == nonVarargCount && oldVarargs != null) {
PsiType type = newParms[i].createType(changeInfo.getMethod(), list.getManager());
if (type instanceof PsiArrayType) {
type = substitutor.substitute(type);
type = TypeConversionUtil.erasure(type);
String typeText = type.getCanonicalText();
if (type instanceof PsiEllipsisType) {
typeText = typeText.replace("...", "[]");
}
String text = "new " + typeText + "{" + StringUtil.join(oldVarargs, ",") + "}";
newArgs[i] = factory.createExpressionFromText(text, changeInfo.getMethod());
continue;
}
}
newArgs[i] =
createActualArgument(changeInfo, list, newParms[i], toInsertDefaultValue, args);
}
if (changeInfo.isArrayToVarargs()) {
if (newVarargInitializers == null) {
newArgs[newNonVarargCount] =
createActualArgument(
changeInfo, list, newParms[newNonVarargCount], toInsertDefaultValue, args);
} else {
System.arraycopy(
newVarargInitializers, 0, newArgs, newNonVarargCount, newVarargInitializers.length);
}
} else {
final int newVarargCount = newArgsLength - newNonVarargCount;
LOG.assertTrue(newVarargCount == 0 || newVarargCount == varargCount);
for (int i = newNonVarargCount; i < newArgsLength; i++) {
final int oldIndex = newParms[newNonVarargCount].getOldIndex();
if (oldIndex >= 0 && oldIndex != nonVarargCount) {
newArgs[i] =
createActualArgument(
changeInfo, list, newParms[newNonVarargCount], toInsertDefaultValue, args);
} else {
System.arraycopy(args, nonVarargCount, newArgs, newNonVarargCount, newVarargCount);
break;
}
}
}
ChangeSignatureUtil.synchronizeList(
list, Arrays.asList(newArgs), ExpressionList.INSTANCE, changeInfo.toRemoveParm());
}
}
}
private static void changeNewOperatorType(
PsiNewExpression originalExpression, PsiType toType, final Editor editor)
throws IncorrectOperationException {
PsiNewExpression newExpression;
PsiElementFactory factory =
JavaPsiFacade.getInstance(originalExpression.getProject()).getElementFactory();
int caretOffset;
TextRange selection;
if (toType instanceof PsiArrayType) {
final PsiExpression[] originalExpressionArrayDimensions =
originalExpression.getArrayDimensions();
caretOffset = 0;
@NonNls String text = "new " + toType.getDeepComponentType().getCanonicalText() + "[";
if (originalExpressionArrayDimensions.length > 0) {
text += originalExpressionArrayDimensions[0].getText();
} else {
text += "0";
caretOffset = -2;
}
text += "]";
for (int i = 1; i < toType.getArrayDimensions(); i++) {
text += "[";
String arrayDimension = "";
if (originalExpressionArrayDimensions.length > i) {
arrayDimension = originalExpressionArrayDimensions[i].getText();
text += arrayDimension;
}
text += "]";
if (caretOffset < 0) {
caretOffset -= arrayDimension.length() + 2;
}
}
newExpression = (PsiNewExpression) factory.createExpressionFromText(text, originalExpression);
if (caretOffset < 0) {
selection = new TextRange(caretOffset, caretOffset + 1);
} else {
selection = null;
}
} else {
final PsiAnonymousClass anonymousClass = originalExpression.getAnonymousClass();
newExpression =
(PsiNewExpression)
factory.createExpressionFromText(
"new " + toType.getCanonicalText() + "()" + (anonymousClass != null ? "{}" : ""),
originalExpression);
PsiExpressionList argumentList = originalExpression.getArgumentList();
if (argumentList == null) return;
newExpression.getArgumentList().replace(argumentList);
if (anonymousClass == null) { // just to prevent useless inference
if (PsiDiamondTypeUtil.canCollapseToDiamond(newExpression, originalExpression, toType)) {
final PsiElement paramList =
PsiDiamondTypeUtil.replaceExplicitWithDiamond(
newExpression.getClassOrAnonymousClassReference().getParameterList());
newExpression = PsiTreeUtil.getParentOfType(paramList, PsiNewExpression.class);
}
}
if (anonymousClass != null) {
final PsiAnonymousClass newAnonymousClass =
(PsiAnonymousClass) newExpression.getAnonymousClass().replace(anonymousClass);
final PsiClass aClass = PsiUtil.resolveClassInType(toType);
assert aClass != null;
newAnonymousClass
.getBaseClassReference()
.replace(factory.createClassReferenceElement(aClass));
}
selection = null;
caretOffset = -1;
}
PsiElement element = originalExpression.replace(newExpression);
editor.getCaretModel().moveToOffset(element.getTextRange().getEndOffset() + caretOffset);
editor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
if (selection != null) {
selection = selection.shiftRight(element.getTextRange().getEndOffset());
editor.getSelectionModel().setSelection(selection.getStartOffset(), selection.getEndOffset());
}
}
