Implement template strings (#17851)

This PR implements template strings (t-strings) in the parser and
formatter for Ruff.

Minimal changes necessary to compile were made in other parts of the code (e.g. ty, the linter, etc.). These will be covered properly in follow-up PRs.

crates/ruff_python_ast/src/generated.rs

@@ -1270,6 +1270,7 @@ pub enum Expr {
     Compare(crate::ExprCompare),
     Call(crate::ExprCall),
     FString(crate::ExprFString),
+    TString(crate::ExprTString),
     StringLiteral(crate::ExprStringLiteral),
     BytesLiteral(crate::ExprBytesLiteral),
     NumberLiteral(crate::ExprNumberLiteral),
@@ -1394,6 +1395,12 @@ impl From<crate::ExprFString> for Expr {
     }
 }
 
+impl From<crate::ExprTString> for Expr {
+    fn from(node: crate::ExprTString) -> Self {
+        Self::TString(node)
+    }
+}
+
 impl From<crate::ExprStringLiteral> for Expr {
     fn from(node: crate::ExprStringLiteral) -> Self {
         Self::StringLiteral(node)
@@ -1499,6 +1506,7 @@ impl ruff_text_size::Ranged for Expr {
             Self::Compare(node) => node.range(),
             Self::Call(node) => node.range(),
             Self::FString(node) => node.range(),
+            Self::TString(node) => node.range(),
             Self::StringLiteral(node) => node.range(),
             Self::BytesLiteral(node) => node.range(),
             Self::NumberLiteral(node) => node.range(),
@@ -2185,6 +2193,43 @@ impl Expr {
         }
     }
 
+    #[inline]
+    pub const fn is_t_string_expr(&self) -> bool {
+        matches!(self, Self::TString(_))
+    }
+
+    #[inline]
+    pub fn t_string_expr(self) -> Option<crate::ExprTString> {
+        match self {
+            Self::TString(val) => Some(val),
+            _ => None,
+        }
+    }
+
+    #[inline]
+    pub fn expect_t_string_expr(self) -> crate::ExprTString {
+        match self {
+            Self::TString(val) => val,
+            _ => panic!("called expect on {self:?}"),
+        }
+    }
+
+    #[inline]
+    pub fn as_t_string_expr_mut(&mut self) -> Option<&mut crate::ExprTString> {
+        match self {
+            Self::TString(val) => Some(val),
+            _ => None,
+        }
+    }
+
+    #[inline]
+    pub fn as_t_string_expr(&self) -> Option<&crate::ExprTString> {
+        match self {
+            Self::TString(val) => Some(val),
+            _ => None,
+        }
+    }
+
     #[inline]
     pub const fn is_string_literal_expr(&self) -> bool {
         matches!(self, Self::StringLiteral(_))
@@ -2761,67 +2806,67 @@ impl ExceptHandler {
 }
 
 #[derive(Clone, Debug, PartialEq)]
-pub enum FStringElement {
-    Expression(crate::FStringExpressionElement),
-    Literal(crate::FStringLiteralElement),
+pub enum InterpolatedStringElement {
+    Interpolation(crate::InterpolatedElement),
+    Literal(crate::InterpolatedStringLiteralElement),
 }
 
-impl From<crate::FStringExpressionElement> for FStringElement {
-    fn from(node: crate::FStringExpressionElement) -> Self {
-        Self::Expression(node)
+impl From<crate::InterpolatedElement> for InterpolatedStringElement {
+    fn from(node: crate::InterpolatedElement) -> Self {
+        Self::Interpolation(node)
     }
 }
 
-impl From<crate::FStringLiteralElement> for FStringElement {
-    fn from(node: crate::FStringLiteralElement) -> Self {
+impl From<crate::InterpolatedStringLiteralElement> for InterpolatedStringElement {
+    fn from(node: crate::InterpolatedStringLiteralElement) -> Self {
         Self::Literal(node)
     }
 }
 
-impl ruff_text_size::Ranged for FStringElement {
+impl ruff_text_size::Ranged for InterpolatedStringElement {
     fn range(&self) -> ruff_text_size::TextRange {
         match self {
-            Self::Expression(node) => node.range(),
+            Self::Interpolation(node) => node.range(),
             Self::Literal(node) => node.range(),
         }
     }
 }
 
 #[allow(dead_code, clippy::match_wildcard_for_single_variants)]
-impl FStringElement {
+impl InterpolatedStringElement {
     #[inline]
-    pub const fn is_expression(&self) -> bool {
-        matches!(self, Self::Expression(_))
+    pub const fn is_interpolation(&self) -> bool {
+        matches!(self, Self::Interpolation(_))
     }
 
     #[inline]
-    pub fn expression(self) -> Option<crate::FStringExpressionElement> {
+    pub fn interpolation(self) -> Option<crate::InterpolatedElement> {
         match self {
-            Self::Expression(val) => Some(val),
+            Self::Interpolation(val) => Some(val),
             _ => None,
         }
     }
 
     #[inline]
-    pub fn expect_expression(self) -> crate::FStringExpressionElement {
+    pub fn expect_interpolation(self) -> crate::InterpolatedElement {
         match self {
-            Self::Expression(val) => val,
+            Self::Interpolation(val) => val,
             _ => panic!("called expect on {self:?}"),
         }
     }
 
     #[inline]
-    pub fn as_expression_mut(&mut self) -> Option<&mut crate::FStringExpressionElement> {
+    pub fn as_interpolation_mut(&mut self) -> Option<&mut crate::InterpolatedElement> {
         match self {
-            Self::Expression(val) => Some(val),
+            Self::Interpolation(val) => Some(val),
             _ => None,
         }
     }
 
     #[inline]
-    pub fn as_expression(&self) -> Option<&crate::FStringExpressionElement> {
+    pub fn as_interpolation(&self) -> Option<&crate::InterpolatedElement> {
         match self {
-            Self::Expression(val) => Some(val),
+            Self::Interpolation(val) => Some(val),
             _ => None,
         }
     }
@@ -2832,7 +2877,7 @@ impl FStringElement {
     }
 
     #[inline]
-    pub fn literal(self) -> Option<crate::FStringLiteralElement> {
+    pub fn literal(self) -> Option<crate::InterpolatedStringLiteralElement> {
         match self {
             Self::Literal(val) => Some(val),
             _ => None,
@@ -2840,7 +2885,7 @@ impl FStringElement {
     }
 
     #[inline]
-    pub fn expect_literal(self) -> crate::FStringLiteralElement {
+    pub fn expect_literal(self) -> crate::InterpolatedStringLiteralElement {
         match self {
             Self::Literal(val) => val,
             _ => panic!("called expect on {self:?}"),
@@ -2848,7 +2893,7 @@ impl FStringElement {
     }
 
     #[inline]
-    pub fn as_literal_mut(&mut self) -> Option<&mut crate::FStringLiteralElement> {
+    pub fn as_literal_mut(&mut self) -> Option<&mut crate::InterpolatedStringLiteralElement> {
         match self {
             Self::Literal(val) => Some(val),
             _ => None,
@@ -2856,7 +2901,7 @@ impl FStringElement {
     }
 
     #[inline]
-    pub fn as_literal(&self) -> Option<&crate::FStringLiteralElement> {
+    pub fn as_literal(&self) -> Option<&crate::InterpolatedStringLiteralElement> {
         match self {
             Self::Literal(val) => Some(val),
             _ => None,
@@ -3659,6 +3704,12 @@ impl ruff_text_size::Ranged for crate::ExprFString {
     }
 }
 
+impl ruff_text_size::Ranged for crate::ExprTString {
+    fn range(&self) -> ruff_text_size::TextRange {
+        self.range
+    }
+}
+
 impl ruff_text_size::Ranged for crate::ExprStringLiteral {
     fn range(&self) -> ruff_text_size::TextRange {
         self.range
@@ -3749,13 +3800,13 @@ impl ruff_text_size::Ranged for crate::ExceptHandlerExceptHandler {
     }
 }
 
-impl ruff_text_size::Ranged for crate::FStringExpressionElement {
+impl ruff_text_size::Ranged for crate::InterpolatedElement {
     fn range(&self) -> ruff_text_size::TextRange {
         self.range
     }
 }
 
-impl ruff_text_size::Ranged for crate::FStringLiteralElement {
+impl ruff_text_size::Ranged for crate::InterpolatedStringLiteralElement {
     fn range(&self) -> ruff_text_size::TextRange {
         self.range
     }
@@ -3827,7 +3878,7 @@ impl ruff_text_size::Ranged for crate::TypeParamParamSpec {
     }
 }
 
-impl ruff_text_size::Ranged for crate::FStringFormatSpec {
+impl ruff_text_size::Ranged for crate::InterpolatedStringFormatSpec {
     fn range(&self) -> ruff_text_size::TextRange {
         self.range
     }
@@ -3923,6 +3974,12 @@ impl ruff_text_size::Ranged for crate::FString {
     }
 }
 
+impl ruff_text_size::Ranged for crate::TString {
+    fn range(&self) -> ruff_text_size::TextRange {
+        self.range
+    }
+}
+
 impl ruff_text_size::Ranged for crate::StringLiteral {
     fn range(&self) -> ruff_text_size::TextRange {
         self.range
@@ -4015,6 +4072,7 @@ impl Expr {
             Expr::Compare(node) => node.visit_source_order(visitor),
             Expr::Call(node) => node.visit_source_order(visitor),
             Expr::FString(node) => node.visit_source_order(visitor),
+            Expr::TString(node) => node.visit_source_order(visitor),
             Expr::StringLiteral(node) => node.visit_source_order(visitor),
             Expr::BytesLiteral(node) => node.visit_source_order(visitor),
             Expr::NumberLiteral(node) => node.visit_source_order(visitor),
@@ -4045,15 +4103,15 @@ impl ExceptHandler {
     }
 }
 
-impl FStringElement {
+impl InterpolatedStringElement {
     #[allow(unused)]
     pub(crate) fn visit_source_order<'a, V>(&'a self, visitor: &mut V)
     where
         V: crate::visitor::source_order::SourceOrderVisitor<'a> + ?Sized,
     {
         match self {
-            FStringElement::Expression(node) => node.visit_source_order(visitor),
-            FStringElement::Literal(node) => node.visit_source_order(visitor),
+            InterpolatedStringElement::Interpolation(node) => node.visit_source_order(visitor),
+            InterpolatedStringElement::Literal(node) => node.visit_source_order(visitor),
         }
     }
 }
@@ -4436,6 +4494,8 @@ pub enum ExprRef<'a> {
     Call(&'a crate::ExprCall),
     #[is(name = "f_string_expr")]
     FString(&'a crate::ExprFString),
+    #[is(name = "t_string_expr")]
+    TString(&'a crate::ExprTString),
     #[is(name = "string_literal_expr")]
     StringLiteral(&'a crate::ExprStringLiteral),
     #[is(name = "bytes_literal_expr")]
@@ -4487,6 +4547,7 @@ impl<'a> From<&'a Expr> for ExprRef<'a> {
             Expr::Compare(node) => ExprRef::Compare(node),
             Expr::Call(node) => ExprRef::Call(node),
             Expr::FString(node) => ExprRef::FString(node),
+            Expr::TString(node) => ExprRef::TString(node),
             Expr::StringLiteral(node) => ExprRef::StringLiteral(node),
             Expr::BytesLiteral(node) => ExprRef::BytesLiteral(node),
             Expr::NumberLiteral(node) => ExprRef::NumberLiteral(node),
@@ -4613,6 +4674,12 @@ impl<'a> From<&'a crate::ExprFString> for ExprRef<'a> {
     }
 }
 
+impl<'a> From<&'a crate::ExprTString> for ExprRef<'a> {
+    fn from(node: &'a crate::ExprTString) -> Self {
+        Self::TString(node)
+    }
+}
+
 impl<'a> From<&'a crate::ExprStringLiteral> for ExprRef<'a> {
     fn from(node: &'a crate::ExprStringLiteral) -> Self {
         Self::StringLiteral(node)
@@ -4718,6 +4785,7 @@ impl ruff_text_size::Ranged for ExprRef<'_> {
             Self::Compare(node) => node.range(),
             Self::Call(node) => node.range(),
             Self::FString(node) => node.range(),
+            Self::TString(node) => node.range(),
             Self::StringLiteral(node) => node.range(),
             Self::BytesLiteral(node) => node.range(),
             Self::NumberLiteral(node) => node.range(),
@@ -4765,36 +4833,38 @@ impl ruff_text_size::Ranged for ExceptHandlerRef<'_> {
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, is_macro::Is)]
-pub enum FStringElementRef<'a> {
-    Expression(&'a crate::FStringExpressionElement),
-    Literal(&'a crate::FStringLiteralElement),
+pub enum InterpolatedStringElementRef<'a> {
+    Interpolation(&'a crate::InterpolatedElement),
+    Literal(&'a crate::InterpolatedStringLiteralElement),
 }
 
-impl<'a> From<&'a FStringElement> for FStringElementRef<'a> {
-    fn from(node: &'a FStringElement) -> Self {
+impl<'a> From<&'a InterpolatedStringElement> for InterpolatedStringElementRef<'a> {
+    fn from(node: &'a InterpolatedStringElement) -> Self {
         match node {
-            FStringElement::Expression(node) => FStringElementRef::Expression(node),
-            FStringElement::Literal(node) => FStringElementRef::Literal(node),
+            InterpolatedStringElement::Interpolation(node) => {
+                InterpolatedStringElementRef::Interpolation(node)
+            }
+            InterpolatedStringElement::Literal(node) => InterpolatedStringElementRef::Literal(node),
         }
     }
 }
 
-impl<'a> From<&'a crate::FStringExpressionElement> for FStringElementRef<'a> {
-    fn from(node: &'a crate::FStringExpressionElement) -> Self {
-        Self::Expression(node)
+impl<'a> From<&'a crate::InterpolatedElement> for InterpolatedStringElementRef<'a> {
+    fn from(node: &'a crate::InterpolatedElement) -> Self {
+        Self::Interpolation(node)
     }
 }
 
-impl<'a> From<&'a crate::FStringLiteralElement> for FStringElementRef<'a> {
-    fn from(node: &'a crate::FStringLiteralElement) -> Self {
+impl<'a> From<&'a crate::InterpolatedStringLiteralElement> for InterpolatedStringElementRef<'a> {
+    fn from(node: &'a crate::InterpolatedStringLiteralElement) -> Self {
         Self::Literal(node)
     }
 }
 
-impl ruff_text_size::Ranged for FStringElementRef<'_> {
+impl ruff_text_size::Ranged for InterpolatedStringElementRef<'_> {
     fn range(&self) -> ruff_text_size::TextRange {
         match self {
-            Self::Expression(node) => node.range(),
+            Self::Interpolation(node) => node.range(),
             Self::Literal(node) => node.range(),
         }
     }
@@ -4984,6 +5054,7 @@ pub enum AnyNodeRef<'a> {
     ExprCompare(&'a crate::ExprCompare),
     ExprCall(&'a crate::ExprCall),
     ExprFString(&'a crate::ExprFString),
+    ExprTString(&'a crate::ExprTString),
     ExprStringLiteral(&'a crate::ExprStringLiteral),
     ExprBytesLiteral(&'a crate::ExprBytesLiteral),
     ExprNumberLiteral(&'a crate::ExprNumberLiteral),
@@ -4999,8 +5070,8 @@ pub enum AnyNodeRef<'a> {
     ExprSlice(&'a crate::ExprSlice),
     ExprIpyEscapeCommand(&'a crate::ExprIpyEscapeCommand),
     ExceptHandlerExceptHandler(&'a crate::ExceptHandlerExceptHandler),
-    FStringExpressionElement(&'a crate::FStringExpressionElement),
-    FStringLiteralElement(&'a crate::FStringLiteralElement),
+    InterpolatedElement(&'a crate::InterpolatedElement),
+    InterpolatedStringLiteralElement(&'a crate::InterpolatedStringLiteralElement),
     PatternMatchValue(&'a crate::PatternMatchValue),
     PatternMatchSingleton(&'a crate::PatternMatchSingleton),
     PatternMatchSequence(&'a crate::PatternMatchSequence),
@@ -5012,7 +5083,7 @@ pub enum AnyNodeRef<'a> {
     TypeParamTypeVar(&'a crate::TypeParamTypeVar),
     TypeParamTypeVarTuple(&'a crate::TypeParamTypeVarTuple),
     TypeParamParamSpec(&'a crate::TypeParamParamSpec),
-    FStringFormatSpec(&'a crate::FStringFormatSpec),
+    InterpolatedStringFormatSpec(&'a crate::InterpolatedStringFormatSpec),
     PatternArguments(&'a crate::PatternArguments),
     PatternKeyword(&'a crate::PatternKeyword),
     Comprehension(&'a crate::Comprehension),
@@ -5028,6 +5099,7 @@ pub enum AnyNodeRef<'a> {
     ElifElseClause(&'a crate::ElifElseClause),
     TypeParams(&'a crate::TypeParams),
     FString(&'a crate::FString),
+    TString(&'a crate::TString),
     StringLiteral(&'a crate::StringLiteral),
     BytesLiteral(&'a crate::BytesLiteral),
     Identifier(&'a crate::Identifier),
@@ -5181,6 +5253,7 @@ impl<'a> From<&'a Expr> for AnyNodeRef<'a> {
             Expr::Compare(node) => AnyNodeRef::ExprCompare(node),
             Expr::Call(node) => AnyNodeRef::ExprCall(node),
             Expr::FString(node) => AnyNodeRef::ExprFString(node),
+            Expr::TString(node) => AnyNodeRef::ExprTString(node),
             Expr::StringLiteral(node) => AnyNodeRef::ExprStringLiteral(node),
             Expr::BytesLiteral(node) => AnyNodeRef::ExprBytesLiteral(node),
             Expr::NumberLiteral(node) => AnyNodeRef::ExprNumberLiteral(node),
@@ -5220,6 +5293,7 @@ impl<'a> From<ExprRef<'a>> for AnyNodeRef<'a> {
             ExprRef::Compare(node) => AnyNodeRef::ExprCompare(node),
             ExprRef::Call(node) => AnyNodeRef::ExprCall(node),
             ExprRef::FString(node) => AnyNodeRef::ExprFString(node),
+            ExprRef::TString(node) => AnyNodeRef::ExprTString(node),
             ExprRef::StringLiteral(node) => AnyNodeRef::ExprStringLiteral(node),
             ExprRef::BytesLiteral(node) => AnyNodeRef::ExprBytesLiteral(node),
             ExprRef::NumberLiteral(node) => AnyNodeRef::ExprNumberLiteral(node),
@@ -5259,6 +5333,7 @@ impl<'a> AnyNodeRef<'a> {
             Self::ExprCompare(node) => Some(ExprRef::Compare(node)),
             Self::ExprCall(node) => Some(ExprRef::Call(node)),
             Self::ExprFString(node) => Some(ExprRef::FString(node)),
+            Self::ExprTString(node) => Some(ExprRef::TString(node)),
             Self::ExprStringLiteral(node) => Some(ExprRef::StringLiteral(node)),
             Self::ExprBytesLiteral(node) => Some(ExprRef::BytesLiteral(node)),
             Self::ExprNumberLiteral(node) => Some(ExprRef::NumberLiteral(node)),
@@ -5305,29 +5380,39 @@ impl<'a> AnyNodeRef<'a> {
     }
 }
 
-impl<'a> From<&'a FStringElement> for AnyNodeRef<'a> {
-    fn from(node: &'a FStringElement) -> AnyNodeRef<'a> {
+impl<'a> From<&'a InterpolatedStringElement> for AnyNodeRef<'a> {
+    fn from(node: &'a InterpolatedStringElement) -> AnyNodeRef<'a> {
         match node {
-            FStringElement::Expression(node) => AnyNodeRef::FStringExpressionElement(node),
-            FStringElement::Literal(node) => AnyNodeRef::FStringLiteralElement(node),
+            InterpolatedStringElement::Interpolation(node) => AnyNodeRef::InterpolatedElement(node),
+            InterpolatedStringElement::Literal(node) => {
+                AnyNodeRef::InterpolatedStringLiteralElement(node)
+            }
         }
     }
 }
 
-impl<'a> From<FStringElementRef<'a>> for AnyNodeRef<'a> {
-    fn from(node: FStringElementRef<'a>) -> AnyNodeRef<'a> {
+impl<'a> From<InterpolatedStringElementRef<'a>> for AnyNodeRef<'a> {
+    fn from(node: InterpolatedStringElementRef<'a>) -> AnyNodeRef<'a> {
         match node {
-            FStringElementRef::Expression(node) => AnyNodeRef::FStringExpressionElement(node),
-            FStringElementRef::Literal(node) => AnyNodeRef::FStringLiteralElement(node),
+            InterpolatedStringElementRef::Interpolation(node) => {
+                AnyNodeRef::InterpolatedElement(node)
+            }
+            InterpolatedStringElementRef::Literal(node) => {
+                AnyNodeRef::InterpolatedStringLiteralElement(node)
+            }
         }
     }
 }
 
 impl<'a> AnyNodeRef<'a> {
-    pub fn as_f_string_element_ref(self) -> Option<FStringElementRef<'a>> {
+    pub fn as_interpolated_string_element_ref(self) -> Option<InterpolatedStringElementRef<'a>> {
         match self {
-            Self::FStringExpressionElement(node) => Some(FStringElementRef::Expression(node)),
-            Self::FStringLiteralElement(node) => Some(FStringElementRef::Literal(node)),
+            Self::InterpolatedElement(node) => {
+                Some(InterpolatedStringElementRef::Interpolation(node))
+            }
+            Self::InterpolatedStringLiteralElement(node) => {
+                Some(InterpolatedStringElementRef::Literal(node))
+            }
 
             _ => None,
         }
@@ -5683,6 +5768,12 @@ impl<'a> From<&'a crate::ExprFString> for AnyNodeRef<'a> {
     }
 }
 
+impl<'a> From<&'a crate::ExprTString> for AnyNodeRef<'a> {
+    fn from(node: &'a crate::ExprTString) -> AnyNodeRef<'a> {
+        AnyNodeRef::ExprTString(node)
+    }
+}
+
 impl<'a> From<&'a crate::ExprStringLiteral> for AnyNodeRef<'a> {
     fn from(node: &'a crate::ExprStringLiteral) -> AnyNodeRef<'a> {
         AnyNodeRef::ExprStringLiteral(node)
@@ -5773,15 +5864,15 @@ impl<'a> From<&'a crate::ExceptHandlerExceptHandler> for AnyNodeRef<'a> {
     }
 }
 
-impl<'a> From<&'a crate::FStringExpressionElement> for AnyNodeRef<'a> {
-    fn from(node: &'a crate::FStringExpressionElement) -> AnyNodeRef<'a> {
-        AnyNodeRef::FStringExpressionElement(node)
+impl<'a> From<&'a crate::InterpolatedElement> for AnyNodeRef<'a> {
+    fn from(node: &'a crate::InterpolatedElement) -> AnyNodeRef<'a> {
+        AnyNodeRef::InterpolatedElement(node)
     }
 }
 
-impl<'a> From<&'a crate::FStringLiteralElement> for AnyNodeRef<'a> {
-    fn from(node: &'a crate::FStringLiteralElement) -> AnyNodeRef<'a> {
-        AnyNodeRef::FStringLiteralElement(node)
+impl<'a> From<&'a crate::InterpolatedStringLiteralElement> for AnyNodeRef<'a> {
+    fn from(node: &'a crate::InterpolatedStringLiteralElement) -> AnyNodeRef<'a> {
+        AnyNodeRef::InterpolatedStringLiteralElement(node)
     }
 }
 
@@ -5851,9 +5942,9 @@ impl<'a> From<&'a crate::TypeParamParamSpec> for AnyNodeRef<'a> {
     }
 }
 
-impl<'a> From<&'a crate::FStringFormatSpec> for AnyNodeRef<'a> {
-    fn from(node: &'a crate::FStringFormatSpec) -> AnyNodeRef<'a> {
-        AnyNodeRef::FStringFormatSpec(node)
+impl<'a> From<&'a crate::InterpolatedStringFormatSpec> for AnyNodeRef<'a> {
+    fn from(node: &'a crate::InterpolatedStringFormatSpec) -> AnyNodeRef<'a> {
+        AnyNodeRef::InterpolatedStringFormatSpec(node)
     }
 }
 
@@ -5947,6 +6038,12 @@ impl<'a> From<&'a crate::FString> for AnyNodeRef<'a> {
     }
 }
 
+impl<'a> From<&'a crate::TString> for AnyNodeRef<'a> {
+    fn from(node: &'a crate::TString) -> AnyNodeRef<'a> {
+        AnyNodeRef::TString(node)
+    }
+}
+
 impl<'a> From<&'a crate::StringLiteral> for AnyNodeRef<'a> {
     fn from(node: &'a crate::StringLiteral) -> AnyNodeRef<'a> {
         AnyNodeRef::StringLiteral(node)
@@ -6013,6 +6110,7 @@ impl ruff_text_size::Ranged for AnyNodeRef<'_> {
             AnyNodeRef::ExprCompare(node) => node.range(),
             AnyNodeRef::ExprCall(node) => node.range(),
             AnyNodeRef::ExprFString(node) => node.range(),
+            AnyNodeRef::ExprTString(node) => node.range(),
             AnyNodeRef::ExprStringLiteral(node) => node.range(),
             AnyNodeRef::ExprBytesLiteral(node) => node.range(),
             AnyNodeRef::ExprNumberLiteral(node) => node.range(),
@@ -6028,8 +6126,8 @@ impl ruff_text_size::Ranged for AnyNodeRef<'_> {
             AnyNodeRef::ExprSlice(node) => node.range(),
             AnyNodeRef::ExprIpyEscapeCommand(node) => node.range(),
             AnyNodeRef::ExceptHandlerExceptHandler(node) => node.range(),
-            AnyNodeRef::FStringExpressionElement(node) => node.range(),
-            AnyNodeRef::FStringLiteralElement(node) => node.range(),
+            AnyNodeRef::InterpolatedElement(node) => node.range(),
+            AnyNodeRef::InterpolatedStringLiteralElement(node) => node.range(),
             AnyNodeRef::PatternMatchValue(node) => node.range(),
             AnyNodeRef::PatternMatchSingleton(node) => node.range(),
             AnyNodeRef::PatternMatchSequence(node) => node.range(),
@@ -6041,7 +6139,7 @@ impl ruff_text_size::Ranged for AnyNodeRef<'_> {
             AnyNodeRef::TypeParamTypeVar(node) => node.range(),
             AnyNodeRef::TypeParamTypeVarTuple(node) => node.range(),
             AnyNodeRef::TypeParamParamSpec(node) => node.range(),
-            AnyNodeRef::FStringFormatSpec(node) => node.range(),
+            AnyNodeRef::InterpolatedStringFormatSpec(node) => node.range(),
             AnyNodeRef::PatternArguments(node) => node.range(),
             AnyNodeRef::PatternKeyword(node) => node.range(),
             AnyNodeRef::Comprehension(node) => node.range(),
@@ -6057,6 +6155,7 @@ impl ruff_text_size::Ranged for AnyNodeRef<'_> {
             AnyNodeRef::ElifElseClause(node) => node.range(),
             AnyNodeRef::TypeParams(node) => node.range(),
             AnyNodeRef::FString(node) => node.range(),
+            AnyNodeRef::TString(node) => node.range(),
             AnyNodeRef::StringLiteral(node) => node.range(),
             AnyNodeRef::BytesLiteral(node) => node.range(),
             AnyNodeRef::Identifier(node) => node.range(),
@@ -6112,6 +6211,7 @@ impl AnyNodeRef<'_> {
             AnyNodeRef::ExprCompare(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::ExprCall(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::ExprFString(node) => std::ptr::NonNull::from(*node).cast(),
+            AnyNodeRef::ExprTString(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::ExprStringLiteral(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::ExprBytesLiteral(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::ExprNumberLiteral(node) => std::ptr::NonNull::from(*node).cast(),
@@ -6127,8 +6227,10 @@ impl AnyNodeRef<'_> {
             AnyNodeRef::ExprSlice(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::ExprIpyEscapeCommand(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::ExceptHandlerExceptHandler(node) => std::ptr::NonNull::from(*node).cast(),
-            AnyNodeRef::FStringExpressionElement(node) => std::ptr::NonNull::from(*node).cast(),
-            AnyNodeRef::FStringLiteralElement(node) => std::ptr::NonNull::from(*node).cast(),
+            AnyNodeRef::InterpolatedElement(node) => std::ptr::NonNull::from(*node).cast(),
+            AnyNodeRef::InterpolatedStringLiteralElement(node) => {
+                std::ptr::NonNull::from(*node).cast()
+            }
             AnyNodeRef::PatternMatchValue(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::PatternMatchSingleton(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::PatternMatchSequence(node) => std::ptr::NonNull::from(*node).cast(),
@@ -6140,7 +6242,7 @@ impl AnyNodeRef<'_> {
             AnyNodeRef::TypeParamTypeVar(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::TypeParamTypeVarTuple(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::TypeParamParamSpec(node) => std::ptr::NonNull::from(*node).cast(),
-            AnyNodeRef::FStringFormatSpec(node) => std::ptr::NonNull::from(*node).cast(),
+            AnyNodeRef::InterpolatedStringFormatSpec(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::PatternArguments(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::PatternKeyword(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::Comprehension(node) => std::ptr::NonNull::from(*node).cast(),
@@ -6156,6 +6258,7 @@ impl AnyNodeRef<'_> {
             AnyNodeRef::ElifElseClause(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::TypeParams(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::FString(node) => std::ptr::NonNull::from(*node).cast(),
+            AnyNodeRef::TString(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::StringLiteral(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::BytesLiteral(node) => std::ptr::NonNull::from(*node).cast(),
             AnyNodeRef::Identifier(node) => std::ptr::NonNull::from(*node).cast(),
@@ -6215,6 +6318,7 @@ impl<'a> AnyNodeRef<'a> {
             AnyNodeRef::ExprCompare(node) => node.visit_source_order(visitor),
             AnyNodeRef::ExprCall(node) => node.visit_source_order(visitor),
             AnyNodeRef::ExprFString(node) => node.visit_source_order(visitor),
+            AnyNodeRef::ExprTString(node) => node.visit_source_order(visitor),
             AnyNodeRef::ExprStringLiteral(node) => node.visit_source_order(visitor),
             AnyNodeRef::ExprBytesLiteral(node) => node.visit_source_order(visitor),
             AnyNodeRef::ExprNumberLiteral(node) => node.visit_source_order(visitor),
@@ -6230,8 +6334,8 @@ impl<'a> AnyNodeRef<'a> {
             AnyNodeRef::ExprSlice(node) => node.visit_source_order(visitor),
             AnyNodeRef::ExprIpyEscapeCommand(node) => node.visit_source_order(visitor),
             AnyNodeRef::ExceptHandlerExceptHandler(node) => node.visit_source_order(visitor),
-            AnyNodeRef::FStringExpressionElement(node) => node.visit_source_order(visitor),
-            AnyNodeRef::FStringLiteralElement(node) => node.visit_source_order(visitor),
+            AnyNodeRef::InterpolatedElement(node) => node.visit_source_order(visitor),
+            AnyNodeRef::InterpolatedStringLiteralElement(node) => node.visit_source_order(visitor),
             AnyNodeRef::PatternMatchValue(node) => node.visit_source_order(visitor),
             AnyNodeRef::PatternMatchSingleton(node) => node.visit_source_order(visitor),
             AnyNodeRef::PatternMatchSequence(node) => node.visit_source_order(visitor),
@@ -6243,7 +6347,7 @@ impl<'a> AnyNodeRef<'a> {
             AnyNodeRef::TypeParamTypeVar(node) => node.visit_source_order(visitor),
             AnyNodeRef::TypeParamTypeVarTuple(node) => node.visit_source_order(visitor),
             AnyNodeRef::TypeParamParamSpec(node) => node.visit_source_order(visitor),
-            AnyNodeRef::FStringFormatSpec(node) => node.visit_source_order(visitor),
+            AnyNodeRef::InterpolatedStringFormatSpec(node) => node.visit_source_order(visitor),
             AnyNodeRef::PatternArguments(node) => node.visit_source_order(visitor),
             AnyNodeRef::PatternKeyword(node) => node.visit_source_order(visitor),
             AnyNodeRef::Comprehension(node) => node.visit_source_order(visitor),
@@ -6259,6 +6363,7 @@ impl<'a> AnyNodeRef<'a> {
             AnyNodeRef::ElifElseClause(node) => node.visit_source_order(visitor),
             AnyNodeRef::TypeParams(node) => node.visit_source_order(visitor),
             AnyNodeRef::FString(node) => node.visit_source_order(visitor),
+            AnyNodeRef::TString(node) => node.visit_source_order(visitor),
             AnyNodeRef::StringLiteral(node) => node.visit_source_order(visitor),
             AnyNodeRef::BytesLiteral(node) => node.visit_source_order(visitor),
             AnyNodeRef::Identifier(node) => node.visit_source_order(visitor),
@@ -6330,6 +6435,7 @@ impl AnyNodeRef<'_> {
                 | AnyNodeRef::ExprCompare(_)
                 | AnyNodeRef::ExprCall(_)
                 | AnyNodeRef::ExprFString(_)
+                | AnyNodeRef::ExprTString(_)
                 | AnyNodeRef::ExprStringLiteral(_)
                 | AnyNodeRef::ExprBytesLiteral(_)
                 | AnyNodeRef::ExprNumberLiteral(_)
@@ -6355,10 +6461,10 @@ impl AnyNodeRef<'_> {
 }
 
 impl AnyNodeRef<'_> {
-    pub const fn is_f_string_element(self) -> bool {
+    pub const fn is_interpolated_string_element(self) -> bool {
         matches!(
             self,
-            AnyNodeRef::FStringExpressionElement(_) | AnyNodeRef::FStringLiteralElement(_)
+            AnyNodeRef::InterpolatedElement(_) | AnyNodeRef::InterpolatedStringLiteralElement(_)
         )
     }
 }
@@ -6437,6 +6543,7 @@ pub enum NodeKind {
     ExprCompare,
     ExprCall,
     ExprFString,
+    ExprTString,
     ExprStringLiteral,
     ExprBytesLiteral,
     ExprNumberLiteral,
@@ -6452,8 +6559,8 @@ pub enum NodeKind {
     ExprSlice,
     ExprIpyEscapeCommand,
     ExceptHandlerExceptHandler,
-    FStringExpressionElement,
-    FStringLiteralElement,
+    InterpolatedElement,
+    InterpolatedStringLiteralElement,
     PatternMatchValue,
     PatternMatchSingleton,
     PatternMatchSequence,
@@ -6465,7 +6572,7 @@ pub enum NodeKind {
     TypeParamTypeVar,
     TypeParamTypeVarTuple,
     TypeParamParamSpec,
-    FStringFormatSpec,
+    InterpolatedStringFormatSpec,
     PatternArguments,
     PatternKeyword,
     Comprehension,
@@ -6481,6 +6588,7 @@ pub enum NodeKind {
     ElifElseClause,
     TypeParams,
     FString,
+    TString,
     StringLiteral,
     BytesLiteral,
     Identifier,
@@ -6534,6 +6642,7 @@ impl AnyNodeRef<'_> {
             AnyNodeRef::ExprCompare(_) => NodeKind::ExprCompare,
             AnyNodeRef::ExprCall(_) => NodeKind::ExprCall,
             AnyNodeRef::ExprFString(_) => NodeKind::ExprFString,
+            AnyNodeRef::ExprTString(_) => NodeKind::ExprTString,
             AnyNodeRef::ExprStringLiteral(_) => NodeKind::ExprStringLiteral,
             AnyNodeRef::ExprBytesLiteral(_) => NodeKind::ExprBytesLiteral,
             AnyNodeRef::ExprNumberLiteral(_) => NodeKind::ExprNumberLiteral,
@@ -6549,8 +6658,10 @@ impl AnyNodeRef<'_> {
             AnyNodeRef::ExprSlice(_) => NodeKind::ExprSlice,
             AnyNodeRef::ExprIpyEscapeCommand(_) => NodeKind::ExprIpyEscapeCommand,
             AnyNodeRef::ExceptHandlerExceptHandler(_) => NodeKind::ExceptHandlerExceptHandler,
-            AnyNodeRef::FStringExpressionElement(_) => NodeKind::FStringExpressionElement,
-            AnyNodeRef::FStringLiteralElement(_) => NodeKind::FStringLiteralElement,
+            AnyNodeRef::InterpolatedElement(_) => NodeKind::InterpolatedElement,
+            AnyNodeRef::InterpolatedStringLiteralElement(_) => {
+                NodeKind::InterpolatedStringLiteralElement
+            }
             AnyNodeRef::PatternMatchValue(_) => NodeKind::PatternMatchValue,
             AnyNodeRef::PatternMatchSingleton(_) => NodeKind::PatternMatchSingleton,
             AnyNodeRef::PatternMatchSequence(_) => NodeKind::PatternMatchSequence,
@@ -6562,7 +6673,7 @@ impl AnyNodeRef<'_> {
             AnyNodeRef::TypeParamTypeVar(_) => NodeKind::TypeParamTypeVar,
             AnyNodeRef::TypeParamTypeVarTuple(_) => NodeKind::TypeParamTypeVarTuple,
             AnyNodeRef::TypeParamParamSpec(_) => NodeKind::TypeParamParamSpec,
-            AnyNodeRef::FStringFormatSpec(_) => NodeKind::FStringFormatSpec,
+            AnyNodeRef::InterpolatedStringFormatSpec(_) => NodeKind::InterpolatedStringFormatSpec,
             AnyNodeRef::PatternArguments(_) => NodeKind::PatternArguments,
             AnyNodeRef::PatternKeyword(_) => NodeKind::PatternKeyword,
             AnyNodeRef::Comprehension(_) => NodeKind::Comprehension,
@@ -6578,6 +6689,7 @@ impl AnyNodeRef<'_> {
             AnyNodeRef::ElifElseClause(_) => NodeKind::ElifElseClause,
             AnyNodeRef::TypeParams(_) => NodeKind::TypeParams,
             AnyNodeRef::FString(_) => NodeKind::FString,
+            AnyNodeRef::TString(_) => NodeKind::TString,
             AnyNodeRef::StringLiteral(_) => NodeKind::StringLiteral,
             AnyNodeRef::BytesLiteral(_) => NodeKind::BytesLiteral,
             AnyNodeRef::Identifier(_) => NodeKind::Identifier,
@@ -7023,6 +7135,20 @@ pub struct ExprFString {
     pub value: crate::FStringValue,
 }
 
+/// An AST node that represents either a single-part t-string literal
+/// or an implicitly concatenated t-string literal.
+///
+/// This type differs from the original Python AST `TemplateStr` in that it
+/// doesn't join the implicitly concatenated parts into a single string. Instead,
+/// it keeps them separate and provide various methods to access the parts.
+///
+/// See also [TemplateStr](https://docs.python.org/3/library/ast.html#ast.TemplateStr)
+#[derive(Clone, Debug, PartialEq)]
+pub struct ExprTString {
+    pub range: ruff_text_size::TextRange,
+    pub value: crate::TStringValue,
+}
+
 /// An AST node that represents either a single-part string literal
 /// or an implicitly concatenated string literal.
 #[derive(Clone, Debug, PartialEq)]