Is there a decent way to produce nested raw string literals?

[taori]

Currently working on a codegenerator which made me think of testing raw string literals.

I have a scenario where i effectively do this:
var sb = new StringBuilder();

sb.Append(
$$"""
<tab><tab>if(....)
<tab><tab><tab>someExecution()

<tab><tab>{{GenerateSomeMoreCodeWithParameters(properties)}} <!------ nested generation
"""
);

void GenerateSomeMoreCodeWithParameters(IEnumerable<PropertyDeclarationSyntax> properties)
{
	var sb = new StringBuilder();
	foreach (var property in properties)
	{
		var names = (real: property.Identifier.Text, camel: property.Identifier.Text.ToCamelCase());

		sb.AppendLine(
		$$"""
		if (_handler.Get{{names.real}}Completions() is var {{names.camel}}Completions && {{names.camel}}Completions.Length > 0)
		""");
		sb.AppendLine(
		$$"""			
		<TAB>{{names.real}}.AddCompletions({{names.camel}}Completions);
		"""
		);
	}
}

This will generate code like this:

if(....)
someExecution()

if (_handler.GetSomePropertyCompletions() is var somePropertyCompletions && somePropertyCompletions.Length > 0)
SomeProperty.AddCompletions(somePropertyCompletions);

I suppose during language design the issues with nested raw string literals came up but exceeded the scope?

Is there a recommended way to deal with such scenarios? There are not many examples about this i could find yet.

[333fred]

I'm not seeing where you want to nest the literals in this example?

[taori]

your snipet is great to reproduce my issue actually

this points out my problem best i think. i would expect b+c to be indented more than they are.

[CyrusNajmabadi]

using System;

Console.WriteLine($"""
    First line
        {"""
        a
            b
                c
        """}
    Last line
    """);

This is working as intended. Let's start with the inner raw literal. the token for that is:

"""
        a
            b
                c
        """

Given the end quotes, the actual content value of that string is:

'a
    b
        c'

(where the quotes designature the start/end of hte content).

Now, that content is embedded into the following:

FirstLine
    $$
LastLine

(where the dollars indicate where tehy will be inserted). So if you insert:

'a
    b
        c'

into that, you get:

FirstLine
    a
    b
        c
LastLine

Which is exactly as intended here.

[CyrusNajmabadi]

Here's another way of thinking about it. Instead of seeing it as a nested literal that should be impacted by the outer, imagine you just wrote this:

using System;

Console.WriteLine($"""
    First line
        {ComputeInner()}
    Last line
    """);

string ComputeInner()
{
    return """
        a
            b
                c
        """;
}

The interpolations in C# never mutate their contents. So whatever their contents are, however they were obtained, is what will be injected in the final string. In this case, regardless of whether you got that inner string from a literal, or as the result of a method call, we take that content and inject it unmolested.

[taori]

Yeah i think it is perfecly reasonable to leave the implementation as is because it produces technically reliable results. I think the easiest way to move forward, for people who experience the same issue, is to point them to your snippet right above or this.

Resetting the indentation prior to inserting a nested literal produces perfectly understandable indentation cases. Thanks for your guidance with this.

[CyrusNajmabadi]

You're welcome :-)

[CyrusNajmabadi]

Nested literals should work fine. I'm not seeing what the problem is.

[taori]

technically they do work fine and they render the way i would expect them to, but for this use case they behave oddly if the nested string literal has a multiple lines. basically i would expect them to "reset" the left indent further in depending on where a subliteral is injected. not sure if it's clear what i mean

[CyrusNajmabadi]

basically i would expect them to "reset" the left indent further in depending on where a subliteral is injected. not sure if it's clear what i mean

This is not how they work :). Each raw string literal is independent, and its indentation is controlled entirely and only by it's end """ line. Thanks!