Add support for GenericParameter and GenericParameterConstraint (#30)

Author: tlakollo

src/coreclr/tools/ILTrim/ILTrim.Tests.Cases/Basic/GenericParameters.cs

@@ -0,0 +1,21 @@
+using Mono.Linker.Tests.Cases.Expectations.Assertions;
+
+namespace Mono.Linker.Tests.Cases.Basic
+{
+    [Kept]
+	class GenericParameters
+	{
+        [Kept]
+        public static void Main()
+        {
+            // We will generate corrupted IL in the method body until we fix the signature parsing
+            //var t = typeof(A<>).ToString();
+        }
+        /*
+        [Kept]
+        class A<T>
+        {
+        }
+        */
+    }
+}

src/coreclr/tools/ILTrim/ILTrim/DependencyAnalysis/NodeFactory.cs

@@ -63,11 +63,11 @@ public TokenBasedNode GetNodeForToken(EcmaModule module, EntityHandle handle)
                 case HandleKind.ManifestResource:
                     throw new NotImplementedException();
                 case HandleKind.GenericParameter:
-                    throw new NotImplementedException();
+                    return GenericParameter(module, (GenericParameterHandle)handle);
                 case HandleKind.MethodSpecification:
                     return MethodSpecification(module, (MethodSpecificationHandle)handle);
                 case HandleKind.GenericParameterConstraint:
-                    throw new NotImplementedException();
+                    return GenericParameterConstraint(module, (GenericParameterConstraintHandle)handle);
                 default:
                     throw new NotImplementedException();
             }
@@ -193,6 +193,22 @@ public AssemblyReferenceNode AssemblyReference(EcmaModule module, AssemblyRefere
             return _assemblyReferences.GetOrAdd(new HandleKey<AssemblyReferenceHandle>(module, handle));
         }
 
+        NodeCache<HandleKey<GenericParameterHandle>, GenericParameterNode> _genericParameters
+           = new NodeCache<HandleKey<GenericParameterHandle>, GenericParameterNode>(key
+               => new GenericParameterNode(key.Module, key.Handle));
+        public GenericParameterNode GenericParameter(EcmaModule module, GenericParameterHandle handle)
+        {
+            return _genericParameters.GetOrAdd(new HandleKey<GenericParameterHandle>(module, handle));
+        }
+
+        NodeCache<HandleKey<GenericParameterConstraintHandle>, GenericParameterConstraintNode> _genericParameterConstraints
+           = new NodeCache<HandleKey<GenericParameterConstraintHandle>, GenericParameterConstraintNode>(key
+               => new GenericParameterConstraintNode(key.Module, key.Handle));
+        public GenericParameterConstraintNode GenericParameterConstraint(EcmaModule module, GenericParameterConstraintHandle handle)
+        {
+            return _genericParameterConstraints.GetOrAdd(new HandleKey<GenericParameterConstraintHandle>(module, handle));
+        }
+
         private struct HandleKey<T> : IEquatable<HandleKey<T>> where T : struct, IEquatable<T>
         {
             public readonly EcmaModule Module;

src/coreclr/tools/ILTrim/ILTrim/DependencyAnalysis/TokenBased/GenericParameterConstraintNode.cs

@@ -0,0 +1,45 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Reflection.Metadata;
+
+namespace ILTrim.DependencyAnalysis
+{
+    /// <summary>
+    /// Represents an entry in the GenericParamConstraint metadata table.
+    /// </summary>
+    public sealed class GenericParameterConstraintNode : TokenBasedNode
+    {
+        public GenericParameterConstraintNode(EcmaModule module, GenericParameterConstraintHandle handle)
+            : base(module, handle)
+        {
+        }
+
+        private GenericParameterConstraintHandle Handle => (GenericParameterConstraintHandle)_handle;
+
+        public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
+        {
+            GenericParameterConstraint genericParamConstraint = _module.MetadataReader.GetGenericParameterConstraint(Handle);
+            yield return new DependencyListEntry(factory.GetNodeForToken(_module, genericParamConstraint.Type), "Parameter constrained to type");
+        }
+
+        protected override EntityHandle WriteInternal(ModuleWritingContext writeContext)
+        {
+            MetadataReader reader = _module.MetadataReader;
+            GenericParameterConstraint genericParamConstraint = reader.GetGenericParameterConstraint(Handle);
+
+            var builder = writeContext.MetadataBuilder;
+
+            return builder.AddGenericParameterConstraint(
+                (GenericParameterHandle)writeContext.TokenMap.MapToken(genericParamConstraint.Parameter),
+                writeContext.TokenMap.MapToken(genericParamConstraint.Type));
+        }
+
+        public override string ToString()
+        {
+            // TODO: would be nice to have a common formatter we can call into
+            return "GenericParameterConstraint";
+        }
+    }
+}

src/coreclr/tools/ILTrim/ILTrim/DependencyAnalysis/TokenBased/GenericParameterNode.cs

@@ -0,0 +1,49 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Reflection.Metadata;
+
+namespace ILTrim.DependencyAnalysis
+{
+    /// <summary>
+    /// Represents an entry in the GenericParam metadata table.
+    /// </summary>
+    public sealed class GenericParameterNode : TokenBasedNode
+    {
+        public GenericParameterNode(EcmaModule module, GenericParameterHandle handle)
+            : base(module, handle)
+        {
+        }
+
+        private GenericParameterHandle Handle => (GenericParameterHandle)_handle;
+
+        public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
+        {
+            GenericParameter genericParam = _module.MetadataReader.GetGenericParameter(Handle);
+            foreach (var genericParamConstrain in genericParam.GetConstraints())
+            {
+                yield return new DependencyListEntry(factory.GenericParameterConstraint(_module, genericParamConstrain), "Generic Parameter Constraint of Generic Parameter");
+            }
+        }
+
+        protected override EntityHandle WriteInternal(ModuleWritingContext writeContext)
+        {
+            MetadataReader reader = _module.MetadataReader;
+            GenericParameter genericParam = reader.GetGenericParameter(Handle);
+
+            var builder = writeContext.MetadataBuilder;
+
+            return builder.AddGenericParameter(writeContext.TokenMap.MapToken(genericParam.Parent),
+                genericParam.Attributes,
+                builder.GetOrAddString(reader.GetString(genericParam.Name)),
+                genericParam.Index);
+        }
+
+        public override string ToString()
+        {
+            MetadataReader reader = _module.MetadataReader;
+            return reader.GetString(reader.GetGenericParameter(Handle).Name);
+        }
+    }
+}

src/coreclr/tools/ILTrim/ILTrim/DependencyAnalysis/TokenBased/TypeDefinitionNode.cs

@@ -28,6 +28,11 @@ public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFacto
                 yield return new(factory.GetNodeForToken(_module, typeDef.BaseType), "Base type of a type");
             }
 
+            foreach (var parameter in typeDef.GetGenericParameters())
+            {
+                yield return new(factory.GenericParameter(_module, parameter), "Generic parameter of type");
+            }
+
             foreach (CustomAttributeHandle customAttribute in typeDef.GetCustomAttributes())
             {
                 yield return new(factory.CustomAttribute(_module, customAttribute), "Custom attribute of a type");