Best code snippets using scala.reflect.api.Symbols$SymbolApi.asClass(Showing top 10 results out of 315)

 case Block((cls: ClassDef) :: Nil, _) => cls
val tpe = checkedDef.symbol.asClass.toType
(checkedDef, tpe)

tpe.baseClasses exists { bc => !(bc == tpe.typeSymbol) && bc.asClass.isCaseClass } match {
def unapply(tpe: Type): Boolean = tpe.typeSymbol.asClass.isCaseClass
 tpe.typeSymbol.asClass.baseClasses exists {
  s => s.fullName == "org.apache.flink.types.Value"
 tpe.typeSymbol.asClass.baseClasses exists {
  s => s.fullName == "org.apache.hadoop.io.Writable"
def unapply(tpe: Type): Boolean = tpe.typeSymbol.asClass.isTrait
def unapply(tpe: Type): Boolean = tpe.typeSymbol.asClass.isJava
 val definingType = tpe.typeSymbol.asClass.baseClasses find {
  _.annotations.exists(_.tpe =:= typeOf[org.apache.flink.api.common.typeinfo.TypeInfo])

package sourcecode

object Compat{
 type Context = scala.reflect.macros.blackbox.Context
 def enclosingOwner(c: Context) = c.internal.enclosingOwner

 def enclosingParamList(c: Context): List[List[c.Symbol]] = {
  def nearestEnclosingMethod(owner: c.Symbol): c.Symbol =
   if (owner.isMethod) owner
   else if (owner.isClass) owner.asClass.primaryConstructor
   else nearestEnclosingMethod(owner.owner)

  nearestEnclosingMethod(enclosingOwner(c)).asMethod.paramLists
 }
}

case x if x.isPackage => Chunk.Pkg
case x if x.isModuleClass => Chunk.Obj
case x if x.isClass && x.asClass.isTrait => Chunk.Trt
case x if x.isClass => Chunk.Cls
case x if x.isMethod => Chunk.Def

val sym = T.tpe.typeSymbol.asClass
val designation = if (sym.isRoot) "root" else if (sym.isBranch) "branch" else if (sym.isLeaf) "leaf" else ???
val roots = sym.baseClasses.filter(_.isRoot)
else if (roots.length > 1) c.abort(c.enclosingPosition, s"multiple roots for a $designation: " + (roots.map(_.fullName).init.mkString(", ")) + " and " + roots.last.fullName)
val root = roots.headOption.getOrElse(NoSymbol)
sym.baseClasses.map(_.asClass).foreach{bsym =>
 val exempt =
  bsym.isModuleClass ||
 vals.foreach(v => ()) // TODO: deep immutability check
check(T.tpe.typeSymbol.asClass)
q"()"

 def inheritsFromAdt = sym.isClass && (sym.asClass.toType <:< typeOf[AdtMetadata.Adt])
 def isBookkeeping = sym.asClass == symbolOf[AdtMetadata.Adt] || sym.asClass == symbolOf[AstMetadata.Ast]
 inheritsFromAdt && !isBookkeeping
def branches: List[Symbol] = { sym.initialize; figureOutDirectSubclasses(sym.asClass).toList.filter(_.isBranch) }
def allBranches: List[Symbol] = (sym.branches ++ sym.branches.flatMap(_.allBranches)).distinct
def leafs: List[Symbol] = { sym.initialize; figureOutDirectSubclasses(sym.asClass).toList.filter(_.isLeaf).map(ensureModule) }
def allLeafs: List[Symbol] = (sym.leafs ++ sym.branches.flatMap(_.allLeafs)).map(ensureModule).distinct
def root: Symbol = sym.asClass.baseClasses.reverse.find(_.isRoot).getOrElse(NoSymbol)
def fields: List[Symbol] = allFields.filter(p => p.isPayload)
def allFields: List[Symbol] = sym.info.decls.filter(_.isField).toList
def parents = sym.asClass.baseClasses.filter(sym1 => sym1 != sym && sym1.isAdt).map(_.asAdt)
def <:< (other: Adt) = sym.asClass.toType <:< other.sym.asClass.toType
override def equals(that: Any) = that match {
 case that: Adt => this.sym == that.sym

} else if (classOf[Writable].isAssignableFrom(rtc)) {
 return writables(rtc.asInstanceOf[Class[Writable]]).asInstanceOf[PType[T]]
} else if (tpe.typeSymbol.asClass.isCaseClass) {
 return encache(tpe, products(tpe, mirror))
} else {

val subTypes = tpe.typeSymbol.asClass.knownDirectSubclasses.toList flatMap { d =>
   val tArgs = (tpe.typeSymbol.asClass.typeParams, typeArgs(tpe)).zipped.toMap
   val dArgs = d.asClass.typeParams map { dp =>
    val tArg = tArgs.keySet.find { tp => dp == tp.typeSignature.asSeenFrom(d.typeSignature, tpe.typeSymbol).typeSymbol }
 case Nil => {
  val (tParams, tArgs) = tpe.typeSymbol.asClass.typeParams.zip(typeArgs(tpe)).unzip
  val baseMembers = tpe.members filter { f => f.isMethod } filter { f => f.asMethod.isSetter } map {
   f => (f, f.asMethod.setter, normTpe(f.asMethod.returnType))
def unapply(tpe: Type): Boolean = tpe.typeSymbol.asClass.isCaseClass
def unapply(tpe: Type): Boolean = tpe.typeSymbol.asClass.isAbstractClass && tpe.typeSymbol.asClass.isSealed
def unapply(tpe: Type): Boolean = tpe.typeSymbol.asClass.baseClasses exists { s => s.fullName == "eu.stratosphere.types.Value" }

 case Block((cls: ClassDef) :: Nil, _) => cls
val tpe = checkedDef.symbol.asClass.toType
(checkedDef, tpe)

tpe.baseClasses exists { bc => !(bc == tpe.typeSymbol) && bc.asClass.isCaseClass } match {
def unapply(tpe: Type): Boolean = tpe.typeSymbol.asClass.isCaseClass
 tpe.typeSymbol.asClass.baseClasses exists {
  s => s.fullName == "org.apache.flink.types.Value"
 tpe.typeSymbol.asClass.baseClasses exists {
  s => s.fullName == "org.apache.hadoop.io.Writable"
def unapply(tpe: Type): Boolean = tpe.typeSymbol.asClass.isTrait
def unapply(tpe: Type): Boolean = tpe.typeSymbol.asClass.isJava
 val definingType = tpe.typeSymbol.asClass.baseClasses find {
  _.annotations.exists(_.tpe =:= typeOf[org.apache.flink.api.common.typeinfo.TypeInfo])