Compiler Options, Linting & Errors

$ scala compile . -Wunused:help
-Wunused  Enable or disable specific `unused` warnings
          Choices:
          - nowarn,
          - all,
          - imports :
          	Warn if an import selector is not referenced.,
          - privates :
          	Warn if a private member is unused,
          - locals :
          	Warn if a local definition is unused,
          - explicits :
          	Warn if an explicit parameter is unused,
          - implicits :
          	Warn if an implicit parameter is unused,
          - params :
          	Enable -Wunused:explicits,implicits,
          - patvars :
          	Warn if a variable bound in a pattern is unused,
          - linted :
          	Enable -Wunused:imports,privates,locals,implicits

//> using scala 3.10.0
package trailhead

@deprecated("use newName", "1.2")
def oldName(): Int = 1

given Conversion[Int, String] = _.toString

@main def dep(): Unit =
  val n = oldName()
  val s: String = n
  println(s)

$ scala compile .
there was 1 feature warning; re-run with -feature for details
there was 1 deprecation warning; re-run with -deprecation for details
2 warnings found

$ scala compile . -deprecation -feature
-- Feature Warning: c/Dep.scala:11:18
11 |  val s: String = n
   |                  ^
   |Use of implicit conversion given instance given_Conversion_Int_String in package trailhead should be enabled
   |by adding the import clause 'import scala.language.implicitConversions'
   |or by setting the compiler option -language:implicitConversions.
   |See the Scala docs for value scala.language.implicitConversions for a discussion
   |why the feature should be explicitly enabled.
-- Deprecation Warning: c/Dep.scala:10:10
10 |  val n = oldName()
   |          ^^^^^^^
   |method oldName in package trailhead is deprecated since 1.2: use newName
2 warnings found

//> using scala 3.10.0
package trailhead

def kind(x: Any): String = x match
  case xs: List[String] => "strings"
  case _ => "other"

@main def unch(): Unit = println(kind(List(1)))

-- [E092] Pattern Match Unchecked Warning: q/Unch.scala:5:7
5 |  case xs: List[String] => "strings"
  |       ^
  |the type test for List[String] cannot be checked at runtime because its type arguments can't be determined from Any
  |
  | longer explanation available when compiling with `-explain`
1 warning found

//> using scala 3.10.0
package trailhead

import java.util.Date
import scala.collection.mutable.ListBuffer

class Counter:
  private var hidden = 0
  private def unusedHelper(): Int = 1
  def next(x: Int, unusedParam: Int): Int =
    val local = 5
    x + 1

@main def lint(): Unit =
  println(Counter().next(1, 2))
  def sideEffect(): Int = 42
  def useIt(): Unit = sideEffect()
  useIt()
  (1, 2) match
    case (a, b) => println(a)

$ scala compile . -Wunused:all
-- [E198] Unused Symbol Warning: a/Lint.scala:4:17
4 |import java.util.Date
  |                 ^^^^
  |                 unused import
-- [E198] Unused Symbol Warning: a/Lint.scala:5:32
5 |import scala.collection.mutable.ListBuffer
  |                                ^^^^^^^^^^
  |                                unused import
-- [E198] Unused Symbol Warning: a/Lint.scala:8:14
8 |  private var hidden = 0
  |              ^^^^^^
  |              unused private member
-- [E198] Unused Symbol Warning: a/Lint.scala:9:14
9 |  private def unusedHelper(): Int = 1
  |              ^^^^^^^^^^^^
  |              unused private member
-- [E198] Unused Symbol Warning: a/Lint.scala:10:19
10 |  def next(x: Int, unusedParam: Int): Int =
   |                   ^^^^^^^^^^^
   |                   unused explicit parameter
-- [E198] Unused Symbol Warning: a/Lint.scala:11:8
11 |    val local = 5
   |        ^^^^^
   |        unused local definition
-- [E198] Unused Symbol Warning: a/Lint.scala:20:13
20 |    case (a, b) => println(a)
   |             ^
   |             unused pattern variable
7 warnings found

//> using scala 3.10.0
package trailhead

import scala.collection.mutable.ListBuffer

def sideEffect(): Int = 42

def useIt(): Unit = sideEffect()

@main def discard(): Unit =
  val buf = ListBuffer(1, 2)
  buf.remove(0)
  buf += 3
  useIt()
  println(buf)

$ scala compile . -Wvalue-discard
-- [E175] Potential Issue Warning: b/Discard.scala:8:30
8 |def useIt(): Unit = sideEffect()
  |                    ^^^^^^^^^^^^
  |   discarded non-Unit value of type Int. Add `: Unit` to discard silently.
1 warning found

$ scala compile . -Wnonunit-statement
-- [E176] Potential Issue Warning: b/Discard.scala:12:12
12 |  buf.remove(0)
   |  ^^^^^^^^^^^^^
   |  unused value of type Int
1 warning found

$ scala compile . -Wshadow:all
-- [E227] Naming Warning: m/Misc.scala:7:14
7 |class Derived(len: Int) extends Base(len):
  |              ^
  |    value len in class Derived shadows field len inherited from class Base
  |
  | longer explanation available when compiling with `-explain`
1 warning found

$ scala compile . -Wtostring-interpolated
-- [E209] Interpolation Warning: m/Misc.scala:15:43
15 |def describe(t: Trail): String = s"trail: $t"
   |                                           ^
   |                                           interpolation uses toString
1 warning found

$ scala compile . -Wrecurse-with-default
-- [E221] Type Warning: m/Misc.scala:13:33
13 |  if n <= 0 then 0 else countDown(n - step)
   |                        ^^^^^^^^^^^^^^^^^^^
   |              Recursive call used a default argument for parameter step.
   |
   | longer explanation available when compiling with `-explain`
1 warning found

$ scala compile . -Winfer-union
-- [E225] Type Warning: n/U.scala:5:14
5 |  val mixed = List(1, "two")
  |              ^^^^
  |              A type argument was inferred to be union type Int | String
  |              This may indicate a programming error.
1 warning found

$ scala compile . -deprecation -feature -Werror
-- Feature Warning: c/Dep.scala:11:18
...
-- Deprecation Warning: c/Dep.scala:10:10
...
No warnings can be incurred under -Werror
2 warnings found
1 error found
Compilation failed

//> using scala 3.10.0
package trailhead

enum Surface:
  case Dirt, Gravel, Paved

def grade(s: Surface): Int = s match
  case Surface.Dirt   => 1
  case Surface.Gravel => 2

@main def err(): Unit =
  val n: Int = "ridge"
  println(grade(Surface.Paved) + n)

$ scala compile .
-- [E007] Type Mismatch Error: f/Err.scala:12:15
12 |  val n: Int = "ridge"
   |               ^^^^^^^
   |               Found:    ("ridge" : String)
   |               Required: Int
   |
   | longer explanation available when compiling with `-explain`
1 error found
Compilation failed

$ scala compile . -explain
-- [E007] Type Mismatch Error: f/Err.scala:12:15
12 |  val n: Int = "ridge"
   |               ^^^^^^^
   |               Found:    ("ridge" : String)
   |               Required: Int
   |----------------------------------------------------------------------------
   | Explanation (enabled by `-explain`)
   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   |
   | Tree:
   |
   | "ridge"
   |
   | I tried to show that
   |   ("ridge" : String)
   | conforms to
   |   Int
   | but none of the attempts shown below succeeded:
   |
   |   ==> ("ridge" : String)  <:  Int
   |     ==> String  <:  Int  = false
   |
   | The tests were made under the empty constraint
    ----------------------------------------------------------------------------
1 error found
Compilation failed

$ scala compile . -explain
-- [E029] Pattern Match Exhaustivity Warning: g/Exh.scala:7:29
7 |def grade(s: Surface): Int = s match
  |                             ^
  |                             match may not be exhaustive.
  |
  |                             It would fail on pattern case: Paved
  |-----------------------------------------------------------------------------
  | Explanation (enabled by `-explain`)
  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  | There are several ways to make the match exhaustive:
  |  - Add missing cases as shown in the warning
  |  - If an extractor always return Some(...), write Some[X] for its return type
  |  - Add a case _ => ... at the end to match all remaining cases
   -----------------------------------------------------------------------------
1 warning found

//> using scala 3.10.0
package trailhead

import scala.collection.mutable._
import scala.language.implicitConversions

object Legacy:
  implicit def intToStr(i: Int): String = i.toString
  def total(xs: Int*): Int = xs.sum
  def greet(implicit n: Int): String = s"hi $n"

@main def migrate(): Unit =
  import Legacy.intToStr
  val buf = ListBuffer(1, 2, 3)
  implicit val n: Int = 7
  println(Legacy.total(buf.toSeq: _*))
  val s: String = 5
  println(Legacy.greet + s)

$ scala compile . -source:future
-- Error: h/w/Legacy.scala:4:32
4 |import scala.collection.mutable._
  |                                ^
  |`_` is no longer supported for a wildcard import; use `*` instead
  |This construct can be rewritten automatically under -rewrite -source future-migration.
-- Error: h/w/Legacy.scala:10:12
10 |  def greet(implicit n: Int): String = s"hi $n"
   |            ^
   |`implicit` parameters are no longer supported, use a `using` clause instead
   |This construct can be rewritten automatically under -rewrite -source future-migration.
-- Error: h/w/Legacy.scala:16:34
16 |  println(Legacy.total(buf.toSeq: _*))
   |                                  ^
   |The syntax `x: _*` is no longer supported for vararg splices; use `x*` instead
   |This construct can be rewritten automatically under -rewrite -source 3.4-migration.
-- Error: h/w/Legacy.scala:8:15
8 |  implicit def intToStr(i: Int): String = i.toString
  |               ^
  |`implicit` conversion methods are no longer supported. They can usually be
  |replaced by given instances of class `Conversion`. Example:
  |
  |    given Conversion[Int, String] = i => ...
  |
-- Error: h/w/Legacy.scala:15:15
15 |  implicit val n: Int = 7
   |               ^
   |`implicit` vals are no longer supported, use a `given` clause instead. Example:
   |
   |   given n: Int = ...
   |
   |Note: given clauses are evaluated lazily unless the right hand side is
   |a simple reference.  If eager evaluation of the value's right hand side
   |is important, you can define a regular val and a given instance like this:
   |
   |    val n = ...
   |    given Int = n
   |
5 errors found
Compilation failed

$ scala compile . -source:future-migration -rewrite
[patched file h/w/Legacy.scala]

$ scala compile .
-- [E003] Syntax Error: s/w/With.scala:9:18
9 |type Both = Named with Sized
  |                  ^^^^
  |with as a type operator has been deprecated; use & instead
  |This construct can be rewritten automatically under -rewrite -source 3.4-migration.
  |
  | longer explanation available when compiling with `-explain`
-- Warning: s/w/With.scala:11:19
11 |def count(xs: List[_]): Int = xs.size
   |                   ^
   |`_` is deprecated for wildcard arguments of types: use `?` instead
   |This construct can be rewritten automatically under -rewrite -source 3.4-migration.
-- Warning: s/w/With.scala:14:9
14 |  private[this] var n = 0
   |         ^^^^^^
   |Ignoring [this] qualifier.
   |The syntax `private[this]` will be deprecated in the future; just write `private` instead.
   |See: https://docs.scala-lang.org/scala3/reference/dropped-features/this-qualifier.html
   |This construct can be rewritten automatically under -rewrite -source 3.4-migration.
-- Warning: s/w/With.scala:23:20
23 |  println(total(xs: _*) + count(xs) + Counter().inc())
   |                    ^
   |The syntax `x: _*` is no longer supported for vararg splices; use `x*` instead
   |This construct can be rewritten automatically under -rewrite -source 3.4-migration.
3 warnings found
1 error found
Compilation failed

$ scala compile . -source:3.4-migration -rewrite
...
[patched file s/w/With.scala]
4 warnings found

9c9
< type Both = Named with Sized
---
> type Both = Named & Sized
11c11
< def count(xs: List[_]): Int = xs.size
---
> def count(xs: List[?]): Int = xs.size
14c14
<   private[this] var n = 0
---
>   private var n = 0
23c23
<   println(total(xs: _*) + count(xs) + Counter().inc())
---
>   println(total(xs*) + count(xs) + Counter().inc())

//> using scala 3.10.0
package trailhead

@main def prev(): Unit =
  val xs = List((1, 1), (2, 3), (3, 5))
  println(xs.collect(case (a, b) if b > 4 => a))

$ scala compile .
-- [E018] Syntax Error: i/Prev.scala:6:21
6 |  println(xs.collect(case (a, b) if b > 4 => a))
  |                     ^^^^
  |                     expression expected but case found
  |
  | longer explanation available when compiling with `-explain`
1 error found
Compilation failed

$ scala run . -preview
List(3)

//> using scala 3.10.0
package trailhead

import scala.annotation.experimental

@experimental def shiny(): Int = 1

@main def exp(): Unit = println(shiny())

$ scala compile .
-- Error: j/Exp.scala:8:32
8 |@main def exp(): Unit = println(shiny())
  |                                ^^^^^
  |         method shiny is marked @experimental
  |
  |         Experimental definition may only be used under experimental mode:
  |           1. in a definition marked as @experimental, or
  |           2. an experimental feature is imported at the package level, or
  |           3. compiling with the -experimental compiler flag.
1 error found

//> using scala 3.10.0
package trailhead

import scala.compiletime.ops.int.*

type Down[N <: Int] <: Int = N match
  case 0 => 0
  case _ => Down[N - 1]

@main def fuel(): Unit =
  val z: Down[400] = 0
  println(z)

$ scala compile .
-- Error: k/Fuel.scala:11:9
11 |  val z: Down[400] = 0
   |         ^^^^^^^^^
   |Recursion limit exceeded.
   |Maybe there is an illegal cyclic reference?
   |If that's not the case, you could try to increase the fuel and stack size: https://docs.scala-lang.org/overviews/compiler-options/compiling-deeply-nested-code.html
   |For the unprocessed stack overflow trace, compile with -Xno-enrich-error-messages.
   |A recurring operation is (inner to outer):
   |
   |  match cases for (220 : Int)
   |  match cases for (221 : Int)
   |  match cases for (222 : Int)
   |  ...
   |
   |  match cases for (398 : Int)
   |  match cases for (399 : Int)
   |  match cases for (400 : Int)
Compilation failed

$ scala run . -Xmax-fuel:100000
0

//> using scala 3.10.0
package trailhead

class Gauge:
  @inline def reading(x: Int): Int = x * 2

object Hot:
  @inline def square(x: Int): Int = x * x

def total(g: Gauge): Int =
  var sum = 0
  for i <- 1 to 10 do sum += Hot.square(i) + g.reading(i)
  sum

@main def opt(): Unit = println(total(Gauge()))

$ scala compile . -opt '-opt-inline:<sources>' -Wopt:at-inline-failed
-- Warning: l/Opt.scala:12:54
12 |  for i <- 1 to 10 do sum += Hot.square(i) + g.reading(i)
   |                                             ^^^^^^^^^^^^
   |trailhead/Gauge::reading(I)I is annotated @inline but could not be inlined:
   |The method is not final and may be overridden.
1 warning found

$ scala run . -opt '-opt-inline:<sources>'
495