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