sway_core/semantic_analysis/ast_node/declaration/
struct.rs

1use crate::{
2    decl_engine::parsed_id::ParsedDeclId,
3    language::{parsed::*, ty, CallPath},
4    semantic_analysis::*,
5    type_system::*,
6    Engines,
7};
8use ast_elements::type_parameter::GenericTypeParameter;
9use sway_error::handler::{ErrorEmitted, Handler};
10use sway_types::Spanned;
11use symbol_collection_context::SymbolCollectionContext;
12
13impl ty::TyStructDecl {
14    pub(crate) fn collect(
15        handler: &Handler,
16        engines: &Engines,
17        ctx: &mut SymbolCollectionContext,
18        decl_id: &ParsedDeclId<StructDeclaration>,
19    ) -> Result<(), ErrorEmitted> {
20        let struct_decl = engines.pe().get_struct(decl_id);
21        let decl = Declaration::StructDeclaration(*decl_id);
22        ctx.insert_parsed_symbol(handler, engines, struct_decl.name.clone(), decl.clone())?;
23
24        // create a namespace for the decl, used to create a scope for generics
25        let _ = ctx.scoped(
26            engines,
27            struct_decl.span.clone(),
28            Some(decl),
29            |_scoped_ctx| Ok(()),
30        );
31        Ok(())
32    }
33
34    pub(crate) fn type_check(
35        handler: &Handler,
36        mut ctx: TypeCheckContext,
37        decl: StructDeclaration,
38    ) -> Result<Self, ErrorEmitted> {
39        let StructDeclaration {
40            name,
41            fields,
42            type_parameters,
43            visibility,
44            span,
45            attributes,
46            ..
47        } = decl;
48
49        // create a namespace for the decl, used to create a scope for generics
50        ctx.scoped(handler, Some(span.clone()), |ctx| {
51            // Type check the type parameters.
52            let new_type_parameters = GenericTypeParameter::type_check_type_params(
53                handler,
54                ctx.by_ref(),
55                type_parameters,
56                None,
57            )?;
58
59            // type check the fields
60            let mut new_fields = vec![];
61            for field in fields.into_iter() {
62                new_fields.push(ty::TyStructField::type_check(handler, ctx.by_ref(), field)?);
63            }
64
65            let path = CallPath::ident_to_fullpath(name, ctx.namespace());
66
67            // create the struct decl
68            let decl = ty::TyStructDecl {
69                call_path: path,
70                generic_parameters: new_type_parameters,
71                fields: new_fields,
72                visibility,
73                span,
74                attributes,
75            };
76
77            Ok(decl)
78        })
79    }
80}
81
82impl ty::TyStructField {
83    pub(crate) fn type_check(
84        handler: &Handler,
85        ctx: TypeCheckContext,
86        field: StructField,
87    ) -> Result<Self, ErrorEmitted> {
88        let type_engine = ctx.engines.te();
89
90        let mut type_argument = field.type_argument;
91        *type_argument.type_id_mut() = ctx
92            .resolve_type(
93                handler,
94                type_argument.type_id(),
95                &type_argument.span(),
96                EnforceTypeArguments::Yes,
97                None,
98            )
99            .unwrap_or_else(|err| type_engine.id_of_error_recovery(err));
100        let field = ty::TyStructField {
101            visibility: field.visibility,
102            name: field.name,
103            span: field.span,
104            type_argument,
105            attributes: field.attributes,
106        };
107        Ok(field)
108    }
109}
110
111impl TypeCheckAnalysis for ty::TyStructDecl {
112    fn type_check_analyze(
113        &self,
114        _handler: &Handler,
115        _ctx: &mut TypeCheckAnalysisContext,
116    ) -> Result<(), ErrorEmitted> {
117        Ok(())
118    }
119}
120
121impl TypeCheckFinalization for ty::TyStructDecl {
122    fn type_check_finalize(
123        &mut self,
124        _handler: &Handler,
125        _ctx: &mut TypeCheckFinalizationContext,
126    ) -> Result<(), ErrorEmitted> {
127        Ok(())
128    }
129}