trait SplainFormatting extends SplainFormatters
- Alphabetic
- By Inheritance
- SplainFormatting
- SplainFormatters
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- Protected
Type Members
- trait SpecialFormatter extends AnyRef
- Definition Classes
- SplainFormatters
- case class TypeParts(sym: Global.Symbol, tt: Global.Type) extends Product with Serializable
Value Members
- object ByNameFormatter extends Analyzer.SpecialFormatter
- Definition Classes
- SplainFormatters
- object FunctionFormatter extends Analyzer.SpecialFormatter
- Definition Classes
- SplainFormatters
- object Refined
- Definition Classes
- SplainFormatters
- object RefinedFormatter extends Analyzer.SpecialFormatter
- Definition Classes
- SplainFormatters
- object TupleFormatter extends Analyzer.SpecialFormatter
- Definition Classes
- SplainFormatters
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- Implicit
- This member is added by an implicit conversion from SplainFormatting toany2stringadd[SplainFormatting] performed by method any2stringadd in scala.Predef.
- Definition Classes
- any2stringadd
- def ->[B](y: B): (SplainFormatting, B)
- Implicit
- This member is added by an implicit conversion from SplainFormatting toArrowAssoc[SplainFormatting] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @inline()
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def bracket[A](params: List[A]): String
- def breakInfix(types: List[Formatted]): TypeRepr
Break a list produced by flattenInfix into lines by taking two elements at a time, then appending the terminal.
Break a list produced by flattenInfix into lines by taking two elements at a time, then appending the terminal. If the expression's length is smaller than the threshold specified via plugin parameter, return a single line.
- val breakInfixLength: Int
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def ctorNames(tpe: Global.Type): List[String]
- def dealias(tpe: Global.Type): Global.Type
- def decideBreak(flat: FlatType, broken: => BrokenType): TypeRepr
- def deepestLevel(chain: List[Analyzer.ImplicitError]): Int
- def ensuring(cond: (SplainFormatting) => Boolean, msg: => Any): SplainFormatting
- Implicit
- This member is added by an implicit conversion from SplainFormatting toEnsuring[SplainFormatting] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: (SplainFormatting) => Boolean): SplainFormatting
- Implicit
- This member is added by an implicit conversion from SplainFormatting toEnsuring[SplainFormatting] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: Boolean, msg: => Any): SplainFormatting
- Implicit
- This member is added by an implicit conversion from SplainFormatting toEnsuring[SplainFormatting] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: Boolean): SplainFormatting
- Implicit
- This member is added by an implicit conversion from SplainFormatting toEnsuring[SplainFormatting] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def extractArgs(tpe: Global.Type): collection.immutable.List[Global.Type]
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def flattenInfix(tpe: Infix): List[Formatted]
Turn a nested infix type structure into a flat list
Turn a nested infix type structure into a flat list
::[A, ::[B, C]]] => List(A, ::, B, ::, C)
- def formatAuxSimple(tpe: Global.Type): (List[String], String)
- def formatDiff(left: Global.Type, right: Global.Type, top: Boolean): Formatted
- val formatDiffCache: FormatCache[(Global.Type, Global.Type, Boolean), Formatted]
- def formatDiffImpl(found: Global.Type, req: Global.Type, top: Boolean): Formatted
- def formatDiffInfix(left: Global.Type, right: Global.Type, top: Boolean): Formatted
- def formatDiffSimple(left: Global.Type, right: Global.Type): Formatted
- def formatDiffSpecial(left: Global.Type, right: Global.Type, top: Boolean): Option[Formatted]
- def formatFunction(args: List[String]): String
- def formatImplicitChain(chain: List[Analyzer.ImplicitError]): List[String]
- def formatImplicitChainFlat(chain: List[Analyzer.ImplicitError]): List[String]
- def formatImplicitChainTreeCompact(chain: List[Analyzer.ImplicitError]): Option[List[String]]
- def formatImplicitChainTreeFull(chain: List[Analyzer.ImplicitError]): List[String]
- def formatImplicitError(param: Global.Symbol, errors: List[Analyzer.ImplicitError], annotationMsg: String): String
- def formatIndentTree(chain: List[Analyzer.ImplicitError], baseIndent: Int): List[String]
- def formatInfix[A](path: List[String], simple: String, left: A, right: A, top: Boolean)(rec: (A, Boolean) => Formatted): Formatted
- def formatNestedImplicit(err: Analyzer.ImplicitError): (String, List[String], Int)
- def formatNestedImplicits(errors: List[Analyzer.ImplicitError]): collection.immutable.List[String]
Remove duplicates and special cases that should not be shown.
Remove duplicates and special cases that should not be shown. In some cases, candidates are reported twice, once as
Foo.f
and once asf
.ImplicitError.equals
checks the simple names for identity, which is suboptimal, but works for 99% of cases. Special cases are handled in hideImpError - def formatNonConfBounds(err: NonconformantBounds): List[String]
- def formatNormalSimple(tpe: Global.Type): (List[String], String)
- def formatRefinement(sym: Global.Symbol): String
- def formatSimpleType(tpe: Global.Type): (List[String], String)
- def formatSpecial[A](tpe: Global.Type, simple: String, args: List[A], formattedArgs: => List[Formatted], top: Boolean)(rec: (A, Boolean) => Formatted): Option[Formatted]
- def formatType(tpe: Global.Type, top: Boolean): Formatted
- Definition Classes
- SplainFormatting → SplainFormatters
- val formatTypeCache: FormatCache[(Global.Type, Boolean), Formatted]
- def formatTypeImpl(tpe: Global.Type, top: Boolean): Formatted
- def formatWithInfix[A](tpe: Global.Type, args: List[A], top: Boolean)(rec: (A, Boolean) => Formatted): Formatted
- def formattedDiff(left: Formatted, right: Formatted): String
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hideImpError(error: Analyzer.ImplicitError): Boolean
- def implicitMessage(param: Global.Symbol, annotationMsg: String): List[String]
- def indent(lines: List[String], n: Int = 1, prefix: String = " "): collection.immutable.List[String]
- def indentLine(line: String, n: Int = 1, prefix: String = " "): String
- def indentTree(tree: List[(String, List[String], Int)], baseIndent: Int): List[String]
- def isAux(tpe: Global.Type): Boolean
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def isRefined(tpe: Global.Type): Boolean
- def isSymbolic(tpe: Global.Type): Boolean
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def pathPrefix: (List[String]) => String
- def qualifiedName(path: List[String], name: FormattedName): String
- def sanitizePath(path: List[String]): List[String]
- def showFormatted(tpe: Formatted): String
- def showFormattedL(tpe: Formatted, break: Boolean): TypeRepr
- val showFormattedLCache: FormatCache[(Formatted, Boolean), TypeRepr]
- def showFormattedLImpl(tpe: Formatted, break: Boolean): TypeRepr
- def showFormattedQualified(path: List[String], name: FormattedName): TypeRepr
- def showFuncParams(args: List[String]): String
- def showRefined(parents: List[String], decls: List[String]): String
- def showTuple(args: List[String]): String
- def showType(tpe: Global.Type): String
- def showTypeApply(cons: String, args: List[TypeRepr], break: Boolean): TypeRepr
If the args of an applied type constructor are multiline, create separate lines for the constructor name and the closing bracket; else return a single line.
- def showTypeBreakL(tpe: Global.Type): List[String]
- val specialFormatters: List[Analyzer.SpecialFormatter]
- def splitChains(errors: List[Analyzer.ImplicitError]): List[List[Analyzer.ImplicitError]]
- def stripModules(path: List[String], name: FormattedName): String
- def stripType(tpe: Global.Type): (List[String], String)
- def symbolPath(sym: Global.Symbol): List[String]
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def truncateDecls(decls: List[Formatted]): Boolean
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- def wrapParens(expr: String, top: Boolean): String
- def wrapParensRepr(tpe: TypeRepr, top: Boolean): TypeRepr
Deprecated Value Members
- def formatted(fmtstr: String): String
- Implicit
- This member is added by an implicit conversion from SplainFormatting toStringFormat[SplainFormatting] performed by method StringFormat in scala.Predef.
- Definition Classes
- StringFormat
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.12.16) Use
formatString.format(value)
instead ofvalue.formatted(formatString)
, or use thef""
string interpolator. In Java 15 and later,formatted
resolves to the new method in String which has reversed parameters.
- def →[B](y: B): (SplainFormatting, B)
- Implicit
- This member is added by an implicit conversion from SplainFormatting toArrowAssoc[SplainFormatting] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use
->
instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.
The Scala compiler and reflection APIs.