From 04d2198017dc8e0732450181125cbcfd2f0c5bfe Mon Sep 17 00:00:00 2001 From: "Maxim.Medvedev" Date: Thu, 26 Apr 2012 17:02:27 +0400 Subject: [PATCH] IDEA-84657 No need to report non-inferrable argument types when parameter types are not specified --- .../GroovyAssignabilityCheckInspection.java | 144 +++++++++++------- .../impl/types/GrClosureSignatureUtil.java | 64 +++++--- .../plugins/groovy/lang/psi/util/PsiUtil.java | 48 ++++-- .../groovy/lang/GroovyHighlightingTest.groovy | 15 ++ .../highlighting/UnknownVarInArgList.groovy | 2 +- 5 files changed, 185 insertions(+), 88 deletions(-) diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/codeInspection/assignment/GroovyAssignabilityCheckInspection.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/codeInspection/assignment/GroovyAssignabilityCheckInspection.java index 34a4c377a77e..b88fa77760a4 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/codeInspection/assignment/GroovyAssignabilityCheckInspection.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/codeInspection/assignment/GroovyAssignabilityCheckInspection.java @@ -55,6 +55,7 @@ import org.jetbrains.plugins.groovy.lang.psi.api.types.GrCodeReferenceElement; import org.jetbrains.plugins.groovy.lang.psi.controlFlow.Instruction; import org.jetbrains.plugins.groovy.lang.psi.impl.GrClosureType; import org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.TypesUtil; +import org.jetbrains.plugins.groovy.lang.psi.impl.types.GrClosureSignatureUtil; import org.jetbrains.plugins.groovy.lang.psi.util.GroovyCommonClassNames; import org.jetbrains.plugins.groovy.lang.psi.util.GroovyConstantExpressionEvaluator; import org.jetbrains.plugins.groovy.lang.psi.util.GroovyPropertyUtils; @@ -264,8 +265,7 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection { final PsiElement constructor = constructorResolveResult.getElement(); if (constructor != null) { - if (!checkConstructorApplicability(constructorResolveResult, refElement)) return; - if (!checkUnknownParams(refElement)) return; + if (!checkConstructorApplicability(constructorResolveResult, refElement, true)) return; } else { final GroovyResolveResult[] results = constructorCall.multiResolve(false); @@ -273,10 +273,9 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection { for (GroovyResolveResult result : results) { PsiElement resolved = result.getElement(); if (resolved instanceof PsiMethod) { - if (!checkConstructorApplicability(result, refElement)) return; + if (!checkConstructorApplicability(result, refElement, false)) return; } } - if (!checkUnknownParams(refElement)) return; registerError(getElementToHighlight(refElement, argList), GroovyBundle.message("constructor.call.is.ambiguous")); } else { @@ -336,21 +335,21 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection { } } else if (element instanceof PsiMethod && ((PsiMethod)element).isConstructor()){ - checkLiteralConstructorApplicability(result, listOrMap); + checkLiteralConstructorApplicability(result, listOrMap, true); } } else { for (GroovyResolveResult result : results) { PsiElement resolved = result.getElement(); if (resolved instanceof PsiMethod) { - if (!checkLiteralConstructorApplicability(result, listOrMap)) return; + if (!checkLiteralConstructorApplicability(result, listOrMap, false)) return; } registerError(listOrMap, GroovyBundle.message("constructor.call.is.ambiguous")); } } } - private boolean checkLiteralConstructorApplicability(GroovyResolveResult result, GrListOrMap listOrMap) { + private boolean checkLiteralConstructorApplicability(GroovyResolveResult result, GrListOrMap listOrMap, boolean checkUnknownArgs) { final PsiElement element = result.getElement(); LOG.assertTrue(element instanceof PsiMethod && ((PsiMethod)element).isConstructor()); final PsiMethod constructor = (PsiMethod)element; @@ -373,15 +372,23 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection { argumentTypes = new PsiType[]{listOrMap.getType()}; } - if (PsiUtil.isApplicable(argumentTypes, constructor, result.getSubstitutor(), listOrMap, false)) { - return true; + GrClosureSignatureUtil.ApplicabilityResult applicable = + PsiUtil.isApplicableConcrete(argumentTypes, constructor, result.getSubstitutor(), listOrMap, false); + switch (applicable) { + case inapplicable: + highlightInapplicableMethodUsage(result, listOrMap, constructor, argumentTypes); + return false; + case canBeApplicable: + if (checkUnknownArgs) { + highlightUnknownArgs(listOrMap); + } + return !checkUnknownArgs; + default: + return true; } - - highlightInapplicableMethodUsage(result, listOrMap, constructor, argumentTypes); - return false; } - private boolean checkConstructorApplicability(GroovyResolveResult constructorResolveResult, GroovyPsiElement place) { + private boolean checkConstructorApplicability(GroovyResolveResult constructorResolveResult, GroovyPsiElement place, boolean checkUnknownArgs) { final PsiElement element = constructorResolveResult.getElement(); LOG.assertTrue(element instanceof PsiMethod && ((PsiMethod)element).isConstructor()); final PsiMethod constructor = (PsiMethod)element; @@ -392,7 +399,7 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection { if (exprArgs.length == 0 && !PsiUtil.isConstructorHasRequiredParameters(constructor)) return true; } - return checkMethodApplicability(constructorResolveResult, place); + return checkMethodApplicability(constructorResolveResult, place, checkUnknownArgs); } @Override @@ -422,25 +429,22 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection { final PsiType type = referenceExpression.getType(); if (resolved != null) { if (resolved instanceof PsiMethod && !resolveResult.isInvokedOnProperty()) { - if (!checkMethodApplicability(resolveResult, referenceExpression)) return; + if (!checkMethodApplicability(resolveResult, referenceExpression, true)) return; } else { - if (!checkCallApplicability(type, referenceExpression)) return; + if (!checkCallApplicability(type, referenceExpression, true)) return; } - - if (!checkUnknownParams(referenceExpression)) return; } else if (results.length > 0) { for (GroovyResolveResult result : results) { resolved = result.getElement(); if (resolved instanceof PsiMethod && !resolveResult.isInvokedOnProperty()) { - if (!checkMethodApplicability(result, referenceExpression)) return; + if (!checkMethodApplicability(result, referenceExpression, false)) return; } else { - if (!checkCallApplicability(type, referenceExpression)) return; + if (!checkCallApplicability(type, referenceExpression, false)) return; } } - if (!checkUnknownParams(referenceExpression)) return; registerError(getElementToHighlight(referenceExpression, PsiUtil.getArgumentsList(referenceExpression)), GroovyBundle.message("method.call.is.ambiguous")); @@ -448,14 +452,13 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection { } } - private boolean checkUnknownParams(PsiElement place) { + private boolean checkUnknownParams(PsiElement place, PsiElement resolved) { PsiType[] args = PsiUtil.getArgumentTypes(place, true); if (args == null) return true; for (PsiType arg : args) { if (arg == null) { - registerError(getElementToHighlight(place, PsiUtil.getArgumentsList(place)), GroovyBundle.message("cannot.infer.argument.types"), - LocalQuickFix.EMPTY_ARRAY, ProblemHighlightType.WEAK_WARNING); + return false; } } @@ -523,7 +526,7 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection { final GrExpression expression = call.getInvokedExpression(); if (!(expression instanceof GrReferenceExpression)) { //it checks in visitRefExpr(...) final PsiType type = expression.getType(); - checkCallApplicability(type, expression); + checkCallApplicability(type, expression, true); } checkNamedArgumentsType(call); @@ -555,29 +558,36 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection { } - private boolean checkCallApplicability(PsiType type, GroovyPsiElement invokedExpr) { + private boolean checkCallApplicability(PsiType type, GroovyPsiElement invokedExpr, boolean checkUnknownArgs) { PsiType[] argumentTypes = PsiUtil.getArgumentTypes(invokedExpr, true); if (type instanceof GrClosureType) { if (argumentTypes == null) return true; - if (PsiUtil.isApplicable(argumentTypes, (GrClosureType)type, invokedExpr)) return true; - - registerCannotApplyError(invokedExpr, argumentTypes, invokedExpr.getText()); - return false; + GrClosureSignatureUtil.ApplicabilityResult result = PsiUtil.isApplicableConcrete(argumentTypes, (GrClosureType)type, invokedExpr); + switch (result) { + case inapplicable: + registerCannotApplyError(invokedExpr, argumentTypes, invokedExpr.getText()); + return false; + case canBeApplicable: + if (checkUnknownArgs) { + highlightUnknownArgs(invokedExpr); + } + return !checkUnknownArgs; + default: + return true; + } } else if (type != null) { final GroovyResolveResult[] calls = ResolveUtil.getMethodCandidates(type, "call", invokedExpr, argumentTypes); for (GroovyResolveResult result : calls) { PsiElement resolved = result.getElement(); if (resolved instanceof PsiMethod && !result.isInvokedOnProperty()) { - if (!checkMethodApplicability(result, invokedExpr)) return false; - if (!checkUnknownParams(invokedExpr)) return false; + if (!checkMethodApplicability(result, invokedExpr, checkUnknownArgs && calls.length == 1)) return false; } else if (resolved instanceof PsiField) { - if (!checkCallApplicability(((PsiField)resolved).getType(), invokedExpr)) return false; + if (!checkCallApplicability(((PsiField)resolved).getType(), invokedExpr, checkUnknownArgs && calls.length == 1)) return false; } - if (!checkUnknownParams(invokedExpr)) return false; } if (calls.length == 0 && !(invokedExpr instanceof GrString)) { registerCannotApplyError(invokedExpr, argumentTypes, invokedExpr.getText()); @@ -609,7 +619,7 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection { return builder.toString(); } - private boolean checkMethodApplicability(GroovyResolveResult methodResolveResult, GroovyPsiElement place) { + private boolean checkMethodApplicability(GroovyResolveResult methodResolveResult, GroovyPsiElement place, boolean checkUnknownArgs) { final PsiElement element = methodResolveResult.getElement(); if (!(element instanceof PsiMethod)) return true; if (element instanceof GrBuilderMethod) return true; @@ -621,39 +631,61 @@ public class GroovyAssignabilityCheckInspection extends BaseInspection { if (qualifierExpression != null) { final PsiType type = qualifierExpression.getType(); if (type instanceof GrClosureType) { - if (!PsiUtil.isApplicable(argumentTypes, (GrClosureType)type, place)) { - highlightInapplicableMethodUsage(methodResolveResult, place, method, argumentTypes); - return false; + GrClosureSignatureUtil.ApplicabilityResult result = PsiUtil.isApplicableConcrete(argumentTypes, (GrClosureType)type, place); + switch (result) { + case inapplicable: + highlightInapplicableMethodUsage(methodResolveResult, place, method, argumentTypes); + return false; + case canBeApplicable: + if (checkUnknownArgs) { + highlightUnknownArgs(place); + } + return !checkUnknownArgs; + default: + return true; } } } } - if (argumentTypes != null && - !PsiUtil.isApplicable(argumentTypes, method, methodResolveResult.getSubstitutor(), place, false)) { + if (argumentTypes == null) return true; - //check for implicit use of property getter which returns closure - if (GroovyPropertyUtils.isSimplePropertyGetter(method)) { - if (method instanceof GrMethod || method instanceof GrAccessorMethod) { - final PsiType returnType = PsiUtil.getSmartReturnType(method); - if (returnType instanceof GrClosureType) { - if (PsiUtil.isApplicable(argumentTypes, ((GrClosureType)returnType), place)) { + GrClosureSignatureUtil.ApplicabilityResult applicable = PsiUtil.isApplicableConcrete(argumentTypes, method, methodResolveResult.getSubstitutor(), place, false); + switch (applicable) { + case inapplicable: + //check for implicit use of property getter which returns closure + if (GroovyPropertyUtils.isSimplePropertyGetter(method)) { + if (method instanceof GrMethod || method instanceof GrAccessorMethod) { + final PsiType returnType = PsiUtil.getSmartReturnType(method); + if (returnType instanceof GrClosureType) { + if (PsiUtil.isApplicable(argumentTypes, ((GrClosureType)returnType), place)) { + return true; + } + } + } + + PsiType returnType = method.getReturnType(); + if (returnType != null) { + if (TypesUtil.isAssignable(TypesUtil.createType(GroovyCommonClassNames.GROOVY_LANG_CLOSURE, element), returnType, place)) { return true; } } } - PsiType returnType = method.getReturnType(); - if (returnType != null) { - if (TypesUtil.isAssignable(TypesUtil.createType(GroovyCommonClassNames.GROOVY_LANG_CLOSURE, element), returnType, place)) { - return true; - } + highlightInapplicableMethodUsage(methodResolveResult, place, method, argumentTypes); + return false; + case canBeApplicable: + if (checkUnknownArgs) { + highlightUnknownArgs(place); } - } - - highlightInapplicableMethodUsage(methodResolveResult, place, method, argumentTypes); - return false; + return !checkUnknownArgs; + default: + return true; } - return true; + } + + private void highlightUnknownArgs(GroovyPsiElement place) { + registerError(getElementToHighlight(place, PsiUtil.getArgumentsList(place)), GroovyBundle.message("cannot.infer.argument.types"), + LocalQuickFix.EMPTY_ARRAY, ProblemHighlightType.WEAK_WARNING); } } diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/types/GrClosureSignatureUtil.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/types/GrClosureSignatureUtil.java index 1ab1ea08ceae..6ac06fe349e9 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/types/GrClosureSignatureUtil.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/types/GrClosureSignatureUtil.java @@ -167,26 +167,56 @@ public class GrClosureSignatureUtil { return new GrClosureSignatureImpl(parameters, returnType); } - public static boolean isSignatureApplicable(GrClosureSignature signature, PsiType[] args, GroovyPsiElement context) { - if (mapArgTypesToParameters(signature, args, context, false) != null) return true; + public static boolean isSignatureApplicable(@NotNull GrClosureSignature signature, @NotNull PsiType[] args, @NotNull GroovyPsiElement context) { + return isSignatureApplicableConcrete(signature, args, context) != ApplicabilityResult.inapplicable; + } + + public static ApplicabilityResult isSignatureApplicableConcrete(@NotNull GrClosureSignature signature, @NotNull PsiType[] args, @NotNull GroovyPsiElement context) { + ArgInfo[] map = mapArgTypesToParameters(signature, args, context, false); + if (map != null) return isSignatureApplicableInner(map, signature); // check for the case foo([1, 2, 3]) if foo(int, int, int) if (args.length == 1 && PsiUtil.isInMethodCallContext(context)) { final GrClosureParameter[] parameters = signature.getParameters(); - if (parameters.length == 1 && parameters[0].getType() instanceof PsiArrayType) return false; + if (parameters.length == 1 && parameters[0].getType() instanceof PsiArrayType) return ApplicabilityResult.inapplicable; PsiType arg = args[0]; if (arg instanceof GrTupleType) { args = ((GrTupleType)arg).getComponentTypes(); - if (mapArgTypesToParameters(signature, args, context, false) != null) return true; + map = mapArgTypesToParameters(signature, args, context, false); + if (map != null) return isSignatureApplicableInner(map, signature); } } - return false; + return ApplicabilityResult.inapplicable; + } + + private static ApplicabilityResult isSignatureApplicableInner(@NotNull ArgInfo[] infos, @NotNull GrClosureSignature signature) { + GrClosureParameter[] parameters = signature.getParameters(); + for (int i = 0; i < infos.length; i++) { + ArgInfo info = infos[i]; + if (info.args.size() != 1 || info.isMultiArg) continue; + PsiType type = info.args.get(0); + if (type != null) continue; + + PsiType pType = parameters[i].getType(); + if (pType != null && !pType.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) { + return ApplicabilityResult.canBeApplicable; + } + } + return ApplicabilityResult.applicable; + } + + public enum ApplicabilityResult { + applicable, inapplicable, canBeApplicable; + + public static boolean isApplicable(ApplicabilityResult r) { + return r != inapplicable; + } } @Nullable public static ArgInfo[] mapArgTypesToParameters(@NotNull GrClosureSignature signature, - PsiType[] args, - GroovyPsiElement context, + @NotNull PsiType[] args, + @NotNull GroovyPsiElement context, boolean partial) { return mapParametersToArguments(signature, args, FunctionUtil.id(), context, partial); } @@ -211,9 +241,9 @@ public class GrClosureSignatureUtil { } @Nullable - private static ArgWrapper[] getActualArgs(GrCurriedClosureSignature signature, - Arg[] args, - Function typeComputer) { + private static ArgWrapper[] getActualArgs(@NotNull GrCurriedClosureSignature signature, + @NotNull Arg[] args, + @NotNull Function typeComputer) { List> actual = new ArrayList>(signature.getParameterCount()); for (Arg arg : args) { actual.add(new ArgWrapper(typeComputer.fun(arg), arg)); @@ -243,8 +273,8 @@ public class GrClosureSignatureUtil { @Nullable private static ArgInfo[] mapParametersToArguments(@NotNull GrClosureSignature signature, - Arg[] args, - Function typeComputer, + @NotNull Arg[] args, + @NotNull Function typeComputer, @NotNull GroovyPsiElement context, boolean partial) { if (signature instanceof GrCurriedClosureSignature) { @@ -291,10 +321,10 @@ public class GrClosureSignatureUtil { } @Nullable - private static ArgInfo[] mapSimple(GrClosureParameter[] params, - Arg[] args, - Function typeComputer, - GroovyPsiElement context) { + private static ArgInfo[] mapSimple(@NotNull GrClosureParameter[] params, + @NotNull Arg[] args, + @NotNull Function typeComputer, + @NotNull GroovyPsiElement context) { ArgInfo[] map = new ArgInfo[params.length]; int optional = getOptionalParamCount(params, false); int notOptional = params.length - optional; @@ -315,7 +345,7 @@ public class GrClosureSignatureUtil { return map; } - private static boolean isAssignableByConversion(PsiType paramType, PsiType argType, GroovyPsiElement context) { + private static boolean isAssignableByConversion(@Nullable PsiType paramType, @Nullable PsiType argType, @NotNull GroovyPsiElement context) { if (argType == null) { return true; } diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/PsiUtil.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/PsiUtil.java index 6583beb4d0fe..d4d57f22a461 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/PsiUtil.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/util/PsiUtil.java @@ -135,11 +135,20 @@ public class PsiUtil { } public static boolean isApplicable(@Nullable PsiType[] argumentTypes, - PsiMethod method, - PsiSubstitutor substitutor, - GroovyPsiElement place, - final boolean eraseParameterTypes) { - if (argumentTypes == null) return true; + PsiMethod method, + PsiSubstitutor substitutor, + GroovyPsiElement place, + final boolean eraseParameterTypes) { + return isApplicableConcrete(argumentTypes, method, substitutor, place, eraseParameterTypes) != + GrClosureSignatureUtil.ApplicabilityResult.inapplicable; + } + + public static GrClosureSignatureUtil.ApplicabilityResult isApplicableConcrete(@Nullable PsiType[] argumentTypes, + PsiMethod method, + PsiSubstitutor substitutor, + GroovyPsiElement place, + final boolean eraseParameterTypes) { + if (argumentTypes == null) return GrClosureSignatureUtil.ApplicabilityResult.canBeApplicable; GrClosureSignature signature = eraseParameterTypes ? GrClosureSignatureUtil.createSignatureWithErasedParameterTypes(method) @@ -149,34 +158,45 @@ public class PsiUtil { if (method.isConstructor()) { final PsiParameter[] parameters = method.getParameterList().getParameters(); if (parameters.length == 0 && argumentTypes.length == 1) { - return InheritanceUtil.isInheritor(argumentTypes[0], CommonClassNames.JAVA_UTIL_MAP); + return InheritanceUtil.isInheritor(argumentTypes[0], CommonClassNames.JAVA_UTIL_MAP) + ? GrClosureSignatureUtil.ApplicabilityResult.applicable + : GrClosureSignatureUtil.ApplicabilityResult.inapplicable; } if (parameters.length == 1 && argumentTypes.length == 0 && InheritanceUtil.isInheritor(parameters[0].getType(), CommonClassNames.JAVA_UTIL_MAP)) { - return false; + return GrClosureSignatureUtil.ApplicabilityResult.inapplicable; } } LOG.assertTrue(signature != null); - if (GrClosureSignatureUtil.isSignatureApplicable(signature, argumentTypes, place)) { - return true; + GrClosureSignatureUtil.ApplicabilityResult result = GrClosureSignatureUtil.isSignatureApplicableConcrete(signature, argumentTypes, place); + if (result != GrClosureSignatureUtil.ApplicabilityResult.inapplicable) { + return result; } if (method instanceof GrBuilderMethod &&!((GrBuilderMethod)method).hasObligatoryNamedArguments()) { final PsiParameter[] parameters = method.getParameterList().getParameters(); if (parameters.length > 0 && parameters[0].getType() instanceof GrMapType && (argumentTypes.length == 0 || !(argumentTypes[0] instanceof GrMapType))) { - return GrClosureSignatureUtil.isSignatureApplicable(GrClosureSignatureUtil.removeParam(signature, 0), argumentTypes, place); + return GrClosureSignatureUtil.isSignatureApplicableConcrete(GrClosureSignatureUtil.removeParam(signature, 0), argumentTypes, place); } } - return false; + return GrClosureSignatureUtil.ApplicabilityResult.inapplicable; } - public static boolean isApplicable(@Nullable PsiType[] argumentTypes, GrClosureType type, GroovyPsiElement context) { - if (argumentTypes == null) return true; + public static boolean isApplicable(@Nullable PsiType[] argumentTypes, + GrClosureType type, + GroovyPsiElement context) { + return isApplicableConcrete(argumentTypes, type, context) != GrClosureSignatureUtil.ApplicabilityResult.inapplicable; + } + + public static GrClosureSignatureUtil.ApplicabilityResult isApplicableConcrete(@Nullable PsiType[] argumentTypes, + GrClosureType type, + GroovyPsiElement context) { + if (argumentTypes == null) return GrClosureSignatureUtil.ApplicabilityResult.canBeApplicable; GrClosureSignature signature = type.getSignature(); - return GrClosureSignatureUtil.isSignatureApplicable(signature, argumentTypes, context); + return GrClosureSignatureUtil.isSignatureApplicableConcrete(signature, argumentTypes, context); } @Nullable diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/GroovyHighlightingTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/GroovyHighlightingTest.groovy index 076050f6afc5..d8fcb4f734ae 100644 --- a/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/GroovyHighlightingTest.groovy +++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/lang/GroovyHighlightingTest.groovy @@ -788,4 +788,19 @@ class C { myFixture.testHighlighting(true, false, false) } + public void testNonInferrableArgsOfDefParams() { + myFixture.configureByText('_.groovy', '''\ +def foo0(def a) { } +def bar0(def b) { foo0(b) } + +def foo1(Object a) { } +def bar1(def b) { foo1(b) } + +def foo2(String a) { } +def bar2(def b) { foo2(b) } +''') + myFixture.enableInspections(new GroovyAssignabilityCheckInspection()) + myFixture.testHighlighting(true, false, true) + } + } \ No newline at end of file diff --git a/plugins/groovy/testdata/highlighting/UnknownVarInArgList.groovy b/plugins/groovy/testdata/highlighting/UnknownVarInArgList.groovy index 028b03609637..8a069fa6cbe9 100644 --- a/plugins/groovy/testdata/highlighting/UnknownVarInArgList.groovy +++ b/plugins/groovy/testdata/highlighting/UnknownVarInArgList.groovy @@ -10,4 +10,4 @@ def abc(Date d){} def abc(int i) {} def x = unknown2 -abc(x) \ No newline at end of file +abc(x) \ No newline at end of file