IDEA-52997: Groovy: good code is red. A field and a property of the same name are...
[idea/community.git] / plugins / groovy / test / org / jetbrains / plugins / groovy / lang / resolve / ResolvePropertyTest.groovy
1 /*
2  *  Copyright 2000-2007 JetBrains s.r.o.
3  *  Licensed under the Apache License, Version 2.0 (the "License");
4  *  you may not use this file except in compliance with the License.
5  *  You may obtain a copy of the License at
6  *
7  *  http://www.apache.org/licenses/LICENSE-2.0
8  *
9  *  Unless required by applicable law or agreed to in writing, software
10  *  distributed under the License is distributed on an "AS IS" BASIS,
11  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  *  See the License for the specific language governing permissions and
13  *  limitations under the License.
14  *
15  */
16 package org.jetbrains.plugins.groovy.lang.resolve;
17
18
19 import com.intellij.psi.util.PropertyUtil
20 import org.jetbrains.plugins.groovy.GroovyFileType
21 import org.jetbrains.plugins.groovy.lang.psi.GrReferenceElement
22 import org.jetbrains.plugins.groovy.lang.psi.GroovyFileBase
23 import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult
24 import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrField
25 import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrVariable
26 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrAssignmentExpression
27 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression
28 import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrAccessorMethod
29 import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrEnumConstant
30 import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod
31 import org.jetbrains.plugins.groovy.lang.psi.api.toplevel.GrTopStatement
32 import org.jetbrains.plugins.groovy.util.TestUtils
33 import com.intellij.psi.*
34
35 /**
36  * @author ven
37  */
38 public class ResolvePropertyTest extends GroovyResolveTestCase {
39   @Override
40   protected String getBasePath() {
41     return TestUtils.getTestDataPath() + "resolve/property/";
42   }
43
44   public void testParameter1() throws Exception {
45     doTest("parameter1/A.groovy");
46   }
47
48   public void testClosureParameter1() throws Exception {
49     doTest("closureParameter1/A.groovy");
50   }
51
52   public void testClosureOwner() throws Exception {
53     PsiReference ref = configureByFile("closureOwner/A.groovy");
54     PsiElement resolved = ref.resolve();
55     assertInstanceOf(resolved, GrVariable);
56     assertEquals(((PsiClassType) ((GrVariable) resolved).getTypeGroovy()).getCanonicalText(), "W");
57   }
58
59   public void testLocal1() throws Exception {
60     doTest("local1/A.groovy");
61   }
62
63   public void testField1() throws Exception {
64     doTest("field1/A.groovy");
65   }
66
67   public void testField2() throws Exception {
68     doTest("field2/A.groovy");
69   }
70
71   public void testForVariable1() throws Exception {
72     doTest("forVariable1/ForVariable.groovy");
73   }
74
75   public void testArrayLength() throws Exception {
76     doTest("arrayLength/A.groovy");
77   }
78
79   public void testFromGetter() throws Exception {
80     PsiReference ref = configureByFile("fromGetter/A.groovy");
81     assertTrue(ref.resolve() instanceof GrAccessorMethod);
82   }
83
84   public void testFromGetter2() throws Exception {
85     PsiReference ref = configureByFile("fromGetter2/A.groovy");
86     assertTrue(ref.resolve() instanceof GrAccessorMethod);
87   }
88
89   public void testFromSetter2() throws Exception {
90     PsiReference ref = configureByFile("fromSetter2/A.groovy");
91     assertTrue(ref.resolve() instanceof GrAccessorMethod);
92   }
93
94   public void testFromSetter() throws Exception {
95     PsiReference ref = configureByFile("fromSetter/A.groovy");
96     assertTrue(ref.resolve() instanceof GrAccessorMethod);
97   }
98
99   public void testForVariable2() throws Exception {
100     doTest("forVariable2/ForVariable.groovy");
101   }
102
103   public void testCatchParameter() throws Exception {
104     doTest("catchParameter/CatchParameter.groovy");
105   }
106
107   public void testCaseClause() throws Exception {
108     doTest("caseClause/CaseClause.groovy");
109   }
110
111   public void testGrvy104() throws Exception {
112     doTest("grvy104/Test.groovy");
113   }
114
115   public void testGrvy270() throws Exception {
116     PsiReference ref = configureByFile("grvy270/Test.groovy");
117     assertNull(ref.resolve());
118   }
119
120   public void testGrvy1483() throws Exception {
121     PsiReference ref = configureByFile("grvy1483/Test.groovy");
122     assertNotNull(ref.resolve());
123   }
124
125   public void testField3() throws Exception {
126     GrReferenceElement ref = (GrReferenceElement) configureByFile("field3/A.groovy").getElement();
127     GroovyResolveResult resolveResult = ref.advancedResolve();
128     assertTrue(resolveResult.getElement() instanceof GrField);
129     assertFalse(resolveResult.isValidResult());
130   }
131
132   public void testToGetter() throws Exception {
133     GrReferenceElement ref = (GrReferenceElement) configureByFile("toGetter/A.groovy").getElement();
134     PsiElement resolved = ref.resolve();
135     assertTrue(resolved instanceof GrMethod);
136     assertTrue(PropertyUtil.isSimplePropertyGetter((PsiMethod) resolved));
137   }
138
139   public void testToSetter() throws Exception {
140     GrReferenceElement ref = (GrReferenceElement) configureByFile("toSetter/A.groovy").getElement();
141     PsiElement resolved = ref.resolve();
142     assertTrue(resolved instanceof GrMethod);
143     assertTrue(PropertyUtil.isSimplePropertySetter((PsiMethod) resolved));
144   }
145
146   public void testUndefinedVar1() throws Exception {
147     PsiReference ref = configureByFile("undefinedVar1/A.groovy");
148     PsiElement resolved = ref.resolve();
149     assertInstanceOf(resolved, GrReferenceExpression);
150     GrTopStatement statement = ((GroovyFileBase) resolved.getContainingFile()).getTopStatements()[2];
151     assertTrue(resolved.equals(((GrAssignmentExpression) statement).getLValue()));
152   }
153
154   public void testRecursive1() throws Exception {
155     PsiReference ref = configureByFile("recursive1/A.groovy");
156     PsiElement resolved = ref.resolve();
157     assertTrue(resolved instanceof GrField);
158   }
159
160   public void testRecursive2() throws Exception {
161     PsiReference ref = configureByFile("recursive2/A.groovy");
162     PsiElement resolved = ref.resolve();
163     assertTrue(resolved instanceof GrMethod);
164     assertEquals(CommonClassNames.JAVA_LANG_OBJECT, ((GrMethod) resolved).returnType.canonicalText);
165   }
166
167   public void testNotAField() throws Exception {
168     PsiReference ref = configureByFile("notAField/A.groovy");
169     assertNull(ref.resolve());
170   }
171
172   public void testUndefinedVar2() throws Exception {
173     doUndefinedVarTest("undefinedVar2/A.groovy");
174   }
175
176   public void testDefinedVar1() throws Exception {
177     doTest("definedVar1/A.groovy");
178   }
179
180   public void testOperatorOverload() throws Exception {
181     doTest("operatorOverload/A.groovy");
182   }
183
184   public void testEnumConstant() throws Exception {
185     PsiReference ref = configureByFile("enumConstant/A.groovy");
186     assertTrue(ref.resolve() instanceof GrEnumConstant);
187   }
188
189   public void testStackOverflow() throws Exception {
190     doTest("stackOverflow/A.groovy");
191   }
192
193   public void testFromDifferentCaseClause() throws Exception {
194     PsiReference ref = configureByFile("fromDifferentCaseClause/A.groovy");
195     assertNull(ref.resolve());
196   }
197
198   public void testNotSettingProperty() throws Exception {
199     PsiReference ref = configureByFile("notSettingProperty/A.groovy");
200     assertNull(ref.resolve());
201   }
202
203   public void testGrvy633() throws Exception {
204     PsiReference ref = configureByFile("grvy633/A.groovy");
205     assertNull(ref.resolve());
206   }
207
208   public void testGrvy575() throws Exception {
209     doTest("grvy575/A.groovy");
210   }
211
212   public void testGrvy747() throws Exception {
213     PsiReference ref = configureByFile("grvy747/A.groovy");
214     assertTrue(ref.resolve() instanceof GrField);
215   }
216
217   public void testClosureCall() throws Exception {
218     PsiReference ref = configureByFile("closureCall/ClosureCall.groovy");
219     assertTrue(ref.resolve() instanceof GrVariable);
220   }
221
222   public void testUnderscoredField() throws Exception {
223     PsiReference ref = configureByFile("underscoredField/UnderscoredField.groovy");
224     final GrField field = assertInstanceOf(ref.resolve(), GrField.class);
225     assertFalse(ref.isReferenceTo(field.getGetters()[0]));
226     assertTrue(ref.isReferenceTo(field));
227   }
228
229   public void testPropertyWithoutField1() throws Exception {
230     PsiReference ref = configureByFile("propertyWithoutField1/PropertyWithoutField1.groovy");
231     assertInstanceOf(ref.resolve(), GrMethod.class);
232   }
233
234   public void testPropertyWithoutField2() throws Exception {
235     PsiReference ref = configureByFile("propertyWithoutField2/PropertyWithoutField2.groovy");
236     assertInstanceOf(ref.resolve(), GrMethod.class);
237   }
238
239   public void testFieldAssignedInTheSameMethod() throws Exception {
240     PsiReference ref = configureByFile("fieldAssignedInTheSameMethod/FieldAssignedInTheSameMethod.groovy");
241     assertInstanceOf(ref.resolve(), GrField.class);
242   }
243
244   public void testPrivateFieldAssignment() throws Throwable {
245     myFixture.configureByText(GroovyFileType.GROOVY_FILE_TYPE, """
246                           class Aaaaa {
247                             final def aaa
248
249                             def foo() {
250                               a<caret>aa = 2
251                             }
252                           }""")
253     def reference = myFixture.file.findReferenceAt(myFixture.editor.caretModel.offset)
254     assertInstanceOf(reference.resolve(), GrField.class)
255   }
256
257   public void testOverriddenGetter() throws Throwable {
258     myFixture.configureByText("a.groovy", """interface Foo {
259                                               def getFoo()
260                                             }
261                                             interface Bar extends Foo {
262                                               def getFoo()
263                                             }
264
265                                             Bar b
266                                             b.fo<caret>o""")
267     def reference = myFixture.file.findReferenceAt(myFixture.editor.caretModel.offset)
268     assertEquals("Bar", assertInstanceOf(reference.resolve(), GrMethod.class).containingClass.name)
269   }
270
271   public void testIDEADEV40403() {
272     myFixture.configureByFile("IDEADEV40403/A.groovy");
273     def reference = findReference()
274     def resolved = reference.resolve()
275     assertInstanceOf(resolved, PsiMethod.class);
276     def clazz = resolved.containingClass
277     assertEquals "Script", clazz.name
278   }
279
280   public void testBooleanGetterPropertyAccess() {
281     myFixture.configureByText("a.groovy", "print([].em<caret>pty)");
282     def ref = findReference()
283     def resolved = ref.resolve()
284     assertInstanceOf resolved, PsiMethod
285   }
286
287   def findReference() { myFixture.file.findReferenceAt(myFixture.editor.caretModel.offset) }
288
289   public void testTriplePropertyUsages() throws Exception {
290     myFixture.configureByText "a.groovy", """
291 class Foo {
292   def bar
293   def zoo = <caret>bar
294 }
295 """
296     def ref = findReference()
297     GrField target = assertInstanceOf(ref.resolve(), GrField)
298     assertTrue ref.isReferenceTo(target)
299     assertFalse ref.isReferenceTo(target.getters[0])
300     assertFalse ref.isReferenceTo(target.setter)
301   }
302
303   public void testAliasedStaticImport() throws Exception {
304     myFixture.addClass """ class Main {
305   static def foo=4
306 """
307
308     myFixture.configureByText "a.groovy", """
309 import static Main.foo as bar
310 print ba<caret>r
311 }
312 """
313     def ref = findReference()
314     def target = assertInstanceOf(ref.resolve(), PsiField)
315     assertEquals target.getName(), "foo"
316   }
317
318   private void doTest(String fileName) throws Exception {
319     PsiReference ref = configureByFile(fileName);
320     PsiElement resolved = ref.resolve();
321     assertTrue(resolved instanceof GrVariable);
322   }
323
324   private void doUndefinedVarTest(String fileName) throws Exception {
325     PsiReference ref = configureByFile(fileName);
326     PsiElement resolved = ref.resolve();
327     assertTrue(resolved instanceof GrReferenceExpression);
328   }
329
330   public void testBooleanProperty() throws Exception {
331     myFixture.configureByText("Abc.groovy", """class A{
332     boolean getFoo(){return true}
333  boolean isFoo(){return false}
334  }
335  print new A().f<caret>oo""");
336     def ref = findReference()
337     def resolved = ref.resolve();
338     assertNotNull resolved
339     assertEquals resolved.getName(), "isFoo"
340   }
341
342   public void testExplicitBooleanProperty() throws Exception {
343     myFixture.configureByText("Abc.groovy", """class A{
344     boolean foo
345  }
346  print new A().f<caret>oo""");
347     def ref = findReference()
348     def resolved = ref.resolve();
349     assertNotNull resolved
350     assertEquals resolved.getName(), "isFoo"
351   }
352
353   public void testStaticFieldAndNonStaticGetter() {
354     myFixture.configureByText("Abc.groovy", "print Float.N<caret>aN")
355     def ref = findReference()
356     def resolved = ref.resolve()
357     assertInstanceOf resolved, PsiField.class
358   }
359
360   public void testPropertyAndFieldDeclarationInsideClass() {
361     myFixture.configureByText("a.groovy", """class Foo {
362   def foo
363   public def foo
364
365   def bar() {
366     print fo<caret>o
367   }
368 }""")
369     def ref = findReference()
370     def resolved = ref.resolve();
371     assertInstanceOf resolved, GrField.class
372     assertTrue resolved.getModifierList().hasExplicitVisibilityModifiers()
373   }
374
375   public void testPropertyAndFieldDeclarationOutsideClass() {
376     myFixture.configureByText("a.groovy", """class Foo {
377   def foo
378   public def foo
379
380   def bar() {
381     print foo
382   }
383 }
384 print new Foo().fo<caret>o""")
385     def ref = findReference()
386     def resolved = ref.resolve();
387     assertInstanceOf resolved, GrAccessorMethod.class
388   }
389
390   public void testPropertyAndFieldDeclarationWithSuperClass1() {
391     myFixture.configureByText("a.groovy", """
392 class Bar{
393   def foo
394 }
395 class Foo extends Bar {
396   public def foo
397
398   def bar() {
399     print foo
400   }
401 }
402 print new Foo().fo<caret>o""")
403     def ref = findReference()
404     def resolved = ref.resolve();
405     assertInstanceOf resolved, GrAccessorMethod.class
406   }
407
408   public void testPropertyAndFieldDeclarationWithSuperClass2() {
409     myFixture.configureByText("a.groovy", """
410 class Bar{
411   def foo
412 }
413 class Foo extends Bar {
414   public def foo
415
416   def bar() {
417     print f<caret>oo
418   }
419 }
420 print new Foo().foo""")
421     def ref = findReference()
422     def resolved = ref.resolve();
423     assertInstanceOf resolved, GrField.class
424     assertTrue resolved.getModifierList().hasExplicitVisibilityModifiers()
425   }
426
427   public void testPropertyAndFieldDeclarationWithSuperClass3() {
428     myFixture.configureByText("a.groovy", """
429 class Bar{
430   public def foo
431 }
432 class Foo extends Bar {
433   def foo
434
435   def bar() {
436     print foo
437   }
438 }
439 print new Foo().fo<caret>o""")
440     def ref = findReference()
441     def resolved = ref.resolve();
442     assertInstanceOf resolved, GrAccessorMethod.class
443   }
444   
445   public void testPropertyAndFieldDeclarationWithSuperClass4() {
446     myFixture.configureByText("a.groovy", """
447 class Bar{
448   public def foo
449 }
450 class Foo extends Bar {
451   def foo
452
453   def bar() {
454     print f<caret>oo
455   }
456 }
457 print new Foo().foo""")
458     def ref = findReference()
459     def resolved = ref.resolve();
460     assertInstanceOf resolved, GrField.class
461     assertTrue !resolved.getModifierList().hasExplicitVisibilityModifiers()
462   }
463 }