Merge 40694c833d into e94fecce66

.github/workflows/release.yml

@@ -26,9 +26,6 @@ jobs:
         with:
           dotnet-version: '8.0.x'
 
-      - name: Add samboy's nuget source
-        run:  dotnet nuget add source https://nuget.samboy.dev/v3/index.json
-
       - name: Build protodec
         run:  dotnet publish --configuration Release --runtime ${{ matrix.runtime }} /p:Version=${{ github.ref_name }} /p:ContinuousIntegrationBuild=true
 

README.md

@@ -1,37 +1,29 @@
 protodec
 ========
-A tool to decompile [protoc](https://github.com/protocolbuffers/protobuf) compiled protobuf classes back into .proto definitions.
+A tool to decompile protobuf classes compiled by [protoc](https://github.com/protocolbuffers/protobuf), from CIL assemblies back into .proto definitions.
 
 Usage
 -----
 ```
-Usage: [command] [arguments...] [options...] [-h|--help] [--version]                                                                                                                                                                                                                    
+Usage: protodec(.exe) <target_assembly_path> <out_path> [options]
-Use reflection backend to load target CIL assembly and its dependants.
-
 Arguments:
-  [0] <string>    Either the path to the target assembly or a directory of assemblies, all of which be parsed.
+  target_assembly_path  Either the path to the target assembly or a directory of assemblies, all of which be parsed.
-  [1] <string>    An existing directory to output into individual files, otherwise output to a single file.
+  out_path              An existing directory to output into individual files, otherwise output to a single file.
-
 Options:
-  --skip-enums                                                  Skip parsing enums and replace references to them with int32. (Optional)
+  --debug                                                     Drops the minimum log level to Debug.
-  --include-properties-without-non-user-code-attribute          Includes properties that aren't decorated with `DebuggerNonUserCode` when parsing. (Optional)
+  --parse_service_servers                                     Parses gRPC service definitions from server classes.
-  --include-service-methods-without-generated-code-attribute    Includes methods that aren't decorated with `GeneratedCode("grpc_csharp_plugin")` when parsing gRPC services. (Optional)
+  --parse_service_clients                                     Parses gRPC service definitions from client classes.
-  --parse-service-servers                                       Parses gRPC service definitions from server classes. (Optional)
+  --skip_enums                                                Skip parsing enums and replace references to them with int32.
-  --parse-service-clients                                       Parses gRPC service definitions from client classes. (Optional)
+  --include_properties_without_non_user_code_attribute        Includes properties that aren't decorated with `DebuggerNonUserCode` when parsing.
-  --log-level <LogLevel>                                        Logging severity level. (Default: Information)
+  --include_service_methods_without_generated_code_attribute  Includes methods that aren't decorated with `GeneratedCode("grpc_csharp_plugin")` when parsing gRPC services.
-
-Commands:
-  il2cpp    Use LibCpp2IL backend to directly load Il2Cpp compiled game assembly. EXPERIMENTAL.
 ```
-See per-command help message for more info.
 
 Limitations
 -----------
 - Integers are assumed to be (u)int32/64 as CIL doesn't differentiate between them and sint32/64 and (s)fixed32/64.
 - Package names are not preserved in protobuf compilation so naturally we cannot recover them during decompilation, which may result in naming conflicts.
-- When decompiling from [Il2CppDumper](https://github.com/Perfare/Il2CppDumper) DummyDLLs or from an Il2Cpp assembly older than metadata version 29, due to the development branch of [LibCpp2Il](https://github.com/SamboyCoding/Cpp2IL/tree/development/LibCpp2IL) not yet recovering method bodies
+- When decompiling from [Il2CppDumper](https://github.com/Perfare/Il2CppDumper) DummyDLLs
-    - The `Name` parameter of `OriginalNameAttribute` is not parsed. In this case, the CIL enum field names are used after conforming them to protobuf conventions.
+    - The `Name` parameter of `OriginalNameAttribute` is not dumped. In this case, the CIL enum field names are used after conforming them to protobuf conventions
-    - The `Tool` parameter of `GeneratedCodeAttribute` is not compared against when parsing gRPC service methods, which may cause false positives in the event that another tool has generated methods in the service class.
 
 License
 -------

protodec.sln

@@ -10,7 +10,6 @@ EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{22F217C3-0FC2-4D06-B5F3-AA1E3AFC402E}"
 	ProjectSection(SolutionItems) = preProject
 		README.md = README.md
-		.github\workflows\release.yml = .github\workflows\release.yml
 	EndProjectSection
 EndProject
 Global

src/LibProtodec/LibProtodec.csproj

@@ -18,10 +18,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.0-preview.6.24327.7" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.0-preview.5.24306.7" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All" />
-    <PackageReference Include="Samboy063.LibCpp2IL" Version="2022.1.0-development.1027" />
+    <PackageReference Include="System.Reflection.MetadataLoadContext" Version="9.0.0-preview.5.24306.7" />
-    <PackageReference Include="System.Reflection.MetadataLoadContext" Version="9.0.0-preview.6.24327.7" />
     <PackageReference Include="Xpl0itR.SystemEx" Version="1.2.0" />
   </ItemGroup>
 

src/LibProtodec/Loaders/CilAssemblyLoader.cs

@@ -6,42 +6,29 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using LibProtodec.Models.Cil;
 
 namespace LibProtodec.Loaders;
 
-public abstract class CilAssemblyLoader
+public abstract class CilAssemblyLoader : IDisposable
 {
+    private ICilType? _iMessage;
+    private ICilType? _clientBase;
+    private ICilType? _bindServiceMethodAttribute;
+
+    // ReSharper disable once InconsistentNaming
+    public ICilType IMessage =>
+        _iMessage ??= FindType("Google.Protobuf.IMessage", "Google.Protobuf");
+
+    public ICilType ClientBase =>
+        _clientBase ??= FindType("Grpc.Core.ClientBase", "Grpc.Core.Api");
+
+    public ICilType BindServiceMethodAttribute =>
+        _bindServiceMethodAttribute ??= FindType("Grpc.Core.BindServiceMethodAttribute", "Grpc.Core.Api");
+
     public IReadOnlyList<ICilType> LoadedTypes { get; protected init; }
 
-    public IEnumerable<ICilType> GetProtobufMessageTypes()
+    public virtual void Dispose() { }
-    {
-        ICilType iMessage = FindType("Google.Protobuf.IMessage", "Google.Protobuf");
-
-        return LoadedTypes.Where(
-            type => type is { IsNested: false, IsSealed: true }
-                 && type.Namespace?.StartsWith("Google.Protobuf", StringComparison.Ordinal) != true
-                 && type.IsAssignableTo(iMessage));
-    }
-
-    public IEnumerable<ICilType> GetProtobufServiceClientTypes()
-    {
-        ICilType clientBase = FindType("Grpc.Core.ClientBase", "Grpc.Core.Api");
-
-        return LoadedTypes.Where(
-            type => type is { IsNested: true, IsAbstract: false }
-                 && type.IsAssignableTo(clientBase));
-    }
-
-    public IEnumerable<ICilType> GetProtobufServiceServerTypes()
-    {
-        ICilType bindServiceMethodAttribute = FindType("Grpc.Core.BindServiceMethodAttribute", "Grpc.Core.Api");
-
-        return LoadedTypes.Where(
-            type => type is { IsNested: true, IsAbstract: true, DeclaringType: { IsNested: false, IsSealed: true, IsAbstract: true } }
-                 && type.CustomAttributes.Any(attribute => attribute.Type == bindServiceMethodAttribute));
-    }
 
     protected abstract ICilType FindType(string typeFullName, string assemblySimpleName);
 }

src/LibProtodec/Loaders/ClrAssemblyLoader.cs

@@ -16,11 +16,11 @@ using Microsoft.Extensions.Logging;
 
 namespace LibProtodec.Loaders;
 
-public sealed class ClrAssemblyLoader : CilAssemblyLoader, IDisposable
+public sealed class ClrAssemblyLoader : CilAssemblyLoader
 {
     public readonly MetadataLoadContext LoadContext;
 
-    public ClrAssemblyLoader(string assemblyPath, ILogger<ClrAssemblyLoader>? logger = null)
+    public ClrAssemblyLoader(string assemblyPath, ILogger? logger = null)
     {
         bool isFile = File.Exists(assemblyPath);
         string assemblyDir = isFile
@@ -55,7 +55,7 @@ public sealed class ClrAssemblyLoader : CilAssemblyLoader, IDisposable
         return ClrType.GetOrCreate(clrType);
     }
 
-    public void Dispose() =>
+    public override void Dispose() =>
         LoadContext.Dispose();
 
     /// <summary>

src/LibProtodec/Loaders/Il2CppAssemblyLoader.cs

@@ -1,64 +0,0 @@
-// Copyright © 2024 Xpl0itR
-// 
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-using System;
-using System.Linq;
-using AssetRipper.Primitives;
-using CommunityToolkit.Diagnostics;
-using LibCpp2IL;
-using LibCpp2IL.Logging;
-using LibCpp2IL.Metadata;
-using LibCpp2IL.Reflection;
-using LibProtodec.Models.Cil;
-using LibProtodec.Models.Cil.Il2Cpp;
-using Microsoft.Extensions.Logging;
-
-namespace LibProtodec.Loaders;
-
-public sealed class Il2CppAssemblyLoader : CilAssemblyLoader
-{
-    public Il2CppAssemblyLoader(string assemblyPath, string metadataPath, UnityVersion unityVersion, ILoggerFactory? loggerFactory = null)
-    {
-        if (loggerFactory is not null)
-        {
-            LibLogger.Writer = new LibCpp2IlLogger(
-                loggerFactory.CreateLogger(nameof(LibCpp2IL)));
-        }
-
-        if (!LibCpp2IlMain.LoadFromFile(assemblyPath, metadataPath, unityVersion))
-            ThrowHelper.ThrowInvalidDataException("Failed to load IL2Cpp assembly!");
-
-        this.LoadedTypes = LibCpp2IlMain.TheMetadata!.typeDefs.Select(Il2CppType.GetOrCreate).ToList();
-
-        loggerFactory?.CreateLogger<Il2CppAssemblyLoader>()
-                      .LogLoadedTypeAndAssemblyCount(this.LoadedTypes.Count, LibCpp2IlMain.TheMetadata.imageDefinitions.Length);
-    }
-
-    protected override ICilType FindType(string typeFullName, string assemblySimpleName)
-    {
-        Il2CppTypeDefinition? type = LibCpp2IlReflection.GetTypeByFullName(typeFullName);
-        Guard.IsNotNull(type);
-
-        return Il2CppType.GetOrCreate(type);
-    }
-
-    private sealed class LibCpp2IlLogger(ILogger logger) : LogWriter
-    {
-        private static readonly Func<string, Exception?, string> MessageFormatter = (message, _) => message.Trim();
-
-        public override void Info(string message) =>
-            logger.Log(LogLevel.Information, default(EventId), message, null, MessageFormatter);
-
-        public override void Warn(string message) =>
-            logger.Log(LogLevel.Warning, default(EventId), message, null, MessageFormatter);
-
-        public override void Error(string message) =>
-            logger.Log(LogLevel.Error, default(EventId), message, null, MessageFormatter);
-
-        public override void Verbose(string message) =>
-            logger.Log(LogLevel.Debug, default(EventId), message, null, MessageFormatter);
-    }
-}

src/LibProtodec/Models/Cil/Clr/ClrAttribute.cs

@@ -15,9 +15,6 @@ public sealed class ClrAttribute(CustomAttributeData clrAttribute) : ICilAttribu
     private ICilType?  _type;
     private object?[]? _constructorArgumentValues;
 
-    public bool CanReadConstructorArgumentValues =>
-        true;
-
     public ICilType Type =>
         _type ??= ClrType.GetOrCreate(
             clrAttribute.AttributeType);

src/LibProtodec/Models/Cil/ICilAttribute.cs

@@ -12,7 +12,5 @@ public interface ICilAttribute
 {
     ICilType Type { get; }
 
-    bool CanReadConstructorArgumentValues { get; }
-
     IList<object?> ConstructorArgumentValues { get; }
 }

src/LibProtodec/Models/Cil/Il2Cpp/Il2CppAttribute.cs

@@ -1,25 +0,0 @@
-// Copyright © 2024 Xpl0itR
-// 
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-using System.Collections.Generic;
-using CommunityToolkit.Diagnostics;
-using LibCpp2IL.Metadata;
-
-namespace LibProtodec.Models.Cil.Il2Cpp;
-
-public sealed class Il2CppAttribute(Il2CppTypeDefinition il2CppAttrType, object?[]? ctorArgValues) : ICilAttribute
-{
-    public ICilType Type =>
-        Il2CppType.GetOrCreate(il2CppAttrType);
-
-    public bool CanReadConstructorArgumentValues =>
-        ctorArgValues is not null;
-
-    public IList<object?> ConstructorArgumentValues =>
-        ctorArgValues
-     ?? ThrowHelper.ThrowNotSupportedException<IList<object?>>(
-            "Attribute constructor argument parsing is only available on Il2Cpp metadata version 29 or greater.");
-}

src/LibProtodec/Models/Cil/Il2Cpp/Il2CppField.cs

@@ -1,40 +0,0 @@
-// Copyright © 2024 Xpl0itR
-// 
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-using System.Reflection;
-using LibCpp2IL.Metadata;
-
-namespace LibProtodec.Models.Cil.Il2Cpp;
-
-public sealed class Il2CppField(Il2CppFieldDefinition il2CppField) : Il2CppMember, ICilField
-{
-    private readonly FieldAttributes _attributes =
-        (FieldAttributes)il2CppField.RawFieldType!.Attrs;
-
-    public string Name =>
-        il2CppField.Name!;
-
-    public object? ConstantValue =>
-        il2CppField.DefaultValue!.Value;
-
-    public bool IsLiteral =>
-        (_attributes & FieldAttributes.Literal) != 0;
-
-    public bool IsPublic =>
-        (_attributes & FieldAttributes.Public) != 0;
-
-    public bool IsStatic =>
-        (_attributes & FieldAttributes.Static) != 0;
-
-    protected override Il2CppImageDefinition DeclaringAssembly =>
-        il2CppField.FieldType!.baseType!.DeclaringAssembly!;
-
-    protected override int CustomAttributeIndex =>
-        il2CppField.customAttributeIndex;
-
-    protected override uint Token =>
-        il2CppField.token;
-}

src/LibProtodec/Models/Cil/Il2Cpp/Il2CppMember.cs

@@ -1,306 +0,0 @@
-// Copyright © 2024 Xpl0itR
-// 
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using SystemEx.Memory;
-using CommunityToolkit.Diagnostics;
-using LibCpp2IL;
-using LibCpp2IL.BinaryStructures;
-using LibCpp2IL.Metadata;
-
-namespace LibProtodec.Models.Cil.Il2Cpp;
-
-public abstract class Il2CppMember
-{
-    private ICilAttribute[]? _customAttributes;
-
-    public IList<ICilAttribute> CustomAttributes
-    {
-        get
-        {
-            if (_customAttributes is null)
-            {
-                if (LibCpp2IlMain.MetadataVersion < 29f)
-                {
-                    int attrTypeRngIdx = LibCpp2IlMain.MetadataVersion <= 24f
-                        ? CustomAttributeIndex
-                        : BinarySearchToken(
-                            LibCpp2IlMain.TheMetadata!.attributeTypeRanges,
-                            Token,
-                            DeclaringAssembly.customAttributeStart,
-                            (int)DeclaringAssembly.customAttributeCount);
-
-                    if (attrTypeRngIdx < 0)
-                        return _customAttributes = Array.Empty<ICilAttribute>();
-
-                    Il2CppCustomAttributeTypeRange attrTypeRng = LibCpp2IlMain.TheMetadata!.attributeTypeRanges[attrTypeRngIdx];
-
-                    _customAttributes = new ICilAttribute[attrTypeRng.count];
-                    for (int attrTypeIdx = 0; attrTypeIdx < attrTypeRng.count; attrTypeIdx++)
-                    {
-                        int typeIndex = LibCpp2IlMain.TheMetadata.attributeTypes[attrTypeRng.start + attrTypeIdx];
-                        var type      = LibCpp2IlMain.Binary!.GetType(typeIndex);
-                        var typeDef   = LibCpp2IlMain.TheMetadata.typeDefs[type.Data.ClassIndex];
-
-                        _customAttributes[attrTypeIdx] = new Il2CppAttribute(typeDef, null);
-                    }
-                }
-                else
-                {
-                    int attrDataRngIdx = BinarySearchToken(
-                        LibCpp2IlMain.TheMetadata!.AttributeDataRanges,
-                        Token,
-                        DeclaringAssembly.customAttributeStart,
-                        (int)DeclaringAssembly.customAttributeCount);
-
-                    if (attrDataRngIdx < 0)
-                        return _customAttributes = Array.Empty<ICilAttribute>();
-
-                    Il2CppCustomAttributeDataRange attrDataRange   = LibCpp2IlMain.TheMetadata.AttributeDataRanges[attrDataRngIdx];
-                    Il2CppCustomAttributeDataRange attrDataRngNext = LibCpp2IlMain.TheMetadata.AttributeDataRanges[attrDataRngIdx + 1];
-
-                    long   attrDataStart = LibCpp2IlMain.TheMetadata.metadataHeader.attributeDataOffset + attrDataRange.startOffset;
-                    long   attrDataEnd   = LibCpp2IlMain.TheMetadata.metadataHeader.attributeDataOffset + attrDataRngNext.startOffset;
-                    byte[] attrData      = LibCpp2IlMain.TheMetadata.ReadByteArrayAtRawAddress(attrDataStart, (int)(attrDataEnd - attrDataStart));
-
-                    MemoryReader reader = new(attrData);
-                    int attributeCount = (int)ReadUnityCompressedUInt32(ref reader);
-
-                    Span<uint> ctorIndices = stackalloc uint[attributeCount];
-                    for (int i = 0; i < attributeCount; i++)
-                        ctorIndices[i] = reader.ReadUInt32LittleEndian();
-
-                    _customAttributes = new ICilAttribute[attributeCount];
-                    for (int i = 0; i < attributeCount; i++)
-                    {
-                        uint ctorArgCount = ReadUnityCompressedUInt32(ref reader);
-                        uint fieldCount   = ReadUnityCompressedUInt32(ref reader);
-                        uint propCount    = ReadUnityCompressedUInt32(ref reader);
-
-                        object?[] ctorArgValues = ctorArgCount > 0
-                            ? new object[ctorArgCount]
-                            : Array.Empty<object?>();
-
-                        for (int j = 0; j < ctorArgCount; j++)
-                        {
-                            ctorArgValues[j] = ReadValue(ref reader);
-                        }
-
-                        for (uint j = 0; j < fieldCount; j++)
-                        {
-                            ReadValue(ref reader);
-                            ResolveMember(ref reader);
-                        }
-
-                        for (uint j = 0; j < propCount; j++)
-                        {
-                            ReadValue(ref reader);
-                            ResolveMember(ref reader);
-                        }
-
-                        Il2CppMethodDefinition attrCtor = LibCpp2IlMain.TheMetadata.methodDefs[ctorIndices[i]];
-                        Il2CppTypeDefinition   attrType = LibCpp2IlMain.TheMetadata.typeDefs[attrCtor.declaringTypeIdx];
-
-                        _customAttributes[i] = new Il2CppAttribute(attrType, ctorArgValues);
-                    }
-                }
-            }
-
-            return _customAttributes;
-        }
-    }
-
-    protected abstract Il2CppImageDefinition DeclaringAssembly { get; }
-
-    protected abstract int CustomAttributeIndex { get; }
-
-    protected abstract uint Token { get; }
-
-    private static int BinarySearchToken(IReadOnlyList<IIl2CppTokenProvider> source, uint token, int start, int count)
-    {
-        int lo = start;
-        int hi = start + count - 1;
-        while (lo <= hi)
-        {
-            int i = lo + ((hi - lo) >> 1);
-
-            switch (source[i].Token.CompareTo(token))
-            {
-                case 0:
-                    return i;
-                case < 0:
-                    lo = i + 1;
-                    break;
-                default:
-                    hi = i - 1;
-                    break;
-            }
-        }
-
-        return ~lo;
-    }
-
-    private static uint ReadUnityCompressedUInt32(ref MemoryReader reader)
-    {
-        byte byt = reader.ReadByte();
-
-        switch (byt)
-        {
-            case < 128:
-                return byt;
-            case 240:
-                return reader.ReadUInt32LittleEndian();
-            case 254:
-                return uint.MaxValue - 1;
-            case byte.MaxValue:
-                return uint.MaxValue;
-        }
-
-        if ((byt & 192) == 192)
-        {
-            return (byt & ~192U) << 24
-                 | ((uint)reader.ReadByte() << 16)
-                 | ((uint)reader.ReadByte() << 8)
-                 | reader.ReadByte();
-        }
-
-        if ((byt & 128) == 128)
-        {
-            return (byt & ~128U) << 8
-                 | reader.ReadByte();
-        }
-
-        return ThrowHelper.ThrowInvalidDataException<uint>();
-    }
-
-    private static int ReadUnityCompressedInt32(ref MemoryReader reader)
-    {
-        uint unsigned = ReadUnityCompressedUInt32(ref reader);
-        if (unsigned == uint.MaxValue)
-            return int.MinValue;
-
-        bool isNegative = (unsigned & 1) == 1;
-        unsigned >>= 1;
-
-        return isNegative
-            ? -(int)(unsigned + 1)
-            : (int)unsigned;
-    }
-
-    private static object? ReadValue(ref MemoryReader reader)
-    {
-        Il2CppTypeEnum type = (Il2CppTypeEnum)reader.ReadByte();
-        return ReadValue(ref reader, type);
-    }
-
-    private static object? ReadValue(ref MemoryReader reader, Il2CppTypeEnum type)
-    {
-        switch (type)
-        {
-            case Il2CppTypeEnum.IL2CPP_TYPE_ENUM:
-                Il2CppTypeEnum underlyingType = ReadEnumUnderlyingType(ref reader);
-                return ReadValue(ref reader, underlyingType);
-            case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
-                return ReadSzArray(ref reader);
-            case Il2CppTypeEnum.IL2CPP_TYPE_IL2CPP_TYPE_INDEX:
-                int typeIndex = ReadUnityCompressedInt32(ref reader);
-                return LibCpp2IlMain.Binary!.GetType(typeIndex);
-            case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN:
-                return reader.ReadBoolean();
-            case Il2CppTypeEnum.IL2CPP_TYPE_CHAR:
-                return (char)reader.ReadInt16LittleEndian();
-            case Il2CppTypeEnum.IL2CPP_TYPE_I1:
-                return reader.ReadSByte();
-            case Il2CppTypeEnum.IL2CPP_TYPE_U1:
-                return reader.ReadByte();
-            case Il2CppTypeEnum.IL2CPP_TYPE_I2:
-                return reader.ReadInt16LittleEndian();
-            case Il2CppTypeEnum.IL2CPP_TYPE_U2:
-                return reader.ReadUInt16LittleEndian();
-            case Il2CppTypeEnum.IL2CPP_TYPE_I4:
-                return ReadUnityCompressedInt32(ref reader);
-            case Il2CppTypeEnum.IL2CPP_TYPE_U4:
-                return ReadUnityCompressedUInt32(ref reader);
-            case Il2CppTypeEnum.IL2CPP_TYPE_I8:
-                return reader.ReadInt64LittleEndian();
-            case Il2CppTypeEnum.IL2CPP_TYPE_U8:
-                return reader.ReadUInt64LittleEndian();
-            case Il2CppTypeEnum.IL2CPP_TYPE_R4:
-                return reader.ReadSingleLittleEndian();
-            case Il2CppTypeEnum.IL2CPP_TYPE_R8:
-                return reader.ReadDoubleLittleEndian();
-            case Il2CppTypeEnum.IL2CPP_TYPE_STRING:
-                return ReadString(ref reader);
-            case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
-            case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT:
-            case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
-            default:
-                return ThrowHelper.ThrowNotSupportedException<object>();
-        }
-    }
-
-    private static Il2CppTypeEnum ReadEnumUnderlyingType(ref MemoryReader reader)
-    {
-        int typeIdx        = ReadUnityCompressedInt32(ref reader);
-        var enumType       = LibCpp2IlMain.Binary!.GetType(typeIdx);
-        var underlyingType = LibCpp2IlMain.Binary.GetType(
-            enumType.AsClass().ElementTypeIndex);
-
-        return underlyingType.Type;
-    }
-
-    private static object?[]? ReadSzArray(ref MemoryReader reader)
-    {
-        int arrayLength = ReadUnityCompressedInt32(ref reader);
-        if (arrayLength == -1)
-            return null;
-
-        Il2CppTypeEnum arrayType = (Il2CppTypeEnum)reader.ReadByte();
-        if (arrayType == Il2CppTypeEnum.IL2CPP_TYPE_ENUM)
-            arrayType = ReadEnumUnderlyingType(ref reader);
-
-        bool typePrefixed = reader.ReadBoolean();
-        if (typePrefixed && arrayType != Il2CppTypeEnum.IL2CPP_TYPE_OBJECT)
-            ThrowHelper.ThrowInvalidDataException("Array elements are type-prefixed, but the array type is not object");
-
-        object?[] array = new object?[arrayLength];
-        for (int i = 0; i < arrayLength; i++)
-        {
-            Il2CppTypeEnum elementType = typePrefixed
-                ? (Il2CppTypeEnum)reader.ReadByte()
-                : arrayType;
-
-            array[i] = ReadValue(ref reader, elementType);
-        }
-
-        return array;
-    }
-
-    private static string? ReadString(ref MemoryReader reader)
-    {
-        int length = ReadUnityCompressedInt32(ref reader);
-        if (length == -1)
-            return null;
-
-        ReadOnlySpan<byte> bytes = reader.ReadBytes(length);
-        return Encoding.UTF8.GetString(bytes);
-    }
-
-    private static void ResolveMember(ref MemoryReader reader)
-    {
-        // We don't care about attribute properties or fields,
-        // so we just read enough to exhaust the stream
-
-        int memberIndex = ReadUnityCompressedInt32(ref reader);
-        if (memberIndex < 0)
-        {
-            uint typeIndex = ReadUnityCompressedUInt32(ref reader);
-            memberIndex = -(memberIndex + 1);
-        }
-    }
-}

src/LibProtodec/Models/Cil/Il2Cpp/Il2CppMethod.cs

@@ -1,57 +0,0 @@
-// Copyright © 2024 Xpl0itR
-// 
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-using System.Collections.Generic;
-using System.Reflection;
-using LibCpp2IL;
-using LibCpp2IL.Metadata;
-using LibCpp2IL.Reflection;
-
-namespace LibProtodec.Models.Cil.Il2Cpp;
-
-public sealed class Il2CppMethod(Il2CppMethodDefinition il2CppMethod) : Il2CppMember, ICilMethod
-{
-    public string Name =>
-        il2CppMethod.Name!;
-
-    public bool IsInherited =>
-        false;
-
-    public bool IsConstructor =>
-        Name is ".ctor" or ".cctor";
-
-    public bool IsPublic =>
-        (il2CppMethod.Attributes & MethodAttributes.Public) != 0;
-
-    public bool IsStatic =>
-        (il2CppMethod.Attributes & MethodAttributes.Static) != 0;
-
-    public bool IsVirtual =>
-        (il2CppMethod.Attributes & MethodAttributes.Virtual) != 0;
-
-    public ICilType ReturnType =>
-        Il2CppType.GetOrCreate(
-            LibCpp2ILUtils.GetTypeReflectionData(
-                LibCpp2IlMain.Binary!.GetType(
-                    il2CppMethod.returnTypeIdx)));
-
-    public IEnumerable<ICilType> GetParameterTypes()
-    {
-        foreach (Il2CppParameterReflectionData parameter in il2CppMethod.Parameters!)
-        {
-            yield return Il2CppType.GetOrCreate(parameter.Type);
-        }
-    }
-
-    protected override Il2CppImageDefinition DeclaringAssembly =>
-        il2CppMethod.DeclaringType!.DeclaringAssembly!;
-
-    protected override int CustomAttributeIndex =>
-        il2CppMethod.customAttributeIndex;
-
-    protected override uint Token =>
-        il2CppMethod.token;
-}

src/LibProtodec/Models/Cil/Il2Cpp/Il2CppProperty.cs

@@ -1,56 +0,0 @@
-// Copyright © 2024 Xpl0itR
-// 
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-using System.Linq;
-using LibCpp2IL;
-using LibCpp2IL.Metadata;
-
-namespace LibProtodec.Models.Cil.Il2Cpp;
-
-public sealed class Il2CppProperty(Il2CppPropertyDefinition il2CppProperty, Il2CppTypeDefinition declaringType) : Il2CppMember, ICilProperty
-{
-    private Il2CppMethod? _getter;
-    private Il2CppMethod? _setter;
-
-    public string Name =>
-        il2CppProperty.Name!;
-
-    public bool IsInherited =>
-        false;
-
-    public bool CanRead =>
-        il2CppProperty.get >= 0;
-
-    public bool CanWrite =>
-        il2CppProperty.set >= 0;
-
-    public ICilMethod? Getter =>
-        CanRead
-            ? _getter ??= new Il2CppMethod(
-                LibCpp2IlMain.TheMetadata!.methodDefs[
-                    declaringType.FirstMethodIdx + il2CppProperty.get])
-            : null;
-
-    public ICilMethod? Setter =>
-        CanWrite
-            ? _setter ??= new Il2CppMethod(
-                LibCpp2IlMain.TheMetadata!.methodDefs[
-                    declaringType.FirstMethodIdx + il2CppProperty.set])
-            : null;
-
-    public ICilType Type =>
-        Getter?.ReturnType
-     ?? Setter!.GetParameterTypes().First();
-
-    protected override Il2CppImageDefinition DeclaringAssembly =>
-        declaringType.DeclaringAssembly!;
-
-    protected override int CustomAttributeIndex =>
-        il2CppProperty.customAttributeIndex;
-
-    protected override uint Token =>
-        il2CppProperty.token;
-}

src/LibProtodec/Models/Cil/Il2Cpp/Il2CppType.cs

@@ -1,197 +0,0 @@
-// Copyright © 2024 Xpl0itR
-// 
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Reflection;
-using CommunityToolkit.Diagnostics;
-using LibCpp2IL;
-using LibCpp2IL.Metadata;
-using LibCpp2IL.Reflection;
-
-namespace LibProtodec.Models.Cil.Il2Cpp;
-
-public sealed class Il2CppType : Il2CppMember, ICilType
-{
-    private readonly Il2CppTypeDefinition _il2CppType;
-    private readonly Il2CppTypeReflectionData[] _genericArgs;
-    private ICilType[]? _genericTypeArguments;
-
-    private Il2CppType(Il2CppTypeDefinition il2CppType, Il2CppTypeReflectionData[] genericArgs) =>
-        (_il2CppType, _genericArgs) = (il2CppType, genericArgs);
-
-    public string Name =>
-        _il2CppType.Name!;
-
-    public string FullName =>
-        _il2CppType.FullName!;
-
-    public string? Namespace =>
-        _il2CppType.Namespace;
-
-    public string DeclaringAssemblyName =>
-        LibCpp2IlMain.TheMetadata!.GetStringFromIndex(
-            DeclaringAssembly.nameIndex);
-
-    public ICilType? DeclaringType =>
-        IsNested
-            ? GetOrCreate(
-                LibCpp2ILUtils.GetTypeReflectionData(
-                    LibCpp2IlMain.Binary!.GetType(
-                        _il2CppType.DeclaringTypeIndex)))
-            : null;
-
-    public ICilType? BaseType =>
-        _il2CppType.ParentIndex == -1
-            ? null
-            : GetOrCreate(
-                LibCpp2ILUtils.GetTypeReflectionData(
-                    LibCpp2IlMain.Binary!.GetType(
-                        _il2CppType.ParentIndex)));
-
-    public bool IsAbstract =>
-        _il2CppType.IsAbstract;
-
-    public bool IsClass =>
-        (_il2CppType.Attributes & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Class
-     && !_il2CppType.IsValueType;
-
-    public bool IsEnum =>
-        _il2CppType.IsEnumType;
-
-    public bool IsNested =>
-        _il2CppType.DeclaringTypeIndex >= 0;
-
-    public bool IsSealed =>
-        (_il2CppType.Attributes & TypeAttributes.Sealed) != 0;
-
-    public IList<ICilType> GenericTypeArguments
-    {
-        get
-        {
-            if (_genericTypeArguments is null)
-            {
-                _genericTypeArguments = _genericArgs.Length < 1
-                    ? Array.Empty<ICilType>()
-                    : new ICilType[_genericArgs.Length];
-
-                for (int i = 0; i < _genericArgs.Length; i++)
-                {
-                    _genericTypeArguments[i] = GetOrCreate(_genericArgs[i]);
-                }
-            }
-
-            return _genericTypeArguments;
-        }
-    }
-
-    public IEnumerable<ICilField> GetFields()
-    {
-        for (int i = 0; i < _il2CppType.FieldCount; i++)
-        {
-            yield return new Il2CppField(
-                LibCpp2IlMain.TheMetadata!.fieldDefs[
-                    _il2CppType.FirstFieldIdx + i]);
-        }
-    }
-
-    public IEnumerable<ICilMethod> GetMethods()
-    {
-        for (int i = 0; i < _il2CppType.MethodCount; i++)
-        {
-            yield return new Il2CppMethod(
-                LibCpp2IlMain.TheMetadata!.methodDefs[
-                    _il2CppType.FirstMethodIdx + i]);
-        }
-    }
-
-    public IEnumerable<ICilType> GetNestedTypes()
-    {
-        for (int i = 0; i < _il2CppType.NestedTypeCount; i++)
-        {
-            yield return GetOrCreate(
-                LibCpp2IlMain.TheMetadata!.typeDefs[
-                    LibCpp2IlMain.TheMetadata.nestedTypeIndices[
-                        _il2CppType.NestedTypesStart + i]]);
-        }
-    }
-
-    public IEnumerable<ICilProperty> GetProperties()
-    {
-        for (int i = 0; i < _il2CppType.PropertyCount; i++)
-        {
-            yield return new Il2CppProperty(
-                LibCpp2IlMain.TheMetadata!.propertyDefs[
-                    _il2CppType.FirstPropertyId + i],
-                _il2CppType);
-        }
-    }
-
-    public bool IsAssignableTo(ICilType type)
-    {
-        if (type is Il2CppType il2CppType)
-        {
-            return IsAssignableTo(_il2CppType, il2CppType._il2CppType);
-        }
-
-        return ThrowHelper.ThrowNotSupportedException<bool>();
-    }
-
-    protected override Il2CppImageDefinition DeclaringAssembly =>
-        _il2CppType.DeclaringAssembly!;
-
-    protected override int CustomAttributeIndex =>
-        _il2CppType.CustomAttributeIndex;
-
-    protected override uint Token =>
-        _il2CppType.Token;
-
-
-    private static readonly ConcurrentDictionary<string, Il2CppType> TypeLookup = [];
-
-    public static ICilType GetOrCreate(Il2CppTypeDefinition il2CppType) =>
-        TypeLookup.GetOrAdd(
-            il2CppType.FullName!,
-            static (_, il2CppType) =>
-                new Il2CppType(il2CppType, Array.Empty<Il2CppTypeReflectionData>()),
-            il2CppType);
-
-    public static ICilType GetOrCreate(Il2CppTypeReflectionData il2CppTypeData)
-    {
-        Guard.IsTrue(il2CppTypeData.isType);
-
-        return TypeLookup.GetOrAdd(
-            il2CppTypeData.ToString(),
-            static (_, il2CppTypeData) =>
-                new Il2CppType(il2CppTypeData.baseType!, il2CppTypeData.genericParams),
-            il2CppTypeData);
-    }
-
-    private static bool IsAssignableTo(Il2CppTypeDefinition thisType, Il2CppTypeDefinition baseType)
-    {
-        if (baseType.IsInterface)
-        {
-            foreach (Il2CppTypeReflectionData @interface in thisType.Interfaces!)
-            {
-                if (@interface.baseType == baseType)
-                {
-                    return true;
-                }
-            }
-        }
-        
-        if (thisType == baseType)
-        {
-            return true;
-        }
-
-        Il2CppTypeDefinition? thisTypeBaseType = thisType.BaseType?.baseType;
-
-        return thisTypeBaseType is not null
-            && IsAssignableTo(thisTypeBaseType, baseType);
-    }
-}

src/LibProtodec/ProtodecContext.cs

@@ -25,14 +25,14 @@ namespace LibProtodec;
 
 public delegate bool NameLookupFunc(string name, [MaybeNullWhen(false)] out string translatedName);
 
-// ReSharper disable ClassWithVirtualMembersNeverInherited.Global, MemberCanBePrivate.Global, MemberCanBeProtected.Global, PropertyCanBeMadeInitOnly.Global
+// ReSharper disable ClassWithVirtualMembersNeverInherited.Global, MemberCanBePrivate.Global, MemberCanBeProtected.Global
 public class ProtodecContext
 {
     private readonly Dictionary<string, TopLevel> _parsed = [];
 
     public readonly List<Protobuf> Protobufs = [];
 
-    public ILogger<ProtodecContext>? Logger { get; set; }
+    public ILogger? Logger { get; set; }
 
     public NameLookupFunc? NameLookup { get; set; }
 
@@ -609,7 +609,7 @@ public class ProtodecContext
 
     protected string TranslateEnumFieldName(IEnumerable<ICilAttribute> attributes, string fieldName, string enumName)
     {
-        if (attributes.SingleOrDefault(static attr => attr is { CanReadConstructorArgumentValues: true, Type.Name: "OriginalNameAttribute" })
+        if (attributes.SingleOrDefault(static attr => attr.Type.Name == "OriginalNameAttribute")
                      ?.ConstructorArgumentValues[0] is string originalName)
         {
             return originalName;
@@ -664,9 +664,8 @@ public class ProtodecContext
         name.Length == 11 && name.CountUpper() == 11;
 
     protected static bool HasGeneratedCodeAttribute(IEnumerable<ICilAttribute> attributes, string tool) =>
-        attributes.Any(attr => attr.Type.Name == nameof(GeneratedCodeAttribute)
+        attributes.Any(attr => attr.Type.Name                              == nameof(GeneratedCodeAttribute)
-                            && (!attr.CanReadConstructorArgumentValues
+                            && attr.ConstructorArgumentValues[0] as string == tool);
-                             || attr.ConstructorArgumentValues[0] as string == tool));
 
     protected static bool HasNonUserCodeAttribute(IEnumerable<ICilAttribute> attributes) =>
         attributes.Any(static attr => attr.Type.Name == nameof(DebuggerNonUserCodeAttribute));

src/protodec/Program.cs

@@ -4,210 +4,137 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
+using System;
 using System.CodeDom.Compiler;
 using System.Collections.Generic;
 using System.IO;
-using AssetRipper.Primitives;
+using System.Linq;
-using ConsoleAppFramework;
-using LibCpp2IL;
 using LibProtodec;
 using LibProtodec.Loaders;
 using LibProtodec.Models.Cil;
 using LibProtodec.Models.Protobuf;
 using Microsoft.Extensions.Logging;
 
-ConsoleApp.ConsoleAppBuilder app = ConsoleApp.Create();
+const string indent = "  ";
-app.Add<Commands>();
+const string help   = """
-app.Run(args);
+    Usage: protodec(.exe) <target_assembly_path> <out_path> [options]
+    Arguments:
+      target_assembly_path  Either the path to the target assembly or a directory of assemblies, all of which be parsed.
+      out_path              An existing directory to output into individual files, otherwise output to a single file.
+    Options:
+      --debug                                                     Drops the minimum log level to Debug.
+      --parse_service_servers                                     Parses gRPC service definitions from server classes.
+      --parse_service_clients                                     Parses gRPC service definitions from client classes.
+      --skip_enums                                                Skip parsing enums and replace references to them with int32.
+      --include_properties_without_non_user_code_attribute        Includes properties that aren't decorated with `DebuggerNonUserCode` when parsing.
+      --include_service_methods_without_generated_code_attribute  Includes methods that aren't decorated with `GeneratedCode("grpc_csharp_plugin")` when parsing gRPC services.
+    """;
 
-internal sealed class Commands
+if (args.Length < 2)
 {
-    /// <summary>
+    Console.WriteLine(help);
-    ///     Use reflection backend to load target CIL assembly and its dependants.
+    return;
-    /// </summary>
+}
-    /// <param name="targetPath">Either the path to the target assembly or a directory of assemblies, all of which be parsed.</param>
+
-    /// <param name="outPath">An existing directory to output into individual files, otherwise output to a single file.</param>
+string        assembly = args[0];
-    /// <param name="logLevel">Logging severity level.</param>
+string        outPath  = Path.GetFullPath(args[1]);
-    /// <param name="parseServiceServers">Parses gRPC service definitions from server classes.</param>
+ParserOptions options  = ParserOptions.None;
-    /// <param name="parseServiceClients">Parses gRPC service definitions from client classes.</param>
+LogLevel      logLevel = args.Contains("--debug")
-    /// <param name="skipEnums">Skip parsing enums and replace references to them with int32.</param>
+    ? LogLevel.Debug
-    /// <param name="includePropertiesWithoutNonUserCodeAttribute">Includes properties that aren't decorated with `DebuggerNonUserCode` when parsing.</param>
+    : LogLevel.Information;
-    /// <param name="includeServiceMethodsWithoutGeneratedCodeAttribute">Includes methods that aren't decorated with `GeneratedCode("grpc_csharp_plugin")` when parsing gRPC services.</param>
+
-    [Command("")]
+if (args.Contains("--skip_enums"))
-    public void Root(
+    options |= ParserOptions.SkipEnums;
-        [Argument] string targetPath,
+
-        [Argument] string outPath,
+if (args.Contains("--include_properties_without_non_user_code_attribute"))
-        bool              skipEnums,
+    options |= ParserOptions.IncludePropertiesWithoutNonUserCodeAttribute;
-        bool              includePropertiesWithoutNonUserCodeAttribute,
+
-        bool              includeServiceMethodsWithoutGeneratedCodeAttribute,
+if (args.Contains("--include_service_methods_without_generated_code_attribute"))
-        bool              parseServiceServers,
+    options |= ParserOptions.IncludeServiceMethodsWithoutGeneratedCodeAttribute;
-        bool              parseServiceClients,
+
-        LogLevel          logLevel = LogLevel.Information)
+using ILoggerFactory loggerFactory = LoggerFactory.Create(
+    builder => builder.AddSimpleConsole(static console => console.IncludeScopes = true)
+                      .SetMinimumLevel(logLevel));
+ILogger logger = loggerFactory.CreateLogger("protodec");
+
+logger.LogInformation("Loading target assemblies...");
+using CilAssemblyLoader loader = new ClrAssemblyLoader(
+    assembly, loggerFactory.CreateLogger<ClrAssemblyLoader>());
+
+ProtodecContext ctx = new()
+{
+    Logger = loggerFactory.CreateLogger<ProtodecContext>()
+};
+
+logger.LogInformation("Parsing Protobuf message types...");
+foreach (ICilType message in GetProtobufMessageTypes())
+{
+    ctx.ParseMessage(message, options);
+}
+
+if (args.Contains("--parse_service_servers"))
+{
+    logger.LogInformation("Parsing Protobuf service server types...");
+    foreach (ICilType service in GetProtobufServiceServerTypes())
     {
-        using ILoggerFactory loggerFactory = CreateLoggerFactory(logLevel);
+        ctx.ParseService(service, options);
-        ILogger logger = CreateProtodecLogger(loggerFactory);
-
-        logger.LogInformation("Loading target assemblies...");
-        using ClrAssemblyLoader loader = new(targetPath, loggerFactory.CreateLogger<ClrAssemblyLoader>());
-
-        Handle(
-            loader,
-            outPath,
-            skipEnums,
-            includePropertiesWithoutNonUserCodeAttribute,
-            includeServiceMethodsWithoutGeneratedCodeAttribute,
-            parseServiceServers,
-            parseServiceClients,
-            loggerFactory,
-            logger);
     }
+}
 
-    /// <summary>
+if (args.Contains("--parse_service_clients"))
-    ///     Use LibCpp2IL backend to directly load Il2Cpp compiled game assembly. EXPERIMENTAL.
+{
-    /// </summary>
+    logger.LogInformation("Parsing Protobuf service client types...");
-    /// <param name="gameAssembly">The path to the game assembly DLL.</param>
+    foreach (ICilType service in GetProtobufServiceClientTypes())
-    /// <param name="globalMetadata">The path to the global-metadata.dat file.</param>
-    /// <param name="unityVersion">The version of Unity which was used to create the metadata file or alternatively, the path to the globalgamemanagers or the data.unity3d file.</param>
-    /// <param name="outPath">An existing directory to output into individual files, otherwise output to a single file.</param>
-    /// <param name="logLevel">Logging severity level.</param>
-    /// <param name="parseServiceServers">Parses gRPC service definitions from server classes.</param>
-    /// <param name="parseServiceClients">Parses gRPC service definitions from client classes.</param>
-    /// <param name="skipEnums">Skip parsing enums and replace references to them with int32.</param>
-    /// <param name="includePropertiesWithoutNonUserCodeAttribute">Includes properties that aren't decorated with `DebuggerNonUserCode` when parsing.</param>
-    /// <param name="includeServiceMethodsWithoutGeneratedCodeAttribute">Includes methods that aren't decorated with `GeneratedCode("grpc_csharp_plugin")` when parsing gRPC services.</param>
-    [Command("il2cpp")]
-    public void Il2Cpp(
-        [Argument] string gameAssembly,
-        [Argument] string globalMetadata,
-        [Argument] string unityVersion,
-        [Argument] string outPath,
-        bool              skipEnums,
-        bool              includePropertiesWithoutNonUserCodeAttribute,
-        bool              includeServiceMethodsWithoutGeneratedCodeAttribute,
-        bool              parseServiceServers,
-        bool              parseServiceClients,
-        LogLevel          logLevel = LogLevel.Information)
     {
-        if (!UnityVersion.TryParse(unityVersion, out UnityVersion unityVer, out _))
+        ctx.ParseService(service, options);
-        {
-            unityVer = unityVersion.EndsWith("globalgamemanagers")
-                ? LibCpp2IlMain.GetVersionFromGlobalGameManagers(
-                    File.ReadAllBytes(unityVersion))
-                : LibCpp2IlMain.GetVersionFromDataUnity3D(
-                    File.OpenRead(unityVersion));
-        }
-
-        using ILoggerFactory loggerFactory = CreateLoggerFactory(logLevel);
-        ILogger logger = CreateProtodecLogger(loggerFactory);
-
-        logger.LogInformation("Loading target assemblies...");
-        Il2CppAssemblyLoader loader = new(gameAssembly, globalMetadata, unityVer, loggerFactory);
-
-        Handle(
-            loader,
-            outPath,
-            skipEnums,
-            includePropertiesWithoutNonUserCodeAttribute,
-            includeServiceMethodsWithoutGeneratedCodeAttribute,
-            parseServiceServers,
-            parseServiceClients,
-            loggerFactory,
-            logger);
     }
+}
 
-    private static void Handle(
+if (Directory.Exists(outPath))
-        CilAssemblyLoader loader,
+{
-        string            outPath,
+    logger.LogInformation("Writing {count} Protobuf files to \"{path}\"...", ctx.Protobufs.Count, outPath);
-        bool              skipEnums,
+
-        bool              includePropertiesWithoutNonUserCodeAttribute,
+    HashSet<string> writtenFiles = [];
-        bool              includeServiceMethodsWithoutGeneratedCodeAttribute,
+    foreach (Protobuf protobuf in ctx.Protobufs)
-        bool              parseServiceServers,
-        bool              parseServiceClients,
-        ILoggerFactory    loggerFactory,
-        ILogger           logger)
     {
-        ParserOptions options = ParserOptions.None;
+        // This workaround stops files from being overwritten in the case of a naming conflict,
-        if (skipEnums)
+        // however the actual conflict will still have to be resolved manually
-            options |= ParserOptions.SkipEnums;
+        string fileName = protobuf.FileName;
-        if (includePropertiesWithoutNonUserCodeAttribute)
+        while (!writtenFiles.Add(fileName))
-            options |= ParserOptions.IncludePropertiesWithoutNonUserCodeAttribute;
-        if (includeServiceMethodsWithoutGeneratedCodeAttribute)
-            options |= ParserOptions.IncludeServiceMethodsWithoutGeneratedCodeAttribute;
-
-        ProtodecContext ctx = new()
         {
-            Logger = loggerFactory.CreateLogger<ProtodecContext>()
+            fileName = '_' + fileName;
-        };
-
-        logger.LogInformation("Parsing Protobuf message types...");
-        foreach (ICilType message in loader.GetProtobufMessageTypes())
-        {
-            ctx.ParseMessage(message, options);
         }
 
-        if (parseServiceServers)
+        string protobufPath = Path.Join(outPath, fileName);
-        {
-            logger.LogInformation("Parsing Protobuf service server types...");
-            foreach (ICilType service in loader.GetProtobufServiceServerTypes())
-            {
-                ctx.ParseService(service, options);
-            }
-        }
 
-        if (parseServiceClients)
+        using StreamWriter       streamWriter = new(protobufPath);
-        {
+        using IndentedTextWriter indentWriter = new(streamWriter, indent);
-            logger.LogInformation("Parsing Protobuf service client types...");
-            foreach (ICilType service in loader.GetProtobufServiceClientTypes())
-            {
-                ctx.ParseService(service, options);
-            }
-        }
 
-        const string indent = "  ";
+        protobuf.WriteTo(indentWriter);
-        if (Directory.Exists(outPath))
-        {
-            logger.LogInformation("Writing {count} Protobuf files to \"{path}\"...", ctx.Protobufs.Count, outPath);
-
-            HashSet<string> writtenFiles = [];
-            foreach (Protobuf protobuf in ctx.Protobufs)
-            {
-                // This workaround stops files from being overwritten in the case of a naming conflict,
-                // however the actual conflict will still have to be resolved manually
-                string fileName = protobuf.FileName;
-                while (!writtenFiles.Add(fileName))
-                {
-                    fileName = '_' + fileName;
-                }
-
-                string protobufPath = Path.Join(outPath, fileName);
-
-                using StreamWriter       streamWriter = new(protobufPath);
-                using IndentedTextWriter indentWriter = new(streamWriter, indent);
-
-                protobuf.WriteTo(indentWriter);
-            }
-        }
-        else
-        {
-            logger.LogInformation("Writing Protobufs as a single file to \"{path}\"...", outPath);
-
-            using StreamWriter       streamWriter = new(outPath);
-            using IndentedTextWriter indentWriter = new(streamWriter, indent);
-
-            ctx.WriteAllTo(indentWriter);
-        }
     }
+}
+else
+{
+    logger.LogInformation("Writing Protobufs as a single file to \"{path}\"...", outPath);
 
-    private static ILoggerFactory CreateLoggerFactory(LogLevel logLevel) =>
+    using StreamWriter       streamWriter = new(outPath);
-        LoggerFactory.Create(
+    using IndentedTextWriter indentWriter = new(streamWriter, indent);
-            builder => builder.AddSimpleConsole(static console => console.IncludeScopes = true)
-                              .SetMinimumLevel(logLevel));
 
-    private static ILogger CreateProtodecLogger(ILoggerFactory loggerFactory)
+    ctx.WriteAllTo(indentWriter);
-    {
+}
-        ILogger logger = loggerFactory.CreateLogger("protodec");
-        ConsoleApp.LogError = msg => logger.LogError(msg);
 
-        return logger;
+IEnumerable<ICilType> GetProtobufMessageTypes() =>
-    }
+    loader.LoadedTypes.Where(
-}
+        type => type is { IsNested: false, IsSealed: true }
+             && type.Namespace?.StartsWith("Google.Protobuf", StringComparison.Ordinal) != true
+             && type.IsAssignableTo(loader.IMessage));
+
+IEnumerable<ICilType> GetProtobufServiceClientTypes() =>
+    loader.LoadedTypes.Where(
+        type => type is { IsNested: true, IsAbstract: false }
+             && type.IsAssignableTo(loader.ClientBase));
+
+IEnumerable<ICilType> GetProtobufServiceServerTypes() =>
+    loader.LoadedTypes.Where(
+        type => type is { IsNested: true, IsAbstract: true, DeclaringType: { IsNested: false, IsSealed: true, IsAbstract: true } }
+             && type.CustomAttributes.Any(attribute => attribute.Type == loader.BindServiceMethodAttribute));

src/protodec/protodec.csproj

@@ -12,8 +12,7 @@
 
   <ItemGroup>
     <ProjectReference Include="$(SolutionDir)src\LibProtodec\LibProtodec.csproj" />
-    <PackageReference Include="ConsoleAppFramework" Version="5.2.2" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="9.0.0-preview.5.24306.7" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="9.0.0-preview.6.24327.7" />
   </ItemGroup>
 
 </Project>