boolean (@NotNull JavaSliceBuilder builder, @NotNull Processor<? super SliceUsage> processor, PsiType actualParameterType, PsiParameter[] actualParameters, int paramSeqNo, PsiElement refElement) { PsiExpressionList argumentList; JavaResolveResult result; if (refElement instanceof PsiCall) { // the case of enum constant decl PsiCall call = (PsiCall)refElement; argumentList = call.getArgumentList(); result = call.resolveMethodGenerics(); } else { PsiElement element = refElement.getParent(); if (element instanceof PsiCompiledElement) return true; if (element instanceof PsiAnonymousClass anon) { argumentList = anon.getArgumentList(); PsiElement callExp = element.getParent(); if (!(callExp instanceof PsiCallExpression)) return true; result = ((PsiCall)callExp).resolveMethodGenerics(); } else if (element instanceof PsiCall call) { argumentList = call.getArgumentList(); result = call.resolveMethodGenerics(); } else { return processIfInForeignLanguage(builder, processor, refElement); } } PsiSubstitutor substitutor = result.getSubstitutor(); PsiExpression[] expressions = argumentList.getExpressions(); if (paramSeqNo >= expressions.length) { return true; } PsiElement passExpression; PsiType actualExpressionType; if (actualParameterType instanceof PsiEllipsisType) { passExpression = argumentList; actualExpressionType = expressions[paramSeqNo].getType(); } else { passExpression = expressions[paramSeqNo]; actualExpressionType = ((PsiExpression)passExpression).getType(); } Project project = argumentList.getProject(); PsiElement element = result.getElement(); if (element instanceof PsiCompiledElement) { element = element.getNavigationElement(); } // for erased method calls for which we cannot determine target substitutor, // rely on call argument types. I.e. new Pair(1,2) -> Pair<Integer, Integer> if (element instanceof PsiTypeParameterListOwner && PsiUtil.isRawSubstitutor((PsiTypeParameterListOwner)element, substitutor)) { PsiTypeParameter[] typeParameters = substitutor.getSubstitutionMap().keySet().toArray(PsiTypeParameter.EMPTY_ARRAY); PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(project).getResolveHelper(); substitutor = resolveHelper.inferTypeArguments(typeParameters, actualParameters, expressions, builder.getSubstitutor(), argumentList, DefaultParameterTypeInferencePolicy.INSTANCE); } substitutor = removeRawMappingsLeftFromResolve(substitutor); builder = builder.combineSubstitutor(substitutor, project); if (builder == null) return true; PsiType substituted = builder.substitute(actualExpressionType); if (substituted instanceof PsiPrimitiveType) { final PsiClassType boxedType = ((PsiPrimitiveType)substituted).getBoxedType(argumentList); substituted = boxedType != null ? boxedType : substituted; } if (substituted == null) return true; PsiType typeToCheck; if (actualParameterType instanceof PsiEllipsisType) { // there may be the case of passing the vararg argument to the other vararg method: foo(int... ints) { bar(ints); } bar(int... ints) {} if (TypeConversionUtil.areTypesConvertible(substituted, actualParameterType)) { return builder.process(expressions[paramSeqNo], processor); } typeToCheck = ((PsiEllipsisType)actualParameterType).getComponentType(); } else { typeToCheck = actualParameterType; } if (!TypeConversionUtil.areTypesConvertible(substituted, typeToCheck)) return true; return builder.process(passExpression, processor); }