swamp_analyzer/
literal.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, TypeContext};
6use source_map_node::Node;
7use std::env::current_dir;
8use swamp_semantic::err::ErrorKind;
9use swamp_semantic::prelude::Error;
10use swamp_semantic::{EnumLiteralExpressions, ExpressionKind};
11use swamp_semantic::{Expression, Fp};
12use swamp_types::prelude::*;
13use tracing::error;
14
15impl Analyzer<'_> {
16    /// # Errors
17    ///
18    /// # Panics
19    /// if core hasn't added `Vec`
20    #[allow(clippy::too_many_lines)]
21    pub fn analyze_complex_literal_to_expression(
22        &mut self,
23        ast_expression: &swamp_ast::Expression,
24        ast_literal_kind: &swamp_ast::LiteralKind,
25        context: &TypeContext,
26    ) -> Expression {
27        let ast_node = &ast_expression.node;
28        let (lit_kind, literal_type) = match &ast_literal_kind {
29            swamp_ast::LiteralKind::InternalInitializerList(items) => {
30                let (collection_type, resolved_items) =
31                    self.analyze_internal_initializer_list(ast_node, items, context);
32
33                (
34                    ExpressionKind::InitializerList(collection_type.clone(), resolved_items),
35                    collection_type,
36                )
37            }
38
39            swamp_ast::LiteralKind::InternalInitializerPairList(entries) => {
40                let (collection_type, resolved_items) =
41                    self.analyze_internal_initializer_pair_list(ast_node, entries, context);
42
43                (
44                    ExpressionKind::InitializerPairList(collection_type.clone(), resolved_items),
45                    collection_type,
46                )
47            }
48
49            _ => return self.analyze_literal(ast_node, ast_literal_kind, context),
50        };
51
52        self.create_expr(lit_kind, literal_type, ast_node)
53    }
54
55    #[allow(clippy::too_many_lines)]
56    pub(crate) fn analyze_literal(
57        &mut self,
58        ast_node: &swamp_ast::Node,
59        ast_literal_kind: &swamp_ast::LiteralKind,
60        context: &TypeContext,
61    ) -> Expression {
62        let node_text = self.get_text(ast_node);
63        let (expression_kind, ty) = match &ast_literal_kind {
64            swamp_ast::LiteralKind::Int => match Self::str_to_int(node_text) {
65                Err(int_err) => {
66                    return self.create_err(ErrorKind::IntConversionError(int_err), ast_node);
67                }
68                Ok(int_value) => (
69                    ExpressionKind::IntLiteral(int_value),
70                    self.shared.state.types.int(),
71                ),
72            },
73            swamp_ast::LiteralKind::Float => match Self::str_to_float(node_text) {
74                Err(float_err) => {
75                    return self.create_err(ErrorKind::FloatConversionError(float_err), ast_node);
76                }
77                Ok(float_value) => (
78                    ExpressionKind::FloatLiteral(Fp::from(float_value)),
79                    self.shared.state.types.float(),
80                ),
81            },
82            swamp_ast::LiteralKind::String(processed_string) => (
83                ExpressionKind::StringLiteral(processed_string.to_string()),
84                self.shared.state.types.string(),
85            ),
86            swamp_ast::LiteralKind::Bool => match Self::str_to_bool(node_text) {
87                Err(_bool_err) => return self.create_err(ErrorKind::BoolConversionError, ast_node),
88                Ok(bool_value) => (
89                    ExpressionKind::BoolLiteral(bool_value),
90                    self.shared.state.types.bool(),
91                ),
92            },
93            swamp_ast::LiteralKind::EnumVariant(enum_literal) => {
94                let (enum_name, variant_name_node) = match enum_literal {
95                    swamp_ast::EnumVariantLiteral::Simple(enum_name, variant_name) => {
96                        (enum_name, variant_name)
97                    }
98                    swamp_ast::EnumVariantLiteral::Tuple(enum_name, variant_name, _) => {
99                        (enum_name, variant_name)
100                    }
101                    swamp_ast::EnumVariantLiteral::Struct(enum_name, variant_name, _, _) => {
102                        (enum_name, variant_name)
103                    }
104                };
105
106                // Get the text first to avoid borrowing conflicts
107                let variant_name_text = self.get_text(&variant_name_node.0).to_string();
108
109                // Get the enum type, then release the borrow
110                let found_enum_type = {
111                    let Some((symbol_table, name)) = self.get_symbol_table_and_name(enum_name)
112                    else {
113                        self.add_err(ErrorKind::UnknownModule, &enum_name.name.0);
114                        return self.create_err(ErrorKind::UnknownEnumVariantType, ast_node);
115                    };
116                    let Some(found_enum_type) = symbol_table.get_type(&name) else {
117                        return self.create_err(ErrorKind::UnknownEnumType, ast_node);
118                    };
119                    found_enum_type.clone()
120                };
121
122                let TypeKind::Enum(enum_type) = &*found_enum_type.kind else {
123                    return self.create_err(ErrorKind::UnknownEnumType, ast_node);
124                };
125                let variant_name = &variant_name_text;
126                // Handle enum variant literals in patterns
127                let Some(variant_ref) = enum_type.get_variant(variant_name) else {
128                    return self
129                        .create_err(ErrorKind::UnknownEnumVariantType, &variant_name_node.0);
130                };
131
132                let resolved_data = match enum_literal {
133                    swamp_ast::EnumVariantLiteral::Simple(_, _) => EnumLiteralExpressions::Nothing,
134                    swamp_ast::EnumVariantLiteral::Tuple(_node, _variant, ast_expressions) => {
135                        let TypeKind::Tuple(tuple_field_types) = &*variant_ref.payload_type.kind
136                        else {
137                            return self.create_err(
138                                ErrorKind::WrongEnumVariantContainer(variant_ref.clone()),
139                                ast_node,
140                            );
141                        };
142
143                        if tuple_field_types.len() != ast_expressions.len() {
144                            return self.create_err(
145                                ErrorKind::WrongNumberOfArguments(
146                                    tuple_field_types.len(),
147                                    ast_expressions.len(),
148                                ),
149                                ast_node,
150                            );
151                        }
152
153                        let resolved_expression = tuple_field_types
154                            .iter()
155                            .zip(ast_expressions)
156                            .map(|(expected_type, ast_expression)| {
157                                let ctx = context.argument(expected_type);
158                                self.analyze_expression(ast_expression, &ctx)
159                            })
160                            .collect();
161
162                        EnumLiteralExpressions::Tuple(resolved_expression)
163                    }
164                    swamp_ast::EnumVariantLiteral::Struct(
165                        _qualified_type_identifier,
166                        variant,
167                        anonym_struct_field_and_expressions,
168                        detected_rest,
169                    ) => {
170                        let TypeKind::AnonymousStruct(anon_payload) =
171                            &*variant_ref.payload_type.kind
172                        else {
173                            return self.create_err(
174                                ErrorKind::WrongEnumVariantContainer(variant_ref.clone()),
175                                ast_node,
176                            );
177                        };
178
179                        if anonym_struct_field_and_expressions.len()
180                            != anon_payload.field_name_sorted_fields.len()
181                        {
182                            return self.create_err(
183                                ErrorKind::WrongNumberOfArguments(
184                                    anonym_struct_field_and_expressions.len(),
185                                    anon_payload.field_name_sorted_fields.len(),
186                                ),
187                                &variant.0,
188                            );
189                        }
190
191                        let resolved_fields = self.analyze_anon_struct_instantiation(
192                            &variant.0.clone(),
193                            anon_payload,
194                            anonym_struct_field_and_expressions,
195                            *detected_rest,
196                        );
197
198                        EnumLiteralExpressions::Struct(resolved_fields)
199                    }
200                };
201
202                (
203                    ExpressionKind::EnumVariantLiteral(variant_ref.clone(), resolved_data),
204                    found_enum_type.clone(),
205                )
206            }
207
208            swamp_ast::LiteralKind::Tuple(expressions) => {
209                let (tuple_type_ref, resolved_items) =
210                    self.analyze_tuple_literal(expressions, context);
211                let tuple_type = self.shared.state.types.tuple(tuple_type_ref);
212                (ExpressionKind::TupleLiteral(resolved_items), tuple_type)
213            }
214            swamp_ast::LiteralKind::None => {
215                if let Some(found_expected_type) = context.expected_type {
216                    let underlying = found_expected_type;
217                    if let TypeKind::Optional(_some_type) = &*underlying.kind {
218                        (ExpressionKind::NoneLiteral, underlying.clone())
219                    } else {
220                        return self.create_err(ErrorKind::NoneNeedsExpectedTypeHint, ast_node);
221                    }
222                } else {
223                    return self.create_err(ErrorKind::NoneNeedsExpectedTypeHint, ast_node);
224                }
225            }
226            &&swamp_ast::LiteralKind::InternalInitializerList(_)
227            | &swamp_ast::LiteralKind::InternalInitializerPairList(_) => {
228                panic!("initializer lists are not basic literals")
229            }
230        };
231
232        self.create_expr(expression_kind, ty, ast_node)
233    }
234
235    fn analyze_tuple_literal(
236        &mut self,
237        items: &[swamp_ast::Expression],
238        context: &TypeContext,
239    ) -> (Vec<TypeRef>, Vec<Expression>) {
240        let expressions = self.analyze_argument_expressions(None, context, items);
241        let mut tuple_types = Vec::new();
242        for expr in &expressions {
243            let item_type = expr.ty.clone();
244            tuple_types.push(item_type);
245        }
246
247        (tuple_types, expressions)
248    }
249
250    fn analyze_tuple_type(
251        &mut self,
252        node: &swamp_ast::Node,
253        expected_types: &[TypeRef],
254        ast_expressions: &Vec<swamp_ast::Expression>,
255    ) -> Vec<Expression> {
256        if ast_expressions.len() != expected_types.len() {
257            return vec![self.create_err(
258                ErrorKind::WrongNumberOfArguments(expected_types.len(), ast_expressions.len()),
259                node,
260            )];
261        }
262
263        let mut expressions = Vec::new();
264        for (expected_type, expr) in expected_types.iter().zip(ast_expressions) {
265            let context = TypeContext::new_argument(
266                expected_type,
267                expected_type.collection_view_that_needs_explicit_storage(),
268            );
269            let resolved_expr = self.analyze_expression(expr, &context);
270            expressions.push(resolved_expr);
271        }
272
273        expressions
274    }
275
276    pub fn add_err(&mut self, kind: ErrorKind, ast_node: &swamp_ast::Node) {
277        self.add_err_resolved(kind, &self.to_node(ast_node));
278    }
279
280    pub(crate) fn add_err_resolved(&mut self, kind: ErrorKind, node: &Node) {
281        error!(?kind, "add error");
282        let err = Error {
283            node: node.clone(),
284            kind,
285        };
286        let line_info = self
287            .shared
288            .source_map
289            .get_line(&node.span, &current_dir().unwrap());
290
291        eprintln!("{}:{} {}", line_info.row, line_info.col, line_info.line);
292        self.shared.state.errors.push(err);
293    }
294
295    #[must_use]
296    pub fn create_err_vec(
297        &mut self,
298        kind: ErrorKind,
299        ast_node: &swamp_ast::Node,
300    ) -> Vec<Expression> {
301        vec![self.create_err(kind, ast_node)]
302    }
303
304    #[must_use]
305    pub fn create_err(&mut self, kind: ErrorKind, ast_node: &swamp_ast::Node) -> Expression {
306        self.add_err(kind.clone(), ast_node);
307
308        Expression {
309            ty: self.types().unit(),
310            node: self.to_node(ast_node),
311            kind: ExpressionKind::Error(kind),
312        }
313    }
314    #[must_use]
315    pub fn create_err_resolved(&mut self, kind: ErrorKind, resolved_node: &Node) -> Expression {
316        self.add_err_resolved(kind.clone(), resolved_node);
317
318        Expression {
319            ty: self.types().unit(),
320            node: resolved_node.clone(),
321            kind: ExpressionKind::Error(kind),
322        }
323    }
324}
swamp_analyzer/literal.rs

swamp_analyzer/
literal.rs
