@Nullable
private JetType getVariableType(
@NotNull JetSimpleNameExpression nameExpression,
@NotNull ReceiverValue receiver,
@Nullable ASTNode callOperationNode,
@NotNull ResolutionContext context,
@NotNull boolean[] result) {
TemporaryBindingTrace traceForVariable =
TemporaryBindingTrace.create(
context.trace, "trace to resolve as local variable or property", nameExpression);
CallResolver callResolver = expressionTypingServices.getCallResolver();
Call call = CallMaker.makePropertyCall(receiver, callOperationNode, nameExpression);
OverloadResolutionResults<VariableDescriptor> resolutionResult =
callResolver.resolveSimpleProperty(
BasicCallResolutionContext.create(
context.replaceBindingTrace(traceForVariable),
call,
ResolveMode.TOP_LEVEL_CALL,
ResolutionResultsCache.create()));
if (!resolutionResult.isNothing()) {
traceForVariable.commit();
checkSuper(receiver, resolutionResult, context.trace, nameExpression);
result[0] = true;
return resolutionResult.isSingleResult()
? resolutionResult.getResultingDescriptor().getReturnType()
: null;
}
ResolutionContext newContext =
receiver.exists() ? context.replaceScope(receiver.getType().getMemberScope()) : context;
TemporaryBindingTrace traceForNamespaceOrClassObject =
TemporaryBindingTrace.create(
context.trace, "trace to resolve as namespace or class object", nameExpression);
JetType jetType =
lookupNamespaceOrClassObject(
nameExpression, newContext.replaceBindingTrace(traceForNamespaceOrClassObject));
if (jetType != null) {
traceForNamespaceOrClassObject.commit();
// Uncommitted changes in temp context
context.trace.record(RESOLUTION_SCOPE, nameExpression, context.scope);
if (context.dataFlowInfo.hasTypeInfoConstraints()) {
context.trace.record(
NON_DEFAULT_EXPRESSION_DATA_FLOW, nameExpression, context.dataFlowInfo);
}
result[0] = true;
return jetType;
}
result[0] = false;
return null;
}
@Nullable
private JetType lookupNamespaceOrClassObject(
@NotNull JetSimpleNameExpression expression, @NotNull ResolutionContext context) {
Name referencedName = expression.getReferencedNameAsName();
final ClassifierDescriptor classifier = context.scope.getClassifier(referencedName);
if (classifier != null) {
JetType classObjectType = classifier.getClassObjectType();
if (classObjectType != null) {
context.trace.record(REFERENCE_TARGET, expression, classifier);
JetType result =
getExtendedClassObjectType(classObjectType, referencedName, classifier, context);
if (result == null) {
context.trace.report(NO_CLASS_OBJECT.on(expression, classifier));
}
return DataFlowUtils.checkType(result, expression, context);
}
}
JetType[] result = new JetType[1];
TemporaryBindingTrace temporaryTrace =
TemporaryBindingTrace.create(
context.trace, "trace for namespace/class object lookup of name", referencedName);
if (furtherNameLookup(expression, result, context.replaceBindingTrace(temporaryTrace))) {
temporaryTrace.commit();
return DataFlowUtils.checkType(result[0], expression, context);
}
// To report NO_CLASS_OBJECT when no namespace found
if (classifier != null) {
if (classifier instanceof TypeParameterDescriptor) {
if (context.expressionPosition == ExpressionPosition.FREE) {
context.trace.report(
TYPE_PARAMETER_IS_NOT_AN_EXPRESSION.on(
expression, (TypeParameterDescriptor) classifier));
} else {
context.trace.report(
TYPE_PARAMETER_ON_LHS_OF_DOT.on(expression, (TypeParameterDescriptor) classifier));
}
} else if (context.expressionPosition == ExpressionPosition.FREE) {
context.trace.report(NO_CLASS_OBJECT.on(expression, classifier));
}
context.trace.record(REFERENCE_TARGET, expression, classifier);
JetScope scopeForStaticMembersResolution =
classifier instanceof ClassDescriptor
? getStaticNestedClassesScope((ClassDescriptor) classifier)
: new JetScopeImpl() {
@NotNull
@Override
public DeclarationDescriptor getContainingDeclaration() {
return classifier;
}
@Override
public String toString() {
return "Scope for the type parameter on the left hand side of dot";
}
};
return new NamespaceType(referencedName, scopeForStaticMembersResolution);
}
temporaryTrace.commit();
return result[0];
}
@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);
}
@Nullable
private JetType lookupNamespaceOrClassObject(
@NotNull JetSimpleNameExpression expression, @NotNull ResolutionContext context) {
Name referencedName = expression.getReferencedNameAsName();
ClassifierDescriptor classifier = context.scope.getClassifier(referencedName);
if (classifier != null) {
JetType classObjectType = classifier.getClassObjectType();
if (classObjectType != null) {
context.trace.record(REFERENCE_TARGET, expression, classifier);
JetType result;
if (context.expressionPosition == ExpressionPosition.LHS_OF_DOT
&& classifier instanceof ClassDescriptor) {
JetScope scope =
new ChainedScope(
classifier,
classObjectType.getMemberScope(),
getStaticNestedClassesScope((ClassDescriptor) classifier));
result = new NamespaceType(referencedName, scope);
} else if (context.expressionPosition == ExpressionPosition.LHS_OF_DOT
|| classifier.isClassObjectAValue()) {
result = classObjectType;
} else {
context.trace.report(NO_CLASS_OBJECT.on(expression, classifier));
result = null;
}
return DataFlowUtils.checkType(result, expression, context);
}
}
JetType[] result = new JetType[1];
TemporaryBindingTrace temporaryTrace =
TemporaryBindingTrace.create(
context.trace, "trace for namespace/class object lookup of name", referencedName);
if (furtherNameLookup(expression, result, context.replaceBindingTrace(temporaryTrace))) {
temporaryTrace.commit();
return DataFlowUtils.checkType(result[0], expression, context);
}
// To report NO_CLASS_OBJECT when no namespace found
if (classifier != null) {
if (context.expressionPosition == ExpressionPosition.FREE) {
context.trace.report(NO_CLASS_OBJECT.on(expression, classifier));
}
context.trace.record(REFERENCE_TARGET, expression, classifier);
JetScope scopeForStaticMembersResolution =
classifier instanceof ClassDescriptor
? getStaticNestedClassesScope((ClassDescriptor) classifier)
: JetScope.EMPTY;
return new NamespaceType(referencedName, scopeForStaticMembersResolution);
}
temporaryTrace.commit();
return result[0];
}
@NotNull
public TypeInfoForCall getCallExpressionTypeInfoForCallWithoutFinalTypeCheck(
@NotNull JetCallExpression callExpression,
@NotNull ReceiverValue receiver,
@Nullable ASTNode callOperationNode,
@NotNull ResolutionContext context,
@NotNull ResolveMode resolveMode) {
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);
ResolvedCall<FunctionDescriptor> resolvedCall =
getResolvedCallForFunction(
call,
callExpression,
receiver,
context.replaceBindingTrace(traceForFunction),
resolveMode,
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 TypeInfoForCall.create(null, context.dataFlowInfo);
}
JetType type = functionDescriptor.getReturnType();
return TypeInfoForCall.create(
type, resolvedCall.getDataFlowInfo(), resolvedCall, call, context, resolveMode);
}
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 TypeInfoForCall.create(null, context.dataFlowInfo);
}
}
traceForFunction.commit();
return TypeInfoForCall.create(null, context.dataFlowInfo);
}