lispexp 0.6.0

A pure-Rust reader (lexer + parser) for S-expression syntax across many Lisp dialects
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Dispatch/method form annotation (ADR-0021).

use lispexp::annotate::{annotate_form, bundled_registry, Role};
use lispexp::{parse, DatumKind, Dialect, Options};

fn annotate<'a>(
    src: &'a str,
    dialect: Dialect,
) -> (Vec<lispexp::Datum<'a>>, lispexp::annotate::Registry) {
    let data = parse(src, &Options::for_dialect(dialect)).data;
    (data, bundled_registry(dialect))
}

#[test]
fn cl_defmethod_with_qualifier_and_specializers() {
    let (data, reg) = annotate(
        "(cl-defmethod foo :around ((x integer) (y string)) (bar))",
        Dialect::EmacsLisp,
    );
    let a = annotate_form(&data[0], &reg).unwrap();

    assert_eq!(a.first(Role::Name).unwrap().kind, DatumKind::Symbol("foo"));

    // The qualifier `:around` is read as a token between name and arglist.
    let quals: Vec<_> = a.all(Role::Qualifier).collect();
    assert_eq!(quals.len(), 1);
    assert_eq!(quals[0].kind, DatumKind::Keyword(":around"));

    // The specialized arglist splits into (variable, specializer) pairs.
    let params = a.specialized_params();
    assert_eq!(params.len(), 2);
    assert_eq!(params[0].variable.kind, DatumKind::Symbol("x"));
    assert_eq!(
        params[0].specializer.unwrap().kind,
        DatumKind::Symbol("integer")
    );
    assert_eq!(params[1].variable.kind, DatumKind::Symbol("y"));
    assert_eq!(
        params[1].specializer.unwrap().kind,
        DatumKind::Symbol("string")
    );
}

#[test]
fn cl_defmethod_zero_qualifiers() {
    let (data, reg) = annotate(
        "(cl-defmethod area ((s square)) (* (side s) (side s)))",
        Dialect::EmacsLisp,
    );
    let a = annotate_form(&data[0], &reg).unwrap();
    assert_eq!(a.all(Role::Qualifier).count(), 0);
    let params = a.specialized_params();
    assert_eq!(params.len(), 1);
    assert_eq!(params[0].variable.kind, DatumKind::Symbol("s"));
    assert_eq!(
        params[0].specializer.unwrap().kind,
        DatumKind::Symbol("square")
    );
}

#[test]
fn cl_defmethod_multiple_qualifiers() {
    // ANSI CL allows several qualifiers; all are captured.
    let (data, reg) = annotate(
        "(defmethod foo :before :extra ((x t)) nil)",
        Dialect::CommonLisp,
    );
    let a = annotate_form(&data[0], &reg).unwrap();
    let quals: Vec<_> = a.all(Role::Qualifier).map(|d| &d.kind).collect();
    assert_eq!(quals.len(), 2);
}

#[test]
fn eql_specializer_is_verbatim_list() {
    let (data, reg) = annotate("(cl-defmethod g ((x (eql 0))) x)", Dialect::EmacsLisp);
    let a = annotate_form(&data[0], &reg).unwrap();
    let params = a.specialized_params();
    assert_eq!(params[0].variable.kind, DatumKind::Symbol("x"));
    // The specializer is the whole `(eql 0)` list, unresolved.
    assert!(matches!(
        params[0].specializer.unwrap().kind,
        DatumKind::List { .. }
    ));
}

#[test]
fn unspecialized_param_has_no_specializer() {
    let (data, reg) = annotate("(cl-defmethod h ((x integer) y) x)", Dialect::EmacsLisp);
    let a = annotate_form(&data[0], &reg).unwrap();
    let params = a.specialized_params();
    assert_eq!(params.len(), 2);
    assert!(params[1].specializer.is_none());
    assert_eq!(params[1].variable.kind, DatumKind::Symbol("y"));
}

#[test]
fn cl_defmethod_docstring_is_tagged() {
    let (data, reg) = annotate(
        r#"(defmethod area ((s square)) "Compute the area." (* s s))"#,
        Dialect::CommonLisp,
    );
    let a = annotate_form(&data[0], &reg).unwrap();
    assert_eq!(
        a.first(Role::Docstring).unwrap().kind,
        DatumKind::Str("\"Compute the area.\"")
    );
}

#[test]
fn clojure_multi_arity_defmethod_clause_is_not_arglist() {
    // `(defmethod f :x ([a] …) ([a b] …))` — the round arity clauses must not
    // be tagged as the Arglist (Clojure arglists are square vectors).
    let (data, reg) = annotate("(defmethod f :x ([a] a) ([a b] b))", Dialect::Clojure);
    let a = annotate_form(&data[0], &reg).unwrap();
    assert!(a.first(Role::Arglist).is_none());
    assert_eq!(a.parts.iter().filter(|p| p.role == Role::Body).count(), 2);
}

#[test]
fn clojure_defmethod_uses_dispatch_value() {
    let (data, reg) = annotate(
        "(defmethod area :circle [shape] (* 3 (:r shape)))",
        Dialect::Clojure,
    );
    let a = annotate_form(&data[0], &reg).unwrap();
    assert_eq!(a.first(Role::Name).unwrap().kind, DatumKind::Symbol("area"));
    // The dispatch value is a single datum, not a qualifier.
    assert_eq!(
        a.first(Role::DispatchValue).unwrap().kind,
        DatumKind::Keyword(":circle")
    );
    assert_eq!(a.all(Role::Qualifier).count(), 0);
    // The plain arglist follows.
    assert!(matches!(
        a.first(Role::Arglist).unwrap().kind,
        DatumKind::List { .. }
    ));
}