calcit 0.13.4

Interpreter and js codegen for Calcit
Documentation 
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
114
115
116
117
118
119

use std::{
  hash::{Hash, Hasher},
  sync::Arc,
};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CalcitSymbolInfo {
  pub at_ns: Arc<str>,
  pub at_def: Arc<str>,
}

/// defRule: ns def
#[derive(Debug, Clone, PartialOrd, Ord)]
pub enum ImportInfo {
  /// ns imported via `:as`
  NsAs {
    at_ns: Arc<str>,
    at_def: Arc<str>,
    alias: Arc<str>,
  },
  /// (ns, def) imported via `:refer`
  NsReferDef { at_ns: Arc<str>, at_def: Arc<str> },
  /// used from calcit.core , forget about at_def for now
  Core { at_ns: Arc<str> },
  /// ns imported via `:default`, js only
  JsDefault {
    /// variable name used in code
    alias: Arc<str>,
    at_ns: Arc<str>,
    at_def: Arc<str>,
  },
  /// use def from same file
  SameFile { at_def: Arc<str> },
}

impl Hash for ImportInfo {
  fn hash<H: Hasher>(&self, state: &mut H) {
    match self {
      ImportInfo::NsAs { at_ns, alias, .. } => {
        "as".hash(state);
        at_ns.hash(state);
        alias.hash(state);
      }
      ImportInfo::NsReferDef { at_ns, .. } => {
        "refer".hash(state);
        at_ns.hash(state);
      }
      ImportInfo::Core { at_ns } => {
        "core".hash(state);
        at_ns.hash(state);
      }
      ImportInfo::JsDefault { at_ns, alias, .. } => {
        "js-default".hash(state);
        at_ns.hash(state);
        alias.hash(state);
      }
      ImportInfo::SameFile { .. } => {
        "same-file".hash(state);
      }
    }
  }
}

/// compare at namespace level, ignore at_def
impl PartialEq for ImportInfo {
  fn eq(&self, other: &Self) -> bool {
    match (self, other) {
      (ImportInfo::NsAs { at_ns: a, alias: b, .. }, ImportInfo::NsAs { at_ns: c, alias: d, .. }) => a == c && b == d,
      (ImportInfo::NsReferDef { at_ns: a, .. }, ImportInfo::NsReferDef { at_ns: b, .. }) => a == b,
      (ImportInfo::Core { at_ns: a }, ImportInfo::Core { at_ns: b }) => a == b,
      (ImportInfo::JsDefault { at_ns: a, alias: b, .. }, ImportInfo::JsDefault { at_ns: c, alias: d, .. }) => a == c && b == d,
      (ImportInfo::SameFile { .. }, ImportInfo::SameFile { .. }) => true,
      _ => false,
    }
  }
}

impl Eq for ImportInfo {}

#[derive(Debug, Clone, PartialOrd, Ord)]
pub struct CalcitImport {
  /// real namespace
  /// detects string syntax for npm package
  pub ns: Arc<str>,
  /// real def
  /// from npm package, use `default` and asterisk in js
  pub def: Arc<str>,
  pub info: Arc<ImportInfo>,
  pub def_id: Option<u32>,
}

/// compare at namespace level, ignore at_def
impl PartialEq for CalcitImport {
  fn eq(&self, other: &Self) -> bool {
    match (&*self.info, &*other.info) {
      // duplication of NsAs handled specially
      (ImportInfo::NsAs { alias, .. }, ImportInfo::NsAs { alias: a2, .. }) => alias == a2 && self.ns == other.ns,
      _ => self.ns == other.ns && self.info == other.info && self.def == other.def,
    }
  }
}

impl Eq for CalcitImport {}

impl Hash for CalcitImport {
  fn hash<H: Hasher>(&self, state: &mut H) {
    match &*self.info {
      ImportInfo::NsAs { alias, .. } => {
        self.ns.hash(state);
        alias.hash(state);
      }
      _ => {
        self.ns.hash(state);
        // ignores different in def
        self.info.hash(state);
      }
    }
  }
}