@NotNull
protected JetTypeInfo visitAssignment(
JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
ExpressionTypingContext context =
contextWithExpectedType.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE).replaceScope(scope);
JetExpression left =
context.expressionTypingServices.deparenthesize(expression.getLeft(), context);
JetExpression right = expression.getRight();
if (left instanceof JetArrayAccessExpression) {
JetArrayAccessExpression arrayAccessExpression = (JetArrayAccessExpression) left;
if (right == null) return JetTypeInfo.create(null, context.dataFlowInfo);
JetTypeInfo typeInfo =
basic.resolveArrayAccessSetMethod(arrayAccessExpression, right, context, context.trace);
basic.checkLValue(context.trace, arrayAccessExpression);
return JetTypeInfo.create(
checkAssignmentType(typeInfo.getType(), expression, contextWithExpectedType),
typeInfo.getDataFlowInfo());
}
JetTypeInfo leftInfo = facade.getTypeInfo(expression.getLeft(), context);
JetType leftType = leftInfo.getType();
DataFlowInfo dataFlowInfo = leftInfo.getDataFlowInfo();
if (right != null) {
JetTypeInfo rightInfo =
facade.getTypeInfo(
right, context.replaceDataFlowInfo(dataFlowInfo).replaceExpectedType(leftType));
dataFlowInfo = rightInfo.getDataFlowInfo();
}
if (leftType != null) { // if leftType == null, some another error has been generated
basic.checkLValue(context.trace, expression.getLeft());
}
return DataFlowUtils.checkStatementType(expression, contextWithExpectedType, dataFlowInfo);
}
private List<ValueParameterDescriptor> createValueParameterDescriptors(
ExpressionTypingContext context,
JetFunctionLiteral functionLiteral,
FunctionDescriptorImpl functionDescriptor,
boolean functionTypeExpected) {
List<ValueParameterDescriptor> valueParameterDescriptors = Lists.newArrayList();
List<JetParameter> declaredValueParameters = functionLiteral.getValueParameters();
List<ValueParameterDescriptor> expectedValueParameters =
(functionTypeExpected)
? JetStandardClasses.getValueParameters(functionDescriptor, context.expectedType)
: null;
boolean hasDeclaredValueParameters = functionLiteral.getValueParameterList() != null;
if (functionTypeExpected
&& !hasDeclaredValueParameters
&& expectedValueParameters.size() == 1) {
ValueParameterDescriptor valueParameterDescriptor = expectedValueParameters.get(0);
ValueParameterDescriptor it =
new ValueParameterDescriptorImpl(
functionDescriptor,
0,
Collections.<AnnotationDescriptor>emptyList(),
"it",
false,
valueParameterDescriptor.getOutType(),
valueParameterDescriptor.hasDefaultValue(),
valueParameterDescriptor.getVarargElementType());
valueParameterDescriptors.add(it);
context.trace.record(AUTO_CREATED_IT, it);
} else {
for (int i = 0; i < declaredValueParameters.size(); i++) {
JetParameter declaredParameter = declaredValueParameters.get(i);
JetTypeReference typeReference = declaredParameter.getTypeReference();
JetType type;
if (typeReference != null) {
type = context.getTypeResolver().resolveType(context.scope, typeReference);
} else {
if (expectedValueParameters != null && i < expectedValueParameters.size()) {
type = expectedValueParameters.get(i).getOutType();
} else {
context.trace.report(CANNOT_INFER_PARAMETER_TYPE.on(declaredParameter));
type = ErrorUtils.createErrorType("Cannot be inferred");
}
}
ValueParameterDescriptor valueParameterDescriptor =
context
.getDescriptorResolver()
.resolveValueParameterDescriptor(functionDescriptor, declaredParameter, i, type);
valueParameterDescriptors.add(valueParameterDescriptor);
}
}
return valueParameterDescriptors;
}
@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);
}
@Nullable
private static JetType computeUnsafeReturnType(
@NotNull JetFunctionLiteralExpression expression,
@NotNull ExpressionTypingContext context,
@NotNull SimpleFunctionDescriptorImpl functionDescriptor,
@Nullable JetType expectedReturnType) {
JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
JetBlockExpression bodyExpression = functionLiteral.getBodyExpression();
assert bodyExpression != null;
JetScope functionInnerScope =
FunctionDescriptorUtil.getFunctionInnerScope(
context.scope, functionDescriptor, context.trace);
JetTypeReference returnTypeRef = functionLiteral.getReturnTypeRef();
JetType declaredReturnType = null;
if (returnTypeRef != null) {
declaredReturnType =
context
.expressionTypingServices
.getTypeResolver()
.resolveType(context.scope, returnTypeRef, context.trace, true);
// This is needed for ControlStructureTypingVisitor#visitReturnExpression() to properly
// type-check returned expressions
functionDescriptor.setReturnType(declaredReturnType);
if (expectedReturnType != null) {
if (!JetTypeChecker.INSTANCE.isSubtypeOf(declaredReturnType, expectedReturnType)) {
context.trace.report(EXPECTED_RETURN_TYPE_MISMATCH.on(returnTypeRef, expectedReturnType));
}
}
}
// Type-check the body
ExpressionTypingContext newContext =
context
.replaceScope(functionInnerScope)
.replaceExpectedType(
declaredReturnType != null
? declaredReturnType
: (expectedReturnType != null ? expectedReturnType : NO_EXPECTED_TYPE));
JetType typeOfBodyExpression =
context
.expressionTypingServices
.getBlockReturnedType(bodyExpression, COERCION_TO_UNIT, newContext)
.getType();
List<JetType> returnedExpressionTypes =
Lists.newArrayList(
getTypesOfLocallyReturnedExpressions(
functionLiteral, context.trace, collectReturns(bodyExpression)));
ContainerUtil.addIfNotNull(returnedExpressionTypes, typeOfBodyExpression);
if (declaredReturnType != null) return declaredReturnType;
if (returnedExpressionTypes.isEmpty()) return null;
return CommonSupertypes.commonSupertype(returnedExpressionTypes);
}
@Override
public JetTypeInfo visitProperty(JetProperty property, ExpressionTypingContext context) {
JetTypeReference receiverTypeRef = property.getReceiverTypeRef();
if (receiverTypeRef != null) {
context.trace.report(LOCAL_EXTENSION_PROPERTY.on(receiverTypeRef));
}
JetPropertyAccessor getter = property.getGetter();
if (getter != null) {
context.trace.report(LOCAL_VARIABLE_WITH_GETTER.on(getter));
}
JetPropertyAccessor setter = property.getSetter();
if (setter != null) {
context.trace.report(LOCAL_VARIABLE_WITH_SETTER.on(setter));
}
VariableDescriptor propertyDescriptor =
context
.expressionTypingServices
.getDescriptorResolver()
.resolveLocalVariableDescriptor(
scope.getContainingDeclaration(),
scope,
property,
context.dataFlowInfo,
context.trace);
JetExpression initializer = property.getInitializer();
DataFlowInfo dataFlowInfo = context.dataFlowInfo;
if (initializer != null) {
JetType outType = propertyDescriptor.getType();
JetTypeInfo typeInfo =
facade.getTypeInfo(initializer, context.replaceExpectedType(outType).replaceScope(scope));
dataFlowInfo = typeInfo.getDataFlowInfo();
}
{
VariableDescriptor olderVariable = scope.getLocalVariable(propertyDescriptor.getName());
ExpressionTypingUtils.checkVariableShadowing(context, propertyDescriptor, olderVariable);
}
scope.addVariableDescriptor(propertyDescriptor);
ModifiersChecker.create(context.trace).checkModifiersForLocalDeclaration(property);
return DataFlowUtils.checkStatementType(property, context, dataFlowInfo);
}
@Override
public JetTypeInfo visitMultiDeclaration(
JetMultiDeclaration multiDeclaration, final ExpressionTypingContext context) {
final JetExpression initializer = multiDeclaration.getInitializer();
if (initializer == null) {
context.trace.report(INITIALIZER_REQUIRED_FOR_MULTIDECLARATION.on(multiDeclaration));
return JetTypeInfo.create(null, context.dataFlowInfo);
}
final ExpressionReceiver expressionReceiver =
ExpressionTypingUtils.getExpressionReceiver(
facade, initializer, context.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE));
DataFlowInfo dataFlowInfo = facade.getTypeInfo(initializer, context).getDataFlowInfo();
if (expressionReceiver == null) {
return JetTypeInfo.create(null, dataFlowInfo);
}
ExpressionTypingUtils.defineLocalVariablesFromMultiDeclaration(
scope, multiDeclaration, expressionReceiver, initializer, context);
return DataFlowUtils.checkStatementType(multiDeclaration, context, dataFlowInfo);
}
private NamedFunctionDescriptorImpl createFunctionDescriptor(
JetFunctionLiteralExpression expression,
ExpressionTypingContext context,
boolean functionTypeExpected) {
JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
JetTypeReference receiverTypeRef = functionLiteral.getReceiverTypeRef();
NamedFunctionDescriptorImpl functionDescriptor =
new NamedFunctionDescriptorImpl(
context.scope.getContainingDeclaration(),
Collections.<AnnotationDescriptor>emptyList(),
"<anonymous>",
CallableMemberDescriptor.Kind.DECLARATION);
List<ValueParameterDescriptor> valueParameterDescriptors =
createValueParameterDescriptors(
context, functionLiteral, functionDescriptor, functionTypeExpected);
JetType effectiveReceiverType;
if (receiverTypeRef == null) {
if (functionTypeExpected) {
effectiveReceiverType = JetStandardClasses.getReceiverType(context.expectedType);
} else {
effectiveReceiverType = null;
}
} else {
effectiveReceiverType = context.getTypeResolver().resolveType(context.scope, receiverTypeRef);
}
functionDescriptor.initialize(
effectiveReceiverType,
NO_RECEIVER,
Collections.<TypeParameterDescriptor>emptyList(),
valueParameterDescriptors,
null,
Modality.FINAL,
Visibility.LOCAL);
context.trace.record(BindingContext.FUNCTION, expression, functionDescriptor);
return functionDescriptor;
}
public static boolean isVariableIterable(
@NotNull ExpressionTypingServices expressionTypingServices,
@NotNull Project project,
@NotNull VariableDescriptor variableDescriptor,
@NotNull JetScope scope) {
JetExpression expression = JetPsiFactory.createExpression(project, "fake");
ExpressionReceiver expressionReceiver =
new ExpressionReceiver(expression, variableDescriptor.getType());
ExpressionTypingContext context =
ExpressionTypingContext.newContext(
expressionTypingServices,
new HashMap<JetPattern, DataFlowInfo>(),
new HashMap<JetPattern, List<VariableDescriptor>>(),
new LabelResolver(),
new BindingTraceContext(),
scope,
DataFlowInfo.EMPTY,
TypeUtils.NO_EXPECTED_TYPE,
TypeUtils.NO_EXPECTED_TYPE,
false);
return ControlStructureTypingVisitor.checkIterableConvention(expressionReceiver, context)
!= null;
}
@Override
public JetType visitFunctionLiteralExpression(
JetFunctionLiteralExpression expression, ExpressionTypingContext context) {
JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
JetBlockExpression bodyExpression = functionLiteral.getBodyExpression();
if (bodyExpression == null) return null;
JetType expectedType = context.expectedType;
boolean functionTypeExpected =
expectedType != TypeUtils.NO_EXPECTED_TYPE
&& JetStandardClasses.isFunctionType(expectedType);
NamedFunctionDescriptorImpl functionDescriptor =
createFunctionDescriptor(expression, context, functionTypeExpected);
List<JetType> parameterTypes = Lists.newArrayList();
List<ValueParameterDescriptor> valueParameters = functionDescriptor.getValueParameters();
for (ValueParameterDescriptor valueParameter : valueParameters) {
parameterTypes.add(valueParameter.getOutType());
}
ReceiverDescriptor receiverParameter = functionDescriptor.getReceiverParameter();
JetType receiver = receiverParameter != NO_RECEIVER ? receiverParameter.getType() : null;
JetType returnType = TypeUtils.NO_EXPECTED_TYPE;
JetScope functionInnerScope =
FunctionDescriptorUtil.getFunctionInnerScope(
context.scope, functionDescriptor, context.trace);
JetTypeReference returnTypeRef = functionLiteral.getReturnTypeRef();
if (returnTypeRef != null) {
returnType = context.getTypeResolver().resolveType(context.scope, returnTypeRef);
context
.getServices()
.checkFunctionReturnType(
expression,
context
.replaceScope(functionInnerScope)
.replaceExpectedType(returnType)
.replaceExpectedReturnType(returnType)
.replaceDataFlowInfo(context.dataFlowInfo));
} else {
if (functionTypeExpected) {
returnType = JetStandardClasses.getReturnTypeFromFunctionType(expectedType);
}
returnType =
context
.getServices()
.getBlockReturnedType(
functionInnerScope,
bodyExpression,
CoercionStrategy.COERCION_TO_UNIT,
context.replaceExpectedType(returnType).replaceExpectedReturnType(returnType));
}
JetType safeReturnType =
returnType == null ? ErrorUtils.createErrorType("<return type>") : returnType;
functionDescriptor.setReturnType(safeReturnType);
boolean hasDeclaredValueParameters = functionLiteral.getValueParameterList() != null;
if (!hasDeclaredValueParameters && functionTypeExpected) {
JetType expectedReturnType = JetStandardClasses.getReturnTypeFromFunctionType(expectedType);
if (JetStandardClasses.isUnit(expectedReturnType)) {
functionDescriptor.setReturnType(JetStandardClasses.getUnitType());
return DataFlowUtils.checkType(
JetStandardClasses.getFunctionType(
Collections.<AnnotationDescriptor>emptyList(),
receiver,
parameterTypes,
JetStandardClasses.getUnitType()),
expression,
context);
}
}
return DataFlowUtils.checkType(
JetStandardClasses.getFunctionType(
Collections.<AnnotationDescriptor>emptyList(),
receiver,
parameterTypes,
safeReturnType),
expression,
context);
}
@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);
}