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 com.intellij.psi.PsiElement;
021 import org.jetbrains.annotations.NotNull;
022 import org.jetbrains.annotations.Nullable;
023 import org.jetbrains.jet.lang.descriptors.*;
024 import org.jetbrains.jet.lang.psi.Call;
025 import org.jetbrains.jet.lang.psi.CallKey;
026 import org.jetbrains.jet.lang.psi.JetExpression;
027 import org.jetbrains.jet.lang.resolve.BindingContext;
028 import org.jetbrains.jet.lang.resolve.TraceUtil;
029 import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext;
030 import org.jetbrains.jet.lang.resolve.calls.context.CallResolutionContext;
031 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintPosition;
032 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem;
033 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl;
034 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
035 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument;
036 import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionCandidate;
037 import org.jetbrains.jet.lang.types.*;
038 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
039
040 import java.util.Collections;
041 import java.util.List;
042 import java.util.Map;
043
044 import static org.jetbrains.jet.lang.types.TypeUtils.CANT_INFER_TYPE_PARAMETER;
045 import static org.jetbrains.jet.lang.types.TypeUtils.DONT_CARE;
046
047 public class CallResolverUtil {
048 public static enum ResolveArgumentsMode {
049 RESOLVE_FUNCTION_ARGUMENTS,
050 SHAPE_FUNCTION_ARGUMENTS
051 }
052
053 private CallResolverUtil() {}
054
055 public static <D extends CallableDescriptor> ResolvedCallImpl<D> copy(@NotNull ResolvedCallImpl<D> call, @NotNull CallResolutionContext<?> context) {
056 ResolutionCandidate<D> candidate = ResolutionCandidate.create(call.getCandidateDescriptor(), call.getThisObject(),
057 call.getReceiverArgument(), call.getExplicitReceiverKind(),
058 call.isSafeCall());
059
060 ResolvedCallImpl<D> copy = ResolvedCallImpl.create(candidate, TraceUtil.DELEGATING_TRACE_STUB, call.getTracing(), call.getDataFlowInfoForArguments());
061 context.trace.record(BindingContext.RESOLVED_CALL, context.call.getCalleeExpression(), copy);
062
063 copy.addStatus(call.getStatus());
064 if (call.isDirty()) {
065 copy.argumentHasNoType();
066 }
067 copy.setHasUnknownTypeParameters(call.hasIncompleteTypeParameters());
068 ConstraintSystem constraintSystem = call.getConstraintSystem();
069 if (constraintSystem != null) {
070 copy.setConstraintSystem(constraintSystem.copy());
071 }
072 for (Map.Entry<ValueParameterDescriptor, ResolvedValueArgument> entry : call.getValueArguments().entrySet()) {
073 copy.recordValueArgument(entry.getKey(), entry.getValue());
074 }
075 return copy;
076 }
077
078
079 public static boolean hasUnknownFunctionParameter(@NotNull JetType type) {
080 assert KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(type);
081 List<TypeProjection> arguments = type.getArguments();
082 // last argument is return type of function type
083 List<TypeProjection> functionParameters = arguments.subList(0, arguments.size() - 1);
084 for (TypeProjection functionParameter : functionParameters) {
085 if (TypeUtils.equalsOrContainsAsArgument(functionParameter.getType(), CANT_INFER_TYPE_PARAMETER, DONT_CARE)) {
086 return true;
087 }
088 }
089 return false;
090 }
091
092 public static boolean hasUnknownReturnType(@NotNull JetType type) {
093 assert KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(type);
094 JetType returnTypeFromFunctionType = KotlinBuiltIns.getInstance().getReturnTypeFromFunctionType(type);
095 return ErrorUtils.containsErrorType(returnTypeFromFunctionType);
096 }
097
098 public static JetType replaceReturnTypeByUnknown(@NotNull JetType type) {
099 assert KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(type);
100 List<TypeProjection> arguments = type.getArguments();
101 List<TypeProjection> newArguments = Lists.newArrayList();
102 newArguments.addAll(arguments.subList(0, arguments.size() - 1));
103 newArguments.add(new TypeProjectionImpl(Variance.INVARIANT, DONT_CARE));
104 return new JetTypeImpl(type.getAnnotations(), type.getConstructor(), type.isNullable(), newArguments, type.getMemberScope());
105 }
106
107 private static boolean hasReturnTypeDependentOnNotInferredParams(
108 @NotNull CallableDescriptor candidateDescriptor,
109 @NotNull ConstraintSystem constraintSystem
110 ) {
111 JetType returnType = candidateDescriptor.getReturnType();
112 if (returnType == null) return false;
113
114 for (TypeParameterDescriptor typeVariable : constraintSystem.getTypeVariables()) {
115 JetType inferredValueForTypeVariable = constraintSystem.getTypeBounds(typeVariable).getValue();
116 if (inferredValueForTypeVariable == null) {
117 if (TypeUtils.dependsOnTypeParameters(returnType, Collections.singleton(typeVariable))) {
118 return true;
119 }
120 }
121 }
122 return false;
123 }
124
125 public static boolean hasInferredReturnType(
126 @NotNull CallableDescriptor candidateDescriptor,
127 @NotNull ConstraintSystem constraintSystem
128 ) {
129 if (hasReturnTypeDependentOnNotInferredParams(candidateDescriptor, constraintSystem)) return false;
130
131 // Expected type mismatch was reported before as 'TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH'
132 if (constraintSystem.getStatus().hasOnlyErrorsFromPosition(ConstraintPosition.EXPECTED_TYPE_POSITION)) return false;
133 return true;
134 }
135
136 @Nullable
137 public static CallKey createCallKey(@NotNull BasicCallResolutionContext context) {
138 if (context.call.getCallType() == Call.CallType.INVOKE) {
139 return null;
140 }
141 PsiElement callElement = context.call.getCallElement();
142 if (!(callElement instanceof JetExpression)) return null;
143 return CallKey.create(context.call.getCallType(), (JetExpression) callElement);
144 }
145
146 @NotNull
147 public static JetType getErasedReceiverType(
148 @NotNull ReceiverParameterDescriptor receiverParameterDescriptor,
149 @NotNull CallableDescriptor descriptor
150 ) {
151 JetType receiverType = receiverParameterDescriptor.getType();
152 for (TypeParameterDescriptor typeParameter : descriptor.getTypeParameters()) {
153 if (typeParameter.getTypeConstructor().equals(receiverType.getConstructor())) {
154 receiverType = typeParameter.getUpperBoundsAsType();
155 }
156 }
157 List<TypeProjection> fakeTypeArguments = Lists.newArrayList();
158 for (TypeProjection typeProjection : receiverType.getArguments()) {
159 fakeTypeArguments.add(new TypeProjectionImpl(typeProjection.getProjectionKind(), DONT_CARE));
160 }
161 return new JetTypeImpl(
162 receiverType.getAnnotations(), receiverType.getConstructor(), receiverType.isNullable(),
163 fakeTypeArguments, ErrorUtils.createErrorScope("Error scope for erased receiver type", /*throwExceptions=*/true));
164 }
165
166 public static boolean isOrOverridesSynthesized(@NotNull CallableMemberDescriptor descriptor) {
167 if (descriptor.getKind() == CallableMemberDescriptor.Kind.SYNTHESIZED) {
168 return true;
169 }
170 if (descriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
171 for (CallableMemberDescriptor overridden : descriptor.getOverriddenDescriptors()) {
172 if (!isOrOverridesSynthesized(overridden)) {
173 return false;
174 }
175 }
176 return true;
177 }
178 return false;
179 }
180 }