detektの概要や導入については以下をご参照ください。
Kotlinの静的解析ツール「detekt」のセットアップ方法
注意
公式ページのルールを簡単に翻訳してまとめたものです。
英語に慣れている方は公式ページを直接見るのがいいです。
https://detekt.github.io/detekt/complexity.html
また、間違っている箇所や不適切な箇所がありましたら教えていただけると嬉しいです。
環境
- Kotlin：1.5.31
- Android Studio：Arctic Fox
- detekt：1.18.1
Default
デフォルトで有効になっているルールの一覧です。
Complexity Rule
ComplexCondition
複雑な条件は、どのような場合にその条件が真か偽かを理解するのが難しくなります。複雑な条件を読みやすく理解しやすくするためには、条件を適切な名前の関数や変数に抽出し、それらを代わりに呼び出すことを検討してください。
// bad
val str = "foo"
val isFoo = if (str.startsWith("foo") && !str.endsWith("foo") && !str.endsWith("bar") && !str.endsWith("_")) {
// ...
}
// good
val str = "foo"
val isFoo = if (str.startsWith("foo") && hasCorrectEnding()) {
// ...
}
fun hasCorrectEnding() = return !str.endsWith("foo") && !str.endsWith("bar") && !str.endsWith("_")
ComplexMethod
複雑なメソッドは、理解するのも読むのも大変です。複雑なメソッドがどのような副作用を持つのか、明らかではないかもしれません。複雑なメソッドは、より理解しやすい小さなメソッドに分割することをお勧めします。
このルールでは、McCabeのCyclomatic Complexity (MCC)という指標を使用して、関数のソースコード内の線形独立パスの数を測定します。独立したパスの数が多いほど、そのメソッドは複雑です。
MCC循環的複雑度について -Qiita
測定対象
・Conditional statements - if, else if, when
・Jump statements - continue, break
・Loops - for, while, do-while, forEach
・Operators &&, ||, ?:
・Exceptions - catch, use
・Scope Functions - let, run, with, apply, and also
LargeClass
このルールでは、大規模なクラスを報告します。クラスは通常、1つの責任を持つべきです。一度に多くのことをするのではなく、大きなクラスを小さなクラスに分割することをお勧めします。
デフォルトはクラス内のソースコードの行数は600以内にするのがベスト
LongMethod
メソッドは1つの責任を持つべきです。行数長いメソッドは、そのメソッドが一度に多くのケースを処理していることを示します。機能を明確に説明して分かりやすい名前付きの行数少なくて小さなメソッドをお勧めします。
行数長いメソッドの機能の一部を別の小さなメソッドに抽出します。
デフォルトはメソッド内のソースコードの行数は60以内にするのがベスト
LongParameterList
コンストラクタや関数の引数の数は少なくすべきです。
// bad
fun sign(userName: String, userId: Int, userSex: String, userMail: String, isCheck: Boolean, token: String) { }
// good
data class User (
var userName: String = "",
var userId: Int = 0,
var userSex: String = "",
var userMail: String = "",
)
fun sign(user: User, isCheck: Boolean, token: String) { }
NestedBlockDepth
最大４レベルの深さでネストすべきです。
// bad
fun f_0(type: ItemType, isCheck: Boolean) {
when (type) {
ItemType.Article -> {
if (isCheck) {
if (article.isNotLoading) {
//do something
}
}
}
}
}
// good
fun f_0(type: ItemType, isCheck: Boolean) {
when (type) {
ItemType.Article -> {
f_1(isCheck)
}
}
}
fun f_1(isCheck: Boolean) {
if (isCheck) {
if (article.isNotLoading) {
//do something
}
}
}
TooManyFunctions
ファイル、クラス、インターフェース、オブジェクト、および列挙内の関数を少なくすべき。
関数が多すぎると、単一責任原則の違反となります。明らかにコードの別の部分にまとめられている機能を抽出することをお勧めします。
デフォルト11個以内
Empty-blocks
EmptyCatchBlock
空のキャッチブロックがあります。
空のキャッチ・ブロックは、例外が無視され、処理されないことを示します。例外を意図的に無視する場合は、 allowedExceptionNameRegexに指定した名前を使用して明示する必要があります。
// bad
fun f() {
try {
//do something
} catch (e: PackageManager.NameNotFoundException) {
}
}
// good
fun f() {
try {
//do something
} catch (e: PackageManager.NameNotFoundException) {
//do something for fixing Exception
}
}
EmptyClassBlock
空のクラスがあります。
EmptyDefaultConstructor
空のデフォルトコンストラクタがあります。
EmptyDoWhileBlock
空のdo/whileループがあります。
EmptyElseBlock
空のelseブロックがあります。
EmptyFinallyBlock
空のfinallyブロックがあります。
EmptyForBlock
空のforブロックがあります。
EmptyFunctionBlock
空の関数ブロックがあります。
EmptyIfBlock
空のifブロックがあります。
EmptyInitBlock
空のinitブロックがあります。
EmptyKtFile
空のKotlinファイルがあります。
EmptySecondaryConstructor
空のセカンダリコンストラクタブロックがあります。
EmptyTryBlock
空のtryブロックがあります。
EmptyWhenBlock
空のwhenブロックがあります。
EmptyWhileBlock
空のwhileブロックがあります。
Exceptions
ExceptionRaisedInUnexpectedLocation
絶対に例外を発生させてはいけない関数内で例外をスローしてはいけない
// bad
class Foo {
override fun toString(): String {
throw IllegalStateException() // exception should not be thrown here
}
}
// good
class Foo {
override fun toString(): String {
//do something
}
}
PrintStackTrace
例外を握りつぶしてはいけない
// bad
fun foo() {
Thread.dumpStack()
}
fun bar() {
try {
// ...
} catch (e: IOException) {
e.printStackTrace()
}
}
// good
val LOGGER = Logger.getLogger()
fun bar() {
try {
// ...
} catch (e: IOException) {
LOGGER.info(e)
}
}
RethrowCaughtException
例外をキャッチされた後、修正なしで再スローしてはいけない
// bad
fun foo() {
try {
// ...
} catch (e: IOException) {
throw e
}
}
// good
fun foo() {
try {
// ...
} catch (e: IOException) {
throw MyException(e)
}
try {
// ...
} catch (e: IOException) {
print(e)
throw e
}
try {
// ...
} catch (e: IOException) {
print(e.message)
throw e
}
}
ReturnFromFinally
finallyブロックでreturn文を使用すると、tryブロックでスローされた例外を破棄されるので
finallyブロックでreturn文を使用してはいけない
// bad
fun foo() {
try {
throw MyException()
} finally {
return // prevents MyException from being propagated
}
}
// good
fun foo() {
try {
throw MyException()
} catch(e: MyException) {
// do something
}
}
SwallowedException
例外を使用しないといけない。または例外をスローすべき
// bad
fun foo() {
try {
// ...
} catch(e: IOException) {
throw MyException(e.message) // e is swallowed
}
try {
// ...
} catch(e: IOException) {
throw MyException() // e is swallowed
}
try {
// ...
} catch(e: IOException) {
bar() // exception is unused
}
}
// good
fun foo() {
try {
// ...
} catch(e: IOException) {
throw MyException(e)
}
try {
// ...
} catch(e: IOException) {
println(e) // logging is ok here
}
}
ThrowingExceptionFromFinally
finallyブロックから例外を投げることは、混乱や例外の破棄につながるため、避けるべきです。
// bad
fun foo() {
try {
// ...
} finally {
throw IOException()
}
}
// good
fun foo() {
try {
// ...
} catch (e: MyException) {
throw IOException()
}
}
ThrowingExceptionsWithoutMessageOrCause
対象例外は引数や詳細な説明なしにスローされてはいけない。
デフォルト対象
['ArrayIndexOutOfBoundsException', 'Exception', 'IllegalArgumentException', 'IllegalMonitorStateException', 'IllegalStateException', 'IndexOutOfBoundsException', 'NullPointerException', 'RuntimeException', 'Throwable']
// bad
fun foo(bar: Int) {
if (bar < 1) {
throw IllegalArgumentException()
}
// ...
}
// good
fun foo(bar: Int) {
if (bar < 1) {
throw IllegalArgumentException("bar must be greater than zero")
}
// ...
}
ThrowingNewInstanceOfSameException
例外を同じ例外タイプの中に包んで、再度スローすることはしてはいけない。
// bad
fun foo() {
try {
// ...
} catch (e: IllegalStateException) {
throw IllegalStateException(e) // rethrows the same exception
}
}
// good
fun foo() {
try {
// ...
} catch (e: IllegalStateException) {
throw MyException(e)
}
}
TooGenericExceptionCaught
現在処理されているケースに対する特定の例外をキャッチすることが望ましい
キャッチする例外の範囲が広すぎると、意図しない例外がキャッチされてしまう可能性があります
デフォルト対象
['ArrayIndexOutOfBoundsException', 'Error', 'Exception', 'IllegalMonitorStateException', 'IndexOutOfBoundsException', 'NullPointerException', 'RuntimeException', 'Throwable']
// bad
fun foo() {
try {
// ... do some I/O
} catch(e: Exception) { } // too generic exception caught here
}
// good
fun foo() {
try {
// ... do some I/O
} catch(e: IOException) { }
}
TooGenericExceptionThrown
現在発生しているケースに対して特定の例外をスローすることが望ましい
スローする例外の範囲が広すぎると、意図しない例外がキャッチされてしまう可能性があります
デフォルト対象
['Error', 'Exception', 'RuntimeException', 'Throwable']
// bad
fun foo(bar: Int) {
if (bar < 1) {
throw Exception() // too generic exception thrown here
}
// ...
}
// good
fun foo(bar: Int) {
if (bar < 1) {
throw IllegalArgumentException("bar must be greater than zero")
}
// ...
}
Naming
ClassNaming
指定された命名規則に従わないクラスやオブジェクトがあります
(default: '[A-Z][a-zA-Z0-9]*')
ConstructorParameterNaming
指定された命名規則に従わないコンストラクタのパラメータがあります
(default: '[a-z][A-Za-z0-9]*')
EnumNaming
指定された命名規則に従わないEnumがあります
(default: '[A-Z][_a-zA-Z0-9]*')
FunctionNaming
指定された命名規則に従わない関数があります
(default: '([a-z][a-zA-Z0-9]*)|(.*)')
FunctionParameterNaming
指定された命名規則に従わない関数のパラメータがあります
(default: '[a-z][A-Za-z0-9]*')
MatchingDeclarationName
ファイルの名前は、そのファイルの中のコードが何をするかを説明するものでなければなりません。
// bad
class Foo // FooUtils.kt
fun Bar.toFoo(): Foo = ...
fun Foo.toBar(): Bar = ...
// good
class Foo { // Foo.kt
fun stuff() = 42
}
fun Bar.toFoo(): Foo = ...
MemberNameEqualsClassName
クラスまたはオブジェクトと同じ名を持つメンバー関数や変数があります。
クラスのインスタンスを作成するファクトリー関数は、このルールの対象外です。
// bad
class MethodNameEqualsClassName {
fun methodNameEqualsClassName() { }
}
class PropertyNameEqualsClassName {
val propertyEqualsClassName = 0
}
// good
class Manager {
companion object {
// factory functions can have the same name as the class
fun manager(): Manager {
return Manager()
}
}
}
ObjectPropertyNaming
指定された命名規則に従わないオブジェクト内のプロパティがあります。
constantPattern (default: '[A-Za-z][A-Za-z0-9]')
propertyPattern (default: '[A-Za-z][_A-Za-z0-9]')
private PropertyPattern (default: '()?[A-Za-z][_A-Za-z0-9]*')
PackageNaming
指定された命名規則に従わないパッケージがあります。
(default: '[a-z]+(.[a-z][A-Za-z0-9])')
TopLevelPropertyNaming
指定された命名規則に従わないトップレベルの定数があります。
constantPattern (default: '[A-Z][A-Z0-9]')
propertyPattern (default: '[A-Za-z][_A-Za-z0-9]')
private PropertyPattern (default: '?[A-Za-z][_A-Za-z0-9]*')
VariableNaming
指定された命名規則に従わない変数があります。
variablePattern (default: '[a-z][A-Za-z0-9]')
private VariablePattern (default: '(_)?[a-z][A-Za-z0-9]')
Performance
ArrayPrimitive
Arrayを使用すると、暗黙のボックス化が発生し、パフォーマンスが低下します。Kotlin に特化した Array インスタンスの使用を推奨します。
// bad
fun function(array: Array<Int>) { }
fun returningFunction(): Array<Double> { }
// good
fun function(array: IntArray) { }
fun returningFunction(): DoubleArray { }
ForEachOnRange
範囲内でforEachメソッドを使用すると、パフォーマンスが大きく低下します。シンプルなforループの使用をお勧めします。
ベンチマークによると、レンジに対してforEachを使用すると、単純なforループに比べてパフォーマンスが大幅に低下することがわかっています。
// bad
(1..10).forEach {
println(it)
}
(1 until 10).forEach {
println(it)
}
(10 downTo 1).forEach {
println(it)
}
// good
for (i in 1..10) {
println(i)
}
SpreadOperator
ほとんどの場合、拡散演算子を使用すると、メソッドを呼び出す前に、配列の完全なコピーが作成されます。
v1.1.60 以降の Kotlin コンパイラには、配列コンストラクタ関数が vararg パラメータに渡される引数の作成に使用されている場合、配列のコピーをスキップする最適化が施されています。
// bad
val strs = arrayOf("value one", "value two")
val foo = bar(*strs)
fun bar(vararg strs: String) {
strs.forEach { println(it) }
}
// good
// array copy skipped in this case since Kotlin 1.1.60
val foo = bar(*arrayOf("value one", "value two"))
// array not passed so no array copy is required
val foo2 = bar("value one", "value two")
fun bar(vararg strs: String) {
strs.forEach { println(it) }
}
UnnecessaryTemporaryInstantiation
プリミティブ型を String に変換する際、一時的なオブジェクトを使用しないようにしました。これは、プリミティブ型を直接使用する場合と比較して、パフォーマンス上のペナルティがあります。
// bad
val i = Integer(1).toString() // temporary Integer instantiation just for the conversion
// good
val i = Integer.toString(1)
Potential-bugs
DuplicateCaseInWhenExpression
when式の中に重複したcase文フラグがあります。
// bad
when (i) {
1 -> println("one")
1 -> println("one")
else -> println("else")
}
// good
when (i) {
1 -> println("one")
else -> println("else")
}
EqualsAlwaysReturnsTrueOrFalse
常にtrueまたはfalseを返すequals()メソッドがあります。
// bad
override fun equals(other: Any?): Boolean {
return true
}
// good
override fun equals(other: Any?): Boolean {
return this === other
}
EqualsWithHashCodeExist
クラスがequals()メソッドをオーバーライドする際には、hashCode()メソッドもオーバーライドする必要があります。
// bad
class Foo {
override fun equals(other: Any?): Boolean {
return super.equals(other)
}
}
// good
class Foo {
override fun equals(other: Any?): Boolean {
return super.equals(other)
}
override fun hashCode(): Int {
return super.hashCode()
}
}
ExplicitGarbageCollectionCall
ガベージコレクタを明示的に呼び出す必要はありません。
ImplicitDefaultLocale
文字列のフォーマットや大文字小文字の変換を行う際に、暗黙のデフォルト値を使用するよりも、[java.util.Locale]を明示的に渡すことをお勧めします。
デフォルトのロケールは、ほとんどの場合、HTTPヘッダのような機械で読めるテキストには不適切です。
// bad
String.format("Timestamp: %d", System.currentTimeMillis())
val str: String = getString()
str.toUpperCase()
str.toLowerCase()
// good
String.format(Locale.US, "Timestamp: %d", System.currentTimeMillis())
val str: String = getString()
str.toUpperCase(Locale.US)
str.toLowerCase(Locale.US)
InvalidRange
無効な範囲があります。
// bad
for (i in 2..1) {}
for (i in 1 downTo 2) {}
val range1 = 2 until 1
val range2 = 2 until 2
// good
for (i in 2..2) {}
for (i in 2 downTo 2) {}
val range = 2 until 3
IteratorHasNextCallsNextMethod
IteratorインターフェースのhasNext()メソッド内でnextメソッドを呼び出してはいけない。
// bad
class MyIterator : Iterator<String> {
override fun hasNext(): Boolean {
return next() != null
}
}
// good
class MyIterator : Iterator<String> {
override fun hasNext(): Boolean {
return // ...
}
override fun next(): String {
return // ...
}
}
IteratorNotThrowingNoSuchElementException
next()メソッドの実装で返すべき要素がなくなったときに NoSuchElementException を投げるべきです。
// bad
class MyIterator : Iterator<String> {
override fun next(): String {
return ""
}
}
// good
class MyIterator : Iterator<String> {
override fun next(): String {
if (!this.hasNext()) {
throw NoSuchElementException()
}
// ...
}
}
RedundantElseInWhen
冗長なelseケースを含むwhen式があります。
// bad
enum class Color {
RED,
GREEN,
BLUE
}
fun whenOnEnumFail(c: Color) {
when(c) {
Color.BLUE -> {}
Color.GREEN -> {}
Color.RED -> {}
else -> {} // no use
}
}
// good
enum class Color {
RED,
GREEN,
BLUE
}
fun whenOnEnumCompliant(c: Color) {
when(c) {
Color.BLUE -> {}
Color.GREEN -> {}
else -> {}
}
}
fun whenOnEnumCompliant2(c: Color) {
when(c) {
Color.BLUE -> {}
Color.GREEN -> {}
Color.RED -> {}
}
}
UnnecessaryNotNullOperator
不要なnot-null演算子(!!)の使用があります。
// bad
val a = 1
val b = a!!
// good
val a = 1
val b = a
UnnecessarySafeCall
不要なセーフコール演算子(?)使用があります。
// bad
val a: String = ""
val b = a?.length
// good
val a: String? = null
val b = a?.length
UnreachableCode
呼び出されないコードがあります。
// bad
for (i in 1..2) {
break
println() // unreachable
}
throw IllegalArgumentException()
println() // unreachable
fun f() {
return
println() // unreachable
}
// good
for (i in 1..2) {
println()
break
}
println()
throw IllegalArgumentException()
fun f() {
println()
return
}
UnsafeCallOnNullableType
nullable型に対する安全でない呼び出しがあります。
// bad
fun foo(str: String?) {
println(str!!.length)
}
// good
fun foo(str: String?) {
println(str?.length)
}
UnsafeCast
絶対に成功しないキャストがあります。
// bad
fun foo(s: String) {
println(s as Int)
}
fun bar(s: String) {
println(s as? Int)
}
// good
fun foo(s: Any) {
println(s as Int)
}
WrongEqualsTypeParameter
誤って型付けされたパラメータを取り込む equals() メソッドがあります。
// bad
class Foo {
fun equals(other: String): Boolean {
return super.equals(other)
}
}
// good
class Foo {
fun equals(other: Any?): Boolean {
return super.equals(other)
}
}
Style
EqualsNullCall
オブジェクトをnullと比較するには、==を使用することをお勧めします。
// bad
fun isNull(str: String) = str.equals(null)
// good
fun isNull(str: String) = str == null
ForbiddenComment
開発時にのみ使用されるべきコメントがあります。
// bad
val a = "" // TODO: remove please
// FIXME: this is a hack
fun foo() { }
// STOPSHIP:
ForbiddenPublicDataClass
データクラスは、パブリックAPIのバイナリ互換性に悪影響を及ぼします。使用を避けてください。
このルールはライブラリのメンテナに向けたものです。もしあなたが最終的なアプリケーションを開発しているのであれば、この問題は無視して構いません。
// bad
data class C(val a: String) // violation: public data class
// good
internal data class C(val a: String)
FunctionOnlyReturningConstant
1つの定数を返すだけの関数があります。const valを使用すべき。
// bad
fun functionReturningConstantString() = "1"
// good
const val constantString = "1"
LibraryCodeMustSpecifyReturnType
ライブラリのパブリックAPIとして公開される関数やプロパティには、明示的な戻り値の型が必要です。
// bad
// code from a library
val strs = listOf("foo, bar")
fun bar() = 5
class Parser {
fun parse() = ...
}
// good
// code from a library
val strs: List<String> = listOf("foo, bar")
fun bar(): Int = 5
class Parser {
fun parse(): ParsingResult = ...
}
LibraryEntitiesShouldNotBePublic
ライブラリのタイプエイリアスとクラスは、internalまたはprivateを使用すべき
// bad
// code from a library
class A
// good
// code from a library
internal class A
LoopWithTooManyJumpStatements
複数のbreakまたはcontinueステートメントを含むループは、読んで理解しにくい。
// bad
val strs = listOf("foo, bar")
for (str in strs) {
if (str == "bar") {
break
} else {
continue
}
}
MagicNumber
マジックナンバーの使用があります。
// bad
class User {
fun checkName(name: String) {
if (name.length > 42) {
throw IllegalArgumentException("username is too long")
}
// ...
}
}
// good
class User {
fun checkName(name: String) {
if (name.length > MAX_USERNAME_SIZE) {
throw IllegalArgumentException("username is too long")
}
// ...
}
companion object {
private const val MAX_USERNAME_SIZE = 42
}
}
MaxLineLength
定義された最大行長を超えるコードがあります。
(default: 120行)
MayBeConst
const val を使用する可能性のあるプロパティ (val) があります。
const valを使用すると、生成されるバイトコードのパフォーマンスが向上するだけでなく、Javaとの相互運用性も向上します。
// bad
val myConstant = "abc"
// good
const val MY_CONSTANT = "abc"
}
ModifierOrder
正しい順序でない修飾語があります。
// bad
lateinit internal val str: String
// good
internal lateinit val str: String
}
NestedClassesVisibility
ネストクラスが親クラスよりアクセスレベル高い修飾語の使用があります。
// bad
internal class Outer {
// explicit public modifier still results in an internal nested class
public class Nested
}
// good
internal class Outer {
class Nested1
internal class Nested2
}
NewLineAtEndOfFile
ファイル末尾に改行を入れるべき
実際に「C, C++」では、改行なしのソースファイルだと未定義扱いになり誤作動を引き起こす、とのこと。
OptionalAbstractKeyword
不要で削除可能な抽象的な修飾語があります。
// bad
abstract interface Foo { // abstract keyword not needed
abstract fun x() // abstract keyword not needed
abstract var y: Int // abstract keyword not needed
}
// good
interface Foo {
fun x()
var y: Int
}
ProtectedMemberInFinalClass
Kotlin のクラスはデフォルトで final です。したがって、open と protected メンバを含むべきではありません。代わりに private や internal を使うべき
// bad
class ProtectedMemberInFinalClass {
protected var i = 0
}
// good
class ProtectedMemberInFinalClass {
private var i = 0
}
ReturnCount
メソッド内で使用できるreturnの数を制限する
(default: 2)
// bad
fun foo(i: Int): String {
when (i) {
1 -> return "one"
2 -> return "two"
else -> return "other"
}
}
// good
fun foo(i: Int): String {
return when (i) {
1 -> "one"
2 -> "two"
else -> "other"
}
}
SafeCast
このルールはキャストを検査し、代わりに安全なキャストに置き換えることができる
// bad
fun numberMagic(number: Number) {
val i = if (number is Int) number else null
// ...
}
// good
fun numberMagic(number: Number) {
val i = number as? Int
// ...
}
SerialVersionUIDInSerializableClass
Serializableインターフェースを実装しているクラスは、serialVersionUIDも正しく宣言する必要があります
// bad
class IncorrectSerializable : Serializable {
companion object {
val serialVersionUID = 1 // wrong declaration for UID
}
}
// good
class CorrectSerializable : Serializable {
companion object {
const val serialVersionUID = 1L
}
}
ThrowsCount
メソッド内で使用できるthrowの数を制限する
(default: 2)
// bad
fun foo(i: Int) {
when (i) {
1 -> throw IllegalArgumentException()
2 -> throw IllegalArgumentException()
3 -> throw IllegalArgumentException()
}
}
// good
fun foo(i: Int) {
when (i) {
1,2,3 -> throw IllegalArgumentException()
}
}
UnnecessaryAbstractClass
抽象クラスが具象メンバーを持たない場合は、インターフェイスにリファクタリングする必要があります。
抽象的なメンバーを定義していない抽象クラスは、代わりに具象クラスにリファクタリングする必要があります。
// bad
abstract class OnlyAbstractMembersInAbstractClass { // violation: no concrete members
abstract val i: Int
abstract fun f()
}
abstract class OnlyConcreteMembersInAbstractClass { // violation: no abstract members
val i: Int = 0
fun f() { }
}
UnnecessaryApply
apply式は頻繁に使用されますが、見た目の複雑さを軽減するために、通常のメソッドや拡張機能の呼び出しに置き換えるべき。
// bad
config.apply { version = "1.2" } // can be replaced with `config.version = "1.2"`
config?.apply { environment = "test" } // can be replaced with `config?.environment = "test"`
config?.apply { println(version) } // `apply` can be replaced by `let`
// good
config.apply {
version = "1.2"
environment = "test"
}
UnnecessaryInheritance
不要なスーパータイプあります。
AnyやObjectからの継承は不要
// bad
class A : Any()
class B : Object()
// good
class A
class B
UnusedPrivateClass
使用されていないプライベートクラスがあります。
UnusedPrivateMember
使用されていないプライベートプロパティ、関数パラメータがあります。
UselessCallOnNotNull
Kotlin stdlibには、NULLの可能性がある参照を操作するために設計された関数がいくつか用意されています。
// bad
val testList = listOf("string").orEmpty()
val testList2 = listOf("string").orEmpty().map { _ }
val testList3 = listOfNotNull("string")
val testString = ""?.isNullOrBlank()
// good
val testList = listOf("string")
val testList2 = listOf("string").map { }
val testList3 = listOf("string")
val testString = ""?.isBlank()
UtilityClassWithPublicConstructor
具体的な実装を伴わないユーティリティー変数や関数のみを含むクラスは、オブジェクトや非公開のコンストラクタを持つクラスにリファクタリングすることができます。
// bad
class UtilityClassViolation {
// public constructor here
constructor() {
// ...
}
companion object {
val i = 0
}
}
open class UtilityClassViolation private constructor() {
// ...
}
// good
class UtilityClass {
private constructor() {
// ...
}
companion object {
val i = 0
}
}
object UtilityClass {
val i = 0
}
VarCouldBeVal
var宣言は、再割り当てされないため、valにすべき
// bad
fun example() {
var i = 1 // violation: this variable is never re-assigned
val j = i + 1
}
// good
fun example() {
val i = 1
val j = i + 1
}
WildcardImport
ワイルドカードによるインポートは、完全修飾クラス名を用いたインポートに置き換えるべきです。これにより、どのクラスがインポートされているかが明確になり、ネーミングコンフリクトを防ぐことができます。
// bad
import io.gitlab.arturbosch.detekt.*
class DetektElements {
val element1 = DetektElement1()
val element2 = DetektElement2()
}
// good
import io.gitlab.arturbosch.detekt.DetektElement1
import io.gitlab.arturbosch.detekt.DetektElement2
class DetektElements {
val element1 = DetektElement1()
val element2 = DetektElement2()
}