Packages

  • package root

    The Scala compiler and reflection APIs.

    The Scala compiler and reflection APIs.

    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

Source
DestructureTypes.scala
Linear Supertypes
(Global.Type) ⇒ Node, AnyRef, Any
Known Subclasses
intoNodes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. DestructureType
  2. Function1
  3. AnyRef
  4. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  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. def andThen[A](g: (Node) ⇒ A): (Global.Type) ⇒ A
    Definition Classes
    Function1
    Annotations
    @unspecialized()
  2. def annotatedType(annotations: List[Global.AnnotationInfo], underlying: Global.Type): Node
  3. def annotation(ann: Global.AnnotationInfo): Node
  4. def apply(tp: Global.Type): Node
    Definition Classes
    DestructureType → Function1
  5. def apply(label: String, tp: Global.Type): Node
  6. def atom[U](label: String, value: U): Node
  7. def compose[A](g: (A) ⇒ Global.Type): (A) ⇒ Node
    Definition Classes
    Function1
    Annotations
    @unspecialized()
  8. def constant(label: String, const: Global.Constant): Node
  9. def list(nodes: List[Node]): Node
  10. def monoFunction(params: List[Global.Symbol], restpe: Global.Type): Node
  11. def node(label: String, node: Node): Node
  12. def nullaryFunction(restpe: Global.Type): Node
  13. def parentList(tps: List[Global.Type]): Node
  14. def polyFunction(tparams: List[Global.Symbol], restpe: Global.Type): Node
  15. def prefix(pre: Global.Type): Node
  16. def product(typeName: String, nodes: Node*): Node
  17. def product(tp: Global.Type, nodes: Node*): Node
  18. def resultType(restpe: Global.Type): Node
  19. def scope(decls: Global.Scope): Node
  20. def symbolType(sym: Global.Symbol): String
  21. def toString(): String
    Definition Classes
    Function1 → AnyRef → Any
  22. def typeArgs(tps: List[Global.Type]): Node
  23. def typeBounds(lo0: Global.Type, hi0: Global.Type): Node
  24. def typeConstraint(constr: Global.TypeConstraint): Node
  25. def typeParams(tps: List[Global.Symbol]): Node
  26. 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.

  27. def typeRefType(sym: Global.Symbol): String
  28. def valueParams(params: List[Global.Symbol]): Node
  29. def wrapSymbolInfo(sym: Global.Symbol): Node
  30. def wrapTree(tree: Global.Tree): Node