Enum DefKind 

#[non_exhaustive]
pub enum DefKind {
    Module,
    Fn,
    Const,
    Global,
    Record {
        unit: bool,
    },
    Sum,
    Class {
        mixin: bool,
    },
    Interface,
    Alias,
    AssocType,
    Variant {
        unit: bool,
    },
    Extern,
    Prim,
    Local,
    Err,
}

What kind of definition a resolution names, as far as scoping cares.

It decides which syntactic namespaces may name the definition (the table of HIR spec §3.3), whether a path may continue through it (Vec::new), and whether a bare identifier pattern matches it rather than binding.

Examples

use hir_lang::Ns;
use resolve_lang::DefKind;

assert!(DefKind::Fn.fits(Ns::Value));
assert!(!DefKind::Fn.fits(Ns::Type));
assert!(DefKind::Record { unit: false }.is_prefix());

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Module

A module (or a whole unit’s root module).

Fn

A function.

Const

A constant.

Global

A global variable.

Record

A record; unit for a record with no fields (struct Unit;).

Fields

unit: bool

The record has the unit shape.

Sum

A sum.

Class

A class; mixin for a PHP trait.

Fields

mixin: bool

The class is a mixin (never instantiated).

Interface

An interface.

Alias

A type alias.

AssocType

An associated type.

Variant

A sum variant; unit for a variant with no fields.

Fields

unit: bool

The variant has the unit shape.

Extern

A host or standard-library symbol.

Prim

A primitive type.

Local

A local binder (a variable, parameter, or generic parameter). Paths name binders through Res::Local; this kind appears in diagnostics.

Err

An error item (already reported).

Implementations

impl DefKind

pub const fn of_item(kind: &ItemKind) -> Option<Self>

The kind of a HIR item, or None for items that name nothing resolvable (impl, imports, mixin uses).

Examples

use hir_lang::{ItemKind, RecordDef, Shape};
use resolve_lang::DefKind;

let unit = ItemKind::Record(RecordDef { shape: Shape::Unit, ..RecordDef::default() });
assert_eq!(DefKind::of_item(&unit), Some(DefKind::Record { unit: true }));

pub const fn fits(self, ns: Ns) -> bool

Whether a fully resolved path in syntactic namespace ns may name a definition of this kind (HIR spec §3.3).

Examples

use hir_lang::Ns;
use resolve_lang::DefKind;

assert!(DefKind::Variant { unit: true }.fits(Ns::Pattern));
assert!(DefKind::Module.fits(Ns::Import));
assert!(!DefKind::Module.fits(Ns::Value));
assert!(DefKind::Prim.fits(Ns::Type));

pub const fn is_prefix(self) -> bool

Whether a path may continue past a definition of this kind, leaving the rest to type-directed or module resolution (a resolved prefix).

Examples

use resolve_lang::DefKind;

assert!(DefKind::Sum.is_prefix());
assert!(!DefKind::Fn.is_prefix());
assert!(!DefKind::Variant { unit: false }.is_prefix());

pub const fn is_pattern_constant(self) -> bool

Whether a bare identifier pattern naming this definition matches it (a constant, a unit variant, a unit record) instead of binding.

Examples

use resolve_lang::DefKind;

assert!(DefKind::Const.is_pattern_constant());
assert!(!DefKind::Variant { unit: false }.is_pattern_constant());

pub const fn name(self) -> &'static str

A short lowercase name, for messages.

Examples

use resolve_lang::DefKind;

assert_eq!(DefKind::Fn.name(), "function");

Trait Implementations

impl Clone for DefKind

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for DefKind

impl Debug for DefKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for DefKind

impl Hash for DefKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DefKind

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for DefKind