Attempt to fix #20410

Emmankoko · Emmankoko · commit 8ef4b893ddcf · 2025-10-25T19:09:06.000Z
diff --git a/compiler/src/dmd/cparse.d b/compiler/src/dmd/cparse.d
@@ -5548,6 +5548,9 @@ final class CParser(AST) : Parser!AST
                 v.isCmacro = true;       // mark it as coming from a C #define
             if (auto td = s.isTemplateDeclaration())
                 td.isCmacro = true; // mark as coming from a C #define
+            if (auto ad = s.isAliasDeclaration())
+                ad.isCmacro = true; // ditto for vars and templates
+
             /* If it's already defined, replace the earlier
              * definition
              */
@@ -5702,6 +5705,47 @@ final class CParser(AST) : Parser!AST
                             }
                             break;
 
+                        case TOK.identifier:
+                        {
+                            /* check for compiler builtins macros/ or specifier references.
+                             * this is a workaround to avoid trying to resolve macros that
+                             * reference other identifiers or functions
+                             * so D users should avoid using custom macros beginning with __
+                             * to reference identifers
+                             */
+                            auto ident = token.ident;
+                            Specifier sp;
+                            sp.packalign = this.packalign;
+                            auto tspec = cparseDeclarationSpecifiers(LVL.global, sp);
+                            const idx = id.toString();
+                            auto identx = ident.toString();
+
+                            if (!tspec.isTypeIdentifier() || isCBuiltin(identx) || isCBuiltin(idx) ||
+                                isCmacrosame(identx, idx) || (identx.length > 2 && identx[0] == '_' && identx[1] == '_')
+                                || (idx.length > 2 && idx[0] == '_' && idx[1] == '_'))
+                            {
+                                ++p;
+                                continue;
+                            }
+
+                            nextToken();
+                            if (token.value != TOK.endOfFile)
+                            {
+                                ++p;
+                                continue;
+                            }
+
+                            /*
+                             * #define identifier value where value can be an identifier.
+                             * The identifier can be anything, so treat it as an AliasDeclaration.
+                             * Mark it as coming from a C file to skip semantic resolution later.
+                             */
+                            auto als = new AST.AliasDeclaration(scanloc, id, tspec);
+                            addSym(als);
+                            ++p;
+                            continue;
+                        }
+
                         case TOK.leftParenthesis:
                         {
                             /* Look for:
@@ -5828,7 +5872,6 @@ final class CParser(AST) : Parser!AST
                             ++p;
                             continue;
                         }
-
                         default:
                             break;
                     }
@@ -5862,3 +5905,39 @@ final class CParser(AST) : Parser!AST
 
     //}
 }
+
+/*
+ * for few compiler intrinsics the compiler cannot resolve
+ * that we have no knowledge of in D,
+ * set them rawly and don't allow them for now
+ * long term, any user of a C header that is being bocked by an intrinsic,
+ * append to this table
+ */
+immutable string[] builtins = [
+    "_Pre_",
+    "_Maybevalid_impl_",
+    "_Pre_z_",
+    "_Notref_impl_",
+    "_Post_",
+    "X",
+    "_Use_decl_anno_impl_",
+    "vector_size",
+    "complex" // stay away from the C99 _complex keyword that share diffs on windows/POSIX
+];
+
+bool isCBuiltin(const(char)[] name)
+{
+    foreach (b; builtins)
+    {
+        if (b == name)
+            return true;
+    }
+    return false;
+}
+
+bool isCmacrosame(const(char)[] idx, const(char)[] ident)
+{
+    if (idx == ident)
+        return true;
+    return false;
+}
diff --git a/compiler/src/dmd/declaration.d b/compiler/src/dmd/declaration.d
@@ -341,6 +341,7 @@ extern (C++) final class AliasDeclaration : Declaration
 
     Dsymbol overnext;   // next in overload list
     Dsymbol _import;    // !=null if unresolved internal alias for selective import
+    bool isCmacro;      // check whether it is coming from a C macro
 
     extern (D) this(Loc loc, Identifier ident, Type type) @safe
     {
diff --git a/compiler/src/dmd/declaration.h b/compiler/src/dmd/declaration.h
@@ -196,6 +196,7 @@ class AliasDeclaration final : public Declaration
     Dsymbol *aliassym;
     Dsymbol *overnext;          // next in overload list
     Dsymbol *_import;           // !=NULL if unresolved internal alias for selective import
+    bool isCmacro;
 
     static AliasDeclaration *create(Loc loc, Identifier *id, Type *type);
     AliasDeclaration *syntaxCopy(Dsymbol *) override;
diff --git a/compiler/src/dmd/dsymbolsem.d b/compiler/src/dmd/dsymbolsem.d
@@ -1187,7 +1187,7 @@ Dsymbol toAlias2(Dsymbol s)
 {
     if (auto ad = s.isAliasDeclaration())
     {
-        if (ad.inuse)
+        if (ad.inuse && !ad.isCmacro) // c amcro can refer to itself and compile
         {
             .error(ad.loc, "%s `%s` recursive alias declaration", ad.kind, ad.toPrettyChars);
             return ad;
@@ -1262,7 +1262,7 @@ private Dsymbol toAliasImpl(AliasDeclaration ad)
             ad.inuse = 0;
         }
     }
-    if (ad.inuse)
+    if (ad.inuse && !ad.isCmacro) // C macros can refer to itself and comoile
     {
         .error(ad.loc, "%s `%s` recursive alias declaration", ad.kind, ad.toPrettyChars);
         return err();
@@ -5825,8 +5825,9 @@ private extern(C++) class AddMemberVisitor : Visitor
             }
 
             // If using C tag/prototype/forward declaration rules
+            // remember, C allows rdececlarations of macros too
+             //(!sc.inCfie && dsym.isAliasDeclaration().isCmacro && s2.isAliasDeclaration().isCmacro)))
             if (sc && sc.inCfile && !dsym.isImport())
-            // When merging master, replace with: if (sc && sc.inCfile && !dsym.isImport())
             {
                 if (handleTagSymbols(*sc, dsym, s2, sds))
                     return;
@@ -6328,15 +6329,30 @@ void aliasSemantic(AliasDeclaration ds, Scope* sc)
     // Detect `alias sym = sym;` to prevent creating loops in overload overnext lists.
     if (auto tident = ds.type.isTypeIdentifier())
     {
-        if (sc.hasEdition(Edition.v2024) && tident.idents.length)
+        if ((sc.hasEdition(Edition.v2024) && tident.idents.length) || ds.isCmacro)
         {
             alias mt = tident;
             Dsymbol pscopesym;
             Dsymbol s = sc.search(ds.loc, mt.ident, pscopesym);
+            /* if the imported macro from C doesn't exist,
+             * probably a builtin one we don't define
+             * stop processing it. C macro refering identifiers
+             * can point to absolutely anything either defined or not
+             * #ifdefine hsgshsh hsshhshs is a valid C compile but emit on usage
+             * then we implement the ones we need
+             */
+            if (!s && sc.inCfile && ds.isCmacro)
+            {
+                ds.aliassym = null;
+                ds.errors = false;                      // no error flag
+                ds.semanticRun = PASS.semanticdone;     // mark semantic as complete
+                ds.inuse = 0;                           // clear recursion flag
+                return;
+            }
             // detect `alias a = var1.member_var;` which confusingly resolves to
             // `typeof(var1).member_var`, which can be valid inside the aggregate type
             if (s && s.isVarDeclaration() &&
-                mt.ident != Id.This && mt.ident != Id._super)
+                mt.ident != Id.This && mt.ident != Id._super && (!ds.isCmacro && !sc.inCfile)) // don't let a C macro alias pass here
             {
                 s = tident.toDsymbol(sc);
                 // don't error for `var1.static_symbol`
@@ -6350,7 +6366,7 @@ void aliasSemantic(AliasDeclaration ds, Scope* sc)
             }
         }
         // Selective imports are allowed to alias to the same name `import mod : sym=sym`.
-        if (!ds._import)
+        if (!ds._import && (!ds.isCmacro && !sc.inCfile)) // C identifier macros are not allowed here
         {
             if (tident.ident is ds.ident && !tident.idents.length)
             {
diff --git a/compiler/src/dmd/frontend.h b/compiler/src/dmd/frontend.h
@@ -6774,6 +6774,7 @@ class AliasDeclaration final : public Declaration
     Dsymbol* aliassym;
     Dsymbol* overnext;
     Dsymbol* _import_;
+    bool isCmacro;
     static AliasDeclaration* create(Loc loc, Identifier* id, Type* type);
     AliasDeclaration* syntaxCopy(Dsymbol* s) override;
     const char* kind() const override;
diff --git a/compiler/src/dmd/importc.d b/compiler/src/dmd/importc.d
@@ -490,6 +490,23 @@ Dsymbol handleSymbolRedeclarations(ref Scope sc, Dsymbol s, Dsymbol s2, ScopeDsy
         if (td.isCmacro) return s2;
     }
 
+/*    if (auto em = s.isEnumMember())
+    {
+        if (auto ad = s2.isAliasDeclaration())
+        {
+            if (ad.isCmacro)
+            {
+                return s;
+            }
+        }
+    }*/
+
+    if (auto ad = s.isAliasDeclaration())
+    {
+        if (ad.isCmacro)
+            return s2;
+    }
+
     auto vd = s.isVarDeclaration(); // new declaration
     auto vd2 = s2.isVarDeclaration(); // existing declaration
 
diff --git a/compiler/test/runnable/fix20410.d b/compiler/test/runnable/fix20410.d
@@ -0,0 +1,13 @@
+/*
+REQUIRED_ARGS: runnable/imports/imp20410.c
+*/
+//https://github.com/dlang/dmd/issues/20410
+import imp20410;
+
+void main()
+{
+    const _ = _RAX;
+
+    assert(num == 5);
+    assert(func() == 9);
+}
diff --git a/compiler/test/runnable/imports/imp20410.c b/compiler/test/runnable/imports/imp20410.c
@@ -0,0 +1,17 @@
+// https://issues.dlang.org/show_bug.cgi?id=24419
+
+typedef enum {
+    #define R0 _RAX
+    _RAX,
+} reg;
+
+
+int number = 5;
+#define num number;
+
+
+int function()
+{
+    return 9;
+}
+#define func function

Original file line number	Diff line number	Diff line change
`@@ -341,6 +341,7 @@ extern (C++) final class AliasDeclaration : Declaration`
`341`	`341`
`342`	`342`	`Dsymbol overnext; // next in overload list`
`343`	`343`	`Dsymbol _import; // !=null if unresolved internal alias for selective import`
	`344`	`+ bool isCmacro; // check whether it is coming from a C macro`
`344`	`345`
`345`	`346`	`extern (D) this(Loc loc, Identifier ident, Type type) @safe`
`346`	`347`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1187,7 +1187,7 @@ Dsymbol toAlias2(Dsymbol s)`
`1187`	`1187`	`{`
`1188`	`1188`	`if (auto ad = s.isAliasDeclaration())`
`1189`	`1189`	`{`
`1190`		`- if (ad.inuse)`
	`1190`	`+ if (ad.inuse && !ad.isCmacro) // c amcro can refer to itself and compile`
`1191`	`1191`	`{`
`1192`	`1192`	.error(ad.loc, "%s `%s` recursive alias declaration", ad.kind, ad.toPrettyChars);
`1193`	`1193`	`return ad;`
`@@ -1262,7 +1262,7 @@ private Dsymbol toAliasImpl(AliasDeclaration ad)`
`1262`	`1262`	`ad.inuse = 0;`
`1263`	`1263`	`}`
`1264`	`1264`	`}`
`1265`		`- if (ad.inuse)`
	`1265`	`+ if (ad.inuse && !ad.isCmacro) // C macros can refer to itself and comoile`
`1266`	`1266`	`{`
`1267`	`1267`	.error(ad.loc, "%s `%s` recursive alias declaration", ad.kind, ad.toPrettyChars);
`1268`	`1268`	`return err();`
`@@ -5825,8 +5825,9 @@ private extern(C++) class AddMemberVisitor : Visitor`
`5825`	`5825`	`}`
`5826`	`5826`
`5827`	`5827`	`// If using C tag/prototype/forward declaration rules`
	`5828`	`+ // remember, C allows rdececlarations of macros too`
	`5829`	`+ //(!sc.inCfie && dsym.isAliasDeclaration().isCmacro && s2.isAliasDeclaration().isCmacro)))`
`5828`	`5830`	`if (sc && sc.inCfile && !dsym.isImport())`
`5829`		`- // When merging master, replace with: if (sc && sc.inCfile && !dsym.isImport())`
`5830`	`5831`	`{`
`5831`	`5832`	`if (handleTagSymbols(*sc, dsym, s2, sds))`
`5832`	`5833`	`return;`
`@@ -6328,15 +6329,30 @@ void aliasSemantic(AliasDeclaration ds, Scope* sc)`
`6328`	`6329`	// Detect `alias sym = sym;` to prevent creating loops in overload overnext lists.
`6329`	`6330`	`if (auto tident = ds.type.isTypeIdentifier())`
`6330`	`6331`	`{`
`6331`		`- if (sc.hasEdition(Edition.v2024) && tident.idents.length)`
	`6332`	`+ if ((sc.hasEdition(Edition.v2024) && tident.idents.length) \|\| ds.isCmacro)`
`6332`	`6333`	`{`
`6333`	`6334`	`alias mt = tident;`
`6334`	`6335`	`Dsymbol pscopesym;`
`6335`	`6336`	`Dsymbol s = sc.search(ds.loc, mt.ident, pscopesym);`
	`6337`	`+ /* if the imported macro from C doesn't exist,`
	`6338`	`+ * probably a builtin one we don't define`
	`6339`	`+ * stop processing it. C macro refering identifiers`
	`6340`	`+ * can point to absolutely anything either defined or not`
	`6341`	`+ * #ifdefine hsgshsh hsshhshs is a valid C compile but emit on usage`
	`6342`	`+ * then we implement the ones we need`
	`6343`	`+ */`
	`6344`	`+ if (!s && sc.inCfile && ds.isCmacro)`
	`6345`	`+ {`
	`6346`	`+ ds.aliassym = null;`
	`6347`	`+ ds.errors = false; // no error flag`
	`6348`	`+ ds.semanticRun = PASS.semanticdone; // mark semantic as complete`
	`6349`	`+ ds.inuse = 0; // clear recursion flag`
	`6350`	`+ return;`
	`6351`	`+ }`
`6336`	`6352`	// detect `alias a = var1.member_var;` which confusingly resolves to
`6337`	`6353`	// `typeof(var1).member_var`, which can be valid inside the aggregate type
`6338`	`6354`	`if (s && s.isVarDeclaration() &&`
`6339`		`- mt.ident != Id.This && mt.ident != Id._super)`
	`6355`	`+ mt.ident != Id.This && mt.ident != Id._super && (!ds.isCmacro && !sc.inCfile)) // don't let a C macro alias pass here`
`6340`	`6356`	`{`
`6341`	`6357`	`s = tident.toDsymbol(sc);`
`6342`	`6358`	// don't error for `var1.static_symbol`
`@@ -6350,7 +6366,7 @@ void aliasSemantic(AliasDeclaration ds, Scope* sc)`
`6350`	`6366`	`}`
`6351`	`6367`	`}`
`6352`	`6368`	// Selective imports are allowed to alias to the same name `import mod : sym=sym`.
`6353`		`- if (!ds._import)`
	`6369`	`+ if (!ds._import && (!ds.isCmacro && !sc.inCfile)) // C identifier macros are not allowed here`
`6354`	`6370`	`{`
`6355`	`6371`	`if (tident.ident is ds.ident && !tident.idents.length)`
`6356`	`6372`	`{`