diff --git a/compiler/src/dmd/dtemplate.d b/compiler/src/dmd/dtemplate.d
index 63c18f8c58f..8fe392bda06 100644
--- a/compiler/src/dmd/dtemplate.d
+++ b/compiler/src/dmd/dtemplate.d
@@ -3235,10 +3235,6 @@ extern (C++) class TemplateParameter : ASTNode
         return DYNCAST.templateparameter;
     }
 
-    /* Create dummy argument based on parameter.
-     */
-    abstract RootObject dummyArg();
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -3319,19 +3315,6 @@ extern (C++) class TemplateTypeParameter : TemplateParameter
         return defaultType !is null;
     }
 
-    override final RootObject dummyArg()
-    {
-        Type t = specType;
-        if (!t)
-        {
-            // Use this for alias-parameter's too (?)
-            if (!tdummy)
-                tdummy = new TypeIdentifier(loc, ident);
-            t = tdummy;
-        }
-        return t;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -3475,24 +3458,6 @@ extern (C++) final class TemplateValueParameter : TemplateParameter
         return defaultValue !is null;
     }
 
-    override RootObject dummyArg()
-    {
-        Expression e = specValue;
-        if (!e)
-        {
-            // Create a dummy value
-            auto pe = cast(void*)valType in edummies;
-            if (!pe)
-            {
-                e = valType.defaultInit(Loc.initial);
-                edummies[cast(void*)valType] = e;
-            }
-            else
-                e = *pe;
-        }
-        return e;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -3578,18 +3543,6 @@ extern (C++) final class TemplateAliasParameter : TemplateParameter
         return defaultAlias !is null;
     }
 
-    override RootObject dummyArg()
-    {
-        RootObject s = specAlias;
-        if (!s)
-        {
-            if (!sdummy)
-                sdummy = new Dsymbol();
-            s = sdummy;
-        }
-        return s;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -3667,11 +3620,6 @@ extern (C++) final class TemplateTupleParameter : TemplateParameter
         return false;
     }
 
-    override RootObject dummyArg()
-    {
-        return null;
-    }
-
     override void accept(Visitor v)
     {
         v.visit(this);
diff --git a/compiler/src/dmd/frontend.h b/compiler/src/dmd/frontend.h
index e5daa3ae1ed..0c6b01d91b4 100644
--- a/compiler/src/dmd/frontend.h
+++ b/compiler/src/dmd/frontend.h
@@ -1446,7 +1446,6 @@ class TemplateParameter : public ASTNode
     virtual bool hasDefaultArg() = 0;
     const char* toChars() const override;
     DYNCAST dyncast() const override;
-    virtual RootObject* dummyArg() = 0;
     void accept(Visitor* v) override;
 };
 
@@ -1463,7 +1462,6 @@ class TemplateAliasParameter final : public TemplateParameter
     RootObject* specialization() override;
     RootObject* defaultArg(const Loc& instLoc, Scope* sc) override;
     bool hasDefaultArg() override;
-    RootObject* dummyArg() override;
     void accept(Visitor* v) override;
 };
 
@@ -1621,7 +1619,6 @@ class TemplateTypeParameter : public TemplateParameter
     RootObject* specialization() final override;
     RootObject* defaultArg(const Loc& instLoc, Scope* sc) final override;
     bool hasDefaultArg() final override;
-    RootObject* dummyArg() final override;
     void accept(Visitor* v) override;
 };
 
@@ -1643,7 +1640,6 @@ class TemplateTupleParameter final : public TemplateParameter
     RootObject* specialization() override;
     RootObject* defaultArg(const Loc& instLoc, Scope* sc) override;
     bool hasDefaultArg() override;
-    RootObject* dummyArg() override;
     void accept(Visitor* v) override;
 };
 
@@ -1660,7 +1656,6 @@ class TemplateValueParameter final : public TemplateParameter
     RootObject* specialization() override;
     RootObject* defaultArg(const Loc& instLoc, Scope* sc) override;
     bool hasDefaultArg() override;
-    RootObject* dummyArg() override;
     void accept(Visitor* v) override;
 };
 
diff --git a/compiler/src/dmd/template.h b/compiler/src/dmd/template.h
index bccec1a68c1..e751eadb5ae 100644
--- a/compiler/src/dmd/template.h
+++ b/compiler/src/dmd/template.h
@@ -133,9 +133,6 @@ class TemplateParameter : public ASTNode
 
     DYNCAST dyncast() const override { return DYNCAST_TEMPLATEPARAMETER; }
 
-    /* Create dummy argument based on parameter.
-     */
-    virtual RootObject *dummyArg() = 0;
     void accept(Visitor *v) override { v->visit(this); }
 };
 
@@ -155,7 +152,6 @@ class TemplateTypeParameter : public TemplateParameter
     RootObject *specialization() override final;
     RootObject *defaultArg(const Loc &instLoc, Scope *sc) override final;
     bool hasDefaultArg() override final;
-    RootObject *dummyArg() override final;
     void accept(Visitor *v) override { v->visit(this); }
 };
 
@@ -187,7 +183,6 @@ class TemplateValueParameter final : public TemplateParameter
     RootObject *specialization() override;
     RootObject *defaultArg(const Loc &instLoc, Scope *sc) override;
     bool hasDefaultArg() override;
-    RootObject *dummyArg() override;
     void accept(Visitor *v) override { v->visit(this); }
 };
 
@@ -208,7 +203,6 @@ class TemplateAliasParameter final : public TemplateParameter
     RootObject *specialization() override;
     RootObject *defaultArg(const Loc &instLoc, Scope *sc) override;
     bool hasDefaultArg() override;
-    RootObject *dummyArg() override;
     void accept(Visitor *v) override { v->visit(this); }
 };
 
@@ -225,7 +219,6 @@ class TemplateTupleParameter final : public TemplateParameter
     RootObject *specialization() override;
     RootObject *defaultArg(const Loc &instLoc, Scope *sc) override;
     bool hasDefaultArg() override;
-    RootObject *dummyArg() override;
     void accept(Visitor *v) override { v->visit(this); }
 };
 
diff --git a/compiler/src/dmd/templatesem.d b/compiler/src/dmd/templatesem.d
index 19b8177bc2a..1d5a450eec6 100644
--- a/compiler/src/dmd/templatesem.d
+++ b/compiler/src/dmd/templatesem.d
@@ -2428,3 +2428,66 @@ void functionResolve(ref MatchAccumulator m, Dsymbol dstart, Loc loc, Scope* sc,
         m.last = MATCH.nomatch;
     }
 }
+/* Create dummy argument based on parameter.
+ */
+private RootObject dummyArg(TemplateParameter tp)
+{
+    scope v = new DummyArgVisitor();
+    v.accept(tp);
+    return v.result;
+}
+extern(C++) class DummyArgVisitor : Visitor
+{
+    RootObject result;
+
+    override void visit(TemplateTypeParameter ttp)
+    {
+        Type t = ttp.specType;
+        if (t)
+        {
+            result = t;
+            return;
+        }
+        // Use this for alias-parameter's too (?)
+        if (!ttp.tdummy)
+            ttp.tdummy = new TypeIdentifier(loc, ident);
+        result = tdummy;
+    }
+    override void visit(TemplateValueParameter tvp)
+    {
+        Expression e = tvp.specValue;
+        if (e)
+        {
+            result = e;
+            return;
+        }
+
+        // Create a dummy value
+        auto pe = cast(void*)valType in tvp.edummies;
+        if (pe)
+        {
+            result = *pe;
+            return;
+        }
+
+        e = tvp.valType.defaultInit(Loc.initial);
+        edummies[cast(void*)valType] = e;
+        result = e;
+    }
+    override void visit(TemplateAliasParameter tap)
+    {
+        RootObject s = tap.specAlias;
+        if (s)
+        {
+            result = s;
+            return;
+        }
+        if (!tap.sdummy)
+            tap.sdummy = new Dsymbol();
+        result = tap.sdummy;
+    }
+    override void visit(TemplateTupleParameter tap)
+    {
+        result = null;
+    }
+}