Support for type ref and asm ref (#9)

Add support for TypeReferences and Assembly References

Author: tlakollo

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

@@ -23,7 +23,7 @@ public TokenBasedNode GetNodeForToken(EcmaModule module, EntityHandle handle)
             switch (handle.Kind)
             {
                 case HandleKind.TypeReference:
-                    throw new NotImplementedException();
+                    return TypeReference(module, (TypeReferenceHandle)handle);
                 case HandleKind.TypeDefinition:
                     return TypeDefinition(module, (TypeDefinitionHandle)handle);
                 case HandleKind.FieldDefinition:
@@ -55,7 +55,7 @@ public TokenBasedNode GetNodeForToken(EcmaModule module, EntityHandle handle)
                 case HandleKind.TypeSpecification:
                     throw new NotImplementedException();
                 case HandleKind.AssemblyReference:
-                    throw new NotImplementedException();
+                    return AssemblyReference(module, (AssemblyReferenceHandle)handle);
                 case HandleKind.AssemblyFile:
                     throw new NotImplementedException();
                 case HandleKind.ExportedType:
@@ -73,6 +73,14 @@ public TokenBasedNode GetNodeForToken(EcmaModule module, EntityHandle handle)
             }
         }
 
+        NodeCache<HandleKey<TypeReferenceHandle>, TypeReferenceNode> _typeReferences
+            = new NodeCache<HandleKey<TypeReferenceHandle>, TypeReferenceNode>(key
+                => new TypeReferenceNode(key.Module, key.Handle));
+        public TypeReferenceNode TypeReference(EcmaModule module, TypeReferenceHandle handle)
+        {
+            return _typeReferences.GetOrAdd(new HandleKey<TypeReferenceHandle>(module, handle));
+        }
+
         NodeCache<HandleKey<TypeDefinitionHandle>, TypeDefinitionNode> _typeDefinitions
             = new NodeCache<HandleKey<TypeDefinitionHandle>, TypeDefinitionNode>(key
                 => new TypeDefinitionNode(key.Module, key.Handle));
@@ -129,6 +137,14 @@ public AssemblyDefinitionNode AssemblyDefinition(EcmaModule module)
             return _assemblyDefinitions.GetOrAdd(module);
         }
 
+        NodeCache<HandleKey<AssemblyReferenceHandle>, AssemblyReferenceNode> _assemblyReferences
+            = new NodeCache<HandleKey<AssemblyReferenceHandle>, AssemblyReferenceNode>(key
+                => new AssemblyReferenceNode(key.Module, key.Handle));
+        public AssemblyReferenceNode AssemblyReference(EcmaModule module, AssemblyReferenceHandle handle)
+        {
+            return _assemblyReferences.GetOrAdd(new HandleKey<AssemblyReferenceHandle>(module, handle));
+        }
+
         private struct HandleKey<T> : IEquatable<HandleKey<T>> where T : struct, IEquatable<T>
         {
             public readonly EcmaModule Module;

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

@@ -0,0 +1,48 @@
+// 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;
+using System.Reflection.Metadata.Ecma335;
+
+namespace ILTrim.DependencyAnalysis
+{
+    /// <summary>
+    /// Represents an entry in the Assembly Reference metadata table.
+    /// </summary>
+    public sealed class AssemblyReferenceNode : TokenBasedNode
+    {
+        public AssemblyReferenceNode(EcmaModule module, AssemblyReferenceHandle handle)
+            : base(module, handle)
+        {
+        }
+
+        private AssemblyReferenceHandle Handle => (AssemblyReferenceHandle)_handle;
+
+        public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
+        {
+            yield break;
+        }
+
+        protected override EntityHandle WriteInternal(ModuleWritingContext writeContext)
+        {
+            MetadataReader reader = _module.MetadataReader;
+            AssemblyReference assemblyRef = reader.GetAssemblyReference(Handle);
+
+            var builder = writeContext.MetadataBuilder;
+
+            return builder.AddAssemblyReference(builder.GetOrAddString(reader.GetString(assemblyRef.Name)),
+                assemblyRef.Version,
+                builder.GetOrAddString(reader.GetString(assemblyRef.Culture)),
+                builder.GetOrAddBlob(reader.GetBlobBytes(assemblyRef.PublicKeyOrToken)),
+                assemblyRef.Flags,
+                builder.GetOrAddBlob(reader.GetBlobBytes(assemblyRef.HashValue)));
+        }
+
+        public override string ToString()
+        {
+            MetadataReader reader = _module.MetadataReader;
+            return reader.GetString(reader.GetAssemblyReference(Handle).Name);
+        }
+    }
+}

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

@@ -47,7 +47,7 @@ protected override EntityHandle WriteInternal(ModuleWritingContext writeContext)
             return builder.AddTypeDefinition(typeDef.Attributes,
                 builder.GetOrAddString(reader.GetString(typeDef.Namespace)),
                 builder.GetOrAddString(reader.GetString(typeDef.Name)),
-                (TypeDefinitionHandle)writeContext.TokenMap.MapToken(typeDef.BaseType),
+                writeContext.TokenMap.MapToken(typeDef.BaseType),
                 writeContext.TokenMap.MapTypeFieldList(Handle),
                 writeContext.TokenMap.MapTypeMethodList(Handle));
         }

src/coreclr/tools/ILTrim/DependencyAnalysis/TokenBased/TypeReferenceNode.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;
+using System.Reflection.Metadata.Ecma335;
+
+using Debug = System.Diagnostics.Debug;
+
+namespace ILTrim.DependencyAnalysis
+{
+    /// <summary>
+    /// Represents an entry in the Type Reference metadata table.
+    /// </summary>
+    public sealed class TypeReferenceNode : TokenBasedNode
+    {
+        public TypeReferenceNode(EcmaModule module, TypeReferenceHandle handle)
+            : base(module, handle)
+        {
+        }
+
+        private TypeReferenceHandle Handle => (TypeReferenceHandle)_handle;
+
+        public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)
+        {
+            TypeReference typeRef = _module.MetadataReader.GetTypeReference(Handle);
+
+            yield return new(factory.GetNodeForToken(_module, typeRef.ResolutionScope), "Resolution Scope of a type reference");
+        }
+
+        protected override EntityHandle WriteInternal(ModuleWritingContext writeContext)
+        {
+            MetadataReader reader = _module.MetadataReader;
+            TypeReference typeRef = reader.GetTypeReference(Handle);
+
+            var builder = writeContext.MetadataBuilder;
+
+            return builder.AddTypeReference(writeContext.TokenMap.MapToken(typeRef.ResolutionScope),
+                builder.GetOrAddString(reader.GetString(typeRef.Namespace)),
+                builder.GetOrAddString(reader.GetString(typeRef.Name)));
+        }
+
+        public override string ToString()
+        {
+            MetadataReader reader = _module.MetadataReader;
+            return reader.GetString(reader.GetTypeReference(Handle).Name);
+        }
+    }
+}