001 /*
002 * Copyright 2010-2013 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.jet.lang.types.expressions;
018
019 import com.google.common.collect.Sets;
020 import com.intellij.psi.tree.IElementType;
021 import org.jetbrains.annotations.NotNull;
022 import org.jetbrains.annotations.Nullable;
023 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
024 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
025 import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
026 import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
027 import org.jetbrains.jet.lang.diagnostics.Errors;
028 import org.jetbrains.jet.lang.psi.*;
029 import org.jetbrains.jet.lang.resolve.*;
030 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
031 import org.jetbrains.jet.lang.resolve.calls.context.TemporaryTraceAndCache;
032 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
033 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
034 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsUtil;
035 import org.jetbrains.jet.lang.resolve.name.Name;
036 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
037 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
038 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
039 import org.jetbrains.jet.lang.types.JetType;
040 import org.jetbrains.jet.lang.types.JetTypeInfo;
041 import org.jetbrains.jet.lang.types.TypeUtils;
042 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
043 import org.jetbrains.jet.lexer.JetTokens;
044
045 import java.util.Collection;
046
047 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
048 import static org.jetbrains.jet.lang.resolve.BindingContext.AMBIGUOUS_REFERENCE_TARGET;
049 import static org.jetbrains.jet.lang.resolve.BindingContext.VARIABLE_REASSIGNMENT;
050 import static org.jetbrains.jet.lang.resolve.calls.context.ContextDependency.INDEPENDENT;
051 import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
052 import static org.jetbrains.jet.lang.types.TypeUtils.noExpectedType;
053
054 @SuppressWarnings("SuspiciousMethodCalls")
055 public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisitor {
056 private final WritableScope scope;
057 private final BasicExpressionTypingVisitor basic;
058 private final ControlStructureTypingVisitor controlStructures;
059 private final PatternMatchingTypingVisitor patterns;
060
061 public ExpressionTypingVisitorForStatements(
062 @NotNull ExpressionTypingInternals facade,
063 @NotNull WritableScope scope,
064 BasicExpressionTypingVisitor basic,
065 @NotNull ControlStructureTypingVisitor controlStructures,
066 @NotNull PatternMatchingTypingVisitor patterns) {
067 super(facade);
068 this.scope = scope;
069 this.basic = basic;
070 this.controlStructures = controlStructures;
071 this.patterns = patterns;
072 }
073
074 @Nullable
075 private static JetType checkAssignmentType(
076 @Nullable JetType assignmentType,
077 @NotNull JetBinaryExpression expression,
078 @NotNull ExpressionTypingContext context
079 ) {
080 if (assignmentType != null && !KotlinBuiltIns.getInstance().isUnit(assignmentType) && !noExpectedType(context.expectedType) &&
081 TypeUtils.equalTypes(context.expectedType, assignmentType)) {
082 context.trace.report(Errors.ASSIGNMENT_TYPE_MISMATCH.on(expression, context.expectedType));
083 return null;
084 }
085 return DataFlowUtils.checkStatementType(expression, context);
086 }
087
088 @Override
089 public JetTypeInfo visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, ExpressionTypingContext context) {
090 TopDownAnalyzer.processClassOrObject(
091 components.globalContext,
092 scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), declaration);
093 return DataFlowUtils.checkStatementType(declaration, context, context.dataFlowInfo);
094 }
095
096 @Override
097 public JetTypeInfo visitProperty(@NotNull JetProperty property, ExpressionTypingContext typingContext) {
098 ExpressionTypingContext context = typingContext.replaceContextDependency(INDEPENDENT).replaceScope(scope);
099 JetTypeReference receiverTypeRef = property.getReceiverTypeRef();
100 if (receiverTypeRef != null) {
101 context.trace.report(LOCAL_EXTENSION_PROPERTY.on(receiverTypeRef));
102 }
103
104 JetPropertyAccessor getter = property.getGetter();
105 if (getter != null) {
106 context.trace.report(LOCAL_VARIABLE_WITH_GETTER.on(getter));
107 }
108
109 JetPropertyAccessor setter = property.getSetter();
110 if (setter != null) {
111 context.trace.report(LOCAL_VARIABLE_WITH_SETTER.on(setter));
112 }
113
114 JetExpression delegateExpression = property.getDelegateExpression();
115 if (delegateExpression != null) {
116 components.expressionTypingServices.getTypeInfo(delegateExpression, context);
117 context.trace.report(LOCAL_VARIABLE_WITH_DELEGATE.on(property.getDelegate()));
118 }
119
120 for (JetTypeParameter typeParameter : property.getTypeParameters()) {
121 AnnotationResolver.reportUnsupportedAnnotationForTypeParameter(typeParameter, context.trace);
122 }
123
124 VariableDescriptor propertyDescriptor = components.expressionTypingServices.getDescriptorResolver().
125 resolveLocalVariableDescriptor(scope, property, context.dataFlowInfo, context.trace);
126 JetExpression initializer = property.getInitializer();
127 DataFlowInfo dataFlowInfo = context.dataFlowInfo;
128 if (initializer != null) {
129 JetType outType = propertyDescriptor.getType();
130 JetTypeInfo typeInfo = facade.getTypeInfo(initializer, context.replaceExpectedType(outType));
131 dataFlowInfo = typeInfo.getDataFlowInfo();
132 }
133
134 {
135 VariableDescriptor olderVariable = scope.getLocalVariable(propertyDescriptor.getName());
136 ExpressionTypingUtils.checkVariableShadowing(context, propertyDescriptor, olderVariable);
137 }
138
139 scope.addVariableDescriptor(propertyDescriptor);
140 ModifiersChecker.create(context.trace).checkModifiersForLocalDeclaration(property);
141 return DataFlowUtils.checkStatementType(property, context, dataFlowInfo);
142 }
143
144 @Override
145 public JetTypeInfo visitMultiDeclaration(@NotNull JetMultiDeclaration multiDeclaration, ExpressionTypingContext context) {
146 components.expressionTypingServices.getAnnotationResolver().resolveAnnotationsWithArguments(
147 scope, multiDeclaration.getModifierList(), context.trace);
148
149 JetExpression initializer = multiDeclaration.getInitializer();
150 if (initializer == null) {
151 context.trace.report(INITIALIZER_REQUIRED_FOR_MULTIDECLARATION.on(multiDeclaration));
152 return JetTypeInfo.create(null, context.dataFlowInfo);
153 }
154 ExpressionReceiver expressionReceiver = ExpressionTypingUtils.getExpressionReceiver(
155 facade, initializer, context.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT));
156 DataFlowInfo dataFlowInfo = facade.getTypeInfo(initializer, context).getDataFlowInfo();
157 if (expressionReceiver == null) {
158 return JetTypeInfo.create(null, dataFlowInfo);
159 }
160 components.expressionTypingUtils.defineLocalVariablesFromMultiDeclaration(scope, multiDeclaration, expressionReceiver, initializer, context);
161 return DataFlowUtils.checkStatementType(multiDeclaration, context, dataFlowInfo);
162 }
163
164 @Override
165 public JetTypeInfo visitNamedFunction(@NotNull JetNamedFunction function, ExpressionTypingContext context) {
166 SimpleFunctionDescriptor functionDescriptor = components.expressionTypingServices.getDescriptorResolver().
167 resolveFunctionDescriptorWithAnnotationArguments(
168 scope.getContainingDeclaration(), scope, function, context.trace, context.dataFlowInfo);
169
170 scope.addFunctionDescriptor(functionDescriptor);
171 JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace);
172 components.expressionTypingServices.checkFunctionReturnType(functionInnerScope, function, functionDescriptor, context.dataFlowInfo, null, context.trace);
173
174 components.expressionTypingServices.resolveValueParameters(function.getValueParameters(), functionDescriptor.getValueParameters(),
175 scope, context.dataFlowInfo, context.trace, /* needCompleteAnalysis = */ true);
176
177 ModifiersChecker.create(context.trace).checkModifiersForLocalDeclaration(function);
178 return DataFlowUtils.checkStatementType(function, context, context.dataFlowInfo);
179 }
180
181 @Override
182 public JetTypeInfo visitClass(@NotNull JetClass klass, ExpressionTypingContext context) {
183 TopDownAnalyzer.processClassOrObject(
184 components.globalContext,
185 scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), klass);
186 return DataFlowUtils.checkStatementType(klass, context, context.dataFlowInfo);
187 }
188
189 @Override
190 public JetTypeInfo visitTypedef(@NotNull JetTypedef typedef, ExpressionTypingContext context) {
191 context.trace.report(UNSUPPORTED.on(typedef, "Typedefs are not supported"));
192 return super.visitTypedef(typedef, context);
193 }
194
195 @Override
196 public JetTypeInfo visitDeclaration(@NotNull JetDeclaration dcl, ExpressionTypingContext context) {
197 return DataFlowUtils.checkStatementType(dcl, context, context.dataFlowInfo);
198 }
199
200 @Override
201 public JetTypeInfo visitBinaryExpression(@NotNull JetBinaryExpression expression, ExpressionTypingContext context) {
202 JetSimpleNameExpression operationSign = expression.getOperationReference();
203 IElementType operationType = operationSign.getReferencedNameElementType();
204 JetTypeInfo result;
205 if (operationType == JetTokens.EQ) {
206 result = visitAssignment(expression, context);
207 }
208 else if (OperatorConventions.ASSIGNMENT_OPERATIONS.containsKey(operationType)) {
209 result = visitAssignmentOperation(expression, context);
210 }
211 else {
212 return facade.getTypeInfo(expression, context);
213 }
214 return DataFlowUtils.checkType(result.getType(), expression, context, result.getDataFlowInfo());
215 }
216
217 @NotNull
218 protected JetTypeInfo visitAssignmentOperation(JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
219 //There is a temporary binding trace for an opportunity to resolve set method for array if needed (the initial trace should be used there)
220 TemporaryTraceAndCache temporary = TemporaryTraceAndCache.create(
221 contextWithExpectedType, "trace to resolve array set method for binary expression", expression);
222 ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE)
223 .replaceTraceAndCache(temporary).replaceContextDependency(INDEPENDENT);
224
225 JetSimpleNameExpression operationSign = expression.getOperationReference();
226 IElementType operationType = operationSign.getReferencedNameElementType();
227 JetExpression leftOperand = expression.getLeft();
228 JetTypeInfo leftInfo = ExpressionTypingUtils.getTypeInfoOrNullType(leftOperand, context, facade);
229 JetType leftType = leftInfo.getType();
230 DataFlowInfo dataFlowInfo = leftInfo.getDataFlowInfo();
231
232 JetExpression right = expression.getRight();
233 JetExpression left = leftOperand == null ? null : JetPsiUtil.deparenthesize(leftOperand);
234 if (right == null || left == null) {
235 temporary.commit();
236 return JetTypeInfo.create(null, dataFlowInfo);
237 }
238
239 if (leftType == null) {
240 dataFlowInfo = facade.getTypeInfo(right, context.replaceDataFlowInfo(dataFlowInfo)).getDataFlowInfo();
241 context.trace.report(UNRESOLVED_REFERENCE.on(operationSign, operationSign));
242 temporary.commit();
243 return JetTypeInfo.create(null, dataFlowInfo);
244 }
245 ExpressionReceiver receiver = new ExpressionReceiver(left, leftType);
246
247 // We check that defined only one of '+=' and '+' operations, and call it (in the case '+' we then also assign)
248 // Check for '+='
249 Name name = OperatorConventions.ASSIGNMENT_OPERATIONS.get(operationType);
250 TemporaryTraceAndCache temporaryForAssignmentOperation = TemporaryTraceAndCache.create(
251 context, "trace to check assignment operation like '+=' for", expression);
252 OverloadResolutionResults<FunctionDescriptor> assignmentOperationDescriptors =
253 components.callResolver.resolveBinaryCall(
254 context.replaceTraceAndCache(temporaryForAssignmentOperation).replaceScope(scope),
255 receiver, expression, name
256 );
257 JetType assignmentOperationType = OverloadResolutionResultsUtil.getResultingType(assignmentOperationDescriptors,
258 context.contextDependency);
259
260 // Check for '+'
261 Name counterpartName = OperatorConventions.BINARY_OPERATION_NAMES.get(OperatorConventions.ASSIGNMENT_OPERATION_COUNTERPARTS.get(operationType));
262 TemporaryTraceAndCache temporaryForBinaryOperation = TemporaryTraceAndCache.create(
263 context, "trace to check binary operation like '+' for", expression);
264 OverloadResolutionResults<FunctionDescriptor> binaryOperationDescriptors = components.callResolver.resolveBinaryCall(
265 context.replaceTraceAndCache(temporaryForBinaryOperation).replaceScope(scope),
266 receiver, expression, counterpartName
267 );
268 JetType binaryOperationType = OverloadResolutionResultsUtil.getResultingType(binaryOperationDescriptors, context.contextDependency);
269
270 JetType type = assignmentOperationType != null ? assignmentOperationType : binaryOperationType;
271 if (assignmentOperationDescriptors.isSuccess() && binaryOperationDescriptors.isSuccess()) {
272 // Both 'plus()' and 'plusAssign()' available => ambiguity
273 OverloadResolutionResults<FunctionDescriptor> ambiguityResolutionResults = OverloadResolutionResultsUtil.ambiguity(assignmentOperationDescriptors, binaryOperationDescriptors);
274 context.trace.report(ASSIGN_OPERATOR_AMBIGUITY.on(operationSign, ambiguityResolutionResults.getResultingCalls()));
275 Collection<DeclarationDescriptor> descriptors = Sets.newHashSet();
276 for (ResolvedCall<?> resolvedCall : ambiguityResolutionResults.getResultingCalls()) {
277 descriptors.add(resolvedCall.getResultingDescriptor());
278 }
279 dataFlowInfo = facade.getTypeInfo(right, context.replaceDataFlowInfo(dataFlowInfo)).getDataFlowInfo();
280 context.trace.record(AMBIGUOUS_REFERENCE_TARGET, operationSign, descriptors);
281 }
282 else if (assignmentOperationType != null && (assignmentOperationDescriptors.isSuccess() || !binaryOperationDescriptors.isSuccess())) {
283 // There's 'plusAssign()', so we do a.plusAssign(b)
284 temporaryForAssignmentOperation.commit();
285 if (!KotlinBuiltIns.getInstance().isUnit(assignmentOperationType)) {
286 context.trace.report(ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT.on(operationSign, assignmentOperationDescriptors.getResultingDescriptor(), operationSign));
287 }
288 }
289 else {
290 // There's only 'plus()', so we try 'a = a + b'
291 temporaryForBinaryOperation.commit();
292 context.trace.record(VARIABLE_REASSIGNMENT, expression);
293 if (left instanceof JetArrayAccessExpression) {
294 ExpressionTypingContext contextForResolve = context.replaceScope(scope).replaceBindingTrace(TemporaryBindingTrace.create(
295 context.trace, "trace to resolve array set method for assignment", expression));
296 basic.resolveArrayAccessSetMethod((JetArrayAccessExpression) left, right, contextForResolve, context.trace);
297 }
298 dataFlowInfo = facade.getTypeInfo(right, context.replaceDataFlowInfo(dataFlowInfo)).getDataFlowInfo();
299 BasicExpressionTypingVisitor.checkLValue(context.trace, leftOperand);
300 }
301 temporary.commit();
302 return JetTypeInfo.create(checkAssignmentType(type, expression, contextWithExpectedType), dataFlowInfo);
303 }
304
305 @NotNull
306 protected JetTypeInfo visitAssignment(JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
307 ExpressionTypingContext context =
308 contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceScope(scope).replaceContextDependency(INDEPENDENT);
309 JetExpression leftOperand = expression.getLeft();
310 JetExpression left = components.expressionTypingServices.deparenthesizeWithTypeResolution(leftOperand, context);
311 JetExpression right = expression.getRight();
312 if (left instanceof JetArrayAccessExpression) {
313 JetArrayAccessExpression arrayAccessExpression = (JetArrayAccessExpression) left;
314 if (right == null) return JetTypeInfo.create(null, context.dataFlowInfo);
315 JetTypeInfo typeInfo = basic.resolveArrayAccessSetMethod(arrayAccessExpression, right, context, context.trace);
316 BasicExpressionTypingVisitor.checkLValue(context.trace, arrayAccessExpression);
317 return JetTypeInfo.create(checkAssignmentType(typeInfo.getType(), expression, contextWithExpectedType),
318 typeInfo.getDataFlowInfo());
319 }
320 JetTypeInfo leftInfo = ExpressionTypingUtils.getTypeInfoOrNullType(left, context, facade);
321 JetType leftType = leftInfo.getType();
322 DataFlowInfo dataFlowInfo = leftInfo.getDataFlowInfo();
323 if (right != null) {
324 JetTypeInfo rightInfo = facade.getTypeInfo(right, context.replaceDataFlowInfo(dataFlowInfo).replaceExpectedType(leftType));
325 dataFlowInfo = rightInfo.getDataFlowInfo();
326 }
327 if (leftType != null && leftOperand != null) { //if leftType == null, some other error has been generated
328 BasicExpressionTypingVisitor.checkLValue(context.trace, leftOperand);
329 }
330 return DataFlowUtils.checkStatementType(expression, contextWithExpectedType, dataFlowInfo);
331 }
332
333
334 @Override
335 public JetTypeInfo visitExpression(@NotNull JetExpression expression, ExpressionTypingContext context) {
336 return facade.getTypeInfo(expression, context);
337 }
338
339 @Override
340 public JetTypeInfo visitJetElement(@NotNull JetElement element, ExpressionTypingContext context) {
341 context.trace.report(UNSUPPORTED.on(element, "in a block"));
342 return JetTypeInfo.create(null, context.dataFlowInfo);
343 }
344
345 @Override
346 public JetTypeInfo visitWhileExpression(@NotNull JetWhileExpression expression, ExpressionTypingContext context) {
347 return controlStructures.visitWhileExpression(expression, context, true);
348 }
349
350 @Override
351 public JetTypeInfo visitDoWhileExpression(@NotNull JetDoWhileExpression expression, ExpressionTypingContext context) {
352 return controlStructures.visitDoWhileExpression(expression, context, true);
353 }
354
355 @Override
356 public JetTypeInfo visitForExpression(@NotNull JetForExpression expression, ExpressionTypingContext context) {
357 return controlStructures.visitForExpression(expression, context, true);
358 }
359
360 @Override
361 public JetTypeInfo visitAnnotatedExpression(
362 @NotNull JetAnnotatedExpression expression, ExpressionTypingContext data
363 ) {
364 return basic.visitAnnotatedExpression(expression, data, true);
365 }
366
367 @Override
368 public JetTypeInfo visitIfExpression(@NotNull JetIfExpression expression, ExpressionTypingContext context) {
369 return controlStructures.visitIfExpression(expression, context, true);
370 }
371
372 @Override
373 public JetTypeInfo visitWhenExpression(@NotNull JetWhenExpression expression, ExpressionTypingContext context) {
374 return patterns.visitWhenExpression(expression, context, true);
375 }
376
377 @Override
378 public JetTypeInfo visitBlockExpression(@NotNull JetBlockExpression expression, ExpressionTypingContext context) {
379 return components.expressionTypingServices.getBlockReturnedType(expression, context, true);
380 }
381
382 @Override
383 public JetTypeInfo visitParenthesizedExpression(@NotNull JetParenthesizedExpression expression, ExpressionTypingContext context) {
384 return basic.visitParenthesizedExpression(expression, context, true);
385 }
386
387 @Override
388 public JetTypeInfo visitUnaryExpression(@NotNull JetUnaryExpression expression, ExpressionTypingContext context) {
389 return basic.visitUnaryExpression(expression, context, true);
390 }
391 }