Preview typefunctions

src/dmd/argtypes_x86.d

@@ -76,6 +76,7 @@ extern (C++) TypeTuple toArgTypes_x86(Type t)
             Type t2 = null;
             switch (t.ty)
             {
+            case Ttype:
             case Tvoid:
                 return;
             case Tbool:

src/dmd/astbase.d

@@ -167,6 +167,10 @@ struct ASTBase
 
         Tdelegate,
         Tnone,
+
+        Ttype,
+        Tempty,
+
         Tvoid,
         Tint8,
         Tuns8,
@@ -204,6 +208,7 @@ struct ASTBase
         Tuns128,
         Ttraits,
         Tmixin,
+        Texp,
         TMAX
     }
 
@@ -219,6 +224,8 @@ struct ASTBase
     alias Tenum = ENUMTY.Tenum;
     alias Tdelegate = ENUMTY.Tdelegate;
     alias Tnone = ENUMTY.Tnone;
+    alias Ttype = ENUMTY.Ttype;
+    alias Tempty = ENUMTY.Tempty;
     alias Tvoid = ENUMTY.Tvoid;
     alias Tint8 = ENUMTY.Tint8;
     alias Tuns8 = ENUMTY.Tuns8;
@@ -253,6 +260,7 @@ struct ASTBase
     alias Tuns128 = ENUMTY.Tuns128;
     alias Ttraits = ENUMTY.Ttraits;
     alias Tmixin = ENUMTY.Tmixin;
+    alias Texp = ENUMTY.Texp;
     alias TMAX = ENUMTY.TMAX;
 
     alias TY = ubyte;
@@ -2767,6 +2775,9 @@ struct ASTBase
         extern (C++) __gshared Type terror;      // for error recovery
         extern (C++) __gshared Type tnull;       // for null type
 
+        extern (C++) __gshared Type ttype;      // type of types
+        extern (C++) __gshared Type tempty;     // the empty type
+
         extern (C++) __gshared Type tsize_t;     // matches size_t alias
         extern (C++) __gshared Type tptrdiff_t;  // matches ptrdiff_t alias
         extern (C++) __gshared Type thash_t;     // matches hash_t alias
@@ -2814,6 +2825,7 @@ struct ASTBase
                 sizeTy[Tnull] = __traits(classInstanceSize, TypeNull);
                 sizeTy[Tvector] = __traits(classInstanceSize, TypeVector);
                 sizeTy[Tmixin] = __traits(classInstanceSize, TypeMixin);
+                sizeTy[Texp] = __traits(classInstanceSize, TypeExpression);
                 return sizeTy;
             }();
 
@@ -3573,6 +3585,7 @@ struct ASTBase
             inout(TypeSlice)      isTypeSlice()      { return ty == Tslice     ? cast(typeof(return))this : null; }
             inout(TypeNull)       isTypeNull()       { return ty == Tnull      ? cast(typeof(return))this : null; }
             inout(TypeMixin)      isTypeMixin()      { return ty == Tmixin     ? cast(typeof(return))this : null; }
+            inout(TypeExpression) isTypeExpression() { return ty == Texp       ? cast(typeof(return))this : null; }
             inout(TypeTraits)     isTypeTraits()     { return ty == Ttraits    ? cast(typeof(return))this : null; }
         }
 
@@ -4530,6 +4543,29 @@ struct ASTBase
         }
     }
 
+    extern (C++) final class TypeExpression : Type
+    {
+        Loc loc;
+        Expression exp;
+
+        extern (D) this(const ref Loc loc, Expression exp)
+        {
+            super(Texp);
+            this.loc = loc;
+            this.exp = exp;
+        }
+
+        override TypeExpression syntaxCopy()
+        {
+            return new TypeExpression(loc, exp.syntaxCopy());
+        }
+
+        override void accept(Visitor v)
+        {
+            v.visit(this);
+        }
+    }
+
     extern (C++) final class TypeIdentifier : TypeQualified
     {
         Identifier ident;

src/dmd/cli.d

@@ -794,6 +794,8 @@ dmd -cov -unittest myprog.d
             "'in' contracts of overridden methods must be a superset of parent contract"),
         Feature("shortenedMethods", "shortenedMethods",
             "allow use of => for methods and top-level functions in addition to lambdas"),
+        Feature("typefunctions", "sk_typefunctions",
+            "enables functions to work with type values, also known as Stefan Kochs type functions"),
         // DEPRECATED previews
         // trigger deprecation message once D repositories don't use this flag anymore
         Feature("markdown", "markdown", "enable Markdown replacements in Ddoc", false, false),

src/dmd/constfold.d

@@ -1727,6 +1727,7 @@ UnionExp Cat(Type type, Expression e1, Expression e2)
     }
     else if ((e1.op == TOK.arrayLiteral || e1.op == TOK.null_) && e1.type.toBasetype().nextOf() && e1.type.toBasetype().nextOf().equals(e2.type))
     {
+    L4:
         auto elems = (e1.op == TOK.arrayLiteral)
                 ? copyElements(e1) : new Expressions();
         elems.push(e2);
@@ -1791,8 +1792,16 @@ UnionExp Cat(Type type, Expression e1, Expression e2)
             e = ue.exp();
         }
     }
+    else if (e1.op == TOK.arrayLiteral && e2.op == TOK.type)
+    {
+        // when we have a type here we can just go the regular array cat
+        goto L4;
+    }
     else
+    {
+        //printf("don't know how to deal with exps.ops: {%s, %s}\n", Token.toChars(e1.op), Token.toChars(e2.op));
         cantExp(ue);
+    }
     assert(ue.exp().type);
     return ue;
 }

src/dmd/ctfeexpr.d

@@ -419,6 +419,11 @@ UnionExp copyLiteral(Expression e)
         emplaceExp!(UnionExp)(&ue, e);
         return ue;
     }
+    if (e.op == TOK.type)
+    {
+        emplaceExp!(TypeExp)(&ue, e.loc, e.type);
+        return ue;
+    }
     e.error("CTFE internal error: literal `%s`", e.toChars());
     assert(0);
 }
@@ -438,6 +443,14 @@ Expression paintTypeOntoLiteral(Type type, Expression lit)
 
 Expression paintTypeOntoLiteral(UnionExp* pue, Type type, Expression lit)
 {
+    // painting to alias is a no-op
+    if (type.ty == Ttype)
+    {
+        auto nlit = lit.copy();
+        //nlit.type = Type.talias;
+        return nlit;
+    }
+
     if (lit.type.equals(type))
         return lit;
     *pue = paintTypeOntoLiteralCopy(type, lit);
@@ -1574,6 +1587,11 @@ Expression ctfeCast(UnionExp* pue, const ref Loc loc, Type type, Type to, Expres
         return paintTypeOntoLiteral(pue, to, e);
     }
 
+    if (to.ty == Ttype)
+    {
+        return e;
+    }
+
     if (e.op == TOK.null_)
         return paint();
 
@@ -1600,7 +1618,7 @@ Expression ctfeCast(UnionExp* pue, const ref Loc loc, Type type, Type to, Expres
         return paint();
 
     Expression r;
-    if (e.type.equals(type) && type.equals(to))
+    if (((type is to && e.type is type) || (e.type.equals(type) && type.equals(to))))
     {
         // necessary not to change e's address for pointer comparisons
         r = e;
@@ -1903,6 +1921,11 @@ bool isCtfeValueValid(Expression newval)
         case TOK.void_:
             return true; // uninitialized value
 
+        case TOK._type__:
+        case TOK.emptyType_:
+        case TOK.scope_:
+            return global.params.sk_typefunctions ? true : false;
+
         default:
             newval.error("CTFE internal error: illegal CTFE value `%s`", newval.toChars());
             return false;

src/dmd/dcast.d

@@ -79,6 +79,14 @@ Expression implicitCastTo(Expression e, Scope* sc, Type t)
         {
             //printf("Expression.implicitCastTo(%s of type %s) => %s\n", e.toChars(), e.type.toChars(), t.toChars());
 
+            if (t.ty == Ttype)
+            {
+                // casts to Ttype just create a new castExp.
+                result = new CastExp(e.loc, e, t);
+                result.type = t;
+                return ;
+            }
+
             if (const match = e.implicitConvTo(t))
             {
                 if (match == MATCH.constant && (e.type.constConv(t) || !e.isLvalue() && e.type.equivalent(t)))
@@ -1437,8 +1445,17 @@ MATCH implicitConvTo(Expression e, Type t)
             if (tb.ty == Tpointer && e.e1.op == TOK.string_)
                 e.e1.accept(this);
         }
+
+        override void visit(TypeExp e)
+        {
+            // TODO FIXME this should work
+            // MATCH match = e.type.implicitConvTo(t);
+            if (t.ty == Ttype)
+                result = MATCH.convert;
+        }
     }
 
+
     scope ImplicitConvTo v = new ImplicitConvTo(t);
     e.accept(v);
     return v.result;

src/dmd/declaration.d

@@ -1226,7 +1226,7 @@ extern (C++) class VarDeclaration : Declaration
         const sz = t.size(loc);
         assert(sz != SIZE_INVALID && sz < uint.max);
         uint memsize = cast(uint)sz;                // size of member
-        uint memalignsize = target.fieldalign(t);   // size of member for alignment purposes
+        uint memalignsize = (t.ty == Ttype) ? 1 : target.fieldalign(t);   // size of member for alignment purposes
         offset = AggregateDeclaration.placeField(
             poffset,
             memsize, memalignsize, alignment,
@@ -1336,7 +1336,7 @@ extern (C++) class VarDeclaration : Declaration
      */
     final bool isCTFE()
     {
-        return (storage_class & STC.ctfe) != 0; // || !isDataseg();
+        return ((storage_class & STC.ctfe) != 0)  || isTypeType(type);
     }
 
     final bool isOverlappedWith(VarDeclaration v)