Merge pull request #4761 from tamasvajk/feature/cil-enum-underlying

C#: Extract enum underlying type from IL

Author: tamasvajk

csharp/change-notes/2020-12-08-cil-enum-underlying-type.md

@@ -0,0 +1,2 @@
+lgtm,codescanning
+* CIL extraction has been improved to store numeric underlying type of `enum` declarations.

csharp/extractor/Semmle.Extraction.CIL/Entities/TypeDefinitionType.cs

@@ -212,6 +212,15 @@ public override IEnumerable<IExtractionProduct> Contents
                     var @base = (Type)Cx.CreateGeneric(this, td.BaseType);
                     yield return @base;
                     yield return Tuples.cil_base_class(this, @base);
+
+                    if (IsSystemEnum(td.BaseType) &&
+                        GetUnderlyingEnumType() is var underlying &&
+                        underlying.HasValue)
+                    {
+                        var underlyingType = Cx.Create(underlying.Value);
+                        yield return underlyingType;
+                        yield return Tuples.cil_enum_underlying_type(this, underlyingType);
+                    }
                 }
 
                 foreach (var @interface in td.GetInterfaceImplementations().Select(i => Cx.MdReader.GetInterfaceImplementation(i)))
@@ -226,6 +235,59 @@ public override IEnumerable<IExtractionProduct> Contents
             }
         }
 
+        private bool IsSystemEnum(EntityHandle baseType)
+        {
+            return baseType.Kind switch
+            {
+                HandleKind.TypeReference => IsSystemEnum((TypeReferenceHandle)baseType),
+                HandleKind.TypeDefinition => IsSystemEnum((TypeDefinitionHandle)baseType),
+                _ => false,
+            };
+        }
+
+        private bool IsSystemEnum(TypeReferenceHandle baseType)
+        {
+            var baseTypeReference = Cx.MdReader.GetTypeReference(baseType);
+
+            return IsSystemEnum(baseTypeReference.Name, baseTypeReference.Namespace);
+        }
+
+        private bool IsSystemEnum(TypeDefinitionHandle baseType)
+        {
+            var baseTypeDefinition = Cx.MdReader.GetTypeDefinition(baseType);
+
+            return IsSystemEnum(baseTypeDefinition.Name, baseTypeDefinition.Namespace);
+        }
+
+        private bool IsSystemEnum(StringHandle typeName, StringHandle namespaceName)
+        {
+            return Cx.MdReader.StringComparer.Equals(typeName, "Enum") &&
+                !namespaceName.IsNil &&
+                Cx.MdReader.StringComparer.Equals(namespaceName, "System");
+        }
+
+        internal PrimitiveTypeCode? GetUnderlyingEnumType()
+        {
+            foreach (var handle in td.GetFields())
+            {
+                var field = Cx.MdReader.GetFieldDefinition(handle);
+                if (field.Attributes.HasFlag(FieldAttributes.Static))
+                {
+                    continue;
+                }
+
+                var blob = Cx.MdReader.GetBlobReader(field.Signature);
+                if (blob.ReadSignatureHeader().Kind != SignatureKind.Field)
+                {
+                    break;
+                }
+
+                return (PrimitiveTypeCode)blob.ReadByte();
+            }
+
+            return null;
+        }
+
         internal override Method LookupMethod(StringHandle name, BlobHandle signature)
         {
             foreach (var h in td.GetMethods())

csharp/extractor/Semmle.Extraction.CIL/Tuples.cs

@@ -32,6 +32,9 @@ internal static Tuple cil_array_type(ArrayType array, Type element, int rank) =>
         internal static Tuple cil_base_class(Type t, Type @base) =>
             new Tuple("cil_base_class", t, @base);
 
+        internal static Tuple cil_enum_underlying_type(Type t, PrimitiveType underlying) =>
+            new Tuple("cil_enum_underlying_type", t, underlying);
+
         internal static Tuple cil_base_interface(Type t, Type @base) =>
             new Tuple("cil_base_interface", t, @base);
 

csharp/ql/src/semmle/code/cil/Type.qll

@@ -79,7 +79,7 @@ class Type extends DotNet::Type, Declaration, TypeContainer, @cil_type {
   }
 
   /** Holds if this type is an `enum`. */
-  predicate isEnum() { this.getBaseClass*().isSystemType("Enum") }
+  predicate isEnum() { this.getBaseClass().isSystemType("Enum") }
 
   /** Holds if this type is public. */
   predicate isPublic() { cil_public(this) }

csharp/ql/src/semmle/code/cil/Types.qll

@@ -47,8 +47,12 @@ class ValueOrRefType extends DotNet::ValueOrRefType, Type, @cil_valueorreftype {
 class Enum extends ValueOrRefType {
   Enum() { this.isEnum() }
 
-  // Note that we don't actually use the proper internal representation yet.
-  override IntType getUnderlyingType() { any() }
+  override IntegralType getUnderlyingType() {
+    cil_enum_underlying_type(this, result)
+    or
+    not cil_enum_underlying_type(this, _) and
+    result instanceof IntType
+  }
 }
 
 /** A `class`. */

csharp/ql/src/semmlecode.csharp.dbscheme

@@ -1803,6 +1803,7 @@ cil_newslot(int id: @cil_method ref);
 
 cil_base_class(unique int id: @cil_type ref, int base: @cil_type ref);
 cil_base_interface(int id: @cil_type ref, int base: @cil_type ref);
+cil_enum_underlying_type(unique int id: @cil_type ref, int underlying: @cil_type ref);
 
 #keyset[unbound, index]
 cil_type_parameter(