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

//! The definition of patterns is shared between the parse-tree and the
//! repr, but customized by a type T that represents the different type
//! representations.

use crate::grammar::parse_tree::{Path, Span};
use crate::util::Sep;
use std::fmt::{Display, Error, Formatter};
use string_cache::DefaultAtom as Atom;

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Pattern<T> {
    pub span: Span,
    pub kind: PatternKind<T>,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct FieldPattern<T> {
    pub field_span: Span,
    pub field_name: Atom,
    pub pattern: Pattern<T>,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum PatternKind<T> {
    Enum(Path, Vec<Pattern<T>>),
    Struct(Path, Vec<FieldPattern<T>>, /* trailing ..? */ bool),
    Path(Path),
    Tuple(Vec<Pattern<T>>),
    TupleStruct(Path, Vec<Pattern<T>>),
    Usize(usize),
    Underscore,
    DotDot,
    Choose(T),
    CharLiteral(Atom),
    String(String),
}

impl<T> Pattern<T> {
    pub fn for_each_binding<U>(&self, map_fn: &mut dyn FnMut(&T) -> U) {
        self.map(map_fn);
    }

    pub fn map<U>(&self, map_fn: &mut dyn FnMut(&T) -> U) -> Pattern<U> {
        Pattern {
            span: self.span,
            kind: self.kind.map(map_fn),
        }
    }
}

impl<T> PatternKind<T> {
    pub fn map<U>(&self, map_fn: &mut dyn FnMut(&T) -> U) -> PatternKind<U> {
        match *self {
            PatternKind::Path(ref path) => PatternKind::Path(path.clone()),
            PatternKind::Enum(ref path, ref pats) => PatternKind::Enum(
                path.clone(),
                pats.iter().map(|pat| pat.map(map_fn)).collect(),
            ),
            PatternKind::Struct(ref path, ref fields, dotdot) => PatternKind::Struct(
                path.clone(),
                fields.iter().map(|pat| pat.map(map_fn)).collect(),
                dotdot,
            ),
            PatternKind::Tuple(ref pats) => {
                PatternKind::Tuple(pats.iter().map(|p| p.map(map_fn)).collect())
            }
            PatternKind::TupleStruct(ref path, ref pats) => {
                PatternKind::TupleStruct(path.clone(), pats.iter().map(|p| p.map(map_fn)).collect())
            }
            PatternKind::Underscore => PatternKind::Underscore,
            PatternKind::DotDot => PatternKind::DotDot,
            PatternKind::Usize(n) => PatternKind::Usize(n),
            PatternKind::Choose(ref ty) => PatternKind::Choose(map_fn(ty)),
            PatternKind::CharLiteral(ref c) => PatternKind::CharLiteral(c.clone()),
            PatternKind::String(ref s) => PatternKind::String(s.clone()),
        }
    }
}

impl<T> FieldPattern<T> {
    pub fn map<U>(&self, map_fn: &mut dyn FnMut(&T) -> U) -> FieldPattern<U> {
        FieldPattern {
            field_name: self.field_name.clone(),
            field_span: self.field_span,
            pattern: self.pattern.map(map_fn),
        }
    }
}

impl<T: Display> Display for Pattern<T> {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
        write!(fmt, "{}", self.kind)
    }
}

impl<T: Display> Display for PatternKind<T> {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
        match *self {
            PatternKind::Path(ref path) => write!(fmt, "{}", path),
            PatternKind::Enum(ref path, ref pats) => write!(fmt, "{}({})", path, Sep(", ", pats)),
            PatternKind::Struct(ref path, ref fields, false) => {
                write!(fmt, "{} {{ {} }}", path, Sep(", ", fields))
            }
            PatternKind::Struct(ref path, ref fields, true) if fields.is_empty() => {
                write!(fmt, "{} {{ .. }}", path)
            }
            PatternKind::Struct(ref path, ref fields, true) => {
                write!(fmt, "{} {{ {}, .. }}", path, Sep(", ", fields))
            }
            PatternKind::Tuple(ref paths) => write!(fmt, "({})", Sep(", ", paths)),
            PatternKind::TupleStruct(ref path, ref paths) => {
                write!(fmt, "{}({})", path, Sep(", ", paths))
            }
            PatternKind::Underscore => write!(fmt, "_"),
            PatternKind::DotDot => write!(fmt, ".."),
            PatternKind::Usize(n) => write!(fmt, "{}", n),
            PatternKind::Choose(ref ty) => write!(fmt, "{}", ty),
            PatternKind::CharLiteral(ref c) => write!(fmt, "'{}'", c),
            PatternKind::String(ref s) => write!(fmt, "{:?}", s),
        }
    }
}

impl<T: Display> Display for FieldPattern<T> {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
        write!(fmt, "{}: {}", self.field_name, self.pattern)
    }
}