Avoid mixins for directly used macros

Author: tim-dlang

src/cppconv/dwriter/declarationcode.d

@@ -2270,27 +2270,41 @@ void declarationToDCode(ref CodeWriter code, DWriterData data, Declaration d, im
                 else
                 {
                     code.customIndent = origCustomIndent;
+                    string innerCode = instance.instanceCode[instance.realCodeStart .. instance.realCodeEnd];
                     if (instance.macroTranslation == MacroTranslation.enumValue)
                         code.writeln("enum ", instance.usedName, " =",
                                 instance.instanceCode[0 .. instance.realCodeStart],
-                                instance.instanceCode[instance.realCodeStart .. instance.realCodeEnd], ";",
+                                innerCode, ";",
                                 instance.instanceCode[instance.realCodeEnd
                                     .. $].withoutTrailingWhitespace);
                     else if (instance.macroTranslation == MacroTranslation.alias_)
                         code.writeln("alias ", instance.usedName, " =",
                                 instance.instanceCode[0 .. instance.realCodeStart],
-                                instance.instanceCode[instance.realCodeStart .. instance.realCodeEnd], ";",
+                                innerCode, ";",
                                 instance.instanceCode[instance.realCodeEnd
                                     .. $].withoutTrailingWhitespace);
                     else if (instance.macroTranslation == MacroTranslation.mixin_)
+                    {
+                        string codePrefix = "q{";
+                        string codeSuffix = "}";
+                        if (instance.mixinMacroHasInterpolation)
+                        {
+                            codePrefix = "mixin(interpolateMixin(" ~ codePrefix;
+                            codeSuffix ~= "))";
+                        }
+                        if (instance.canForwardMacroMixin && innerCode.startsWith("$(") && innerCode.endsWith(")"))
+                        {
+                            codePrefix = "";
+                            codeSuffix = "";
+                            innerCode = innerCode[2 .. $ - 1];
+                        }
                         code.writeln("enum ", instance.usedName, " =",
                                 instance.instanceCode[0 .. instance.realCodeStart],
-                                instance.mixinMacroHasInterpolation ? "mixin(interpolateMixin(" : "",
-                                "q{", instance.instanceCode[instance.realCodeStart .. instance.realCodeEnd], "}",
-                                instance.mixinMacroHasInterpolation ? "))" : "",
+                                codePrefix, innerCode, codeSuffix,
                                 ";",
                                 instance.instanceCode[instance.realCodeEnd
                                     .. $].withoutTrailingWhitespace);
+                    }
                     code.customIndent = newCustomIndent;
                 }
             }

src/cppconv/dwriter/macrodeclaration.d

@@ -64,6 +64,7 @@ class MacroDeclarationInstance
     size_t realCodeStart;
     size_t realCodeEnd;
     bool mixinMacroHasInterpolation;
+    bool canForwardMacroMixin;
     string usedName;
     MacroTranslation macroTranslation;
     MacroDeclarationInstance[] extraDeps;
@@ -708,6 +709,14 @@ void generateMacroCode(DWriterData data, Semantic mergedSemantic, MacroDeclarati
     }
     else
     {
+        if (usedTrees.length == 1 && usedTrees[0] in data.macroReplacement)
+        {
+            auto instance3 = data.macroReplacement[usedTrees[0]];
+            if (instance3.macroDeclaration.type != DeclarationType.macroParam
+                && instance3.macroTranslation == MacroTranslation.mixin_)
+                instance.canForwardMacroMixin = true;
+        }
+
         foreach (usedTree; usedTrees)
         {
             if (code.data.length == 0 && usedTree.isValid)
@@ -1060,13 +1069,20 @@ void writeMacroInstance(ref CodeWriter code, DWriterData data, Tree tree, immuta
                     if (!allCodesSame)
                         code.write("/* WARNING: Parameter has been split. */");
                     code.write(x.instanceCode[0 .. x.realCodeStart]);
+                    string innerCode = x.instanceCode[x.realCodeStart .. x.realCodeEnd];
                     if (!data.inMixinMacro && x.mixinMacroHasInterpolation)
                     {
                         codePrefix = "mixin(interpolateMixin(" ~ codePrefix;
                         codeSuffix ~= "))";
                     }
+                    if (x.canForwardMacroMixin && innerCode.startsWith("$(") && innerCode.endsWith(")"))
+                    {
+                        codePrefix = "";
+                        codeSuffix = "";
+                        innerCode = innerCode[2 .. $ - 1];
+                    }
                     code.write(codePrefix);
-                    code.write(x.instanceCode[x.realCodeStart .. x.realCodeEnd]);
+                    code.write(innerCode);
                     code.write(codeSuffix);
                     code.write(x.instanceCode[x.realCodeEnd .. $]);
                 }

tests/multifile/testinclude99/testinclude99a.d

@@ -13,6 +13,6 @@ void g()
 {
     import testinclude99b;
 
-    int z = mixin(M(mixin(interpolateMixin(q{$(X)}))));
+    int z = mixin(M(X));
 }
 

tests/single/test34.d

@@ -20,7 +20,7 @@ extern(D) alias f = function string(string x)
 };
 __gshared int i3 = mixin(f(q{5}));
 /+ #define Y f(6) +/
-enum Y = mixin(interpolateMixin(q{$(imported!q{test34}.f(q{6}))}));
+enum Y = imported!q{test34}.f(q{6});
 __gshared int i4 = mixin(Y);
 /+ #define g() X +/
 extern(D) alias g = function string()

tests/single/testdefines71.c

@@ -0,0 +1,10 @@
+const int g = 1;
+#define f(x) x
+#define X (1*g)
+int i = f(X) + 1;
+
+#define Y X
+int i2 = Y;
+
+#define f2(y) f(y)
+int i3 = f2(X) + 3;

tests/single/testdefines71.d

@@ -0,0 +1,26 @@
+module testdefines71;
+
+import config;
+import cppconvhelpers;
+
+__gshared const(int) g = 1;
+/+ #define f(x) x +/
+extern(D) alias f = function string(string x)
+{
+    return mixin(interpolateMixin(q{$(x)}));
+};
+/+ #define X (1*g) +/
+enum X = q{(1*imported!q{testdefines71}.g)};
+__gshared int i = mixin(f(X)) + 1;
+
+/+ #define Y X +/
+enum Y = imported!q{testdefines71}.X;
+__gshared int i2 = mixin(Y);
+
+/+ #define f2(y) f(y) +/
+extern(D) alias f2 = function string(string y)
+{
+    return mixin(interpolateMixin(q{$(imported!q{testdefines71}.f(q{$(y)}))}));
+};
+__gshared int i3 = mixin(f2(X)) + 3;
+