
/* Compiler implementation of the D programming language
 * Copyright (C) 1999-2021 by The D Language Foundation, All Rights Reserved
 * written by Walter Bright
 * http://www.digitalmars.com
 * Distributed under the Boost Software License, Version 1.0.
 * http://www.boost.org/LICENSE_1_0.txt
 */

#include "root/dsystem.h"
#include "root/checkedint.h"

#include "mtype.h"
#include "aggregate.h"
#include "enum.h"
#include "errors.h"
#include "expression.h"
#include "hdrgen.h"
#include "id.h"
#include "init.h"
#include "parse.h"
#include "scope.h"
#include "target.h"
#include "template.h"
#include "visitor.h"

Expression *typeToExpression(Type *t);
Expression *typeToExpressionHelper(TypeQualified *t, Expression *e, size_t i = 0);
bool expressionsToString(OutBuffer &buf, Scope *sc, Expressions *exps);
char *MODtoChars(MOD mod);

class TypeToExpressionVisitor : public Visitor
{
public:
    Expression *result;
    Type *itype;

    TypeToExpressionVisitor(Type *itype)
    {
        this->result = NULL;
        this->itype = itype;
    }

    void visit(Type *)
    {
        result = NULL;
    }

    void visit(TypeSArray *t)
    {
        Expression *e = typeToExpression(t->next);
        if (e)
            e = new ArrayExp(t->dim->loc, e, t->dim);
        result = e;
    }

    void visit(TypeAArray *t)
    {
        Expression *e = typeToExpression(t->next);
        if (e)
        {
            Expression *ei = typeToExpression(t->index);
            if (ei)
            {
                result = new ArrayExp(t->loc, e, ei);
                return;
            }
        }
        result = NULL;
    }

    void visit(TypeIdentifier *t)
    {
        result = typeToExpressionHelper(t, new IdentifierExp(t->loc, t->ident));
    }

    void visit(TypeInstance *t)
    {
        result = typeToExpressionHelper(t, new ScopeExp(t->loc, t->tempinst));
    }

    void visit(TypeMixin *t)
    {
        result = new TypeExp(t->loc, t);
    }
};

/* We've mistakenly parsed this as a type.
 * Redo it as an Expression.
 * NULL if cannot.
 */
Expression *typeToExpression(Type *t)
{
    if (t->mod)
        return NULL;
    TypeToExpressionVisitor v = TypeToExpressionVisitor(t);
    t->accept(&v);
    return v.result;
}

/* Helper function for `typeToExpression`. Contains common code
 * for TypeQualified derived classes.
 */
Expression *typeToExpressionHelper(TypeQualified *t, Expression *e, size_t i)
{
    //printf("toExpressionHelper(e = %s %s)\n", Token::toChars(e->op), e->toChars());
    for (; i < t->idents.length; i++)
    {
        RootObject *id = t->idents[i];
        //printf("\t[%d] e: '%s', id: '%s'\n", i, e->toChars(), id->toChars());

        switch (id->dyncast())
        {
            case DYNCAST_IDENTIFIER:
            {
                // ... '. ident'
                e = new DotIdExp(e->loc, e, (Identifier *)id);
                break;
            }
            case DYNCAST_DSYMBOL:
            {
                // ... '. name!(tiargs)'
                TemplateInstance *ti = ((Dsymbol *)id)->isTemplateInstance();
                assert(ti);
                e = new DotTemplateInstanceExp(e->loc, e, ti->name, ti->tiargs);
                break;
            }
            case DYNCAST_TYPE:          // Bugzilla 1215
            {
                // ... '[type]'
                e = new ArrayExp(t->loc, e, new TypeExp(t->loc, (Type *)id));
                break;
            }
            case DYNCAST_EXPRESSION:    // Bugzilla 1215
            {
                // ... '[expr]'
                e = new ArrayExp(t->loc, e, (Expression *)id);
                break;
            }
            default:
                assert(0);
        }
    }
    return e;
}

/**************************
 * This evaluates exp while setting length to be the number
 * of elements in the tuple t.
 */
static Expression *semanticLength(Scope *sc, Type *t, Expression *exp)
{
    if (t->ty == Ttuple)
    {
        ScopeDsymbol *sym = new ArrayScopeSymbol(sc, (TypeTuple *)t);
        sym->parent = sc->scopesym;
        sc = sc->push(sym);

        sc = sc->startCTFE();
        exp = expressionSemantic(exp, sc);
        sc = sc->endCTFE();

        sc->pop();
    }
    else
    {
        sc = sc->startCTFE();
        exp = expressionSemantic(exp, sc);
        sc = sc->endCTFE();
    }

    return exp;
}

static Expression *semanticLength(Scope *sc, TupleDeclaration *s, Expression *exp)
{
    ScopeDsymbol *sym = new ArrayScopeSymbol(sc, s);
    sym->parent = sc->scopesym;
    sc = sc->push(sym);

    sc = sc->startCTFE();
    exp = expressionSemantic(exp, sc);
    sc = sc->endCTFE();

    sc->pop();
    return exp;
}

/******************************************
 * Compile the MixinType, returning the type or expression AST.
 *
 * Doesn't run semantic() on the returned object.
 * Params:
 *      tm = mixin to compile as a type or expression
 *      loc = location for error messages
 *      sc = context
 * Return:
 *      null if error, else RootObject AST as parsed
 */
RootObject *compileTypeMixin(TypeMixin *tm, Loc loc, Scope *sc)
{
    OutBuffer buf;
    if (expressionsToString(buf, sc, tm->exps))
        return NULL;

    const unsigned errors = global.errors;
    const size_t len = buf.length();
    const char *str = buf.extractChars();
    Parser p(loc, sc->_module, (const utf8_t *)str, len, false);
    p.nextToken();
    //printf("p.loc.linnum = %d\n", p.loc.linnum);

    RootObject *o = p.parseTypeOrAssignExp(TOKeof);
    if (errors != global.errors)
    {
        assert(global.errors != errors); // should have caught all these cases
        return NULL;
    }
    if (p.token.value != TOKeof)
    {
        ::error(loc, "incomplete mixin type `%s`", str);
        return NULL;
    }

    Type *t = isType(o);
    Expression *e = t ? typeToExpression(t) : isExpression(o);

    return (!e && t) ? (RootObject *)t : (RootObject *)e;
}

/******************************************
 * Perform semantic analysis on a type.
 * Params:
 *      type = Type AST node
 *      loc = the location of the type
 *      sc = context
 * Returns:
 *      `Type` with completed semantic analysis, `Terror` if errors
 *      were encountered
 */
Type *typeSemantic(Type *type, const Loc &loc, Scope *sc)
{
    class TypeSemanticVisitor : public Visitor
    {
    public:
        Loc loc;
        Scope *sc;
        Type *result;

        TypeSemanticVisitor(const Loc &loc, Scope *sc)
        {
            this->loc = loc;
            this->sc = sc;
            this->result = NULL;
        }

    private:
        void error()
        {
            result = Type::terror;
        }

    public:
        void visit(Type *t)
        {
            if (t->ty == Tint128 || t->ty == Tuns128)
            {
                ::error(loc, "cent and ucent types not implemented");
                return error();
            }

            result = t->merge();
        }

        void visit(TypeVector *mtype)
        {
            unsigned int errors = global.errors;
            mtype->basetype = typeSemantic(mtype->basetype, loc, sc);
            if (errors != global.errors)
                return error();
            mtype->basetype = mtype->basetype->toBasetype()->mutableOf();
            if (mtype->basetype->ty != Tsarray)
            {
                ::error(loc, "T in __vector(T) must be a static array, not %s", mtype->basetype->toChars());
                return error();
            }
            TypeSArray *t = (TypeSArray *)mtype->basetype;
            int sz = (int)t->size(loc);
            switch (target.isVectorTypeSupported(sz, t->nextOf()))
            {
            case 0: // valid
                break;
            case 1: // no support at all
                ::error(loc, "SIMD vector types not supported on this platform");
                return error();
            case 2: // invalid base type
                ::error(loc, "vector type %s is not supported on this platform", mtype->toChars());
                return error();
            case 3: // invalid size
                ::error(loc, "%d byte vector type %s is not supported on this platform", sz, mtype->toChars());
                return error();
            default:
                assert(0);
            }
            result = mtype->merge();
        }

        void visit(TypeSArray *mtype)
        {
            //printf("TypeSArray::semantic() %s\n", mtype->toChars());

            Type *t;
            Expression *e;
            Dsymbol *s;
            mtype->next->resolve(loc, sc, &e, &t, &s);

            if (mtype->dim && s && s->isTupleDeclaration())
            {
                TupleDeclaration *sd = s->isTupleDeclaration();

                mtype->dim = semanticLength(sc, sd, mtype->dim);
                mtype->dim = mtype->dim->ctfeInterpret();
                if(mtype->dim->op == TOKerror)
                    return error();

                uinteger_t d = mtype->dim->toUInteger();
                if (d >= sd->objects->length)
                {
                    ::error(loc, "tuple index %llu exceeds %llu", (unsigned long long)d, (unsigned long long)sd->objects->length);
                    return error();
                }

                RootObject *o = (*sd->objects)[(size_t)d];
                if (o->dyncast() != DYNCAST_TYPE)
                {
                    ::error(loc, "%s is not a type", mtype->toChars());
                    return error();
                }
                result = ((Type *)o)->addMod(mtype->mod);
                return;
            }

            if (t && t->ty == Terror)
                return error();

            Type *tn = typeSemantic(mtype->next, loc, sc);
            if (tn->ty == Terror)
                return error();

            Type *tbn = tn->toBasetype();
            if (mtype->dim)
            {
                unsigned int errors = global.errors;
                mtype->dim = semanticLength(sc, tbn, mtype->dim);
                if (errors != global.errors)
                    return error();

                mtype->dim = mtype->dim->optimize(WANTvalue);
                mtype->dim = mtype->dim->ctfeInterpret();
                if (mtype->dim->op == TOKerror)
                    return error();
                errors = global.errors;
                dinteger_t d1 = mtype->dim->toInteger();
                if (errors != global.errors)
                    return error();

                mtype->dim = mtype->dim->implicitCastTo(sc, Type::tsize_t);
                mtype->dim = mtype->dim->optimize(WANTvalue);
                if (mtype->dim->op == TOKerror)
                    return error();
                errors = global.errors;
                dinteger_t d2 = mtype->dim->toInteger();
                if (errors != global.errors)
                    return error();

                if (mtype->dim->op == TOKerror)
                    return error();

                if (d1 != d2)
                {
                Loverflow:
                    ::error(loc, "%s size %llu * %llu exceeds 0x%llx size limit for static array",
                          mtype->toChars(), (unsigned long long)tbn->size(loc), (unsigned long long)d1, target.maxStaticDataSize);
                    return error();
                }

                Type *tbx = tbn->baseElemOf();
                if ((tbx->ty == Tstruct && !((TypeStruct *)tbx)->sym->members) ||
                    (tbx->ty == Tenum && !((TypeEnum *)tbx)->sym->members))
                {
                    /* To avoid meaningless error message, skip the total size limit check
                     * when the bottom of element type is opaque.
                     */
                }
                else if (tbn->isTypeBasic() ||
                         tbn->ty == Tpointer ||
                         tbn->ty == Tarray ||
                         tbn->ty == Tsarray ||
                         tbn->ty == Taarray ||
                         (tbn->ty == Tstruct && (((TypeStruct *)tbn)->sym->sizeok == SIZEOKdone)) ||
                         tbn->ty == Tclass)
                {
                    /* Only do this for types that don't need to have semantic()
                     * run on them for the size, since they may be forward referenced.
                     */
                    bool overflow = false;
                    if (mulu(tbn->size(loc), d2, overflow) >= target.maxStaticDataSize || overflow)
                        goto Loverflow;
                }
            }
            switch (tbn->ty)
            {
                case Ttuple:
                {
                    // Index the tuple to get the type
                    assert(mtype->dim);
                    TypeTuple *tt = (TypeTuple *)tbn;
                    uinteger_t d = mtype->dim->toUInteger();
                    if (d >= tt->arguments->length)
                    {
                        ::error(loc, "tuple index %llu exceeds %llu", (unsigned long long)d, (unsigned long long)tt->arguments->length);
                        return error();
                    }
                    Type *telem = (*tt->arguments)[(size_t)d]->type;
                    result = telem->addMod(mtype->mod);
                    return;
                }
                case Tfunction:
                case Tnone:
                    ::error(loc, "cannot have array of %s", tbn->toChars());
                    return error();
                default:
                    break;
            }
            if (tbn->isscope())
            {
                ::error(loc, "cannot have array of scope %s", tbn->toChars());
                return error();
            }

            /* Ensure things like const(immutable(T)[3]) become immutable(T[3])
             * and const(T)[3] become const(T[3])
             */
            mtype->next = tn;
            mtype->transitive();
            result = mtype->addMod(tn->mod)->merge();
        }

        void visit(TypeDArray *mtype)
        {
            Type *tn = typeSemantic(mtype->next, loc,sc);
            Type *tbn = tn->toBasetype();
            switch (tbn->ty)
            {
                case Ttuple:
                    result = tbn;
                    return;
                case Tfunction:
                case Tnone:
                    ::error(loc, "cannot have array of %s", tbn->toChars());
                    return error();
                case Terror:
                    return error();
                default:
                    break;
            }
            if (tn->isscope())
            {
                ::error(loc, "cannot have array of scope %s", tn->toChars());
                return error();
            }
            mtype->next = tn;
            mtype->transitive();
            result = mtype->merge();
        }

        void visit(TypeAArray *mtype)
        {
            //printf("TypeAArray::semantic() %s index->ty = %d\n", mtype->toChars(), mtype->index->ty);
            if (mtype->deco)
            {
                result = mtype;
                return;
            }

            mtype->loc = loc;
            mtype->sc = sc;
            if (sc)
                sc->setNoFree();

            // Deal with the case where we thought the index was a type, but
            // in reality it was an expression.
            if (mtype->index->ty == Tident || mtype->index->ty == Tinstance || mtype->index->ty == Tsarray ||
                mtype->index->ty == Ttypeof || mtype->index->ty == Treturn || mtype->index->ty == Tmixin)
            {
                Expression *e;
                Type *t;
                Dsymbol *s;

                mtype->index->resolve(loc, sc, &e, &t, &s);
                if (e)
                {
                    // It was an expression -
                    // Rewrite as a static array
                    TypeSArray *tsa = new TypeSArray(mtype->next, e);
                    result = typeSemantic(tsa, loc, sc);
                    return;
                }
                else if (t)
                    mtype->index = typeSemantic(t, loc, sc);
                else
                {
                    mtype->index->error(loc, "index is not a type or an expression");
                    return error();
                }
            }
            else
                mtype->index = typeSemantic(mtype->index, loc,sc);
            mtype->index = mtype->index->merge2();

            if (mtype->index->nextOf() && !mtype->index->nextOf()->isImmutable())
            {
                mtype->index = mtype->index->constOf()->mutableOf();
            }

            switch (mtype->index->toBasetype()->ty)
            {
                case Tfunction:
                case Tvoid:
                case Tnone:
                case Ttuple:
                    ::error(loc, "cannot have associative array key of %s", mtype->index->toBasetype()->toChars());
                    /* fall through */
                case Terror:
                    return error();
                default:
                    break;
            }
            Type *tbase = mtype->index->baseElemOf();
            while (tbase->ty == Tarray)
                tbase = tbase->nextOf()->baseElemOf();
            if (tbase->ty == Tstruct)
            {
                /* AA's need typeid(index).equals() and getHash(). Issue error if not correctly set up.
                 */
                StructDeclaration *sd = ((TypeStruct *)tbase)->sym;
                if (sd->semanticRun < PASSsemanticdone)
                    dsymbolSemantic(sd, NULL);

                // duplicate a part of StructDeclaration::semanticTypeInfoMembers
                //printf("AA = %s, key: xeq = %p, xerreq = %p xhash = %p\n", mtype->toChars(), sd->xeq, sd->xerreq, sd->xhash);
                if (sd->xeq &&
                    sd->xeq->_scope &&
                    sd->xeq->semanticRun < PASSsemantic3done)
                {
                    unsigned errors = global.startGagging();
                    semantic3(sd->xeq, sd->xeq->_scope);
                    if (global.endGagging(errors))
                        sd->xeq = sd->xerreq;
                }

                const char *s = (mtype->index->toBasetype()->ty != Tstruct) ? "bottom of " : "";
                if (!sd->xeq)
                {
                    // If sd->xhash != NULL:
                    //   sd or its fields have user-defined toHash.
                    //   AA assumes that its result is consistent with bitwise equality.
                    // else:
                    //   bitwise equality & hashing
                }
                else if (sd->xeq == sd->xerreq)
                {
                    if (search_function(sd, Id::eq))
                    {
                        ::error(loc, "%sAA key type %s does not have `bool opEquals(ref const %s) const`",
                                s, sd->toChars(), sd->toChars());
                    }
                    else
                    {
                        ::error(loc, "%sAA key type %s does not support const equality",
                                s, sd->toChars());
                    }
                    return error();
                }
                else if (!sd->xhash)
                {
                    if (search_function(sd, Id::eq))
                    {
                        ::error(loc, "%sAA key type %s should have `size_t toHash() const nothrow @safe` if opEquals defined",
                                s, sd->toChars());
                    }
                    else
                    {
                        ::error(loc, "%sAA key type %s supports const equality but doesn't support const hashing",
                                s, sd->toChars());
                    }
                    return error();
                }
                else
                {
                    // defined equality & hashing
                    assert(sd->xeq && sd->xhash);

                    /* xeq and xhash may be implicitly defined by compiler. For example:
                     *   struct S { int[] arr; }
                     * With 'arr' field equality and hashing, compiler will implicitly
                     * generate functions for xopEquals and xtoHash in TypeInfo_Struct.
                     */
                }
            }
            else if (tbase->ty == Tclass && !((TypeClass *)tbase)->sym->isInterfaceDeclaration())
            {
                ClassDeclaration *cd = ((TypeClass *)tbase)->sym;
                if (cd->semanticRun < PASSsemanticdone)
                    dsymbolSemantic(cd, NULL);

                if (!ClassDeclaration::object)
                {
                    ::error(Loc(), "missing or corrupt object.d");
                    fatal();
                }

                static FuncDeclaration *feq   = NULL;
                static FuncDeclaration *fcmp  = NULL;
                static FuncDeclaration *fhash = NULL;
                if (!feq)   feq   = search_function(ClassDeclaration::object, Id::eq)->isFuncDeclaration();
                if (!fcmp)  fcmp  = search_function(ClassDeclaration::object, Id::cmp)->isFuncDeclaration();
                if (!fhash) fhash = search_function(ClassDeclaration::object, Id::tohash)->isFuncDeclaration();
                assert(fcmp && feq && fhash);

                if (feq->vtblIndex < (int)cd->vtbl.length && cd->vtbl[feq ->vtblIndex] == feq)
                {
                    if (fcmp->vtblIndex < (int)cd->vtbl.length && cd->vtbl[fcmp->vtblIndex] != fcmp)
                    {
                        const char *s = (mtype->index->toBasetype()->ty != Tclass) ? "bottom of " : "";
                        ::error(loc, "%sAA key type %s now requires equality rather than comparison",
                            s, cd->toChars());
                        errorSupplemental(loc, "Please override Object.opEquals and toHash.");
                    }
                }
            }
            mtype->next = typeSemantic(mtype->next, loc,sc)->merge2();
            mtype->transitive();

            switch (mtype->next->toBasetype()->ty)
            {
                case Tfunction:
                case Tvoid:
                case Tnone:
                case Ttuple:
                    ::error(loc, "cannot have associative array of %s", mtype->next->toChars());
                    /* fall through */
                case Terror:
                    return error();
            }
            if (mtype->next->isscope())
            {
                ::error(loc, "cannot have array of scope %s", mtype->next->toChars());
                return error();
            }
            result = mtype->merge();
        }

        void visit(TypePointer *mtype)
        {
            //printf("TypePointer::semantic() %s\n", mtype->toChars());
            if (mtype->deco)
            {
                result = mtype;
                return;
            }
            Type *n = typeSemantic(mtype->next, loc, sc);
            switch (n->toBasetype()->ty)
            {
                case Ttuple:
                    ::error(loc, "cannot have pointer to %s", n->toChars());
                    /* fall through */
                case Terror:
                    return error();
                default:
                    break;
            }
            if (n != mtype->next)
            {
                mtype->deco = NULL;
            }
            mtype->next = n;
            if (mtype->next->ty != Tfunction)
            {
                mtype->transitive();
                result = mtype->merge();
                return;
            }
            mtype->deco = mtype->merge()->deco;
            /* Don't return merge(), because arg identifiers and default args
             * can be different
             * even though the types match
             */
            result = mtype;
        }

        void visit(TypeReference *mtype)
        {
            //printf("TypeReference::semantic()\n");
            Type *n = typeSemantic(mtype->next, loc, sc);
            if (n != mtype->next)
                mtype->deco = NULL;
            mtype->next = n;
            mtype->transitive();
            result = mtype->merge();
        }


        void visit(TypeFunction *mtype)
        {
            if (mtype->deco)                   // if semantic() already run
            {
                //printf("already done\n");
                result = mtype;
                return;
            }
            //printf("TypeFunction::semantic() this = %p\n", this);
            //printf("TypeFunction::semantic() %s, sc->stc = %llx, fargs = %p\n", mtype->toChars(), sc->stc, mtype->fargs);

            bool errors = false;

            if (mtype->inuse > global.recursionLimit)
            {
                mtype->inuse = 0;
                ::error(loc, "recursive type");
                return error();
            }

            /* Copy in order to not mess up original.
             * This can produce redundant copies if inferring return type,
             * as semantic() will get called again on this.
             */
            TypeFunction *tf = mtype->copy()->toTypeFunction();
            if (mtype->parameterList.parameters)
            {
                tf->parameterList.parameters = mtype->parameterList.parameters->copy();
                for (size_t i = 0; i < mtype->parameterList.parameters->length; i++)
                {
                    void *pp = mem.xmalloc(sizeof(Parameter));
                    Parameter *p = (Parameter *)memcpy(pp, (void *)(*mtype->parameterList.parameters)[i],
                                                       sizeof(Parameter));
                    (*tf->parameterList.parameters)[i] = p;
                }
            }

            if (sc->stc & STCpure)
                tf->purity = PUREfwdref;
            if (sc->stc & STCnothrow)
                tf->isnothrow = true;
            if (sc->stc & STCnogc)
                tf->isnogc = true;
            if (sc->stc & STCref)
                tf->isref = true;
            if (sc->stc & STCreturn)
                tf->isreturn = true;
            if (sc->stc & STCscope)
                tf->isscope = true;
            if (sc->stc & STCscopeinferred)
                tf->isscopeinferred = true;
            //if ((sc->stc & (STCreturn | STCref)) == STCreturn)
            //    tf->isscope = true; // return by itself means 'return scope'

            if (tf->trust == TRUSTdefault)
            {
                if (sc->stc & STCsafe)
                    tf->trust = TRUSTsafe;
                if (sc->stc & STCsystem)
                    tf->trust = TRUSTsystem;
                if (sc->stc & STCtrusted)
                    tf->trust = TRUSTtrusted;
            }

            if (sc->stc & STCproperty)
                tf->isproperty = true;

            tf->linkage = sc->linkage;
            bool wildreturn = false;
            if (tf->next)
            {
                sc = sc->push();
                sc->stc &= ~(STC_TYPECTOR | STC_FUNCATTR);
                tf->next = typeSemantic(tf->next, loc, sc);
                sc = sc->pop();
                errors |= tf->checkRetType(loc);
                if (tf->next->isscope() && !(sc->flags & SCOPEctor))
                {
                    ::error(loc, "functions cannot return scope %s", tf->next->toChars());
                    errors = true;
                }
                if (tf->next->hasWild())
                    wildreturn = true;

                if (tf->isreturn && !tf->isref && !tf->next->hasPointers())
                {
                    tf->isreturn = false;
                }
            }

            unsigned char wildparams = 0;
            if (tf->parameterList.parameters)
            {
                /* Create a scope for evaluating the default arguments for the parameters
                 */
                Scope *argsc = sc->push();
                argsc->stc = 0;                 // don't inherit storage class
                argsc->protection = Prot(Prot::public_);
                argsc->func = NULL;

                size_t dim = tf->parameterList.length();
                for (size_t i = 0; i < dim; i++)
                {
                    Parameter *fparam = tf->parameterList[i];
                    mtype->inuse++;
                    fparam->type = typeSemantic(fparam->type, loc, argsc);
                    mtype->inuse--;

                    if (fparam->type->ty == Terror)
                    {
                        errors = true;
                        continue;
                    }

                    fparam->type = fparam->type->addStorageClass(fparam->storageClass);

                    if (fparam->storageClass & (STCauto | STCalias | STCstatic))
                    {
                        if (!fparam->type)
                            continue;
                    }

                    Type *t = fparam->type->toBasetype();

                    if (t->ty == Tfunction)
                    {
                        ::error(loc, "cannot have parameter of function type %s", fparam->type->toChars());
                        errors = true;
                    }
                    else if (!(fparam->storageClass & (STCref | STCout)) &&
                             (t->ty == Tstruct || t->ty == Tsarray || t->ty == Tenum))
                    {
                        Type *tb2 = t->baseElemOf();
                        if ((tb2->ty == Tstruct && !((TypeStruct *)tb2)->sym->members) ||
                            (tb2->ty == Tenum && !((TypeEnum *)tb2)->sym->memtype))
                        {
                            ::error(loc, "cannot have parameter of opaque type %s by value", fparam->type->toChars());
                            errors = true;
                        }
                    }
                    else if (!(fparam->storageClass & STClazy) && t->ty == Tvoid)
                    {
                        ::error(loc, "cannot have parameter of type %s", fparam->type->toChars());
                        errors = true;
                    }

                    if ((fparam->storageClass & (STCref | STCwild)) == (STCref | STCwild))
                    {
                        // 'ref inout' implies 'return'
                        fparam->storageClass |= STCreturn;
                    }

                    if (fparam->storageClass & STCreturn)
                    {
                        if (fparam->storageClass & (STCref | STCout))
                        {
                            // Disabled for the moment awaiting improvement to allow return by ref
                            // to be transformed into return by scope.
                            if (0 && !tf->isref)
                            {
                                StorageClass stc = fparam->storageClass & (STCref | STCout);
                                ::error(loc, "parameter `%s` is `return %s` but function does not return by `ref`",
                                    fparam->ident ? fparam->ident->toChars() : "",
                                    stcToChars(stc));
                                errors = true;
                            }
                        }
                        else
                        {
                            fparam->storageClass |= STCscope;        // 'return' implies 'scope'
                            if (tf->isref)
                            {
                            }
                            else if (!tf->isref && tf->next && !tf->next->hasPointers())
                            {
                                fparam->storageClass &= STCreturn;   // https://issues.dlang.org/show_bug.cgi?id=18963
                            }
                        }
                    }

                    if (fparam->storageClass & (STCref | STClazy))
                    {
                    }
                    else if (fparam->storageClass & STCout)
                    {
                        if (unsigned char m = fparam->type->mod & (MODimmutable | MODconst | MODwild))
                        {
                            ::error(loc, "cannot have %s out parameter of type %s", MODtoChars(m), t->toChars());
                            errors = true;
                        }
                        else
                        {
                            Type *tv = t;
                            while (tv->ty == Tsarray)
                                tv = tv->nextOf()->toBasetype();
                            if (tv->ty == Tstruct && ((TypeStruct *)tv)->sym->noDefaultCtor)
                            {
                                ::error(loc, "cannot have out parameter of type %s because the default construction is disabled",
                                    fparam->type->toChars());
                                errors = true;
                            }
                        }
                    }

                    if (fparam->storageClass & STCscope && !fparam->type->hasPointers() && fparam->type->ty != Ttuple)
                    {
                        fparam->storageClass &= ~STCscope;
                        if (!(fparam->storageClass & STCref))
                            fparam->storageClass &= ~STCreturn;
                    }

                    if (t->hasWild())
                    {
                        wildparams |= 1;
                        //if (tf->next && !wildreturn)
                        //    ::error(loc, "inout on parameter means inout must be on return type as well (if from D1 code, replace with `ref`)");
                    }

                    if (fparam->defaultArg)
                    {
                        Expression *e = fparam->defaultArg;
                        if (fparam->storageClass & (STCref | STCout))
                        {
                            e = expressionSemantic(e, argsc);
                            e = resolveProperties(argsc, e);
                        }
                        else
                        {
                            e = inferType(e, fparam->type);
                            Initializer *iz = new ExpInitializer(e->loc, e);
                            iz = initializerSemantic(iz, argsc, fparam->type, INITnointerpret);
                            e = initializerToExpression(iz);
                        }
                        if (e->op == TOKfunction)               // see Bugzilla 4820
                        {
                            FuncExp *fe = (FuncExp *)e;
                            // Replace function literal with a function symbol,
                            // since default arg expression must be copied when used
                            // and copying the literal itself is wrong.
                            e = new VarExp(e->loc, fe->fd, false);
                            e = new AddrExp(e->loc, e);
                            e = expressionSemantic(e, argsc);
                        }
                        e = e->implicitCastTo(argsc, fparam->type);

                        // default arg must be an lvalue
                        if (fparam->storageClass & (STCout | STCref))
                            e = e->toLvalue(argsc, e);

                        fparam->defaultArg = e;
                        if (e->op == TOKerror)
                            errors = true;
                    }

                    /* If fparam after semantic() turns out to be a tuple, the number of parameters may
                     * change.
                     */
                    if (t->ty == Ttuple)
                    {
                        /* TypeFunction::parameter also is used as the storage of
                         * Parameter objects for FuncDeclaration. So we should copy
                         * the elements of TypeTuple::arguments to avoid unintended
                         * sharing of Parameter object among other functions.
                         */
                        TypeTuple *tt = (TypeTuple *)t;
                        if (tt->arguments && tt->arguments->length)
                        {
                            /* Propagate additional storage class from tuple parameters to their
                             * element-parameters.
                             * Make a copy, as original may be referenced elsewhere.
                             */
                            size_t tdim = tt->arguments->length;
                            Parameters *newparams = new Parameters();
                            newparams->setDim(tdim);
                            for (size_t j = 0; j < tdim; j++)
                            {
                                Parameter *narg = (*tt->arguments)[j];

                                // Bugzilla 12744: If the storage classes of narg
                                // conflict with the ones in fparam, it's ignored.
                                StorageClass stc  = fparam->storageClass | narg->storageClass;
                                StorageClass stc1 = fparam->storageClass & (STCref | STCout | STClazy);
                                StorageClass stc2 =   narg->storageClass & (STCref | STCout | STClazy);
                                if (stc1 && stc2 && stc1 != stc2)
                                {
                                    OutBuffer buf1;  stcToBuffer(&buf1, stc1 | ((stc1 & STCref) ? (fparam->storageClass & STCauto) : 0));
                                    OutBuffer buf2;  stcToBuffer(&buf2, stc2);

                                    ::error(loc, "incompatible parameter storage classes `%s` and `%s`",
                                              buf1.peekChars(), buf2.peekChars());
                                    errors = true;
                                    stc = stc1 | (stc & ~(STCref | STCout | STClazy));
                                }

                                (*newparams)[j] = new Parameter(
                                        stc, narg->type, narg->ident, narg->defaultArg, narg->userAttribDecl);
                            }
                            fparam->type = new TypeTuple(newparams);
                        }
                        fparam->storageClass = 0;

                        /* Reset number of parameters, and back up one to do this fparam again,
                         * now that it is a tuple
                         */
                        dim = tf->parameterList.length();
                        i--;
                        continue;
                    }

                    /* Resolve "auto ref" storage class to be either ref or value,
                     * based on the argument matching the parameter
                     */
                    if (fparam->storageClass & STCauto)
                    {
                        if (mtype->fargs && i < mtype->fargs->length && (fparam->storageClass & STCref))
                        {
                            Expression *farg = (*mtype->fargs)[i];
                            if (farg->isLvalue())
                                ;                               // ref parameter
                            else
                                fparam->storageClass &= ~STCref;        // value parameter
                            fparam->storageClass &= ~STCauto;    // Bugzilla 14656
                            fparam->storageClass |= STCautoref;
                        }
                        else
                        {
                            ::error(loc, "`auto` can only be used as part of `auto ref` for template function parameters");
                            errors = true;
                        }
                    }

                    // Remove redundant storage classes for type, they are already applied
                    fparam->storageClass &= ~(STC_TYPECTOR | STCin);
                }
                argsc->pop();
            }
            if (tf->isWild())
                wildparams |= 2;

            if (wildreturn && !wildparams)
            {
                ::error(loc, "inout on return means inout must be on a parameter as well for %s", mtype->toChars());
                errors = true;
            }
            tf->iswild = wildparams;

            if (tf->isproperty && (tf->parameterList.varargs != VARARGnone || tf->parameterList.length() > 2))
            {
                ::error(loc, "properties can only have zero, one, or two parameter");
                errors = true;
            }

            if (tf->parameterList.varargs == VARARGvariadic && tf->linkage != LINKd && tf->parameterList.length() == 0)
            {
                ::error(loc, "variadic functions with non-D linkage must have at least one parameter");
                errors = true;
            }

            if (errors)
                return error();

            if (tf->next)
                tf->deco = tf->merge()->deco;

            /* Don't return merge(), because arg identifiers and default args
             * can be different
             * even though the types match
             */
            result = tf;
        }

        void visit(TypeDelegate *mtype)
        {
            //printf("TypeDelegate::semantic() %s\n", mtype->toChars());
            if (mtype->deco)                   // if semantic() already run
            {
                //printf("already done\n");
                result = mtype;
                return;
            }
            mtype->next = typeSemantic(mtype->next, loc,sc);
            if (mtype->next->ty != Tfunction)
                return error();

            /* In order to deal with Bugzilla 4028, perhaps default arguments should
             * be removed from next before the merge.
             */

            /* Don't return merge(), because arg identifiers and default args
             * can be different
             * even though the types match
             */
            mtype->deco = mtype->merge()->deco;
            result = mtype;
        }

        void visit(TypeTraits *mtype)
        {
            if (mtype->ty == Terror)
            {
                result = mtype;
                return;
            }

            const int inAlias = (sc->flags & SCOPEalias) != 0;
            if (mtype->exp->ident != Id::allMembers &&
                mtype->exp->ident != Id::derivedMembers &&
                mtype->exp->ident != Id::getMember &&
                mtype->exp->ident != Id::parent &&
                mtype->exp->ident != Id::child &&
                mtype->exp->ident != Id::toType &&
                mtype->exp->ident != Id::getOverloads &&
                mtype->exp->ident != Id::getVirtualFunctions &&
                mtype->exp->ident != Id::getVirtualMethods &&
                mtype->exp->ident != Id::getAttributes &&
                mtype->exp->ident != Id::getUnitTests &&
                mtype->exp->ident != Id::getAliasThis)
            {
                static const char *ctxt[2] = {"as type", "in alias"};
                ::error(loc, "trait `%s` is either invalid or not supported %s",
                        mtype->exp->ident->toChars(), ctxt[inAlias]);
                mtype->ty = Terror;
                result = mtype;
                return;
            }

            if (Expression *e = semanticTraits(mtype->exp, sc))
            {
                switch (e->op)
                {
                case TOKdotvar:
                    mtype->sym = ((DotVarExp *)e)->var;
                    break;
                case TOKvar:
                    mtype->sym = ((VarExp *)e)->var;
                    break;
                case TOKfunction:
                {
                    FuncExp *fe = (FuncExp *)e;
                    if (fe->td)
                        mtype->sym = fe->td;
                    else
                        mtype->sym = fe->fd;
                    break;
                }
                case TOKdottd:
                    mtype->sym = ((DotTemplateExp*)e)->td;
                    break;
                case TOKdsymbol:
                    mtype->sym = ((DsymbolExp *)e)->s;
                    break;
                case TOKtemplate:
                    mtype->sym = ((TemplateExp *)e)->td;
                    break;
                case TOKscope:
                    mtype->sym = ((ScopeExp *)e)->sds;
                    break;
                case TOKtuple:
                {
                    TupleExp *te = e->toTupleExp();
                    Objects *elems = new Objects;
                    elems->setDim(te->exps->length);
                    for (size_t i = 0; i < elems->length; i++)
                    {
                        Expression *src = (*te->exps)[i];
                        switch (src->op)
                        {
                        case TOKtype:
                            (*elems)[i] = ((TypeExp *)src)->type;
                            break;
                        case TOKdottype:
                            (*elems)[i] = ((DotTypeExp *)src)->type;
                            break;
                        case TOKoverloadset:
                            (*elems)[i] = ((OverExp *)src)->type;
                            break;
                        default:
                            if (Dsymbol *sym = isDsymbol(src))
                                (*elems)[i] = sym;
                            else
                                (*elems)[i] = src;
                        }
                    }
                    TupleDeclaration *td = new TupleDeclaration(e->loc,
                        Identifier::generateId("__aliastup"), elems);
                    mtype->sym = td;
                    break;
                }
                case TOKdottype:
                    result = isType(((DotTypeExp *)e)->sym);
                    break;
                case TOKtype:
                    result = ((TypeExp *)e)->type;
                    break;
                case TOKoverloadset:
                    result = ((OverExp *)e)->type;
                    break;
                default:
                    break;
                }
            }

            if (result)
                result = result->addMod(mtype->mod);
            if (!inAlias && !result)
            {
                if (!global.errors)
                    ::error(loc, "`%s` does not give a valid type", mtype->toChars());
                return error();
            }
        }

        void visit(TypeIdentifier *mtype)
        {
            Type *t;
            Expression *e;
            Dsymbol *s;

            //printf("TypeIdentifier::semantic(%s)\n", mtype->toChars());
            mtype->resolve(loc, sc, &e, &t, &s);
            if (t)
            {
                //printf("\tit's a type %d, %s, %s\n", t->ty, t->toChars(), t->deco);
                t = t->addMod(mtype->mod);
            }
            else
            {
                if (s)
                {
                    s->error(loc, "is used as a type");
                    //halt();
                }
                else
                    ::error(loc, "%s is used as a type", mtype->toChars());
                return error();
            }
            //t->print();
            result = t;
        }

        void visit(TypeInstance *mtype)
        {
            Type *t;
            Expression *e;
            Dsymbol *s;

            //printf("TypeInstance::semantic(%p, %s)\n", this, mtype->toChars());
            {
                unsigned errors = global.errors;
                mtype->resolve(loc, sc, &e, &t, &s);
                // if we had an error evaluating the symbol, suppress further errors
                if (!t && errors != global.errors)
                    return error();
            }

            if (!t)
            {
                if (!e && s && s->errors)
                {
                    // if there was an error evaluating the symbol, it might actually
                    // be a type. Avoid misleading error messages.
                    ::error(loc, "%s had previous errors", mtype->toChars());
                }
                else
                    ::error(loc, "%s is used as a type", mtype->toChars());
                return error();
            }
            result = t;
        }

        void visit(TypeTypeof *mtype)
        {
            //printf("TypeTypeof::semantic() %s\n", mtype->toChars());

            Expression *e;
            Type *t;
            Dsymbol *s;
            mtype->resolve(loc, sc, &e, &t, &s);
            if (s && (t = s->getType()) != NULL)
                t = t->addMod(mtype->mod);
            if (!t)
            {
                ::error(loc, "%s is used as a type", mtype->toChars());
                return error();
            }
            result = t;
        }

        void visit(TypeReturn *mtype)
        {
            //printf("TypeReturn::semantic() %s\n", mtype->toChars());

            Expression *e;
            Type *t;
            Dsymbol *s;
            mtype->resolve(loc, sc, &e, &t, &s);
            if (s && (t = s->getType()) != NULL)
                t = t->addMod(mtype->mod);
            if (!t)
            {
                ::error(loc, "%s is used as a type", mtype->toChars());
                return error();
            }
            result = t;
        }

        void visit(TypeEnum *mtype)
        {
            //printf("TypeEnum::semantic() %s\n", mtype->toChars());
            result = mtype->deco ? mtype : mtype->merge();
        }

        void visit(TypeStruct *mtype)
        {
            //printf("TypeStruct::semantic('%s')\n", mtype->toChars());
            if (mtype->deco)
            {
                if (sc && sc->cppmangle != CPPMANGLEdefault)
                {
                    if (mtype->cppmangle == CPPMANGLEdefault)
                        mtype->cppmangle = sc->cppmangle;
                    else
                        assert(mtype->cppmangle == sc->cppmangle);
                }
                result = mtype;
                return;
            }

            /* Don't semantic for sym because it should be deferred until
             * sizeof needed or its members accessed.
             */
            // instead, parent should be set correctly
            assert(mtype->sym->parent);

            if (mtype->sym->type->ty == Terror)
                return error();
            if (sc)
                mtype->cppmangle = sc->cppmangle;
            result = mtype->merge();
        }

        void visit(TypeClass *mtype)
        {
            //printf("TypeClass::semantic(%s)\n", mtype->toChars());
            if (mtype->deco)
            {
                if (sc && sc->cppmangle != CPPMANGLEdefault)
                {
                    if (mtype->cppmangle == CPPMANGLEdefault)
                        mtype->cppmangle = sc->cppmangle;
                    else
                        assert(mtype->cppmangle == sc->cppmangle);
                }
                result = mtype;
                return;
            }

            /* Don't semantic for sym because it should be deferred until
             * sizeof needed or its members accessed.
             */
            // instead, parent should be set correctly
            assert(mtype->sym->parent);

            if (mtype->sym->type->ty == Terror)
                return error();
            if (sc)
                mtype->cppmangle = sc->cppmangle;
            result = mtype->merge();
        }

        void visit(TypeTuple *mtype)
        {
            //printf("TypeTuple::semantic(this = %p)\n", this);
            //printf("TypeTuple::semantic() %p, %s\n", this, mtype->toChars());
            if (!mtype->deco)
                mtype->deco = mtype->merge()->deco;

            /* Don't return merge(), because a tuple with one type has the
             * same deco as that type.
             */
            result = mtype;
        }

        void visit(TypeSlice *mtype)
        {
            //printf("TypeSlice::semantic() %s\n", mtype->toChars());
            Type *tn = typeSemantic(mtype->next, loc, sc);
            //printf("next: %s\n", tn->toChars());

            Type *tbn = tn->toBasetype();
            if (tbn->ty != Ttuple)
            {
                ::error(loc, "can only slice tuple types, not %s", tbn->toChars());
                return error();
            }
            TypeTuple *tt = (TypeTuple *)tbn;

            mtype->lwr = semanticLength(sc, tbn, mtype->lwr);
            mtype->lwr = mtype->lwr->ctfeInterpret();
            uinteger_t i1 = mtype->lwr->toUInteger();

            mtype->upr = semanticLength(sc, tbn, mtype->upr);
            mtype->upr = mtype->upr->ctfeInterpret();
            uinteger_t i2 = mtype->upr->toUInteger();

            if (!(i1 <= i2 && i2 <= tt->arguments->length))
            {
                ::error(loc, "slice `[%llu..%llu]` is out of range of [0..%llu]",
                    (unsigned long long)i1, (unsigned long long)i2, (unsigned long long)tt->arguments->length);
                return error();
            }

            mtype->next = tn;
            mtype->transitive();

            Parameters *args = new Parameters;
            args->reserve((size_t)(i2 - i1));
            for (size_t i = (size_t)i1; i < (size_t)i2; i++)
            {
                Parameter *arg = (*tt->arguments)[i];
                args->push(arg);
            }
            Type *t = new TypeTuple(args);
            result = typeSemantic(t, loc, sc);
        }

        void visit(TypeMixin *mtype)
        {
            //printf("TypeMixin::semantic() %s\n", mtype->toChars());

            Expression *e = NULL;
            Type *t = NULL;
            Dsymbol *s = NULL;
            mtype->resolve(loc, sc, &e, &t, &s);

            if (t && t->ty != Terror)
            {
                result = t;
                return;
            }

            ::error(mtype->loc, "`mixin(%s)` does not give a valid type", mtype->obj->toChars());
            return error();
        }
    };
    TypeSemanticVisitor v(loc, sc);
    type->accept(&v);
    return v.result;
}