From 6afc85846f1938634fc05bc98bf543868ea359cc Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 27 Sep 2026 04:29:12 +0000
Subject: [PATCH] Parenthesise a negative literal under a unary minus

Negating -1 was written (--1), which C, C++, C#, JavaScript and Go read as a
decrement of a literal and refuse to compile. GenerateUnaryExpression now wraps
an operand whose spelling starts with the operator's own last character, so it
comes out (-(-1)).

Fixes ktsu-dev/Coder#82

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NtawxkUssqE3PHcqRCW1Ag
---
 Coder.Test/Languages/UnaryOperandSignTests.cs | 82 +++++++++++++++++++
 Coder/Languages/LanguageGeneratorBase.cs      | 35 ++++++++
 2 files changed, 117 insertions(+)
 create mode 100644 Coder.Test/Languages/UnaryOperandSignTests.cs

diff --git a/Coder.Test/Languages/UnaryOperandSignTests.cs b/Coder.Test/Languages/UnaryOperandSignTests.cs
new file mode 100644
index 0000000..072ba20
--- /dev/null
+++ b/Coder.Test/Languages/UnaryOperandSignTests.cs
@@ -0,0 +1,82 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Coder.Test.Languages;
+
+using ktsu.Coder.Ast;
+using ktsu.Coder.Languages;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+/// <summary>
+/// Tests that a unary operator is not run into the sign of a negative operand.
+/// </summary>
+/// <remarks>
+/// Negating <c>-1</c> written as <c>(--1)</c> is a decrement of a literal in C, C++, C#, JavaScript
+/// and Go, which fails to compile.
+/// </remarks>
+[TestClass]
+public class UnaryOperandSignTests
+{
+	/// <summary>
+	/// Every generator, since each one negates through the shared unary emitter.
+	/// </summary>
+	private static readonly ILanguageGenerator[] Generators =
+	[
+		new CSharpGenerator(),
+		new CGenerator(),
+		new CppGenerator(),
+		new GoGenerator(),
+		new RustGenerator(),
+		new PythonGenerator(),
+		new JavaScriptGenerator(),
+	];
+
+	/// <summary>
+	/// Tests that negating a negative integer literal parenthesises the literal.
+	/// </summary>
+	[TestMethod]
+	public void NegatingANegativeIntegerDoesNotWriteADecrement()
+	{
+		UnaryExpression negated = new(UnaryOperator.Negate, Literal.Number(-1));
+
+		foreach (ILanguageGenerator generator in Generators)
+		{
+			Assert.AreEqual("(-(-1))", generator.Generate(negated).Trim(), generator.GetType().Name);
+		}
+	}
+
+	/// <summary>
+	/// Tests that negating a negative double literal parenthesises the literal.
+	/// </summary>
+	[TestMethod]
+	public void NegatingANegativeDoubleDoesNotWriteADecrement()
+	{
+		UnaryExpression negated = new(UnaryOperator.Negate, Literal.DecimalValue(-1.5));
+
+		foreach (ILanguageGenerator generator in Generators)
+		{
+			string code = generator.Generate(negated);
+
+			Assert.DoesNotContain("--", code, StringComparison.Ordinal, $"{generator.GetType().Name} wrote {code}");
+			Assert.StartsWith("(-(-1.5", code.Trim(), StringComparison.Ordinal, $"{generator.GetType().Name} wrote {code}");
+		}
+	}
+
+	/// <summary>
+	/// Tests that an operand that cannot fuse with the operator is still written bare.
+	/// </summary>
+	/// <param name="op">The operator under test.</param>
+	/// <param name="value">The literal operand.</param>
+	/// <param name="expected">The expected generated source.</param>
+	[TestMethod]
+	[DataRow(UnaryOperator.Negate, 1, "(-1)")]
+	[DataRow(UnaryOperator.Plus, -1, "(+-1)")]
+	public void AnOperandThatCannotFuseIsWrittenBare(UnaryOperator op, int value, string expected)
+	{
+		UnaryExpression unary = new(op, Literal.Number(value));
+
+		foreach (ILanguageGenerator generator in Generators)
+		{
+			Assert.AreEqual(expected, generator.Generate(unary).Trim(), generator.GetType().Name);
+		}
+	}
+}
diff --git a/Coder/Languages/LanguageGeneratorBase.cs b/Coder/Languages/LanguageGeneratorBase.cs
index dae41c6..ec3d004 100644
--- a/Coder/Languages/LanguageGeneratorBase.cs
+++ b/Coder/Languages/LanguageGeneratorBase.cs
@@ -650,6 +650,11 @@ protected void GenerateBinaryExpression(BinaryExpression binaryExpr, CodeBlocker
 	/// <c>not ready</c> and C#'s <c>!ready</c> both come out right without either language special-casing
 	/// the emitter.
 	/// </para>
+	/// <para>
+	/// An operand whose spelling starts with the operator's own last character is parenthesised, so
+	/// negating <c>-1</c> is written <c>(-(-1))</c> rather than <c>(--1)</c>, which every C-family
+	/// target reads as a decrement.
+	/// </para>
 	/// </remarks>
 	protected void GenerateUnaryExpression(UnaryExpression unaryExpr, CodeBlocker code, string operatorSpelling)
 	{
@@ -665,10 +670,40 @@ protected void GenerateUnaryExpression(UnaryExpression unaryExpr, CodeBlocker co
 			code.Write(" ");
 		}
 
+		bool wouldFuse = operatorSpelling.Length > 0 && LeadingSign(unaryExpr.Operand) == operatorSpelling[^1];
+
+		if (wouldFuse)
+		{
+			code.Write("(");
+		}
+
 		GenerateInternal(unaryExpr.Operand, code);
+
+		if (wouldFuse)
+		{
+			code.Write(")");
+		}
+
 		code.Write(")");
 	}
 
+	/// <summary>
+	/// Reports the sign a node's spelling starts with, if any.
+	/// </summary>
+	/// <param name="node">The node to inspect.</param>
+	/// <returns><c>'-'</c> for a negative number literal; otherwise null.</returns>
+	/// <remarks>
+	/// Every other expression starts with a name, a quote, a digit or a parenthesis, so only a
+	/// negative literal can run its sign into the operator in front of it.
+	/// </remarks>
+	private static char? LeadingSign(AstNode? node) => node switch
+	{
+		LiteralExpression<int> { Value: < 0 } => '-',
+		LiteralExpression<double> doubleLit when double.IsNegative(doubleLit.Value) => '-',
+		AstLeafNode<int> { Value: < 0 } => '-',
+		_ => null,
+	};
+
 	/// <summary>
 	/// Reports whether a node is one of the standard shapes a generator built on these helpers accepts.
 	/// </summary>