Method expr_struct_call

compiler/src/parser.rs:667–724

(&mut self, lhs: Expr)

    }

    fn expr_struct_call(&mut self, lhs: Expr) -> Expr {
        assert!(self.tok.kind == TokenKind::LCurly);

        let name = self.flatten_expr_to_name(&lhs);

        // consume '{'
        let start = self.next();

        let mut fields = vec![];
        let mut rest = None;

        while self.is_not(TokenKind::RCurly) {
            if rest.is_some() {
                self.error("rest expression (..x) should be last".to_string());
                break;
            }

            // Parse ..rest
            if self.tok.kind == TokenKind::Dot {
                rest = Some(self.expr_rest());
                continue;
            }

            // Parse field: value
            let field = self.parse_one_ident();
            let value = if self.tok.kind == TokenKind::Colon {
                // consume ':'
                self.next();
                self.parse_expr()
            } else {
                // shorthand syntax ie. Foo { x }
                // create a field x => Var("x")
                Expr::Var {
                    value: field.clone(),
                    decl: Span::dummy(),
                    generics_instantiated: Default::default(),
                    ty: Type::dummy(),
                    span: self.make_span(start),
                }
            };

            fields.push(StructField { name: field, value });

            if self.tok.kind == TokenKind::Comma {
                self.next();
            }
        }

        self.expect(TokenKind::RCurly);

        Expr::StructCall {
            name,
            fields,
            rest: rest.into(),
            ty: Type::dummy(),
            span: self.make_span(start),
        }
    }