WhiteboxMacroUtils

abstract val c: Context

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def DirectOnly: MacroUtils.DirectOnly.type

final def Everything: MacroUtils.Everything.type

final def LeavesOnly: MacroUtils.LeavesOnly.type

def LitNil: scala.reflect.macros.Universe.Ident

final def asInstanceOf[T0]: T0

implicit def autoTypeOrTree1(t: scala.reflect.macros.Universe.Type): TypeOrTree

implicit def autoTypeOrTree2(t: scala.reflect.macros.Universe.Tree): TypeOrTree

final def caseClassType[T](implicit arg0: scala.reflect.macros.whitebox.Context.WeakTypeTag[T]): scala.reflect.macros.Universe.Type

def clone(): AnyRef

final def concreteWeakTypeOf[T](implicit arg0: scala.reflect.macros.whitebox.Context.WeakTypeTag[T]): scala.reflect.macros.Universe.Type

final def crawlADT[A](tpe: scala.reflect.macros.Universe.Type, attempt: (scala.reflect.macros.Universe.ClassSymbol, scala.reflect.macros.Universe.Type) ⇒ Option[A], giveUp: (scala.reflect.macros.Universe.ClassSymbol, scala.reflect.macros.Universe.Type) ⇒ TraversableOnce[A]): Vector[A]

def determineAdtType(root: scala.reflect.macros.Universe.Type, t: scala.reflect.macros.Universe.ClassSymbol): scala.reflect.macros.Universe.Type

findConcreteTypes will spit out type constructors.

def deterministicOrderC(ts: TraversableOnce[scala.reflect.macros.Universe.ClassSymbol]): Vector[scala.reflect.macros.Universe.ClassSymbol]

def deterministicOrderT(ts: TraversableOnce[scala.reflect.macros.Universe.Type]): Vector[scala.reflect.macros.Universe.Type]

final def ensureCaseClass(t: scala.reflect.macros.Universe.Type): Unit

final def ensureConcrete(t: scala.reflect.macros.Universe.Type): Unit

final def ensureValidAdtBase(tpe: scala.reflect.macros.Universe.Type): scala.reflect.macros.Universe.ClassSymbol

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def excludeNamedParams(exclusions: Seq[String], data: List[(scala.reflect.macros.Universe.TermName, scala.reflect.macros.Universe.Type)]): List[(scala.reflect.macros.Universe.TermName, scala.reflect.macros.Universe.Type)]

def extractStaticAnnotationArgs: List[scala.reflect.macros.Universe.Tree]

final def fail(msg: String): Nothing

def finalize(): Unit

final def findConcreteAdtTypes(tpe: scala.reflect.macros.Universe.Type, f: FindSubClasses): Vector[scala.reflect.macros.Universe.Type]

final def findConcreteAdtTypesNE(tpe: scala.reflect.macros.Universe.Type, f: FindSubClasses): Vector[scala.reflect.macros.Universe.Type]

final def findConcreteTypes(tpe: scala.reflect.macros.Universe.Type, f: FindSubClasses): Vector[scala.reflect.macros.Universe.ClassSymbol]

Constraints: - Type must be sealed.

final def findConcreteTypesNE(tpe: scala.reflect.macros.Universe.Type, f: FindSubClasses): Vector[scala.reflect.macros.Universe.ClassSymbol]

final def fixAdtTypeForCaseDef(t: scala.reflect.macros.Universe.Type): scala.reflect.macros.Universe.Tree

Sometimes using a type directly in a clause like "case _: $t => ...", causes spurious exhaustiveness warnings.

final def flattenBlocks(trees: List[scala.reflect.macros.Universe.Tree]): Vector[scala.reflect.macros.Universe.Tree]

final def getClass(): Class[_]

def hashCode(): Int

def identityExpr[T](implicit arg0: scala.reflect.macros.whitebox.Context.WeakTypeTag[T]): scala.reflect.macros.whitebox.Context.Expr[(T) ⇒ T]

final def isInstanceOf[T0]: Boolean

implicit val liftInit: scala.reflect.macros.Universe.Liftable[Init]

final def lowerCaseHead(s: String): String

final def modStringHead(s: String, f: (Char) ⇒ Char): String

final def nameAndType(T: scala.reflect.macros.Universe.Type, s: scala.reflect.macros.Universe.Symbol): NameAndType

final def ne(arg0: AnyRef): Boolean

final def needInferImplicit(t: scala.reflect.macros.Universe.Type): scala.reflect.macros.Universe.Tree

final def notify(): Unit

final def notifyAll(): Unit

final def primaryConstructorParams(t: scala.reflect.macros.Universe.Type): List[scala.reflect.macros.Universe.Symbol]

final def primaryConstructorParamsExcluding(t: scala.reflect.macros.Universe.Type, exclusions: Seq[scala.reflect.macros.whitebox.Context.Expr[Symbol]]): List[(scala.reflect.macros.Universe.TermName, scala.reflect.macros.Universe.Type)]

final def primaryConstructorParams_require1(t: scala.reflect.macros.Universe.Type): scala.reflect.macros.Universe.Symbol

final def primaryConstructorParams_require2(t: scala.reflect.macros.Universe.Type): (scala.reflect.macros.Universe.Symbol, scala.reflect.macros.Universe.Symbol)

def propagateTypeParams(root0: scala.reflect.macros.Universe.Type, child: scala.reflect.macros.Universe.ClassSymbol): scala.reflect.macros.Universe.Type

propagateTypeParams(Either[Int, Long], Right) -> Right[Long]

final def readMacroArg_boolean(e: scala.reflect.macros.whitebox.Context.Expr[Boolean]): Boolean

final def readMacroArg_string(e: scala.reflect.macros.whitebox.Context.Expr[String]): String

final def readMacroArg_stringString(e: scala.reflect.macros.whitebox.Context.Expr[(String, String)]): (String, scala.reflect.macros.Universe.Literal)

final def readMacroArg_symbol(e: scala.reflect.macros.whitebox.Context.Expr[Symbol]): String

final def readMacroArg_symbolBoolean(e: scala.reflect.macros.whitebox.Context.Expr[(Symbol, Boolean)]): (String, Boolean)

final def readMacroArg_symbolString(e: scala.reflect.macros.whitebox.Context.Expr[(Symbol, String)]): (String, scala.reflect.macros.Universe.Literal)

final def readMacroArg_tToLitFn[T, V](e: scala.reflect.macros.whitebox.Context.Expr[(T) ⇒ V])(implicit arg0: Manifest[V]): List[(Either[scala.reflect.macros.Universe.Select, scala.reflect.macros.Universe.Type], scala.reflect.macros.Universe.Literal)]

final def readMacroArg_tToTree[T, V](e: scala.reflect.macros.whitebox.Context.Expr[(T) ⇒ V]): List[(Either[scala.reflect.macros.Universe.Select, scala.reflect.macros.Universe.Type], scala.reflect.macros.Universe.Tree)]

def replaceEmptyBodyInAnnotatedObject(annottees: Seq[scala.reflect.macros.whitebox.Context.Expr[Any]])(newBody: List[scala.reflect.macros.Universe.Tree]): scala.reflect.macros.Universe.Tree

final def replaceMacroMethod(newMethod: String): scala.reflect.macros.Universe.Select

final def selectFQN(s: String, lastIsType: Boolean): scala.reflect.macros.Universe.RefTree

final def sep: String

def showUnorderedTypes(ts: Set[scala.reflect.macros.Universe.Type]): String

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

final def tcApplyFn(t: scala.reflect.macros.Universe.Type): scala.reflect.macros.Universe.Select

Create code for a function that will call .apply() on a given type's type companion object.

final def toSelectFQN(t: scala.reflect.macros.Universe.TypeSymbol): scala.reflect.macros.Universe.RefTree

def toString(): String

final def tryInferImplicit(t: scala.reflect.macros.Universe.Type): Option[scala.reflect.macros.Universe.Tree]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def warn(msg: String): Unit