@NotNull
public JetTypeInfo getSimpleNameExpressionTypeInfo(
@NotNull JetSimpleNameExpression nameExpression,
@NotNull ReceiverValue receiver,
@Nullable ASTNode callOperationNode,
@NotNull ResolutionContext context) {
boolean[] result = new boolean[1];
TemporaryBindingTrace traceForVariable =
TemporaryBindingTrace.create(context.trace, "trace to resolve as variable", nameExpression);
JetType type =
getVariableType(
nameExpression,
receiver,
callOperationNode,
context.replaceBindingTrace(traceForVariable),
result);
if (result[0]) {
traceForVariable.commit();
if (type instanceof NamespaceType && context.expressionPosition == ExpressionPosition.FREE) {
type = null;
}
return JetTypeInfo.create(type, context.dataFlowInfo);
}
Call call =
CallMaker.makeCall(
nameExpression,
receiver,
callOperationNode,
nameExpression,
Collections.<ValueArgument>emptyList());
TemporaryBindingTrace traceForFunction =
TemporaryBindingTrace.create(context.trace, "trace to resolve as function", nameExpression);
ResolvedCall<FunctionDescriptor> resolvedCall =
getResolvedCallForFunction(
call,
nameExpression,
receiver,
context,
ResolveMode.TOP_LEVEL_CALL,
ResolutionResultsCache.create(),
result);
if (result[0]) {
FunctionDescriptor functionDescriptor =
resolvedCall != null ? resolvedCall.getResultingDescriptor() : null;
traceForFunction.commit();
boolean hasValueParameters =
functionDescriptor == null || functionDescriptor.getValueParameters().size() > 0;
context.trace.report(
FUNCTION_CALL_EXPECTED.on(nameExpression, nameExpression, hasValueParameters));
type = functionDescriptor != null ? functionDescriptor.getReturnType() : null;
return JetTypeInfo.create(type, context.dataFlowInfo);
}
traceForVariable.commit();
return JetTypeInfo.create(null, context.dataFlowInfo);
}
@NotNull
public TypeInfoForCall getQualifiedExpressionExtendedTypeInfo(
@NotNull JetQualifiedExpression expression,
@NotNull ResolutionContext context,
@NotNull ResolveMode resolveMode) {
// TODO : functions as values
JetExpression selectorExpression = expression.getSelectorExpression();
JetExpression receiverExpression = expression.getReceiverExpression();
JetTypeInfo receiverTypeInfo =
expressionTypingServices.getTypeInfoWithNamespaces(
receiverExpression,
context.scope,
NO_EXPECTED_TYPE,
context.dataFlowInfo,
context.trace);
JetType receiverType = receiverTypeInfo.getType();
if (selectorExpression == null) return TypeInfoForCall.create(null, context.dataFlowInfo);
if (receiverType == null)
receiverType = ErrorUtils.createErrorType("Type for " + expression.getText());
context = context.replaceDataFlowInfo(receiverTypeInfo.getDataFlowInfo());
if (selectorExpression instanceof JetSimpleNameExpression) {
ConstantUtils.propagateConstantValues(
expression, context.trace, (JetSimpleNameExpression) selectorExpression);
}
TypeInfoForCall selectorReturnTypeInfo =
getSelectorReturnTypeInfo(
new ExpressionReceiver(receiverExpression, receiverType),
expression.getOperationTokenNode(),
selectorExpression,
context,
resolveMode);
JetType selectorReturnType = selectorReturnTypeInfo.getType();
// TODO move further
if (!(receiverType instanceof NamespaceType)
&& expression.getOperationSign() == JetTokens.SAFE_ACCESS) {
if (selectorReturnType != null
&& !selectorReturnType.isNullable()
&& !KotlinBuiltIns.getInstance().isUnit(selectorReturnType)) {
if (receiverType.isNullable()) {
selectorReturnType = TypeUtils.makeNullable(selectorReturnType);
}
}
}
// TODO : this is suspicious: remove this code?
if (selectorReturnType != null) {
context.trace.record(BindingContext.EXPRESSION_TYPE, selectorExpression, selectorReturnType);
}
JetTypeInfo typeInfo =
JetTypeInfo.create(selectorReturnType, selectorReturnTypeInfo.getDataFlowInfo());
if (resolveMode == ResolveMode.TOP_LEVEL_CALL) {
DataFlowUtils.checkType(typeInfo.getType(), expression, context, typeInfo.getDataFlowInfo());
}
return TypeInfoForCall.create(typeInfo, selectorReturnTypeInfo);
}
@NotNull
private JetTypeInfo getSelectorReturnTypeInfo(
@NotNull ReceiverValue receiver,
@Nullable ASTNode callOperationNode,
@NotNull JetExpression selectorExpression,
@NotNull ResolutionContext context,
@NotNull ResolveMode resolveMode,
@NotNull ResolutionResultsCache resolutionResultsCache) {
if (selectorExpression instanceof JetCallExpression) {
return getCallExpressionTypeInfoWithoutFinalTypeCheck(
(JetCallExpression) selectorExpression,
receiver,
callOperationNode,
context,
resolveMode,
resolutionResultsCache);
} else if (selectorExpression instanceof JetSimpleNameExpression) {
return getSimpleNameExpressionTypeInfo(
(JetSimpleNameExpression) selectorExpression, receiver, callOperationNode, context);
} else if (selectorExpression instanceof JetQualifiedExpression) {
JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) selectorExpression;
JetExpression newReceiverExpression = qualifiedExpression.getReceiverExpression();
JetTypeInfo newReceiverTypeInfo =
getSelectorReturnTypeInfo(
receiver,
callOperationNode,
newReceiverExpression,
context.replaceExpectedType(NO_EXPECTED_TYPE),
resolveMode,
resolutionResultsCache);
JetType newReceiverType = newReceiverTypeInfo.getType();
DataFlowInfo newReceiverDataFlowInfo = newReceiverTypeInfo.getDataFlowInfo();
JetExpression newSelectorExpression = qualifiedExpression.getSelectorExpression();
if (newReceiverType != null && newSelectorExpression != null) {
ExpressionReceiver expressionReceiver =
new ExpressionReceiver(newReceiverExpression, newReceiverType);
return getSelectorReturnTypeInfo(
expressionReceiver,
qualifiedExpression.getOperationTokenNode(),
newSelectorExpression,
context.replaceDataFlowInfo(newReceiverDataFlowInfo),
resolveMode,
resolutionResultsCache);
}
} else {
context.trace.report(ILLEGAL_SELECTOR.on(selectorExpression, selectorExpression.getText()));
}
return JetTypeInfo.create(null, context.dataFlowInfo);
}
@Override
public JetTypeInfo visitFunctionLiteralExpression(
@NotNull JetFunctionLiteralExpression expression, ExpressionTypingContext context) {
JetBlockExpression bodyExpression = expression.getFunctionLiteral().getBodyExpression();
if (bodyExpression == null) return null;
Name callerName = getCallerName(expression);
if (callerName != null) {
context.labelResolver.enterLabeledElement(new LabelName(callerName.asString()), expression);
}
JetType expectedType = context.expectedType;
boolean functionTypeExpected =
!noExpectedType(expectedType)
&& KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(expectedType);
AnonymousFunctionDescriptor functionDescriptor =
createFunctionDescriptor(expression, context, functionTypeExpected);
JetType safeReturnType =
computeReturnType(expression, context, functionDescriptor, functionTypeExpected);
functionDescriptor.setReturnType(safeReturnType);
JetType receiver =
DescriptorUtils.getReceiverParameterType(functionDescriptor.getReceiverParameter());
List<JetType> valueParametersTypes =
DescriptorUtils.getValueParametersTypes(functionDescriptor.getValueParameters());
JetType resultType =
KotlinBuiltIns.getInstance()
.getFunctionType(
Collections.<AnnotationDescriptor>emptyList(),
receiver,
valueParametersTypes,
safeReturnType);
if (!noExpectedType(expectedType)
&& KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(expectedType)) {
// all checks were done before
return JetTypeInfo.create(resultType, context.dataFlowInfo);
}
if (callerName != null) {
context.labelResolver.exitLabeledElement(expression);
}
return DataFlowUtils.checkType(resultType, expression, context, context.dataFlowInfo);
}
@NotNull
public <D extends CallableDescriptor> JetTypeInfo getCallExpressionTypeInfoWithoutFinalTypeCheck(
@NotNull JetCallExpression callExpression,
@NotNull ReceiverValue receiver,
@Nullable ASTNode callOperationNode,
@NotNull ResolutionContext context,
@NotNull ResolveMode resolveMode,
@NotNull ResolutionResultsCache resolutionResultsCache) {
boolean[] result = new boolean[1];
Call call = CallMaker.makeCall(receiver, callOperationNode, callExpression);
TemporaryBindingTrace traceForFunction =
TemporaryBindingTrace.create(
context.trace, "trace to resolve as function call", callExpression);
ResolvedCallWithTrace<FunctionDescriptor> resolvedCall =
getResolvedCallForFunction(
call,
callExpression,
receiver,
context.replaceBindingTrace(traceForFunction),
resolveMode,
resolutionResultsCache,
result);
if (result[0]) {
FunctionDescriptor functionDescriptor =
resolvedCall != null ? resolvedCall.getResultingDescriptor() : null;
traceForFunction.commit();
if (callExpression.getValueArgumentList() == null
&& callExpression.getFunctionLiteralArguments().isEmpty()) {
// there are only type arguments
boolean hasValueParameters =
functionDescriptor == null || functionDescriptor.getValueParameters().size() > 0;
context.trace.report(
FUNCTION_CALL_EXPECTED.on(callExpression, callExpression, hasValueParameters));
}
if (functionDescriptor == null) {
return JetTypeInfo.create(null, context.dataFlowInfo);
}
JetType type = functionDescriptor.getReturnType();
return JetTypeInfo.create(type, resolvedCall.getDataFlowInfo());
}
JetExpression calleeExpression = callExpression.getCalleeExpression();
if (calleeExpression instanceof JetSimpleNameExpression
&& callExpression.getTypeArgumentList() == null) {
TemporaryBindingTrace traceForVariable =
TemporaryBindingTrace.create(
context.trace, "trace to resolve as variable with 'invoke' call", callExpression);
JetType type =
getVariableType(
(JetSimpleNameExpression) calleeExpression,
receiver,
callOperationNode,
context.replaceBindingTrace(traceForVariable),
result);
if (result[0]) {
traceForVariable.commit();
context.trace.report(
FUNCTION_EXPECTED.on(
(JetReferenceExpression) calleeExpression,
calleeExpression,
type != null ? type : ErrorUtils.createErrorType("")));
return JetTypeInfo.create(null, context.dataFlowInfo);
}
}
traceForFunction.commit();
return JetTypeInfo.create(null, context.dataFlowInfo);
}