Fix dlang#18337 - Emit coverage counters at call sites of inlined functions (dlang#22922)

inlined functions always showed 0000000 in -cov reports even when called.
the standalone function body is never executed at runtime (it's inlined at
each call site), so its counters stayed zero.

fixes https://issues.dlang.org/show_bug.cgi?id=5848
fixes dlang#18337

Author: suyashkumar102

changelog/dmd.cov-inline-pragma.dd

@@ -0,0 +1,14 @@
+Coverage counters are now emitted at call sites of inlined functions
+
+Functions marked `pragma(inline, true)` (and functions inlined via the
+`-inline` flag) would always show `0000000` in `-cov` coverage reports
+even when executed. The inlined function body is never called as a
+standalone function at runtime - only the inlined copy inside the caller
+runs, so its coverage counters stayed at zero.
+
+Coverage counters are now emitted at each call site where a function is
+inlined, so the function's lines correctly reflect how many times they
+were executed.
+
+Fixes $(LINK2 https://issues.dlang.org/show_bug.cgi?id=5848, Issue 5848) /
+$(LINK2 https://github.com/dlang/dmd/issues/18337, #18337)

compiler/include/dmd/expression.h

@@ -948,6 +948,7 @@ class CommaExp final : public BinExp
 {
 public:
     d_bool isGenerated;
+    d_bool isInlineSequence;
     d_bool allowCommaExp;
     Expression* originalExp;
     void accept(Visitor *v) override { v->visit(this); }

compiler/src/dmd/astbase.d

@@ -5701,6 +5701,7 @@ struct ASTBase
     extern (C++) final class CommaExp : BinExp
     {
         const bool isGenerated;
+        bool isInlineSequence;
         bool allowCommaExp;
 
         extern (D) this(Loc loc, Expression e1, Expression e2, bool generated = true)

compiler/src/dmd/expression.d

@@ -2829,6 +2829,9 @@ extern (C++) final class CommaExp : BinExp
     /// to trigger the deprecation.
     const bool isGenerated;
 
+    /// `true` if this comma chain was introduced by inline expansion.
+    bool isInlineSequence;
+
     /// Temporary variable to enable / disable deprecation of comma expression
     /// depending on the context.
     /// Since most constructor calls are rewritting, the only place where

compiler/src/dmd/frontend.h

@@ -2649,6 +2649,7 @@ class CommaExp final : public BinExp
 {
 public:
     const bool isGenerated;
+    bool isInlineSequence;
     bool allowCommaExp;
     Expression* originalExp;
     void accept(Visitor* v) override;

compiler/src/dmd/glue/e2ir.d

@@ -3292,8 +3292,27 @@ elem* toElem(Expression e, ref IRState irs)
     elem* visitComma(CommaExp ce)
     {
         assert(ce.e1 && ce.e2);
+        elem* inlineCoverage(Expression e)
+        {
+            if (!ce.isInlineSequence || !irs.params.cov || !e || !e.loc.isValid())
+                return null;
+
+            // Nested inline-sequence commas are accounted for recursively.
+            if (auto nested = e.isCommaExp())
+            {
+                if (nested.isInlineSequence)
+                    return null;
+            }
+
+            return incUsageElem(irs, e.loc);
+        }
+
         elem* eleft  = toElem(ce.e1, irs);
+        eleft = el_combine(inlineCoverage(ce.e1), eleft);
+
         elem* eright = toElem(ce.e2, irs);
+        eright = el_combine(inlineCoverage(ce.e2), eright);
+
         elem* e = el_combine(eleft, eright);
         if (e)
             elem_setLoc(e, ce.loc);

compiler/src/dmd/inline.d

@@ -120,6 +120,15 @@ private final class InlineDoState
     }
 }
 
+private Expression combineInlineSequence(Expression e1, Expression e2)
+{
+    auto result = Expression.combine(e1, e2);
+    if (result)
+        if (auto ce = result.isCommaExp())
+            ce.isInlineSequence = true;
+    return result;
+}
+
 /***********************************************************
  * Perform the inlining from (Statement or Expression) to (Statement or Expression).
  *
@@ -218,13 +227,13 @@ public:
                         e2.type = Type.tvoid;
                         e.type = Type.tvoid;
                     }
-                    result = Expression.combine(result, e);
+                    result = combineInlineSequence(result, e);
                 }
                 else
                 {
                     ids.foundReturn = false;
                     auto e = doInlineAs!Expression(sx, ids);
-                    result = Expression.combine(result, e);
+                    result = combineInlineSequence(result, e);
                 }
             }
 
@@ -253,7 +262,7 @@ public:
             static if (asStatements)
                 as.push(r);
             else
-                result = Expression.combine(result, r);
+                result = combineInlineSequence(result, r);
 
             if (ids.foundReturn)
                 break;
@@ -2350,7 +2359,7 @@ private void expandInline(CallExp ecall, FuncDeclaration fd, FuncDeclaration par
             ids.from.push(vfrom);
             ids.to.push(vto);
 
-            auto de = new DeclarationExp(vto.loc, vto);
+            auto de = new DeclarationExp(Loc.initial, vto);
             de.type = Type.tvoid;
             eparams = Expression.combine(eparams, de);
 
@@ -2445,8 +2454,10 @@ private void expandInline(CallExp ecall, FuncDeclaration fd, FuncDeclaration par
             e.type = Type.tvoid;
         }
 
-        eresult = Expression.combine(eresult, eret, ethis, eparams);
-        eresult = Expression.combine(eresult, e);
+        eresult = combineInlineSequence(eresult, eret);
+        eresult = combineInlineSequence(eresult, ethis);
+        eresult = combineInlineSequence(eresult, eparams);
+        eresult = combineInlineSequence(eresult, e);
 
         if (ecall.rvalue || tf.isRvalue)
             eresult.rvalue = true;

compiler/test/runnable/extra-files/runnable-test18337.lst

@@ -0,0 +1,26 @@
+       |// PERMUTE_ARGS:
+       |// REQUIRED_ARGS: -cov
+       |// POST_SCRIPT: runnable/extra-files/coverage-postscript.sh
+       |// EXECUTE_ARGS: ${RESULTS_DIR}/runnable
+       |
+       |extern(C) void dmd_coverDestPath(string path);
+       |
+       |pragma(inline, true)
+       |int square(int x)
+       |{
+      2|    int y = x * x;
+      2|    return y;
+       |}
+       |
+       |pragma(inline, true)
+       |int addSquares(int a, int b)
+       |{
+      1|    return square(a) + square(b);
+       |}
+       |
+       |void main(string[] args)
+       |{
+      1|    dmd_coverDestPath(args[1]);
+      1|    auto value = addSquares(2, 3);
+      1|    assert(value == 13);
+       |}

compiler/test/runnable/test18337.d

@@ -0,0 +1,26 @@
+// PERMUTE_ARGS:
+// REQUIRED_ARGS: -cov
+// POST_SCRIPT: runnable/extra-files/coverage-postscript.sh
+// EXECUTE_ARGS: ${RESULTS_DIR}/runnable
+
+extern(C) void dmd_coverDestPath(string path);
+
+pragma(inline, true)
+int square(int x)
+{
+    int y = x * x;
+    return y;
+}
+
+pragma(inline, true)
+int addSquares(int a, int b)
+{
+    return square(a) + square(b);
+}
+
+void main(string[] args)
+{
+    dmd_coverDestPath(args[1]);
+    auto value = addSquares(2, 3);
+    assert(value == 13);
+}