Instance Constructors

1.  new Newlines(source: SourceHints = Newlines.classic, avoidInResultType: Boolean = false, neverBeforeJsNative: Boolean = false, sometimesBeforeColonInMethodReturnType: Boolean = true, penalizeSingleSelectMultiArgList: Boolean = true, alwaysBeforeCurlyBraceLambdaParams: Boolean = false, beforeCurlyLambdaParams: BeforeCurlyLambdaParams = BeforeCurlyLambdaParams.never, topLevelStatementsMinBreaks: Int = 1, topLevelStatements: Seq[BeforeAfter] = Seq.empty, alwaysBeforeTopLevelStatements: Boolean = false, afterCurlyLambdaParams: AfterCurlyLambdaParams = AfterCurlyLambdaParams.never, implicitParamListModifierForce: Seq[BeforeAfter] = Seq.empty, implicitParamListModifierPrefer: Option[BeforeAfter] = None, alwaysBeforeElseAfterCurlyIf: Boolean = false, alwaysBeforeMultilineDef: Boolean = false, beforeMultiline: Option[SourceHints] = None, beforeMultilineDef: Option[SourceHints] = None, afterInfix: Option[AfterInfix] = None, afterInfixBreakOnNested: Boolean = false, afterInfixMaxCountPerExprForSome: Int = 10, afterInfixMaxCountPerFile: Int = 500, avoidForSimpleOverflow: Seq[AvoidForSimpleOverflow] = Seq.empty, avoidAfterYield: Boolean = true)
   source

   Controls how line breaks in the input source are handled If classic (default), the old mixed behaviour will be used If keep, try to keep source newlines If fold, ignore source and try to remove line breaks If unfold, ignore source and try to break lines

   neverBeforeJsNative

   If true, a newline will never be placed in front of js.native.

   sometimesBeforeColonInMethodReturnType

   If true, scalafmt may choose to put a newline before colon : at defs.

   penalizeSingleSelectMultiArgList

   If true, adds a penalty to newlines before a dot starting a select chain of length one and argument list. The penalty matches the number of arguments to the select chain application.

   // If true, favor
   logger.elem(a,
               b,
               c)
   // instead of
   logger
     .elem(a, b, c)
   
   // penalty is proportional to argument count, example:
   logger.elem(a, b, c)    // penalty 2
   logger.elem(a, b, c, d) // penalty 3, etc.

   If false, matches pre-v0.5 behavior. Note. this option may be removed in a future release.

   beforeCurlyLambdaParams

   • if Never, tries to use a space between the opening curly brace and the list of parameters of anonymous functions, and some partial functions (those with a single case clause and no conditions)
   • if MultilineWithCaseOnly, forces a newline in partial functions (see above) which can't be formatted on a single line
   • if Always, forces a newline in lambda and partial functions. For example:

   something.map {
     n =>
       consume(n)
   }

   topLevelStatementsMinBreaks

   Minimum span (number of line breaks between first and last line) to start forcing blank lines.

   topLevelStatements

   Forces a blank line before and/or after a top-level statement.

   afterCurlyLambdaParams

   If never (default), it will remove any extra lines below curly lambdas

   something.map { x =>
   
     f(x)
   }

   will become

   something.map { x =>
     f(x)
   }

   If always, it will always add one empty line (opposite of never). If preserve, and there isn't an empty line, it will keep it as it is. If there is one or more empty lines, it will place a single empty line. If squash, it will try to squash lambda body in one line:

   xs.map { x =>
     x + 1
   }

   will become

   xs.map { x => x + 1 }

   alwaysBeforeElseAfterCurlyIf

   if true, add a new line between the end of a curly if and the following else. For example if(someCond) { // ... } else //...

   beforeMultilineDef

   If unfold (or true), add a newline before the body of a multiline def without curly braces. See #1126 for discussion. For example,

   // newlines.beforeMultilineDef = fold
   def foo(bar: Bar): Foo = bar
     .flatMap(f)
     .map(g)
   
   // newlines.beforeMultilineDef = unfold
   def foo(bar: Bar): Foo =
     bar
       .flatMap(f)
       .map(g)

   afterInfix

   Controls how line breaks around operations are handled If keep (default for source=classic,keep), preserve existing If some (default for source=fold), break after some infix ops If many (default for source=unfold), break after many infix ops

   afterInfixBreakOnNested

   Force breaks around nested (enclosed in parentheses) expressions

   afterInfixMaxCountPerExprForSome

   Switch to many for a given expression (possibly nested) if the number of operations in that expression exceeds this value AND afterInfix had been set to some.

   afterInfixMaxCountPerFile

   Switch to keep for a given file if the total number of infix operations in that file exceeds this value

   avoidForSimpleOverflow

   • punct: don't force break if overflow is only due to trailing punctuation
   • tooLong: don't force break if overflow is due to tokens which are too long and would likely overflow even after a break

   avoidAfterYield

   If false (legacy behavior), inserts unconditional line break after yield if the yield body doesn't fit on a single line. For example,

   // newlines.avoidAfterYield = true (default)
   for (a <- as)
   yield Future {
     ...
   }
   
   // newlines.avoidAfterYield = false (default before v2).
   for (a <- as)
   yield
     Future {
       ...
     }