Fix anonymous composites in clang 19.1.7

In some new clang versions, the name (cursor.spelling) of anonymous structs,
unions and enums was set to an informative message instead of an empty
string. I.e. "enum (unnamed at [declaration_file.h:48]"

This fixes the errors that happen due to that in a backwards compatible
way, since it still checks for empty spellings.

This patch is possibly overeager in checking the cursor.spellings for
these new special values, I haven't checked at every single location
whether the check is necessary.

Author: Inkrementator

dstep/translator/Context.d

@@ -21,6 +21,7 @@ import dstep.translator.Output;
 import dstep.translator.Translator;
 import dstep.translator.TypedefIndex;
 import dstep.translator.HeaderIndex;
+import dstep.translator.Util;
 
 class Context
 {
@@ -194,7 +195,7 @@ class Context
 
     private string translateSpellingImpl(in Cursor cursor)
     {
-        return cursor.spelling == ""
+        return cursor.spelling.isUnnamed()
             ? generateAnonymousName(cursor)
             : cursor.spelling;
     }
@@ -272,7 +273,7 @@ class Context
         {
             auto typedefp = typedefParent(cursor.canonical);
 
-            if (typedefp.isValid && cursor.spelling == "")
+            if (typedefp.isValid && cursor.spelling.isUnnamed)
             {
                 spelling = typedefp.spelling;
             }
@@ -378,8 +379,19 @@ bool variablesInParentScope(Cursor cursor)
   */
 bool shouldBeAnonymous(Context context, Cursor cursor)
 {
-    return cursor.type.isAnonymous &&
-        context.typedefIndex.typedefParent(cursor).isEmpty;
+    import std.string: startsWith;
+
+    /* Unfortunately, libclang isAnonymous doesn't seem to work on enums
+     * https://stackoverflow.com/a/35184821
+     * Checking for the string value instead is brittle and might break in a future
+     * version, but I don't think there's a better way
+     */
+    if (cursor.kind == CXCursorKind.enumDecl)
+        return cursor.spelling.isUnnamed
+            && context.typedefIndex.typedefParent(cursor).isEmpty;
+    else
+        return cursor.type.isAnonymous &&
+            context.typedefIndex.typedefParent(cursor).isEmpty;
 }
 
 /**

dstep/translator/Declaration.d

@@ -10,6 +10,7 @@ import clang.Cursor;
 
 import dstep.translator.Translator;
 import dstep.translator.Output;
+import dstep.translator.Util;
 
 abstract class Declaration
 {
@@ -44,6 +45,6 @@ abstract class Declaration
     @property string spelling ()
     {
         auto name = cursor.spelling;
-        return name.length || parent.isEmpty ? name : translator.context.generateAnonymousName(cursor);
+        return !name.isUnnamed && (name.length || parent.isEmpty) ? name : translator.context.generateAnonymousName(cursor);
     }
 }

dstep/translator/Enum.d

@@ -19,6 +19,7 @@ import dstep.translator.Declaration;
 import dstep.translator.Output;
 import dstep.translator.Translator;
 import dstep.translator.Type;
+import dstep.translator.Util;
 
 void translateEnumConstantDecl(
     Output output,

dstep/translator/Record.d

@@ -19,6 +19,7 @@ import dstep.translator.Declaration;
 import dstep.translator.Output;
 import dstep.translator.Translator;
 import dstep.translator.Type;
+import dstep.translator.Util;
 
 string translateRecordTypeKeyword(in Cursor cursor)
 {
@@ -140,7 +141,14 @@ void translateRecordDef(
     auto canonical = cursor.canonical;
 
     auto spelling = keepUnnamed ? "" : context.translateTagSpelling(cursor);
-    spelling = spelling == "" ? spelling : " " ~ spelling;
+    /* Spaghetti warning: Since unnamed values might in at least clang 19.1
+     * contain "unnamed enum" or something as the name instead of being empty,
+     * explicitly set it our variable to the empty string.
+     *
+     * Preferably, this would be disentagled and it would be ensured that there
+     * is only one source of the spelling in this whole function.
+     */
+    spelling = spelling.isUnnamed ? "" : " " ~ spelling;
     auto type = translateRecordTypeKeyword(cursor);
 
     output.subscopeStrong(cursor.extent, "%s%s", type, spelling) in {
@@ -195,7 +203,7 @@ void translateRecordDef(
 
                     case CXCursorKind.unionDecl:
                     case CXCursorKind.structDecl:
-                        if (cursor.type.isAnonymous)
+                        if (cursor.type.isAnonymous || cursor.spelling.isUnnamed)
                             translateAnonymousRecord(output, context, cursor);
 
                         break;
@@ -216,7 +224,8 @@ void translateRecordDecl(Output output, Context context, Cursor cursor)
     context.markAsDefined(cursor);
 
     auto spelling = context.translateTagSpelling(cursor);
-    spelling = spelling == "" ? spelling : " " ~ spelling;
+    //spelling = spelling == "" ? spelling : " " ~ spelling;
+    spelling = spelling.isUnnamed ? "" : " " ~ spelling;
     auto type = translateRecordTypeKeyword(cursor);
     output.singleLine(cursor.extent, "%s%s;", type, spelling);
 }
@@ -233,7 +242,7 @@ bool shouldSkipRecord(Context context, Cursor cursor)
         cursor.kind == CXCursorKind.unionDecl)
     {
         auto typedefp = context.typedefParent(cursor.canonical);
-        auto spelling = typedefp.isValid && cursor.spelling == ""
+        auto spelling = typedefp.isValid && isUnnamed(cursor.spelling)
             ? typedefp.spelling
             : cursor.spelling;
 
@@ -249,7 +258,7 @@ bool shouldSkipRecordDefinition(Context context, Cursor cursor)
         cursor.kind == CXCursorKind.unionDecl)
     {
         auto typedefp = context.typedefParent(cursor.canonical);
-        auto spelling = typedefp.isValid && cursor.spelling == ""
+        auto spelling = typedefp.isValid && cursor.spelling.isUnnamed
             ? typedefp.spelling
             : cursor.spelling;
 

dstep/translator/Util.d

@@ -0,0 +1,21 @@
+module dstep.translator.Util;
+
+/** In recent versions of clang (at least 19.1.7), unnamed (anonymous) types will not
+ * set the spelling field to an empty string, but instead to a message like
+ * "enum (unnamed at [declaration_file.h:48]"
+ * "struct (anonymous at [declaration_file.h:48]"
+ * Either unnamed or anonymous is used.
+ * This applies to structs, enums and unions.
+ *
+ * structs and unions additionally have the isAnonymous() helper which doesn't for enums.
+ *
+ * Usage:
+ *      cursor.spelling.isUnnamed()
+ */
+bool isUnnamed(string s){
+    import std.algorithm.searching;
+    return s == "" || 
+            s.canFind("(unnamed at") ||
+            s.canFind("(anonymous at");
+}
+