Function parse_literal_ok

src/expr-parser/src/parser.rs:1033–1067

(input: ParseStream)

    }

    fn parse_literal_ok(input: ParseStream) -> Result {
        let mut row = Row::default();
        let mut packer = row.packer();

        let typ = if input.eat(kw::null) {
            packer.push(Datum::Null);
            input.parse::<syn::Token![::]>()?;
            ReprColumnType {
                scalar_type: analyses::parse_scalar_type(input)?,
                nullable: true,
            }
        } else {
            match input.parse::<syn::Lit>()? {
                syn::Lit::Str(l) => {
                    packer.push(Datum::from(l.value().as_str()));
                    Ok(ReprColumnType::from(&String::as_column_type()))
                }
                syn::Lit::Int(l) => {
                    packer.push(Datum::from(l.base10_parse::<i64>()?));
                    Ok(ReprColumnType::from(&i64::as_column_type()))
                }
                syn::Lit::Float(l) => {
                    packer.push(Datum::from(l.base10_parse::<f64>()?));
                    Ok(ReprColumnType::from(&f64::as_column_type()))
                }
                syn::Lit::Bool(l) => {
                    packer.push(Datum::from(l.value));
                    Ok(ReprColumnType::from(&bool::as_column_type()))
                }
                _ => Err(Error::new(input.span(), "cannot parse literal")),
            }?
        };

        Ok(MirScalarExpr::Literal(Ok(row), typ))
    }
    fn parse_literal_err(input: ParseStream) -> Result {
        input.parse::<kw::error>()?;
        let mut msg = {