@Override
public void visitClass(@NotNull PsiClass aClass) {
// no call to super, so it doesn't drill down
if (aClass.isInterface() || aClass.isAnnotationType()) {
return;
}
if (!SerializationUtils.isSerializable(aClass)) {
return;
}
PsiClass ancestor = aClass.getSuperClass();
final Set<PsiClass> visitedClasses = new HashSet<PsiClass>(16);
while (ancestor != null && SerializationUtils.isSerializable(ancestor)) {
ancestor = ancestor.getSuperClass();
if (!visitedClasses.add(ancestor)) {
return;
}
}
if (ancestor == null) {
return; // can't happen, since Object isn't serializable,
//// but I don't trust the PSI as far as I can throw it
}
if (classHasNoArgConstructor(ancestor)) {
return;
}
registerClassError(aClass, ancestor);
}
@Override
public List<AbstractStepDefinition> loadStepsFor(
@Nullable PsiFile featureFile, @NotNull Module module) {
final GlobalSearchScope dependenciesScope =
module.getModuleWithDependenciesAndLibrariesScope(true);
PsiClass stepDefAnnotationClass =
JavaPsiFacade.getInstance(module.getProject())
.findClass(CUCUMBER_RUNTIME_JAVA_STEP_DEF_ANNOTATION, dependenciesScope);
if (stepDefAnnotationClass == null) {
return Collections.emptyList();
}
final List<AbstractStepDefinition> result = new ArrayList<>();
final Query<PsiClass> stepDefAnnotations =
AnnotatedElementsSearch.searchPsiClasses(stepDefAnnotationClass, dependenciesScope);
for (PsiClass annotationClass : stepDefAnnotations) {
if (annotationClass.isAnnotationType()) {
final Query<PsiMethod> javaStepDefinitions =
AnnotatedElementsSearch.searchPsiMethods(annotationClass, dependenciesScope);
for (PsiMethod stepDefMethod : javaStepDefinitions) {
result.add(new JavaStepDefinition(stepDefMethod));
}
}
}
return result;
}
private static boolean isClassAccepted(
final PsiClass clazz,
@Nullable final ClassKind classKind,
final boolean instantiatable,
final boolean concrete,
final boolean notInterface,
final boolean notEnum) {
if (classKind == ClassKind.ANNOTATION) return clazz.isAnnotationType();
if (classKind == ClassKind.ENUM) return clazz.isEnum();
if (instantiatable) {
if (PsiUtil.isInstantiatable(clazz)) {
return true;
}
} else if (concrete) {
if (!clazz.hasModifierProperty(PsiModifier.ABSTRACT) && !clazz.isInterface()) {
return true;
}
} else if (notInterface) {
if (!clazz.isInterface()) {
return true;
}
} else if (notEnum) {
if (!clazz.isEnum()) {
return true;
}
} else {
return true;
}
return false;
}
@NotNull
public GrAnnotation addAnnotation(@NotNull @NonNls String qualifiedName) {
final PsiClass psiClass =
JavaPsiFacade.getInstance(getProject()).findClass(qualifiedName, getResolveScope());
final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(getProject());
GrAnnotation annotation;
if (psiClass != null && psiClass.isAnnotationType()) {
annotation = (GrAnnotation) addAfter(factory.createModifierFromText("@xxx"), null);
annotation.getClassReference().bindToElement(psiClass);
} else {
annotation =
(GrAnnotation) addAfter(factory.createModifierFromText("@" + qualifiedName), null);
}
final PsiElement parent = getParent();
if (!(parent instanceof GrParameter)) {
final ASTNode node = annotation.getNode();
final ASTNode treeNext = node.getTreeNext();
if (treeNext != null) {
getNode().addLeaf(TokenType.WHITE_SPACE, "\n", treeNext);
} else {
parent.getNode().addLeaf(TokenType.WHITE_SPACE, "\n", getNode().getTreeNext());
}
}
return annotation;
}
// returns contained element
private static PsiClass contained(PsiClass annotationType) {
if (!annotationType.isAnnotationType()) return null;
PsiMethod[] values = annotationType.findMethodsByName("value", false);
if (values.length != 1) return null;
PsiMethod value = values[0];
PsiType returnType = value.getReturnType();
if (!(returnType instanceof PsiArrayType)) return null;
PsiType type = ((PsiArrayType) returnType).getComponentType();
if (!(type instanceof PsiClassType)) return null;
PsiClass contained = ((PsiClassType) type).resolve();
if (contained == null || !contained.isAnnotationType()) return null;
if (PsiImplUtil.findAnnotation(
contained.getModifierList(), CommonClassNames.JAVA_LANG_ANNOTATION_REPEATABLE)
== null) return null;
return contained;
}
private static boolean isTestSubjectClass(PsiClass klass) {
if (klass.isEnum()
|| klass.isInterface()
|| klass.isAnnotationType()
|| TestUtil.isTestClass(klass)) {
return false;
}
return true;
}
private static void findClassUsages(
final PsiClass psiClass,
final PsiElement[] allElementsToDelete,
final List<UsageInfo> usages) {
final boolean justPrivates = containsOnlyPrivates(psiClass);
final String qualifiedName = psiClass.getQualifiedName();
final boolean annotationType = psiClass.isAnnotationType() && qualifiedName != null;
ReferencesSearch.search(psiClass)
.forEach(
reference -> {
final PsiElement element = reference.getElement();
if (!isInside(element, allElementsToDelete)) {
PsiElement parent = element.getParent();
if (parent instanceof PsiReferenceList) {
final PsiElement pparent = parent.getParent();
if (pparent instanceof PsiClass
&& element instanceof PsiJavaCodeReferenceElement) {
final PsiClass inheritor = (PsiClass) pparent;
// If psiClass contains only private members, then it is safe to remove it and
// change inheritor's extends/implements accordingly
if (justPrivates) {
if (parent.equals(inheritor.getExtendsList())
|| parent.equals(inheritor.getImplementsList())) {
usages.add(
new SafeDeleteExtendsClassUsageInfo(
(PsiJavaCodeReferenceElement) element, psiClass, inheritor));
return true;
}
}
}
}
LOG.assertTrue(element.getTextRange() != null);
final PsiFile containingFile = psiClass.getContainingFile();
boolean sameFileWithSingleClass = false;
if (containingFile instanceof PsiClassOwner) {
final PsiClass[] classes = ((PsiClassOwner) containingFile).getClasses();
sameFileWithSingleClass =
classes.length == 1
&& classes[0] == psiClass
&& element.getContainingFile() == containingFile;
}
final boolean safeDelete = sameFileWithSingleClass || isInNonStaticImport(element);
if (annotationType && parent instanceof PsiAnnotation) {
usages.add(
new SafeDeleteAnnotation((PsiAnnotation) parent, psiClass, safeDelete));
} else {
usages.add(
new SafeDeleteReferenceJavaDeleteUsageInfo(element, psiClass, safeDelete));
}
}
return true;
});
}
@Nullable
private static PsiClass getRepeatableContainer(@NotNull PsiAnnotation annotation) {
PsiAnnotationMemberValue containerRef = PsiImplUtil.findAttributeValue(annotation, null);
if (!(containerRef instanceof PsiClassObjectAccessExpression)) return null;
PsiType containerType = ((PsiClassObjectAccessExpression) containerRef).getOperand().getType();
if (!(containerType instanceof PsiClassType)) return null;
PsiClass container = ((PsiClassType) containerType).resolve();
if (container == null || !container.isAnnotationType()) return null;
return container;
}
@Override
@NotNull
public PsiClass createAnnotationType(@NotNull PsiDirectory dir, @NotNull String name)
throws IncorrectOperationException {
String templateName = JavaTemplateUtil.INTERNAL_ANNOTATION_TYPE_TEMPLATE_NAME;
PsiClass someClass = createClassFromTemplate(dir, name, templateName);
if (!someClass.isAnnotationType()) {
throw new IncorrectOperationException(getIncorrectTemplateMessage(templateName));
}
return someClass;
}
@Test
public void shouldNotFindBuilderForAnnotationType() {
// given
given(psiClass.isAnnotationType()).willReturn(true);
// when
PsiClass result = builderFinder.findBuilderForClass(psiClass);
// then
assertThat(result, is(nullValue()));
}
@Before
public void setUp() {
given(psiClass.isEnum()).willReturn(false);
given(psiClass.isInterface()).willReturn(false);
given(psiClass.isAnnotationType()).willReturn(false);
given(psiClass.getProject()).willReturn(project);
given(psiClass.getName()).willReturn(CLASS_NAME);
given(builderClass.getName()).willReturn(BUILDER_NAME);
given(builderClass.getProject()).willReturn(project);
}
@Override
public boolean execute(
@NotNull final AnnotatedElementsSearch.Parameters p,
@NotNull final Processor<PsiModifierListOwner> consumer) {
final PsiClass annClass = p.getAnnotationClass();
assert annClass.isAnnotationType()
: "Annotation type should be passed to annotated members search";
final String annotationFQN = annClass.getQualifiedName();
assert annotationFQN != null;
final SearchScope useScope = p.getScope();
for (final PsiElement elt : getJetAnnotationCandidates(annClass, useScope)) {
if (notJetAnnotationEntry(elt)) continue;
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
public void run() {
// TODO LazyResolve
AnalyzeExhaust analyzeExhaust =
WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile(
(JetFile) elt.getContainingFile());
JetDeclaration parentOfType =
PsiTreeUtil.getParentOfType(elt, JetDeclaration.class);
if (parentOfType == null) return;
BindingContext context = analyzeExhaust.getBindingContext();
AnnotationDescriptor annotationDescriptor =
context.get(BindingContext.ANNOTATION, (JetAnnotationEntry) elt);
if (annotationDescriptor == null) return;
ClassifierDescriptor descriptor =
annotationDescriptor.getType().getConstructor().getDeclarationDescriptor();
if (descriptor == null) return;
if (!(DescriptorUtils.getFQName(descriptor).getFqName().equals(annotationFQN)))
return;
if (parentOfType instanceof JetClass) {
JetLightClass lightClass = JetLightClass.wrapDelegate((JetClass) parentOfType);
consumer.process(lightClass);
} else if (parentOfType instanceof JetNamedFunction) {
PsiMethod wrappedMethod =
JetLightClass.wrapMethod((JetNamedFunction) parentOfType);
consumer.process(wrappedMethod);
}
}
});
}
return true;
}
private static boolean containsError(PsiAnnotation annotation) {
final PsiJavaCodeReferenceElement nameRef = annotation.getNameReferenceElement();
if (nameRef == null) {
return true;
}
final PsiClass aClass = (PsiClass) nameRef.resolve();
if (aClass == null || !aClass.isAnnotationType()) {
return true;
}
final Set<String> names = new HashSet<String>();
final PsiAnnotationParameterList annotationParameterList = annotation.getParameterList();
if (PsiUtilCore.hasErrorElementChild(annotationParameterList)) {
return true;
}
final PsiNameValuePair[] attributes = annotationParameterList.getAttributes();
for (PsiNameValuePair attribute : attributes) {
final PsiReference reference = attribute.getReference();
if (reference == null) {
return true;
}
final PsiMethod method = (PsiMethod) reference.resolve();
if (method == null) {
return true;
}
final PsiAnnotationMemberValue value = attribute.getValue();
if (value == null || PsiUtilCore.hasErrorElementChild(value)) {
return true;
}
if (value instanceof PsiAnnotation && containsError((PsiAnnotation) value)) {
return true;
}
if (!hasCorrectType(value, method.getReturnType())) {
return true;
}
final String name = attribute.getName();
if (!names.add(name != null ? name : PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME)) {
return true;
}
}
for (PsiMethod method : aClass.getMethods()) {
if (!(method instanceof PsiAnnotationMethod)) {
continue;
}
final PsiAnnotationMethod annotationMethod = (PsiAnnotationMethod) method;
if (annotationMethod.getDefaultValue() == null
&& !names.contains(annotationMethod.getName())) {
return true; // missing a required argument
}
}
return false;
}
/**
* Returns a set of targets where the given annotation may be applied, or {@code null} when the
* type is not a valid annotation.
*/
@Nullable
public static Set<TargetType> getAnnotationTargets(@NotNull PsiClass annotationType) {
if (!annotationType.isAnnotationType()) return null;
PsiModifierList modifierList = annotationType.getModifierList();
if (modifierList == null) return null;
PsiAnnotation target =
modifierList.findAnnotation(CommonClassNames.JAVA_LANG_ANNOTATION_TARGET);
if (target == null)
return DEFAULT_TARGETS; // if omitted it is applicable to all but Java 8
// TYPE_USE/TYPE_PARAMETERS targets
return extractRequiredAnnotationTargets(target.findAttributeValue(null));
}
@Nullable
public static HighlightInfo checkCyclicMemberType(PsiTypeElement typeElement, PsiClass aClass) {
LOG.assertTrue(aClass.isAnnotationType());
PsiType type = typeElement.getType();
final Set<PsiClass> checked = new HashSet<PsiClass>();
if (cyclicDependencies(aClass, type, checked, aClass.getManager())) {
String description = JavaErrorMessages.message("annotation.cyclic.element.type");
return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
.range(typeElement)
.descriptionAndTooltip(description)
.create();
}
return null;
}
@Override
public Boolean visitClassType(PsiClassType classType) {
if (classType.getParameters().length > 0) {
PsiClassType rawType = classType.rawType();
return rawType.equalsToText(CommonClassNames.JAVA_LANG_CLASS);
}
PsiClass aClass = classType.resolve();
if (aClass != null && (aClass.isAnnotationType() || aClass.isEnum())) {
return Boolean.TRUE;
}
return classType.equalsToText(CommonClassNames.JAVA_LANG_CLASS)
|| classType.equalsToText(CommonClassNames.JAVA_LANG_STRING);
}
private static boolean cyclicDependencies(
PsiClass aClass, PsiType type, @NotNull Set<PsiClass> checked, @NotNull PsiManager manager) {
final PsiClass resolvedClass = PsiUtil.resolveClassInType(type);
if (resolvedClass != null && resolvedClass.isAnnotationType()) {
if (aClass == resolvedClass) {
return true;
}
if (!checked.add(resolvedClass) || !manager.isInProject(resolvedClass)) return false;
final PsiMethod[] methods = resolvedClass.getMethods();
for (PsiMethod method : methods) {
if (cyclicDependencies(aClass, method.getReturnType(), checked, manager)) return true;
}
}
return false;
}
@Override
public void visitClass(@NotNull PsiClass aClass) {
if (!aClass.isInterface() || aClass.isAnnotationType()) {
return;
}
if (ignoreInterfacesThatOnlyDeclareConstants && aClass.getMethods().length == 0) {
if (aClass.getFields().length != 0) {
return;
}
}
if (InheritanceUtil.hasImplementation(aClass)) {
return;
}
registerClassError(aClass);
}
public static boolean hasAccessibleConstructor(PsiType type) {
if (type instanceof PsiArrayType) return true;
final PsiClass psiClass = PsiUtil.resolveClassInType(type);
if (psiClass == null || psiClass.isEnum() || psiClass.isAnnotationType()) return false;
if (!(psiClass instanceof PsiCompiledElement)) return true;
final PsiMethod[] methods = psiClass.getConstructors();
if (methods.length == 0) return true;
for (final PsiMethod method : methods) {
if (!method.hasModifierProperty(PsiModifier.PRIVATE)) return true;
}
return false;
}
@Nullable
public static HighlightInfo checkMissingAttributes(PsiAnnotation annotation) {
PsiJavaCodeReferenceElement nameRef = annotation.getNameReferenceElement();
if (nameRef == null) return null;
PsiClass aClass = (PsiClass) nameRef.resolve();
if (aClass != null && aClass.isAnnotationType()) {
Set<String> names = new HashSet<String>();
PsiNameValuePair[] attributes = annotation.getParameterList().getAttributes();
for (PsiNameValuePair attribute : attributes) {
final String name = attribute.getName();
if (name != null) {
names.add(name);
} else {
names.add(PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME);
}
}
PsiMethod[] annotationMethods = aClass.getMethods();
List<String> missed = new ArrayList<String>();
for (PsiMethod method : annotationMethods) {
if (PsiUtil.isAnnotationMethod(method)) {
PsiAnnotationMethod annotationMethod = (PsiAnnotationMethod) method;
if (annotationMethod.getDefaultValue() == null) {
if (!names.contains(annotationMethod.getName())) {
missed.add(annotationMethod.getName());
}
}
}
}
if (!missed.isEmpty()) {
StringBuffer buff = new StringBuffer("'" + missed.get(0) + "'");
for (int i = 1; i < missed.size(); i++) {
buff.append(", ");
buff.append("'").append(missed.get(i)).append("'");
}
String description = JavaErrorMessages.message("annotation.missing.attribute", buff);
return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
.range(nameRef)
.descriptionAndTooltip(description)
.create();
}
}
return null;
}
private static String getContainingClassDescription(PsiClass aClass, String formatted) {
if (aClass instanceof PsiAnonymousClass) {
return LangBundle.message("java.terms.of.anonymous.class", formatted);
} else {
final String qualifiedName = aClass.getQualifiedName();
final String className = qualifiedName != null ? qualifiedName : aClass.getName();
if (aClass.isInterface()) {
return LangBundle.message("java.terms.of.interface", formatted, className);
}
if (aClass.isEnum()) {
return LangBundle.message("java.terms.of.enum", formatted, className);
}
if (aClass.isAnnotationType()) {
return LangBundle.message("java.terms.of.annotation.type", formatted, className);
}
return LangBundle.message("java.terms.of.class", formatted, className);
}
}
@NotNull
public static TargetType[] getApplicableElementTypeFields(PsiElement owner) {
if (owner instanceof PsiClass) {
PsiClass aClass = (PsiClass) owner;
if (aClass.isAnnotationType()) {
return new TargetType[] {TargetType.ANNOTATION_TYPE, TargetType.TYPE};
} else if (aClass instanceof GrTypeParameter) {
return new TargetType[] {TargetType.TYPE_PARAMETER};
} else {
return new TargetType[] {TargetType.TYPE};
}
}
if (owner instanceof GrMethod) {
if (((PsiMethod) owner).isConstructor()) {
return new TargetType[] {TargetType.CONSTRUCTOR};
} else {
return new TargetType[] {TargetType.METHOD};
}
}
if (owner instanceof GrVariableDeclaration) {
final GrVariable[] variables = ((GrVariableDeclaration) owner).getVariables();
if (variables.length == 0) {
return TargetType.EMPTY_ARRAY;
}
if (variables[0] instanceof GrField || ResolveUtil.isScriptField(variables[0])) {
return new TargetType[] {TargetType.FIELD};
} else {
return new TargetType[] {TargetType.LOCAL_VARIABLE};
}
}
if (owner instanceof GrParameter) {
return new TargetType[] {TargetType.PARAMETER};
}
if (owner instanceof GrPackageDefinition) {
return new TargetType[] {TargetType.PACKAGE};
}
if (owner instanceof GrTypeElement) {
return new TargetType[] {TargetType.TYPE_USE};
}
return TargetType.EMPTY_ARRAY;
}
@NotNull
public static PsiClassType[] getExtendsListTypes(@NotNull PsiClass psiClass) {
if (psiClass.isEnum()) {
PsiClassType enumSuperType =
getEnumSuperType(
psiClass, JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory());
return enumSuperType == null ? PsiClassType.EMPTY_ARRAY : new PsiClassType[] {enumSuperType};
}
if (psiClass.isAnnotationType()) {
return new PsiClassType[] {
getAnnotationSuperType(
psiClass, JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory())
};
}
final PsiReferenceList extendsList = psiClass.getExtendsList();
if (extendsList != null) {
return extendsList.getReferencedTypes();
}
return PsiClassType.EMPTY_ARRAY;
}
private void checkMember(@NotNull final PsiMember member) {
if (member.hasModifierProperty(PsiModifier.PRIVATE)
|| member.hasModifierProperty(PsiModifier.NATIVE)) return;
if (member instanceof PsiMethod && member instanceof SyntheticElement || !member.isPhysical())
return;
if (member instanceof PsiMethod) {
PsiMethod method = (PsiMethod) member;
if (!method.getHierarchicalMethodSignature().getSuperSignatures().isEmpty()) {
log(member.getName() + " overrides");
return; // overrides
}
if (MethodUtils.isOverridden(method)) {
log(member.getName() + " overridden");
return;
}
}
if (member instanceof PsiEnumConstant) return;
if (member instanceof PsiClass
&& (member instanceof PsiAnonymousClass
|| member instanceof PsiTypeParameter
|| member instanceof PsiSyntheticClass
|| PsiUtil.isLocalClass((PsiClass) member))) {
return;
}
final PsiClass memberClass = member.getContainingClass();
if (memberClass != null
&& (memberClass.isInterface()
|| memberClass.isEnum()
|| memberClass.isAnnotationType()
|| PsiUtil.isLocalClass(memberClass) && member instanceof PsiClass)) {
return;
}
final PsiFile memberFile = member.getContainingFile();
Project project = memberFile.getProject();
if (myDeadCodeInspection.isEntryPoint(member)) {
log(member.getName() + " is entry point");
return;
}
PsiModifierList memberModifierList = member.getModifierList();
if (memberModifierList == null) return;
final int currentLevel = PsiUtil.getAccessLevel(memberModifierList);
final AtomicInteger maxLevel = new AtomicInteger(PsiUtil.ACCESS_LEVEL_PRIVATE);
final AtomicBoolean foundUsage = new AtomicBoolean();
PsiDirectory memberDirectory = memberFile.getContainingDirectory();
final PsiPackage memberPackage =
memberDirectory == null
? null
: JavaDirectoryService.getInstance().getPackage(memberDirectory);
log(member.getName() + ": checking effective level for " + member);
boolean result =
UnusedSymbolUtil.processUsages(
project,
memberFile,
member,
new EmptyProgressIndicator(),
null,
new Processor<UsageInfo>() {
@Override
public boolean process(UsageInfo info) {
foundUsage.set(true);
PsiFile psiFile = info.getFile();
if (psiFile == null) return true;
if (!(psiFile instanceof PsiJavaFile)) {
log(" refd from " + psiFile.getName() + "; set to public");
maxLevel.set(PsiUtil.ACCESS_LEVEL_PUBLIC);
if (memberClass != null) {
childMembersAreUsedOutsideMyPackage.add(memberClass);
}
return false; // referenced from XML, has to be public
}
// int offset = info.getNavigationOffset();
// if (offset == -1) return true;
PsiElement element = info.getElement();
if (element == null) return true;
@PsiUtil.AccessLevel
int level =
getEffectiveLevel(element, psiFile, memberFile, memberClass, memberPackage);
log(
" ref in file "
+ psiFile.getName()
+ "; level = "
+ PsiUtil.getAccessModifier(level)
+ "; ("
+ element
+ ")");
while (true) {
int oldLevel = maxLevel.get();
if (level <= oldLevel || maxLevel.compareAndSet(oldLevel, level)) break;
}
if (level == PsiUtil.ACCESS_LEVEL_PUBLIC && memberClass != null) {
childMembersAreUsedOutsideMyPackage.add(memberClass);
}
return level != PsiUtil.ACCESS_LEVEL_PUBLIC;
}
});
if (!foundUsage.get()) {
log(member.getName() + " unused; ignore");
return; // do not propose private for unused method
}
int max = maxLevel.get();
if (max == PsiUtil.ACCESS_LEVEL_PRIVATE && memberClass == null) {
max = PsiUtil.ACCESS_LEVEL_PACKAGE_LOCAL;
}
log(member.getName() + ": effective level is '" + PsiUtil.getAccessModifier(max) + "'");
if (max < currentLevel) {
if (max == PsiUtil.ACCESS_LEVEL_PACKAGE_LOCAL
&& member instanceof PsiClass
&& childMembersAreUsedOutsideMyPackage.contains(member)) {
log(member.getName() + " children used outside my package; ignore");
return; // e.g. some public method is used outside my package (without importing class)
}
PsiElement toHighlight =
currentLevel == PsiUtil.ACCESS_LEVEL_PACKAGE_LOCAL
? ((PsiNameIdentifierOwner) member).getNameIdentifier()
: ContainerUtil.find(
memberModifierList.getChildren(),
new Condition<PsiElement>() {
@Override
public boolean value(PsiElement element) {
return element instanceof PsiKeyword
&& element.getText().equals(PsiUtil.getAccessModifier(currentLevel));
}
});
assert toHighlight != null
: member
+ " ; "
+ ((PsiNameIdentifierOwner) member).getNameIdentifier()
+ "; "
+ memberModifierList.getText();
myHolder.registerProblem(
toHighlight,
"Access can be " + PsiUtil.getAccessModifier(max),
new ChangeModifierFix(PsiUtil.getAccessModifier(max)));
}
}
public SNode convertClass(PsiClass x) {
final Wrappers._T<SNode> classifier = new Wrappers._T<SNode>();
if (x.isAnnotationType()) {
classifier.value =
SConceptOperations.createNewNode("jetbrains.mps.baseLanguage.structure.Annotation", null);
} else if (x.isEnum()) {
classifier.value =
SConceptOperations.createNewNode("jetbrains.mps.baseLanguage.structure.EnumClass", null);
} else if (x.isInterface()) {
classifier.value =
SConceptOperations.createNewNode("jetbrains.mps.baseLanguage.structure.Interface", null);
} else {
classifier.value =
SConceptOperations.createNewNode(
"jetbrains.mps.baseLanguage.structure.ClassConcept", null);
}
final SNode ourConcept = SNodeOperations.getConceptDeclaration(classifier.value);
SPropertyOperations.set(classifier.value, "name", x.getName());
SLinkOperations.setTarget(classifier.value, "visibility", getVisibility(x), true);
SConceptPropertyOperations.setBoolean(classifier.value, "final", isFinal(x));
addTypeParams(x, classifier.value);
if (isNotEmpty_rbndtb_a0m0a(SPropertyOperations.getString(classifier.value, "name"))) {
String id =
SNodeId.Foreign.ID_PREFIX + SPropertyOperations.getString(classifier.value, "name");
classifier.value.setId(new SNodeId.Foreign(id));
}
Sequence.fromIterable(Sequence.fromArray(x.getFields()))
.visitAll(
new IVisitor<PsiField>() {
public void visit(PsiField it) {
SNode node = convertField(it, ourConcept);
if (SNodeOperations.isInstanceOf(
node, "jetbrains.mps.baseLanguage.structure.StaticFieldDeclaration")) {
ListSequence.fromList(
SLinkOperations.getTargets(classifier.value, "staticField", true))
.addElement(
SNodeOperations.cast(
node, "jetbrains.mps.baseLanguage.structure.StaticFieldDeclaration"));
} else if (SNodeOperations.isInstanceOf(
node, "jetbrains.mps.baseLanguage.structure.FieldDeclaration")) {
ListSequence.fromList(
SLinkOperations.getTargets(
SNodeOperations.cast(
classifier.value,
"jetbrains.mps.baseLanguage.structure.ClassConcept"),
"field",
true))
.addElement(
SNodeOperations.cast(
node, "jetbrains.mps.baseLanguage.structure.FieldDeclaration"));
}
}
});
Sequence.fromIterable(Sequence.fromArray(x.getMethods()))
.visitAll(
new IVisitor<PsiMethod>() {
public void visit(PsiMethod it) {
SNode node = convertMethod(it, ourConcept);
if (SNodeOperations.isInstanceOf(
node, "jetbrains.mps.baseLanguage.structure.InstanceMethodDeclaration")) {
ListSequence.fromList(
SLinkOperations.getTargets(classifier.value, "method", true))
.addElement(
SNodeOperations.cast(
node,
"jetbrains.mps.baseLanguage.structure.InstanceMethodDeclaration"));
} else if (SNodeOperations.isInstanceOf(
node, "jetbrains.mps.baseLanguage.structure.StaticMethodDeclaration")) {
ListSequence.fromList(
SLinkOperations.getTargets(
SNodeOperations.cast(
classifier.value,
"jetbrains.mps.baseLanguage.structure.ClassConcept"),
"staticMethod",
true))
.addElement(
SNodeOperations.cast(
node,
"jetbrains.mps.baseLanguage.structure.StaticMethodDeclaration"));
} else if (SNodeOperations.isInstanceOf(
node, "jetbrains.mps.baseLanguage.structure.ConstructorDeclaration")) {
ListSequence.fromList(
SLinkOperations.getTargets(
SNodeOperations.cast(
classifier.value,
"jetbrains.mps.baseLanguage.structure.ClassConcept"),
"constructor",
true))
.addElement(
SNodeOperations.cast(
node, "jetbrains.mps.baseLanguage.structure.ConstructorDeclaration"));
}
}
});
return classifier.value;
}
public PsiElement findTargetMember(PsiElement element) {
IGosuMethod method = PsiTreeUtil.getParentOfType(element, IGosuMethod.class);
IGosuStatementList stList = PsiTreeUtil.getParentOfType(element, IGosuStatementList.class);
if (method != null && stList == null) {
return method;
}
if (PsiTreeUtil.getParentOfType(element, PsiParameterList.class) != null) {
return PsiTreeUtil.getParentOfType(element, PsiMethod.class);
}
final PsiTypeParameterList typeParameterList =
PsiTreeUtil.getParentOfType(element, PsiTypeParameterList.class);
if (typeParameterList != null) {
return PsiTreeUtil.getParentOfType(typeParameterList, PsiMember.class);
}
final PsiElement elementParent = element.getParent();
if (elementParent instanceof PsiMethod
&& ((PsiMethod) elementParent).getNameIdentifier() == element) {
final PsiClass containingClass = ((PsiMethod) elementParent).getContainingClass();
if (containingClass != null && containingClass.isAnnotationType()) {
return null;
}
return elementParent;
}
if (elementParent instanceof PsiClass
&& ((PsiClass) elementParent).getNameIdentifier() == element) {
if (((PsiClass) elementParent).isAnnotationType()) {
return null;
}
return elementParent;
}
final PsiCallExpression expression =
PsiTreeUtil.getParentOfType(element, PsiCallExpression.class);
if (expression != null) {
final PsiExpression qualifierExpression;
if (expression instanceof PsiMethodCallExpression) {
qualifierExpression =
((PsiMethodCallExpression) expression).getMethodExpression().getQualifierExpression();
} else if (expression instanceof PsiNewExpression) {
qualifierExpression = ((PsiNewExpression) expression).getQualifier();
} else {
qualifierExpression = null;
}
if (PsiTreeUtil.isAncestor(qualifierExpression, element, false)) {
final PsiExpressionList expressionList =
PsiTreeUtil.getParentOfType(qualifierExpression, PsiExpressionList.class);
if (expressionList != null) {
final PsiElement parent = expressionList.getParent();
if (parent instanceof PsiCallExpression) {
return ((PsiCallExpression) parent).resolveMethod();
}
}
} else {
return expression.resolveMethod();
}
}
final PsiReferenceParameterList referenceParameterList =
PsiTreeUtil.getParentOfType(element, PsiReferenceParameterList.class);
if (referenceParameterList != null) {
final PsiJavaCodeReferenceElement referenceElement =
PsiTreeUtil.getParentOfType(referenceParameterList, PsiJavaCodeReferenceElement.class);
if (referenceElement != null) {
final PsiElement resolved = referenceElement.resolve();
if (resolved instanceof PsiClass) {
return resolved;
} else if (resolved instanceof PsiMethod) {
return resolved;
}
}
}
return null;
}
