style(check): fix shell-escape artifacts in comments

A past edit through a shell pipeline left '\'' sequences in place
of apostrophes across several comment blocks. Restore the plain
apostrophes. Comments only - the legitimate '\'' rune literals in
the converter and error-message code are untouched.

Author: amterp

rts/check/narrow.go

@@ -709,7 +709,7 @@ func narrowByTypeOf(base rl.TypingT, target string) (truthy, falsy rl.TypingT) {
 			// Drop Never contributions; preserve actual types.
 			// nil from a recursive call means "this arm has no
 			// static handle for either side." Pass the arm through
-			// unchanged so the union join doesn'\''t lose it.
+			// unchanged so the union join doesn't lose it.
 			if tA == nil {
 				truthyArms = append(truthyArms, arm)
 			} else if !isNeverType(tA) {
@@ -735,7 +735,7 @@ func narrowByTypeOf(base rl.TypingT, target string) (truthy, falsy rl.TypingT) {
 			// left is null.
 			return inner, rl.NewNullType()
 		}
-		// Inner doesn'\''t match target and null doesn'\''t match any
+		// Inner doesn't match target and null doesn't match any
 		// non-null target. Truthy is empty; falsy is the original.
 		return rl.NewNeverType(), base
 	}

rts/check/narrow_interp_test.go

@@ -187,8 +187,8 @@ func TestNarrowByTypeOf_OptionalNullTarget(t *testing.T) {
 
 func TestNarrowByTypeOf_UnionWithOptionalPreservesNullArm(t *testing.T) {
 	// int?|str narrowed by type_of=="int".
-	// Truthy: int (the optional'\''s inner matched).
-	// Falsy: int? (the optional'\''s null half stays) and str (untouched).
+	// Truthy: int (the optional's inner matched).
+	// Falsy: int? (the optional's null half stays) and str (untouched).
 	// This is the Phase 4h regression test for "union+optional drops null."
 	base := rl.NewUnionType(
 		rl.NewOptionalType(rl.NewIntType()),
@@ -200,14 +200,14 @@ func TestNarrowByTypeOf_UnionWithOptionalPreservesNullArm(t *testing.T) {
 	require.NotNil(t, falsy)
 	// Falsy should contain int? (null arm preserved) and str. Exact
 	// representation depends on the join; what matters is the null
-	// component isn'\''t silently dropped.
+	// component isn't silently dropped.
 	name := falsy.Name()
 	assert.Contains(t, name, "?",
 		"falsy must retain the nullable arm; got %q", name)
 }
 
 func TestNarrowByTypeOf_AnyShortCircuits(t *testing.T) {
-	// any can'\''t be partitioned without losing information.
+	// any can't be partitioned without losing information.
 	truthy, falsy := narrowByTypeOf(rl.NewAnyType(), "int")
 	assert.Nil(t, truthy)
 	assert.Nil(t, falsy)
@@ -268,7 +268,7 @@ func TestInterpretCondition_TypeOfSwappedOperands(t *testing.T) {
 }
 
 func TestInterpretCondition_TypeOfInvalidTargetMakesTruthyUnreachable(t *testing.T) {
-	// type_of(x) == "frobnicate" - "frobnicate" isn'\''t a valid type_of
+	// type_of(x) == "frobnicate" - "frobnicate" isn't a valid type_of
 	// return, so the equality is statically false. Truthy is Never.
 	tc, ident, sym := makeChecker(rl.NewIntType())
 	cond := rl.NewOpBinary(rl.Span{}, rl.OpEq,
@@ -344,7 +344,7 @@ func TestInterpretCondition_StrEnumNeqLiteralInverts(t *testing.T) {
 }
 
 func TestInterpretCondition_StrEnumPlainStrNoNarrowing(t *testing.T) {
-	// Plain str shouldn'\''t narrow to a singleton enum - that surprises
+	// Plain str shouldn't narrow to a singleton enum - that surprises
 	// users who declared the var as str.
 	tc, ident, sym := makeChecker(rl.NewStrType())
 	cond := rl.NewOpBinary(rl.Span{}, rl.OpEq, ident, rl.NewLitStringSimple(rl.Span{}, "x"))

rts/check/type_check_test.go

@@ -841,7 +841,7 @@ y = x
 	require.NotNil(t, ySym)
 	got := info.SymbolTypes[ySym]
 	require.NotNil(t, got)
-	// Union dedupes by Name; order isn'\''t guaranteed because the
+	// Union dedupes by Name; order isn't guaranteed because the
 	// joined symbol map iterates Go maps. Accept either ordering.
 	name := got.Name()
 	assert.Contains(t, []string{"int|str", "str|int"}, name,
@@ -966,7 +966,7 @@ func TestUnionJoin_AllNeverGivesNever(t *testing.T) {
 }
 
 func TestUnionJoin_AnyDoesNotSwallowConcrete(t *testing.T) {
-	// `int | any` keeps both arms - gradual any shouldn'\''t silently
+	// `int | any` keeps both arms - gradual any shouldn't silently
 	// erase the concrete int.
 	got := check.UnionJoinForTest([]rl.TypingT{
 		rl.NewIntType(),
@@ -1068,7 +1068,7 @@ func TestTypeCheck_ReassignmentWidens(t *testing.T) {
 
 func TestTypeCheck_WhileSorbetDropsBodyAssignedNarrowing(t *testing.T) {
 	// The body reassigns x; the post-loop frame must not assume x is
-	// the WhenFalse-narrowed type for x'\''s base. We just verify the
+	// the WhenFalse-narrowed type for x's base. We just verify the
 	// reassigned var has its widened type post-loop.
 	src := `fn f(x: int|str):
     while type_of(x) == "int":
@@ -1156,7 +1156,7 @@ func TestTypeCheck_ForLoopVarFromStringIsStr(t *testing.T) {
 }
 
 func TestTypeCheck_ForLoopVarDynamicForUnknownIter(t *testing.T) {
-	// A function call we can'\''t resolve yields Dynamic.
+	// A function call we can't resolve yields Dynamic.
 	src := `for v in unknown_fn():
     print(v)
 `
@@ -1274,7 +1274,7 @@ func TestTypeCheck_IfDoesNotLeakNarrowingAfter(t *testing.T) {
 	// After a non-exiting if, the narrowing should not persist into
 	// subsequent statements at the same scope. Use a fn param so the
 	// base type stays int? - a top-level `x: int? = 5` would narrow
-	// x to int on assignment, and the if'\''s null-predicate would have
+	// x to int on assignment, and the if's null-predicate would have
 	// nothing to strip.
 	src := `fn f(x: int?):
     if x != null:
@@ -1290,7 +1290,7 @@ func TestTypeCheck_IfDoesNotLeakNarrowingAfter(t *testing.T) {
 	// Branches contribute int (truthy exit) and int? (acc = base).
 	// The dedupe-by-Name union keeps them as int|int?; semantically
 	// equivalent to int? (since int <: int?), but a tighter
-	// representation would need union-arm subsumption that we don'\''t
+	// representation would need union-arm subsumption that we don't
 	// have today.
 	name := gotXUse.Name()
 	assert.Contains(t, []string{"int?", "int|int?", "int?|int"}, name,