Struct CodeChunk 

pub struct CodeChunk {
    pub file_path: String,
    pub name: String,
    pub kind: String,
    pub content_kind: ContentKind,
    pub start_line: usize,
    pub end_line: usize,
    pub symbol_line: usize,
    pub content: String,
    pub enriched_content: String,
    pub qualified_name: Option<String>,
}

A semantic chunk extracted from a source file.

Fields

file_path: String

Path to the source file.

name: String

Name of the definition (function name, class name, etc.).

kind: String

Kind of syntax node (e.g., function_item, class_definition). For chunks emitted from the dense.rs semble path, this is the LSP SymbolKind numeric value serialized as a string (e.g., "12" for Function). For chunks emitted from chunk.rs’s query-based path, this is the raw tree-sitter node kind string. Downstream consumers should call crate::languages::lsp_symbol_kind_for_node_kind to normalize.

content_kind: ContentKind

High-level content category derived from the file extension.

Set by the chunker at emission time. Downstream filters (e.g., find_duplicates, get_repo_map) use this to exclude ContentKind::Meta files from code-centric queries by default.

start_line: usize

1-based start line number (first line of the chunk, which may be a doc-comment line preceding the symbol’s identifier).

end_line: usize

1-based end line number.

symbol_line: usize

1-based line number of the symbol’s name-identifier token within this chunk. For tree-sitter query-based chunks (chunk_file), this is the exact line where the @name capture appears, so LSP tools that jump to lsp_location.start_line land on the identifier rather than on a preceding doc-comment line.

Defaults to start_line for chunks produced by the sliding-window fallback, the semble/dense path, and RDF-block paths, where the name-identifier line is not separately tracked.

Convention matches start_line: 1-based, relative to the file’s first line.

content: String

Source text of the chunk (raw code for display).

enriched_content: String

Enriched content with scope chain and signature metadata for embedding. Falls back to content if metadata would exceed chunk size limits.

qualified_name: Option<String>

Optional language-specific composite identifier that disambiguates a symbol whose bare name is shared across many declarations.

For HCL: resource "aws_iam_role" "loader" { ... } ships name = "loader" and qualified_name = Some("aws_iam_role.loader"). Each local.X = ... extracted as its own chunk ships qualified_name = Some("local.X"). Workspace symbol consumers surface qualified_name when set so a query for the composite form finds the right resource on corpora that reuse names like loader across many resource types (R1, R6, Wave 3).

None for all non-HCL chunks today; reserved for future language-specific composite naming.

Trait Implementations

impl Archive for CodeChunk

where String: Archive, ContentKind: Archive, usize: Archive, Option<String>: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedCodeChunk

The archived representation of this type.

type Resolver = CodeChunkResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for CodeChunk

fn clone(&self) -> CodeChunk

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CodeChunk

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<CodeChunk, __D> for Archived<CodeChunk>

where String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, ContentKind: Archive, <ContentKind as Archive>::Archived: Deserialize<ContentKind, __D>, usize: Archive, <usize as Archive>::Archived: Deserialize<usize, __D>, Option<String>: Archive, <Option<String> as Archive>::Archived: Deserialize<Option<String>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<CodeChunk, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for CodeChunk

where String: Serialize<__S>, ContentKind: Serialize<__S>, usize: Serialize<__S>, Option<String>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<'__de> Decode<'__de> for CodeChunk

where '__de:,

impl Encode for CodeChunk