Add TypeFlags for signature variables (#1559)

This makes signature variables easier to handle in various double
dispatch scenarios.

1 files changed, 48 insertions, 49 deletions

diff --git a/src/ILCompiler.MetadataTransform/src/ILCompiler/Metadata/Transform.Type.cs b/src/ILCompiler.MetadataTransform/src/ILCompiler/Metadata/Transform.Type.cs
index 60ae0e148..5c094dc67 100644
--- a/src/ILCompiler.MetadataTransform/src/ILCompiler/Metadata/Transform.Type.cs
+++ b/src/ILCompiler.MetadataTransform/src/ILCompiler/Metadata/Transform.Type.cs
@@ -25,7 +25,7 @@ namespace ILCompiler.Metadata
         private Action<Cts.ArrayType, TypeSpecification> _initArray;
         private Action<Cts.ByRefType, TypeSpecification> _initByRef;
         private Action<Cts.PointerType, TypeSpecification> _initPointer;
-        private Action<Cts.InstantiatedType, TypeSpecification> _initTypeInst;
+        private Action<Cts.TypeDesc, TypeSpecification> _initTypeInst;
         private Action<Cts.SignatureTypeVariable, TypeSpecification> _initTypeVar;
         private Action<Cts.SignatureMethodVariable, TypeSpecification> _initMethodVar;
 
@@ -39,54 +39,53 @@ namespace ILCompiler.Metadata
                 return rec;
             }
 
-            if (type.IsSzArray)
-            {
-                var arrayType = (Cts.ArrayType)type;
-                rec = _types.Create(arrayType, _initSzArray ?? (_initSzArray = InitializeSzArray));
-            }
-            else if (type.IsArray)
-            {
-                var arrayType = (Cts.ArrayType)type;
-                rec = _types.Create(arrayType, _initArray ?? (_initArray = InitializeArray));
-            }
-            else if (type.IsByRef)
-            {
-                var byRefType = (Cts.ByRefType)type;
-                rec = _types.Create(byRefType, _initByRef ?? (_initByRef = InitializeByRef));
-            }
-            else if (type.IsPointer)
-            {
-                var pointerType = (Cts.PointerType)type;
-                rec = _types.Create(pointerType, _initPointer ?? (_initPointer = InitializePointer));
-            }
-            else if (type is Cts.SignatureTypeVariable)
-            {
-                var variable = (Cts.SignatureTypeVariable)type;
-                rec = _types.Create(variable, _initTypeVar ?? (_initTypeVar = InitializeTypeVariable));
-            }
-            else if (type is Cts.SignatureMethodVariable)
-            {
-                var variable = (Cts.SignatureMethodVariable)type;
-                rec = _types.Create(variable, _initMethodVar ?? (_initMethodVar = InitializeMethodVariable));
-            }
-            else if (type is Cts.InstantiatedType)
-            {
-                var instType = (Cts.InstantiatedType)type;
-                rec = _types.Create(instType, _initTypeInst ?? (_initTypeInst = InitializeTypeInstance));
-            }
-            else
-            {
-                var metadataType = (Cts.MetadataType)type;
-                if (_policy.GeneratesMetadata(metadataType))
-                {
-                    rec = _types.Create(metadataType, _initTypeDef ?? (_initTypeDef = InitializeTypeDef));
-                }
-                else
-                {
-                    rec = _types.Create(metadataType, _initTypeRef ?? (_initTypeRef = InitializeTypeRef));
-                }
+            switch (type.Category)
+            {
+                case Cts.TypeFlags.SzArray:
+                    rec = _types.Create((Cts.ArrayType)type, _initSzArray ?? (_initSzArray = InitializeSzArray));
+                    break;
+                case Cts.TypeFlags.Array:
+                    rec = _types.Create((Cts.ArrayType)type, _initArray ?? (_initArray = InitializeArray));
+                    break;
+                case Cts.TypeFlags.ByRef:
+                    rec = _types.Create((Cts.ByRefType)type, _initByRef ?? (_initByRef = InitializeByRef));
+                    break;
+                case Cts.TypeFlags.Pointer:
+                    rec = _types.Create((Cts.PointerType)type, _initPointer ?? (_initPointer = InitializePointer));
+                    break;
+                case Cts.TypeFlags.SignatureTypeVariable:
+                    rec = _types.Create((Cts.SignatureTypeVariable)type, _initTypeVar ?? (_initTypeVar = InitializeTypeVariable));
+                    break;
+                case Cts.TypeFlags.SignatureMethodVariable:
+                    rec = _types.Create((Cts.SignatureMethodVariable)type, _initMethodVar ?? (_initMethodVar = InitializeMethodVariable));
+                    break;
+                default:
+                    {
+                        Debug.Assert(type.IsDefType);
+
+                        if (!type.IsTypeDefinition)
+                        {
+                            // Instantiated generic type
+                            rec = _types.Create(type, _initTypeInst ?? (_initTypeInst = InitializeTypeInstance));
+                        }
+                        else
+                        {
+                            // Type definition
+                            var metadataType = (Cts.MetadataType)type;
+                            if (_policy.GeneratesMetadata(metadataType))
+                            {
+                                rec = _types.Create(metadataType, _initTypeDef ?? (_initTypeDef = InitializeTypeDef));
+                            }
+                            else
+                            {
+                                rec = _types.Create(metadataType, _initTypeRef ?? (_initTypeRef = InitializeTypeRef));
+                            }
+                        }
+                    }
+                    break;
             }
-
+            
+ 
             Debug.Assert(rec is TypeDefinition || rec is TypeReference || rec is TypeSpecification);
 
             return rec;
@@ -143,7 +142,7 @@ namespace ILCompiler.Metadata
             };
         }
 
-        private void InitializeTypeInstance(Cts.InstantiatedType entity, TypeSpecification record)
+        private void InitializeTypeInstance(Cts.TypeDesc entity, TypeSpecification record)
         {
             var sig = new TypeInstantiationSignature
             {