Merge pull request #10003 from michaelnebel/csharp/stubsenum

C#: Stub generator improvements.

Author: michaelnebel

csharp/ql/lib/semmle/code/csharp/Type.qll

@@ -882,37 +882,37 @@ private newtype TCallingConvention =
   MkCallingConvention(int i) { function_pointer_calling_conventions(_, i) }
 
 /**
- * Represents a signature calling convention. Specifies how arguments in a given
+ * A signature representing a calling convention. Specifies how arguments in a given
  * signature are passed from the caller to the callee.
  */
 class CallingConvention extends TCallingConvention {
   /** Gets a textual representation of this calling convention. */
   string toString() { result = "CallingConvention" }
 }
 
-/** Managed calling convention with fixed-length argument list. */
+/** A managed calling convention with fixed-length argument list. */
 class DefaultCallingConvention extends CallingConvention {
   DefaultCallingConvention() { this = MkCallingConvention(0) }
 
   override string toString() { result = "DefaultCallingConvention" }
 }
 
-/** Unmanaged C/C++-style calling convention where the call stack is cleaned by the caller. */
+/** An unmanaged C/C++-style calling convention where the call stack is cleaned by the caller. */
 class CDeclCallingConvention extends CallingConvention {
   CDeclCallingConvention() { this = MkCallingConvention(1) }
 
   override string toString() { result = "CDeclCallingConvention" }
 }
 
-/** Unmanaged calling convention where call stack is cleaned up by the callee. */
+/** An unmanaged calling convention where call stack is cleaned up by the callee. */
 class StdCallCallingConvention extends CallingConvention {
   StdCallCallingConvention() { this = MkCallingConvention(2) }
 
   override string toString() { result = "StdCallCallingConvention" }
 }
 
 /**
- * Unmanaged C++-style calling convention for calling instance member functions
+ * An unmanaged C++-style calling convention for calling instance member functions
  * with a fixed argument list.
  */
 class ThisCallCallingConvention extends CallingConvention {
@@ -921,20 +921,30 @@ class ThisCallCallingConvention extends CallingConvention {
   override string toString() { result = "ThisCallCallingConvention" }
 }
 
-/** Unmanaged calling convention where arguments are passed in registers when possible. */
+/** An unmanaged calling convention where arguments are passed in registers when possible. */
 class FastCallCallingConvention extends CallingConvention {
   FastCallCallingConvention() { this = MkCallingConvention(4) }
 
   override string toString() { result = "FastCallCallingConvention" }
 }
 
-/** Managed calling convention for passing extra arguments. */
+/** A managed calling convention for passing extra arguments. */
 class VarArgsCallingConvention extends CallingConvention {
   VarArgsCallingConvention() { this = MkCallingConvention(5) }
 
   override string toString() { result = "VarArgsCallingConvention" }
 }
 
+/**
+ * An unmanaged calling convention that indicates that the specifics
+ * are encoded as modopts.
+ */
+class UnmanagedCallingConvention extends CallingConvention {
+  UnmanagedCallingConvention() { this = MkCallingConvention(9) }
+
+  override string toString() { result = "UnmanagedCallingConvention" }
+}
+
 /**
  * A function pointer type, for example
  *

csharp/ql/src/Stubs/Stubs.qll

@@ -160,7 +160,7 @@ abstract private class GeneratedType extends Type, GeneratedElement {
 
   private string stubBaseTypesString() {
     if this instanceof Enum
-    then result = ""
+    then result = " : " + this.(Enum).getUnderlyingType().toStringWithTypes()
     else
       if exists(this.getAnInterestingBaseType())
       then
@@ -502,23 +502,48 @@ private string stubClassName(Type t) {
                       else
                         if t instanceof TupleType
                         then
-                          if t.(TupleType).getArity() < 2
-                          then result = stubClassName(t.(TupleType).getUnderlyingType())
-                          else
-                            result =
-                              "(" +
-                                concat(int i, Type element |
-                                  element = t.(TupleType).getElementType(i)
-                                |
-                                  stubClassName(element), "," order by i
-                                ) + ")"
+                          exists(TupleType tt | tt = t |
+                            if tt.getArity() < 2
+                            then result = stubClassName(tt.getUnderlyingType())
+                            else
+                              result =
+                                "(" +
+                                  concat(int i, Type element |
+                                    element = tt.getElementType(i)
+                                  |
+                                    stubClassName(element), "," order by i
+                                  ) + ")"
+                          )
                         else
-                          if t instanceof ValueOrRefType
+                          if t instanceof FunctionPointerType
                           then
-                            result =
-                              stubQualifiedNamePrefix(t) + t.getUndecoratedName() +
-                                stubGenericArguments(t)
-                          else result = "<error>"
+                            exists(
+                              FunctionPointerType fpt, CallingConvention callconvention,
+                              string calltext
+                            |
+                              fpt = t
+                            |
+                              callconvention = fpt.getCallingConvention() and
+                              (
+                                if callconvention instanceof UnmanagedCallingConvention
+                                then calltext = "unmanaged"
+                                else calltext = ""
+                              ) and
+                              result =
+                                "delegate* " + calltext + "<" +
+                                  concat(int i, Parameter p |
+                                    p = fpt.getParameter(i)
+                                  |
+                                    stubClassName(p.getType()) + "," order by i
+                                  ) + stubClassName(fpt.getReturnType()) + ">"
+                            )
+                          else
+                            if t instanceof ValueOrRefType
+                            then
+                              result =
+                                stubQualifiedNamePrefix(t) + t.getUndecoratedName() +
+                                  stubGenericArguments(t)
+                            else result = "<error>"
 }
 
 language[monotonicAggregates]
@@ -726,7 +751,7 @@ pragma[noinline]
 private string stubEnumConstant(EnumConstant ec, Assembly assembly) {
   ec instanceof GeneratedMember and
   ec.getALocation() = assembly and
-  result = "    " + escapeIfKeyword(ec.getName()) + ",\n"
+  result = "    " + escapeIfKeyword(ec.getName()) + " = " + ec.getValue() + ",\n"
 }
 
 pragma[noinline]

csharp/ql/test/library-tests/csharp9/FunctionPointer.expected

@@ -11,11 +11,11 @@ type
 | file://:0:0:0:0 | delegate* default<Void*,Int32*> | int* | DefaultCallingConvention |
 | file://:0:0:0:0 | delegate* default<Void*,Object> | object | DefaultCallingConvention |
 | file://:0:0:0:0 | delegate* stdcall<Int32 ref,Object out,T,Void> | Void | StdCallCallingConvention |
-| file://:0:0:0:0 | delegate* unmanaged<Char*,IntPtr,Void> | Void | CallingConvention |
-| file://:0:0:0:0 | delegate* unmanaged<Int32,PosixSignal,Int32> | int | CallingConvention |
-| file://:0:0:0:0 | delegate* unmanaged<IntPtr,Int32> | int | CallingConvention |
-| file://:0:0:0:0 | delegate* unmanaged<IntPtr,Void> | Void | CallingConvention |
-| file://:0:0:0:0 | delegate* unmanaged<Void> | Void | CallingConvention |
+| file://:0:0:0:0 | delegate* unmanaged<Char*,IntPtr,Void> | Void | UnmanagedCallingConvention |
+| file://:0:0:0:0 | delegate* unmanaged<Int32,PosixSignal,Int32> | int | UnmanagedCallingConvention |
+| file://:0:0:0:0 | delegate* unmanaged<IntPtr,Int32> | int | UnmanagedCallingConvention |
+| file://:0:0:0:0 | delegate* unmanaged<IntPtr,Void> | Void | UnmanagedCallingConvention |
+| file://:0:0:0:0 | delegate* unmanaged<Void> | Void | UnmanagedCallingConvention |
 unmanagedCallingConvention
 parameter
 | file://:0:0:0:0 | delegate* default<A,B> | 0 | file://:0:0:0:0 |  | A |