sway_core/semantic_analysis/ast_node/declaration/
struct.rs1use 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 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 ctx.scoped(handler, Some(span.clone()), |ctx| {
51 let new_type_parameters = GenericTypeParameter::type_check_type_params(
53 handler,
54 ctx.by_ref(),
55 type_parameters,
56 None,
57 )?;
58
59 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 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}