e68c854392c9e412074c5f57d686d3d482341e7c
[idea/community.git] / java / java-psi-impl / src / com / intellij / psi / impl / source / resolve / graphInference / constraints / CheckedExceptionCompatibilityConstraint.java
1 /*
2  * Copyright 2000-2013 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.psi.impl.source.resolve.graphInference.constraints;
17
18 import com.intellij.codeInsight.ExceptionUtil;
19 import com.intellij.openapi.diagnostic.Logger;
20 import com.intellij.psi.*;
21 import com.intellij.psi.impl.source.resolve.graphInference.FunctionalInterfaceParameterizationUtil;
22 import com.intellij.psi.impl.source.resolve.graphInference.InferenceSession;
23 import com.intellij.psi.impl.source.resolve.graphInference.InferenceVariable;
24 import com.intellij.psi.impl.source.resolve.graphInference.PsiPolyExpressionUtil;
25 import com.intellij.psi.util.PsiUtil;
26 import com.intellij.psi.util.TypeConversionUtil;
27 import com.intellij.util.Function;
28 import com.intellij.util.containers.ContainerUtil;
29
30 import java.util.ArrayList;
31 import java.util.List;
32 import java.util.Set;
33
34 public class CheckedExceptionCompatibilityConstraint extends InputOutputConstraintFormula {
35   private static final Logger LOG = Logger.getInstance(CheckedExceptionCompatibilityConstraint.class);
36   private final PsiExpression myExpression;
37   private PsiType myT;
38
39   public CheckedExceptionCompatibilityConstraint(PsiExpression expression, PsiType t) {
40     myExpression = expression;
41     myT = t;
42   }
43
44   @Override
45   public boolean reduce(final InferenceSession session, List<ConstraintFormula> constraints) {
46     if (!PsiPolyExpressionUtil.isPolyExpression(myExpression)) {
47       return true;
48     }
49     if (myExpression instanceof PsiParenthesizedExpression) {
50       constraints.add(new CheckedExceptionCompatibilityConstraint(((PsiParenthesizedExpression)myExpression).getExpression(), myT));
51       return true;
52     }
53     if (myExpression instanceof PsiConditionalExpression) {
54       final PsiExpression thenExpression = ((PsiConditionalExpression)myExpression).getThenExpression();
55       if (thenExpression != null) {
56         constraints.add(new CheckedExceptionCompatibilityConstraint(thenExpression, myT));
57       }
58       final PsiExpression elseExpression = ((PsiConditionalExpression)myExpression).getElseExpression();
59       if (elseExpression != null) {
60         constraints.add(new CheckedExceptionCompatibilityConstraint(elseExpression, myT));
61       }
62       return true;
63     }
64     if (myExpression instanceof PsiLambdaExpression || myExpression instanceof PsiMethodReferenceExpression) {
65       if (!LambdaUtil.isFunctionalType(myT)) {
66         session.registerIncompatibleErrorMessage(session.getPresentableText(myT) + " is not a functional interface");
67         return false;
68       }
69
70       final PsiType groundTargetType = myExpression instanceof PsiLambdaExpression ? FunctionalInterfaceParameterizationUtil.getGroundTargetType(myT, (PsiLambdaExpression)myExpression, false) 
71                                                                                    : FunctionalInterfaceParameterizationUtil.getGroundTargetType(myT);
72       final PsiMethod interfaceMethod = LambdaUtil.getFunctionalInterfaceMethod(groundTargetType);
73       if (interfaceMethod == null) {
74         session.registerIncompatibleErrorMessage("No valid function type can be found for " + session.getPresentableText(myT));
75         return false;
76       }
77
78       final PsiSubstitutor substitutor = LambdaUtil.getSubstitutor(interfaceMethod, PsiUtil.resolveGenericsClassInType(groundTargetType));
79       if (myExpression instanceof PsiLambdaExpression && !((PsiLambdaExpression)myExpression).hasFormalParameterTypes() ||
80           myExpression instanceof PsiMethodReferenceExpression && !((PsiMethodReferenceExpression)myExpression).isExact()) {
81         for (PsiParameter parameter : interfaceMethod.getParameterList().getParameters()) {
82           final PsiType type = substitutor.substitute(parameter.getType());
83           if (!session.isProperType(type)) {
84             session.registerIncompatibleErrorMessage("Parameter type is not yet inferred: " + session.getPresentableText(type));
85             return false;
86           }
87         }
88       }
89
90       final PsiType returnType = interfaceMethod.getReturnType();
91       if (myExpression instanceof PsiLambdaExpression || !((PsiMethodReferenceExpression)myExpression).isExact()) {
92         final PsiType type = substitutor.substitute(returnType);
93         if (!session.isProperType(type)) {
94           session.registerIncompatibleErrorMessage("Return type is not yet inferred: " + session.getPresentableText(type));
95           return false;
96         }
97       }
98
99       final List<PsiType>
100         expectedThrownTypes = ContainerUtil.map(interfaceMethod.getThrowsList().getReferencedTypes(),
101                                                 (Function<PsiType, PsiType>)type -> session.substituteWithInferenceVariables(substitutor.substitute(type)));
102       final List<PsiType> expectedNonProperThrownTypes = new ArrayList<>();
103       for (PsiType type : expectedThrownTypes) {
104         if (!session.isProperType(type)) {
105           expectedNonProperThrownTypes.add(type);
106         }
107       }
108       
109       final List<PsiType> thrownTypes = new ArrayList<>();
110       final PsiElement body = myExpression instanceof PsiLambdaExpression ? ((PsiLambdaExpression)myExpression).getBody() : myExpression;
111       if (body != null) {
112         final List<PsiClassType> exceptions =  ExceptionUtil.getUnhandledExceptions(new PsiElement[] {body});
113         if (exceptions != null) {
114           thrownTypes.addAll(ContainerUtil.filter(exceptions, type -> !ExceptionUtil.isUncheckedException(type)));
115         }
116       }
117
118       if (expectedNonProperThrownTypes.isEmpty()) {
119         for (PsiType thrownType : thrownTypes) {
120           if (!isAddressed(expectedThrownTypes, thrownType)) {
121             session.registerIncompatibleErrorMessage("Unhandled exception: " + session.getPresentableText(thrownType));
122             return false;
123           }
124         }
125       } else {
126         final ArrayList<PsiType> expectedProperTypes = new ArrayList<>(expectedThrownTypes);
127         expectedProperTypes.removeAll(expectedNonProperThrownTypes);
128         for (PsiType thrownType : thrownTypes) {
129           if (!isAddressed(expectedProperTypes, thrownType)) {
130             for (PsiType expectedNonProperThrownType : expectedNonProperThrownTypes) {
131               constraints.add(new StrictSubtypingConstraint(expectedNonProperThrownType, thrownType));
132             }
133           }
134         }
135
136         for (PsiType expectedNonProperThrownType : expectedNonProperThrownTypes) {
137           final InferenceVariable variable = session.getInferenceVariable(expectedNonProperThrownType);
138           //could be null for invalid code
139           if (variable != null) {
140             variable.setThrownBound();
141           }
142         }
143       }
144     }
145
146     return true;
147   }
148
149   private static boolean isAddressed(List<PsiType> expectedThrownTypes, PsiType thrownType) {
150     for (PsiType expectedThrownType : expectedThrownTypes) {
151       if (TypeConversionUtil.isAssignable(expectedThrownType, thrownType)) {
152         return true;
153       }
154     }
155     return false;
156   }
157
158   @Override
159   public PsiExpression getExpression() {
160     return myExpression;
161   }
162
163   @Override
164   protected PsiType getT() {
165     return myT;
166   }
167
168   @Override
169   protected void setT(PsiType t) {
170     myT = t;
171   }
172
173   @Override
174   protected InputOutputConstraintFormula createSelfConstraint(PsiType type, PsiExpression expression) {
175     return new CheckedExceptionCompatibilityConstraint(expression, type);
176   }
177
178   @Override
179   protected void collectReturnTypeVariables(InferenceSession session,
180                                             PsiExpression psiExpression,
181                                             PsiType returnType, 
182                                             Set<InferenceVariable> result) {
183     session.collectDependencies(returnType, result);
184   }
185 }