feat(codegen): emit Sharpy.Bytes construction from byte string literals

Add GenerateBytesLiteral() that converts b"hello" to
new Sharpy.Bytes(new byte[] { 104, 101, 108, 108, 111 })
using SyntaxFactory. Add SharpyBytes constant to CSharpTypeNames
and bytes mapping to TypeSyntaxMapper. Update exhaustiveness test.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: antonsynd

src/Sharpy.Compiler.Tests/AstExhaustivenessTests.cs

@@ -33,7 +33,7 @@ public void AllExpressionSubtypes_AreCoveredInCodeGen()
         var handledTypes = new HashSet<string>
         {
             // Literals
-            "IntegerLiteral", "FloatLiteral", "StringLiteral",
+            "IntegerLiteral", "FloatLiteral", "StringLiteral", "BytesLiteralExpression",
             "BooleanLiteral", "NoneLiteral", "EllipsisLiteral", "FStringLiteral",
             // Collections
             "ListLiteral", "DictLiteral", "SetLiteral", "TupleLiteral",

src/Sharpy.Compiler/CodeGen/RoslynEmitter.Expressions.cs

@@ -23,6 +23,7 @@ private ExpressionSyntax GenerateExpression(Sharpy.Compiler.Parser.Ast.Expressio
             IntegerLiteral intLit => GenerateIntegerLiteral(intLit),
             FloatLiteral floatLit => GenerateFloatLiteral(floatLit),
             StringLiteral strLit => GenerateStringLiteral(strLit),
+            BytesLiteralExpression bytesLit => GenerateBytesLiteral(bytesLit),
             BooleanLiteral boolLit => LiteralExpression(boolLit.Value ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression),
             NoneLiteral => LiteralExpression(SyntaxKind.DefaultLiteralExpression),
             EllipsisLiteral => GenerateEllipsisLiteral(),
@@ -260,6 +261,26 @@ private ExpressionSyntax GenerateStringLiteral(StringLiteral literal)
         return LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(literal.Value));
     }
 
+    private ExpressionSyntax GenerateBytesLiteral(BytesLiteralExpression literal)
+    {
+        // Convert each character to a byte literal: b"hello" -> new Sharpy.Bytes(new byte[] { 104, 101, 108, 108, 111 })
+        var byteValues = literal.Value.Select(c =>
+            LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal((byte)c)));
+
+        var byteArrayInit = ArrayCreationExpression(
+            ArrayType(PredefinedType(Token(SyntaxKind.ByteKeyword)))
+                .WithRankSpecifiers(SingletonList(
+                    ArrayRankSpecifier(SingletonSeparatedList<ExpressionSyntax>(
+                        OmittedArraySizeExpression())))))
+            .WithInitializer(
+                InitializerExpression(
+                    SyntaxKind.ArrayInitializerExpression,
+                    SeparatedList<ExpressionSyntax>(byteValues)));
+
+        return ObjectCreationExpression(ParseTypeName(CSharpTypeNames.SharpyBytes))
+            .WithArgumentList(ArgumentList(SingletonSeparatedList(Argument(byteArrayInit))));
+    }
+
     /// <summary>
     /// Gets the semantic type of an expression from SemanticInfo, if available.
     /// </summary>

src/Sharpy.Compiler/CodeGen/TypeSyntaxMapper.cs

@@ -34,6 +34,7 @@ static TypeSyntaxMapper()
         _builtinTypeMap[BuiltinNames.List] = CSharpTypeNames.SharpyList;
         _builtinTypeMap[BuiltinNames.Dict] = CSharpTypeNames.SharpyDict;
         _builtinTypeMap[BuiltinNames.Set] = CSharpTypeNames.SharpySet;
+        _builtinTypeMap[BuiltinNames.Bytes] = CSharpTypeNames.SharpyBytes;
         _builtinTypeMap[BuiltinNames.Tuple] = "System.ValueTuple";
     }
 

src/Sharpy.Compiler/Shared/CSharpTypeNames.cs

@@ -9,6 +9,7 @@ internal static class CSharpTypeNames
     internal const string SharpyList = "Sharpy.List";
     internal const string SharpyDict = "Sharpy.Dict";
     internal const string SharpySet = "Sharpy.Set";
+    internal const string SharpyBytes = "Sharpy.Bytes";
     internal const string SharpyOptional = "Sharpy.Optional";
     internal const string SharpyResult = "Sharpy.Result";
     internal const string IEnumerable = "IEnumerable";