Skip to main content

smpl/
module.rs

1/*!
2
3  Contains data structures used to represent SMPL code.
4
5*/
6
7use std::path::PathBuf;
8
9use crate::analysis::ModuleId;
10use crate::ast::Module;
11
12///
13/// Represents where a SMPL module came from. Used to help gather source location info.
14///
15/// * `ModuleSource::File` should be used whenever checking SMPL code from a file.
16///
17/// * Otherwise, use `ModuleSource::Anonymous`
18///
19///   * `ModuleSource::Anonymous` can carry a hint (`Some(string)`) that will appear
20///   within source location info
21///
22///   * Without a hint, source location info will contain an `anonymous`
23///
24#[derive(Debug, Clone)]
25pub enum ModuleSource {
26    Anonymous(Option<String>),
27    File(PathBuf),
28}
29
30impl std::fmt::Display for ModuleSource {
31    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
32        match self {
33            ModuleSource::Anonymous(Some(ref a)) => write!(f, "{}", a),
34            ModuleSource::Anonymous(None) => write!(f, "{}", "anonymous"),
35            ModuleSource::File(ref buff) => write!(f, "{}", buff.display()),
36        }
37    }
38}
39
40///
41/// Represents an unparsed SMPL module.
42///
43pub struct UnparsedModule<'a> {
44    pub(crate) source: ModuleSource,
45    pub(crate) module: &'a str,
46}
47
48impl<'a> UnparsedModule<'a> {
49
50    ///
51    /// Symbolizes an unparsed SMPL module from a file.
52    ///
53    /// # Arguments
54    ///
55    /// * `path` - Path to the file
56    /// * `data` - ENTIRE content of the file 
57    ///
58    pub fn file(path: PathBuf, data: &str) -> UnparsedModule {
59        UnparsedModule {
60            source: ModuleSource::File(path),
61            module: data,
62        }
63    }
64
65    ///
66    /// Symbolizes an unparsed SMPL module from an unnamed source.
67    ///
68    /// # Arguments
69    ///
70    /// * `data` - ENTIRE SMPL module
71    ///
72    pub fn anonymous(data: &str) -> UnparsedModule {
73        UnparsedModule {
74            source: ModuleSource::Anonymous(None),
75            module: data,
76        }
77    }
78
79    ///
80    /// Symbolizes an unparsed SMPL module from an hintable unnamed source.
81    ///
82    /// # Arguments
83    ///
84    /// * `hint` - Hint to where the SMPL code came from
85    /// * `data` - ENTIRE SMPL module
86    ///
87    pub fn anonymous_hint(hint: String, data: &str) -> UnparsedModule {
88        UnparsedModule {
89            source: ModuleSource::Anonymous(Some(hint)),
90            module: data,
91        }
92    }
93
94    ///
95    /// Returns a reference to a SMPL module's source data
96    ///
97    pub fn source(&self) -> &ModuleSource {
98        &self.source
99    }
100}
101
102///
103/// Represents a parsed SMPL module that is syntactically correct.
104///
105/// Created by calling `smpl::parser::parse_module`.
106/// 
107pub struct ParsedModule {
108    pub(crate) source: ModuleSource,
109    pub(crate) module: Module,
110    pub(crate) id: ModuleId,
111}
112
113impl ParsedModule {
114    pub(crate) fn new(data: Module, source: ModuleSource) -> ParsedModule {
115        ParsedModule {
116            source: source,
117            module: data,
118            id: ModuleId::new(),
119        }
120    }
121
122    pub fn id(&self) -> ModuleId {
123        self.id
124    }
125
126    ///
127    /// Returns a reference to a SMPL module's source data
128    ///
129    pub fn source(&self) -> &ModuleSource {
130        &self.source
131    }
132}