diff --git a/plugin/src/main/java/com/intellij/java/impl/analysis/BaseClassesAnalysisAction.java b/plugin/src/main/java/com/intellij/java/impl/analysis/BaseClassesAnalysisAction.java index cb70d0a2b..205aa6a8b 100644 --- a/plugin/src/main/java/com/intellij/java/impl/analysis/BaseClassesAnalysisAction.java +++ b/plugin/src/main/java/com/intellij/java/impl/analysis/BaseClassesAnalysisAction.java @@ -33,10 +33,12 @@ * @author mike */ public abstract class BaseClassesAnalysisAction extends BaseAnalysisAction { - protected BaseClassesAnalysisAction(LocalizeValue actionText, - LocalizeValue actionDescription, - LocalizeValue title, - LocalizeValue analysisNoon) { + protected BaseClassesAnalysisAction( + LocalizeValue actionText, + LocalizeValue actionDescription, + LocalizeValue title, + LocalizeValue analysisNoon + ) { super(actionText, actionDescription, title, analysisNoon); } @@ -53,13 +55,13 @@ public void run(ProgressIndicator indicator) { indicator.setIndeterminate(true); indicator.setText(AnalysisScopeLocalize.checkingClassFiles()); - CompilerManager compilerManager = CompilerManager.getInstance((Project)getProject()); + CompilerManager compilerManager = CompilerManager.getInstance((Project) getProject()); boolean upToDate = compilerManager.isUpToDate(compilerManager.createProjectCompileScope()); project.getApplication().invokeLater(() -> { if (!upToDate) { int i = Messages.showYesNoCancelDialog( - (Project)getProject(), + (Project) getProject(), AnalysisScopeLocalize.recompileConfirmationMessage().get(), AnalysisScopeLocalize.projectIsOutOfDate().get(), UIUtil.getWarningIcon() @@ -89,7 +91,7 @@ private void doAnalyze(Project project, AnalysisScope scope) { @Override public NotificationInfo getNotificationInfo() { return new NotificationInfo( - LocalizeValue.localizeTODO("Analysis"), + "Analysis", LocalizeValue.localizeTODO("\"" + getTitle() + "\" Analysis Finished"), LocalizeValue.empty() ); @@ -105,11 +107,14 @@ public void run(ProgressIndicator indicator) { @RequiredReadAction private void compileAndAnalyze(Project project, AnalysisScope scope) { CompilerManager compilerManager = CompilerManager.getInstance(project); - compilerManager.make(compilerManager.createProjectCompileScope(), (aborted, errors, warnings, compileContext) -> { - if (aborted || errors != 0) { - return; + compilerManager.make( + compilerManager.createProjectCompileScope(), + (aborted, errors, warnings, compileContext) -> { + if (aborted || errors != 0) { + return; + } + project.getApplication().invokeLater(() -> doAnalyze(project, scope)); } - project.getApplication().invokeLater(() -> doAnalyze(project, scope)); - }); + ); } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/highlighting/HighlightExitPointsHandler.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/highlighting/HighlightExitPointsHandler.java index f9aeb9863..aa7e87428 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/highlighting/HighlightExitPointsHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/highlighting/HighlightExitPointsHandler.java @@ -17,6 +17,7 @@ import com.intellij.java.language.impl.psi.controlFlow.*; import com.intellij.java.language.psi.*; +import consulo.annotation.access.RequiredReadAction; import consulo.codeEditor.Editor; import consulo.externalService.statistic.FeatureUsageTracker; import consulo.ide.impl.idea.codeInsight.highlighting.HighlightUsagesHandler; @@ -37,132 +38,139 @@ import java.util.function.Consumer; public class HighlightExitPointsHandler extends HighlightUsagesHandlerBase { - private final PsiElement myTarget; - - public HighlightExitPointsHandler(Editor editor, PsiFile file, PsiElement target) { - super(editor, file); - myTarget = target; - } - - @Override - public List getTargets() { - return Collections.singletonList(myTarget); - } - - @Override - protected void selectTargets(List targets, Consumer> selectionConsumer) { - selectionConsumer.accept(targets); - } - - @Override - public void computeUsages(List targets) { - FeatureUsageTracker.getInstance().triggerFeatureUsed(ProductivityFeatureNames.CODEASSISTS_HIGHLIGHT_RETURN); - - PsiElement parent = myTarget.getParent(); - if (!(parent instanceof PsiReturnStatement) && !(parent instanceof PsiThrowStatement)) { - return; - } + private final PsiElement myTarget; - PsiCodeBlock body = null; - PsiLambdaExpression lambdaExpression = PsiTreeUtil.getParentOfType(myTarget, PsiLambdaExpression.class); - if (lambdaExpression != null) { - PsiElement lambdaBody = lambdaExpression.getBody(); - if (lambdaBody instanceof PsiCodeBlock codeBlock) { - body = codeBlock; - } + public HighlightExitPointsHandler(Editor editor, PsiFile file, PsiElement target) { + super(editor, file); + myTarget = target; } - if (body == null) { - PsiMethod method = PsiTreeUtil.getParentOfType(myTarget, PsiMethod.class); - body = method != null ? method.getBody() : null; + @Override + @RequiredReadAction + public List getTargets() { + return Collections.singletonList(myTarget); } - if (body == null) { - return; + @Override + protected void selectTargets(List targets, Consumer> selectionConsumer) { + selectionConsumer.accept(targets); } - try { - highlightExitPoints((PsiStatement) parent, body); - } catch (AnalysisCanceledException e) { - // ignore - } - } - - @Nullable - private static PsiElement getExitTarget(PsiStatement exitStatement) { - if (exitStatement instanceof PsiReturnStatement) { - return PsiTreeUtil.getParentOfType(exitStatement, PsiMethod.class); - } else if (exitStatement instanceof PsiBreakStatement breakStatement) { - return breakStatement.findExitedStatement(); - } else if (exitStatement instanceof PsiContinueStatement continueStatement) { - return continueStatement.findContinuedStatement(); - } else if (exitStatement instanceof PsiThrowStatement throwStatement) { - PsiExpression expr = throwStatement.getException(); - if (expr == null) { - return null; - } - PsiType exceptionType = expr.getType(); - if (!(exceptionType instanceof PsiClassType)) { - return null; - } - - PsiElement target = exitStatement; - while (!(target instanceof PsiMethod || target == null || target instanceof PsiClass || target instanceof PsiFile)) { - if (target instanceof PsiTryStatement tryStatement) { - PsiParameter[] params = tryStatement.getCatchBlockParameters(); - for (PsiParameter param : params) { - if (param.getType().isAssignableFrom(exceptionType)) { - break; + @Override + @RequiredReadAction + public void computeUsages(List targets) { + FeatureUsageTracker.getInstance().triggerFeatureUsed(ProductivityFeatureNames.CODEASSISTS_HIGHLIGHT_RETURN); + + PsiElement parent = myTarget.getParent(); + if (!(parent instanceof PsiReturnStatement) && !(parent instanceof PsiThrowStatement)) { + return; + } + + PsiCodeBlock body = null; + PsiLambdaExpression lambdaExpression = PsiTreeUtil.getParentOfType(myTarget, PsiLambdaExpression.class); + if (lambdaExpression != null) { + PsiElement lambdaBody = lambdaExpression.getBody(); + if (lambdaBody instanceof PsiCodeBlock codeBlock) { + body = codeBlock; } - } } - target = target.getParent(); - } - if (target instanceof PsiMethod || target instanceof PsiTryStatement) { - return target; - } - return null; - } - return null; - } - - private void highlightExitPoints(PsiStatement parent, PsiCodeBlock body) throws AnalysisCanceledException { - Project project = myTarget.getProject(); - ControlFlow flow = ControlFlowFactory.getInstance(project).getControlFlow( - body, - LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance(), - false - ); - - Collection exitStatements = ControlFlowUtil.findExitPointsAndStatements( - flow, - 0, - flow.getSize(), - IntLists.newArrayList(), - PsiReturnStatement.class, - PsiBreakStatement.class, - PsiContinueStatement.class, - PsiThrowStatement.class - ); - if (!exitStatements.contains(parent)) { - return; + if (body == null) { + PsiMethod method = PsiTreeUtil.getParentOfType(myTarget, PsiMethod.class); + body = method != null ? method.getBody() : null; + } + + if (body == null) { + return; + } + + try { + highlightExitPoints((PsiStatement) parent, body); + } + catch (AnalysisCanceledException e) { + // ignore + } } - PsiElement originalTarget = getExitTarget(parent); + @Nullable + private static PsiElement getExitTarget(PsiStatement exitStatement) { + if (exitStatement instanceof PsiReturnStatement) { + return PsiTreeUtil.getParentOfType(exitStatement, PsiMethod.class); + } + else if (exitStatement instanceof PsiBreakStatement breakStatement) { + return breakStatement.findExitedStatement(); + } + else if (exitStatement instanceof PsiContinueStatement continueStatement) { + return continueStatement.findContinuedStatement(); + } + else if (exitStatement instanceof PsiThrowStatement throwStatement) { + PsiExpression expr = throwStatement.getException(); + if (expr == null) { + return null; + } + PsiType exceptionType = expr.getType(); + if (!(exceptionType instanceof PsiClassType)) { + return null; + } + + PsiElement target = exitStatement; + while (!(target instanceof PsiMethod || target == null || target instanceof PsiClass || target instanceof PsiFile)) { + if (target instanceof PsiTryStatement tryStatement) { + PsiParameter[] params = tryStatement.getCatchBlockParameters(); + for (PsiParameter param : params) { + if (param.getType().isAssignableFrom(exceptionType)) { + break; + } + } + } + target = target.getParent(); + } + if (target instanceof PsiMethod || target instanceof PsiTryStatement) { + return target; + } + return null; + } - Iterator it = exitStatements.iterator(); - while (it.hasNext()) { - PsiStatement psiStatement = it.next(); - if (getExitTarget(psiStatement) != originalTarget) { - it.remove(); - } + return null; } - for (PsiElement e : exitStatements) { - addOccurrence(e); + @RequiredReadAction + private void highlightExitPoints(PsiStatement parent, PsiCodeBlock body) throws AnalysisCanceledException { + Project project = myTarget.getProject(); + ControlFlow flow = ControlFlowFactory.getInstance(project).getControlFlow( + body, + LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance(), + false + ); + + Collection exitStatements = ControlFlowUtil.findExitPointsAndStatements( + flow, + 0, + flow.getSize(), + IntLists.newArrayList(), + PsiReturnStatement.class, + PsiBreakStatement.class, + PsiContinueStatement.class, + PsiThrowStatement.class + ); + if (!exitStatements.contains(parent)) { + return; + } + + PsiElement originalTarget = getExitTarget(parent); + + Iterator it = exitStatements.iterator(); + while (it.hasNext()) { + PsiStatement psiStatement = it.next(); + if (getExitTarget(psiStatement) != originalTarget) { + it.remove(); + } + } + + for (PsiElement e : exitStatements) { + addOccurrence(e); + } + myStatusText = + CodeInsightLocalize.statusBarExitPointsHighlightedMessage(exitStatements.size(), HighlightUsagesHandler.getShortcutText()); } - myStatusText = - CodeInsightLocalize.statusBarExitPointsHighlightedMessage(exitStatements.size(), HighlightUsagesHandler.getShortcutText()).get(); - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/highlighting/HighlightOverridingMethodsHandler.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/highlighting/HighlightOverridingMethodsHandler.java index a6f78b19a..1091716e3 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/highlighting/HighlightOverridingMethodsHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/highlighting/HighlightOverridingMethodsHandler.java @@ -18,7 +18,6 @@ import com.intellij.java.language.psi.*; import com.intellij.java.language.psi.util.InheritanceUtil; import consulo.annotation.access.RequiredReadAction; -import consulo.application.ApplicationManager; import consulo.codeEditor.Editor; import consulo.externalService.statistic.FeatureUsageTracker; import consulo.ide.impl.idea.codeInsight.highlighting.HighlightUsagesHandler; @@ -27,6 +26,7 @@ import consulo.language.editor.localize.CodeInsightLocalize; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; +import consulo.localize.LocalizeValue; import consulo.navigation.ItemPresentation; import java.util.Arrays; @@ -99,7 +99,9 @@ public void computeUsages(List classes) { else { name = ""; } - myHintText = CodeInsightBundle.message("no.methods.overriding.0.are.found", classes.size(), name); + myHintText = LocalizeValue.localizeTODO( + CodeInsightBundle.message("no.methods.overriding.0.are.found", classes.size(), name) + ); } else { addOccurrence(myTarget); @@ -107,7 +109,7 @@ public void computeUsages(List classes) { myStatusText = CodeInsightLocalize.statusBarOverriddenMethodsHighlightedMessage( methodCount, HighlightUsagesHandler.getShortcutText() - ).get(); + ); } } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/AnnotatedMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/AnnotatedMacro.java index cb7c868dd..3d618ffde 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/AnnotatedMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/AnnotatedMacro.java @@ -13,7 +13,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package com.intellij.java.impl.codeInsight.template.macro; import com.intellij.java.impl.codeInsight.template.JavaCodeContextType; @@ -33,6 +32,7 @@ import consulo.language.editor.template.macro.Macro; import consulo.language.psi.PsiManager; import consulo.language.psi.scope.GlobalSearchScope; +import consulo.localize.LocalizeValue; import consulo.project.Project; import org.jspecify.annotations.Nullable; @@ -44,81 +44,85 @@ * @author Maxim.Mossienko */ @ExtensionImpl -public class AnnotatedMacro extends Macro { - - @Override - public String getName() { - return "annotated"; - } - - @Override - public String getPresentableName() { - return "annotated(\"annotation qname\")"; - } - - @Nullable - private static Query findAnnotated(ExpressionContext context, Expression[] params) { - if (params == null || params.length == 0) return null; - PsiManager instance = PsiManager.getInstance(context.getProject()); - - String paramResult = params[0].calculateResult(context).toString(); - if (paramResult == null) return null; - GlobalSearchScope scope = GlobalSearchScope.allScope(context.getProject()); - PsiClass myBaseClass = JavaPsiFacade.getInstance(instance.getProject()).findClass(paramResult, scope); - - if (myBaseClass != null) { - return AnnotatedMembersSearch.search(myBaseClass, scope); +public class AnnotatedMacro extends Macro { + @Override + public String getName() { + return "annotated"; + } + + @Override + public LocalizeValue getPresentableName() { + return LocalizeValue.localizeTODO("annotated(\"annotation qname\")"); + } + + @Nullable + private static Query findAnnotated(ExpressionContext context, Expression[] params) { + if (params == null || params.length == 0) { + return null; + } + PsiManager instance = PsiManager.getInstance(context.getProject()); + + String paramResult = params[0].calculateResult(context).toString(); + if (paramResult == null) { + return null; + } + GlobalSearchScope scope = GlobalSearchScope.allScope(context.getProject()); + PsiClass myBaseClass = JavaPsiFacade.getInstance(instance.getProject()).findClass(paramResult, scope); + + if (myBaseClass != null) { + return AnnotatedMembersSearch.search(myBaseClass, scope); + } + return null; } - return null; - } - @Override - public Result calculateResult(Expression[] expressions, ExpressionContext expressionContext) { - Query psiMembers = findAnnotated(expressionContext, expressions); + @Override + public Result calculateResult(Expression[] expressions, ExpressionContext expressionContext) { + Query psiMembers = findAnnotated(expressionContext, expressions); - if (psiMembers != null) { - PsiMember member = psiMembers.findFirst(); + if (psiMembers != null) { + PsiMember member = psiMembers.findFirst(); - if (member != null) { - return new TextResult(member instanceof PsiClass ? ((PsiClass)member).getQualifiedName():member.getName()); - } + if (member != null) { + return new TextResult(member instanceof PsiClass ? ((PsiClass) member).getQualifiedName() : member.getName()); + } + } + return null; } - return null; - } - - @Override - public Result calculateQuickResult(Expression[] expressions, ExpressionContext expressionContext) { - return calculateResult(expressions, expressionContext); - } - - @Override - public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { - Query query = findAnnotated(context, params); - - if (query != null) { - Set set = new LinkedHashSet(); - String secondParamValue = params.length > 1 ? params[1].calculateResult(context).toString() : null; - boolean isShortName = secondParamValue != null && !Boolean.valueOf(secondParamValue); - Project project = context.getProject(); - PsiClass findInClass = secondParamValue != null - ? JavaPsiFacade.getInstance(project).findClass(secondParamValue, GlobalSearchScope.allScope(project)) - : null; - - for (PsiMember object : query.findAll()) { - if (findInClass != null && !object.getContainingClass().equals(findInClass)) continue; - boolean isClazz = object instanceof PsiClass; - String name = isShortName || !isClazz ? object.getName() : ((PsiClass) object).getQualifiedName(); - set.add(LookupElementBuilder.create(name)); - } - - return set.toArray(new LookupElement[set.size()]); + + @Override + public Result calculateQuickResult(Expression[] expressions, ExpressionContext expressionContext) { + return calculateResult(expressions, expressionContext); } - return LookupElement.EMPTY_ARRAY; - } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { + Query query = findAnnotated(context, params); + + if (query != null) { + Set set = new LinkedHashSet<>(); + String secondParamValue = params.length > 1 ? params[1].calculateResult(context).toString() : null; + boolean isShortName = secondParamValue != null && !Boolean.valueOf(secondParamValue); + Project project = context.getProject(); + PsiClass findInClass = secondParamValue != null + ? JavaPsiFacade.getInstance(project).findClass(secondParamValue, GlobalSearchScope.allScope(project)) + : null; + + for (PsiMember object : query.findAll()) { + if (findInClass != null && !object.getContainingClass().equals(findInClass)) { + continue; + } + boolean isClazz = object instanceof PsiClass; + String name = isShortName || !isClazz ? object.getName() : ((PsiClass) object).getQualifiedName(); + set.add(LookupElementBuilder.create(name)); + } + + return set.toArray(new LookupElement[set.size()]); + } + return LookupElement.EMPTY_ARRAY; + } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ArrayVariableMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ArrayVariableMacro.java index 1a8a55cfa..e704db362 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ArrayVariableMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ArrayVariableMacro.java @@ -27,39 +27,42 @@ import consulo.language.psi.PsiDocumentManager; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; +import consulo.localize.LocalizeValue; import consulo.project.Project; import java.util.ArrayList; @ExtensionImpl public class ArrayVariableMacro extends VariableTypeMacroBase { - @Override - public String getName() { - return "arrayVariable"; - } + @Override + public String getName() { + return "arrayVariable"; + } - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroArrayVariable().get(); - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroArrayVariable(); + } - @Override - @RequiredReadAction - protected PsiElement[] getVariables(Expression[] params, ExpressionContext context) { - if (params.length != 0) return null; + @Override + @RequiredReadAction + protected PsiElement[] getVariables(Expression[] params, ExpressionContext context) { + if (params.length != 0) { + return null; + } - Project project = context.getProject(); - int offset = context.getStartOffset(); - ArrayList array = new ArrayList<>(); - PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); - PsiElement place = file.findElementAt(offset); - PsiVariable[] variables = MacroUtil.getVariablesVisibleAt(place, ""); - for (PsiVariable variable : variables) { - PsiType type = VariableTypeCalculator.getVarTypeAt(variable, place); - if (type instanceof PsiArrayType) { - array.add(variable); - } + Project project = context.getProject(); + int offset = context.getStartOffset(); + ArrayList array = new ArrayList<>(); + PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); + PsiElement place = file.findElementAt(offset); + PsiVariable[] variables = MacroUtil.getVariablesVisibleAt(place, ""); + for (PsiVariable variable : variables) { + PsiType type = VariableTypeCalculator.getVarTypeAt(variable, place); + if (type instanceof PsiArrayType) { + array.add(variable); + } + } + return array.toArray(new PsiVariable[array.size()]); } - return array.toArray(new PsiVariable[array.size()]); - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/CastToLeftSideTypeMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/CastToLeftSideTypeMacro.java index 328eaaad3..b7b2406a9 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/CastToLeftSideTypeMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/CastToLeftSideTypeMacro.java @@ -34,56 +34,58 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import consulo.project.Project; @ExtensionImpl public class CastToLeftSideTypeMacro extends Macro { - @Override - public String getName() { - return "castToLeftSideType"; - } - - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroCastToLeftSideType().get(); - } - - @Override - public String getDefaultValue() { - return "(A)"; - } - - @Override - @RequiredReadAction - public Result calculateResult(Expression[] params, ExpressionContext context) { - int offset = context.getStartOffset(); - Project project = context.getProject(); - PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); - PsiElement element = file.findElementAt(offset); - element = PsiTreeUtil.getParentOfType(element, PsiAssignmentExpression.class, PsiVariable.class); - PsiType leftType = null; - PsiExpression rightSide = null; - if (element instanceof PsiAssignmentExpression assignment) { - leftType = assignment.getLExpression().getType(); - rightSide = assignment.getRExpression(); - } else if (element instanceof PsiVariable var) { - leftType = var.getType(); - rightSide = var.getInitializer(); + @Override + public String getName() { + return "castToLeftSideType"; } - while (rightSide instanceof PsiTypeCastExpression typeCastExpression) { - rightSide = typeCastExpression.getOperand(); + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroCastToLeftSideType(); } - if (leftType != null && rightSide != null && rightSide.getType() != null && !leftType.isAssignableFrom(rightSide.getType())) { - return new TextResult("("+ leftType.getCanonicalText() + ")"); + @Override + public String getDefaultValue() { + return "(A)"; } - return new TextResult(""); - } + @Override + @RequiredReadAction + public Result calculateResult(Expression[] params, ExpressionContext context) { + int offset = context.getStartOffset(); + Project project = context.getProject(); + PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); + PsiElement element = file.findElementAt(offset); + element = PsiTreeUtil.getParentOfType(element, PsiAssignmentExpression.class, PsiVariable.class); + PsiType leftType = null; + PsiExpression rightSide = null; + if (element instanceof PsiAssignmentExpression assignment) { + leftType = assignment.getLExpression().getType(); + rightSide = assignment.getRExpression(); + } + else if (element instanceof PsiVariable var) { + leftType = var.getType(); + rightSide = var.getInitializer(); + } + + while (rightSide instanceof PsiTypeCastExpression typeCastExpression) { + rightSide = typeCastExpression.getOperand(); + } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + if (leftType != null && rightSide != null && rightSide.getType() != null && !leftType.isAssignableFrom(rightSide.getType())) { + return new TextResult("(" + leftType.getCanonicalText() + ")"); + } + + return new TextResult(""); + } + + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ClassNameMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ClassNameMacro.java index 0e071f5d6..3134d46da 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ClassNameMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ClassNameMacro.java @@ -30,57 +30,59 @@ import consulo.language.editor.template.context.TemplateContextType; import consulo.language.editor.template.macro.Macro; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; @ExtensionImpl public class ClassNameMacro extends Macro { + @Override + public String getName() { + return "className"; + } - @Override - public String getName() { - return "className"; - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroClassname(); + } - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroClassname().get(); - } + @Override + @RequiredReadAction + public Result calculateResult(Expression[] params, ExpressionContext context) { + int templateStartOffset = context.getTemplateStartOffset(); + int offset = templateStartOffset > 0 ? context.getTemplateStartOffset() - 1 : context.getTemplateStartOffset(); + PsiElement place = context.getPsiElementAtStartOffset(); + PsiClass aClass = null; - @Override - @RequiredReadAction - public Result calculateResult(Expression[] params, ExpressionContext context) { - int templateStartOffset = context.getTemplateStartOffset(); - int offset = templateStartOffset > 0 ? context.getTemplateStartOffset() - 1 : context.getTemplateStartOffset(); - PsiElement place = context.getPsiElementAtStartOffset(); - PsiClass aClass = null; + while (place != null) { + if (place instanceof PsiClass placeClass && !(place instanceof PsiAnonymousClass) && !(place instanceof PsiTypeParameter)) { + aClass = placeClass; + // if className() is evaluated outside of the body of inner class, return name of its outer class instead (IDEADEV-19865) + PsiElement lBrace = aClass.getLBrace(); + if (lBrace != null && offset < lBrace.getTextOffset() && aClass.getContainingClass() != null) { + aClass = aClass.getContainingClass(); + } + break; + } + if (place instanceof PsiJavaFile javaFile) { + PsiClass[] classes = javaFile.getClasses(); + aClass = classes.length != 0 ? classes[0] : null; + break; + } + place = place.getParent(); + } - while (place != null) { - if (place instanceof PsiClass placeClass && !(place instanceof PsiAnonymousClass) && !(place instanceof PsiTypeParameter)) { - aClass = placeClass; - // if className() is evaluated outside of the body of inner class, return name of its outer class instead (IDEADEV-19865) - PsiElement lBrace = aClass.getLBrace(); - if (lBrace != null && offset < lBrace.getTextOffset() && aClass.getContainingClass() != null) { - aClass = aClass.getContainingClass(); + if (aClass == null) { + return null; } - break; - } - if (place instanceof PsiJavaFile javaFile) { - PsiClass[] classes = javaFile.getClasses(); - aClass = classes.length != 0 ? classes[0] : null; - break; - } - place = place.getParent(); + String result = aClass.getName(); + while (aClass.getContainingClass() != null && aClass.getContainingClass().getName() != null) { + result = aClass.getContainingClass().getName() + "$" + result; + aClass = aClass.getContainingClass(); + } + return new TextResult(result); } - if (aClass == null) return null; - String result = aClass.getName(); - while (aClass.getContainingClass() != null && aClass.getContainingClass().getName() != null) { - result = aClass.getContainingClass().getName() + "$" + result; - aClass = aClass.getContainingClass(); + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; } - return new TextResult(result); - } - - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ComponentTypeOfMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ComponentTypeOfMacro.java index ddcb7b719..7705a4357 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ComponentTypeOfMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ComponentTypeOfMacro.java @@ -32,88 +32,89 @@ import consulo.language.editor.template.Result; import consulo.language.editor.template.context.TemplateContextType; import consulo.language.editor.template.macro.Macro; +import consulo.localize.LocalizeValue; import java.util.ArrayList; import java.util.List; @ExtensionImpl public class ComponentTypeOfMacro extends Macro { - @Override - public String getName() { - return "componentTypeOf"; - } - - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroComponentTypeOfArray().get(); - } - - @Override - public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { - if (params.length != 1) { - return null; + @Override + public String getName() { + return "componentTypeOf"; } - LookupElement[] lookupItems = params[0].calculateLookupItems(context); - if (lookupItems == null) { - return null; + + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroComponentTypeOfArray(); } - List result = new ArrayList<>(); - for (LookupElement element : lookupItems) { - PsiTypeLookupItem lookupItem = element.as(PsiTypeLookupItem.CLASS_CONDITION_KEY); - if (lookupItem != null) { - PsiType psiType = lookupItem.getType(); - if (psiType instanceof PsiArrayType arrayType) { - result.add(PsiTypeLookupItem.createLookupItem(arrayType.getComponentType(), null)); + @Override + public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { + if (params.length != 1) { + return null; + } + LookupElement[] lookupItems = params[0].calculateLookupItems(context); + if (lookupItems == null) { + return null; } - } - } - return lookupItems; - } + List result = new ArrayList<>(); + for (LookupElement element : lookupItems) { + PsiTypeLookupItem lookupItem = element.as(PsiTypeLookupItem.CLASS_CONDITION_KEY); + if (lookupItem != null) { + PsiType psiType = lookupItem.getType(); + if (psiType instanceof PsiArrayType arrayType) { + result.add(PsiTypeLookupItem.createLookupItem(arrayType.getComponentType(), null)); + } + } + } - @Override - @RequiredReadAction - public Result calculateResult(Expression[] params, ExpressionContext context) { - if (params.length != 1) { - return null; - } - Result result = params[0].calculateResult(context); - if (result == null) { - return null; + return lookupItems; } - if (result instanceof PsiTypeResult typeResult) { - PsiType type = typeResult.getType(); - if (type instanceof PsiArrayType arrayType) { - return new PsiTypeResult(arrayType.getComponentType(), context.getProject()); - } - } + @Override + @RequiredReadAction + public Result calculateResult(Expression[] params, ExpressionContext context) { + if (params.length != 1) { + return null; + } + Result result = params[0].calculateResult(context); + if (result == null) { + return null; + } - PsiExpression expr = MacroUtil.resultToPsiExpression(result, context); - PsiType type = expr == null ? MacroUtil.resultToPsiType(result, context) : expr.getType(); - if (type instanceof PsiArrayType arrayType) { - return new PsiTypeResult(arrayType.getComponentType(), context.getProject()); - } + if (result instanceof PsiTypeResult typeResult) { + PsiType type = typeResult.getType(); + if (type instanceof PsiArrayType arrayType) { + return new PsiTypeResult(arrayType.getComponentType(), context.getProject()); + } + } - LookupElement[] elements = params[0].calculateLookupItems(context); - if (elements != null) { - for (LookupElement element : elements) { - PsiTypeLookupItem typeLookupItem = element.as(PsiTypeLookupItem.CLASS_CONDITION_KEY); - if (typeLookupItem != null) { - PsiType psiType = typeLookupItem.getType(); - if (psiType instanceof PsiArrayType arrayType) { + PsiExpression expr = MacroUtil.resultToPsiExpression(result, context); + PsiType type = expr == null ? MacroUtil.resultToPsiType(result, context) : expr.getType(); + if (type instanceof PsiArrayType arrayType) { return new PsiTypeResult(arrayType.getComponentType(), context.getProject()); - } } - } - } - return new PsiElementResult(null); - } + LookupElement[] elements = params[0].calculateLookupItems(context); + if (elements != null) { + for (LookupElement element : elements) { + PsiTypeLookupItem typeLookupItem = element.as(PsiTypeLookupItem.CLASS_CONDITION_KEY); + if (typeLookupItem != null) { + PsiType psiType = typeLookupItem.getType(); + if (psiType instanceof PsiArrayType arrayType) { + return new PsiTypeResult(arrayType.getComponentType(), context.getProject()); + } + } + } + } + + return new PsiElementResult(null); + } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/CurrentPackageMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/CurrentPackageMacro.java index c2e4a540b..b962f54d1 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/CurrentPackageMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/CurrentPackageMacro.java @@ -27,41 +27,39 @@ import consulo.language.editor.template.macro.Macro; import consulo.language.psi.PsiDocumentManager; import consulo.language.psi.PsiFile; +import consulo.localize.LocalizeValue; import consulo.project.Project; /** - * Created by IntelliJ IDEA. - * User: ven - * Date: May 13, 2003 - * Time: 8:36:42 PM - * To change this template use Options | File Templates. + * @author ven + * @since 2003-05-13 */ @ExtensionImpl public class CurrentPackageMacro extends Macro { - @Override - public String getName() { - return "currentPackage"; - } + @Override + public String getName() { + return "currentPackage"; + } - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroCurrentPackage().get(); - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroCurrentPackage(); + } - @Override - public Result calculateResult(Expression[] params, ExpressionContext context) { - Project project = context.getProject(); - PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); - return file instanceof PsiJavaFile javaFile ? new TextResult(javaFile.getPackageName()) : new TextResult(""); - } + @Override + public Result calculateResult(Expression[] params, ExpressionContext context) { + Project project = context.getProject(); + PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); + return file instanceof PsiJavaFile javaFile ? new TextResult(javaFile.getPackageName()) : new TextResult(""); + } - @Override - public Result calculateQuickResult(Expression[] params, ExpressionContext context) { - return calculateResult(params, context); - } + @Override + public Result calculateQuickResult(Expression[] params, ExpressionContext context) { + return calculateResult(params, context); + } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/DescendantClassesEnumMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/DescendantClassesEnumMacro.java index 03bd880ee..66997bff9 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/DescendantClassesEnumMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/DescendantClassesEnumMacro.java @@ -22,6 +22,7 @@ import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiModifier; import com.intellij.java.language.psi.PsiModifierList; +import consulo.annotation.access.RequiredReadAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.editor.completion.lookup.LookupElement; import consulo.language.editor.completion.lookup.LookupElementBuilder; @@ -35,6 +36,7 @@ import consulo.language.psi.resolve.PsiElementProcessor; import consulo.language.psi.resolve.PsiElementProcessorAdapter; import consulo.language.psi.scope.GlobalSearchScope; +import consulo.localize.LocalizeValue; import org.jspecify.annotations.Nullable; import java.util.ArrayList; @@ -44,106 +46,123 @@ @ExtensionImpl public class DescendantClassesEnumMacro extends Macro { - @Override - public String getName() { - return "descendantClassesEnum"; - } - - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroDescendantClassesEnum().get(); - } - - @Override - public Result calculateResult(Expression[] params, ExpressionContext context) { - List classes = findDescendants(context, params); - if (classes == null || classes.size() == 0) return null; - Result[] results = calculateResults(classes); - - return results[0]; - } - - private static Result[] calculateResults(List classes) { - Result[] results = new Result[classes.size()]; - int i = 0; - - for (PsiClass aClass : classes) { - results[i++] = new JavaPsiElementResult(aClass); + @Override + public String getName() { + return "descendantClassesEnum"; } - return results; - } - - @Nullable - private static List findDescendants(ExpressionContext context, Expression[] params) { - if (params == null || params.length == 0) return null; - PsiManager instance = PsiManager.getInstance(context.getProject()); - - Result result = params[0].calculateResult(context); - if (result == null) return null; - - String paramResult = result.toString(); - if (paramResult == null) return null; - - boolean isAllowAbstract = isAllowAbstract(context, params); - PsiClass myBaseClass = - JavaPsiFacade.getInstance(instance.getProject()).findClass(paramResult, GlobalSearchScope.allScope(context.getProject())); - - if (myBaseClass != null) { - List classes = new ArrayList<>(); - - ClassInheritorsSearch.search(myBaseClass, true) - .forEach(new PsiElementProcessorAdapter<>((PsiElementProcessor)element -> { - if (isAllowAbstract || !isAbstractOrInterface(element)) { - classes.add(element); - } - return true; - })); - - return classes; + + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroDescendantClassesEnum(); } - return null; - } + @Override + @RequiredReadAction + public Result calculateResult(Expression[] params, ExpressionContext context) { + List classes = findDescendants(context, params); + if (classes == null || classes.size() == 0) { + return null; + } + Result[] results = calculateResults(classes); - @Override - public Result calculateQuickResult(Expression[] params, ExpressionContext context) { - List classes = findDescendants(context, params); - if (classes == null || classes.size() == 0) return null; - Result[] results = calculateResults(classes); + return results[0]; + } - return results[0]; - } + private static Result[] calculateResults(List classes) { + Result[] results = new Result[classes.size()]; + int i = 0; - @Override - public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { - List classes = findDescendants(context, params); - if (classes == null || classes.size() == 0) return null; + for (PsiClass aClass : classes) { + results[i++] = new JavaPsiElementResult(aClass); + } + return results; + } + + @Nullable + @RequiredReadAction + private static List findDescendants(ExpressionContext context, Expression[] params) { + if (params == null || params.length == 0) { + return null; + } + PsiManager instance = PsiManager.getInstance(context.getProject()); + + Result result = params[0].calculateResult(context); + if (result == null) { + return null; + } + + String paramResult = result.toString(); + if (paramResult == null) { + return null; + } + + boolean isAllowAbstract = isAllowAbstract(context, params); + PsiClass myBaseClass = + JavaPsiFacade.getInstance(instance.getProject()).findClass(paramResult, GlobalSearchScope.allScope(context.getProject())); + + if (myBaseClass != null) { + List classes = new ArrayList<>(); + + ClassInheritorsSearch.search(myBaseClass, true) + .forEach(new PsiElementProcessorAdapter<>((PsiElementProcessor) element -> { + if (isAllowAbstract || !isAbstractOrInterface(element)) { + classes.add(element); + } + return true; + })); + + return classes; + } + + return null; + } - Set set = new LinkedHashSet<>(); - boolean isShortName = params.length > 1 && !Boolean.valueOf(params[1].calculateResult(context).toString()); + @Override + @RequiredReadAction + public Result calculateQuickResult(Expression[] params, ExpressionContext context) { + List classes = findDescendants(context, params); + if (classes == null || classes.size() == 0) { + return null; + } + Result[] results = calculateResults(classes); - for (PsiClass object : classes) { - String name = isShortName ? object.getName() : object.getQualifiedName(); - if (name != null && name.length() > 0) { - set.add(LookupElementBuilder.create(name)); - } + return results[0]; } - return set.toArray(new LookupElement[set.size()]); - } + @Override + @RequiredReadAction + public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { + List classes = findDescendants(context, params); + if (classes == null || classes.size() == 0) { + return null; + } + + Set set = new LinkedHashSet<>(); + boolean isShortName = params.length > 1 && !Boolean.valueOf(params[1].calculateResult(context).toString()); + + for (PsiClass object : classes) { + String name = isShortName ? object.getName() : object.getQualifiedName(); + if (name != null && name.length() > 0) { + set.add(LookupElementBuilder.create(name)); + } + } + + return set.toArray(new LookupElement[set.size()]); + } - private static boolean isAbstractOrInterface(PsiClass psiClass) { - PsiModifierList modifierList = psiClass.getModifierList(); + @RequiredReadAction + private static boolean isAbstractOrInterface(PsiClass psiClass) { + PsiModifierList modifierList = psiClass.getModifierList(); - return psiClass.isInterface() || (modifierList != null && modifierList.hasModifierProperty(PsiModifier.ABSTRACT)); - } + return psiClass.isInterface() || (modifierList != null && modifierList.hasModifierProperty(PsiModifier.ABSTRACT)); + } - private static boolean isAllowAbstract(ExpressionContext context, Expression[] params) { - return params.length > 2 ? Boolean.valueOf(params[2].calculateResult(context).toString()) : true; - } + private static boolean isAllowAbstract(ExpressionContext context, Expression[] params) { + return params.length > 2 ? Boolean.valueOf(params[2].calculateResult(context).toString()) : true; + } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ExpectedTypeMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ExpectedTypeMacro.java index 1d3b467fa..ff95bed69 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ExpectedTypeMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/ExpectedTypeMacro.java @@ -23,6 +23,7 @@ import com.intellij.java.language.psi.PsiExpression; import com.intellij.java.language.psi.PsiIdentifier; import com.intellij.java.language.psi.PsiType; +import consulo.annotation.access.RequiredReadAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.editor.completion.CompletionUtilCore; import consulo.language.editor.completion.lookup.LookupElement; @@ -36,6 +37,7 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.psi.ReparseRangeUtil; +import consulo.localize.LocalizeValue; import consulo.project.Project; import org.jspecify.annotations.Nullable; @@ -44,75 +46,83 @@ @ExtensionImpl public class ExpectedTypeMacro extends Macro { + @Override + public String getName() { + return "expectedType"; + } - @Override - public String getName() { - return "expectedType"; - } - - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroExpectedType().get(); - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroExpectedType(); + } - @Override - public String getDefaultValue() { - return "A"; - } + @Override + public String getDefaultValue() { + return "A"; + } - @Override - public Result calculateResult(Expression[] params, ExpressionContext context) { - PsiType[] types = getExpectedTypes(params, context); - if (types == null || types.length == 0) return null; - return new PsiTypeResult(types[0], context.getProject()); - } + @Override + @RequiredReadAction + public Result calculateResult(Expression[] params, ExpressionContext context) { + PsiType[] types = getExpectedTypes(params, context); + if (types == null || types.length == 0) { + return null; + } + return new PsiTypeResult(types[0], context.getProject()); + } - @Override - public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { - PsiType[] types = getExpectedTypes(params, context); - if (types == null || types.length < 2) return null; - Set set = new LinkedHashSet<>(); - for (PsiType type : types) { - JavaEditorTemplateUtilImpl.addTypeLookupItem(set, type); + @Override + @RequiredReadAction + public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { + PsiType[] types = getExpectedTypes(params, context); + if (types == null || types.length < 2) { + return null; + } + Set set = new LinkedHashSet<>(); + for (PsiType type : types) { + JavaEditorTemplateUtilImpl.addTypeLookupItem(set, type); + } + return set.toArray(new LookupElement[set.size()]); } - return set.toArray(new LookupElement[set.size()]); - } - @Nullable - private static PsiType[] getExpectedTypes(Expression[] params, ExpressionContext context) { - if (params.length != 0) return null; + @Nullable + @RequiredReadAction + private static PsiType[] getExpectedTypes(Expression[] params, ExpressionContext context) { + if (params.length != 0) { + return null; + } + + Project project = context.getProject(); + PsiType[] types = null; - Project project = context.getProject(); - PsiType[] types = null; + PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); + assert file != null; + PsiFile fileCopy = (PsiFile) file.copy(); + ReparseRangeUtil.reparseRange( + fileCopy, + context.getTemplateStartOffset(), + context.getTemplateEndOffset(), + CompletionUtilCore.DUMMY_IDENTIFIER + ); - PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); - assert file != null; - PsiFile fileCopy = (PsiFile)file.copy(); - ReparseRangeUtil.reparseRange( - fileCopy, - context.getTemplateStartOffset(), - context.getTemplateEndOffset(), - CompletionUtilCore.DUMMY_IDENTIFIER - ); - - PsiElement element = fileCopy.findElementAt(context.getTemplateStartOffset()); + PsiElement element = fileCopy.findElementAt(context.getTemplateStartOffset()); - if (element instanceof PsiIdentifier && element.getParent() instanceof PsiExpression parentExpression) { - ExpectedTypeInfo[] infos = ExpectedTypesProvider.getExpectedTypes(parentExpression, true); - if (infos.length > 0) { - types = new PsiType[infos.length]; - for (int i = 0; i < infos.length; i++) { - ExpectedTypeInfo info = infos[i]; - types[i] = info.getType(); + if (element instanceof PsiIdentifier && element.getParent() instanceof PsiExpression parentExpression) { + ExpectedTypeInfo[] infos = ExpectedTypesProvider.getExpectedTypes(parentExpression, true); + if (infos.length > 0) { + types = new PsiType[infos.length]; + for (int i = 0; i < infos.length; i++) { + ExpectedTypeInfo info = infos[i]; + types[i] = info.getType(); + } + } } - } - } - return types; - } + return types; + } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/GroovyScriptMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/GroovyScriptMacro.java index 254570652..0c64f633f 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/GroovyScriptMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/GroovyScriptMacro.java @@ -24,6 +24,7 @@ import consulo.language.editor.template.Result; import consulo.language.editor.template.TextResult; import consulo.language.editor.template.macro.Macro; +import consulo.localize.LocalizeValue; import java.util.LinkedHashSet; import java.util.Set; @@ -33,25 +34,29 @@ */ @ExtensionImpl public class GroovyScriptMacro extends Macro { - @Override - public String getName() { - return "groovyScript"; - } + @Override + public String getName() { + return "groovyScript"; + } - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroGroovyScript().get(); - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroGroovyScript(); + } - @Override - public Result calculateResult(Expression[] params, ExpressionContext context) { - if (params.length == 0) return null; - Object o = runIt(params, context); - if (o != null) return new TextResult(o.toString()); - return null; - } + @Override + public Result calculateResult(Expression[] params, ExpressionContext context) { + if (params.length == 0) { + return null; + } + Object o = runIt(params, context); + if (o != null) { + return new TextResult(o.toString()); + } + return null; + } - private static Object runIt(Expression[] params, ExpressionContext context) { + private static Object runIt(Expression[] params, ExpressionContext context) { /* TODO [VISTALL] groovy depend try { @@ -88,22 +93,22 @@ public String apply(Result result) { } catch (Exception e) { return new TextResult(StringUtil.convertLineSeparators(e.getLocalizedMessage())); } */ - return null; - } + return null; + } - @Override - public Result calculateQuickResult(Expression[] params, ExpressionContext context) { - return calculateResult(params, context); - } + @Override + public Result calculateQuickResult(Expression[] params, ExpressionContext context) { + return calculateResult(params, context); + } - @Override - public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { - Object o = runIt(params, context); - if (o != null) { - Set set = new LinkedHashSet<>(); - set.add(LookupElementBuilder.create(o.toString())); - return set.toArray(new LookupElement[set.size()]); + @Override + public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { + Object o = runIt(params, context); + if (o != null) { + Set set = new LinkedHashSet<>(); + set.add(LookupElementBuilder.create(o.toString())); + return set.toArray(new LookupElement[set.size()]); + } + return LookupElement.EMPTY_ARRAY; } - return LookupElement.EMPTY_ARRAY; - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/GuessElementTypeMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/GuessElementTypeMacro.java index b36d1b7c9..8fde84329 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/GuessElementTypeMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/GuessElementTypeMacro.java @@ -1,4 +1,3 @@ - /* * Copyright 2000-2009 JetBrains s.r.o. * @@ -34,6 +33,7 @@ import consulo.language.editor.template.Result; import consulo.language.editor.template.context.TemplateContextType; import consulo.language.editor.template.macro.Macro; +import consulo.localize.LocalizeValue; import consulo.project.Project; import org.jspecify.annotations.Nullable; @@ -42,69 +42,80 @@ @ExtensionImpl public class GuessElementTypeMacro extends Macro { - @Override - public String getName() { - return "guessElementType"; - } + @Override + public String getName() { + return "guessElementType"; + } - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroGuessElementTypeOfContainer().get(); - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroGuessElementTypeOfContainer(); + } - @Override - public String getDefaultValue() { - return "A"; - } + @Override + public String getDefaultValue() { + return "A"; + } - @Override - @RequiredReadAction - public Result calculateResult(Expression[] params, ExpressionContext context) { - PsiType[] types = guessTypes(params, context); - if (types == null || types.length == 0) return null; - return new PsiTypeResult(types[0], context.getProject()); - } + @Override + @RequiredReadAction + public Result calculateResult(Expression[] params, ExpressionContext context) { + PsiType[] types = guessTypes(params, context); + if (types == null || types.length == 0) { + return null; + } + return new PsiTypeResult(types[0], context.getProject()); + } - @Override - @RequiredReadAction - public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { - PsiType[] types = guessTypes(params, context); - if (types == null || types.length < 2) return null; - Set set = new LinkedHashSet<>(); - for (PsiType type : types) { - JavaEditorTemplateUtilImpl.addTypeLookupItem(set, type); + @Override + @RequiredReadAction + public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { + PsiType[] types = guessTypes(params, context); + if (types == null || types.length < 2) { + return null; + } + Set set = new LinkedHashSet<>(); + for (PsiType type : types) { + JavaEditorTemplateUtilImpl.addTypeLookupItem(set, type); + } + return set.toArray(new LookupElement[set.size()]); } - return set.toArray(new LookupElement[set.size()]); - } - @Nullable - @RequiredReadAction - private static PsiType[] guessTypes(Expression[] params, ExpressionContext context) { - if (params.length != 1) return null; - Result result = params[0].calculateResult(context); - if (result == null) return null; + @Nullable + @RequiredReadAction + private static PsiType[] guessTypes(Expression[] params, ExpressionContext context) { + if (params.length != 1) { + return null; + } + Result result = params[0].calculateResult(context); + if (result == null) { + return null; + } - Project project = context.getProject(); + Project project = context.getProject(); - PsiExpression expr = MacroUtil.resultToPsiExpression(result, context); - if (expr == null) return null; - PsiType[] types = GuessManager.getInstance(project) - .guessContainerElementType(expr, new TextRange(context.getTemplateStartOffset(), context.getTemplateEndOffset())); - for (int i = 0; i < types.length; i++) { - PsiType type = types[i]; - if (type instanceof PsiWildcardType wildcardType) { - if (wildcardType.isExtends()) { - types[i] = wildcardType.getBound(); - } else { - types[i] = PsiType.getJavaLangObject(expr.getManager(), expr.getResolveScope()); + PsiExpression expr = MacroUtil.resultToPsiExpression(result, context); + if (expr == null) { + return null; + } + PsiType[] types = GuessManager.getInstance(project) + .guessContainerElementType(expr, new TextRange(context.getTemplateStartOffset(), context.getTemplateEndOffset())); + for (int i = 0; i < types.length; i++) { + PsiType type = types[i]; + if (type instanceof PsiWildcardType wildcardType) { + if (wildcardType.isExtends()) { + types[i] = wildcardType.getBound(); + } + else { + types[i] = PsiType.getJavaLangObject(expr.getManager(), expr.getResolveScope()); + } + } } - } + return types; } - return types; - } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/IterableComponentTypeMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/IterableComponentTypeMacro.java index 5bd5774e3..bd928f431 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/IterableComponentTypeMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/IterableComponentTypeMacro.java @@ -28,6 +28,7 @@ import consulo.language.editor.template.Result; import consulo.language.editor.template.context.TemplateContextType; import consulo.language.editor.template.macro.Macro; +import consulo.localize.LocalizeValue; import consulo.project.Project; /** @@ -35,77 +36,87 @@ */ @ExtensionImpl public class IterableComponentTypeMacro extends Macro { - @Override - public String getName() { - return "iterableComponentType"; - } + @Override + public String getName() { + return "iterableComponentType"; + } - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroIterableComponentType().get(); - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroIterableComponentType(); + } - @Override - public String getDefaultValue() { - return "a"; - } + @Override + public String getDefaultValue() { + return "a"; + } - @Override - @RequiredReadAction - public Result calculateResult(Expression[] params, ExpressionContext context) { - if (params.length != 1) return null; - Result result = params[0].calculateResult(context); - if (result == null) return null; + @Override + @RequiredReadAction + public Result calculateResult(Expression[] params, ExpressionContext context) { + if (params.length != 1) { + return null; + } + Result result = params[0].calculateResult(context); + if (result == null) { + return null; + } - Project project = context.getProject(); + Project project = context.getProject(); - PsiExpression expr = MacroUtil.resultToPsiExpression(result, context); - if (expr == null) return null; - PsiType type = expr.getType(); + PsiExpression expr = MacroUtil.resultToPsiExpression(result, context); + if (expr == null) { + return null; + } + PsiType type = expr.getType(); - if (type instanceof PsiArrayType arrayType) { - return new PsiTypeResult(arrayType.getComponentType(), project); - } + if (type instanceof PsiArrayType arrayType) { + return new PsiTypeResult(arrayType.getComponentType(), project); + } - if (type instanceof PsiClassType classType) { - PsiClassType.ClassResolveResult resolveResult = classType.resolveGenerics(); - PsiClass aClass = resolveResult.getElement(); + if (type instanceof PsiClassType classType) { + PsiClassType.ClassResolveResult resolveResult = classType.resolveGenerics(); + PsiClass aClass = resolveResult.getElement(); - if (aClass != null) { - PsiClass iterableClass = JavaPsiFacade.getInstance(project).findClass(CommonClassNames.JAVA_LANG_ITERABLE, aClass.getResolveScope()); - if (iterableClass != null) { - PsiSubstitutor substitutor = TypeConversionUtil.getClassSubstitutor(iterableClass, aClass, resolveResult.getSubstitutor()); - if (substitutor != null) { - PsiType parameterType = substitutor.substitute(iterableClass.getTypeParameters()[0]); - if (parameterType instanceof PsiCapturedWildcardType capturedWildcardType) { - parameterType = capturedWildcardType.getWildcard(); - } - if (parameterType != null) { - if (parameterType instanceof PsiWildcardType wildcardType) { - if (wildcardType.isExtends()) { - return new PsiTypeResult(wildcardType.getBound(), project); + if (aClass != null) { + PsiClass iterableClass = + JavaPsiFacade.getInstance(project).findClass(CommonClassNames.JAVA_LANG_ITERABLE, aClass.getResolveScope()); + if (iterableClass != null) { + PsiSubstitutor substitutor = + TypeConversionUtil.getClassSubstitutor(iterableClass, aClass, resolveResult.getSubstitutor()); + if (substitutor != null) { + PsiType parameterType = substitutor.substitute(iterableClass.getTypeParameters()[0]); + if (parameterType instanceof PsiCapturedWildcardType capturedWildcardType) { + parameterType = capturedWildcardType.getWildcard(); + } + if (parameterType != null) { + if (parameterType instanceof PsiWildcardType wildcardType) { + if (wildcardType.isExtends()) { + return new PsiTypeResult(wildcardType.getBound(), project); + } + else { + return null; + } + } + return new PsiTypeResult(parameterType, project); + } + } } - else return null; - } - return new PsiTypeResult(parameterType, project); } - } } - } - } - return null; - } + return null; + } - @Override - @RequiredReadAction - public Result calculateQuickResult(Expression[] params, ExpressionContext context) { - return calculateResult(params, context); - } + @Override + @RequiredReadAction + public Result calculateQuickResult(Expression[] params, ExpressionContext context) { + return calculateResult(params, context); + } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/IterableVariableMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/IterableVariableMacro.java index 29aab051b..c99daf813 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/IterableVariableMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/IterableVariableMacro.java @@ -29,6 +29,7 @@ import consulo.language.psi.scope.GlobalSearchScope; import consulo.language.psi.util.PsiTreeUtil; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; import org.jspecify.annotations.Nullable; @@ -41,60 +42,62 @@ */ @ExtensionImpl public class IterableVariableMacro extends VariableTypeMacroBase { - private static final Logger LOG = Logger.getInstance(IterableVariableMacro.class); + private static final Logger LOG = Logger.getInstance(IterableVariableMacro.class); - @Override - public String getName() { - return "iterableVariable"; - } - - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroIterableVariable().get(); - } + @Override + public String getName() { + return "iterableVariable"; + } - @Override - @Nullable - @RequiredReadAction - protected PsiElement[] getVariables(Expression[] params, ExpressionContext context) { - if (params.length != 0) { - return null; + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroIterableVariable(); } - List result = new ArrayList<>(); + @Override + @Nullable + @RequiredReadAction + protected PsiElement[] getVariables(Expression[] params, ExpressionContext context) { + if (params.length != 0) { + return null; + } + + List result = new ArrayList<>(); - Project project = context.getProject(); - int offset = context.getStartOffset(); - PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); - assert file != null; - PsiElement place = file.findElementAt(offset); - PsiElementFactory elementFactory = JavaPsiFacade.getInstance(project).getElementFactory(); - GlobalSearchScope scope = file.getResolveScope(); + Project project = context.getProject(); + int offset = context.getStartOffset(); + PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); + assert file != null; + PsiElement place = file.findElementAt(offset); + PsiElementFactory elementFactory = JavaPsiFacade.getInstance(project).getElementFactory(); + GlobalSearchScope scope = file.getResolveScope(); - PsiType iterableType = elementFactory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_ITERABLE, scope); - PsiType mapType = elementFactory.createTypeByFQClassName(CommonClassNames.JAVA_UTIL_MAP, scope); + PsiType iterableType = elementFactory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_ITERABLE, scope); + PsiType mapType = elementFactory.createTypeByFQClassName(CommonClassNames.JAVA_UTIL_MAP, scope); - PsiVariable[] variables = MacroUtil.getVariablesVisibleAt(place, ""); - for (PsiVariable var : variables) { - PsiElement parent = var.getParent(); - if (parent instanceof PsiForeachStatement && parent == PsiTreeUtil.getParentOfType(place, PsiForeachStatement.class)) { - continue; - } + PsiVariable[] variables = MacroUtil.getVariablesVisibleAt(place, ""); + for (PsiVariable var : variables) { + PsiElement parent = var.getParent(); + if (parent instanceof PsiForeachStatement && parent == PsiTreeUtil.getParentOfType(place, PsiForeachStatement.class)) { + continue; + } - PsiType type = VariableTypeCalculator.getVarTypeAt(var, place); - if (type instanceof PsiArrayType || iterableType.isAssignableFrom(type)) { - result.add(var); - } else if (mapType.isAssignableFrom(type)) { - try { - result.add(elementFactory.createExpressionFromText(var.getName() + ".keySet()", var.getParent())); - result.add(elementFactory.createExpressionFromText(var.getName() + ".values()", var.getParent())); - result.add(elementFactory.createExpressionFromText(var.getName() + ".entrySet()", var.getParent())); - } catch (IncorrectOperationException e) { - LOG.error(e); + PsiType type = VariableTypeCalculator.getVarTypeAt(var, place); + if (type instanceof PsiArrayType || iterableType.isAssignableFrom(type)) { + result.add(var); + } + else if (mapType.isAssignableFrom(type)) { + try { + result.add(elementFactory.createExpressionFromText(var.getName() + ".keySet()", var.getParent())); + result.add(elementFactory.createExpressionFromText(var.getName() + ".values()", var.getParent())); + result.add(elementFactory.createExpressionFromText(var.getName() + ".entrySet()", var.getParent())); + } + catch (IncorrectOperationException e) { + LOG.error(e); + } + } } - } + return PsiUtilCore.toPsiElementArray(result); } - return PsiUtilCore.toPsiElementArray(result); - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/MethodNameMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/MethodNameMacro.java index 7fe756962..8bbd4843a 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/MethodNameMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/MethodNameMacro.java @@ -28,44 +28,46 @@ import consulo.language.editor.template.TextResult; import consulo.language.editor.template.context.TemplateContextType; import consulo.language.editor.template.macro.Macro; +import consulo.language.localize.LanguageLocalize; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; @ExtensionImpl public class MethodNameMacro extends Macro { + @Override + public String getName() { + return "methodName"; + } - @Override - public String getName() { - return "methodName"; - } - - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroMethodname().get(); - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroMethodname(); + } - @Override - public String getDefaultValue() { - return "a"; - } + @Override + public String getDefaultValue() { + return "a"; + } - @Override - public Result calculateResult(Expression[] params, ExpressionContext context) { - PsiElement place = context.getPsiElementAtStartOffset(); - while (place != null){ - if (place instanceof PsiMethod){ - return new TextResult(((PsiMethod)place).getName()); - } else if (place instanceof PsiClassInitializer classInitializer) { - return classInitializer.hasModifierProperty(PsiModifier.STATIC) - ? new TextResult(LangBundle.message("java.terms.static.initializer")) - : new TextResult(LangBundle.message("java.terms.instance.initializer")); - } - place = place.getParent(); + @Override + public Result calculateResult(Expression[] params, ExpressionContext context) { + PsiElement place = context.getPsiElementAtStartOffset(); + while (place != null) { + if (place instanceof PsiMethod method) { + return new TextResult(method.getName()); + } + else if (place instanceof PsiClassInitializer classInitializer) { + return classInitializer.isStatic() + ? new TextResult(LanguageLocalize.javaTermsStaticInitializer().get()) + : new TextResult(LanguageLocalize.javaTermsInstanceInitializer().get()); + } + place = place.getParent(); + } + return null; } - return null; - } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/MethodParametersMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/MethodParametersMacro.java index e3a021b66..17375e11f 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/MethodParametersMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/MethodParametersMacro.java @@ -24,46 +24,46 @@ import consulo.language.editor.template.context.TemplateContextType; import consulo.language.editor.template.macro.Macro; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; import java.util.ArrayList; import java.util.List; @ExtensionImpl public class MethodParametersMacro extends Macro { + @Override + public String getName() { + return "methodParameters"; + } - @Override - public String getName() { - return "methodParameters"; - } - - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroMethodParameters().get(); - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroMethodParameters(); + } - @Override - public String getDefaultValue() { - return "a"; - } + @Override + public String getDefaultValue() { + return "a"; + } - @Override - public Result calculateResult(Expression[] params, ExpressionContext context) { - PsiElement place = context.getPsiElementAtStartOffset(); - while (place != null){ - if (place instanceof PsiMethod method) { - List result = new ArrayList<>(); - for (PsiParameter parameter : method.getParameterList().getParameters()) { - result.add(new TextResult(parameter.getName())); + @Override + public Result calculateResult(Expression[] params, ExpressionContext context) { + PsiElement place = context.getPsiElementAtStartOffset(); + while (place != null) { + if (place instanceof PsiMethod method) { + List result = new ArrayList<>(); + for (PsiParameter parameter : method.getParameterList().getParameters()) { + result.add(new TextResult(parameter.getName())); + } + return new ListResult(result); + } + place = place.getParent(); } - return new ListResult(result); - } - place = place.getParent(); + return null; } - return null; - } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/MethodReturnTypeMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/MethodReturnTypeMacro.java index 308c28a38..fc0a94ae7 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/MethodReturnTypeMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/MethodReturnTypeMacro.java @@ -25,44 +25,42 @@ import consulo.language.editor.template.context.TemplateContextType; import consulo.language.editor.template.macro.Macro; import consulo.language.psi.PsiElement; - +import consulo.localize.LocalizeValue; /** * @author yole */ @ExtensionImpl public class MethodReturnTypeMacro extends Macro { - @Override - public String getName() { - return "methodReturnType"; - } - - @Override - public String getPresentableName() { - return "methodReturnType()"; - } - - @Override - public String getDefaultValue() { - return "a"; - } + @Override + public String getName() { + return "methodReturnType"; + } - @Override - public Result calculateResult(Expression[] params, ExpressionContext context) { - PsiElement place = context.getPsiElementAtStartOffset(); - while(place != null){ - if (place instanceof PsiMethod){ - return new PsiTypeResult(((PsiMethod)place).getReturnType(), place.getProject()); - } - place = place.getParent(); + @Override + public LocalizeValue getPresentableName() { + return LocalizeValue.localizeTODO("methodReturnType()"); } - return null; - } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public String getDefaultValue() { + return "a"; + } + @Override + public Result calculateResult(Expression[] params, ExpressionContext context) { + PsiElement place = context.getPsiElementAtStartOffset(); + while (place != null) { + if (place instanceof PsiMethod method) { + return new PsiTypeResult(method.getReturnType(), place.getProject()); + } + place = place.getParent(); + } + return null; + } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/QualifiedClassNameMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/QualifiedClassNameMacro.java index e530881ea..c74ce1293 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/QualifiedClassNameMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/QualifiedClassNameMacro.java @@ -28,35 +28,35 @@ import consulo.language.editor.template.context.TemplateContextType; import consulo.language.editor.template.macro.Macro; import consulo.language.psi.PsiElement; +import consulo.localize.LocalizeValue; @ExtensionImpl public class QualifiedClassNameMacro extends Macro { + @Override + public String getName() { + return "qualifiedClassName"; + } - @Override - public String getName() { - return "qualifiedClassName"; - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroQualifiedClassName(); + } - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroQualifiedClassName().get(); - } + @Override + public Result calculateResult(Expression[] params, ExpressionContext context) { + PsiElement place = context.getPsiElementAtStartOffset(); + while (place != null) { + if (place instanceof PsiClass psiClass && !(place instanceof PsiAnonymousClass) && !(place instanceof PsiTypeParameter)) { + return new TextResult(psiClass.getQualifiedName()); + } + place = place.getParent(); + } - @Override - public Result calculateResult(Expression[] params, ExpressionContext context) { - PsiElement place = context.getPsiElementAtStartOffset(); - while (place != null){ - if (place instanceof PsiClass psiClass && !(place instanceof PsiAnonymousClass) && !(place instanceof PsiTypeParameter)){ - return new TextResult(psiClass.getQualifiedName()); - } - place = place.getParent(); + return null; } - return null; - } - - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/RightSideTypeMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/RightSideTypeMacro.java index 974455436..5f0794082 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/RightSideTypeMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/RightSideTypeMacro.java @@ -22,6 +22,7 @@ import com.intellij.java.language.psi.PsiExpression; import com.intellij.java.language.psi.PsiType; import com.intellij.java.language.psi.PsiVariable; +import consulo.annotation.access.RequiredReadAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.editor.localize.CodeInsightLocalize; import consulo.language.editor.template.Expression; @@ -33,50 +34,59 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import consulo.project.Project; - - /** * @author ven */ @ExtensionImpl public class RightSideTypeMacro extends Macro { - @Override - public String getName() { - return "rightSideType"; - } + @Override + public String getName() { + return "rightSideType"; + } - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroRightSideType().get(); - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroRightSideType(); + } - @Override - public Result calculateResult(Expression[] params, ExpressionContext context) { - int offset = context.getStartOffset(); - Project project = context.getProject(); - PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); - PsiElement element = file.findElementAt(offset); - element = PsiTreeUtil.getParentOfType(element, PsiAssignmentExpression.class, PsiVariable.class); - if (element instanceof PsiAssignmentExpression assignment) { - PsiExpression rhs = assignment.getRExpression(); - if (rhs == null) return null; - PsiType rhsType = rhs.getType(); - if (rhsType == null) return null; - return new PsiTypeResult(rhsType, project); - } else if (element instanceof PsiVariable var) { - PsiExpression initializer = var.getInitializer(); - if (initializer == null) return null; - PsiType type = RefactoringUtil.getTypeByExpression(initializer); - if (type == null) return null; - return new PsiTypeResult(type, project); + @Override + @RequiredReadAction + public Result calculateResult(Expression[] params, ExpressionContext context) { + int offset = context.getStartOffset(); + Project project = context.getProject(); + PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); + PsiElement element = file.findElementAt(offset); + element = PsiTreeUtil.getParentOfType(element, PsiAssignmentExpression.class, PsiVariable.class); + if (element instanceof PsiAssignmentExpression assignment) { + PsiExpression rhs = assignment.getRExpression(); + if (rhs == null) { + return null; + } + PsiType rhsType = rhs.getType(); + if (rhsType == null) { + return null; + } + return new PsiTypeResult(rhsType, project); + } + else if (element instanceof PsiVariable var) { + PsiExpression initializer = var.getInitializer(); + if (initializer == null) { + return null; + } + PsiType type = RefactoringUtil.getTypeByExpression(initializer); + if (type == null) { + return null; + } + return new PsiTypeResult(type, project); + } + return null; } - return null; - } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SubtypesMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SubtypesMacro.java index bd2c166ad..15274330e 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SubtypesMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SubtypesMacro.java @@ -20,6 +20,7 @@ import com.intellij.java.impl.codeInsight.template.JavaEditorTemplateUtilImpl; import com.intellij.java.language.impl.codeInsight.template.macro.PsiTypeResult; import com.intellij.java.language.psi.PsiType; +import consulo.annotation.access.RequiredReadAction; import consulo.annotation.component.ExtensionImpl; import consulo.application.util.matcher.PrefixMatcher; import consulo.language.editor.completion.lookup.LookupElement; @@ -31,64 +32,69 @@ import consulo.language.psi.PsiDocumentManager; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; +import consulo.localize.LocalizeValue; import java.util.LinkedHashSet; import java.util.Set; -import java.util.function.Consumer; @ExtensionImpl public class SubtypesMacro extends Macro { - @Override - public String getName() { - return "subtypes"; - } + @Override + public String getName() { + return "subtypes"; + } - @Override - public String getPresentableName() { - return "subtypes(TYPE)"; - } + @Override + public LocalizeValue getPresentableName() { + return LocalizeValue.of("subtypes(TYPE)"); + } - @Override - public String getDefaultValue() { - return "A"; - } + @Override + public String getDefaultValue() { + return "A"; + } - @Override - public Result calculateResult(Expression[] params, ExpressionContext context) { - if (params.length == 0) return null; - return params[0].calculateQuickResult(context); - } + @Override + public Result calculateResult(Expression[] params, ExpressionContext context) { + if (params.length == 0) { + return null; + } + return params[0].calculateQuickResult(context); + } - @Override - public Result calculateQuickResult(Expression[] params, ExpressionContext context) { - return calculateResult(params, context); - } + @Override + public Result calculateQuickResult(Expression[] params, ExpressionContext context) { + return calculateResult(params, context); + } - @Override - public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { - if (params.length == 0) return LookupElement.EMPTY_ARRAY; - Result paramResult = params[0].calculateQuickResult(context); - if (paramResult instanceof PsiTypeResult) { - PsiType type = ((PsiTypeResult)paramResult).getType(); - PsiFile file = PsiDocumentManager.getInstance(context.getProject()).getPsiFile(context.getEditor().getDocument()); - PsiElement element = file.findElementAt(context.getStartOffset()); + @Override + @RequiredReadAction + public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { + if (params.length == 0) { + return LookupElement.EMPTY_ARRAY; + } + Result paramResult = params[0].calculateQuickResult(context); + if (paramResult instanceof PsiTypeResult typeResult) { + PsiType type = typeResult.getType(); + PsiFile file = PsiDocumentManager.getInstance(context.getProject()).getPsiFile(context.getEditor().getDocument()); + PsiElement element = file.findElementAt(context.getStartOffset()); - final Set set = new LinkedHashSet(); - JavaEditorTemplateUtilImpl.addTypeLookupItem(set, type); - CodeInsightUtil.processSubTypes(type, element, false, PrefixMatcher.ALWAYS_TRUE, new Consumer() { - @Override - public void accept(PsiType psiType) { - JavaEditorTemplateUtilImpl.addTypeLookupItem(set, psiType); + Set set = new LinkedHashSet<>(); + JavaEditorTemplateUtilImpl.addTypeLookupItem(set, type); + CodeInsightUtil.processSubTypes( + type, + element, + false, + PrefixMatcher.ALWAYS_TRUE, + psiType -> JavaEditorTemplateUtilImpl.addTypeLookupItem(set, psiType) + ); + return set.toArray(new LookupElement[set.size()]); } - }); - return set.toArray(new LookupElement[set.size()]); + return LookupElement.EMPTY_ARRAY; } - return LookupElement.EMPTY_ARRAY; - } - - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SuggestFirstVariableNameMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SuggestFirstVariableNameMacro.java index 70d3e8fbc..4a32e7058 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SuggestFirstVariableNameMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SuggestFirstVariableNameMacro.java @@ -22,6 +22,7 @@ import consulo.language.editor.template.ExpressionContext; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiUtilCore; +import consulo.localize.LocalizeValue; import java.util.ArrayList; import java.util.Arrays; @@ -32,30 +33,32 @@ */ @ExtensionImpl public class SuggestFirstVariableNameMacro extends VariableOfTypeMacro { - @Override - public String getName() { - return "suggestFirstVariableName"; - } + @Override + public String getName() { + return "suggestFirstVariableName"; + } - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroSuggestFirstVariableName().get(); - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroSuggestFirstVariableName(); + } - @Override - @RequiredReadAction - protected PsiElement[] getVariables(Expression[] params, ExpressionContext context) { - PsiElement[] variables = super.getVariables(params, context); - if (variables == null) return null; - List result = new ArrayList<>(); - List skip = Arrays.asList("true", "false", "this", "super"); - for (PsiElement variable : variables) { - if (!skip.contains(variable.getText())) { - result.add(variable); - } + @Override + @RequiredReadAction + protected PsiElement[] getVariables(Expression[] params, ExpressionContext context) { + PsiElement[] variables = super.getVariables(params, context); + if (variables == null) { + return null; + } + List result = new ArrayList<>(); + List skip = Arrays.asList("true", "false", "this", "super"); + for (PsiElement variable : variables) { + if (!skip.contains(variable.getText())) { + result.add(variable); + } + } + return PsiUtilCore.toPsiElementArray(result); } - return PsiUtilCore.toPsiElementArray(result); - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SuggestIndexNameMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SuggestIndexNameMacro.java index 74660b658..2cece4e3a 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SuggestIndexNameMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SuggestIndexNameMacro.java @@ -34,63 +34,65 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import consulo.project.Project; @ExtensionImpl public class SuggestIndexNameMacro extends Macro { - @Override - public String getName() { - return "suggestIndexName"; - } + @Override + public String getName() { + return "suggestIndexName"; + } - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroSuggestIndexName().get(); - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroSuggestIndexName(); + } - @Override - public String getDefaultValue() { - return "a"; - } + @Override + public String getDefaultValue() { + return "a"; + } - @Override - @RequiredReadAction - public Result calculateResult(Expression[] params, ExpressionContext context) { - if (params.length != 0) return null; + @Override + @RequiredReadAction + public Result calculateResult(Expression[] params, ExpressionContext context) { + if (params.length != 0) { + return null; + } - Project project = context.getProject(); - int offset = context.getStartOffset(); + Project project = context.getProject(); + int offset = context.getStartOffset(); - PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); - PsiElement place = file.findElementAt(offset); - PsiVariable[] vars = MacroUtil.getVariablesVisibleAt(place, ""); - ChooseLetterLoop: - for (char letter = 'i'; letter <= 'z'; letter++){ - for (PsiVariable var : vars) { - PsiIdentifier identifier = var.getNameIdentifier(); - if (identifier == null || place.equals(identifier)) continue; - if (var instanceof PsiLocalVariable) { - PsiElement parent = var.getParent(); - if (parent instanceof PsiDeclarationStatement) { - if (PsiTreeUtil.isAncestor(parent, place, false) && - var.getTextRange().getStartOffset() > place.getTextRange().getStartOffset()) { - continue; + PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); + PsiElement place = file.findElementAt(offset); + PsiVariable[] vars = MacroUtil.getVariablesVisibleAt(place, ""); + ChooseLetterLoop: + for (char letter = 'i'; letter <= 'z'; letter++) { + for (PsiVariable var : vars) { + PsiIdentifier identifier = var.getNameIdentifier(); + if (identifier == null || place.equals(identifier)) { + continue; + } + if (var instanceof PsiLocalVariable + && var.getParent() instanceof PsiDeclarationStatement decl + && PsiTreeUtil.isAncestor(decl, place, false) + && var.getTextRange().getStartOffset() > place.getTextRange().getStartOffset()) { + continue; + } + String name = identifier.getText(); + if (name.length() == 1 && name.charAt(0) == letter) { + continue ChooseLetterLoop; + } } - } + return new TextResult("" + letter); } - String name = identifier.getText(); - if (name.length() == 1 && name.charAt(0) == letter) { - continue ChooseLetterLoop; - } - } - return new TextResult("" + letter); - } - return null; - } + return null; + } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SuggestVariableNameMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SuggestVariableNameMacro.java index 3e0ac326a..4d4c9de09 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SuggestVariableNameMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/SuggestVariableNameMacro.java @@ -33,6 +33,7 @@ import consulo.language.psi.PsiDocumentManager; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; +import consulo.localize.LocalizeValue; import consulo.util.collection.ArrayUtil; import org.jspecify.annotations.Nullable; @@ -41,77 +42,89 @@ @ExtensionImpl public class SuggestVariableNameMacro extends Macro { + @Override + public String getName() { + return "suggestVariableName"; + } - @Override - public String getName() { - return "suggestVariableName"; - } - - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroSuggestVariableName().get(); - } - - @Override - public String getDefaultValue() { - return "a"; - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroSuggestVariableName(); + } - @Override - public Result calculateResult(Expression[] params, ExpressionContext context) { - String[] names = getNames(context); - if (names == null || names.length == 0) return null; - return new TextResult(names[0]); - } + @Override + public String getDefaultValue() { + return "a"; + } - @Nullable - @Override - public Result calculateQuickResult(Expression[] params, ExpressionContext context) { - return calculateResult(params, context); - } + @Override + @RequiredReadAction + public Result calculateResult(Expression[] params, ExpressionContext context) { + String[] names = getNames(context); + if (names == null || names.length == 0) { + return null; + } + return new TextResult(names[0]); + } - @Override - public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { - String[] names = getNames(context); - if (names == null || names.length < 2) return null; - LookupItem[] items = new LookupItem[names.length]; - for (int i = 0; i < names.length; i++) { - String name = names[i]; - items[i] = LookupItem.fromString(name); + @Nullable + @Override + @RequiredReadAction + public Result calculateQuickResult(Expression[] params, ExpressionContext context) { + return calculateResult(params, context); } - return items; - } - @RequiredReadAction - private static String[] getNames (ExpressionContext context) { - String[] names = ExpressionUtil.getNames(context); - if (names == null || names.length == 0) return names; - PsiFile file = PsiDocumentManager.getInstance(context.getProject()).getPsiFile(context.getEditor().getDocument()); - PsiElement e = file.findElementAt(context.getStartOffset()); - PsiVariable[] vars = MacroUtil.getVariablesVisibleAt(e, ""); - LinkedList namesList = new LinkedList<>(Arrays.asList(names)); - for (PsiVariable var : vars) { - if (e.equals(var.getNameIdentifier())) continue; - namesList.remove(var.getName()); + @Override + @RequiredReadAction + public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { + String[] names = getNames(context); + if (names == null || names.length < 2) { + return null; + } + LookupItem[] items = new LookupItem[names.length]; + for (int i = 0; i < names.length; i++) { + String name = names[i]; + items[i] = LookupItem.fromString(name); + } + return items; } - if (namesList.isEmpty()) { - String name = names[0]; - index: - for (int j = 1; ; j++) { - String name1 = name + j; + @RequiredReadAction + private static String[] getNames(ExpressionContext context) { + String[] names = ExpressionUtil.getNames(context); + if (names == null || names.length == 0) { + return names; + } + PsiFile file = PsiDocumentManager.getInstance(context.getProject()).getPsiFile(context.getEditor().getDocument()); + PsiElement e = file.findElementAt(context.getStartOffset()); + PsiVariable[] vars = MacroUtil.getVariablesVisibleAt(e, ""); + LinkedList namesList = new LinkedList<>(Arrays.asList(names)); for (PsiVariable var : vars) { - if (name1.equals(var.getName()) && !var.getNameIdentifier().equals(e)) continue index; + if (e.equals(var.getNameIdentifier())) { + continue; + } + namesList.remove(var.getName()); } - return new String[]{name1}; - } - } - return ArrayUtil.toStringArray(namesList); - } + if (namesList.isEmpty()) { + String name = names[0]; + index: + for (int j = 1; ; j++) { + String name1 = name + j; + for (PsiVariable var : vars) { + if (name1.equals(var.getName()) && !var.getNameIdentifier().equals(e)) { + continue index; + } + } + return new String[]{name1}; + } + } - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + return ArrayUtil.toStringArray(namesList); + } + + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/TypeOfVariableMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/TypeOfVariableMacro.java index 0a3396833..44691b585 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/TypeOfVariableMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/TypeOfVariableMacro.java @@ -19,6 +19,7 @@ import com.intellij.java.language.impl.codeInsight.template.macro.PsiTypeResult; import com.intellij.java.language.impl.codeInsight.template.macro.MacroUtil; import com.intellij.java.language.psi.PsiVariable; +import consulo.annotation.access.RequiredReadAction; import consulo.annotation.component.ExtensionImpl; import consulo.language.editor.template.*; import consulo.language.editor.template.context.TemplateContextType; @@ -26,57 +27,62 @@ import consulo.language.psi.PsiDocumentManager; import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; +import consulo.localize.LocalizeValue; import consulo.project.Project; - @ExtensionImpl public class TypeOfVariableMacro extends Macro { - @Override - public String getName() { - return "typeOfVariable"; - } + @Override + public String getName() { + return "typeOfVariable"; + } - @Override - public String getPresentableName() { - return "typeOfVariable(VAR)"; - } + @Override + public LocalizeValue getPresentableName() { + return LocalizeValue.of("typeOfVariable(VAR)"); + } - @Override - public String getDefaultValue() { - return "A"; - } + @Override + public String getDefaultValue() { + return "A"; + } - @Override - public Result calculateResult(Expression[] params, ExpressionContext context) { - if (params.length == 0) return null; + @Override + @RequiredReadAction + public Result calculateResult(Expression[] params, ExpressionContext context) { + if (params.length == 0) { + return null; + } - Project project = context.getProject(); - Result result = params[0].calculateQuickResult(context); - if (result instanceof PsiElementResult) { - PsiElement element = ((PsiElementResult)result).getElement(); - if (element instanceof PsiVariable) { - return new PsiTypeResult(((PsiVariable)element).getType(), project); - } - } else if (result instanceof TextResult) { - PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); - PsiElement place = file.findElementAt(context.getStartOffset()); - PsiVariable[] vars = MacroUtil.getVariablesVisibleAt(place, ""); - String name = result.toString(); - for (PsiVariable var : vars) { - if (name.equals(var.getName())) return new PsiTypeResult(var.getType(), project); - } + Project project = context.getProject(); + Result result = params[0].calculateQuickResult(context); + if (result instanceof PsiElementResult elementResult) { + if (elementResult.getElement() instanceof PsiVariable variable) { + return new PsiTypeResult(variable.getType(), project); + } + } + else if (result instanceof TextResult) { + PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); + PsiElement place = file.findElementAt(context.getStartOffset()); + PsiVariable[] vars = MacroUtil.getVariablesVisibleAt(place, ""); + String name = result.toString(); + for (PsiVariable var : vars) { + if (name.equals(var.getName())) { + return new PsiTypeResult(var.getType(), project); + } + } + } + return null; } - return null; - } - @Override - public Result calculateQuickResult(Expression[] params, ExpressionContext context) { - return calculateResult(params, context); - } - - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + @RequiredReadAction + public Result calculateQuickResult(Expression[] params, ExpressionContext context) { + return calculateResult(params, context); + } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/VariableOfTypeMacro.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/VariableOfTypeMacro.java index 731b8c2cd..474e6d6dd 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/VariableOfTypeMacro.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/template/macro/VariableOfTypeMacro.java @@ -20,9 +20,9 @@ import com.intellij.java.impl.codeInsight.template.JavaPsiElementResult; import com.intellij.java.language.impl.codeInsight.template.macro.MacroUtil; import com.intellij.java.language.psi.*; +import consulo.annotation.access.RequiredReadAction; import consulo.annotation.component.ExtensionImpl; import consulo.document.util.TextRange; -import consulo.language.editor.CodeInsightBundle; import consulo.language.editor.completion.lookup.LookupElement; import consulo.language.editor.localize.CodeInsightLocalize; import consulo.language.editor.template.Expression; @@ -32,94 +32,107 @@ import consulo.language.editor.template.macro.Macro; import consulo.language.psi.*; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.util.collection.ContainerUtil; - import org.jspecify.annotations.Nullable; import java.util.ArrayList; import java.util.LinkedHashSet; +import java.util.List; import java.util.Set; @ExtensionImpl public class VariableOfTypeMacro extends Macro { + @Override + public String getName() { + return "variableOfType"; + } - @Override - public String getName() { - return "variableOfType"; - } - - @Override - public String getPresentableName() { - return CodeInsightLocalize.macroVariableOfType().get(); - } - - @Override - public String getDefaultValue() { - return "a"; - } - - @Override - public Result calculateResult(Expression[] params, ExpressionContext context) { - PsiElement[] vars = getVariables(params, context); - if (vars == null || vars.length == 0) return null; - return new JavaPsiElementResult(vars[0]); - } + @Override + public LocalizeValue getPresentableName() { + return CodeInsightLocalize.macroVariableOfType(); + } - @Override - public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { - PsiElement[] vars = getVariables(params, context); - if (vars == null || vars.length < 2) return null; - Set set = new LinkedHashSet<>(); - for (PsiElement var : vars) { - JavaEditorTemplateUtilImpl.addElementLookupItem(set, var); + @Override + public String getDefaultValue() { + return "a"; } - return set.toArray(new LookupElement[set.size()]); - } - @Nullable - protected PsiElement[] getVariables(Expression[] params, ExpressionContext context) { - if (params.length != 1) return null; - Result result = params[0].calculateResult(context); - if (result == null) return null; + @Override + @RequiredReadAction + public Result calculateResult(Expression[] params, ExpressionContext context) { + PsiElement[] vars = getVariables(params, context); + if (vars == null || vars.length == 0) { + return null; + } + return new JavaPsiElementResult(vars[0]); + } - Project project = context.getProject(); - int offset = context.getStartOffset(); + @Override + @RequiredReadAction + public LookupElement[] calculateLookupItems(Expression[] params, ExpressionContext context) { + PsiElement[] vars = getVariables(params, context); + if (vars == null || vars.length < 2) { + return null; + } + Set set = new LinkedHashSet<>(); + for (PsiElement var : vars) { + JavaEditorTemplateUtilImpl.addElementLookupItem(set, var); + } + return set.toArray(new LookupElement[set.size()]); + } - ArrayList array = new ArrayList(); - PsiType type = MacroUtil.resultToPsiType(result, context); - PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); - PsiElement place = file.findElementAt(offset); + @Nullable + @RequiredReadAction + protected PsiElement[] getVariables(Expression[] params, ExpressionContext context) { + if (params.length != 1) { + return null; + } + Result result = params[0].calculateResult(context); + if (result == null) { + return null; + } - PsiVariable[] variables = MacroUtil.getVariablesVisibleAt(place, ""); - PsiManager manager = PsiManager.getInstance(project); - for (PsiVariable var : variables) { - if (var instanceof PsiField field && var.hasModifierProperty(PsiModifier.STATIC)) { - PsiClass varClass = field.getContainingClass(); - PsiClass placeClass = PsiTreeUtil.getParentOfType(place, PsiClass.class); - if (!manager.areElementsEquivalent(varClass, placeClass)) continue; - } - else if (var instanceof PsiLocalVariable) { - TextRange range = var.getNameIdentifier().getTextRange(); - if (range != null && range.contains(offset)) { - continue; + Project project = context.getProject(); + int offset = context.getStartOffset(); + + List array = new ArrayList<>(); + PsiType type = MacroUtil.resultToPsiType(result, context); + PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(context.getEditor().getDocument()); + PsiElement place = file.findElementAt(offset); + + PsiVariable[] variables = MacroUtil.getVariablesVisibleAt(place, ""); + PsiManager manager = PsiManager.getInstance(project); + for (PsiVariable var : variables) { + if (var instanceof PsiField field && var.hasModifierProperty(PsiModifier.STATIC)) { + PsiClass varClass = field.getContainingClass(); + PsiClass placeClass = PsiTreeUtil.getParentOfType(place, PsiClass.class); + if (!manager.areElementsEquivalent(varClass, placeClass)) { + continue; + } + } + else if (var instanceof PsiLocalVariable) { + TextRange range = var.getNameIdentifier().getTextRange(); + if (range != null && range.contains(offset)) { + continue; + } + } + + PsiType type1 = VariableTypeCalculator.getVarTypeAt(var, place); + if (type == null || type.isAssignableFrom(type1)) { + array.add(var); + } } - } - PsiType type1 = VariableTypeCalculator.getVarTypeAt(var, place); - if (type == null || type.isAssignableFrom(type1)) { - array.add(var); - } + PsiExpression[] expressions = MacroUtil.getStandardExpressionsOfType(place, type); + ContainerUtil.addAll(array, expressions); + return PsiUtilCore.toPsiElementArray(array); } - PsiExpression[] expressions = MacroUtil.getStandardExpressionsOfType(place, type); - ContainerUtil.addAll(array, expressions); - return PsiUtilCore.toPsiElementArray(array); - } - - @Override - public boolean isAcceptableInContext(TemplateContextType context) { - return context instanceof JavaCodeContextType; - } + @Override + public boolean isAcceptableInContext(TemplateContextType context) { + return context instanceof JavaCodeContextType; + } }