Formatting

abstract def featureBreakInfix: Option[Int]

abstract def featureColor: Boolean

abstract def featureCompact: Boolean

abstract def featureInfix: Boolean

abstract def featureTree: Boolean

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object FunctionFormatter extends Analyzer.SpecialFormatter

object SLRecordItemFormatter extends Analyzer.SpecialFormatter

object TermName

object TupleFormatter extends Analyzer.SpecialFormatter

final def asInstanceOf[T0]: T0

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.

def cacheStats: String

def clone(): AnyRef

implicit def colors: StringColor

def ctorNames(tpe: scala.tools.nsc.Global.Type): List[String]

def dealias(tpe: scala.tools.nsc.Global.Type): scala.tools.nsc.Global.Type

def decideBreak(flat: FlatType, broken: ⇒ BrokenType): TypeRepr

def effectiveImplicitType(tpe: scala.tools.nsc.Global.Type): scala.tools.nsc.Global.Type

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extractArgs(tpe: scala.tools.nsc.Global.Type): List[scala.tools.nsc.Global.Type]

def finalize(): Unit

def flattenInfix(tpe: Infix): List[Formatted]

Turn a nested infix type structure into a flat list ::[A, ::[B, C]]] => List(A, ::, B, ::, C)

def formatAuxSimple(tpe: scala.tools.nsc.Global.Type): String

def formatDiff(left: scala.tools.nsc.Global.Type, right: scala.tools.nsc.Global.Type, top: Boolean): Formatted

val formatDiffCache: FormatCache[(scala.tools.nsc.Global.Type, scala.tools.nsc.Global.Type, Boolean), Formatted]

def formatDiffImpl(found: scala.tools.nsc.Global.Type, req: scala.tools.nsc.Global.Type, top: Boolean): Formatted

def formatDiffInfix(left: scala.tools.nsc.Global.Type, right: scala.tools.nsc.Global.Type, top: Boolean): Formatted

def formatDiffSimple(left: scala.tools.nsc.Global.Type, right: scala.tools.nsc.Global.Type): Diff

def formatDiffSpecial(left: scala.tools.nsc.Global.Type, right: scala.tools.nsc.Global.Type, top: Boolean): Option[Formatted]

def formatFunction(args: List[String]): String

def formatImplicitChain(chain: List[Analyzer.ImpFailReason]): List[String]

def formatImplicitChainFlat(chain: List[Analyzer.ImpFailReason]): List[String]

def formatImplicitChainTree(chain: List[Analyzer.ImpFailReason]): List[String]

def formatImplicitChainTreeCompact(chain: List[Analyzer.ImpFailReason]): Option[List[String]]

def formatImplicitChainTreeFull(chain: List[Analyzer.ImpFailReason]): List[String]

def formatImplicitError(param: scala.tools.nsc.Global.Symbol, errors: List[Analyzer.ImpFailReason]): String

def formatImplicitParam(sym: scala.tools.nsc.Global.Symbol): String

def formatIndentTree(chain: List[Analyzer.ImpFailReason], baseIndent: Int): List[String]

def formatInfix[A](simple: String, left: A, right: A, top: Boolean, rec: (A) ⇒ (Boolean) ⇒ Formatted): Infix

def formatNestedImplicit(err: Analyzer.ImpFailReason): List[String]

def formatNestedImplicits(errors: List[Analyzer.ImpFailReason]): List[String]

Remove duplicates and special cases that should not be shown.

def formatNonConfBounds(err: Analyzer.NonConfBounds): String

def formatNormalSimple(tpe: scala.tools.nsc.Global.Type): String

def formatRefinement(sym: scala.tools.nsc.Global.Symbol): String

def formatSimpleType(tpe: scala.tools.nsc.Global.Type): String

def formatSpecial[A](tpe: scala.tools.nsc.Global.Type, simple: String, args: List[A], formattedArgs: ⇒ List[Formatted], top: Boolean, rec: (A) ⇒ (Boolean) ⇒ Formatted): Option[Formatted]

def formatType(tpe: scala.tools.nsc.Global.Type, top: Boolean): Formatted

val formatTypeCache: FormatCache[(scala.tools.nsc.Global.Type, Boolean), Formatted]

def formatTypeImpl(tpe: scala.tools.nsc.Global.Type, top: Boolean): Formatted

def formatWithInfix[A](tpe: scala.tools.nsc.Global.Type, args: List[A], top: Boolean, rec: (A) ⇒ (Boolean) ⇒ Formatted): Formatted

final def getClass(): Class[_]

def hashCode(): Int

def hideImpError(error: Analyzer.ImpFailReason): Boolean

def implicitMessage(param: scala.tools.nsc.Global.Symbol): String

def indent(lines: List[String], n: Int = 1): List[String]

def indentTree(tree: List[List[String]], baseIndent: Int): List[String]

def isAux(tpe: scala.tools.nsc.Global.Type): Boolean

final def isInstanceOf[T0]: Boolean

def isRefined(tpe: scala.tools.nsc.Global.Type): Boolean

def isSymbolic(tpe: scala.tools.nsc.Global.Type): Boolean

final def ne(arg0: AnyRef): Boolean

def newTyper(context: Analyzer.Context): Analyzer.Typer

final def notify(): Unit

final def notifyAll(): Unit

def overrideMessage(msg: String): Option[String]

def showFormatted(tpe: Formatted, break: Boolean): String

def showFormattedL(tpe: Formatted, break: Boolean): TypeRepr

def showFormattedLBreak(tpe: Formatted): TypeRepr

val showFormattedLCache: FormatCache[(Formatted, Boolean), TypeRepr]

def showFormattedLImpl(tpe: Formatted, break: Boolean): TypeRepr

def showFormattedLNoBreak(tpe: Formatted): TypeRepr

def showFormattedNoBreak(tpe: Formatted): String

def showSLRecordItem(key: Formatted, value: Formatted): FlatType

def showTuple(args: List[String]): String

def showType(tpe: scala.tools.nsc.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 showTypeBreak(tpe: scala.tools.nsc.Global.Type): String

val specialFormatters: List[Analyzer.SpecialFormatter]

def splitChains(errors: List[Analyzer.ImpFailReason]): List[List[Analyzer.ImpFailReason]]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def wrapParens(expr: String, top: Boolean): String

def wrapParensRepr(tpe: TypeRepr, top: Boolean): TypeRepr