From 5ebd616df5a736474590ac3fff1c8977d11104d7 Mon Sep 17 00:00:00 2001 From: slobber Date: Thu, 5 Nov 2026 13:00:00 +0800 Subject: [PATCH] fix(codegen): preserve enum members with framework refs MSBuild supplies Microsoft.NETCore.App.Ref reference assemblies for the target framework. Do not mix them with runtime framework assemblies, which prevents Roslyn from resolving enum constants and produces empty IDL enums. --- .../FrameworkReferenceEnumTests.cs | 92 +++++++++++++++++++ tools/CycloneDDS.CodeGen/SchemaDiscovery.cs | 26 ++++-- 2 files changed, 110 insertions(+), 8 deletions(-) create mode 100644 tests/CycloneDDS.CodeGen.Tests/FrameworkReferenceEnumTests.cs diff --git a/tests/CycloneDDS.CodeGen.Tests/FrameworkReferenceEnumTests.cs b/tests/CycloneDDS.CodeGen.Tests/FrameworkReferenceEnumTests.cs new file mode 100644 index 0000000..defe43b --- /dev/null +++ b/tests/CycloneDDS.CodeGen.Tests/FrameworkReferenceEnumTests.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using Xunit; + +namespace CycloneDDS.CodeGen.Tests; + +public sealed class FrameworkReferenceEnumTests : IDisposable +{ + private readonly string _sourceDir; + + public FrameworkReferenceEnumTests() + { + _sourceDir = Path.Combine(Path.GetTempPath(), "CG_FWREF_" + Guid.NewGuid().ToString("N")); + Directory.CreateDirectory(_sourceDir); + } + + public void Dispose() + { + try { Directory.Delete(_sourceDir, true); } catch { } + } + + [Fact] + public void DiscoverTopics_WithFrameworkReferenceAssemblies_PreservesEnumMembers() + { + File.WriteAllText( + Path.Combine(_sourceDir, "ValueTypeDiscriminator.cs"), + """ + namespace Repro + { + public enum ValueTypeDiscriminator : int + { + Empty_ = 0, + Object_ = 1, + Boolean_ = 2, + Int_ = 3, + UInt_ = 4, + Float_ = 5, + String_ = 6, + ByteArray_ = 7, + SingleArray_ = 8, + DoubleArray_ = 9, + Waveform_ = 10, + DateTime_ = 11, + } + } + """); + + var discovery = new SchemaDiscovery(); + var types = discovery.DiscoverTopics(_sourceDir, FindFrameworkReferenceAssemblies()); + var discriminator = Assert.Single(types, t => t.Name == "ValueTypeDiscriminator"); + + Assert.Equal( + new[] + { + "Empty_", "Object_", "Boolean_", "Int_", "UInt_", "Float_", + "String_", "ByteArray_", "SingleArray_", "DoubleArray_", "Waveform_", "DateTime_", + }, + discriminator.EnumMembers); + Assert.Equal(Enumerable.Range(0, 12).Select(i => (long)i), discriminator.EnumMemberValues); + } + + private static IReadOnlyList FindFrameworkReferenceAssemblies() + { + var runtimeDir = Path.GetDirectoryName(typeof(object).Assembly.Location) + ?? throw new InvalidOperationException("Cannot locate the .NET runtime directory."); + var dotnetRoot = Path.GetFullPath(Path.Combine(runtimeDir, "..", "..", "..")); + var targetingPacks = Path.Combine(dotnetRoot, "packs", "Microsoft.NETCore.App.Ref"); + + Assert.True(Directory.Exists(targetingPacks), + $"Expected framework reference assemblies under '{targetingPacks}'."); + + var referenceDir = Directory.EnumerateDirectories(targetingPacks) + .Select(versionDir => Path.Combine(versionDir, "ref")) + .Where(Directory.Exists) + .SelectMany(Directory.EnumerateDirectories) + .Where(dir => File.Exists(Path.Combine(dir, "System.Runtime.dll"))) + .OrderByDescending(dir => ParseFrameworkVersion(Path.GetFileName(dir))) + .First(); + + return Directory.GetFiles(referenceDir, "*.dll"); + } + + private static Version ParseFrameworkVersion(string directoryName) + { + var value = directoryName.StartsWith("net", StringComparison.Ordinal) + ? directoryName[3..] + : directoryName; + return Version.TryParse(value, out var version) ? version : new Version(); + } +} diff --git a/tools/CycloneDDS.CodeGen/SchemaDiscovery.cs b/tools/CycloneDDS.CodeGen/SchemaDiscovery.cs index 55ec75a..37b13e5 100644 --- a/tools/CycloneDDS.CodeGen/SchemaDiscovery.cs +++ b/tools/CycloneDDS.CodeGen/SchemaDiscovery.cs @@ -41,12 +41,22 @@ public List DiscoverTopics(string sourceDirectory, IEnumerable CSharpSyntaxTree.ParseText(File.ReadAllText(f), path: f)).ToList(); // 3. Create compilation + // MSBuild supplies reference assemblies for the target framework. Do not + // mix them with runtime assemblies (System.Private.CoreLib), because that + // prevents Roslyn from resolving enum member constants. + bool hasFrameworkRefs = referencePaths?.Any(p => + p.IndexOf("Microsoft.NETCore.App.Ref", StringComparison.OrdinalIgnoreCase) >= 0) ?? false; + var references = new List { - MetadataReference.CreateFromFile(typeof(object).Assembly.Location), MetadataReference.CreateFromFile(typeof(CycloneDDS.Schema.DdsTopicAttribute).Assembly.Location) }; + if (!hasFrameworkRefs) + { + references.Add(MetadataReference.CreateFromFile(typeof(object).Assembly.Location)); + } + if (referencePaths != null) { foreach (var refPath in referencePaths) @@ -58,15 +68,15 @@ public List DiscoverTopics(string sourceDirectory, IEnumerable } } - // Add System.Runtime for net8.0 if needed, but object might be enough for basic types - // If running on .NET Core, we might need more refs. - // For now, let's trust the environment or add basic refs. - var trustedAssemblies = AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") as string; - if (trustedAssemblies != null) + if (!hasFrameworkRefs) { - foreach (var path in trustedAssemblies.Split(Path.PathSeparator)) + var trustedAssemblies = AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") as string; + if (trustedAssemblies != null) { - references.Add(MetadataReference.CreateFromFile(path)); + foreach (var path in trustedAssemblies.Split(Path.PathSeparator)) + { + references.Add(MetadataReference.CreateFromFile(path)); + } } }