scalameta/scalafmt

Code formatter for Scala

scalafmt

User documentation

Head over to the user docs for instructions on how to install scalafmt.

Quick help

• sbt compile or sbt core/compile (specific project).
• Run all unit tests: sbt test
• Run only formatting tests: tests/testOnly *FormatTests.
• Write new formatting test: read this doc.
• Build docs: See instructions on the site or locally at ./docs/contributing-website.md.
• Hack on sbt plugin: run sbt scripted.
• Run jmh benchmarks: ./bin/run-benchmarks.sh.
• Run formatter on millions of lines of code: tests/test:runMain org.scalafmt.ScalafmtProps (slow, and requires a lot of memory/cpu)
• Debug performance: after each test run in FormatTests, a flamegraph report like this one is generated in target/index.html. I usually keep a browser tab open at localhost:3000/target/index.html along with this background process: browser-sync start --server --files "target/*.html". See Browsersync.

Team

The current maintainers (people who can merge pull requests) are:

• Ólafur Páll Geirsson - @olafurpg
• Pedro J Rodriguez Tavarez - @pjrt
• Iurii Susuk - @ysusuk
• Paul Draper - @pauldraper
• Rikito Taniguchi @tanishiking
• Mikhail Chugunkov @poslegm

An up-to-date list of contributors is available here: https://github.com/scalameta/scalafmt/graphs/contributors

We strive to offer a welcoming environment to learn, teach and contribute.

Acknowledgements

JProfiler generously supports scalafmt with its full-featured Java Profiler.

scalafmt's Issues

Absurd formatting of a (deprecated) secondary constructor

Original:

@js.native
class ClipboardEvent(`type`: String, settings: ClipboardEventInit) extends Event {
  @deprecated("Use the overload with a ClipboardEventInit instead.", "0.8.1")
  def this(`type`: String, settings: js.Dynamic) = this(`type`, settings.asInstanceOf[ClipboardEventInit])

Scalafmt:

@js.native
class ClipboardEvent(`type` : String, settings: ClipboardEventInit)
    extends Event {
  @deprecated("Use the overload with a ClipboardEventInit instead.", "0.8.1") def this (`type` : String,
  settings: js.Dynamic) = this(
      `type`, settings.asInstanceOf[ClipboardEventInit])

I would like the input to look like this:

@js.native
class ClipboardEvent(`type` : String, settings: ClipboardEventInit)
    extends Event {
  @deprecated("Use the overload with a ClipboardEventInit instead.", "0.8.1")
  def this (`type`: String, settings: js.Dynamic) =
    this(`type`, settings.asInstanceOf[ClipboardEventInit])

Using

• 0.1.1
• default

Configuration: spaces inside parentheses `( arg )`

Original:

function(arg)

Scalafmt:

function(arg)

I would like the input to look like this:

function( arg )

Remove ficus jdk8 dependency.

#40 shouldn't have been necessary.

Decrease indent when leaving block

Example

val x
  = 1;
val y = 2

When we leave val x = 1; we must remove the 2 indentation.

Optimize policies.

Currently, each FormatToken is run against all policies. This can lead to O(n^2) overhead (each token is run against policies for all previous tokens).

Spurious breaking of a class header (it's not too long for one line)

Original:

 *
 */
@js.native
class MediaStream() extends EventTarget {

  /**
   * Is a Boolean value set to true if the ended event has been
   * fired on the object, meaning that the stream has been completely read,

Scalafmt:

 *
 */
@js.native
class MediaStream()
    extends EventTarget {
  /**
   * Is a Boolean value set to true if the ended event has been
   * fired on the object, meaning that the stream has been completely read,

I would like the input to look like this:

 *
 */
@js.native
class MediaStream() extends EventTarget {

  /**
   * Is a Boolean value set to true if the ended event has been
   * fired on the object, meaning that the stream has been completely read,

Using

• 0.1.1
• default

There should be no space between . and type in a singleton type

Original:

  lazy val Blob: raw.Blob.type = raw.Blob

Scalafmt:

  lazy val Blob: raw.Blob. type = raw.Blob

I would like the input to look like this:

  lazy val Blob: raw.Blob.type = raw.Blob

Using

• 0.1.1
• default

some indentation of long, nested types

Original:

val x:FooBarrrrrr[BaaaaaaaaaaaazBazzz[String, Option[List[Either[Int, Option[String]]]]]

Scalafmt (this is a guess):

val x: FooBarrrrrr[BaaaaaaaaaaaazBazzz[String, Option[List[Either[Int, Option[String]]]]]

I would like the input to look like this (roughly):

val x: FooBarrrrrr[
  BaaaaaaaaaaaazBazzz[
    String,
    Option[ List[
        Either[ Int, Option[String] ]
 ]]]

Breaking between params should be preferred over breaking inside []

Original:

@js.native
class MutationObserver(callback: js.Function2[js.Array[MutationRecord], MutationObserver, _]

Scalafmt:

@js.native
class MutationObserver(callback: js.Function2[js.Array[MutationRecord],
    MutationObserver, _])
    extends js.Object {

I would like the input to look like this:

@js.native
class MutationObserver(
    callback: js.Function2[js.Array[MutationRecord], MutationObserver, _])
    extends js.Object {

Using

• 0.1.1
• default

Preserve . chains

Unit test

<<< SKIP preserve chains, this is scala.js style.
  val files = FilesUtil.listFiles(".")
    .filter(_.endsWith(".scala"))
    .filterNot(_.contains("/target/"))
    .filterNot(_.contains("/resources/"))
>>>
val files = FilesUtil.listFiles(".")
  .filter(_.endsWith(".scala"))
  .filterNot(_.contains("/target/"))
  .filterNot(_.contains("/resources/"))

Members with backticks should not force a space before :

Original:

val `type`: String = js.native

Scalafmt:

val `type` : String = js.native

I would like the input to look like this:

val `type`: String = js.native

The space before : is not necessary after a backtick.

Using

• 0.1.1
• default

(personal preference?) there should be space between visibility modifier and ctor params

Original:

class WebGLFramebuffer private () extends js.Object

Scalafmt:

class WebGLFramebuffer private() extends js.Object

I would like the input to look like this:

class WebGLFramebuffer private () extends js.Object

Using

• 0.1.1
• default

Existing blank line between comments should be kept

Original:

  // =======================================================================================
  // 6.3.2 Modifier Keys

  /** The Alternative (Alt, Option, Menu) key. Enable alternate modifier function for interp
  final val Alt = "Alt"

Scalafmt:

  // =======================================================================================
  // 6.3.2 Modifier Keys
  /** The Alternative (Alt, Option, Menu) key. Enable alternate modifier function for interp
  final val Alt = "Alt"

I would like the input to look like this:

  // =======================================================================================
  // 6.3.2 Modifier Keys

  /** The Alternative (Alt, Option, Menu) key. Enable alternate modifier function for interp
  final val Alt = "Alt"

i.e., the blank line that existed between two existing comments should be kept.

Using

• 0.1.1
• default

private[this] (and qualified-private?) is wrongly formatted

From Reddit

Original:

private[this] val root = Path(s"/$path")

Scalafmt:

private [ this] val root = Path(s"/$path")

I would like the input to look like this:

private[this] val root = Path(s"/$path")

This probably also applies to protected, as well as qualified-private private[EnclosingEntity].

Using

• 0.1.1
• (don't know)

There should be no space between a variance annotation and the type param

Original:

trait JSIterator[+A] extends js.Object {

Scalafmt:

trait JSIterator[+ A] extends js.Object {

I would like the input to look like this:

trait JSIterator[+A] extends js.Object {

Using

• 0.1.1
• default

Optimize formatting imports=

Something is wrong here:

Newline between `Defn`s

The current implentation is buggy, see output

[info]   case object OneArgOneLine extends ArgumentHandling trait ScalaStyle {
[info]     def maxColumn: Int
[info]       = 80 def argumentHandling: ArgumentHandling = OneArgOneLine
[info]   }

There should be a newline before the second def.

Support splitting strategies

Current model only supports local decisions for each FormatToken, however in some cases (e.g. argument list) I may want to make decisions at one FormatToken for multiple upcoming FormatTokens (e.g. opening '(' controls all commas and closing ')' of argument list).

Shrink search space

Two lines like this

val x = 1
val y = 2

do not interfere with each other. When we find the cheapest path to val in the second line, we can clear the search queue since we know no other path will lead to better results.

Escape hatch

Original:

// format: OFF
val identityMatrix = Array(1, 0, 0
                           0, 1, 0
                           0, 0, 1)
// format: ON

I would like the input to look like this:

// format: OFF
val identityMatrix = Array(1, 0, 0
                           0, 1, 0
                           0, 0, 1)
// format: ON

[Scala.js-specific] = js.native should always be kept on the same line

Note that this is not a question of preference of the Scala.js style guide. It should apply equally to all style guides, but it's specific to Scala.js code. The = js.native is a very special beast.

Original:

  def uniform4fv(location: WebGLUniformLocation, v: Float32Array): Unit = js.native

Scalafmt:

  def uniform4fv(location: WebGLUniformLocation, v: Float32Array): Unit =
    js.native

I would like the input to look like this:

  def uniform4fv(location: WebGLUniformLocation,
      v: Float32Array): Unit = js.native

In all cases, js.native should be kept right next to its =. Which means that the line should be broken somewhere else.

Using

• 0.1.1
• default

Prefer splitting at higher levels of nesting

This should be possible with policies, for example

<<< SKIP #15 Split at higher levels
object Object {
  val x = function(first(a, b), second(c, d))
}
>>>
object Object {
  val x = function(first(a, b),
                   second(c, d))
}

Format boolean conditions

Input

object a {
  if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
        bbbbbbbbbbbbbbbbbb) println("a")
}

Current output

[info]   object a {
[info]     if(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbb) println(
[info]         "a")
[info]   }

Insert space after identifiers that end with `_`

For example

val x_: Int = 1

won't parse since x_: is parsed as one token.

Efficient and simple handling of `Tokens`

Implement an abstraction to support simple management of non-whitespace tokens and the whitespace tokens between them.

Strategies can constrain future splits

For example, the one-liner block strategy should be able to make sure that no newlines are introduced inside the block. Below the formatter is happy to insert a newline after function( even though we are trying to define Object in a single line.

object Object { function(
  argument) }

A possible solution is to increase the cost of newlines inside the block.

@annotations in front of `def` should be kept there

Original:

  @inline def Rule = raw.CSSRule

Scalafmt:

  @inline
  def Rule = raw.CSSRule

I would like the input to look like this:

  @inline def Rule = raw.CSSRule

at least if the everything up to = stays on one line.

Although, if the original had @inline on a separate line, I'd like scalafmt to keep it on a separate line.

Using

• 0.1.1
• default

Breaking before . in .-chain should be preferred over breaking inside []

Original:

object RsaHashedImportParams {
  @inline
  def apply(name: String, hash: HashAlgorithmIdentifier): RsaHashedImportParams =
    js.Dynamic.literal(name = name, hash = hash.asInstanceOf[js.Any]).asInstanceOf[RsaHashed
}

Scalafmt:

object RsaHashedImportParams {
  @inline
  def apply(
      name: String, hash: HashAlgorithmIdentifier): RsaHashedImportParams =
    js.Dynamic
      .literal(name = name, hash = hash.asInstanceOf[js.Any]).asInstanceOf[
        RsaHashedImportParams]
}

I would like the input to look like this:

object RsaHashedImportParams {
  @inline
  def apply(
      name: String, hash: HashAlgorithmIdentifier): RsaHashedImportParams =
    js.Dynamic
      .literal(name = name, hash = hash.asInstanceOf[js.Any])
      .asInstanceOf[RsaHashedImportParams]
}

Using

• 0.1.1
• default

Get tests to register code coverage in `core`

See https://codecov.io/github/olafurpg/scalafmt/core/src/main/scala/org/scalafmt?ref=3ff3d1cab85dd804c40790a4ccd81fe243cc3620

After I moved the tests to tests the code coverage got messed up.

Safer/richer indentation abstraction

The indentation is managed by State.indent: Int. Splits and policies can increment/decrement the int.

• This makes it tricky for example to indent a function argument to the same column as the opening ( because we don't know the exact integer value of the state's column.
• unindenting the same number of spaces at the closing ) requires us to know integer value at the opening )
• We violate DRY by relying on decrementing the same number as we increment.

A more powerful abstraction would work like a stack, you push an Indent which can be a concrete number or a useful object like state.column

Determine indentation for all tokens beforehand

For example with a Map[Token, Int]. If we put a newline before a token we can lookup the required indentation after the newline.

/* */ comment at EOL should be attached like a //

Original:

  final val BLEND_EQUATION = 0x8009
  final val BLEND_EQUATION_RGB = 0x8009   /* same as BLEND_EQUATION */
  final val BLEND_EQUATION_ALPHA = 0x883D

Scalafmt:

  final val BLEND_EQUATION = 0x8009
  final val BLEND_EQUATION_RGB = 0x8009
  /* same as BLEND_EQUATION */
  final val BLEND_EQUATION_ALPHA = 0x883D

I would like the input to look like this:

  final val BLEND_EQUATION = 0x8009
  final val BLEND_EQUATION_RGB = 0x8009 /* same as BLEND_EQUATION */
  final val BLEND_EQUATION_ALPHA = 0x883D

Of course, that comment should have been a // comment in the first place. But that's no excuse ;) The current reformatting actively harms further readability.

Using

• 0.1.1
• default

Disappearing blank line between method and Scaladoc of the next method

Original:

  /**
   * See [[https://streams.spec.whatwg.org/#reader-cancel §3.4.4.2. cancel(reason)]]
   * of whatwg Streams spec.
   *
   * If the reader is active, the cancel method behaves the same as that for
   * the associated stream. When done, it automatically releases the lock.
   *
   * //todo determine type of reason
   */
  def cancel(reason: Any): js.Promise[Any] = js.native //not actually sure what the return type is here

  /**
   * See [[https://streams.spec.whatwg.org/#reader-read 3.4.4.3. read()]] of
   * whatwg Stream spec.
   *
   * The read method will return a promise that allows access to the next chunk
   * from the stream’s internal queue, if available. If the chunk does become
   * available, the promise will be fulfilled with an object of the form {
   * value: theChunk, done: false }. If the stream becomes closed, the
   * promise will be fulfilled with an object of the form { value: undefined,
   * done: true }. If the stream becomes errored, the promise will be
   * rejected with the relevant error. If reading a chunk causes the queue to
   * become empty, more data will be pulled from the underlying source.
   */
  def read(): js.Promise[Chunk[T]] = js.native

Scalafmt:

  /**
   * See [[https://streams.spec.whatwg.org/#reader-cancel §3.4.4.2. cancel(reason)]]
   * of whatwg Streams spec.
   *
   * If the reader is active, the cancel method behaves the same as that for
   * the associated stream. When done, it automatically releases the lock.
   *
   * //todo determine type of reason
   */
  def cancel(reason: Any): js.Promise[Any] =
    js.native //not actually sure what the return type is here
  /**
   * See [[https://streams.spec.whatwg.org/#reader-read 3.4.4.3. read()]] of
   * whatwg Stream spec.
   *
   * The read method will return a promise that allows access to the next chunk
   * from the stream’s internal queue, if available. If the chunk does become
   * available, the promise will be fulfilled with an object of the form {
   * value: theChunk, done: false }. If the stream becomes closed, the
   * promise will be fulfilled with an object of the form { value: undefined,
   * done: true }. If the stream becomes errored, the promise will be
   * rejected with the relevant error. If reading a chunk causes the queue to
   * become empty, more data will be pulled from the underlying source.
   */
  def read(): js.Promise[Chunk[T]] = js.native

I would like the input to look like this:

  /**
   * See [[https://streams.spec.whatwg.org/#reader-cancel §3.4.4.2. cancel(reason)]]
   * of whatwg Streams spec.
   *
   * If the reader is active, the cancel method behaves the same as that for
   * the associated stream. When done, it automatically releases the lock.
   *
   * //todo determine type of reason
   */
  def cancel(reason: Any): js.Promise[Any] =
    js.native //not actually sure what the return type is here

  /**
   * See [[https://streams.spec.whatwg.org/#reader-read 3.4.4.3. read()]] of
   * whatwg Stream spec.
   *
   * The read method will return a promise that allows access to the next chunk
   * from the stream’s internal queue, if available. If the chunk does become
   * available, the promise will be fulfilled with an object of the form {
   * value: theChunk, done: false }. If the stream becomes closed, the
   * promise will be fulfilled with an object of the form { value: undefined,
   * done: true }. If the stream becomes errored, the promise will be
   * rejected with the relevant error. If reading a chunk causes the queue to
   * become empty, more data will be pulled from the underlying source.
   */
  def read(): js.Promise[Chunk[T]] = js.native

Using

• 0.1.1
• default

Correctly unindent multiline comments

It's not enough to unindent the comment token here, we also want to remove 2 spaces before the * starting each line afterwards.

[info]   object a {
[info]     /**
[info]        * One
[info]        */
[info]     def one = 1
[info]   }

NoSuchMethodError: java.lang.Long.hashCode(J)

https://www.reddit.com/r/scala/comments/49j5am/scalafmt_010_released_with_sbt_plugin_cli_and/d0t6anf

Long.hashCode appeared in Java 8.

There should be no space before a * of repeated param

Original:

    def fillPath(points: (Double, Double)*) = {
      prepPath(points)
      ctx.fill()
    }

Scalafmt:

    def fillPath(points: (Double, Double) *) = {
      prepPath(points)
      ctx.fill()
    }

I would like the input to look like this:

    def fillPath(points: (Double, Double)*) = {
      prepPath(points)
      ctx.fill()
    }

Using

• 0.1.1
• default

Format argument lists

Improve debugging/visualisation of search graph.

Given an output, you should be able to easily retrace each decision that was made and why.

Make it easy to validate performance improvements.

For example, keep a golden-performance.csv file under tests and after every test run compare performance of last run to golden performance. We need to take into account different hardware, of course.

More robust indentation

Push should expire at a certain token, and then we can eliminate Pop.

The current implementation makes it too easy to pop the wrong indentation, and get output like

[info]   ===========
[info]   => Obtained
[info]   ===========
[info]   {
[info]     val x = 1
[info]
[info]     def log(split: Split): String =
[info]       s"$split"
[info]     }

Find efficient way to lookup matching parens.

Should be possible with a single pass over all tokens and a single stack.

Breaking of import lines

Original:

import scala.language.implicitConversions

import org.scalajs.dom.experimental.serviceworkers.{ServiceWorkerGlobalScope, ServiceWorkerRegistration}

import scala.scalajs.js

Scalafmt:

import scala.language.implicitConversions

import org.scalajs.dom.experimental.serviceworkers.{ServiceWorkerGlobalScope,
ServiceWorkerRegistration}

import scala.scalajs.js

I would like the input to look like this:

import scala.language.implicitConversions

import org.scalajs.dom.experimental.serviceworkers.{ServiceWorkerGlobalScope, ServiceWorkerRegistration}

import scala.scalajs.js

or

import scala.language.implicitConversions

import org.scalajs.dom.experimental.serviceworkers.{
  ServiceWorkerGlobalScope, ServiceWorkerRegistration
}

import scala.scalajs.js

Using

• 0.1.1
• default

Support large arguments to `Term.apply`

See

The policy should not have to be indented by StateColumn

Test for mis-formatted text

Would love (specifically in SBT but probably in other contexts) to have an option to test for formatting violations (so we can fail a build) without having to actually format the code.

(personal preference?) If breaking before `with`, should break before `extends` beforehand

Original:

trait WorkerNavigator extends NavigatorID with NavigatorOnLine with NavigatorLanguage

Scalafmt:

trait WorkerNavigator extends NavigatorID with NavigatorOnLine
    with NavigatorLanguage

I would like the input to look like this:

trait WorkerNavigator
    extends NavigatorID with NavigatorOnLine with NavigatorLanguage

or, if that does not fit on the line length either:

trait WorkerNavigator
    extends NavigatorID with NavigatorOnLine
    with NavigatorLanguage

Using

• 0.1.1
• default

Configuration through .scalafmt

Proposal: to configure scalafmt there should be a .scalafmt file with some
standard syntax for configuration, perhaps similar to .clang-format http://clang.llvm.org/docs/ClangFormatStyleOptions.html

Add penalty for overflowing column-limit.

Post comparison report from Travis to pull request.

(personal preference?) Empty {} should be kept on separate lines

Original:

abstract class HTMLTableHeaderCellElement extends HTMLTableCellElement {
}

Scalafmt:

abstract class HTMLTableHeaderCellElement extends HTMLTableCellElement {}

I would like the input to look like this:

abstract class HTMLTableHeaderCellElement extends HTMLTableCellElement {
}

Using

• 0.1.1
• default

Add more tests to FormatTest