MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

argument highlighting for index-property access

Browse Source 
GrIndexProperty is GrCallExpression
remove duplicating methods from GrConstructorCall
This commit is contained in:
Maxim.Medvedev
2012-04-04 16:07:19 +04:00
parent 1618027e48
commit 55f60ecd0b
26 changed files with 413 additions and 318 deletions
Download Patch File Download Diff File Expand all files Collapse all files
plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/GroovyAnnotator.java
+2 -2
View File
@@ -878,9 +878,9 @@ public class GroovyAnnotator extends GroovyElementVisitor implements Annotator {
@Override
public void visitConstructorInvocation(GrConstructorInvocation invocation) {
final GroovyResolveResult resolveResult = invocation.resolveConstructorGenerics();
final GroovyResolveResult resolveResult = invocation.advancedResolve();
if (resolveResult.getElement() == null) {
final GroovyResolveResult[] results = invocation.multiResolveConstructor();
final GroovyResolveResult[] results = invocation.multiResolve(false);
final GrArgumentList argList = invocation.getArgumentList();
if (results.length > 0) {
String message = GroovyBundle.message("ambiguous.constructor.call");
plugins/groovy/src/org/jetbrains/plugins/groovy/codeInspection/assignment/GroovyAssignabilityCheckInspection.java
+18 -15
View File
@@ -259,8 +259,8 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection {
private void checkConstructorCall(GrConstructorCall constructorCall, GroovyPsiElement refElement) {
final GrArgumentList argList = constructorCall.getArgumentList();
if (checkCannotInferArgumentTypes(refElement)) return;
final GroovyResolveResult constructorResolveResult = constructorCall.resolveConstructorGenerics();
if (!checkCannotInferArgumentTypes(refElement)) return;
final GroovyResolveResult constructorResolveResult = constructorCall.advancedResolve();
final PsiElement constructor = constructorResolveResult.getElement();
if (constructor != null) {
@@ -268,7 +268,7 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection {
if (!checkUnknownParams(refElement)) return;
}
else {
final GroovyResolveResult[] results = constructorCall.multiResolveConstructor();
final GroovyResolveResult[] results = constructorCall.multiResolve(false);
if (results.length > 0) {
for (GroovyResolveResult result : results) {
PsiElement resolved = result.getElement();
@@ -404,27 +404,30 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection {
@Override
public void visitReferenceExpression(GrReferenceExpression referenceExpression) {
super.visitReferenceExpression(referenceExpression);
GroovyResolveResult resolveResult = referenceExpression.advancedResolve();
GroovyResolveResult[] results = referenceExpression.multiResolve(false); //cached
PsiElement resolved = resolveResult.getElement();
final PsiElement parent = referenceExpression.getParent();
if (resolved == null) {
GrExpression qualifier = referenceExpression.getQualifierExpression();
if (qualifier == null && GroovyAnnotator.isDeclarationAssignment(referenceExpression)) return;
}
if (parent instanceof GrCall) {
if (checkCannotInferArgumentTypes(referenceExpression)) return;
GrCall call = (GrCall)parent;
GroovyResolveResult resolveResult = call.advancedResolve();
GroovyResolveResult[] results = call.multiResolve(false); //cached
PsiElement resolved = resolveResult.getElement();
if (resolved == null) {
GrExpression qualifier = referenceExpression.getQualifierExpression();
if (qualifier == null && GroovyAnnotator.isDeclarationAssignment(referenceExpression)) return;
}
if (!checkCannotInferArgumentTypes(referenceExpression)) return;
final PsiType type = referenceExpression.getType();
if (resolved != null ) {
if (resolved != null) {
if (resolved instanceof PsiMethod && !resolveResult.isInvokedOnProperty()) {
if (!checkMethodApplicability(resolveResult, referenceExpression)) return;
}
else {
if (!checkCallApplicability(type, referenceExpression)) return;
}
if (!checkUnknownParams(referenceExpression)) return;
}
else if (results.length > 0) {
@@ -460,11 +463,11 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection {
}
private boolean checkCannotInferArgumentTypes(PsiElement referenceExpression) {
if (PsiUtil.getArgumentTypes(referenceExpression, true) != null) return false;
if (PsiUtil.getArgumentTypes(referenceExpression, true) != null) return true;
registerError(getElementToHighlight(referenceExpression, PsiUtil.getArgumentsList(referenceExpression)),
GroovyBundle.message("cannot.infer.argument.types"), LocalQuickFix.EMPTY_ARRAY, ProblemHighlightType.WEAK_WARNING);
return true;
return false;
}
@Override
plugins/groovy/src/org/jetbrains/plugins/groovy/codeInspection/bugs/GroovyConstructorNamedArgumentsInspection.java
+2 -2
View File
@@ -83,7 +83,7 @@ public class GroovyConstructorNamedArgumentsInspection extends BaseInspection {
GrCodeReferenceElement refElement = newExpression.getReferenceElement();
if (refElement == null) return;
final GroovyResolveResult constructorResolveResult = newExpression.resolveConstructorGenerics();
final GroovyResolveResult constructorResolveResult = newExpression.advancedResolve();
final PsiElement constructor = constructorResolveResult.getElement();
if (constructor != null) {
final GrArgumentList argList = newExpression.getArgumentList();
@@ -94,7 +94,7 @@ public class GroovyConstructorNamedArgumentsInspection extends BaseInspection {
}
}
else {
final GroovyResolveResult[] results = newExpression.multiResolveConstructor();
final GroovyResolveResult[] results = newExpression.multiResolve(false);
final GrArgumentList argList = newExpression.getArgumentList();
final PsiElement element = refElement.resolve();
plugins/groovy/src/org/jetbrains/plugins/groovy/codeInspection/bugs/RecursionUtils.java
+1 -1
View File
@@ -305,7 +305,7 @@ class RecursionUtils {
private static boolean arrayAccessExpressionDefinitelyRecurses(
GrIndexProperty expression, GrMethod method) {
final GrExpression arrayExp = expression.getSelectedExpression();
final GrExpression arrayExp = expression.getInvokedExpression();
return expressionDefinitelyRecurses(arrayExp, method);
}
plugins/groovy/src/org/jetbrains/plugins/groovy/codeInspection/utils/EquivalenceChecker.java
+2 -2
View File
@@ -540,8 +540,8 @@ public class EquivalenceChecker {
private static boolean indexExpressionsAreEquivalent(GrIndexProperty expression1,
GrIndexProperty expression2) {
final GrExpression operand1 = expression1.getSelectedExpression();
final GrExpression operand2 = expression2.getSelectedExpression();
final GrExpression operand1 = expression1.getInvokedExpression();
final GrExpression operand2 = expression2.getInvokedExpression();
return expressionsAreEquivalent(operand1, operand2);
}
plugins/groovy/src/org/jetbrains/plugins/groovy/intentions/conversions/IndexedExpressionConversionIntention.java
+1 -1
View File
@@ -46,7 +46,7 @@ public class IndexedExpressionConversionIntention extends Intention {
final GrExpression[] arguments = argList.getExpressionArguments();
final PsiElement parent = element.getParent();
final GrExpression arrayExpression = arrayIndexExpression.getSelectedExpression();
final GrExpression arrayExpression = arrayIndexExpression.getInvokedExpression();
if (!(parent instanceof GrAssignmentExpression)) {
rewriteAsGetAt(arrayIndexExpression, arrayExpression, arguments[0]);
return;
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/completion/GroovyCompletionUtil.java
+1 -1
View File
@@ -335,7 +335,7 @@ public class GroovyCompletionUtil {
}
public static boolean hasConstructorParameters(@NotNull PsiClass clazz, @NotNull GroovyPsiElement place) {
for (GroovyResolveResult result : ResolveUtil.getAllClassConstructors(clazz, place, PsiSubstitutor.EMPTY)) {
for (GroovyResolveResult result : ResolveUtil.getAllClassConstructors(clazz, place, PsiSubstitutor.EMPTY, null)) {
if (result.isAccessible() && ((PsiMethod)result.getElement()).getParameterList().getParametersCount() > 0) {
return true;
}
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/api/statements/expressions/GrCall.java
+9 -3
View File
@@ -32,21 +32,27 @@ public interface GrCall extends GroovyPsiElement {
@Nullable
GrArgumentList getArgumentList();
@NotNull
GrNamedArgument[] getNamedArguments();
@NotNull
GrExpression[] getExpressionArguments();
@NotNull
GrClosableBlock[] getClosureArguments();
@Nullable
GrNamedArgument addNamedArgument(GrNamedArgument namedArgument) throws IncorrectOperationException;
@NotNull
GroovyResolveResult[] getCallVariants(@Nullable GrExpression upToArgument);
@NotNull
GrClosableBlock[] getClosureArguments();
@Nullable
PsiMethod resolveMethod();
@NotNull
GroovyResolveResult advancedResolve();
@NotNull
GroovyResolveResult[] multiResolve(boolean incompleteCode);
}
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/api/statements/expressions/GrConstructorCall.java
-6
View File
@@ -15,17 +15,11 @@
*/
package org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult;
/**
* @author ven
*/
public interface GrConstructorCall extends GrCall {
@NotNull
GroovyResolveResult resolveConstructorGenerics();
GroovyResolveResult[] multiResolveConstructor();
GroovyResolveResult[] multiResolveClass();
}
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/api/statements/expressions/path/GrIndexProperty.java
+2 -11
View File
@@ -16,22 +16,13 @@
package org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.path;
import com.intellij.psi.PsiPolyVariantReference;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
/**
* @author ilyas
*/
public interface GrIndexProperty extends GrExpression, PsiPolyVariantReference {
public interface GrIndexProperty extends GrExpression, GrCallExpression {
@NotNull
GrExpression getSelectedExpression();
GrArgumentList getArgumentList();
@NotNull
@Override
GroovyResolveResult[] multiResolve(final boolean incompleteCode);
GrExpression getInvokedExpression();
}
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/PsiImplUtil.java
+1 -1
View File
@@ -621,7 +621,7 @@ public class PsiImplUtil {
public static PsiType normalizeWildcardTypeByPosition(@NotNull PsiType type, @NotNull GrExpression expression) {
GrExpression toplevel = expression;
while (toplevel.getParent() instanceof GrIndexProperty &&
((GrIndexProperty)toplevel.getParent()).getSelectedExpression() == toplevel) {
((GrIndexProperty)toplevel.getParent()).getInvokedExpression() == toplevel) {
toplevel = (GrExpression)toplevel.getParent();
}
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/GrConstructorInvocationImpl.java
+6 -28
View File
@@ -16,7 +16,6 @@
package org.jetbrains.plugins.groovy.lang.psi.impl.statements;
import com.intellij.lang.ASTNode;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.*;
import com.intellij.psi.tree.TokenSet;
import com.intellij.psi.util.PsiTreeUtil;
@@ -69,11 +68,8 @@ public class GrConstructorInvocationImpl extends GrCallImpl implements GrConstru
return (GrThisSuperReferenceExpression)findNotNullChildByType(THIS_OR_SUPER_SET);
}
public GroovyResolveResult[] multiResolveConstructor() {
return multiResolveImpl(false);
}
private GroovyResolveResult[] multiResolveImpl(boolean allVariants) {
@NotNull
public GroovyResolveResult[] multiResolve(boolean incompleteCode) {
PsiClass clazz = getDelegatedClass();
if (clazz != null) {
PsiType[] argTypes = PsiUtil.getArgumentTypes(getFirstChild(), false);
@@ -88,7 +84,7 @@ public class GrConstructorInvocationImpl extends GrCallImpl implements GrConstru
}
PsiType thisType = factory.createType(clazz, substitutor);
MethodResolverProcessor processor = new MethodResolverProcessor(clazz.getName(), this, true, thisType, argTypes, PsiType.EMPTY_ARRAY,
allVariants, false);
incompleteCode, false);
final ResolveState state = ResolveState.initial().put(PsiSubstitutor.KEY, substitutor);
clazz.processDeclarations(processor, state, null, this);
ResolveUtil.processNonCodeMembers(thisType, processor, this, state);
@@ -103,18 +99,13 @@ public class GrConstructorInvocationImpl extends GrCallImpl implements GrConstru
}
public PsiMethod resolveMethod() {
return PsiImplUtil.extractUniqueElement(multiResolveConstructor());
}
@NotNull
public GroovyResolveResult resolveConstructorGenerics() {
return PsiImplUtil.extractUniqueResult(multiResolveConstructor());
return PsiImplUtil.extractUniqueElement(multiResolve(false));
}
@NotNull
@Override
public GroovyResolveResult advancedResolve() {
return resolveConstructorGenerics();
return PsiImplUtil.extractUniqueResult(multiResolve(false));
}
@Nullable
@@ -130,19 +121,6 @@ public class GrConstructorInvocationImpl extends GrCallImpl implements GrConstru
return PsiTreeUtil.getParentOfType(this, GrTypeDefinition.class);
}
public PsiElement getElement() {
return this;
}
public TextRange getRangeInElement() {
return new TextRange(0, getThisOrSuperKeyword().getTextLength());
}
@Nullable
public PsiElement resolve() {
return resolveMethod();
}
@NotNull
public String getCanonicalText() {
return getText(); //TODO
@@ -151,6 +129,6 @@ public class GrConstructorInvocationImpl extends GrCallImpl implements GrConstru
@NotNull
@Override
public GroovyResolveResult[] getCallVariants(@Nullable GrExpression upToArgument) {
return multiResolveImpl(true);
return multiResolve(true);
}
}
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/GrCallImpl.java
+2
View File
@@ -43,11 +43,13 @@ public abstract class GrCallImpl extends GroovyPsiElementImpl implements GrCall
return null;
}
@NotNull
public GrNamedArgument[] getNamedArguments() {
GrArgumentList argList = getArgumentList();
return argList != null ? argList.getNamedArguments() : GrNamedArgument.EMPTY_ARRAY;
}
@NotNull
public GrExpression[] getExpressionArguments() {
GrArgumentList argList = getArgumentList();
return argList != null ? argList.getExpressionArguments() : GrExpression.EMPTY_ARRAY;
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/GrMethodCallImpl.java
+8
View File
@@ -110,4 +110,12 @@ public abstract class GrMethodCallImpl extends GrCallExpressionImpl implements G
return ((GrReferenceExpression)expression).getDotToken() == null;
}
@NotNull
@Override
public GroovyResolveResult[] multiResolve(boolean incompleteCode) {
GrExpression expression = getInvokedExpression();
if (!(expression instanceof GrReferenceExpression)) return GroovyResolveResult.EMPTY_ARRAY;
return ((GrReferenceExpression)expression).multiResolve(incompleteCode);
}
}
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/GrNewExpressionImpl.java
+99 -41
View File
@@ -17,11 +17,13 @@
package org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions;
import com.intellij.lang.ASTNode;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.*;
import com.intellij.psi.util.InheritanceUtil;
import com.intellij.util.Function;
import com.intellij.util.IncorrectOperationException;
import com.intellij.util.NullableFunction;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.plugins.groovy.lang.psi.GroovyElementVisitor;
@@ -138,39 +140,6 @@ public class GrNewExpressionImpl extends GrCallExpressionImpl implements GrNewEx
return findChildByClass(GrCodeReferenceElement.class);
}
@NotNull
public GroovyResolveResult[] multiResolveConstructor() {
GrCodeReferenceElement ref = getReferenceElement();
if (ref == null) return GroovyResolveResult.EMPTY_ARRAY;
final GroovyResolveResult[] classResults = ref.multiResolve(false);
if (classResults.length == 0) return GroovyResolveResult.EMPTY_ARRAY;
final GrArgumentList argumentList = getArgumentList();
if (argumentList == null) return GroovyResolveResult.EMPTY_ARRAY;
if (argumentList.getNamedArguments().length > 0 && argumentList.getExpressionArguments().length == 0) {
PsiType mapType = new GrMapType(argumentList, getNamedArguments());
GroovyResolveResult[] constructorResults = PsiUtil.getConstructorCandidates(ref, classResults, new PsiType[]{mapType}); //one Map parameter, actually
for (GroovyResolveResult result : constructorResults) {
final PsiElement resolved = result.getElement();
if (resolved instanceof PsiMethod) {
PsiMethod constructor = (PsiMethod)resolved;
final PsiParameter[] parameters = constructor.getParameterList().getParameters();
if (parameters.length == 1 && InheritanceUtil.isInheritor(parameters[0].getType(), CommonClassNames.JAVA_UTIL_MAP)) {
return constructorResults;
}
}
}
final GroovyResolveResult[] emptyConstructors = PsiUtil.getConstructorCandidates(ref, classResults, PsiType.EMPTY_ARRAY);
if (emptyConstructors.length > 0) {
return emptyConstructors;
}
}
return PsiUtil.getConstructorCandidates(ref, classResults, PsiUtil.getArgumentTypes(ref, false));
}
public GroovyResolveResult[] multiResolveClass() {
final GrCodeReferenceElement referenceElement = getReferenceElement();
if (referenceElement != null) {
@@ -179,11 +148,6 @@ public class GrNewExpressionImpl extends GrCallExpressionImpl implements GrNewEx
return GroovyResolveResult.EMPTY_ARRAY;
}
@NotNull
public GroovyResolveResult resolveConstructorGenerics() {
return PsiImplUtil.extractUniqueResult(multiResolveConstructor());
}
public int getArrayCount() {
final GrArrayDeclaration arrayDeclaration = getArrayDeclaration();
if (arrayDeclaration == null) return 0;
@@ -208,13 +172,13 @@ public class GrNewExpressionImpl extends GrCallExpressionImpl implements GrNewEx
@Nullable
public PsiMethod resolveMethod() {
return PsiImplUtil.extractUniqueElement(multiResolveConstructor());
return PsiImplUtil.extractUniqueElement(multiResolve(false));
}
@NotNull
@Override
public GroovyResolveResult advancedResolve() {
return resolveConstructorGenerics();
return PsiImplUtil.extractUniqueResult(multiResolve(false));
}
@NotNull
@@ -226,7 +190,7 @@ public class GrNewExpressionImpl extends GrCallExpressionImpl implements GrNewEx
for (GroovyResolveResult classResult : referenceElement.multiResolve(false)) {
final PsiElement element = classResult.getElement();
if (element instanceof PsiClass) {
result.addAll(ResolveUtil.getAllClassConstructors((PsiClass)element, this, classResult.getSubstitutor()));
ContainerUtil.addAll(result, ResolveUtil.getAllClassConstructors((PsiClass)element, this, classResult.getSubstitutor(), null));
}
}
@@ -237,4 +201,98 @@ public class GrNewExpressionImpl extends GrCallExpressionImpl implements GrNewEx
public GrTypeElement getTypeElement() {
return findChildByClass(GrTypeElement.class);
}
@NotNull
@Override
public GroovyResolveResult[] multiResolve(boolean incompleteCode) {
//ResolveCache.getInstance(getProject()).resolveWithCaching()
GrCodeReferenceElement ref = getReferenceElement();
if (ref == null) return GroovyResolveResult.EMPTY_ARRAY;
final GroovyResolveResult[] classResults = ref.multiResolve(false);
if (classResults.length == 0) return GroovyResolveResult.EMPTY_ARRAY;
if (incompleteCode) {
return PsiUtil.getConstructorCandidates(ref, classResults, null);
}
final GrArgumentList argumentList = getArgumentList();
if (argumentList == null) return GroovyResolveResult.EMPTY_ARRAY;
if (argumentList.getNamedArguments().length > 0 && argumentList.getExpressionArguments().length == 0) {
PsiType mapType = new GrMapType(argumentList, getNamedArguments());
GroovyResolveResult[] constructorResults = PsiUtil.getConstructorCandidates(ref, classResults, new PsiType[]{mapType}); //one Map parameter, actually
for (GroovyResolveResult result : constructorResults) {
final PsiElement resolved = result.getElement();
if (resolved instanceof PsiMethod) {
PsiMethod constructor = (PsiMethod)resolved;
final PsiParameter[] parameters = constructor.getParameterList().getParameters();
if (parameters.length == 1 && InheritanceUtil.isInheritor(parameters[0].getType(), CommonClassNames.JAVA_UTIL_MAP)) {
return constructorResults;
}
}
}
final GroovyResolveResult[] emptyConstructors = PsiUtil.getConstructorCandidates(ref, classResults, PsiType.EMPTY_ARRAY);
if (emptyConstructors.length > 0) {
return emptyConstructors;
}
}
return PsiUtil.getConstructorCandidates(ref, classResults, PsiUtil.getArgumentTypes(ref, true));
}
private class MyRef implements PsiPolyVariantReference {
@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
return GrNewExpressionImpl.this.multiResolve(incompleteCode);
}
@Override
public PsiElement getElement() {
return GrNewExpressionImpl.this;
}
@Override
public TextRange getRangeInElement() {
return getReferenceElement().getRangeInElement();
}
@Override
public PsiElement resolve() {
return resolveMethod();
}
@NotNull
@Override
public String getCanonicalText() {
return "new expression reference";
}
@Override
public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException {
return GrNewExpressionImpl.this;
}
@Override
public PsiElement bindToElement(@NotNull PsiElement element) throws IncorrectOperationException {
return GrNewExpressionImpl.this;
}
@Override
public boolean isReferenceTo(PsiElement element) {
return getManager().areElementsEquivalent(resolveMethod(), element);
}
@NotNull
@Override
public Object[] getVariants() {
return multiResolve(true);
}
@Override
public boolean isSoft() {
return false;
}
}
}
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/GrThisSuperReferenceExpressionBase.java
+1 -1
View File
@@ -100,7 +100,7 @@ public abstract class GrThisSuperReferenceExpressionBase extends GrExpressionImp
public ResolveResult[] multiResolve(boolean incompleteCode) {
final PsiElement parent = getParent();
if (parent instanceof GrConstructorInvocation) {
return ((GrConstructorInvocation)parent).multiResolveConstructor();
return ((GrConstructorInvocation)parent).multiResolve(incompleteCode);
}
return ResolveResult.EMPTY_ARRAY;
}
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/path/GrIndexPropertyImpl.java
+202 -129
View File
@@ -29,10 +29,11 @@ import com.intellij.util.IncorrectOperationException;
import com.intellij.util.NullableFunction;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes;
import org.jetbrains.plugins.groovy.lang.psi.GroovyElementVisitor;
import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.branch.GrThrowStatement;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrBuiltinTypeClassExpression;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
@@ -59,7 +60,7 @@ public class GrIndexPropertyImpl extends GrExpressionImpl implements GrIndexProp
private static final Function<GrIndexPropertyImpl, PsiType> TYPE_CALCULATOR = new NullableFunction<GrIndexPropertyImpl, PsiType>() {
@Override
public PsiType fun(GrIndexPropertyImpl index) {
GrExpression selected = index.getSelectedExpression();
GrExpression selected = index.getInvokedExpression();
PsiType thisType = selected.getType();
if (thisType == null) return null;
@@ -118,85 +119,91 @@ public class GrIndexPropertyImpl extends GrExpressionImpl implements GrIndexProp
return TypesUtil.boxPrimitiveType(substituted, manager, resolveScope);
}
};
private static final ResolveCache.PolyVariantResolver<GrIndexPropertyImpl> RESOLVER =
new ResolveCache.PolyVariantResolver<GrIndexPropertyImpl>() {
private static final ResolveCache.PolyVariantResolver<MyReference> RESOLVER =
new ResolveCache.PolyVariantResolver<MyReference>() {
@Override
public GroovyResolveResult[] resolve(GrIndexPropertyImpl index, boolean incompleteCode) {
GrExpression selected = index.getSelectedExpression();
PsiType thisType = selected.getType();
if (thisType == null) return GroovyResolveResult.EMPTY_ARRAY;
GrArgumentList argList = index.getArgumentList();
if (argList == null) return GroovyResolveResult.EMPTY_ARRAY;
PsiType[] argTypes = PsiUtil.getArgumentTypes(argList);
if (argTypes == null) return GroovyResolveResult.EMPTY_ARRAY;
final PsiManager manager = index.getManager();
final GlobalSearchScope resolveScope = index.getResolveScope();
if (argTypes.length == 0) {
PsiType arrType = null;
if (selected instanceof GrBuiltinTypeClassExpression) {
arrType = ((GrBuiltinTypeClassExpression)selected).getPrimitiveType();
}
if (selected instanceof GrReferenceExpression) {
final PsiElement resolved = ((GrReferenceExpression)selected).resolve();
if (resolved instanceof PsiClass) {
String qname = ((PsiClass)resolved).getQualifiedName();
if (qname != null) {
arrType = TypesUtil.createTypeByFQClassName(qname, index);
}
}
}
if (arrType != null) {
return GroovyResolveResult.EMPTY_ARRAY;
}
}
if (PsiImplUtil.isSimpleArrayAccess(thisType, argTypes, manager, resolveScope)) {
return GroovyResolveResult.EMPTY_ARRAY;
}
GroovyResolveResult[] candidates;
final String name;
if (PsiUtil.isLValue(index)) {
name = "putAt";
if (!incompleteCode) {
argTypes = ArrayUtil.append(argTypes, TypeInferenceHelper.getInitializerFor(index), PsiType.class);
}
}
else {
name = "getAt";
}
candidates = ResolveUtil.getMethodCandidates(thisType, name, index, true, incompleteCode, false, argTypes);
//hack for remove DefaultGroovyMethods.getAt(Object, ...)
if (candidates.length == 2) {
for (int i = 0; i < candidates.length; i++) {
GroovyResolveResult candidate = candidates[i];
final PsiElement element = candidate.getElement();
if (element instanceof GrGdkMethod) {
final PsiMethod staticMethod = ((GrGdkMethod)element).getStaticMethod();
final PsiParameter param = staticMethod.getParameterList().getParameters()[0];
if (param.getType().equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) {
return new GroovyResolveResult[]{candidates[1 - i]};
}
}
}
}
if (candidates.length != 1) {
final GrTupleType tupleType = new GrTupleType(argTypes, JavaPsiFacade.getInstance(index.getProject()), index.getResolveScope());
candidates = ResolveUtil.getMethodCandidates(thisType, name, index, tupleType);
}
return candidates;
public GroovyResolveResult[] resolve(MyReference index, boolean incompleteCode) {
return index.getElement().resolveImpl(incompleteCode, null);
}
};
private MyReference myReference = new MyReference();
private GroovyResolveResult[] resolveImpl(boolean incompleteCode, @Nullable GrExpression upToArgument) {
GrExpression invoked = getInvokedExpression();
PsiType thisType = invoked.getType();
if (thisType == null) return GroovyResolveResult.EMPTY_ARRAY;
GrArgumentList argList = getArgumentList();
if (argList == null) return GroovyResolveResult.EMPTY_ARRAY;
PsiType[] argTypes = PsiUtil.getArgumentTypes(argList, true, upToArgument);
if (argTypes == null) return GroovyResolveResult.EMPTY_ARRAY;
final PsiManager manager = getManager();
final GlobalSearchScope resolveScope = getResolveScope();
if (argTypes.length == 0) {
PsiType arrType = null;
if (invoked instanceof GrBuiltinTypeClassExpression) {
arrType = ((GrBuiltinTypeClassExpression)invoked).getPrimitiveType();
}
if (invoked instanceof GrReferenceExpression) {
final PsiElement resolved = ((GrReferenceExpression)invoked).resolve();
if (resolved instanceof PsiClass) {
String qname = ((PsiClass)resolved).getQualifiedName();
if (qname != null) {
arrType = TypesUtil.createTypeByFQClassName(qname, this);
}
}
}
if (arrType != null) {
return GroovyResolveResult.EMPTY_ARRAY;
}
}
if (PsiImplUtil.isSimpleArrayAccess(thisType, argTypes, manager, resolveScope)) {
return GroovyResolveResult.EMPTY_ARRAY;
}
GroovyResolveResult[] candidates;
final String name;
if (PsiUtil.isLValue(this)) {
name = "putAt";
if (!incompleteCode) {
argTypes = ArrayUtil.append(argTypes, TypeInferenceHelper.getInitializerFor(this), PsiType.class);
}
}
else {
name = "getAt";
}
candidates = ResolveUtil.getMethodCandidates(thisType, name, this, true, incompleteCode, false, argTypes);
//hack for remove DefaultGroovyMethods.getAt(Object, ...)
if (candidates.length == 2) {
for (int i = 0; i < candidates.length; i++) {
GroovyResolveResult candidate = candidates[i];
final PsiElement element = candidate.getElement();
if (element instanceof GrGdkMethod) {
final PsiMethod staticMethod = ((GrGdkMethod)element).getStaticMethod();
final PsiParameter param = staticMethod.getParameterList().getParameters()[0];
if (param.getType().equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) {
return new GroovyResolveResult[]{candidates[1 - i]};
}
}
}
}
if (candidates.length != 1) {
final GrTupleType tupleType = new GrTupleType(argTypes, JavaPsiFacade.getInstance(getProject()), resolveScope);
candidates = ResolveUtil.getMethodCandidates(thisType, name, this, tupleType);
}
return candidates;
}
public GrIndexPropertyImpl(@NotNull ASTNode node) {
super(node);
}
@@ -210,7 +217,7 @@ public class GrIndexPropertyImpl extends GrExpressionImpl implements GrIndexProp
}
@NotNull
public GrExpression getSelectedExpression() {
public GrExpression getInvokedExpression() {
return findNotNullChildByClass(GrExpression.class);
}
@@ -222,61 +229,13 @@ public class GrIndexPropertyImpl extends GrExpressionImpl implements GrIndexProp
@NotNull
@Override
public GroovyResolveResult[] multiResolve(boolean incompleteCode) {
return (GroovyResolveResult[])ResolveCache.getInstance(getProject()).resolveWithCaching(this, RESOLVER, false, incompleteCode);
return (GroovyResolveResult[])ResolveCache.getInstance(getProject()).resolveWithCaching(myReference, RESOLVER, false, incompleteCode);
}
public PsiType getType() {
return GroovyPsiManager.getInstance(getProject()).getType(this, TYPE_CALCULATOR);
}
@Override
public PsiElement getElement() {
return this;
}
@Override
public TextRange getRangeInElement() {
final int offset = findNotNullChildByType(GroovyTokenTypes.mLBRACK).getStartOffsetInParent();
return new TextRange(offset, offset + 1);
}
@Override
public PsiElement resolve() {
return PsiImplUtil.extractUniqueElement(multiResolve(false));
}
@NotNull
@Override
public String getCanonicalText() {
return "Array-style access";
}
@Override
public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException {
return this;
}
@Override
public PsiElement bindToElement(@NotNull PsiElement element) throws IncorrectOperationException {
return this;
}
@Override
public boolean isReferenceTo(PsiElement element) {
return getManager().areElementsEquivalent(resolve(), element);
}
@NotNull
@Override
public Object[] getVariants() {
return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
@Override
public boolean isSoft() {
return false;
}
@Override
public PsiType getNominalType() {
if (getParent() instanceof GrThrowStatement) return super.getNominalType();
@@ -292,8 +251,9 @@ public class GrIndexPropertyImpl extends GrExpressionImpl implements GrIndexProp
@Nullable
private PsiType extractLastParameterType(GroovyResolveResult candidate) {
if (candidate.getElement() instanceof PsiMethod) {
PsiParameter[] parameters = ((PsiMethod)candidate.getElement()).getParameterList().getParameters();
PsiElement element = candidate.getElement();
if (element instanceof PsiMethod) {
PsiParameter[] parameters = ((PsiMethod)element).getParameterList().getParameters();
if (parameters.length > 1) {
PsiParameter last = parameters[parameters.length - 1];
return TypesUtil.substituteBoxAndNormalizeType(last.getType(), candidate.getSubstitutor(), this);
@@ -301,4 +261,117 @@ public class GrIndexPropertyImpl extends GrExpressionImpl implements GrIndexProp
}
return null;
}
@NotNull
@Override
public GrNamedArgument[] getNamedArguments() {
GrArgumentList list = getArgumentList();
return list == null ? GrNamedArgument.EMPTY_ARRAY : list.getNamedArguments();
}
@NotNull
@Override
public GrExpression[] getExpressionArguments() {
GrArgumentList list = getArgumentList();
return list == null ? GrExpression.EMPTY_ARRAY : list.getExpressionArguments();
}
@Override
public GrNamedArgument addNamedArgument(GrNamedArgument namedArgument) throws IncorrectOperationException {
GrArgumentList list = getArgumentList();
if (list == null) throw new IncorrectOperationException("Argument list is null");
return list.addNamedArgument(namedArgument);
}
@NotNull
@Override
public GroovyResolveResult[] getCallVariants(@Nullable GrExpression upToArgument) {
if (upToArgument == null) {
return multiResolve(true);
}
return resolveImpl(true, upToArgument);
}
@NotNull
@Override
public GrClosableBlock[] getClosureArguments() {
return GrClosableBlock.EMPTY_ARRAY;
}
@Override
public PsiMethod resolveMethod() {
PsiElement resolved = PsiImplUtil.extractUniqueElement(multiResolve(false));
if (resolved instanceof PsiMethod) {
return (PsiMethod)resolved;
}
return null;
}
@NotNull
@Override
public GroovyResolveResult advancedResolve() {
GroovyResolveResult[] results = multiResolve(false);
return results.length == 1 ? results[0] : GroovyResolveResult.EMPTY_RESULT;
}
@Override
public PsiReference getReference() {
return myReference;
}
private class MyReference implements PsiPolyVariantReference {
@Override
public GrIndexPropertyImpl getElement() {
return GrIndexPropertyImpl.this;
}
@Override
public TextRange getRangeInElement() {
final int offset = getArgumentList().getStartOffsetInParent();
return new TextRange(offset, offset + 1);
}
@Override
public PsiElement resolve() {
return resolveMethod();
}
@NotNull
@Override
public String getCanonicalText() {
return "Array-style access";
}
@Override
public PsiElement handleElementRename(String newElementName) throws IncorrectOperationException {
return GrIndexPropertyImpl.this;
}
@Override
public PsiElement bindToElement(@NotNull PsiElement element) throws IncorrectOperationException {
return GrIndexPropertyImpl.this;
}
@Override
public boolean isReferenceTo(PsiElement element) {
return getManager().areElementsEquivalent(resolve(), element);
}
@NotNull
@Override
public Object[] getVariants() {
return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
@Override
public boolean isSoft() {
return false;
}
@NotNull
@Override
public ResolveResult[] multiResolve(boolean incompleteCode) {
return resolveImpl(incompleteCode, null);
}
}
}
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/typedef/enumConstant/GrEnumConstantImpl.java
+20 -25
View File
@@ -101,26 +101,6 @@ public class GrEnumConstantImpl extends GrFieldImpl implements GrEnumConstant {
return false;
}
@NotNull
public GroovyResolveResult resolveConstructorGenerics() {
return PsiImplUtil.extractUniqueResult(multiResolveConstructor());
}
public GroovyResolveResult[] multiResolveConstructor() {
return multiResolveConstructorImpl(false);
}
private GroovyResolveResult[] multiResolveConstructorImpl(boolean allVariants) {
PsiType[] argTypes = PsiUtil.getArgumentTypes(getFirstChild(), false);
PsiClass clazz = getContainingClass();
assert clazz != null;
PsiType thisType = JavaPsiFacade.getInstance(getProject()).getElementFactory().createType(clazz, PsiSubstitutor.EMPTY);
MethodResolverProcessor processor =
new MethodResolverProcessor(clazz.getName(), this, true, thisType, argTypes, PsiType.EMPTY_ARRAY, allVariants, false);
clazz.processDeclarations(processor, ResolveState.initial(), null, this);
return processor.getCandidates();
}
public GroovyResolveResult[] multiResolveClass() {
final PsiClass psiClass = getContainingClass();
GroovyResolveResult result = new GroovyResolveResultImpl(psiClass, this, PsiSubstitutor.EMPTY, true, true);
@@ -143,12 +123,14 @@ public class GrEnumConstantImpl extends GrFieldImpl implements GrEnumConstant {
return list.addNamedArgument(namedArgument);
}
@NotNull
@Override
public GrNamedArgument[] getNamedArguments() {
final GrArgumentList argumentList = getArgumentList();
return argumentList == null ? GrNamedArgument.EMPTY_ARRAY : argumentList.getNamedArguments();
}
@NotNull
@Override
public GrExpression[] getExpressionArguments() {
final GrArgumentList argumentList = getArgumentList();
@@ -159,7 +141,7 @@ public class GrEnumConstantImpl extends GrFieldImpl implements GrEnumConstant {
@NotNull
@Override
public GroovyResolveResult[] getCallVariants(@Nullable GrExpression upToArgument) {
return multiResolveConstructorImpl(true);
return multiResolve(true);
}
@NotNull
@@ -170,7 +152,7 @@ public class GrEnumConstantImpl extends GrFieldImpl implements GrEnumConstant {
@Override
public PsiMethod resolveMethod() {
return PsiImplUtil.extractUniqueElement(multiResolveConstructor());
return PsiImplUtil.extractUniqueElement(multiResolve(false));
}
@NotNull
@@ -210,7 +192,7 @@ public class GrEnumConstantImpl extends GrFieldImpl implements GrEnumConstant {
@NotNull
@Override
public GroovyResolveResult advancedResolve() {
return resolveConstructorGenerics();
return PsiImplUtil.extractUniqueResult(multiResolve(false));
}
@Override
@@ -218,10 +200,23 @@ public class GrEnumConstantImpl extends GrFieldImpl implements GrEnumConstant {
return resolveMethod();
}
@NotNull
@Override
public GroovyResolveResult[] multiResolve(boolean incompleteCode) {
PsiType[] argTypes = PsiUtil.getArgumentTypes(getFirstChild(), false);
PsiClass clazz = getContainingClass();
assert clazz != null;
PsiType thisType = JavaPsiFacade.getInstance(getProject()).getElementFactory().createType(clazz, PsiSubstitutor.EMPTY);
MethodResolverProcessor processor =
new MethodResolverProcessor(clazz.getName(), this, true, thisType, argTypes, PsiType.EMPTY_ARRAY, incompleteCode, false);
clazz.processDeclarations(processor, ResolveState.initial(), null, this);
return processor.getCandidates();
}
private class MyReference implements PsiPolyVariantReference {
@NotNull
public ResolveResult[] multiResolve(boolean incompleteCode) {
return multiResolveConstructor();
return GrEnumConstantImpl.this.multiResolve(false);
}
public PsiElement getElement() {
@@ -238,7 +233,7 @@ public class GrEnumConstantImpl extends GrFieldImpl implements GrEnumConstant {
@NotNull
public GroovyResolveResult advancedResolve() {
return resolveConstructorGenerics();
return GrEnumConstantImpl.this.advancedResolve();
}
@NotNull
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/PsiUtil.java
+3 -15
View File
@@ -81,7 +81,6 @@ import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.JavaIdentifier;
import org.jetbrains.plugins.groovy.lang.psi.impl.types.GrClosureSignatureUtil;
import org.jetbrains.plugins.groovy.lang.resolve.ResolveUtil;
import org.jetbrains.plugins.groovy.lang.resolve.processors.MethodResolverProcessor;
import org.jetbrains.plugins.groovy.lang.resolve.processors.ResolverProcessor;
import java.util.*;
@@ -612,7 +611,7 @@ public class PsiUtil {
}
private static boolean isRawIndexPropertyAccess(GrIndexProperty expr) {
final GrExpression qualifier = expr.getSelectedExpression();
final GrExpression qualifier = expr.getInvokedExpression();
final PsiType qualifierType = qualifier.getType();
if (qualifierType instanceof PsiClassType) {
@@ -824,24 +823,13 @@ public class PsiUtil {
return false;
}
public static GroovyResolveResult[] getConstructorCandidates(GroovyPsiElement place, GroovyResolveResult[] classCandidates, PsiType[] argTypes) {
public static GroovyResolveResult[] getConstructorCandidates(GroovyPsiElement place, GroovyResolveResult[] classCandidates, @Nullable PsiType[] argTypes) {
for (GroovyResolveResult classResult : classCandidates) {
final PsiElement element = classResult.getElement();
if (element instanceof PsiClass) {
final GroovyPsiElement context = classResult.getCurrentFileResolveContext();
PsiClass clazz = (PsiClass)element;
String className = clazz.getName();
PsiType thisType = JavaPsiFacade.getElementFactory(place.getProject()).createType(clazz, classResult.getSubstitutor());
final MethodResolverProcessor processor = new MethodResolverProcessor(className, place, true, thisType, argTypes, PsiType.EMPTY_ARRAY);
PsiSubstitutor substitutor = classResult.getSubstitutor();
final ResolveState state = ResolveState.initial().put(PsiSubstitutor.KEY, substitutor).put(ResolverProcessor.RESOLVE_CONTEXT, context);
List<GroovyResolveResult> constructors = ResolveUtil.getAllClassConstructors(clazz, place, substitutor);
if (!constructors.isEmpty()) {
for (GroovyResolveResult result : constructors) {
processor.execute(result.getElement(), state.put(PsiSubstitutor.KEY, result.getSubstitutor()));
}
return processor.getCandidates();
}
return ResolveUtil.getAllClassConstructors(clazz, place, substitutor, argTypes);
}
}
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/resolve/ResolveUtil.java
+5 -10
View File
@@ -25,7 +25,6 @@ import com.intellij.psi.scope.JavaScopeProcessorEvent;
import com.intellij.psi.scope.NameHint;
import com.intellij.psi.scope.PsiScopeProcessor;
import com.intellij.psi.util.*;
import com.intellij.util.containers.CollectionFactory;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -533,20 +532,16 @@ public class ResolveUtil {
return variants;
}
public static List<GroovyResolveResult> getAllClassConstructors(PsiClass psiClass, GroovyPsiElement place, PsiSubstitutor substitutor) {
final List<GroovyResolveResult> result = CollectionFactory.arrayList();
final PsiResolveHelper helper = JavaPsiFacade.getInstance(place.getProject()).getResolveHelper();
public static GroovyResolveResult[] getAllClassConstructors(PsiClass psiClass, GroovyPsiElement place, PsiSubstitutor substitutor, @Nullable PsiType[] argTypes) {
final MethodResolverProcessor processor = new MethodResolverProcessor(psiClass.getName(), place, true, null, argTypes, PsiType.EMPTY_ARRAY);
ResolveState state = ResolveState.initial().put(PsiSubstitutor.KEY, substitutor);
for (PsiMethod constructor : psiClass.getConstructors()) {
result.add(new GroovyResolveResultImpl(constructor, null, substitutor, helper.isAccessible(constructor, place, null), true));
processor.execute(constructor, state);
}
final PsiClassType qualifierType = JavaPsiFacade.getElementFactory(psiClass.getProject()).createType(psiClass);
final MethodResolverProcessor processor = new MethodResolverProcessor(psiClass.getName(), place, true, null, null, PsiType.EMPTY_ARRAY);
ResolveState state = ResolveState.initial().put(PsiSubstitutor.KEY, substitutor);
NonCodeMembersContributor.runContributors(qualifierType, processor, place, state);
Collections.addAll(result, processor.getCandidates());
return result;
return processor.getCandidates();
}
public static boolean isKeyOfMap(GrReferenceExpression ref) {
plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/changeSignature/GrMethodCallUsageInfo.java
+2 -2
View File
@@ -97,7 +97,7 @@ public class GrMethodCallUsageInfo extends UsageInfo implements PossiblyIncorrec
@Nullable
private static GroovyResolveResult resolveMethod(final PsiElement ref) {
if (ref instanceof GrEnumConstant) return ((GrEnumConstant)ref).resolveConstructorGenerics();
if (ref instanceof GrEnumConstant) return ((GrEnumConstant)ref).advancedResolve();
PsiElement parent = ref.getParent();
if (parent instanceof GrMethodCall) {
final GrExpression expression = ((GrMethodCall)parent).getInvokedExpression();
@@ -106,7 +106,7 @@ public class GrMethodCallUsageInfo extends UsageInfo implements PossiblyIncorrec
}
}
else if (parent instanceof GrConstructorCall) {
return ((GrConstructorCall)parent).resolveConstructorGenerics();
return ((GrConstructorCall)parent).advancedResolve();
}
return null;
plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ClassItemGeneratorImpl.java
+1 -1
View File
@@ -69,7 +69,7 @@ public class ClassItemGeneratorImpl implements ClassItemGenerator {
final GrArgumentList argumentList = constant.getArgumentList();
if (argumentList != null) {
final GroovyResolveResult resolveResult = constant.resolveConstructorGenerics();
final GroovyResolveResult resolveResult = constant.advancedResolve();
GrClosureSignature signature = GrClosureSignatureUtil.createSignature(resolveResult);
new ArgumentListGenerator(builder, context.extend()).generate(
signature,
plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/CodeBlockGenerator.java
+1 -1
View File
@@ -165,7 +165,7 @@ public class CodeBlockGenerator extends Generator {
public void writeStatement(StringBuilder builder, ExpressionContext context) {
final GrThisSuperReferenceExpression thisOrSuperKeyword = invocation.getThisOrSuperKeyword();
final GrArgumentList argumentList = invocation.getArgumentList();
final GroovyResolveResult resolveResult = invocation.resolveConstructorGenerics();
final GroovyResolveResult resolveResult = invocation.advancedResolve();
if (thisOrSuperKeyword.getQualifier() == null) {
builder.append(thisOrSuperKeyword.getReferenceName());
}
plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/ExpressionGenerator.java
+14 -15
View File
@@ -27,7 +27,6 @@ import com.intellij.util.ArrayUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.plugins.groovy.intentions.conversions.ConvertGStringToStringIntention;
import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes;
import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement;
import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory;
import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult;
@@ -230,7 +229,7 @@ public class ExpressionGenerator extends Generator {
GrClosureSignature signature = null;
final GroovyResolveResult resolveResult = newExpression.resolveConstructorGenerics();
final GroovyResolveResult resolveResult = newExpression.advancedResolve();
final PsiElement constructor = resolveResult.getElement();
if (constructor instanceof PsiMethod) {
signature = GrClosureSignatureUtil.createSignature((PsiMethod)constructor, resolveResult.getSubstitutor());
@@ -324,7 +323,7 @@ public class ExpressionGenerator extends Generator {
final GrCodeReferenceElement refElement = newExpression.getReferenceElement();
if (refElement == null) return false;
final GroovyResolveResult resolveResult = newExpression.resolveConstructorGenerics();
final GroovyResolveResult resolveResult = newExpression.advancedResolve();
final PsiElement constructor = resolveResult.getElement();
if (constructor instanceof PsiMethod) {
return ((PsiMethod)constructor).getParameterList().getParametersCount() == 0;
@@ -374,7 +373,7 @@ public class ExpressionGenerator extends Generator {
else {
final GroovyResolveResult[] results = ResolveUtil.getMethodCandidates(type, "asBoolean", expression, PsiType.EMPTY_ARRAY);
final GroovyResolveResult result = PsiImplUtil.extractUniqueResult(results);
GenerationUtil.invokeMethodByResolveResult(
invokeMethodByResolveResult(
elvis ? factory.createReferenceExpressionFromText(var, expression) : condition,
result,
"asBoolean",
@@ -456,24 +455,24 @@ public class ExpressionGenerator extends Generator {
final PsiElement resolved = result.getElement();
if (resolved instanceof PsiMethod) {
final GrExpression[] args = ((GrIndexProperty)realLValue).getArgumentList().getExpressionArguments();
writeAssignmentWithSetter(((GrIndexProperty)realLValue).getSelectedExpression(), (PsiMethod)resolved,
writeAssignmentWithSetter(((GrIndexProperty)realLValue).getInvokedExpression(), (PsiMethod)resolved,
ArrayUtil.append(args, getRValue(expression)), GrNamedArgument.EMPTY_ARRAY, EMPTY_ARRAY,
result.getSubstitutor(), expression);
return;
}
}
final PsiType lType = GenerationUtil.getDeclaredType(lValue, context);
final PsiType lType = getDeclaredType(lValue, context);
if (token == mASSIGN) {
//write simple assignment
lValue.accept(this);
builder.append(" = ");
final PsiType rType = GenerationUtil.getDeclaredType(rValue, context);
final PsiType rType = getDeclaredType(rValue, context);
if (lType != null && rType != null && !TypesUtil.isAssignableByMethodCallConversion(lType, rType, expression)) {
builder.append('(');
GenerationUtil.writeType(builder, lType, expression);
writeType(builder, lType, expression);
builder.append(')');
}
if (rValue != null) {
@@ -489,10 +488,10 @@ public class ExpressionGenerator extends Generator {
lValue.accept(this);
builder.append(" = ");
final PsiType rType = GenerationUtil.getDeclaredType((PsiMethod)resolved, resolveResult.getSubstitutor(), context);
final PsiType rType = getDeclaredType((PsiMethod)resolved, resolveResult.getSubstitutor(), context);
if (lType != null && rType != null && !TypesUtil.isAssignableByMethodCallConversion(lType, rType, expression)) {
builder.append('(');
GenerationUtil.writeType(builder, lType, expression);
writeType(builder, lType, expression);
builder.append(')');
}
invokeMethodOn(
@@ -545,8 +544,8 @@ public class ExpressionGenerator extends Generator {
GrExpression lValue = expression.getLValue();
IElementType opToken = expression.getOperationToken();
if (opToken == GroovyTokenTypes.mASSIGN) return rValue;
Pair<String, IElementType> pair = GenerationUtil.getBinaryOperatorType(opToken);
if (opToken == mASSIGN) return rValue;
Pair<String, IElementType> pair = getBinaryOperatorType(opToken);
LOG.assertTrue(pair != null);
return factory.createExpressionFromText(lValue.getText() + pair.getFirst() + rValue.getText(), expression);
@@ -891,7 +890,7 @@ public class ExpressionGenerator extends Generator {
(resolved == null ||
resolved instanceof GrReferenceExpression ||
resolved instanceof LightElement && !(resolved instanceof ClosureSyntheticParameter)) &&
!(referenceExpression.getParent() instanceof GrCall) &&
(referenceExpression.getParent() instanceof GrIndexProperty || !(referenceExpression.getParent() instanceof GrCall)) &&
PsiUtil.isInScriptContext(referenceExpression)) {
final GrExpression thisExpr = factory.createExpressionFromText("this", referenceExpression);
thisExpr.accept(this);
@@ -1034,7 +1033,7 @@ public class ExpressionGenerator extends Generator {
builder.append(')');
boolean insertParentheses =
operand instanceof GrBinaryExpression && ((GrBinaryExpression)operand).getOperationTokenType() == GroovyTokenTypes.mEQUAL;
operand instanceof GrBinaryExpression && ((GrBinaryExpression)operand).getOperationTokenType() == mEQUAL;
if (insertParentheses) builder.append('(');
if (operand != null) {
@@ -1129,7 +1128,7 @@ public class ExpressionGenerator extends Generator {
@Override
public void visitIndexProperty(GrIndexProperty expression) {
final GrExpression selectedExpression = expression.getSelectedExpression();
final GrExpression selectedExpression = expression.getInvokedExpression();
final PsiType thisType = selectedExpression.getType();
final GrArgumentList argList = expression.getArgumentList();
plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/GenerationUtil.java
+8 -3
View File
@@ -595,9 +595,14 @@ public class GenerationUtil {
final GrExpression invokedExpression = ((GrMethodCall)expression).getInvokedExpression();
return getDeclaredType(invokedExpression, context);
}
else if (expression instanceof GrBinaryExpression || expression instanceof GrIndexProperty) {
final GroovyResolveResult result =
PsiImplUtil.extractUniqueResult((GroovyResolveResult[])((PsiPolyVariantReference)expression).multiResolve(false));
else if (expression instanceof GrBinaryExpression) {
final GroovyResolveResult result = PsiImplUtil.extractUniqueResult(((GrBinaryExpression)expression).multiResolve(false));
if (result.getElement() instanceof PsiMethod) {
return getDeclaredType((PsiMethod)result.getElement(), result.getSubstitutor(), context);
}
}
else if (expression instanceof GrIndexProperty) {
final GroovyResolveResult result = ((GrIndexProperty)expression).advancedResolve();
if (result.getElement() instanceof PsiMethod) {
return getDeclaredType((PsiMethod)result.getElement(), result.getSubstitutor(), context);
}
plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/convertToJava/StubGenerator.java
+2 -2
View File
@@ -254,12 +254,12 @@ public class StubGenerator implements ClassItemGenerator {
return null;
}
GroovyResolveResult resolveResult = constructorInvocation.resolveConstructorGenerics();
GroovyResolveResult resolveResult = constructorInvocation.advancedResolve();
if (resolveResult.getElement() != null) {
return resolveResult;
}
final GroovyResolveResult[] results = constructorInvocation.multiResolveConstructor();
final GroovyResolveResult[] results = constructorInvocation.multiResolve(false);
if (results.length > 0) {
int i = 0;
while (results.length > i + 1) {