genotype_project 0.17.0

Genotype language project crate
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

use crate::prelude::internal::*;

// region: Modules

mod parse;
pub use parse::*;

mod resolve;
pub use resolve::*;

mod type_check;
pub use type_check::*;

mod error;
pub use error::*;

mod source;
pub use source::*;

// endregion

// region: Module

#[derive(Debug, PartialEq, Clone, Serialize)]
pub enum GtpModule {
    /// Module is currently being loaded.
    Initialized(GtpModuleSource),

    /// Module failed to load.
    Error(GtpModuleSource, GtpModuleError),

    /// Module has been parsed successfully.
    Parsed(Box<GtpModuleParse>),

    /// Module has been resolved successfully.
    Resolved(Box<GtpModuleResolved>),

    /// Module has been type checked successfully.
    TypeChecked(Box<GtpModuleTypeChecked>),
}

impl GtpModule {
    /// Module state name.
    pub fn state_name(&self) -> &'static str {
        match self {
            GtpModule::Initialized(_) => "initialized",
            GtpModule::Error(_, _) => "error",
            GtpModule::Parsed(_) => "parsed",
            GtpModule::Resolved(_) => "resolved",
            GtpModule::TypeChecked(_) => "type checked",
        }
    }

    /// Resolves the module parse.
    pub fn module_parse(&self) -> Option<&GtModuleParse> {
        self.project_module_parse().map(|parse| &parse.module_parse)
    }

    /// Resolves the project module parse.
    pub fn project_module_parse(&self) -> Option<&GtpModuleParse> {
        match self {
            GtpModule::Initialized(_) => None,
            GtpModule::Error(_, _) => None,
            GtpModule::Parsed(state) => Some(state),
            GtpModule::Resolved(state) => Some(&state.project_module_parse),
            GtpModule::TypeChecked(state) => Some(&state.module_resolved.project_module_parse),
        }
    }

    /// Resolves the module path.
    pub fn path(&self) -> &GtpModulePath {
        match self {
            GtpModule::Initialized(source) => source.path(),
            GtpModule::Error(source, _) => source.path(),
            GtpModule::Parsed(state) => &state.path,
            GtpModule::Resolved(state) => &state.project_module_parse.path,
            GtpModule::TypeChecked(state) => &state.module_resolved.project_module_parse.path,
        }
    }

    /// Resolves the module source.
    pub fn source(&self) -> &GtpModuleSource {
        match self {
            GtpModule::Initialized(source) => source,
            GtpModule::Error(source, _) => source,
            GtpModule::Parsed(state) => &state.source,
            GtpModule::Resolved(state) => &state.project_module_parse.source,
            GtpModule::TypeChecked(state) => &state.module_resolved.project_module_parse.source,
        }
    }

    // Resolves the module source code.
    pub fn source_code(&self) -> Option<&str> {
        match self {
            GtpModule::Initialized(_) => None,
            GtpModule::Error(_, _) => None,
            GtpModule::Parsed(state) => Some(&state.source_code.content),
            GtpModule::Resolved(state) => Some(&state.project_module_parse.source_code.content),
            GtpModule::TypeChecked(state) => Some(
                &state
                    .module_resolved
                    .project_module_parse
                    .source_code
                    .content,
            ),
        }
    }
}

// endregion