Upload 33 files

roblox-cs-master/.github/FUNDING.yml

@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+github: R-unic
+ko_fi: runic_

roblox-cs-master/.github/workflows/publish.yml

@@ -0,0 +1,50 @@
+name: Publish
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up .NET Core
+      uses: actions/setup-dotnet@v4.0.1
+      with:
+        dotnet-version: '8.0.x'
+
+    - name: Install xmllint
+      run: sudo apt-get update && sudo apt-get install -y libxml2-utils
+
+    - name: Add GitHub source to NuGet
+      run: dotnet nuget add source --username roblox-csharp --password ${{ secrets.GITHUB_TOKEN }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/roblox-csharp/index.json"
+
+    - name: Extract version from .csproj
+      id: extract_version
+      run: |
+        VERSION=$(xmllint --xpath "string(//Project/PropertyGroup/Version)" RobloxCS/RobloxCS.csproj)
+        echo "PACKAGE_VERSION=$VERSION" >> $GITHUB_ENV
+
+    - name: Package the project
+      run: dotnet pack --configuration Release
+
+    - name: Check if version is already published
+      id: check_version
+      run: |
+        VERSION_EXISTS=$(dotnet nuget search roblox-cs --source "github" | grep -c "${{ env.PACKAGE_VERSION }}" || true)
+        echo "VERSION_EXISTS=$VERSION_EXISTS" >> $GITHUB_ENV
+
+    - name: Find and publish the latest package
+      if: env.VERSION_EXISTS == '0'
+      run: |
+        PACKAGE_PATH=$(find ./RobloxCS/bin/Release -name "*.nupkg" -type f -print0 | xargs -0 ls -1t | head -n 1)
+        dotnet nuget push "$PACKAGE_PATH" --api-key ${{ secrets.GITHUB_TOKEN }} --source "github" --skip-duplicate
+
+    - name: Version already published
+      if: env.VERSION_EXISTS != '0'
+      run: echo "The version is already published. Skipping publish step."

roblox-cs-master/.github/workflows/tests.yml

@@ -0,0 +1,26 @@
+name: CI
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 8.0.x
+    - name: Add GitHub source to NuGet
+      run: dotnet nuget add source --username roblox-csharp --password ${{ secrets.GITHUB_TOKEN }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/roblox-csharp/index.json"
+    - name: Restore dependencies
+      run: dotnet restore
+    - name: Build (Release)
+      run: dotnet build -c Release --no-restore
+    - name: Build (Debug)
+      run: dotnet build -c Debug --no-restore
+    - name: Test
+      run: dotnet test --no-build --verbosity normal

roblox-cs-master/.gitignore

@@ -0,0 +1,5 @@
+bin/
+obj/
+.vs/
+include/
+TestProject/

roblox-cs-master/README.md

@@ -0,0 +1,13 @@
+# roblox-cs
+
+![CI](https://github.com/roblox-csharp/roblox-cs/actions/workflows/tests.yml/badge.svg)  
+Roblox CSharp to Lua compiler
+
+## Contributing
+### This section only applies for the `rewrite` branch currently, I will not accept PRs on the `master` branch!
+
+1. [Fork it](https://github.com/roblox-csharp/roblox-cs/fork)
+2. Commit your changes (`git commit -m 'feat: add some feature'`)
+3. Test your code (`dotnet test` or Ctrl + R, A in Visual Studio)
+4. Push your changes (`git push`)
+5. Create a pull request

roblox-cs-master/RobloxCS.CLI/Program.cs

@@ -0,0 +1,178 @@
+using System.Reflection;
+using LibGit2Sharp;
+using CommandLine;
+using Spectre.Console;
+using DotNet = Microsoft.DotNet.Cli.Utils;
+
+namespace RobloxCS.CLI
+{
+    public static class Program
+    {
+        private const string _exampleProjectRepo = "https://github.com/roblox-csharp/example-project.git";
+        private static readonly Assembly _compilerAssembly = Assembly.Load("RobloxCS");
+        private static readonly System.Version _version = _compilerAssembly.GetName().Version!;
+
+        public class Options
+        {
+            [Option('v', "version", Required = false, HelpText = "Return the compiler version.")]
+            public bool Version { get; set; }
+
+            [Option('w', "watch", Required = false, HelpText = "Watches the directory and re-compiles when changes are detected.")]
+            public bool WatchMode { get; set; }
+
+            [Option("init", Required = false, HelpText = "Initialize a new roblox-cs project.")]
+            public bool Init { get; set; }
+
+            [Value(0, Required = false, HelpText = "Project directory path", MetaName = "Path")]
+            public string? Path { get; set; }
+        }
+
+        public static void Main(string[] args)
+        {
+            Parser.Default.ParseArguments<Options>(args)
+                .WithParsed(options =>
+                {
+                    var path = options.Path ?? ".";
+                    if (options.Version)
+                    {
+                        Console.WriteLine($"roblox-cs {_version.Major}.{_version.Minor}.{_version.Build}");
+                    }
+                    else if (options.Init)
+                    {
+                        InitializeProject(path);
+                    }
+                    else if (options.WatchMode)
+                    {
+                        StartWatchMode(path);
+                    }
+                    else
+                    {
+                        new Transpiler(path).Transpile();
+                    }
+                });
+        }
+
+        private static void StartWatchMode(string path)
+        {
+            var transpiler = new Transpiler(path);
+            var watcher = new FileSystemWatcher
+            {
+                Path = path,
+                NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.Size,
+                Filter = "*.*",
+                IncludeSubdirectories = true
+            };
+
+            watcher.Changed += (sender, e) => OnFileChanged(path, e);
+            watcher.Created += (sender, e) => OnFileChanged(path, e);
+            watcher.Renamed += (sender, e) => OnFileChanged(path, e);
+            watcher.Deleted += (sender, e) => OnFileChanged(path, e);
+            watcher.EnableRaisingEvents = true;
+
+            AnsiConsole.MarkupLine("[yellow]Watching for file changes. Press \"enter\" to exit.[/]");
+            Console.WriteLine();
+            Console.ReadLine();
+        }
+
+        private static void OnFileChanged(string path, FileSystemEventArgs e)
+        {
+            HashSet<WatcherChangeTypes> validChangeTypes = [WatcherChangeTypes.Changed, WatcherChangeTypes.Created, WatcherChangeTypes.Renamed];
+            if (!validChangeTypes.Contains(e.ChangeType)) return;
+
+            var filePath = Utility.FixPathSep(e.FullPath);
+            var extension = Path.GetExtension(filePath);
+            var transpiler = new Transpiler(path);
+            var isValidLuaFile = extension == ".lua"
+                && !filePath.EndsWith("include/RuntimeLib.lua")
+                && !filePath.Contains($"/{transpiler.Config.OutputFolder}/");
+
+            if (extension == ".cs" || isValidLuaFile || extension == ".yml")
+            {
+                AnsiConsole.MarkupLine($"[yellow]{(e.ChangeType == WatcherChangeTypes.Renamed ? "Changed" : e.ChangeType)}: {filePath}[/]");
+                transpiler.Transpile();
+            }
+        }
+
+        private static void InitializeProject(string path)
+        {
+            var projectName = Path.GetDirectoryName(path) == "" ? Path.GetFileName(path) : Path.GetDirectoryName(path) ?? "Example";
+            try
+            {
+                Repository.Clone(_exampleProjectRepo, path);
+                AnsiConsole.MarkupLine($"[cyan]Repository cloned to {Path.GetFullPath(path)}[/]");
+            }
+            catch (Exception ex)
+            {
+                AnsiConsole.MarkupLine($"[red]Failed to clone example project repository: {ex.Message}[/]");
+                Environment.Exit(1);
+            }
+
+            DeleteDirectoryManual(Path.Combine(path, ".git"));
+            DotNet.Command.Create("dotnet", ["restore", path]).Execute();
+            AnsiConsole.MarkupLine("[cyan]Successfully restored .NET project.[/]");
+
+            if (projectName != "Example")
+            {
+                var projectFolder = path;
+                var projectSourceFolder = Path.Combine(projectFolder, projectName, "src");
+                var projectFile = Path.Combine(projectSourceFolder, $"{projectName}.csproj");
+                var rojoManifestFile = Path.Combine(projectFolder, projectName, "default.project.json");
+
+                AnsiConsole.MarkupLine("[yellow]Renaming project...[/]");
+                File.Delete(Path.Combine(path, "Example.sln"));
+                DotNet.Command.Create("dotnet", ["new", "sln", "-n", projectName, "-o", path]).Execute();
+                Directory.Move(Path.Combine(path, "Example"), Path.Combine(projectFolder, projectName));
+                File.Move(Path.Combine(projectSourceFolder, "Example.csproj"), projectFile);
+
+                // Dynamicallty replace <Title>...</Title> inside of the csproj file. This sucks, and we must edit the solution to not lose the reference to it.
+                var lines = File.ReadAllText(projectFile);
+                var start = lines.IndexOf("<Title>", StringComparison.InvariantCulture) + "<Title>".Length;
+                var end = lines.IndexOf("</Title>", StringComparison.InvariantCulture);
+                lines = lines.Remove(start, end - start);
+                lines = lines.Insert(start, projectName);
+                File.WriteAllText(projectFile, lines);
+
+                DotNet.Command.Create("dotnet", ["sln", Path.Combine(path, $"{projectName}.sln"), "add", projectFile]).Execute();
+                AnsiConsole.MarkupLine("[cyan]Successfully renamed project.[/]");
+
+                AnsiConsole.MarkupLine("[yellow]Modifying rojo manifest...[/]");
+
+                var rojoManifest = File.ReadAllText(rojoManifestFile);
+                // Match for the name JSON key and its end and replace the name of it, horrible, but works.
+                var idxOfStart = rojoManifest.IndexOf("\"name\": \"", StringComparison.InvariantCulture) + "\"name\": \"".Length;
+                var idxOfEnd = rojoManifest.IndexOf("\",", idxOfStart, StringComparison.InvariantCulture);
+                rojoManifest = rojoManifest.Remove(idxOfStart, idxOfEnd - idxOfStart);
+                rojoManifest = rojoManifest.Insert(idxOfStart, projectName);
+                File.WriteAllText(rojoManifestFile, rojoManifest);
+
+            }
+
+            Console.WriteLine($"Configuration:");
+            var initRepo = AnsiConsole.Confirm("\t[yellow]Do you want to initialize a Git repository?[/]", true);
+            if (initRepo)
+            {
+                Repository.Init(path);
+                AnsiConsole.MarkupLine("[cyan]Successfully initialized Git repository.[/]");
+            }
+        }
+
+        private static void DeleteDirectoryManual(string path)
+        {
+            if (Directory.Exists(path))
+            {
+                foreach (string file in Directory.GetFiles(path))
+                {
+                    File.SetAttributes(file, FileAttributes.Normal); // Ensure file is not read-only
+                    File.Delete(file);
+                }
+
+                foreach (string subdir in Directory.GetDirectories(path))
+                {
+                    DeleteDirectoryManual(subdir);
+                }
+
+                Directory.Delete(path, recursive: true);
+            }
+        }
+    }
+}

roblox-cs-master/RobloxCS.CLI/RobloxCS.CLI.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <OutputPath>../bin/</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AssemblyName>rbxcsc</AssemblyName>
+    <RootNamespace>RobloxCS</RootNamespace>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\RobloxCS\RobloxCS.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="CommandLineParser" Version="2.9.1" />
+    <PackageReference Include="LibGit2Sharp" Version="0.30.0" />
+    <PackageReference Include="Microsoft.DotNet.Cli.Utils" Version="2.0.0" />
+    <PackageReference Include="Spectre.Console" Version="0.49.1" />
+  </ItemGroup>
+
+</Project>

roblox-cs-master/RobloxCS.Tests/CodeGenerator_Should.cs

@@ -0,0 +1,290 @@
+namespace RobloxCS.Tests
+{
+    public class CodeGenerator_Should
+    {
+        [Fact]
+        public void NativeAttribute_GeneratesLuauAttribute()
+        {
+            var cleanedLua = GetCleanLua("using Roblox; [Native] void doSomething() { }");
+            var lines = GetLines(cleanedLua);
+            var expectedLines = new List<string>
+            {
+                "@native",
+                "local function doSomething(): nil",
+                    "return nil :: any",
+                "end"
+            };
+
+            AssertEqualLines(lines, expectedLines);
+        }
+
+        [Fact]
+        public void IfStatements_GeneratesIf()
+        {
+            var cleanedLua = GetCleanLua("using static Roblox.Globals; var x = 1; if (x == 4) print(\"x is 4\"); else if (x == \"abc\") print(\"x is abc\"); else print(\"x is unknown\");", 1);
+            var lines = GetLines(cleanedLua);
+            var expectedLines = new List<string>
+            {
+                "if x == 4 then",
+                    "print(\"x is 4\")",
+                "elseif x == \"abc\" then",
+                    "print(\"x is abc\")",
+                "else",
+                    "print(\"x is unknown\")",
+                "end"
+            };
+
+            AssertEqualLines(lines, expectedLines);
+        }
+
+        [Theory]
+        [InlineData("var @abc = 1")]
+        [InlineData("var @hello_brah = 1")]
+        [InlineData("var @SIGMA = 1")]
+        public void IdentifierWithAtSymbol_HasAtSymbolRemoved(string expression)
+        {
+            var cleanedLua = GetCleanLua(expression);
+            Assert.Equal(expression.Replace("@", "").Replace("var", "local"), cleanedLua);
+        }
+
+        [Theory]
+        [InlineData("ToNumber(\"69\")")]
+        [InlineData("ToFloat(\"69\")")]
+        [InlineData("ToDouble(\"69\")")]
+        [InlineData("ToInt(\"69\")")]
+        [InlineData("ToUInt(\"69\")")]
+        [InlineData("ToShort(\"69\")")]
+        [InlineData("ToUShort(\"69\")")]
+        [InlineData("ToByte(\"69\")")]
+        [InlineData("ToSByte(\"69\")")]
+        public void NumberParsingMethods_MacroToToNumber(string methodCall)
+        {
+            var cleanedLua = GetCleanLua(methodCall);
+            Assert.Equal("tonumber(\"69\")", cleanedLua);
+        }
+
+        [Fact]
+        public void NamespaceDeclaration_GeneratesRuntimeCalls()
+        {
+
+            var cleanedLua = GetCleanLua("namespace Test { }");
+            var expectedLua = "CS.namespace(\"Test\", @native function(namespace: CS.Namespace)\nend)";
+            Assert.Equal(expectedLua, cleanedLua);
+        }
+
+        [Fact]
+        public void NestedNamespaceDeclaration_GeneratesRuntimeCalls()
+        {
+
+            var cleanedLua = GetCleanLua("namespace Test.Nested { }");
+            var lines = GetLines(cleanedLua);
+            var expectedLines = new List<string>
+            {
+                "CS.namespace(\"Test\", @native function(namespace: CS.Namespace)",
+                    "namespace:namespace(\"Nested\", @native function(namespace: CS.Namespace)",
+                    "end)",
+                "end)"
+            };
+
+            AssertEqualLines(lines, expectedLines);
+        }
+
+        [Fact]
+        public void ClassDeclaration_GeneratesRuntimeCalls()
+        {
+            var cleanedLua = GetCleanLua("namespace Test { class HelloWorld { } }");
+            var lines = GetLines(cleanedLua);
+            var expectedLines = new List<string>
+            {
+                "CS.namespace(\"Test\", @native function(namespace: CS.Namespace)",
+                    "namespace:class(\"HelloWorld\", @native function(namespace: CS.Namespace)",
+                        "local class = CS.classDef(\"HelloWorld\", namespace)",
+                        "",
+                        "function class.new()",
+                            "local mt = {}",
+                            "local self = CS.classInstance(class, mt, namespace)",
+                            "",
+                            "",
+                            "return self",
+                        "end",
+                        "",
+                        "return class",
+                    "end)",
+                "end)"
+            };
+
+            AssertEqualLines(lines, expectedLines);
+        }
+
+        [Theory]
+        [InlineData("var x = 5;", "local x = 5")]
+        [InlineData("char f = 'f'", "local f: string = \"f\"")]
+        [InlineData("object a = 123", "local a: any = 123")]
+        public void VariableDeclaration_GeneratesLocal(string input, string expected)
+        {
+            var cleanedLua = GetCleanLua(input);
+            Assert.Equal(expected, cleanedLua);
+        }
+
+        [Theory]
+        [InlineData("(1 + 2) * 4")]
+        [InlineData("(44 / (4 % 6) * 12) - 2")]
+        public void Parentheses_GenerateParentheses(string input)
+        {
+            var cleanedLua = GetCleanLua(input);
+            Assert.Equal(input, cleanedLua);
+        }
+
+        [Theory]
+        [InlineData("69", "69")]
+        [InlineData("420.0f", "420")]
+        [InlineData("'h'", "\"h\"")]
+        [InlineData("\"abcefg\"", "\"abcefg\"")]
+        [InlineData("true", "true")]
+        [InlineData("false", "false")]
+        [InlineData("null", "nil")]
+        public void Literal_GeneratesLiteral(string input, string expected)
+        {
+            var cleanedLua = GetCleanLua(input);
+            Assert.Equal(expected, cleanedLua);
+        }
+
+        [Fact]
+        public void StringInterpolation_GeneratesInterpolation()
+        {
+            var cleanedLua = GetCleanLua("int count = 6; $\"count: {count}\"", 1);
+            var expectedLua = "`count: {count}`";
+            Assert.Equal(expectedLua, cleanedLua);
+        }
+
+        [Theory]
+        [InlineData("Vector3")]
+        [InlineData("NumberRange")]
+        [InlineData("BrickColor")]
+        [InlineData("Instance")]
+        public void RobloxType_DoesNotGenerateGetAssemblyTypeCall(string robloxType)
+        {
+
+            var cleanedLua = GetCleanLua($"using {Utility.RuntimeAssemblyName}; {robloxType}.a;");
+            Assert.Equal(robloxType + ".a", cleanedLua);
+        }
+
+        [Theory]
+        [InlineData("Instance")]
+        [InlineData($"{Utility.RuntimeAssemblyName}.Instance")]
+        public void InstanceCreate_Macros(string instanceClassPath)
+        {
+            var cleanedLua = GetCleanLua($"using {Utility.RuntimeAssemblyName}; var part = {instanceClassPath}.Create<Part>()");
+            Assert.Equal("local part = Instance.new(\"Part\")", cleanedLua);
+        }
+
+        [Fact]
+        public void InstanceIsA_Macros()
+        {
+            var cleanedLua = GetCleanLua($"using {Utility.RuntimeAssemblyName}; var part = Instance.Create<Part>(); part.IsA<Frame>();", 1);
+            Assert.Equal("part:IsA(\"Frame\")", cleanedLua);
+        }
+
+        [Theory]
+        [InlineData("using static Roblox.Globals; print")]
+        [InlineData("Roblox.Globals.print")]
+        public void ConsoleMethods_Macro(string fullMethodPath)
+        {
+            var cleanedLua = GetCleanLua($"{fullMethodPath}(\"hello world\")");
+            Assert.Equal("print(\"hello world\")", cleanedLua);
+        }
+
+        [Theory]
+        [InlineData("game")]
+        [InlineData("script")]
+        [InlineData("os")]
+        [InlineData("task")]
+        public void StaticClass_NoFullQualification(string memberName)
+        {
+            var cleanedLua = GetCleanLua($"{Utility.RuntimeAssemblyName}.Globals.{memberName}");
+            Assert.Equal(memberName, cleanedLua);
+        }
+
+        [Theory]
+        [InlineData("object obj; obj?.Name;")]
+        [InlineData("object a; a.b?.c;")]
+        public void SafeNavigation_GeneratesIfStatement(string source)
+        {
+            var cleanedLua = GetCleanLua(source, 1);
+            switch (source)
+            {
+                case "object obj; obj?.Name;":
+                    Assert.Equal("if obj == nil then nil else obj.Name", cleanedLua);
+                    break;
+                case "object a; a.b?.c;":
+                    Assert.Equal("if a.b == nil then nil else a.b.c", cleanedLua);
+                    break;
+            }
+        }
+
+        [Fact]
+        public void NullCoalescing_GeneratesIfStatement()
+        {
+            
+            var cleanedLua = GetCleanLua("int? x; int? y; x ?? y", 2);
+            Assert.Equal("if x == nil then y else x", cleanedLua);
+        }
+
+        [Fact]
+        public void TupleExpression_GeneratesTable()
+        {
+            var cleanedLua = GetCleanLua("var tuple = (1, 2, 3)");
+            Assert.Equal("local tuple = {1, 2, 3}", cleanedLua);
+        }
+
+        [Fact]
+        public void TupleIndexing_GeneratesTableIndexing()
+        {
+            var cleanedLua = GetCleanLua("var tuple = (1, 2, 3);\ntuple.Item1;\ntuple.Item2;\ntuple.Item3;\n", 1);
+            var lines = GetLines(cleanedLua);
+            Assert.Equal("tuple[1]", lines[0]);
+            Assert.Equal("tuple[2]", lines[1]);
+            Assert.Equal("tuple[3]", lines[2]);
+        }
+
+        [Fact]
+        public void CollectionInitializer_GeneratesTable()
+        {
+            var cleanedLua = GetCleanLua("int[] nums = [1, 2, 3]");
+            Assert.Equal("local nums: { number } = {1, 2, 3}", cleanedLua);
+        }
+
+        [Theory]
+        [InlineData("int[] nums = [1, 2, 3]; nums[0]", "nums[1]", 1)]
+        [InlineData("int[] nums = [1, 2, 3]; int i = 4; nums[i]", "nums[i + 1]", 2)]
+        public void CollectionIndexing_AddsOneToNumericalIndices(string input, string expected, int removeLines)
+        {
+            var cleanedLua = GetCleanLua(input, removeLines);
+            Assert.Equal(expected, cleanedLua);
+        }
+
+        private static void AssertEqualLines(List<string> lines, List<string> expectedLines)
+        {
+            foreach (var line in lines)
+            {
+                var expectedLine = expectedLines.ElementAt(lines.IndexOf(line));
+                Assert.Equal(expectedLine, line);
+            }
+        }
+
+        private List<string> GetLines(string cleanLua)
+        {
+            return cleanLua.Split('\n').Select(line => line.Trim()).ToList();
+        }
+
+        private string GetCleanLua(string source, int extraLines = 0)
+        {
+            var cleanTree = TranspilerUtility.ParseTree(source);
+            var transformedTree = TranspilerUtility.TransformTree(cleanTree, [BuiltInTransformers.Main()]);
+            var compiler = TranspilerUtility.GetCompiler([transformedTree]);
+            var memberCollector = new MemberCollector([cleanTree]);
+            var generatedLua = TranspilerUtility.GenerateLua(transformedTree, compiler, memberCollector.Collect());
+            return TranspilerUtility.CleanUpLuaForTests(generatedLua, extraLines);
+        }
+    }
+}

roblox-cs-master/RobloxCS.Tests/DebugTransformer_Should.cs

@@ -0,0 +1,51 @@
+namespace RobloxCS.Tests
+{
+    public class DebugTransformer_Should
+    {
+        private const string _testFileName = "TestFile.client.cs";
+
+        [Theory]
+        [InlineData("print(\"hello baby\")")]
+        [InlineData("warn(\"hello baby\")")]
+        public void FileInfo_PrependsArgument(string input)
+        {
+            var cleanTree = TranspilerUtility.ParseTree(input);
+            var transformedTree = TranspilerUtility.TransformTree(cleanTree, [BuiltInTransformers.Main(), BuiltInTransformers.Get("Debug")]);
+            var cleanRoot = cleanTree.GetRoot();
+            var cleanInvocation = cleanRoot.DescendantNodes().OfType<InvocationExpressionSyntax>().First();
+            var transformedRoot = transformedTree.GetRoot();
+            var transformedInvocation = transformedRoot.DescendantNodes().OfType<InvocationExpressionSyntax>().First();
+            var cleanArgs = cleanInvocation.ArgumentList.Arguments;
+            var transformedArgs = transformedInvocation.ArgumentList.Arguments;
+            var fileInfoArg = transformedArgs.FirstOrDefault();
+            Assert.True(cleanArgs.Count == 1);
+            Assert.True(transformedArgs.Count == 2);
+            Assert.NotNull(fileInfoArg);
+
+            var fileInfoLiteral = (LiteralExpressionSyntax)fileInfoArg.Expression;
+            Assert.Equal($"[{_testFileName}:1:51]:", fileInfoLiteral.Token.ValueText);
+        }
+
+        [Theory]
+        [InlineData("error(\"hello baby\")")]
+        public void FileInfo_ConcatenatesLiteral(string input)
+        {
+            var cleanTree = TranspilerUtility.ParseTree(input);
+            var transformedTree = TranspilerUtility.TransformTree(cleanTree, [BuiltInTransformers.Main(), BuiltInTransformers.Get("Debug")]);
+            var cleanRoot = cleanTree.GetRoot();
+            var cleanInvocation = cleanRoot.DescendantNodes().OfType<InvocationExpressionSyntax>().First();
+            var transformedRoot = transformedTree.GetRoot();
+            var transformedInvocation = transformedRoot.DescendantNodes().OfType<InvocationExpressionSyntax>().First();
+            var cleanArgs = cleanInvocation.ArgumentList.Arguments;
+            var transformedArgs = transformedInvocation.ArgumentList.Arguments;
+            var fullMessageArg = transformedArgs.FirstOrDefault();
+            Assert.True(cleanArgs.Count == 1);
+            Assert.True(transformedArgs.Count == 1);
+            Assert.NotNull(fullMessageArg);
+
+            var fullMessageBinary= (BinaryExpressionSyntax)fullMessageArg.Expression;
+            var fileInfoLiteral = (LiteralExpressionSyntax)fullMessageBinary.Left;
+            Assert.Equal($"[{_testFileName}:1:51]: ", fileInfoLiteral.Token.ValueText);
+        }
+    }
+}

roblox-cs-master/RobloxCS.Tests/GlobalUsings.cs

@@ -0,0 +1,4 @@
+global using Xunit;
+global using Microsoft.CodeAnalysis;
+global using Microsoft.CodeAnalysis.CSharp;
+global using Microsoft.CodeAnalysis.CSharp.Syntax;

roblox-cs-master/RobloxCS.Tests/MainTransformer_Should.cs

@@ -0,0 +1,21 @@
+namespace RobloxCS.Tests
+{
+    public class MainTransformer_Should
+    {
+        [Theory]
+        [InlineData("obj?.Name;")]
+        [InlineData("hello?.World;")]
+        [InlineData("a.b?.c;")]
+        public void SafeNavigation_TransformsWhenNotNull(string source)
+        {
+            var cleanTree = TranspilerUtility.ParseTree(source);
+            var transformedTree = TranspilerUtility.TransformTree(cleanTree, [BuiltInTransformers.Main()]);
+            var cleanRoot = cleanTree.GetRoot();
+            var cleanTernary = cleanRoot.DescendantNodes().OfType<ConditionalAccessExpressionSyntax>().First();
+            var transformedRoot = transformedTree.GetRoot();
+            var transformedTernary = transformedRoot.DescendantNodes().OfType<ConditionalAccessExpressionSyntax>().First();
+            Assert.True(cleanTernary.WhenNotNull.IsKind(SyntaxKind.MemberBindingExpression));
+            Assert.True(transformedTernary.WhenNotNull.IsKind(SyntaxKind.SimpleMemberAccessExpression));
+        }
+    }
+}

roblox-cs-master/RobloxCS.Tests/RobloxCS.Tests.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\RobloxCS\RobloxCS.csproj" />
+    <PackageReference Include="Microsoft.CodeAnalysis" Version="4.10.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.0.4" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.0.4" />
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="xunit" Version="2.9.0" />
+    <PackageReference Include="xunit.analyzers" Version="1.15.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>

roblox-cs-master/RobloxCS/CodeGenerator.cs

@@ -0,0 +1,2097 @@
+using System.Text;
+using System.Collections.Immutable;
+using System.Text.RegularExpressions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Linq;
+
+namespace RobloxCS
+{
+    internal class CodeGeneratorFlags
+    {
+        public bool ShouldCallGetAssemblyType { get; set; }
+        public bool ClientEntryPointDefined { get; set; }
+        public bool ServerEntryPointDefined { get; set; }
+    }
+
+    internal sealed class CodeGenerator : CSharpSyntaxWalker
+    {
+        private readonly SyntaxTree _tree;
+        private readonly ConfigData _config;
+        private readonly MemberCollectionResult _members;
+        private readonly string _inputDirectory;
+        private readonly CSharpCompilation _compiler;
+        private readonly SemanticModel _semanticModel;
+        private readonly SymbolAnalyzerResults _symbolAnalysis;
+        private readonly INamespaceSymbol _globalNamespace;
+        private readonly INamespaceSymbol _runtimeLibNamespace;
+        private readonly RojoProject? _rojoProject;
+        private readonly int _indentSize;
+        private readonly CodeGeneratorFlags _flags = new CodeGeneratorFlags
+        {
+            ShouldCallGetAssemblyType = true,
+            ClientEntryPointDefined = false,
+            ServerEntryPointDefined = false
+        };
+
+        private readonly StringBuilder _output = new StringBuilder();
+        private int _indent = 0;
+
+        public CodeGenerator(
+            SyntaxTree tree,
+            CSharpCompilation compiler,
+            RojoProject? rojoProject,
+            MemberCollectionResult members,
+            ConfigData config,
+            string inputDirectory,
+            int indentSize = 4
+        )
+        {
+            _tree = tree;
+            _config = config;
+            _members = members;
+            _inputDirectory = inputDirectory;
+            _compiler = compiler;
+            _semanticModel = compiler.GetSemanticModel(tree);
+
+            var symbolAnalyzer = new SymbolAnalyzer(tree, _semanticModel);
+            _symbolAnalysis = symbolAnalyzer.Analyze();
+            _globalNamespace = compiler.GlobalNamespace;
+            _runtimeLibNamespace = _globalNamespace.GetNamespaceMembers().FirstOrDefault(ns => ns.Name == Utility.RuntimeAssemblyName)!;
+            _rojoProject = rojoProject;
+            _indentSize = indentSize;
+        }
+
+        public string GenerateLua()
+        {
+            WriteHeader();
+            Visit(_tree.GetRoot());
+            WriteFooter();
+            return _output.ToString().Trim();
+        }
+
+        private void WriteHeader()
+        {
+            Write($"local CS = ");
+            WriteRequire(GetLuaRuntimeLibPath());
+            WriteLine();
+
+            foreach (var (namespaceName, declaringFiles) in GetNamespaceFilePaths())
+            {
+                var symbol = _tree.GetRoot()
+                    .DescendantNodes()
+                    .Select(node => _semanticModel.GetTypeInfo(node).Type)
+                    .OfType<INamespaceOrTypeSymbol>()
+                    .Where(namespaceSymbol => namespaceSymbol.ContainingAssembly != null && namespaceSymbol.ContainingAssembly.Name == _config.CSharpOptions.AssemblyName)
+                    .FirstOrDefault(symbol => symbol.Name == namespaceName);
+
+                var namespaceSymbol = symbol == null ? null : (symbol.IsNamespace ? symbol : symbol.ContainingNamespace);
+                if (namespaceSymbol == null || !_symbolAnalysis.TypeHasMemberUsedAsValue(namespaceSymbol))
+                {
+                    continue;
+                }
+
+                WriteLine($"-- using {namespaceName};");
+                foreach (var csharpFilePath in declaringFiles)
+                {
+                    WriteLine($"require({GetRequirePath(csharpFilePath)})");
+                }
+                WriteLine();
+            }
+        }
+
+        private void WriteFooter()
+        {
+            if (!_tree.FilePath.EndsWith(".client.cs") && !_tree.FilePath.EndsWith(".server.cs"))
+            {
+                WriteLine("return {}");
+            }
+        }
+
+        private string GetLuaRuntimeLibPath()
+        {
+            if (_rojoProject == null)
+            {
+                return $"\"{Utility.LuaRuntimeModuleName}\"";
+            }
+            else
+            {
+                return RojoReader.ResolveInstancePath(_rojoProject, $"include/{Utility.LuaRuntimeModuleName}.lua")!;
+            }
+        }
+
+        private string GetRequirePath(string longCSharpFilePath)
+        {
+            var inputDirectory = _inputDirectory.EndsWith('/') ? _inputDirectory : _inputDirectory + '/';
+            var csharpFilePath = longCSharpFilePath.Replace(inputDirectory, "").Replace(_config.SourceFolder, _config.OutputFolder);
+            if (csharpFilePath.StartsWith('/'))
+            {
+                csharpFilePath = csharpFilePath.Substring(1);
+            }
+
+            if (_rojoProject == null)
+            {
+                return "\"./" + csharpFilePath.Replace(".cs", "") + '"';
+            }
+            else
+            {
+                return RojoReader.ResolveInstancePath(_rojoProject, csharpFilePath)!;
+            }
+        }
+
+        private Dictionary<string, HashSet<string>> GetNamespaceFilePaths()
+        {
+            var globalNamespaceSymbols = _tree.GetRoot()
+                .DescendantNodes()
+                .Select(node => _semanticModel.GetTypeInfo(node).Type)
+                .OfType<INamedTypeSymbol>()
+                .Where(namespaceSymbol => namespaceSymbol.ContainingAssembly != null && namespaceSymbol.ContainingAssembly.Name == _config.CSharpOptions.AssemblyName);
+
+            return new Dictionary<string, HashSet<string>>(
+                Utility.FilterDuplicates(globalNamespaceSymbols, SymbolEqualityComparer.Default)
+                    .OfType<INamedTypeSymbol>()
+                    .Select(namespaceSymbol => KeyValuePair.Create(namespaceSymbol.Name, GetPathsForSymbolDeclarations(namespaceSymbol)))
+                    .Where(pair => !string.IsNullOrEmpty(pair.Key) && !pair.Value.Contains(_tree.FilePath))
+            );
+        }
+
+        private HashSet<string> GetPathsForSymbolDeclarations(ISymbol symbol)
+        {
+            var filePaths = new HashSet<string>();
+            foreach (var syntaxReference in symbol.DeclaringSyntaxReferences)
+            {
+                var syntaxTree = syntaxReference.SyntaxTree;
+                var filePath = syntaxTree.FilePath;
+                if (!string.IsNullOrEmpty(filePath))
+                {
+                    filePaths.Add(filePath);
+                }
+            }
+
+            return filePaths;
+        }
+
+        public override void VisitRefExpression(RefExpressionSyntax node)
+        {
+            Logger.UnsupportedError(node, "Refs");
+        }
+
+        public override void VisitUnsafeStatement(UnsafeStatementSyntax node)
+        {
+            Logger.UnsupportedError(node, "Unsafe contexts");
+        }
+
+        public override void VisitUsingStatement(UsingStatementSyntax node)
+        {
+            Logger.UnsupportedError(node, "Using statements");
+        }
+
+        public override void VisitAttribute(AttributeSyntax node)
+        {
+            if (GetName(node) == "Native")
+            {
+                WriteLine("@native");
+            }
+        }
+
+        public override void VisitAttributeList(AttributeListSyntax node)
+        {
+            base.VisitAttributeList(node);
+        }
+
+        public override void VisitLocalFunctionStatement(LocalFunctionStatementSyntax node)
+        {
+            foreach (var attributeList in node.AttributeLists)
+            {
+                Visit(attributeList);
+            }
+            Write($"local function {GetName(node)}");
+            Visit(node.ParameterList);
+            _indent++;
+
+            Visit(node.Body);
+            WriteDefaultReturn(node.Body);
+
+            _indent--;
+            WriteLine("end");
+        }
+
+        public override void VisitCastExpression(CastExpressionSyntax node)
+        {
+            // ignore
+            Visit(node.Expression);
+        }
+
+        public override void VisitThrowStatement(ThrowStatementSyntax node)
+        {
+            Throw(node.Expression);
+        }
+
+        public override void VisitThrowExpression(ThrowExpressionSyntax node)
+        {
+            Throw(node.Expression);
+        }
+
+        private void Throw(ExpressionSyntax? exception)
+        {
+            if (exception == null)
+            {
+                WriteLine("_catch_rethrow()");
+            }
+            else
+            {
+                Visit(exception);
+                Write(":Throw(");
+                Write((exception.Parent?.Parent is TryStatementSyntax).ToString().ToLower());
+                WriteLine(')');
+            }
+        }
+
+        public override void VisitTryStatement(TryStatementSyntax node)
+        {
+            WriteLine("CS.try(function()");
+            _indent++;
+
+            Visit(node.Block);
+
+            _indent--;
+            Write("end, ");
+            if (node.Finally != null)
+            {
+                WriteLine("function()");
+                _indent++;
+
+                Visit(node.Finally);
+
+                _indent--;
+                Write("end");
+            }
+            else
+            {
+                Write("nil");
+            }
+            WriteLine(", {");
+            _indent++;
+
+            foreach (var catchBlock in node.Catches)
+            {
+                WriteLine('{');
+                _indent++;
+
+                Write("exceptionClass = ");
+                if (catchBlock.Declaration != null)
+                {
+                    Write('"');
+                    Write(catchBlock.Declaration.Type.ToString());
+                    Write('"');
+                    WriteLine(", ");
+                }
+                Write("block = function(");
+                Write(catchBlock.Declaration != null ? (GetName(catchBlock.Declaration) + ": CS.Exception") : "_");
+                WriteLine(", _catch_rethrow: () -> nil)");
+                _indent++;
+
+                Visit(catchBlock.Block);
+
+                _indent--;
+                WriteLine("end");
+
+                _indent--;
+                WriteLine('}');
+            }
+
+            _indent--;
+            WriteLine("})");
+        }
+
+        public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
+        {
+            Visit(node.Variable);
+        }
+
+        public override void VisitForEachStatement(ForEachStatementSyntax node)
+        {
+            Write("for _, ");
+            Write(GetName(node));
+            Write(" in ");
+            Visit(node.Expression);
+            WriteLine(" do");
+            _indent++;
+
+            Visit(node.Statement);
+
+            _indent--;
+            WriteLine("end");
+        }
+
+        public override void VisitForStatement(ForStatementSyntax node)
+        {
+            var hasDeclaration = node.Declaration != null;
+            if (hasDeclaration)
+            {
+                WriteLine("do");
+                _indent++;
+                Visit(node.Declaration);
+            }
+            foreach (var initializer in node.Initializers)
+            {
+                Visit(initializer);
+            }
+            Write("while ");
+            if (node.Condition != null)
+            {
+                Visit(node.Condition);
+            }
+            else
+            {
+                Write("true");
+            }
+            WriteLine(" do");
+            _indent++;
+
+
+            Visit(node.Statement);
+            foreach (var incrementor in node.Incrementors)
+            {
+                Visit(incrementor);
+            }
+
+            _indent--;
+            WriteLine("end");
+
+            if (hasDeclaration)
+            {
+                _indent--;
+                WriteLine("end");
+            }
+        }
+
+        public override void VisitLabeledStatement(LabeledStatementSyntax node)
+        {
+            Logger.UnsupportedError(node, "Labels & goto statements");
+        }
+
+        public override void VisitGotoStatement(GotoStatementSyntax node)
+        {
+            Logger.UnsupportedError(node, "Labels & goto statements");
+        }
+
+        public override void VisitDoStatement(DoStatementSyntax node)
+        {
+            WriteLine("repeat");
+            _indent++;
+
+            Visit(node.Statement);
+
+            _indent--;
+            Write("until ");
+            Visit(node.Condition);
+            WriteLine();
+        }
+
+        public override void VisitWhileStatement(WhileStatementSyntax node)
+        {
+            Write("while ");
+            Visit(node.Condition);
+            WriteLine(" do");
+            _indent++;
+
+            Visit(node.Statement);
+
+            _indent--;
+            WriteLine("end");
+        }
+
+        public override void VisitIfStatement(IfStatementSyntax node)
+        {
+            Write("if ");
+            Visit(node.Condition);
+            WriteLine(" then");
+            _indent++;
+
+            WritePatternDeclarations(node.Condition);
+            Visit(node.Statement);
+
+            _indent--;
+            if (node.Else != null)
+            {
+                var isElseIf = node.Else.Statement.IsKind(SyntaxKind.IfStatement);
+
+                Write("else");
+                if (!isElseIf)
+                {
+                    WriteLine();
+                    _indent++;
+                }
+
+                Visit(node.Else);
+                if (!isElseIf)
+                {
+                    _indent--;
+                    WriteLine("end");
+                }
+            }
+            else
+            {
+                WriteLine("end");
+            }
+        }
+
+        public override void VisitSwitchStatement(SwitchStatementSyntax node)
+        {
+            var condition = node.Expression;
+            WriteLine("repeat");
+            _indent++;
+
+            var checkNoFallthrough = (StatementSyntax statement) =>
+                !statement.IsKind(SyntaxKind.BreakStatement)
+                && !statement.IsKind(SyntaxKind.ReturnStatement)
+                && !statement.DescendantNodes().All(descendant => !descendant.IsKind(SyntaxKind.BreakStatement) && !descendant.IsKind(SyntaxKind.ReturnStatement));
+
+            if (node.Sections.Count > 0 && !node.Sections.Any(section => section.Statements.Any(checkNoFallthrough))) // TODO: check for break/return
+            {
+                WriteLine("local _fallthrough = false");
+            }
+            foreach (var section in node.Sections)
+            {
+                var statementKinds = section.Statements.Select(stmt => stmt.Kind());
+                HashSet<SyntaxKind> supportedPatterns = [
+                    SyntaxKind.VarPattern,
+                    SyntaxKind.DeclarationPattern
+                ];
+
+                var caseLabels = section.Labels.Where(label =>
+                    !label.IsKind(SyntaxKind.DefaultSwitchLabel)
+                        && !(label is CasePatternSwitchLabelSyntax casePattern
+                            && supportedPatterns.Contains(casePattern.Pattern.Kind()))
+                );
+
+                foreach (var label in caseLabels)
+                {
+                    Write("if ");
+                    if (label != caseLabels.FirstOrDefault())
+                    {
+                        Write("_fallthrough or ");
+                    }
+
+                    var expressions = label.ChildNodes();
+                    var expression = expressions.First();
+                    Write('(');
+                    Visit(condition);
+
+                    var op = expression.IsKind(SyntaxKind.NotPattern) ?
+                        "~="
+                        : expression is RelationalPatternSyntax relationalPattern ?
+                            Utility.GetMappedOperator(relationalPattern.OperatorToken.Text)
+                            : "==";
+
+                    Write($" {op} ");
+                    Visit(expression);
+                    if (label is CasePatternSwitchLabelSyntax casePattern && casePattern.WhenClause != null)
+                    {
+                        Write(" and ");
+                        Visit(casePattern.WhenClause.Condition);
+                    }
+                    WriteLine(") then");
+                    _indent++;
+
+                    if (label != caseLabels.Last())
+                    {
+                        WriteLine("_fallthrough = true");
+                    }
+                    else
+                    {
+                        foreach (var statement in section.Statements)
+                        {
+                            Visit(statement);
+                            if (statement == section.Statements.Last() && !statement.IsKind(SyntaxKind.ReturnStatement))
+                            {
+                                WriteLine("break");
+                            }
+                        }
+                    }
+
+                    _indent--;
+                    WriteLine("end");
+                }
+            }
+
+            void visitDefaultStatements(SwitchLabelSyntax defaultLabel)
+            {
+                var section = (SwitchSectionSyntax)defaultLabel.Parent!;
+                foreach (var statement in section.Statements)
+                {
+                    Visit(statement);
+                }
+            }
+
+            var casePatternLabels = node.Sections.SelectMany(section => section.Labels.Where(label => label.IsKind(SyntaxKind.CasePatternSwitchLabel)));
+            foreach (var casePatternLabel in casePatternLabels)
+            {
+                var pattern = casePatternLabel.ChildNodes().FirstOrDefault();
+                if (pattern.IsKind(SyntaxKind.VarPattern) || pattern.IsKind(SyntaxKind.DeclarationPattern))
+                {
+                    Visit(pattern);
+                    Write(" = ");
+                    Visit(condition);
+                    WriteLine();
+                    visitDefaultStatements(casePatternLabel);
+                }
+            }
+
+            var defaultLabel = node.Sections.SelectMany(section => section.Labels.Where(label => label.IsKind(SyntaxKind.DefaultSwitchLabel))).FirstOrDefault();
+            if (defaultLabel != null)
+            {
+                visitDefaultStatements(defaultLabel);
+            }
+
+            _indent--;
+            WriteLine("until true");
+        }
+
+        public override void VisitParenthesizedLambdaExpression(ParenthesizedLambdaExpressionSyntax node)
+        {
+            Write("function");
+            Visit(node.ParameterList);
+            WriteLine();
+            _indent++;
+
+            if (node.Block != null || node.ExpressionBody.IsKind(SyntaxKind.SimpleAssignmentExpression))
+            {
+                Visit(node.Body);
+            }
+            else
+            {
+                Write("return ");
+                Visit(node.ExpressionBody);
+                WriteLine();
+            }
+
+            _indent--;
+            Write("end");
+        }
+
+        public override void VisitSimpleLambdaExpression(SimpleLambdaExpressionSyntax node)
+        {
+            Write("function(");
+            Visit(node.Parameter);
+            Write(')');
+            WriteLine();
+            _indent++;
+
+            if (node.Block != null || node.ExpressionBody.IsKind(SyntaxKind.SimpleAssignmentExpression))
+            {
+                Visit(node.Body);
+            }
+            else
+            {
+                Write("return ");
+                Visit(node.ExpressionBody);
+                WriteLine();
+            }
+
+            _indent--;
+            Write("end");
+        }
+
+        public override void VisitBracketedArgumentList(BracketedArgumentListSyntax node)
+        {
+            Write('[');
+            if (node.Arguments.Count > 1)
+            {
+                Logger.CodegenError(node.Arguments.Last(), "Cannot have more than one argument between brackets.");
+            }
+
+            foreach (var argument in node.Arguments)
+            {
+                if (argument.Expression is LiteralExpressionSyntax numericLiteral && numericLiteral.IsKind(SyntaxKind.NumericLiteralExpression))
+                {
+                    int.TryParse(numericLiteral.Token.ValueText, out var indexValue);
+                    Write((indexValue + 1).ToString());
+                }
+                else
+                {
+                    Visit(argument);
+
+                    var typeSymbol = _semanticModel.GetTypeInfo(argument.Expression).Type;
+                    if (typeSymbol != null && Constants.INTEGER_TYPES.Contains(typeSymbol.Name))
+                    {
+                        Write(" + 1");
+                    }
+                }
+            }
+            Write(']');
+        }
+
+        public override void VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
+        {
+            Write("if ");
+            Visit(node.Expression);
+            Write(" == nil then nil else ");
+            Visit(node.WhenNotNull);
+        }
+
+        public override void VisitConditionalExpression(ConditionalExpressionSyntax node)
+        {
+            Write("if ");
+            Visit(node.Condition);
+            Write(" then ");
+            Visit(node.WhenTrue);
+            Write(" else ");
+            Visit(node.WhenFalse);
+        }
+
+        public override void VisitParenthesizedExpression(ParenthesizedExpressionSyntax node)
+        {
+            Write('(');
+            Visit(node.Expression);
+            Write(')');
+        }
+
+        public override void VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
+        {
+            Visit(node.Operand);
+            if (node.IsKind(SyntaxKind.SuppressNullableWarningExpression))
+            {
+                var typeSymbol = _semanticModel.GetTypeInfo(node.Operand).Type;
+                if (typeSymbol == null)
+                {
+                    Write(" :: any");
+                }
+                return;
+            }
+
+            var mappedOperator = Utility.GetMappedOperator(node.OperatorToken.Text);
+            WriteLine($" {mappedOperator} 1");
+        }
+
+        public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
+        {
+            var mappedOperator = Utility.GetMappedOperator(node.OperatorToken.Text);
+            var bit32Method = Utility.GetBit32MethodName(mappedOperator);
+            if (bit32Method != mappedOperator)
+            {
+                Write($"bit32.{bit32Method}(");
+                Visit(node.Operand);
+                Write(")");
+                return;
+            }
+
+            Write(mappedOperator);
+            Visit(node.Operand);
+        }
+
+        public override void VisitBinaryExpression(BinaryExpressionSyntax node)
+        {
+            var operatorText = node.OperatorToken.Text;
+            var leftType = _semanticModel.GetTypeInfo(node.Left).Type;
+            var rightType = _semanticModel.GetTypeInfo(node.Right).Type;
+            var perTypeOperators = Constants.PER_TYPE_BINARY_OPERATOR_MAP;
+            if (
+                (leftType != null && perTypeOperators.Any(pair => pair.Key.Contains(leftType.Name)))
+                || (rightType != null && perTypeOperators.Any(pair => pair.Key.Contains(rightType.Name)))
+            )
+            {
+                var typeList = perTypeOperators.FirstOrDefault(pair => pair.Key.Contains(leftType!.Name) || pair.Key.Contains(rightType!.Name)).Key;
+                var operatorMap = perTypeOperators[typeList];
+                if (operatorText == operatorMap.Item1)
+                {
+                    operatorText = operatorMap.Item2;
+                }
+            }
+
+            if (Constants.IGNORED_BINARY_OPERATORS.Contains(operatorText))
+            {
+                Visit(node.Left);
+                return;
+            }
+
+            var mappedOperator = Utility.GetMappedOperator(operatorText);
+            switch (mappedOperator)
+            {
+                case "??":
+                    Write("if ");
+                    Visit(node.Left);
+                    Write(" == nil then ");
+                    Visit(node.Right);
+                    Write(" else ");
+                    Visit(node.Left);
+                    return;
+            }
+
+            var bit32Method = Utility.GetBit32MethodName(mappedOperator);
+            if (bit32Method != mappedOperator)
+            {
+                Write($"bit32.{bit32Method}(");
+                Visit(node.Left);
+                Write(", ");
+                Visit(node.Right);
+                Write(")");
+
+                if ((leftType == null || rightType == null) || (!Constants.UNSUPPORTED_BITWISE_TYPES.Contains(leftType.Name) && !Constants.UNSUPPORTED_BITWISE_TYPES.Contains(rightType.Name)))
+                    return;
+
+                Logger.CodegenWarning(node, "Using 128/64 bit integers when performing binary operations on Luau may result in undefined behaviour.");
+                WriteLine();
+                Write("--> rbxcsc warn: long/Int64 or Int128/UInt128 bit operations may lead to undefined behaviour (above this warning).");
+
+                return;
+            }
+
+            Visit(node.Left);
+            Write($" {mappedOperator} ");
+            Visit(node.Right);
+        }
+
+        public override void VisitTupleExpression(TupleExpressionSyntax node)
+        {
+            WriteListTable(node.Arguments.Select(arg => arg.Expression).ToList());
+        }
+
+        public override void VisitCollectionExpression(CollectionExpressionSyntax node)
+        {
+            Write('{');
+            foreach (var element in node.Elements)
+            {
+                var children = element.ChildNodes();
+                foreach (var child in children)
+                {
+                    Visit(child);
+                }
+                if (element != node.Elements.Last())
+                {
+                    Write(", ");
+                }
+            }
+            Write('}');
+        }
+
+        public override void VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
+        {
+            Visit(node.Initializer);
+        }
+
+        public override void VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
+        {
+            Visit(node.Initializer);
+        }
+
+        public override void VisitInitializerExpression(InitializerExpressionSyntax node)
+        {
+            WriteListTable(node.Expressions.ToList());
+        }
+
+        public override void VisitAnonymousObjectMemberDeclarator(AnonymousObjectMemberDeclaratorSyntax node)
+        {
+            if (node.NameEquals != null)
+            {
+                Write(GetName(node.NameEquals));
+                Write(" = ");
+            }
+            Visit(node.Expression);
+        }
+
+        public override void VisitAnonymousObjectCreationExpression(AnonymousObjectCreationExpressionSyntax node)
+        {
+            WriteLine('{');
+            _indent++;
+
+            foreach (var initializer in node.Initializers)
+            {
+                Visit(initializer);
+                if (initializer != node.Initializers.Last())
+                {
+                    Write(", ");
+                }
+                WriteLine();
+            }
+
+            _indent--;
+            WriteLine('}');
+        }
+
+        public override void VisitObjectCreationExpression(ObjectCreationExpressionSyntax node)
+        {
+            Visit(node.Type);
+            Write(".new");
+            Visit(node.ArgumentList);
+        }
+
+        public override void VisitUsingDirective(UsingDirectiveSyntax node)
+        {
+            // do nothing (for now)
+        }
+
+        public override void VisitContinueStatement(ContinueStatementSyntax node)
+        {
+            Write("continue");
+        }
+
+        public override void VisitReturnStatement(ReturnStatementSyntax node)
+        {
+            Write("return ");
+            Visit(node.Expression);
+            WriteLine();
+        }
+
+        public override void VisitExpressionStatement(ExpressionStatementSyntax node)
+        {
+            base.VisitExpressionStatement(node);
+            WriteLine();
+        }
+
+        public override void VisitArgumentList(ArgumentListSyntax node)
+        {
+            Write('(');
+            foreach (var argument in node.Arguments)
+            {
+                Visit(argument);
+                if (argument != node.Arguments.Last())
+                {
+                    Write(", ");
+                }
+            }
+            Write(')');
+        }
+
+        public override void VisitInvocationExpression(InvocationExpressionSyntax node)
+        {
+
+            if (node.Expression is MemberAccessExpressionSyntax memberAccess)
+            {
+                var objectType = _semanticModel.GetTypeInfo(memberAccess.Expression).Type;
+                var name = GetName(memberAccess.Name);
+
+                switch (name)
+                {
+                    case "ToString":
+                        Write("tostring(");
+                        Visit(memberAccess.Expression);
+                        Write(')');
+                        return;
+                    case "Equals":
+                        Visit(memberAccess.Expression);
+                        Write(" == ");
+
+                        var value = node.ArgumentList.Arguments.FirstOrDefault();
+                        if (value != null)
+                        {
+                            Visit(value);
+                        }
+                        else
+                        {
+                            Write("nil");
+                        }
+                        return;
+                    case "Length":
+                        if (objectType == null || !Constants.LENGTH_READABLE_TYPES.Contains(objectType.Name)) return;
+                        Write('#');
+                        Visit(memberAccess.Expression);
+                        return;
+                    case "ToLower":
+                    case "ToUpper":
+                    case "Replace":
+                    case "Split":
+                        if (objectType == null || objectType.Name.ToLower() != "string") return;
+                        Write('(');
+                        Visit(memberAccess.Expression);
+                        Write(')');
+                        Write(':');
+
+                        var methodName = GetName(memberAccess.Name);
+                        var mappedMethodName = Constants.MAPPED_STRING_METHODS.GetValueOrDefault(methodName, methodName);
+                        Write(mappedMethodName);
+                        Visit(node.ArgumentList);
+                        return;
+                    case "Create":
+                        {
+                            if (objectType == null || objectType.Name != "Instance") break;
+
+                            var symbol = _semanticModel.GetSymbolInfo(node).Symbol;
+                            if (symbol is IMethodSymbol methodSymbol)
+                            {
+                                if (!methodSymbol.IsGenericMethod)
+                                    Logger.CompilerError("Attempt to macro Instance.Create<T>() but it is not generic");
+
+                                var arguments = node.ArgumentList.Arguments;
+                                var instanceType = methodSymbol.TypeArguments.First();
+                                Visit(memberAccess.Expression);
+                                Write($".new(\"{instanceType.Name}\"");
+                                if (arguments.Count > 0)
+                                {
+                                    Write(", ");
+                                    foreach (var argument in arguments)
+                                    {
+                                        Visit(argument.Expression);
+                                        if (argument != arguments.Last())
+                                        {
+                                            Write(", ");
+                                        }
+                                    }
+                                }
+
+                                Write(')');
+                                return;
+                            }
+                            break;
+                        }
+                    case "GetService":
+                    case "FindFirstChildOfClass":
+                    case "FindFirstChildWhichIsA":
+                    case "FindFirstAncestorOfClass":
+                    case "FindFirstAncestorWhichIsA":
+                    case "IsA":
+                        {
+                            if (objectType == null) return;
+
+                            var superclasses = objectType.AllInterfaces.ToList();
+                            if (objectType.Name != "Instance" && !superclasses.Select(@interface => @interface.Name).Contains("Instance")) return;
+
+                            var symbol = _semanticModel.GetSymbolInfo(node).Symbol;
+                            var methodSymbol = (IMethodSymbol)symbol!;
+                            if (!methodSymbol.IsGenericMethod)
+                                Logger.CompilerError($"Attempt to macro {objectType.Name}.{name}<T>() but it is not generic");
+
+                            var arguments = node.ArgumentList.Arguments;
+                            var instanceType = methodSymbol.TypeArguments.First();
+                            Visit(memberAccess.Expression);
+                            Write($":{name}(\"{instanceType.Name}\"");
+                            if (arguments.Count > 0)
+                            {
+                                Write(", ");
+                                foreach (var argument in arguments)
+                                {
+                                    Visit(argument.Expression);
+                                    if (argument != arguments.Last())
+                                    {
+                                        Write(", ");
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                Write(')');
+                            }
+                            return;
+                        }
+                }
+            }
+            else if (node.Expression is IdentifierNameSyntax || node.Expression is GenericNameSyntax)
+            {
+                var name = GetName(node.Expression);
+                switch (name)
+                {
+                    case "TypeOf":
+                        Write("typeof");
+                        Visit(node.ArgumentList);
+                        return;
+
+                    case "ToNumber":
+                    case "ToFloat":
+                    case "ToDouble":
+                    case "ToInt":
+                    case "ToUInt":
+                    case "ToShort":
+                    case "ToUShort":
+                    case "ToByte":
+                    case "ToSByte":
+                        Write("tonumber");
+                        Visit(node.ArgumentList);
+                        return;
+
+                    case "nameof":
+                        Write('"');
+                        Write(_semanticModel.GetConstantValue(node).Value?.ToString() ?? $"??? nameof({node}) ???");
+                        Write('"');
+                        return;
+                }
+            }
+
+            Visit(node.Expression);
+            Visit(node.ArgumentList);
+        }
+
+        public override void VisitThisExpression(ThisExpressionSyntax node)
+        {
+            Write("self");
+        }
+
+        public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
+        {
+            var leftIsLiteral = node.Expression is LiteralExpressionSyntax;
+            var objectSymbol = _semanticModel.GetSymbolInfo(node.Expression).Symbol?.OriginalDefinition;
+            var objectType = _semanticModel.GetTypeInfo(node.Expression).Type;
+            var nameType = _semanticModel.GetSymbolInfo(node.Name).Symbol?.OriginalDefinition;
+            var operatorText = '.';
+            if (objectSymbol != null)
+            {
+                if (objectType is INamedTypeSymbol objectDefinitionSymbol && (objectDefinitionSymbol.Name == "Services" || objectDefinitionSymbol.AllInterfaces.Select(@interface => @interface.Name).Contains("Services")))
+                {
+                    Write("game:GetService(\"");
+                    Visit(node.Name);
+                    Write("\")");
+                    return;
+                }
+
+                if (nameType is IMethodSymbol methodSymbol)
+                {
+                    operatorText = methodSymbol.IsStatic ? '.' : ':';
+                }
+            }
+
+            var usings = GetUsings();
+            var containingNamespace = objectSymbol?.ContainingNamespace;
+            if (objectSymbol != null && (objectSymbol.Kind == SymbolKind.Namespace || (objectSymbol.Kind == SymbolKind.NamedType && objectSymbol.IsStatic)))
+            {
+                var namespaceName = objectSymbol.ToDisplayString();
+                var filePathsContainingType = objectSymbol.Locations
+                    .Where(location => location.SourceTree != null && location.SourceTree.FilePath != _tree.FilePath)
+                    .Select(location => location.SourceTree!.FilePath);
+
+                var isNoFullQualificationType = Constants.NO_FULL_QUALIFICATION_TYPES.Contains(namespaceName) || (containingNamespace != null ? Constants.NO_FULL_QUALIFICATION_TYPES.Contains(containingNamespace.Name) : false);
+                var noFullQualification = isNoFullQualificationType && (objectType == null || !Constants.GLOBAL_LIBRARIES.Contains(objectType.Name));
+                var typeIsImported = usings.Any(usingDirective => usingDirective.Name != null && Utility.GetNamesFromNode(usingDirective).Any(name => namespaceName.StartsWith(name)));
+                if (noFullQualification && namespaceName != "System")
+                {
+                    if (node.Expression is IdentifierNameSyntax identifier)
+                    {
+                        // TODO: check parent classes of parent class
+                        var parentClass = FindFirstAncestor<ClassDeclarationSyntax>(node);
+                        var parentClassSymbol = parentClass != null ? _semanticModel.GetDeclaredSymbol(parentClass) : null;
+                        if (parentClass != null && SymbolEqualityComparer.Default.Equals(objectType, parentClassSymbol))
+                        {
+                            Write("class");
+                        }
+                        else
+                        {
+                            if (GetName(node.Name) == "Globals") return;
+                            Visit(node.Name);
+                        }
+                    }
+                    else if (node.Expression is GenericNameSyntax genericName)
+                    {
+                        Visit(genericName);
+                    }
+                    else if (node.Expression is MemberAccessExpressionSyntax memberAccess)
+                    {
+                        if (namespaceName == Utility.RuntimeAssemblyName && Utility.GetNamesFromNode(memberAccess.Expression).LastOrDefault() != "Globals")
+                        {
+                            Visit(memberAccess.Name);
+                            Write('.');
+                        }
+                        Visit(node.Name);
+                    }
+                    else
+                    {
+                        throw new NotSupportedException("Unsupported node.Expression type for a NO_FULL_QUALIFICATION_TYPES member");
+                    }
+                    return;
+                }
+            }
+
+            if (objectSymbol?.OriginalDefinition is ILocalSymbol typeSymbol)
+            {
+                switch (typeSymbol.Type.Name)
+                {
+                    case "ValueTuple":
+                        var name = GetName(node.Name);
+                        if (name.StartsWith("Item"))
+                        {
+                            var itemIndex = name.Split("Item").Last();
+                            if (leftIsLiteral)
+                            {
+                                Write('(');
+                            }
+                            Visit(node.Expression);
+                            if (leftIsLiteral)
+                            {
+                                Write(')');
+                            }
+                            Write($"[{itemIndex}]");
+                            return;
+                        }
+                        break;
+                }
+            }
+
+            if (leftIsLiteral)
+            {
+                Write('(');
+            }
+            Visit(node.Expression);
+            if (leftIsLiteral)
+            {
+                Write(')');
+            }
+            Write(operatorText);
+            Visit(node.Name);
+        }
+
+        private List<UsingDirectiveSyntax> GetUsings()
+        {
+            var root = _tree.GetRoot();
+            var usings = root.DescendantNodes().OfType<UsingDirectiveSyntax>().ToList();
+            var compilationUnit = root as CompilationUnitSyntax;
+            if (compilationUnit != null)
+            {
+                foreach (var usingDirective in compilationUnit.Usings)
+                {
+                    usings.Add(usingDirective);
+                }
+            }
+
+            return usings;
+        }
+
+        private void FullyQualifyMemberAccess(INamespaceSymbol? namespaceType, List<UsingDirectiveSyntax> usings)
+        {
+            if (namespaceType == null) return;
+
+            var typeIsImported = usings.Any(usingDirective => namespaceType.ContainingNamespace != null && usingDirective.Name != null && Utility.GetNamesFromNode(usingDirective).Contains(namespaceType.ContainingNamespace.Name));
+            Write($"CS.getAssemblyType(\"{namespaceType.Name}\").");
+            _flags.ShouldCallGetAssemblyType = false;
+        }
+
+        public override void VisitIsPatternExpression(IsPatternExpressionSyntax node)
+        {
+            var objectType = _semanticModel.GetTypeInfo(node.Expression).Type;
+            var superclasses = objectType == null ? [] : objectType.AllInterfaces.ToList();
+            var pattern = node.Pattern;
+
+            void writeTypePattern(TypeSyntax type)
+            {
+                var typeSymbol = _semanticModel.GetTypeInfo(type).Type;
+                var mappedType = Utility.GetMappedType(type.ToString());
+                HashSet<TypeKind> valueTypes = [TypeKind.Class, TypeKind.Struct, TypeKind.Enum];
+                var isValueType = typeSymbol != null && valueTypes.Contains(typeSymbol.TypeKind);
+                if (!isValueType)
+                {
+                    Write('"');
+                }
+                Write(mappedType);
+                if (!isValueType)
+                {
+                    Write('"');
+                }
+            }
+
+            (bool, Action) getPatternWriter()
+            {
+                if (pattern is TypePatternSyntax typePattern)
+                {
+                    return (true, () => writeTypePattern(typePattern.Type));
+                }
+                else if (pattern is DeclarationPatternSyntax declarationPattern)
+                {
+                    return (true, () => writeTypePattern(declarationPattern.Type));
+                }
+                else if (pattern is VarPatternSyntax varPattern)
+                {
+                    return (true, () => Write("true"));
+                }
+                else
+                {
+                    return (false, () => Visit(pattern));
+                }
+            }
+
+            var (willBeHandled, writePattern) = getPatternWriter();
+            if (!willBeHandled && pattern.IsKind(SyntaxKind.NotPattern))
+            {
+                Write("not ");
+            }
+            Write("CS.is(");
+            Visit(node.Expression);
+            Write(", ");
+            writePattern();
+            Write(')');
+        }
+
+        public override void VisitDeclarationPattern(DeclarationPatternSyntax node)
+        {
+            Visit(node.Designation);
+            WriteTypeAnnotation(node.Type);
+        }
+
+        public override void VisitDiscardDesignation(DiscardDesignationSyntax node)
+        {
+            // do nothing (discard)
+        }
+
+        public override void VisitSingleVariableDesignation(SingleVariableDesignationSyntax node)
+        {
+            Write($"local {GetName(node)}");
+        }
+
+        public override void VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node)
+        {
+            Visit(node.Declaration);
+        }
+
+        public override void VisitVariableDeclaration(VariableDeclarationSyntax node)
+        {
+            foreach (var declarator in node.Variables)
+            {
+                Visit(declarator);
+            }
+        }
+
+        public override void VisitVariableDeclarator(VariableDeclaratorSyntax node)
+        {
+            var localDeclaration = FindFirstAncestor<LocalDeclarationStatementSyntax>(node);
+            var classDeclaration = FindFirstAncestor<ClassDeclarationSyntax>(node);
+            if (
+                localDeclaration != null
+                    && classDeclaration != null
+                    && !IsDescendantOf<MethodDeclarationSyntax>(node)
+                    && !IsDescendantOf<PropertyDeclarationSyntax>(node))
+            {
+                var isStatic = HasSyntax(classDeclaration.Modifiers, SyntaxKind.StaticKeyword) || HasSyntax(localDeclaration.Modifiers, SyntaxKind.StaticKeyword);
+                Write(isStatic ? "class" : "self");
+                Write(".");
+            }
+            else
+            {
+                Write("local ");
+            }
+
+            Write($"{GetName(node)}");
+            var parent = node.Parent;
+            if (parent is VariableDeclarationSyntax declaration)
+            {
+                WriteTypeAnnotation(declaration.Type);
+            }
+
+            if (node.Initializer != null)
+            {
+                Write(" = ");
+                Visit(node.Initializer);
+                if (node.Initializer.Value.IsKind(SyntaxKind.IsPatternExpression))
+                {
+                    WriteLine();
+                }
+                WritePatternDeclarations(node.Initializer.Value);
+            }
+            WriteLine();
+        }
+
+        public override void VisitAssignmentExpression(AssignmentExpressionSyntax node)
+        {
+            Visit(node.Left);
+            Write(" = ");
+            Visit(node.Right);
+            if (node.Right.IsKind(SyntaxKind.IsPatternExpression))
+            {
+                WriteLine();
+            }
+            WritePatternDeclarations(node.Right);
+        }
+
+        public override void VisitGenericName(GenericNameSyntax node)
+        {
+            WriteName(node, node.Identifier);
+        }
+
+        public override void VisitIdentifierName(IdentifierNameSyntax node)
+        {
+            WriteName(node, node.Identifier);
+        }
+
+        public override void VisitInterpolatedStringText(InterpolatedStringTextSyntax node)
+        {
+            Write(node.TextToken.Text);
+        }
+
+        public override void VisitInterpolation(InterpolationSyntax node)
+        {
+            Write('{');
+            Visit(node.Expression);
+            Write('}');
+        }
+
+        public override void VisitInterpolatedStringExpression(InterpolatedStringExpressionSyntax node)
+        {
+            Write('`');
+            foreach (var content in node.Contents)
+            {
+                Visit(content);
+            }
+            Write('`');
+        }
+
+        public override void VisitLiteralExpression(LiteralExpressionSyntax node)
+        {
+            switch (node.Kind())
+            {
+                case SyntaxKind.StringLiteralExpression:
+                case SyntaxKind.Utf8StringLiteralExpression:
+                case SyntaxKind.CharacterLiteralExpression:
+                    Write($"\"{node.Token.ValueText}\"");
+                    break;
+
+                case SyntaxKind.TrueLiteralExpression:
+                case SyntaxKind.FalseLiteralExpression:
+                case SyntaxKind.NumericLiteralExpression:
+                    Write(node.Token.ValueText);
+                    break;
+
+                case SyntaxKind.DefaultLiteralExpression:
+                    var typeSymbol = _semanticModel.GetTypeInfo(node).Type;
+                    if (typeSymbol == null) break;
+
+                    if (Constants.INTEGER_TYPES.Contains(typeSymbol.Name) || Constants.DECIMAL_TYPES.Contains(typeSymbol.Name))
+                    {
+                        Write("0");
+                        break;
+                    }
+
+                    switch (typeSymbol.Name)
+                    {
+                        case "char":
+                        case "Char":
+                        case "string":
+                        case "String":
+                            Write("\"\"");
+                            break;
+                        case "bool":
+                        case "Boolean":
+                            Write("false");
+                            break;
+                        default:
+                            Write("nil");
+                            break;
+                    }
+                    break;
+                case SyntaxKind.NullLiteralExpression:
+                    Write("nil");
+                    break;
+            }
+
+            base.VisitLiteralExpression(node);
+        }
+
+        public override void VisitParameter(ParameterSyntax node)
+        {
+            if (node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.ParamsKeyword)))
+            {
+                Write("...");
+                if (node.Type != null)
+                    WriteTypeAnnotation(node.Type);
+                return;
+            }
+            Write(GetName(node));
+            if (node.Type != null)
+            {
+                WriteTypeAnnotation(node.Type);
+            }
+        }
+
+        public override void VisitParameterList(ParameterListSyntax node)
+        {
+            var callable = node.Parent;
+            Write('(');
+            {
+                if (callable is MethodDeclarationSyntax method && !HasSyntax(method.Modifiers, SyntaxKind.StaticKeyword))
+                {
+                    Write('_');
+                    if (node.Parameters.Count > 0)
+                    {
+                        Write(", ");
+                    }
+                }
+            }
+            ParameterSyntax? vaargParameter = null;
+            foreach (var parameter in node.Parameters)
+            {
+                Visit(parameter);
+                if (parameter != node.Parameters.Last())
+                {
+                    Write(", ");
+                }
+                else
+                {
+                    if (parameter.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.ParamsKeyword))) vaargParameter = parameter;
+                }
+            }
+            Write(')');
+            switch (callable)
+            {
+                case ConstructorDeclarationSyntax constructor:
+                    WriteLine($": {GetName(constructor)}");
+                    break;
+                case MethodDeclarationSyntax method:
+                    WriteTypeAnnotation(method.ReturnType, true);
+                    break;
+                case LocalFunctionStatementSyntax localFunction:
+                    WriteTypeAnnotation(localFunction.ReturnType, true);
+                    break;
+                default:
+                    WriteLine();
+                    break;
+            }
+            _indent++;
+
+            if (vaargParameter != null)
+            {
+                WriteLine("--> rbxcsc: vararg parameter conversion");
+                Write($"local {GetName(vaargParameter)} = {{ ... }}");
+                WriteLine();
+            }
+
+
+            foreach (var parameter in node.Parameters)
+            {
+                if (parameter.Default == null) continue;
+
+                var name = GetName(parameter);
+                Write(name);
+                Write(" = ");
+                Write($"if {name} == nil then ");
+                Visit(parameter.Default);
+                WriteLine($" else {name}");
+            }
+
+            _indent--;
+        }
+
+        public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
+        {
+            var isWithinNamespace = IsDescendantOf<NamespaceDeclarationSyntax>(node);
+            var allNames = Utility.GetNamesFromNode(node);
+            var firstName = allNames.First();
+            allNames.Remove(firstName);
+
+            var nativeAttribute = _config.EmitNativeAttributeOnClassOrNamespaceCallbacks ? "@native " : "";
+            WriteLine($"{(isWithinNamespace ? "namespace:" : "CS.")}namespace(\"{firstName}\", {nativeAttribute}function(namespace: CS.Namespace)");
+            _indent++;
+
+            if (allNames.Count > 0)
+            {
+                foreach (var name in allNames)
+                {
+                    WriteLine($"namespace:namespace(\"{name}\", {nativeAttribute}function(namespace: CS.Namespace)");
+                    _indent++;
+
+                    foreach (var member in node.Members)
+                    {
+                        Visit(member);
+                    }
+
+                    _indent--;
+                    WriteLine("end)");
+                }
+            }
+            else
+            {
+                foreach (var member in node.Members)
+                {
+                    Visit(member);
+                }
+            }
+
+            _indent--;
+            WriteLine("end)");
+            WriteLine();
+        }
+
+        public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
+        {
+            var isWithinNamespace = IsDescendantOf<NamespaceDeclarationSyntax>(node);
+            Write($"CS.enum(\"{GetName(node)}\", {{");
+            if (node.Members.Count > 0)
+            {
+                WriteLine();
+                _indent++;
+
+                var firstValue = node.Members.FirstOrDefault()?.EqualsValue?.Value;
+                var lastIndex = firstValue != null ? (firstValue as LiteralExpressionSyntax)?.Token.Value as int? ?? -1 : -1;
+                foreach (var enumMember in node.Members)
+                {
+                    Write(GetName(enumMember));
+                    Write(" = ");
+                    if (enumMember.EqualsValue != null)
+                    {
+                        Visit(enumMember.EqualsValue);
+                        lastIndex = (int)((LiteralExpressionSyntax)enumMember.EqualsValue.Value).Token.Value!;
+                    }
+                    else
+                    {
+                        var index = (enumMember.EqualsValue?.Value is LiteralExpressionSyntax literal ? literal.Token.Value as int? : null) ?? lastIndex + 1;
+                        lastIndex = index;
+                        Write(index.ToString());
+                    }
+                    WriteLine(enumMember != node.Members.Last() ? ", " : "");
+                }
+
+                _indent--;
+            }
+            WriteLine($"}}, {(isWithinNamespace ? "namespace" : "nil")})");
+        }
+
+        public override void VisitInterfaceDeclaration(InterfaceDeclarationSyntax node)
+        {
+            foreach (var member in node.Members)
+            {
+                if (HasSyntax(member.Modifiers, SyntaxKind.VirtualKeyword))
+                {
+                    Logger.UnsupportedError(node, "Virtual methods on interfaces");
+                }
+            }
+        }
+
+        public override void VisitClassDeclaration(ClassDeclarationSyntax node)
+        {
+            if (HasSyntax(node.Modifiers, SyntaxKind.AbstractKeyword))
+            {
+                Logger.UnsupportedError(node, "Abstract classes");
+                return;
+            }
+            if (HasSyntax(node.Modifiers, SyntaxKind.PartialKeyword))
+            {
+                Logger.UnsupportedError(node, "Partial classes");
+                return;
+            }
+
+            var isWithinNamespace = IsDescendantOf<NamespaceDeclarationSyntax>(node);
+            var isStatic = HasSyntax(node.Modifiers, SyntaxKind.StaticKeyword);
+            var className = GetName(node);
+            var nativeAttribute = _config.EmitNativeAttributeOnClassOrNamespaceCallbacks ? "@native " : "";
+            WriteLine($"{(isWithinNamespace ? "namespace:" : "CS.")}class(\"{className}\", {nativeAttribute}function(namespace: CS.Namespace)");
+            _indent++;
+
+            Write($"local class = CS.classDef(\"{GetName(node)}\", ");
+            Write(isWithinNamespace ? "namespace" : "nil");
+
+            // TODO: check if superclass or mixin
+            var ancestorIdentifiers = (node.BaseList?.Types ?? []).Select(ancestor =>
+            {
+                var typeSymbol = _semanticModel.GetTypeInfo(ancestor.Type).Type;
+                return $"\"{Regex.Replace(typeSymbol?.ToString() ?? ancestor.Type.ToString(), @"<[^>]*>", "")}\"";
+            });
+            if (ancestorIdentifiers.Count() > 0)
+            {
+                Write(", ");
+            }
+            Write(string.Join(", ", ancestorIdentifiers));
+            WriteLine(')');
+            WriteLine();
+            InitializeFields(
+                node.Members
+                    .OfType<FieldDeclarationSyntax>()
+                    .Where(member => isStatic || HasSyntax(member.Modifiers, SyntaxKind.StaticKeyword))
+            );
+            InitializeProperties(
+                node.Members
+                    .OfType<PropertyDeclarationSyntax>()
+                    .Where(member => isStatic || HasSyntax(member.Modifiers, SyntaxKind.StaticKeyword))
+            );
+
+            var constructors = node.Members.OfType<ConstructorDeclarationSyntax>().ToList();
+            constructors.Sort((a, b) => a.ParameterList.Parameters.Count - b.ParameterList.Parameters.Count);
+
+            var constructor = constructors.FirstOrDefault();
+            if (!isStatic)
+            {
+                if (constructor == null)
+                {
+                    CreateDefaultConstructor(node);
+                }
+                else
+                {
+                    VisitConstructorDeclaration(constructor);
+                }
+            }
+
+            var methods = node.Members.OfType<MethodDeclarationSyntax>();
+            var staticMethods = methods.Where(method => HasSyntax(method.Modifiers, SyntaxKind.StaticKeyword));
+            foreach (var method in staticMethods)
+            {
+                Visit(method);
+            }
+
+            var isEntryPointClass = GetName(node) == _config.CSharpOptions.EntryPointName;
+            if (isEntryPointClass)
+            {
+                var filePath = Path.TrimEndingDirectorySeparator(_tree.FilePath);
+                var isClientFile = filePath.EndsWith(".client.cs");
+                if ((_flags.ClientEntryPointDefined && isClientFile) || (_flags.ServerEntryPointDefined && !isClientFile))
+                {
+                    Logger.CodegenError(node, $"No more than one main method can be defined on the {(isClientFile ? "client" : "server")}.");
+                }
+                if (isClientFile)
+                {
+                    _flags.ClientEntryPointDefined = true;
+                }
+                else
+                {
+                    _flags.ServerEntryPointDefined = true;
+                }
+
+                var mainMethod = methods.FirstOrDefault(method => GetName(method) == _config.CSharpOptions.MainMethodName);
+                if (mainMethod == null)
+                {
+                    Logger.CodegenError(node.Identifier, $"No main method \"{_config.CSharpOptions.MainMethodName}\" found in entry point class");
+                    return;
+                }
+                if (!HasSyntax(mainMethod.Modifiers, SyntaxKind.StaticKeyword))
+                {
+                    Logger.CodegenError(node.Identifier, $"Main method must be static.");
+                }
+
+                WriteLine();
+                WriteLine("if namespace == nil then");
+                _indent++;
+                WriteLine($"class.{_config.CSharpOptions.MainMethodName}()");
+                _indent--;
+                WriteLine("else");
+                _indent++;
+                WriteLine($"namespace[\"$onLoaded\"](namespace, class.{_config.CSharpOptions.MainMethodName})");
+                _indent--;
+                Write("end");
+            }
+
+            WriteLine();
+            WriteLine($"return class");
+
+            _indent--;
+            WriteLine("end)");
+        }
+
+        public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
+        {
+            if (HasSyntax(node.Modifiers, SyntaxKind.ExternKeyword))
+            {
+                Logger.UnsupportedError(node, "Extern methods", useYet: false);
+            }
+
+            foreach (var attributeList in node.AttributeLists)
+            {
+                Visit(attributeList);
+            }
+
+            var isStatic = HasSyntax(node.Modifiers, SyntaxKind.StaticKeyword);
+            var isMetamethod = Constants.METAMETHODS.Contains(GetName(node));
+            var objectName = "self";
+            if (isStatic)
+            {
+                objectName = "class";
+            }
+            else if (isMetamethod)
+            {
+                objectName = "mt";
+            }
+
+            var name = GetName(node);
+            Write($"function {objectName}.{name}");
+            Visit(node.ParameterList);
+            _indent++;
+
+            Visit(node.Body);
+            WriteDefaultReturn(node.Body);
+
+            _indent--;
+            WriteLine("end");
+        }
+
+        public override void VisitBaseExpression(BaseExpressionSyntax node)
+        {
+            Write("self[\"$superclass\"]");
+        }
+
+        public override void VisitConstructorDeclaration(ConstructorDeclarationSyntax node)
+        {
+            // TODO: struct support?
+            foreach (var attributeList in node.AttributeLists)
+            {
+                Visit(attributeList);
+            }
+            Write($"function class.new");
+            Visit(node.ParameterList);
+            _indent++;
+
+            VisitConstructorBody(FindFirstAncestor<ClassDeclarationSyntax>(node)!, node.Body, node.Initializer?.ArgumentList);
+
+            _indent--;
+            WriteLine("end");
+        }
+
+        private void VisitConstructorBody(ClassDeclarationSyntax parentClass, BlockSyntax? block, ArgumentListSyntax? initializerArguments)
+        {
+            var isWithinNamespace = IsDescendantOf<NamespaceDeclarationSyntax>(parentClass);
+            WriteLine("local mt = {}");
+            Write("local self = CS.classInstance(class, mt");
+            if (isWithinNamespace)
+            {
+                Write(", namespace");
+            }
+            WriteLine(')'); // TODO: (when typedefs are generated for classes) $") :: {GetName(parentClass)}" 
+            WriteLine();
+            if (initializerArguments != null)
+            {
+                Write("self[\"$base\"]");
+                Visit(initializerArguments);
+            }
+
+            var isNotStatic = (MemberDeclarationSyntax member) => !HasSyntax(parentClass.Modifiers, SyntaxKind.StaticKeyword) && !HasSyntax(member.Modifiers, SyntaxKind.StaticKeyword);
+            var isNotAbstract = (MemberDeclarationSyntax member) => !HasSyntax(member.Modifiers, SyntaxKind.AbstractKeyword);
+            var nonStaticFields = parentClass.Members
+                .Where(isNotStatic)
+                .Where(isNotAbstract)
+                .OfType<FieldDeclarationSyntax>();
+            var nonStaticProperties = parentClass.Members
+                .Where(isNotStatic)
+                .Where(isNotAbstract)
+                .OfType<PropertyDeclarationSyntax>();
+            var nonStaticMethods = parentClass.Members
+                .Where(isNotStatic)
+                .Where(isNotAbstract)
+                .OfType<MethodDeclarationSyntax>();
+
+            InitializeFields(nonStaticFields);
+            InitializeProperties(nonStaticProperties);
+            if (block != null)
+            {
+                WriteLine();
+                Visit(block);
+            }
+            if (nonStaticMethods.Count() > 0)
+            {
+                WriteLine();
+            }
+            foreach (var method in nonStaticMethods)
+            {
+                Visit(method);
+            }
+
+            WriteLine();
+            WriteLine("return self");
+        }
+
+        private void CreateDefaultConstructor(ClassDeclarationSyntax node)
+        {
+            WriteLine($"function class.new()");
+            _indent++;
+
+            VisitConstructorBody(node, null, null);
+
+            _indent--;
+            WriteLine("end");
+        }
+
+        private void InitializeFields(IEnumerable<FieldDeclarationSyntax> fields)
+        {
+            foreach (var field in fields)
+            {
+                var classDeclaration = FindFirstAncestor<ClassDeclarationSyntax>(field)!;
+                var isStatic = HasSyntax(classDeclaration.Modifiers, SyntaxKind.StaticKeyword) || HasSyntax(field.Modifiers, SyntaxKind.StaticKeyword);
+                foreach (var declarator in field.Declaration.Variables)
+                {
+                    if (declarator.Initializer == null) continue;
+                    Write($"{(isStatic ? "class" : "self")}.{GetName(declarator)} = ");
+                    Visit(declarator.Initializer);
+                    WriteLine();
+                }
+            }
+        }
+
+        private void InitializeProperties(IEnumerable<PropertyDeclarationSyntax> properties)
+        {
+            foreach (var property in properties)
+            {
+                if (property.Initializer == null) continue;
+
+                var classDeclaration = FindFirstAncestor<ClassDeclarationSyntax>(property)!;
+                var isStatic = HasSyntax(classDeclaration.Modifiers, SyntaxKind.StaticKeyword) || HasSyntax(property.Modifiers, SyntaxKind.StaticKeyword);
+                Write($"{(isStatic ? "class" : "self")}.{GetName(property)} = ");
+                Visit(property.Initializer);
+                WriteLine();
+            }
+        }
+
+        private void WriteName(SyntaxNode node, SyntaxToken identifier)
+        {
+            var identifierText = identifier.ValueText;
+            var originalIdentifierName = identifier.Text;
+            if (identifierText == "var") return;
+            if (Constants.LUAU_KEYWORDS.Contains(identifierText))
+            {
+                Logger.CodegenError(node, $"Using reserved Luau keywords as identifier names is unsupported!");
+            }
+
+            var isWithinClass = IsDescendantOf<ClassDeclarationSyntax>(node);
+            var prefix = "";
+            if (isWithinClass)
+            {
+                // Check the fields in classes that this node is a descendant of for the identifier name
+                var ancestorClasses = GetAncestors<ClassDeclarationSyntax>(node);
+                for (int i = 0; i < ancestorClasses.Length; i++)
+                {
+                    var ancestorClass = ancestorClasses[i];
+                    var fields = ancestorClass.Members.OfType<FieldDeclarationSyntax>();
+                    foreach (var field in fields)
+                    {
+                        var classDeclaration = FindFirstAncestor<ClassDeclarationSyntax>(field)!;
+                        var isStatic = HasSyntax(classDeclaration.Modifiers, SyntaxKind.StaticKeyword) || HasSyntax(field.Modifiers, SyntaxKind.StaticKeyword);
+                        foreach (var declarator in field.Declaration.Variables)
+                        {
+                            var name = GetName(declarator);
+                            if (name != identifierText) continue;
+                            prefix = (isStatic ? "class" : "self") + '.';
+                        }
+                    }
+                }
+            }
+
+            if (prefix == "")
+            {
+                var symbol = _semanticModel.GetSymbolInfo(node).Symbol;
+                var parentNamespace = FindFirstAncestor<NamespaceDeclarationSyntax>(node);
+                var parentNamespaceSymbol = parentNamespace != null ? _semanticModel.GetDeclaredSymbol(parentNamespace) : null;
+                var pluginClassesNamespace = _runtimeLibNamespace.GetNamespaceMembers().FirstOrDefault(ns => ns.Name == "PluginClasses");
+                var runtimeNamespaceIncludesIdentifier = symbol != null ? (
+                    IsDescendantOfNamespaceSymbol(symbol, _runtimeLibNamespace)
+                    || (pluginClassesNamespace != null && IsDescendantOfNamespaceSymbol(symbol, pluginClassesNamespace))
+                ) : false;
+
+                HashSet<SyntaxKind> fullyQualifiedParentKinds = [SyntaxKind.SimpleMemberAccessExpression, SyntaxKind.ObjectCreationExpression];
+                if (
+                    symbol != null
+                    && symbol is ITypeSymbol typeSymbol
+                    && node.Parent != null
+                    && fullyQualifiedParentKinds.Contains(node.Parent.Kind())
+                    && typeSymbol.ContainingNamespace != null
+                    && (parentNamespace != null ? Utility.GetNamesFromNode(parentNamespace.Name).LastOrDefault() != typeSymbol.ContainingNamespace.Name : true)
+                    && !Constants.NO_FULL_QUALIFICATION_TYPES.Contains(typeSymbol.ContainingNamespace.Name)
+                )
+                {
+                    var usings = GetUsings();
+                    FullyQualifyMemberAccess(typeSymbol.ContainingNamespace, usings);
+                }
+
+                var parentAccessExpression = FindFirstAncestor<MemberAccessExpressionSyntax>(node);
+                var isLeftSide = parentAccessExpression == null ? true : node == parentAccessExpression.Expression;
+                var parentBlocks = GetAncestors<SyntaxNode>(node);
+                var localScopeIncludesIdentifier = parentBlocks.Any(block =>
+                {
+                    var descendants = block.DescendantNodes();
+                    var localFunctions = descendants.OfType<LocalFunctionStatementSyntax>();
+                    var variableDesignations = descendants.OfType<VariableDesignationSyntax>();
+                    var variableDeclarators = descendants.OfType<VariableDeclaratorSyntax>();
+                    var forEachStatements = descendants.OfType<ForEachStatementSyntax>();
+                    var forStatements = descendants.OfType<ForStatementSyntax>();
+                    var parameters = descendants.OfType<ParameterSyntax>();
+                    var catchDeclarations = descendants.OfType<CatchDeclarationSyntax>();
+                    var checkNamePredicate = (SyntaxNode node) => TryGetName(node) == identifierText;
+                    return localFunctions.Any(checkNamePredicate)
+                        || variableDesignations.Any(checkNamePredicate)
+                        || variableDeclarators.Any(checkNamePredicate)
+                        || parameters.Any(checkNamePredicate)
+                        || catchDeclarations.Any(checkNamePredicate)
+                        || forEachStatements.Any(checkNamePredicate)
+                        || forStatements.Any(forStatement => forStatement.Initializers.Count() > 0);
+                });
+
+                if (isLeftSide && !localScopeIncludesIdentifier && !runtimeNamespaceIncludesIdentifier)
+                {
+                    var namespaceSymbol = parentNamespace != null ? _semanticModel.GetDeclaredSymbol(parentNamespace) : null;
+                    var namespaceIncludesIdentifier = namespaceSymbol != null && Utility.FindMember(namespaceSymbol, originalIdentifierName) != null;
+                    var parentClass = FindFirstAncestor<ClassDeclarationSyntax>(node);
+                    var classSymbol = parentClass != null ? _semanticModel.GetDeclaredSymbol(parentClass) : null;
+                    var classMemberSymbol = classSymbol != null ? Utility.FindMemberDeep(classSymbol, originalIdentifierName) : null;
+
+                    if (namespaceIncludesIdentifier)
+                    {
+                        Write($"namespace[\"$getMember\"](namespace, \"{identifierText}\")");
+                    }
+                    else if (classMemberSymbol != null)
+                    {
+                        Write($"{(classMemberSymbol.IsStatic ? "class" : "self")}.{identifierText}");
+                    }
+                    else
+                    {
+                        if (_flags.ShouldCallGetAssemblyType)
+                        {
+                            Write($"CS.getAssemblyType(\"{identifierText}\")");
+                        }
+                        else
+                        {
+                            Write(identifierText);
+                            _flags.ShouldCallGetAssemblyType = true;
+                        }
+                    }
+                }
+                else
+                {
+                    Write(identifierText);
+                }
+            }
+            else
+            {
+                Write(prefix + identifierText);
+            }
+        }
+
+        private void WriteListTable(List<ExpressionSyntax> expressions)
+        {
+            Write('{');
+            foreach (var expression in expressions)
+            {
+                Visit(expression);
+                if (expression != expressions.Last())
+                {
+                    Write(", ");
+                }
+            }
+            Write('}');
+        }
+
+        private void WriteDefaultReturn(BlockSyntax? block)
+        {
+            if (block != null && !block.Statements.Any(stmt => stmt.IsKind(SyntaxKind.ReturnStatement)))
+            {
+                WriteLine("return nil :: any");
+            }
+        }
+
+        private void WritePatternDeclarations(SyntaxNode node)
+        {
+            if (node is IsPatternExpressionSyntax isPattern)
+            {
+                void writeInitializer()
+                {
+                    Write(" = ");
+                    Visit(isPattern.Expression);
+                    WriteLine();
+                }
+
+                if (isPattern.Pattern is DeclarationPatternSyntax declarationPattern)
+                {
+                    Visit(declarationPattern.Designation);
+                    writeInitializer();
+                }
+                else if (isPattern.Pattern is VarPatternSyntax varPattern)
+                {
+                    Visit(varPattern.Designation);
+                    writeInitializer();
+                }
+            }
+        }
+
+        private void WriteTypeAnnotation(TypeSyntax type, bool isReturnType = false)
+        {
+            if (!type.IsVar)
+            {
+                var mappedType = Utility.GetMappedType(type.ToString());
+                Write($": {mappedType}");
+                if (isReturnType)
+                {
+                    WriteLine();
+                }
+            }
+        }
+
+        private void WriteRequire(string path)
+        {
+            WriteLine($"require({path})");
+        }
+
+        private void WriteLine()
+        {
+            WriteLine("");
+        }
+
+        private void WriteLine(char text)
+        {
+            WriteLine(text.ToString());
+        }
+
+        private void WriteLine(string text)
+        {
+            if (text == null)
+            {
+                _output.AppendLine();
+                return;
+            }
+
+            WriteTab();
+            _output.AppendLine(text);
+        }
+
+        private void Write(char text)
+        {
+            Write(text.ToString());
+        }
+
+        private void Write(string text)
+        {
+            WriteTab();
+            _output.Append(text);
+        }
+
+        private void WriteTab()
+        {
+            _output.Append(MatchLastCharacter('\n') ? GetTabString() : "");
+        }
+
+        private string GetTabString()
+        {
+            return string.Concat(Enumerable.Repeat(" ", _indentSize * _indent));
+        }
+
+        private void RemoveLastCharacters(int amount)
+        {
+            _output.Remove(_output.Length - amount, amount);
+        }
+
+        private bool HasSyntax(SyntaxTokenList tokens, SyntaxKind syntax)
+        {
+            return tokens.Any(token => token.IsKind(syntax));
+        }
+
+        private bool IsDescendantOfNamespaceSymbol(ISymbol symbol, INamespaceSymbol ancestor)
+        {
+            var namespaceSymbol = symbol.ContainingNamespace;
+            while (namespaceSymbol != null)
+            {
+                if (SymbolEqualityComparer.Default.Equals(namespaceSymbol, ancestor))
+                {
+                    return true;
+                }
+                namespaceSymbol = namespaceSymbol.ContainingNamespace;
+            }
+            return false;
+        }
+
+        private bool IsDescendantOf<T>(SyntaxNode node) where T : SyntaxNode
+        {
+            return FindFirstAncestor<T>(node) != null;
+        }
+
+        private T? FindFirstAncestor<T>(SyntaxNode node) where T : SyntaxNode
+        {
+            return GetAncestors<T>(node).FirstOrDefault();
+        }
+
+        private T[] GetAncestors<T>(SyntaxNode node) where T : SyntaxNode
+        {
+            return node.Ancestors().OfType<T>().ToArray();
+        }
+
+        private string? TryGetName(SyntaxNode node)
+        {
+            return Utility.GetNamesFromNode(node).FirstOrDefault();
+        }
+
+        private string GetName(SyntaxNode node)
+        {
+            return Utility.GetNamesFromNode(node).First();
+        }
+
+        private bool MatchLastCharacter(char character)
+        {
+            if (_output.Length == 0) return false;
+            return _output[_output.Length - 1] == character;
+        }
+    }
+}

roblox-cs-master/RobloxCS/CompiledFile.cs

@@ -0,0 +1,14 @@
+namespace RobloxCS
+{
+    internal sealed class CompiledFile
+    {
+        public readonly string Path;
+        public readonly string LuaSource;
+
+        public CompiledFile(string path, string luaSource)
+        {
+            Path = path;
+            LuaSource = luaSource;
+        }
+    }
+}

roblox-cs-master/RobloxCS/ConfigReader.cs

@@ -0,0 +1,74 @@
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+
+namespace RobloxCS
+{
+    public static class ConfigReader
+    {
+        public static ConfigData UnitTestingConfig
+        {
+            get
+            {
+                return new ConfigData()
+                {
+                    SourceFolder = "test-src",
+                    OutputFolder = "test-dist",
+                    RojoProjectName = "UNIT_TESTING",
+                    EnabledBuiltInTransformers = ["Debug"],
+                    EmitNativeAttributeOnClassOrNamespaceCallbacks = true,
+                    CSharpOptions = new CSharpOptions()
+                    {
+                        EntryPointName = "UnitTest",
+                        MainMethodName = "Main",
+                        AssemblyName = "UnitTesting"
+                    }
+                };
+            }
+        }
+
+        private const string _fileName = "roblox-cs.yml";
+
+        public static ConfigData Read(string inputDirectory)
+        {
+            var configPath = inputDirectory + "/" + _fileName;
+            ConfigData? config = default;
+            string ymlContent = default!;
+
+            try
+            {
+                ymlContent = File.ReadAllText(configPath);
+            }
+            catch (Exception e)
+            {
+                FailToRead(e.Message);
+            }
+
+            var deserializer = new DeserializerBuilder()
+                .WithNamingConvention(PascalCaseNamingConvention.Instance)
+                .WithAttemptingUnquotedStringTypeDeserialization()
+                .WithDuplicateKeyChecking()
+                .Build();
+
+            try
+            {
+                config = deserializer.Deserialize<ConfigData>(ymlContent);
+            }
+            catch (Exception e)
+            {
+                FailToRead(e.ToString());
+            }
+
+            if (config == null || !config.IsValid())
+            {
+                FailToRead("Invalid config! Make sure it has all required fields.");
+            }
+
+            return config!;
+        }
+
+        private static void FailToRead(string message)
+        {
+            Logger.Error($"Failed to read {_fileName}!\n{message}");
+        }
+    }
+}

roblox-cs-master/RobloxCS/ConfigTemplate.cs

@@ -0,0 +1,38 @@
+namespace RobloxCS
+{
+#pragma warning disable CS8618
+    public sealed class CSharpOptions
+    {
+        public string EntryPointName { get; set; }
+        public string MainMethodName { get; set; }
+        public string AssemblyName { get; set; }
+        public bool EntryPointRequired { get; set; } = true;
+
+        public bool IsValid()
+        {
+            return !string.IsNullOrEmpty(EntryPointName)
+                && !string.IsNullOrEmpty(MainMethodName)
+                && !string.IsNullOrEmpty(AssemblyName);
+        }
+    }
+
+    public sealed class ConfigData
+    {
+        public string SourceFolder { get; set; }
+        public string OutputFolder { get; set; }
+        public string RojoProjectName { get; set; } = "default";
+        public bool EmitNativeAttributeOnClassOrNamespaceCallbacks { get; set; } = true;
+        public HashSet<string> EnabledBuiltInTransformers { get; set; } = ["Debug"];
+        public CSharpOptions CSharpOptions { get; set; }
+
+        public bool IsValid()
+        {
+            return !string.IsNullOrEmpty(SourceFolder)
+                && !string.IsNullOrEmpty(OutputFolder)
+                && !string.IsNullOrEmpty(RojoProjectName)
+                && CSharpOptions != null
+                && CSharpOptions.IsValid();
+        }
+    }
+#pragma warning restore CS8618
+}

roblox-cs-master/RobloxCS/Constants.cs

@@ -0,0 +1,143 @@
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace RobloxCS
+{
+    internal static class Constants
+    {
+        public static readonly HashSet<string> UNSUPPORTED_BITWISE_TYPES =
+        [
+            "UInt128",
+            "ulong",
+            "long",
+            "Int128"
+        ];
+
+        public static readonly HashSet<string> LENGTH_READABLE_TYPES =
+        [
+            "String",
+            "string",
+            "Array"
+        ];
+
+        public static readonly Dictionary<string, string> MAPPED_STRING_METHODS = new Dictionary<string, string>
+        {
+            { "Replace", "gsub" },
+            { "Split", "split" },
+            { "ToLower", "lower" },
+            { "ToUpper", "upper" },
+            { "Reverse", "reverse" }
+        };
+
+        public static readonly HashSet<string> GLOBAL_LIBRARIES =
+        [
+            "task",
+            "math",
+            "table",
+            "os",
+            "buffer",
+            "coroutine",
+            "utf8",
+            "debug"
+        ];
+
+        public static readonly HashSet<string> METAMETHODS =
+        [
+            "__tostring",
+            "__add",
+            "__sub",
+            "__mul",
+            "__div",
+            "__idiv",
+            "__mod",
+            "__pow",
+            "__unm",
+            "__eq",
+            "__le",
+            "__lte",
+            "__len",
+            "__iter",
+            "__call",
+            "__concat",
+            "__mode",
+            "__index",
+            "__newindex",
+            "__metatable",
+        ];
+
+        public static readonly HashSet<string> LUAU_KEYWORDS =
+        [
+            "local",
+            "and",
+            "or",
+            "if",
+            "else",
+            "elseif",
+            "then",
+            "do",
+            "end",
+            "function",
+            "for",
+            "while",
+            "in",
+            "export",
+            "type",
+            "typeof"
+        ];
+
+        public static readonly HashSet<SyntaxKind> MEMBER_PARENT_SYNTAXES =
+        [
+            SyntaxKind.NamespaceDeclaration,
+            SyntaxKind.ClassDeclaration,
+            SyntaxKind.InterfaceDeclaration,
+            SyntaxKind.StructDeclaration
+        ];
+
+        public static readonly HashSet<string> NO_FULL_QUALIFICATION_TYPES =
+        [
+            "System",
+            "Roblox",
+            "Globals",
+            "PluginClasses"
+        ];
+
+        public static readonly HashSet<string> IGNORED_BINARY_OPERATORS =
+        [
+            "as"
+        ];
+
+        public static readonly Dictionary<List<string>, (string, string)> PER_TYPE_BINARY_OPERATOR_MAP = new Dictionary<List<string>, (string, string)>
+        {
+            { ["String", "string"], ("+", "..") }
+        };
+
+        public static readonly HashSet<string> DECIMAL_TYPES =
+        [
+            "float",
+            "double",
+            "Single",
+            "Double"
+        ];
+
+        public static readonly HashSet<string> INTEGER_TYPES =
+        [
+            "sbyte",
+            "byte",
+            "short",
+            "ushort",
+            "int",
+            "uint",
+            "long",
+            "ulong",
+            "SByte",
+            "Byte",
+            "Int16",
+            "Int32",
+            "Int64",
+            "Int128",
+            "UInt16",
+            "UInt32",
+            "UInt64",
+            "UInt128",
+        ];
+    }
+}

roblox-cs-master/RobloxCS/FileManager.cs

@@ -0,0 +1,86 @@
+namespace RobloxCS
+{
+    internal static class FileManager
+    {
+        public static IEnumerable<string> GetSourceFiles(string sourceDirectory)
+        {
+            try
+            {
+                return Directory.GetFiles(sourceDirectory, "*.cs", SearchOption.AllDirectories)
+                    .Where(file => !Utility.FixPathSep(file).StartsWith(Utility.FixPathSep(sourceDirectory) + "/obj"))
+                    .Select(Utility.FixPathSep);
+            }
+            catch (Exception e)
+            {
+                Logger.Error($"Failed to read source files: {e.Message}");
+                return [];
+            }
+        }
+
+        public static void CopyDirectory(string sourceDirectory, string destinationDirectory)
+        {
+            var directory = new DirectoryInfo(sourceDirectory);
+            if (!directory.Exists)
+            {
+                throw new DirectoryNotFoundException(
+                    "Source directory does not exist or could not be found: "
+                    + sourceDirectory);
+            }
+
+            if (!Directory.Exists(destinationDirectory))
+            {
+                Directory.CreateDirectory(destinationDirectory);
+            }
+
+            var files = directory.GetFiles();
+            foreach (var file in files)
+            {
+                var tempPath = Path.Combine(destinationDirectory, file.Name);
+                file.CopyTo(tempPath, true);
+            }
+
+            var directories = directory.GetDirectories();
+            foreach (var subdirectory in directories)
+            {
+                var tempPath = Path.Combine(destinationDirectory, subdirectory.Name);
+                CopyDirectory(subdirectory.FullName, tempPath);
+            }
+        }
+
+        public static void WriteCompiledFiles(string outDirectory, List<CompiledFile> compiledFiles)
+        {
+            Logger.Info($"Compiling {compiledFiles.Count} files...");
+            TryCreateDirectory(outDirectory);
+
+            foreach (var compiledFile in compiledFiles)
+            {
+                var directoryParts = compiledFile.Path.Split('/').ToList();
+                directoryParts.Remove(directoryParts.Last());
+                var parentDirectory = string.Join('/', directoryParts);
+                TryCreateDirectory(parentDirectory);
+
+                try
+                {
+                    File.WriteAllText(compiledFile.Path, compiledFile.LuaSource);
+                }
+                catch (Exception e)
+                {
+                    Logger.Error($"Failed to write to \"{compiledFile.Path}\": {e.Message}");
+                }
+                Logger.Info($"Successfully wrote \"{compiledFile.Path}\"!");
+            }
+        }
+
+        private static void TryCreateDirectory(string path)
+        {
+            try
+            {
+                Directory.CreateDirectory(path);
+            }
+            catch (Exception e)
+            {
+                Logger.Error($"Failed to create directory \"{path}\": {e.Message}");
+            }
+        }
+    }
+}

roblox-cs-master/RobloxCS/Include/RuntimeLib.lua

@@ -0,0 +1,321 @@
+--!strict
+--!native
+
+local CS = {}
+local assemblyGlobal = {}
+
+local function chainIndex(location: table, ...: table): () -> any
+    local names = {...}
+    return function(t, k)
+        for _, name in names do
+            local tbl = location[name]
+            local v = tbl[k]
+            if v ~= nil then
+                return v
+            end
+        end
+    end
+end
+
+local function createArithmeticOperators(self, mt, fieldName): table
+    -- TODO: bitwise ops (if necessary) (or possible)
+    local function getNumericValue(value: table | number): number
+        return if typeof(value) == "table" and value.__isEnumMember then value[fieldName] else value
+    end
+
+    function mt:__add(other)
+        return self[fieldName] + getNumericValue(other)
+    end
+    function mt:__sub(other)
+        return self[fieldName] - getNumericValue(other)
+    end
+    function mt:__mul(other)
+        return self[fieldName] * getNumericValue(other)
+    end
+    function mt:__div(other)
+        return self[fieldName] / getNumericValue(other)
+    end
+    function mt:__idiv(other)
+        return self[fieldName] // getNumericValue(other)
+    end
+    function mt:__mod(other)
+        return self[fieldName] % getNumericValue(other)
+    end
+    function mt:__pow(other)
+        return self[fieldName] ^ getNumericValue(other)
+    end
+    function mt:__unm()
+        return -self[fieldName]
+    end
+    return mt
+end
+
+export type Class = table;
+export type Namespace = {
+    name: string;
+    parent: Namespace?;
+    members: { Namespace | Class };
+    class: (self: Namespace, name: string, create: (self: Namespace) -> Class) -> nil;
+}
+
+local CSNamespace = {} do
+    @native
+    function CSNamespace.new(name, parent)
+        local self = {}
+        self.name = name
+        self.parent = parent
+        self.members = {}
+        self["$loadCallbacks"] = {}
+        if self.parent ~= nil then
+            self = setmetatable(self, { __index = self.parent })
+        end
+        return setmetatable(self, CSNamespace)
+    end
+
+    @native
+    function CSNamespace:__index(index)
+        return self.members[index] or CSNamespace[index]
+    end
+
+    @native
+    function CSNamespace:__newindex(index, value)
+        self.members[index] = value
+    end
+
+    @native
+    function CSNamespace:__tostring(index)
+        return self.name
+    end
+
+    CSNamespace["$getMember"] = @native function(self, name)
+        return self.members[name]
+    end
+
+    CSNamespace["$onLoaded"] = @native function(self, callback)
+        table.insert(self["$loadCallbacks"], callback)
+    end
+
+    @native
+    function CSNamespace:class(name, create)
+        CS.class(name, create, self)
+    end
+
+    @native
+    function CSNamespace:namespace(name, registerMembers)
+        CS.namespace(name, registerMembers, self.members, self)
+    end
+end
+
+@native
+function CS.classInstance(class: Class, mt: table, namespace: Namespace?)
+    local instance = {}
+    instance["$className"] = class.__name
+
+    @native
+    local function getSuperclass()
+        if class.__superclass == nil then return end
+        if class.__superclass:match(".") == nil then
+            return assemblyGlobal[class.__superclass]
+        end
+
+        local pieces = class.__superclass:split(".");
+        local result = assemblyGlobal
+        for _, piece in pieces do
+            result = result[piece] or result
+        end
+        return result
+    end
+
+    @native
+    function mt.__tostring()
+        return class.__name
+    end
+
+    instance["$base"] = @native function(...)
+        if instance["$superclass"] ~= nil then return end
+        local Superclass = getSuperclass()
+        local superclassInstance = Superclass.new(...)
+        instance["$superclass"] = superclassInstance
+        mt.__index = superclassInstance
+    end
+
+    return setmetatable(instance, mt)
+end
+
+@native
+function CS.classDef(name: string, namespace: Namespace?, superclass: string?, ...: string)
+    local mt = {}
+    mt.__index = chainIndex(if namespace ~= nil then namespace else assemblyGlobal, ...)
+
+    @native
+    function mt.__tostring()
+        return name
+    end
+
+    local class = {}
+    class.__name = name
+    class.__superclass = superclass
+    return setmetatable(class, mt)
+end
+
+@native
+function CS.class(name: string, create: (namespace: Namespace?) -> table, namespace: Namespace?)
+    local location = if namespace ~= nil then namespace.members else assemblyGlobal
+    local class = create(namespace)
+    location[name] = class
+end
+
+@native
+function CS.namespace(name: string, registerMembers: () -> nil, location: table?): Namespace
+    local parent = location
+    if location == nil then
+        location = assemblyGlobal
+    end
+
+    local namespaceDefinition = location[name] or CSNamespace.new(name, parent)
+    registerMembers(namespaceDefinition)
+    location[name] = namespaceDefinition
+
+    for _, callback in namespaceDefinition["$loadCallbacks"] do
+        callback()
+    end
+
+    return namespaceDefinition
+end
+
+@native
+function CS.enum(name: string, definition: table, location: table): table
+    if location == nil then
+        location = assemblyGlobal
+    end
+    definition.__name = name
+
+    @native
+    function definition:__index(index: string | number): table
+        if index == "__name" then return name end
+        local member = {
+            name = index,
+            value = definition[index],
+            __isEnumMember = true
+        }
+
+        return setmetatable(member, createArithmeticOperators(member, {
+            __eq = @native function(self, other)
+                return typeof(other) == "table" and other.__isEnumMember and self.value == other.value
+            end,
+            __tostring = @native function(self)
+                return self.name
+            end
+        }, "value"))
+    end
+
+    @native
+    function definition:__eq(other: table): boolean
+        return self.__name == other.__name
+    end
+
+    @native
+    function definition:__tostring(): string
+        return self.__name
+    end
+
+    location[name] = location[name] or table.freeze(setmetatable({}, definition))
+    return location[name]
+end
+
+@native
+function CS.is(object: any, class: Class | string): boolean
+    if typeof(class) == "table" and type(class.__name) == "string" then
+		return typeof(object) == "table" and type(object["className"]) == "string" and object["className"] == class.__name
+	end
+
+	-- metatable check
+	if typeof(object) == "table" then
+		obj = getmetatable(obj)
+		while object ~= nil do
+			if object == class then
+				return true
+			end
+			local mt = getmetatable(object)
+			if mt then
+				object = mt.__index
+			else
+				object = nil
+			end
+		end
+	end
+
+    if typeof(class) == "string" then
+        return if typeof(object) == "Instance" then object:IsA(class) else typeof(object) == class
+    end
+
+    return false
+end
+
+@native
+function CS.getAssemblyType(name)
+    local env
+    if getfenv == nil then
+        env = _ENV
+    else
+        env = getfenv()
+    end
+    return assemblyGlobal[name] or env[name]
+end
+
+CS.class("Exception", @native function()
+    local class = CS.classDef("Exception")
+
+    @native
+    function class.new(message: string?): Exception
+        local mt = {}
+        local self = CS.classInstance(class, mt) :: Exception
+
+        if message == nil then message = "An error occurred" end
+        self.Message = message
+
+        @native
+        function mt.__tostring(): string
+            return `{self["$className"]}: {self.Message}`
+        end
+
+        @native
+        function self.Throw(withinTryBlock: boolean): nil
+            error(if withinTryBlock then self else tostring(self))
+            return nil
+        end
+
+        return self
+    end
+
+    return class
+end)
+
+export type Exception = {
+    Message: string;
+    Throw: () -> nil;
+}
+
+type CatchBlock = {
+    exceptionClass: string;
+    block: (ex: Exception?, rethrow: () -> nil) -> nil
+}
+
+@native
+function CS.try(block: () -> nil, finallyBlock: () -> nil, catchBlocks: { CatchBlock })
+    local success: boolean, ex: Exception | string | nil = pcall(block)
+    if not success then
+        if typeof(ex) == "string" then
+            ex = CS.getAssemblyType("Exception").new(ex, false)
+        end
+        for _, catchBlock in catchBlocks do
+            if catchBlock.exceptionClass ~= nil and catchBlock.exceptionClass ~= ex["$className"] then continue end
+            catchBlock.block(ex :: Exception, (ex :: Exception).Throw)
+        end
+    end
+    if finallyBlock ~= nil then
+        finallyBlock()
+    end
+end
+
+return CS

roblox-cs-master/RobloxCS/Logger.cs

@@ -0,0 +1,109 @@
+using Microsoft.CodeAnalysis;
+
+namespace RobloxCS
+{
+    internal static class Logger
+    {
+        public static void Ok(string message)
+        {
+            Log(message, ConsoleColor.Green, "OK");
+        }
+
+        public static void Info(string message)
+        {
+            Log(message, ConsoleColor.Cyan, "INFO");
+        }
+
+        public static void Error(string message)
+        {
+            Log(message, ConsoleColor.Red, "ERROR");
+            Environment.Exit(1);
+        }
+
+        public static void CompilerError(string message)
+        {
+            Error($"{message} (roblox-cs compiler error)");
+        }
+
+        public static void CodegenError(SyntaxToken token, string message)
+        {
+            var lineSpan = token.GetLocation().GetLineSpan();
+            Error($"{message}\n\t- {Utility.FormatLocation(lineSpan)}");
+        }
+
+        public static void CodegenWarning(SyntaxToken token, string message)
+        {
+            var lineSpan = token.GetLocation().GetLineSpan();
+            Warn($"{message}\n\t- {Utility.FormatLocation(lineSpan)}");
+        }
+
+        public static void UnsupportedError(SyntaxNode node, string subject, bool useIs = false, bool useYet = true)
+        {
+            CodegenError(node, $"{subject} {(useIs == true ? "is" : "are")} not {(useYet ? "yet " : "")} supported, sorry!");
+        }
+
+        public static void CodegenError(SyntaxNode node, string message)
+        {
+            CodegenError(node.GetFirstToken(), message);
+        }
+
+        public static void CodegenWarning(SyntaxNode node, string message)
+        {
+            CodegenWarning(node.GetFirstToken(), message);
+        }
+
+        public static void HandleDiagnostic(Diagnostic diagnostic)
+        {
+            HashSet<string> ignoredCodes = ["CS7022", "CS0017" /* more than one entry point */];
+            if (ignoredCodes.Contains(diagnostic.Id)) return;
+
+            var lineSpan = diagnostic.Location.GetLineSpan();
+            var diagnosticMessage = $"{diagnostic.Id}: {diagnostic.GetMessage()}";
+            var location = $"\n\t- {Utility.FormatLocation(lineSpan)}";
+            switch (diagnostic.Severity)
+            {
+                case DiagnosticSeverity.Error:
+                    {
+                        Error(diagnosticMessage + location);
+                        break;
+                    }
+                case DiagnosticSeverity.Warning:
+                    {
+                        if (diagnostic.IsWarningAsError)
+                        {
+                            Error(diagnosticMessage + location);
+                        }
+                        else
+                        {
+                            Warn(diagnosticMessage + location);
+                        }
+                        break;
+                    }
+                case DiagnosticSeverity.Info:
+                    {
+                        Info(diagnosticMessage);
+                        break;
+                    }
+            }
+
+        }
+
+        public static void Warn(string message)
+        {
+            Log(message, ConsoleColor.Yellow, "WARN");
+        }
+
+        public static void Debug(string message)
+        {
+            Log(message, ConsoleColor.Magenta, "DEBUG");
+        }
+
+        private static void Log(string message, ConsoleColor color, string level)
+        {
+            var originalColor = Console.ForegroundColor;
+            Console.ForegroundColor = color;
+            Console.WriteLine($"[{level}] {message}");
+            Console.ForegroundColor = originalColor;
+        }
+    }
+}

roblox-cs-master/RobloxCS/MemberCollector.cs

@@ -0,0 +1,45 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace RobloxCS
+{
+    public sealed class MemberCollectionResult
+    {
+        public Dictionary<NamespaceDeclarationSyntax, List<MemberDeclarationSyntax>> Namespaces { get; set; } = [];
+    }
+
+    public sealed class MemberCollector : CSharpSyntaxWalker
+    {
+        private readonly Dictionary<NamespaceDeclarationSyntax, List<MemberDeclarationSyntax>> _namespaces = [];
+        private readonly List<SyntaxTree> _trees;
+
+        public MemberCollector(List<SyntaxTree> trees)
+        {
+            _trees = trees;
+        }
+
+        public MemberCollectionResult Collect()
+        {
+            foreach (var tree in _trees)
+            {
+                Visit(tree.GetRoot());
+            }
+
+            return new MemberCollectionResult()
+            {
+                Namespaces = _namespaces
+            };
+        }
+
+        public override void VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)
+        {
+            var members = _namespaces.ContainsKey(node) ? _namespaces[node] : new List<MemberDeclarationSyntax>();
+            foreach (var member in node.Members)
+            {
+                members.Add(member);
+            }
+            _namespaces[node] = members;
+        }
+    }
+}

roblox-cs-master/RobloxCS/README.md

@@ -0,0 +1,30 @@
+# RobloxCS
+This project includes the compiler and transformers.
+
+## To-do
+- Array/dictionary, number, & (the rest of) string macros/extensions
+- Macro `IEnumerable<T>` (or `Array`?) methods
+- Classes/structs/interfaces nested in classes/structs/interfaces
+- `LuaTuple` type handling
+- Compile `operator` methods as regular method declarations but onto `mt`
+- Transform parameterized class declarations (i.e `class Vector4(float x = 0, float y = 0, float z = 0, float w = 0)`) into regular class declarations with a constructor
+- Switch expressions
+- Destructuring/parenthesized variable designation (i.e. `var (value1, value2) = tuple;`)
+- Emit virtual methods of interfaces similar to a class
+- Abstract classes
+- Type hoisting when outside of namespace
+- Macro `GetType` function to the name of the type as a string (maybe)
+- Async/await
+- Overloaded methods
+- Full qualification of types/namespaces inside of namespaces
+- Macro `new T()` with collection types to `{}`
+- Test `MainTransformer` more
+
+## Will maybe be supported
+- [Class finalizers (destructors)](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/finalizers)
+- Custom get/set methods
+- Named arguments
+- `yield` keyword
+- `out` keyword
+- `partial` keyword
+- `using Name = Type` expressions (type aliases)

roblox-cs-master/RobloxCS/RobloxCS.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <Title>RobloxCS</Title>
+    <Version>1.2.0</Version>
+    <PackageId>RobloxCS.Compiler</PackageId>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis" Version="4.10.0" />
+    <PackageReference Include="YamlDotNet" Version="15.3.0" />
+    <PackageReference Include="RobloxCS.Types" Version="*" />
+  </ItemGroup>
+
+</Project>

roblox-cs-master/RobloxCS/RojoReader.cs

@@ -0,0 +1,186 @@
+using Microsoft.CodeAnalysis;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+#pragma warning disable CS8618
+public sealed class RojoProject
+{
+    [JsonPropertyName("name")]
+    public string Name { get; set; }
+
+    [JsonPropertyName("tree")]
+    public InstanceDescription Tree { get; set; }
+
+    [JsonPropertyName("servePort")]
+    public int ServePort { get; set; } = 34872;
+
+    [JsonPropertyName("servePlaceIds")]
+    public List<ulong> ServePlaceIds { get; set; } = [];
+
+    [JsonPropertyName("placeId")]
+    public string? PlaceId { get; set; }
+
+    [JsonPropertyName("gameId")]
+    public string? GameId { get; set; }
+
+    [JsonPropertyName("serveAddress")]
+    public string? ServeAddress { get; set; }
+
+    [JsonPropertyName("globIgnorePaths")]
+    public List<string> GlobIgnorePaths { get; set; } = [];
+
+    [JsonPropertyName("emitLegacyScripts")]
+    public bool EmitLegacyScripts { get; set; } = true;
+
+    public bool IsValid()
+    {
+        return !string.IsNullOrEmpty(Name) && Tree != null;
+    }
+}
+
+public sealed class InstanceDescription
+{
+    [JsonPropertyName("$className")]
+    public string? ClassName { get; set; }
+    [JsonPropertyName("$path")]
+    public string? Path { get; set; }
+    [JsonPropertyName("$properties")]
+    public Dictionary<string, object>? Properties { get; set; }
+    [JsonPropertyName("$ignoreUnknownInstances")]
+    public bool IgnoreUnknownInstances { get; set; } = true;
+    public Dictionary<string, InstanceDescription> Instances { get; set; } = [];
+
+    [JsonExtensionData]
+    public IDictionary<string, JsonElement> AdditionalData { get; set; } = new Dictionary<string, JsonElement>();
+
+    public void OnDeserialized()
+    {
+        foreach (var kvp in AdditionalData)
+        {
+            var childInstance = kvp.Value.Deserialize<InstanceDescription>()!;
+            Instances[kvp.Key] = childInstance;
+            childInstance.OnDeserialized();
+        }
+    }
+}
+#pragma warning restore CS8618
+
+namespace RobloxCS
+{
+    public static class RojoReader
+    {
+        private static readonly List<string> _services = ["ReplicatedStorage", "ReplicatedFirst", "ServerStorage", "ServerScriptService", "StarterPlayer", "StarterPlayerScripts"]; // things that will be converted into game:GetService("XXX")
+        private static readonly Dictionary<string, string> _instanceNameMap = new Dictionary<string, string>
+        {
+            { "StarterPlayer", "game:GetService(\"Players\").LocalPlayer" },
+            { "StarterPlayerScripts", "PlayerScripts" }
+        };
+
+        public static RojoProject Read(string configPath)
+        {
+            var jsonContent = "";
+            RojoProject? project = default;
+
+            try
+            {
+                jsonContent = File.ReadAllText(configPath);
+            }
+            catch (Exception e)
+            {
+                FailToRead(configPath, e.Message);
+            }
+
+            try
+            {
+                project = JsonSerializer.Deserialize<RojoProject>(jsonContent);
+            }
+            catch (Exception e)
+            {
+                FailToRead(configPath, e.ToString());
+            }
+
+            if (project == null || !project.IsValid())
+            {
+                FailToRead(configPath, "Invalid Rojo project! Make sure it has all required fields ('name' and 'tree').");
+            }
+
+            UpdateChildInstances(project!.Tree);
+            return project!;
+        }
+
+        public static string? FindProjectPath(string directoryPath, string projectName)
+        {
+            return Directory.GetFiles(directoryPath).FirstOrDefault(file => Path.GetFileName(file) == $"{projectName}.project.json");
+        }
+
+        public static string? ResolveInstancePath(RojoProject project, string filePath)
+        {
+            var path = TraverseInstanceTree(project.Tree, Utility.FixPathSep(filePath));
+            return path == null ? null : FormatInstancePath(Utility.FixPathSep(path));
+        }
+
+        private static string? TraverseInstanceTree(InstanceDescription instance, string filePath)
+        {
+            var instancePath = instance.Path != null ? Utility.FixPathSep(instance.Path) : null;
+            if (instancePath != null && filePath.StartsWith(instancePath))
+            {
+                var remainingPath = filePath.Substring(instancePath.Length + 1); // +1 to omit '/'
+                return Path.ChangeExtension(remainingPath, null);
+            }
+
+            foreach (var childInstance in instance.Instances)
+            {
+                var result = TraverseInstanceTree(childInstance.Value, filePath);
+                var leftName = childInstance.Key;
+                if (_instanceNameMap.TryGetValue(leftName, out var mappedName))
+                {
+                    leftName = mappedName;
+                }
+
+                if (result != null)
+                {
+                    return $"{leftName}/{result}";
+                }
+            }
+
+            return null;
+        }
+
+        private static string FormatInstancePath(string path)
+        {
+            var segments = path.Split('/');
+            var formattedPath = new StringBuilder();
+            foreach (var segment in segments)
+            {
+                var isServiceIdentifier = _services.Contains(segment);
+                if (segment == segments.First())
+                {
+                    formattedPath.Append(isServiceIdentifier ? $"game:GetService(\"{segment}\")" : segment);
+                }
+                else
+                {
+                    formattedPath.Append(formattedPath.Length > 0 ? "[\"" : "");
+                    formattedPath.Append(segment);
+                    formattedPath.Append("\"]");
+                }
+            }
+
+            return formattedPath.ToString();
+        }
+
+        private static void UpdateChildInstances(InstanceDescription instance)
+        {
+            instance.OnDeserialized();
+            foreach (var childInstance in instance.Instances.Values)
+            {
+                UpdateChildInstances(childInstance);
+            }
+        }
+
+        private static void FailToRead(string configPath, string message)
+        {
+            Logger.Error($"Failed to read {configPath}!\n{message}");
+        }
+    }
+}

roblox-cs-master/RobloxCS/SymbolAnalyzer.cs

@@ -0,0 +1,110 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace RobloxCS
+{
+    internal sealed class SymbolAnalyzerResults
+    {
+        public List<INamespaceOrTypeSymbol> TypesWithMembersUsedAsValues { get; set; } = new List<INamespaceOrTypeSymbol>();
+
+        public bool TypeHasMemberUsedAsValue(INamespaceOrTypeSymbol namespaceOrType)
+        {
+            return TypesWithMembersUsedAsValues.Any(symbol => SymbolEqualityComparer.Default.Equals(symbol, namespaceOrType));
+        }
+    }
+
+    internal sealed class SymbolAnalyzer
+    {
+        private readonly SyntaxTree _tree;
+        private readonly SemanticModel _semanticModel;
+        private readonly SymbolAnalyzerResults _results = new SymbolAnalyzerResults();
+
+        public SymbolAnalyzer(SyntaxTree tree, SemanticModel semanticModel)
+        {
+            _tree = tree;
+            _semanticModel = semanticModel;
+        }
+
+        public SymbolAnalyzerResults Analyze()
+        {
+            AnalyzeUsings();
+            AnalyzeNamespaces();
+            return _results;
+        }
+
+        private void AnalyzeNamespaces()
+        {
+            var root = _tree.GetRoot();
+            var namespaceDeclarations = root.DescendantNodes().OfType<NamespaceDeclarationSyntax>();
+
+            foreach (var namespaceDeclaration in namespaceDeclarations)
+            {
+                var symbolInfo = _semanticModel.GetSymbolInfo(namespaceDeclaration.Name);
+                if (symbolInfo.Symbol is INamespaceOrTypeSymbol namespaceOrTypeSymbol && HasMembersUsedAsValues(namespaceOrTypeSymbol, root))
+                {
+                    _results.TypesWithMembersUsedAsValues.Add(namespaceOrTypeSymbol);
+                }
+            }
+        }
+
+        private void AnalyzeUsings()
+        {
+            var root = _tree.GetRoot();
+            var usingDirectives = root.DescendantNodes().OfType<UsingDirectiveSyntax>();
+
+            foreach (var usingDirective in usingDirectives)
+            {
+                if (usingDirective.Name == null) continue;
+
+                var symbolInfo = _semanticModel.GetSymbolInfo(usingDirective.Name);
+                if (symbolInfo.Symbol is INamespaceOrTypeSymbol namespaceOrTypeSymbol && HasMembersUsedAsValues(namespaceOrTypeSymbol, root))
+                {
+                    _results.TypesWithMembersUsedAsValues.Add(namespaceOrTypeSymbol);
+                }
+            }
+        }
+        
+        private bool HasMembersUsedAsValues(INamespaceOrTypeSymbol namespaceOrTypeSymbol, SyntaxNode root)
+        {
+            var typeUsages = root.DescendantNodes()
+                .OfType<IdentifierNameSyntax>()
+                .Where(identifier => 
+                    _semanticModel.GetSymbolInfo(identifier).Symbol is INamedTypeSymbol symbol
+                        && SymbolEqualityComparer.Default.Equals(symbol.ContainingNamespace, namespaceOrTypeSymbol)
+                );
+
+            foreach (var usage in typeUsages)
+            {
+                if (IsUsedAsValue(usage))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private bool IsUsedAsValue(SyntaxNode node)
+        {
+            // Check for object instantiation, member access, or variable declarator
+            if (node.Parent is ObjectCreationExpressionSyntax ||
+                node.Parent is MemberAccessExpressionSyntax ||
+                node.Parent is VariableDeclaratorSyntax ||
+                node.Parent is AssignmentExpressionSyntax)
+            {
+                return true;
+            }
+
+            // Check if used in a method invocation
+            if (node.Parent is InvocationExpressionSyntax invocation)
+            {
+                var symbolInfo = _semanticModel.GetSymbolInfo(invocation);
+                if (symbolInfo.Symbol is IMethodSymbol methodSymbol)
+                {
+                    return methodSymbol.Parameters.Any(p => SymbolEqualityComparer.Default.Equals(p.Type, _semanticModel.GetTypeInfo(node).Type));
+                }
+            }
+
+            return false;
+        }
+    }
+}

roblox-cs-master/RobloxCS/Transformers/BaseTransformer.cs

@@ -0,0 +1,40 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace RobloxCS
+{
+    public abstract class BaseTransformer : CSharpSyntaxRewriter
+    {
+        protected SyntaxNode _root;
+        protected readonly SyntaxTree _tree;
+        protected readonly ConfigData _config;
+
+        public BaseTransformer(SyntaxTree tree, ConfigData config)
+        {
+            _root = tree.GetRoot();
+            _tree = tree;
+            _config = config;
+        }
+
+        public SyntaxTree TransformTree()
+        {
+            return _tree.WithRootAndOptions(Visit(_root), _tree.Options);
+        }
+
+        protected string? TryGetName(SyntaxNode node)
+        {
+            return Utility.GetNamesFromNode(node).FirstOrDefault();
+        }
+
+        protected string GetName(SyntaxNode node)
+        {
+            return Utility.GetNamesFromNode(node).First();
+        }
+
+        protected SyntaxToken CreateIdentifierToken(string text, string? valueText = null, SyntaxTriviaList? trivia = null)
+        {
+            var triviaList = trivia ?? SyntaxFactory.TriviaList();
+            return SyntaxFactory.VerbatimIdentifier(triviaList, text, valueText ?? text, triviaList);
+        }
+    }
+}

roblox-cs-master/RobloxCS/Transformers/BuiltInTransformers.cs

@@ -0,0 +1,29 @@
+using Microsoft.CodeAnalysis;
+
+namespace RobloxCS
+{
+    using TransformMethod = Func<SyntaxTree, ConfigData, SyntaxTree>;
+
+    public static partial class BuiltInTransformers
+    {
+        public static TransformMethod Main()
+        {
+            return (tree, config) => new MainTransformer(tree, config).TransformTree();
+        }
+
+        public static TransformMethod Get(string name)
+        {
+            return name.ToLower() switch
+            {
+                "debug" => (tree, config) => new DebugTransformer(tree, config).TransformTree(),
+                _ => FailedToGetTransformer(name)
+            };
+        }
+
+        private static TransformMethod FailedToGetTransformer(string name)
+        {
+            Logger.Error($"No built-in transformer \"{name}\" exists (roblox-cs.yml)");
+            return null!; // hack
+        }
+    }
+}

roblox-cs-master/RobloxCS/Transformers/DebugTransformer.cs

@@ -0,0 +1,91 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace RobloxCS
+{
+    public sealed class DebugTransformer : BaseTransformer
+    {
+        public DebugTransformer(SyntaxTree tree, ConfigData config)
+            : base(tree, config)
+        {
+        }
+
+        public override SyntaxNode? VisitInvocationExpression(InvocationExpressionSyntax node)
+        {
+            if (node.Expression is IdentifierNameSyntax || node.Expression is MemberAccessExpressionSyntax)
+            {
+                {
+                    if (node.Expression is MemberAccessExpressionSyntax memberAccess)
+                    {
+                        if (Utility.GetNamesFromNode(memberAccess.Expression).LastOrDefault() != "Globals")
+                        {
+                            goto DoNothing;
+                        }
+                    }
+                }
+                {
+                    var name = GetName(node.Expression is MemberAccessExpressionSyntax memberAccess ? memberAccess.Name : node.Expression);
+                    HashSet<string> concatMethodNames = ["error"];
+                    HashSet<string> extraArgNames = ["print", "warn"];
+
+                    var newNode = node;
+                    if (concatMethodNames.Contains(name))
+                    {
+                        newNode = ConcatenateFileInfoToMessageArgument(node);
+                    }
+                    else if (extraArgNames.Contains(name))
+                    {
+                        newNode = PrependFileInfoArgument(node);
+                    }
+
+                    return base.VisitInvocationExpression(node.Expression is MemberAccessExpressionSyntax _memberAccess ? newNode.WithExpression(_memberAccess.Name) : newNode);
+                }
+            }
+
+            DoNothing:
+            return base.VisitInvocationExpression(node);
+        }
+
+        private InvocationExpressionSyntax ConcatenateFileInfoToMessageArgument(InvocationExpressionSyntax node)
+        {
+            var messageArgument = node.ArgumentList.Arguments.First().Expression;
+            var fileInfoLiteral = GetFileInfoLiteral(node, addSpace: true);
+            var emptyTrivia = SyntaxFactory.TriviaList();
+            var plusToken = SyntaxFactory.Token(emptyTrivia, SyntaxKind.PlusToken, "+", "", emptyTrivia);
+            var binaryExpression = SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, fileInfoLiteral, plusToken, messageArgument);
+            var newArgument = SyntaxFactory.Argument(binaryExpression);
+            var newArguments = SeparatedSyntaxList.Create(new ReadOnlySpan<ArgumentSyntax>(ref newArgument));
+            var newArgumentListNode = node.ArgumentList.WithArguments(newArguments);
+            return node.WithArgumentList(newArgumentListNode);
+        }
+
+        private InvocationExpressionSyntax PrependFileInfoArgument(InvocationExpressionSyntax node)
+        {
+            var fileInfoLiteral = GetFileInfoLiteral(node, addSpace: false);
+            var argument = SyntaxFactory.Argument(fileInfoLiteral);
+            var newArguments = SeparatedSyntaxList.Create(new ReadOnlySpan<ArgumentSyntax>(new List<ArgumentSyntax> { argument }.Concat(node.ArgumentList.Arguments).ToArray())); // good lord why do they make that so convoluted
+            var newArgumentListNode = node.ArgumentList.WithArguments(newArguments);
+            return node.WithArgumentList(newArgumentListNode);
+        }
+
+        private LiteralExpressionSyntax GetFileInfoLiteral(SyntaxNode node, bool addSpace)
+        {
+            var fileLocation = FormatLocation(node);
+            var infoText = $"[{fileLocation}]:" + (addSpace ? " " : "");
+            var emptyTrivia = SyntaxFactory.TriviaList();
+            var token = SyntaxFactory.Token(emptyTrivia, SyntaxKind.StringLiteralToken, infoText, infoText, emptyTrivia); // why is trivia required bruh
+            return SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, token);
+        }
+
+        private string FormatLocation(SyntaxNode node)
+        {
+            var location = Utility.FormatLocation(node.GetLocation().GetLineSpan())
+                .Replace(_config.SourceFolder + "/", "")
+                .Replace("..", "./")
+                .Replace("./", "");
+
+            return location;
+        }
+    }
+}

roblox-cs-master/RobloxCS/Transformers/MainTransformer.cs

@@ -0,0 +1,137 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace RobloxCS
+{
+    internal sealed class MainTransformer : BaseTransformer
+    {
+        public MainTransformer(SyntaxTree tree, ConfigData config)
+            : base(tree, config)
+        {
+        }
+
+        public override SyntaxNode? VisitCompilationUnit(CompilationUnitSyntax node)
+        {
+            var usings = node.Usings;
+            usings = usings.Add(SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("Roblox")));
+            usings = usings.Add(SyntaxFactory.UsingDirective(SyntaxFactory.Token(SyntaxKind.StaticKeyword), null, SyntaxFactory.QualifiedName(SyntaxFactory.IdentifierName("Roblox"), SyntaxFactory.IdentifierName("Globals"))));
+            return base.VisitCompilationUnit(node.WithUsings(usings));
+        }
+
+        public override SyntaxNode? VisitFileScopedNamespaceDeclaration(FileScopedNamespaceDeclarationSyntax node)
+        {
+            return VisitNamespaceDeclaration(SyntaxFactory.NamespaceDeclaration(node.AttributeLists, node.Modifiers, node.Name, node.Externs, node.Usings, node.Members));
+        }
+
+        public override SyntaxNode? VisitDoStatement(DoStatementSyntax node)
+        {
+            // invert condition
+            return base.VisitDoStatement(node.WithCondition(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, node.Condition)));
+        }
+
+        public override SyntaxNode? VisitBinaryExpression(BinaryExpressionSyntax node)
+        {
+            if (node.OperatorToken.Text == "is")
+            {
+                var pattern = SyntaxFactory.TypePattern(SyntaxFactory.ParseTypeName(((IdentifierNameSyntax)node.Right).Identifier.Text));
+                return SyntaxFactory.IsPatternExpression(node.Left, pattern);
+            }
+            return base.VisitBinaryExpression(node);
+        }
+
+        public override SyntaxNode? VisitMethodDeclaration(MethodDeclarationSyntax node)
+        {
+            var newNode = node.Identifier.ValueText switch
+            {
+                "ToString" => node.WithIdentifier(CreateIdentifierToken("__tostring")),
+                "Equals" => node.WithIdentifier(CreateIdentifierToken("__eq")),
+                _ => node
+            };
+            if (node != newNode && HasSyntax(newNode.Modifiers, SyntaxKind.OverrideKeyword))
+            {
+                var newModifiers = newNode.Modifiers.RemoveAt(newNode.Modifiers.Select(token => token.Kind()).ToList().IndexOf(SyntaxKind.OverrideKeyword));
+                newNode = newNode.WithModifiers(newModifiers);
+            }
+            return base.VisitMethodDeclaration(newNode);
+        }
+
+        public override SyntaxNode? VisitIdentifierName(IdentifierNameSyntax node)
+        {
+            var identifierText = node.Identifier.Text;
+            if (!identifierText.Contains("@") || identifierText == "var")
+            {
+                return base.VisitIdentifierName(node);
+            }
+
+            var fixedIdentifierText = identifierText.Replace("@", "");
+            var newToken = CreateIdentifierToken(fixedIdentifierText);
+            return base.VisitIdentifierName(node.WithIdentifier(newToken));
+        }
+
+        public override SyntaxNode? VisitArgument(ArgumentSyntax node)
+        {
+            if (node.Expression.IsKind(SyntaxKind.IdentifierName))
+            {
+                var newExpression = VisitIdentifierName((IdentifierNameSyntax)node.Expression);
+                return base.VisitArgument(node.WithExpression((ExpressionSyntax)newExpression!));
+            }
+            return base.VisitArgument(node);
+        }
+
+        public override SyntaxNode? VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node)
+        {
+            var whenNotNull = ProcessWhenNotNull(node.Expression, node.WhenNotNull);
+            if (whenNotNull != null)
+            {
+                return base.VisitConditionalAccessExpression(node.WithWhenNotNull(whenNotNull));
+            }
+            return base.VisitConditionalAccessExpression(node);
+        }
+
+        private static bool HasSyntax(SyntaxTokenList tokens, SyntaxKind syntax)
+        {
+            return tokens.Any(token => token.IsKind(syntax));
+        }
+
+        private ExpressionSyntax? ProcessWhenNotNull(ExpressionSyntax expression, ExpressionSyntax whenNotNull)
+        {
+            if (whenNotNull == null)
+            {
+                return null;
+            }
+
+            switch (whenNotNull)
+            {
+                case MemberBindingExpressionSyntax memberBinding:
+                    return SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, expression, memberBinding.Name);
+                case InvocationExpressionSyntax invocation:
+                    return invocation.WithExpression((invocation.Expression switch
+                    {
+                        MemberAccessExpressionSyntax memberAccess => SyntaxFactory.MemberAccessExpression(
+                            SyntaxKind.SimpleMemberAccessExpression,
+                            expression,
+                            memberAccess.Name
+                        ),
+                        ConditionalAccessExpressionSyntax nestedConditional => ProcessWhenNotNull(nestedConditional.WhenNotNull, expression),
+                        MemberBindingExpressionSyntax memberBinding => SyntaxFactory.MemberAccessExpression(
+                            SyntaxKind.SimpleMemberAccessExpression,
+                            expression,
+                            memberBinding.Name
+                        ),
+                        _ => SyntaxFactory.MemberAccessExpression(
+                            SyntaxKind.SimpleMemberAccessExpression,
+                            expression,
+                            SyntaxFactory.IdentifierName(invocation.Expression.ToString())
+                        )
+                    })!);
+                case ConditionalAccessExpressionSyntax conditionalAccess:
+                    return conditionalAccess
+                        .WithExpression(ProcessWhenNotNull(expression, conditionalAccess.Expression) ?? conditionalAccess.Expression)
+                        .WithWhenNotNull(ProcessWhenNotNull(expression, conditionalAccess.WhenNotNull) ?? conditionalAccess.WhenNotNull);
+                default:
+                    return null;
+            };
+        }
+    }
+}

roblox-cs-master/RobloxCS/Transpiler.cs

@@ -0,0 +1,128 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace RobloxCS
+{
+    public sealed class Transpiler
+    {
+        public readonly ConfigData Config;
+
+        private const string _includeFolderName = "Include";
+        private List<SyntaxTree> _fileTrees = new List<SyntaxTree>();
+        private readonly string _inputDirectory;
+        private readonly string _sourceDirectory;
+        private readonly string _outDirectory;
+
+        public Transpiler(string inputDirectory)
+        {
+            Config = ConfigReader.Read(inputDirectory);
+            _inputDirectory = inputDirectory;
+            _sourceDirectory = inputDirectory + "/" + Config.SourceFolder;
+            _outDirectory = inputDirectory + "/" + Config.OutputFolder;
+        }
+
+        public void Transpile()
+        {
+            ParseSource();
+            var compiler = CompileASTs();
+            CopyIncludedLua();
+            WriteLuaOutput(compiler);
+        }
+
+        private void ParseSource()
+        {
+            if (!Directory.Exists(_sourceDirectory))
+            {
+                Logger.Error($"Source folder \"{Config.SourceFolder}\" does not exist!");
+            }
+
+            var sourceFiles = FileManager.GetSourceFiles(_sourceDirectory);
+            foreach (var sourceFile in sourceFiles)
+            {
+                var fileContents = File.ReadAllText(sourceFile);
+                var tree = TranspilerUtility.ParseTree(fileContents, sourceFile);
+                HashSet<Func<SyntaxTree, ConfigData, SyntaxTree>> transformers = [BuiltInTransformers.Main()];
+
+                foreach (var transformerName in Config.EnabledBuiltInTransformers)
+                {
+                    transformers.Add(BuiltInTransformers.Get(transformerName));
+                }
+
+                var transformedTree = TranspilerUtility.TransformTree(tree, transformers, Config);
+                foreach (var diagnostic in transformedTree.GetDiagnostics())
+                {
+                    Logger.HandleDiagnostic(diagnostic);
+                }
+
+                _fileTrees.Add(transformedTree);
+            }
+        }
+        
+        private CSharpCompilation CompileASTs()
+        {
+            var compiler = TranspilerUtility.GetCompiler(_fileTrees, Config);
+            foreach (var diagnostic in compiler.GetDiagnostics())
+            {
+                Logger.HandleDiagnostic(diagnostic);
+            }
+
+            return compiler;
+        }
+
+        private void CopyIncludedLua()
+        {
+            var rbxcsDirectory = Utility.GetRbxcsDirectory();
+            if (rbxcsDirectory == null)
+            {
+                Logger.CompilerError("Failed to find RobloxCS directory");
+                return;
+            }
+
+            var compilerDirectory = Utility.FixPathSep(Path.Combine(rbxcsDirectory, "RobloxCS"));
+            var includeDirectory = Utility.FixPathSep(Path.Combine(compilerDirectory, _includeFolderName));
+            var destinationIncludeDirectory = includeDirectory
+                .Replace(compilerDirectory, _inputDirectory)
+                .Replace(_includeFolderName, _includeFolderName.ToLower());
+
+            try
+            {
+                FileManager.CopyDirectory(includeDirectory, destinationIncludeDirectory);
+            }
+            catch (Exception e)
+            {
+                Logger.Error($"Failed to copy included Lua files: {e.Message}");
+            }
+        }
+
+        private void WriteLuaOutput(CSharpCompilation compiler)
+        {
+            var compiledFiles = new List<CompiledFile>();
+            var memberCollector = new MemberCollector(_fileTrees);
+            var members = memberCollector.Collect();
+            if (Config.CSharpOptions.EntryPointRequired && _fileTrees.All(tree => !tree.GetRoot().DescendantNodes().Any(node => node is ClassDeclarationSyntax classDeclaration && Utility.GetNamesFromNode(classDeclaration).FirstOrDefault() == Config.CSharpOptions.EntryPointName)))
+            {
+                Logger.Error($"No entry point class \"{Config.CSharpOptions.EntryPointName}\" found!");
+            }
+
+            foreach (var tree in _fileTrees)
+            {
+                var generatedLua = TranspilerUtility.GenerateLua(tree, compiler, members, _inputDirectory, Config);
+                var targetPath = tree.FilePath.Replace(Config.SourceFolder, Config.OutputFolder).Replace(".cs", ".lua");
+                compiledFiles.Add(new CompiledFile(targetPath, generatedLua));
+            }
+
+            EnsureDirectoriesExist();
+            FileManager.WriteCompiledFiles(_outDirectory, compiledFiles);
+        }
+
+        private void EnsureDirectoriesExist()
+        {
+            var subDirectories = Directory.GetDirectories(_sourceDirectory, "*", SearchOption.AllDirectories);
+            foreach (string subDirectory in subDirectories)
+            {
+                Directory.CreateDirectory(subDirectory.Replace(Config.SourceFolder, Config.OutputFolder));
+            }
+        }
+    }
+}

roblox-cs-master/RobloxCS/TranspilerUtility.cs

@@ -0,0 +1,118 @@
+using System.Reflection;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace RobloxCS
+{
+    public static class TranspilerUtility
+    {
+        public static RojoProject? GetRojoProject(string inputDirectory, string projectName)
+        {
+            if (projectName == "UNIT_TESTING") return null;
+
+            var path = RojoReader.FindProjectPath(inputDirectory, projectName);
+            if (path == null)
+            {
+                Logger.Error($"Failed to find Rojo project file \"{projectName}.project.json\"!");
+                return null!;
+            }
+
+            return RojoReader.Read(path);
+        }
+
+        public static string CleanUpLuaForTests(string luaSource, int? extraLines)
+        {
+            var lines = luaSource.Split('\n').ToList();
+            lines.RemoveRange(0, 2 + (extraLines ?? 0));
+
+            return string.Join('\n', lines).Replace("\r", "").Trim();
+        }
+
+        public static string GenerateLua(
+            SyntaxTree tree,
+            CSharpCompilation compiler,
+            MemberCollectionResult members,
+            string inputDirectory = "",
+            ConfigData? config = null
+        )
+        {
+            config ??= ConfigReader.UnitTestingConfig;
+            var rojoProject = GetRojoProject(inputDirectory, config.RojoProjectName);
+            var codeGenerator = new CodeGenerator(tree, compiler, rojoProject, members, config, Utility.FixPathSep(inputDirectory));
+            return codeGenerator.GenerateLua();
+        }
+
+        public static CSharpCompilation GetCompiler(List<SyntaxTree> trees, ConfigData? config = null)
+        {
+            config ??= ConfigReader.UnitTestingConfig;
+            var compilationOptions = new CSharpCompilationOptions(OutputKind.ConsoleApplication);
+            var compiler = CSharpCompilation.Create(
+                assemblyName: config.CSharpOptions.AssemblyName,
+                syntaxTrees: trees,
+                references: GetCompilationReferences(),
+                options: compilationOptions
+            );
+
+            return compiler;
+        }
+
+        public static SyntaxTree TransformTree(SyntaxTree cleanTree, HashSet<Func<SyntaxTree, ConfigData, SyntaxTree>> transformMethods, ConfigData? config = null)
+        {
+            config ??= ConfigReader.UnitTestingConfig;
+
+            var tree = cleanTree;
+            foreach (var transform in transformMethods)
+            {
+                tree = transform(tree, config);
+            }
+            return tree;
+        }
+
+        public static SyntaxTree ParseTree(string source, string sourceFile = "TestFile.client.cs")
+        {
+            var cleanTree = CSharpSyntaxTree.ParseText(source);
+            var compilationUnit = (CompilationUnitSyntax)cleanTree.GetRoot();
+            var usingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System"));
+            var newRoot = compilationUnit.AddUsings(usingDirective);
+            return cleanTree
+                .WithRootAndOptions(newRoot, cleanTree.Options)
+                .WithFilePath(sourceFile);
+        }
+
+        private static List<PortableExecutableReference> GetCompilationReferences()
+        {
+            var runtimeLibAssemblyPath = string.Join('/', Utility.GetAssemblyDirectory(), Utility.RuntimeAssemblyName + ".dll");
+            if (!File.Exists(runtimeLibAssemblyPath))
+            {
+                var directoryName = Path.GetDirectoryName(runtimeLibAssemblyPath);
+                Logger.Error($"Failed to find {Utility.RuntimeAssemblyName}.dll in {(directoryName == null ? "(could not find assembly directory)" : Utility.FixPathSep(directoryName))}");
+            }
+
+            var references = new List<PortableExecutableReference>()
+            {
+                MetadataReference.CreateFromFile(runtimeLibAssemblyPath)
+            };
+
+            foreach (var coreLibReference in GetCoreLibReferences())
+            {
+                references.Add(coreLibReference);
+            }
+            return references;
+        }
+
+        private static HashSet<PortableExecutableReference> GetCoreLibReferences()
+        {
+            var coreLib = typeof(object).GetTypeInfo().Assembly.Location;
+            HashSet<string> coreDlls = ["System.Runtime.dll", "System.Core.dll", "System.Collections.dll"];
+            HashSet<PortableExecutableReference> references = [MetadataReference.CreateFromFile(coreLib)];
+            
+            foreach (var coreDll in coreDlls)
+            {
+                var dllPath = Path.Combine(Path.GetDirectoryName(coreLib)!, coreDll);
+                references.Add(MetadataReference.CreateFromFile(dllPath));
+            }
+            return references;
+        }
+    }
+}

roblox-cs-master/RobloxCS/Utility.cs

@@ -0,0 +1,255 @@
+using System.Reflection;
+using System.Text.RegularExpressions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace RobloxCS
+{
+    public static class Utility
+    {
+        public const string RuntimeAssemblyName = "Roblox";
+        public const string LuaRuntimeModuleName = "RuntimeLib";
+
+        public static string GetMappedType(string csharpType)
+        {
+            if (csharpType.EndsWith("[]"))
+            {
+                var arrayType = csharpType.Substring(0, csharpType.Length - 2);
+                return $"{{ {GetMappedType(arrayType)} }}";
+            }
+            if (csharpType.EndsWith('?'))
+            {
+                var nonNullableType = csharpType.Substring(0, csharpType.Length - 1);
+                return $"{GetMappedType(nonNullableType)}?";
+            }
+
+            switch (csharpType)
+            {
+                case "object":
+                    return "any";
+
+                case "void":
+                case "null":
+                    return "nil";
+
+                case "char":
+                case "Char":
+                case "String":
+                    return "string";
+                case "double":
+                case "float":
+                    return "number";
+
+                default:
+                    if (Constants.INTEGER_TYPES.Contains(csharpType))
+                    {
+                        return "number";
+                    }
+                    return csharpType;
+            }
+        }
+
+        public static string GetBit32MethodName(string bitOp)
+        {
+            switch (bitOp)
+            {
+                case "&=":
+                case "&":
+                    return "band";
+                case "|=":
+                case "|":
+                    return "bor";
+                case "^=":
+                case "^":
+                    return "bxor";
+                case ">>=":
+                case ">>":
+                    return "rshift";
+                case ">>>=":
+                case ">>>":
+                    return "arshift";
+                case "<<=":
+                case "<<":
+                    return "lshift";
+                case "~":
+                    return "bnot";
+                default:
+                    return bitOp;
+            }
+        }
+
+        public static string GetMappedOperator(string op)
+        {
+            switch (op)
+            {
+                case "++":
+                    return "+=";
+                case "--":
+                    return "--";
+                case "!":
+                    return "not ";
+                case "!=":
+                    return "~=";
+                case "&&":
+                    return "and";
+                case "||":
+                    return "or";
+                default:
+                    return op;
+            }
+        }
+
+        public static List<string> ExtractTypeArguments(string input)
+        {
+            var typeArguments = new List<string>();
+            var regex = new Regex(@"<(?<args>[^<>]+)>");
+            var match = regex.Match(input);
+            if (match.Success)
+            {
+                // Get the matched group containing the type arguments
+                var args = match.Groups["args"].Value;
+
+                // Split the arguments by comma and trim whitespace
+                var argsArray = args.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
+
+                foreach (var arg in argsArray)
+                {
+                    typeArguments.Add(arg.Trim());
+                }
+            }
+
+            return typeArguments;
+        }
+
+        public static string FormatLocation(FileLinePositionSpan lineSpan)
+        {
+            return $"{(lineSpan.Path == "" ? "<anonymous>" : lineSpan.Path)}:{lineSpan.StartLinePosition.Line + 1}:{lineSpan.StartLinePosition.Character + 1}";
+        }
+
+        public static ISymbol? FindMember(INamespaceSymbol namespaceSymbol, string memberName)
+        {
+            var member = namespaceSymbol.GetMembers().FirstOrDefault<ISymbol?>(member => member?.Name == memberName, null);
+            if (member == null && namespaceSymbol.ContainingNamespace != null)
+            {
+                member = FindMember(namespaceSymbol.ContainingNamespace, memberName);
+            }
+            return member;
+        }
+
+        public static ISymbol? FindMemberDeep(INamedTypeSymbol namedTypeSymbol, string memberName)
+        {
+            var member = namedTypeSymbol.GetMembers().FirstOrDefault(member => member.Name == memberName);
+            if (namedTypeSymbol.BaseType != null && member == null)
+            {
+                return FindMemberDeep(namedTypeSymbol.BaseType, memberName);
+            }
+            return member;
+        }
+
+        public static List<string> GetNamesFromNode(SyntaxNode? node)
+        {
+            if (node is BaseExpressionSyntax baseExpression)
+            {
+                return [""];
+            }
+
+            var names = new List<string>();
+            if (node == null) return names;
+
+            var identifierProperty = node.GetType().GetProperty("Identifier");
+            var identifierValue = identifierProperty?.GetValue(node);
+            if (identifierProperty != null && identifierValue != null && identifierValue is SyntaxToken)
+            {
+                names.Add(((SyntaxToken)identifierValue).ValueText.Trim());
+                return names;
+            }
+
+            var childNodes = node.ChildNodes();
+            var qualifiedNameNodes = node.IsKind(SyntaxKind.QualifiedName) ? [(QualifiedNameSyntax)node] : childNodes.OfType<QualifiedNameSyntax>();
+            var identifierNameNodes = node.IsKind(SyntaxKind.IdentifierName) ? [(IdentifierNameSyntax)node] : childNodes.OfType<IdentifierNameSyntax>();
+            foreach (var qualifiedNameNode in qualifiedNameNodes)
+            {
+                foreach (var name in GetNamesFromNode(qualifiedNameNode.Left))
+                {
+                    names.Add(name.Trim());
+                }
+                foreach (var name in GetNamesFromNode(qualifiedNameNode.Right))
+                {
+                    names.Add(name.Trim());
+                }
+            }
+
+            foreach (var identifierNameNode in identifierNameNodes)
+            {
+                names.Add(identifierNameNode.Identifier.ValueText.Trim());
+            }
+
+            return names;
+        }
+
+        public static string FixPathSep(string path)
+        {
+            path = Path.TrimEndingDirectorySeparator(path);
+            return Regex.Replace(path.Replace("\\\\", "/").Replace('\\', '/').Replace("//", "/"), @"(?<!\.)\./", "");
+        }
+
+        public static string? GetRbxcsDirectory()
+        {
+            var directoryName = Path.GetDirectoryName(GetAssemblyDirectory()); // pretend like this isn't here lol
+            return directoryName == null ? null : FixPathSep(directoryName);
+        }
+
+        public static string GetAssemblyDirectory()
+        {
+            var location = FixPathSep(Assembly.GetExecutingAssembly().Location);
+            var directoryName = Path.GetDirectoryName(location)!;
+            return FixPathSep(directoryName);
+        }
+
+        public static string GetTargetFramework()
+        {
+            var assemblyDirectory = GetAssemblyDirectory();
+            if (assemblyDirectory == null)
+            {
+                Logger.Error("Failed to find RobloxCS assembly directory!");
+            }
+
+            return assemblyDirectory!.Split('/').Last();
+        }
+
+        public static List<T> FilterDuplicates<T>(IEnumerable<T> items, IEqualityComparer<T> comparer)
+        {
+            var seen = new Dictionary<T, bool>(comparer);
+            var result = new List<T>();
+            foreach (var item in items)
+            {
+                if (!seen.ContainsKey(item))
+                {
+                    seen[item] = true;
+                    result.Add(item);
+                }
+            }
+
+            return result;
+        }
+
+        public static void PrintChildNodes(SyntaxNode node)
+        {
+            Logger.Info($"{node.Kind()} node children: {node.ChildNodes().Count()}");
+            foreach (var child in node.ChildNodes())
+            {
+                Logger.Info(child.Kind().ToString() + ": " + child.GetText());
+            }
+        }
+
+        public static void PrintChildTokens(SyntaxNode node)
+        {
+            Logger.Info($"{node.Kind()} token children: {node.ChildTokens().Count()}");
+            foreach (var child in node.ChildTokens())
+            {
+                Logger.Info(child.Kind().ToString() + ": " + child.Text);
+            }
+        }
+    }
+}

roblox-cs-master/roblox-cs.sln

@@ -0,0 +1,45 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.8.34330.188
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RobloxCS", "RobloxCS\RobloxCS.csproj", "{B61F0F15-38BF-4A07-A08C-DD309F4EFF33}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{3F25D38D-D965-4675-B51F-80A39A5259F2}"
+	ProjectSection(SolutionItems) = preProject
+		.gitignore = .gitignore
+		.github\workflows\publish.yml = .github\workflows\publish.yml
+		README.md = README.md
+		.github\workflows\tests.yml = .github\workflows\tests.yml
+	EndProjectSection
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RobloxCS.Tests", "RobloxCS.Tests\RobloxCS.Tests.csproj", "{ECEF0FD6-BADA-4AA9-B55F-EB9D0BE18A5F}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RobloxCS.CLI", "RobloxCS.CLI\RobloxCS.CLI.csproj", "{DCB5D69F-7AE3-4F15-85AA-CE9490529A71}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{B61F0F15-38BF-4A07-A08C-DD309F4EFF33}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B61F0F15-38BF-4A07-A08C-DD309F4EFF33}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B61F0F15-38BF-4A07-A08C-DD309F4EFF33}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B61F0F15-38BF-4A07-A08C-DD309F4EFF33}.Release|Any CPU.Build.0 = Release|Any CPU
+		{ECEF0FD6-BADA-4AA9-B55F-EB9D0BE18A5F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{ECEF0FD6-BADA-4AA9-B55F-EB9D0BE18A5F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{ECEF0FD6-BADA-4AA9-B55F-EB9D0BE18A5F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{ECEF0FD6-BADA-4AA9-B55F-EB9D0BE18A5F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{DCB5D69F-7AE3-4F15-85AA-CE9490529A71}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DCB5D69F-7AE3-4F15-85AA-CE9490529A71}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DCB5D69F-7AE3-4F15-85AA-CE9490529A71}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DCB5D69F-7AE3-4F15-85AA-CE9490529A71}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {5C9B4FC3-25E8-401B-AC78-69DE5D1AFA9C}
+	EndGlobalSection
+EndGlobal