Method parse_pat_struct

compiler/src/parser.rs:1236–1275

(&mut self, ident: String)

    }

    fn parse_pat_struct(&mut self, ident: String) -> Pat {
        assert!(self.tok.kind == TokenKind::LCurly);

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

        let mut fields = vec![];

        while self.is_not(TokenKind::RCurly) {
            // Parse field: value
            let field = self.parse_one_ident();
            let value = if self.tok.kind == TokenKind::Colon {
                // consume ':'
                self.next();
                self.parse_pat()
            } else {
                Pat::Type {
                    ident: field.clone(),
                    is_mut: false,
                    ann: TypeAst::Unknown,
                    span: self.make_span(start),
                }
            };

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

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

        self.expect(TokenKind::RCurly);

        Pat::Struct {
            ident,
            fields,
            ty: Type::dummy(),
            span: self.make_span(start),
        }
    }

    fn parse_pat_lit(&mut self) -> Pat {
        let expr = self.parse_expr();