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.google.common.collect.Lists;
020 import org.jetbrains.annotations.NotNull;
021 import org.jetbrains.jet.lang.descriptors.*;
022 import org.jetbrains.jet.lang.psi.*;
023 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintPosition;
024 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem;
025 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
026 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
027 import org.jetbrains.jet.lang.types.*;
028 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
029
030 import java.util.Collections;
031 import java.util.List;
032
033 import static org.jetbrains.jet.lang.types.TypeUtils.DONT_CARE;
034
035 public class CallResolverUtil {
036 public static enum ResolveArgumentsMode {
037 RESOLVE_FUNCTION_ARGUMENTS,
038 SHAPE_FUNCTION_ARGUMENTS
039 }
040
041 private CallResolverUtil() {}
042
043
044 public static boolean hasUnknownFunctionParameter(@NotNull JetType type) {
045 assert KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(type);
046 List<TypeProjection> arguments = type.getArguments();
047 // last argument is return type of function type
048 List<TypeProjection> functionParameters = arguments.subList(0, arguments.size() - 1);
049 for (TypeProjection functionParameter : functionParameters) {
050 if (TypeUtils.containsSpecialType(functionParameter.getType(), DONT_CARE)
051 || ErrorUtils.containsUninferredParameter(functionParameter.getType())) {
052 return true;
053 }
054 }
055 return false;
056 }
057
058 public static boolean hasUnknownReturnType(@NotNull JetType type) {
059 assert KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(type);
060 JetType returnTypeFromFunctionType = KotlinBuiltIns.getInstance().getReturnTypeFromFunctionType(type);
061 return ErrorUtils.containsErrorType(returnTypeFromFunctionType);
062 }
063
064 public static JetType replaceReturnTypeByUnknown(@NotNull JetType type) {
065 assert KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(type);
066 List<TypeProjection> arguments = type.getArguments();
067 List<TypeProjection> newArguments = Lists.newArrayList();
068 newArguments.addAll(arguments.subList(0, arguments.size() - 1));
069 newArguments.add(new TypeProjectionImpl(Variance.INVARIANT, DONT_CARE));
070 return new JetTypeImpl(type.getAnnotations(), type.getConstructor(), type.isNullable(), newArguments, type.getMemberScope());
071 }
072
073 private static boolean hasReturnTypeDependentOnUninferredParams(
074 @NotNull CallableDescriptor candidateDescriptor,
075 @NotNull ConstraintSystem constraintSystem
076 ) {
077 JetType returnType = candidateDescriptor.getReturnType();
078 if (returnType == null) return false;
079
080 for (TypeParameterDescriptor typeVariable : constraintSystem.getTypeVariables()) {
081 JetType inferredValueForTypeVariable = constraintSystem.getTypeBounds(typeVariable).getValue();
082 if (inferredValueForTypeVariable == null) {
083 if (TypeUtils.dependsOnTypeParameters(returnType, Collections.singleton(typeVariable))) {
084 return true;
085 }
086 }
087 }
088 return false;
089 }
090
091 public static boolean hasInferredReturnType(
092 @NotNull CallableDescriptor candidateDescriptor,
093 @NotNull ConstraintSystem constraintSystem
094 ) {
095 if (hasReturnTypeDependentOnUninferredParams(candidateDescriptor, constraintSystem)) return false;
096
097 // Expected type mismatch was reported before as 'TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH'
098 if (constraintSystem.getStatus().hasOnlyErrorsFromPosition(ConstraintPosition.EXPECTED_TYPE_POSITION)) return false;
099 return true;
100 }
101
102 @NotNull
103 public static JetType getErasedReceiverType(
104 @NotNull ReceiverParameterDescriptor receiverParameterDescriptor,
105 @NotNull CallableDescriptor descriptor
106 ) {
107 JetType receiverType = receiverParameterDescriptor.getType();
108 for (TypeParameterDescriptor typeParameter : descriptor.getTypeParameters()) {
109 if (typeParameter.getTypeConstructor().equals(receiverType.getConstructor())) {
110 receiverType = typeParameter.getUpperBoundsAsType();
111 }
112 }
113 List<TypeProjection> fakeTypeArguments = Lists.newArrayList();
114 for (TypeProjection typeProjection : receiverType.getArguments()) {
115 fakeTypeArguments.add(new TypeProjectionImpl(typeProjection.getProjectionKind(), DONT_CARE));
116 }
117 return new JetTypeImpl(
118 receiverType.getAnnotations(), receiverType.getConstructor(), receiverType.isNullable(),
119 fakeTypeArguments, ErrorUtils.createErrorScope("Error scope for erased receiver type", /*throwExceptions=*/true));
120 }
121
122 public static boolean isOrOverridesSynthesized(@NotNull CallableMemberDescriptor descriptor) {
123 if (descriptor.getKind() == CallableMemberDescriptor.Kind.SYNTHESIZED) {
124 return true;
125 }
126 if (descriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
127 for (CallableMemberDescriptor overridden : descriptor.getOverriddenDescriptors()) {
128 if (!isOrOverridesSynthesized(overridden)) {
129 return false;
130 }
131 }
132 return true;
133 }
134 return false;
135 }
136
137 public static boolean isInvokeCallOnVariable(@NotNull Call call) {
138 if (call.getCallType() != Call.CallType.INVOKE) return false;
139 ReceiverValue dispatchReceiver = call.getDispatchReceiver();
140 //calleeExpressionAsDispatchReceiver for invoke is always ExpressionReceiver, see CallForImplicitInvoke
141 JetExpression expression = ((ExpressionReceiver) dispatchReceiver).getExpression();
142 return expression instanceof JetSimpleNameExpression;
143 }
144
145 public static boolean isInvokeCallOnExpressionWithBothReceivers(@NotNull Call call) {
146 if (call.getCallType() != Call.CallType.INVOKE || isInvokeCallOnVariable(call)) return false;
147 return call.getExplicitReceiver().exists() && call.getDispatchReceiver().exists();
148 }
149 }