swamp_analyzer/
types.rs

1/*
2 * Copyright (c) Peter Bjorklund. All rights reserved. https://github.com/swamp/swamp
3 * Licensed under the MIT License. See LICENSE in the project root for license information.
4 */
5use crate::Analyzer;
6use crate::err::Error;
7use swamp_types::{Signature, Type, TypeForParameter};
8
9impl Analyzer<'_> {
10    /// # Errors
11    ///
12    pub fn analyze_map_type(
13        &mut self,
14        ast_key_type: &swamp_ast::Type,
15        ast_value_type: &swamp_ast::Type,
16    ) -> Result<(Type, Type), Error> {
17        // TODO: Check for an existing map type with exact same type
18
19        let key_type = self.analyze_type(ast_key_type)?;
20        let value_type = self.analyze_type(ast_value_type)?;
21
22        Ok((key_type, value_type))
23    }
24
25    /// # Errors
26    ///
27    pub fn analyze_slice_type(&mut self, ast_type: &swamp_ast::Type) -> Result<Type, Error> {
28        self.analyze_type(ast_type)
29    }
30
31    /// # Errors
32    ///
33    /// # Panics
34    /// if `Vec` wasn't added in core.
35    pub fn analyze_type(&mut self, ast_type: &swamp_ast::Type) -> Result<Type, Error> {
36        let resolved = match ast_type {
37            swamp_ast::Type::AnonymousStruct(ast_struct) => {
38                let struct_ref = self.analyze_anonymous_struct_type(ast_struct)?;
39                Type::AnonymousStruct(struct_ref)
40            }
41            swamp_ast::Type::Slice(ast_type) => {
42                let analyzed_element_type = self.analyze_slice_type(ast_type)?;
43                let vec_blueprint = self
44                    .shared
45                    .core_symbol_table
46                    .get_blueprint("Vec")
47                    .unwrap()
48                    .clone();
49                self.shared
50                    .state
51                    .instantiator
52                    .instantiate_blueprint_and_members(&vec_blueprint, &[analyzed_element_type])?
53            }
54            swamp_ast::Type::SlicePair(key_type, value_type) => {
55                let analyzed_key_type = self.analyze_slice_type(key_type)?;
56                let analyzed_value_type = self.analyze_slice_type(value_type)?;
57                let map_blueprint = self
58                    .shared
59                    .core_symbol_table
60                    .get_blueprint("Map")
61                    .unwrap()
62                    .clone();
63
64                self.shared
65                    .state
66                    .instantiator
67                    .instantiate_blueprint_and_members(
68                        &map_blueprint,
69                        &[analyzed_key_type, analyzed_value_type],
70                    )?
71            }
72            swamp_ast::Type::Tuple(types) => Type::Tuple(self.analyze_types(types)?),
73            //            swamp_ast::Type::Generic(base_type, generic_types) => {
74            //              let base_type = self.analyze_type(base_type)?;
75            //Type::Generic(Box::new(base_type), self.analyze_types(generic_types)?)
76            //        }
77            swamp_ast::Type::Named(ast_type_reference) => {
78                self.analyze_named_type(ast_type_reference)?
79            }
80            swamp_ast::Type::Unit => Type::Unit,
81            swamp_ast::Type::Optional(inner_type_ast, _node) => {
82                let inner_resolved_type = self.analyze_type(inner_type_ast)?;
83                Type::Optional(Box::from(inner_resolved_type))
84            }
85            swamp_ast::Type::Function(parameters, return_type) => {
86                let parameter_types = self.analyze_param_types(parameters)?;
87
88                let resolved_return_type = self.analyze_type(return_type)?;
89                Type::Function(Signature {
90                    parameters: parameter_types,
91                    return_type: Box::new(resolved_return_type),
92                })
93            }
94        };
95
96        Ok(resolved)
97    }
98
99    pub(crate) fn analyze_types(&mut self, types: &[swamp_ast::Type]) -> Result<Vec<Type>, Error> {
100        let mut resolved_types = Vec::new();
101        for some_type in types {
102            resolved_types.push(self.analyze_type(some_type)?);
103        }
104        Ok(resolved_types)
105    }
106
107    fn analyze_param_types(
108        &mut self,
109        type_for_parameters: &Vec<swamp_ast::TypeForParameter>,
110    ) -> Result<Vec<TypeForParameter>, Error> {
111        let mut vec = Vec::new();
112        for x in type_for_parameters {
113            vec.push(TypeForParameter {
114                name: String::new(),
115                resolved_type: self.analyze_type(&x.ast_type)?,
116                is_mutable: x.is_mutable,
117                node: None,
118            });
119        }
120
121        Ok(vec)
122    }
123}
swamp_analyzer/types.rs

swamp_analyzer/
types.rs
