Added factory function check to MemberNameEqualsClassName

detekt-rules/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/style/MemberNameEqualsClassName.kt

@@ -8,10 +8,14 @@ import io.gitlab.arturbosch.detekt.api.Issue
 import io.gitlab.arturbosch.detekt.api.Rule
 import io.gitlab.arturbosch.detekt.api.Severity
 import io.gitlab.arturbosch.detekt.rules.isOverridden
+import org.jetbrains.kotlin.psi.KtBlockExpression
 import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassBody
 import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.KtObjectDeclaration
+import org.jetbrains.kotlin.util.collectionUtils.concat
 
 /**
  *
@@ -47,37 +51,49 @@ class MemberNameEqualsClassName(config: Config = Config.empty) : Rule(config) {
 
 	override fun visitClass(klass: KtClass) {
 		if (!klass.isInterface()) {
-			checkClassOrObjectFunctions(klass, klass.name, classMessage)
- 			checkCompanionObjectFunctions(klass)
+			getMisnamedMembers(klass, klass.name)
+					.concat(getMisnamedCompanionObjectMembers(klass))
+					?.forEach { report(CodeSmell(issue, Entity.from(it), classMessage)) }
 		}
 		super.visitClass(klass)
 	}
 
 	override fun visitObjectDeclaration(declaration: KtObjectDeclaration) {
 		if (!declaration.isCompanion()) {
-			checkClassOrObjectFunctions(declaration, declaration.name, objectMessage)
+			getMisnamedMembers(declaration, declaration.name)
+					.forEach { report(CodeSmell(issue, Entity.from(it), objectMessage)) }
 		}
 		super.visitObjectDeclaration(declaration)
 	}
 
-	private fun checkClassOrObjectFunctions(klassOrObject: KtClassOrObject, name: String?, message: String) {
-		val body = klassOrObject.getBody() ?: return
+	private fun getMisnamedMembers(klassOrObject: KtClassOrObject, name: String?): List<KtNamedDeclaration> {
+		val body = klassOrObject.getBody() ?: return emptyList()
+		val declarations = getFunctions(body).concat(body.properties)
+		return declarations?.filter { it.name?.equals(name, ignoreCase = true) == true } ?: emptyList()
+	}
+
+	private fun getFunctions(body: KtClassBody): List<KtNamedDeclaration> {
 		var functions = body.children.filterIsInstance<KtNamedFunction>()
 		if (ignoreOverriddenFunction) {
 			functions = functions.filter { !it.isOverridden() }
 		}
-		functions
-				.filter { it.name?.equals(name, ignoreCase = true) == true }
-				.forEach { report(CodeSmell(issue, Entity.from(it), message)) }
-		body.properties
-				.filter { it.name?.equals(name, ignoreCase = true) == true }
-				.forEach { report(CodeSmell(issue, Entity.from(it), message)) }
+		return functions
 	}
 
-	private fun checkCompanionObjectFunctions(klass: KtClass) {
-		klass.companionObjects.forEach {
-			checkClassOrObjectFunctions(it, klass.name, classMessage)
-		}
+	private fun getMisnamedCompanionObjectMembers(klass: KtClass): List<KtNamedDeclaration> {
+		val list = mutableListOf<KtNamedDeclaration>()
+		klass.companionObjects.forEach { list.addAll(getMisnamedMembers(it, klass.name)) }
+		list
+				.filterIsInstance<KtNamedFunction>()
+				.filter { isFactoryMethod(it, klass) }
+				.forEach { it -> list.remove(it) }
+		return list
+	}
+
+	private fun isFactoryMethod(function: KtNamedFunction, klass: KtClass): Boolean {
+		val typeReference = function.typeReference
+		return typeReference == null && function.bodyExpression !is KtBlockExpression
+				|| typeReference?.text?.equals(klass.name) == true
 	}
 
 	companion object {

detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/style/MemberNameEqualsClassNameSpec.kt

@@ -26,7 +26,7 @@ class MemberNameEqualsClassNameSpec : SubjectSpek<MemberNameEqualsClassName>({
 		val findings = subject.lint(path)
 
 		it("reports methods which are named after the class") {
-			assertThat(findings).hasSize(6)
+			assertThat(findings).hasSize(8)
 		}
 
 		it("reports methods which are named after the class object") {
@@ -37,7 +37,7 @@ class MemberNameEqualsClassNameSpec : SubjectSpek<MemberNameEqualsClassName>({
 		it("reports methods which are named after the class object including overridden functions") {
 			val config = TestConfig(mapOf("ignoreOverriddenFunction" to "false"))
 			val rule = MemberNameEqualsClassName(config)
-			assertThat(rule.lint(path)).hasSize(7)
+			assertThat(rule.lint(path)).hasSize(9)
 		}
 	}
 })

detekt-rules/src/test/resources/cases/MemberNameEqualsClassNameNegative.kt

@@ -25,6 +25,24 @@ class StaticMethodNameEqualsObjectName {
 	}
 }
 
+// factory method can have the same name as the class
+class FactoryClass1 {
+
+	companion object {
+		fun factoryClass1(): FactoryClass1 {
+			return FactoryClass1()
+		}
+	}
+}
+
+// factory method can have the same name as the class
+class FactoryClass2 {
+
+	companion object {
+		fun factoryClass2() = FactoryClass2()
+	}
+}
+
 abstract class BaseClassForMethodNameEqualsClassName {
 
 	abstract fun AbstractMethodNameEqualsClassName()

detekt-rules/src/test/resources/cases/MemberNameEqualsClassNamePositive.kt

@@ -37,6 +37,22 @@ class MethodNameContainer {
 	}
 }
 
+class WrongFactoryClass1 {
+
+	companion object {
+		fun wrongFactoryClass1() {} // reports 1 - no return type
+	}
+}
+
+class WrongFactoryClass2 {
+
+	companion object {
+		fun wrongFactoryClass2(): Int { // reports 1 - wrong return type
+			return 0
+		}
+	}
+}
+
 class AbstractMethodNameEqualsClassName : BaseClassForMethodNameEqualsClassName() {
 
 	// reports if overridden functions are not ignored