make TypeTraits semantic more clear and prevent invalid type swaps.

The switch over the traits expression gives a better control over what's accepted and how the matching type or symbol is extracted.
Previously using getType() as a default fallback could lead to an invalid type swap from the expression type to the type represented TypeTrait.

This commit also restores the getDsymbolWithoutExpCtx() function as it was before the implementation of TypeTraits.

src/dmd/traits.d

@@ -69,16 +69,14 @@ enum LOGSEMANTIC = false;
  * Returns:
  *      Dsymbol  the corresponding symbol for oarg
  */
-Dsymbol getDsymbolWithoutExpCtx(RootObject oarg)
+private Dsymbol getDsymbolWithoutExpCtx(RootObject oarg)
 {
     if (auto e = isExpression(oarg))
     {
         if (e.op == TOK.dotVariable)
             return (cast(DotVarExp)e).var;
         if (e.op == TOK.dotTemplateDeclaration)
             return (cast(DotTemplateExp)e).td;
-        if (e.op == TOK.scope_)
-            return (cast(ScopeExp)e).sds;
     }
     return getDsymbol(oarg);
 }

src/dmd/typesem.d

@@ -1624,22 +1624,44 @@ extern(C++) Type typeSemantic(Type t, Loc loc, Scope* sc)
             return mtype;
         }
 
-        import dmd.traits : semanticTraits, getDsymbolWithoutExpCtx;
+        import dmd.traits : semanticTraits;
         Type result;
 
         if (Expression e = semanticTraits(mtype.exp, sc))
         {
-            if (TupleExp te = e.toTupleExp)
-                mtype.sym = new TupleDeclaration(mtype.loc,
-                    Identifier.generateId("__aliastup"), cast(Objects*) te.exps);
-            else if (Dsymbol ds = getDsymbol(e))
-                mtype.sym = ds;
-            else if (Dsymbol ds = getDsymbolWithoutExpCtx(e))
-                mtype.sym = ds;
-            else if (Type t = getType(e))
-                result = t.addMod(mtype.mod);
+            switch (e.op)
+            {
+            case TOK.dotVariable:
+                mtype.sym = (cast(DotVarExp)e).var;
+                break;
+            case TOK.variable:
+                mtype.sym = (cast(VarExp)e).var;
+                break;
+            case TOK.dotTemplateDeclaration:
+                mtype.sym = (cast(DotTemplateExp)e).td;
+                break;
+            case TOK.dSymbol:
+                mtype.sym = (cast(DsymbolExp)e).s;
+                break;
+            case TOK.scope_:
+                mtype.sym = (cast(ScopeExp)e).sds;
+                break;
+            case TOK.tuple:
+                mtype.sym = new TupleDeclaration(e.loc,
+                    Identifier.generateId("__aliastup"), cast(Objects*) e.toTupleExp.exps);
+                break;
+            case TOK.dotType:
+                result = (cast(DotTypeExp)e).sym.isType();
+                break;
+            case TOK.type:
+                result = (cast(TypeExp)e).type;
+                break;
+            default:
+            }
         }
 
+        if (result)
+            result = result.addMod(mtype.mod);
         if (!mtype.inAliasDeclaration && !result)
         {
             if (!global.errors)