swamp_script_analyzer/
types.rs

1/*
2 * Copyright (c) Peter Bjorklund. All rights reserved. https://github.com/swamp/script
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_script_types::{Signature, Type, TypeForParameter};
8
9impl Analyzer<'_> {
10    /// # Errors
11    ///
12    pub fn analyze_map_type(
13        &mut self,
14        ast_key_type: &swamp_script_ast::Type,
15        ast_value_type: &swamp_script_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_script_ast::Type) -> Result<Type, Error> {
28        self.analyze_type(ast_type)
29    }
30
31    /// # Errors
32    ///
33    pub fn analyze_type(&mut self, ast_type: &swamp_script_ast::Type) -> Result<Type, Error> {
34        let resolved = match ast_type {
35            swamp_script_ast::Type::AnonymousStruct(ast_struct) => {
36                let struct_ref = self.analyze_anonymous_struct_type(ast_struct)?;
37                Type::AnonymousStruct(struct_ref.into())
38            }
39            swamp_script_ast::Type::Slice(ast_type) => {
40                let analyzed_element_type = self.analyze_slice_type(ast_type)?;
41                let vec_blueprint = self
42                    .shared
43                    .core_symbol_table
44                    .get_blueprint("Vec")
45                    .unwrap()
46                    .clone();
47                let instantiated_vec = self
48                    .instantiate_blueprint_and_members(&vec_blueprint, &[analyzed_element_type])?;
49                instantiated_vec
50            }
51            swamp_script_ast::Type::SlicePair(key_type, value_type) => {
52                let analyzed_key_type = self.analyze_slice_type(key_type)?;
53                let analyzed_value_type = self.analyze_slice_type(value_type)?;
54                let map_blueprint = self
55                    .shared
56                    .core_symbol_table
57                    .get_blueprint("Map")
58                    .unwrap()
59                    .clone();
60
61                let instantiated_vec = self.instantiate_blueprint_and_members(
62                    &map_blueprint,
63                    &[analyzed_key_type, analyzed_value_type],
64                )?;
65                instantiated_vec
66            }
67            swamp_script_ast::Type::Tuple(types) => Type::Tuple(self.analyze_types(types)?),
68            //            swamp_script_ast::Type::Generic(base_type, generic_types) => {
69            //              let base_type = self.analyze_type(base_type)?;
70            //Type::Generic(Box::new(base_type), self.analyze_types(generic_types)?)
71            //        }
72            swamp_script_ast::Type::Named(ast_type_reference) => {
73                self.analyze_named_type(ast_type_reference)?
74            }
75            swamp_script_ast::Type::Optional(inner_type_ast, _node) => {
76                let inner_resolved_type = self.analyze_type(inner_type_ast)?;
77                Type::Optional(Box::from(inner_resolved_type))
78            }
79            swamp_script_ast::Type::Function(parameters, return_type) => {
80                let parameter_types = self.analyze_param_types(parameters)?;
81
82                let resolved_return_type = self.analyze_type(return_type)?;
83                Type::Function(Signature {
84                    parameters: parameter_types,
85                    return_type: Box::new(resolved_return_type),
86                })
87            }
88        };
89
90        Ok(resolved)
91    }
92
93    pub(crate) fn analyze_types(
94        &mut self,
95        types: &[swamp_script_ast::Type],
96    ) -> Result<Vec<Type>, Error> {
97        let mut resolved_types = Vec::new();
98        for some_type in types {
99            resolved_types.push(self.analyze_type(some_type)?);
100        }
101        Ok(resolved_types)
102    }
103
104    fn analyze_param_types(
105        &mut self,
106        type_for_parameters: &Vec<swamp_script_ast::TypeForParameter>,
107    ) -> Result<Vec<TypeForParameter>, Error> {
108        let mut vec = Vec::new();
109        for x in type_for_parameters {
110            vec.push(TypeForParameter {
111                name: String::new(),
112                resolved_type: self.analyze_type(&x.ast_type)?,
113                is_mutable: x.is_mutable,
114                node: None,
115            });
116        }
117
118        Ok(vec)
119    }
120}
swamp_script_analyzer/types.rs

swamp_script_analyzer/
types.rs
