Package com.intellij.psi

Class LambdaUtil

java.lang.Object

com.intellij.psi.LambdaUtil

public class LambdaUtil
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description
LambdaUtil()

Method Summary

Modifier and Type	Method and Description
static java.util.Map<PsiElement,java.lang.String>	checkReturnTypeCompatible(PsiLambdaExpression lambdaExpression, PsiType functionalInterfaceReturnType)
static PsiCall	copyTopLevelCall(PsiCall call)
static PsiElement	copyWithExpectedType(PsiElement expression, PsiType type)
static java.lang.String	createLambda(PsiVariable variable, PsiExpression expression) Generate lambda text for single argument expression lambda
static java.lang.String	createLambdaParameterListWithFormalTypes(PsiType functionalInterfaceType, PsiLambdaExpression lambdaExpression, boolean checkApplicability)
static PsiExpression	extractSingleExpressionFromBody(PsiElement body)
static java.util.List<HierarchicalMethodSignature>	findFunctionCandidates(PsiClass psiClass)
static MethodSignature	getFunction(PsiClass psiClass)
static PsiMethod	getFunctionalInterfaceMethod(PsiClass aClass)
static PsiMethod	getFunctionalInterfaceMethod(PsiClassType.ClassResolveResult result)
static PsiMethod	getFunctionalInterfaceMethod(PsiElement element)
static PsiMethod	getFunctionalInterfaceMethod(PsiType functionalInterfaceType)
static PsiType	getFunctionalInterfaceReturnType(PsiFunctionalExpression expr)
static PsiType	getFunctionalInterfaceReturnType(PsiType functionalInterfaceType)
static PsiType	getFunctionalInterfaceType(PsiElement expression, boolean tryToSubstitute)
static int	getLambdaIdx(PsiExpressionList expressionList, PsiElement element)
static PsiType	getLambdaParameterFromType(PsiType functionalInterfaceType, int parameterIndex)
static java.util.List<PsiExpression>	getReturnExpressions(PsiLambdaExpression lambdaExpression)
static PsiReturnStatement []	getReturnStatements(PsiLambdaExpression lambdaExpression)
static PsiSubstitutor	getSubstitutor(PsiMethod method, PsiClassType.ClassResolveResult resolveResult)
static boolean	isCapturingLambda(PsiLambdaExpression lambda) Returns true if given lambda captures any variable or "this" reference.
static boolean	isExpressionStatementExpression(PsiElement body)
static boolean	isFunctionalClass(PsiClass aClass)
static boolean	isFunctionalType(PsiType type)
static boolean	isIdentityLambda(PsiLambdaExpression lambda) Returns true if lambda has single parameter and its return value is the same as parameter.
static boolean	isPotentiallyCompatibleWithTypeParameter(PsiFunctionalExpression expression, PsiExpressionList argsList, PsiMethod method)
static boolean	isSafeLambdaBodyReplacement(PsiLambdaExpression lambda, java.util.function.Supplier<? extends PsiElement> newBodySupplier) Returns false if after suggested replacement of lambda body, containing method call would resolve to something else or its return type will change.
static boolean	isSafeLambdaReplacement(PsiLambdaExpression lambda, java.lang.String replacementText) Returns false if after suggested replacement of lambda body, containing method call would resolve to something else or its return type will change.
static boolean	isSafeLambdaReplacement(PsiLambdaExpression lambda, java.util.function.Supplier<? extends PsiExpression> newFunctionSupplier) Returns false if after suggested replacement of lambda body, containing method call would resolve to something else or its return type will change.
static boolean	isSafeLambdaReturnValueReplacement(PsiExpression lambdaReturnExpression, PsiExpression replacement) isSafeLambdaBodyReplacement(PsiLambdaExpression, Supplier) overload to test the same lambda body, but with only return value expression changed to replacement
static boolean	isValidLambdaContext(PsiElement context)
static boolean	notInferredType(PsiType typeByExpression)
static <T> T	performWithSubstitutedParameterBounds(PsiTypeParameter[] typeParameters, PsiSubstitutor substitutor, java.util.function.Supplier<? extends T> producer)
static <T> T	performWithTargetType(PsiElement element, PsiType targetType, java.util.function.Supplier<? extends T> producer)
static boolean	processParentOverloads(PsiFunctionalExpression functionalExpression, Consumer<? super PsiType> overloadProcessor)
static PsiClass	resolveFunctionalInterfaceClass(PsiFunctionalExpression expression) Resolves a functional interface class for given functional expression
static PsiParameterList	specifyLambdaParameterTypes(PsiLambdaExpression lambdaExpression)
static PsiParameterList	specifyLambdaParameterTypes(PsiType functionalInterfaceType, PsiLambdaExpression lambdaExpression)
static PsiCall	treeWalkUp(PsiElement context)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

LambdaUtil

public LambdaUtil()

Method Detail

getFunctionalInterfaceReturnType

public static PsiType getFunctionalInterfaceReturnType(PsiFunctionalExpression expr)

getFunctionalInterfaceReturnType

public static PsiType getFunctionalInterfaceReturnType(PsiType functionalInterfaceType)

getFunctionalInterfaceMethod

public static PsiMethod getFunctionalInterfaceMethod(PsiType functionalInterfaceType)

getFunctionalInterfaceMethod

public static PsiMethod getFunctionalInterfaceMethod(PsiElement element)

getFunctionalInterfaceMethod

public static PsiMethod getFunctionalInterfaceMethod(PsiClassType.ClassResolveResult result)

getFunctionalInterfaceMethod

public static PsiMethod getFunctionalInterfaceMethod(PsiClass aClass)

getSubstitutor

public static PsiSubstitutor getSubstitutor(PsiMethod method,
                                            PsiClassType.ClassResolveResult resolveResult)

isFunctionalType

public static boolean isFunctionalType(PsiType type)

isFunctionalClass

public static boolean isFunctionalClass(PsiClass aClass)

isValidLambdaContext

public static boolean isValidLambdaContext(PsiElement context)

getFunction

public static MethodSignature getFunction(PsiClass psiClass)

findFunctionCandidates

public static java.util.List<HierarchicalMethodSignature> findFunctionCandidates(PsiClass psiClass)

getLambdaIdx

public static int getLambdaIdx(PsiExpressionList expressionList,
                               PsiElement element)

getFunctionalInterfaceType

public static PsiType getFunctionalInterfaceType(PsiElement expression,
                                                 boolean tryToSubstitute)

processParentOverloads

public static boolean processParentOverloads(PsiFunctionalExpression functionalExpression,
                                             Consumer<? super PsiType> overloadProcessor)

notInferredType

public static boolean notInferredType(PsiType typeByExpression)

getReturnStatements

public static PsiReturnStatement [] getReturnStatements(PsiLambdaExpression lambdaExpression)

getReturnExpressions

public static java.util.List<PsiExpression> getReturnExpressions(PsiLambdaExpression lambdaExpression)

isExpressionStatementExpression

public static boolean isExpressionStatementExpression(PsiElement body)

extractSingleExpressionFromBody

public static PsiExpression extractSingleExpressionFromBody(PsiElement body)

isPotentiallyCompatibleWithTypeParameter

public static boolean isPotentiallyCompatibleWithTypeParameter(PsiFunctionalExpression expression,
                                                               PsiExpressionList argsList,
                                                               PsiMethod method)

checkReturnTypeCompatible

public static java.util.Map<PsiElement,java.lang.String> checkReturnTypeCompatible(PsiLambdaExpression lambdaExpression,
                                                                                   PsiType functionalInterfaceReturnType)

getLambdaParameterFromType

public static PsiType getLambdaParameterFromType(PsiType functionalInterfaceType,
                                                 int parameterIndex)

treeWalkUp

public static PsiCall treeWalkUp(PsiElement context)

copyTopLevelCall

public static PsiCall copyTopLevelCall(PsiCall call)

performWithSubstitutedParameterBounds

public static <T> T performWithSubstitutedParameterBounds(PsiTypeParameter[] typeParameters,
                                                          PsiSubstitutor substitutor,
                                                          java.util.function.Supplier<? extends T> producer)

performWithTargetType

public static <T> T performWithTargetType(PsiElement element,
                                          PsiType targetType,
                                          java.util.function.Supplier<? extends T> producer)

createLambda

public static java.lang.String createLambda(PsiVariable variable,
                                            PsiExpression expression)

Generate lambda text for single argument expression lambda

Parameters:

variable - lambda sole argument

expression - lambda body (expression)

Returns:

lambda text

isIdentityLambda

public static boolean isIdentityLambda(PsiLambdaExpression lambda)

Returns true if lambda has single parameter and its return value is the same as parameter.

The lambdas like this are considered identity lambda: x -> x, x -> {return x;} (String x) -> (x), etc.

This method does not check the lambda type, also it does not check whether auto-(un)boxing occurs, so a lambda like ((Predicate<Boolean>)b -> b) is also identity lambda even though it performs auto-unboxing.

Parameters:

lambda - a lambda to check

Returns:

true if the supplied lambda is an identity lambda

isSafeLambdaReplacement

public static boolean isSafeLambdaReplacement(PsiLambdaExpression lambda,
                                              java.util.function.Supplier<? extends PsiExpression> newFunctionSupplier)

Returns false if after suggested replacement of lambda body, containing method call would resolve to something else or its return type will change.

Parameters:

lambda - a lambda whose body is going to be replaced

newFunctionSupplier - replacement for lambda to check, lazy computed for lambdas in invocation context only. Replacement evaluated to null is treated as invalid overload

isSafeLambdaReplacement

public static boolean isSafeLambdaReplacement(PsiLambdaExpression lambda,
                                              java.lang.String replacementText)

Returns false if after suggested replacement of lambda body, containing method call would resolve to something else or its return type will change.

Parameters:

lambda - a lambda whose body is going to be replaced

replacementText - a text of new expression to replace lambda

isSafeLambdaBodyReplacement

public static boolean isSafeLambdaBodyReplacement(PsiLambdaExpression lambda,
                                                  java.util.function.Supplier<? extends PsiElement> newBodySupplier)

Returns false if after suggested replacement of lambda body, containing method call would resolve to something else or its return type will change.

True will be returned for lambdas in non-invocation context as well as for lambdas in invocation context, when invoked method is not overloaded or all overloads are 'lambda friendly'

Value-compatible lambda like () -> foo() == true can be converted to value-compatible AND void-compatible () -> foo() during simplification. This could lead to ambiguity during containing method call resolution and thus to the errors after applying the suggestion.

Parameters:

lambda - a lambda whose body is going to be replaced

newBodySupplier - replacement for lambda's body to check, lazy computed for lambdas in invocation context only. Replacement evaluated to null is treated as invalid overload

isSafeLambdaReturnValueReplacement

public static boolean isSafeLambdaReturnValueReplacement(PsiExpression lambdaReturnExpression,
                                                         PsiExpression replacement)

isSafeLambdaBodyReplacement(PsiLambdaExpression, Supplier) overload to test the same lambda body, but with only return value expression changed to replacement

Parameters:

lambdaReturnExpression - a return expression inside lambda body

replacement - a replacement for return expression

copyWithExpectedType

public static PsiElement copyWithExpectedType(PsiElement expression,
                                              PsiType type)

isCapturingLambda

public static boolean isCapturingLambda(PsiLambdaExpression lambda)

Returns true if given lambda captures any variable or "this" reference.

Parameters:

lambda - lambda to check

Returns:

true if given lambda captures any variable or "this" reference.

resolveFunctionalInterfaceClass

public static PsiClass resolveFunctionalInterfaceClass(PsiFunctionalExpression expression)

Resolves a functional interface class for given functional expression

Parameters:

expression - functional expression

Returns:

resolved class or null if cannot be resolved

createLambdaParameterListWithFormalTypes

public static java.lang.String createLambdaParameterListWithFormalTypes(PsiType functionalInterfaceType,
                                                                        PsiLambdaExpression lambdaExpression,
                                                                        boolean checkApplicability)

specifyLambdaParameterTypes

public static PsiParameterList specifyLambdaParameterTypes(PsiLambdaExpression lambdaExpression)

specifyLambdaParameterTypes

public static PsiParameterList specifyLambdaParameterTypes(PsiType functionalInterfaceType,
                                                           PsiLambdaExpression lambdaExpression)