org.jetbrains.jet.lang.resolve.calls
Class ArgumentTypeResolver

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

public class ArgumentTypeResolver
extends java.lang.Object

Constructor Summary

ArgumentTypeResolver()

Method Summary

<D extends CallableDescriptor> void	analyzeArgumentsAndRecordTypes(CallResolutionContext<?> context)
<D extends CallableDescriptor> void	checkTypesForFunctionArguments(CallResolutionContext<?> context, ResolvedCallImpl<D> resolvedCall)
void	checkTypesForFunctionArgumentsWithNoCallee(CallResolutionContext<?> context)
void	checkTypesWithNoCallee(CallResolutionContext<?> context)
void	checkTypesWithNoCallee(CallResolutionContext<?> context, CallResolverUtil.ResolveArgumentsMode resolveFunctionArgumentBodies)
void	checkUnmappedArgumentTypes(CallResolutionContext<?> context, java.util.Set<ValueArgument> unmappedArguments)
JetTypeInfo	getArgumentTypeInfo(JetExpression expression, CallResolutionContext<?> context, CallResolverUtil.ResolveArgumentsMode resolveArgumentsMode)
static JetFunctionLiteralExpression	getFunctionLiteralArgument(JetExpression expression)
JetTypeInfo	getFunctionLiteralTypeInfo(JetExpression expression, JetFunctionLiteralExpression functionLiteralExpression, CallResolutionContext<?> context, CallResolverUtil.ResolveArgumentsMode resolveArgumentsMode)
JetType	getShapeTypeOfFunctionLiteral(JetFunctionLiteralExpression expression, JetScope scope, BindingTrace trace, boolean expectedTypeIsUnknown)
static boolean	isFunctionLiteralArgument(JetExpression expression)
static boolean	isSubtypeOfForArgumentType(JetType actualType, JetType expectedType)
JetType	resolveTypeRefWithDefault(JetTypeReference returnTypeRef, JetScope scope, BindingTrace trace, JetType defaultValue)
void	setExpressionTypingServices(ExpressionTypingServices expressionTypingServices)
void	setTypeResolver(TypeResolver typeResolver)
<D extends CallableDescriptor> 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()

Method Detail

setTypeResolver

@Inject
public void setTypeResolver(@NotNull
                                   TypeResolver typeResolver)

setExpressionTypingServices

@Inject
public void setExpressionTypingServices(@NotNull
                                               ExpressionTypingServices expressionTypingServices)

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
                                   CallResolverUtil.ResolveArgumentsMode resolveFunctionArgumentBodies)

checkTypesForFunctionArgumentsWithNoCallee

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

checkUnmappedArgumentTypes

public void checkUnmappedArgumentTypes(CallResolutionContext<?> context,
                                       java.util.Set<ValueArgument> unmappedArguments)

checkTypesForFunctionArguments

public <D extends CallableDescriptor> void checkTypesForFunctionArguments(CallResolutionContext<?> context,
                                                                          ResolvedCallImpl<D> resolvedCall)

isFunctionLiteralArgument

public static boolean isFunctionLiteralArgument(@NotNull
                                                JetExpression expression)

getFunctionLiteralArgument

@NotNull
public static JetFunctionLiteralExpression getFunctionLiteralArgument(@NotNull
                                                                              JetExpression expression)

getArgumentTypeInfo

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

getFunctionLiteralTypeInfo

@NotNull
public JetTypeInfo getFunctionLiteralTypeInfo(@NotNull
                                                      JetExpression expression,
                                                      @NotNull
                                                      JetFunctionLiteralExpression functionLiteralExpression,
                                                      @NotNull
                                                      CallResolutionContext<?> context,
                                                      @NotNull
                                                      CallResolverUtil.ResolveArgumentsMode resolveArgumentsMode)

getShapeTypeOfFunctionLiteral

@Nullable
public JetType getShapeTypeOfFunctionLiteral(@NotNull
                                                      JetFunctionLiteralExpression expression,
                                                      @NotNull
                                                      JetScope scope,
                                                      @NotNull
                                                      BindingTrace trace,
                                                      boolean expectedTypeIsUnknown)

resolveTypeRefWithDefault

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

analyzeArgumentsAndRecordTypes

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

updateResultArgumentTypeIfNotDenotable

@Nullable
public <D extends CallableDescriptor> JetType updateResultArgumentTypeIfNotDenotable(@NotNull
                                                                                              ResolutionContext context,
                                                                                              @NotNull
                                                                                              JetExpression expression)