fix Issue 13816 - The compiler crashes with recursive tuple expansion

src/declaration.c

@@ -257,6 +257,22 @@ Type *TupleDeclaration::getType()
     return tupletype;
 }
 
+Dsymbol *TupleDeclaration::toAlias2()
+{
+    //printf("TupleDeclaration::toAlias2() '%s' objects = %s\n", toChars(), objects->toChars());
+
+    for (size_t i = 0; i < objects->dim; i++)
+    {
+        RootObject *o = (*objects)[i];
+        if (Dsymbol *s = isDsymbol(o))
+        {
+            s = s->toAlias2();
+            (*objects)[i] = s;
+        }
+    }
+    return this;
+}
+
 bool TupleDeclaration::needThis()
 {
     //printf("TupleDeclaration::needThis(%s)\n", toChars());
@@ -607,6 +623,19 @@ Dsymbol *AliasDeclaration::toAlias()
     return s;
 }
 
+Dsymbol *AliasDeclaration::toAlias2()
+{
+    if (inuse)
+    {
+        error("recursive alias declaration");
+        return this;
+    }
+    inuse = 1;
+    Dsymbol *s  = aliassym ? aliassym->toAlias2() : this;
+    inuse = 0;
+    return s;
+}
+
 /****************************** OverDeclaration **************************/
 
 OverDeclaration::OverDeclaration(Dsymbol *s, bool hasOverloads)

src/declaration.h

@@ -181,6 +181,7 @@ class TupleDeclaration : public Declaration
     Dsymbol *syntaxCopy(Dsymbol *);
     const char *kind();
     Type *getType();
+    Dsymbol *toAlias2();
     bool needThis();
 
     TupleDeclaration *isTupleDeclaration() { return this; }
@@ -204,6 +205,7 @@ class AliasDeclaration : public Declaration
     const char *kind();
     Type *getType();
     Dsymbol *toAlias();
+    Dsymbol *toAlias2();
 
     AliasDeclaration *isAliasDeclaration() { return this; }
     void accept(Visitor *v) { v->visit(this); }

src/dsymbol.c

@@ -271,12 +271,19 @@ const char *Dsymbol::kind()
  * If this symbol is really an alias for another,
  * return that other.
  */
-
 Dsymbol *Dsymbol::toAlias()
 {
     return this;
 }
 
+/*********************************
+ * Resolve recursive tuple expansion in eponymous template.
+ */
+Dsymbol *Dsymbol::toAlias2()
+{
+    return toAlias();
+}
+
 Dsymbol *Dsymbol::toParent()
 {
     return parent ? parent->pastMixin() : NULL;

src/dsymbol.h

@@ -190,6 +190,7 @@ class Dsymbol : public RootObject
     virtual const char *toPrettyChars(bool QualifyTypes = false);
     virtual const char *kind();
     virtual Dsymbol *toAlias();                 // resolve real symbol
+    virtual Dsymbol *toAlias2();
     virtual int apply(Dsymbol_apply_ft_t fp, void *param);
     virtual void addMember(Scope *sc, ScopeDsymbol *sds);
     virtual void setScope(Scope *sc);

src/template.c

@@ -6285,6 +6285,19 @@ void TemplateInstance::semantic(Scope *sc, Expressions *fargs)
         }
     }
 
+    if (aliasdecl)
+    {
+        /* Bugzilla 13816: AliasDeclaration tries to resolve forward reference
+         * twice (See inuse check in AliasDeclaration::toAlias()). It's
+         * necessary to resolve mutual references of instantiated symbols, but
+         * it will left a true recursive alias in tuple declaration - an
+         * AliasDeclaration A refers TupleDeclaration B, and B contains A
+         * in its elements.  To correctly make it an error, we strictly need to
+         * resolve the alias of eponymous member.
+         */
+        aliasdecl = aliasdecl->toAlias2();
+    }
+
   Laftersemantic:
     sc2->pop();
 

test/fail_compilation/ice13816.d

@@ -0,0 +1,23 @@
+/*
+TEST_OUTPUT:
+---
+fail_compilation/ice13816.d(15): Error: alias ice13816.ItemProperty!().ItemProperty recursive alias declaration
+fail_compilation/ice13816.d(20): Error: template instance ice13816.ItemProperty!() error instantiating
+---
+*/
+
+alias TypeTuple(T...) = T;
+
+template ItemProperty()
+{
+    static if (true)
+    {
+        alias ItemProperty = TypeTuple!(ItemProperty!());
+    }
+}
+void main()
+{
+    alias items = ItemProperty!();
+
+    enum num = items.length;
+}