protected void invokeImpl(final PsiClass targetClass) {
final Project project = myConstructorCall.getProject();
PsiElementFactory elementFactory = JavaPsiFacade.getInstance(project).getElementFactory();
try {
PsiMethod constructor = (PsiMethod) targetClass.add(elementFactory.createConstructor());
final PsiFile file = targetClass.getContainingFile();
TemplateBuilderImpl templateBuilder = new TemplateBuilderImpl(constructor);
CreateFromUsageUtils.setupMethodParameters(
constructor,
templateBuilder,
myConstructorCall.getArgumentList(),
getTargetSubstitutor(myConstructorCall));
final PsiMethod superConstructor =
CreateClassFromNewFix.setupSuperCall(targetClass, constructor, templateBuilder);
constructor = CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(constructor);
Template template = templateBuilder.buildTemplate();
if (targetClass == null) return;
final Editor editor = positionCursor(project, targetClass.getContainingFile(), targetClass);
final TextRange textRange = constructor.getTextRange();
editor.getDocument().deleteString(textRange.getStartOffset(), textRange.getEndOffset());
editor.getCaretModel().moveToOffset(textRange.getStartOffset());
startTemplate(
editor,
template,
project,
new TemplateEditingAdapter() {
public void templateFinished(Template template, boolean brokenOff) {
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
public void run() {
try {
PsiDocumentManager.getInstance(project)
.commitDocument(editor.getDocument());
final int offset = editor.getCaretModel().getOffset();
PsiMethod constructor =
PsiTreeUtil.findElementOfClassAtOffset(
file, offset, PsiMethod.class, false);
if (superConstructor == null) {
CreateFromUsageUtils.setupMethodBody(constructor);
} else {
OverrideImplementUtil.setupMethodBody(
constructor, superConstructor, targetClass);
}
CreateFromUsageUtils.setupEditor(constructor, editor);
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
});
}
});
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
protected boolean isValidElement(PsiElement element) {
PsiConstructorCall constructorCall = (PsiConstructorCall) element;
PsiMethod method = constructorCall.resolveConstructor();
PsiExpressionList argumentList = constructorCall.getArgumentList();
PsiClass targetClass = getTargetClasses(constructorCall).get(0);
return !CreateFromUsageUtils.shouldCreateConstructor(targetClass, argumentList, method);
}
protected PsiElement getElement() {
if (!myConstructorCall.isValid()
|| !myConstructorCall.getManager().isInProject(myConstructorCall)) return null;
PsiExpressionList argumentList = myConstructorCall.getArgumentList();
if (argumentList == null) return null;
if (myConstructorCall instanceof PsiEnumConstant) return myConstructorCall;
PsiJavaCodeReferenceElement referenceElement = getReferenceElement(myConstructorCall);
if (referenceElement == null) return null;
if (referenceElement.getReferenceNameElement() instanceof PsiIdentifier)
return myConstructorCall;
return null;
}
private static PsiFile getTargetFile(PsiElement element) {
final PsiConstructorCall constructorCall = (PsiConstructorCall) element;
// Enum constants constructors are file local
if (constructorCall instanceof PsiEnumConstant) return constructorCall.getContainingFile();
PsiJavaCodeReferenceElement referenceElement = getReferenceElement(constructorCall);
if (referenceElement.getQualifier() instanceof PsiJavaCodeReferenceElement) {
PsiJavaCodeReferenceElement qualifier =
(PsiJavaCodeReferenceElement) referenceElement.getQualifier();
PsiElement psiElement = qualifier.resolve();
if (psiElement instanceof PsiClass) {
PsiClass psiClass = (PsiClass) psiElement;
return psiClass.getContainingFile();
}
}
return null;
}
