@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);
}
protected final void registerNewExpressionError(
@NotNull PsiNewExpression expression, Object... infos) {
final PsiJavaCodeReferenceElement classReference =
expression.getClassOrAnonymousClassReference();
if (classReference == null) {
registerError(expression, infos);
} else {
registerError(classReference, infos);
}
}
@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 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());
}
}
