Packages

  • package root
    Definition Classes
    root
  • package scala
    Definition Classes
    root
  • package tools
    Definition Classes
    scala
  • package nsc
    Definition Classes
    tools
  • package typechecker
    Definition Classes
    nsc
  • trait DestructureTypes extends AnyRef

    A generic means of breaking down types into their subcomponents.

    A generic means of breaking down types into their subcomponents. Types are decomposed top down, and recognizable substructure is dispatched via self-apparently named methods. Those methods can be overridden for custom behavior, but only the abstract methods require implementations, each of which must create some unknown "Node" type from its inputs.

    • wrapProduct create Node from a product of Nodes
    • wrapSequence create Node from a sequence of Nodes
    • wrapAtom create Node from an arbitrary value

    This is a work in progress.

    Definition Classes
    typechecker
  • DestructureType

trait DestructureType[Node] extends (Global.Type) ⇒ Node

Linear Supertypes
(Global.Type) ⇒ Node, AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. DestructureType
  2. Function1
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def withLabel(node: Node, label: String): Node
  2. abstract def withType(node: Node, typeName: String): Node
  3. abstract def wrapAtom[U](value: U): Node
  4. abstract def wrapEmpty: Node
  5. abstract def wrapMono(in: Node, out: Node): Node
  6. abstract def wrapPoly(in: Node, out: Node): Node
  7. abstract def wrapProduct(nodes: List[Node]): Node
  8. abstract def wrapSequence(nodes: List[Node]): Node

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def andThen[A](g: (Node) ⇒ A): (Global.Type) ⇒ A
    Definition Classes
    Function1
    Annotations
    @unspecialized()
  5. def annotatedType(annotations: List[Global.AnnotationInfo], underlying: Global.Type): Node
  6. def annotation(ann: Global.AnnotationInfo): Node
  7. def apply(tp: Global.Type): Node
    Definition Classes
    DestructureType → Function1
  8. def apply(label: String, tp: Global.Type): Node
  9. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  10. def atom[U](label: String, value: U): Node
  11. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  12. def compose[A](g: (A) ⇒ Global.Type): (A) ⇒ Node
    Definition Classes
    Function1
    Annotations
    @unspecialized()
  13. def constant(label: String, const: Global.Constant): Node
  14. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  15. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  16. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  17. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  18. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  19. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  20. def list(nodes: List[Node]): Node
  21. def monoFunction(params: List[Global.Symbol], restpe: Global.Type): Node
  22. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  23. def node(label: String, node: Node): Node
  24. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  25. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  26. def nullaryFunction(restpe: Global.Type): Node
  27. def parentList(tps: List[Global.Type]): Node
  28. def polyFunction(tparams: List[Global.Symbol], restpe: Global.Type): Node
  29. def prefix(pre: Global.Type): Node
  30. def product(typeName: String, nodes: Node*): Node
  31. def product(tp: Global.Type, nodes: Node*): Node
  32. def resultType(restpe: Global.Type): Node
  33. def scope(decls: Global.Scope): Node
  34. def symbolType(sym: Global.Symbol): String
  35. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  36. def toString(): String
    Definition Classes
    Function1 → AnyRef → Any
  37. def typeArgs(tps: List[Global.Type]): Node
  38. def typeBounds(lo0: Global.Type, hi0: Global.Type): Node
  39. def typeConstraint(constr: Global.TypeConstraint): Node
  40. def typeParams(tps: List[Global.Symbol]): Node
  41. def typeRef(tp: Global.TypeRef): Node

    This imposes additional structure beyond that which is visible in the case class hierarchy.

    This imposes additional structure beyond that which is visible in the case class hierarchy. In particular, (too) many different constructs are encoded in TypeRefs; here they are partitioned somewhat before being dispatched.

    For example, a typical type parameter is encoded as TypeRef(NoPrefix, sym, Nil) with its upper and lower bounds stored in the info of the symbol. Viewing the TypeRef naively we are treated to both too much information (useless prefix, usually empty args) and too little (bounds hidden behind indirection.) So drop the prefix and promote the bounds.

  42. def typeRefType(sym: Global.Symbol): String
  43. def valueParams(params: List[Global.Symbol]): Node
  44. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  45. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  46. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  47. def wrapSymbolInfo(sym: Global.Symbol): Node
  48. def wrapTree(tree: Global.Tree): Node

Inherited from (Global.Type) ⇒ Node

Inherited from AnyRef

Inherited from Any

Ungrouped