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