Function concat_string_exprs

parser/src/parser/mod.rs:57–150

(lhs: Expression, rhs: Expression)

}

pub fn concat_string_exprs(lhs: Expression, rhs: Expression) -> Result<Expression, ParsingError> {
    use crate::parser::ast::{Constant, ConstantValue};
    match (lhs, rhs) {
        (Expression::Constant(lhs), Expression::Constant(rhs)) => {
            let node = Node {
                start: lhs.node.start,
                end: rhs.node.end,
            };
            let concatnated_string = match (lhs.value, rhs.value) {
                (ConstantValue::Str(_), ConstantValue::Str(_)) => {
                    Expression::Constant(Box::new(Constant {
                        node,
                        value: ConstantValue::Str(QuoteType::Concat),
                    }))
                }
                (ConstantValue::Bytes, ConstantValue::Bytes) => {
                    Expression::Constant(Box::new(Constant {
                        node,
                        value: ConstantValue::Bytes,
                    }))
                }
                (ConstantValue::Bytes, _) => {
                    panic!("Cannot concat bytes and string");
                }
                (_, ConstantValue::Bytes) => {
                    panic!("Can only concat bytes with other bytes");
                }
                _ => panic!("Cannot concat string"),
            };
            Ok(concatnated_string)
        }
        (Expression::JoinedStr(fstring_lhs), Expression::JoinedStr(fstring_rhs)) => {
            let mut values = fstring_lhs.values;
            values.extend(fstring_rhs.values);
            Ok(Expression::JoinedStr(Box::new(JoinedStr {
                node: Node {
                    start: fstring_lhs.node.start,
                    end: fstring_rhs.node.end,
                },
                values,
            })))
        }
        (Expression::JoinedStr(fstring_lhs), Expression::Constant(const_rhs)) => {
            let mut values = fstring_lhs.values;
            match const_rhs.value {
                ConstantValue::Str(s) => {
                    values.push(Expression::Constant(Box::new(Constant {
                        node: Node {
                            start: const_rhs.node.start,
                            end: const_rhs.node.end,
                        },
                        value: ConstantValue::Str(s),
                    })));
                }
                ConstantValue::Bytes => {
                    panic!("Cannot concat string and bytes");
                }
                _ => panic!("Cannot concat string"),