sonicop 26.8.111 → 26.8.113

data/src/rules/style/redundant_current_directory_in_path.rs

@@ -17,7 +17,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         }
         let Some(argument) = node
             .field("arguments")
-            .and_then(|arguments| super::nodes::children(arguments).into_iter().next())
+            .and_then(|arguments| super::nodes::children_in(arguments, context).into_iter().next())
         else {
             continue;
         };
@@ -56,7 +56,7 @@ fn leading_path_content<'a>(node: Node<'_>, context: &'a RuleContext<'_>) -> Opt
     if node.kind_str() != "string" {
         return None;
     }
-    let first = super::nodes::children(node).into_iter().next()?;
+    let first = super::nodes::children_in(node, context).into_iter().next()?;
     if first.kind_str() != "string_content" {
         return None;
     }

data/src/rules/style/redundant_double_splat_hash_braces.rs

@@ -14,7 +14,15 @@ const MERGE_METHODS: &[&str] = &["merge", "merge!"];
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of("hash") {
-        let pairs = super::nodes::children(node);
+        // `node.pairs` lists the `pair` children alone -- a nested `**{…}` is a `kwsplat` and is
+        // not one of them. Counting it as a pair made every hash holding one look rocket-written
+        // and dropped the **outer** hash of `**{a: 1, **{b: 2}}` on the floor.
+        let written = super::nodes::children_in(node, context);
+        let pairs: Vec<Node<'_>> = written
+            .iter()
+            .copied()
+            .filter(|child| child.kind_str() == "pair")
+            .collect();
         if pairs.is_empty() || pairs.iter().any(|pair| is_hash_rocket(*pair, context)) {
             continue;
         }
@@ -35,7 +43,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         offenses.push(
             context
                 .offense(MSG, splat.byte_range())
-                .corrected_by_all(autocorrect(context, node, splat, &pairs)),
+                .corrected_by_all(autocorrect(context, node, splat, &written)),
         );
     }
 }
@@ -98,6 +106,8 @@ fn autocorrect(
     context: &RuleContext<'_>,
     node: Node<'_>,
     splat: Node<'_>,
+    // Everything the braces hold, `kwsplat` children included: the braces come off around all of
+    // it, not just around the pairs.
     pairs: &[Node<'_>],
 ) -> Vec<Edit> {
     let mut edits = Vec::new();
@@ -157,15 +167,15 @@ fn autocorrect(
 }
 
 /// `select_merge_method_nodes`, in the order `each_descendant` walks them.
-fn merge_calls<'tree>(splat: Node<'tree>, context: &RuleContext<'_>) -> Vec<Node<'tree>> {
+fn merge_calls<'tree>(splat: Node<'tree>, context: &'tree RuleContext<'_>) -> Vec<Node<'tree>> {
     let mut found = Vec::new();
     let mut stack: Vec<Node<'tree>> = Vec::new();
-    crate::rules::push_named_children(splat, &mut stack);
+    crate::rules::push_named_children_in(splat, context, &mut stack);
     while let Some(node) = stack.pop() {
         if node.kind_str() == "call" && mergeable(node, context) {
             found.push(node);
         }
-        crate::rules::push_named_children(node, &mut stack);
+        crate::rules::push_named_children_in(node, context, &mut stack);
     }
     found.sort_by_key(Node::start_byte);
     found

data/src/rules/style/redundant_exception.rs

@@ -117,7 +117,9 @@ fn argument_source(context: &RuleContext<'_>, message: &Argument<'_>) -> String
     let literal = message.parts().len() == 1
         && matches!(
             message.first().kind_str(),
-            "string" | "chained_string" | "character" | "heredoc_beginning"
+            // `any_str_type?` is `str`, `dstr` **and `xstr`** -- a backtick command is a string
+            // literal, so it needs no `.to_s`.
+            "string" | "chained_string" | "character" | "heredoc_beginning" | "subshell"
         );
     if literal {
         text.to_owned()

data/src/rules/style/redundant_file_extension_in_require.rs

@@ -21,13 +21,13 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let Some(arguments) = node.field("arguments") else {
             continue;
         };
-        let [name] = super::nodes::children(arguments)[..] else {
+        let [name] = super::nodes::children_in(arguments, context)[..] else {
             continue;
         };
         // `$str_type?`: an interpolated or multi-line literal is a `dstr` upstream.
         if name.kind_str() != "string"
             || name.start_position().row != name.end_position().row
-            || super::nodes::children(name)
+            || super::nodes::children_in(name, context)
                 .iter()
                 .any(|child| child.kind_str() == "interpolation")
         {

data/src/rules/style/redundant_format.rs

@@ -10,6 +10,8 @@ use crate::rules::ruby_literal::{string_value, unescape};
 use crate::rules::send_node::{
     Argument, arguments, has_interpolation, heredoc_body, send_range, symbol_name,
 };
+use crate::rules::send_node::all_children_of;
+use crate::rules::send_node::named_children_iter;
 
 /// `RESTRICT_ON_SEND`.
 const FORMAT_METHODS: &[&str] = &["format", "sprintf"];
@@ -97,8 +99,8 @@ fn static_string_value(node: Node<'_>, context: &RuleContext<'_>) -> Option<Stri
         "string" if !has_interpolation(node) => Some(string_value(node, context)),
         "string" => {
             let mut text = String::new();
-            let mut cursor = node.walk();
-            for child in node.named_children(&mut cursor) {
+            let _cursor = node.walk();
+            for child in named_children_iter(node, context) {
                 if child.kind_str() != "interpolation" {
                     text.push_str(&string_value(node, context));
                     break;
@@ -108,8 +110,8 @@ fn static_string_value(node: Node<'_>, context: &RuleContext<'_>) -> Option<Stri
         }
         "chained_string" => {
             let mut text = String::new();
-            let mut cursor = node.walk();
-            for child in node.named_children(&mut cursor) {
+            let _cursor = node.walk();
+            for child in named_children_iter(node, context) {
                 if child.kind_str() == "string" && !has_interpolation(child) {
                     text.push_str(&string_value(child, context));
                 }
@@ -120,8 +122,8 @@ fn static_string_value(node: Node<'_>, context: &RuleContext<'_>) -> Option<Stri
         "heredoc_beginning" => {
             let body = heredoc_body(node, context)?;
             let mut text = String::new();
-            let mut cursor = body.walk();
-            for child in body.named_children(&mut cursor) {
+            let _cursor = body.walk();
+            for child in named_children_iter(body, context) {
                 if child.kind_str() == "heredoc_content" {
                     text.push_str(context.source.node_text(child));
                 }
@@ -148,6 +150,11 @@ fn detect_unnecessary_fields(
     if template.kind_str() != "string" || has_interpolation(*template) || rest.is_empty() {
         return;
     }
+    // `$str`: a template written over lines is a `dstr` of one `str` per line, which the pattern
+    // does not match.
+    if crate::rules::support::quoted_spans_lines(context.source.node_text(*template)) {
+        return;
+    }
     if splatted_arguments(rest) {
         return;
     }
@@ -204,6 +211,22 @@ fn all_fields_literal(
         if unknown_variable_width(sequence, &pending, values) {
             continue;
         }
+        // `%999…$d`: upstream raises on an argument number no argument answers, and a raising
+        // `format` is not a redundant one. Reading the unparsable number as "no number given"
+        // instead made the cop fold the call to whatever the first argument printed as.
+        if unreadable_argument_number(sequence) {
+            return false;
+        }
+        // `format('%{y}', 2015)` raises `ArgumentError: one hash required`. A named sequence has
+        // nothing to read without a hash to read it from, so there is no value to fold to.
+        if hash.is_none()
+            && matches!(
+                sequence.style,
+                SequenceStyle::Annotated | SequenceStyle::Template
+            )
+        {
+            return false;
+        }
         let Some(index) = find_argument(sequence, &mut pending, hash, values) else {
             continue;
         };
@@ -348,11 +371,30 @@ fn as_integer(value: &Value) -> Option<i128> {
         Value::Float(number) => Some(number.trunc() as i128),
         // `Integer('0x10')` is 16: the prefixes count, which a plain parse would refuse.
         Value::Text(text) => parse_integer(text.trim()),
+        // `Integer((5+0i))` is 5: a complex whose imaginary part is zero converts, and one whose
+        // is not raises. `Value::Complex` keeps what the literal prints as, which is where the
+        // two halves are read from.
+        Value::Complex(text) => real_part_of_complex(text),
         Value::Computed(inner) => as_integer(inner),
         _ => None,
     }
 }
 
+/// The real part of a complex literal whose imaginary part is zero, as `Integer()` reads it.
+fn real_part_of_complex(text: &str) -> Option<i128> {
+    let body = text.trim();
+    let imaginary = body.rfind(['+', '-']).filter(|index| *index > 0)?;
+    if !body.ends_with('i') {
+        return None;
+    }
+    let tail = &body[imaginary + 1..body.len() - 1];
+    // `(5+0i)` converts, `(5+1i)` does not.
+    if tail.parse::<f64>().ok()? != 0.0 {
+        return None;
+    }
+    parse_integer(body[..imaginary].trim())
+}
+
 /// `numeric?` together with `Float(value, exception: false)`.
 fn as_float(value: &Value) -> Option<f64> {
     match value {
@@ -360,6 +402,7 @@ fn as_float(value: &Value) -> Option<f64> {
         Value::Rational(numerator, denominator) => Some(*numerator as f64 / *denominator as f64),
         Value::Float(number) => Some(*number),
         Value::Text(text) => text.trim().parse::<f64>().ok(),
+        Value::Complex(text) => real_part_of_complex(text).map(|number| number as f64),
         Value::Computed(inner) => as_float(inner),
         _ => None,
     }
@@ -458,7 +501,7 @@ fn pair_value(context: &RuleContext<'_>, pair: Node<'_>) -> Option<(String, Valu
 /// `argument_value`, for the literals this cop can reproduce.
 fn argument_value(context: &RuleContext<'_>, node: Node<'_>) -> Option<Value> {
     let node = match node.kind_str() {
-        "parenthesized_statements" => *super::nodes::children(node).first()?,
+        "parenthesized_statements" => *super::nodes::children_in(node, context).first()?,
         _ => node,
     };
     let text = context.source.node_text(node);
@@ -490,6 +533,9 @@ fn argument_value(context: &RuleContext<'_>, node: Node<'_>) -> Option<Value> {
         "delimited_symbol" if !has_interpolation(node) => {
             symbol_name(node, context).map(|name| Value::Text(name.to_owned()))
         }
+        // `dsym_value`: a symbol written with an interpolation formats to what its own text reads
+        // as, so `:"#{foo}"` carries the same value the string `"#{foo}"` does.
+        "delimited_symbol" => Some(Value::Dynamic(dstr_value(node, context))),
         // `?a`, which the parser resolves into the one-character string it stands for.
         "character" => Some(Value::Text(crate::rules::ruby_literal::character_value(
             text,
@@ -501,7 +547,7 @@ fn argument_value(context: &RuleContext<'_>, node: Node<'_>) -> Option<Value> {
         "complex" => complex_value(text).map(Value::Complex),
         "hash" => {
             let mut held = Vec::new();
-            for pair in super::nodes::children(node) {
+            for pair in super::nodes::children_in(node, context) {
                 held.push(pair_value(context, pair)?);
             }
             Some(Value::Pairs(held))
@@ -541,7 +587,10 @@ fn computed_number(context: &RuleContext<'_>, node: Node<'_>) -> Option<Value> {
                 true => "",
                 false => "+",
             };
-            let imaginary = imaginary.trim_start_matches("0+").trim_start_matches("0");
+            // Only the `0+` real part that `complex_value` writes comes off. Trimming a further
+            // `0` turned `(5+0i)` into `5+i`, which is `5+1i` -- and `Integer()` then refused it,
+            // because a complex with a non-zero imaginary part does not convert.
+            let imaginary = imaginary.trim_start_matches("0+");
             Some(Value::Computed(Box::new(Value::Complex(format!(
                 "{left_text}{sign}{imaginary}"
             )))))
@@ -554,7 +603,7 @@ fn computed_number(context: &RuleContext<'_>, node: Node<'_>) -> Option<Value> {
 /// interpolated contributes the source it was written as.
 fn dstr_value(node: Node<'_>, context: &RuleContext<'_>) -> String {
     if node.kind_str() == "chained_string" {
-        return super::nodes::children(node)
+        return super::nodes::children_in(node, context)
             .into_iter()
             .map(|child| dstr_value(child, context))
             .collect();
@@ -563,8 +612,8 @@ fn dstr_value(node: Node<'_>, context: &RuleContext<'_>) -> String {
         return string_value(node, context);
     }
     let mut value = String::new();
-    let mut cursor = node.walk();
-    for child in node.named_children(&mut cursor) {
+    let _cursor = node.walk();
+    for child in named_children_iter(node, context) {
         match child.kind_str() {
             "string_content" => value.push_str(context.source.node_text(child)),
             "escape_sequence" => unescape(context.source.node_text(child), &mut value),
@@ -645,6 +694,15 @@ fn apply_format(text: &str, values: &[Value]) -> Option<String> {
             }
             false => sequence.width.parse::<isize>().ok(),
         };
+        // `%.*f` takes its precision from an argument too, and consumes it before the value.
+        let precision = match sequence.precision.starts_with('*') {
+            true => {
+                let taken = *pending.first()?;
+                pending.remove(0);
+                Some(as_integer(values.get(taken)?)?.max(0) as usize)
+            }
+            false => None,
+        };
         let index = match hash.is_some()
             && matches!(
                 sequence.style,
@@ -661,17 +719,27 @@ fn apply_format(text: &str, values: &[Value]) -> Option<String> {
             },
         };
         let value = value_at(values, hash, sequence, index)?;
-        out.push_str(&render(sequence, value, width)?);
+        out.push_str(&render(sequence, value, width, precision)?);
     }
     out.push_str(text.get(cursor..)?);
     Some(out)
 }
 
 /// One formatted field.
-fn render(sequence: &Sequence, value: &Value, width: Option<isize>) -> Option<String> {
-    let precision: Option<usize> = match sequence.precision.is_empty() {
-        true => None,
-        false => Some(sequence.precision.parse().ok()?),
+fn render(
+    sequence: &Sequence,
+    value: &Value,
+    width: Option<isize>,
+    from_argument: Option<usize>,
+) -> Option<String> {
+    let precision: Option<usize> = match from_argument {
+        Some(precision) => Some(precision),
+        None => match (sequence.has_precision, sequence.precision.is_empty()) {
+            (false, _) => None,
+            // `%.d`: the dot with no digits behind it asks for a precision of zero.
+            (true, true) => Some(0),
+            (true, false) => Some(sequence.precision.parse().ok()?),
+        },
     };
     let kind = match sequence.style {
         SequenceStyle::Template => 's',
@@ -689,6 +757,11 @@ fn render(sequence: &Sequence, value: &Value, width: Option<isize>) -> Option<St
             let number = as_integer(value)?;
             let mut digits = number.unsigned_abs().to_string();
             if let Some(precision) = precision {
+                // `format('%.d', 0)` is `''`: a precision of zero asks for no digits at all, and
+                // zero has none to keep. Padding up to the precision left the `0` in place.
+                if precision == 0 && number == 0 {
+                    digits.clear();
+                }
                 while digits.len() < precision {
                     digits.insert(0, '0');
                 }
@@ -784,9 +857,9 @@ fn to_s(value: &Value) -> String {
 
 /// `quote`: the result keeps the delimiters the template was written with.
 fn quote(context: &RuleContext<'_>, template: Node<'_>, call: Node<'_>, formatted: &str) -> String {
-    let mut cursor = template.walk();
-    let delimiters: Vec<Node<'_>> = template
-        .children(&mut cursor)
+    let _cursor = template.walk();
+    let delimiters: Vec<Node<'_>> = all_children_of(template, context)
+        .into_iter()
         .filter(|child| !child.is_named())
         .collect();
     let mut opening = delimiters.first().map_or("'".to_owned(), |token| {
@@ -863,3 +936,8 @@ fn report(context: &RuleContext<'_>, call: Node<'_>, replacement: String) -> Off
             safe: true,
         })
 }
+
+/// A `%N$` whose `N` no `usize` holds -- upstream raises rather than formatting.
+fn unreadable_argument_number(sequence: &Sequence) -> bool {
+    sequence.flags.contains('$') && argument_number(sequence).is_none()
+}

data/src/rules/style/redundant_freeze.rs

@@ -132,7 +132,7 @@ fn operation_produces_immutable_object(
     if node.kind_str() != "parenthesized_statements" {
         return false;
     }
-    let children = super::nodes::children(node);
+    let children = super::nodes::children_in(node, context);
     let [only] = children.as_slice() else {
         return false;
     };

data/src/rules/style/redundant_heredoc_delimiter_quotes.rs

@@ -67,7 +67,7 @@ fn needs_quotes(
     let Some(body) = send_node::heredoc_body(node, context) else {
         return true;
     };
-    let children = super::nodes::children(body);
+    let children = super::nodes::children_in(body, context);
     let Some(end) = children
         .last()
         .filter(|last| last.kind_str() == "heredoc_end")

data/src/rules/style/redundant_initialize.rs

@@ -42,7 +42,7 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         let statements = node
             .field("body")
             .map(|body| {
-                super::nodes::children(body)
+                super::nodes::children_in(body, context)
                     .into_iter()
                     .filter(|child| child.kind_str() != "comment")
                     .collect::<Vec<Node<'_>>>()
@@ -122,10 +122,13 @@ fn holds_comments(node: Node<'_>, context: &RuleContext<'_>) -> bool {
 /// `find_end_line` for a definition.
 fn find_end_line(node: Node<'_>, context: &RuleContext<'_>) -> usize {
     let fallback = context.source.line_column(node.end_byte()).0;
-    let Some(parent) = node.parent() else {
+    // `node.parent` is nil at the top level upstream, and the `|| node.loc.end.line` fallback is
+    // what answers there. The grammar hands back `program` instead, which would otherwise put the
+    // end line at 1 and hide every comment inside the definition.
+    let Some(parent) = node.parent().filter(|parent| parent.kind_str() != "program") else {
         return fallback;
     };
-    let siblings: Vec<Node<'_>> = super::nodes::children(parent)
+    let siblings: Vec<Node<'_>> = super::nodes::children_in(parent, context)
         .into_iter()
         .filter(|child| child.kind_str() != "comment")
         .collect();

data/src/rules/style/redundant_interpolation.rs

@@ -5,8 +5,8 @@ use tree_sitter::Node;
 use crate::diagnostic::{Edit, Offense};
 use crate::ruby_version::RubyVersion;
 use crate::rules::RuleContext;
-use crate::rules::send_node;
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node;
 
 const MSG: &str = "Prefer `to_s` over string interpolation.";
 
@@ -20,7 +20,7 @@ const NOT_ON_ITS_OWN: &[&str] = &["chained_string", "string_array", "symbol_arra
 
 pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
     for node in context.nodes_of("string") {
-        let children = super::nodes::children(node);
+        let children = super::nodes::children_in(node, context);
         let [interpolation] = children.as_slice() else {
             continue;
         };
@@ -39,12 +39,14 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
         if is_symbol_key(context, node) {
             continue;
         }
-        let embedded = super::nodes::children(*interpolation);
-        // `use_match_pattern?`: `"#{x => y}"` binds a name rather than producing one.
+        let embedded = super::nodes::children_in(*interpolation, context);
+        // `use_match_pattern?`: `"#{x => y}"` binds a name rather than producing one. The test it
+        // runs is `match_pattern_type?`, which `x in y` fails -- that is a `match_pattern_p`, and
+        // `"#{42 in var}"` is reported like any other interpolation.
         if context.target_ruby_version() > RubyVersion::new(2, 7)
             && embedded
                 .iter()
-                .any(|child| matches!(child.kind_str(), "match_pattern" | "test_pattern"))
+                .any(|child| child.kind_str() == "match_pattern")
         {
             continue;
         }
@@ -162,9 +164,7 @@ fn is_symbol_key(context: &RuleContext<'_>, node: Node<'_>) -> bool {
         return false;
     };
     parent.kind_str() == "pair"
-        && parent
-            .field("key")
-            .is_some_and(|key| key.id() == node.id())
+        && parent.field("key").is_some_and(|key| key.id() == node.id())
         && parent
             .child(1)
             .is_some_and(|separator| context.source.node_text(separator) == ":")

data/src/rules/style/redundant_interpolation_unfreeze.rs

@@ -47,7 +47,7 @@ fn interpolates(node: Node<'_>, context: &RuleContext<'_>) -> bool {
     } else {
         node
     };
-    super::nodes::children(literal)
+    super::nodes::children_in(literal, context)
         .iter()
         .any(|child| match child.kind_str() {
             "interpolation" => true,
@@ -83,7 +83,14 @@ fn unfreezing(
                 return None;
             }
             let selector = parent.field("method")?;
-            if context.source.node_text(selector) != "dup" {
+            // `:+@` written as an ordinary call (`"...".+@`) reaches the same matcher as the
+            // unary form; the grammar only spells the operator one as `unary`.
+            if !matches!(context.source.node_text(selector), "dup" | "+@") {
+                return None;
+            }
+            // `(send dstr_type? {:+@ :dup})` takes no arguments: `"…".dup(baz)` is a different
+            // call and upstream leaves it alone.
+            if !crate::rules::send_node::arguments(parent).is_empty() {
                 return None;
             }
             Some((
@@ -106,7 +113,7 @@ fn unfreezing(
             if context.source.node_text(selector) != "new" {
                 return None;
             }
-            match super::nodes::children(parent).as_slice() {
+            match super::nodes::children_in(parent, context).as_slice() {
                 [only] if only.id() == node.id() => {}
                 _ => return None,
             }

data/src/rules/style/redundant_line_continuation.rs

@@ -6,8 +6,9 @@ use tree_sitter::Node;
 
 use crate::diagnostic::{Edit, Offense};
 use crate::rules::RuleContext;
-use crate::rules::layout::tokens::{TokenKind, tokens};
+use crate::rules::layout::tokens::{Token, TokenKind, tokens};
 use crate::rules::node_ext::NodeExt;
+use crate::rules::send_node::named_children_of;
 
 const MSG: &str = "Redundant line continuation.";
 
@@ -66,10 +67,12 @@ pub(super) fn check(context: &RuleContext<'_>, offenses: &mut Vec<Offense>) {
 /// continuation written after the last of them.
 fn ast_range(context: &RuleContext<'_>) -> Option<Range<usize>> {
     let root = context.root_node();
-    let mut cursor = root.walk();
-    let statements: Vec<Node<'_>> = root
-        .named_children(&mut cursor)
-        .filter(|child| child.kind_str() != "comment")
+    let _cursor = root.walk();
+    let statements: Vec<Node<'_>> = named_children_of(root, context)
+        .into_iter()
+        // `__END__` and what follows it is `DATA`, not code: upstream's AST stops at the keyword,
+        // so a `\` down there is out of the range the candidates are searched in.
+        .filter(|child| !matches!(child.kind_str(), "comment" | "uninterpreted"))
         .collect();
     let (first, last) = (statements.first()?, statements.last()?);
     Some(first.start_byte()..last.end_byte())
@@ -102,7 +105,7 @@ fn within_comment(context: &RuleContext<'_>, range: &Range<usize>) -> bool {
 /// `implicit_string_concatenation?`: two string literals written one under the other, which the
 /// continuation is what joins.
 fn implicit_string_concatenation(context: &RuleContext<'_>, range: &Range<usize>) -> bool {
-    let stream = tokens(context);
+    let stream: &[Token] = tokens(context);
     let line = context.source.line_column(range.start).0;
     let before = stream.iter().rfind(|token| token.range.end <= range.start);
     let ends = before.is_some_and(|token| {
@@ -131,7 +134,7 @@ fn string_content_ranges(context: &RuleContext<'_>) -> Vec<Range<usize>> {
     let mut stack = vec![context.root_node()];
     while let Some(node) = stack.pop() {
         if !LITERALS.contains(&node.kind_str()) {
-            crate::rules::push_named_children(node, &mut stack);
+            crate::rules::push_named_children_in(node, context, &mut stack);
             continue;
         }
         // What an interpolation holds is code again, so it is cut out of the literal and walked.