dtoh: Don't assert when handling complex and imaginary types (dlang#12068)

ibuclaw · MoonlightSentinel · web-flow · commit 8ffc8de3d0e2 · 2021-06-07T14:27:54.000+09:00
* dtoh: Don't assert when handling complex and imaginary types

* Fixup initial commit

Co-authored-by: MoonlightSentinel &lt;moonlightsentinel@disroot.org&gt;
diff --git a/changelog/dtoh-improvements.dd b/changelog/dtoh-improvements.dd
@@ -6,6 +6,7 @@ experimental C++ header generator:
 - Declarations from template mixins are emitted into the instantation context
 - (Superclass) methods aliases are emitted as `using ...` instead of `typedef ...`
 - Renamed imports are emitted as `using ...`
+- Complex types are emitted as `_Complex`.
 
 Note: The header generator is still considerer experimental, so please submit
       any bugs encountered to [the bug tracker](https://issues.dlang.org).
diff --git a/src/dmd/astcodegen.d b/src/dmd/astcodegen.d
@@ -57,6 +57,7 @@ struct ASTCodegen
     alias Tfloat80                  = dmd.mtype.Tfloat80;
     alias Tfunction                 = dmd.mtype.Tfunction;
     alias Tpointer                  = dmd.mtype.Tpointer;
+    alias Treference                = dmd.mtype.Treference;
     alias Tident                    = dmd.mtype.Tident;
     alias Tint8                     = dmd.mtype.Tint8;
     alias Tint16                    = dmd.mtype.Tint16;
@@ -71,6 +72,13 @@ struct ASTCodegen
     alias Tvoid                     = dmd.mtype.Tvoid;
     alias Twchar                    = dmd.mtype.Twchar;
 
+    alias Timaginary32              = dmd.mtype.Timaginary32;
+    alias Timaginary64              = dmd.mtype.Timaginary64;
+    alias Timaginary80              = dmd.mtype.Timaginary80;
+    alias Tcomplex32                = dmd.mtype.Tcomplex32;
+    alias Tcomplex64                = dmd.mtype.Tcomplex64;
+    alias Tcomplex80                = dmd.mtype.Tcomplex80;
+
     alias ParameterList             = dmd.mtype.ParameterList;
     alias VarArg                    = dmd.mtype.VarArg;
     alias STC                       = dmd.declaration.STC;
diff --git a/src/dmd/dtoh.d b/src/dmd/dtoh.d
@@ -518,6 +518,49 @@ public:
             buf.writeByte('_');
     }
 
+    /// Checks whether `t` is a type that can be exported to C++
+    private bool isSupportedType(AST.Type t)
+    {
+        if (!t)
+        {
+            assert(tdparent);
+            return true;
+        }
+
+        switch (t.ty)
+        {
+            // Nested types
+            case AST.Tarray:
+            case AST.Tsarray:
+            case AST.Tpointer:
+            case AST.Treference:
+            case AST.Tdelegate:
+                return isSupportedType((cast(AST.TypeNext) t).next);
+
+            // Function pointers
+            case AST.Tfunction:
+            {
+                auto tf = cast(AST.TypeFunction) t;
+                if (!isSupportedType(tf.next))
+                    return false;
+                foreach (_, param; tf.parameterList)
+                {
+                    if (!isSupportedType(param.type))
+                        return false;
+                }
+                return true;
+            }
+
+            // _Imaginary is C only.
+            case AST.Timaginary32:
+            case AST.Timaginary64:
+            case AST.Timaginary80:
+                return false;
+            default:
+                return true;
+        }
+    }
+
     override void visit(AST.Dsymbol s)
     {
         debug (Debug_DtoH)
@@ -680,20 +723,7 @@ public:
         if ((tf && tf.linkage != LINK.c && tf.linkage != LINK.cpp) || (!tf && fd.isPostBlitDeclaration()))
         {
             ignored("function %s because of linkage", fd.toPrettyChars());
-
-            // Virtual extern(D) functions require a dummy declaration to ensure proper
-            // vtable layout - but omit redundant declarations - the slot was already
-            // reserved  in the base class
-            if (fd.isVirtual() && fd.introducing)
-            {
-                // Hide placeholders because they are not ABI compatible
-                writeProtection(AST.Visibility.Kind.private_);
-
-                __gshared int counter; // Ensure unique names in all cases
-                buf.printf("virtual void __vtable_slot_%u();", counter++);
-                buf.writenl();
-            }
-            return;
+            return checkVirtualFunction(fd);
         }
         if (!adparent && !fd.fbody)
         {
@@ -705,6 +735,20 @@ public:
             ignored("function %s because it is private", fd.toPrettyChars());
             return;
         }
+        if (tf && !isSupportedType(tf.next))
+        {
+            ignored("function %s because its return type cannot be mapped to C++", fd.toPrettyChars());
+            return checkVirtualFunction(fd);
+        }
+        if (tf) foreach (i, fparam; tf.parameterList)
+        {
+            if (!isSupportedType(fparam.type))
+            {
+                ignored("function %s because one of its parameters has type `%s` which cannot be mapped to C++",
+                        fd.toPrettyChars(), fparam.type.toChars());
+                return checkVirtualFunction(fd);
+            }
+        }
 
         writeProtection(fd.visibility.kind);
 
@@ -773,6 +817,23 @@ public:
 
     }
 
+    /// Checks whether `fd` is a virtual function and emits a dummy declaration
+    /// if required to ensure proper vtable layout
+    private void checkVirtualFunction(AST.FuncDeclaration fd)
+    {
+        // Omit redundant declarations - the slot was already
+        // reserved in the base class
+        if (fd.isVirtual() && fd.introducing)
+        {
+            // Hide placeholders because they are not ABI compatible
+            writeProtection(AST.Visibility.Kind.private_);
+
+            __gshared int counter; // Ensure unique names in all cases
+            buf.printf("virtual void __vtable_slot_%u();", counter++);
+            buf.writenl();
+        }
+    }
+
     override void visit(AST.UnitTestDeclaration utd)
     {
         debug (Debug_DtoH)
@@ -870,6 +931,11 @@ public:
                 ignored("variable %s because of linkage", vd.toPrettyChars());
                 return;
             }
+            if (!isSupportedType(vd.type))
+            {
+                ignored("variable %s because its type cannot be mapped to C++", vd.toPrettyChars());
+                return;
+            }
             writeProtection(vd.visibility.kind);
             typeToBuffer(vd.type, vd, adparent && !(vd.storage_class & (AST.STC.static_ | AST.STC.gshared)));
             buf.writestringln(";");
@@ -889,6 +955,11 @@ public:
                 ignored("variable %s because of thread-local storage", vd.toPrettyChars());
                 return;
             }
+            if (!isSupportedType(vd.type))
+            {
+                ignored("variable %s because its type cannot be mapped to C++", vd.toPrettyChars());
+                return;
+            }
             writeProtection(vd.visibility.kind);
             if (vd.linkage == LINK.c)
                 buf.writestring("extern \"C\" ");
@@ -1761,6 +1832,20 @@ public:
                 typeName = "_d_real";
                 hasReal = true;
                 break;
+            case AST.Tcomplex32:  typeName = "_Complex float";  break;
+            case AST.Tcomplex64:  typeName = "_Complex double"; break;
+            case AST.Tcomplex80:
+                typeName = "_Complex _d_real";
+                hasReal = true;
+                break;
+            // ???: This is not strictly correct, but it should be ignored
+            // in all places where it matters most (variables, functions, ...).
+            case AST.Timaginary32: typeName = "float";  break;
+            case AST.Timaginary64: typeName = "double"; break;
+            case AST.Timaginary80:
+                typeName = "_d_real";
+                hasReal = true;
+                break;
             default:
                 //t.print();
                 assert(0);
diff --git a/test/compilable/dtoh_ignored.d b/test/compilable/dtoh_ignored.d
@@ -0,0 +1,145 @@
+/++
+REQUIRED_ARGS: -HC=verbose -c -o- -d
+PERMUTE_ARGS:
+TEST_OUTPUT:
+---
+// Automatically generated by Digital Mars D Compiler v2097
+
+#pragma once
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <math.h>
+
+#ifdef CUSTOM_D_ARRAY_TYPE
+#define _d_dynamicArray CUSTOM_D_ARRAY_TYPE
+#else
+/// Represents a D [] array
+template<typename T>
+struct _d_dynamicArray
+{
+    size_t length;
+    T *ptr;
+
+    _d_dynamicArray() : length(0), ptr(NULL) { }
+
+    _d_dynamicArray(size_t length_in, T *ptr_in)
+        : length(length_in), ptr(ptr_in) { }
+
+    T& operator[](const size_t idx) {
+        assert(idx < length);
+        return ptr[idx];
+    }
+
+    const T& operator[](const size_t idx) const {
+        assert(idx < length);
+        return ptr[idx];
+    }
+};
+#endif
+#if !defined(_d_real)
+# define _d_real long double
+#endif
+
+class WithImaginary
+{
+public:
+    float memberIf;
+    double memberId;
+    _d_real memberIr;
+    _Complex float memberCf;
+    _Complex double memberCd;
+    _Complex _d_real memberCr;
+    _d_dynamicArray< float > nested;
+    // Ignored function dtoh_ignored.WithImaginary.onReturn because its return type cannot be mapped to C++
+private:
+    virtual void __vtable_slot_0();
+    // Ignored function dtoh_ignored.WithImaginary.onParam because one of its parameters has type `ifloat` which cannot be mapped to C++
+    virtual void __vtable_slot_1();
+};
+
+template <typename T>
+struct WithImaginaryTemplate
+{
+    // Ignoring var member alignment 0
+    float member;
+    // Ignored function onReturn because its return type cannot be mapped to C++
+    // Ignored function onParam because one of its parameters has type `ifloat` which cannot be mapped to C++
+    // Ignoring var onVariable alignment 0
+    // Ignored variable onVariable because of linkage
+    WithImaginaryTemplate()
+    {
+    }
+};
+
+extern WithImaginaryTemplate<int32_t > instance;
+
+// Ignored variable dtoh_ignored.onVariable because its type cannot be mapped to C++
+// Ignored variable dtoh_ignored.onVariablePointer because its type cannot be mapped to C++
+// Ignored variable dtoh_ignored.onVariableSlice because its type cannot be mapped to C++
+// Ignored variable dtoh_ignored.onVariableArray because its type cannot be mapped to C++
+extern void* onVariableAssocArray;
+
+// Ignored variable dtoh_ignored.onVariableFunction because its type cannot be mapped to C++
+// Ignored variable dtoh_ignored.onVariableFunctionParam because its type cannot be mapped to C++
+// Ignored variable dtoh_ignored.onVariableDelegate because its type cannot be mapped to C++
+
+---
++/
+
+extern (C++):
+
+class WithImaginary
+{
+    ifloat memberIf;
+	idouble memberId;
+	ireal memberIr;
+
+	cfloat memberCf;
+	cdouble memberCd;
+	creal memberCr;
+
+    ifloat[] nested;
+
+    ifloat onReturn()
+    {
+        return 0i;
+    }
+
+    void onParam(ifloat) {}
+}
+
+struct WithImaginaryTemplate(T)
+{
+    ifloat member;
+
+    ifloat onReturn()
+    {
+        return 0i;
+    }
+
+    void onParam(ifloat)
+    {
+    }
+
+    __gshared ifloat onVariable;
+}
+
+__gshared WithImaginaryTemplate!int instance;
+
+__gshared ifloat onVariable;
+
+__gshared ifloat** onVariablePointer;
+
+__gshared ifloat[] onVariableSlice;
+
+__gshared ifloat[2] onVariableArray;
+
+__gshared ifloat[int] onVariableAssocArray;
+
+__gshared ifloat function() onVariableFunction;
+
+__gshared void function(ifloat) onVariableFunctionParam;
+
+__gshared ifloat delegate() onVariableDelegate;
diff --git a/test/compilable/dtoh_invalid_identifiers.d b/test/compilable/dtoh_invalid_identifiers.d
@@ -102,6 +102,19 @@ class Alias : public typename_
 };
 
 extern void user(Alias* i);
+
+template <typename typename_>
+struct InvalidNames
+{
+    // Ignoring var register alignment 0
+    typename_ register_;
+    void foo(typename_ and_);
+    InvalidNames()
+    {
+    }
+};
+
+extern void useInvalid(InvalidNames<int32_t > _param_0);
 ---
 +/
 #line 100
@@ -136,3 +149,12 @@ class Base {
 class Alias(typename) : typename {}
 
 void user(Alias!Base i) {}
+
+struct InvalidNames(typename)
+{
+    typename register;
+
+    void foo(typename and) {}
+}
+
+void useInvalid(InvalidNames!int) {}
