@Override
public void visitReferenceExpression(final PsiReferenceExpression reference) {
if (myLineRange.intersects(reference.getTextRange())) {
final PsiElement psiElement = reference.resolve();
if (psiElement instanceof PsiVariable) {
final PsiVariable var = (PsiVariable) psiElement;
if (var instanceof PsiField) {
if (myCollectExpressions
&& !DebuggerUtils.hasSideEffectsOrReferencesMissingVars(
reference, myVisibleLocals)) {
/*
if (var instanceof PsiEnumConstant && reference.getQualifier() == null) {
final PsiClass enumClass = ((PsiEnumConstant)var).getContainingClass();
if (enumClass != null) {
final PsiExpression expression = JavaPsiFacade.getInstance(var.getProject()).getParserFacade().createExpressionFromText(enumClass.getName() + "." + var.getName(), var);
final PsiReference ref = expression.getReference();
if (ref != null) {
ref.bindToElement(var);
myExpressions.add(new TextWithImportsImpl(expression));
}
}
}
else {
myExpressions.add(new TextWithImportsImpl(reference));
}
*/
final PsiModifierList modifierList = var.getModifierList();
boolean isConstant =
(var instanceof PsiEnumConstant)
|| (modifierList != null
&& modifierList.hasModifierProperty(PsiModifier.STATIC)
&& modifierList.hasModifierProperty(PsiModifier.FINAL));
if (!isConstant) {
myExpressions.add(new TextWithImportsImpl(reference));
}
}
} else {
if (myVisibleLocals.contains(var.getName())) {
myVars.add(var.getName());
} else {
// fix for variables used in inner classes
if (!Comparing.equal(
PsiTreeUtil.getParentOfType(reference, PsiClass.class),
PsiTreeUtil.getParentOfType(var, PsiClass.class))) {
myExpressions.add(new TextWithImportsImpl(reference));
}
}
}
}
}
super.visitReferenceExpression(reference);
}
@Override
public void handleInsert(InsertionContext context) {
PsiVariable variable = getObject();
Document document = context.getDocument();
document.replaceString(context.getStartOffset(), context.getTailOffset(), variable.getName());
context.commitDocument();
if (variable instanceof PsiField) {
if (willBeImported()) {
RangeMarker toDelete =
JavaCompletionUtil.insertTemporary(context.getTailOffset(), document, " ");
context.commitDocument();
final PsiReferenceExpression ref =
PsiTreeUtil.findElementOfClassAtOffset(
context.getFile(), context.getStartOffset(), PsiReferenceExpression.class, false);
if (ref != null) {
ref.bindToElementViaStaticImport(((PsiField) variable).getContainingClass());
PostprocessReformattingAspect.getInstance(ref.getProject()).doPostponedFormatting();
}
if (toDelete.isValid()) {
document.deleteString(toDelete.getStartOffset(), toDelete.getEndOffset());
}
context.commitDocument();
} else if (shouldQualify((PsiField) variable, context)) {
qualifyFieldReference(context, (PsiField) variable);
}
}
PsiReferenceExpression ref =
PsiTreeUtil.findElementOfClassAtOffset(
context.getFile(), context.getTailOffset() - 1, PsiReferenceExpression.class, false);
if (ref != null) {
JavaCodeStyleManager.getInstance(context.getProject()).shortenClassReferences(ref);
}
ref =
PsiTreeUtil.findElementOfClassAtOffset(
context.getFile(), context.getTailOffset() - 1, PsiReferenceExpression.class, false);
makeVariableFinalIfNeeded(context, ref);
final char completionChar = context.getCompletionChar();
if (completionChar == '=') {
context.setAddCompletionChar(false);
TailType.EQ.processTail(context.getEditor(), context.getTailOffset());
} else if (completionChar == ','
&& getAttribute(LookupItem.TAIL_TYPE_ATTR) != TailType.UNKNOWN) {
context.setAddCompletionChar(false);
TailType.COMMA.processTail(context.getEditor(), context.getTailOffset());
AutoPopupController.getInstance(context.getProject())
.autoPopupParameterInfo(context.getEditor(), null);
} else if (completionChar == ':') {
context.setAddCompletionChar(false);
TailType.COND_EXPR_COLON.processTail(context.getEditor(), context.getTailOffset());
} else if (completionChar == '.') {
AutoPopupController.getInstance(context.getProject())
.autoPopupMemberLookup(context.getEditor(), null);
} else if (completionChar == '!' && PsiType.BOOLEAN.isAssignableFrom(variable.getType())) {
context.setAddCompletionChar(false);
if (ref != null) {
FeatureUsageTracker.getInstance()
.triggerFeatureUsed(CodeCompletionFeatures.EXCLAMATION_FINISH);
document.insertString(ref.getTextRange().getStartOffset(), "!");
}
}
}
@Nullable
static HighlightInfo checkCannotWriteToFinal(
@NotNull PsiExpression expression, @NotNull PsiFile containingFile) {
PsiReferenceExpression reference = null;
boolean readBeforeWrite = false;
if (expression instanceof PsiAssignmentExpression) {
final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression) expression;
final PsiExpression left =
PsiUtil.skipParenthesizedExprDown(assignmentExpression.getLExpression());
if (left instanceof PsiReferenceExpression) {
reference = (PsiReferenceExpression) left;
}
readBeforeWrite = assignmentExpression.getOperationTokenType() != JavaTokenType.EQ;
} else if (expression instanceof PsiPostfixExpression) {
final PsiExpression operand =
PsiUtil.skipParenthesizedExprDown(((PsiPostfixExpression) expression).getOperand());
final IElementType sign = ((PsiPostfixExpression) expression).getOperationTokenType();
if (operand instanceof PsiReferenceExpression
&& (sign == JavaTokenType.PLUSPLUS || sign == JavaTokenType.MINUSMINUS)) {
reference = (PsiReferenceExpression) operand;
}
readBeforeWrite = true;
} else if (expression instanceof PsiPrefixExpression) {
final PsiExpression operand =
PsiUtil.skipParenthesizedExprDown(((PsiPrefixExpression) expression).getOperand());
final IElementType sign = ((PsiPrefixExpression) expression).getOperationTokenType();
if (operand instanceof PsiReferenceExpression
&& (sign == JavaTokenType.PLUSPLUS || sign == JavaTokenType.MINUSMINUS)) {
reference = (PsiReferenceExpression) operand;
}
readBeforeWrite = true;
}
final PsiElement resolved = reference == null ? null : reference.resolve();
PsiVariable variable = resolved instanceof PsiVariable ? (PsiVariable) resolved : null;
if (variable == null || !variable.hasModifierProperty(PsiModifier.FINAL)) return null;
final boolean canWrite =
canWriteToFinal(variable, expression, reference, containingFile)
&& checkWriteToFinalInsideLambda(variable, reference) == null;
if (readBeforeWrite || !canWrite) {
final String name = variable.getName();
String description =
canWrite
? JavaErrorMessages.message("variable.not.initialized", name)
: JavaErrorMessages.message("assignment.to.final.variable", name);
final HighlightInfo highlightInfo =
HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
.range(reference.getTextRange())
.descriptionAndTooltip(description)
.create();
final PsiElement innerClass = getInnerClassVariableReferencedFrom(variable, expression);
if (innerClass == null || variable instanceof PsiField) {
QuickFixAction.registerQuickFixAction(
highlightInfo,
QUICK_FIX_FACTORY.createModifierListFix(variable, PsiModifier.FINAL, false, false));
} else {
QuickFixAction.registerQuickFixAction(
highlightInfo,
QUICK_FIX_FACTORY.createVariableAccessFromInnerClassFix(variable, innerClass));
}
return highlightInfo;
}
return null;
}
@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;
}
public void invoke(@NotNull Project project, Editor editor, PsiFile file)
throws IncorrectOperationException {
LOG.assertTrue(myOutOfScopeVariable != null);
PsiManager manager = file.getManager();
myOutOfScopeVariable.normalizeDeclaration();
PsiUtil.setModifierProperty(myOutOfScopeVariable, PsiModifier.FINAL, false);
PsiElement commonParent =
PsiTreeUtil.findCommonParent(myOutOfScopeVariable, myUnresolvedReference);
LOG.assertTrue(commonParent != null);
PsiElement child =
myOutOfScopeVariable.getTextRange().getStartOffset()
< myUnresolvedReference.getTextRange().getStartOffset()
? myOutOfScopeVariable
: myUnresolvedReference;
while (child.getParent() != commonParent) child = child.getParent();
PsiDeclarationStatement newDeclaration =
(PsiDeclarationStatement)
JavaPsiFacade.getInstance(manager.getProject())
.getElementFactory()
.createStatementFromText("int i = 0", null);
PsiVariable variable =
(PsiVariable) newDeclaration.getDeclaredElements()[0].replace(myOutOfScopeVariable);
if (variable.getInitializer() != null) {
variable.getInitializer().delete();
}
while (!(child instanceof PsiStatement) || !(child.getParent() instanceof PsiCodeBlock)) {
child = child.getParent();
commonParent = commonParent.getParent();
}
LOG.assertTrue(commonParent != null);
PsiDeclarationStatement added =
(PsiDeclarationStatement) commonParent.addBefore(newDeclaration, child);
PsiLocalVariable addedVar = (PsiLocalVariable) added.getDeclaredElements()[0];
manager.getCodeStyleManager().reformat(commonParent);
// Leave initializer assignment
PsiExpression initializer = myOutOfScopeVariable.getInitializer();
if (initializer != null) {
PsiExpressionStatement assignment =
(PsiExpressionStatement)
JavaPsiFacade.getInstance(manager.getProject())
.getElementFactory()
.createStatementFromText(myOutOfScopeVariable.getName() + "= e;", null);
((PsiAssignmentExpression) assignment.getExpression()).getRExpression().replace(initializer);
assignment = (PsiExpressionStatement) manager.getCodeStyleManager().reformat(assignment);
PsiDeclarationStatement declStatement =
PsiTreeUtil.getParentOfType(myOutOfScopeVariable, PsiDeclarationStatement.class);
LOG.assertTrue(declStatement != null);
PsiElement parent = declStatement.getParent();
if (parent instanceof PsiForStatement) {
declStatement.replace(assignment);
} else {
parent.addAfter(assignment, declStatement);
}
}
if (myOutOfScopeVariable.isValid()) {
myOutOfScopeVariable.delete();
}
if (HighlightControlFlowUtil.checkVariableInitializedBeforeUsage(
myUnresolvedReference,
addedVar,
new THashMap<PsiElement, Collection<PsiReferenceExpression>>())
!= null) {
initialize(addedVar);
}
DaemonCodeAnalyzer.getInstance(project).updateVisibleHighlighters(editor);
}
