Double the braces in a Rust compile-time assertion message [patch]

Coder.Test/Languages/RustGeneratedSourceCompilesTests.cs

@@ -303,6 +303,11 @@ private static SourceFile Exemplar()
 			Condition = "std::mem::size_of::<i32>() == 4",
 			Message = "an i32 is four bytes",
 		});
+		geometry.Members.Add(new CompileTimeAssertion
+		{
+			Condition = "std::mem::size_of::<u8>() == 1",
+			Message = "size {N} fits, brace {} here",
+		});
 
 		file.Members.Add(geometry);
 		return file;

Coder.Test/Languages/RustGeneratorTests.cs

@@ -692,6 +692,18 @@
 		StringAssert.Contains(code, "\"a Point is two i32s\");", StringComparison.Ordinal);
 	}
 
+	/// <summary>
+	/// Tests that braces in an assertion's message are doubled, because <c>assert!</c> reads its
+	/// message as a format string and a single brace would open a placeholder.
+	/// </summary>
+	[TestMethod]
+	public void CompileTimeAssertion_DoublesBracesInTheMessage()
+	{
+		CompileTimeAssertion assertion = new("true", "size {N} fits, brace {} here");
+
+		StringAssert.Contains(Generator.Generate(assertion), "\"size {{N}} fits, brace {{}} here\");", StringComparison.Ordinal);
+	}
+
 	/// <summary>
 	/// Tests that an alias is a type alias.
 	/// </summary>

Coder/Languages/RustGenerator.cs

@@ -341,7 +341,7 @@
 	/// The associated constants of <c>f64</c>, which need nothing imported.
 	/// </remarks>
 	protected override string SpellNonFiniteDouble(double value) =>
 		double.IsNaN(value) ? "f64::NAN" : value > 0 ? "f64::INFINITY" : "f64::NEG_INFINITY";
 
 	/// <inheritdoc/>
 	/// <remarks>
@@ -782,7 +782,7 @@
 		HashSet<string> reassigned = op.ReturnsBool
 			? []
 			: ReassignedNames(funcDecl.Body, [SelfName, .. funcDecl.Parameters.Select(OperandName)]);
 		string self = op.ReturnsBool ? "&self" : reassigned.Contains(SelfName) ? $"mut {SelfName}" : SelfName;
 		code.Write($"fn {op.Method}({self}");
 
 		foreach (Parameter parameter in funcDecl.Parameters)
@@ -1383,6 +1383,10 @@
 	/// <c>const _: () = assert!(…)</c>, which is Rust's own compile-time assertion and needs no
 	/// macro crate: a constant nobody names still has to be evaluated for the program to build, and
 	/// a failed <c>assert!</c> in that position is a compile error naming the message.
+	/// <para>
+	/// The message is <c>assert!</c>'s format string rather than a plain literal, so its braces are
+	/// doubled: a single <c>{N}</c> would be read as a placeholder naming a value that does not exist.
+	/// </para>
 	/// </remarks>
 	protected override void GenerateCompileTimeAssertion(CompileTimeAssertion assertion, CodeBlocker code)
 	{
@@ -1397,7 +1401,10 @@
 		{
 			code.WriteLine(",");
 			code.Indent();
-			code.Write($"\"{EscapeString(assertion.Message)}\"");
+			string message = EscapeString(assertion.Message)
+				.Replace("{", "{{", StringComparison.Ordinal)
+				.Replace("}", "}}", StringComparison.Ordinal);
+			code.Write($"\"{message}\"");
 			code.Outdent();
 		}