laburnum 1.17.3

An LSP framework for building language servers and compilers, powered by an incremental query tree with content-addressed storage, task-based dataflow, and parallel queries.
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

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

use {
  crate::{
    Ident,
    database::storage::Partitions,
    hash::content::ContentHasher,
  },
  std::hash::{Hash, Hasher},
};

/// An opaque reference to a record by its index key (partition_key + sort_key).
///
/// Unlike `RecordHandle<P>` which references a CAS record by content hash,
/// `RecordKey` references a record by its position in the index. The sort key
/// is the typed [`Partitions::SortKey`] sum type (ADR0011) — never a string.
///
/// External consumers fetch the record with `get_record()`, pattern-match the
/// typed `sort_key()` to read structured fields, or derive a deterministic hash
/// with `key_ident()`. There is no string projection of the key.
pub struct RecordKey<P: Partitions> {
  partition_key: crate::SpannedIdent,
  sort_key: P::SortKey,
}

impl<P: Partitions> RecordKey<P> {
  pub(crate) fn new(
    partition_key: crate::SpannedIdent,
    sort_key: P::SortKey,
  ) -> Self {
    Self {
      partition_key,
      sort_key,
    }
  }

  /// Returns the partition key.
  pub(crate) fn partition_key(&self) -> Ident {
    self.partition_key.ident()
  }

  /// Returns the partition key with its span.
  pub(crate) fn partition_key_spanned(&self) -> crate::SpannedIdent {
    self.partition_key
  }

  /// Returns the typed sort key.
  ///
  /// Pattern-match the variant to read structured fields. There is deliberately
  /// no string form (ADR0011); to render for humans, use
  /// [`PartitionSortKey::resolve`](crate::database::partitions::PartitionSortKey::resolve)
  /// with a resolver.
  pub fn sort_key(&self) -> &P::SortKey {
    &self.sort_key
  }

  /// Fetch the record from the database using a query client.
  pub async fn get_record(
    &self,
    query_client: &mut impl crate::database::query::QueryReads<Storage = P>,
  ) -> crate::database::query_results::QueryResults<P> {
    query_client
      .get_record(self.partition_key, self.sort_key.clone())
      .await
  }

  /// Derive a deterministic `Ident` from the key's structural content.
  ///
  /// Hashes the typed key via its `Hash` impl — no string round-trip.
  pub fn key_ident(&self) -> Ident {
    let mut hasher = ContentHasher::new();
    self.partition_key.hash(&mut hasher);
    self.sort_key.hash(&mut hasher);
    hasher.finish_ident()
  }
}

impl<P: Partitions> Clone for RecordKey<P> {
  fn clone(&self) -> Self {
    Self {
      partition_key: self.partition_key,
      sort_key: self.sort_key.clone(),
    }
  }
}

impl<P: Partitions> PartialEq for RecordKey<P> {
  fn eq(&self, other: &Self) -> bool {
    self.partition_key == other.partition_key && self.sort_key == other.sort_key
  }
}

impl<P: Partitions> Eq for RecordKey<P> {}

impl<P: Partitions> Hash for RecordKey<P> {
  fn hash<H: Hasher>(&self, state: &mut H) {
    self.partition_key.hash(state);
    self.sort_key.hash(state);
  }
}

impl<P: Partitions> std::fmt::Debug for RecordKey<P> {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    // The sort key has no string/Debug form (ADR0011); show only the partition.
    f.debug_struct("RecordKey")
      .field("partition_key", &self.partition_key)
      .finish_non_exhaustive()
  }
}