Make cdac APIs public but experimental (dotnet#111180)

Author: jkoritzinsky

src/native/managed/cdacreader/Directory.Build.props

@@ -0,0 +1,8 @@
+<Project>
+    <Import Project="..\Directory.Build.props" />
+    <ItemGroup>
+      <AssemblyAttribute Include="System.Diagnostics.CodeAnalysis.ExperimentalAttribute">
+        <_Parameter1>NETCDAC0001</_Parameter1>
+      </AssemblyAttribute>
+    </ItemGroup>
+</Project>

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/ContractRegistry.cs

@@ -9,7 +9,7 @@ namespace Microsoft.Diagnostics.DataContractReader;
 /// <summary>
 /// A registry of all the contracts that may be provided by a target.
 /// </summary>
-internal abstract class ContractRegistry
+public abstract class ContractRegistry
 {
     /// <summary>
     /// Gets an instance of the Exception contract for the target.

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/Extensions/ICodeVersionsExtensions.cs

@@ -3,9 +3,9 @@
 
 namespace Microsoft.Diagnostics.DataContractReader.Contracts.Extensions;
 
-internal static class ICodeVersionsExtensions
+public static class ICodeVersionsExtensions
 {
-    internal static NativeCodeVersionHandle GetActiveNativeCodeVersion(this ICodeVersions cv, TargetPointer methodDesc)
+    public static NativeCodeVersionHandle GetActiveNativeCodeVersion(this ICodeVersions cv, TargetPointer methodDesc)
     {
         ILCodeVersionHandle ilCodeVersionHandle = cv.GetActiveILCodeVersion(methodDesc);
         return cv.GetActiveNativeCodeVersionForILCodeVersion(methodDesc, ilCodeVersionHandle);

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/Extensions/IReJITExtensions.cs

@@ -5,7 +5,7 @@
 
 namespace Microsoft.Diagnostics.DataContractReader.Contracts.Extensions;
 
-internal static class IReJITExtensions
+public static class IReJITExtensions
 {
     public static IEnumerable<TargetNUInt> GetRejitIds(this IReJIT rejit, Target target, TargetPointer methodDesc)
     {

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/ICodeVersions.cs

@@ -6,7 +6,7 @@
 
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
-internal interface ICodeVersions : IContract
+public interface ICodeVersions : IContract
 {
     static string IContract.Name { get; } = nameof(CodeVersions);
 
@@ -27,11 +27,12 @@ internal interface ICodeVersions : IContract
     public virtual bool CodeVersionManagerSupportsMethod(TargetPointer methodDesc) => throw new NotImplementedException();
 }
 
-internal readonly struct ILCodeVersionHandle
+public readonly struct ILCodeVersionHandle
 {
-    internal readonly TargetPointer Module;
-    internal readonly uint MethodDefinition;
-    internal readonly TargetPointer ILCodeVersionNode;
+    // TODO-Layering: These members should be accessible only to contract implementations.
+    public readonly TargetPointer Module;
+    public readonly uint MethodDefinition;
+    public readonly TargetPointer ILCodeVersionNode;
     private ILCodeVersionHandle(TargetPointer module, uint methodDef, TargetPointer ilCodeVersionNodeAddress)
     {
         if (module != TargetPointer.Null && ilCodeVersionNodeAddress != TargetPointer.Null)
@@ -49,23 +50,24 @@ private ILCodeVersionHandle(TargetPointer module, uint methodDef, TargetPointer
     }
 
     // for more information on Explicit/Synthetic code versions see docs/design/features/code-versioning.md
-    internal static ILCodeVersionHandle CreateExplicit(TargetPointer ilCodeVersionNodeAddress) =>
+    public static ILCodeVersionHandle CreateExplicit(TargetPointer ilCodeVersionNodeAddress) =>
         new ILCodeVersionHandle(TargetPointer.Null, 0, ilCodeVersionNodeAddress);
-    internal static ILCodeVersionHandle CreateSynthetic(TargetPointer module, uint methodDef) =>
+    public static ILCodeVersionHandle CreateSynthetic(TargetPointer module, uint methodDef) =>
         new ILCodeVersionHandle(module, methodDef, TargetPointer.Null);
 
     public static ILCodeVersionHandle Invalid { get; } = new(TargetPointer.Null, 0, TargetPointer.Null);
 
     public bool IsValid => Module != TargetPointer.Null || ILCodeVersionNode != TargetPointer.Null;
 
-    internal bool IsExplicit => ILCodeVersionNode != TargetPointer.Null;
+    public bool IsExplicit => ILCodeVersionNode != TargetPointer.Null;
 }
 
-internal readonly struct NativeCodeVersionHandle
+public readonly struct NativeCodeVersionHandle
 {
     // no public constructors
-    internal readonly TargetPointer MethodDescAddress;
-    internal readonly TargetPointer CodeVersionNodeAddress;
+    // TODO-Layering: These members should be accessible only to contract implementations.
+    public readonly TargetPointer MethodDescAddress;
+    public readonly TargetPointer CodeVersionNodeAddress;
     private NativeCodeVersionHandle(TargetPointer methodDescAddress, TargetPointer codeVersionNodeAddress)
     {
         if (methodDescAddress != TargetPointer.Null && codeVersionNodeAddress != TargetPointer.Null)
@@ -77,19 +79,19 @@ private NativeCodeVersionHandle(TargetPointer methodDescAddress, TargetPointer c
     }
 
     // for more information on Explicit/Synthetic code versions see docs/design/features/code-versioning.md
-    internal static NativeCodeVersionHandle CreateExplicit(TargetPointer codeVersionNodeAddress) =>
+    public static NativeCodeVersionHandle CreateExplicit(TargetPointer codeVersionNodeAddress) =>
         new NativeCodeVersionHandle(TargetPointer.Null, codeVersionNodeAddress);
-    internal static NativeCodeVersionHandle CreateSynthetic(TargetPointer methodDescAddress) =>
+    public static NativeCodeVersionHandle CreateSynthetic(TargetPointer methodDescAddress) =>
         new NativeCodeVersionHandle(methodDescAddress, TargetPointer.Null);
 
     public static NativeCodeVersionHandle Invalid { get; } = new(TargetPointer.Null, TargetPointer.Null);
 
     public bool Valid => MethodDescAddress != TargetPointer.Null || CodeVersionNodeAddress != TargetPointer.Null;
 
-    internal bool IsExplicit => CodeVersionNodeAddress != TargetPointer.Null;
+    public bool IsExplicit => CodeVersionNodeAddress != TargetPointer.Null;
 }
 
-internal readonly struct CodeVersions : ICodeVersions
+public readonly struct CodeVersions : ICodeVersions
 {
     // throws NotImplementedException for all methods
 }

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IContract.cs

@@ -5,7 +5,7 @@
 
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
-internal interface IContract
+public interface IContract
 {
     static virtual string Name => throw new NotImplementedException();
 }

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IDacStreams.cs

@@ -5,13 +5,13 @@
 
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
-internal interface IDacStreams : IContract
+public interface IDacStreams : IContract
 {
     static string IContract.Name { get; } = nameof(DacStreams);
     public virtual string? StringFromEEAddress(TargetPointer address) => throw new NotImplementedException();
 }
 
-internal readonly struct DacStreams : IDacStreams
+public readonly struct DacStreams : IDacStreams
 {
     // Everything throws NotImplementedException
 }

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IEcmaMetadata.cs

@@ -6,14 +6,14 @@
 
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
-internal interface IEcmaMetadata : IContract
+public interface IEcmaMetadata : IContract
 {
     static string IContract.Name { get; } = nameof(EcmaMetadata);
     public virtual TargetSpan GetReadOnlyMetadataAddress(ModuleHandle handle) => throw new NotImplementedException();
     public virtual MetadataReader? GetMetadata(ModuleHandle module) => throw new NotImplementedException();
 }
 
-internal readonly struct EcmaMetadata : IEcmaMetadata
+public readonly struct EcmaMetadata : IEcmaMetadata
 {
     // Everything throws NotImplementedException
 }

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IException.cs

@@ -5,7 +5,7 @@
 
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
-internal record struct ExceptionData(
+public record struct ExceptionData(
     TargetPointer Message,
     TargetPointer InnerException,
     TargetPointer StackTrace,
@@ -15,15 +15,15 @@ internal record struct ExceptionData(
     int HResult,
     int XCode);
 
-internal interface IException : IContract
+public interface IException : IContract
 {
     static string IContract.Name { get; } = nameof(Exception);
 
     public virtual TargetPointer GetNestedExceptionInfo(TargetPointer exception, out TargetPointer nextNestedException) => throw new NotImplementedException();
     public virtual ExceptionData GetExceptionData(TargetPointer managedException) => throw new NotImplementedException();
 }
 
-internal readonly struct Exception : IException
+public readonly struct Exception : IException
 {
     // Everything throws NotImplementedException
 }

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IExecutionManager.cs

@@ -5,21 +5,22 @@
 
 namespace Microsoft.Diagnostics.DataContractReader.Contracts;
 
-internal struct CodeBlockHandle
+public struct CodeBlockHandle
 {
+    // TODO-Layering: These members should be accessible only to contract implementations.
     public readonly TargetPointer Address;
-    internal CodeBlockHandle(TargetPointer address) => Address = address;
+    public CodeBlockHandle(TargetPointer address) => Address = address;
 }
 
-internal interface IExecutionManager : IContract
+public interface IExecutionManager : IContract
 {
     static string IContract.Name { get; } = nameof(ExecutionManager);
     CodeBlockHandle? GetCodeBlockHandle(TargetCodePointer ip) => throw new NotImplementedException();
     TargetPointer GetMethodDesc(CodeBlockHandle codeInfoHandle) => throw new NotImplementedException();
     TargetCodePointer GetStartAddress(CodeBlockHandle codeInfoHandle) => throw new NotImplementedException();
 }
 
-internal readonly struct ExecutionManager : IExecutionManager
+public readonly struct ExecutionManager : IExecutionManager
 {
 
 }