Enum SymbolKind 

pub enum SymbolKind {
    Package,
    Class,
    Role,
    Subroutine,
    Method,
    Variable(VarKind),
    Constant,
    Import,
    Export,
    Label,
    Format,
}

Symbol extraction, table, and reference types for navigation. Unified Perl symbol classification for LSP tooling.

This enum represents all meaningful symbol types in Perl code, designed to be the canonical taxonomy across all crates in the perl-lsp ecosystem.

LSP Protocol Mapping

Each variant maps to an LSP SymbolKind number via Self::to_lsp_kind():

Variant	LSP Kind	Number	Description
Package	Module	2	Package declaration
Class	Class	5	OO class (Moose, Moo, class keyword)
Role	Interface	8	Role definition (Moose::Role)
Subroutine	Function	12	Standalone subroutine
Method	Method	6	OO method
Variable(_)	Variable	13	Variables (scalar, array, hash)
Constant	Constant	14	use constant or Readonly
Import	Module	2	Imported symbol
Export	Function	12	Exported symbol
Label	Key	20	Loop/block label
Format	Struct	23	format declaration

Variants

Package

Package declaration (package Foo;)

Class

OO class declaration (class keyword, Moose, Moo)

Role

Role definition (role keyword, Moose::Role)

Subroutine

Subroutine definition (sub name { })

Method

Method definition in OO context

Variable(VarKind)

Variable declaration with sigil-based container type

Constant

Constant value (use constant NAME => value)

Import

Imported symbol from use statement

Export

Exported symbol via Exporter

Label

Loop/block label (LABEL: while ...)

Format

Format declaration (format STDOUT =)

Implementations

impl SymbolKind

pub const fn to_lsp_kind(self) -> u32

Convert to LSP-compliant symbol kind number (workspace profile).

Maps Perl symbol types to the closest LSP protocol equivalents. This is the default mapping used for workspace symbols where a generic “Variable” kind is appropriate for all variable types.

See the enum documentation for the full mapping table.

pub const fn to_lsp_kind_document_symbol(self) -> u32

Convert to LSP symbol kind with richer variable type distinctions.

This mapping provides a richer UI experience for document symbols by distinguishing between scalar, array, and hash variables:

Variable Type	LSP Kind	Number	Icon
Scalar ($)	Variable	13	generic variable
Array (@)	Array	18	array/list icon
Hash (%)	Object	19	object/dict icon

Use this for document symbol providers where visual distinction of variable types improves navigation.

pub const fn sigil(self) -> Option<&'static str>

Returns the sigil for this symbol kind if applicable.

Only variable symbols have sigils; all other symbols return None.

Examples

use perl_symbol_types::{SymbolKind, VarKind};

assert_eq!(SymbolKind::Variable(VarKind::Scalar).sigil(), Some("$"));
assert_eq!(SymbolKind::Variable(VarKind::Array).sigil(), Some("@"));
assert_eq!(SymbolKind::Subroutine.sigil(), None);

pub const fn is_variable(self) -> bool

Returns true if this is any variable type.

pub const fn is_callable(self) -> bool

Returns true if this is a callable type (subroutine or method).

pub const fn is_namespace(self) -> bool

Returns true if this is a namespace type (package, class, or role).

pub const fn scalar() -> SymbolKind

Create a scalar variable symbol kind.

pub const fn array() -> SymbolKind

Create an array variable symbol kind.

pub const fn hash() -> SymbolKind

Create a hash variable symbol kind.

Trait Implementations

impl Clone for SymbolKind

fn clone(&self) -> SymbolKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SymbolKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SymbolKind

fn deserialize<__D>( __deserializer: __D, ) -> Result<SymbolKind, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for SymbolKind

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

where __H: Hasher,

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 SymbolKind

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SymbolKind

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for SymbolKind

impl Eq for SymbolKind

impl StructuralPartialEq for SymbolKind