SY-4159: Arc String Formatting

arc/cpp/stl/str/str_test.cpp

@@ -7,6 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+#include <cmath>
 #include <limits>
 #include <memory>
 #include <string>
@@ -247,6 +248,7 @@ TEST(StrModule, FromF32FormatsShortestRoundTrip) {
     EXPECT_EQ(call_from<float>(f, "call_from_f32", 100.0f), "100");
     EXPECT_EQ(call_from<float>(f, "call_from_f32", -2.5f), "-2.5");
     EXPECT_EQ(call_from<float>(f, "call_from_f32", 42.5f), "42.5");
+    EXPECT_EQ(call_from<float>(f, "call_from_f32", std::copysign(0.0f, -1.0f)), "-0");
 }
 
 TEST(StrModule, FromF64FormatsShortestRoundTrip) {
@@ -259,6 +261,7 @@ TEST(StrModule, FromF64FormatsShortestRoundTrip) {
         call_from<double>(f, "call_from_f64", 0.1234567890123456),
         "0.1234567890123456"
     );
+    EXPECT_EQ(call_from<double>(f, "call_from_f64", std::copysign(0.0, -1.0)), "-0");
 }
 
 TEST(StrModule, FromF64HandlesNaNAndInfinityWithGoCapitalization) {

arc/go/analyzer/expression/expression.go

@@ -524,7 +524,10 @@ func analyzePrimary(ctx context.Context[parser.IPrimaryExpressionContext]) {
 		}
 		return
 	}
-	if ctx.AST.Literal() != nil {
+	if lit := ctx.AST.Literal(); lit != nil {
+		if rawStr := lit.STR_LITERAL_RAW(); rawStr != nil {
+			AnalyzeStringFmtLiteral(ctx, rawStr)
+		}
 		return
 	}
 	if expr := ctx.AST.Expression(); expr != nil {

arc/go/analyzer/expression/string_fmt.go

@@ -0,0 +1,88 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+package expression
+
+import (
+	"github.com/antlr4-go/antlr/v4"
+	"github.com/synnaxlabs/arc/analyzer/context"
+	"github.com/synnaxlabs/arc/analyzer/types"
+	"github.com/synnaxlabs/arc/fmtstring"
+	"github.com/synnaxlabs/arc/parser"
+	basetypes "github.com/synnaxlabs/arc/types"
+	"github.com/synnaxlabs/x/diagnostics"
+	"github.com/synnaxlabs/x/errors"
+)
+
+// AnalyzeStringFmtLiteral parses a STR_LITERAL_RAW token and analyzes its
+// placeholders. Bypasses literal.ParseRawString so body offsets map to source
+// bytes for per-placeholder diagnostic anchoring.
+func AnalyzeStringFmtLiteral[T antlr.ParserRuleContext](
+	ctx context.Context[T],
+	rawStr antlr.TerminalNode,
+) {
+	body, ok := fmtstring.StripDelimiters(rawStr.GetText())
+	if !ok {
+		ctx.Diagnostics.Add(diagnostics.Error(
+			errors.Newf("invalid raw string literal: %s", rawStr.GetText()), ctx.AST,
+		))
+		return
+	}
+	sym := rawStr.GetSymbol()
+	base := diagnostics.Position{Line: sym.GetLine(), Col: sym.GetColumn() + 1}
+	AnalyzeStringFmtSegments(ctx, body, base, ctx.AST)
+}
+
+// AnalyzeStringFmtSegments parses body and analyzes each placeholder expression
+// in ctx's scope. base is the source position of body[0]; placeholder
+// diagnostics anchor on the offending `{...}` span. Returns parsed segments,
+// or nil if body is malformed.
+func AnalyzeStringFmtSegments[T antlr.ParserRuleContext](
+	ctx context.Context[T],
+	body string,
+	base diagnostics.Position,
+	anchor antlr.ParserRuleContext,
+) []fmtstring.Segment {
+	segments, err := fmtstring.Parse(body)
+	if err != nil {
+		ctx.Diagnostics.Add(diagnostics.Error(err, anchor))
+		return nil
+	}
+	for _, seg := range segments {
+		if !seg.IsPlaceholder {
+			continue
+		}
+		segStart := base.Advance(body, seg.Start)
+		segEnd := base.Advance(body, seg.End)
+		emit := func(d diagnostics.Diagnostic) {
+			ctx.Diagnostics.Add(d.WithRange(segStart, segEnd))
+		}
+		expr, diags := parser.ParseExpression(seg.Text)
+		if diags != nil && !diags.Ok() {
+			emit(diagnostics.Errorf(anchor,
+				"invalid placeholder expression %q: %s", seg.Text, diags.String()))
+			continue
+		}
+		Analyze(context.Child(ctx, expr))
+		t := types.InferFromExpression(context.Child(ctx, expr)).UnwrapChan()
+		if !t.IsNumeric() && t.Kind != basetypes.KindString {
+			emit(diagnostics.Errorf(anchor,
+				"placeholder %q has type %s; only numeric and string types are supported",
+				seg.Text, t))
+			continue
+		}
+		if seg.Spec == "" {
+			continue
+		}
+		if err := fmtstring.ValidateSpec(seg.Spec, t); err != nil {
+			emit(diagnostics.Error(err, anchor))
+		}
+	}
+	return segments
+}