org.jetbrains.kotlin.resolve.calls
Class ArgumentTypeResolver

java.lang.Object
  org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver

public class ArgumentTypeResolver
extends java.lang.Object

Constructor Summary

ArgumentTypeResolver(TypeResolver typeResolver, CallResolver callResolver, ExpressionTypingServices expressionTypingServices, KotlinBuiltIns builtIns, ReflectionTypes reflectionTypes, ConstantExpressionEvaluator constantExpressionEvaluator)

Method Summary

void	analyzeArgumentsAndRecordTypes(CallResolutionContext<?> context) Visits function call arguments and determines data flow information changes
void	checkTypesForFunctionArgumentsWithNoCallee(CallResolutionContext<?> context)
void	checkTypesWithNoCallee(CallResolutionContext<?> context)
void	checkTypesWithNoCallee(CallResolutionContext<?> context, ResolveArgumentsMode resolveFunctionArgumentBodies)
JetTypeInfo	getArgumentTypeInfo(JetExpression expression, CallResolutionContext<?> context, ResolveArgumentsMode resolveArgumentsMode)
static JetCallableReferenceExpression	getCallableReferenceExpressionIfAny(JetExpression expression, CallResolutionContext<?> context)
JetTypeInfo	getCallableReferenceTypeInfo(JetExpression expression, JetCallableReferenceExpression callableReferenceExpression, CallResolutionContext<?> context, ResolveArgumentsMode resolveArgumentsMode)
static JetFunction	getFunctionLiteralArgument(JetExpression expression, ResolutionContext context)
static JetFunction	getFunctionLiteralArgumentIfAny(JetExpression expression, ResolutionContext context)
JetTypeInfo	getFunctionLiteralTypeInfo(JetExpression expression, JetFunction functionLiteral, CallResolutionContext<?> context, ResolveArgumentsMode resolveArgumentsMode)
JetType	getShapeTypeOfCallableReference(JetCallableReferenceExpression callableReferenceExpression, CallResolutionContext<?> context, boolean expectedTypeIsUnknown)
JetType	getShapeTypeOfFunctionLiteral(JetFunction function, LexicalScope scope, BindingTrace trace, boolean expectedTypeIsUnknown)
static boolean	isFunctionLiteralArgument(JetExpression expression, ResolutionContext context)
static boolean	isSubtypeOfForArgumentType(JetType actualType, JetType expectedType)
JetType	resolveTypeRefWithDefault(JetTypeReference returnTypeRef, LexicalScope scope, BindingTrace trace, JetType defaultValue)
JetType	updateResultArgumentTypeIfNotDenotable(ResolutionContext context, JetExpression expression)

Methods inherited from class java.lang.Object

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

Constructor Detail

ArgumentTypeResolver

public ArgumentTypeResolver(@NotNull
                            TypeResolver typeResolver,
                            @NotNull
                            CallResolver callResolver,
                            @NotNull
                            ExpressionTypingServices expressionTypingServices,
                            @NotNull
                            KotlinBuiltIns builtIns,
                            @NotNull
                            ReflectionTypes reflectionTypes,
                            @NotNull
                            ConstantExpressionEvaluator constantExpressionEvaluator)

Method Detail

isSubtypeOfForArgumentType

public static boolean isSubtypeOfForArgumentType(@NotNull
                                                 JetType actualType,
                                                 @NotNull
                                                 JetType expectedType)

checkTypesWithNoCallee

public void checkTypesWithNoCallee(@NotNull
                                   CallResolutionContext<?> context)

checkTypesWithNoCallee

public void checkTypesWithNoCallee(@NotNull
                                   CallResolutionContext<?> context,
                                   @NotNull
                                   ResolveArgumentsMode resolveFunctionArgumentBodies)

checkTypesForFunctionArgumentsWithNoCallee

public void checkTypesForFunctionArgumentsWithNoCallee(@NotNull
                                                       CallResolutionContext<?> context)

isFunctionLiteralArgument

public static boolean isFunctionLiteralArgument(@NotNull
                                                JetExpression expression,
                                                @NotNull
                                                ResolutionContext context)

getFunctionLiteralArgument

@NotNull
public static JetFunction getFunctionLiteralArgument(@NotNull
                                                             JetExpression expression,
                                                             @NotNull
                                                             ResolutionContext context)

getFunctionLiteralArgumentIfAny

@Nullable
public static JetFunction getFunctionLiteralArgumentIfAny(@NotNull
                                                                   JetExpression expression,
                                                                   @NotNull
                                                                   ResolutionContext context)

getCallableReferenceExpressionIfAny

@Nullable
public static JetCallableReferenceExpression getCallableReferenceExpressionIfAny(@NotNull
                                                                                          JetExpression expression,
                                                                                          @NotNull
                                                                                          CallResolutionContext<?> context)

getArgumentTypeInfo

@NotNull
public JetTypeInfo getArgumentTypeInfo(@Nullable
                                               JetExpression expression,
                                               @NotNull
                                               CallResolutionContext<?> context,
                                               @NotNull
                                               ResolveArgumentsMode resolveArgumentsMode)

getCallableReferenceTypeInfo

@NotNull
public JetTypeInfo getCallableReferenceTypeInfo(@NotNull
                                                        JetExpression expression,
                                                        @NotNull
                                                        JetCallableReferenceExpression callableReferenceExpression,
                                                        @NotNull
                                                        CallResolutionContext<?> context,
                                                        @NotNull
                                                        ResolveArgumentsMode resolveArgumentsMode)

getShapeTypeOfCallableReference

@Nullable
public JetType getShapeTypeOfCallableReference(@NotNull
                                                        JetCallableReferenceExpression callableReferenceExpression,
                                                        @NotNull
                                                        CallResolutionContext<?> context,
                                                        boolean expectedTypeIsUnknown)

getFunctionLiteralTypeInfo

@NotNull
public JetTypeInfo getFunctionLiteralTypeInfo(@NotNull
                                                      JetExpression expression,
                                                      @NotNull
                                                      JetFunction functionLiteral,
                                                      @NotNull
                                                      CallResolutionContext<?> context,
                                                      @NotNull
                                                      ResolveArgumentsMode resolveArgumentsMode)

getShapeTypeOfFunctionLiteral

@Nullable
public JetType getShapeTypeOfFunctionLiteral(@NotNull
                                                      JetFunction function,
                                                      @NotNull
                                                      LexicalScope scope,
                                                      @NotNull
                                                      BindingTrace trace,
                                                      boolean expectedTypeIsUnknown)

resolveTypeRefWithDefault

@Nullable
public JetType resolveTypeRefWithDefault(@Nullable
                                                  JetTypeReference returnTypeRef,
                                                  @NotNull
                                                  LexicalScope scope,
                                                  @NotNull
                                                  BindingTrace trace,
                                                  @Nullable
                                                  JetType defaultValue)

analyzeArgumentsAndRecordTypes

public void analyzeArgumentsAndRecordTypes(@NotNull
                                           CallResolutionContext<?> context)

Visits function call arguments and determines data flow information changes

updateResultArgumentTypeIfNotDenotable

@Nullable
public JetType updateResultArgumentTypeIfNotDenotable(@NotNull
                                                               ResolutionContext context,
                                                               @NotNull
                                                               JetExpression expression)