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.resolve.calls;
018
019 import com.intellij.lang.ASTNode;
020 import org.jetbrains.annotations.NotNull;
021 import org.jetbrains.annotations.Nullable;
022 import org.jetbrains.jet.lang.descriptors.*;
023 import org.jetbrains.jet.lang.psi.*;
024 import org.jetbrains.jet.lang.resolve.BindingContext;
025 import org.jetbrains.jet.lang.resolve.BindingTrace;
026 import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace;
027 import org.jetbrains.jet.lang.resolve.calls.context.*;
028 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
029 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
030 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
031 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsImpl;
032 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsUtil;
033 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
034 import org.jetbrains.jet.lang.resolve.constants.ConstantUtils;
035 import org.jetbrains.jet.lang.resolve.name.Name;
036 import org.jetbrains.jet.lang.resolve.scopes.ChainedScope;
037 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
038 import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
039 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
040 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
041 import org.jetbrains.jet.lang.types.*;
042 import org.jetbrains.jet.lang.types.expressions.DataFlowUtils;
043 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
044 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
045 import org.jetbrains.jet.lexer.JetTokens;
046
047 import javax.inject.Inject;
048 import java.util.ArrayList;
049 import java.util.Collections;
050 import java.util.List;
051
052 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
053 import static org.jetbrains.jet.lang.resolve.BindingContext.*;
054 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getStaticNestedClassesScope;
055 import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
056
057 public class CallExpressionResolver {
058 @NotNull
059 private ExpressionTypingServices expressionTypingServices;
060
061 @Inject
062 public void setExpressionTypingServices(@NotNull ExpressionTypingServices expressionTypingServices) {
063 this.expressionTypingServices = expressionTypingServices;
064 }
065
066 @Nullable
067 private JetType lookupNamespaceOrClassObject(@NotNull JetSimpleNameExpression expression, @NotNull ResolutionContext context) {
068 Name referencedName = expression.getReferencedNameAsName();
069 final ClassifierDescriptor classifier = context.scope.getClassifier(referencedName);
070 if (classifier != null) {
071 JetType classObjectType = classifier.getClassObjectType();
072 if (classObjectType != null) {
073 context.trace.record(REFERENCE_TARGET, expression, classifier);
074 JetType result = getExtendedClassObjectType(classObjectType, referencedName, classifier, context);
075 return DataFlowUtils.checkType(result, expression, context);
076 }
077 }
078 JetType[] result = new JetType[1];
079 TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(
080 context.trace, "trace for namespace/class object lookup of name", referencedName);
081 if (furtherNameLookup(expression, result, context.replaceBindingTrace(temporaryTrace))) {
082 temporaryTrace.commit();
083 return DataFlowUtils.checkType(result[0], expression, context);
084 }
085 // To report NO_CLASS_OBJECT when no namespace found
086 if (classifier != null) {
087 if (classifier instanceof TypeParameterDescriptor) {
088 if (context.expressionPosition == ExpressionPosition.FREE) {
089 context.trace.report(TYPE_PARAMETER_IS_NOT_AN_EXPRESSION.on(expression, (TypeParameterDescriptor) classifier));
090 }
091 else {
092 context.trace.report(TYPE_PARAMETER_ON_LHS_OF_DOT.on(expression, (TypeParameterDescriptor) classifier));
093 }
094 }
095 else if (context.expressionPosition == ExpressionPosition.FREE) {
096 context.trace.report(NO_CLASS_OBJECT.on(expression, classifier));
097 }
098 context.trace.record(REFERENCE_TARGET, expression, classifier);
099 JetScope scopeForStaticMembersResolution =
100 classifier instanceof ClassDescriptor
101 ? getStaticNestedClassesScope((ClassDescriptor) classifier)
102 : new JetScopeImpl() {
103 @NotNull
104 @Override
105 public DeclarationDescriptor getContainingDeclaration() {
106 return classifier;
107 }
108
109 @Override
110 public String toString() {
111 return "Scope for the type parameter on the left hand side of dot";
112 }
113 };
114 return new NamespaceType(referencedName, scopeForStaticMembersResolution);
115 }
116 temporaryTrace.commit();
117 return result[0];
118 }
119
120 @NotNull
121 private JetType getExtendedClassObjectType(
122 @NotNull JetType classObjectType,
123 @NotNull Name referencedName,
124 @NotNull ClassifierDescriptor classifier,
125 @NotNull ResolutionContext context
126 ) {
127 if (context.expressionPosition == ExpressionPosition.LHS_OF_DOT && classifier instanceof ClassDescriptor) {
128 List<JetScope> scopes = new ArrayList<JetScope>(3);
129
130 scopes.add(classObjectType.getMemberScope());
131 scopes.add(getStaticNestedClassesScope((ClassDescriptor) classifier));
132
133 NamespaceDescriptor namespace = context.scope.getNamespace(referencedName);
134 if (namespace != null) {
135 //for enums loaded from java binaries
136 scopes.add(namespace.getMemberScope());
137 }
138
139 JetScope scope = new ChainedScope(classifier, scopes.toArray(new JetScope[scopes.size()]));
140 return new NamespaceType(referencedName, scope);
141 }
142 return classObjectType;
143 }
144
145 private boolean furtherNameLookup(
146 @NotNull JetSimpleNameExpression expression,
147 @NotNull JetType[] result,
148 @NotNull ResolutionContext context
149 ) {
150 NamespaceType namespaceType = lookupNamespaceType(expression, context);
151 if (namespaceType == null) {
152 return false;
153 }
154 if (context.expressionPosition == ExpressionPosition.LHS_OF_DOT) {
155 result[0] = namespaceType;
156 return true;
157 }
158 context.trace.report(EXPRESSION_EXPECTED_NAMESPACE_FOUND.on(expression));
159 result[0] = ErrorUtils.createErrorType("Type for " + expression.getReferencedNameAsName());
160 return false;
161 }
162
163 @Nullable
164 private NamespaceType lookupNamespaceType(@NotNull JetSimpleNameExpression expression, @NotNull ResolutionContext context) {
165 Name name = expression.getReferencedNameAsName();
166 NamespaceDescriptor namespace = context.scope.getNamespace(name);
167 if (namespace == null) {
168 return null;
169 }
170 context.trace.record(REFERENCE_TARGET, expression, namespace);
171
172 // Construct a NamespaceType with everything from the namespace and with nested classes of the corresponding class (if any)
173 JetScope scope;
174 ClassifierDescriptor classifier = context.scope.getClassifier(name);
175 if (classifier instanceof ClassDescriptor) {
176 scope = new ChainedScope(namespace, namespace.getMemberScope(), getStaticNestedClassesScope((ClassDescriptor) classifier));
177 }
178 else {
179 scope = namespace.getMemberScope();
180 }
181 return new NamespaceType(name, scope);
182 }
183
184 @Nullable
185 public ResolvedCallWithTrace<FunctionDescriptor> getResolvedCallForFunction(
186 @NotNull Call call, @NotNull JetExpression callExpression,
187 @NotNull ResolutionContext context, @NotNull CheckValueArgumentsMode checkArguments,
188 @NotNull boolean[] result
189 ) {
190 CallResolver callResolver = expressionTypingServices.getCallResolver();
191 OverloadResolutionResultsImpl<FunctionDescriptor> results = callResolver.resolveFunctionCall(
192 BasicCallResolutionContext.create(context, call, checkArguments));
193 if (!results.isNothing()) {
194 checkSuper(call.getExplicitReceiver(), results, context.trace, callExpression);
195 result[0] = true;
196 return OverloadResolutionResultsUtil.getResultingCall(results, context.contextDependency);
197 }
198 result[0] = false;
199 return null;
200 }
201
202 @Nullable
203 private JetType getVariableType(@NotNull JetSimpleNameExpression nameExpression, @NotNull ReceiverValue receiver,
204 @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context, @NotNull boolean[] result
205 ) {
206 TemporaryTraceAndCache temporaryForVariable = TemporaryTraceAndCache.create(
207 context, "trace to resolve as local variable or property", nameExpression);
208 CallResolver callResolver = expressionTypingServices.getCallResolver();
209 Call call = CallMaker.makePropertyCall(receiver, callOperationNode, nameExpression);
210 BasicCallResolutionContext contextForVariable = BasicCallResolutionContext.create(
211 context.replaceTraceAndCache(temporaryForVariable),
212 call, CheckValueArgumentsMode.ENABLED);
213 OverloadResolutionResults<VariableDescriptor> resolutionResult = callResolver.resolveSimpleProperty(contextForVariable);
214 if (!resolutionResult.isNothing()) {
215 temporaryForVariable.commit();
216 checkSuper(receiver, resolutionResult, context.trace, nameExpression);
217 result[0] = true;
218 return resolutionResult.isSingleResult() ? resolutionResult.getResultingDescriptor().getReturnType() : null;
219 }
220
221 ResolutionContext newContext = receiver.exists()
222 ? context.replaceScope(receiver.getType().getMemberScope())
223 : context;
224 TemporaryTraceAndCache temporaryForNamespaceOrClassObject = TemporaryTraceAndCache.create(
225 context, "trace to resolve as namespace or class object", nameExpression);
226 JetType jetType = lookupNamespaceOrClassObject(nameExpression, newContext.replaceTraceAndCache(temporaryForNamespaceOrClassObject));
227 if (jetType != null) {
228 temporaryForNamespaceOrClassObject.commit();
229
230 // Uncommitted changes in temp context
231 context.trace.record(RESOLUTION_SCOPE, nameExpression, context.scope);
232 if (context.dataFlowInfo.hasTypeInfoConstraints()) {
233 context.trace.record(NON_DEFAULT_EXPRESSION_DATA_FLOW, nameExpression, context.dataFlowInfo);
234 }
235 result[0] = true;
236 return jetType;
237 }
238 temporaryForVariable.commit();
239 result[0] = false;
240 return null;
241 }
242
243 @NotNull
244 public JetTypeInfo getSimpleNameExpressionTypeInfo(@NotNull JetSimpleNameExpression nameExpression, @NotNull ReceiverValue receiver,
245 @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context
246 ) {
247 boolean[] result = new boolean[1];
248
249 TemporaryTraceAndCache temporaryForVariable = TemporaryTraceAndCache.create(
250 context, "trace to resolve as variable", nameExpression);
251 JetType type = getVariableType(nameExpression, receiver, callOperationNode, context.replaceTraceAndCache(temporaryForVariable), result);
252 if (result[0]) {
253 temporaryForVariable.commit();
254 if (type instanceof NamespaceType && context.expressionPosition == ExpressionPosition.FREE) {
255 type = null;
256 }
257 return JetTypeInfo.create(type, context.dataFlowInfo);
258 }
259
260 Call call = CallMaker.makeCall(nameExpression, receiver, callOperationNode, nameExpression, Collections.<ValueArgument>emptyList());
261 TemporaryTraceAndCache temporaryForFunction = TemporaryTraceAndCache.create(
262 context, "trace to resolve as function", nameExpression);
263 ResolutionContext newContext = context.replaceTraceAndCache(temporaryForFunction);
264 ResolvedCall<FunctionDescriptor> resolvedCall = getResolvedCallForFunction(
265 call, nameExpression, newContext, CheckValueArgumentsMode.ENABLED, result);
266 if (result[0]) {
267 FunctionDescriptor functionDescriptor = resolvedCall != null ? resolvedCall.getResultingDescriptor() : null;
268 temporaryForFunction.commit();
269 boolean hasValueParameters = functionDescriptor == null || functionDescriptor.getValueParameters().size() > 0;
270 context.trace.report(FUNCTION_CALL_EXPECTED.on(nameExpression, nameExpression, hasValueParameters));
271 type = functionDescriptor != null ? functionDescriptor.getReturnType() : null;
272 return JetTypeInfo.create(type, context.dataFlowInfo);
273 }
274
275 temporaryForVariable.commit();
276 return JetTypeInfo.create(null, context.dataFlowInfo);
277 }
278
279 @NotNull
280 public JetTypeInfo getCallExpressionTypeInfo(
281 @NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver,
282 @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context
283 ) {
284 JetTypeInfo typeInfo = getCallExpressionTypeInfoWithoutFinalTypeCheck(
285 callExpression, receiver, callOperationNode, context);
286 if (context.contextDependency == ContextDependency.INDEPENDENT) {
287 DataFlowUtils.checkType(typeInfo, callExpression, context);
288 }
289 return typeInfo;
290 }
291
292 @NotNull
293 public JetTypeInfo getCallExpressionTypeInfoWithoutFinalTypeCheck(
294 @NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver,
295 @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context
296 ) {
297 boolean[] result = new boolean[1];
298 Call call = CallMaker.makeCall(receiver, callOperationNode, callExpression);
299
300 TemporaryTraceAndCache temporaryForFunction = TemporaryTraceAndCache.create(
301 context, "trace to resolve as function call", callExpression);
302 ResolvedCallWithTrace<FunctionDescriptor> resolvedCall = getResolvedCallForFunction(
303 call, callExpression, context.replaceTraceAndCache(temporaryForFunction),
304 CheckValueArgumentsMode.ENABLED, result);
305 if (result[0]) {
306 FunctionDescriptor functionDescriptor = resolvedCall != null ? resolvedCall.getResultingDescriptor() : null;
307 temporaryForFunction.commit();
308 if (callExpression.getValueArgumentList() == null && callExpression.getFunctionLiteralArguments().isEmpty()) {
309 // there are only type arguments
310 boolean hasValueParameters = functionDescriptor == null || functionDescriptor.getValueParameters().size() > 0;
311 context.trace.report(FUNCTION_CALL_EXPECTED.on(callExpression, callExpression, hasValueParameters));
312 }
313 if (functionDescriptor == null) {
314 return JetTypeInfo.create(null, context.dataFlowInfo);
315 }
316 JetType type = functionDescriptor.getReturnType();
317
318 return JetTypeInfo.create(type, resolvedCall.getDataFlowInfoForArguments().getResultInfo());
319 }
320
321 JetExpression calleeExpression = callExpression.getCalleeExpression();
322 if (calleeExpression instanceof JetSimpleNameExpression && callExpression.getTypeArgumentList() == null) {
323 TemporaryTraceAndCache temporaryForVariable = TemporaryTraceAndCache.create(
324 context, "trace to resolve as variable with 'invoke' call", callExpression);
325 JetType type = getVariableType((JetSimpleNameExpression) calleeExpression, receiver, callOperationNode,
326 context.replaceTraceAndCache(temporaryForVariable), result);
327 if (result[0]) {
328 temporaryForVariable.commit();
329 context.trace.report(FUNCTION_EXPECTED.on((JetReferenceExpression) calleeExpression, calleeExpression,
330 type != null ? type : ErrorUtils.createErrorType("")));
331 return JetTypeInfo.create(null, context.dataFlowInfo);
332 }
333 }
334 temporaryForFunction.commit();
335 return JetTypeInfo.create(null, context.dataFlowInfo);
336 }
337
338 private void checkSuper(@NotNull ReceiverValue receiverValue, @NotNull OverloadResolutionResults<? extends CallableDescriptor> results,
339 @NotNull BindingTrace trace, @NotNull JetExpression expression) {
340 if (!results.isSingleResult()) return;
341 if (!(receiverValue instanceof ExpressionReceiver)) return;
342 JetExpression receiver = ((ExpressionReceiver) receiverValue).getExpression();
343 CallableDescriptor descriptor = results.getResultingDescriptor();
344 if (receiver instanceof JetSuperExpression && descriptor instanceof MemberDescriptor) {
345 if (((MemberDescriptor) descriptor).getModality() == Modality.ABSTRACT) {
346 trace.report(ABSTRACT_SUPER_CALL.on(expression));
347 }
348 }
349 }
350
351 @NotNull
352 private JetTypeInfo getSelectorReturnTypeInfo(
353 @NotNull ReceiverValue receiver,
354 @Nullable ASTNode callOperationNode,
355 @NotNull JetExpression selectorExpression,
356 @NotNull ResolutionContext context
357 ) {
358 if (selectorExpression instanceof JetCallExpression) {
359 return getCallExpressionTypeInfoWithoutFinalTypeCheck((JetCallExpression) selectorExpression, receiver,
360 callOperationNode, context);
361 }
362 else if (selectorExpression instanceof JetSimpleNameExpression) {
363 return getSimpleNameExpressionTypeInfo((JetSimpleNameExpression) selectorExpression, receiver, callOperationNode, context);
364 }
365 else {
366 context.trace.report(ILLEGAL_SELECTOR.on(selectorExpression, selectorExpression.getText()));
367 }
368 return JetTypeInfo.create(null, context.dataFlowInfo);
369 }
370
371 @NotNull
372 public JetTypeInfo getQualifiedExpressionTypeInfo(
373 @NotNull JetQualifiedExpression expression, @NotNull ResolutionContext context
374 ) {
375 // TODO : functions as values
376 JetExpression selectorExpression = expression.getSelectorExpression();
377 JetExpression receiverExpression = expression.getReceiverExpression();
378 ResolutionContext contextForReceiver = context
379 .replaceExpectedType(NO_EXPECTED_TYPE).replaceExpressionPosition(ExpressionPosition.LHS_OF_DOT)
380 .replaceContextDependency(ContextDependency.INDEPENDENT);
381 JetTypeInfo receiverTypeInfo = expressionTypingServices.getTypeInfo(receiverExpression, contextForReceiver);
382 JetType receiverType = receiverTypeInfo.getType();
383 if (selectorExpression == null) return JetTypeInfo.create(null, context.dataFlowInfo);
384 if (receiverType == null) receiverType = ErrorUtils.createErrorType("Type for " + expression.getText());
385
386 context = context.replaceDataFlowInfo(receiverTypeInfo.getDataFlowInfo());
387
388 if (selectorExpression instanceof JetSimpleNameExpression) {
389 ConstantUtils.propagateConstantValues(expression, context.trace, (JetSimpleNameExpression) selectorExpression);
390 }
391
392 JetTypeInfo selectorReturnTypeInfo = getSelectorReturnTypeInfo(
393 new ExpressionReceiver(receiverExpression, receiverType),
394 expression.getOperationTokenNode(), selectorExpression, context);
395 JetType selectorReturnType = selectorReturnTypeInfo.getType();
396
397 //TODO move further
398 if (!(receiverType instanceof NamespaceType) && expression.getOperationSign() == JetTokens.SAFE_ACCESS) {
399 if (selectorReturnType != null && !selectorReturnType.isNullable() && !KotlinBuiltIns.getInstance().isUnit(selectorReturnType)) {
400 if (receiverType.isNullable()) {
401 selectorReturnType = TypeUtils.makeNullable(selectorReturnType);
402 }
403 }
404 }
405
406 // TODO : this is suspicious: remove this code?
407 if (selectorReturnType != null) {
408 context.trace.record(BindingContext.EXPRESSION_TYPE, selectorExpression, selectorReturnType);
409 }
410 JetTypeInfo typeInfo = JetTypeInfo.create(selectorReturnType, selectorReturnTypeInfo.getDataFlowInfo());
411 if (context.contextDependency == ContextDependency.INDEPENDENT) {
412 DataFlowUtils.checkType(typeInfo, expression, context);
413 }
414 return typeInfo;
415 }
416 }