@Override
public JetTypeInfo visitObjectLiteralExpression(
@NotNull final JetObjectLiteralExpression expression, final ExpressionTypingContext context) {
DelegatingBindingTrace delegatingBindingTrace =
context.trace.get(TRACE_DELTAS_CACHE, expression.getObjectDeclaration());
if (delegatingBindingTrace != null) {
delegatingBindingTrace.addAllMyDataTo(context.trace);
JetType type = context.trace.get(EXPRESSION_TYPE, expression);
return DataFlowUtils.checkType(type, expression, context, context.dataFlowInfo);
}
final JetType[] result = new JetType[1];
final TemporaryBindingTrace temporaryTrace =
TemporaryBindingTrace.create(
context.trace, "trace to resolve object literal expression", expression);
ObservableBindingTrace.RecordHandler<PsiElement, ClassDescriptor> handler =
new ObservableBindingTrace.RecordHandler<PsiElement, ClassDescriptor>() {
@Override
public void handleRecord(
WritableSlice<PsiElement, ClassDescriptor> slice,
PsiElement declaration,
final ClassDescriptor descriptor) {
if (slice == CLASS && declaration == expression.getObjectDeclaration()) {
JetType defaultType =
DeferredType.create(
context.trace,
createRecursionIntolerantLazyValueWithDefault(
ErrorUtils.createErrorType("Recursive dependency"),
new Function0<JetType>() {
@Override
public JetType invoke() {
return descriptor.getDefaultType();
}
}));
result[0] = defaultType;
if (!context.trace.get(PROCESSED, expression)) {
temporaryTrace.record(EXPRESSION_TYPE, expression, defaultType);
temporaryTrace.record(PROCESSED, expression);
}
}
}
};
ObservableBindingTrace traceAdapter = new ObservableBindingTrace(temporaryTrace);
traceAdapter.addHandler(CLASS, handler);
TopDownAnalyzer.processClassOrObject(
context.replaceBindingTrace(traceAdapter).replaceContextDependency(INDEPENDENT),
context.scope.getContainingDeclaration(),
expression.getObjectDeclaration());
DelegatingBindingTrace cloneDelta =
new DelegatingBindingTrace(
new BindingTraceContext().getBindingContext(),
"cached delta trace for object literal expression resolve",
expression);
temporaryTrace.addAllMyDataTo(cloneDelta);
context.trace.record(TRACE_DELTAS_CACHE, expression.getObjectDeclaration(), cloneDelta);
temporaryTrace.commit();
return DataFlowUtils.checkType(result[0], expression, context, context.dataFlowInfo);
}
@NotNull
protected JetTypeInfo visitAssignmentOperation(
JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
// There is a temporary binding trace for an opportunity to resolve set method for array if
// needed (the initial trace should be used there)
TemporaryBindingTrace temporaryBindingTrace =
TemporaryBindingTrace.create(
contextWithExpectedType.trace,
"trace to resolve array set method for binary expression",
expression);
ExpressionTypingContext context =
contextWithExpectedType
.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE)
.replaceBindingTrace(temporaryBindingTrace);
JetSimpleNameExpression operationSign = expression.getOperationReference();
IElementType operationType = operationSign.getReferencedNameElementType();
JetTypeInfo leftInfo = facade.getTypeInfo(expression.getLeft(), context);
JetType leftType = leftInfo.getType();
DataFlowInfo dataFlowInfo = leftInfo.getDataFlowInfo();
JetExpression right = expression.getRight();
JetExpression left = JetPsiUtil.deparenthesizeWithNoTypeResolution(expression.getLeft());
if (right == null || left == null) {
temporaryBindingTrace.commit();
return JetTypeInfo.create(null, dataFlowInfo);
}
if (leftType == null) {
dataFlowInfo =
facade.getTypeInfo(right, context.replaceDataFlowInfo(dataFlowInfo)).getDataFlowInfo();
context.trace.report(UNRESOLVED_REFERENCE.on(operationSign));
temporaryBindingTrace.commit();
return JetTypeInfo.create(null, dataFlowInfo);
}
ExpressionReceiver receiver = new ExpressionReceiver(left, leftType);
// We check that defined only one of '+=' and '+' operations, and call it (in the case '+' we
// then also assign)
// Check for '+='
Name name = OperatorConventions.ASSIGNMENT_OPERATIONS.get(operationType);
TemporaryBindingTrace assignmentOperationTrace =
TemporaryBindingTrace.create(
context.trace, "trace to check assignment operation like '+=' for", expression);
OverloadResolutionResults<FunctionDescriptor> assignmentOperationDescriptors =
basic.getResolutionResultsForBinaryCall(
scope,
name,
context.replaceBindingTrace(assignmentOperationTrace),
expression,
receiver);
JetType assignmentOperationType =
OverloadResolutionResultsUtil.getResultType(assignmentOperationDescriptors);
// Check for '+'
Name counterpartName =
OperatorConventions.BINARY_OPERATION_NAMES.get(
OperatorConventions.ASSIGNMENT_OPERATION_COUNTERPARTS.get(operationType));
TemporaryBindingTrace binaryOperationTrace =
TemporaryBindingTrace.create(
context.trace, "trace to check binary operation like '+' for", expression);
OverloadResolutionResults<FunctionDescriptor> binaryOperationDescriptors =
basic.getResolutionResultsForBinaryCall(
scope,
counterpartName,
context.replaceBindingTrace(binaryOperationTrace),
expression,
receiver);
JetType binaryOperationType =
OverloadResolutionResultsUtil.getResultType(binaryOperationDescriptors);
JetType type = assignmentOperationType != null ? assignmentOperationType : binaryOperationType;
if (assignmentOperationType != null && binaryOperationType != null) {
OverloadResolutionResults<FunctionDescriptor> ambiguityResolutionResults =
OverloadResolutionResultsUtil.ambiguity(
assignmentOperationDescriptors, binaryOperationDescriptors);
context.trace.report(
ASSIGN_OPERATOR_AMBIGUITY.on(
operationSign, ambiguityResolutionResults.getResultingCalls()));
Collection<DeclarationDescriptor> descriptors = Sets.newHashSet();
for (ResolvedCall<? extends FunctionDescriptor> call :
ambiguityResolutionResults.getResultingCalls()) {
descriptors.add(call.getResultingDescriptor());
}
dataFlowInfo =
facade.getTypeInfo(right, context.replaceDataFlowInfo(dataFlowInfo)).getDataFlowInfo();
context.trace.record(AMBIGUOUS_REFERENCE_TARGET, operationSign, descriptors);
} else if (assignmentOperationType != null) {
assignmentOperationTrace.commit();
if (!KotlinBuiltIns.getInstance().isUnit(assignmentOperationType)) {
context.trace.report(
ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT.on(
operationSign,
assignmentOperationDescriptors.getResultingDescriptor(),
operationSign));
}
} else {
binaryOperationTrace.commit();
context.trace.record(VARIABLE_REASSIGNMENT, expression);
if (left instanceof JetArrayAccessExpression) {
ExpressionTypingContext contextForResolve =
context
.replaceScope(scope)
.replaceBindingTrace(
TemporaryBindingTrace.create(
contextWithExpectedType.trace,
"trace to resolve array set method for assignment",
expression));
basic.resolveArrayAccessSetMethod(
(JetArrayAccessExpression) left, right, contextForResolve, context.trace);
}
dataFlowInfo =
facade.getTypeInfo(right, context.replaceDataFlowInfo(dataFlowInfo)).getDataFlowInfo();
}
basic.checkLValue(context.trace, expression.getLeft());
temporaryBindingTrace.commit();
return JetTypeInfo.create(
checkAssignmentType(type, expression, contextWithExpectedType), dataFlowInfo);
}
