Reduce indentation in TemplateDeclaration constructor

also rename TemplateDeclaration members `isAlias` and `isAliasSeq` to
`isTrivialAlias` and `isTrivialAliasSeq`

Author: thewilsonator

src/dmd/dsymbolsem.d

@@ -5919,15 +5919,15 @@ void templateInstanceSemantic(TemplateInstance tempinst, Scope* sc, Expressions*
 
     /* Greatly simplified semantic processing for AliasSeq templates
      */
-    if (tempdecl.isAliasSeq)
+    if (tempdecl.isTrivialAliasSeq)
     {
         tempinst.inst = tempinst;
         return aliasSeqInstanceSemantic(tempinst, sc, fargs, tempdecl);
     }
 
     /* Greatly simplified semantic processing for Alias templates
      */
-    else if (tempdecl.isAlias)
+    else if (tempdecl.isTrivialAlias)
     {
         tempinst.inst = tempinst;
         return aliasInstanceSemantic(tempinst, sc, fargs, tempdecl);

src/dmd/dtemplate.d

@@ -558,8 +558,8 @@ extern (C++) final class TemplateDeclaration : ScopeDsymbol
     bool literal;           // this template declaration is a literal
     bool ismixin;           // this is a mixin template declaration
     bool isstatic;          // this is static template declaration
-    bool isAliasSeq;        /// matches pattern `template AliasSeq(T...) { alias AliasSeq = T; }`
-    bool isAlias;           /// matches pattern `template Alias(T) { alias Alias = qualifiers(T); }`
+    bool isTrivialAliasSeq; /// matches pattern `template AliasSeq(T...) { alias AliasSeq = T; }`
+    bool isTrivialAlias;    /// matches pattern `template Alias(T) { alias Alias = qualifiers(T); }`
     Prot protection;
     int inuse;              /// for recursive expansion detection
 
@@ -602,49 +602,48 @@ extern (C++) final class TemplateDeclaration : ScopeDsymbol
 
         // Compute in advance for Ddoc's use
         // https://issues.dlang.org/show_bug.cgi?id=11153: ident could be NULL if parsing fails.
-        if (members && ident)
-        {
-            Dsymbol s;
-            if (Dsymbol.oneMembers(members, &s, ident) && s)
-            {
-                onemember = s;
-                s.parent = this;
+        if (!members || !ident)
+            return;
 
-                /* Set isAliasSeq if this fits the pattern:
-                 *   template AliasSeq(T...) { alias AliasSeq = T; }
-                 * or set isAlias if this fits the pattern:
-                 *   template Alias(T) { alias Alias = qualifiers(T); }
-                 */
-                if (!(parameters && parameters.length == 1))
-                    return;
+        Dsymbol s;
+        if (!Dsymbol.oneMembers(members, &s, ident) || !s)
+            return;
 
-                if (auto ad = s.isAliasDeclaration())
-                {
-                    if (!ad.type)
-                        return;
-                    if (auto ti = ad.type.isTypeIdentifier())
-                    {
-                        if (auto ttp = (*parameters)[0].isTemplateTupleParameter())
-                        {
-                            if (ti.idents.length == 0 &&
-                                ti.ident is ttp.ident &&
-                                ti.mod == 0)
-                            {
-                                //printf("found isAliasSeq %s %s\n", s.toChars(), ad.type.toChars());
-                                isAliasSeq = true;
-                            }
-                        }
-                        else if (auto ttp = (*parameters)[0].isTemplateTypeParameter())
-                        {
-                            if (ti.idents.length == 0 &&
-                                ti.ident is ttp.ident)
-                            {
-                                //printf("found isAlias %s %s\n", s.toChars(), ad.type.toChars());
-                                isAlias = true;
-                            }
-                        }
-                    }
-                }
+        onemember = s;
+        s.parent = this;
+
+        /* Set isTrivialAliasSeq if this fits the pattern:
+         *   template AliasSeq(T...) { alias AliasSeq = T; }
+         * or set isTrivialAlias if this fits the pattern:
+         *   template Alias(T) { alias Alias = qualifiers(T); }
+         */
+        if (!(parameters && parameters.length == 1))
+            return;
+
+        auto ad = s.isAliasDeclaration();
+        if (!ad || !ad.type)
+            return;
+
+        auto ti = ad.type.isTypeIdentifier();
+
+        if (!ti || ti.idents.length != 0)
+            return;
+
+        if (auto ttp = (*parameters)[0].isTemplateTupleParameter())
+        {
+            if (ti.ident is ttp.ident &&
+                ti.mod == 0)
+            {
+                //printf("found isTrivialAliasSeq %s %s\n", s.toChars(), ad.type.toChars());
+                isTrivialAliasSeq = true;
+            }
+        }
+        else if (auto ttp = (*parameters)[0].isTemplateTypeParameter())
+        {
+            if (ti.ident is ttp.ident)
+            {
+                //printf("found isTrivialAlias %s %s\n", s.toChars(), ad.type.toChars());
+                isTrivialAlias = true;
             }
         }
     }

src/dmd/template.h

@@ -66,8 +66,8 @@ class TemplateDeclaration : public ScopeDsymbol
     bool literal;               // this template declaration is a literal
     bool ismixin;               // template declaration is only to be used as a mixin
     bool isstatic;              // this is static template declaration
-    bool isAliasSeq;            // matches `template AliasSeq(T...) { alias AliasSeq = T; }
-    bool isAlias;               // matches `template Alias(T) { alias Alias = T; }
+    bool isTrivialAliasSeq;     // matches `template AliasSeq(T...) { alias AliasSeq = T; }
+    bool isTrivialAlias;        // matches pattern `template Alias(T) { alias Alias = qualifiers(T); }`
     Prot protection;
     int inuse;                  // for recursive expansion detection