Cleanup: NotNull/Nullable
[idea/community.git] / java / java-psi-api / src / com / intellij / patterns / PsiJavaPatterns.java
1 /*
2  * Copyright 2000-2014 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.patterns;
17
18 import com.intellij.psi.*;
19 import com.intellij.psi.tree.IElementType;
20 import com.intellij.util.ProcessingContext;
21 import org.jetbrains.annotations.NotNull;
22 import org.jetbrains.annotations.Nullable;
23
24 import java.util.Collections;
25 import java.util.List;
26
27 /**
28  * @author peter
29  */
30 public class PsiJavaPatterns extends StandardPatterns{
31
32   public static IElementTypePattern elementType() {
33     return PlatformPatterns.elementType();
34   }
35
36   public static VirtualFilePattern virtualFile() {
37     return PlatformPatterns.virtualFile();
38   }
39
40   public static PsiJavaElementPattern.Capture<PsiElement> psiElement() {
41     return new PsiJavaElementPattern.Capture<>(PsiElement.class);
42   }
43
44   public static PsiJavaElementPattern.Capture<PsiElement> psiElement(IElementType type) {
45     return psiElement().withElementType(type);
46   }
47
48   public static <T extends PsiElement> PsiJavaElementPattern.Capture<T> psiElement(final Class<T> aClass) {
49     return new PsiJavaElementPattern.Capture<>(aClass);
50   }
51
52   @SafeVarargs
53   public static PsiJavaElementPattern.Capture<PsiElement> psiElement(final Class<? extends PsiElement>... classAlternatives) {
54     return new PsiJavaElementPattern.Capture<>(new InitialPatternCondition<PsiElement>(PsiElement.class) {
55       @Override
56       public boolean accepts(@Nullable Object o, ProcessingContext context) {
57         for (Class<? extends PsiElement> classAlternative : classAlternatives) {
58           if (classAlternative.isInstance(o)) {
59             return true;
60           }
61         }
62         return false;
63       }
64     });
65   }
66
67   public static PsiJavaElementPattern.Capture<PsiLiteralExpression> literalExpression() {
68     return literalExpression(null);
69   }
70
71   public static PsiJavaElementPattern.Capture<PsiLiteral> psiLiteral() {
72     return psiLiteral(null);
73   }
74
75   public static PsiJavaElementPattern.Capture<PsiLiteral> psiLiteral(@Nullable final ElementPattern value) {
76     return new PsiJavaElementPattern.Capture<>(new InitialPatternConditionPlus<PsiLiteral>(PsiLiteral.class) {
77       @Override
78       public boolean accepts(@Nullable final Object o, final ProcessingContext context) {
79         return o instanceof PsiLiteral && (value == null || value.accepts(((PsiLiteral)o).getValue(), context));
80       }
81
82       @Override
83       public List<ElementPattern<?>> getPatterns() {
84         return Collections.singletonList(value);
85       }
86     });
87   }
88
89   public static PsiJavaElementPattern.Capture<PsiNewExpression> psiNewExpression(@NotNull final String... fqns) {
90     return new PsiJavaElementPattern.Capture<>(new InitialPatternCondition<PsiNewExpression>(PsiNewExpression.class) {
91       @Override
92       public boolean accepts(@Nullable final Object o, final ProcessingContext context) {
93         if (o instanceof PsiNewExpression) {
94           PsiJavaCodeReferenceElement reference = ((PsiNewExpression)o).getClassOrAnonymousClassReference();
95           if (reference != null) {
96             for (String fqn : fqns) {
97               if (fqn.equals(reference.getQualifiedName())) return true;
98             }
99           }
100         }
101         return false;
102       }
103     });
104   }
105
106   public static PsiJavaElementPattern.Capture<PsiLiteralExpression> literalExpression(@Nullable final ElementPattern value) {
107     return new PsiJavaElementPattern.Capture<>(new InitialPatternConditionPlus<PsiLiteralExpression>(PsiLiteralExpression.class) {
108       @Override
109       public boolean accepts(@Nullable final Object o, final ProcessingContext context) {
110         return o instanceof PsiLiteralExpression && (value == null || value.accepts(((PsiLiteralExpression)o).getValue(), context));
111       }
112
113       @Override
114       public List<ElementPattern<?>> getPatterns() {
115         return Collections.singletonList(value);
116       }
117     });
118   }
119
120   public static PsiMemberPattern.Capture psiMember() {
121     return new PsiMemberPattern.Capture();
122   }
123
124   public static PsiMethodPattern psiMethod() {
125     return new PsiMethodPattern();
126   }
127
128   public static PsiParameterPattern psiParameter() {
129     return new PsiParameterPattern();
130   }
131
132   public static PsiModifierListOwnerPattern.Capture<PsiModifierListOwner> psiModifierListOwner() {
133     return new PsiModifierListOwnerPattern.Capture<>(new InitialPatternCondition<PsiModifierListOwner>(PsiModifierListOwner.class) {
134       @Override
135       public boolean accepts(@Nullable Object o, ProcessingContext context) {
136         return o instanceof PsiModifierListOwner;
137       }
138     });
139   }
140   
141
142   public static PsiFieldPattern psiField() {
143     return new PsiFieldPattern();
144   }
145
146   public static PsiClassPattern psiClass() {
147     return new PsiClassPattern();
148   }
149
150   public static PsiAnnotationPattern psiAnnotation() {
151     return PsiAnnotationPattern.PSI_ANNOTATION_PATTERN;
152   }
153
154   public static PsiNameValuePairPattern psiNameValuePair() {
155     return PsiNameValuePairPattern.NAME_VALUE_PAIR_PATTERN;
156   }
157
158   public static PsiTypePattern psiType() {
159     return new PsiTypePattern();
160   }
161
162   public static PsiExpressionPattern.Capture<PsiExpression> psiExpression() {
163     return new PsiExpressionPattern.Capture<>(PsiExpression.class);
164   }
165
166   public static PsiBinaryExpressionPattern psiBinaryExpression() {
167     return new PsiBinaryExpressionPattern();
168   }
169
170   public static PsiTypeCastExpressionPattern psiTypeCastExpression() {
171     return new PsiTypeCastExpressionPattern();
172   }
173
174   public static PsiJavaElementPattern.Capture<PsiReferenceExpression> psiReferenceExpression() {
175     return psiElement(PsiReferenceExpression.class);
176   }
177
178   public static PsiStatementPattern.Capture<PsiExpressionStatement> psiExpressionStatement() {
179     return new PsiStatementPattern.Capture<>(PsiExpressionStatement.class);
180   }
181
182   public static PsiStatementPattern.Capture<PsiReturnStatement> psiReturnStatement() {
183     return new PsiStatementPattern.Capture<>(PsiReturnStatement.class);
184   }
185 }