001 /*
002 * Copyright 2010-2015 JetBrains s.r.o.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.jetbrains.kotlin.types.expressions;
018
019 import com.google.common.base.Function;
020 import com.google.common.collect.Sets;
021 import com.intellij.psi.tree.IElementType;
022 import org.jetbrains.annotations.NotNull;
023 import org.jetbrains.annotations.Nullable;
024 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
025 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
026 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
027 import org.jetbrains.kotlin.descriptors.VariableDescriptor;
028 import org.jetbrains.kotlin.diagnostics.Errors;
029 import org.jetbrains.kotlin.lexer.JetTokens;
030 import org.jetbrains.kotlin.name.Name;
031 import org.jetbrains.kotlin.psi.*;
032 import org.jetbrains.kotlin.resolve.AnnotationResolver;
033 import org.jetbrains.kotlin.resolve.DescriptorUtils;
034 import org.jetbrains.kotlin.resolve.TemporaryBindingTrace;
035 import org.jetbrains.kotlin.resolve.calls.context.TemporaryTraceAndCache;
036 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
037 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults;
038 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsImpl;
039 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsUtil;
040 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
041 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue;
042 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory;
043 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope;
044 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
045 import org.jetbrains.kotlin.resolve.scopes.utils.UtilsPackage;
046 import org.jetbrains.kotlin.types.JetType;
047 import org.jetbrains.kotlin.types.TypeUtils;
048 import org.jetbrains.kotlin.types.checker.JetTypeChecker;
049 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.TypeInfoFactoryPackage;
050
051 import java.util.Collection;
052
053 import static org.jetbrains.kotlin.diagnostics.Errors.*;
054 import static org.jetbrains.kotlin.psi.JetPsiUtil.deparenthesizeWithResolutionStrategy;
055 import static org.jetbrains.kotlin.resolve.BindingContext.AMBIGUOUS_REFERENCE_TARGET;
056 import static org.jetbrains.kotlin.resolve.BindingContext.VARIABLE_REASSIGNMENT;
057 import static org.jetbrains.kotlin.resolve.calls.context.ContextDependency.INDEPENDENT;
058 import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE;
059 import static org.jetbrains.kotlin.types.TypeUtils.noExpectedType;
060
061 @SuppressWarnings("SuspiciousMethodCalls")
062 public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisitor {
063 private final LexicalWritableScope scope;
064 private final BasicExpressionTypingVisitor basic;
065 private final ControlStructureTypingVisitor controlStructures;
066 private final PatternMatchingTypingVisitor patterns;
067 private final FunctionsTypingVisitor functions;
068
069 public ExpressionTypingVisitorForStatements(
070 @NotNull ExpressionTypingInternals facade,
071 @NotNull LexicalWritableScope scope,
072 @NotNull BasicExpressionTypingVisitor basic,
073 @NotNull ControlStructureTypingVisitor controlStructures,
074 @NotNull PatternMatchingTypingVisitor patterns,
075 @NotNull FunctionsTypingVisitor functions
076 ) {
077 super(facade);
078 this.scope = scope;
079 this.basic = basic;
080 this.controlStructures = controlStructures;
081 this.patterns = patterns;
082 this.functions = functions;
083 }
084
085 @Nullable
086 private JetType checkAssignmentType(
087 @Nullable JetType assignmentType,
088 @NotNull JetBinaryExpression expression,
089 @NotNull ExpressionTypingContext context
090 ) {
091 if (assignmentType != null && !KotlinBuiltIns.isUnit(assignmentType) && !noExpectedType(context.expectedType) &&
092 !context.expectedType.isError() && TypeUtils.equalTypes(context.expectedType, assignmentType)) {
093 context.trace.report(Errors.ASSIGNMENT_TYPE_MISMATCH.on(expression, context.expectedType));
094 return null;
095 }
096 return components.dataFlowAnalyzer.checkStatementType(expression, context);
097 }
098
099 @Override
100 public JetTypeInfo visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, ExpressionTypingContext context) {
101 components.localClassifierAnalyzer.processClassOrObject(
102 scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT),
103 scope.getOwnerDescriptor(),
104 declaration);
105 return TypeInfoFactoryPackage.createTypeInfo(components.dataFlowAnalyzer.checkStatementType(declaration, context), context);
106 }
107
108 @Override
109 public JetTypeInfo visitProperty(@NotNull JetProperty property, ExpressionTypingContext typingContext) {
110 ExpressionTypingContext context = typingContext.replaceContextDependency(INDEPENDENT).replaceScope(scope);
111 JetTypeReference receiverTypeRef = property.getReceiverTypeReference();
112 if (receiverTypeRef != null) {
113 context.trace.report(LOCAL_EXTENSION_PROPERTY.on(receiverTypeRef));
114 }
115
116 JetPropertyAccessor getter = property.getGetter();
117 if (getter != null) {
118 context.trace.report(LOCAL_VARIABLE_WITH_GETTER.on(getter));
119 }
120
121 JetPropertyAccessor setter = property.getSetter();
122 if (setter != null) {
123 context.trace.report(LOCAL_VARIABLE_WITH_SETTER.on(setter));
124 }
125
126 JetExpression delegateExpression = property.getDelegateExpression();
127 if (delegateExpression != null) {
128 components.expressionTypingServices.getTypeInfo(delegateExpression, context);
129 context.trace.report(LOCAL_VARIABLE_WITH_DELEGATE.on(property.getDelegate()));
130 }
131
132 for (JetTypeParameter typeParameter : property.getTypeParameters()) {
133 AnnotationResolver.reportUnsupportedAnnotationForTypeParameter(typeParameter, context.trace);
134 }
135
136 VariableDescriptor propertyDescriptor = components.descriptorResolver.
137 resolveLocalVariableDescriptor(scope, property, context.dataFlowInfo, context.trace);
138 JetExpression initializer = property.getInitializer();
139 JetTypeInfo typeInfo;
140 if (initializer != null) {
141 JetType outType = propertyDescriptor.getType();
142 typeInfo = facade.getTypeInfo(initializer, context.replaceExpectedType(outType));
143 DataFlowInfo dataFlowInfo = typeInfo.getDataFlowInfo();
144 JetType type = typeInfo.getType();
145 // At this moment we do not take initializer value into account if type is given for a property
146 // We can comment first part of this condition to take them into account, like here: var s: String? = "xyz"
147 // In this case s will be not-nullable until it is changed
148 if (property.getTypeReference() == null && type != null) {
149 DataFlowValue variableDataFlowValue = DataFlowValueFactory.createDataFlowValue(
150 propertyDescriptor, context.trace.getBindingContext(),
151 DescriptorUtils.getContainingModuleOrNull(scope.getOwnerDescriptor()));
152 DataFlowValue initializerDataFlowValue = DataFlowValueFactory.createDataFlowValue(initializer, type, context);
153 // We cannot say here anything new about initializerDataFlowValue
154 // except it has the same value as variableDataFlowValue
155 typeInfo = typeInfo.replaceDataFlowInfo(dataFlowInfo.assign(variableDataFlowValue, initializerDataFlowValue));
156 }
157 }
158 else {
159 typeInfo = TypeInfoFactoryPackage.noTypeInfo(context);
160 }
161
162 {
163 VariableDescriptor olderVariable = UtilsPackage.getLocalVariable(scope, propertyDescriptor.getName());
164 ExpressionTypingUtils.checkVariableShadowing(context, propertyDescriptor, olderVariable);
165 }
166
167 scope.addVariableDescriptor(propertyDescriptor);
168 components.modifiersChecker.withTrace(context.trace).checkModifiersForLocalDeclaration(property, propertyDescriptor);
169 return typeInfo.replaceType(components.dataFlowAnalyzer.checkStatementType(property, context));
170 }
171
172 @Override
173 public JetTypeInfo visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration, ExpressionTypingContext context) {
174 components.annotationResolver.resolveAnnotationsWithArguments(scope, multiDeclaration.getModifierList(), context.trace);
175
176 JetExpression initializer = multiDeclaration.getInitializer();
177 if (initializer == null) {
178 context.trace.report(INITIALIZER_REQUIRED_FOR_MULTIDECLARATION.on(multiDeclaration));
179 return TypeInfoFactoryPackage.noTypeInfo(context);
180 }
181 ExpressionReceiver expressionReceiver = ExpressionTypingUtils.getExpressionReceiver(
182 facade, initializer, context.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT));
183 JetTypeInfo typeInfo = facade.getTypeInfo(initializer, context);
184 if (expressionReceiver == null) {
185 return TypeInfoFactoryPackage.noTypeInfo(context);
186 }
187 components.multiDeclarationResolver.defineLocalVariablesFromMultiDeclaration(scope, multiDeclaration, expressionReceiver, initializer, context);
188 return typeInfo.replaceType(components.dataFlowAnalyzer.checkStatementType(multiDeclaration, context));
189 }
190
191 @Override
192 public JetTypeInfo visitNamedFunction(@NotNull JetNamedFunction function, ExpressionTypingContext context) {
193 return functions.visitNamedFunction(function, context, true, scope);
194 }
195
196 @Override
197 public JetTypeInfo visitClass(@NotNull JetClass klass, ExpressionTypingContext context) {
198 components.localClassifierAnalyzer.processClassOrObject(
199 scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT),
200 scope.getOwnerDescriptor(),
201 klass);
202 return TypeInfoFactoryPackage.createTypeInfo(components.dataFlowAnalyzer.checkStatementType(klass, context), context);
203 }
204
205 @Override
206 public JetTypeInfo visitTypedef(@NotNull JetTypedef typedef, ExpressionTypingContext context) {
207 context.trace.report(UNSUPPORTED.on(typedef, "Typedefs are not supported"));
208 return super.visitTypedef(typedef, context);
209 }
210
211 @Override
212 public JetTypeInfo visitDeclaration(@NotNull JetDeclaration dcl, ExpressionTypingContext context) {
213 return TypeInfoFactoryPackage.createTypeInfo(components.dataFlowAnalyzer.checkStatementType(dcl, context), context);
214 }
215
216 @Override
217 public JetTypeInfo visitBinaryExpression(@NotNull JetBinaryExpression expression, ExpressionTypingContext context) {
218 JetSimpleNameExpression operationSign = expression.getOperationReference();
219 IElementType operationType = operationSign.getReferencedNameElementType();
220 JetTypeInfo result;
221 if (operationType == JetTokens.EQ) {
222 result = visitAssignment(expression, context);
223 }
224 else if (OperatorConventions.ASSIGNMENT_OPERATIONS.containsKey(operationType)) {
225 result = visitAssignmentOperation(expression, context);
226 }
227 else {
228 return facade.getTypeInfo(expression, context);
229 }
230 return components.dataFlowAnalyzer.checkType(result, expression, context);
231 }
232
233 @NotNull
234 protected JetTypeInfo visitAssignmentOperation(JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
235 //There is a temporary binding trace for an opportunity to resolve set method for array if needed (the initial trace should be used there)
236 TemporaryTraceAndCache temporary = TemporaryTraceAndCache.create(
237 contextWithExpectedType, "trace to resolve array set method for binary expression", expression);
238 ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE)
239 .replaceTraceAndCache(temporary).replaceContextDependency(INDEPENDENT);
240
241 JetSimpleNameExpression operationSign = expression.getOperationReference();
242 IElementType operationType = operationSign.getReferencedNameElementType();
243 JetExpression leftOperand = expression.getLeft();
244 JetTypeInfo leftInfo = ExpressionTypingUtils.getTypeInfoOrNullType(leftOperand, context, facade);
245 JetType leftType = leftInfo.getType();
246
247 JetExpression right = expression.getRight();
248 JetExpression left = leftOperand == null ? null : JetPsiUtil.deparenthesize(leftOperand);
249 if (right == null || left == null) {
250 temporary.commit();
251 return leftInfo.clearType();
252 }
253
254 if (leftType == null) {
255 JetTypeInfo rightInfo = facade.getTypeInfo(right, context.replaceDataFlowInfo(leftInfo.getDataFlowInfo()));
256 context.trace.report(UNRESOLVED_REFERENCE.on(operationSign, operationSign));
257 temporary.commit();
258 return rightInfo.clearType();
259 }
260 ExpressionReceiver receiver = new ExpressionReceiver(left, leftType);
261
262 // We check that defined only one of '+=' and '+' operations, and call it (in the case '+' we then also assign)
263 // Check for '+='
264 Name name = OperatorConventions.ASSIGNMENT_OPERATIONS.get(operationType);
265 TemporaryTraceAndCache temporaryForAssignmentOperation = TemporaryTraceAndCache.create(
266 context, "trace to check assignment operation like '+=' for", expression);
267 OverloadResolutionResults<FunctionDescriptor> assignmentOperationDescriptors =
268 components.callResolver.resolveBinaryCall(
269 context.replaceTraceAndCache(temporaryForAssignmentOperation).replaceScope(scope),
270 receiver, expression, name
271 );
272 JetType assignmentOperationType = OverloadResolutionResultsUtil.getResultingType(assignmentOperationDescriptors,
273 context.contextDependency);
274
275 OverloadResolutionResults<FunctionDescriptor> binaryOperationDescriptors;
276 JetType binaryOperationType;
277 TemporaryTraceAndCache temporaryForBinaryOperation = TemporaryTraceAndCache.create(
278 context, "trace to check binary operation like '+' for", expression);
279 TemporaryBindingTrace ignoreReportsTrace = TemporaryBindingTrace.create(context.trace, "Trace for checking assignability");
280 boolean lhsAssignable = basic.checkLValue(ignoreReportsTrace, context, left, right);
281 if (assignmentOperationType == null || lhsAssignable) {
282 // Check for '+'
283 Name counterpartName = OperatorConventions.BINARY_OPERATION_NAMES.get(OperatorConventions.ASSIGNMENT_OPERATION_COUNTERPARTS.get(operationType));
284 binaryOperationDescriptors = components.callResolver.resolveBinaryCall(
285 context.replaceTraceAndCache(temporaryForBinaryOperation).replaceScope(scope),
286 receiver, expression, counterpartName
287 );
288 binaryOperationType = OverloadResolutionResultsUtil.getResultingType(binaryOperationDescriptors, context.contextDependency);
289 }
290 else {
291 binaryOperationDescriptors = OverloadResolutionResultsImpl.nameNotFound();
292 binaryOperationType = null;
293 }
294
295 JetType type = assignmentOperationType != null ? assignmentOperationType : binaryOperationType;
296 JetTypeInfo rightInfo = leftInfo;
297 if (assignmentOperationDescriptors.isSuccess() && binaryOperationDescriptors.isSuccess()) {
298 // Both 'plus()' and 'plusAssign()' available => ambiguity
299 OverloadResolutionResults<FunctionDescriptor> ambiguityResolutionResults = OverloadResolutionResultsUtil.ambiguity(assignmentOperationDescriptors, binaryOperationDescriptors);
300 context.trace.report(ASSIGN_OPERATOR_AMBIGUITY.on(operationSign, ambiguityResolutionResults.getResultingCalls()));
301 Collection<DeclarationDescriptor> descriptors = Sets.newHashSet();
302 for (ResolvedCall<?> resolvedCall : ambiguityResolutionResults.getResultingCalls()) {
303 descriptors.add(resolvedCall.getResultingDescriptor());
304 }
305 rightInfo = facade.getTypeInfo(right, context.replaceDataFlowInfo(leftInfo.getDataFlowInfo()));
306 context.trace.record(AMBIGUOUS_REFERENCE_TARGET, operationSign, descriptors);
307 }
308 else if (assignmentOperationType != null && (assignmentOperationDescriptors.isSuccess() || !binaryOperationDescriptors.isSuccess())) {
309 // There's 'plusAssign()', so we do a.plusAssign(b)
310 temporaryForAssignmentOperation.commit();
311 if (!JetTypeChecker.DEFAULT.equalTypes(components.builtIns.getUnitType(), assignmentOperationType)) {
312 context.trace.report(ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT.on(operationSign, assignmentOperationDescriptors.getResultingDescriptor(), operationSign));
313 }
314 }
315 else {
316 // There's only 'plus()', so we try 'a = a + b'
317 temporaryForBinaryOperation.commit();
318 context.trace.record(VARIABLE_REASSIGNMENT, expression);
319 if (left instanceof JetArrayAccessExpression) {
320 ExpressionTypingContext contextForResolve = context.replaceScope(scope).replaceBindingTrace(TemporaryBindingTrace.create(
321 context.trace, "trace to resolve array set method for assignment", expression));
322 basic.resolveArrayAccessSetMethod((JetArrayAccessExpression) left, right, contextForResolve, context.trace);
323 }
324 rightInfo = facade.getTypeInfo(right, context.replaceDataFlowInfo(leftInfo.getDataFlowInfo()));
325 components.dataFlowAnalyzer.checkType(binaryOperationType, expression, context.replaceExpectedType(leftType).replaceDataFlowInfo(rightInfo.getDataFlowInfo()));
326 basic.checkLValue(context.trace, context, leftOperand, right);
327 }
328 temporary.commit();
329 return rightInfo.replaceType(checkAssignmentType(type, expression, contextWithExpectedType));
330 }
331
332 @NotNull
333 protected JetTypeInfo visitAssignment(JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
334 final ExpressionTypingContext context =
335 contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceScope(scope).replaceContextDependency(INDEPENDENT);
336 JetExpression leftOperand = expression.getLeft();
337 JetExpression left = deparenthesizeWithResolutionStrategy(leftOperand, new Function<JetTypeReference, Void>() {
338 @Override
339 public Void apply(JetTypeReference reference) {
340 components.typeResolver.resolveType(context.scope, reference, context.trace, true);
341 return null;
342 }
343 });
344 JetExpression right = expression.getRight();
345 if (left instanceof JetArrayAccessExpression) {
346 JetArrayAccessExpression arrayAccessExpression = (JetArrayAccessExpression) left;
347 if (right == null) return TypeInfoFactoryPackage.noTypeInfo(context);
348 JetTypeInfo typeInfo = basic.resolveArrayAccessSetMethod(arrayAccessExpression, right, context, context.trace);
349 basic.checkLValue(context.trace, context, arrayAccessExpression, right);
350 return typeInfo.replaceType(checkAssignmentType(typeInfo.getType(), expression, contextWithExpectedType));
351 }
352 JetTypeInfo leftInfo = ExpressionTypingUtils.getTypeInfoOrNullType(left, context, facade);
353 JetType leftType = leftInfo.getType();
354 DataFlowInfo dataFlowInfo = leftInfo.getDataFlowInfo();
355 JetTypeInfo resultInfo;
356 if (right != null) {
357 resultInfo = facade.getTypeInfo(right, context.replaceDataFlowInfo(dataFlowInfo).replaceExpectedType(leftType));
358 dataFlowInfo = resultInfo.getDataFlowInfo();
359 JetType rightType = resultInfo.getType();
360 if (left != null && leftType != null && rightType != null) {
361 DataFlowValue leftValue = DataFlowValueFactory.createDataFlowValue(left, leftType, context);
362 DataFlowValue rightValue = DataFlowValueFactory.createDataFlowValue(right, rightType, context);
363 // We cannot say here anything new about rightValue except it has the same value as leftValue
364 resultInfo = resultInfo.replaceDataFlowInfo(dataFlowInfo.assign(leftValue, rightValue));
365 }
366 }
367 else {
368 resultInfo = leftInfo;
369 }
370 if (leftType != null && leftOperand != null) { //if leftType == null, some other error has been generated
371 basic.checkLValue(context.trace, context, leftOperand, right);
372 }
373 return resultInfo.replaceType(components.dataFlowAnalyzer.checkStatementType(expression, contextWithExpectedType));
374 }
375
376
377 @Override
378 public JetTypeInfo visitExpression(@NotNull JetExpression expression, ExpressionTypingContext context) {
379 return facade.getTypeInfo(expression, context);
380 }
381
382 @Override
383 public JetTypeInfo visitJetElement(@NotNull JetElement element, ExpressionTypingContext context) {
384 context.trace.report(UNSUPPORTED.on(element, "in a block"));
385 return TypeInfoFactoryPackage.noTypeInfo(context);
386 }
387
388 @Override
389 public JetTypeInfo visitWhileExpression(@NotNull JetWhileExpression expression, ExpressionTypingContext context) {
390 return controlStructures.visitWhileExpression(expression, context, true);
391 }
392
393 @Override
394 public JetTypeInfo visitDoWhileExpression(@NotNull JetDoWhileExpression expression, ExpressionTypingContext context) {
395 return controlStructures.visitDoWhileExpression(expression, context, true);
396 }
397
398 @Override
399 public JetTypeInfo visitForExpression(@NotNull JetForExpression expression, ExpressionTypingContext context) {
400 return controlStructures.visitForExpression(expression, context, true);
401 }
402
403 @Override
404 public JetTypeInfo visitAnnotatedExpression(
405 @NotNull JetAnnotatedExpression expression, ExpressionTypingContext data
406 ) {
407 return basic.visitAnnotatedExpression(expression, data, true);
408 }
409
410 @Override
411 public JetTypeInfo visitIfExpression(@NotNull JetIfExpression expression, ExpressionTypingContext context) {
412 return controlStructures.visitIfExpression(expression, context, true);
413 }
414
415 @Override
416 public JetTypeInfo visitWhenExpression(@NotNull JetWhenExpression expression, ExpressionTypingContext context) {
417 return patterns.visitWhenExpression(expression, context, true);
418 }
419
420 @Override
421 public JetTypeInfo visitBlockExpression(@NotNull JetBlockExpression expression, ExpressionTypingContext context) {
422 return components.expressionTypingServices.getBlockReturnedType(expression, context, true);
423 }
424
425 @Override
426 public JetTypeInfo visitLabeledExpression(@NotNull JetLabeledExpression expression, ExpressionTypingContext context) {
427 return basic.visitLabeledExpression(expression, context, true);
428 }
429 }