makepad_shader_compiler/
dep_analyse.rs

1use{
2    std::cell::Cell,
3    crate::{
4        makepad_live_compiler::{
5            TokenSpan
6        },
7        shader_ast::*,
8        shader_registry::ShaderRegistry
9    }
10};
11
12
13#[derive(Clone)]
14pub struct DepAnalyser<'a> {
15    pub fn_def: &'a FnDef,
16    pub shader_registry: &'a ShaderRegistry,
17    pub scopes: &'a Scopes,
18}
19 
20impl<'a> DepAnalyser<'a> {
21    pub fn dep_analyse_expr(&mut self, expr: &Expr) {
22        match expr.kind {
23            ExprKind::Cond {
24                span,
25                ref expr,
26                ref expr_if_true,
27                ref expr_if_false,
28            } => self.dep_analyse_cond_expr(span, expr, expr_if_true, expr_if_false),
29            ExprKind::Bin {
30                span,
31                op,
32                ref left_expr,
33                ref right_expr,
34            } => self.dep_analyse_bin_expr(span, op, left_expr, right_expr),
35            ExprKind::Un {span, op, ref expr} => self.dep_analyse_un_expr(span, op, expr),
36            ExprKind::Field {
37                span,
38                ref expr,
39                field_ident,
40            } => self.dep_analyse_field_expr(span, expr, field_ident),
41            ExprKind::Index {
42                span,
43                ref expr,
44                ref index_expr,
45            } => self.dep_analyse_index_expr(span, expr, index_expr),
46            ExprKind::MethodCall {
47                span,
48                ident,
49                ref arg_exprs,
50                ..
51            } => self.dep_analyse_method_call_expr(span, ident, arg_exprs),
52            ExprKind::PlainCall {
53                span,
54                //dent,
55                ref arg_exprs,
56                ref param_index,
57                fn_ptr,
58                ..
59            } => if param_index.get().is_none() {
60                self.dep_analyse_plain_call_expr(span, arg_exprs, fn_ptr.unwrap())
61            },
62            ExprKind::BuiltinCall {
63                span,
64                ident,
65                ref arg_exprs,
66            } => self.dep_analyse_builtin_call_expr(span, ident, arg_exprs),
67            ExprKind::ClosureDef(_) => (),
68            ExprKind::ConsCall {
69                span,
70                ty_lit,
71                ref arg_exprs,
72            } => self.dep_analyse_cons_call_expr(span, ty_lit, arg_exprs),
73            ExprKind::StructCons{
74                struct_ptr,
75                span,
76                ref args
77            } => self.dep_analyse_struct_cons(struct_ptr, span, args),
78            ExprKind::Var {
79                span,
80                ref kind,
81                ..
82            } => self.dep_analyse_var_expr(span, expr.ty.borrow().as_ref(), kind),
83            ExprKind::Lit {span, lit} => self.dep_analyse_lit_expr(span, lit),
84        }
85    }
86    
87    fn dep_analyse_cond_expr(
88        &mut self,
89        _span: TokenSpan,
90        expr: &Expr,
91        expr_if_true: &Expr,
92        expr_if_false: &Expr,
93    ) {
94        self.dep_analyse_expr(expr);
95        self.dep_analyse_expr(expr_if_true);
96        self.dep_analyse_expr(expr_if_false);
97    }
98    
99    fn dep_analyse_bin_expr(
100        &mut self,
101        _span: TokenSpan,
102        _op: BinOp,
103        left_expr: &Expr,
104        right_expr: &Expr,
105    ) {
106        self.dep_analyse_expr(left_expr);
107        self.dep_analyse_expr(right_expr);
108    }
109    
110    fn dep_analyse_un_expr(&mut self, _span: TokenSpan, _op: UnOp, expr: &Expr) {
111        self.dep_analyse_expr(expr);
112    }
113    
114    fn dep_analyse_method_call_expr(
115        &mut self,
116        _span: TokenSpan,
117        method_ident: Ident,
118        arg_exprs: &[Expr],
119    ) {
120        match arg_exprs[0].ty.borrow().as_ref().unwrap() {
121            Ty::Struct(struct_ptr) => {
122                // ok we have a struct ptr
123                for arg_expr in arg_exprs {
124                    self.dep_analyse_expr(arg_expr);
125                }
126                let mut set = self.fn_def.callees.borrow_mut();
127                // ok we need to find the method FnPtr from the struct_ptr
128                let struct_decl = self.shader_registry.structs.get(struct_ptr).unwrap();
129                if let Some(fn_node_ptr) = self.shader_registry.struct_method_ptr_from_ident(struct_decl, method_ident){
130                    set.as_mut().unwrap().insert(fn_node_ptr);
131                }
132                //panic!("IMPL")
133            }
134            Ty::DrawShader(shader_ptr)=>{
135                // ok we have a struct ptr
136                for arg_expr in arg_exprs {
137                    self.dep_analyse_expr(arg_expr);
138                }
139                let mut set = self.fn_def.callees.borrow_mut();
140                let draw_shader_decl = self.shader_registry.draw_shader_defs.get(shader_ptr).unwrap();
141                if let Some(fn_node_ptr) = self.shader_registry.draw_shader_method_ptr_from_ident(draw_shader_decl, method_ident){
142                    set.as_mut().unwrap().insert(fn_node_ptr);
143                }
144            }
145            _ => panic!(),
146        }
147    }
148    
149    fn dep_analyse_builtin_call_expr(
150        &mut self,
151        _span: TokenSpan,
152        ident: Ident,
153        arg_exprs: &[Expr],
154    ) {
155        for arg_expr in arg_exprs {
156            self.dep_analyse_expr(arg_expr);
157        }
158        self.fn_def
159            .builtin_deps
160            .borrow_mut()
161            .as_mut()
162            .unwrap()
163            .insert(ident);
164    }
165    
166    
167    fn dep_analyse_plain_call_expr(
168        &mut self,
169        _span: TokenSpan,
170        //ident: Ident,
171        arg_exprs: &[Expr],
172        fn_ptr: FnPtr,
173        
174    ) {
175        //let ident = ident_path.get_single().expect("IMPL");
176        for arg_expr in arg_exprs {
177            self.dep_analyse_expr(arg_expr);
178        }
179        let mut set = self.fn_def.callees.borrow_mut();
180        set.as_mut().unwrap().insert(fn_ptr);
181    }
182    
183    fn dep_analyse_field_expr(&mut self, _span: TokenSpan, expr: &Expr, field_ident: Ident) {
184        // so we have to store which 'shader props' we use
185        match expr.ty.borrow().as_ref().unwrap(){
186            Ty::DrawShader(_)=>{
187                self.fn_def.draw_shader_refs.borrow_mut().as_mut().unwrap().insert(field_ident);
188            }
189            _=>{
190                  self.dep_analyse_expr(expr)
191            }
192        }
193       
194    }
195    
196    fn dep_analyse_index_expr(&mut self, _span: TokenSpan, expr: &Expr, index_expr: &Expr) {
197        self.dep_analyse_expr(expr);
198        self.dep_analyse_expr(index_expr);
199    }
200    
201    fn dep_analyse_cons_call_expr(&mut self, _span: TokenSpan, ty_lit: TyLit, arg_exprs: &[Expr]) {
202        for arg_expr in arg_exprs {
203            self.dep_analyse_expr(arg_expr);
204        }
205        self.fn_def
206            .constructor_fn_deps
207            .borrow_mut()
208            .as_mut()
209            .unwrap()
210            .insert((
211            ty_lit,
212            arg_exprs
213                .iter()
214                .map( | arg_expr | arg_expr.ty.borrow().as_ref().unwrap().clone())
215                .collect::<Vec<_ >> (),
216        ));
217    }
218    
219    fn dep_analyse_struct_cons(
220        &mut self,
221        struct_ptr: StructPtr,
222        _span: TokenSpan,
223        args: &Vec<(Ident,Expr)>,
224    ) {
225        // alright we have a struct constructor
226        self.fn_def.struct_refs.borrow_mut().as_mut().unwrap().insert(struct_ptr);
227        for arg in args{
228            self.dep_analyse_expr(&arg.1);
229        }
230    }    
231    
232    fn dep_analyse_var_expr(&mut self, _span: TokenSpan, ty:Option<&Ty>, kind: &Cell<Option<VarKind >>) {
233        // alright so. a var expr..
234        match kind.get().unwrap() {
235            VarKind::LiveValue(value_ptr)=>{
236                self.fn_def.live_refs.borrow_mut().as_mut().unwrap().insert(value_ptr, ty.unwrap().clone());
237            }
238            VarKind::Local{..} | VarKind::MutLocal{..}=>{ // we need to store the type
239                match ty{
240                    Some(Ty::Struct(struct_ptr))=>{
241                        self.fn_def.struct_refs.borrow_mut().as_mut().unwrap().insert(*struct_ptr);
242                    }
243                    Some(Ty::Array{..})=>{
244                        todo!();
245                    }
246                    _=>()
247                }
248            },
249        };
250        
251    }
252
253    fn dep_analyse_lit_expr(&mut self, _span: TokenSpan, _lit: Lit) {}
254}
makepad_shader_compiler/dep_analyse.rs

makepad_shader_compiler/
dep_analyse.rs
