naga/compact/
types.rs

1use super::{HandleSet, ModuleMap};
2use crate::Handle;
3
4pub struct TypeTracer<'a> {
5    pub overrides: &'a crate::Arena<crate::Override>,
6    pub types_used: &'a mut HandleSet<crate::Type>,
7    pub expressions_used: &'a mut HandleSet<crate::Expression>,
8    pub overrides_used: &'a mut HandleSet<crate::Override>,
9}
10
11impl TypeTracer<'_> {
12    pub fn trace_type(&mut self, ty: &crate::Type) {
13        use crate::TypeInner as Ti;
14        match ty.inner {
15            // Types that do not contain handles.
16            Ti::Scalar { .. }
17            | Ti::Vector { .. }
18            | Ti::Matrix { .. }
19            | Ti::CooperativeMatrix { .. }
20            | Ti::Atomic { .. }
21            | Ti::ValuePointer { .. }
22            | Ti::Image { .. }
23            | Ti::Sampler { .. }
24            | Ti::AccelerationStructure { .. }
25            | Ti::RayQuery { .. } => {}
26
27            // Types that do contain handles.
28            Ti::Array {
29                base,
30                size,
31                stride: _,
32            }
33            | Ti::BindingArray { base, size } => {
34                self.types_used.insert(base);
35                match size {
36                    crate::ArraySize::Pending(handle) => {
37                        self.overrides_used.insert(handle);
38                        let r#override = &self.overrides[handle];
39                        self.types_used.insert(r#override.ty);
40                        if let Some(expr) = r#override.init {
41                            self.expressions_used.insert(expr);
42                        }
43                    }
44                    crate::ArraySize::Constant(_) | crate::ArraySize::Dynamic => {}
45                }
46            }
47            Ti::Pointer { base, space: _ } => {
48                self.types_used.insert(base);
49            }
50            Ti::Struct {
51                ref members,
52                span: _,
53            } => {
54                self.types_used.insert_iter(members.iter().map(|m| m.ty));
55            }
56        }
57    }
58}
59
60impl ModuleMap {
61    pub fn adjust_type(&self, ty: &mut crate::Type) {
62        let adjust = |ty: &mut Handle<crate::Type>| self.types.adjust(ty);
63
64        use crate::TypeInner as Ti;
65        match ty.inner {
66            // Types that do not contain handles.
67            Ti::Scalar(_)
68            | Ti::Vector { .. }
69            | Ti::Matrix { .. }
70            | Ti::CooperativeMatrix { .. }
71            | Ti::Atomic(_)
72            | Ti::ValuePointer { .. }
73            | Ti::Image { .. }
74            | Ti::Sampler { .. }
75            | Ti::AccelerationStructure { .. }
76            | Ti::RayQuery { .. } => {}
77
78            // Types that do contain handles.
79            Ti::Pointer {
80                ref mut base,
81                space: _,
82            } => adjust(base),
83            Ti::Array {
84                ref mut base,
85                ref mut size,
86                stride: _,
87            }
88            | Ti::BindingArray {
89                ref mut base,
90                ref mut size,
91            } => {
92                adjust(base);
93                match *size {
94                    crate::ArraySize::Pending(ref mut r#override) => {
95                        self.overrides.adjust(r#override);
96                    }
97                    crate::ArraySize::Constant(_) | crate::ArraySize::Dynamic => {}
98                }
99            }
100            Ti::Struct {
101                ref mut members,
102                span: _,
103            } => {
104                for member in members {
105                    self.types.adjust(&mut member.ty);
106                }
107            }
108        };
109    }
110}
naga/compact/types.rs

naga/compact/
types.rs
