NirGenPhase

abstract val nirAddons: NirGlobalAddons { val global: NirGenPhase.this.global.type }

Not for use in the constructor body: only initialized afterwards.

abstract val runsAfter: List[String]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object SAMFunctionAttachCompat

object SAMFunctionAttachCompatDef

lazy val SAMFunctionCompat: SAMFunction.type

object SimpleType extends Serializable

final def afterOwnPhase[T](op: ⇒ T): T

final def asInstanceOf[T0]: T0

final def beforeOwnPhase[T](op: ⇒ T): T

def clone(): AnyRef

val curClassFresh: ScopedVar[Fresh]

val curClassSym: ScopedVar[G.Symbol]

val curFresh: ScopedVar[Fresh]

val curMethodEnv: ScopedVar[MethodEnv]

val curMethodInfo: ScopedVar[CollectMethodInfo]

val curMethodIsExtern: ScopedVar[Boolean]

val curMethodSig: ScopedVar[Type]

val curMethodSym: ScopedVar[G.Symbol]

val curMethodThis: ScopedVar[Option[Val]]

val curStatBuffer: ScopedVar[StatBuffer]

val curUnwindHandler: ScopedVar[Option[Local]]

def description: String

def enabled: Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def genAnonName(owner: G.Symbol, anon: G.Symbol): Member

def genArrayCode(st: SimpleType): Char

def genBoxType(st: SimpleType): Type

def genExternMethodSig(sym: G.Symbol): nir.Type.Function

def genExternType(st: SimpleType): Type

def genFieldName(sym: G.Symbol): Global

def genFuncPtrExternForwarderName(ownerSym: G.Symbol): Global

def genIRFile(path: Path, defns: Seq[Defn]): Unit

def genMethodName(sym: G.Symbol): Global

def genMethodSig(sym: G.Symbol): nir.Type.Function

def genName(sym: G.Symbol): Global

def genParamSyms(dd: G.DefDef, isStatic: Boolean): Seq[Option[G.Symbol]]

def genPathFor(cunit: G.CompilationUnit, id: String): Path

def genPathFor(cunit: G.CompilationUnit, ownerName: Global): Path

def genPrimCode(st: SimpleType): Char

def genRefType(st: SimpleType): Type

def genStruct(st: SimpleType): Type

def genStructFields(st: SimpleType): Seq[Type]

def genType(st: SimpleType): Type

def genTypeName(sym: G.Symbol): Top

def genTypeValue(st: SimpleType): Val

final def getClass(): Class[_]

val global: G

def hashCode(): Int

val initial: Boolean

final val internal: Boolean(false)

def isImplClass(sym: G.Symbol): Boolean

final def isInstanceOf[T0]: Boolean

val isScala211: Boolean

def isStaticModule(sym: G.Symbol): Boolean

final def ne(arg0: AnyRef): Boolean

def newPhase(prev: Phase): StdPhase

final def notify(): Unit

final def notifyAll(): Unit

def ownPhase: Phase

val phaseName: String

def phaseNewFlags: Long

def phaseNextFlags: Long

val reflectiveInstantiationInfo: UnrolledBuffer[ReflectiveInstantiationBuffer]

val requires: List[String]

val runsBefore: List[String]

val runsRightAfter: Option[String]

lazy val scalaUsesImplClasses: Boolean

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

val terminal: Boolean

implicit def toNirPosition(pos: G.Position): Position

def toString(): String

def unwind(implicit fresh: Fresh): Next

def unwrapClassTag(tree: G.Tree): G.Symbol

def unwrapClassTagOption(tree: G.Tree): Option[G.Symbol]

def unwrapTag(tree: G.Tree): SimpleType

def unwrapTagOption(tree: G.Tree): Option[SimpleType]

final def wait(): Unit

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

final def wait(arg0: Long): Unit