5b3e5fa90e5fcda3a38dfcc13b81396a0b1422d2
[idea/community.git] / plugins / groovy / src / org / jetbrains / plugins / groovy / lang / psi / impl / statements / params / GrParameterImpl.java
1 /*
2  * Copyright 2000-2009 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
17 package org.jetbrains.plugins.groovy.lang.psi.impl.statements.params;
18
19 import com.intellij.lang.ASTNode;
20 import com.intellij.psi.*;
21 import com.intellij.psi.search.LocalSearchScope;
22 import com.intellij.psi.search.SearchScope;
23 import com.intellij.psi.util.InheritanceUtil;
24 import com.intellij.psi.util.PsiTreeUtil;
25 import com.intellij.psi.util.PsiUtil;
26 import org.jetbrains.annotations.NotNull;
27 import org.jetbrains.annotations.Nullable;
28 import org.jetbrains.plugins.groovy.lang.groovydoc.psi.api.GrDocComment;
29 import org.jetbrains.plugins.groovy.lang.groovydoc.psi.api.GrDocCommentOwner;
30 import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes;
31 import org.jetbrains.plugins.groovy.lang.psi.GroovyElementVisitor;
32 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.modifiers.GrModifierList;
33 import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrCatchClause;
34 import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrParametersOwner;
35 import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
36 import org.jetbrains.plugins.groovy.lang.psi.api.statements.clauses.GrForInClause;
37 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
38 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrParenthesizedExpression;
39 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
40 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.arithmetic.GrRangeExpression;
41 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.path.GrMethodCallExpression;
42 import org.jetbrains.plugins.groovy.lang.psi.api.statements.params.GrParameter;
43 import org.jetbrains.plugins.groovy.lang.psi.api.statements.params.GrParameterList;
44 import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod;
45 import org.jetbrains.plugins.groovy.lang.psi.api.types.GrTypeElement;
46 import org.jetbrains.plugins.groovy.lang.psi.impl.GrTupleType;
47 import org.jetbrains.plugins.groovy.lang.psi.impl.PsiImplUtil;
48 import org.jetbrains.plugins.groovy.lang.psi.impl.statements.GrVariableImpl;
49 import org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.TypesUtil;
50
51 /**
52  * @author: Dmitry.Krasilschikov
53  * @date: 26.03.2007
54  */
55 public class GrParameterImpl extends GrVariableImpl implements GrParameter {
56   public GrParameterImpl(@NotNull ASTNode node) {
57     super(node);
58   }
59
60   public void accept(GroovyElementVisitor visitor) {
61     visitor.visitParameter(this);
62   }
63
64   public String toString() {
65     return "Parameter";
66   }
67
68   @Nullable
69   public PsiType getTypeGroovy() {
70     GrTypeElement typeElement = getTypeElementGroovy();
71     if (typeElement != null) {
72       PsiType type = typeElement.getType();
73       if (!isVarArgs()) {
74         return type;
75       }
76       else {
77         return new PsiEllipsisType(type);
78       }
79     }
80     PsiElementFactory factory = JavaPsiFacade.getInstance(getProject()).getElementFactory();
81     if (isVarArgs()) {
82       PsiClassType type = factory.createTypeByFQClassName("java.lang.Object", getResolveScope());
83       return new PsiEllipsisType(type);
84     }
85     PsiElement parent = getParent();
86     if (parent instanceof GrForInClause) {
87       GrExpression iteratedExpression = ((GrForInClause)parent).getIteratedExpression();
88       if (iteratedExpression instanceof GrRangeExpression) {
89         return factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_INTEGER, getResolveScope());
90       }
91       else if (iteratedExpression != null) {
92         PsiType result = findTypeForCollection(iteratedExpression, factory, this);
93         if (result != null) {
94           return result;
95         }
96       }
97     } else if (parent instanceof GrCatchClause) {
98       return factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_THROWABLE, getResolveScope()); 
99     }
100
101     String argumentName = getElementToCompare();
102     GrClosableBlock closure = findClosureWithArgument(parent);
103
104     return findClosureParameterType(closure, argumentName, factory, this);
105   }
106
107   @Nullable
108   public static PsiType findClosureParameterType(GrClosableBlock closure,
109                                                  String argumentName,
110                                                  PsiElementFactory factory,
111                                                  PsiElement context) {
112     if (closure != null && closure.getParent() instanceof GrMethodCallExpression) {
113       GrMethodCallExpression methodCall = (GrMethodCallExpression)closure.getParent();
114       String methodName = findMethodName(methodCall);
115       //final GrExpression invokedExpression = methodCall.getInvokedExpression();
116       //PsiType type = findQualifierType(methodCall);
117
118       GrExpression expression = methodCall.getInvokedExpression();
119       if (!(expression instanceof GrReferenceExpression)) return null;
120
121       GrExpression qualifier = ((GrReferenceExpression)expression).getQualifierExpression();
122       if (qualifier == null) return null;
123       PsiType type = qualifier.getType();
124
125       GrParameter[] params = closure.getParameters();
126       if (type == null) {
127         return null;
128       }
129
130       if ("each".equals(methodName) ||
131           "every".equals(methodName) ||
132           "collect".equals(methodName) ||
133           "find".equals(methodName) ||
134           "findAll".equals(methodName) ||
135           "findIndexOf".equals(methodName)) {
136         PsiType res = findTypeForCollection(qualifier, factory, context);
137         if (closure.getParameters().length <= 1 && res != null) {
138           return res;
139         }
140
141         if (InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_MAP)) {
142           if (closure.getParameters().length <= 1) {
143             return getEntryForMap(type, factory, context);
144           }
145           if (closure.getParameters().length == 2) {
146             if (argumentName.equals(params[0].getName())) {
147               return PsiUtil.substituteTypeParameter(type, CommonClassNames.JAVA_UTIL_MAP, 0, true);
148             }
149             return PsiUtil.substituteTypeParameter(type, CommonClassNames.JAVA_UTIL_MAP, 1, true);
150           }
151         }
152       }
153       else if ("with".equals(methodName) && closure.getParameters().length <= 1) {
154         return type;
155       }
156       else if ("eachWithIndex".equals(methodName)) {
157         PsiType res = findTypeForCollection(qualifier, factory, context);
158         if (closure.getParameters().length == 2 && res != null) {
159           if (argumentName.equals(params[0].getName())) {
160             return res;
161           }
162           return factory.createTypeFromText(CommonClassNames.JAVA_LANG_INTEGER, context);
163         }
164         if (InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_MAP)) {
165           if (params.length == 2) {
166             if (argumentName.equals(params[0].getName())) {
167               return getEntryForMap(type, factory, context);
168             }
169             return factory.createTypeFromText(CommonClassNames.JAVA_LANG_INTEGER, context);
170           }
171           if (params.length == 3) {
172             if (argumentName.equals(params[0].getName())) {
173               return PsiUtil.substituteTypeParameter(type, CommonClassNames.JAVA_UTIL_MAP, 0, true);
174             }
175             if (argumentName.equals(params[1].getName())) {
176               return PsiUtil.substituteTypeParameter(type, CommonClassNames.JAVA_UTIL_MAP, 1, true);
177             }
178             return factory.createTypeFromText(CommonClassNames.JAVA_LANG_INTEGER, context);
179           }
180         }
181       }
182       else if ("inject".equals(methodName) && params.length == 2) {
183         if (argumentName.equals(params[0].getName())) {
184           return factory.createTypeFromText(CommonClassNames.JAVA_LANG_OBJECT, context);
185         }
186
187         PsiType res = findTypeForCollection(qualifier, factory, context);
188         if (res != null) {
189           return res;
190         }
191         if (InheritanceUtil.isInheritor(type, CommonClassNames.JAVA_UTIL_MAP)) {
192           return getEntryForMap(type, factory, context);
193         }
194       }
195     }
196     return null;
197   }
198
199   @Nullable
200   private static PsiType getEntryForMap(PsiType map, PsiElementFactory factory, PsiElement context) {
201     PsiType key = PsiUtil.substituteTypeParameter(map, CommonClassNames.JAVA_UTIL_MAP, 0, true);
202     PsiType value = PsiUtil.substituteTypeParameter(map, CommonClassNames.JAVA_UTIL_MAP, 1, true);
203     if (key != null && value != null) {
204       return factory.createTypeFromText("java.util.Map.Entry<" + key.getCanonicalText() + ", " + value.getCanonicalText() + ">", context);
205     }
206     return null;
207   }
208
209   @Nullable
210   private static PsiType findTypeForCollection(GrExpression qualifier, PsiElementFactory factory, PsiElement context) {
211     PsiType iterType = qualifier.getType();
212     if (iterType == null) return null;
213     if (iterType instanceof PsiArrayType) {
214       return ((PsiArrayType)iterType).getComponentType();
215     }
216     if (iterType instanceof GrTupleType) {
217       PsiType[] types = ((GrTupleType)iterType).getParameters();
218       return types.length == 1 ? types[0] : null;
219     }
220
221     if (factory.createTypeFromText("groovy.lang.IntRange", context).isAssignableFrom(iterType)) {
222       return factory.createTypeFromText(CommonClassNames.JAVA_LANG_INTEGER, context);
223     }
224     if (factory.createTypeFromText("groovy.lang.ObjectRange", context).isAssignableFrom(iterType)) {
225       PsiElement element = qualifier;
226       element = removeBrackets(element);
227       if (element instanceof GrReferenceExpression) {
228         GrReferenceExpression ref = (GrReferenceExpression)element;
229         element = removeBrackets(ref.resolve());
230       }
231       if (element instanceof GrRangeExpression) {
232         return getRangeElementType((GrRangeExpression)element);
233       }
234       return null;
235     }
236
237     PsiType res = PsiUtil.extractIterableTypeParameter(iterType, true);
238     if (res != null) {
239       return res;
240     }
241
242     if (iterType.equalsToText(CommonClassNames.JAVA_LANG_STRING) || iterType.equalsToText("java.io.File")) {
243       return factory.createTypeFromText(CommonClassNames.JAVA_LANG_STRING, context);
244     }
245     return null;
246   }
247
248   private static PsiElement removeBrackets(PsiElement element) {
249     while (element instanceof GrParenthesizedExpression) {
250       element = ((GrParenthesizedExpression)element).getOperand();
251     }
252     return element;
253   }
254
255   @Nullable
256   private static PsiType getRangeElementType(GrRangeExpression range) {
257     GrExpression left = range.getLeftOperand();
258     GrExpression right = range.getRightOperand();
259     if (right != null) {
260       final PsiType leftType = left.getType();
261       final PsiType rightType = right.getType();
262       if (leftType != null && rightType != null) {
263         return TypesUtil.getLeastUpperBound(leftType, rightType, range.getManager());
264       }
265     }
266     return null;
267   }
268
269   @Nullable
270   private static String findMethodName(@NotNull GrMethodCallExpression methodCall) {
271     GrExpression expression = methodCall.getInvokedExpression();
272     if (expression instanceof GrReferenceExpression) {
273       return ((GrReferenceExpression)expression).getReferenceName();
274     }
275     return null;
276   }
277
278   @Nullable
279   private static GrClosableBlock findClosureWithArgument(@NotNull PsiElement parent) {
280     if (parent instanceof GrParameterList) {
281       GrParameterList list = (GrParameterList)parent;
282       if (list.getParent() instanceof GrClosableBlock) {
283         return (GrClosableBlock)list.getParent();
284       }
285     }
286     return null;
287   }
288
289   @NotNull
290   public PsiType getType() {
291     /*PsiType type = getTypeGroovy();
292     if (type == null) type = super.getType();*/
293     PsiType type = super.getType();
294     if (isVarArgs()) {
295       return new PsiEllipsisType(type);
296     }
297     else if (isMainMethodFirstUntypedParameter()) {
298       PsiClassType stringType =
299         JavaPsiFacade.getInstance(getProject()).getElementFactory().createTypeByFQClassName("java.lang.String", getResolveScope());
300       return stringType.createArrayType();
301     }
302     else {
303       return type;
304     }
305   }
306
307   private boolean isMainMethodFirstUntypedParameter() {
308     if (getTypeElementGroovy() != null) return false;
309
310     if (getParent() instanceof GrParameterList) {
311       GrParameterList parameterList = (GrParameterList)getParent();
312       GrParameter[] params = parameterList.getParameters();
313       if (params.length != 1 || this != params[0]) return false;
314
315       if (parameterList.getParent() instanceof GrMethod) {
316         GrMethod method = (GrMethod)parameterList.getParent();
317         return PsiImplUtil.isMainMethod(method);
318       }
319     }
320     return false;
321   }
322
323   public void setType(@Nullable PsiType type) {
324     throw new RuntimeException("NIY");
325   }
326
327   @Nullable
328   public GrTypeElement getTypeElementGroovy() {
329     return findChildByClass(GrTypeElement.class);
330   }
331
332   @Nullable
333   public GrExpression getDefaultInitializer() {
334     return findChildByClass(GrExpression.class);
335   }
336
337   public boolean isOptional() {
338     return getDefaultInitializer() != null;
339   }
340
341   @NotNull
342   public SearchScope getUseScope() {
343     if (!isPhysical()) {
344       final PsiFile file = getContainingFile();
345       final PsiElement context = file.getContext();
346       if (context != null) return new LocalSearchScope(context);
347       return super.getUseScope();
348     }
349
350     final PsiElement scope = getDeclarationScope();
351     if (scope instanceof GrDocCommentOwner) {
352       GrDocCommentOwner owner = (GrDocCommentOwner)scope;
353       final GrDocComment comment = owner.getDocComment();
354       if (comment != null) {
355         return new LocalSearchScope(new PsiElement[]{scope, comment});
356       }
357     }
358
359     return new LocalSearchScope(scope);
360   }
361
362   @NotNull
363   public String getName() {
364     return getNameIdentifierGroovy().getText();
365   }
366
367   public int getTextOffset() {
368     return getNameIdentifierGroovy().getTextRange().getStartOffset();
369   }
370
371   @Nullable
372   public GrModifierList getModifierList() {
373     return findChildByClass(GrModifierList.class);
374   }
375
376   @NotNull
377   public PsiElement getDeclarationScope() {
378     final GrParametersOwner owner = PsiTreeUtil.getParentOfType(this, GrParametersOwner.class);
379     assert owner != null;
380     if (owner instanceof GrForInClause) return owner.getParent();
381     return owner;
382   }
383
384   public boolean isVarArgs() {
385     PsiElement dots = findChildByType(GroovyTokenTypes.mTRIPLE_DOT);
386     return dots != null;
387   }
388
389   @NotNull
390   public PsiAnnotation[] getAnnotations() {
391     return PsiAnnotation.EMPTY_ARRAY;
392   }
393
394   @Override
395   public PsiType getDeclaredType() {
396     PsiType type = super.getDeclaredType();
397     if (type == null) {
398       type = getTypeGroovy();
399     }
400     return type;
401   }
402 }