SelectiveCPSTransform

abstract val global: Global

abstract val runsAfter: List[String]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

lazy val Context: Symbol

lazy val MarkerCPSAdaptMinus: Symbol

lazy val MarkerCPSAdaptPlus: Symbol

lazy val MarkerCPSSym: Symbol

lazy val MarkerCPSSynth: Symbol

lazy val MarkerCPSTypes: Symbol

lazy val MethReify: Symbol

lazy val MethReifyR: Symbol

lazy val MethShift: Symbol

lazy val MethShiftR: Symbol

lazy val MethShiftUnit: Symbol

lazy val MethShiftUnit0: Symbol

lazy val MethShiftUnitR: Symbol

lazy val ModCPS: Symbol

lazy val allCPSAnnotations: List[Symbol]

def annTypes(ann: AnnotationInfo): (Type, Type)

final def asInstanceOf[T0]: T0

def changesBaseClasses: Boolean

This class does not change linearization

def clone(): AnyRef

var cpsEnabled: Boolean

object cpsNames extends AnyRef

def cpsParamAnnotation(tpe: Type): List[AnnotationInfo]

def cpsParamTypes(tpe: Type): Option[(Type, Type)]

def debuglog(s: ⇒ String): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filterAnnotations(tpe: Type, p: (AnnotationInfo) ⇒ Boolean): Type

def filterAttribs(tpe: Type, cls: Symbol): List[AnnotationInfo]

def finalize(): Unit

def getAnswerTypeAnn(tp: Type): Option[(Type, Type)]

final def getClass(): java.lang.Class[_]

def getExternalAnswerTypeAnn(tp: Type): Option[(Type, Type)]

def hasAnswerTypeAnn(tp: Type): Boolean

def hasCpsParamTypes(tpe: Type): Boolean

def hasMinusMarker(tpe: Type): Boolean

def hasPlusMarker(tpe: Type): Boolean

def hasSynthMarker(tpe: Type): Boolean

def hashCode(): Int

final val internal: Boolean(false)

final def isInstanceOf[T0]: Boolean

def keepsTypeParams: Boolean

def linearize(a: CPSInfo, b: CPSInfo)(implicit unit: CompilationUnit, pos: Position): CPSInfo

def linearize(ann: List[AnnotationInfo]): AnnotationInfo

def matches(annotationInfo: AnnotationInfo, clazz: Symbol): Boolean

final def ne(arg0: AnyRef): Boolean

def newCpsParamsMarker(tp1: Type, tp2: Type): AnnotationInfo

def newMarker(sym: Symbol): AnnotationInfo

def newMarker(tpe: Type): AnnotationInfo

def newMinusMarker(): AnnotationInfo

def newPhase(prev: Phase): StdPhase

def newPlusMarker(): AnnotationInfo

def newSynthMarker(): AnnotationInfo

def newTransformer(unit: CompilationUnit): Transformer

final def notify(): Unit

final def notifyAll(): Unit

def ownPhase: Phase

val phaseName: String

the following two members override abstract members in Transform

def phaseNewFlags: Long

def phaseNextFlags: Long

def removeAllCPSAnnotations(tpe: Type): Type

def removeAttribs(tpe: Type, classes: Symbol*): Type

val runsBefore: List[String]

val runsRightAfter: Option[String]

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

implicit def toAnnotationInfoOps(annObj: SelectiveCPSTransform.this.global.AnnotationInfo.type): AnnotationInfoOps

def toString(): String

implicit def toSymbolOps(sym: Symbol): SymbolOps

implicit def toTreeGenOps(gen: TreeGen): TreeGenOps

implicit def toTreeOps(from: Tree): TreeOps

implicit def toTypeOps(tpe: Type): TypeOps

def transformCPSType(tp: Type): Type

def transformInfo(sym: Symbol, tp: Type): Type

- return symbol's transformed type,

def updateSynthFlag(tree: Tree): Tree

val verbose: Boolean

def vprintln(x: ⇒ Any): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit