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        let ident = self.expect_ident(live_error_origin!()) ?;
717        let ty_expr = if self.accept_token(LiveToken::Punct(live_id!(:))) {
718            Some(self.expect_ty_expr() ?)
719        } else {
720            None
721        };
722        let expr = if self.accept_token(LiveToken::Punct(live_id!( =))) {
723            Some(self.expect_expr() ?)
724        } else {
725            None
726        };
727        self.accept_optional_delim();
728        //self.expect_token(Token::Punct(live_id!(;))) ?;
729        Ok(span.end(self, | span | Stmt::Let {
730            span,
731            shadow: Cell::new(None),
732            ty: RefCell::new(None),
733            ident,
734            ty_expr,
735            expr,
736        }))
737    }
738    
739    fn expect_return_stmt(&mut self) -> Result<Stmt, LiveError> {
740        let span = self.begin_span();
741        self.expect_token(LiveToken::Ident(live_id!(return))) ?;
742        // if we have a void return type, we don't expect expr otherwise we do
743        
744        let expr = if !self.accept_token(LiveToken::Punct(live_id!(;))) {
745            if self.peek_token() == LiveToken::Close(Delim::Brace) {
746                None
747            }
748            else {
749                let expr = self.expect_expr() ?;
750                self.accept_optional_delim();
751                Some(expr)
752            }
753        } else {
754            None
755        };
756        Ok(span.end(self, | span | Stmt::Return {span, expr}))
757    }
758    
759    fn expect_expr_stmt(&mut self) -> Result<Stmt, LiveError> {
760        let span = self.begin_span();
761        let expr = self.expect_expr() ?;
762        self.accept_optional_delim();
763        Ok(span.end(self, | span | Stmt::Expr {span, expr}))
764    }
765    
766    fn expect_expr(&mut self) -> Result<Expr, LiveError> {
767        self.expect_assign_expr()
768    }
769    
770    fn expect_assign_expr(&mut self) -> Result<Expr, LiveError> {
771        let span = self.begin_span();
772        let expr = self.expect_cond_expr() ?;
773        Ok(if let Some(op) = BinOp::from_assign_op(self.peek_token()) {
774            self.skip_token();
775            let left_expr = Box::new(expr);
776            let right_expr = Box::new(self.expect_assign_expr() ?);
777            span.end(self, | span | Expr {
778                span,
779                ty: RefCell::new(None),
780                const_val: RefCell::new(None),
781                const_index: Cell::new(None),
782                kind: ExprKind::Bin {
783                    span,
784                    op,
785                    left_expr,
786                    right_expr,
787                },
788            })
789        } else {
790            expr
791        })
792    }
793    
794    
795    fn expect_cond_expr(&mut self) -> Result<Expr, LiveError> {
796        let span = self.begin_span();
797        let expr = self.expect_or_expr() ?;
798        Ok(if self.accept_token(LiveToken::Punct(live_id!( ?))) {
799            let expr = Box::new(expr);
800            let expr_if_true = Box::new(self.expect_expr() ?);
801            self.expect_token(LiveToken::Punct(live_id!(:))) ?;
802            let expr_if_false = Box::new(self.expect_cond_expr() ?);
803            span.end(self, | span | Expr {
804                span,
805                ty: RefCell::new(None),
806                const_val: RefCell::new(None),
807                const_index: Cell::new(None),
808                kind: ExprKind::Cond {
809                    span,
810                    expr,
811                    expr_if_true,
812                    expr_if_false,
813                },
814            })
815        } else {
816            expr
817        })
818    }
819    
820    
821    fn expect_or_expr(&mut self) -> Result<Expr, LiveError> {
822        let span = self.begin_span();
823        let mut acc = self.expect_and_expr() ?;
824        while let Some(op) = BinOp::from_or_op(self.peek_token()) {
825            self.skip_token();
826            let left_expr = Box::new(acc);
827            let right_expr = Box::new(self.expect_and_expr() ?);
828            acc = span.end(self, | span | Expr {
829                span,
830                ty: RefCell::new(None),
831                const_val: RefCell::new(None),
832                const_index: Cell::new(None),
833                kind: ExprKind::Bin {
834                    span,
835                    op,
836                    left_expr,
837                    right_expr,
838                },
839            });
840        }
841        Ok(acc)
842    }
843    
844    
845    fn expect_and_expr(&mut self) -> Result<Expr, LiveError> {
846        let span = self.begin_span();
847        let mut acc = self.expect_eq_expr() ?;
848        while let Some(op) = BinOp::from_and_op(self.peek_token()) {
849            self.skip_token();
850            let left_expr = Box::new(acc);
851            let right_expr = Box::new(self.expect_eq_expr() ?);
852            acc = span.end(self, | span | Expr {
853                span,
854                ty: RefCell::new(None),
855                const_val: RefCell::new(None),
856                const_index: Cell::new(None),
857                kind: ExprKind::Bin {
858                    span,
859                    op,
860                    left_expr,
861                    right_expr,
862                },
863            });
864        }
865        Ok(acc)
866    }
867    
868    
869    fn expect_eq_expr(&mut self) -> Result<Expr, LiveError> {
870        let span = self.begin_span();
871        let mut acc = self.expect_rel_expr() ?;
872        while let Some(op) = BinOp::from_eq_op(self.peek_token()) {
873            self.skip_token();
874            let left_expr = Box::new(acc);
875            let right_expr = Box::new(self.expect_rel_expr() ?);
876            acc = span.end(self, | span | Expr {
877                span,
878                ty: RefCell::new(None),
879                const_val: RefCell::new(None),
880                const_index: Cell::new(None),
881                kind: ExprKind::Bin {
882                    span,
883                    op,
884                    left_expr,
885                    right_expr,
886                },
887            });
888        }
889        Ok(acc)
890    }
891    
892    fn expect_rel_expr(&mut self) -> Result<Expr, LiveError> {
893        let span = self.begin_span();
894        let mut acc = self.expect_add_expr() ?;
895        while let Some(op) = BinOp::from_rel_op(self.peek_token()) {
896            self.skip_token();
897            let left_expr = Box::new(acc);
898            let right_expr = Box::new(self.expect_add_expr() ?);
899            acc = span.end(self, | span | Expr {
900                span,
901                ty: RefCell::new(None),
902                const_val: RefCell::new(None),
903                const_index: Cell::new(None),
904                kind: ExprKind::Bin {
905                    span,
906                    op,
907                    left_expr,
908                    right_expr,
909                },
910            });
911        }
912        Ok(acc)
913    }
914    
915    fn expect_add_expr(&mut self) -> Result<Expr, LiveError> {
916        let span = self.begin_span();
917        let mut acc = self.expect_mul_expr() ?;
918        while let Some(op) = BinOp::from_add_op(self.peek_token()) {
919            self.skip_token();
920            let left_expr = Box::new(acc);
921            let right_expr = Box::new(self.expect_mul_expr() ?);
922            acc = span.end(self, | span | Expr {
923                span,
924                ty: RefCell::new(None),
925                const_val: RefCell::new(None),
926                const_index: Cell::new(None),
927                kind: ExprKind::Bin {
928                    span,
929                    op,
930                    left_expr,
931                    right_expr,
932                },
933            });
934        }
935        Ok(acc)
936    }
937    
938    fn expect_mul_expr(&mut self) -> Result<Expr, LiveError> {
939        let span = self.begin_span();
940        let mut acc = self.expect_un_expr() ?;
941        while let Some(op) = BinOp::from_mul_op(self.peek_token()) {
942            self.skip_token();
943            let left_expr = Box::new(acc);
944            let right_expr = Box::new(self.expect_un_expr() ?);
945            acc = span.end(self, | span | Expr {
946                span,
947                ty: RefCell::new(None),
948                const_val: RefCell::new(None),
949                const_index: Cell::new(None),
950                kind: ExprKind::Bin {
951                    span,
952                    op,
953                    left_expr,
954                    right_expr,
955                },
956            });
957        }
958        Ok(acc)
959    }
960    
961    fn expect_un_expr(&mut self) -> Result<Expr, LiveError> {
962        let span = self.begin_span();
963        Ok(if let Some(op) = UnOp::from_un_op(self.peek_token()) {
964            self.skip_token();
965            let expr = Box::new(self.expect_un_expr() ?);
966            span.end(self, | span | Expr {
967                span,
968                ty: RefCell::new(None),
969                const_val: RefCell::new(None),
970                const_index: Cell::new(None),
971                kind: ExprKind::Un {span, op, expr},
972            })
973        } else {
974            self.expect_postfix_expr() ?
975        })
976    }
977    
978    fn expect_postfix_expr(&mut self) -> Result<Expr, LiveError> {
979        let span = self.begin_span();
980        let mut acc = self.expect_prim_expr() ?;
981        loop {
982            match self.peek_token() {
983                LiveToken::Punct(live_id!(.)) => {
984                    self.skip_token();
985                    let ident = self.expect_ident(live_error_origin!()) ?;
986                    acc = if self.accept_token(LiveToken::Open(Delim::Paren)) {
987                        let mut arg_exprs = vec![acc];
988                        if !self.accept_token(LiveToken::Close(Delim::Paren)) {
989                            loop {
990                                arg_exprs.push(self.expect_expr() ?);
991                                if !self.accept_token(LiveToken::Punct(live_id!(,))) {
992                                    break;
993                                }
994                            }
995                            self.expect_token(LiveToken::Close(Delim::Paren)) ?;
996                        }
997                        span.end(self, | span | Expr {
998                            span,
999                            ty: RefCell::new(None),
1000                            const_val: RefCell::new(None),
1001                            const_index: Cell::new(None),
1002                            kind: ExprKind::MethodCall {
1003                                span,
1004                                ident,
1005                                arg_exprs,
1006                                closure_site_index: Cell::new(None)
1007                            },
1008                        })
1009                    } else {
1010                        let expr = Box::new(acc);
1011                        span.end(self, | span | Expr {
1012                            span,
1013                            ty: RefCell::new(None),
1014                            const_val: RefCell::new(None),
1015                            const_index: Cell::new(None),
1016                            kind: ExprKind::Field {
1017                                span,
1018                                expr,
1019                                field_ident: ident,
1020                            },
1021                        })
1022                    }
1023                }
1024                LiveToken::Close(Delim::Bracket) => {
1025                    self.skip_token();
1026                    let expr = Box::new(acc);
1027                    let index_expr = Box::new(self.expect_expr() ?);
1028                    self.expect_token(LiveToken::Close(Delim::Bracket)) ?;
1029                    acc = span.end(self, | span | Expr {
1030                        span,
1031                        ty: RefCell::new(None),
1032                        const_val: RefCell::new(None),
1033                        const_index: Cell::new(None),
1034                        kind: ExprKind::Index {
1035                            span,
1036                            expr,
1037                            index_expr,
1038                        },
1039                    });
1040                }
1041                _ => break,
1042            }
1043        }
1044        Ok(acc)
1045    }
1046    
1047    
1048    fn expect_prim_expr(&mut self) -> Result<Expr, LiveError> {
1049        let span = self.begin_span();
1050        match self.peek_token() {
1051            LiveToken::Ident(ident) => {
1052                if let Some(ty_lit) = TyLit::from_id(ident) {
1053                    self.skip_token();
1054                    self.expect_token(LiveToken::Open(Delim::Paren)) ?;
1055                    let mut arg_exprs = Vec::new();
1056                    if !self.accept_token(LiveToken::Close(Delim::Paren)) {
1057                        loop {
1058                            arg_exprs.push(self.expect_expr() ?);
1059                            if !self.accept_token(LiveToken::Punct(live_id!(,))) {
1060                                break;
1061                            }
1062                        }
1063                        self.expect_token(LiveToken::Close(Delim::Paren)) ?;
1064                    }
1065                    return Ok(span.end(self, | span | Expr {
1066                        span,
1067                        ty: RefCell::new(None),
1068                        const_val: RefCell::new(None),
1069                        const_index: Cell::new(None),
1070                        kind: ExprKind::ConsCall {
1071                            span,
1072                            ty_lit,
1073                            arg_exprs,
1074                        },
1075                    }))
1076                }
1077                else {
1078                    let ident_path = self.expect_ident_path() ?;
1079                    match self.peek_token() {
1080                        LiveToken::Open(Delim::Brace) => { // its a struct constructor call
1081                            
1082                            let struct_ptr = if ident_path.len() == 1 && ident_path.segs[0] == live_id!(Self) {
1083                                if let Some(FnSelfKind::Struct(struct_node_ptr)) = self.self_kind {
1084                                    struct_node_ptr
1085                                }
1086                                else {
1087                                    return Err(span.error(self, live_error_origin!(), format!("Use of Self not allowed here").into()));
1088                                }
1089                            }
1090                            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]) {
1091                                match self.shader_registry.find_live_node_by_path(self.live_registry, ptr, &ident_path.segs[1..ident_path.len()]) {
1092                                    LiveNodeFindResult::Error(err) => {
1093                                        return Err(err)
1094                                    }
1095                                    LiveNodeFindResult::Struct(struct_ptr) => {
1096                                        self.type_deps.push(ShaderParserDep::Struct(struct_ptr));
1097                                        struct_ptr
1098                                    }
1099                                    LiveNodeFindResult::NotFound => {
1100                                        return Err(span.error(self, live_error_origin!(), format!("Struct not found `{}`", ident_path).into()))
1101                                    }
1102                                    LiveNodeFindResult::PossibleStatic(_, _)
1103                                        | LiveNodeFindResult::Function(_)
1104                                        | LiveNodeFindResult::Component(_)
1105                                    //    | LiveNodeFindResult::Const(_)
1106                                        | LiveNodeFindResult::LiveValue(_, _) => {
1107                                        return Err(span.error(self, live_error_origin!(), format!("Not a struct `{}`", ident_path).into()))
1108                                    }
1109                                }
1110                            }
1111                            else {
1112                                return Err(span.error(self, live_error_origin!(), format!("Struct not found `{}`", ident_path).into()))
1113                            };
1114                            
1115                            self.skip_token();
1116                            let mut args = Vec::new();
1117                            loop {
1118                                let name = self.expect_ident(live_error_origin!()) ?;
1119                                self.expect_token(LiveToken::Punct(live_id!(:))) ?;
1120                                let expr = self.expect_expr() ?;
1121                                self.accept_token(LiveToken::Punct(live_id!(,)));
1122                                args.push((name, expr));
1123                                // see if we have a } or a ,
1124                                match self.peek_token() {
1125                                    LiveToken::Eof => {
1126                                        return Err(span.error(self, live_error_origin!(), format!("Unexpected Eof").into()))
1127                                    }
1128                                    LiveToken::Close(Delim::Brace) => {
1129                                        self.skip_token();
1130                                        return Ok(span.end(self, | span | Expr {
1131                                            span,
1132                                            ty: RefCell::new(None),
1133                                            const_val: RefCell::new(None),
1134                                            const_index: Cell::new(None),
1135                                            kind: ExprKind::StructCons {
1136                                                struct_ptr,
1137                                                span,
1138                                                args
1139                                            },
1140                                        }))
1141                                    }
1142                                    _ => ()
1143                                }
1144                                
1145                            }
1146                        }
1147                        LiveToken::Open(Delim::Paren) => {
1148                            let arg_exprs = self.expect_arg_exprs() ?;
1149                            if ident_path.len() == 1 && self.shader_registry.builtins.get(&Ident(ident_path.segs[0])).is_some() {
1150                                Ok(span.end(self, | span | Expr {
1151                                    span,
1152                                    ty: RefCell::new(None),
1153                                    const_val: RefCell::new(None),
1154                                    const_index: Cell::new(None),
1155                                    kind: ExprKind::BuiltinCall {
1156                                        span,
1157                                        ident: Ident(ident_path.segs[0]),
1158                                        arg_exprs,
1159                                    },
1160                                }))
1161                            }
1162                            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]) {
1163                                match self.shader_registry.find_live_node_by_path(self.live_registry, ptr, &ident_path.segs[1..ident_path.len()]) {
1164                                    LiveNodeFindResult::Error(err) => {
1165                                        return Err(err)
1166                                    }
1167                                    LiveNodeFindResult::NotFound => {
1168                                        Err(span.error(self, live_error_origin!(), format!("Function not found `{}`", ident_path).into()))
1169                                    }
1170                                    LiveNodeFindResult::Component(_)
1171                                        | LiveNodeFindResult::Struct(_)
1172                                    //    | LiveNodeFindResult::Const(_)
1173                                        | LiveNodeFindResult::LiveValue(_, _) => {
1174                                        Err(span.error(self, live_error_origin!(), format!("Not a function `{}`", ident_path).into()))
1175                                    }
1176                                    LiveNodeFindResult::Function(fn_ptr) => {
1177                                        self.type_deps.push(ShaderParserDep::Function(None, fn_ptr));
1178                                        Ok(span.end(self, | span | Expr {
1179                                            span,
1180                                            ty: RefCell::new(None),
1181                                            const_val: RefCell::new(None),
1182                                            const_index: Cell::new(None),
1183                                            kind: ExprKind::PlainCall {
1184                                                span,
1185                                                fn_ptr: Some(fn_ptr),
1186                                                ident: if ident_path.len() == 1 {Some(Ident(ident_path.segs[0]))}else {None},
1187                                                arg_exprs,
1188                                                param_index: Cell::new(None),
1189                                                closure_site_index: Cell::new(None),
1190                                            },
1191                                        }))
1192                                        //Err(span.error(self, live_error_origin!(), format!("Cannot call a struct `{}`", ident_path).into()))
1193                                    }
1194                                    LiveNodeFindResult::PossibleStatic(struct_ptr, fn_ptr) => {
1195                                        // we need to register struct_node_ptr as a dep to compile
1196                                        self.type_deps.push(ShaderParserDep::Struct(struct_ptr));
1197                                        self.type_deps.push(ShaderParserDep::Function(Some(struct_ptr), fn_ptr));
1198                                        Ok(span.end(self, | span | Expr {
1199                                            span,
1200                                            ty: RefCell::new(None),
1201                                            const_val: RefCell::new(None),
1202                                            const_index: Cell::new(None),
1203                                            kind: ExprKind::PlainCall {
1204                                                span,
1205                                                ident: if ident_path.len() == 1 {Some(Ident(ident_path.segs[0]))}else {None},
1206                                                fn_ptr: Some(fn_ptr),
1207                                                arg_exprs,
1208                                                param_index: Cell::new(None),
1209                                                closure_site_index: Cell::new(None),
1210                                            },
1211                                        }))
1212                                        //Err(span.error(self, live_error_origin!(), format!("Cannot call a struct `{}`", ident_path).into()))
1213                                    }
1214                                    
1215                                }
1216                            }
1217                            else if ident_path.len() == 1 {
1218                                // it must be a closure call, even though we don't know if its really there.
1219                                Ok(span.end(self, | span | Expr {
1220                                    span,
1221                                    ty: RefCell::new(None),
1222                                    const_val: RefCell::new(None),
1223                                    const_index: Cell::new(None),
1224                                    kind: ExprKind::PlainCall {
1225                                        span,
1226                                        ident: Some(Ident(ident_path.segs[0])),
1227                                        fn_ptr: None,
1228                                        arg_exprs,
1229                                        param_index: Cell::new(None),
1230                                        closure_site_index: Cell::new(None),
1231                                    },
1232                                }))
1233                            }
1234                            else {
1235                                Err(span.error(self, live_error_origin!(), format!("Call not found `{}`", ident_path).into()))
1236                            }
1237                        }
1238                        _ => {
1239                            // ok we wanna resolve, however if its multi-segment and not resolved it fails.
1240                            
1241                            let mut var_resolve = VarResolve::NotFound;
1242                            
1243                            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]) {
1244                                
1245                                let find_result = self.shader_registry.find_live_node_by_path(self.live_registry, ptr, &ident_path.segs[1..ident_path.len()]);
1246                                match find_result {
1247                                   LiveNodeFindResult::Error(err)=>{
1248                                        return Err(err)
1249                                    }
1250                                    LiveNodeFindResult::LiveValue(value_ptr, ty) => {
1251                                        var_resolve = VarResolve::LiveValue(value_ptr, ty);
1252                                    }
1253                                    //LiveNodeFindResult::Const(const_ptr) => {
1254                                    //    self.type_deps.push(ShaderParserDep::Const(const_ptr));
1255                                    //    var_resolve = VarResolve::Const(const_ptr);
1256                                    // }
1257                                    LiveNodeFindResult::Function(fn_ptr) => {
1258                                        self.type_deps.push(ShaderParserDep::Function(None, fn_ptr));
1259                                        var_resolve = VarResolve::Function(fn_ptr);
1260                                    }
1261                                    _ => {}
1262                                }
1263                            }
1264                            if let VarResolve::NotFound = var_resolve {
1265                                if ident_path.len()>1 {
1266                                    return Err(span.error(self, live_error_origin!(), format!("Identifier not found `{}`", ident_path).into()))
1267                                }
1268                            }
1269                            
1270                            Ok(span.end(self, | span | Expr {
1271                                span,
1272                                ty: RefCell::new(None),
1273                                const_val: RefCell::new(None),
1274                                const_index: Cell::new(None),
1275                                kind: ExprKind::Var {
1276                                    ident: if ident_path.len()>1 {None} else {Some(Ident(ident_path.segs[0]))},
1277                                    span,
1278                                    var_resolve,
1279                                    kind: Cell::new(None),
1280                                },
1281                            }))
1282                        },
1283                    }
1284                }
1285            }
1286            LiveToken::Bool(v) => {
1287                self.skip_token();
1288                Ok(span.end(self, | span | Expr {
1289                    span,
1290                    ty: RefCell::new(None),
1291                    const_val: RefCell::new(None),
1292                    const_index: Cell::new(None),
1293                    kind: ExprKind::Lit {span, lit: Lit::Bool(v)},
1294                }))
1295            }
1296            LiveToken::Int(v) => {
1297                self.skip_token();
1298                Ok(span.end(self, | span | Expr {
1299                    span,
1300                    ty: RefCell::new(None),
1301                    const_val: RefCell::new(None),
1302                    const_index: Cell::new(None),
1303                    kind: ExprKind::Lit {span, lit: Lit::Float(v as f32)},
1304                }))
1305            }
1306            LiveToken::Float(v) => {
1307                self.skip_token();
1308                Ok(span.end(self, | span | Expr {
1309                    span,
1310                    ty: RefCell::new(None),
1311                    const_val: RefCell::new(None),
1312                    const_index: Cell::new(None),
1313                    kind: ExprKind::Lit {span, lit: Lit::Float(v as f32)},
1314                }))
1315            }
1316            LiveToken::Color(v) => {
1317                self.skip_token();
1318                Ok(span.end(self, | span | Expr {
1319                    span,
1320                    ty: RefCell::new(None),
1321                    const_val: RefCell::new(None),
1322                    const_index: Cell::new(None),
1323                    kind: ExprKind::Lit {span, lit: Lit::Color(v)},
1324                }))
1325            }
1326            LiveToken::Punct(live_id!( |)) => {
1327                // closure def
1328                self.skip_token();
1329                let mut params = Vec::new();
1330                if !self.accept_token(LiveToken::Punct(live_id!( |))) {
1331                    loop {
1332                        let span = self.begin_span();
1333                        params.push(ClosureParam {
1334                            ident: self.expect_ident(live_error_origin!()) ?,
1335                            span: span.end(self, | span | span),
1336                            shadow: Cell::new(None)
1337                        });
1338                        if !self.accept_token(LiveToken::Punct(live_id!(,))) {
1339                            break;
1340                        }
1341                    }
1342                    self.expect_token(LiveToken::Punct(live_id!( |))) ?;
1343                }
1344                if self.peek_token() == LiveToken::Open(Delim::Brace) {
1345                    let block = self.expect_block() ?;
1346                    let span = span.end(self, | span | span);
1347                    let closure_def_index = ClosureDefIndex(self.closure_defs.len());
1348                    self.closure_defs.push(ClosureDef {
1349                        span,
1350                        params,
1351                        closed_over_syms: RefCell::new(None),
1352                        kind: ClosureDefKind::Block(block)
1353                    });
1354                    Ok(Expr {
1355                        span,
1356                        ty: RefCell::new(None),
1357                        const_val: RefCell::new(None),
1358                        const_index: Cell::new(None),
1359                        kind: ExprKind::ClosureDef(closure_def_index)
1360                    })
1361                }
1362                else {
1363                    let expr = self.expect_expr() ?;
1364                    let span = span.end(self, | span | span);
1365                    let closure_def_index = ClosureDefIndex(self.closure_defs.len());
1366                    self.closure_defs.push(ClosureDef {
1367                        span,
1368                        params,
1369                        closed_over_syms: RefCell::new(None),
1370                        kind: ClosureDefKind::Expr(expr)
1371                    });
1372                    Ok(Expr {
1373                        span,
1374                        ty: RefCell::new(None),
1375                        const_val: RefCell::new(None),
1376                        const_index: Cell::new(None),
1377                        kind: ExprKind::ClosureDef(closure_def_index)
1378                    })
1379                }
1380            }
1381            LiveToken::Open(Delim::Paren) => {
1382                self.skip_token();
1383                let expr = self.expect_expr() ?;
1384                self.expect_token(LiveToken::Close(Delim::Paren)) ?;
1385                Ok(expr)
1386            }
1387            token => Err(span.error(self, live_error_origin!(), format!("unexpected token `{}`", token).into())),
1388        }
1389    }
1390    
1391    fn expect_arg_exprs(&mut self) -> Result<Vec<Expr>, LiveError> {
1392        self.expect_token(LiveToken::Open(Delim::Paren)) ?;
1393        let mut arg_exprs = Vec::new();
1394        if !self.accept_token(LiveToken::Close(Delim::Paren)) {
1395            loop {
1396                arg_exprs.push(self.expect_expr() ?);
1397                if !self.accept_token(LiveToken::Punct(live_id!(,))) {
1398                    break;
1399                }
1400            }
1401            self.expect_token(LiveToken::Close(Delim::Paren)) ?;
1402        }
1403        Ok(arg_exprs)
1404    }
1405    
1406    pub fn accept_optional_delim(&mut self) {
1407        while self.accept_token(LiveToken::Punct(live_id!(;))) {};
1408    }
1409}
1410
1411
1412pub struct SpanTracker {
1413    pub file_id: LiveFileId,
1414    pub start: TextPos,
1415    pub start_index: usize,
1416}
1417
1418impl SpanTracker {
1419    pub fn end<F, R>(&self, parser: &mut ShaderParser, f: F) -> R
1420    where
1421    F: FnOnce(TokenSpan) -> R,
1422    {
1423        f(TokenSpan {
1424            token_id: LiveTokenId::new(self.file_id, self.start_index),
1425            len: parser.token_index - self.start_index
1426        })
1427    }
1428    
1429    pub fn error(&self, parser: &mut ShaderParser, origin: LiveErrorOrigin, message: String) -> LiveError {
1430        LiveError {
1431            origin,
1432            span: TextSpan {
1433                file_id: self.file_id,
1434                start: self.start,
1435                end: parser.token_end(),
1436            }.into(),
1437            message,
1438        }
1439    }
1440}
makepad_shader_compiler/shader_parser.rs

makepad_shader_compiler/
shader_parser.rs
