sway_core/language/ty/declaration/
impl_trait.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
use std::hash::{Hash, Hasher};

use sway_types::{Ident, Named, Span, Spanned};

use crate::{
    decl_engine::DeclRefMixedInterface,
    engine_threading::*,
    has_changes,
    language::{parsed::ImplSelfOrTrait, CallPath},
    type_system::*,
};

use super::{TyDeclParsedType, TyTraitItem};

pub type TyImplItem = TyTraitItem;

// impl <A, B, C> Trait<Arg, Arg> for Type<Arg, Arg>
#[derive(Clone, Debug)]
pub struct TyImplSelfOrTrait {
    pub impl_type_parameters: Vec<TypeParameter>,
    pub trait_name: CallPath,
    pub trait_type_arguments: Vec<TypeArgument>,
    pub items: Vec<TyImplItem>,
    pub supertrait_items: Vec<TyImplItem>,
    pub trait_decl_ref: Option<DeclRefMixedInterface>,
    pub implementing_for: TypeArgument,
    pub span: Span,
}

impl TyImplSelfOrTrait {
    pub fn is_impl_contract(&self, te: &TypeEngine) -> bool {
        matches!(&*te.get(self.implementing_for.type_id), TypeInfo::Contract)
    }
}

impl TyDeclParsedType for TyImplSelfOrTrait {
    type ParsedType = ImplSelfOrTrait;
}

impl Named for TyImplSelfOrTrait {
    fn name(&self) -> &Ident {
        &self.trait_name.suffix
    }
}

impl Spanned for TyImplSelfOrTrait {
    fn span(&self) -> Span {
        self.span.clone()
    }
}

impl EqWithEngines for TyImplSelfOrTrait {}
impl PartialEqWithEngines for TyImplSelfOrTrait {
    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
        self.impl_type_parameters
            .eq(&other.impl_type_parameters, ctx)
            && self.trait_name == other.trait_name
            && self
                .trait_type_arguments
                .eq(&other.trait_type_arguments, ctx)
            && self.items.eq(&other.items, ctx)
            && self.implementing_for.eq(&other.implementing_for, ctx)
            && self.trait_decl_ref.eq(&other.trait_decl_ref, ctx)
    }
}

impl HashWithEngines for TyImplSelfOrTrait {
    fn hash<H: Hasher>(&self, state: &mut H, engines: &Engines) {
        let TyImplSelfOrTrait {
            impl_type_parameters,
            trait_name,
            trait_type_arguments,
            items,
            implementing_for,
            trait_decl_ref,
            // these fields are not hashed because they aren't relevant/a
            // reliable source of obj v. obj distinction
            span: _,
            supertrait_items: _,
        } = self;
        trait_name.hash(state);
        impl_type_parameters.hash(state, engines);
        trait_type_arguments.hash(state, engines);
        items.hash(state, engines);
        implementing_for.hash(state, engines);
        trait_decl_ref.hash(state, engines);
    }
}

impl SubstTypes for TyImplSelfOrTrait {
    fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
        has_changes! {
            self.impl_type_parameters.subst(ctx);
            self.implementing_for.subst_inner(ctx);
            self.items.subst(ctx);
        }
    }
}