makepad_shader_compiler/
lhs_check.rs

1use{
2    std::cell::Cell,
3    crate::{
4        makepad_live_compiler::*,
5        shader_ast::*,
6        shader_registry::ShaderRegistry
7    }
8};
9
10pub struct LhsChecker<'a> {
11    pub scopes: &'a Scopes,
12    pub shader_registry: &'a ShaderRegistry,
13}
14
15impl<'a> LhsChecker<'a> {
16    pub fn lhs_check_expr(&mut self, expr: &Expr) -> Result<(), LiveError> {
17        match expr.kind {
18            ExprKind::Cond {
19                span,
20                ref expr,
21                ref expr_if_true,
22                ref expr_if_false,
23                ..
24            } => self.lhs_check_cond_expr(span, expr, expr_if_true, expr_if_false),
25            ExprKind::Bin {
26                span,
27                op,
28                ref left_expr,
29                ref right_expr,
30                ..
31            } => self.lhs_check_bin_expr(span, op, left_expr, right_expr),
32            ExprKind::Un {span, op, ref expr} => self.lhs_check_un_expr(span, op, expr),
33            ExprKind::Field {
34                span,
35                ref expr,
36                field_ident,
37            } => self.lhs_check_field_expr(span, expr, field_ident),
38            ExprKind::Index {
39                span,
40                ref expr,
41                ref index_expr,
42            } => self.lhs_check_index_expr(span, expr, index_expr),
43            ExprKind::MethodCall {
44                span,
45                ..
46            } => self.lhs_check_all_call_expr(span),
47            ExprKind::PlainCall {
48                span,
49                ..
50            } => self.lhs_check_all_call_expr(span),
51           /* ExprKind::ClosureCall {
52                span,
53                ..
54            } => self.lhs_check_all_call_expr(span),*/
55            ExprKind::ClosureDef(_) => self.lhs_check_closure(expr.span),
56            ExprKind::BuiltinCall {
57                span,
58                ..
59            } => self.lhs_check_all_call_expr(span),
60            ExprKind::ConsCall {
61                span,
62                ..
63            } => self.lhs_check_all_call_expr(span),
64            ExprKind::StructCons {
65                span,
66                ..
67            } => self.lhs_check_all_call_expr(span),
68            ExprKind::Var {
69                span,
70                ref kind,
71                ..
72            } => self.lhs_check_var_expr(span, kind),
73            ExprKind::Lit {span, lit} => self.lhs_check_lit_expr(span, lit),
74        }
75    }
76    
77    fn lhs_check_closure(
78        &mut self,
79        span: TokenSpan,
80    ) -> Result<(), LiveError> {
81        return Err(LiveError {
82            origin: live_error_origin!(),
83            span:span.into(),
84            message: String::from("expression is not a valid left hand side"),
85        });
86    }
87    
88    fn lhs_check_cond_expr(
89        &mut self,
90        span: TokenSpan,
91        _expr: &Expr,
92        _expr_if_true: &Expr,
93        _expr_if_false: &Expr,
94    ) -> Result<(), LiveError> {
95        return Err(LiveError {
96            origin: live_error_origin!(),
97            span:span.into(),
98            message: String::from("expression is not a valid left hand side"),
99        });
100    }
101    
102    fn lhs_check_bin_expr(
103        &mut self,
104        span: TokenSpan,
105        _op: BinOp,
106        _left_expr: &Expr,
107        _right_expr: &Expr,
108    ) -> Result<(), LiveError> {
109        return Err(LiveError {
110            origin:live_error_origin!(),
111            span:span.into(),
112            message: String::from("expression is not a valid left hand side"),
113        });
114    }
115    
116    fn lhs_check_un_expr(&mut self, span: TokenSpan, _op: UnOp, _expr: &Expr) -> Result<(), LiveError> {
117        return Err(LiveError {
118            origin:live_error_origin!(),
119            span:span.into(),
120            message: String::from("expression is not a valid left hand side"),
121        });
122    }
123    
124    fn lhs_check_all_call_expr(
125        &mut self,
126        span: TokenSpan,
127    ) -> Result<(), LiveError> {
128        return Err(LiveError {
129            origin:live_error_origin!(),
130            span:span.into(),
131            message: String::from("expression is not a valid left hand side"),
132        });
133    }
134    
135    fn lhs_check_field_expr(
136        &mut self,
137        span: TokenSpan,
138        expr: &Expr,
139        field_ident: Ident,
140    ) -> Result<(), LiveError> {
141        // lets grab the ty from expr
142        match expr.ty.borrow().as_ref().unwrap(){
143            Ty::DrawShader(shader_ptr)=>{
144                let field_decl = self.shader_registry.draw_shader_defs.get(shader_ptr).unwrap().find_field(field_ident) .unwrap();
145                match &field_decl.kind{
146                    DrawShaderFieldKind::Varying{..}=>{
147                        Ok(())
148                    }
149                    _=>{
150                        Err(LiveError {
151                            origin:live_error_origin!(),
152                            span:span.into(),
153                            message: String::from("Can only assign to varying values for shader self"),
154                        })
155                    }
156                }
157            }
158            _=>{
159                 self.lhs_check_expr(expr)
160            }
161        }
162    }
163    
164    fn lhs_check_index_expr(
165        &mut self,
166        _span: TokenSpan,
167        expr: &Expr,
168        _index_expr: &Expr,
169    ) -> Result<(), LiveError> {
170        self.lhs_check_expr(expr)
171    }
172    
173    fn lhs_check_call_expr(
174        &mut self,
175        span: TokenSpan,
176        _ident_path: IdentPath,
177        _arg_exprs: &[Expr],
178    ) -> Result<(), LiveError> {
179        return Err(LiveError {
180            origin:live_error_origin!(),
181            span:span.into(),
182            message: String::from("expression is not a valid left hand side"),
183        });
184    }
185    
186    fn lhs_check_var_expr(
187        &mut self,
188        span: TokenSpan,
189        kind: &Cell<Option<VarKind >>,
190    ) -> Result<(), LiveError> {
191        if let VarKind::MutLocal{..} = kind.get().unwrap(){
192            Ok(())
193        }
194        else{
195            Err(LiveError {
196                origin:live_error_origin!(),
197                span:span.into(),
198                message: String::from("expression is not a valid left hand side"),
199            })
200        }
201    }
202    /*
203    fn lhs_check_live_id_expr(
204        &mut self,
205        span: Span,
206        _kind: &Cell<Option<VarKind>>,
207        _id:LiveItemId,
208        _ident: Ident,
209    ) -> Result<(), LiveError> {
210        return Err(LiveError {
211            span,
212            message: String::from("liveid is not a valid left hand side"),
213        });
214    }*/
215    
216    fn lhs_check_lit_expr(&mut self, _span: TokenSpan, _lit: Lit) -> Result<(), LiveError> {
217        Ok(())
218    }
219}
makepad_shader_compiler/lhs_check.rs

makepad_shader_compiler/
lhs_check.rs
