analyzer rule that checks if Scala constants are properly declared

Author: Roman Janusz

commons-analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala

@@ -56,7 +56,8 @@ final class AnalyzerPlugin(val global: Global) extends Plugin { plugin =>
     new Any2StringAdd(global),
     new ThrowableObjects(global),
     new DiscardedMonixTask(global),
-    new BadSingletonComponent(global)
+    new BadSingletonComponent(global),
+    new ConstantDeclarations(global),
   )
 
   private lazy val rulesByName = rules.map(r => (r.name, r)).toMap

commons-analyzer/src/main/scala/com/avsystem/commons/analyzer/ConstantDeclarations.scala

@@ -0,0 +1,34 @@
+package com.avsystem.commons
+package analyzer
+
+import scala.tools.nsc.Global
+
+class ConstantDeclarations(g: Global) extends AnalyzerRule(g, "constantDeclarations") {
+
+  import global._
+
+  def analyze(unit: CompilationUnit): Unit = unit.body.foreach {
+    case t@ValDef(mods, name, tpt, rhs)
+      if t.symbol.hasGetter && t.symbol.owner.isEffectivelyFinal =>
+
+      val getter = t.symbol.getterIn(t.symbol.owner)
+      if (getter.isPublic && getter.isStable && getter.overrides.isEmpty) {
+        val constantValue = rhs.tpe match {
+          case ConstantType(_) => true
+          case _ => false
+        }
+
+        val firstChar = name.toString.charAt(0)
+        if (constantValue && (firstChar.isLower || !getter.isFinal)) {
+          report(t.pos, "a constant should be declared as a `final val` with an UpperCamelCase name")
+        }
+        if (firstChar.isUpper && !getter.isFinal) {
+          report(t.pos, "a constant with UpperCamelCase name should be declared as a `final val`")
+        }
+        if (getter.isFinal && constantValue && !(tpt.tpe =:= rhs.tpe)) {
+          report(t.pos, "a constant with a literal value should not have an explicit type annotation")
+        }
+      }
+    case _ =>
+  }
+}

commons-analyzer/src/test/scala/com/avsystem/commons/analyzer/CheckMacroPrivateTest.scala

@@ -50,7 +50,7 @@ class CheckMacroPrivateTest extends AnyFunSuite with AnalyzerTest {
         |object test {
         |  @macroPrivate def macroPrivateMethod = { println("whatever"); 5 }
         |  @macroPrivate object macroPrivateObject {
-        |    val x = 42
+        |    final val X = 42
         |  }
         |}
       """.stripMargin

commons-analyzer/src/test/scala/com/avsystem/commons/analyzer/ConstantDeclarationsTest.scala

@@ -0,0 +1,83 @@
+package com.avsystem.commons
+package analyzer
+
+import org.scalatest.funsuite.AnyFunSuite
+
+class ConstantDeclarationsTest extends AnyFunSuite with AnalyzerTest {
+  test("literal-valued constants should be non-lazy final vals with UpperCamelCase and no type annotation") {
+    assertErrors(4,
+      """
+        |object Whatever {
+        |  // bad
+        |  val a = 10
+        |  val B = 10
+        |  final val c = 10
+        |  final val D: Int = 10
+        |
+        |  // good
+        |  final val E = 10
+        |}
+      """.stripMargin)
+  }
+
+  test("effectively final, non-literal UpperCamelCase vals should be final") {
+    assertErrors(1,
+      """
+        |object Whatever {
+        |  // bad
+        |  val A = "foo".trim
+        |
+        |  // good
+        |  final val B = "foo".trim
+        |  val c = "foo".trim
+        |}
+      """.stripMargin)
+  }
+
+  test("no constant checking in traits or non-final classes") {
+    assertNoErrors(
+      """
+        |trait Whatever {
+        |  val a = 10
+        |  val B = 10
+        |  final val c = 10
+        |  final val D: Int = 10
+        |  val A = "foo".trim
+        |}
+        |
+        |class Stuff {
+        |  val a = 10
+        |  val B = 10
+        |  final val c = 10
+        |  final val D: Int = 10
+        |  val A = "foo".trim
+        |}
+      """.stripMargin)
+  }
+
+  test("no constant checking for overrides") {
+    assertNoErrors(
+      """
+        |trait Whatever {
+        |  def a: Int
+        |}
+        |
+        |object Stuff extends Whatever {
+        |  val a: Int = 42
+        |}
+      """.stripMargin)
+  }
+
+  test("no constant checking for privates") {
+    assertNoErrors(
+      """
+        |object Whatever {
+        |  private val a = 10
+        |  private val B = 10
+        |  private final val c = 10
+        |  private final val D: Int = 10
+        |  private val A = "foo".trim
+        |}
+      """.stripMargin)
+  }
+}