makepad_shader_compiler/
shader_parser.rs

1use {
2    std::{
3        iter::Cloned,
4        slice::Iter,
5        cell::{Cell, RefCell}
6    },
7    crate::{
8        makepad_live_id::*,
9        makepad_live_compiler::*,
10        makepad_live_compiler::makepad_live_tokenizer::Delim,
11        shader_ast::*,
12        shader_registry::{ShaderRegistry, LiveNodeFindResult}
13    }
14};
15
16#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Ord, PartialOrd)]
17pub enum ShaderParserDep {
18    Struct(StructPtr),
19    Function(Option<StructPtr>, FnPtr)
20}
21
22pub struct ShaderParser<'a> {
23    pub token_index: usize,
24    pub dsl_expand_index: usize,
25    pub origin_file_id: LiveFileId,
26    pub tokens_with_span: Cloned<Iter<'a, TokenWithSpan >>,
27    pub live_registry: &'a LiveRegistry,
28    pub shader_registry: &'a ShaderRegistry,
29    pub type_deps: &'a mut Vec<ShaderParserDep>,
30    pub closure_defs: Vec<ClosureDef>,
31    pub token_with_span: TokenWithSpan,
32    pub self_kind: Option<FnSelfKind>,
33    pub end: TextPos,
34}
35
36impl<'a> ShaderParser<'a> {
37    pub fn new(
38        live_registry: &'a LiveRegistry,
39        shader_registry: &'a ShaderRegistry,
40        tokens: &'a [TokenWithSpan],
41        type_deps: &'a mut Vec<ShaderParserDep>,
42        self_kind: Option<FnSelfKind>,
43        dsl_expand_index: usize,
44        origin_file_id: LiveFileId,
45        token_start: usize
46    ) -> Self {
47        let mut tokens_with_span = tokens.iter().cloned();
48        let token_with_span = tokens_with_span.next().unwrap();
49        ShaderParser {
50            closure_defs: Vec::new(),
51            live_registry,
52            shader_registry,
53            dsl_expand_index,
54            origin_file_id,
55            type_deps,
56            tokens_with_span,
57            token_with_span,
58            token_index: token_start,
59            end: TextPos::default(),
60            self_kind
61        }
62    }
63}
64
65impl<'a> ShaderParser<'a> {
66    
67    #[inline]
68    fn peek_span(&self) -> TextSpan {
69        self.token_with_span.span
70    }
71    
72    #[inline]
73    fn peek_token(&self) -> LiveToken {
74        self.token_with_span.token.clone()
75    }
76    
77    #[inline]
78    fn eat_token(&mut self) -> LiveToken {
79        let token = self.peek_token();
80        self.skip_token();
81        token
82    }
83    
84    #[inline]
85    fn skip_token(&mut self) {
86        self.end = self.token_with_span.span.end;
87        if LiveToken::Eof == self.token_with_span.token {
88            return
89        }
90        
91        if let Some(token_with_span) = self.tokens_with_span.next() {
92            self.token_with_span = token_with_span;
93            self.token_index += 1;
94        }
95        else {
96            self.token_with_span = TokenWithSpan {
97                span: self.token_with_span.span,
98                token: LiveToken::Eof
99            };
100            self.token_index += 1;
101        }
102    }
103    
104    fn error(&mut self, origin: LiveErrorOrigin, message: String) -> LiveError {
105        LiveError {
106            origin,
107            span: self.token_with_span.span.into(),
108            message,
109        }
110    }
111    
112    fn end(&self) -> TextPos {
113        self.end
114    }
115    
116    fn token_end(&self) -> TextPos {
117        self.token_with_span.span.end
118    }
119    
120    #[inline]
121    fn accept_ident(&mut self) -> Option<Ident> {
122        if let LiveToken::Ident(id) = self.peek_token() {
123            self.skip_token();
124            Some(Ident(id))
125        }
126        else {
127            None
128        }
129    }
130    
131    fn expect_ident_path(&mut self) -> Result<IdentPath, LiveError> {
132        let mut ident_path = IdentPath::default();
133        let span = self.begin_span();
134        match self.peek_token() {
135            LiveToken::Ident(ident) => {
136                self.skip_token();
137                ident_path.push(Ident(ident));
138            },
139            token => {
140                return Err(span.error(self, live_error_origin!(), format!("expected ident_path, unexpected token `{}`", token)));
141            }
142        };
143        
144        loop {
145            if !self.accept_token(LiveToken::Punct(live_id!(::))) {
146                return Ok(ident_path);
147            }
148            match self.peek_token() {
149                LiveToken::Ident(ident) => {
150                    self.skip_token();
151                    if !ident_path.push(Ident(ident)) {
152                        return Err(span.error(self, live_error_origin!(), format!("identifier too long `{}`", ident_path)));
153                    }
154                },
155                _ => {
156                    return Ok(ident_path);
157                }
158            }
159        }
160    }
161    
162    #[inline]
163    fn accept_token(&mut self, token: LiveToken) -> bool {
164        if self.peek_token() != token {
165            return false;
166        }
167        self.skip_token();
168        true
169    }
170    
171    #[inline]
172    fn expect_ident(&mut self, live_error_origin: LiveErrorOrigin) -> Result<Ident, LiveError> {
173        match self.peek_token() {
174            LiveToken::Ident(id) => {
175                self.skip_token();
176                Ok(Ident(id))
177            }
178            token => Err(self.error(live_error_origin, format!("expected ident, unexpected token `{}`", token))),
179        }
180    }
181    
182    #[inline]
183    fn expect_specific_ident(&mut self, specific_id: LiveId) -> Result<(), LiveError> {
184        match self.peek_token() {
185            LiveToken::Ident(id) if id == id => {
186                self.skip_token();
187                Ok(())
188            }
189            token => Err(self.error(live_error_origin!(), format!("expected ident {}, unexpected token `{}`", specific_id, token))),
190        }
191    }
192    
193    #[inline]
194    fn expect_token(&mut self, expected: LiveToken) -> Result<(), LiveError> {
195        let actual = self.peek_token();
196        if actual != expected {
197            return Err(self.error(live_error_origin!(), format!("expected {} unexpected token `{}`", expected, actual)));
198        }
199        self.skip_token();
200        Ok(())
201    }
202    
203    #[inline]
204    fn begin_span(&self) -> SpanTracker {
205        SpanTracker {
206            file_id: self.token_with_span.span.file_id,
207            start: self.token_with_span.span.start,
208            start_index: self.token_index
209        }
210    }
211    
212    // lets parse a function.
213    pub fn expect_self_decl(&mut self, ident: Ident, decl_node_ptr: LivePtr) -> Result<Option<DrawShaderFieldDef>, LiveError> {
214        let span = self.begin_span();
215        let decl_ty = self.expect_ident(live_error_origin!()) ?;
216        let decl_name = self.expect_ident(live_error_origin!()) ?;
217        if decl_name != ident {
218            panic!()
219        }
220        self.expect_token(LiveToken::Punct(live_id!(:))) ?;
221        // now we expect a type
222        let ty_expr = self.expect_ty_expr() ?;
223        match decl_ty {
224            Ident(live_id!(geometry)) => {
225                return span.end(self, | span | Ok(Some(DrawShaderFieldDef {
226                    kind: DrawShaderFieldKind::Geometry {
227                        is_used_in_pixel_shader: Cell::new(false),
228                        var_def_ptr: Some(VarDefPtr(decl_node_ptr)),
229                    },
230                    span,
231                    ident,
232                    ty_expr
233                })))
234            }
235            Ident(live_id!(instance)) => {
236                return span.end(self, | span | Ok(Some(DrawShaderFieldDef {
237                    kind: DrawShaderFieldKind::Instance {
238                        is_used_in_pixel_shader: Cell::new(false),
239                        live_field_kind: LiveFieldKind::Live,
240                        var_def_ptr: Some(VarDefPtr(decl_node_ptr)),
241                        //input_type: DrawShaderInputType::VarDef(decl_node_ptr),
242                    },
243                    span,
244                    ident,
245                    ty_expr
246                })))
247            }
248            Ident(live_id!(uniform)) => {
249                let block_ident = if self.accept_token(LiveToken::Ident(live_id!(in))) {
250                    self.expect_ident(live_error_origin!()) ?
251                }
252                else {
253                    Ident(live_id!(user))
254                };
255                return span.end(self, | span | Ok(Some(DrawShaderFieldDef {
256                    kind: DrawShaderFieldKind::Uniform {
257                        var_def_ptr: Some(VarDefPtr(decl_node_ptr)),
258                        //input_type: DrawShaderInputType::VarDef(decl_node_ptr),
259                        block_ident,
260                    },
261                    span,
262                    ident,
263                    ty_expr
264                })))
265            }
266            Ident(live_id!(varying)) => {
267                return span.end(self, | span | Ok(Some(DrawShaderFieldDef {
268                    kind: DrawShaderFieldKind::Varying {
269                        var_def_ptr: VarDefPtr(decl_node_ptr),
270                    },
271                    span,
272                    ident,
273                    ty_expr
274                })))
275            }
276            Ident(live_id!(texture)) => {
277                return span.end(self, | span | Ok(Some(DrawShaderFieldDef {
278                    kind: DrawShaderFieldKind::Texture {
279                        var_def_ptr: Some(VarDefPtr(decl_node_ptr)),
280                        //input_type: DrawShaderInputType::VarDef(decl_node_ptr),
281                    },
282                    span,
283                    ident,
284                    ty_expr
285                })))
286            }
287            Ident(live_id!(const)) => {
288                return Ok(None)
289            }
290            _ => {
291                return Err(span.error(self, live_error_origin!(), format!("unexpected decl type `{}`", decl_ty)))
292            }
293        }
294    }
295    
296    // lets parse a function.
297    pub fn expect_const_def(&mut self, ident: Ident) -> Result<ConstDef, LiveError> {
298        let span = self.begin_span();
299        let decl_ty = self.expect_ident(live_error_origin!()) ?;
300        let decl_name = self.expect_ident(live_error_origin!()) ?;
301        if decl_name != ident {
302            panic!()
303        }
304        self.expect_token(LiveToken::Punct(live_id!(:))) ?;
305        // now we expect a type
306        let ty_expr = self.expect_ty_expr() ?;
307        self.expect_token(LiveToken::Punct(live_id!( =))) ?;
308        
309        let expr = self.expect_expr() ?;
310        
311        if decl_ty != Ident(live_id!(const)) {
312            panic!()
313        }
314        
315        // ok lets parse the value
316        return span.end(self, | span | Ok(ConstDef {
317            span,
318            ident,
319            ty_expr,
320            expr
321        }))
322    }
323    
324    // lets parse a function.
325    /*
326    pub fn expect_field(&mut self, ident: Ident, var_def_ptr: VarDefPtr) -> Result<Option<StructFieldDef>, LiveError> {
327        let span = self.begin_span();
328        let decl_ty = self.expect_ident(live_error_origin!()) ?;
329        let decl_name = self.expect_ident(live_error_origin!()) ?;
330        if decl_name != ident {
331            panic!()
332        }
333        self.expect_token(LiveToken::Punct(live_id!(:))) ?;
334        // now we expect a type
335        let ty_expr = self.expect_ty_expr() ?;
336        match decl_ty {
337            Ident(live_id!(field)) => {
338                return span.end(self, | span | Ok(Some(StructFieldDef {
339                    var_def_ptr,
340                    span,
341                    ident,
342                    ty_expr
343                })))
344            }
345            _ => {
346                return Err(span.error(self, live_error_origin!(), format!("unexpected decl type in struct `{}`", decl_ty).into()))
347            }
348        }
349    }*/
350    
351    // lets parse a function.
352    pub fn expect_method_def(mut self, fn_ptr: FnPtr, outer_ident: Ident) -> Result<Option<FnDef>, LiveError> {
353        
354        let span = self.begin_span();
355        self.expect_specific_ident(live_id!(fn)) ?;
356        let ident = self.expect_ident(live_error_origin!()) ?;
357        if ident != outer_ident {
358            panic!();
359        }
360        self.expect_token(LiveToken::Open(Delim::Paren)) ?;
361        let mut params = Vec::new();
362        if !self.accept_token(LiveToken::Close(Delim::Paren)) {
363            
364            let span = self.begin_span();
365            let is_inout = self.accept_token(LiveToken::Ident(live_id!(inout)));
366            
367            if self.peek_token() != LiveToken::Ident(live_id!(self)) {
368                return Ok(None)
369            }
370            self.skip_token();
371            //self.expect_token(token_ident!(self)) ?;
372            
373            let kind = self.self_kind.unwrap().to_ty_expr_kind();
374            params.push(span.end(&mut self, | span | Param {
375                span,
376                is_inout,
377                ident: Ident(live_id!(self)),
378                shadow: Cell::new(None),
379                ty_expr: TyExpr {
380                    span,
381                    ty: RefCell::new(None),
382                    kind
383                },
384            }));
385            
386            while self.accept_token(LiveToken::Punct(live_id!(,))) {
387                params.push(self.expect_param() ?);
388            }
389            self.expect_token(LiveToken::Close(Delim::Paren)) ?;
390        }
391        let return_ty_expr = if self.accept_token(LiveToken::Punct(live_id!( ->))) {
392            Some(self.expect_ty_expr() ?)
393        } else {
394            None
395        };
396        let block = self.expect_block() ?;
397        let self_kind = self.self_kind.clone();
398        let span = span.end(&mut self, | span | span);
399        Ok(Some(FnDef::new(
400            fn_ptr,
401            span,
402            ident,
403            self_kind,
404            params,
405            return_ty_expr,
406            block,
407            self.closure_defs
408        )))
409    }
410    
411    // lets parse a function.
412    pub fn expect_plain_fn_def(mut self, fn_ptr: FnPtr, outer_ident: Ident) -> Result<FnDef, LiveError> {
413        let span = self.begin_span();
414        self.expect_specific_ident(live_id!(fn)) ?;
415        let ident = self.expect_ident(live_error_origin!()) ?;
416        if ident != outer_ident {
417            panic!();
418        }
419        self.expect_token(LiveToken::Open(Delim::Paren)) ?;
420        let mut params = Vec::new();
421        if !self.accept_token(LiveToken::Close(Delim::Paren)) {
422            if self.peek_token() == LiveToken::Ident(live_id!(self)) {
423                return Err(span.error(&mut self, live_error_origin!(), format!("use of self not allowed in plain function")))
424            }
425            let param = self.expect_param() ?;
426            
427            params.push(param);
428            while self.accept_token(LiveToken::Punct(live_id!(,))) {
429                params.push(self.expect_param() ?);
430            }
431            self.expect_token(LiveToken::Close(Delim::Paren)) ?;
432        }
433        let return_ty_expr = if self.accept_token(LiveToken::Punct(live_id!( ->))) {
434            Some(self.expect_ty_expr() ?)
435        } else {
436            None
437        };
438        let block = self.expect_block() ?;
439        let self_kind = self.self_kind.clone();
440        let span = span.end(&mut self, | span | span);
441        Ok(FnDef::new(
442            fn_ptr,
443            span,
444            ident,
445            self_kind,
446            params,
447            return_ty_expr,
448            block,
449            self.closure_defs
450        ))
451    }
452    
453    fn expect_ty_expr(&mut self) -> Result<TyExpr, LiveError> {
454        let span = self.begin_span();
455        let mut acc = self.expect_prim_ty_expr() ?;
456        if self.accept_token(LiveToken::Open(Delim::Bracket)) {
457            let elem_ty_expr = Box::new(acc);
458            let token = self.peek_token();
459            if let Some(Lit::Int(len)) = Lit::from_token(&token) {
460                self.skip_token();
461                self.expect_token(LiveToken::Close(Delim::Bracket)) ?;
462                acc = span.end(self, | span | TyExpr {
463                    ty: RefCell::new(None),
464                    span,
465                    kind: TyExprKind::Array {
466                        elem_ty_expr,
467                        len: len as u32,
468                    },
469                });
470            }
471            else {
472                return Err(span.error(self, live_error_origin!(), format!("unexpected token `{}`", token)))
473            }
474        }
475        Ok(acc)
476    }
477    
478    fn expect_prim_ty_expr(&mut self) -> Result<TyExpr, LiveError> {
479        let span = self.begin_span();
480        match self.peek_token() {
481            LiveToken::Ident(id) => {
482                // properly parse type here
483                if id == live_id!(fn) {
484                    self.skip_token();
485                    // ok now we parse (ident:ty, ty)
486                    self.expect_token(LiveToken::Open(Delim::Paren)) ?;
487                    let mut params = Vec::new();
488                    if !self.accept_token(LiveToken::Close(Delim::Paren)) {
489                        params.push(self.expect_param() ?);
490                        while self.accept_token(LiveToken::Punct(live_id!(,))) {
491                            params.push(self.expect_param() ?);
492                        }
493                        self.expect_token(LiveToken::Close(Delim::Paren)) ?;
494                    }
495                    let return_ty_expr = if self.accept_token(LiveToken::Punct(live_id!( ->))) {
496                        Some(self.expect_ty_expr() ?)
497                    } else {
498                        None
499                    };
500                    Ok(span.end(self, | span | TyExpr {
501                        ty: RefCell::new(None),
502                        span,
503                        kind: TyExprKind::ClosureDecl {
504                            params,
505                            return_ty: RefCell::new(None),
506                            return_ty_expr: Box::new(return_ty_expr)
507                        },
508                    }))
509                }
510                else
511                if let Some(ty_lit) = TyLit::from_id(id) {
512                    self.skip_token();
513                    Ok(span.end(self, | span | TyExpr {
514                        ty: RefCell::new(None),
515                        span,
516                        kind: TyExprKind::Lit {ty_lit: ty_lit},
517                    }))
518                }
519                else {
520                    if id == live_id!(Self) {
521                        self.skip_token();
522                        if let Some(FnSelfKind::Struct(struct_node_ptr)) = self.self_kind {
523                            return Ok(span.end(self, | span | TyExpr {
524                                span,
525                                ty: RefCell::new(None),
526                                kind: TyExprKind::Struct(struct_node_ptr),
527                            }))
528                        }
529                        return Err(span.error(self, live_error_origin!(), "Use of Self not allowed here".to_string()));
530                    }
531                    // ok lets tget the ident path
532                    
533                    let ident_path = self.expect_ident_path() ?;
534                    
535                    if let Some(ptr) = self.live_registry.find_scope_ptr_via_expand_index(self.origin_file_id, self.dsl_expand_index, ident_path.segs[0]) {
536                        match self.shader_registry.find_live_node_by_path(self.live_registry, ptr, &ident_path.segs[1..ident_path.len()]) {
537                            LiveNodeFindResult::Error(err) => {
538                                return Err(err)
539                            }
540                            LiveNodeFindResult::NotFound => {
541                                return Err(span.error(self, live_error_origin!(), format!("Struct not found `{}`", ident_path)))
542                            }
543                            LiveNodeFindResult::Function(_)
544                                | LiveNodeFindResult::Component(_)
545                                | LiveNodeFindResult::LiveValue(_, _)
546                                | LiveNodeFindResult::PossibleStatic(_, _) => {
547                                return Err(span.error(self, live_error_origin!(), format!("Not a Struct type `{}`", ident_path)))
548                            }
549                            LiveNodeFindResult::Struct(struct_ptr) => {
550                                //yay .. lets make a struct typedep
551                                self.type_deps.push(ShaderParserDep::Struct(struct_ptr));
552                                return Ok(span.end(self, | span | TyExpr {
553                                    span,
554                                    ty: RefCell::new(None),
555                                    kind: TyExprKind::Struct(struct_ptr),
556                                }))
557                            }
558                        }
559                    }
560                    else {
561                        return Err(span.error(self, live_error_origin!(), format!("Cannot find type `{}`", ident_path).into()));
562                    }
563                }
564            }
565            token => Err(span.error(self, live_error_origin!(), format!("unexpected token `{}`", token).into())),
566        }
567    }
568    
569    fn expect_param(&mut self) -> Result<Param, LiveError> {
570        let span = self.begin_span();
571        let is_inout = self.accept_token(LiveToken::Ident(live_id!(inout)));
572        let ident = self.expect_ident(live_error_origin!()) ?;
573        self.expect_token(LiveToken::Punct(live_id!(:))) ?;
574        let ty_expr = self.expect_ty_expr() ?;
575        Ok(span.end(self, | span | Param {
576            shadow: Cell::new(None),
577            span,
578            is_inout,
579            ident,
580            ty_expr,
581        }))
582    }
583    
584    fn expect_block(&mut self) -> Result<Block, LiveError> {
585        self.expect_token(LiveToken::Open(Delim::Brace)) ?;
586        let mut stmts = Vec::new();
587        while !self.accept_token(LiveToken::Close(Delim::Brace)) {
588            stmts.push(self.expect_stmt() ?);
589        }
590        Ok(Block {stmts})
591    }
592    
593    
594    fn expect_stmt(&mut self) -> Result<Stmt, LiveError> {
595        match self.peek_token() {
596            LiveToken::Ident(live_id!(break)) => self.expect_break_stmt(),
597            LiveToken::Ident(live_id!(continue)) => self.expect_continue_stmt(),
598            LiveToken::Ident(live_id!(for)) => self.expect_for_stmt(),
599            LiveToken::Ident(live_id!(if)) => self.expect_if_stmt(),
600            LiveToken::Ident(live_id!(match)) => self.expect_match_stmt(),
601            LiveToken::Ident(live_id!(let)) => self.expect_let_stmt(),
602            LiveToken::Ident(live_id!(return)) => self.expect_return_stmt(),
603            _ => self.expect_expr_stmt(),
604        }
605    }
606    
607    fn expect_break_stmt(&mut self) -> Result<Stmt, LiveError> {
608        let span = self.begin_span();
609        self.expect_token(LiveToken::Ident(live_id!(break))) ?;
610        self.accept_optional_delim();
611        //self.expect_token(Token::Punct(live_id!(;))) ?;
612        Ok(span.end(self, | span | Stmt::Break {span}))
613    }
614    
615    fn expect_continue_stmt(&mut self) -> Result<Stmt, LiveError> {
616        let span = self.begin_span();
617        self.expect_token(LiveToken::Ident(live_id!(continue))) ?;
618        self.accept_optional_delim();
619        //self.expect_token(Token::Punct(live_id!(;))) ?;
620        Ok(span.end(self, | span | Stmt::Continue {span}))
621    }
622    
623    fn expect_for_stmt(&mut self) -> Result<Stmt, LiveError> {
624        let span = self.begin_span();
625        self.expect_token(LiveToken::Ident(live_id!(for))) ?;
626        let ident = self.expect_ident(live_error_origin!()) ?;
627        
628        self.expect_token(LiveToken::Ident(live_id!(in))) ?;
629        
630        let from_expr = self.expect_expr() ?;
631        self.expect_token(LiveToken::Punct(live_id!(..))) ?;
632        //self.expect_token(LiveToken::Ident(live_id!(to))) ?;
633        let to_expr = self.expect_expr() ?;
634        let step_expr = if self.accept_token(LiveToken::Ident(live_id!(step_by))) {
635            Some(self.expect_expr() ?)
636        } else {
637            None
638        };
639        let block = Box::new(self.expect_block() ?);
640        Ok(span.end(self, | span | Stmt::For {
641            span,
642            ident,
643            from_expr,
644            to_expr,
645            step_expr,
646            block,
647        }))
648    }
649    
650    
651    fn expect_if_stmt(&mut self) -> Result<Stmt, LiveError> {
652        let span = self.begin_span();
653        self.expect_token(LiveToken::Ident(live_id!(if))) ?;
654        let expr = self.expect_expr() ?;
655        let block_if_true = Box::new(self.expect_block() ?);
656        let block_if_false = if self.accept_token(LiveToken::Ident(live_id!(else))) {
657            if self.peek_token() == LiveToken::Ident(live_id!(if)) {
658                Some(Box::new(Block {
659                    stmts: vec![self.expect_if_stmt() ?],
660                }))
661            } else {
662                Some(Box::new(self.expect_block() ?))
663            }
664        } else {
665            None
666        };
667        Ok(span.end(self, | span | Stmt::If {
668            span,
669            expr,
670            block_if_true,
671            block_if_false,
672        }))
673    }
674    
675    fn expect_match_item(&mut self) -> Result<Match, LiveError> {
676        let span = self.begin_span();
677        let enum_name = self.expect_ident(live_error_origin!()) ?;
678        self.expect_token(LiveToken::Punct(live_id!(::))) ?;
679        let enum_variant = self.expect_ident(live_error_origin!()) ?;
680        
681        self.expect_token(LiveToken::Punct(live_id!( =>))) ?;
682        let block = self.expect_block() ?;
683        Ok(span.end(self, | span | Match {
684            span,
685            enum_name,
686            enum_variant,
687            enum_value: Cell::new(None),
688            block
689        }))
690    }
691    
692    fn expect_match_stmt(&mut self) -> Result<Stmt, LiveError> {
693        let span = self.begin_span();
694        self.expect_token(LiveToken::Ident(live_id!(match))) ?;
695        
696        let expr = self.expect_expr() ?;
697        
698        // now we parse our match block
699        self.expect_token(LiveToken::Open(Delim::Brace)) ?;
700        
701        let mut matches = Vec::new();
702        while !self.accept_token(LiveToken::Close(Delim::Brace)) {
703            matches.push(self.expect_match_item() ?);
704        }
705        
706        Ok(span.end(self, | span | Stmt::Match {
707            span,
708            expr,
709            matches,
710        }))
711    }
712    
713    fn expect_let_stmt(&mut self) -> Result<Stmt, LiveError> {
714        let span = self.begin_span();
715        self.expect_token(LiveToken::Ident(live_id!(let))) ?;
716        self.accept_token(LiveToken::Ident(live_id!(mut)));
717        let ident = self.expect_ident(live_error_origin!()) ?;
718            
719        let ty_expr = if self.accept_token(LiveToken::Punct(live_id!(:))) {
720            Some(self.expect_ty_expr() ?)
721        } else {
722            None
723        };
724        let expr = if self.accept_token(LiveToken::Punct(live_id!( =))) {
725            Some(self.expect_expr() ?)
726        } else {
727            None
728        };
729        self.accept_optional_delim();
730        //self.expect_token(Token::Punct(live_id!(;))) ?;
731        Ok(span.end(self, | span | Stmt::Let {
732            span,
733            shadow: Cell::new(None),
734            ty: RefCell::new(None),
735            ident,
736            ty_expr,
737            expr,
738        }))
739    }
740    
741    fn expect_return_stmt(&mut self) -> Result<Stmt, LiveError> {
742        let span = self.begin_span();
743        self.expect_token(LiveToken::Ident(live_id!(return))) ?;
744        // if we have a void return type, we don't expect expr otherwise we do
745        
746        let expr = if !self.accept_token(LiveToken::Punct(live_id!(;))) {
747            if self.peek_token() == LiveToken::Close(Delim::Brace) {
748                None
749            }
750            else {
751                let expr = self.expect_expr() ?;
752                self.accept_optional_delim();
753                Some(expr)
754            }
755        } else {
756            None
757        };
758        Ok(span.end(self, | span | Stmt::Return {span, expr}))
759    }
760    
761    fn expect_expr_stmt(&mut self) -> Result<Stmt, LiveError> {
762        let span = self.begin_span();
763        let expr = self.expect_expr() ?;
764        self.accept_optional_delim();
765        Ok(span.end(self, | span | Stmt::Expr {span, expr}))
766    }
767    
768    fn expect_expr(&mut self) -> Result<Expr, LiveError> {
769        self.expect_assign_expr()
770    }
771    
772    fn expect_assign_expr(&mut self) -> Result<Expr, LiveError> {
773        let span = self.begin_span();
774        let expr = self.expect_cond_expr() ?;
775        Ok(if let Some(op) = BinOp::from_assign_op(self.peek_token()) {
776            self.skip_token();
777            let left_expr = Box::new(expr);
778            let right_expr = Box::new(self.expect_assign_expr() ?);
779            span.end(self, | span | Expr {
780                span,
781                ty: RefCell::new(None),
782                const_val: RefCell::new(None),
783                const_index: Cell::new(None),
784                kind: ExprKind::Bin {
785                    span,
786                    op,
787                    left_expr,
788                    right_expr,
789                },
790            })
791        } else {
792            expr
793        })
794    }
795    
796    
797    fn expect_cond_expr(&mut self) -> Result<Expr, LiveError> {
798        let span = self.begin_span();
799        let expr = self.expect_or_expr() ?;
800        Ok(if self.accept_token(LiveToken::Punct(live_id!( ?))) {
801            let expr = Box::new(expr);
802            let expr_if_true = Box::new(self.expect_expr() ?);
803            self.expect_token(LiveToken::Punct(live_id!(:))) ?;
804            let expr_if_false = Box::new(self.expect_cond_expr() ?);
805            span.end(self, | span | Expr {
806                span,
807                ty: RefCell::new(None),
808                const_val: RefCell::new(None),
809                const_index: Cell::new(None),
810                kind: ExprKind::Cond {
811                    span,
812                    expr,
813                    expr_if_true,
814                    expr_if_false,
815                },
816            })
817        } else {
818            expr
819        })
820    }
821    
822    
823    fn expect_or_expr(&mut self) -> Result<Expr, LiveError> {
824        let span = self.begin_span();
825        let mut acc = self.expect_and_expr() ?;
826        while let Some(op) = BinOp::from_or_op(self.peek_token()) {
827            self.skip_token();
828            let left_expr = Box::new(acc);
829            let right_expr = Box::new(self.expect_and_expr() ?);
830            acc = span.end(self, | span | Expr {
831                span,
832                ty: RefCell::new(None),
833                const_val: RefCell::new(None),
834                const_index: Cell::new(None),
835                kind: ExprKind::Bin {
836                    span,
837                    op,
838                    left_expr,
839                    right_expr,
840                },
841            });
842        }
843        Ok(acc)
844    }
845    
846    
847    fn expect_and_expr(&mut self) -> Result<Expr, LiveError> {
848        let span = self.begin_span();
849        let mut acc = self.expect_eq_expr() ?;
850        while let Some(op) = BinOp::from_and_op(self.peek_token()) {
851            self.skip_token();
852            let left_expr = Box::new(acc);
853            let right_expr = Box::new(self.expect_eq_expr() ?);
854            acc = span.end(self, | span | Expr {
855                span,
856                ty: RefCell::new(None),
857                const_val: RefCell::new(None),
858                const_index: Cell::new(None),
859                kind: ExprKind::Bin {
860                    span,
861                    op,
862                    left_expr,
863                    right_expr,
864                },
865            });
866        }
867        Ok(acc)
868    }
869    
870    
871    fn expect_eq_expr(&mut self) -> Result<Expr, LiveError> {
872        let span = self.begin_span();
873        let mut acc = self.expect_rel_expr() ?;
874        while let Some(op) = BinOp::from_eq_op(self.peek_token()) {
875            self.skip_token();
876            let left_expr = Box::new(acc);
877            let right_expr = Box::new(self.expect_rel_expr() ?);
878            acc = span.end(self, | span | Expr {
879                span,
880                ty: RefCell::new(None),
881                const_val: RefCell::new(None),
882                const_index: Cell::new(None),
883                kind: ExprKind::Bin {
884                    span,
885                    op,
886                    left_expr,
887                    right_expr,
888                },
889            });
890        }
891        Ok(acc)
892    }
893    
894    fn expect_rel_expr(&mut self) -> Result<Expr, LiveError> {
895        let span = self.begin_span();
896        let mut acc = self.expect_add_expr() ?;
897        while let Some(op) = BinOp::from_rel_op(self.peek_token()) {
898            self.skip_token();
899            let left_expr = Box::new(acc);
900            let right_expr = Box::new(self.expect_add_expr() ?);
901            acc = span.end(self, | span | Expr {
902                span,
903                ty: RefCell::new(None),
904                const_val: RefCell::new(None),
905                const_index: Cell::new(None),
906                kind: ExprKind::Bin {
907                    span,
908                    op,
909                    left_expr,
910                    right_expr,
911                },
912            });
913        }
914        Ok(acc)
915    }
916    
917    fn expect_add_expr(&mut self) -> Result<Expr, LiveError> {
918        let span = self.begin_span();
919        let mut acc = self.expect_mul_expr() ?;
920        while let Some(op) = BinOp::from_add_op(self.peek_token()) {
921            self.skip_token();
922            let left_expr = Box::new(acc);
923            let right_expr = Box::new(self.expect_mul_expr() ?);
924            acc = span.end(self, | span | Expr {
925                span,
926                ty: RefCell::new(None),
927                const_val: RefCell::new(None),
928                const_index: Cell::new(None),
929                kind: ExprKind::Bin {
930                    span,
931                    op,
932                    left_expr,
933                    right_expr,
934                },
935            });
936        }
937        Ok(acc)
938    }
939    
940    fn expect_mul_expr(&mut self) -> Result<Expr, LiveError> {
941        let span = self.begin_span();
942        let mut acc = self.expect_un_expr() ?;
943        while let Some(op) = BinOp::from_mul_op(self.peek_token()) {
944            self.skip_token();
945            let left_expr = Box::new(acc);
946            let right_expr = Box::new(self.expect_un_expr() ?);
947            acc = span.end(self, | span | Expr {
948                span,
949                ty: RefCell::new(None),
950                const_val: RefCell::new(None),
951                const_index: Cell::new(None),
952                kind: ExprKind::Bin {
953                    span,
954                    op,
955                    left_expr,
956                    right_expr,
957                },
958            });
959        }
960        Ok(acc)
961    }
962    
963    fn expect_un_expr(&mut self) -> Result<Expr, LiveError> {
964        let span = self.begin_span();
965        Ok(if let Some(op) = UnOp::from_un_op(self.peek_token()) {
966            self.skip_token();
967            let expr = Box::new(self.expect_un_expr() ?);
968            span.end(self, | span | Expr {
969                span,
970                ty: RefCell::new(None),
971                const_val: RefCell::new(None),
972                const_index: Cell::new(None),
973                kind: ExprKind::Un {span, op, expr},
974            })
975        } else {
976            self.expect_postfix_expr() ?
977        })
978    }
979    
980    fn expect_postfix_expr(&mut self) -> Result<Expr, LiveError> {
981        let span = self.begin_span();
982        let mut acc = self.expect_prim_expr() ?;
983        loop {
984            match self.peek_token() {
985                LiveToken::Punct(live_id!(.)) => {
986                    self.skip_token();
987                    let ident = self.expect_ident(live_error_origin!()) ?;
988                    acc = if self.accept_token(LiveToken::Open(Delim::Paren)) {
989                        let mut arg_exprs = vec![acc];
990                        if !self.accept_token(LiveToken::Close(Delim::Paren)) {
991                            loop {
992                                arg_exprs.push(self.expect_expr() ?);
993                                if !self.accept_token(LiveToken::Punct(live_id!(,))) {
994                                    break;
995                                }
996                            }
997                            self.expect_token(LiveToken::Close(Delim::Paren)) ?;
998                        }
999                        span.end(self, | span | Expr {
1000                            span,
1001                            ty: RefCell::new(None),
1002                            const_val: RefCell::new(None),
1003                            const_index: Cell::new(None),
1004                            kind: ExprKind::MethodCall {
1005                                span,
1006                                ident,
1007                                arg_exprs,
1008                                closure_site_index: Cell::new(None)
1009                            },
1010                        })
1011                    } else {
1012                        let expr = Box::new(acc);
1013                        span.end(self, | span | Expr {
1014                            span,
1015                            ty: RefCell::new(None),
1016                            const_val: RefCell::new(None),
1017                            const_index: Cell::new(None),
1018                            kind: ExprKind::Field {
1019                                span,
1020                                expr,
1021                                field_ident: ident,
1022                            },
1023                        })
1024                    }
1025                }
1026                LiveToken::Close(Delim::Bracket) => {
1027                    self.skip_token();
1028                    let expr = Box::new(acc);
1029                    let index_expr = Box::new(self.expect_expr() ?);
1030                    self.expect_token(LiveToken::Close(Delim::Bracket)) ?;
1031                    acc = span.end(self, | span | Expr {
1032                        span,
1033                        ty: RefCell::new(None),
1034                        const_val: RefCell::new(None),
1035                        const_index: Cell::new(None),
1036                        kind: ExprKind::Index {
1037                            span,
1038                            expr,
1039                            index_expr,
1040                        },
1041                    });
1042                }
1043                _ => break,
1044            }
1045        }
1046        Ok(acc)
1047    }
1048    
1049    
1050    fn expect_prim_expr(&mut self) -> Result<Expr, LiveError> {
1051        let span = self.begin_span();
1052        match self.peek_token() {
1053            LiveToken::Ident(ident) => {
1054                if let Some(ty_lit) = TyLit::from_id(ident) {
1055                    self.skip_token();
1056                    self.expect_token(LiveToken::Open(Delim::Paren)) ?;
1057                    let mut arg_exprs = Vec::new();
1058                    if !self.accept_token(LiveToken::Close(Delim::Paren)) {
1059                        loop {
1060                            arg_exprs.push(self.expect_expr() ?);
1061                            if !self.accept_token(LiveToken::Punct(live_id!(,))) {
1062                                break;
1063                            }
1064                        }
1065                        self.expect_token(LiveToken::Close(Delim::Paren)) ?;
1066                    }
1067                    return Ok(span.end(self, | span | Expr {
1068                        span,
1069                        ty: RefCell::new(None),
1070                        const_val: RefCell::new(None),
1071                        const_index: Cell::new(None),
1072                        kind: ExprKind::ConsCall {
1073                            span,
1074                            ty_lit,
1075                            arg_exprs,
1076                        },
1077                    }))
1078                }
1079                else {
1080                    let ident_path = self.expect_ident_path() ?;
1081                    match self.peek_token() {
1082                        LiveToken::Open(Delim::Brace) => { // its a struct constructor call
1083                            
1084                            let struct_ptr = if ident_path.len() == 1 && ident_path.segs[0] == live_id!(Self) {
1085                                if let Some(FnSelfKind::Struct(struct_node_ptr)) = self.self_kind {
1086                                    struct_node_ptr
1087                                }
1088                                else {
1089                                    return Err(span.error(self, live_error_origin!(), format!("Use of Self not allowed here").into()));
1090                                }
1091                            }
1092                            else if let Some(ptr) = self.live_registry.find_scope_ptr_via_expand_index(self.origin_file_id, self.dsl_expand_index, ident_path.segs[0]) {
1093                                match self.shader_registry.find_live_node_by_path(self.live_registry, ptr, &ident_path.segs[1..ident_path.len()]) {
1094                                    LiveNodeFindResult::Error(err) => {
1095                                        return Err(err)
1096                                    }
1097                                    LiveNodeFindResult::Struct(struct_ptr) => {
1098                                        self.type_deps.push(ShaderParserDep::Struct(struct_ptr));
1099                                        struct_ptr
1100                                    }
1101                                    LiveNodeFindResult::NotFound => {
1102                                        return Err(span.error(self, live_error_origin!(), format!("Struct not found `{}`", ident_path).into()))
1103                                    }
1104                                    LiveNodeFindResult::PossibleStatic(_, _)
1105                                        | LiveNodeFindResult::Function(_)
1106                                        | LiveNodeFindResult::Component(_)
1107                                    //    | LiveNodeFindResult::Const(_)
1108                                        | LiveNodeFindResult::LiveValue(_, _) => {
1109                                        return Err(span.error(self, live_error_origin!(), format!("Not a struct `{}`", ident_path).into()))
1110                                    }
1111                                }
1112                            }
1113                            else {
1114                                return Err(span.error(self, live_error_origin!(), format!("Struct not found `{}`", ident_path).into()))
1115                            };
1116                            
1117                            self.skip_token();
1118                            let mut args = Vec::new();
1119                            loop {
1120                                let name = self.expect_ident(live_error_origin!()) ?;
1121                                self.expect_token(LiveToken::Punct(live_id!(:))) ?;
1122                                let expr = self.expect_expr() ?;
1123                                self.accept_token(LiveToken::Punct(live_id!(,)));
1124                                args.push((name, expr));
1125                                // see if we have a } or a ,
1126                                match self.peek_token() {
1127                                    LiveToken::Eof => {
1128                                        return Err(span.error(self, live_error_origin!(), format!("Unexpected Eof").into()))
1129                                    }
1130                                    LiveToken::Close(Delim::Brace) => {
1131                                        self.skip_token();
1132                                        return Ok(span.end(self, | span | Expr {
1133                                            span,
1134                                            ty: RefCell::new(None),
1135                                            const_val: RefCell::new(None),
1136                                            const_index: Cell::new(None),
1137                                            kind: ExprKind::StructCons {
1138                                                struct_ptr,
1139                                                span,
1140                                                args
1141                                            },
1142                                        }))
1143                                    }
1144                                    _ => ()
1145                                }
1146                                
1147                            }
1148                        }
1149                        LiveToken::Open(Delim::Paren) => {
1150                            let arg_exprs = self.expect_arg_exprs() ?;
1151                            if ident_path.len() == 1 && self.shader_registry.builtins.get(&Ident(ident_path.segs[0])).is_some() {
1152                                Ok(span.end(self, | span | Expr {
1153                                    span,
1154                                    ty: RefCell::new(None),
1155                                    const_val: RefCell::new(None),
1156                                    const_index: Cell::new(None),
1157                                    kind: ExprKind::BuiltinCall {
1158                                        span,
1159                                        ident: Ident(ident_path.segs[0]),
1160                                        arg_exprs,
1161                                    },
1162                                }))
1163                            }
1164                            else if let Some(ptr) = self.live_registry.find_scope_ptr_via_expand_index(self.origin_file_id, self.dsl_expand_index, ident_path.segs[0]) {
1165                                match self.shader_registry.find_live_node_by_path(self.live_registry, ptr, &ident_path.segs[1..ident_path.len()]) {
1166                                    LiveNodeFindResult::Error(err) => {
1167                                        return Err(err)
1168                                    }
1169                                    LiveNodeFindResult::NotFound => {
1170                                        Err(span.error(self, live_error_origin!(), format!("Function not found `{}`", ident_path).into()))
1171                                    }
1172                                    LiveNodeFindResult::Component(_)
1173                                        | LiveNodeFindResult::Struct(_)
1174                                    //    | LiveNodeFindResult::Const(_)
1175                                        | LiveNodeFindResult::LiveValue(_, _) => {
1176                                        Err(span.error(self, live_error_origin!(), format!("Not a function `{}`", ident_path).into()))
1177                                    }
1178                                    LiveNodeFindResult::Function(fn_ptr) => {
1179                                        self.type_deps.push(ShaderParserDep::Function(None, fn_ptr));
1180                                        Ok(span.end(self, | span | Expr {
1181                                            span,
1182                                            ty: RefCell::new(None),
1183                                            const_val: RefCell::new(None),
1184                                            const_index: Cell::new(None),
1185                                            kind: ExprKind::PlainCall {
1186                                                span,
1187                                                fn_ptr: Some(fn_ptr),
1188                                                ident: if ident_path.len() == 1 {Some(Ident(ident_path.segs[0]))}else {None},
1189                                                arg_exprs,
1190                                                param_index: Cell::new(None),
1191                                                closure_site_index: Cell::new(None),
1192                                            },
1193                                        }))
1194                                        //Err(span.error(self, live_error_origin!(), format!("Cannot call a struct `{}`", ident_path).into()))
1195                                    }
1196                                    LiveNodeFindResult::PossibleStatic(struct_ptr, fn_ptr) => {
1197                                        // we need to register struct_node_ptr as a dep to compile
1198                                        self.type_deps.push(ShaderParserDep::Struct(struct_ptr));
1199                                        self.type_deps.push(ShaderParserDep::Function(Some(struct_ptr), fn_ptr));
1200                                        Ok(span.end(self, | span | Expr {
1201                                            span,
1202                                            ty: RefCell::new(None),
1203                                            const_val: RefCell::new(None),
1204                                            const_index: Cell::new(None),
1205                                            kind: ExprKind::PlainCall {
1206                                                span,
1207                                                ident: if ident_path.len() == 1 {Some(Ident(ident_path.segs[0]))}else {None},
1208                                                fn_ptr: Some(fn_ptr),
1209                                                arg_exprs,
1210                                                param_index: Cell::new(None),
1211                                                closure_site_index: Cell::new(None),
1212                                            },
1213                                        }))
1214                                        //Err(span.error(self, live_error_origin!(), format!("Cannot call a struct `{}`", ident_path).into()))
1215                                    }
1216                                    
1217                                }
1218                            }
1219                            else if ident_path.len() == 1 {
1220                                // it must be a closure call, even though we don't know if its really there.
1221                                Ok(span.end(self, | span | Expr {
1222                                    span,
1223                                    ty: RefCell::new(None),
1224                                    const_val: RefCell::new(None),
1225                                    const_index: Cell::new(None),
1226                                    kind: ExprKind::PlainCall {
1227                                        span,
1228                                        ident: Some(Ident(ident_path.segs[0])),
1229                                        fn_ptr: None,
1230                                        arg_exprs,
1231                                        param_index: Cell::new(None),
1232                                        closure_site_index: Cell::new(None),
1233                                    },
1234                                }))
1235                            }
1236                            else {
1237                                Err(span.error(self, live_error_origin!(), format!("Call not found `{}`", ident_path).into()))
1238                            }
1239                        }
1240                        _ => {
1241                            // ok we wanna resolve, however if its multi-segment and not resolved it fails.
1242                            
1243                            let mut var_resolve = VarResolve::NotFound;
1244                            
1245                            if let Some(ptr) = self.live_registry.find_scope_ptr_via_expand_index(self.origin_file_id, self.dsl_expand_index, ident_path.segs[0]) {
1246                                
1247                                let find_result = self.shader_registry.find_live_node_by_path(self.live_registry, ptr, &ident_path.segs[1..ident_path.len()]);
1248                                match find_result {
1249                                   LiveNodeFindResult::Error(err)=>{
1250                                        return Err(err)
1251                                    }
1252                                    LiveNodeFindResult::LiveValue(value_ptr, ty) => {
1253                                        var_resolve = VarResolve::LiveValue(value_ptr, ty);
1254                                    }
1255                                    //LiveNodeFindResult::Const(const_ptr) => {
1256                                    //    self.type_deps.push(ShaderParserDep::Const(const_ptr));
1257                                    //    var_resolve = VarResolve::Const(const_ptr);
1258                                    // }
1259                                    LiveNodeFindResult::Function(fn_ptr) => {
1260                                        self.type_deps.push(ShaderParserDep::Function(None, fn_ptr));
1261                                        var_resolve = VarResolve::Function(fn_ptr);
1262                                    }
1263                                    _ => {}
1264                                }
1265                            }
1266                            if let VarResolve::NotFound = var_resolve {
1267                                if ident_path.len()>1 {
1268                                    return Err(span.error(self, live_error_origin!(), format!("Identifier not found `{}`", ident_path).into()))
1269                                }
1270                            }
1271                            
1272                            Ok(span.end(self, | span | Expr {
1273                                span,
1274                                ty: RefCell::new(None),
1275                                const_val: RefCell::new(None),
1276                                const_index: Cell::new(None),
1277                                kind: ExprKind::Var {
1278                                    ident: if ident_path.len()>1 {None} else {Some(Ident(ident_path.segs[0]))},
1279                                    span,
1280                                    var_resolve,
1281                                    kind: Cell::new(None),
1282                                },
1283                            }))
1284                        },
1285                    }
1286                }
1287            }
1288            LiveToken::Bool(v) => {
1289                self.skip_token();
1290                Ok(span.end(self, | span | Expr {
1291                    span,
1292                    ty: RefCell::new(None),
1293                    const_val: RefCell::new(None),
1294                    const_index: Cell::new(None),
1295                    kind: ExprKind::Lit {span, lit: Lit::Bool(v)},
1296                }))
1297            }
1298            LiveToken::Int(v) => {
1299                self.skip_token();
1300                Ok(span.end(self, | span | Expr {
1301                    span,
1302                    ty: RefCell::new(None),
1303                    const_val: RefCell::new(None),
1304                    const_index: Cell::new(None),
1305                    kind: ExprKind::Lit {span, lit: Lit::Float(v as f32)},
1306                }))
1307            }
1308            LiveToken::Float(v) => {
1309                self.skip_token();
1310                Ok(span.end(self, | span | Expr {
1311                    span,
1312                    ty: RefCell::new(None),
1313                    const_val: RefCell::new(None),
1314                    const_index: Cell::new(None),
1315                    kind: ExprKind::Lit {span, lit: Lit::Float(v as f32)},
1316                }))
1317            }
1318            LiveToken::Color(v) => {
1319                self.skip_token();
1320                Ok(span.end(self, | span | Expr {
1321                    span,
1322                    ty: RefCell::new(None),
1323                    const_val: RefCell::new(None),
1324                    const_index: Cell::new(None),
1325                    kind: ExprKind::Lit {span, lit: Lit::Color(v)},
1326                }))
1327            }
1328            LiveToken::Punct(live_id!( |)) => {
1329                // closure def
1330                self.skip_token();
1331                let mut params = Vec::new();
1332                if !self.accept_token(LiveToken::Punct(live_id!( |))) {
1333                    loop {
1334                        let span = self.begin_span();
1335                        params.push(ClosureParam {
1336                            ident: self.expect_ident(live_error_origin!()) ?,
1337                            span: span.end(self, | span | span),
1338                            shadow: Cell::new(None)
1339                        });
1340                        if !self.accept_token(LiveToken::Punct(live_id!(,))) {
1341                            break;
1342                        }
1343                    }
1344                    self.expect_token(LiveToken::Punct(live_id!( |))) ?;
1345                }
1346                if self.peek_token() == LiveToken::Open(Delim::Brace) {
1347                    let block = self.expect_block() ?;
1348                    let span = span.end(self, | span | span);
1349                    let closure_def_index = ClosureDefIndex(self.closure_defs.len());
1350                    self.closure_defs.push(ClosureDef {
1351                        span,
1352                        params,
1353                        closed_over_syms: RefCell::new(None),
1354                        kind: ClosureDefKind::Block(block)
1355                    });
1356                    Ok(Expr {
1357                        span,
1358                        ty: RefCell::new(None),
1359                        const_val: RefCell::new(None),
1360                        const_index: Cell::new(None),
1361                        kind: ExprKind::ClosureDef(closure_def_index)
1362                    })
1363                }
1364                else {
1365                    let expr = self.expect_expr() ?;
1366                    let span = span.end(self, | span | span);
1367                    let closure_def_index = ClosureDefIndex(self.closure_defs.len());
1368                    self.closure_defs.push(ClosureDef {
1369                        span,
1370                        params,
1371                        closed_over_syms: RefCell::new(None),
1372                        kind: ClosureDefKind::Expr(expr)
1373                    });
1374                    Ok(Expr {
1375                        span,
1376                        ty: RefCell::new(None),
1377                        const_val: RefCell::new(None),
1378                        const_index: Cell::new(None),
1379                        kind: ExprKind::ClosureDef(closure_def_index)
1380                    })
1381                }
1382            }
1383            LiveToken::Open(Delim::Paren) => {
1384                self.skip_token();
1385                let expr = self.expect_expr() ?;
1386                self.expect_token(LiveToken::Close(Delim::Paren)) ?;
1387                Ok(expr)
1388            }
1389            token => Err(span.error(self, live_error_origin!(), format!("unexpected token `{}`", token).into())),
1390        }
1391    }
1392    
1393    fn expect_arg_exprs(&mut self) -> Result<Vec<Expr>, LiveError> {
1394        self.expect_token(LiveToken::Open(Delim::Paren)) ?;
1395        let mut arg_exprs = Vec::new();
1396        if !self.accept_token(LiveToken::Close(Delim::Paren)) {
1397            loop {
1398                arg_exprs.push(self.expect_expr() ?);
1399                if !self.accept_token(LiveToken::Punct(live_id!(,))) {
1400                    break;
1401                }
1402            }
1403            self.expect_token(LiveToken::Close(Delim::Paren)) ?;
1404        }
1405        Ok(arg_exprs)
1406    }
1407    
1408    pub fn accept_optional_delim(&mut self) {
1409        while self.accept_token(LiveToken::Punct(live_id!(;))) {};
1410    }
1411}
1412
1413
1414pub struct SpanTracker {
1415    pub file_id: LiveFileId,
1416    pub start: TextPos,
1417    pub start_index: usize,
1418}
1419
1420impl SpanTracker {
1421    pub fn end<F, R>(&self, parser: &mut ShaderParser, f: F) -> R
1422    where
1423    F: FnOnce(TokenSpan) -> R,
1424    {
1425        f(TokenSpan {
1426            token_id: LiveTokenId::new(self.file_id, self.start_index),
1427            len: parser.token_index - self.start_index
1428        })
1429    }
1430    
1431    pub fn error(&self, parser: &mut ShaderParser, origin: LiveErrorOrigin, message: String) -> LiveError {
1432        LiveError {
1433            origin,
1434            span: TextSpan {
1435                file_id: self.file_id,
1436                start: self.start,
1437                end: parser.token_end(),
1438            }.into(),
1439            message,
1440        }
1441    }
1442}
makepad_shader_compiler/shader_parser.rs

makepad_shader_compiler/
shader_parser.rs
