org.jetbrains.jet.lang.resolve.calls.model

Class ResolvedCallImpl<D extends CallableDescriptor>

java.lang.Object

org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl<D>

All Implemented Interfaces:

ResolvedCall<D>, ResolvedCallWithTrace<D>

public class ResolvedCallImpl<D extends CallableDescriptor>
extends java.lang.Object
implements ResolvedCallWithTrace<D>

Field Summary

Fields

Modifier and Type	Field and Description
static com.intellij.util.Function<ResolvedCallWithTrace<? extends CallableDescriptor>,CallableDescriptor>	MAP_TO_CANDIDATE
static com.intellij.util.Function<ResolvedCallWithTrace<? extends CallableDescriptor>,CallableDescriptor>	MAP_TO_RESULT

Method Summary

Methods

Modifier and Type	Method and Description
void	addDataFlowInfo(DataFlowInfo info)
void	addStatus(ResolutionStatus status)
void	argumentHasNoType()
static <D extends CallableDescriptor> ResolvedCallImpl<D>	create(ResolutionCandidate<D> candidate, DelegatingBindingTrace trace, TracingStrategy tracing)
ResolvedCallImpl<D>	getCallToCompleteTypeArgumentInference() //todo get rid of Impl class in the interface If the call has incomplete type parameters, it should be completed after resolution process is finished.
D	getCandidateDescriptor() A target callable descriptor as it was accessible in the corresponding scope, i.e.
ConstraintSystem	getConstraintSystem()
DataFlowInfo	getDataFlowInfo()
ExplicitReceiverKind	getExplicitReceiverKind() Determines whether receiver argument or this object is substituted for explicit receiver
ReceiverValue	getReceiverArgument() If the target was an extension function or property, this is the value for its receiver parameter
D	getResultingDescriptor() Type arguments are substituted.
ResolutionStatus	getStatus()
ReceiverValue	getThisObject() If the target was a member of a class, this is the object of that class to call it on
DelegatingBindingTrace	getTrace()
TracingStrategy	getTracing()
java.util.Map<TypeParameterDescriptor,JetType>	getTypeArguments() What's substituted for type parameters
java.util.Set<ValueArgument>	getUnmappedArguments()
java.util.Map<ValueParameterDescriptor,ResolvedValueArgument>	getValueArguments() Values (arguments) for value parameters
java.util.List<ResolvedValueArgument>	getValueArgumentsByIndex() Values (arguments) for value parameters indexed by parameter index
boolean	hasIncompleteTypeParameters() Resolved call can have incomplete type parameters if ResolutionStatus is INCOMPLETE_TYPE_INFERENCE (might be completed successfully) or OTHER_ERROR (cannot be completed successfully, but if there's only one candidate, should be completed anyway).
boolean	isDirty()
boolean	isSafeCall()
void	recordTypeArgument(TypeParameterDescriptor typeParameter, JetType typeArgument)
void	recordValueArgument(ValueParameterDescriptor valueParameter, ResolvedValueArgument valueArgument)
void	setConstraintSystem(ConstraintSystem constraintSystem)
void	setHasUnknownTypeParameters(boolean hasUnknownTypeParameters)
void	setInitialDataFlowInfo(DataFlowInfo info)
void	setResultingSubstitutor(TypeSubstitutor substitutor)
void	setStatusToSuccess()
void	setUnmappedArguments(java.util.Collection<ValueArgument> unmappedArguments)

Methods inherited from class java.lang.Object

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

Field Detail

MAP_TO_CANDIDATE

public static final com.intellij.util.Function<ResolvedCallWithTrace<? extends CallableDescriptor>,CallableDescriptor> MAP_TO_CANDIDATE

MAP_TO_RESULT

public static final com.intellij.util.Function<ResolvedCallWithTrace<? extends CallableDescriptor>,CallableDescriptor> MAP_TO_RESULT

Method Detail

create

@NotNull
public static <D extends CallableDescriptor> ResolvedCallImpl<D> create(@NotNull
                                                                ResolutionCandidate<D> candidate,
                                                                @NotNull
                                                                DelegatingBindingTrace trace,
                                                                @NotNull
                                                                TracingStrategy tracing)

getStatus

@NotNull
public ResolutionStatus getStatus()

Specified by:

getStatus in interface ResolvedCallWithTrace<D extends CallableDescriptor>

addStatus

public void addStatus(@NotNull
             ResolutionStatus status)

setStatusToSuccess

public void setStatusToSuccess()

hasIncompleteTypeParameters

public boolean hasIncompleteTypeParameters()

Description copied from interface: ResolvedCallWithTrace

Resolved call can have incomplete type parameters if ResolutionStatus is INCOMPLETE_TYPE_INFERENCE (might be completed successfully) or OTHER_ERROR (cannot be completed successfully, but if there's only one candidate, should be completed anyway).

Specified by:

hasIncompleteTypeParameters in interface ResolvedCallWithTrace<D extends CallableDescriptor>

Returns:

true if resolved call has unknown type parameters (inference is incomplete)

setHasUnknownTypeParameters

public void setHasUnknownTypeParameters(boolean hasUnknownTypeParameters)

getTrace

@NotNull
public DelegatingBindingTrace getTrace()

Specified by:

getTrace in interface ResolvedCallWithTrace<D extends CallableDescriptor>

getTracing

@NotNull
public TracingStrategy getTracing()

getCandidateDescriptor

@NotNull
public D getCandidateDescriptor()

Description copied from interface: ResolvedCall

A target callable descriptor as it was accessible in the corresponding scope, i.e. with type arguments not substituted

Specified by:

getCandidateDescriptor in interface ResolvedCall<D extends CallableDescriptor>

getResultingDescriptor

@NotNull
public D getResultingDescriptor()

Description copied from interface: ResolvedCall

Type arguments are substituted. This descriptor is guaranteed to have NO declared type parameters

Specified by:

getResultingDescriptor in interface ResolvedCall<D extends CallableDescriptor>

setResultingSubstitutor

public void setResultingSubstitutor(@NotNull
                           TypeSubstitutor substitutor)

recordTypeArgument

public void recordTypeArgument(@NotNull
                      TypeParameterDescriptor typeParameter,
                      @NotNull
                      JetType typeArgument)

setConstraintSystem

public void setConstraintSystem(@NotNull
                       ConstraintSystem constraintSystem)

getConstraintSystem

@Nullable
public ConstraintSystem getConstraintSystem()

recordValueArgument

public void recordValueArgument(@NotNull
                       ValueParameterDescriptor valueParameter,
                       @NotNull
                       ResolvedValueArgument valueArgument)

setUnmappedArguments

public void setUnmappedArguments(@NotNull
                        java.util.Collection<ValueArgument> unmappedArguments)

getUnmappedArguments

@NotNull
public java.util.Set<ValueArgument> getUnmappedArguments()

getReceiverArgument

@NotNull
public ReceiverValue getReceiverArgument()

Description copied from interface: ResolvedCall

If the target was an extension function or property, this is the value for its receiver parameter

Specified by:

getReceiverArgument in interface ResolvedCall<D extends CallableDescriptor>

getThisObject

@NotNull
public ReceiverValue getThisObject()

Description copied from interface: ResolvedCall

If the target was a member of a class, this is the object of that class to call it on

Specified by:

getThisObject in interface ResolvedCall<D extends CallableDescriptor>

getExplicitReceiverKind

@NotNull
public ExplicitReceiverKind getExplicitReceiverKind()

Description copied from interface: ResolvedCall

Determines whether receiver argument or this object is substituted for explicit receiver

Specified by:

getExplicitReceiverKind in interface ResolvedCall<D extends CallableDescriptor>

getValueArguments

@NotNull
public java.util.Map<ValueParameterDescriptor,ResolvedValueArgument> getValueArguments()

Description copied from interface: ResolvedCall

Values (arguments) for value parameters

Specified by:

getValueArguments in interface ResolvedCall<D extends CallableDescriptor>

getValueArgumentsByIndex

@NotNull
public java.util.List<ResolvedValueArgument> getValueArgumentsByIndex()

Description copied from interface: ResolvedCall

Values (arguments) for value parameters indexed by parameter index

Specified by:

getValueArgumentsByIndex in interface ResolvedCall<D extends CallableDescriptor>

argumentHasNoType

public void argumentHasNoType()

isDirty

public boolean isDirty()

Specified by:

isDirty in interface ResolvedCallWithTrace<D extends CallableDescriptor>

getTypeArguments

@NotNull
public java.util.Map<TypeParameterDescriptor,JetType> getTypeArguments()

Description copied from interface: ResolvedCall

What's substituted for type parameters

Specified by:

getTypeArguments in interface ResolvedCall<D extends CallableDescriptor>

isSafeCall

public boolean isSafeCall()

Specified by:

isSafeCall in interface ResolvedCall<D extends CallableDescriptor>

getDataFlowInfo

@NotNull
public DataFlowInfo getDataFlowInfo()

Specified by:

getDataFlowInfo in interface ResolvedCall<D extends CallableDescriptor>

setInitialDataFlowInfo

public void setInitialDataFlowInfo(@NotNull
                          DataFlowInfo info)

addDataFlowInfo

public void addDataFlowInfo(@NotNull
                   DataFlowInfo info)

getCallToCompleteTypeArgumentInference

@NotNull
public ResolvedCallImpl<D> getCallToCompleteTypeArgumentInference()

Description copied from interface: ResolvedCallWithTrace

//todo get rid of Impl class in the interface If the call has incomplete type parameters, it should be completed after resolution process is finished. Returns this for normal call and function call for VariableAsFunctionCall.

Specified by:

getCallToCompleteTypeArgumentInference in interface ResolvedCallWithTrace<D extends CallableDescriptor>