Scalafix

https://scalacenter.github.io/scalafix/
Admin
Scalafix is a refactoring and linting tool for Scala that automates code health tasks, migrations,...
Tokens:39,505
Snippets:476
Trust Score:8.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### Clone and run example project

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

Clone the official example repository and execute a rule to verify setup.

```bash
git clone https://github.com/scalacenter/sbt-scalafix-example
cd sbt-scalafix-example
sbt "scalafix RemoveUnused"
git diff // should produce a diff
```

--------------------------------

### Define dealiasing example

Source: https://scalacenter.github.io/scalafix/docs/developers/semantic-type.html

Example program for dealiasing limitations.

```scala
// Main.scala
package example
object Main {
  val a = "message"
  val b: String = "message"
  val c: List[String] = List()
}
```

--------------------------------

### ExpandRelative Configuration Example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Configuration snippet for enabling relative import expansion.

```hocon
OrganizeImports {
  expandRelative = true
  groups = ["re:javax?\.", "scala.", "*"]
}
```

--------------------------------

### OrganizeImports Before and After Example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Demonstrates the basic reordering and grouping of imports performed by the rule.

```scala
Before:
import scala.collection.JavaConverters._
import java.time.Clock
import sun.misc.BASE64Encoder
import javax.annotation.Generated
import scala.concurrent.ExecutionContext
```

```scala
After:
import java.time.Clock
import javax.annotation.Generated
import scala.collection.JavaConverters._
import scala.concurrent.ExecutionContext

import sun.misc.BASE64Encoder
```

--------------------------------

### Install Bash tab completions

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

Commands to generate and install bash completion scripts for Scalafix on macOS and Linux.

```bash
# macOS, requires "brew install bash-completion"
scalafix --bash > /usr/local/etc/bash_completion.d/scalafix
# Linux
scalafix --bash > /etc/bash_completion.d/scalafix
```

--------------------------------

### Install sbt-scalafix plugin

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

Add the plugin to your project/plugins.sbt file.

```sbt
// project/plugins.sbt
addSbtPlugin("ch.epfl.scala" % "sbt-scalafix" % "0.14.7")
```

```sbt
// project/plugins.sbt
addSbtPlugin("ch.epfl.scala" % "sbt-scalafix" % "0.10.4") // final Scala 2.11 version
```

```sbt
// project/plugins.sbt
addSbtPlugin("ch.epfl.scala" % "sbt-scalafix" % "0.9.29") // final sbt 0.13.x version
dependencyOverrides += "ch.epfl.scala" % "scalafix-interfaces" % "0.14.7"
```

--------------------------------

### Clone and Initialize Repository

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Commands to clone the tutorial repository and start the sbt shell.

```bash
git clone https://github.com/scalacenter/scalafix-named-literal-arguments.git
cd scalafix-named-literal-arguments/scalafix
sbt
...
[info] sbt server started at local://$HOME/.sbt/1.0/server/93fc24de3bb97dec3e5b/sock
sbt:scalafix>
```

--------------------------------

### Auto blankLines example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Configuration and transformation example for Auto blankLines mode.

```hocon
OrganizeImports {
  blankLines = Auto
  groups = [
    "re:javax?\."
    "scala."
    "*"
  ]
}
```

```scala
import scala.collection.JavaConverters._
import java.time.Clock
import sun.misc.BASE64Encoder
import javax.annotation.Generated
import scala.concurrent.ExecutionContext
```

```scala
import java.time.Clock
import javax.annotation.Generated

import scala.collection.JavaConverters._
import scala.concurrent.ExecutionContext

import sun.misc.BASE64Encoder
```

--------------------------------

### Define input for atomic patch examples

Source: https://scalacenter.github.io/scalafix/docs/developers/patch.html

Example source file containing a scalafix suppression comment.

```scala
// Main.scala
object Main extends App {
  val x = 42
  // scalafix:off
  println(x)
}
```

--------------------------------

### Generate Documentation

Source: https://scalacenter.github.io/scalafix/docs/developers/contributing.html

Commands to compile documentation and start the Docusaurus development server.

```bash
$ sbt
> ci-docs
```

```bash
cd website
yarn install
yarn start
```

--------------------------------

### Example of Procedure Syntax

Source: https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html

A basic demonstration of the deprecated procedure syntax style.

```scala
def debug { println("debug") }
```

--------------------------------

### Relative Imports Example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Example of imports that are order-sensitive and should not be sorted alphabetically.

```scala
import scala.util
import util.control
import control.NonFatal
```

--------------------------------

### Install and launch Scalafix via Coursier

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

Use Coursier to install or launch specific versions of the Scalafix CLI.

```bash
cs install scalafix
scalafix --version # Should say 0.14.7

cs install scalafix:0.14.0
scalafix --version # Should say 0.14.0

cs launch scalafix:0.13.0 -- --version # Should say 0.13.0
```

--------------------------------

### Example input source file

Source: https://scalacenter.github.io/scalafix/docs/developers/symbol-matcher.html

A sample source file used to demonstrate symbol matching behavior.

```scala
// Main.scala
package com
class Main() {}            // com/Main# class
object Main extends App {  // com/Main. object
  println()                // println()   overload with no parameter
  println("Hello Predef!") // println(+1) overload with string parameter
}
```

--------------------------------

### Configure ExplicitResultTypes example

Source: https://scalacenter.github.io/scalafix/docs/rules/ExplicitResultTypes.html

An example configuration snippet for the ExplicitResultTypes rule.

```hocon
ExplicitResultTypes.memberKind = [Def, Val, Var]
ExplicitResultTypes.memberVisibility = [Public, Protected]
ExplicitResultTypes.skipSimpleDefinitions = ['Lit', 'Term.New']
```

--------------------------------

### Install Zsh tab completions

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

Commands to generate and register zsh completion functions for Scalafix.

```bash
scalafix --zsh > /usr/local/share/zsh/site-functions/_scalafix
unfunction _scalafix
autoload -U _scalafix
```

--------------------------------

### Define subtyping example

Source: https://scalacenter.github.io/scalafix/docs/developers/semantic-type.html

Example program for subtyping limitations.

```scala
sealed abstract class A[+T]
case class B(n: Int) extends A[Int]
```

--------------------------------

### DisableSyntax Custom Configuration Example

Source: https://scalacenter.github.io/scalafix/docs/rules/DisableSyntax.html

Example configuration enabling universal equality checks and a custom regex rule.

```hocon
DisableSyntax.noUniversalEquality = true
DisableSyntax.noUniversalEqualityMessage = "use === instead of =="
DisableSyntax.regex = [
  {
    id = "offensive"
    pattern = "[Pp]imp"
    message = "Please consider a less offensive word such as 'extension' or 'enrichment'"
  }
]
```

--------------------------------

### Define example program for symbol lookup

Source: https://scalacenter.github.io/scalafix/docs/developers/semantic-type.html

A sample object containing values to inspect.

```scala
// Main.scala
package example
object Main {
  val a = 42
  val b = List(42)
}
```

--------------------------------

### Define and instantiate a case class

Source: https://scalacenter.github.io/scalafix/docs/developers/api.html

Example of a simple case class definition and instantiation.

```scala
case class User(name: String)

User("\"John")
// res0: User = User(name = "\"John")
```

--------------------------------

### Manual blankLines configuration

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Example configuration for Manual blankLines mode using markers.

```hocon
OrganizeImports {
  blankLines = Manual
  groups = [
    "re:javax?\."
    "scala."
    "---"
    "*"
  ]
}
```

--------------------------------

### ExpandRelative Import Expansion Example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Demonstrates how relative imports are expanded to fully-qualified paths.

```scala
import scala.util
import util.control
import control.NonFatal
```

```scala
import scala.util
import scala.util.control
import scala.util.control.NonFatal
```

--------------------------------

### Look up implicit arguments

Source: https://scalacenter.github.io/scalafix/docs/developers/semantic-tree.html

Example program demonstrating implicit argument resolution.

```scala
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
def run(implicit message: String) = println(message)
implicit val message = "hello world"

Future.apply[Int](3) // implicit argument: global
Main.run             // implicit argument: message
```

--------------------------------

### Define Input Source for Patch Examples

Source: https://scalacenter.github.io/scalafix/docs/developers/patch.html

The input source file used for the following patch examples.

```scala
// Main.scala
import scala.concurrent.{Future, Await}
import scala.util._, hashing.{MurmurHash3 => Hash}

object Program extends App {
  println("Hello world!")
}
```

--------------------------------

### Complete Configurable Rule Implementation

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Full example of a configurable Scalafix rule including diagnostic reporting and configuration handling.

```scala
// NoLiteralArguments.scala
package fix

import metaconfig.Configured
import scala.meta._
import scalafix.v1._

case class LiteralArgument(literal: Lit) extends Diagnostic {
  override def position: Position = literal.pos
  override def message: String =
    s"Use named arguments for literals such as 'parameterName = $literal'"
}

case class NoLiteralArgumentsConfig(
    disabledLiterals: List[String] = List("Boolean")
) {
  def isDisabled(lit: Lit): Boolean = {
    val kind = lit.productPrefix.stripPrefix("Lit.")
    disabledLiterals.contains(kind)
  }
}

object NoLiteralArgumentsConfig {
  val default = NoLiteralArgumentsConfig()
  implicit val surface =
    metaconfig.generic.deriveSurface[NoLiteralArgumentsConfig]
  implicit val decoder =
    metaconfig.generic.deriveDecoder(default)
}

class NoLiteralArguments(config: NoLiteralArgumentsConfig)
    extends SyntacticRule("NoLiteralArguments") {
  def this() = this(NoLiteralArgumentsConfig.default)
  override def withConfiguration(config: Configuration): Configured[Rule] = {
    config.conf
      .getOrElse("NoLiteralArguments")(this.config)
      .map(newConfig => new NoLiteralArguments(newConfig))
  }
  override def fix(implicit doc: SyntacticDocument): Patch = {
    doc.tree
      .collect {
        case Term.Apply(_, args) =>
          args.collect {
            case t: Lit if config.isDisabled(t) =>
              Patch.lint(LiteralArgument(t))
          }
      }
      .flatten
      .asPatch
  }
}
```

--------------------------------

### Define term lookup example

Source: https://scalacenter.github.io/scalafix/docs/developers/semantic-type.html

Example program for term inspection limitations.

```scala
object Main {
  val list = List(1).map(_ + 1)
}
```

--------------------------------

### CoalesceToWildcardImportThreshold Configuration Example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Configuration snippet for setting the wildcard threshold.

```hocon
OrganizeImports {
  groupedImports = Keep
  coalesceToWildcardImportThreshold = 3
}
```

--------------------------------

### Ascii sorting example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Demonstrates the transformation of import statements when using the Ascii sorting order.

```scala
import scala.concurrent._
import scala.concurrent.{Future, Promise}
import scala.concurrent.ExecutionContext.Implicits._
import scala.concurrent.duration
```

```scala
import scala.concurrent.ExecutionContext.Implicits._
import scala.concurrent._
import scala.concurrent.duration
import scala.concurrent.{Promise, Future}
```

--------------------------------

### Example diff output

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

Typical diff output after applying a rule.

```diff
-  def myProcedure {
+  def myProcedure: Unit = {
```

```diff
- import scala.util.{ Success, Failure }
+ import scala.util.Success
```

--------------------------------

### View Scalafix diff output

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

Example of the expected diff output after applying a rule.

```diff
+// v1 SyntacticRule!
```

--------------------------------

### SymbolsFirst sorting example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Demonstrates the transformation of import statements when using the SymbolsFirst sorting order.

```scala
import scala.concurrent.ExecutionContext.Implicits._
import scala.concurrent._
import scala.concurrent.duration
import scala.concurrent.{Promise, Future}
```

```scala
import scala.concurrent._
import scala.concurrent.{Future, Promise}
import scala.concurrent.ExecutionContext.Implicits._
import scala.concurrent.duration
```

--------------------------------

### AggressiveMerge Correctness Example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Demonstrates how naive merging can cause compilation errors due to import precedence, and the correct way to handle it.

```scala
import scala.collection.immutable._
import scala.collection.mutable.Map
import scala.collection.mutable._

object Example {
  val m: Map[Int, Int] = ???
}

```

```scala
import scala.collection.immutable._
import scala.collection.mutable._

```

```scala
import scala.collection.immutable._
import scala.collection.mutable.{Map, _}

```

--------------------------------

### Illustrate implicit import conflict

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Example demonstrating how reordering imports can cause implicit resolution failures due to wildcard import precedence.

```scala
package a

import c._
import b.i

object b { implicit def i: Int = 1 }
object c { implicit def i: Int = 2 }

object Imports {
  def f()(implicit i: Int) = println(1)
  def main() = f()
}
```

```scala
import b.i
import c._
```

```text
error: could not find implicit value for parameter i: Int
  def main() = f()
                ^
```

--------------------------------

### Install custom Scalafix rules

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

Add external rules to the build by defining them in scalafixDependencies.

```sbt
// at the top of build.sbt
ThisBuild / scalafixDependencies +=
  "ch.epfl.scala" %% "example-scalafix-rule" % "4.0.0"
```

--------------------------------

### Define Test Cases

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Example test cases for verifying argument naming logic.

```scala
def complete(isSuccess: Boolean): Unit = ()
def finish(isError: Boolean): Unit = ()
complete(true)
finish(true)
```

--------------------------------

### AggressiveMerge Optimization Example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Shows how AggressiveMerge simplifies redundant imports compared to conservative merging.

```scala
import scala.collection.mutable.Map
import scala.collection.mutable._

```

```scala
import scala.collection.mutable.{Map, _}

```

```scala
import scala.collection.mutable._

```

--------------------------------

### Define case class for field lookup

Source: https://scalacenter.github.io/scalafix/docs/developers/symbol-information.html

Example case class structure for demonstrating field lookup.

```scala
// User.scala
package example
case class User(name: String, age: Int) {
  def this(secondaryName: String) = this(secondaryName, 42)
  val upperCaseName = name.toUpperCase
}
```

--------------------------------

### Install external rule permanently

Source: https://scalacenter.github.io/scalafix/docs/rules/external-rules.html

Add a rule dependency to build.sbt to enable it for the entire build, then run it via the sbt shell.

```sbt
// build.sbt
ThisBuild / scalafixDependencies +=
  "GROUP" %% "ARTIFACT" % "VERSION"
// sbt shell
> scalafix RULE
```

--------------------------------

### ExpandRelative Before and After Example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Shows the full effect of expanding relative imports on a larger import block.

```scala
Before:
import scala.util
import util.control
import control.NonFatal
import scala.collection.JavaConverters._
import java.time.Clock
import sun.misc.BASE64Encoder
import javax.annotation.Generated
import scala.concurrent.ExecutionContext
```

```scala
After:
import java.time.Clock
import javax.annotation.Generated

import scala.collection.JavaConverters._
import scala.concurrent.ExecutionContext
import scala.util
import scala.util.control
import scala.util.control.NonFatal

import sun.misc.BASE64Encoder
```

--------------------------------

### Initialize Scalafix project

Source: https://scalacenter.github.io/scalafix/docs/developers/setup.html

Use the g8 template to generate a new Scalafix rule project structure.

```bash
cd repo-name # The project you want to implement rules for.

sbt new scalacenter/scalafix.g8 --repo="Repository Name"
cd scalafix
sbt tests / test
```

--------------------------------

### Scalafix CLI help output

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

View the available options and usage documentation for the Scalafix CLI.

```text
Scalafix 0.14.7+27-f57ebd50-SNAPSHOT
Usage: scalafix [options] [<path> ...]

Scalafix is a refactoring and linting tool. Scalafix
supports both syntactic and semantic linter and rewrite
rules. Syntactic rules can run on source code without
compilation. Semantic rules can run on source code that has
been compiled with the SemanticDB compiler plugin. 

Common options:

  --rules | -r [String ...] (default: [])
    Scalafix rules to run, for example ExplicitResultTypes. The
    syntax for rules is documented in
    https://scalacenter.github.io/scalafix/docs/users/configuration#rules

  --files | -f [<path> ...] (default: [])
    Files or directories (recursively visited) to fix.

  --config <path> (default: null)
    File path to a .scalafix.conf configuration file. Defaults
    to .scalafix.conf in the current working directory, if
    any.

  --check
    Check that all files have been fixed with scalafix, exiting
    with non-zero code on violations. Won't write to files.

  --stdout
    Print fixed output to stdout instead of writing in-place.

  --diff
    If set, only apply scalafix to added and edited files in git
    diff against the master branch.

  --diff-base String (default: null)
    If set, only apply scalafix to added and edited files in git
    diff against a provided branch, commit or tag.

  --scala-version ScalaVersion (default: "2.13.18")
    The major or binary Scala version that the provided files
    are targeting, or the full version that was used to
    compile them when a classpath is provided.

  --syntactic
    Run only syntactic rules, ignore semantic rules even if they
    are explicitly configured in .scalafix.conf or via
    --rules

  --triggered
    Overlay the default rules & rule settings in .scalafix.conf
    with the `triggered` section

  --verbose
    Print out additional diagnostics while running scalafix.

  --help | -h
    Print out this help message and exit

  --version | -v
    Print out version number and exit

Semantic options:

  --classpath Classpath (default: "<classpath>")
    Full classpath of the files to fix, required for semantic
    rules. The source files that should be fixed must be
    compiled with semanticdb-scalac. Dependencies are
    required by rules like ExplicitResultTypes, but the
    dependencies do not need to be compiled with
    semanticdb-scalac.

  --sourceroot <path> (default: null)
    Absolute path passed to semanticdb with
    -P:semanticdb:sourceroot:<path>. Relative filenames
    persisted in the Semantic DB are absolutized by the
    sourceroot. Defaults to current working directory if not
    provided.

  --semanticdb-targetroots [<path> ...] (default: [])
    Absolute paths passed to semanticdb with
    -P:semanticdb:targetroot:<path>. Used to locate
    semanticdb files. By default, Scalafix will try to
    locate semanticdb files in the classpath

  --auto-classpath
    If set, automatically infer the --classpath flag by scanning
    for directories with META-INF/semanticdb
```

--------------------------------

### Complex Import Aliasing Example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Example of multiple aliased imports that are not supported by the Merge strategy.

```scala
import p.{A => A1}
import p.{A => A2}
import p.{A => A3}

import p.{B => B1}
import p.{B => B2}

import p.{C => C1}
import p.{C => C2}
import p.{C => C3}
import p.{C => C4}

```

```scala
import p.{A => A1, B => B1, C => C1}
import p.{A => A2, B => B2, C => C2}
import p.{A => A3, C3 => C3}
import p.{C => C4}

```

--------------------------------

### Select configuration via CLI

Source: https://scalacenter.github.io/scalafix/docs/users/cross-building.html

Pass the appropriate configuration file to the Scalafix CLI using the --config flag.

```bash
scalafix --config .scalafix-scala2.conf
scalafix --config .scalafix-scala3.conf
```

--------------------------------

### Configure build.sbt for SemanticDB

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

Settings to enable SemanticDB and required compiler options.

```sbt
 /*
  * build.sbt
  * SemanticDB is enabled for all sub-projects via ThisBuild scope.
  * https://www.scala-sbt.org/1.x/docs/sbt-1.3-Release-Notes.html#SemanticDB+support
  */
 inThisBuild(
   List(
     scalaVersion := "2.12.21", // 2.13.18, 3.3.8 or 3.8.4
+    semanticdbEnabled := true, // enable SemanticDB
+    semanticdbVersion := scalafixSemanticdb.revision // only required for Scala 2.x
   )
 )

 lazy val myproject = project.settings(
+  scalacOptions += {
+    if (scalaVersion.value.startsWith("2.12"))
+      "-Ywarn-unused-import"
+    else
+      "-Wunused:imports"
+  }
 )
```

```sbt
 /*
  * build.sbt
  * SemanticDB is enabled only for a sub-project.
  * https://www.scala-sbt.org/1.x/docs/sbt-1.3-Release-Notes.html#SemanticDB+support
  */
 lazy val myproject = project.settings(
   scalaVersion := "2.12.21", // 2.13.18, 3.3.8 or 3.8.4
+  semanticdbEnabled := true, // enable SemanticDB
+  semanticdbVersion := scalafixSemanticdb.revision, // only required for Scala 2.x
+  scalacOptions += {
+    if (scalaVersion.value.startsWith("2.12"))
+      "-Ywarn-unused-import"
+    else
+      "-Wunused:imports"
+  }
 )
```

--------------------------------

### Define non-TypeRef example

Source: https://scalacenter.github.io/scalafix/docs/developers/semantic-type.html

Program demonstrating types that are not TypeRef instances.

```scala
// Main.scala
package example
class Main
object Main {
  val a: Main with Serializable = ???
  val b: Main.type = this
}
```

--------------------------------

### CoalesceToWildcardImportThreshold Before and After Example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Shows the transformation of grouped imports into wildcards based on the threshold.

```scala
Before:
import scala.collection.immutable.{Seq, Map, Vector, Set}
import scala.collection.immutable.{Seq, Map, Vector}
import scala.collection.immutable.{Seq, Map, Vector => Vec, Set, Stream}
import scala.collection.immutable.{Seq, Map, Vector => _, Set, Stream}
```

```scala
After:
import scala.collection.immutable._
import scala.collection.immutable.{Map, Seq, Vector}
import scala.collection.immutable.{Vector => Vec, _}
import scala.collection.immutable.{Vector => _, _}
```

--------------------------------

### Define directory structure for single-project build

Source: https://scalacenter.github.io/scalafix/docs/developers/local-rules.html

Place custom rules in the src/scalafix/scala directory to enable local development.

```text
 repository
 ├── build.sbt
 ├── project
 │   └── plugins.sbt
 └── src
     ├── main
     │   └── ...
     ├── test
     │   └── ...
+    └── scalafix
+       ├── resources/META-INF/services
+       │   └── scalafix.v1.Rule // not mandatory, but allows syntax
+       |                        // `MyRule1` over `class:fix.MyRule1`
+       └── scala/fix
+           ├── MyRule1.scala
+           ├── MyRule2.scala
+           └── ...
```

--------------------------------

### Defining Method Overrides

Source: https://scalacenter.github.io/scalafix/docs/developers/symbol-information.html

Example structure for testing method override lookups.

```scala
trait A {
  def add(a: Int, b: Int): Int
}
class B extends A {
  override def add(a: Int, b: Int): Int = a + b
}
```

--------------------------------

### Run Scalafix Tests and Rules via SBT

Source: https://scalacenter.github.io/scalafix/docs/developers/local-rules.html

Commands to execute unit tests for rules and apply rules to specific services.

```bash
$ sbt
> scalafixTests / test
> service1 / scalafix MyRule1 MyRule2
```

--------------------------------

### Defining Annotated Symbols

Source: https://scalacenter.github.io/scalafix/docs/developers/symbol-information.html

Example of defining classes and methods with annotations in Scala.

```scala
// Main.scala
package example
object Main {
  @deprecated("Use add instead", "1.0")
  def +(a: Int, b: Int) = add(a, b)

  class typed[T] extends scala.annotation.StaticAnnotation
  @typed[Int]
  def add(a: Int, b: Int) = a + b
}
```

--------------------------------

### Run Scalafix and Scalafmt sequence

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Command sequence to verify that OrganizeImports and Scalafmt do not conflict.

```bash
sbt> scalafixAll
...
sbt> scalafmtAll
...
sbt> scalafixAll --check
...
```

--------------------------------

### Define class with constructors

Source: https://scalacenter.github.io/scalafix/docs/developers/symbol-information.html

Example of a Scala class with both a primary and a secondary constructor.

```scala
// User.scala
package example
class User(name: String, age: Int) {      // primary constructor
  def this(name: String) = this(name, 42) // secondary constructor
}
```

--------------------------------

### Handle Rule Suppression

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Example of a test case requiring rule suppression.

```scala
complete(false) // scalafix:ok; rule suppression
```

--------------------------------

### Equivalent blankLines configurations

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Demonstrates how Auto and Manual blankLines modes achieve the same grouping result.

```hocon
OrganizeImports {
  blankLines = Auto
  groups = [
    "re:javax?\."
    "scala."
    "*"
  ]
}
```

```hocon
OrganizeImports {
  blankLines = Manual
  groups = [
    "re:javax?\."
    "---"
    "scala."
    "---"
    "*"
  ]
}
```

--------------------------------

### NoLiteralArguments Linter Error

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Example of the error message reported by the NoLiteralArguments linter.

```text
test/NamedLiteralArguments.scala:9:12: error: [NoLiteralArguments]:
Use named arguments for literals such as 'parameterName = true'
  complete(true)
           ^^^^
```

--------------------------------

### Import SemanticType and meta

Source: https://scalacenter.github.io/scalafix/docs/developers/semantic-type.html

Demonstrates the necessary imports to use Scalafix SemanticType alongside scala.meta.

```scala
import scalafix.v1._
import scala.meta._
```

--------------------------------

### NamedLiteralArguments Rewrite Diff

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Example of the code transformation produced by the NamedLiteralArguments rule.

```diff
  def complete(isSuccess: Boolean): Unit = ???
- complete(true)
+ complete(isSuccess = true)
```

--------------------------------

### Configure build settings for publishing

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Add project metadata to build.sbt to prepare for publishing to Maven Central.

```sbt
// build.sbt
inThisBuild(List(
  organization := "ch.epfl.scala",
  homepage := Some(url("https://github.com/scalacenter/scalafix")),
  licenses := List("Apache-2.0" -> url("http://www.apache.org/licenses/LICENSE-2.0")),
  developers := List(
    Developer(
      "olafurpg",
      "Ólafur Páll Geirsson",
      "olafurpg@gmail.com",
      url("https://geirsson.com")
    )
  )
))
```

--------------------------------

### Running Scalafix via CLI

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Execute a rule using the command-line interface with the --tool-classpath flag.

```bash
scalafix \
  --tool-classpath $(cs fetch ch.epfl.scala::named-literal-arguments:latest.release -p) \
  -r NamedLiteralArguments \
  --classpath MY_PROJECT_CLASSPATH \
  my-project/src/main/scala
```

--------------------------------

### Run Scalafix rules via CLI

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

Execute rules using sbt tab completion after dependencies are downloaded.

```bash
$ sbt
> scalafix Syn<TAB>
> scalafix SyntacticRule
```

--------------------------------

### View unreported diagnostic error

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Example of the error output when a diagnostic is expected but not reported.

```text
===========> Unreported <===========
fix/NoLiteralArgumentsConfig.scala:16:16: error
  complete(42) // assert: NoLiteralArguments
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-------
```

--------------------------------

### Configure OrganizeImports with DEFAULT preset

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Use the DEFAULT preset for new projects to ensure correctness and minimize merge conflicts.

```hocon
OrganizeImports {
  blankLines = Auto
  coalesceToWildcardImportThreshold = null
  expandRelative = false
  groupSeparately = []
  groupedImports = Explode
  groups = [
    "*"
    "re:(javax?|scala)\\."
  ]
  importSelectorsOrder = Ascii
  importsOrder = Ascii
  preset = DEFAULT
  removeUnused = true
}
```

--------------------------------

### Pass configuration via CLI arguments

Source: https://scalacenter.github.io/scalafix/docs/users/configuration.html

Override configuration file settings using the --settings prefix in the command line.

```hocon
// .scalafix.conf
DisableSyntax {
  noFinalize = true
}
lint.error.includes = ".*"
lint.error.excludes = "UnusedScalafixSuppression"
```

```bash
$ scalafix ... \
  --settings.DisableSyntax.noFinalize=true \
  --settings.lint.error.includes=.\* \
  --settings.lint.error.excludes=UnusedScalafixSuppression
```

--------------------------------

### Unused suppression warning example

Source: https://scalacenter.github.io/scalafix/docs/users/suppression.html

Scalafix reports warnings for suppressions that are no longer needed.

```text
project/Dependencies.scala:4:19: warning: Unused Scalafix suppression,
                                          this can be removed
[warn]   val x = List(1) // scalafix:ok
[warn]                   ^^^^^^^^^^^^^^
```

--------------------------------

### Verify rule execution

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

Successful execution output after configuration.

```text
> myproject / scalafix RemoveUnused
[info] Compiling 15 Scala sources to ...
[info] Running scalafix on 15 Scala sources
```

--------------------------------

### Configure StandardLayout Dialect

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Uses path-based detection to apply Scala 3 syntax for files in scala-3 directories and Scala 2 syntax elsewhere.

```hocon
OrganizeImports {
  targetDialect = StandardLayout
}
```

```scala
import scala.collection.immutable.{List => L}
import scala.collection.mutable.{Map}
import scala.collection.mutable.{Buffer => _, Seq => S, _}
import scala.concurrent.ExecutionContext.Implicits.{given scala.concurrent.ExecutionContext}
```

```scala
import scala.collection.immutable.List as L
import scala.collection.mutable.Map
import scala.collection.mutable.{Buffer as _, Seq as S, *}
import scala.concurrent.ExecutionContext.Implicits.given scala.concurrent.ExecutionContext
```

```scala
import scala.collection.immutable.{List => L}
import scala.collection.mutable.{Map}
import scala.collection.mutable.{Buffer => _, Seq => S, _}
```

```scala
import scala.collection.immutable.{List => L}
import scala.collection.mutable.Map
import scala.collection.mutable.{Buffer => _, Seq => S, _}
```

--------------------------------

### Define Configuration Companion Object

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Create a companion object with metaconfig decoders to enable reading configuration from .scalafix.conf.

```scala
object NoLiteralArgumentsConfig {
  def default = NoLiteralArgumentsConfig()
  implicit val surface =
    metaconfig.generic.deriveSurface[NoLiteralArgumentsConfig]
  implicit val decoder =
    metaconfig.generic.deriveDecoder(default)
}
```

--------------------------------

### Run a rule from a local file

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Execute a custom rule located on the local filesystem.

```bash
scalafix --rules=file:/path/to/NamedLiteralArguments.scala
```

--------------------------------

### Configure OrganizeImports removeUnused

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Example configuration for the OrganizeImports rule enabling the removal of unused imports.

```hocon
OrganizeImports {
  groups = ["javax?\.", "scala.", "*"]
  removeUnused = true
}
```

--------------------------------

### GroupedImports Merge Limitation Example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Illustrates the limitations of merging imports when multiple aliases are involved.

```scala
import java.lang.{Double => JDouble}
import java.lang.{Double => JavaDouble}
import java.lang.Integer
```

```scala
import java.lang.{Double => JDouble}
import java.lang.{Double => JavaDouble, Integer}
```

```scala
import java.lang.{Double => JDouble, Double => JavaDouble, Integer}
```

--------------------------------

### Release Management

Source: https://scalacenter.github.io/scalafix/docs/developers/contributing.html

Commands for tagging releases, verifying artifacts, and handling failed releases.

```bash
git fetch && git log origin/main --pretty=oneline # choose the commit hash you want to tag
COMMIT_HASH=14a069a3765739f5540129e8220104b17f233020 # change this variable
VERSION=0.9.15 # change this variable
git tag -af "v$VERSION" $COMMIT_HASH -m "v$VERSION" && git push -f origin v$VERSION
```

```bash
./bin/test-release.sh $VERSION
```

```bash
TAG=??? # for example "v0.5.3"
git tag -d $TAG
git push origin :refs/tags/$TAG
```

--------------------------------

### Import Organization Before and After

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Demonstrates the transformation of import statements when applying the OrganizeImports rule.

```scala
import org.apache.spark.SparkContext
import org.apache.spark.RDD
import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.Buffer
import scala.concurrent.ExecutionContext.Implicits.global
import scala.sys.process.stringToProcess
```

```scala
import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.Buffer

import org.apache.spark.RDD
import org.apache.spark.SparkContext

import scala.concurrent.ExecutionContext.Implicits.global
import scala.sys.process.stringToProcess
```

--------------------------------

### Configure build.sbt for Scalafix Rules and Testkit

Source: https://scalacenter.github.io/scalafix/docs/developers/local-rules.html

SBT configuration to define rule projects and link them with the Scalafix testkit for automated testing.

```scala
// build.sbt
import _root_.scalafix.sbt.{BuildInfo => ScalafixBuildInfo}

lazy val service1 = project // sub-project where rule(s) will be used
  .dependsOn(`scalafix-rules` % ScalafixConfig)

lazy val `scalafix-rules` = (project in file("scalafix/rules"))
  .disablePlugins(ScalafixPlugin)
  .settings(
    libraryDependencies +=
      ("ch.epfl.scala" %% "scalafix-core" % ScalafixBuildInfo.scalafixVersion)
        .cross(CrossVersion.for3Use2_13)
  )

// Projects below are optional, demonstrating usage of the testkit for unit tests

lazy val `scalafix-input` = (project in file("scalafix/input"))
  .disablePlugins(ScalafixPlugin)

lazy val `scalafix-output` = (project in file("scalafix/output"))
  .disablePlugins(ScalafixPlugin)

lazy val `scalafix-tests` = (project in file("scalafix/tests"))
  .settings(
    scalafixTestkitOutputSourceDirectories :=
      (`scalafix-output` / Compile / sourceDirectories).value,
    scalafixTestkitInputSourceDirectories :=
      (`scalafix-input` / Compile / sourceDirectories).value,
    scalafixTestkitInputClasspath :=
      (`scalafix-input` / Compile / fullClasspath).value,
    scalafixTestkitInputScalacOptions :=
      (`scalafix-input` / Compile / scalacOptions).value,
    scalafixTestkitInputScalaVersion :=
      (`scalafix-input` / Compile / scalaVersion).value
  )
  .dependsOn(`scalafix-input`, `scalafix-rules`)
  .enablePlugins(ScalafixTestkitPlugin)
```

--------------------------------

### Get Symbol of a Tree

Source: https://scalacenter.github.io/scalafix/docs/developers/symbol-information.html

Use Tree.symbol to retrieve the symbol associated with a specific tree node.

```scala
println(42)
println()
```

```scala
doc.tree.collect {
  case apply @ Term.Apply.After_4_6_0(println @ Term.Name("println"), _) =>
    (apply.syntax, println.symbol)
}
// res1: List[(String, Symbol)] = List(
//   ("println(42)", scala/Predef.println(+1).),
//   ("println()", scala/Predef.println().)
// )
```

--------------------------------

### Create test suite

Source: https://scalacenter.github.io/scalafix/docs/developers/setup.html

Implement a test suite by extending AbstractSemanticRuleSuite.

```scala
package myproject
class MyTests
    extends scalafix.testkit.AbstractSemanticRuleSuite {

  runAllTests()
}
```

--------------------------------

### CoalesceToWildcardImportThreshold Risk Example

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Illustrates how coalescing imports into a wildcard can introduce compilation errors due to shadowing.

```scala
import scala.collection.immutable._
import scala.collection.mutable.{ArrayBuffer, Map, Set}

object Example {
  val m: Map[Int, Int] = ???
}
```

```scala
import scala.collection.immutable._
import scala.collection.mutable._

object Example {
  val m: Map[Int, Int] = ???
}
```

--------------------------------

### Implement configuration case class

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Define a class to hold and validate rule configuration.

```scala
case class NoLiteralArgumentsConfig(
    disabledLiterals: List[String] = List("Boolean")
) {
  def isDisabled(lit: Lit): Boolean = {
    val kind = lit.productPrefix.stripPrefix("Lit.")
    disabledLiterals.contains(kind)
  }
}
```

--------------------------------

### Test Failure Diff

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Example of a test failure output when the rule implementation does not match the expected output.

```diff
 > ~tests / test
--- obtained
+++ expected
@@ -4,3 +4,3 @@
   def complete(isSuccess: Boolean): Unit = ()
-  complete(true)
+  complete(isSuccess = true)
 }
```

--------------------------------

### Run Scalafix Tests

Source: https://scalacenter.github.io/scalafix/docs/developers/contributing.html

Commands to execute specific test suites using sbt.

```sbt
> unit3_3_6 / testWindows
> integration3_3_6 / testWindows

# Only run tests for built-in rules, using scalafix-testkit.
> expect3_3_6Target3_3_6 / test

# Only run ProcedureSyntax unit tests.
> expect3_3_6Target3_3_6 / testOnly -- -z ProcedureSyntax
```

--------------------------------

### Test rule configuration

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Create a test file that uses specific rule configuration.

```scala
/*
rule = NoLiteralArguments
NoLiteralArguments.disabledLiterals = [
  Int
  Boolean
]
 */
package test

class NoLiteralArgumentsConfig {
  def complete(message: String): Unit = ()
  def complete(count: Int): Unit = ()
  def complete(isSuccess: Boolean): Unit = ()
  complete("done") // ok, no error message
  complete(42) // assert: NoLiteralArguments
  complete(true) // assert: NoLiteralArguments
  complete(true) // scalafix:ok; rule suppression
}
```

--------------------------------

### Run a rule from a GitHub repository

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Execute a custom rule directly from a GitHub repository using the scheme syntax.

```bash
scalafix --rules=github:scalacenter/named-literal-arguments
```

--------------------------------

### Blank Line Marker Configurations

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Shows how blank line markers are handled under different blankLines settings.

```hocon
OrganizeImports {
  blankLines = Manual
  groups = [
    "---"
    "re:javax?\."
    "---"
    "scala."
    "---"
    "---"
    "*"
    "---"
  ]
}

OrganizeImports {
  blankLines = Manual
  groups = [
    "re:javax?\."
    "---"
    "scala."
    "---"
    "*"
  ]
}

OrganizeImports {
  blankLines = Auto
  groups = [
    "re:javax?\."
    "scala."
    "*"
  ]
}
```

--------------------------------

### DisableSyntax Error Output Example

Source: https://scalacenter.github.io/scalafix/docs/rules/DisableSyntax.html

Shows the format of an error message generated by the DisableSyntax rule when a throw expression is detected.

```text
MyCode.scala:10: error: [DisableSyntax.throw] exceptions should be avoided,
                        consider encoding the error in the return type instead
  throw new IllegalArgumentException
  ^^^^^
```

--------------------------------

### Get Case Class Field Names

Source: https://scalacenter.github.io/scalafix/docs/developers/symbol-information.html

Iterate through constructors to identify the primary constructor and extract field names from its signature.

```scala
getConstructors(Symbol("example/User#")).foreach {
  case ctor if ctor.isPrimary =>
    ctor.signature match {
      case MethodSignature(_, parameters :: _, _) =>
        val names = parameters.map(_.displayName)
        println("names: " + names.mkString(", "))
    }
  case _ => // secondary constructor, ignore `this(secondaryName: String)`
}
// names: name, age
```

--------------------------------

### Configure rule via .scalafix.conf

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Define configuration parameters for the rule in the project configuration file.

```hocon
// .scalafix.conf
NoLiteralArguments.disabledLiterals = [
  "Int",
  "String",
  "Boolean"
]
```

--------------------------------

### Define directory structure for multi-project build

Source: https://scalacenter.github.io/scalafix/docs/developers/local-rules.html

Organize rules within a specific sub-project to isolate them from the global build.

```text
 repository
 ├── build.sbt
 ├── project
 │   └── plugins.sbt
 └── service1
 │   └── src
 │       ├── main
 │       │   └── ...
 │       ├── test
 │       │   └── ...
+│       └── scalafix
+│           ├── resources/META-INF/services
+│           │   └── scalafix.v1.Rule // not mandatory, but allows syntax
+|           |                        // `MyRule1` over `class:fix.MyRule1`
+│           └── scala/fix
+│               ├── MyRule1.scala
+│               ├── MyRule2.scala
+│               └── ...
 ├── service2
 │   └── ...
 └── service3
     └── ...
```

--------------------------------

### View project structure

Source: https://scalacenter.github.io/scalafix/docs/developers/setup.html

The generated directory structure for a Scalafix rule project.

```text
scalafix
├── rules/src/main
│   ├── resources/META-INF/services
│   │   └── scalafix.v1.Rule // ServiceLoader configuration to load rule
│   └── scala/fix
│       └── Rewrite.scala // Implementation of a rewrite rule
├── input/src/main/scala/test
│   └── RewriteTest.scala // Unit test for rewrite rule,
│                         // must have corresponding file in output.
│                         // no corresponding output file needed.
├── output/src/main/scala/test
│   └── RewriteTest.scala // Expected output from running rewrite
│                         // on RewriteTest.scala from input project
└── tests/src/test/scala/fix
    └── RuleSuite.scala
```

--------------------------------

### Equivalent Wildcard Configurations

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Demonstrates that the wildcard pattern can be omitted when it is the last group.

```hocon
OrganizeImports.groups = ["re:javax?\.", "scala.", "*"]
OrganizeImports.groups = ["re:javax?\.", "scala."]
```

--------------------------------

### Launch Scalafix CLI with Snapshot

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

Use Coursier to launch a specific snapshot version of the Scalafix CLI from the Sonatype repository.

```bash
cs launch ch.epfl.scala:scalafix-cli_2.13.18:0.14.7+27-f57ebd50-SNAPSHOT -r https://central.sonatype.com/repository/maven-snapshots --main scalafix.cli.Cli -- --help
```

--------------------------------

### Demonstrate NoAutoTupling limitations

Source: https://scalacenter.github.io/scalafix/docs/rules/NoAutoTupling.html

Illustrates that constructor applications using 'new' are not automatically fixed by this rule.

```scala
case class Foo(x: (String, Boolean))
new Foo("string", true) // won't be fixed
Foo("string", true)     // will be fixed
```

--------------------------------

### Run local rules via sbt

Source: https://scalacenter.github.io/scalafix/docs/developers/local-rules.html

Execute custom rules using the scalafix command in the sbt shell.

```bash
$ sbt
> scalafix MyRule1 MyRule2
```

--------------------------------

### Run a rule from a raw HTTP URL

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Execute a custom rule by providing a direct link to the raw source code, such as a GitHub Gist.

```bash
scalafix --rules=https://gist.githubusercontent.com/olafurpg/eeccf32f035d13f0728bc94d8ec0a776/raw/78c81bb7f390eb98178dd26ea03c42bd5a998666/NamedLiteralArguments.scala
```

--------------------------------

### Create a test input file

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

Define a test case with rule assertions and suppression comments.

```scala
/*
rule = NoLiteralArguments
 */
package test

class NoLiteralArguments {
  def complete(isSuccess: Boolean): Unit = ()
  complete(true) // assert: NoLiteralArguments
  complete(true) // scalafix:ok; should not assert
}
```

--------------------------------

### Configure rules in .scalafix.conf

Source: https://scalacenter.github.io/scalafix/docs/users/configuration.html

Define the list of rules to execute during a Scalafix run.

```hocon
// .scalafix.conf
rules = [
  DisableSyntax
]
```

--------------------------------

### Project Structure

Source: https://scalacenter.github.io/scalafix/docs/developers/tutorial.html

The expected directory structure for input and output files in the test suite.

```text
input/src
└── main
    └── scala
        └── fix
            └── NamedLiteralArguments.scala
output/src
└── main
    └── scala
        └── fix
            └── NamedLiteralArguments.scala
```

--------------------------------

### JVM memory configuration

Source: https://scalacenter.github.io/scalafix/docs/users/installation.html

Recommended JVM settings for compilation overhead.

```text
  -Xss8m
  -Xms1G
  -Xmx8G
```

--------------------------------

### Configure OrganizeImports with INTELLIJ_2020_3 preset

Source: https://scalacenter.github.io/scalafix/docs/rules/OrganizeImports.html

Use the INTELLIJ_2020_3 preset for compatibility with existing projects using the IntelliJ Scala plugin.

```hocon
OrganizeImports {
  blankLines = Auto
  coalesceToWildcardImportThreshold = 5
  expandRelative = false
  groupSeparately = []
  groupedImports = Merge
  groups = [
    "*"
    "re:(javax?|scala)\\."
  ]
  importSelectorsOrder = Ascii
  importsOrder = Ascii
  preset = INTELLIJ_2020_3
  removeUnused = true
}
```

--------------------------------

### Configure build.sbt for local rules

Source: https://scalacenter.github.io/scalafix/docs/developers/local-rules.html

Add scalafix-core to libraryDependencies using the ScalafixConfig configuration.

```scala
// build.sbt
import _root_.scalafix.sbt.{BuildInfo => ScalafixBuildInfo}

libraryDependencies +=
  ("ch.epfl.scala" %% "scalafix-core" % ScalafixBuildInfo.scalafixVersion)
    .cross(CrossVersion.for3Use2_13) % ScalafixConfig

// Since sbt 1.10.x (https://github.com/sbt/sbt/pull/7480), scala3-library is
// not automatically added to non-standard configurations, but is needed by the
// Scala 3 compiler, so it must be added explicitly if no dependency brings it
// implicitly, which is the case here because the only dependency is for3Use2_13
libraryDependencies ++= {
  if (scalaBinaryVersion.value == "3")
    Seq("org.scala-lang" %% "scala3-library" % scalaVersion.value % ScalafixConfig)
  else
    Nil
}
```

--------------------------------

### Apply rule-specific configuration

Source: https://scalacenter.github.io/scalafix/docs/users/configuration.html

Set top-level configuration parameters for specific rules.

```hocon
// .scalafix.conf
rules = [
  DisableSyntax
]
DisableSyntax.noFinalize = true
```
Tokens:
Raw