tastyquery

In-memory representation of the contents of classpaths.

Container for top-level definitions related to contexts.

See Contexts.Context for more details.

Source language of a symbol.

The offsets part of a full position, consisting of 2 or 3 entries:

• start: the start offset of the span, in characters from start of file
• end : the end offset of the span
• point: if given, the offset where a single ^ would be logically placed

Spans are encoded according to the following format in little endian: Start: unsigned 26 Bits (works for source files up to 64M) End: unsigned 26 Bits Point: unsigned 12 Bits relative to start NoSpan encoded as -1L (this is a normally invalid span because point would lie beyond end).

Symbols for all kinds of definitions in Scala programs.

Every definition, like classes, defs, types and type parameters, is associated with a Symbol. Symbols are organized in a hierarchy, depending on what kind of definitions they represent.

Symbol
|
+- PackageSymbol                   any package, including the root package, the empty package, and nested packages
|
+- TermOrTypeSymbol                   any term or type symbol, i.e., not a package
   |
   +- TermSymbol                      any term definition:
   |                                  `val`, `var`, `def`, term param, term capture, `object` value
   |
   +- TypeSymbol                      any definition for a type
      +- ClassSymbol                  definition for a `class`, `trait`, or the module class of an `object`
      +- TypeSymbolWithBounds         any other kind of type: `type` definitions, type params, type captures
         +- TypeMemberSymbol          `type` definition, further refined through its `typeDef`
         +- TypeParamSymbol
            +- ClassTypeParamSymbol   type parameter of a class
            +- LocalTypeParamSymbol   any other type parameter

Additionally, PackageSymbol and ClassSymbol extend DeclaringSymbol. Declaring symbols are the ones that contain declarations, which can be looked up with their names.

TypeMemberSymbols exist in 3 flavors, indicated by their typeDef field, of type TypeMemberDefinition:

• TypeAlias(alias): type alias of the form type T = alias
• AbstractType(bounds): abstract type member of the form type T >: bounds.low <: bounds.high
• OpaqueTypeAlias(bounds, alias): opaque type alias of the form type T >: bounds.low <: bounds.high = alias

The main property a TermSymbol is its declaredType, which is a Type. All TypeSymbolWithBounds have bounds of type TypeBounds, which are often used as their primary characteristic. ClassSymbols are entirely defined by themselves.

With the exception of the root package symbol, all symbols have an owner which is another Symbol.

All symbols also have a name. It is a TypeName for TypeSymbols, and a TermName for TermSymbols and PackageSymbols.

Types in the Scala type system.

Every type from the Scala type system is represented in tasty-query as an instance of Type. That abstract class has a number of subtypes for all the possible "shapes" of types.

For example, a reference to the class scala.Int is represented as

TypeRef(PackageRef("scala"), TypeName("Int"))

Type applications of the form C[T1, ..., Tn] are represented as

AppliedType(typeForC, List(typeForT1, ..., typeForTn))

etc.

The full hierarchy is organized as follows:

Type
|
+- WildcardTypeBounds         `? >: L <: H`
|
+- TermType                   a type that can be the type of a term tree
   |
   +- PackageRef              a reference to a package (typically used as `prefix` of `NamedType`s)
   |
   +- MethodicType            types of methods
   |  +- MethodType           `(termParams): resultType`
   |  +- PolyType             `[TypeParams]: resultType`
   |
   +- ValueType               a type that can be the type of a run-time value or type lambda,
      |                       i.e., what the spec calls a regular *type*
      +- NamedType
      |  +- TypeRef           type selection of the form `prefix.T`
      |  +- TermRef           term selection of the form `prefix.t`
      +- AppliedType          `C[T1, ..., Tn]`
      +- ByNameType            type of a by-name parameter `=> T`
      +- ThisType             `C.this`
      +- OrType               `A | B`
      +- AndType              `A & B`
      +- TypeLambda           `[T1, ..., Tn] => R`
      +- TypeParamRef         reference to a type parameter of an enclosing `TypeLambda` or `PolyType`
      +- TermParamRef         reference to a term parameter of an enclosing `MethodType`
      +- AnnotatedType        `T @annotation`
      +- ConstantType         literal singleton type, such as `42` or `"foo"`
      +- MatchType            `T match { case ... }`
      +- RefinedType
      |  +- TypeRefinement    `P { type T >: L <: H }`
      |  +- TermRefinement    `P { val/def t: T }`
      +- RecType              recursive type that introduces a recursive `this` binding
      +- RecThis              recursive reference to the `this` of a `RecType`
      +- SuperType            `super[mix]` (typically used as `prefix` of `NamedType`s)

Common shapes of types can be constructed with properties of Symbols.Symbol and with combinator methods on Type:

• typeSymbol.staticRef constructs a TypeRef to the given static typeSymbol
• termSymbol.staticRef constructs a TermRef to the given static termSymbol
• tpe1.appliedTo(tpe2) constructs the application tpe1[tpe2] (there is an overload that accepts a list of type arguments)
• tpe1 | tpe2 constructs a union type
• tpe1 & tpe2 constructs an intersection type