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
056 public static boolean hasUnknownFunctionParameter(@NotNull JetType type) {
057 assert KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(type);
058 List<TypeProjection> arguments = type.getArguments();
059 // last argument is return type of function type
060 List<TypeProjection> functionParameters = arguments.subList(0, arguments.size() - 1);
061 for (TypeProjection functionParameter : functionParameters) {
062 if (TypeUtils.equalsOrContainsAsArgument(functionParameter.getType(), CANT_INFER_TYPE_PARAMETER, DONT_CARE)) {
063 return true;
064 }
065 }
066 return false;
067 }
068
069 public static boolean hasUnknownReturnType(@NotNull JetType type) {
070 assert KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(type);
071 JetType returnTypeFromFunctionType = KotlinBuiltIns.getInstance().getReturnTypeFromFunctionType(type);
072 return ErrorUtils.containsErrorType(returnTypeFromFunctionType);
073 }
074
075 public static JetType replaceReturnTypeByUnknown(@NotNull JetType type) {
076 assert KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(type);
077 List<TypeProjection> arguments = type.getArguments();
078 List<TypeProjection> newArguments = Lists.newArrayList();
079 newArguments.addAll(arguments.subList(0, arguments.size() - 1));
080 newArguments.add(new TypeProjectionImpl(Variance.INVARIANT, DONT_CARE));
081 return new JetTypeImpl(type.getAnnotations(), type.getConstructor(), type.isNullable(), newArguments, type.getMemberScope());
082 }
083
084 private static boolean hasReturnTypeDependentOnNotInferredParams(
085 @NotNull CallableDescriptor candidateDescriptor,
086 @NotNull ConstraintSystem constraintSystem
087 ) {
088 JetType returnType = candidateDescriptor.getReturnType();
089 if (returnType == null) return false;
090
091 for (TypeParameterDescriptor typeVariable : constraintSystem.getTypeVariables()) {
092 JetType inferredValueForTypeVariable = constraintSystem.getTypeBounds(typeVariable).getValue();
093 if (inferredValueForTypeVariable == null) {
094 if (TypeUtils.dependsOnTypeParameters(returnType, Collections.singleton(typeVariable))) {
095 return true;
096 }
097 }
098 }
099 return false;
100 }
101
102 public static boolean hasInferredReturnType(
103 @NotNull CallableDescriptor candidateDescriptor,
104 @NotNull ConstraintSystem constraintSystem
105 ) {
106 if (hasReturnTypeDependentOnNotInferredParams(candidateDescriptor, constraintSystem)) return false;
107
108 // Expected type mismatch was reported before as 'TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH'
109 if (constraintSystem.getStatus().hasOnlyErrorsFromPosition(ConstraintPosition.EXPECTED_TYPE_POSITION)) return false;
110 return true;
111 }
112
113 @Nullable
114 public static CallKey createCallKey(@NotNull BasicCallResolutionContext context) {
115 if (context.call.getCallType() == Call.CallType.INVOKE) {
116 return null;
117 }
118 PsiElement callElement = context.call.getCallElement();
119 if (!(callElement instanceof JetExpression)) return null;
120 return CallKey.create(context.call.getCallType(), (JetExpression) callElement);
121 }
122
123 @NotNull
124 public static JetType getErasedReceiverType(
125 @NotNull ReceiverParameterDescriptor receiverParameterDescriptor,
126 @NotNull CallableDescriptor descriptor
127 ) {
128 JetType receiverType = receiverParameterDescriptor.getType();
129 for (TypeParameterDescriptor typeParameter : descriptor.getTypeParameters()) {
130 if (typeParameter.getTypeConstructor().equals(receiverType.getConstructor())) {
131 receiverType = typeParameter.getUpperBoundsAsType();
132 }
133 }
134 List<TypeProjection> fakeTypeArguments = Lists.newArrayList();
135 for (TypeProjection typeProjection : receiverType.getArguments()) {
136 fakeTypeArguments.add(new TypeProjectionImpl(typeProjection.getProjectionKind(), DONT_CARE));
137 }
138 return new JetTypeImpl(
139 receiverType.getAnnotations(), receiverType.getConstructor(), receiverType.isNullable(),
140 fakeTypeArguments, ErrorUtils.createErrorScope("Error scope for erased receiver type", /*throwExceptions=*/true));
141 }
142
143 public static boolean isOrOverridesSynthesized(@NotNull CallableMemberDescriptor descriptor) {
144 if (descriptor.getKind() == CallableMemberDescriptor.Kind.SYNTHESIZED) {
145 return true;
146 }
147 if (descriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
148 for (CallableMemberDescriptor overridden : descriptor.getOverriddenDescriptors()) {
149 if (!isOrOverridesSynthesized(overridden)) {
150 return false;
151 }
152 }
153 return true;
154 }
155 return false;
156 }
157 }