@Override
public void visitMethod(PsiMethod method) {
ArrangementSettingsToken type = method.isConstructor() ? CONSTRUCTOR : METHOD;
JavaElementArrangementEntry entry =
createNewEntry(method, method.getTextRange(), type, method.getName(), true);
if (entry == null) {
return;
}
processEntry(entry, method, method.getBody());
parseProperties(method, entry);
myInfo.onMethodEntryCreated(method, entry);
MethodSignatureBackedByPsiMethod overridden =
SuperMethodsSearch.search(method, null, true, false).findFirst();
if (overridden != null) {
myInfo.onOverriddenMethod(overridden.getMethod(), method);
}
boolean reset = myMethodBodyProcessor.setBaseMethod(method);
try {
method.accept(myMethodBodyProcessor);
} finally {
if (reset) {
myMethodBodyProcessor.setBaseMethod(null);
}
}
}
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);
}
}
private static TextRange calculateLimitRange(
final PsiFile file, final Document doc, final int line) {
final int offset = doc.getLineStartOffset(line);
if (offset > 0) {
PsiMethod method =
PsiTreeUtil.getParentOfType(file.findElementAt(offset), PsiMethod.class, false);
if (method != null) {
final TextRange elemRange = method.getTextRange();
return new TextRange(
doc.getLineNumber(elemRange.getStartOffset()),
doc.getLineNumber(elemRange.getEndOffset()));
}
}
return new TextRange(0, doc.getLineCount() - 1);
}
@Nullable
public static HighlightInfo checkVariableInitializedBeforeUsage(
@NotNull PsiReferenceExpression expression,
@NotNull PsiVariable variable,
@NotNull Map<PsiElement, Collection<PsiReferenceExpression>> uninitializedVarProblems,
@NotNull PsiFile containingFile) {
if (variable instanceof ImplicitVariable) return null;
if (!PsiUtil.isAccessedForReading(expression)) return null;
int startOffset = expression.getTextRange().getStartOffset();
final PsiElement topBlock;
if (variable.hasInitializer()) {
topBlock = PsiUtil.getVariableCodeBlock(variable, variable);
if (topBlock == null) return null;
} else {
PsiElement scope =
variable instanceof PsiField
? ((PsiField) variable).getContainingClass()
: variable.getParent() != null ? variable.getParent().getParent() : null;
if (scope instanceof PsiCodeBlock && scope.getParent() instanceof PsiSwitchStatement) {
scope = PsiTreeUtil.getParentOfType(scope, PsiCodeBlock.class);
}
topBlock =
FileTypeUtils.isInServerPageFile(scope) && scope instanceof PsiFile
? scope
: PsiUtil.getTopLevelEnclosingCodeBlock(expression, scope);
if (variable instanceof PsiField) {
// non final field already initialized with default value
if (!variable.hasModifierProperty(PsiModifier.FINAL)) return null;
// final field may be initialized in ctor or class initializer only
// if we're inside non-ctr method, skip it
if (PsiUtil.findEnclosingConstructorOrInitializer(expression) == null
&& HighlightUtil.findEnclosingFieldInitializer(expression) == null) {
return null;
}
if (topBlock == null) return null;
final PsiElement parent = topBlock.getParent();
// access to final fields from inner classes always allowed
if (inInnerClass(expression, ((PsiField) variable).getContainingClass(), containingFile))
return null;
final PsiCodeBlock block;
final PsiClass aClass;
if (parent instanceof PsiMethod) {
PsiMethod constructor = (PsiMethod) parent;
if (!containingFile
.getManager()
.areElementsEquivalent(
constructor.getContainingClass(), ((PsiField) variable).getContainingClass()))
return null;
// static variables already initialized in class initializers
if (variable.hasModifierProperty(PsiModifier.STATIC)) return null;
// as a last chance, field may be initialized in this() call
final List<PsiMethod> redirectedConstructors =
JavaHighlightUtil.getChainedConstructors(constructor);
for (int j = 0;
redirectedConstructors != null && j < redirectedConstructors.size();
j++) {
PsiMethod redirectedConstructor = redirectedConstructors.get(j);
// variable must be initialized before its usage
// ???
// if (startOffset < redirectedConstructor.getTextRange().getStartOffset()) continue;
PsiCodeBlock body = redirectedConstructor.getBody();
if (body != null && variableDefinitelyAssignedIn(variable, body)) {
return null;
}
}
block = constructor.getBody();
aClass = constructor.getContainingClass();
} else if (parent instanceof PsiClassInitializer) {
final PsiClassInitializer classInitializer = (PsiClassInitializer) parent;
if (!containingFile
.getManager()
.areElementsEquivalent(
classInitializer.getContainingClass(),
((PsiField) variable).getContainingClass())) return null;
block = classInitializer.getBody();
aClass = classInitializer.getContainingClass();
} else {
// field reference outside code block
// check variable initialized before its usage
final PsiField field = (PsiField) variable;
aClass = field.getContainingClass();
if (aClass == null
|| isFieldInitializedInOtherFieldInitializer(
aClass, field, field.hasModifierProperty(PsiModifier.STATIC))) {
return null;
}
final PsiField anotherField =
PsiTreeUtil.getTopmostParentOfType(expression, PsiField.class);
int offset = startOffset;
if (anotherField != null
&& anotherField.getContainingClass() == aClass
&& !field.hasModifierProperty(PsiModifier.STATIC)) {
offset = 0;
}
block = null;
// initializers will be checked later
final PsiMethod[] constructors = aClass.getConstructors();
for (PsiMethod constructor : constructors) {
// variable must be initialized before its usage
if (offset < constructor.getTextRange().getStartOffset()) continue;
PsiCodeBlock body = constructor.getBody();
if (body != null && variableDefinitelyAssignedIn(variable, body)) {
return null;
}
// as a last chance, field may be initialized in this() call
final List<PsiMethod> redirectedConstructors =
JavaHighlightUtil.getChainedConstructors(constructor);
for (int j = 0;
redirectedConstructors != null && j < redirectedConstructors.size();
j++) {
PsiMethod redirectedConstructor = redirectedConstructors.get(j);
// variable must be initialized before its usage
if (offset < redirectedConstructor.getTextRange().getStartOffset()) continue;
PsiCodeBlock redirectedBody = redirectedConstructor.getBody();
if (redirectedBody != null
&& variableDefinitelyAssignedIn(variable, redirectedBody)) {
return null;
}
}
}
}
if (aClass != null) {
// field may be initialized in class initializer
final PsiClassInitializer[] initializers = aClass.getInitializers();
for (PsiClassInitializer initializer : initializers) {
PsiCodeBlock body = initializer.getBody();
if (body == block) break;
// variable referenced in initializer must be initialized in initializer preceding
// assignment
// variable referenced in field initializer or in class initializer
boolean shouldCheckInitializerOrder =
block == null || block.getParent() instanceof PsiClassInitializer;
if (shouldCheckInitializerOrder
&& startOffset < initializer.getTextRange().getStartOffset()) continue;
if (initializer.hasModifierProperty(PsiModifier.STATIC)
== variable.hasModifierProperty(PsiModifier.STATIC)) {
if (variableDefinitelyAssignedIn(variable, body)) return null;
}
}
}
}
}
if (topBlock == null) return null;
Collection<PsiReferenceExpression> codeBlockProblems = uninitializedVarProblems.get(topBlock);
if (codeBlockProblems == null) {
try {
final ControlFlow controlFlow = getControlFlow(topBlock);
codeBlockProblems = ControlFlowUtil.getReadBeforeWriteLocals(controlFlow);
} catch (AnalysisCanceledException | IndexNotReadyException e) {
codeBlockProblems = Collections.emptyList();
}
uninitializedVarProblems.put(topBlock, codeBlockProblems);
}
if (codeBlockProblems.contains(expression)) {
final String name = expression.getElement().getText();
String description = JavaErrorMessages.message("variable.not.initialized", name);
HighlightInfo highlightInfo =
HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
.range(expression)
.descriptionAndTooltip(description)
.create();
QuickFixAction.registerQuickFixAction(
highlightInfo, QUICK_FIX_FACTORY.createAddVariableInitializerFix(variable));
if (variable instanceof PsiField) {
QuickFixAction.registerQuickFixAction(
highlightInfo,
QUICK_FIX_FACTORY.createModifierListFix(variable, PsiModifier.FINAL, false, false));
}
return highlightInfo;
}
return null;
}
@Override
protected void invokeImpl(PsiClass targetClass) {
final PsiFile callSite = myMethodCall.getContainingFile();
final Project project = myMethodCall.getProject();
PsiElementFactory elementFactory = JavaPsiFacade.getInstance(project).getElementFactory();
IdeDocumentHistory.getInstance(project).includeCurrentPlaceAsChangePlace();
try {
PsiMethod constructor = elementFactory.createConstructor();
constructor = (PsiMethod) targetClass.add(constructor);
final TemplateBuilderImpl templateBuilder = new TemplateBuilderImpl(constructor);
CreateFromUsageUtils.setupMethodParameters(
constructor,
templateBuilder,
myMethodCall.getArgumentList(),
getTargetSubstitutor(myMethodCall));
final PsiFile psiFile = myMethodCall.getContainingFile();
templateBuilder.setEndVariableAfter(constructor.getBody().getLBrace());
final RangeMarker rangeMarker =
psiFile.getViewProvider().getDocument().createRangeMarker(myMethodCall.getTextRange());
constructor = CodeInsightUtilCore.forcePsiPostprocessAndRestoreElement(constructor);
targetClass = constructor.getContainingClass();
myMethodCall =
CodeInsightUtil.findElementInRange(
psiFile,
rangeMarker.getStartOffset(),
rangeMarker.getEndOffset(),
myMethodCall.getClass());
rangeMarker.dispose();
Template template = templateBuilder.buildTemplate();
final Editor editor = positionCursor(project, targetClass.getContainingFile(), targetClass);
if (editor == null) return;
final TextRange textRange = constructor.getTextRange();
final PsiFile file = targetClass.getContainingFile();
editor.getDocument().deleteString(textRange.getStartOffset(), textRange.getEndOffset());
editor.getCaretModel().moveToOffset(textRange.getStartOffset());
startTemplate(
editor,
template,
project,
new TemplateEditingAdapter() {
@Override
public void templateFinished(Template template, boolean brokenOff) {
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
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);
CreateFromUsageUtils.setupMethodBody(constructor);
CreateFromUsageUtils.setupEditor(constructor, editor);
UndoUtil.markPsiFileForUndo(callSite);
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
});
}
});
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
