Add an implicit concatenation flag to string and bytes constants (#6512)

## Summary

Per the discussion in
https://github.com/astral-sh/ruff/discussions/6183, this PR adds an
`implicit_concatenated` flag to the string and bytes constant variants.
It's not actually _used_ anywhere as of this PR, but it is covered by
the tests.

Specifically, we now use a struct for the string and bytes cases, along
with the `Expr::FString` node. That struct holds the value, plus the
flag:

```rust
#[derive(Clone, Debug, PartialEq, is_macro::Is)]
pub enum Constant {
    Str(StringConstant),
    Bytes(BytesConstant),
    ...
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct StringConstant {
    /// The string value as resolved by the parser (i.e., without quotes, or escape sequences, or
    /// implicit concatenations).
    pub value: String,
    /// Whether the string contains multiple string tokens that were implicitly concatenated.
    pub implicit_concatenated: bool,
}

impl Deref for StringConstant {
    type Target = str;
    fn deref(&self) -> &Self::Target {
        self.value.as_str()
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BytesConstant {
    /// The bytes value as resolved by the parser (i.e., without quotes, or escape sequences, or
    /// implicit concatenations).
    pub value: Vec<u8>,
    /// Whether the string contains multiple string tokens that were implicitly concatenated.
    pub implicit_concatenated: bool,
}

impl Deref for BytesConstant {
    type Target = [u8];
    fn deref(&self) -> &Self::Target {
        self.value.as_slice()
    }
}
```

## Test Plan

`cargo test`
This commit is contained in:
Charlie Marsh 2023-08-14 09:46:54 -04:00 committed by GitHub
parent fc0c9507d0
commit f16e780e0a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
88 changed files with 1252 additions and 761 deletions

View file

@ -1104,7 +1104,7 @@ impl<'a> Generator<'a> {
*conversion,
format_spec.as_deref(),
),
Expr::FString(ast::ExprFString { values, range: _ }) => {
Expr::FString(ast::ExprFString { values, .. }) => {
self.unparse_f_string(values, false);
}
Expr::Constant(ast::ExprConstant {
@ -1197,8 +1197,8 @@ impl<'a> Generator<'a> {
Constant::Bytes(b) => {
self.p_bytes_repr(b);
}
Constant::Str(s) => {
self.p_str_repr(s);
Constant::Str(ast::StringConstant { value, .. }) => {
self.p_str_repr(value);
}
Constant::None => self.p("None"),
Constant::Bool(b) => self.p(if *b { "True" } else { "False" }),
@ -1339,13 +1339,13 @@ impl<'a> Generator<'a> {
fn unparse_f_string_elem(&mut self, expr: &Expr, is_spec: bool) {
match expr {
Expr::Constant(ast::ExprConstant { value, .. }) => {
if let Constant::Str(s) = value {
self.unparse_f_string_literal(s);
if let Constant::Str(ast::StringConstant { value, .. }) = value {
self.unparse_f_string_literal(value);
} else {
unreachable!()
}
}
Expr::FString(ast::ExprFString { values, range: _ }) => {
Expr::FString(ast::ExprFString { values, .. }) => {
self.unparse_f_string(values, is_spec);
}
Expr::FormattedValue(ast::ExprFormattedValue {