symbolique 0.1.1

Symbol table pipeline for language servers — parse, link, merge, and resolve symbols across files, built on the laburnum LSP framework.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

// Copyright Two Neutron Stars Incorporated and contributors
// SPDX-License-Identifier: BlueOak-1.0.0

//! Resolution partition.
//!
//! Stage 4 of the symbolique pipeline. Resolution maps references to their
//! target definitions:
//!
//! - **SymbolResolution**: Index-only partition with `ResolutionEntry` entries
//!   pointing to target definitions in the shared `Symbols` partition
//!
//! Resolution algorithms are user-defined - symbolique provides the partition
//! for storing results. No new shapes are created; resolution links existing
//! Reference/Import shapes to existing Definition shapes.

use {
  super::records::ResolutionEntry,
  crate::core::{
    Ident, SymbolPath, SymbolVisibility, Value, Visibility,
  },
  laburnum::{
    Ident as LaburnumIdent,
    database::{Partition, PartitionKey},
  },
  std::marker::PhantomData,
};

/// Symbol resolution partition (index-only).
///
/// Stores only index entries that reference target definitions in the shared
/// `Symbols` partition. Each entry contains the target path and a handle to
/// the target symbol shape.
pub struct SymbolResolution<V, I, P, S = SymbolVisibility>(
  PhantomData<(V, I, P, S)>,
);

impl<V, I, P, S> Default for SymbolResolution<V, I, P, S> {
  fn default() -> Self {
    Self(PhantomData)
  }
}

impl<V, I, P, S> Clone for SymbolResolution<V, I, P, S> {
  fn clone(&self) -> Self {
    *self
  }
}

impl<V, I, P, S> Copy for SymbolResolution<V, I, P, S> {}

impl<V, I, P, S> std::fmt::Debug for SymbolResolution<V, I, P, S> {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    f.debug_struct("SymbolResolution").finish()
  }
}

impl<V, I, P, S> PartitionKey for SymbolResolution<V, I, P, S>
where
  V: Value<I>,
  I: Ident,
  P: SymbolPath,
  S: Visibility,
{
  const KEY: LaburnumIdent = LaburnumIdent::new("symbolique::resolution");
}

impl<V, I, P, S> Partition for SymbolResolution<V, I, P, S>
where
  V: Value<I>,
  I: Ident,
  P: SymbolPath,
  S: Visibility,
{
  type Record = (); // Index-only
  type IndexEntry = ResolutionEntry<V, I, P, S>;
  type SortKey = P;
}

#[cfg(test)]
mod tests {
  use super::*;

  #[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
  struct TestPath(String);

  impl laburnum::PartitionSortKey for TestPath {
    fn is_prefix_of(&self, other: &Self) -> bool {
      other.0.starts_with(&self.0)
    }

    fn resolve(&self, _resolver: &dyn laburnum::SourceResolver) -> String {
      self.0.clone()
    }
  }

  #[test]
  fn symbol_resolution_partition_key() {
    use crate::core::{DefaultValue, StringIdent};

    let _key = SymbolResolution::<DefaultValue, StringIdent, TestPath>::KEY;
  }

  #[test]
  fn symbol_resolution_is_index_only() {
    use crate::core::{DefaultValue, StringIdent};

    fn assert_record_is_unit<P: Partition<Record = ()>>() {}

    assert_record_is_unit::<
      SymbolResolution<DefaultValue, StringIdent, TestPath>,
    >();
  }
}