/*
* SonarQube Java
* Copyright (C) 2012-2016 SonarSource SA
* mailto:contact AT sonarsource DOT com
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package org.sonar.java.checks;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.LinkedListMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
import org.apache.commons.lang.BooleanUtils;
import org.sonar.check.Rule;
import org.sonar.java.model.declaration.MethodTreeImpl;
import org.sonar.plugins.java.api.IssuableSubscriptionVisitor;
import org.sonar.plugins.java.api.semantic.Symbol;
import org.sonar.plugins.java.api.semantic.Type;
import org.sonar.plugins.java.api.tree.ClassTree;
import org.sonar.plugins.java.api.tree.IdentifierTree;
import org.sonar.plugins.java.api.tree.MethodTree;
import org.sonar.plugins.java.api.tree.Tree;
import org.sonar.plugins.java.api.tree.VariableTree;
import java.util.List;
import java.util.Optional;
@Rule(key = "S1845")
public class MembersDifferOnlyByCapitalizationCheck extends IssuableSubscriptionVisitor {
@Override
public List<Tree.Kind> nodesToVisit() {
return ImmutableList.of(Tree.Kind.CLASS, Tree.Kind.INTERFACE, Tree.Kind.ENUM);
}
@Override
public void visitNode(Tree tree) {
if (!hasSemantic()) {
return;
}
ClassTree classTree = (ClassTree) tree;
List<Symbol> allMembers = retrieveMembers(classTree.symbol());
Multimap<String, Symbol> membersByName = sortByName(allMembers);
for (Tree member : classTree.members()) {
if (member.is(Tree.Kind.METHOD)) {
MethodTree methodTree = (MethodTree) member;
checkForIssue(methodTree.symbol(), methodTree.simpleName(), membersByName);
} else if (member.is(Tree.Kind.VARIABLE)) {
VariableTree variableTree = (VariableTree) member;
checkForIssue(variableTree.symbol(), variableTree.simpleName(), membersByName);
}
}
}
private void checkForIssue(Symbol symbol, IdentifierTree reportTree, Multimap<String, Symbol> membersByName) {
String name = symbol.name();
for (String knownMemberName : membersByName.keySet()) {
if (name.equalsIgnoreCase(knownMemberName)) {
Optional<Symbol> conflictingMember = membersByName.get(knownMemberName).stream()
.filter(knownMemberSymbol -> !symbol.equals(knownMemberSymbol) && isValidIssueLocation(symbol, knownMemberSymbol) && isInvalidMember(symbol, knownMemberSymbol))
.findFirst();
if (conflictingMember.isPresent()) {
Symbol conflictingSymbol = conflictingMember.get();
reportIssue(reportTree,
"Rename "
+ getSymbolTypeName(symbol) + " \"" + name + "\" "
+ "to prevent any misunderstanding/clash with "
+ getSymbolTypeName(conflictingSymbol) + " \"" + knownMemberName + "\""
+ getDefinitionPlace(symbol, conflictingSymbol) + ".");
}
}
}
}
private static boolean isOverriding(Symbol symbol) {
if (symbol.isMethodSymbol()) {
MethodTreeImpl methodDeclaration = (MethodTreeImpl) symbol.declaration();
return methodDeclaration != null && BooleanUtils.isTrue(methodDeclaration.isOverriding());
}
return false;
}
private static boolean isInvalidMember(Symbol currentMember, Symbol knownMember) {
if (!isOverriding(currentMember)) {
return differentTypes(currentMember, knownMember) ? sameVisibilityNotPrivate(currentMember, knownMember) : !sameName(currentMember, knownMember);
}
return false;
}
private static boolean isValidIssueLocation(Symbol currentMember, Symbol knownMember) {
return !sameOwner(currentMember, knownMember) || isOverriding(knownMember) || getDeclarationLine(currentMember) > getDeclarationLine(knownMember);
}
private static boolean sameVisibilityNotPrivate(Symbol s1, Symbol s2) {
return bothPublic(s1, s2) || bothProtected(s1, s2) || bothPackageVisibility(s1, s2);
}
private static boolean bothPackageVisibility(Symbol s1, Symbol s2) {
return s1.isPackageVisibility() && s2.isPackageVisibility();
}
private static boolean bothProtected(Symbol s1, Symbol s2) {
return s1.isProtected() && s2.isProtected();
}
private static boolean bothPublic(Symbol s1, Symbol s2) {
return s1.isPublic() && s2.isPublic();
}
private static boolean sameOwner(Symbol currentMember, Symbol knownMember) {
return currentMember.owner().equals(knownMember.owner());
}
private static boolean sameName(Symbol currentMember, Symbol knownMember) {
return currentMember.name().equals(knownMember.name());
}
private static boolean differentTypes(Symbol s1, Symbol s2) {
return variableAndMethod(s1, s2) || variableAndMethod(s2, s1);
}
private static boolean variableAndMethod(Symbol s1, Symbol s2) {
return s1.isVariableSymbol() && s2.isMethodSymbol();
}
private static String getDefinitionPlace(Symbol symbol, Symbol knownMemberSymbol) {
if (sameOwner(symbol, knownMemberSymbol)) {
int declarationLine = getDeclarationLine(knownMemberSymbol);
if (declarationLine == -1) {
return "";
}
return " defined on line " + declarationLine;
}
return " defined in " + (knownMemberSymbol.owner().isInterface() ? "interface" : "superclass") + " \"" + knownMemberSymbol.owner().type().fullyQualifiedName() + "\"";
}
private static int getDeclarationLine(Symbol symbol) {
if (symbol.declaration() == null) {
return -1;
}
if (symbol.isVariableSymbol()) {
return ((Symbol.VariableSymbol) symbol).declaration().simpleName().identifierToken().line();
}
return ((Symbol.MethodSymbol) symbol).declaration().simpleName().identifierToken().line();
}
private static String getSymbolTypeName(Symbol symbol) {
return symbol.isMethodSymbol() ? "method" : "field";
}
private static Multimap<String, Symbol> sortByName(List<Symbol> members) {
Multimap<String, Symbol> membersByName = LinkedListMultimap.create();
for (Symbol member : members) {
membersByName.put(member.name(), member);
}
return membersByName;
}
private static List<Symbol> retrieveMembers(Symbol.TypeSymbol classSymbol) {
List<Symbol> results = Lists.newLinkedList();
results.addAll(extractMembers(classSymbol, false));
for (Type parentInterface : classSymbol.interfaces()) {
results.addAll(extractMembers(parentInterface.symbol(), true));
}
Type superClass = classSymbol.superClass();
if (superClass != null) {
results.addAll(extractMembers(superClass.symbol(), true));
}
return results;
}
private static List<Symbol> extractMembers(Symbol.TypeSymbol classSymbol, boolean ignorePrivate) {
List<Symbol> results = Lists.newLinkedList();
for (Symbol symbol : classSymbol.memberSymbols()) {
if ((isVariableToExtract(symbol) || isMethodToExtract(symbol)) && !(symbol.isPrivate() && ignorePrivate)) {
results.add(symbol);
}
}
return results;
}
private static boolean isVariableToExtract(Symbol symbol) {
String name = symbol.name();
return !symbol.isEnum() && symbol.isVariableSymbol() && !"this".equals(name) && !"super".equals(name);
}
private static boolean isMethodToExtract(Symbol symbol) {
return symbol.isMethodSymbol() && !"<init>".equals(symbol.name());
}
}