sway_core/language/ty/declaration/
trait_fn.rs

1use std::{
2    fmt,
3    hash::{Hash, Hasher},
4};
5
6use monomorphization::MonomorphizeHelper;
7use sway_error::handler::Handler;
8use sway_types::{Ident, Named, Span, Spanned};
9
10use crate::{
11    ast_elements::type_argument::GenericTypeArgument,
12    engine_threading::*,
13    has_changes,
14    language::{parsed::TraitFn, ty::*, Purity},
15    transform,
16    type_system::*,
17};
18
19#[derive(Clone, Debug)]
20pub struct TyTraitFn {
21    pub name: Ident,
22    pub(crate) span: Span,
23    pub(crate) purity: Purity,
24    pub parameters: Vec<TyFunctionParameter>,
25    pub return_type: GenericTypeArgument,
26    pub attributes: transform::Attributes,
27}
28
29impl TyDeclParsedType for TyTraitFn {
30    type ParsedType = TraitFn;
31}
32
33impl DebugWithEngines for TyTraitFn {
34    fn fmt(&self, f: &mut fmt::Formatter<'_>, engines: &Engines) -> fmt::Result {
35        write!(
36            f,
37            "{:?}({}):{}",
38            self.name,
39            self.parameters
40                .iter()
41                .map(|p| format!(
42                    "{}:{}",
43                    p.name.as_str(),
44                    engines.help_out(p.type_argument.initial_type_id)
45                ))
46                .collect::<Vec<_>>()
47                .join(", "),
48            engines.help_out(self.return_type.initial_type_id),
49        )
50    }
51}
52
53impl Named for TyTraitFn {
54    fn name(&self) -> &Ident {
55        &self.name
56    }
57}
58
59impl Spanned for TyTraitFn {
60    fn span(&self) -> Span {
61        self.span.clone()
62    }
63}
64
65impl IsConcrete for TyTraitFn {
66    fn is_concrete(&self, handler: &Handler, engines: &Engines) -> bool {
67        self.type_parameters()
68            .iter()
69            .all(|tp| tp.is_concrete(handler, engines))
70            && self
71                .return_type
72                .type_id
73                .is_concrete(engines, TreatNumericAs::Concrete)
74            && self.parameters().iter().all(|t| {
75                t.type_argument
76                    .type_id
77                    .is_concrete(engines, TreatNumericAs::Concrete)
78            })
79    }
80}
81
82impl declaration::FunctionSignature for TyTraitFn {
83    fn parameters(&self) -> &Vec<TyFunctionParameter> {
84        &self.parameters
85    }
86
87    fn return_type(&self) -> &GenericTypeArgument {
88        &self.return_type
89    }
90}
91
92impl EqWithEngines for TyTraitFn {}
93impl PartialEqWithEngines for TyTraitFn {
94    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
95        let type_engine = ctx.engines().te();
96        self.name == other.name
97            && self.purity == other.purity
98            && self.parameters.eq(&other.parameters, ctx)
99            && type_engine
100                .get(self.return_type.type_id)
101                .eq(&type_engine.get(other.return_type.type_id), ctx)
102            && self.attributes == other.attributes
103    }
104}
105
106impl HashWithEngines for TyTraitFn {
107    fn hash<H: Hasher>(&self, state: &mut H, engines: &Engines) {
108        let TyTraitFn {
109            name,
110            purity,
111            parameters,
112            return_type,
113            // these fields are not hashed because they aren't relevant/a
114            // reliable source of obj v. obj distinction
115            span: _,
116            attributes: _,
117        } = self;
118        let type_engine = engines.te();
119        name.hash(state);
120        parameters.hash(state, engines);
121        type_engine.get(return_type.type_id).hash(state, engines);
122        purity.hash(state);
123    }
124}
125
126impl SubstTypes for TyTraitFn {
127    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
128        has_changes! {
129            self.parameters.subst(ctx);
130            self.return_type.subst(ctx);
131        }
132    }
133}
134
135impl MonomorphizeHelper for TyTraitFn {
136    fn name(&self) -> &Ident {
137        &self.name
138    }
139
140    fn type_parameters(&self) -> &[TypeParameter] {
141        &[]
142    }
143
144    fn has_self_type_param(&self) -> bool {
145        false
146    }
147}
sway_core/language/ty/declaration/trait_fn.rs

sway_core/language/ty/declaration/
trait_fn.rs
