gcc/d/dmd/expressionsem.c

/* 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/rmem.h"
#include "root/root.h"

#include "mars.h"
#include "mangle.h"
#include "mtype.h"
#include "init.h"
#include "expression.h"
#include "template.h"
#include "utf.h"
#include "enum.h"
#include "scope.h"
#include "statement.h"
#include "declaration.h"
#include "aggregate.h"
#include "import.h"
#include "id.h"
#include "dsymbol.h"
#include "module.h"
#include "attrib.h"
#include "hdrgen.h"
#include "parse.h"
#include "nspace.h"
#include "ctfe.h"
#include "target.h"

bool typeMerge(Scope *sc, TOK op, Type **pt, Expression **pe1, Expression **pe2);
bool isArrayOpValid(Expression *e);
Expression *expandVar(int result, VarDeclaration *v);
bool checkAssignEscape(Scope *sc, Expression *e, bool gag);
bool checkParamArgumentEscape(Scope *sc, FuncDeclaration *fdc, Identifier *par, Expression *arg, bool gag);
bool checkAccess(AggregateDeclaration *ad, Loc loc, Scope *sc, Dsymbol *smember);
bool checkNestedRef(Dsymbol *s, Dsymbol *p);
bool checkFrameAccess(Loc loc, Scope *sc, AggregateDeclaration *ad, size_t istart = 0);
bool symbolIsVisible(Module *mod, Dsymbol *s);
bool symbolIsVisible(Scope *sc, Dsymbol *s);
VarDeclaration *copyToTemp(StorageClass stc, const char *name, Expression *e);
Expression *extractSideEffect(Scope *sc, const char *name, Expression **e0, Expression *e, bool alwaysCopy = false);
Type *getTypeInfoType(Loc loc, Type *t, Scope *sc);
char *MODtoChars(MOD mod);
bool MODimplicitConv(MOD modfrom, MOD modto);
MOD MODmerge(MOD mod1, MOD mod2);
MATCH MODmethodConv(MOD modfrom, MOD modto);
void MODMatchToBuffer(OutBuffer *buf, unsigned char lhsMod, unsigned char rhsMod);

void unSpeculative(Scope *sc, RootObject *o);
bool isDotOpDispatch(Expression *e);
bool isNeedThisScope(Scope *sc, Declaration *d);
bool checkUnsafeAccess(Scope *sc, Expression *e, bool readonly, bool printmsg);
bool isSafeCast(Expression *e, Type *tfrom, Type *tto);
FuncDeclaration *isFuncAddress(Expression *e, bool *hasOverloads = NULL);
Expression *callCpCtor(Scope *sc, Expression *e);

Expression *resolve(Loc loc, Scope *sc, Dsymbol *s, bool hasOverloads);

bool checkPrintfFormat(const Loc &loc, const char *format, Expressions &args, bool isVa_list);
bool checkScanfFormat(const Loc &loc, const char *format, Expressions &args, bool isVa_list);

/********************************************************
 * Perform semantic analysis and CTFE on expressions to produce
 * a string.
 * Params:
 *      buf = append generated string to buffer
 *      sc = context
 *      exps = array of Expressions
 * Returns:
 *      true on error
 */
bool expressionsToString(OutBuffer &buf, Scope *sc, Expressions *exps)
{
    if (!exps)
        return false;

    for (size_t i = 0; i < exps->length; i++)
    {
        Expression *ex = (*exps)[i];
        if (!ex)
            continue;
        Scope *sc2 = sc->startCTFE();
        Expression *e2 = expressionSemantic(ex, sc2);
        Expression *e3 = resolveProperties(sc2, e2);
        sc2->endCTFE();

        // allowed to contain types as well as expressions
        Expression *e4 = ctfeInterpretForPragmaMsg(e3);
        if (!e4 || e4->op == TOKerror)
            return true;

        // expand tuple
        if (TupleExp *te = e4->isTupleExp())
        {
            if (expressionsToString(buf, sc, te->exps))
                return true;
            continue;
        }
        // char literals exp `.toStringExp` return `null` but we cant override it
        // because in most contexts we don't want the conversion to succeed.
        IntegerExp *ie = e4->isIntegerExp();
        const TY ty = (ie && ie->type) ? ie->type->ty : (TY)Terror;
        if (ty == Tchar || ty == Twchar || ty == Tdchar)
        {
            TypeSArray *tsa = new TypeSArray(ie->type, new IntegerExp(ex->loc, 1, Type::tint32));
            e4 = new ArrayLiteralExp(ex->loc, tsa, ie);
        }

        if (StringExp *se = e4->toStringExp())
            buf.writestring(se->toUTF8(sc)->toPtr());
        else
            buf.writestring(e4->toChars());
    }
    return false;
}

/***********************************************************
 * Resolve `exp` as a compile-time known string.
 * Params:
 *  sc  = scope
 *  exp = Expression which expected as a string
 *  s   = What the string is expected for, will be used in error diagnostic.
 * Returns:
 *  String literal, or `null` if error happens.
 */
StringExp *semanticString(Scope *sc, Expression *exp, const char *s)
{
    sc = sc->startCTFE();
    exp = expressionSemantic(exp, sc);
    exp = resolveProperties(sc, exp);
    sc = sc->endCTFE();

    if (exp->op == TOKerror)
        return NULL;

    Expression *e = exp;
    if (exp->type->isString())
    {
        e = e->ctfeInterpret();
        if (e->op == TOKerror)
            return NULL;
    }

    StringExp *se = e->toStringExp();
    if (!se)
    {
        exp->error("string expected for %s, not (%s) of type %s",
            s, exp->toChars(), exp->type->toChars());
        return NULL;
    }
    return se;
}

/****************************************************************/

static Expression *extractOpDollarSideEffect(Scope *sc, UnaExp *ue)
{
    Expression *e0;
    Expression *e1 = Expression::extractLast(ue->e1, &e0);
    // Bugzilla 12585: Extract the side effect part if ue->e1 is comma.

    if (!isTrivialExp(e1))
    {
        /* Even if opDollar is needed, 'e1' should be evaluate only once. So
         * Rewrite:
         *      e1.opIndex( ... use of $ ... )
         *      e1.opSlice( ... use of $ ... )
         * as:
         *      (ref __dop = e1, __dop).opIndex( ... __dop.opDollar ...)
         *      (ref __dop = e1, __dop).opSlice( ... __dop.opDollar ...)
         */
        e1 = extractSideEffect(sc, "__dop", &e0, e1, false);
        assert(e1->op == TOKvar);
        VarExp *ve = (VarExp *)e1;
        ve->var->storage_class |= STCexptemp;     // lifetime limited to expression
    }
    ue->e1 = e1;
    return e0;
}

/**************************************
 * Runs semantic on ae->arguments. Declares temporary variables
 * if '$' was used.
 */
Expression *resolveOpDollar(Scope *sc, ArrayExp *ae, Expression **pe0)
{
    assert(!ae->lengthVar);

    *pe0 = NULL;

    AggregateDeclaration *ad = isAggregate(ae->e1->type);
    Dsymbol *slice = search_function(ad, Id::slice);
    //printf("slice = %s %s\n", slice->kind(), slice->toChars());

    for (size_t i = 0; i < ae->arguments->length; i++)
    {
        if (i == 0)
            *pe0 = extractOpDollarSideEffect(sc, ae);

        Expression *e = (*ae->arguments)[i];
        if (e->op == TOKinterval && !(slice && slice->isTemplateDeclaration()))
        {
        Lfallback:
            if (ae->arguments->length == 1)
                return NULL;
            ae->error("multi-dimensional slicing requires template opSlice");
            return new ErrorExp();
        }
        //printf("[%d] e = %s\n", i, e->toChars());

        // Create scope for '$' variable for this dimension
        ArrayScopeSymbol *sym = new ArrayScopeSymbol(sc, ae);
        sym->loc = ae->loc;
        sym->parent = sc->scopesym;
        sc = sc->push(sym);
        ae->lengthVar = NULL;       // Create it only if required
        ae->currentDimension = i;   // Dimension for $, if required

        e = expressionSemantic(e, sc);
        e = resolveProperties(sc, e);

        if (ae->lengthVar && sc->func)
        {
            // If $ was used, declare it now
            Expression *de = new DeclarationExp(ae->loc, ae->lengthVar);
            de = expressionSemantic(de, sc);
            *pe0 = Expression::combine(*pe0, de);
        }
        sc = sc->pop();

        if (e->op == TOKinterval)
        {
            IntervalExp *ie = (IntervalExp *)e;

            Objects *tiargs = new Objects();
            Expression *edim = new IntegerExp(ae->loc, i, Type::tsize_t);
            edim = expressionSemantic(edim, sc);
            tiargs->push(edim);

            Expressions *fargs = new Expressions();
            fargs->push(ie->lwr);
            fargs->push(ie->upr);

            unsigned xerrors = global.startGagging();
            sc = sc->push();
            FuncDeclaration *fslice = resolveFuncCall(ae->loc, sc, slice, tiargs, ae->e1->type, fargs, 1);
            sc = sc->pop();
            global.endGagging(xerrors);
            if (!fslice)
                goto Lfallback;

            e = new DotTemplateInstanceExp(ae->loc, ae->e1, slice->ident, tiargs);
            e = new CallExp(ae->loc, e, fargs);
            e = expressionSemantic(e, sc);
        }

        if (!e->type)
        {
            ae->error("%s has no value", e->toChars());
            e = new ErrorExp();
        }
        if (e->op == TOKerror)
            return e;

        (*ae->arguments)[i] = e;
    }

    return ae;
}

/**************************************
 * Runs semantic on se->lwr and se->upr. Declares a temporary variable
 * if '$' was used.
 */
Expression *resolveOpDollar(Scope *sc, ArrayExp *ae, IntervalExp *ie, Expression **pe0)
{
    //assert(!ae->lengthVar);
    if (!ie)
        return ae;

    VarDeclaration *lengthVar = ae->lengthVar;

    // create scope for '$'
    ArrayScopeSymbol *sym = new ArrayScopeSymbol(sc, ae);
    sym->loc = ae->loc;
    sym->parent = sc->scopesym;
    sc = sc->push(sym);

    for (size_t i = 0; i < 2; ++i)
    {
        Expression *e = i == 0 ? ie->lwr : ie->upr;
        e = expressionSemantic(e, sc);
        e = resolveProperties(sc, e);
        if (!e->type)
        {
            ae->error("%s has no value", e->toChars());
            return new ErrorExp();
        }
        (i == 0 ? ie->lwr : ie->upr) = e;
    }

    if (lengthVar != ae->lengthVar && sc->func)
    {
        // If $ was used, declare it now
        Expression *de = new DeclarationExp(ae->loc, ae->lengthVar);
        de = expressionSemantic(de, sc);
        *pe0 = Expression::combine(*pe0, de);
    }
    sc = sc->pop();

    return ae;
}

/******************************
 * Perform semantic() on an array of Expressions.
 */

bool arrayExpressionSemantic(Expressions *exps, Scope *sc, bool preserveErrors)
{
    bool err = false;
    if (exps)
    {
        for (size_t i = 0; i < exps->length; i++)
        {
            Expression *e = (*exps)[i];
            if (e)
            {
                e = expressionSemantic(e, sc);
                if (e->op == TOKerror)
                    err = true;
                if (preserveErrors || e->op != TOKerror)
                    (*exps)[i] = e;
            }
        }
    }
    return err;
}

/******************************
 * Check the tail CallExp is really property function call.
 */
static bool checkPropertyCall(Expression *e)
{
    while (e->op == TOKcomma)
        e = ((CommaExp *)e)->e2;

    if (e->op == TOKcall)
    {
        CallExp *ce = (CallExp *)e;
        TypeFunction *tf;
        if (ce->f)
        {
            tf = (TypeFunction *)ce->f->type;
            /* If a forward reference to ce->f, try to resolve it
             */
            if (!tf->deco && ce->f->semanticRun < PASSsemanticdone)
            {
                dsymbolSemantic(ce->f, NULL);
                tf = (TypeFunction *)ce->f->type;
            }
        }
        else if (ce->e1->type->ty == Tfunction)
            tf = (TypeFunction *)ce->e1->type;
        else if (ce->e1->type->ty == Tdelegate)
            tf = (TypeFunction *)ce->e1->type->nextOf();
        else if (ce->e1->type->ty == Tpointer && ce->e1->type->nextOf()->ty == Tfunction)
            tf = (TypeFunction *)ce->e1->type->nextOf();
        else
            assert(0);
    }
    return false;
}

// TODO: merge with Scope::search::searchScopes()
static Dsymbol *searchScopes(Scope *sc, Loc loc, Identifier *ident, int flags)
{
    Dsymbol *s = NULL;
    for (Scope *scx = sc; scx; scx = scx->enclosing)
    {
        if (!scx->scopesym)
            continue;
        if (scx->scopesym->isModule())
            flags |= SearchUnqualifiedModule;    // tell Module.search() that SearchLocalsOnly is to be obeyed
        s = scx->scopesym->search(loc, ident, flags);
        if (s)
        {
            // overload set contains only module scope symbols.
            if (s->isOverloadSet())
                break;
            // selective/renamed imports also be picked up
            if (AliasDeclaration *ad = s->isAliasDeclaration())
            {
                if (ad->_import)
                    break;
            }
            // See only module scope symbols for UFCS target.
            Dsymbol *p = s->toParent2();
            if (p && p->isModule())
                break;
        }
        s = NULL;

        // Stop when we hit a module, but keep going if that is not just under the global scope
        if (scx->scopesym->isModule() && !(scx->enclosing && !scx->enclosing->enclosing))
            break;
    }
    return s;
}

/******************************
 * Find symbol in accordance with the UFCS name look up rule
 */

static Expression *searchUFCS(Scope *sc, UnaExp *ue, Identifier *ident)
{
    //printf("searchUFCS(ident = %s)\n", ident->toChars());
    Loc loc = ue->loc;
    int flags = 0;
    Dsymbol *s = NULL;

    if (sc->flags & SCOPEignoresymbolvisibility)
        flags |= IgnoreSymbolVisibility;

    // First look in local scopes
    s = searchScopes(sc, loc, ident, flags | SearchLocalsOnly);
    if (!s)
    {
        // Second look in imported modules
        s = searchScopes(sc, loc, ident, flags | SearchImportsOnly);
    }

    if (!s)
        return ue->e1->type->Type::getProperty(loc, ident, 0);

    FuncDeclaration *f = s->isFuncDeclaration();
    if (f)
    {
        TemplateDeclaration *td = getFuncTemplateDecl(f);
        if (td)
        {
            if (td->overroot)
                td = td->overroot;
            s = td;
        }
    }

    if (ue->op == TOKdotti)
    {
        DotTemplateInstanceExp *dti = (DotTemplateInstanceExp *)ue;
        TemplateInstance *ti = new TemplateInstance(loc, s->ident);
        ti->tiargs = dti->ti->tiargs;   // for better diagnostic message
        if (!ti->updateTempDecl(sc, s))
            return new ErrorExp();
        return new ScopeExp(loc, ti);
    }
    else
    {
        //printf("-searchUFCS() %s\n", s->toChars());
        return new DsymbolExp(loc, s);
    }
}

/******************************
 * Pull out callable entity with UFCS.
 */

static Expression *resolveUFCS(Scope *sc, CallExp *ce)
{
    Loc loc = ce->loc;
    Expression *eleft;
    Expression *e;

    if (ce->e1->op == TOKdotid)
    {
        DotIdExp *die = (DotIdExp *)ce->e1;
        Identifier *ident = die->ident;

        Expression *ex = semanticX(die, sc);
        if (ex != die)
        {
            ce->e1 = ex;
            return NULL;
        }
        eleft = die->e1;

        Type *t = eleft->type->toBasetype();
        if (t->ty == Tarray || t->ty == Tsarray ||
            t->ty == Tnull  || (t->isTypeBasic() && t->ty != Tvoid))
        {
            /* Built-in types and arrays have no callable properties, so do shortcut.
             * It is necessary in: e.init()
             */
        }
        else if (t->ty == Taarray)
        {
            if (ident == Id::remove)
            {
                /* Transform:
                 *  aa.remove(arg) into delete aa[arg]
                 */
                if (!ce->arguments || ce->arguments->length != 1)
                {
                    ce->error("expected key as argument to aa.remove()");
                    return new ErrorExp();
                }
                if (!eleft->type->isMutable())
                {
                    ce->error("cannot remove key from %s associative array %s",
                            MODtoChars(t->mod), eleft->toChars());
                    return new ErrorExp();
                }
                Expression *key = (*ce->arguments)[0];
                key = expressionSemantic(key, sc);
                key = resolveProperties(sc, key);

                TypeAArray *taa = (TypeAArray *)t;
                key = key->implicitCastTo(sc, taa->index);

                if (key->checkValue())
                    return new ErrorExp();

                semanticTypeInfo(sc, taa->index);

                return new RemoveExp(loc, eleft, key);
            }
        }
        else
        {
            if (Expression *ey = semanticY(die, sc, 1))
            {
                if (ey->op == TOKerror)
                    return ey;
                ce->e1 = ey;
                if (isDotOpDispatch(ey))
                {
                    unsigned errors = global.startGagging();
                    e = expressionSemantic(ce->syntaxCopy(), sc);
                    if (!global.endGagging(errors))
                        return e;
                    /* fall down to UFCS */
                }
                else
                    return NULL;
            }
        }
        e = searchUFCS(sc, die, ident);
    }
    else if (ce->e1->op == TOKdotti)
    {
        DotTemplateInstanceExp *dti = (DotTemplateInstanceExp *)ce->e1;
        if (Expression *ey = semanticY(dti, sc, 1))
        {
            ce->e1 = ey;
            return NULL;
        }
        eleft = dti->e1;
        e = searchUFCS(sc, dti, dti->ti->name);
    }
    else
        return NULL;

    // Rewrite
    ce->e1 = e;
    if (!ce->arguments)
        ce->arguments = new Expressions();
    ce->arguments->shift(eleft);

    return NULL;
}

/******************************
 * Pull out property with UFCS.
 */

static Expression *resolveUFCSProperties(Scope *sc, Expression *e1, Expression *e2 = NULL)
{
    Loc loc = e1->loc;
    Expression *eleft;
    Expression *e;

    if (e1->op == TOKdotid)
    {
        DotIdExp *die = (DotIdExp *)e1;
        eleft = die->e1;
        e = searchUFCS(sc, die, die->ident);
    }
    else if (e1->op == TOKdotti)
    {
        DotTemplateInstanceExp *dti;
        dti = (DotTemplateInstanceExp *)e1;
        eleft = dti->e1;
        e = searchUFCS(sc, dti, dti->ti->name);
    }
    else
        return NULL;

    if (e == NULL)
        return NULL;

    // Rewrite
    if (e2)
    {
        // run semantic without gagging
        e2 = expressionSemantic(e2, sc);

        /* f(e1) = e2
         */
        Expression *ex = e->copy();
        Expressions *a1 = new Expressions();
        a1->setDim(1);
        (*a1)[0] = eleft;
        ex = new CallExp(loc, ex, a1);
        ex = trySemantic(ex, sc);

        /* f(e1, e2)
         */
        Expressions *a2 = new Expressions();
        a2->setDim(2);
        (*a2)[0] = eleft;
        (*a2)[1] = e2;
        e = new CallExp(loc, e, a2);
        if (ex)
        {   // if fallback setter exists, gag errors
            e = trySemantic(e, sc);
            if (!e)
            {   checkPropertyCall(ex);
                ex = new AssignExp(loc, ex, e2);
                return expressionSemantic(ex, sc);
            }
        }
        else
        {   // strict setter prints errors if fails
            e = expressionSemantic(e, sc);
        }
        checkPropertyCall(e);
        return e;
    }
    else
    {
        /* f(e1)
         */
        Expressions *arguments = new Expressions();
        arguments->setDim(1);
        (*arguments)[0] = eleft;
        e = new CallExp(loc, e, arguments);
        e = expressionSemantic(e, sc);
        checkPropertyCall(e);
        return expressionSemantic(e, sc);
    }
}

/******************************
 * If e1 is a property function (template), resolve it.
 */

Expression *resolvePropertiesOnly(Scope *sc, Expression *e1)
{
    //printf("e1 = %s %s\n", Token::toChars(e1->op), e1->toChars());
    OverloadSet *os;
    FuncDeclaration *fd;
    TemplateDeclaration *td;

    if (e1->op == TOKdot)
    {
        DotExp *de = (DotExp *)e1;
        if (de->e2->op == TOKoverloadset)
        {
            os = ((OverExp *)de->e2)->vars;
            goto Los;
        }
    }
    else if (e1->op == TOKoverloadset)
    {
        os = ((OverExp *)e1)->vars;
    Los:
        assert(os);
        for (size_t i = 0; i < os->a.length; i++)
        {
            Dsymbol *s = os->a[i];
            fd = s->isFuncDeclaration();
            td = s->isTemplateDeclaration();
            if (fd)
            {
                if (((TypeFunction *)fd->type)->isproperty)
                    return resolveProperties(sc, e1);
            }
            else if (td && td->onemember &&
                     (fd = td->onemember->isFuncDeclaration()) != NULL)
            {
                if (((TypeFunction *)fd->type)->isproperty ||
                    (fd->storage_class2 & STCproperty) ||
                    (td->_scope->stc & STCproperty))
                {
                    return resolveProperties(sc, e1);
                }
            }
        }
    }
    else if (e1->op == TOKdotti)
    {
        DotTemplateInstanceExp* dti = (DotTemplateInstanceExp *)e1;
        if (dti->ti->tempdecl && (td = dti->ti->tempdecl->isTemplateDeclaration()) != NULL)
            goto Ltd;
    }
    else if (e1->op == TOKdottd)
    {
        td = ((DotTemplateExp *)e1)->td;
        goto Ltd;
    }
    else if (e1->op == TOKscope)
    {
        Dsymbol *s = ((ScopeExp *)e1)->sds;
        TemplateInstance *ti = s->isTemplateInstance();
        if (ti && !ti->semanticRun && ti->tempdecl)
        {
            if ((td = ti->tempdecl->isTemplateDeclaration()) != NULL)
                goto Ltd;
        }
    }
    else if (e1->op == TOKtemplate)
    {
        td = ((TemplateExp *)e1)->td;
    Ltd:
        assert(td);
        if (td->onemember &&
            (fd = td->onemember->isFuncDeclaration()) != NULL)
        {
            if (((TypeFunction *)fd->type)->isproperty ||
                (fd->storage_class2 & STCproperty) ||
                (td->_scope->stc & STCproperty))
            {
                return resolveProperties(sc, e1);
            }
        }
    }
    else if (e1->op == TOKdotvar && e1->type->ty == Tfunction)
    {
        DotVarExp *dve = (DotVarExp *)e1;
        fd = dve->var->isFuncDeclaration();
        goto Lfd;
    }
    else if (e1->op == TOKvar && e1->type->ty == Tfunction &&
        (sc->intypeof || !((VarExp *)e1)->var->needThis()))
    {
        fd = ((VarExp *)e1)->var->isFuncDeclaration();
    Lfd:
        assert(fd);
        if (((TypeFunction *)fd->type)->isproperty)
            return resolveProperties(sc, e1);
    }
    return e1;
}

/*************************************************************
 * Given var, we need to get the
 * right 'this' pointer if var is in an outer class, but our
 * existing 'this' pointer is in an inner class.
 * Input:
 *      e1      existing 'this'
 *      ad      struct or class we need the correct 'this' for
 *      var     the specific member of ad we're accessing
 */

static Expression *getRightThis(Loc loc, Scope *sc, AggregateDeclaration *ad,
        Expression *e1, Declaration *var, int flag = 0)
{
    //printf("\ngetRightThis(e1 = %s, ad = %s, var = %s)\n", e1->toChars(), ad->toChars(), var->toChars());
 L1:
    Type *t = e1->type->toBasetype();
    //printf("e1->type = %s, var->type = %s\n", e1->type->toChars(), var->type->toChars());

    /* If e1 is not the 'this' pointer for ad
     */
    if (ad &&
        !(t->ty == Tpointer && t->nextOf()->ty == Tstruct &&
          ((TypeStruct *)t->nextOf())->sym == ad)
        &&
        !(t->ty == Tstruct &&
          ((TypeStruct *)t)->sym == ad)
       )
    {
        ClassDeclaration *cd = ad->isClassDeclaration();
        ClassDeclaration *tcd = t->isClassHandle();

        /* e1 is the right this if ad is a base class of e1
         */
        if (!cd || !tcd ||
            !(tcd == cd || cd->isBaseOf(tcd, NULL))
           )
        {
            /* Only classes can be inner classes with an 'outer'
             * member pointing to the enclosing class instance
             */
            if (tcd && tcd->isNested())
            {
                /* e1 is the 'this' pointer for an inner class: tcd.
                 * Rewrite it as the 'this' pointer for the outer class.
                 */

                e1 = new DotVarExp(loc, e1, tcd->vthis);
                e1->type = tcd->vthis->type;
                e1->type = e1->type->addMod(t->mod);
                // Do not call checkNestedRef()
                //e1 = expressionSemantic(e1, sc);

                // Skip up over nested functions, and get the enclosing
                // class type.
                int n = 0;
                Dsymbol *s;
                for (s = tcd->toParent();
                     s && s->isFuncDeclaration();
                     s = s->toParent())
                {
                    FuncDeclaration *f = s->isFuncDeclaration();
                    if (f->vthis)
                    {
                        //printf("rewriting e1 to %s's this\n", f->toChars());
                        n++;
                        e1 = new VarExp(loc, f->vthis);
                    }
                    else
                    {
                        e1->error("need `this` of type %s to access member %s"
                                  " from static function %s",
                            ad->toChars(), var->toChars(), f->toChars());
                        e1 = new ErrorExp();
                        return e1;
                    }
                }
                if (s && s->isClassDeclaration())
                {
                    e1->type = s->isClassDeclaration()->type;
                    e1->type = e1->type->addMod(t->mod);
                    if (n > 1)
                        e1 = expressionSemantic(e1, sc);
                }
                else
                    e1 = expressionSemantic(e1, sc);
                goto L1;
            }

            /* Can't find a path from e1 to ad
             */
            if (flag)
                return NULL;
            e1->error("this for %s needs to be type %s not type %s",
                var->toChars(), ad->toChars(), t->toChars());
            return new ErrorExp();
        }
    }
    return e1;
}

/***************************************
 * Pull out any properties.
 */

static Expression *resolvePropertiesX(Scope *sc, Expression *e1, Expression *e2 = NULL)
{
    //printf("resolvePropertiesX, e1 = %s %s, e2 = %s\n", Token::toChars(e1->op), e1->toChars(), e2 ? e2->toChars() : NULL);
    Loc loc = e1->loc;

    OverloadSet *os;
    Dsymbol *s;
    Objects *tiargs;
    Type *tthis;
    if (e1->op == TOKdot)
    {
        DotExp *de = (DotExp *)e1;
        if (de->e2->op == TOKoverloadset)
        {
            tiargs = NULL;
            tthis  = de->e1->type;
            os = ((OverExp *)de->e2)->vars;
            goto Los;
        }
    }
    else if (e1->op == TOKoverloadset)
    {
        tiargs = NULL;
        tthis  = NULL;
        os = ((OverExp *)e1)->vars;
    Los:
        assert(os);
        FuncDeclaration *fd = NULL;
        if (e2)
        {
            e2 = expressionSemantic(e2, sc);
            if (e2->op == TOKerror)
                return new ErrorExp();
            e2 = resolveProperties(sc, e2);

            Expressions a;
            a.push(e2);

            for (size_t i = 0; i < os->a.length; i++)
            {
                FuncDeclaration *f = resolveFuncCall(loc, sc, os->a[i], tiargs, tthis, &a, 1);
                if (f)
                {
                    if (f->errors)
                        return new ErrorExp();
                    fd = f;
                    assert(fd->type->ty == Tfunction);
                }
            }
            if (fd)
            {
                Expression *e = new CallExp(loc, e1, e2);
                return expressionSemantic(e, sc);
            }
        }
        {
            for (size_t i = 0; i < os->a.length; i++)
            {
                FuncDeclaration *f = resolveFuncCall(loc, sc, os->a[i], tiargs, tthis, NULL, 1);
                if (f)
                {
                    if (f->errors)
                        return new ErrorExp();
                    fd = f;
                    assert(fd->type->ty == Tfunction);
                    TypeFunction *tf = (TypeFunction *)fd->type;
                    if (!tf->isref && e2)
                        goto Leproplvalue;
                }
            }
            if (fd)
            {
                Expression *e = new CallExp(loc, e1);
                if (e2)
                    e = new AssignExp(loc, e, e2);
                return expressionSemantic(e, sc);
            }
        }
        if (e2)
            goto Leprop;
    }
    else if (e1->op == TOKdotti)
    {
        DotTemplateInstanceExp* dti = (DotTemplateInstanceExp *)e1;
        if (!dti->findTempDecl(sc))
            goto Leprop;
        if (!dti->ti->semanticTiargs(sc))
            goto Leprop;
        tiargs = dti->ti->tiargs;
        tthis  = dti->e1->type;
        if ((os = dti->ti->tempdecl->isOverloadSet()) != NULL)
            goto Los;
        if ((s = dti->ti->tempdecl) != NULL)
            goto Lfd;
    }
    else if (e1->op == TOKdottd)
    {
        DotTemplateExp *dte = (DotTemplateExp *)e1;
        s      = dte->td;
        tiargs = NULL;
        tthis  = dte->e1->type;
        goto Lfd;
    }
    else if (e1->op == TOKscope)
    {
        s = ((ScopeExp *)e1)->sds;
        TemplateInstance *ti = s->isTemplateInstance();
        if (ti && !ti->semanticRun && ti->tempdecl)
        {
            //assert(ti->needsTypeInference(sc));
            if (!ti->semanticTiargs(sc))
                goto Leprop;
            tiargs = ti->tiargs;
            tthis  = NULL;
            if ((os = ti->tempdecl->isOverloadSet()) != NULL)
                goto Los;
            if ((s = ti->tempdecl) != NULL)
                goto Lfd;
        }
    }
    else if (e1->op == TOKtemplate)
    {
        s      = ((TemplateExp *)e1)->td;
        tiargs = NULL;
        tthis  = NULL;
        goto Lfd;
    }
    else if (e1->op == TOKdotvar && e1->type && e1->type->toBasetype()->ty == Tfunction)
    {
        DotVarExp *dve = (DotVarExp *)e1;
        s      = dve->var->isFuncDeclaration();
        tiargs = NULL;
        tthis  = dve->e1->type;
        goto Lfd;
    }
    else if (e1->op == TOKvar && e1->type && e1->type->toBasetype()->ty == Tfunction)
    {
        s      = ((VarExp *)e1)->var->isFuncDeclaration();
        tiargs = NULL;
        tthis  = NULL;
    Lfd:
        assert(s);
        if (e2)
        {
            e2 = expressionSemantic(e2, sc);
            if (e2->op == TOKerror)
                return new ErrorExp();
            e2 = resolveProperties(sc, e2);

            Expressions a;
            a.push(e2);

            FuncDeclaration *fd = resolveFuncCall(loc, sc, s, tiargs, tthis, &a, 1);
            if (fd && fd->type)
            {
                if (fd->errors)
                    return new ErrorExp();
                assert(fd->type->ty == Tfunction);
                Expression *e = new CallExp(loc, e1, e2);
                return expressionSemantic(e, sc);
            }
        }
        {
            FuncDeclaration *fd = resolveFuncCall(loc, sc, s, tiargs, tthis, NULL, 1);
            if (fd && fd->type)
            {
                if (fd->errors)
                    return new ErrorExp();
                assert(fd->type->ty == Tfunction);
                TypeFunction *tf = (TypeFunction *)fd->type;
                if (!e2 || tf->isref)
                {
                    Expression *e = new CallExp(loc, e1);
                    if (e2)
                        e = new AssignExp(loc, e, e2);
                    return expressionSemantic(e, sc);
                }
            }
        }
        if (FuncDeclaration *fd = s->isFuncDeclaration())
        {
            // Keep better diagnostic message for invalid property usage of functions
            assert(fd->type->ty == Tfunction);
            Expression *e = new CallExp(loc, e1, e2);
            return expressionSemantic(e, sc);
        }
        if (e2)
            goto Leprop;
    }
    if (e1->op == TOKvar)
    {
        VarExp *ve = (VarExp *)e1;
        VarDeclaration *v = ve->var->isVarDeclaration();
        if (v && ve->checkPurity(sc, v))
            return new ErrorExp();
    }
    if (e2)
        return NULL;

    if (e1->type &&
        e1->op != TOKtype)      // function type is not a property
    {
        /* Look for e1 being a lazy parameter; rewrite as delegate call
         */
        if (e1->op == TOKvar)
        {
            VarExp *ve = (VarExp *)e1;

            if (ve->var->storage_class & STClazy)
            {
                Expression *e = new CallExp(loc, e1);
                return expressionSemantic(e, sc);
            }
        }
        else if (e1->op == TOKdotvar)
        {
            // Check for reading overlapped pointer field in @safe code.
            if (checkUnsafeAccess(sc, e1, true, true))
                return new ErrorExp();
        }
        else if (e1->op == TOKcall)
        {
            CallExp *ce = (CallExp *)e1;
            // Check for reading overlapped pointer field in @safe code.
            if (checkUnsafeAccess(sc, ce->e1, true, true))
                return new ErrorExp();
        }
    }

    if (!e1->type)
    {
        error(loc, "cannot resolve type for %s", e1->toChars());
        e1 = new ErrorExp();
    }
    return e1;

Leprop:
    error(loc, "not a property %s", e1->toChars());
    return new ErrorExp();

Leproplvalue:
    error(loc, "%s is not an lvalue", e1->toChars());
    return new ErrorExp();
}

Expression *resolveProperties(Scope *sc, Expression *e)
{
    //printf("resolveProperties(%s)\n", e->toChars());

    e = resolvePropertiesX(sc, e);
    if (e->checkRightThis(sc))
        return new ErrorExp();
    return e;
}

/****************************************
 * The common type is determined by applying ?: to each pair.
 * Output:
 *      exps[]  properties resolved, implicitly cast to common type, rewritten in place
 *      *pt     if pt is not NULL, set to the common type
 * Returns:
 *      true    a semantic error was detected
 */

static bool arrayExpressionToCommonType(Scope *sc, Expressions *exps, Type **pt)
{
    /* Still have a problem with:
     *  ubyte[][] = [ cast(ubyte[])"hello", [1]];
     * which works if the array literal is initialized top down with the ubyte[][]
     * type, but fails with this function doing bottom up typing.
     */
    //printf("arrayExpressionToCommonType()\n");
    IntegerExp integerexp(0);
    CondExp condexp(Loc(), &integerexp, NULL, NULL);

    Type *t0 = NULL;
    Expression *e0 = NULL;      // dead-store to prevent spurious warning
    size_t j0 = ~0;             // dead-store to prevent spurious warning
    bool foundType = false;

    for (size_t i = 0; i < exps->length; i++)
    {
        Expression *e = (*exps)[i];
        if (!e)
            continue;

        e = resolveProperties(sc, e);
        if (!e->type)
        {
            e->error("%s has no value", e->toChars());
            t0 = Type::terror;
            continue;
        }
        if (e->op == TOKtype)
        {
            foundType = true;   // do not break immediately, there might be more errors
            e->checkValue();    // report an error "type T has no value"
            t0 = Type::terror;
            continue;
        }
        if (e->type->ty == Tvoid)
        {
            // void expressions do not concur to the determination of the common
            // type.
            continue;
        }
        if (checkNonAssignmentArrayOp(e))
        {
            t0 = Type::terror;
            continue;
        }

        e = doCopyOrMove(sc, e);

        if (!foundType && t0 && !t0->equals(e->type))
        {
            /* This applies ?: to merge the types. It's backwards;
             * ?: should call this function to merge types.
             */
            condexp.type = NULL;
            condexp.e1 = e0;
            condexp.e2 = e;
            condexp.loc = e->loc;
            Expression *ex = expressionSemantic(&condexp, sc);
            if (ex->op == TOKerror)
                e = ex;
            else
            {
                (*exps)[j0] = condexp.e1;
                e = condexp.e2;
            }
        }
        j0 = i;
        e0 = e;
        t0 = e->type;
        if (e->op != TOKerror)
            (*exps)[i] = e;
    }

    if (!t0)
        t0 = Type::tvoid;               // [] is typed as void[]
    else if (t0->ty != Terror)
    {
        for (size_t i = 0; i < exps->length; i++)
        {
            Expression *e = (*exps)[i];
            if (!e)
                continue;

            e = e->implicitCastTo(sc, t0);
            //assert(e->op != TOKerror);
            if (e->op == TOKerror)
            {
                /* Bugzilla 13024: a workaround for the bug in typeMerge -
                 * it should paint e1 and e2 by deduced common type,
                 * but doesn't in this particular case.
                 */
                t0 = Type::terror;
                break;
            }
            (*exps)[i] = e;
        }
    }
    if (pt)
        *pt = t0;

    return (t0 == Type::terror);
}

static Expression *opAssignToOp(Loc loc, TOK op, Expression *e1, Expression *e2)
{   Expression *e;

    switch (op)
    {
        case TOKaddass:   e = new AddExp(loc, e1, e2);  break;
        case TOKminass:   e = new MinExp(loc, e1, e2);  break;
        case TOKmulass:   e = new MulExp(loc, e1, e2);  break;
        case TOKdivass:   e = new DivExp(loc, e1, e2);  break;
        case TOKmodass:   e = new ModExp(loc, e1, e2);  break;
        case TOKandass:   e = new AndExp(loc, e1, e2);  break;
        case TOKorass:    e = new OrExp (loc, e1, e2);  break;
        case TOKxorass:   e = new XorExp(loc, e1, e2);  break;
        case TOKshlass:   e = new ShlExp(loc, e1, e2);  break;
        case TOKshrass:   e = new ShrExp(loc, e1, e2);  break;
        case TOKushrass:  e = new UshrExp(loc, e1, e2); break;
        default:        assert(0);
    }
    return e;
}

/*********************
 * Rewrite:
 *    array.length op= e2
 * as:
 *    array.length = array.length op e2
 * or:
 *    auto tmp = &array;
 *    (*tmp).length = (*tmp).length op e2
 */

static Expression *rewriteOpAssign(BinExp *exp)
{
    Expression *e;

    assert(exp->e1->op == TOKarraylength);
    ArrayLengthExp *ale = (ArrayLengthExp *)exp->e1;
    if (ale->e1->op == TOKvar)
    {
        e = opAssignToOp(exp->loc, exp->op, ale, exp->e2);
        e = new AssignExp(exp->loc, ale->syntaxCopy(), e);
    }
    else
    {
        /*    auto tmp = &array;
         *    (*tmp).length = (*tmp).length op e2
         */
        VarDeclaration *tmp = copyToTemp(0, "__arraylength", new AddrExp(ale->loc, ale->e1));

        Expression *e1 = new ArrayLengthExp(ale->loc, new PtrExp(ale->loc, new VarExp(ale->loc, tmp)));
        Expression *elvalue = e1->syntaxCopy();
        e = opAssignToOp(exp->loc, exp->op, e1, exp->e2);
        e = new AssignExp(exp->loc, elvalue, e);
        e = new CommaExp(exp->loc, new DeclarationExp(ale->loc, tmp), e);
    }
    return e;
}

/****************************************
 * Preprocess arguments to function.
 * Output:
 *      exps[]  tuples expanded, properties resolved, rewritten in place
 * Returns:
 *      true    a semantic error occurred
 */

static bool preFunctionParameters(Scope *sc, Expressions *exps)
{
    bool err = false;
    if (exps)
    {
        expandTuples(exps);

        for (size_t i = 0; i < exps->length; i++)
        {
            Expression *arg = (*exps)[i];

            arg = resolveProperties(sc, arg);
            if (arg->op == TOKtype)
            {
                arg->error("cannot pass type %s as a function argument", arg->toChars());
                arg = new ErrorExp();
                err = true;
            }
            else if (arg->type->toBasetype()->ty == Tfunction)
            {
                arg->error("cannot pass type %s as a function argument", arg->toChars());
                arg = new ErrorExp();
                err = true;
            }
            else if (checkNonAssignmentArrayOp(arg))
            {
                arg = new ErrorExp();
                err = true;
            }
            (*exps)[i] = arg;
        }
    }
    return err;
}

/********************************************
 * Issue an error if default construction is disabled for type t.
 * Default construction is required for arrays and 'out' parameters.
 * Returns:
 *      true    an error was issued
 */
static bool checkDefCtor(Loc loc, Type *t)
{
    t = t->baseElemOf();
    if (t->ty == Tstruct)
    {
        StructDeclaration *sd = ((TypeStruct *)t)->sym;
        if (sd->noDefaultCtor)
        {
            sd->error(loc, "default construction is disabled");
            return true;
        }
    }
    return false;
}

/****************************************
 * Now that we know the exact type of the function we're calling,
 * the arguments[] need to be adjusted:
 *      1. implicitly convert argument to the corresponding parameter type
 *      2. add default arguments for any missing arguments
 *      3. do default promotions on arguments corresponding to ...
 *      4. add hidden _arguments[] argument
 *      5. call copy constructor for struct value arguments
 * Input:
 *      tf      type of the function
 *      fd      the function being called, NULL if called indirectly
 * Output:
 *      *prettype return type of function
 *      *peprefix expression to execute before arguments[] are evaluated, NULL if none
 * Returns:
 *      true    errors happened
 */

static bool functionParameters(Loc loc, Scope *sc, TypeFunction *tf,
        Type *tthis, Expressions *arguments, FuncDeclaration *fd, Type **prettype, Expression **peprefix)
{
    //printf("functionParameters()\n");
    assert(arguments);
    assert(fd || tf->next);
    size_t nargs = arguments ? arguments->length : 0;
    size_t nparams = tf->parameterList.length();
    unsigned olderrors = global.errors;
    bool err = false;
    *prettype = Type::terror;
    Expression *eprefix = NULL;
    *peprefix = NULL;

    if (nargs > nparams && tf->parameterList.varargs == VARARGnone)
    {
        error(loc, "expected %llu arguments, not %llu for non-variadic function type %s", (ulonglong)nparams, (ulonglong)nargs, tf->toChars());
        return true;
    }

    // If inferring return type, and semantic3() needs to be run if not already run
    if (!tf->next && fd->inferRetType)
    {
        fd->functionSemantic();
    }
    else if (fd && fd->parent)
    {
        TemplateInstance *ti = fd->parent->isTemplateInstance();
        if (ti && ti->tempdecl)
        {
            fd->functionSemantic3();
        }
    }
    bool isCtorCall = fd && fd->needThis() && fd->isCtorDeclaration();

    size_t n = (nargs > nparams) ? nargs : nparams;   // n = max(nargs, nparams)

    /* If the function return type has wildcards in it, we'll need to figure out the actual type
     * based on the actual argument types.
     */
    MOD wildmatch = 0;
    if (tthis && tf->isWild() && !isCtorCall)
    {
        Type *t = tthis;
        if (t->isImmutable())
            wildmatch = MODimmutable;
        else if (t->isWildConst())
            wildmatch = MODwildconst;
        else if (t->isWild())
            wildmatch = MODwild;
        else if (t->isConst())
            wildmatch = MODconst;
        else
            wildmatch = MODmutable;
    }

    int done = 0;
    for (size_t i = 0; i < n; i++)
    {
        Expression *arg;

        if (i < nargs)
            arg = (*arguments)[i];
        else
            arg = NULL;

        if (i < nparams)
        {
            Parameter *p = tf->parameterList[i];

            if (!arg)
            {
                if (!p->defaultArg)
                {
                    if (tf->parameterList.varargs == VARARGtypesafe && i + 1 == nparams)
                        goto L2;
                    error(loc, "expected %llu function arguments, not %llu", (ulonglong)nparams, (ulonglong)nargs);
                    return true;
                }
                arg = p->defaultArg;
                arg = inlineCopy(arg, sc);
                // __FILE__, __LINE__, __MODULE__, __FUNCTION__, and __PRETTY_FUNCTION__
                arg = arg->resolveLoc(loc, sc);
                arguments->push(arg);
                nargs++;
            }

            if (tf->parameterList.varargs == VARARGtypesafe && i + 1 == nparams)
            {
                //printf("\t\tvarargs == 2, p->type = '%s'\n", p->type->toChars());
                {
                    MATCH m;
                    if ((m = arg->implicitConvTo(p->type)) > MATCHnomatch)
                    {
                        if (p->type->nextOf() && arg->implicitConvTo(p->type->nextOf()) >= m)
                            goto L2;
                        else if (nargs != nparams)
                        {   error(loc, "expected %llu function arguments, not %llu", (ulonglong)nparams, (ulonglong)nargs);
                            return true;
                        }
                        goto L1;
                    }
                }
             L2:
                Type *tb = p->type->toBasetype();
                Type *tret = p->isLazyArray();
                switch (tb->ty)
                {
                    case Tsarray:
                    case Tarray:
                    {
                        /* Create a static array variable v of type arg->type:
                         *  T[dim] __arrayArg = [ arguments[i], ..., arguments[nargs-1] ];
                         *
                         * The array literal in the initializer of the hidden variable
                         * is now optimized. See Bugzilla 2356.
                         */
                        Type *tbn = ((TypeArray *)tb)->next;

                        Expressions *elements = new Expressions();
                        elements->setDim(nargs - i);
                        for (size_t u = 0; u < elements->length; u++)
                        {
                            Expression *a = (*arguments)[i + u];
                            if (tret && a->implicitConvTo(tret))
                            {
                                a = a->implicitCastTo(sc, tret);
                                a = a->optimize(WANTvalue);
                                a = toDelegate(a, a->type, sc);
                            }
                            else
                                a = a->implicitCastTo(sc, tbn);
                            (*elements)[u] = a;
                        }
                        // Bugzilla 14395: Convert to a static array literal, or its slice.
                        arg = new ArrayLiteralExp(loc, tbn->sarrayOf(nargs - i), elements);
                        if (tb->ty == Tarray)
                        {
                            arg = new SliceExp(loc, arg, NULL, NULL);
                            arg->type = p->type;
                        }
                        break;
                    }
                    case Tclass:
                    {
                        /* Set arg to be:
                         *      new Tclass(arg0, arg1, ..., argn)
                         */
                        Expressions *args = new Expressions();
                        args->setDim(nargs - i);
                        for (size_t u = i; u < nargs; u++)
                            (*args)[u - i] = (*arguments)[u];
                        arg = new NewExp(loc, NULL, NULL, p->type, args);
                        break;
                    }
                    default:
                        if (!arg)
                        {
                            error(loc, "not enough arguments");
                            return true;
                        }
                        break;
                }
                arg = expressionSemantic(arg, sc);
                //printf("\targ = '%s'\n", arg->toChars());
                arguments->setDim(i + 1);
                (*arguments)[i] =  arg;
                nargs = i + 1;
                done = 1;
            }

        L1:
            if (!(p->storageClass & STClazy && p->type->ty == Tvoid))
            {
                bool isRef = (p->storageClass & (STCref | STCout)) != 0;
                if (unsigned char wm = arg->type->deduceWild(p->type, isRef))
                {
                    if (wildmatch)
                        wildmatch = MODmerge(wildmatch, wm);
                    else
                        wildmatch = wm;
                    //printf("[%d] p = %s, a = %s, wm = %d, wildmatch = %d\n", i, p->type->toChars(), arg->type->toChars(), wm, wildmatch);
                }
            }
        }
        if (done)
            break;
    }
    if ((wildmatch == MODmutable || wildmatch == MODimmutable) &&
        tf->next->hasWild() &&
        (tf->isref || !tf->next->implicitConvTo(tf->next->immutableOf())))
    {
        if (fd)
        {
            /* If the called function may return the reference to
             * outer inout data, it should be rejected.
             *
             * void foo(ref inout(int) x) {
             *   ref inout(int) bar(inout(int)) { return x; }
             *   struct S { ref inout(int) bar() inout { return x; } }
             *   bar(int.init) = 1;  // bad!
             *   S().bar() = 1;      // bad!
             * }
             */
            Dsymbol *s = NULL;
            if (fd->isThis() || fd->isNested())
                s = fd->toParent2();
            for (; s; s = s->toParent2())
            {
                if (AggregateDeclaration *ad = s->isAggregateDeclaration())
                {
                    if (ad->isNested())
                        continue;
                    break;
                }
                if (FuncDeclaration *ff = s->isFuncDeclaration())
                {
                    if (((TypeFunction *)ff->type)->iswild)
                        goto Linouterr;

                    if (ff->isNested() || ff->isThis())
                        continue;
                }
                break;
            }
        }
        else if (tf->isWild())
        {
        Linouterr:
            const char *s = wildmatch == MODmutable ? "mutable" : MODtoChars(wildmatch);
            error(loc, "modify inout to %s is not allowed inside inout function", s);
            return true;
        }
    }

    assert(nargs >= nparams);
    for (size_t i = 0; i < nargs; i++)
    {
        Expression *arg = (*arguments)[i];
        assert(arg);
        if (i < nparams)
        {
            Parameter *p = tf->parameterList[i];

            if (!(p->storageClass & STClazy && p->type->ty == Tvoid))
            {
                Type *tprm = p->type;
                if (p->type->hasWild())
                    tprm = p->type->substWildTo(wildmatch);
                if (!tprm->equals(arg->type))
                {
                    //printf("arg->type = %s, p->type = %s\n", arg->type->toChars(), p->type->toChars());
                    arg = arg->implicitCastTo(sc, tprm);
                    arg = arg->optimize(WANTvalue, (p->storageClass & (STCref | STCout)) != 0);
                }
            }
            if (p->storageClass & STCref)
            {
                arg = arg->toLvalue(sc, arg);

                // Look for mutable misaligned pointer, etc., in @safe mode
                err |= checkUnsafeAccess(sc, arg, false, true);
            }
            else if (p->storageClass & STCout)
            {
                Type *t = arg->type;
                if (!t->isMutable() || !t->isAssignable())  // check blit assignable
                {
                    arg->error("cannot modify struct %s with immutable members", arg->toChars());
                    err = true;
                }
                else
                {
                    // Look for misaligned pointer, etc., in @safe mode
                    err |= checkUnsafeAccess(sc, arg, false, true);
                    err |= checkDefCtor(arg->loc, t);   // t must be default constructible
                }
                arg = arg->toLvalue(sc, arg);
            }
            else if (p->storageClass & STClazy)
            {
                // Convert lazy argument to a delegate
                if (p->type->ty == Tvoid)
                    arg = toDelegate(arg, p->type, sc);
                else
                    arg = toDelegate(arg, arg->type, sc);
            }

            //printf("arg: %s\n", arg->toChars());
            //printf("type: %s\n", arg->type->toChars());
            if (tf->parameterEscapes(p))
            {
                /* Argument value can escape from the called function.
                 * Check arg to see if it matters.
                 */
                if (global.params.vsafe)
                    err |= checkParamArgumentEscape(sc, fd, p->ident, arg, false);
            }
            else
            {
                /* Argument value cannot escape from the called function.
                 */
                Expression *a = arg;
                if (a->op == TOKcast)
                    a = ((CastExp *)a)->e1;

                if (a->op == TOKfunction)
                {
                    /* Function literals can only appear once, so if this
                     * appearance was scoped, there cannot be any others.
                     */
                    FuncExp *fe = (FuncExp *)a;
                    fe->fd->tookAddressOf = 0;
                }
                else if (a->op == TOKdelegate)
                {
                    /* For passing a delegate to a scoped parameter,
                     * this doesn't count as taking the address of it.
                     * We only worry about 'escaping' references to the function.
                     */
                    DelegateExp *de = (DelegateExp *)a;
                    if (de->e1->op == TOKvar)
                    {   VarExp *ve = (VarExp *)de->e1;
                        FuncDeclaration *f = ve->var->isFuncDeclaration();
                        if (f)
                        {   f->tookAddressOf--;
                            //printf("tookAddressOf = %d\n", f->tookAddressOf);
                        }
                    }
                }
            }
            arg = arg->optimize(WANTvalue, (p->storageClass & (STCref | STCout)) != 0);
        }
        else
        {
            // These will be the trailing ... arguments

            // If not D linkage, do promotions
            if (tf->linkage != LINKd)
            {
                // Promote bytes, words, etc., to ints
                arg = integralPromotions(arg, sc);

                // Promote floats to doubles
                switch (arg->type->ty)
                {
                    case Tfloat32:
                        arg = arg->castTo(sc, Type::tfloat64);
                        break;

                    case Timaginary32:
                        arg = arg->castTo(sc, Type::timaginary64);
                        break;
                }

                if (tf->parameterList.varargs == VARARGvariadic)
                {
                    const char *p = tf->linkage == LINKc ? "extern(C)" : "extern(C++)";
                    if (arg->type->ty == Tarray)
                    {
                        arg->error("cannot pass dynamic arrays to %s vararg functions", p);
                        err = true;
                    }
                    if (arg->type->ty == Tsarray)
                    {
                        arg->error("cannot pass static arrays to %s vararg functions", p);
                        err = true;
                    }
                }
            }

            // Do not allow types that need destructors
            if (arg->type->needsDestruction())
            {
                arg->error("cannot pass types that need destruction as variadic arguments");
                err = true;
            }

            // Convert static arrays to dynamic arrays
            // BUG: I don't think this is right for D2
            Type *tb = arg->type->toBasetype();
            if (tb->ty == Tsarray)
            {
                TypeSArray *ts = (TypeSArray *)tb;
                Type *ta = ts->next->arrayOf();
                if (ts->size(arg->loc) == 0)
                    arg = new NullExp(arg->loc, ta);
                else
                    arg = arg->castTo(sc, ta);
            }
            if (tb->ty == Tstruct)
            {
                //arg = callCpCtor(sc, arg);
            }

            // Give error for overloaded function addresses
            if (arg->op == TOKsymoff)
            {   SymOffExp *se = (SymOffExp *)arg;
                if (se->hasOverloads &&
                    !se->var->isFuncDeclaration()->isUnique())
                {   arg->error("function %s is overloaded", arg->toChars());
                    err = true;
                }
            }
            if (arg->checkValue())
                err = true;
            arg = arg->optimize(WANTvalue);
        }
        (*arguments)[i] = arg;
    }

    /* If calling C scanf(), printf(), or any variants, check the format string against the arguments
     */
    const bool isVa_list = tf->parameterList.varargs == VARARGnone;
    if (fd && (fd->flags & FUNCFLAGprintf))
    {
        if (StringExp *se = (*arguments)[nparams - 1 - isVa_list]->isStringExp())
        {
            Expressions argslice;
            argslice.reserve(nargs - nparams);
            for (size_t i = nparams; i < nargs; i++)
                argslice.push((*arguments)[i]);
            checkPrintfFormat(se->loc, se->toPtr(), argslice, isVa_list);
        }
    }
    else if (fd && (fd->flags & FUNCFLAGscanf))
    {
        if (StringExp *se = (*arguments)[nparams - 1 - isVa_list]->isStringExp())
        {
            Expressions argslice;
            argslice.reserve(nargs - nparams);
            for (size_t i = nparams; i < nargs; i++)
                argslice.push((*arguments)[i]);
            checkPrintfFormat(se->loc, se->toPtr(), argslice, isVa_list);
        }
    }

    /* Remaining problems:
     * 1. order of evaluation - some function push L-to-R, others R-to-L. Until we resolve what array assignment does (which is
     *    implemented by calling a function) we'll defer this for now.
     * 2. value structs (or static arrays of them) that need to be copy constructed
     * 3. value structs (or static arrays of them) that have destructors, and subsequent arguments that may throw before the
     *    function gets called (functions normally destroy their parameters)
     * 2 and 3 are handled by doing the argument construction in 'eprefix' so that if a later argument throws, they are cleaned
     * up properly. Pushing arguments on the stack then cannot fail.
     */
    if (1)
    {
        /* TODO: tackle problem 1)
         */
        const bool leftToRight = true; // TODO: something like !fd.isArrayOp
        if (!leftToRight)
            assert(nargs == nparams); // no variadics for RTL order, as they would probably be evaluated LTR and so add complexity

        const ptrdiff_t start = (leftToRight ? 0 : (ptrdiff_t)nargs - 1);
        const ptrdiff_t end = (leftToRight ? (ptrdiff_t)nargs : -1);
        const ptrdiff_t step = (leftToRight ? 1 : -1);

        /* Compute indices of last throwing argument and first arg needing destruction.
         * Used to not set up destructors unless an arg needs destruction on a throw
         * in a later argument.
         */
        ptrdiff_t lastthrow = -1;
        ptrdiff_t firstdtor = -1;
        for (ptrdiff_t i = start; i != end; i += step)
        {
            Expression *arg = (*arguments)[i];
            if (canThrow(arg, sc->func, false))
                lastthrow = i;
            if (firstdtor == -1 && arg->type->needsDestruction())
            {
                Parameter *p = (i >= (ptrdiff_t)nparams ? NULL : tf->parameterList[i]);
                if (!(p && (p->storageClass & (STClazy | STCref | STCout))))
                    firstdtor = i;
            }
        }

        /* Does problem 3) apply to this call?
         */
        const bool needsPrefix = (firstdtor >= 0 && lastthrow >= 0
            && (lastthrow - firstdtor) * step > 0);

        /* If so, initialize 'eprefix' by declaring the gate
         */
        VarDeclaration *gate = NULL;
        if (needsPrefix)
        {
            // eprefix => bool __gate [= false]
            Identifier *idtmp = Identifier::generateId("__gate");
            gate = new VarDeclaration(loc, Type::tbool, idtmp, NULL);
            gate->storage_class |= STCtemp | STCctfe | STCvolatile;
            dsymbolSemantic(gate, sc);

            Expression *ae = new DeclarationExp(loc, gate);
            eprefix = expressionSemantic(ae, sc);
        }

        for (ptrdiff_t i = start; i != end; i += step)
        {
            Expression *arg = (*arguments)[i];

            Parameter *parameter = (i >= (ptrdiff_t)nparams ? NULL : tf->parameterList[i]);
            const bool isRef = (parameter && (parameter->storageClass & (STCref | STCout)));
            const bool isLazy = (parameter && (parameter->storageClass & STClazy));

            /* Skip lazy parameters
             */
            if (isLazy)
                continue;

            /* Do we have a gate? Then we have a prefix and we're not yet past the last throwing arg.
             * Declare a temporary variable for this arg and append that declaration to 'eprefix',
             * which will implicitly take care of potential problem 2) for this arg.
             * 'eprefix' will therefore finally contain all args up to and including the last
             * potentially throwing arg, excluding all lazy parameters.
             */
            if (gate)
            {
                const bool needsDtor = (!isRef && arg->type->needsDestruction() && i != lastthrow);

                /* Declare temporary 'auto __pfx = arg' (needsDtor) or 'auto __pfy = arg' (!needsDtor)
                 */
                VarDeclaration *tmp = copyToTemp(0,
                    needsDtor ? "__pfx" : "__pfy",
                    !isRef ? arg : arg->addressOf());
                dsymbolSemantic(tmp, sc);

                /* Modify the destructor so it only runs if gate==false, i.e.,
                 * only if there was a throw while constructing the args
                 */
                if (!needsDtor)
                {
                    if (tmp->edtor)
                    {
                        assert(i == lastthrow);
                        tmp->edtor = NULL;
                    }
                }
                else
                {
                    // edtor => (__gate || edtor)
                    assert(tmp->edtor);
                    Expression *e = tmp->edtor;
                    e = new LogicalExp(e->loc, TOKoror, new VarExp(e->loc, gate), e);
                    tmp->edtor = expressionSemantic(e, sc);
                    //printf("edtor: %s\n", tmp->edtor->toChars());
                }

                // eprefix => (eprefix, auto __pfx/y = arg)
                DeclarationExp *ae = new DeclarationExp(loc, tmp);
                eprefix = Expression::combine(eprefix, expressionSemantic(ae, sc));

                // arg => __pfx/y
                arg = new VarExp(loc, tmp);
                arg = expressionSemantic(arg, sc);
                if (isRef)
                {
                    arg = new PtrExp(loc, arg);
                    arg = expressionSemantic(arg, sc);
                }

                /* Last throwing arg? Then finalize eprefix => (eprefix, gate = true),
                 * i.e., disable the dtors right after constructing the last throwing arg.
                 * From now on, the callee will take care of destructing the args because
                 * the args are implicitly moved into function parameters.
                 *
                 * Set gate to null to let the next iterations know they don't need to
                 * append to eprefix anymore.
                 */
                if (i == lastthrow)
                {
                    Expression *e = new AssignExp(gate->loc, new VarExp(gate->loc, gate), new IntegerExp(gate->loc, 1, Type::tbool));
                    eprefix = Expression::combine(eprefix, expressionSemantic(e, sc));
                    gate = NULL;
                }
            }
            else
            {
                /* No gate, no prefix to append to.
                 * Handle problem 2) by calling the copy constructor for value structs
                 * (or static arrays of them) if appropriate.
                 */
                Type *tv = arg->type->baseElemOf();
                if (!isRef && tv->ty == Tstruct)
                    arg = doCopyOrMove(sc, arg);
            }

            (*arguments)[i] = arg;
        }
    }
    //if (eprefix) printf("eprefix: %s\n", eprefix->toChars());

    // If D linkage and variadic, add _arguments[] as first argument
    if (tf->isDstyleVariadic())
    {
        assert(arguments->length >= nparams);

        Parameters *args = new Parameters;
        args->setDim(arguments->length - nparams);
        for (size_t i = 0; i < arguments->length - nparams; i++)
        {
            Parameter *arg = new Parameter(STCin, (*arguments)[nparams + i]->type, NULL, NULL, NULL);
            (*args)[i] = arg;
        }

        TypeTuple *tup = new TypeTuple(args);
        Expression *e = new TypeidExp(loc, tup);
        e = expressionSemantic(e, sc);
        arguments->insert(0, e);
    }

    Type *tret = tf->next;
    if (isCtorCall)
    {
        //printf("[%s] fd = %s %s, %d %d %d\n", loc.toChars(), fd->toChars(), fd->type->toChars(),
        //    wildmatch, tf->isWild(), fd->isolateReturn());
        if (!tthis)
        {
            assert(sc->intypeof || global.errors);
            tthis = fd->isThis()->type->addMod(fd->type->mod);
        }
        if (tf->isWild() && !fd->isolateReturn())
        {
            if (wildmatch)
                tret = tret->substWildTo(wildmatch);
            int offset;
            if (!tret->implicitConvTo(tthis) &&
                !(MODimplicitConv(tret->mod, tthis->mod) && tret->isBaseOf(tthis, &offset) && offset == 0))
            {
                const char* s1 = tret ->isNaked() ? " mutable" : tret ->modToChars();
                const char* s2 = tthis->isNaked() ? " mutable" : tthis->modToChars();
                ::error(loc, "inout constructor %s creates%s object, not%s",
                        fd->toPrettyChars(), s1, s2);
                err = true;
            }
        }
        tret = tthis;
    }
    else if (wildmatch && tret)
    {
        /* Adjust function return type based on wildmatch
         */
        //printf("wildmatch = x%x, tret = %s\n", wildmatch, tret->toChars());
        tret = tret->substWildTo(wildmatch);
    }
    *prettype = tret;
    *peprefix = eprefix;
    return (err || olderrors != global.errors);
}

/**
 * Determines whether a symbol represents a module or package
 * (Used as a helper for is(type == module) and is(type == package))
 *
 * Params:
 *  sym = the symbol to be checked
 *
 * Returns:
 *  the symbol which `sym` represents (or `null` if it doesn't represent a `Package`)
 */
Package *resolveIsPackage(Dsymbol *sym)
{
    Package *pkg;
    if (Import *imp = sym->isImport())
    {
        if (imp->pkg == NULL)
        {
            error(sym->loc, "Internal Compiler Error: unable to process forward-referenced import `%s`",
                  imp->toChars());
            assert(0);
        }
        pkg = imp->pkg;
    }
    else if (Module *mod = sym->isModule())
        pkg = mod->isPackageFile ? mod->pkg : sym->isPackage();
    else
        pkg = sym->isPackage();
    if (pkg)
        pkg->resolvePKGunknown();
    return pkg;
}

static Module *loadStdMath()
{
  static Import *impStdMath = NULL;
  if (!impStdMath)
    {
      Identifiers *a = new Identifiers();
      a->push(Id::std);
      Import *s = new Import(Loc(), a, Id::math, NULL, false);
      s->load(NULL);
      if (s->mod)
      {
          s->mod->importAll(NULL);
          dsymbolSemantic(s->mod, NULL);
      }
      impStdMath = s;
    }
  return impStdMath->mod;
}

class ExpressionSemanticVisitor : public Visitor
{
public:
    Expression *result;
    Scope *sc;

    ExpressionSemanticVisitor(Scope *sc)
    {
        this->result = NULL;
        this->sc = sc;
    }

private:
    void setError()
    {
        result = new ErrorExp();
    }

    /*********************
     * Mark the operand as will never be dereferenced,
     * which is useful info for @safe checks.
     * Do before semantic() on operands rewrites them.
     */
    static void setNoderefOperand(UnaExp *e)
    {
        if (e->e1->op == TOKdotid)
            ((DotIdExp *)e->e1)->noderef = true;
    }

    /*********************
     * Mark the operands as will never be dereferenced,
     * which is useful info for @safe checks.
     * Do before semantic() on operands rewrites them.
     */
    static void setNoderefOperands(BinExp *e)
    {
        if (e->e1->op == TOKdotid)
            ((DotIdExp *)e->e1)->noderef = true;
        if (e->e2->op == TOKdotid)
            ((DotIdExp *)e->e2)->noderef = true;
    }

    static FuncDeclaration *resolveOverloadSet(Loc loc, Scope *sc,
        OverloadSet *os, Objects* tiargs, Type *tthis, Expressions *arguments)
    {
        FuncDeclaration *f = NULL;
        for (size_t i = 0; i < os->a.length; i++)
        {
            Dsymbol *s = os->a[i];
            if (tiargs && s->isFuncDeclaration())
                continue;
            if (FuncDeclaration *f2 = resolveFuncCall(loc, sc, s, tiargs, tthis, arguments, 1))
            {
                if (f2->errors)
                    return NULL;
                if (f)
                {
                    /* Error if match in more than one overload set,
                     * even if one is a 'better' match than the other.
                     */
                    ScopeDsymbol::multiplyDefined(loc, f, f2);
                }
                else
                    f = f2;
            }
        }
        if (!f)
            ::error(loc, "no overload matches for %s", os->toChars());
        else if (f->errors)
            f = NULL;
        return f;
    }

    /****************************************************
     * Determine if `exp`, which takes the address of `v`, can do so safely.
     * Params:
     *      sc = context
     *      exp = expression that takes the address of `v`
     *      v = the variable getting its address taken
     * Returns:
     *      `true` if ok, `false` for error
     */
    static bool checkAddressVar(Scope *sc, UnaExp *e, VarDeclaration *v)
    {
        if (v)
        {
            if (!v->canTakeAddressOf())
            {
                e->error("cannot take address of %s", e->e1->toChars());
                return false;
            }
            if (sc->func && !sc->intypeof && !v->isDataseg())
            {
                const char *p = v->isParameter() ? "parameter" : "local";
                if (global.params.vsafe)
                {
                    // Taking the address of v means it cannot be set to 'scope' later
                    v->storage_class &= ~STCmaybescope;
                    v->doNotInferScope = true;
                    if (v->storage_class & STCscope && sc->func->setUnsafe())
                    {
                        e->error("cannot take address of scope %s %s in @safe function %s", p, v->toChars(), sc->func->toChars());
                        return false;
                    }
                }
                else if (sc->func->setUnsafe())
                {
                    e->error("cannot take address of %s %s in @safe function %s", p, v->toChars(), sc->func->toChars());
                    return false;
                }
            }
        }
        return true;
    }

    static bool checkVectorElem(Expression *e, Expression *elem)
    {
        if (elem->isConst() == 1)
            return false;

        e->error("constant expression expected, not %s", elem->toChars());
        return true;
    }

public:
    void visit(Expression *e)
    {
        if (e->type)
            e->type = typeSemantic(e->type, e->loc, sc);
        else
            e->type = Type::tvoid;
        result = e;
    }

    void visit(IntegerExp *e)
    {
        assert(e->type);
        if (e->type->ty == Terror)
            return setError();
        assert(e->type->deco);
        e->normalize();
        result = e;
    }

    void visit(RealExp *e)
    {
        if (!e->type)
            e->type = Type::tfloat64;
        else
            e->type = typeSemantic(e->type, e->loc, sc);
        result = e;
    }

    void visit(ComplexExp *e)
    {
        if (!e->type)
            e->type = Type::tcomplex80;
        else
            e->type = typeSemantic(e->type, e->loc, sc);
        result = e;
    }

    void visit(IdentifierExp *exp)
    {
        if (exp->type)   // This is used as the dummy expression
        {
            result = exp;
            return;
        }

        Dsymbol *scopesym;
        Dsymbol *s = sc->search(exp->loc, exp->ident, &scopesym);
        if (s)
        {
            if (s->errors)
                return setError();

            Expression *e;

            /* See if the symbol was a member of an enclosing 'with'
            */
            WithScopeSymbol *withsym = scopesym->isWithScopeSymbol();
            if (withsym && withsym->withstate->wthis && symbolIsVisible(sc, s))
            {
                /* Disallow shadowing
                */
                // First find the scope of the with
                Scope *scwith = sc;
                while (scwith->scopesym != scopesym)
                {
                    scwith = scwith->enclosing;
                    assert(scwith);
                }
                // Look at enclosing scopes for symbols with the same name,
                // in the same function
                for (Scope *scx = scwith; scx && scx->func == scwith->func; scx = scx->enclosing)
                {
                    Dsymbol *s2;
                    if (scx->scopesym && scx->scopesym->symtab &&
                        (s2 = scx->scopesym->symtab->lookup(s->ident)) != NULL &&
                        s != s2)
                    {
                        exp->error("with symbol %s is shadowing local symbol %s", s->toPrettyChars(), s2->toPrettyChars());
                        return setError();
                    }
                }
                s = s->toAlias();

                // Same as wthis.ident
                //  TODO: DotIdExp.semantic will find 'ident' from 'wthis' again.
                //  The redudancy should be removed.
                e = new VarExp(exp->loc, withsym->withstate->wthis);
                e = new DotIdExp(exp->loc, e, exp->ident);
                e = expressionSemantic(e, sc);
            }
            else
            {
                if (withsym)
                {
                    if (withsym->withstate->exp->type->ty != Tvoid)
                    {
                        // with (exp)' is a type expression
                        // or 's' is not visible there (for error message)
                        e = new TypeExp(exp->loc, withsym->withstate->exp->type);
                    }
                    else
                    {
                        // 'with (exp)' is a Package/Module
                        e = withsym->withstate->exp;
                    }
                    e = new DotIdExp(exp->loc, e, exp->ident);
                    result = expressionSemantic(e, sc);
                    return;
                }

                /* If f is really a function template,
                 * then replace f with the function template declaration.
                 */
                FuncDeclaration *f = s->isFuncDeclaration();
                if (f)
                {
                    TemplateDeclaration *td = getFuncTemplateDecl(f);
                    if (td)
                    {
                        if (td->overroot)       // if not start of overloaded list of TemplateDeclaration's
                            td = td->overroot;  // then get the start
                        e = new TemplateExp(exp->loc, td, f);
                        e = expressionSemantic(e, sc);
                        result = e;
                        return;
                    }
                }
                // Haven't done overload resolution yet, so pass 1
                e = resolve(exp->loc, sc, s, true);
            }
            result = e;
            return;
        }

        if (hasThis(sc))
        {
            AggregateDeclaration *ad = sc->getStructClassScope();
            if (ad && ad->aliasthis)
            {
                Expression *e;
                e = new IdentifierExp(exp->loc, Id::This);
                e = new DotIdExp(exp->loc, e, ad->aliasthis->ident);
                e = new DotIdExp(exp->loc, e, exp->ident);
                e = trySemantic(e, sc);
                if (e)
                {
                    result = e;
                    return;
                }
            }
        }

        if (exp->ident == Id::ctfe)
        {
            if (sc->flags & SCOPEctfe)
            {
                exp->error("variable __ctfe cannot be read at compile time");
                return setError();
            }

            // Create the magic __ctfe bool variable
            VarDeclaration *vd = new VarDeclaration(exp->loc, Type::tbool, Id::ctfe, NULL);
            vd->storage_class |= STCtemp;
            vd->semanticRun = PASSsemanticdone;
            Expression *e = new VarExp(exp->loc, vd);
            e = expressionSemantic(e, sc);
            result = e;
            return;
        }

        // If we've reached this point and are inside a with() scope then we may
        // try one last attempt by checking whether the 'wthis' object supports
        // dynamic dispatching via opDispatch.
        // This is done by rewriting this expression as wthis.ident.
        for (Scope *sc2 = sc; sc2; sc2 = sc2->enclosing)
        {
            if (!sc2->scopesym)
                continue;

            if (WithScopeSymbol *ss = sc2->scopesym->isWithScopeSymbol())
            {
                if (ss->withstate->wthis)
                {
                    Expression *e;
                    e = new VarExp(exp->loc, ss->withstate->wthis);
                    e = new DotIdExp(exp->loc, e, exp->ident);
                    e = trySemantic(e, sc);
                    if (e)
                    {
                        result = e;
                        return;
                    }
                }
                break;
            }
        }

        /* Look for what user might have meant
         */
        if (const char *n = importHint(exp->ident->toChars()))
            exp->error("`%s` is not defined, perhaps `import %s;` is needed?", exp->ident->toChars(), n);
        else if (Dsymbol *s2 = sc->search_correct(exp->ident))
            exp->error("undefined identifier `%s`, did you mean %s `%s`?", exp->ident->toChars(), s2->kind(), s2->toChars());
        else if (const char *p = Scope::search_correct_C(exp->ident))
            exp->error("undefined identifier `%s`, did you mean `%s`?", exp->ident->toChars(), p);
        else
            exp->error("undefined identifier `%s`", exp->ident->toChars());
        return setError();
    }

    void visit(DsymbolExp *e)
    {
        result = resolve(e->loc, sc, e->s, e->hasOverloads);
    }

    void visit(ThisExp *e)
    {
        if (e->type)
        {
            result = e;
            return;
        }

        FuncDeclaration *fd = hasThis(sc);  // fd is the uplevel function with the 'this' variable

        /* Special case for typeof(this) and typeof(super) since both
         * should work even if they are not inside a non-static member function
         */
        if (!fd && sc->intypeof == 1)
        {
            // Find enclosing struct or class
            for (Dsymbol *s = sc->getStructClassScope(); 1; s = s->parent)
            {
                if (!s)
                {
                    e->error("%s is not in a class or struct scope", e->toChars());
                    goto Lerr;
                }
                ClassDeclaration *cd = s->isClassDeclaration();
                if (cd)
                {
                    e->type = cd->type;
                    result = e;
                    return;
                }
                StructDeclaration *sd = s->isStructDeclaration();
                if (sd)
                {
                    e->type = sd->type;
                    result = e;
                    return;
                }
            }
        }
        if (!fd)
            goto Lerr;

        assert(fd->vthis);
        e->var = fd->vthis;
        assert(e->var->parent);
        e->type = e->var->type;
        if (e->var->checkNestedReference(sc, e->loc))
            return setError();
        if (!sc->intypeof)
            sc->callSuper |= CSXthis;
        result = e;
        return;

    Lerr:
        e->error("`this` is only defined in non-static member functions, not %s", sc->parent->toChars());
        return setError();
    }

    void visit(SuperExp *e)
    {
        if (e->type)
        {
            result = e;
            return;
        }

        FuncDeclaration *fd = hasThis(sc);
        ClassDeclaration *cd;
        Dsymbol *s;

        /* Special case for typeof(this) and typeof(super) since both
         * should work even if they are not inside a non-static member function
         */
        if (!fd && sc->intypeof == 1)
        {
            // Find enclosing class
            for (s = sc->getStructClassScope(); 1; s = s->parent)
            {
                if (!s)
                {
                    e->error("%s is not in a class scope", e->toChars());
                    goto Lerr;
                }
                cd = s->isClassDeclaration();
                if (cd)
                {
                    cd = cd->baseClass;
                    if (!cd)
                    {
                        e->error("class %s has no `super`", s->toChars());
                        goto Lerr;
                    }
                    e->type = cd->type;
                    result = e;
                    return;
                }
            }
        }
        if (!fd)
            goto Lerr;

        e->var = fd->vthis;
        assert(e->var && e->var->parent);

        s = fd->toParent();
        while (s && s->isTemplateInstance())
            s = s->toParent();
        if (s->isTemplateDeclaration()) // allow inside template constraint
            s = s->toParent();
        assert(s);
        cd = s->isClassDeclaration();
        //printf("parent is %s %s\n", fd->toParent()->kind(), fd->toParent()->toChars());
        if (!cd)
            goto Lerr;
        if (!cd->baseClass)
        {
            e->error("no base class for %s", cd->toChars());
            e->type = e->var->type;
        }
        else
        {
            e->type = cd->baseClass->type;
            e->type = e->type->castMod(e->var->type->mod);
        }

        if (e->var->checkNestedReference(sc, e->loc))
            return setError();

        if (!sc->intypeof)
            sc->callSuper |= CSXsuper;
        result = e;
        return;

    Lerr:
        e->error("`super` is only allowed in non-static class member functions");
        return setError();
    }

    void visit(NullExp *e)
    {
        // NULL is the same as (void *)0
        if (e->type)
        {
            result = e;
            return;
        }
        e->type = Type::tnull;
        result = e;
    }

    void visit(StringExp *e)
    {
        if (e->type)
        {
            result = e;
            return;
        }

        OutBuffer buffer;
        size_t newlen = 0;
        const char *p;
        size_t u;
        unsigned c;

        switch (e->postfix)
        {
            case 'd':
                for (u = 0; u < e->len;)
                {
                    p = utf_decodeChar((utf8_t *)e->string, e->len, &u, &c);
                    if (p)
                    {
                        e->error("%s", p);
                        return setError();
                    }
                    else
                    {
                        buffer.write4(c);
                        newlen++;
                    }
                }
                buffer.write4(0);
                e->string = buffer.extractData();
                e->len = newlen;
                e->sz = 4;
                e->type = new TypeDArray(Type::tdchar->immutableOf());
                e->committed = 1;
                break;

            case 'w':
                for (u = 0; u < e->len;)
                {
                    p = utf_decodeChar((utf8_t *)e->string, e->len, &u, &c);
                    if (p)
                    {
                        e->error("%s", p);
                        return setError();
                    }
                    else
                    {
                        buffer.writeUTF16(c);
                        newlen++;
                        if (c >= 0x10000)
                            newlen++;
                    }
                }
                buffer.writeUTF16(0);
                e->string = buffer.extractData();
                e->len = newlen;
                e->sz = 2;
                e->type = new TypeDArray(Type::twchar->immutableOf());
                e->committed = 1;
                break;

            case 'c':
                e->committed = 1;
                /* fall through */

            default:
                e->type = new TypeDArray(Type::tchar->immutableOf());
                break;
        }
        e->type = typeSemantic(e->type, e->loc, sc);
        //e->type = e->type->immutableOf();
        //printf("type = %s\n", e->type->toChars());

        result = e;
    }

    void visit(ArrayLiteralExp *e)
    {
        if (e->type)
        {
            result = e;
            return;
        }

        /* Perhaps an empty array literal [ ] should be rewritten as null?
        */

        if (e->basis)
            e->basis = expressionSemantic(e->basis, sc);
        if (arrayExpressionSemantic(e->elements, sc) || (e->basis && e->basis->op == TOKerror))
            return setError();
        expandTuples(e->elements);

        Type *t0;
        if (e->basis)
            e->elements->push(e->basis);
        bool err = arrayExpressionToCommonType(sc, e->elements, &t0);
        if (e->basis)
            e->elements->pop();
        if (err)
            return setError();

        e->type = t0->arrayOf();
        e->type = typeSemantic(e->type, e->loc, sc);

        /* Disallow array literals of type void being used.
        */
        if (e->elements->length > 0 && t0->ty == Tvoid)
        {
            e->error("%s of type %s has no value", e->toChars(), e->type->toChars());
            return setError();
        }

        if (global.params.useTypeInfo && Type::dtypeinfo)
            semanticTypeInfo(sc, e->type);

        result = e;
    }

    void visit(AssocArrayLiteralExp *e)
    {
        if (e->type)
        {
            result = e;
            return;
        }

        // Run semantic() on each element
        bool err_keys = arrayExpressionSemantic(e->keys, sc);
        bool err_vals = arrayExpressionSemantic(e->values, sc);
        if (err_keys || err_vals)
            return setError();
        expandTuples(e->keys);
        expandTuples(e->values);
        if (e->keys->length != e->values->length)
        {
            e->error("number of keys is %u, must match number of values %u", e->keys->length, e->values->length);
            return setError();
        }

        Type *tkey = NULL;
        Type *tvalue = NULL;
        err_keys = arrayExpressionToCommonType(sc, e->keys, &tkey);
        err_vals = arrayExpressionToCommonType(sc, e->values, &tvalue);
        if (err_keys || err_vals)
            return setError();

        if (tkey == Type::terror || tvalue == Type::terror)
            return setError();

        e->type = new TypeAArray(tvalue, tkey);
        e->type = typeSemantic(e->type, e->loc, sc);

        semanticTypeInfo(sc, e->type);

        result = e;
    }

    void visit(StructLiteralExp *e)
    {
        if (e->type)
        {
            result = e;
            return;
        }

        e->sd->size(e->loc);
        if (e->sd->sizeok != SIZEOKdone)
            return setError();

        if (arrayExpressionSemantic(e->elements, sc))  // run semantic() on each element
            return setError();
        expandTuples(e->elements);

        /* Fit elements[] to the corresponding type of field[].
        */
        if (!e->sd->fit(e->loc, sc, e->elements, e->stype))
            return setError();

        /* Fill out remainder of elements[] with default initializers for fields[]
        */
        if (!e->sd->fill(e->loc, e->elements, false))
        {
            /* An error in the initializer needs to be recorded as an error
             * in the enclosing function or template, since the initializer
             * will be part of the stuct declaration.
             */
            global.increaseErrorCount();
            return setError();
        }

        if (checkFrameAccess(e->loc, sc, e->sd, e->elements->length))
            return setError();

        e->type = e->stype ? e->stype : e->sd->type;
        result = e;
    }

    void visit(TypeExp *exp)
    {
        if (exp->type->ty == Terror)
            return setError();

        //printf("TypeExp::semantic(%s)\n", exp->type->toChars());
        Expression *e;
        Type *t;
        Dsymbol *s;

        exp->type->resolve(exp->loc, sc, &e, &t, &s, true);
        if (e)
        {
            // `(Type)` is actually `(var)` so if `(var)` is a member requiring `this`
            // then rewrite as `(this.var)` in case it would be followed by a DotVar
            // to fix https://issues.dlang.org/show_bug.cgi?id=9490
            VarExp *ve = e->isVarExp();
            if (ve && ve->var && exp->parens && !ve->var->isStatic() && !(sc->stc & STCstatic) &&
                sc->func && sc->func->needThis() && ve->var->toParent2()->isAggregateDeclaration())
            {
                // printf("apply fix for issue 9490: add `this.` to `%s`...\n", e->toChars());
                e = new DotVarExp(exp->loc, new ThisExp(exp->loc), ve->var, false);
            }
            //printf("e = %s %s\n", Token::toChars(e->op), e->toChars());
            e = expressionSemantic(e, sc);
        }
        else if (t)
        {
            //printf("t = %d %s\n", t->ty, t->toChars());
            exp->type = typeSemantic(t, exp->loc, sc);
            e = exp;
        }
        else if (s)
        {
            //printf("s = %s %s\n", s->kind(), s->toChars());
            e = resolve(exp->loc, sc, s, true);
        }
        else
            assert(0);

        if (global.params.vcomplex)
            exp->type->checkComplexTransition(exp->loc);

        result = e;
    }

    void visit(ScopeExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        ScopeDsymbol *sds2 = exp->sds;
        TemplateInstance *ti = sds2->isTemplateInstance();
        while (ti)
        {
            WithScopeSymbol *withsym;
            if (!ti->findTempDecl(sc, &withsym) ||
                !ti->semanticTiargs(sc))
                return setError();
            if (withsym && withsym->withstate->wthis)
            {
                Expression *e = new VarExp(exp->loc, withsym->withstate->wthis);
                e = new DotTemplateInstanceExp(exp->loc, e, ti);
                result = expressionSemantic(e, sc);
                return;
            }
            if (ti->needsTypeInference(sc))
            {
                if (TemplateDeclaration *td = ti->tempdecl->isTemplateDeclaration())
                {
                    Dsymbol *p = td->toParent2();
                    FuncDeclaration *fdthis = hasThis(sc);
                    AggregateDeclaration *ad = p ? p->isAggregateDeclaration() : NULL;
                    if (fdthis && ad && isAggregate(fdthis->vthis->type) == ad &&
                        (td->_scope->stc & STCstatic) == 0)
                    {
                        Expression *e = new DotTemplateInstanceExp(exp->loc, new ThisExp(exp->loc), ti->name, ti->tiargs);
                        result = expressionSemantic(e, sc);
                        return;
                    }
                }
                else if (OverloadSet *os = ti->tempdecl->isOverloadSet())
                {
                    FuncDeclaration *fdthis = hasThis(sc);
                    AggregateDeclaration *ad = os->parent->isAggregateDeclaration();
                    if (fdthis && ad && isAggregate(fdthis->vthis->type) == ad)
                    {
                        Expression *e = new DotTemplateInstanceExp(exp->loc, new ThisExp(exp->loc), ti->name, ti->tiargs);
                        result = expressionSemantic(e, sc);
                        return;
                    }
                }
                // ti is an instance which requires IFTI.
                exp->sds = ti;
                exp->type = Type::tvoid;
                result = exp;
                return;
            }
            dsymbolSemantic(ti, sc);
            if (!ti->inst || ti->errors)
                return setError();

            Dsymbol *s = ti->toAlias();
            if (s == ti)
            {
                exp->sds = ti;
                exp->type = Type::tvoid;
                result = exp;
                return;
            }
            sds2 = s->isScopeDsymbol();
            if (sds2)
            {
                ti = sds2->isTemplateInstance();
                //printf("+ sds2 = %s, '%s'\n", sds2->kind(), sds2->toChars());
                continue;
            }

            if (VarDeclaration *v = s->isVarDeclaration())
            {
                if (!v->type)
                {
                    exp->error("forward reference of %s %s", v->kind(), v->toChars());
                    return setError();
                }
                if ((v->storage_class & STCmanifest) && v->_init)
                {
                    /* When an instance that will be converted to a constant exists,
                     * the instance representation "foo!tiargs" is treated like a
                     * variable name, and its recursive appearance check (note that
                     * it's equivalent with a recursive instantiation of foo) is done
                     * separately from the circular initialization check for the
                     * eponymous enum variable declaration.
                     *
                     *  template foo(T) {
                     *    enum bool foo = foo;    // recursive definition check (v.inuse)
                     *  }
                     *  template bar(T) {
                     *    enum bool bar = bar!T;  // recursive instantiation check (ti.inuse)
                     *  }
                     */
                    if (ti->inuse)
                    {
                        exp->error("recursive expansion of %s `%s`", ti->kind(), ti->toPrettyChars());
                        return setError();
                    }

                    Expression *e = v->expandInitializer(exp->loc);
                    ti->inuse++;
                    e = expressionSemantic(e, sc);
                    ti->inuse--;
                    result = e;
                    return;
                }
            }

            //printf("s = %s, '%s'\n", s->kind(), s->toChars());
            Expression *e = resolve(exp->loc, sc, s, true);
            //printf("-1ScopeExp::semantic()\n");
            result = e;
            return;
        }

        //printf("sds2 = %s, '%s'\n", sds2->kind(), sds2->toChars());
        //printf("\tparent = '%s'\n", sds2->parent->toChars());
        dsymbolSemantic(sds2, sc);

        if (Type *t = sds2->getType())    // (Aggregate|Enum)Declaration
        {
            Expression *ex = new TypeExp(exp->loc, t);
            result = expressionSemantic(ex, sc);
            return;
        }

        if (TemplateDeclaration *td = sds2->isTemplateDeclaration())
        {
            result = expressionSemantic(new TemplateExp(exp->loc, td), sc);
            return;
        }

        exp->sds = sds2;
        exp->type = Type::tvoid;
        //printf("-2ScopeExp::semantic() %s\n", exp->toChars());
        result = exp;
    }

    void visit(NewExp *exp)
    {
        if (exp->type)                   // if semantic() already run
        {
            result = exp;
            return;
        }

        // Bugzilla 11581: With the syntax `new T[edim]` or `thisexp.new T[edim]`,
        // T should be analyzed first and edim should go into arguments iff it's
        // not a tuple.
        Expression *edim = NULL;
        if (!exp->arguments && exp->newtype->ty == Tsarray)
        {
            edim = ((TypeSArray *)exp->newtype)->dim;
            exp->newtype = ((TypeNext *)exp->newtype)->next;
        }

        ClassDeclaration *cdthis = NULL;
        if (exp->thisexp)
        {
            exp->thisexp = expressionSemantic(exp->thisexp, sc);
            if (exp->thisexp->op == TOKerror)
                return setError();
            cdthis = exp->thisexp->type->isClassHandle();
            if (!cdthis)
            {
                exp->error("`this` for nested class must be a class type, not %s", exp->thisexp->type->toChars());
                return setError();
            }

            sc = sc->push(cdthis);
            exp->type = typeSemantic(exp->newtype, exp->loc, sc);
            sc = sc->pop();
        }
        else
        {
            exp->type = typeSemantic(exp->newtype, exp->loc, sc);
        }
        if (exp->type->ty == Terror)
            return setError();

        if (edim)
        {
            if (exp->type->toBasetype()->ty == Ttuple)
            {
                // --> new T[edim]
                exp->type = new TypeSArray(exp->type, edim);
                exp->type = typeSemantic(exp->type, exp->loc, sc);
                if (exp->type->ty == Terror)
                    return setError();
            }
            else
            {
                // --> new T[](edim)
                exp->arguments = new Expressions();
                exp->arguments->push(edim);
                exp->type = exp->type->arrayOf();
            }
        }

        exp->newtype = exp->type;             // in case type gets cast to something else
        Type *tb = exp->type->toBasetype();
        //printf("tb: %s, deco = %s\n", tb->toChars(), tb->deco);

        if (arrayExpressionSemantic(exp->newargs, sc) ||
            preFunctionParameters(sc, exp->newargs))
        {
            return setError();
        }
        if (arrayExpressionSemantic(exp->arguments, sc) ||
            preFunctionParameters(sc, exp->arguments))
        {
            return setError();
        }

        if (exp->thisexp && tb->ty != Tclass)
        {
            exp->error("e.new is only for allocating nested classes, not %s", tb->toChars());
            return setError();
        }

        size_t nargs = exp->arguments ? exp->arguments->length : 0;
        Expression *newprefix = NULL;

        if (tb->ty == Tclass)
        {
            ClassDeclaration *cd = ((TypeClass *)tb)->sym;
            cd->size(exp->loc);
            if (cd->sizeok != SIZEOKdone)
                return setError();
            if (!cd->ctor)
                cd->ctor = cd->searchCtor();
            if (cd->noDefaultCtor && !nargs && !cd->defaultCtor)
            {
                exp->error("default construction is disabled for type %s", cd->type->toChars());
                return setError();
            }

            if (cd->isInterfaceDeclaration())
            {
                exp->error("cannot create instance of interface %s", cd->toChars());
                return setError();
            }
            if (cd->isAbstract())
            {
                exp->error("cannot create instance of abstract class %s", cd->toChars());
                for (size_t i = 0; i < cd->vtbl.length; i++)
                {
                    FuncDeclaration *fd = cd->vtbl[i]->isFuncDeclaration();
                    if (fd && fd->isAbstract())
                        errorSupplemental(exp->loc, "function `%s` is not implemented", fd->toFullSignature());
                }
                return setError();
            }
            // checkDeprecated() is already done in newtype->semantic().

            if (cd->isNested())
            {
                /* We need a 'this' pointer for the nested class.
                 * Ensure we have the right one.
                 */
                Dsymbol *s = cd->toParent2();
                //printf("cd isNested, parent = %s '%s'\n", s->kind(), s->toPrettyChars());
                if (ClassDeclaration *cdn = s->isClassDeclaration())
                {
                    if (!cdthis)
                    {
                        // Supply an implicit 'this' and try again
                        exp->thisexp = new ThisExp(exp->loc);
                        for (Dsymbol *sp = sc->parent; 1; sp = sp->parent)
                        {
                            if (!sp)
                            {
                                exp->error("outer class %s `this` needed to `new` nested class %s", cdn->toChars(), cd->toChars());
                                return setError();
                            }
                            ClassDeclaration *cdp = sp->isClassDeclaration();
                            if (!cdp)
                                continue;
                            if (cdp == cdn || cdn->isBaseOf(cdp, NULL))
                                break;
                            // Add a '.outer' and try again
                            exp->thisexp = new DotIdExp(exp->loc, exp->thisexp, Id::outer);
                        }
                        exp->thisexp = expressionSemantic(exp->thisexp, sc);
                        if (exp->thisexp->op == TOKerror)
                            return setError();
                        cdthis = exp->thisexp->type->isClassHandle();
                    }
                    if (cdthis != cdn && !cdn->isBaseOf(cdthis, NULL))
                    {
                        //printf("cdthis = %s\n", cdthis->toChars());
                        exp->error("`this` for nested class must be of type %s, not %s",
                            cdn->toChars(), exp->thisexp->type->toChars());
                        return setError();
                    }
                    if (!MODimplicitConv(exp->thisexp->type->mod, exp->newtype->mod))
                    {
                        exp->error("nested type %s should have the same or weaker constancy as enclosing type %s",
                            exp->newtype->toChars(), exp->thisexp->type->toChars());
                        return setError();
                    }
                }
                else if (exp->thisexp)
                {
                    exp->error("e.new is only for allocating nested classes");
                    return setError();
                }
                else if (FuncDeclaration *fdn = s->isFuncDeclaration())
                {
                    // make sure the parent context fdn of cd is reachable from sc
                    if (checkNestedRef(sc->parent, fdn))
                    {
                        exp->error("outer function context of %s is needed to `new` nested class %s",
                            fdn->toPrettyChars(), cd->toPrettyChars());
                        return setError();
                    }
                }
                else
                    assert(0);
            }
            else if (exp->thisexp)
            {
                exp->error("e.new is only for allocating nested classes");
                return setError();
            }

            if (cd->aggNew)
            {
                // Prepend the size argument to newargs[]
                Expression *e = new IntegerExp(exp->loc, cd->size(exp->loc), Type::tsize_t);
                if (!exp->newargs)
                    exp->newargs = new Expressions();
                exp->newargs->shift(e);

                FuncDeclaration *f = resolveFuncCall(exp->loc, sc, cd->aggNew, NULL, tb, exp->newargs);
                if (!f || f->errors)
                    return setError();
                exp->checkDeprecated(sc, f);
                exp->checkDisabled(sc, f);
                exp->checkPurity(sc, f);
                exp->checkSafety(sc, f);
                exp->checkNogc(sc, f);
                checkAccess(cd, exp->loc, sc, f);

                TypeFunction *tf = (TypeFunction *)f->type;
                Type *rettype;
                if (functionParameters(exp->loc, sc, tf, NULL, exp->newargs, f, &rettype, &newprefix))
                    return setError();

                exp->allocator = f->isNewDeclaration();
                assert(exp->allocator);
            }
            else
            {
                if (exp->newargs && exp->newargs->length)
                {
                    exp->error("no allocator for %s", cd->toChars());
                    return setError();
                }
            }

            if (cd->ctor)
            {
                FuncDeclaration *f = resolveFuncCall(exp->loc, sc, cd->ctor, NULL, tb, exp->arguments, 0);
                if (!f || f->errors)
                    return setError();
                exp->checkDeprecated(sc, f);
                exp->checkDisabled(sc, f);
                exp->checkPurity(sc, f);
                exp->checkSafety(sc, f);
                exp->checkNogc(sc, f);
                checkAccess(cd, exp->loc, sc, f);

                TypeFunction *tf = (TypeFunction *)f->type;
                if (!exp->arguments)
                    exp->arguments = new Expressions();
                if (functionParameters(exp->loc, sc, tf, exp->type, exp->arguments, f, &exp->type, &exp->argprefix))
                    return setError();

                exp->member = f->isCtorDeclaration();
                assert(exp->member);
            }
            else
            {
                if (nargs)
                {
                    exp->error("no constructor for %s", cd->toChars());
                    return setError();
                }

                // https://issues.dlang.org/show_bug.cgi?id=19941
                // Run semantic on all field initializers to resolve any forward
                // references. This is the same as done for structs in sd->fill().
                for (ClassDeclaration *c = cd; c; c = c->baseClass)
                {
                    for (size_t i = 0; i < c->fields.length; i++)
                    {
                        VarDeclaration *v = c->fields[i];
                        if (v->inuse || v->_scope == NULL || v->_init == NULL ||
                            v->_init->isVoidInitializer())
                            continue;
                        v->inuse++;
                        v->_init = initializerSemantic(v->_init, v->_scope, v->type, INITinterpret);
                        v->inuse--;
                    }
                }
            }
        }
        else if (tb->ty == Tstruct)
        {
            StructDeclaration *sd = ((TypeStruct *)tb)->sym;
            sd->size(exp->loc);
            if (sd->sizeok != SIZEOKdone)
                return setError();
            if (!sd->ctor)
                sd->ctor = sd->searchCtor();
            if (sd->noDefaultCtor && !nargs)
            {
                exp->error("default construction is disabled for type %s", sd->type->toChars());
                return setError();
            }
            // checkDeprecated() is already done in newtype->semantic().

            if (sd->aggNew)
            {
                // Prepend the uint size argument to newargs[]
                Expression *e = new IntegerExp(exp->loc, sd->size(exp->loc), Type::tsize_t);
                if (!exp->newargs)
                    exp->newargs = new Expressions();
                exp->newargs->shift(e);

                FuncDeclaration *f = resolveFuncCall(exp->loc, sc, sd->aggNew, NULL, tb, exp->newargs);
                if (!f || f->errors)
                    return setError();
                exp->checkDeprecated(sc, f);
                exp->checkDisabled(sc, f);
                exp->checkPurity(sc, f);
                exp->checkSafety(sc, f);
                exp->checkNogc(sc, f);
                checkAccess(sd, exp->loc, sc, f);

                TypeFunction *tf = (TypeFunction *)f->type;
                Type *rettype;
                if (functionParameters(exp->loc, sc, tf, NULL, exp->newargs, f, &rettype, &newprefix))
                    return setError();

                exp->allocator = f->isNewDeclaration();
                assert(exp->allocator);
            }
            else
            {
                if (exp->newargs && exp->newargs->length)
                {
                    exp->error("no allocator for %s", sd->toChars());
                    return setError();
                }
            }

            if (sd->ctor && nargs)
            {
                FuncDeclaration *f = resolveFuncCall(exp->loc, sc, sd->ctor, NULL, tb, exp->arguments, 0);
                if (!f || f->errors)
                    return setError();
                exp->checkDeprecated(sc, f);
                exp->checkDisabled(sc, f);
                exp->checkPurity(sc, f);
                exp->checkSafety(sc, f);
                exp->checkNogc(sc, f);
                checkAccess(sd, exp->loc, sc, f);

                TypeFunction *tf = (TypeFunction *)f->type;
                if (!exp->arguments)
                    exp->arguments = new Expressions();
                if (functionParameters(exp->loc, sc, tf, exp->type, exp->arguments, f, &exp->type, &exp->argprefix))
                    return setError();

                exp->member = f->isCtorDeclaration();
                assert(exp->member);

                if (checkFrameAccess(exp->loc, sc, sd, sd->fields.length))
                    return setError();
            }
            else
            {
                if (!exp->arguments)
                    exp->arguments = new Expressions();

                if (!sd->fit(exp->loc, sc, exp->arguments, tb))
                    return setError();
                if (!sd->fill(exp->loc, exp->arguments, false))
                    return setError();
                if (checkFrameAccess(exp->loc, sc, sd, exp->arguments ? exp->arguments->length : 0))
                    return setError();
            }

            exp->type = exp->type->pointerTo();
        }
        else if (tb->ty == Tarray && nargs)
        {
            Type *tn = tb->nextOf()->baseElemOf();
            Dsymbol *s = tn->toDsymbol(sc);
            AggregateDeclaration *ad = s ? s->isAggregateDeclaration() : NULL;
            if (ad && ad->noDefaultCtor)
            {
                exp->error("default construction is disabled for type %s", tb->nextOf()->toChars());
                return setError();
            }
            for (size_t i = 0; i < nargs; i++)
            {
                if (tb->ty != Tarray)
                {
                    exp->error("too many arguments for array");
                    return setError();
                }

                Expression *arg = (*exp->arguments)[i];
                arg = resolveProperties(sc, arg);
                arg = arg->implicitCastTo(sc, Type::tsize_t);
                arg = arg->optimize(WANTvalue);
                if (arg->op == TOKint64 && (sinteger_t)arg->toInteger() < 0)
                {
                    exp->error("negative array index %s", arg->toChars());
                    return setError();
                }
                (*exp->arguments)[i] =  arg;
                tb = ((TypeDArray *)tb)->next->toBasetype();
            }
        }
        else if (tb->isscalar())
        {
            if (!nargs)
            {
            }
            else if (nargs == 1)
            {
                Expression *e = (*exp->arguments)[0];
                e = e->implicitCastTo(sc, tb);
                (*exp->arguments)[0] = e;
            }
            else
            {
                exp->error("more than one argument for construction of %s", exp->type->toChars());
                return setError();
            }

            exp->type = exp->type->pointerTo();
        }
        else
        {
            exp->error("new can only create structs, dynamic arrays or class objects, not %s's", exp->type->toChars());
            return setError();
        }

        //printf("NewExp: '%s'\n", toChars());
        //printf("NewExp:type '%s'\n", exp->type->toChars());
        semanticTypeInfo(sc, exp->type);

        if (newprefix)
        {
            result = Expression::combine(newprefix, exp);
            return;
        }
        result = exp;
    }

    void visit(NewAnonClassExp *e)
    {
        Expression *d = new DeclarationExp(e->loc, e->cd);
        sc = sc->push();            // just create new scope
        sc->flags &= ~SCOPEctfe;    // temporary stop CTFE
        d = expressionSemantic(d, sc);
        sc = sc->pop();

        if (!e->cd->errors && sc->intypeof && !sc->parent->inNonRoot())
        {
            ScopeDsymbol *sds = sc->tinst ? (ScopeDsymbol *)sc->tinst : sc->_module;
            sds->members->push(e->cd);
        }

        Expression *n = new NewExp(e->loc, e->thisexp, e->newargs, e->cd->type, e->arguments);

        Expression *c = new CommaExp(e->loc, d, n);
        result = expressionSemantic(c, sc);
    }

    void visit(SymOffExp *e)
    {
        //dsymbolSemantic(var, sc);
        if (!e->type)
            e->type = e->var->type->pointerTo();
        if (VarDeclaration *v = e->var->isVarDeclaration())
        {
            if (v->checkNestedReference(sc, e->loc))
                return setError();
        }
        else if (FuncDeclaration *f = e->var->isFuncDeclaration())
        {
            if (f->checkNestedReference(sc, e->loc))
                return setError();
        }
        result = e;
    }

    void visit(VarExp *e)
    {
        VarDeclaration *vd = e->var->isVarDeclaration();
        FuncDeclaration *fd = e->var->isFuncDeclaration();

        if (fd)
        {
            //printf("L%d fd = %s\n", __LINE__, f->toChars());
            if (!fd->functionSemantic())
                return setError();
        }

        if (!e->type)
            e->type = e->var->type;

        if (e->type && !e->type->deco)
        {
            Declaration *decl = e->var->isDeclaration();
            if (decl)
                decl->inuse++;
            e->type = typeSemantic(e->type, e->loc, sc);
            if (decl)
                decl->inuse--;
        }

        /* Fix for 1161 doesn't work because it causes protection
         * problems when instantiating imported templates passing private
         * variables as alias template parameters.
         */
        //checkAccess(e->loc, sc, NULL, e->var);

        if (vd)
        {
            if (vd->checkNestedReference(sc, e->loc))
                return setError();
            // Bugzilla 12025: If the variable is not actually used in runtime code,
            // the purity violation error is redundant.
            //checkPurity(sc, vd);
        }
        else if (fd)
        {
            // TODO: If fd isn't yet resolved its overload, the checkNestedReference
            // call would cause incorrect validation.
            // Maybe here should be moved in CallExp, or AddrExp for functions.
            if (fd->checkNestedReference(sc, e->loc))
                return setError();
        }
        else if (e->var->isOverDeclaration())
        {
            e->type = Type::tvoid; // ambiguous type?
        }

        result = e;
    }

    void visit(TupleExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (exp->e0)
            exp->e0 = expressionSemantic(exp->e0, sc);

        // Run semantic() on each argument
        bool err = false;
        for (size_t i = 0; i < exp->exps->length; i++)
        {
            Expression *e = (*exp->exps)[i];
            e = expressionSemantic(e, sc);
            if (!e->type)
            {
                exp->error("%s has no value", e->toChars());
                err = true;
            }
            else if (e->op == TOKerror)
                err = true;
            else
                (*exp->exps)[i] = e;
        }
        if (err)
            return setError();

        expandTuples(exp->exps);
        exp->type = new TypeTuple(exp->exps);
        exp->type = typeSemantic(exp->type, exp->loc, sc);
        //printf("-TupleExp::semantic(%s)\n", exp->toChars());
        result = exp;
    }

    void visit(FuncExp *exp)
    {
        Expression *e = exp;

        sc = sc->push();            // just create new scope
        sc->flags &= ~SCOPEctfe;    // temporary stop CTFE
        sc->protection = Prot(Prot::public_);    // Bugzilla 12506

        if (!exp->type || exp->type == Type::tvoid)
        {
            /* fd->treq might be incomplete type,
             * so should not semantic it.
             * void foo(T)(T delegate(int) dg){}
             * foo(a=>a); // in IFTI, treq == T delegate(int)
             */
            //if (exp->fd->treq)
            //    exp->fd->treq = typeSemantic(exp->fd->treq, exp->loc, sc);

            exp->genIdent(sc);

            // Set target of return type inference
            if (exp->fd->treq && !exp->fd->type->nextOf())
            {
                TypeFunction *tfv = NULL;
                if (exp->fd->treq->ty == Tdelegate ||
                    (exp->fd->treq->ty == Tpointer && exp->fd->treq->nextOf()->ty == Tfunction))
                    tfv = (TypeFunction *)exp->fd->treq->nextOf();
                if (tfv)
                {
                    TypeFunction *tfl = (TypeFunction *)exp->fd->type;
                    tfl->next = tfv->nextOf();
                }
            }

            //printf("td = %p, treq = %p\n", exp->td, exp->fd->treq);
            if (exp->td)
            {
                assert(exp->td->parameters && exp->td->parameters->length);
                dsymbolSemantic(exp->td, sc);
                exp->type = Type::tvoid; // temporary type

                if (exp->fd->treq)       // defer type determination
                {
                    FuncExp *fe;
                    if (exp->matchType(exp->fd->treq, sc, &fe) > MATCHnomatch)
                        e = fe;
                    else
                        e = new ErrorExp();
                }
                goto Ldone;
            }

            unsigned olderrors = global.errors;
            dsymbolSemantic(exp->fd, sc);
            if (olderrors == global.errors)
            {
                semantic2(exp->fd, sc);
                if (olderrors == global.errors)
                    semantic3(exp->fd, sc);
            }
            if (olderrors != global.errors)
            {
                if (exp->fd->type && exp->fd->type->ty == Tfunction && !exp->fd->type->nextOf())
                    ((TypeFunction *)exp->fd->type)->next = Type::terror;
                e = new ErrorExp();
                goto Ldone;
            }

            // Type is a "delegate to" or "pointer to" the function literal
            if ((exp->fd->isNested() && exp->fd->tok == TOKdelegate) ||
                (exp->tok == TOKreserved && exp->fd->treq && exp->fd->treq->ty == Tdelegate))
            {
                exp->type = new TypeDelegate(exp->fd->type);
                exp->type = typeSemantic(exp->type, exp->loc, sc);

                exp->fd->tok = TOKdelegate;
            }
            else
            {
                exp->type = new TypePointer(exp->fd->type);
                exp->type = typeSemantic(exp->type, exp->loc, sc);
                //exp->type = exp->fd->type->pointerTo();

                /* A lambda expression deduced to function pointer might become
                 * to a delegate literal implicitly.
                 *
                 *   auto foo(void function() fp) { return 1; }
                 *   assert(foo({}) == 1);
                 *
                 * So, should keep fd->tok == TOKreserve if fd->treq == NULL.
                 */
                if (exp->fd->treq && exp->fd->treq->ty == Tpointer)
                {
                    // change to non-nested
                    exp->fd->tok = TOKfunction;
                    exp->fd->vthis = NULL;
                }
            }
            exp->fd->tookAddressOf++;
        }
    Ldone:
        sc = sc->pop();
        result = e;
    }

    // used from CallExp::semantic()
    Expression *callExpSemantic(FuncExp *exp, Scope *sc, Expressions *arguments)
    {
        if ((!exp->type || exp->type == Type::tvoid) && exp->td && arguments && arguments->length)
        {
            for (size_t k = 0; k < arguments->length; k++)
            {   Expression *checkarg = (*arguments)[k];
                if (checkarg->op == TOKerror)
                    return checkarg;
            }

            exp->genIdent(sc);

            assert(exp->td->parameters && exp->td->parameters->length);
            dsymbolSemantic(exp->td, sc);

            TypeFunction *tfl = (TypeFunction *)exp->fd->type;
            size_t dim = tfl->parameterList.length();
            if (arguments->length < dim)
            {   // Default arguments are always typed, so they don't need inference.
                Parameter *p = tfl->parameterList[arguments->length];
                if (p->defaultArg)
                    dim = arguments->length;
            }

            if ((tfl->parameterList.varargs == VARARGnone && arguments->length == dim) ||
                (tfl->parameterList.varargs != VARARGnone && arguments->length >= dim))
            {
                Objects *tiargs = new Objects();
                tiargs->reserve(exp->td->parameters->length);

                for (size_t i = 0; i < exp->td->parameters->length; i++)
                {
                    TemplateParameter *tp = (*exp->td->parameters)[i];
                    for (size_t u = 0; u < dim; u++)
                    {   Parameter *p = tfl->parameterList[u];
                        if (p->type->ty == Tident &&
                            ((TypeIdentifier *)p->type)->ident == tp->ident)
                        {   Expression *e = (*arguments)[u];
                            tiargs->push(e->type);
                            u = dim;    // break inner loop
                        }
                    }
                }

                TemplateInstance *ti = new TemplateInstance(exp->loc, exp->td, tiargs);
                Expression *se = new ScopeExp(exp->loc, ti);
                return expressionSemantic(se, sc);
            }
            exp->error("cannot infer function literal type");
            return new ErrorExp();
        }
        return expressionSemantic(exp, sc);
    }

    void visit(DeclarationExp *e)
    {
        if (e->type)
        {
            result = e;
            return;
        }

        unsigned olderrors = global.errors;

        /* This is here to support extern(linkage) declaration,
         * where the extern(linkage) winds up being an AttribDeclaration
         * wrapper.
         */
        Dsymbol *s = e->declaration;

        while (1)
        {
            AttribDeclaration *ad = s->isAttribDeclaration();
            if (ad)
            {
                if (ad->decl && ad->decl->length == 1)
                {
                    s = (*ad->decl)[0];
                    continue;
                }
            }
            break;
        }

        VarDeclaration *v = s->isVarDeclaration();
        if (v)
        {
            // Do semantic() on initializer first, so:
            //      int a = a;
            // will be illegal.
            dsymbolSemantic(e->declaration, sc);
            s->parent = sc->parent;
        }

        //printf("inserting '%s' %p into sc = %p\n", s->toChars(), s, sc);
        // Insert into both local scope and function scope.
        // Must be unique in both.
        if (s->ident)
        {
            if (!sc->insert(s))
            {
                e->error("declaration %s is already defined", s->toPrettyChars());
                return setError();
            }
            else if (sc->func)
            {
                // Bugzilla 11720 - include Dataseg variables
                if ((s->isFuncDeclaration() ||
                     s->isAggregateDeclaration() ||
                     s->isEnumDeclaration() ||
                     (v && v->isDataseg())) &&
                    !sc->func->localsymtab->insert(s))
                {
                    e->error("declaration %s is already defined in another scope in %s",
                        s->toPrettyChars(), sc->func->toChars());
                    return setError();
                }
                else
                {
                    // Disallow shadowing
                    for (Scope *scx = sc->enclosing; scx && (scx->func == sc->func || (scx->func && sc->func->fes)); scx = scx->enclosing)
                    {
                        Dsymbol *s2;
                        if (scx->scopesym && scx->scopesym->symtab &&
                            (s2 = scx->scopesym->symtab->lookup(s->ident)) != NULL &&
                            s != s2)
                        {
                            // allow STClocal symbols to be shadowed
                            // TODO: not reallly an optimal design
                            Declaration *decl = s2->isDeclaration();
                            if (!decl || !(decl->storage_class & STClocal))
                            {
                                if (sc->func->fes)
                                {
                                    e->deprecation("%s `%s` is shadowing %s `%s`. Rename the `foreach` variable.",
                                        s->kind(), s->ident->toChars(), s2->kind(), s2->toPrettyChars());
                                }
                                else
                                {
                                    e->error("%s %s is shadowing %s %s",
                                        s->kind(), s->ident->toChars(), s2->kind(), s2->toPrettyChars());
                                    return setError();
                                }
                            }
                        }
                    }
                }
            }
        }
        if (!s->isVarDeclaration())
        {
            Scope *sc2 = sc;
            if (sc2->stc & (STCpure | STCnothrow | STCnogc))
                sc2 = sc->push();
            sc2->stc &= ~(STCpure | STCnothrow | STCnogc);
            dsymbolSemantic(e->declaration, sc2);
            if (sc2 != sc)
                sc2->pop();
            s->parent = sc->parent;
        }
        if (global.errors == olderrors)
        {
            semantic2(e->declaration, sc);
            if (global.errors == olderrors)
            {
                semantic3(e->declaration, sc);
            }
        }
        // todo: error in declaration should be propagated.

        e->type = Type::tvoid;
        result = e;
    }

    void visit(TypeidExp *exp)
    {
        Type *ta = isType(exp->obj);
        Expression *ea = isExpression(exp->obj);
        Dsymbol *sa = isDsymbol(exp->obj);

        //printf("ta %p ea %p sa %p\n", ta, ea, sa);

        if (ta)
        {
            ta->resolve(exp->loc, sc, &ea, &ta, &sa, true);
        }

        if (ea)
        {
            if (Dsymbol *sym = getDsymbol(ea))
                ea = resolve(exp->loc, sc, sym, false);
            else
                ea = expressionSemantic(ea, sc);
            ea = resolveProperties(sc, ea);
            ta = ea->type;
            if (ea->op == TOKtype)
                ea = NULL;
        }

        if (!ta)
        {
            //printf("ta %p ea %p sa %p\n", ta, ea, sa);
            exp->error("no type for typeid(%s)", ea ? ea->toChars() : (sa ? sa->toChars() : ""));
            return setError();
        }

        if (global.params.vcomplex)
            ta->checkComplexTransition(exp->loc);

        Expression *e;
        if (ea && ta->toBasetype()->ty == Tclass)
        {
            if (!Type::typeinfoclass)
            {
                error(exp->loc, "`object.TypeInfo_Class` could not be found, but is implicitly used");
                e = new ErrorExp();
            }
            else
            {
                /* Get the dynamic type, which is .classinfo
                */
                ea = expressionSemantic(ea, sc);
                e = new TypeidExp(ea->loc, ea);
                e->type = Type::typeinfoclass->type;
            }
        }
        else if (ta->ty == Terror)
        {
            e = new ErrorExp();
        }
        else
        {
            // Handle this in the glue layer
            e = new TypeidExp(exp->loc, ta);
            e->type = getTypeInfoType(exp->loc, ta, sc);

            semanticTypeInfo(sc, ta);

            if (ea)
            {
                e = new CommaExp(exp->loc, ea, e);       // execute ea
                e = expressionSemantic(e, sc);
            }
        }
        result = e;
    }

    void visit(TraitsExp *e)
    {
        result = semanticTraits(e, sc);
    }

    void visit(HaltExp *e)
    {
        e->type = Type::tnoreturn;
        result = e;
    }

    void visit(IsExp *e)
    {
        /* is(targ id tok tspec)
         * is(targ id :  tok2)
         * is(targ id == tok2)
         */

        //printf("IsExp::semantic(%s)\n", toChars());
        if (e->id && !(sc->flags & SCOPEcondition))
        {
            e->error("can only declare type aliases within static if conditionals or static asserts");
            return setError();
        }

        Type *tded = NULL;
        if (e->tok2 == TOKpackage || e->tok2 == TOKmodule) // These is() expressions are special because they can work on modules, not just types.
        {
            const unsigned oldErrors = global.startGagging();
            Dsymbol *sym = e->targ->toDsymbol(sc);
            global.endGagging(oldErrors);
            if (sym == NULL)
                goto Lno;
            Package *p = resolveIsPackage(sym);
            if (p == NULL)
                goto Lno;
            if (e->tok2 == TOKpackage && p->isModule()) // Note that isModule() will return null for package modules because they're not actually instances of Module.
                goto Lno;
            else if(e->tok2 == TOKmodule && !(p->isModule() || p->isPackageMod()))
                goto Lno;
            tded = e->targ;
            goto Lyes;
        }

        {
            Scope *sc2 = sc->copy(); // keep sc->flags
            sc2->tinst = NULL;
            sc2->minst = NULL;
            sc2->flags |= SCOPEfullinst;
            Type *t = e->targ->trySemantic(e->loc, sc2);
            sc2->pop();
            if (!t) // errors, so condition is false
                goto Lno;
            e->targ = t;
        }

        if (e->tok2 != TOKreserved)
        {
            switch (e->tok2)
            {
                case TOKstruct:
                    if (e->targ->ty != Tstruct)
                        goto Lno;
                    if (((TypeStruct *)e->targ)->sym->isUnionDeclaration())
                        goto Lno;
                    tded = e->targ;
                    break;

                case TOKunion:
                    if (e->targ->ty != Tstruct)
                        goto Lno;
                    if (!((TypeStruct *)e->targ)->sym->isUnionDeclaration())
                        goto Lno;
                    tded = e->targ;
                    break;

                case TOKclass:
                    if (e->targ->ty != Tclass)
                        goto Lno;
                    if (((TypeClass *)e->targ)->sym->isInterfaceDeclaration())
                        goto Lno;
                    tded = e->targ;
                    break;

                case TOKinterface:
                    if (e->targ->ty != Tclass)
                        goto Lno;
                    if (!((TypeClass *)e->targ)->sym->isInterfaceDeclaration())
                        goto Lno;
                    tded = e->targ;
                    break;
                case TOKconst:
                    if (!e->targ->isConst())
                        goto Lno;
                    tded = e->targ;
                    break;

                case TOKimmutable:
                    if (!e->targ->isImmutable())
                        goto Lno;
                    tded = e->targ;
                    break;

                case TOKshared:
                    if (!e->targ->isShared())
                        goto Lno;
                    tded = e->targ;
                    break;

                case TOKwild:
                    if (!e->targ->isWild())
                        goto Lno;
                    tded = e->targ;
                    break;

                case TOKsuper:
                    // If class or interface, get the base class and interfaces
                    if (e->targ->ty != Tclass)
                        goto Lno;
                    else
                    {
                        ClassDeclaration *cd = ((TypeClass *)e->targ)->sym;
                        Parameters *args = new Parameters;
                        args->reserve(cd->baseclasses->length);
                        if (cd->semanticRun < PASSsemanticdone)
                            dsymbolSemantic(cd, NULL);
                        for (size_t i = 0; i < cd->baseclasses->length; i++)
                        {
                            BaseClass *b = (*cd->baseclasses)[i];
                            args->push(new Parameter(STCin, b->type, NULL, NULL, NULL));
                        }
                        tded = new TypeTuple(args);
                    }
                    break;

                case TOKenum:
                    if (e->targ->ty != Tenum)
                        goto Lno;
                    if (e->id)
                        tded = ((TypeEnum *)e->targ)->sym->getMemtype(e->loc);
                    else
                        tded = e->targ;
                    if (tded->ty == Terror)
                        return setError();
                    break;

                case TOKdelegate:
                    if (e->targ->ty != Tdelegate)
                        goto Lno;
                    tded = ((TypeDelegate *)e->targ)->next;    // the underlying function type
                    break;

                case TOKfunction:
                case TOKparameters:
                    {
                        if (e->targ->ty != Tfunction)
                            goto Lno;
                        tded = e->targ;

                        /* Generate tuple from function parameter types.
                        */
                        assert(tded->ty == Tfunction);
                        TypeFunction *tdedf = (TypeFunction *)tded;
                        size_t dim = tdedf->parameterList.length();
                        Parameters *args = new Parameters;
                        args->reserve(dim);
                        for (size_t i = 0; i < dim; i++)
                        {
                            Parameter *arg = tdedf->parameterList[i];
                            assert(arg && arg->type);
                            /* If one of the default arguments was an error,
                               don't return an invalid tuple
                               */
                            if (e->tok2 == TOKparameters && arg->defaultArg &&
                                arg->defaultArg->op == TOKerror)
                                return setError();
                            args->push(new Parameter(arg->storageClass, arg->type,
                                                     (e->tok2 == TOKparameters) ? arg->ident : NULL,
                                                     (e->tok2 == TOKparameters) ? arg->defaultArg : NULL,
                                                     arg->userAttribDecl));
                        }
                        tded = new TypeTuple(args);
                        break;
                    }
                case TOKreturn:
                    /* Get the 'return type' for the function,
                     * delegate, or pointer to function.
                     */
                    if (e->targ->ty == Tfunction)
                        tded = ((TypeFunction *)e->targ)->next;
                    else if (e->targ->ty == Tdelegate)
                    {
                        tded = ((TypeDelegate *)e->targ)->next;
                        tded = ((TypeFunction *)tded)->next;
                    }
                    else if (e->targ->ty == Tpointer &&
                             ((TypePointer *)e->targ)->next->ty == Tfunction)
                    {
                        tded = ((TypePointer *)e->targ)->next;
                        tded = ((TypeFunction *)tded)->next;
                    }
                    else
                        goto Lno;
                    break;

                case TOKargTypes:
                    /* Generate a type tuple of the equivalent types used to determine if a
                     * function argument of this type can be passed in registers.
                     * The results of this are highly platform dependent, and intended
                     * primarly for use in implementing va_arg().
                     */
                    tded = target.toArgTypes(e->targ);
                    if (!tded)
                        goto Lno;           // not valid for a parameter
                    break;

                case TOKvector:
                    if (e->targ->ty != Tvector)
                        goto Lno;
                    tded = ((TypeVector *)e->targ)->basetype;
                    break;

                default:
                    assert(0);
            }
            goto Lyes;
        }
        else if (e->tspec && !e->id && !(e->parameters && e->parameters->length))
        {
            /* Evaluate to true if targ matches tspec
             * is(targ == tspec)
             * is(targ : tspec)
             */
            e->tspec = typeSemantic(e->tspec, e->loc, sc);
            //printf("targ  = %s, %s\n", e->targ->toChars(), e->targ->deco);
            //printf("tspec = %s, %s\n", e->tspec->toChars(), e->tspec->deco);
            if (e->tok == TOKcolon)
            {
                if (e->targ->implicitConvTo(e->tspec))
                    goto Lyes;
                else
                    goto Lno;
            }
            else /* == */
            {
                if (e->targ->equals(e->tspec))
                    goto Lyes;
                else
                    goto Lno;
            }
        }
        else if (e->tspec)
        {
            /* Evaluate to true if targ matches tspec.
             * If true, declare id as an alias for the specialized type.
             * is(targ == tspec, tpl)
             * is(targ : tspec, tpl)
             * is(targ id == tspec)
             * is(targ id : tspec)
             * is(targ id == tspec, tpl)
             * is(targ id : tspec, tpl)
             */

            Identifier *tid = e->id ? e->id : Identifier::generateId("__isexp_id");
            e->parameters->insert(0, new TemplateTypeParameter(e->loc, tid, NULL, NULL));

            Objects dedtypes;
            dedtypes.setDim(e->parameters->length);
            dedtypes.zero();

            MATCH m = deduceType(e->targ, sc, e->tspec, e->parameters, &dedtypes);
            //printf("targ: %s\n", e->targ->toChars());
            //printf("tspec: %s\n", e->tspec->toChars());
            if (m <= MATCHnomatch ||
                (m != MATCHexact && e->tok == TOKequal))
            {
                goto Lno;
            }
            else
            {
                tded = (Type *)dedtypes[0];
                if (!tded)
                    tded = e->targ;
                Objects tiargs;
                tiargs.setDim(1);
                tiargs[0] = e->targ;

                /* Declare trailing parameters
                */
                for (size_t i = 1; i < e->parameters->length; i++)
                {
                    TemplateParameter *tp = (*e->parameters)[i];
                    Declaration *s = NULL;

                    m = tp->matchArg(e->loc, sc, &tiargs, i, e->parameters, &dedtypes, &s);
                    if (m <= MATCHnomatch)
                        goto Lno;
                    dsymbolSemantic(s, sc);
                    if (!sc->insert(s))
                        e->error("declaration %s is already defined", s->toChars());

                    unSpeculative(sc, s);
                }
                goto Lyes;
            }
        }
        else if (e->id)
        {
            /* Declare id as an alias for type targ. Evaluate to true
             * is(targ id)
             */
            tded = e->targ;
            goto Lyes;
        }

    Lyes:
        if (e->id)
        {
            Dsymbol *s;
            Tuple *tup = isTuple(tded);
            if (tup)
                s = new TupleDeclaration(e->loc, e->id, &(tup->objects));
            else
                s = new AliasDeclaration(e->loc, e->id, tded);
            dsymbolSemantic(s, sc);
            /* The reason for the !tup is unclear. It fails Phobos unittests if it is not there.
             * More investigation is needed.
             */
            if (!tup && !sc->insert(s))
                e->error("declaration %s is already defined", s->toChars());

            unSpeculative(sc, s);
        }
        //printf("Lyes\n");
        result = new IntegerExp(e->loc, 1, Type::tbool);
        return;

    Lno:
        //printf("Lno\n");
        result = new IntegerExp(e->loc, 0, Type::tbool);
    }

    void visit(BinAssignExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (exp->e1->checkReadModifyWrite(exp->op, exp->e2))
            return setError();

        if (exp->e1->op == TOKarraylength)
        {
            // arr.length op= e2;
            e = rewriteOpAssign(exp);
            e = expressionSemantic(e, sc);
            result = e;
            return;
        }
        if (exp->e1->op == TOKslice || exp->e1->type->ty == Tarray || exp->e1->type->ty == Tsarray)
        {
            if (checkNonAssignmentArrayOp(exp->e1))
                return setError();

            if (exp->e1->op == TOKslice)
                ((SliceExp *)exp->e1)->arrayop = true;

            // T[] op= ...
            if (exp->e2->implicitConvTo(exp->e1->type->nextOf()))
            {
                // T[] op= T
                exp->e2 = exp->e2->castTo(sc, exp->e1->type->nextOf());
            }
            else if (Expression *ex = typeCombine(exp, sc))
            {
                result = ex;
                return;
            }
            exp->type = exp->e1->type;
            result = arrayOp(exp, sc);
            return;
        }

        exp->e1 = expressionSemantic(exp->e1, sc);
        exp->e1 = exp->e1->optimize(WANTvalue);
        exp->e1 = exp->e1->modifiableLvalue(sc, exp->e1);
        exp->type = exp->e1->type;
        if (exp->checkScalar())
            return setError();

        int arith = (exp->op == TOKaddass || exp->op == TOKminass || exp->op == TOKmulass ||
                     exp->op == TOKdivass || exp->op == TOKmodass || exp->op == TOKpowass);
        int bitwise = (exp->op == TOKandass || exp->op == TOKorass || exp->op == TOKxorass);
        int shift = (exp->op == TOKshlass || exp->op == TOKshrass || exp->op == TOKushrass);

        if (bitwise && exp->type->toBasetype()->ty == Tbool)
            exp->e2 = exp->e2->implicitCastTo(sc, exp->type);
        else if (exp->checkNoBool())
            return setError();

        if ((exp->op == TOKaddass || exp->op == TOKminass) &&
            exp->e1->type->toBasetype()->ty == Tpointer &&
            exp->e2->type->toBasetype()->isintegral())
        {
            result = scaleFactor(exp, sc);
            return;
        }

        if (Expression *ex = typeCombine(exp, sc))
        {
            result = ex;
            return;
        }

        if (arith && exp->checkArithmeticBin())
            return setError();
        if ((bitwise || shift) && exp->checkIntegralBin())
            return setError();
        if (shift)
        {
            if (exp->e2->type->toBasetype()->ty != Tvector)
                exp->e2 = exp->e2->castTo(sc, Type::tshiftcnt);
        }

        if (!target.isVectorOpSupported(exp->type->toBasetype(), exp->op, exp->e2->type->toBasetype()))
        {
            result = exp->incompatibleTypes();
            return;
        }

        if (exp->e1->op == TOKerror || exp->e2->op == TOKerror)
            return setError();

        e = exp->checkOpAssignTypes(sc);
        if (e->op == TOKerror)
        {
            result = e;
            return;
        }

        assert(e->op == TOKassign || e == exp);
        result = ((BinExp *)e)->reorderSettingAAElem(sc);
    }

private:
    Expression *compileIt(CompileExp *exp)
    {
        OutBuffer buf;
        if (expressionsToString(buf, sc, exp->exps))
            return NULL;

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

        Expression *e = p.parseExpression();
        if (global.errors != errors)
            return NULL;

        if (p.token.value != TOKeof)
        {
            exp->error("incomplete mixin expression (%s)", str);
            return NULL;
        }
        return e;
    }

public:
    void visit(CompileExp *exp)
    {
        //printf("CompileExp::semantic('%s')\n", exp->toChars());
        Expression *e = compileIt(exp);
        if (!e)
            return setError();
        result = expressionSemantic(e, sc);
    }

    void visit(ImportExp *e)
    {
        StringExp *se = semanticString(sc, e->e1, "file name argument");
        if (!se)
            return setError();
        se = se->toUTF8(sc);

        const char *name = (char *)se->string;
        if (!global.params.fileImppath)
        {
            e->error("need -Jpath switch to import text file %s", name);
            return setError();
        }

        /* Be wary of CWE-22: Improper Limitation of a Pathname to a Restricted Directory
         * ('Path Traversal') attacks.
         * http://cwe.mitre.org/data/definitions/22.html
         */

        name = FileName::safeSearchPath(global.filePath, name);
        if (!name)
        {
            e->error("file %s cannot be found or not in a path specified with -J", se->toChars());
            return setError();
        }

        sc->_module->contentImportedFiles.push(name);
        if (global.params.verbose)
            message("file      %.*s\t(%s)", (int)se->len, (char *)se->string, name);
        if (global.params.moduleDeps != NULL)
        {
            OutBuffer *ob = global.params.moduleDeps;
            Module* imod = sc->instantiatingModule();

            if (!global.params.moduleDepsFile.length)
                ob->writestring("depsFile ");
            ob->writestring(imod->toPrettyChars());
            ob->writestring(" (");
            escapePath(ob, imod->srcfile->toChars());
            ob->writestring(") : ");
            if (global.params.moduleDepsFile.length)
                ob->writestring("string : ");
            ob->writestring((char *) se->string);
            ob->writestring(" (");
            escapePath(ob, name);
            ob->writestring(")");
            ob->writenl();
        }

        {
            File f(name);
            if (f.read())
            {
                e->error("cannot read file %s", f.toChars());
                return setError();
            }
            else
            {
                f.ref = 1;
                se = new StringExp(e->loc, f.buffer, f.len);
            }
        }
        result = expressionSemantic(se, sc);
    }

    void visit(AssertExp *exp)
    {
        if (Expression *ex = unaSemantic(exp, sc))
        {
            result = ex;
            return;
        }
        exp->e1 = resolveProperties(sc, exp->e1);
        // BUG: see if we can do compile time elimination of the Assert
        exp->e1 = exp->e1->optimize(WANTvalue);
        exp->e1 = exp->e1->toBoolean(sc);
        if (exp->msg)
        {
            exp->msg = expressionSemantic(exp->msg, sc);
            exp->msg = resolveProperties(sc, exp->msg);
            exp->msg = exp->msg->implicitCastTo(sc, Type::tchar->constOf()->arrayOf());
            exp->msg = exp->msg->optimize(WANTvalue);
        }

        if (exp->e1->op == TOKerror)
        {
            result = exp->e1;
            return;
        }
        if (exp->msg && exp->msg->op == TOKerror)
        {
            result = exp->msg;
            return;
        }

        bool f1 = checkNonAssignmentArrayOp(exp->e1);
        bool f2 = exp->msg && checkNonAssignmentArrayOp(exp->msg);
        if (f1 || f2)
            return setError();

        if (exp->e1->isBool(false))
        {
            /* This is an `assert(0)` which means halt program execution
             */
            FuncDeclaration *fd = sc->parent->isFuncDeclaration();
            if (fd)
                fd->hasReturnExp |= 4;
            sc->callSuper |= CSXhalt;
            if (sc->fieldinit)
            {
                for (size_t i = 0; i < sc->fieldinit_dim; i++)
                    sc->fieldinit[i] |= CSXhalt;
            }

            if (global.params.useAssert == CHECKENABLEoff)
            {
                Expression *e = new HaltExp(exp->loc);
                e = expressionSemantic(e, sc);
                result = e;
                return;
            }
            exp->type = Type::tnoreturn;
        }
        else
            exp->type = Type::tvoid;
        result = exp;
    }

    void visit(DotIdExp *exp)
    {
        Expression *e = semanticY(exp, sc, 1);
        if (e && isDotOpDispatch(e))
        {
            unsigned errors = global.startGagging();
            e = resolvePropertiesX(sc, e);
            if (global.endGagging(errors))
                e = NULL;   /* fall down to UFCS */
            else
            {
                result = e;
                return;
            }
        }
        if (!e)     // if failed to find the property
        {
            /* If ident is not a valid property, rewrite:
             *   e1.ident
             * as:
             *   .ident(e1)
             */
            e = resolveUFCSProperties(sc, exp);
        }
        result = e;
    }

    void visit(DotTemplateExp *e)
    {
        if (e->type)
        {
            result = e;
            return;
        }
        if (Expression *ex = unaSemantic(e, sc))
        {
            result = ex;
            return;
        }
        // 'void' like TemplateExp
        e->type = Type::tvoid;
        result = e;
    }

    void visit(DotVarExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        exp->var = exp->var->toAlias()->isDeclaration();

        exp->e1 = expressionSemantic(exp->e1, sc);

        if (TupleDeclaration *tup = exp->var->isTupleDeclaration())
        {
            /* Replace:
             *  e1.tuple(a, b, c)
             * with:
             *  tuple(e1.a, e1.b, e1.c)
             */
            Expression *e0 = NULL;
            Expression *ev = sc->func ? extractSideEffect(sc, "__tup", &e0, exp->e1) : exp->e1;

            Expressions *exps = new Expressions;
            exps->reserve(tup->objects->length);
            for (size_t i = 0; i < tup->objects->length; i++)
            {
                RootObject *o = (*tup->objects)[i];
                Expression *e;
                if (o->dyncast() == DYNCAST_EXPRESSION)
                {
                    e = (Expression *)o;
                    if (e->op == TOKdsymbol)
                    {
                        Dsymbol *s = ((DsymbolExp *)e)->s;
                        e = new DotVarExp(exp->loc, ev, s->isDeclaration());
                    }
                }
                else if (o->dyncast() == DYNCAST_DSYMBOL)
                {
                    e = new DsymbolExp(exp->loc, (Dsymbol *)o);
                }
                else if (o->dyncast() == DYNCAST_TYPE)
                {
                    e = new TypeExp(exp->loc, (Type *)o);
                }
                else
                {
                    exp->error("%s is not an expression", o->toChars());
                    return setError();
                }
                exps->push(e);
            }

            Expression *e = new TupleExp(exp->loc, e0, exps);
            e = expressionSemantic(e, sc);
            result = e;
            return;
        }

        exp->e1 = exp->e1->addDtorHook(sc);

        Type *t1 = exp->e1->type;

        if (FuncDeclaration *fd = exp->var->isFuncDeclaration())
        {
            // for functions, do checks after overload resolution
            if (!fd->functionSemantic())
                return setError();

            /* Bugzilla 13843: If fd obviously has no overloads, we should
             * normalize AST, and it will give a chance to wrap fd with FuncExp.
             */
            if (fd->isNested() || fd->isFuncLiteralDeclaration())
            {
                // (e1, fd)
                Expression *e = resolve(exp->loc, sc, fd, false);
                result = Expression::combine(exp->e1, e);
                return;
            }

            exp->type = fd->type;
            assert(exp->type);
        }
        else if (exp->var->isOverDeclaration())
        {
            exp->type = Type::tvoid; // ambiguous type?
        }
        else
        {
            exp->type = exp->var->type;
            if (!exp->type && global.errors)
            {
                // var is goofed up, just return 0
                return setError();
            }
            assert(exp->type);

            if (t1->ty == Tpointer)
                t1 = t1->nextOf();

            exp->type = exp->type->addMod(t1->mod);

            Dsymbol *vparent = exp->var->toParent();
            AggregateDeclaration *ad = vparent ? vparent->isAggregateDeclaration() : NULL;

            if (Expression *e1x = getRightThis(exp->loc, sc, ad, exp->e1, exp->var, 1))
                exp->e1 = e1x;
            else
            {
                /* Later checkRightThis will report correct error for invalid field variable access.
                */
                Expression *e = new VarExp(exp->loc, exp->var);
                e = expressionSemantic(e, sc);
                result = e;
                return;
            }
            checkAccess(exp->loc, sc, exp->e1, exp->var);

            VarDeclaration *v = exp->var->isVarDeclaration();
            if (v && (v->isDataseg() || (v->storage_class & STCmanifest)))
            {
                Expression *e = expandVar(WANTvalue, v);
                if (e)
                {
                    result = e;
                    return;
                }
            }

            if (v && v->isDataseg())     // fix bugzilla 8238
            {
                // (e1, v)
                checkAccess(exp->loc, sc, exp->e1, v);
                Expression *e = new VarExp(exp->loc, v);
                e = new CommaExp(exp->loc, exp->e1, e);
                e = expressionSemantic(e, sc);
                result = e;
                return;
            }
        }

        //printf("-DotVarExp::semantic('%s')\n", exp->toChars());
        result = exp;
    }

    void visit(DotTemplateInstanceExp *exp)
    {
        // Indicate we need to resolve by UFCS.
        Expression *e = semanticY(exp, sc, 1);
        if (!e)
            e = resolveUFCSProperties(sc, exp);
        result = e;
    }

    void visit(DelegateExp *e)
    {
        if (e->type)
        {
            result = e;
            return;
        }

        e->e1 = expressionSemantic(e->e1, sc);
        e->type = new TypeDelegate(e->func->type);
        e->type = typeSemantic(e->type, e->loc, sc);
        FuncDeclaration *f = e->func->toAliasFunc();
        AggregateDeclaration *ad = f->toParent()->isAggregateDeclaration();
        if (f->needThis())
            e->e1 = getRightThis(e->loc, sc, ad, e->e1, f);
        if (f->type->ty == Tfunction)
        {
            TypeFunction *tf = (TypeFunction *)f->type;
            if (!MODmethodConv(e->e1->type->mod, f->type->mod))
            {
                OutBuffer thisBuf, funcBuf;
                MODMatchToBuffer(&thisBuf, e->e1->type->mod, tf->mod);
                MODMatchToBuffer(&funcBuf, tf->mod, e->e1->type->mod);
                e->error("%smethod %s is not callable using a %s%s",
                    funcBuf.peekChars(), f->toPrettyChars(), thisBuf.peekChars(), e->e1->toChars());
                return setError();
            }
        }
        if (ad && ad->isClassDeclaration() && ad->type != e->e1->type)
        {
            // A downcast is required for interfaces, see Bugzilla 3706
            e->e1 = new CastExp(e->loc, e->e1, ad->type);
            e->e1 = expressionSemantic(e->e1, sc);
        }
        result = e;
    }

    void visit(DotTypeExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *e = unaSemantic(exp, sc))
        {
            result = e;
            return;
        }

        exp->type = exp->sym->getType()->addMod(exp->e1->type->mod);
        result = exp;
    }

    void visit(CallExp *exp)
    {
        if (exp->type)
        {
            result = exp;            // semantic() already run
            return;
        }

        Type *t1;
        Objects *tiargs = NULL;     // initial list of template arguments
        Expression *ethis = NULL;
        Type *tthis = NULL;
        Expression *e1org = exp->e1;

        if (exp->e1->op == TOKcomma)
        {
            /* Rewrite (a,b)(args) as (a,(b(args)))
            */
            CommaExp *ce = (CommaExp *)exp->e1;
            exp->e1 = ce->e2;
            ce->e2 = exp;
            result = expressionSemantic(ce, sc);
            return;
        }

        if (exp->e1->op == TOKdelegate)
        {
            DelegateExp *de = (DelegateExp *)exp->e1;
            exp->e1 = new DotVarExp(de->loc, de->e1, de->func, de->hasOverloads);
            result = expressionSemantic(exp, sc);
            return;
        }

        if (exp->e1->op == TOKfunction)
        {
            if (arrayExpressionSemantic(exp->arguments, sc) ||
                preFunctionParameters(sc, exp->arguments))
            {
                return setError();
            }

            // Run e1 semantic even if arguments have any errors
            FuncExp *fe = (FuncExp *)exp->e1;
            exp->e1 = callExpSemantic(fe, sc, exp->arguments);
            if (exp->e1->op == TOKerror)
            {
                result = exp->e1;
                return;
            }
        }

        if (Expression *ex = resolveUFCS(sc, exp))
        {
            result = ex;
            return;
        }

        /* This recognizes:
         *  foo!(tiargs)(funcargs)
         */
        if (exp->e1->op == TOKscope)
        {
            ScopeExp *se = (ScopeExp *)exp->e1;
            TemplateInstance *ti = se->sds->isTemplateInstance();
            if (ti)
            {
                /* Attempt to instantiate ti. If that works, go with it.
                 * If not, go with partial explicit specialization.
                 */
                WithScopeSymbol *withsym;
                if (!ti->findTempDecl(sc, &withsym) ||
                    !ti->semanticTiargs(sc))
                {
                    return setError();
                }
                if (withsym && withsym->withstate->wthis)
                {
                    exp->e1 = new VarExp(exp->e1->loc, withsym->withstate->wthis);
                    exp->e1 = new DotTemplateInstanceExp(exp->e1->loc, exp->e1, ti);
                    goto Ldotti;
                }
                if (ti->needsTypeInference(sc, 1))
                {
                    /* Go with partial explicit specialization
                    */
                    tiargs = ti->tiargs;
                    assert(ti->tempdecl);
                    if (TemplateDeclaration *td = ti->tempdecl->isTemplateDeclaration())
                        exp->e1 = new TemplateExp(exp->loc, td);
                    else if (OverDeclaration *od = ti->tempdecl->isOverDeclaration())
                        exp->e1 = new VarExp(exp->loc, od);
                    else
                        exp->e1 = new OverExp(exp->loc, ti->tempdecl->isOverloadSet());
                }
                else
                {
                    Expression *e1x = expressionSemantic(exp->e1, sc);
                    if (e1x->op == TOKerror)
                    {
                        result = e1x;
                        return;
                    }
                    exp->e1 = e1x;
                }
            }
        }

        /* This recognizes:
         *  expr.foo!(tiargs)(funcargs)
         */
    Ldotti:
        if (exp->e1->op == TOKdotti && !exp->e1->type)
        {
            DotTemplateInstanceExp *se = (DotTemplateInstanceExp *)exp->e1;
            TemplateInstance *ti = se->ti;
            {
                /* Attempt to instantiate ti. If that works, go with it.
                 * If not, go with partial explicit specialization.
                 */
                if (!se->findTempDecl(sc) ||
                    !ti->semanticTiargs(sc))
                {
                    return setError();
                }
                if (ti->needsTypeInference(sc, 1))
                {
                    /* Go with partial explicit specialization
                    */
                    tiargs = ti->tiargs;
                    assert(ti->tempdecl);
                    if (TemplateDeclaration *td = ti->tempdecl->isTemplateDeclaration())
                        exp->e1 = new DotTemplateExp(exp->loc, se->e1, td);
                    else if (OverDeclaration *od = ti->tempdecl->isOverDeclaration())
                    {
                        exp->e1 = new DotVarExp(exp->loc, se->e1, od, true);
                    }
                    else
                        exp->e1 = new DotExp(exp->loc, se->e1, new OverExp(exp->loc, ti->tempdecl->isOverloadSet()));
                }
                else
                {
                    Expression *e1x = expressionSemantic(exp->e1, sc);
                    if (e1x->op == TOKerror)
                    {
                        result =e1x;
                        return;
                    }
                    exp->e1 = e1x;
                }
            }
        }

    Lagain:
        //printf("Lagain: %s\n", exp->toChars());
        exp->f = NULL;
        if (exp->e1->op == TOKthis || exp->e1->op == TOKsuper)
        {
            // semantic() run later for these
        }
        else
        {
            if (exp->e1->op == TOKdotid)
            {
                DotIdExp *die = (DotIdExp *)exp->e1;
                exp->e1 = expressionSemantic(die, sc);
                /* Look for e1 having been rewritten to expr.opDispatch!(string)
                 * We handle such earlier, so go back.
                 * Note that in the rewrite, we carefully did not run semantic() on e1
                 */
                if (exp->e1->op == TOKdotti && !exp->e1->type)
                {
                    goto Ldotti;
                }
            }
            else
            {
                static int nest;
                if (++nest > global.recursionLimit)
                {
                    exp->error("recursive evaluation of %s", exp->toChars());
                    --nest;
                    return setError();
                }
                Expression *ex = unaSemantic(exp, sc);
                --nest;
                if (ex)
                {
                    result = ex;
                    return;
                }
            }

            /* Look for e1 being a lazy parameter
            */
            if (exp->e1->op == TOKvar)
            {
                VarExp *ve = (VarExp *)exp->e1;
                if (ve->var->storage_class & STClazy)
                {
                    // lazy paramaters can be called without violating purity and safety
                    Type *tw = ve->var->type;
                    Type *tc = ve->var->type->substWildTo(MODconst);
                    TypeFunction *tf = new TypeFunction(ParameterList(), tc, LINKd, STCsafe | STCpure);
                    (tf = (TypeFunction *)typeSemantic(tf, exp->loc, sc))->next = tw;    // hack for bug7757
                    TypeDelegate *t = new TypeDelegate(tf);
                    ve->type = typeSemantic(t, exp->loc, sc);
                }
                VarDeclaration *v = ve->var->isVarDeclaration();
                if (v && ve->checkPurity(sc, v))
                    return setError();
            }

            if (exp->e1->op == TOKsymoff && ((SymOffExp *)exp->e1)->hasOverloads)
            {
                SymOffExp *se = (SymOffExp *)exp->e1;
                exp->e1 = new VarExp(se->loc, se->var, true);
                exp->e1 = expressionSemantic(exp->e1, sc);
            }
            else if (exp->e1->op == TOKdot)
            {
                DotExp *de = (DotExp *) exp->e1;

                if (de->e2->op == TOKoverloadset)
                {
                    ethis = de->e1;
                    tthis = de->e1->type;
                    exp->e1 = de->e2;
                }
            }
            else if (exp->e1->op == TOKstar && exp->e1->type->ty == Tfunction)
            {
                // Rewrite (*fp)(arguments) to fp(arguments)
                exp->e1 = ((PtrExp *)exp->e1)->e1;
            }
        }

        t1 = exp->e1->type ? exp->e1->type->toBasetype() : NULL;

        if (exp->e1->op == TOKerror)
        {
            result = exp->e1;
            return;
        }
        if (arrayExpressionSemantic(exp->arguments, sc) ||
            preFunctionParameters(sc, exp->arguments))
        {
            return setError();
        }

        // Check for call operator overload
        if (t1)
        {
            if (t1->ty == Tstruct)
            {
                StructDeclaration *sd = ((TypeStruct *)t1)->sym;
                sd->size(exp->loc);      // Resolve forward references to construct object
                if (sd->sizeok != SIZEOKdone)
                    return setError();
                if (!sd->ctor)
                    sd->ctor = sd->searchCtor();

                // First look for constructor
                if (exp->e1->op == TOKtype && sd->ctor)
                {
                    if (!sd->noDefaultCtor && !(exp->arguments && exp->arguments->length))
                        goto Lx;

                    StructLiteralExp *sle = new StructLiteralExp(exp->loc, sd, NULL, exp->e1->type);
                    if (!sd->fill(exp->loc, sle->elements, true))
                        return setError();
                    if (checkFrameAccess(exp->loc, sc, sd, sle->elements->length))
                        return setError();
                    // Bugzilla 14556: Set concrete type to avoid further redundant semantic().
                    sle->type = exp->e1->type;

                    /* Constructor takes a mutable object, so don't use
                     * the immutable initializer symbol.
                     */
                    sle->useStaticInit = false;

                    Expression *e = sle;
                    if (CtorDeclaration *cf = sd->ctor->isCtorDeclaration())
                    {
                        e = new DotVarExp(exp->loc, e, cf, true);
                    }
                    else if (TemplateDeclaration *td = sd->ctor->isTemplateDeclaration())
                    {
                        e = new DotTemplateExp(exp->loc, e, td);
                    }
                    else if (OverloadSet *os = sd->ctor->isOverloadSet())
                    {
                        e = new DotExp(exp->loc, e, new OverExp(exp->loc, os));
                    }
                    else
                        assert(0);
                    e = new CallExp(exp->loc, e, exp->arguments);
                    result = expressionSemantic(e, sc);
                    return;
                }
                // No constructor, look for overload of opCall
                if (search_function(sd, Id::call))
                    goto L1;        // overload of opCall, therefore it's a call

                if (exp->e1->op != TOKtype)
                {
                    if (sd->aliasthis && exp->e1->type != exp->att1)
                    {
                        if (!exp->att1 && exp->e1->type->checkAliasThisRec())
                            exp->att1 = exp->e1->type;
                        exp->e1 = resolveAliasThis(sc, exp->e1);
                        goto Lagain;
                    }
                    exp->error("%s %s does not overload ()", sd->kind(), sd->toChars());
                    return setError();
                }

                /* It's a struct literal
                */
            Lx:
                Expression *e = new StructLiteralExp(exp->loc, sd, exp->arguments, exp->e1->type);
                result = expressionSemantic(e, sc);
                return;
            }
            else if (t1->ty == Tclass)
            {
            L1:
                // Rewrite as e1.call(arguments)
                Expression *e = new DotIdExp(exp->loc, exp->e1, Id::call);
                e = new CallExp(exp->loc, e, exp->arguments);
                result = expressionSemantic(e, sc);
                return;
            }
            else if (exp->e1->op == TOKtype && t1->isscalar())
            {
                Expression *e;

                // Make sure to use the the enum type itself rather than its
                // base type (see bugzilla 16346)
                if (exp->e1->type->ty == Tenum)
                {
                    t1 = exp->e1->type;
                }

                if (!exp->arguments || exp->arguments->length == 0)
                {
                    e = t1->defaultInitLiteral(exp->loc);
                }
                else if (exp->arguments->length == 1)
                {
                    e = (*exp->arguments)[0];
                    e = e->implicitCastTo(sc, t1);
                    e = new CastExp(exp->loc, e, t1);
                }
                else
                {
                    exp->error("more than one argument for construction of %s", t1->toChars());
                    e = new ErrorExp();
                }
                result = expressionSemantic(e, sc);
                return;
            }
        }

        if ((exp->e1->op == TOKdotvar && t1->ty == Tfunction) ||
            exp->e1->op == TOKdottd)
        {
            UnaExp *ue = (UnaExp *)(exp->e1);

            Expression *ue1 = ue->e1;
            Expression *ue1old = ue1;   // need for 'right this' check
            VarDeclaration *v;
            if (ue1->op == TOKvar &&
                (v = ((VarExp *)ue1)->var->isVarDeclaration()) != NULL &&
                v->needThis())
            {
                ue->e1 = new TypeExp(ue1->loc, ue1->type);
                ue1 = NULL;
            }

            DotVarExp *dve;
            DotTemplateExp *dte;
            Dsymbol *s;
            if (exp->e1->op == TOKdotvar)
            {
                dve = (DotVarExp *)(exp->e1);
                dte = NULL;
                s = dve->var;
                tiargs = NULL;
            }
            else
            {
                dve = NULL;
                dte = (DotTemplateExp *)(exp->e1);
                s = dte->td;
            }

            // Do overload resolution
            exp->f = resolveFuncCall(exp->loc, sc, s, tiargs, ue1 ? ue1->type : NULL, exp->arguments);
            if (!exp->f || exp->f->errors || exp->f->type->ty == Terror)
                return setError();
            if (exp->f->interfaceVirtual)
            {
                /* Cast 'this' to the type of the interface, and replace f with the interface's equivalent
                */
                BaseClass *b = exp->f->interfaceVirtual;
                ClassDeclaration *ad2 = b->sym;
                ue->e1 = ue->e1->castTo(sc, ad2->type->addMod(ue->e1->type->mod));
                ue->e1 = expressionSemantic(ue->e1, sc);
                ue1 = ue->e1;
                int vi = exp->f->findVtblIndex((Dsymbols*)&ad2->vtbl, (int)ad2->vtbl.length);
                assert(vi >= 0);
                exp->f = ad2->vtbl[vi]->isFuncDeclaration();
                assert(exp->f);
            }
            if (exp->f->needThis())
            {
                AggregateDeclaration *ad = exp->f->toParent2()->isAggregateDeclaration();
                ue->e1 = getRightThis(exp->loc, sc, ad, ue->e1, exp->f);
                if (ue->e1->op == TOKerror)
                {
                    result = ue->e1;
                    return;
                }
                ethis = ue->e1;
                tthis = ue->e1->type;
                if (!(exp->f->type->ty == Tfunction && ((TypeFunction *)exp->f->type)->isscope))
                {
                    if (global.params.vsafe && checkParamArgumentEscape(sc, exp->f, Id::This, ethis, false))
                        return setError();
                }
            }

            /* Cannot call public functions from inside invariant
             * (because then the invariant would have infinite recursion)
             */
            if (sc->func && sc->func->isInvariantDeclaration() &&
                ue->e1->op == TOKthis &&
                exp->f->addPostInvariant()
               )
            {
                exp->error("cannot call public/export function %s from invariant", exp->f->toChars());
                return setError();
            }

            exp->checkDeprecated(sc, exp->f);
            exp->checkDisabled(sc, exp->f);
            exp->checkPurity(sc, exp->f);
            exp->checkSafety(sc, exp->f);
            exp->checkNogc(sc, exp->f);
            checkAccess(exp->loc, sc, ue->e1, exp->f);
            if (!exp->f->needThis())
            {
                exp->e1 = Expression::combine(ue->e1, new VarExp(exp->loc, exp->f, false));
            }
            else
            {
                if (ue1old->checkRightThis(sc))
                    return setError();
                if (exp->e1->op == TOKdotvar)
                {
                    dve->var = exp->f;
                    exp->e1->type = exp->f->type;
                }
                else
                {
                    exp->e1 = new DotVarExp(exp->loc, dte->e1, exp->f, false);
                    exp->e1 = expressionSemantic(exp->e1, sc);
                    if (exp->e1->op == TOKerror)
                        return setError();
                    ue = (UnaExp *)exp->e1;
                }

                // See if we need to adjust the 'this' pointer
                AggregateDeclaration *ad = exp->f->isThis();
                ClassDeclaration *cd = ue->e1->type->isClassHandle();
                if (ad && cd && ad->isClassDeclaration())
                {
                    if (ue->e1->op == TOKdottype)
                    {
                        ue->e1 = ((DotTypeExp *)ue->e1)->e1;
                        exp->directcall = true;
                    }
                    else if (ue->e1->op == TOKsuper)
                        exp->directcall = true;
                    else if ((cd->storage_class & STCfinal) != 0)   // Bugzilla 14211
                        exp->directcall = true;

                    if (ad != cd)
                    {
                        ue->e1 = ue->e1->castTo(sc, ad->type->addMod(ue->e1->type->mod));
                        ue->e1 = expressionSemantic(ue->e1, sc);
                    }
                }
            }
            // If we've got a pointer to a function then deference it
            // https://issues.dlang.org/show_bug.cgi?id=16483
            if (exp->e1->type->ty == Tpointer && exp->e1->type->nextOf()->ty == Tfunction)
            {
                Expression *e = new PtrExp(exp->loc, exp->e1);
                e->type = exp->e1->type->nextOf();
                exp->e1 = e;
            }
            t1 = exp->e1->type;
        }
        else if (exp->e1->op == TOKsuper)
        {
            // Base class constructor call
            AggregateDeclaration *ad = sc->func ? sc->func->isThis() : NULL;
            ClassDeclaration *cd = ad ? ad->isClassDeclaration() : NULL;
            if (!cd || !cd->baseClass || !sc->func->isCtorDeclaration())
            {
                exp->error("super class constructor call must be in a constructor");
                return setError();
            }
            if (!cd->baseClass->ctor)
            {
                exp->error("no super class constructor for %s", cd->baseClass->toChars());
                return setError();
            }

            if (!sc->intypeof && !(sc->callSuper & CSXhalt))
            {
                if (sc->noctor || sc->callSuper & CSXlabel)
                    exp->error("constructor calls not allowed in loops or after labels");
                if (sc->callSuper & (CSXsuper_ctor | CSXthis_ctor))
                    exp->error("multiple constructor calls");
                if ((sc->callSuper & CSXreturn) && !(sc->callSuper & CSXany_ctor))
                    exp->error("an earlier return statement skips constructor");
                sc->callSuper |= CSXany_ctor | CSXsuper_ctor;
            }

            tthis = cd->type->addMod(sc->func->type->mod);
            if (OverloadSet *os = cd->baseClass->ctor->isOverloadSet())
                exp->f = resolveOverloadSet(exp->loc, sc, os, NULL, tthis, exp->arguments);
            else
                exp->f = resolveFuncCall(exp->loc, sc, cd->baseClass->ctor, NULL, tthis, exp->arguments, 0);
            if (!exp->f || exp->f->errors)
                return setError();
            exp->checkDeprecated(sc, exp->f);
            exp->checkDisabled(sc, exp->f);
            exp->checkPurity(sc, exp->f);
            exp->checkSafety(sc, exp->f);
            exp->checkNogc(sc, exp->f);
            checkAccess(exp->loc, sc, NULL, exp->f);

            exp->e1 = new DotVarExp(exp->e1->loc, exp->e1, exp->f, false);
            exp->e1 = expressionSemantic(exp->e1, sc);
            t1 = exp->e1->type;
        }
        else if (exp->e1->op == TOKthis)
        {
            // same class constructor call
            AggregateDeclaration *ad = sc->func ? sc->func->isThis() : NULL;
            if (!ad || !sc->func->isCtorDeclaration())
            {
                exp->error("constructor call must be in a constructor");
                return setError();
            }

            // https://issues.dlang.org/show_bug.cgi?id=18719
            // If `exp` is a call expression to another constructor
            // then it means that all struct/class fields will be
            // initialized after this call.
            for (size_t i = 0; i < sc->fieldinit_dim; i++)
                sc->fieldinit[i] |= CSXthis_ctor;

            if (!sc->intypeof && !(sc->callSuper & CSXhalt))
            {
                if (sc->noctor || sc->callSuper & CSXlabel)
                    exp->error("constructor calls not allowed in loops or after labels");
                if (sc->callSuper & (CSXsuper_ctor | CSXthis_ctor))
                    exp->error("multiple constructor calls");
                if ((sc->callSuper & CSXreturn) && !(sc->callSuper & CSXany_ctor))
                    exp->error("an earlier return statement skips constructor");
                sc->callSuper |= CSXany_ctor | CSXthis_ctor;
            }

            tthis = ad->type->addMod(sc->func->type->mod);
            if (OverloadSet *os = ad->ctor->isOverloadSet())
                exp->f = resolveOverloadSet(exp->loc, sc, os, NULL, tthis, exp->arguments);
            else
                exp->f = resolveFuncCall(exp->loc, sc, ad->ctor, NULL, tthis, exp->arguments, 0);
            if (!exp->f || exp->f->errors)
                return setError();
            exp->checkDeprecated(sc, exp->f);
            exp->checkDisabled(sc, exp->f);
            exp->checkPurity(sc, exp->f);
            exp->checkSafety(sc, exp->f);
            exp->checkNogc(sc, exp->f);
            //checkAccess(exp->loc, sc, NULL, exp->f);    // necessary?

            exp->e1 = new DotVarExp(exp->e1->loc, exp->e1, exp->f, false);
            exp->e1 = expressionSemantic(exp->e1, sc);
            t1 = exp->e1->type;

            // BUG: this should really be done by checking the static
            // call graph
            if (exp->f == sc->func)
            {
                exp->error("cyclic constructor call");
                return setError();
            }
        }
        else if (exp->e1->op == TOKoverloadset)
        {
            OverloadSet *os = ((OverExp *)exp->e1)->vars;
            exp->f = resolveOverloadSet(exp->loc, sc, os, tiargs, tthis, exp->arguments);
            if (!exp->f)
                return setError();
            if (ethis)
                exp->e1 = new DotVarExp(exp->loc, ethis, exp->f, false);
            else
                exp->e1 = new VarExp(exp->loc, exp->f, false);
            goto Lagain;
        }
        else if (!t1)
        {
            exp->error("function expected before (), not `%s`", exp->e1->toChars());
            return setError();
        }
        else if (t1->ty == Terror)
        {
            return setError();
        }
        else if (t1->ty != Tfunction)
        {
            TypeFunction *tf;
            const char *p;
            Dsymbol *s;
            exp->f = NULL;
            if (exp->e1->op == TOKfunction)
            {
                // function literal that direct called is always inferred.
                assert(((FuncExp *)exp->e1)->fd);
                exp->f = ((FuncExp *)exp->e1)->fd;
                tf = (TypeFunction *)exp->f->type;
                p = "function literal";
            }
            else if (t1->ty == Tdelegate)
            {
                TypeDelegate *td = (TypeDelegate *)t1;
                assert(td->next->ty == Tfunction);
                tf = (TypeFunction *)(td->next);
                p = "delegate";
            }
            else if (t1->ty == Tpointer && ((TypePointer *)t1)->next->ty == Tfunction)
            {
                tf = (TypeFunction *)(((TypePointer *)t1)->next);
                p = "function pointer";
            }
            else if (exp->e1->op == TOKdotvar &&
                     ((DotVarExp *)exp->e1)->var->isOverDeclaration())
            {
                DotVarExp *dve = (DotVarExp *)exp->e1;
                exp->f = resolveFuncCall(exp->loc, sc, dve->var, tiargs, dve->e1->type, exp->arguments, 2);
                if (!exp->f)
                    return setError();
                if (exp->f->needThis())
                {
                    dve->var = exp->f;
                    dve->type = exp->f->type;
                    dve->hasOverloads = false;
                    goto Lagain;
                }
                exp->e1 = new VarExp(dve->loc, exp->f, false);
                Expression *e = new CommaExp(exp->loc, dve->e1, exp);
                result = expressionSemantic(e, sc);
                return;
            }
            else if (exp->e1->op == TOKvar &&
                     ((VarExp *)exp->e1)->var->isOverDeclaration())
            {
                s = ((VarExp *)exp->e1)->var;
                goto L2;
            }
            else if (exp->e1->op == TOKtemplate)
            {
                s = ((TemplateExp *)exp->e1)->td;
            L2:
                exp->f = resolveFuncCall(exp->loc, sc, s, tiargs, NULL, exp->arguments);
                if (!exp->f || exp->f->errors)
                    return setError();
                if (exp->f->needThis())
                {
                    if (hasThis(sc))
                    {
                        // Supply an implicit 'this', as in
                        //    this.ident
                        Expression *ex = new ThisExp(exp->loc);
                        ex = expressionSemantic(ex, sc);
                        exp->e1 = new DotVarExp(exp->loc, ex, exp->f, false);
                        goto Lagain;
                    }
                    else if (isNeedThisScope(sc, exp->f))
                    {
                        exp->error("need `this` for `%s` of type `%s`", exp->f->toChars(), exp->f->type->toChars());
                        return setError();
                    }
                }
                exp->e1 = new VarExp(exp->e1->loc, exp->f, false);
                goto Lagain;
            }
            else
            {
                exp->error("function expected before (), not %s of type %s", exp->e1->toChars(), exp->e1->type->toChars());
                return setError();
            }

            const char *failMessage = NULL;
            if (!tf->callMatch(NULL, exp->arguments, 0, &failMessage))
            {
                OutBuffer buf;

                buf.writeByte('(');
                argExpTypesToCBuffer(&buf, exp->arguments);
                buf.writeByte(')');
                if (tthis)
                    tthis->modToBuffer(&buf);

                //printf("tf = %s, args = %s\n", tf->deco, (*exp->arguments)[0]->type->deco);
                ::error(exp->loc, "%s `%s%s` is not callable using argument types `%s`",
                        p, exp->e1->toChars(), parametersTypeToChars(tf->parameterList),
                        buf.peekChars());
                if (failMessage)
                    errorSupplemental(exp->loc, failMessage);
                return setError();
            }

            // Purity and safety check should run after testing arguments matching
            if (exp->f)
            {
                exp->checkPurity(sc, exp->f);
                exp->checkSafety(sc, exp->f);
                exp->checkNogc(sc, exp->f);
                if (exp->f->checkNestedReference(sc, exp->loc))
                    return setError();
            }
            else if (sc->func && sc->intypeof != 1 && !(sc->flags & SCOPEctfe))
            {
                bool err = false;
                if (!tf->purity && !(sc->flags & SCOPEdebug) && sc->func->setImpure())
                {
                    exp->error("pure %s `%s` cannot call impure %s `%s`",
                          sc->func->kind(), sc->func->toPrettyChars(), p, exp->e1->toChars());
                    err = true;
                }
                if (!tf->isnogc && sc->func->setGC())
                {
                    exp->error("@nogc %s `%s` cannot call non-@nogc %s `%s`",
                          sc->func->kind(), sc->func->toPrettyChars(), p, exp->e1->toChars());
                    err = true;
                }
                if (tf->trust <= TRUSTsystem && sc->func->setUnsafe())
                {
                    exp->error("@safe %s `%s` cannot call @system %s `%s`",
                          sc->func->kind(), sc->func->toPrettyChars(), p, exp->e1->toChars());
                    err = true;
                }
                if (err)
                    return setError();
            }

            if (t1->ty == Tpointer)
            {
                Expression *e = new PtrExp(exp->loc, exp->e1);
                e->type = tf;
                exp->e1 = e;
            }
            t1 = tf;
        }
        else if (exp->e1->op == TOKvar)
        {
            // Do overload resolution
            VarExp *ve = (VarExp *)exp->e1;

            exp->f = ve->var->isFuncDeclaration();
            assert(exp->f);
            tiargs = NULL;

            if (exp->f->overnext)
                exp->f = resolveFuncCall(exp->loc, sc, exp->f, tiargs, NULL, exp->arguments, 2);
            else
            {
                exp->f = exp->f->toAliasFunc();
                TypeFunction *tf = (TypeFunction *)exp->f->type;
                const char *failMessage = NULL;
                if (!tf->callMatch(NULL, exp->arguments, 0, &failMessage))
                {
                    OutBuffer buf;

                    buf.writeByte('(');
                    argExpTypesToCBuffer(&buf, exp->arguments);
                    buf.writeByte(')');

                    //printf("tf = %s, args = %s\n", tf->deco, (*exp->arguments)[0]->type->deco);
                    ::error(exp->loc, "%s `%s%s` is not callable using argument types `%s`",
                            exp->f->kind(), exp->e1->toChars(), parametersTypeToChars(tf->parameterList),
                            buf.peekChars());
                    if (failMessage)
                        errorSupplemental(exp->loc, failMessage);
                    exp->f = NULL;
                }
            }
            if (!exp->f || exp->f->errors)
                return setError();

            if (exp->f->needThis())
            {
                // Change the ancestor lambdas to delegate before hasThis(sc) call.
                if (exp->f->checkNestedReference(sc, exp->loc))
                    return setError();

                if (hasThis(sc))
                {
                    // Supply an implicit 'this', as in
                    //    this.ident

                    Expression *ex = new ThisExp(exp->loc);
                    ex = expressionSemantic(ex, sc);
                    exp->e1 = new DotVarExp(exp->loc, ex, ve->var);
                    // Note: we cannot use f directly, because further overload resolution
                    // through the supplied 'this' may cause different result.
                    goto Lagain;
                }
                else if (isNeedThisScope(sc, exp->f))
                {
                    exp->error("need `this` for `%s` of type `%s`", exp->f->toChars(), exp->f->type->toChars());
                    return setError();
                }
            }

            exp->checkDeprecated(sc, exp->f);
            exp->checkDisabled(sc, exp->f);
            exp->checkPurity(sc, exp->f);
            exp->checkSafety(sc, exp->f);
            exp->checkNogc(sc, exp->f);
            checkAccess(exp->loc, sc, NULL, exp->f);
            if (exp->f->checkNestedReference(sc, exp->loc))
                return setError();

            ethis = NULL;
            tthis = NULL;

            if (ve->hasOverloads)
            {
                exp->e1 = new VarExp(ve->loc, exp->f, false);
                exp->e1->type = exp->f->type;
            }
            t1 = exp->f->type;
        }
        assert(t1->ty == Tfunction);

        Expression *argprefix;
        if (!exp->arguments)
            exp->arguments = new Expressions();
        if (functionParameters(exp->loc, sc, (TypeFunction *)(t1), tthis, exp->arguments, exp->f, &exp->type, &argprefix))
            return setError();

        if (!exp->type)
        {
            exp->e1 = e1org;     // Bugzilla 10922, avoid recursive expression printing
            exp->error("forward reference to inferred return type of function call `%s`", exp->toChars());
            return setError();
        }

        if (exp->f && exp->f->tintro)
        {
            Type *t = exp->type;
            int offset = 0;
            TypeFunction *tf = (TypeFunction *)exp->f->tintro;

            if (tf->next->isBaseOf(t, &offset) && offset)
            {
                exp->type = tf->next;
                result = Expression::combine(argprefix, exp->castTo(sc, t));
                return;
            }
        }

        // Handle the case of a direct lambda call
        if (exp->f && exp->f->isFuncLiteralDeclaration() &&
            sc->func && !sc->intypeof)
        {
            exp->f->tookAddressOf = 0;
        }

        result = Expression::combine(argprefix, exp);
    }

    void visit(AddrExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = unaSemantic(exp, sc))
        {
            result = ex;
            return;
        }
        int wasCond = exp->e1->op == TOKquestion;
        if (exp->e1->op == TOKdotti)
        {
            DotTemplateInstanceExp* dti = (DotTemplateInstanceExp *)exp->e1;
            TemplateInstance *ti = dti->ti;
            {
                //assert(ti->needsTypeInference(sc));
                dsymbolSemantic(ti, sc);
                if (!ti->inst || ti->errors)    // if template failed to expand
                    return setError();
                Dsymbol *s = ti->toAlias();
                FuncDeclaration *f = s->isFuncDeclaration();
                if (f)
                {
                    exp->e1 = new DotVarExp(exp->e1->loc, dti->e1, f);
                    exp->e1 = expressionSemantic(exp->e1, sc);
                }
            }
        }
        else if (exp->e1->op == TOKscope)
        {
            TemplateInstance *ti = ((ScopeExp *)exp->e1)->sds->isTemplateInstance();
            if (ti)
            {
                //assert(ti->needsTypeInference(sc));
                dsymbolSemantic(ti, sc);
                if (!ti->inst || ti->errors)    // if template failed to expand
                    return setError();
                Dsymbol *s = ti->toAlias();
                FuncDeclaration *f = s->isFuncDeclaration();
                if (f)
                {
                    exp->e1 = new VarExp(exp->e1->loc, f);
                    exp->e1 = expressionSemantic(exp->e1, sc);
                }
            }
        }
        exp->e1 = exp->e1->toLvalue(sc, NULL);
        if (exp->e1->op == TOKerror)
        {
            result = exp->e1;
            return;
        }
        if (checkNonAssignmentArrayOp(exp->e1))
            return setError();

        if (!exp->e1->type)
        {
            exp->error("cannot take address of %s", exp->e1->toChars());
            return setError();
        }

        bool hasOverloads = false;
        if (FuncDeclaration *f = isFuncAddress(exp, &hasOverloads))
        {
            if (!hasOverloads && f->checkForwardRef(exp->loc))
                return setError();
        }
        else if (!exp->e1->type->deco)
        {
            if (exp->e1->op == TOKvar)
            {
                VarExp *ve = (VarExp *)exp->e1;
                Declaration *d = ve->var;
                exp->error("forward reference to %s %s", d->kind(), d->toChars());
            }
            else
                exp->error("forward reference to %s", exp->e1->toChars());
            return setError();
        }

        exp->type = exp->e1->type->pointerTo();

        // See if this should really be a delegate
        if (exp->e1->op == TOKdotvar)
        {
            DotVarExp *dve = (DotVarExp *)exp->e1;
            FuncDeclaration *f = dve->var->isFuncDeclaration();
            if (f)
            {
                f = f->toAliasFunc();   // FIXME, should see overloads - Bugzilla 1983
                if (!dve->hasOverloads)
                    f->tookAddressOf++;

                Expression *e;
                if (f->needThis())
                    e = new DelegateExp(exp->loc, dve->e1, f, dve->hasOverloads);
                else // It is a function pointer. Convert &v.f() --> (v, &V.f())
                    e = new CommaExp(exp->loc, dve->e1, new AddrExp(exp->loc, new VarExp(exp->loc, f, dve->hasOverloads)));
                e = expressionSemantic(e, sc);
                result = e;
                return;
            }

            // Look for misaligned pointer in @safe mode
            if (checkUnsafeAccess(sc, dve, !exp->type->isMutable(), true))
                return setError();

            if (dve->e1->op == TOKvar && global.params.vsafe)
            {
                VarExp *ve = (VarExp *)dve->e1;
                VarDeclaration *v = ve->var->isVarDeclaration();
                if (v)
                {
                    if (!checkAddressVar(sc, exp, v))
                        return setError();
                }
            }
            else if ((dve->e1->op == TOKthis || dve->e1->op == TOKsuper) && global.params.vsafe)
            {
                ThisExp *ve = (ThisExp *)dve->e1;
                VarDeclaration *v = ve->var->isVarDeclaration();
                if (v && v->storage_class & STCref)
                {
                    if (!checkAddressVar(sc, exp, v))
                        return setError();
                }
            }
        }
        else if (exp->e1->op == TOKvar)
        {
            VarExp *ve = (VarExp *)exp->e1;

            VarDeclaration *v = ve->var->isVarDeclaration();
            if (v)
            {
                if (!checkAddressVar(sc, exp, v))
                    return setError();

                ve->checkPurity(sc, v);
            }

            FuncDeclaration *f = ve->var->isFuncDeclaration();
            if (f)
            {
                /* Because nested functions cannot be overloaded,
                 * mark here that we took its address because castTo()
                 * may not be called with an exact match.
                 */
                if (!ve->hasOverloads || f->isNested())
                    f->tookAddressOf++;
                if (f->isNested())
                {
                    if (f->isFuncLiteralDeclaration())
                    {
                        if (!f->FuncDeclaration::isNested())
                        {
                            /* Supply a 'null' for a this pointer if no this is available
                            */
                            Expression *e = new DelegateExp(exp->loc, new NullExp(exp->loc, Type::tnull), f, ve->hasOverloads);
                            e = expressionSemantic(e, sc);
                            result = e;
                            return;
                        }
                    }
                    Expression *e = new DelegateExp(exp->loc, exp->e1, f, ve->hasOverloads);
                    e = expressionSemantic(e, sc);
                    result = e;
                    return;
                }
                if (f->needThis())
                {
                    if (hasThis(sc))
                    {
                        /* Should probably supply 'this' after overload resolution,
                         * not before.
                         */
                        Expression *ethis = new ThisExp(exp->loc);
                        Expression *e = new DelegateExp(exp->loc, ethis, f, ve->hasOverloads);
                        e = expressionSemantic(e, sc);
                        result = e;
                        return;
                    }
                    if (sc->func && !sc->intypeof)
                    {
                        if (sc->func->setUnsafe())
                        {
                            exp->error("`this` reference necessary to take address of member %s in @safe function %s",
                                f->toChars(), sc->func->toChars());
                        }
                    }
                }
            }
        }
        else if ((exp->e1->op == TOKthis || exp->e1->op == TOKsuper) && global.params.vsafe)
        {
            ThisExp *ve = (ThisExp *)exp->e1;
            VarDeclaration *v = ve->var->isVarDeclaration();
            if (v)
            {
                if (!checkAddressVar(sc, exp, v))
                    return setError();
            }
        }
        else if (exp->e1->op == TOKcall)
        {
            CallExp *ce = (CallExp *)exp->e1;
            if (ce->e1->type->ty == Tfunction)
            {
                TypeFunction *tf = (TypeFunction *)ce->e1->type;
                if (tf->isref && sc->func && !sc->intypeof && sc->func->setUnsafe())
                {
                    exp->error("cannot take address of ref return of %s() in @safe function %s",
                        ce->e1->toChars(), sc->func->toChars());
                }
            }
        }
        else if (exp->e1->op == TOKindex)
        {
            /* For:
             *   int[3] a;
             *   &a[i]
             * check 'a' the same as for a regular variable
             */
            IndexExp *ei = (IndexExp *)exp->e1;
            Type *tyi = ei->e1->type->toBasetype();
            if (tyi->ty == Tsarray && ei->e1->op == TOKvar)
            {
                VarExp *ve = (VarExp *)ei->e1;
                VarDeclaration *v = ve->var->isVarDeclaration();
                if (v)
                {
                    if (!checkAddressVar(sc, exp, v))
                        return setError();

                    ve->checkPurity(sc, v);
                }
            }
        }
        else if (wasCond)
        {
            /* a ? b : c was transformed to *(a ? &b : &c), but we still
             * need to do safety checks
             */
            assert(exp->e1->op == TOKstar);
            PtrExp *pe = (PtrExp *)exp->e1;
            assert(pe->e1->op == TOKquestion);
            CondExp *ce = (CondExp *)pe->e1;
            assert(ce->e1->op == TOKaddress);
            assert(ce->e2->op == TOKaddress);

            // Re-run semantic on the address expressions only
            ce->e1->type = NULL;
            ce->e1 = expressionSemantic(ce->e1, sc);
            ce->e2->type = NULL;
            ce->e2 = expressionSemantic(ce->e2, sc);
        }

        result = exp->optimize(WANTvalue);
    }

    void visit(PtrExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        Type *tb = exp->e1->type->toBasetype();
        switch (tb->ty)
        {
            case Tpointer:
                exp->type = ((TypePointer *)tb)->next;
                break;

            case Tsarray:
            case Tarray:
                exp->error("using * on an array is no longer supported; use *(%s).ptr instead", exp->e1->toChars());
                exp->type = ((TypeArray *)tb)->next;
                exp->e1 = exp->e1->castTo(sc, exp->type->pointerTo());
                break;

            case Tnull:
                exp->type = Type::tnoreturn;    // typeof(*null) is bottom type
                break;

            default:
                exp->error("can only * a pointer, not a `%s`", exp->e1->type->toChars());
                /* fall through */

            case Terror:
                return setError();
        }
        if (exp->checkValue())
            return setError();

        result = exp;
    }

    void visit(NegExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        exp->type = exp->e1->type;
        Type *tb = exp->type->toBasetype();
        if (tb->ty == Tarray || tb->ty == Tsarray)
        {
            if (!isArrayOpValid(exp->e1))
            {
                exp->error("invalid array operation %s (possible missing [])", exp->toChars());
                return setError();
            }
            result = exp;
            return;
        }

        if (!target.isVectorOpSupported(tb, exp->op))
        {
            result = exp->incompatibleTypes();
            return;
        }
        if (exp->e1->checkNoBool())
            return setError();
        if (exp->e1->checkArithmetic())
            return setError();

        result = exp;
    }

    void visit(UAddExp *exp)
    {
        assert(!exp->type);

        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (!target.isVectorOpSupported(exp->e1->type->toBasetype(), exp->op))
        {
            result = exp->incompatibleTypes();
            return;
        }
        if (exp->e1->checkNoBool())
            return setError();
        if (exp->e1->checkArithmetic())
            return setError();

        result = exp->e1;
    }

    void visit(ComExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        exp->type = exp->e1->type;
        Type *tb = exp->type->toBasetype();
        if (tb->ty == Tarray || tb->ty == Tsarray)
        {
            if (!isArrayOpValid(exp->e1))
            {
                exp->error("invalid array operation %s (possible missing [])", exp->toChars());
                return setError();
            }
            result = exp;
            return;
        }

        if (!target.isVectorOpSupported(tb, exp->op))
        {
            result = exp->incompatibleTypes();
            return;
        }
        if (exp->e1->checkNoBool())
            return setError();
        if (exp->e1->checkIntegral())
            return setError();

        result = exp;
    }

    void visit(NotExp *e)
    {
        if (e->type)
        {
            result = e;
            return;
        }

        setNoderefOperand(e);

        // Note there is no operator overload
        if (Expression *ex = unaSemantic(e, sc))
        {
            result = ex;
            return;
        }

        // for static alias this: https://issues.dlang.org/show_bug.cgi?id=17684
        if (e->e1->op == TOKtype)
            e->e1 = resolveAliasThis(sc, e->e1);

        e->e1 = resolveProperties(sc, e->e1);
        e->e1 = e->e1->toBoolean(sc);
        if (e->e1->type == Type::terror)
        {
            result = e->e1;
            return;
        }

        if (!target.isVectorOpSupported(e->e1->type->toBasetype(), e->op))
        {
            result = e->incompatibleTypes();
            return;
        }
        // Bugzilla 13910: Today NotExp can take an array as its operand.
        if (checkNonAssignmentArrayOp(e->e1))
            return setError();

        e->type = Type::tbool;
        result = e;
    }

    void visit(DeleteExp *exp)
    {
        if (Expression *ex = unaSemantic(exp, sc))
        {
            result = ex;
            return;
        }
        exp->e1 = resolveProperties(sc, exp->e1);
        exp->e1 = exp->e1->modifiableLvalue(sc, NULL);
        if (exp->e1->op == TOKerror)
        {
            result = exp->e1;
            return;
        }
        exp->type = Type::tvoid;

        AggregateDeclaration *ad = NULL;
        Type *tb = exp->e1->type->toBasetype();
        switch (tb->ty)
        {   case Tclass:
            {
                ClassDeclaration *cd = ((TypeClass *)tb)->sym;

                if (cd->isCOMinterface())
                {   /* Because COM classes are deleted by IUnknown.Release()
                */
                    exp->error("cannot delete instance of COM interface %s", cd->toChars());
                    return setError();
                }

                ad = cd;
                break;
            }
            case Tpointer:
            tb = ((TypePointer *)tb)->next->toBasetype();
            if (tb->ty == Tstruct)
            {
                ad = ((TypeStruct *)tb)->sym;
                FuncDeclaration *f = ad->aggDelete;
                FuncDeclaration *fd = ad->dtor;

                if (!f)
                {
                    semanticTypeInfo(sc, tb);
                    break;
                }

                /* Construct:
                 *      ea = copy e1 to a tmp to do side effects only once
                 *      eb = call destructor
                 *      ec = call deallocator
                 */
                Expression *ea = NULL;
                Expression *eb = NULL;
                Expression *ec = NULL;
                VarDeclaration *v = NULL;

                if (fd && f)
                {
                    v = copyToTemp(0, "__tmpea", exp->e1);
                    dsymbolSemantic(v, sc);
                    ea = new DeclarationExp(exp->loc, v);
                    ea->type = v->type;
                }

                if (fd)
                {
                    Expression *e = ea ? new VarExp(exp->loc, v) : exp->e1;
                    e = new DotVarExp(Loc(), e, fd, false);
                    eb = new CallExp(exp->loc, e);
                    eb = expressionSemantic(eb, sc);
                }

                if (f)
                {
                    Type *tpv = Type::tvoid->pointerTo();
                    Expression *e = ea ? new VarExp(exp->loc, v) : exp->e1->castTo(sc, tpv);
                    e = new CallExp(exp->loc, new VarExp(exp->loc, f, false), e);
                    ec = expressionSemantic(e, sc);
                }
                ea = Expression::combine(ea, eb);
                ea = Expression::combine(ea, ec);
                assert(ea);
                result = ea;
                return;
            }
            break;

            case Tarray:
            {
                Type *tv = tb->nextOf()->baseElemOf();
                if (tv->ty == Tstruct)
                {
                    ad = ((TypeStruct *)tv)->sym;
                    if (ad->dtor)
                        semanticTypeInfo(sc, ad->type);
                }
                break;
            }
            default:
            exp->error("cannot delete type %s", exp->e1->type->toChars());
            return setError();
        }

        bool err = false;
        if (ad)
        {
            if (ad->dtor)
            {
                err |= exp->checkPurity(sc, ad->dtor);
                err |= exp->checkSafety(sc, ad->dtor);
                err |= exp->checkNogc(sc, ad->dtor);
            }
            if (ad->aggDelete && tb->ty != Tarray)
            {
                err |= exp->checkPurity(sc, ad->aggDelete);
                err |= exp->checkSafety(sc, ad->aggDelete);
                err |= exp->checkNogc(sc, ad->aggDelete);
            }
            if (err)
                return setError();
        }

        if (!sc->intypeof && sc->func &&
            !exp->isRAII &&
            sc->func->setUnsafe())
        {
            exp->error("%s is not @safe but is used in @safe function %s", exp->toChars(), sc->func->toChars());
            err = true;
        }
        if (err)
            return setError();

        result = exp;
    }

    void visit(CastExp *exp)
    {
        //static int x; assert(++x < 10);
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (exp->to)
        {
            exp->to = typeSemantic(exp->to, exp->loc, sc);
            if (exp->to == Type::terror)
                return setError();

            if (!exp->to->hasPointers())
                setNoderefOperand(exp);

            // When e1 is a template lambda, this cast may instantiate it with
            // the type 'to'.
            exp->e1 = inferType(exp->e1, exp->to);
        }

        if (Expression *ex = unaSemantic(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e1x = resolveProperties(sc, exp->e1);
        if (e1x->op == TOKerror)
        {
            result = e1x;
            return;
        }
        if (e1x->checkType())
            return setError();
        exp->e1 = e1x;

        if (!exp->e1->type)
        {
            exp->error("cannot cast %s", exp->e1->toChars());
            return setError();
        }

        if (!exp->to)    // Handle cast(const) and cast(immutable), etc.
        {
            exp->to = exp->e1->type->castMod(exp->mod);
            exp->to = typeSemantic(exp->to, exp->loc, sc);
            if (exp->to == Type::terror)
                return setError();
        }

        if (exp->to->ty == Ttuple)
        {
            exp->error("cannot cast %s to tuple type %s", exp->e1->toChars(), exp->to->toChars());
            return setError();
        }
        if (exp->e1->type->ty != Tvoid ||
            (exp->e1->op == TOKfunction && exp->to->ty == Tvoid) ||
            exp->e1->op == TOKtype ||
            exp->e1->op == TOKtemplate)
        {
            if (exp->e1->checkValue())
                return setError();
        }

        // cast(void) is used to mark e1 as unused, so it is safe
        if (exp->to->ty == Tvoid)
        {
            exp->type = exp->to;
            result = exp;
            return;
        }

        if (!exp->to->equals(exp->e1->type) && exp->mod == (unsigned char)~0)
        {
            if (Expression *e = exp->op_overload(sc))
            {
                result = e->implicitCastTo(sc, exp->to);
                return;
            }
        }

        Type *t1b = exp->e1->type->toBasetype();
        Type *tob = exp->to->toBasetype();

        if (tob->ty == Tstruct && !tob->equals(t1b))
        {
            /* Look to replace:
             *  cast(S)t
             * with:
             *  S(t)
             */

            // Rewrite as to.call(e1)
            Expression *e = new TypeExp(exp->loc, exp->to);
            e = new CallExp(exp->loc, e, exp->e1);
            e = trySemantic(e, sc);
            if (e)
            {
                result = e;
                return;
            }
        }

        if (!t1b->equals(tob) && (t1b->ty == Tarray || t1b->ty == Tsarray))
        {
            if (checkNonAssignmentArrayOp(exp->e1))
                return setError();
        }

        // Look for casting to a vector type
        if (tob->ty == Tvector && t1b->ty != Tvector)
        {
            result = new VectorExp(exp->loc, exp->e1, exp->to);
            return;
        }

        Expression *ex = exp->e1->castTo(sc, exp->to);
        if (ex->op == TOKerror)
        {
            result = ex;
            return;
        }

        // Check for unsafe casts
        if (sc->func && !sc->intypeof &&
            !isSafeCast(ex, t1b, tob) &&
            sc->func->setUnsafe())
        {
            exp->error("cast from %s to %s not allowed in safe code", exp->e1->type->toChars(), exp->to->toChars());
            return setError();
        }

        result = ex;
    }

    void visit(VectorExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        exp->e1 = expressionSemantic(exp->e1, sc);
        exp->type = typeSemantic(exp->to, exp->loc, sc);
        if (exp->e1->op == TOKerror || exp->type->ty == Terror)
        {
            result = exp->e1;
            return;
        }

        Type *tb = exp->type->toBasetype();
        assert(tb->ty == Tvector);
        TypeVector *tv = (TypeVector *)tb;
        Type *te = tv->elementType();
        exp->dim = (int)(tv->size(exp->loc) / te->size(exp->loc));

        exp->e1 = exp->e1->optimize(WANTvalue);
        bool res = false;
        if (exp->e1->op == TOKarrayliteral)
        {
            for (size_t i = 0; i < exp->dim; i++)
            {
                // Do not stop on first error - check all AST nodes even if error found
                res |= checkVectorElem(exp, ((ArrayLiteralExp *)exp->e1)->getElement(i));
            }
        }
        else if (exp->e1->type->ty == Tvoid)
            res = checkVectorElem(exp, exp->e1);

        Expression *e = exp;
        if (res)
            e = new ErrorExp();
        result = e;
    }

    void visit(VectorArrayExp *e)
    {
        if (!e->type)
        {
            unaSemantic(e, sc);
            e->e1 = resolveProperties(sc, e->e1);

            if (e->e1->op == TOKerror)
            {
                result = e->e1;
                return;
            }
            assert(e->e1->type->ty == Tvector);
            TypeVector *tv = (TypeVector *)e->e1->type;
            e->type = tv->basetype;
        }
        result = e;
    }

    void visit(SliceExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        // operator overloading should be handled in ArrayExp already.

        if (Expression *ex = unaSemantic(exp, sc))
        {
            result = ex;
            return;
        }
        exp->e1 = resolveProperties(sc, exp->e1);
        if (exp->e1->op == TOKtype && exp->e1->type->ty != Ttuple)
        {
            if (exp->lwr || exp->upr)
            {
                exp->error("cannot slice type `%s`", exp->e1->toChars());
                return setError();
            }
            Expression *e = new TypeExp(exp->loc, exp->e1->type->arrayOf());
            result = expressionSemantic(e, sc);
            return;
        }
        if (!exp->lwr && !exp->upr)
        {
            if (exp->e1->op == TOKarrayliteral)
            {
                // Convert [a,b,c][] to [a,b,c]
                Type *t1b = exp->e1->type->toBasetype();
                Expression *e = exp->e1;
                if (t1b->ty == Tsarray)
                {
                    e = e->copy();
                    e->type = t1b->nextOf()->arrayOf();
                }
                result = e;
                return;
            }
            if (exp->e1->op == TOKslice)
            {
                // Convert e[][] to e[]
                SliceExp *se = (SliceExp *)exp->e1;
                if (!se->lwr && !se->upr)
                {
                    result = se;
                    return;
                }
            }
            if (isArrayOpOperand(exp->e1))
            {
                // Convert (a[]+b[])[] to a[]+b[]
                result = exp->e1;
                return;
            }
        }
        if (exp->e1->op == TOKerror)
        {
            result = exp->e1;
            return;
        }
        if (exp->e1->type->ty == Terror)
            return setError();

        Type *t1b = exp->e1->type->toBasetype();
        if (t1b->ty == Tpointer)
        {
            if (((TypePointer *)t1b)->next->ty == Tfunction)
            {
                exp->error("cannot slice function pointer %s", exp->e1->toChars());
                return setError();
            }
            if (!exp->lwr || !exp->upr)
            {
                exp->error("need upper and lower bound to slice pointer");
                return setError();
            }
            if (sc->func && !sc->intypeof && sc->func->setUnsafe())
            {
                exp->error("pointer slicing not allowed in safe functions");
                return setError();
            }
        }
        else if (t1b->ty == Tarray)
        {
        }
        else if (t1b->ty == Tsarray)
        {
            if (!exp->arrayop && global.params.vsafe)
            {
                /* Slicing a static array is like taking the address of it.
                 * Perform checks as if e[] was &e
                 */
                VarDeclaration *v = NULL;
                if (exp->e1->op == TOKdotvar)
                {
                    DotVarExp *dve = (DotVarExp *)exp->e1;
                    if (dve->e1->op == TOKvar)
                    {
                        VarExp *ve = (VarExp *)dve->e1;
                        v = ve->var->isVarDeclaration();
                    }
                    else if (dve->e1->op == TOKthis || dve->e1->op == TOKsuper)
                    {
                        ThisExp *ve = (ThisExp *)dve->e1;
                        v = ve->var->isVarDeclaration();
                        if (v && !(v->storage_class & STCref))
                            v = NULL;
                    }
                }
                else if (exp->e1->op == TOKvar)
                {
                    VarExp *ve = (VarExp *)exp->e1;
                    v = ve->var->isVarDeclaration();
                }
                else if (exp->e1->op == TOKthis || exp->e1->op == TOKsuper)
                {
                    ThisExp *ve = (ThisExp *)exp->e1;
                    v = ve->var->isVarDeclaration();
                }

                if (v)
                {
                    if (!checkAddressVar(sc, exp, v))
                        return setError();
                }
            }
        }
        else if (t1b->ty == Ttuple)
        {
            if (!exp->lwr && !exp->upr)
            {
                result = exp->e1;
                return;
            }
            if (!exp->lwr || !exp->upr)
            {
                exp->error("need upper and lower bound to slice tuple");
                return setError();
            }
        }
        else if (t1b->ty == Tvector)
        {
            // Convert e1 to corresponding static array
            TypeVector *tv1 = (TypeVector *)t1b;
            t1b = tv1->basetype;
            t1b = t1b->castMod(tv1->mod);
            exp->e1->type = t1b;
        }
        else
        {
            exp->error("%s cannot be sliced with []",
                t1b->ty == Tvoid ? exp->e1->toChars() : t1b->toChars());
            return setError();
        }

        /* Run semantic on lwr and upr.
        */
        Scope *scx = sc;
        if (t1b->ty == Tsarray || t1b->ty == Tarray || t1b->ty == Ttuple)
        {
            // Create scope for 'length' variable
            ScopeDsymbol *sym = new ArrayScopeSymbol(sc, exp);
            sym->loc = exp->loc;
            sym->parent = sc->scopesym;
            sc = sc->push(sym);
        }
        if (exp->lwr)
        {
            if (t1b->ty == Ttuple) sc = sc->startCTFE();
            exp->lwr = expressionSemantic(exp->lwr, sc);
            exp->lwr = resolveProperties(sc, exp->lwr);
            if (t1b->ty == Ttuple) sc = sc->endCTFE();
            exp->lwr = exp->lwr->implicitCastTo(sc, Type::tsize_t);
        }
        if (exp->upr)
        {
            if (t1b->ty == Ttuple) sc = sc->startCTFE();
            exp->upr = expressionSemantic(exp->upr, sc);
            exp->upr = resolveProperties(sc, exp->upr);
            if (t1b->ty == Ttuple) sc = sc->endCTFE();
            exp->upr = exp->upr->implicitCastTo(sc, Type::tsize_t);
        }
        if (sc != scx)
            sc = sc->pop();
        if ((exp->lwr && exp->lwr->type == Type::terror) ||
            (exp->upr && exp->upr->type == Type::terror))
        {
            return setError();
        }

        if (t1b->ty == Ttuple)
        {
            exp->lwr = exp->lwr->ctfeInterpret();
            exp->upr = exp->upr->ctfeInterpret();
            uinteger_t i1 = exp->lwr->toUInteger();
            uinteger_t i2 = exp->upr->toUInteger();

            TupleExp *te;
            TypeTuple *tup;
            size_t length;
            if (exp->e1->op == TOKtuple)         // slicing an expression tuple
            {
                te = (TupleExp *)exp->e1;
                tup = NULL;
                length = te->exps->length;
            }
            else if (exp->e1->op == TOKtype)     // slicing a type tuple
            {
                te = NULL;
                tup = (TypeTuple *)t1b;
                length = Parameter::dim(tup->arguments);
            }
            else
                assert(0);

            if (i2 < i1 || length < i2)
            {
                exp->error("string slice [%llu .. %llu] is out of bounds", i1, i2);
                return setError();
            }

            size_t j1 = (size_t) i1;
            size_t j2 = (size_t) i2;
            Expression *e;
            if (exp->e1->op == TOKtuple)
            {
                Expressions *exps = new Expressions;
                exps->setDim(j2 - j1);
                for (size_t i = 0; i < j2 - j1; i++)
                {
                    (*exps)[i] = (*te->exps)[j1 + i];
                }
                e = new TupleExp(exp->loc, te->e0, exps);
            }
            else
            {
                Parameters *args = new Parameters;
                args->reserve(j2 - j1);
                for (size_t i = j1; i < j2; i++)
                {
                    Parameter *arg = Parameter::getNth(tup->arguments, i);
                    args->push(arg);
                }
                e = new TypeExp(exp->e1->loc, new TypeTuple(args));
            }
            e = expressionSemantic(e, sc);
            result = e;
            return;
        }

        exp->type = t1b->nextOf()->arrayOf();
        // Allow typedef[] -> typedef[]
        if (exp->type->equals(t1b))
            exp->type = exp->e1->type;

        if (exp->lwr && exp->upr)
        {
            exp->lwr = exp->lwr->optimize(WANTvalue);
            exp->upr = exp->upr->optimize(WANTvalue);

            IntRange lwrRange = getIntRange(exp->lwr);
            IntRange uprRange = getIntRange(exp->upr);

            if (t1b->ty == Tsarray || t1b->ty == Tarray)
            {
                Expression *el = new ArrayLengthExp(exp->loc, exp->e1);
                el = expressionSemantic(el, sc);
                el = el->optimize(WANTvalue);
                if (el->op == TOKint64)
                {
                    dinteger_t length = el->toInteger();
                    IntRange bounds(SignExtendedNumber(0), SignExtendedNumber(length));
                    exp->upperIsInBounds = bounds.contains(uprRange);
                }
            }
            else if (t1b->ty == Tpointer)
            {
                exp->upperIsInBounds = true;
            }
            else
                assert(0);

            exp->lowerIsLessThanUpper = (lwrRange.imax <= uprRange.imin);

            //printf("upperIsInBounds = %d lowerIsLessThanUpper = %d\n", upperIsInBounds, lowerIsLessThanUpper);
        }

        result = exp;
    }

    void visit(ArrayLengthExp *e)
    {
        if (e->type)
        {
            result = e;
            return;
        }

        if (Expression *ex = unaSemantic(e, sc))
        {
            result = ex;
            return;
        }
        e->e1 = resolveProperties(sc, e->e1);

        e->type = Type::tsize_t;
        result = e;
    }

    void visit(IntervalExp *e)
    {
        if (e->type)
        {
            result = e;
            return;
        }

        Expression *le = e->lwr;
        le = expressionSemantic(le, sc);
        le = resolveProperties(sc, le);

        Expression *ue = e->upr;
        ue = expressionSemantic(ue, sc);
        ue = resolveProperties(sc, ue);

        if (le->op == TOKerror)
        {
            result = le;
            return;
        }
        if (ue->op == TOKerror)
        {
            result = ue;
            return;
        }

        e->lwr = le;
        e->upr = ue;

        e->type = Type::tvoid;
        result = e;
    }

    void visit(DelegatePtrExp *e)
    {
        if (!e->type)
        {
            unaSemantic(e, sc);
            e->e1 = resolveProperties(sc, e->e1);

            if (e->e1->op == TOKerror)
            {
                result = e->e1;
                return;
            }
            e->type = Type::tvoidptr;
        }
        result = e;
    }

    void visit(DelegateFuncptrExp *e)
    {
        if (!e->type)
        {
            unaSemantic(e, sc);
            e->e1 = resolveProperties(sc, e->e1);

            if (e->e1->op == TOKerror)
            {
                result = e->e1;
                return;
            }
            e->type = e->e1->type->nextOf()->pointerTo();
        }
        result = e;
    }

    void visit(ArrayExp *exp)
    {
        assert(!exp->type);

        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (isAggregate(exp->e1->type))
            exp->error("no [] operator overload for type %s", exp->e1->type->toChars());
        else
            exp->error("only one index allowed to index %s", exp->e1->type->toChars());
        return setError();
    }

    void visit(DotExp *exp)
    {
        exp->e1 = expressionSemantic(exp->e1, sc);
        exp->e2 = expressionSemantic(exp->e2, sc);

        if (exp->e1->op == TOKtype)
        {
            result = exp->e2;
            return;
        }
        if (exp->e2->op == TOKtype)
        {
            result = exp->e2;
            return;
        }
        if (exp->e2->op == TOKtemplate)
        {
            TemplateDeclaration *td = ((TemplateExp *)exp->e2)->td;
            Expression *e = new DotTemplateExp(exp->loc, exp->e1, td);
            result = expressionSemantic(e, sc);
            return;
        }
        if (!exp->type)
            exp->type = exp->e2->type;
        result = exp;
    }

    void visit(CommaExp *e)
    {
        if (e->type)
        {
            result = e;
            return;
        }

        // Allow `((a,b),(x,y))`
        if (e->allowCommaExp)
        {
            if (e->e1 && e->e1->op == TOKcomma)
                ((CommaExp *)e->e1)->allowCommaExp = true;
            if (e->e2 && e->e2->op == TOKcomma)
                ((CommaExp *)e->e2)->allowCommaExp = true;
        }

        if (Expression *ex = binSemanticProp(e, sc))
        {
            result = ex;
            return;
        }
        e->e1 = e->e1->addDtorHook(sc);

        if (checkNonAssignmentArrayOp(e->e1))
            return setError();

        e->type = e->e2->type;
        if (e->type != Type::tvoid && !e->allowCommaExp && !e->isGenerated)
            e->deprecation("Using the result of a comma expression is deprecated");
        result = e;
    }

    void visit(IndexExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        // operator overloading should be handled in ArrayExp already.

        if (!exp->e1->type)
            exp->e1 = expressionSemantic(exp->e1, sc);
        assert(exp->e1->type);           // semantic() should already be run on it
        if (exp->e1->op == TOKtype && exp->e1->type->ty != Ttuple)
        {
            exp->e2 = expressionSemantic(exp->e2, sc);
            exp->e2 = resolveProperties(sc, exp->e2);
            Type *nt;
            if (exp->e2->op == TOKtype)
                nt = new TypeAArray(exp->e1->type, exp->e2->type);
            else
                nt = new TypeSArray(exp->e1->type, exp->e2);
            Expression *e = new TypeExp(exp->loc, nt);
            result = expressionSemantic(e, sc);
            return;
        }
        if (exp->e1->op == TOKerror)
        {
            result = exp->e1;
            return;
        }
        if (exp->e1->type->ty == Terror)
            return setError();

        // Note that unlike C we do not implement the int[ptr]

        Type *t1b = exp->e1->type->toBasetype();

        if (t1b->ty == Tvector)
        {
            // Convert e1 to corresponding static array
            TypeVector *tv1 = (TypeVector *)t1b;
            t1b = tv1->basetype;
            t1b = t1b->castMod(tv1->mod);
            exp->e1->type = t1b;
        }

        /* Run semantic on e2
        */
        Scope *scx = sc;
        if (t1b->ty == Tsarray || t1b->ty == Tarray || t1b->ty == Ttuple)
        {
            // Create scope for 'length' variable
            ScopeDsymbol *sym = new ArrayScopeSymbol(sc, exp);
            sym->loc = exp->loc;
            sym->parent = sc->scopesym;
            sc = sc->push(sym);
        }
        if (t1b->ty == Ttuple) sc = sc->startCTFE();
        exp->e2 = expressionSemantic(exp->e2, sc);
        exp->e2 = resolveProperties(sc, exp->e2);
        if (t1b->ty == Ttuple) sc = sc->endCTFE();
        if (exp->e2->op == TOKtuple)
        {
            TupleExp *te = (TupleExp *)exp->e2;
            if (te->exps && te->exps->length == 1)
                exp->e2 = Expression::combine(te->e0, (*te->exps)[0]);  // bug 4444 fix
        }
        if (sc != scx)
            sc = sc->pop();
        if (exp->e2->type == Type::terror)
            return setError();

        if (checkNonAssignmentArrayOp(exp->e1))
            return setError();

        switch (t1b->ty)
        {
            case Tpointer:
                if (((TypePointer *)t1b)->next->ty == Tfunction)
                {
                    exp->error("cannot index function pointer %s", exp->e1->toChars());
                    return setError();
                }
                exp->e2 = exp->e2->implicitCastTo(sc, Type::tsize_t);
                if (exp->e2->type == Type::terror)
                    return setError();
                exp->e2 = exp->e2->optimize(WANTvalue);
                if (exp->e2->op == TOKint64 && exp->e2->toInteger() == 0)
                    ;
                else if (sc->func && sc->func->setUnsafe())
                {
                    exp->error("safe function `%s` cannot index pointer `%s`",
                        sc->func->toPrettyChars(), exp->e1->toChars());
                    return setError();
                }
                exp->type = ((TypeNext *)t1b)->next;
                break;

            case Tarray:
                exp->e2 = exp->e2->implicitCastTo(sc, Type::tsize_t);
                if (exp->e2->type == Type::terror)
                    return setError();
                exp->type = ((TypeNext *)t1b)->next;
                break;

            case Tsarray:
                {
                    exp->e2 = exp->e2->implicitCastTo(sc, Type::tsize_t);
                    if (exp->e2->type == Type::terror)
                        return setError();
                    exp->type = t1b->nextOf();
                    break;
                }

            case Taarray:
                {
                    TypeAArray *taa = (TypeAArray *)t1b;
                    /* We can skip the implicit conversion if they differ only by
                     * constness (Bugzilla 2684, see also bug 2954b)
                     */
                    if (!arrayTypeCompatibleWithoutCasting(exp->e2->type, taa->index))
                    {
                        exp->e2 = exp->e2->implicitCastTo(sc, taa->index);        // type checking
                        if (exp->e2->type == Type::terror)
                            return setError();
                    }

                    semanticTypeInfo(sc, taa);

                    exp->type = taa->next;
                    break;
                }

            case Ttuple:
                {
                    exp->e2 = exp->e2->implicitCastTo(sc, Type::tsize_t);
                    if (exp->e2->type == Type::terror)
                        return setError();
                    exp->e2 = exp->e2->ctfeInterpret();
                    uinteger_t index = exp->e2->toUInteger();

                    TupleExp *te;
                    TypeTuple *tup;
                    size_t length;
                    if (exp->e1->op == TOKtuple)
                    {
                        te = (TupleExp *)exp->e1;
                        tup = NULL;
                        length = te->exps->length;
                    }
                    else if (exp->e1->op == TOKtype)
                    {
                        te = NULL;
                        tup = (TypeTuple *)t1b;
                        length = Parameter::dim(tup->arguments);
                    }
                    else
                        assert(0);

                    if (length <= index)
                    {
                        exp->error("array index [%llu] is outside array bounds [0 .. %llu]",
                            index, (ulonglong)length);
                        return setError();
                    }

                    Expression *e;
                    if (exp->e1->op == TOKtuple)
                    {
                        e = (*te->exps)[(size_t)index];
                        e = Expression::combine(te->e0, e);
                    }
                    else
                        e = new TypeExp(exp->e1->loc, Parameter::getNth(tup->arguments, (size_t)index)->type);
                    result = e;
                    return;
                }

            default:
                exp->error("%s must be an array or pointer type, not %s",
                    exp->e1->toChars(), exp->e1->type->toChars());
                return setError();
        }

        if (t1b->ty == Tsarray || t1b->ty == Tarray)
        {
            Expression *el = new ArrayLengthExp(exp->loc, exp->e1);
            el = expressionSemantic(el, sc);
            el = el->optimize(WANTvalue);
            if (el->op == TOKint64)
            {
                exp->e2 = exp->e2->optimize(WANTvalue);
                dinteger_t length = el->toInteger();
                if (length)
                {
                    IntRange bounds(SignExtendedNumber(0), SignExtendedNumber(length - 1));
                    exp->indexIsInBounds = bounds.contains(getIntRange(exp->e2));
                }
            }
        }

        result = exp;
    }

    void visit(PostExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemantic(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e1x = resolveProperties(sc, exp->e1);
        if (e1x->op == TOKerror)
        {
            result = e1x;
            return;
        }
        exp->e1 = e1x;

        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (exp->e1->checkReadModifyWrite(exp->op))
            return setError();
        if (exp->e1->op == TOKslice)
        {
            const char *s = exp->op == TOKplusplus ? "increment" : "decrement";
            exp->error("cannot post-%s array slice `%s`, use pre-%s instead", s, exp->e1->toChars(), s);
            return setError();
        }

        exp->e1 = exp->e1->optimize(WANTvalue);

        Type *t1 = exp->e1->type->toBasetype();
        if (t1->ty == Tclass || t1->ty == Tstruct || exp->e1->op == TOKarraylength)
        {
            /* Check for operator overloading,
             * but rewrite in terms of ++e instead of e++
             */

            /* If e1 is not trivial, take a reference to it
            */
            Expression *de = NULL;
            if (exp->e1->op != TOKvar && exp->e1->op != TOKarraylength)
            {
                // ref v = e1;
                VarDeclaration *v = copyToTemp(STCref, "__postref", exp->e1);
                de = new DeclarationExp(exp->loc, v);
                exp->e1 = new VarExp(exp->e1->loc, v);
            }

            /* Rewrite as:
             * auto tmp = e1; ++e1; tmp
             */
            VarDeclaration *tmp = copyToTemp(0, "__pitmp", exp->e1);
            Expression *ea = new DeclarationExp(exp->loc, tmp);

            Expression *eb = exp->e1->syntaxCopy();
            eb = new PreExp(exp->op == TOKplusplus ? TOKpreplusplus : TOKpreminusminus, exp->loc, eb);

            Expression *ec = new VarExp(exp->loc, tmp);

            // Combine de,ea,eb,ec
            if (de)
                ea = new CommaExp(exp->loc, de, ea);
            e = new CommaExp(exp->loc, ea, eb);
            e = new CommaExp(exp->loc, e, ec);
            e = expressionSemantic(e, sc);
            result = e;
            return;
        }

        exp->e1 = exp->e1->modifiableLvalue(sc, exp->e1);

        e = exp;
        if (exp->e1->checkScalar())
            return setError();
        if (exp->e1->checkNoBool())
            return setError();

        if (exp->e1->type->ty == Tpointer)
            e = scaleFactor(exp, sc);
        else
            exp->e2 = exp->e2->castTo(sc, exp->e1->type);
        e->type = exp->e1->type;
        result = e;
    }

    void visit(PreExp *exp)
    {
        Expression *e = exp->op_overload(sc);
        // printf("PreExp::semantic('%s')\n", exp->toChars());

        if (e)
        {
            result = e;
            return;
        }

        // Rewrite as e1+=1 or e1-=1
        if (exp->op == TOKpreplusplus)
            e = new AddAssignExp(exp->loc, exp->e1, new IntegerExp(exp->loc, 1, Type::tint32));
        else
            e = new MinAssignExp(exp->loc, exp->e1, new IntegerExp(exp->loc, 1, Type::tint32));
        result = expressionSemantic(e, sc);
    }

    void visit(AssignExp *exp)
    {
        //printf("e1->op = %d, '%s'\n", exp->e1->op, Token::toChars(exp->e1->op));
        //printf("e2->op = %d, '%s'\n", exp->e2->op, Token::toChars(exp->e2->op));
        if (exp->type)
        {
            result = exp;
            return;
        }

        Expression *e1old = exp->e1;

        if (exp->e2->op == TOKcomma)
        {
            /* Rewrite to get rid of the comma from rvalue
            */
            if (!((CommaExp *)exp->e2)->isGenerated)
                exp->deprecation("Using the result of a comma expression is deprecated");
            Expression *e0;
            exp->e2 = Expression::extractLast(exp->e2, &e0);
            Expression *e = Expression::combine(e0, exp);
            result = expressionSemantic(e, sc);
            return;
        }

        /* Look for operator overloading of a[arguments] = e2.
         * Do it before e1->semantic() otherwise the ArrayExp will have been
         * converted to unary operator overloading already.
         */
        if (exp->e1->op == TOKarray)
        {
            Expression *res;

            ArrayExp *ae = (ArrayExp *)exp->e1;
            ae->e1 = expressionSemantic(ae->e1, sc);
            ae->e1 = resolveProperties(sc, ae->e1);
            Expression *ae1old = ae->e1;

            const bool maybeSlice =
                (ae->arguments->length == 0 ||
                 (ae->arguments->length == 1 && (*ae->arguments)[0]->op == TOKinterval));
            IntervalExp *ie = NULL;
            if (maybeSlice && ae->arguments->length)
            {
                assert((*ae->arguments)[0]->op == TOKinterval);
                ie = (IntervalExp *)(*ae->arguments)[0];
            }

            while (true)
            {
                if (ae->e1->op == TOKerror)
                {
                    result = ae->e1;
                    return;
                }
                Expression *e0 = NULL;
                Expression *ae1save = ae->e1;
                ae->lengthVar = NULL;

                Type *t1b = ae->e1->type->toBasetype();
                AggregateDeclaration *ad = isAggregate(t1b);
                if (!ad)
                    break;
                if (search_function(ad, Id::indexass))
                {
                    // Deal with $
                    res = resolveOpDollar(sc, ae, &e0);
                    if (!res)    // a[i..j] = e2 might be: a.opSliceAssign(e2, i, j)
                        goto Lfallback;
                    if (res->op == TOKerror)
                    {
                        result = res;
                        return;
                    }

                    res = expressionSemantic(exp->e2, sc);
                    if (res->op == TOKerror)
                    {
                        result = res;
                        return;
                    }
                    exp->e2 = res;

                    /* Rewrite (a[arguments] = e2) as:
                     *      a.opIndexAssign(e2, arguments)
                     */
                    Expressions *a = (Expressions *)ae->arguments->copy();
                    a->insert(0, exp->e2);
                    res = new DotIdExp(exp->loc, ae->e1, Id::indexass);
                    res = new CallExp(exp->loc, res, a);
                    if (maybeSlice) // a[] = e2 might be: a.opSliceAssign(e2)
                        res = trySemantic(res, sc);
                    else
                        res = expressionSemantic(res, sc);
                    if (res)
                    {
                        res = Expression::combine(e0, res);
                        result = res;
                        return;
                    }
                }
            Lfallback:
                if (maybeSlice && search_function(ad, Id::sliceass))
                {
                    // Deal with $
                    res = resolveOpDollar(sc, ae, ie, &e0);
                    if (res->op == TOKerror)
                    {
                        result = res;
                        return;
                    }

                    res = expressionSemantic(exp->e2, sc);
                    if (res->op == TOKerror)
                    {
                        result = res;
                        return;
                    }
                    exp->e2 = res;

                    /* Rewrite (a[i..j] = e2) as:
                     *      a.opSliceAssign(e2, i, j)
                     */
                    Expressions *a = new Expressions();
                    a->push(exp->e2);
                    if (ie)
                    {
                        a->push(ie->lwr);
                        a->push(ie->upr);
                    }
                    res = new DotIdExp(exp->loc, ae->e1, Id::sliceass);
                    res = new CallExp(exp->loc, res, a);
                    res = expressionSemantic(res, sc);
                    res = Expression::combine(e0, res);
                    result = res;
                    return;
                }

                // No operator overloading member function found yet, but
                // there might be an alias this to try.
                if (ad->aliasthis && t1b != ae->att1)
                {
                    if (!ae->att1 && t1b->checkAliasThisRec())
                        ae->att1 = t1b;

                    /* Rewrite (a[arguments] op e2) as:
                     *      a.aliasthis[arguments] op e2
                     */
                    ae->e1 = resolveAliasThis(sc, ae1save, true);
                    if (ae->e1)
                        continue;
                }
                break;
            }
            ae->e1 = ae1old;    // recovery
            ae->lengthVar = NULL;
        }

        /* Run exp->e1 semantic.
         */
        {
            Expression *e1x = exp->e1;

            /* With UFCS, e.f = value
             * Could mean:
             *      .f(e, value)
             * or:
             *      .f(e) = value
             */
            if (e1x->op == TOKdotti)
            {
                DotTemplateInstanceExp *dti = (DotTemplateInstanceExp *)e1x;
                Expression *e = semanticY(dti, sc, 1);
                if (!e)
                {
                    result = resolveUFCSProperties(sc, e1x, exp->e2);
                    return;
                }
                e1x = e;
            }
            else if (e1x->op == TOKdotid)
            {
                DotIdExp *die = (DotIdExp *)e1x;
                Expression *e = semanticY(die, sc, 1);
                if (e && isDotOpDispatch(e))
                {
                    unsigned errors = global.startGagging();
                    e = resolvePropertiesX(sc, e, exp->e2);
                    if (global.endGagging(errors))
                        e = NULL;   /* fall down to UFCS */
                    else
                    {
                        result = e;
                        return;
                    }
                }
                if (!e)
                {
                    result = resolveUFCSProperties(sc, e1x, exp->e2);
                    return;
                }
                e1x = e;
            }
            else
            {
                if (e1x->op == TOKslice)
                    ((SliceExp *)e1x)->arrayop = true;

                e1x = expressionSemantic(e1x, sc);
            }

            /* We have f = value.
             * Could mean:
             *      f(value)
             * or:
             *      f() = value
             */
            if (Expression *e = resolvePropertiesX(sc, e1x, exp->e2))
            {
                result = e;
                return;
            }
            if (e1x->checkRightThis(sc))
                return setError();
            exp->e1 = e1x;
            assert(exp->e1->type);
        }
        Type *t1 = exp->e1->type->toBasetype();

        /* Run exp->e2 semantic.
         * Different from other binary expressions, the analysis of e2
         * depends on the result of e1 in assignments.
         */
        {
            Expression *e2x = inferType(exp->e2, t1->baseElemOf());

            e2x = expressionSemantic(e2x, sc);
            e2x = resolveProperties(sc, e2x);

            if (e2x->op == TOKtype)
                e2x = resolveAliasThis(sc, e2x); //https://issues.dlang.org/show_bug.cgi?id=17684
            if (e2x->op == TOKerror)
            {
                result = e2x;
                return;
            }
            if (e2x->checkValue())
                return setError();
            exp->e2 = e2x;
        }

        /* Rewrite tuple assignment as a tuple of assignments.
        */
        {
            Expression *e2x = exp->e2;

        Ltupleassign:
            if (exp->e1->op == TOKtuple && e2x->op == TOKtuple)
            {
                TupleExp *tup1 = (TupleExp *)exp->e1;
                TupleExp *tup2 = (TupleExp *)e2x;
                size_t dim = tup1->exps->length;
                Expression *e = NULL;
                if (dim != tup2->exps->length)
                {
                    exp->error("mismatched tuple lengths, %d and %d", (int)dim, (int)tup2->exps->length);
                    return setError();
                }
                if (dim == 0)
                {
                    e = new IntegerExp(exp->loc, 0, Type::tint32);
                    e = new CastExp(exp->loc, e, Type::tvoid);   // avoid "has no effect" error
                    e = Expression::combine(Expression::combine(tup1->e0, tup2->e0), e);
                }
                else
                {
                    Expressions *exps = new Expressions;
                    exps->setDim(dim);
                    for (size_t i = 0; i < dim; i++)
                    {
                        Expression *ex1 = (*tup1->exps)[i];
                        Expression *ex2 = (*tup2->exps)[i];
                        (*exps)[i] = new AssignExp(exp->loc, ex1, ex2);
                    }
                    e = new TupleExp(exp->loc, Expression::combine(tup1->e0, tup2->e0), exps);
                }
                result = expressionSemantic(e, sc);
                return;
            }

            /* Look for form: e1 = e2->aliasthis.
             */
            if (exp->e1->op == TOKtuple)
            {
                TupleDeclaration *td = isAliasThisTuple(e2x);
                if (!td)
                    goto Lnomatch;

                assert(exp->e1->type->ty == Ttuple);
                TypeTuple *tt = (TypeTuple *)exp->e1->type;

                Expression *e0 = NULL;
                Expression *ev = extractSideEffect(sc, "__tup", &e0, e2x);

                Expressions *iexps = new Expressions();
                iexps->push(ev);

                for (size_t u = 0; u < iexps->length ; u++)
                {
            Lexpand:
                    Expression *e = (*iexps)[u];

                    Parameter *arg = Parameter::getNth(tt->arguments, u);
                    //printf("[%d] iexps->length = %d, ", u, iexps->length);
                    //printf("e = (%s %s, %s), ", Token::tochars[e->op], e->toChars(), e->type->toChars());
                    //printf("arg = (%s, %s)\n", arg->toChars(), arg->type->toChars());

                    if (!arg || !e->type->implicitConvTo(arg->type))
                    {
                        // expand initializer to tuple
                        if (expandAliasThisTuples(iexps, u) != -1)
                        {
                            if (iexps->length <= u)
                                break;
                            goto Lexpand;
                        }
                        goto Lnomatch;
                    }
                }
                e2x = new TupleExp(e2x->loc, e0, iexps);
                e2x = expressionSemantic(e2x, sc);
                if (e2x->op == TOKerror)
                {
                    result = e2x;
                    return;
                }
                // Do not need to overwrite exp->e2
                goto Ltupleassign;
            }
        Lnomatch:
            ;
        }

        /* Inside constructor, if this is the first assignment of object field,
         * rewrite this to initializing the field.
         */
        if (exp->op == TOKassign && exp->e1->checkModifiable(sc) == 2)
        {
            //printf("[%s] change to init - %s\n", exp->loc.toChars(), toChars());
            exp->op = TOKconstruct;

            // Bugzilla 13515: set Index::modifiable flag for complex AA element initialization
            if (exp->e1->op == TOKindex)
            {
                Expression *e1x = ((IndexExp *)exp->e1)->markSettingAAElem();
                if (e1x->op == TOKerror)
                {
                    result = e1x;
                    return;
                }
            }
        }
        else if (exp->op == TOKconstruct && exp->e1->op == TOKvar &&
                 ((VarExp *)exp->e1)->var->storage_class & (STCout | STCref))
        {
            exp->memset |= referenceInit;
        }

        /* If it is an assignment from a 'foreign' type,
         * check for operator overloading.
         */
        if (exp->memset & referenceInit)
        {
            // If this is an initialization of a reference,
            // do nothing
        }
        else if (t1->ty == Tstruct)
        {
            Expression *e1x = exp->e1;
            Expression *e2x = exp->e2;
            StructDeclaration *sd = ((TypeStruct *)t1)->sym;

            if (exp->op == TOKconstruct)
            {
                Type *t2 = e2x->type->toBasetype();
                if (t2->ty == Tstruct && sd == ((TypeStruct *)t2)->sym)
                {
                    sd->size(exp->loc);
                    if (sd->sizeok != SIZEOKdone)
                        return setError();
                    if (!sd->ctor)
                        sd->ctor = sd->searchCtor();

                    // Bugzilla 15661: Look for the form from last of comma chain.
                    Expression *e2y = e2x;
                    while (e2y->op == TOKcomma)
                        e2y = ((CommaExp *)e2y)->e2;

                    CallExp *ce = (e2y->op == TOKcall) ? (CallExp *)e2y : NULL;
                    DotVarExp *dve = (ce && ce->e1->op == TOKdotvar)
                        ? (DotVarExp *)ce->e1 : NULL;
                    if (sd->ctor && ce && dve && dve->var->isCtorDeclaration() &&
                        e2y->type->implicitConvTo(t1))
                    {
                        /* Look for form of constructor call which is:
                         *    __ctmp.ctor(arguments...)
                         */

                        /* Before calling the constructor, initialize
                         * variable with a bit copy of the default
                         * initializer
                         */
                        AssignExp *ae = exp;
                        if (sd->zeroInit == 1 && !sd->isNested())
                        {
                            // Bugzilla 14606: Always use BlitExp for the special expression: (struct = 0)
                            ae = new BlitExp(ae->loc, ae->e1, new IntegerExp(exp->loc, 0, Type::tint32));
                        }
                        else
                        {
                            // Keep ae->op == TOKconstruct
                            ae->e2 = sd->isNested() ? t1->defaultInitLiteral(exp->loc) : t1->defaultInit(exp->loc);
                        }
                        ae->type = e1x->type;

                        /* Replace __ctmp being constructed with e1.
                         * We need to copy constructor call expression,
                         * because it may be used in other place.
                         */
                        DotVarExp *dvx = (DotVarExp *)dve->copy();
                        dvx->e1 = e1x;
                        CallExp *cx = (CallExp *)ce->copy();
                        cx->e1 = dvx;

                        Expression *e0;
                        Expression::extractLast(e2x, &e0);

                        Expression *e = Expression::combine(ae, cx);
                        e = Expression::combine(e0, e);
                        e = expressionSemantic(e, sc);
                        result = e;
                        return;
                    }
                    if (sd->postblit)
                    {
                        /* We have a copy constructor for this
                        */
                        if (e2x->op == TOKquestion)
                        {
                            /* Rewrite as:
                             *  a ? e1 = b : e1 = c;
                             */
                            CondExp *econd = (CondExp *)e2x;
                            Expression *ea1 = new ConstructExp(econd->e1->loc, e1x, econd->e1);
                            Expression *ea2 = new ConstructExp(econd->e1->loc, e1x, econd->e2);
                            Expression *e = new CondExp(exp->loc, econd->econd, ea1, ea2);
                            result = expressionSemantic(e, sc);
                            return;
                        }

                        if (e2x->isLvalue())
                        {
                            if (!e2x->type->implicitConvTo(e1x->type))
                            {
                                exp->error("conversion error from %s to %s", e2x->type->toChars(), e1x->type->toChars());
                                return setError();
                            }

                            /* Rewrite as:
                             *  (e1 = e2).postblit();
                             *
                             * Blit assignment e1 = e2 returns a reference to the original e1,
                             * then call the postblit on it.
                             */
                            Expression *e = e1x->copy();
                            e->type = e->type->mutableOf();
                            e = new BlitExp(exp->loc, e, e2x);
                            e = new DotVarExp(exp->loc, e, sd->postblit, false);
                            e = new CallExp(exp->loc, e);
                            result = expressionSemantic(e, sc);
                            return;
                        }
                        else
                        {
                            /* The struct value returned from the function is transferred
                             * so should not call the destructor on it.
                             */
                            e2x = valueNoDtor(e2x);
                        }
                    }
                }
                else if (!e2x->implicitConvTo(t1))
                {
                    sd->size(exp->loc);
                    if (sd->sizeok != SIZEOKdone)
                        return setError();
                    if (!sd->ctor)
                        sd->ctor = sd->searchCtor();

                    if (sd->ctor)
                    {
                        /* Look for implicit constructor call
                         * Rewrite as:
                         *  e1 = init, e1.ctor(e2)
                         */
                        Expression *einit;
                        einit = new BlitExp(exp->loc, e1x, e1x->type->defaultInit(exp->loc));
                        einit->type = e1x->type;

                        Expression *e;
                        e = new DotIdExp(exp->loc, e1x, Id::ctor);
                        e = new CallExp(exp->loc, e, e2x);
                        e = new CommaExp(exp->loc, einit, e);
                        e = expressionSemantic(e, sc);
                        result = e;
                        return;
                    }
                    if (search_function(sd, Id::call))
                    {
                        /* Look for static opCall
                         * (See bugzilla 2702 for more discussion)
                         * Rewrite as:
                         *  e1 = typeof(e1).opCall(arguments)
                         */
                        e2x = typeDotIdExp(e2x->loc, e1x->type, Id::call);
                        e2x = new CallExp(exp->loc, e2x, exp->e2);

                        e2x = expressionSemantic(e2x, sc);
                        e2x = resolveProperties(sc, e2x);
                        if (e2x->op == TOKerror)
                        {
                            result = e2x;
                            return;
                        }
                        if (e2x->checkValue())
                            return setError();
                    }
                }
                else    // Bugzilla 11355
                {
                    AggregateDeclaration *ad2 = isAggregate(e2x->type);
                    if (ad2 && ad2->aliasthis && !(exp->att2 && e2x->type == exp->att2))
                    {
                        if (!exp->att2 && exp->e2->type->checkAliasThisRec())
                            exp->att2 = exp->e2->type;

                        /* Rewrite (e1 op e2) as:
                         *      (e1 op e2.aliasthis)
                         */
                        exp->e2 = new DotIdExp(exp->e2->loc, exp->e2, ad2->aliasthis->ident);
                        result = expressionSemantic(exp, sc);
                        return;
                    }
                }
            }
            else if (exp->op == TOKassign)
            {
                if (e1x->op == TOKindex &&
                    ((IndexExp *)e1x)->e1->type->toBasetype()->ty == Taarray)
                {
                    /*
                     * Rewrite:
                     *      aa[key] = e2;
                     * as:
                     *      ref __aatmp = aa;
                     *      ref __aakey = key;
                     *      ref __aaval = e2;
                     *      (__aakey in __aatmp
                     *          ? __aatmp[__aakey].opAssign(__aaval)
                     *          : ConstructExp(__aatmp[__aakey], __aaval));
                     */
                    IndexExp *ie = (IndexExp *)e1x;
                    Type *t2 = e2x->type->toBasetype();

                    Expression *e0 = NULL;
                    Expression *ea = extractSideEffect(sc, "__aatmp", &e0, ie->e1);
                    Expression *ek = extractSideEffect(sc, "__aakey", &e0, ie->e2);
                    Expression *ev = extractSideEffect(sc, "__aaval", &e0, e2x);

                    AssignExp *ae = (AssignExp *)exp->copy();
                    ae->e1 = new IndexExp(exp->loc, ea, ek);
                    ae->e1 = expressionSemantic(ae->e1, sc);
                    ae->e1 = ae->e1->optimize(WANTvalue);
                    ae->e2 = ev;
                    Expression *e = ae->op_overload(sc);
                    if (e)
                    {
                        Expression *ey = NULL;
                        if (t2->ty == Tstruct && sd == t2->toDsymbol(sc))
                        {
                            ey = ev;
                        }
                        else if (!ev->implicitConvTo(ie->type) && sd->ctor)
                        {
                            // Look for implicit constructor call
                            // Rewrite as S().ctor(e2)
                            ey = new StructLiteralExp(exp->loc, sd, NULL);
                            ey = new DotIdExp(exp->loc, ey, Id::ctor);
                            ey = new CallExp(exp->loc, ey, ev);
                            ey = trySemantic(ey, sc);
                        }
                        if (ey)
                        {
                            Expression *ex;
                            ex = new IndexExp(exp->loc, ea, ek);
                            ex = expressionSemantic(ex, sc);
                            ex = ex->optimize(WANTvalue);
                            ex = ex->modifiableLvalue(sc, ex);  // allocate new slot
                            ey = new ConstructExp(exp->loc, ex, ey);
                            ey = expressionSemantic(ey, sc);
                            if (ey->op == TOKerror)
                            {
                                result = ey;
                                return;
                            }
                            ex = e;

                            // Bugzilla 14144: The whole expression should have the common type
                            // of opAssign() return and assigned AA entry.
                            // Even if there's no common type, expression should be typed as void.
                            Type *t = NULL;
                            if (!typeMerge(sc, TOKquestion, &t, &ex, &ey))
                            {
                                ex = new CastExp(ex->loc, ex, Type::tvoid);
                                ey = new CastExp(ey->loc, ey, Type::tvoid);
                            }
                            e = new CondExp(exp->loc, new InExp(exp->loc, ek, ea), ex, ey);
                        }
                        e = Expression::combine(e0, e);
                        e = expressionSemantic(e, sc);
                        result = e;
                        return;
                    }
                }
                else
                {
                    Expression *e = exp->op_overload(sc);
                    if (e)
                    {
                        result = e;
                        return;
                    }
                }
            }
            else
                assert(exp->op == TOKblit);

            exp->e1 = e1x;
            exp->e2 = e2x;
        }
        else if (t1->ty == Tclass)
        {
            // Disallow assignment operator overloads for same type
            if (exp->op == TOKassign && !exp->e2->implicitConvTo(exp->e1->type))
            {
                Expression *e = exp->op_overload(sc);
                if (e)
                {
                    result = e;
                    return;
                }
            }
        }
        else if (t1->ty == Tsarray)
        {
            // SliceExp cannot have static array type without context inference.
            assert(exp->e1->op != TOKslice);

            Expression *e1x = exp->e1;
            Expression *e2x = exp->e2;

            if (e2x->implicitConvTo(e1x->type))
            {
                if (exp->op != TOKblit &&
                    ((e2x->op == TOKslice && ((UnaExp *)e2x)->e1->isLvalue()) ||
                     (e2x->op == TOKcast  && ((UnaExp *)e2x)->e1->isLvalue()) ||
                     (e2x->op != TOKslice && e2x->isLvalue())))
                {
                    if (e1x->checkPostblit(sc, t1))
                        return setError();
                }

                // e2 matches to t1 because of the implicit length match, so
                if (isUnaArrayOp(e2x->op) || isBinArrayOp(e2x->op))
                {
                    // convert e1 to e1[]
                    // e.g. e1[] = a[] + b[];
                    SliceExp *sle = new SliceExp(e1x->loc, e1x, NULL, NULL);
                    sle->arrayop = true;
                    e1x = expressionSemantic(sle, sc);
                }
                else
                {
                    // convert e2 to t1 later
                    // e.g. e1 = [1, 2, 3];
                }
            }
            else
            {
                if (e2x->implicitConvTo(t1->nextOf()->arrayOf()) > MATCHnomatch)
                {
                    uinteger_t dim1 = ((TypeSArray *)t1)->dim->toInteger();
                    uinteger_t dim2 = dim1;
                    if (e2x->op == TOKarrayliteral)
                    {
                        ArrayLiteralExp *ale = (ArrayLiteralExp *)e2x;
                        dim2 = ale->elements ? ale->elements->length : 0;
                    }
                    else if (e2x->op == TOKslice)
                    {
                        Type *tx = toStaticArrayType((SliceExp *)e2x);
                        if (tx)
                            dim2 = ((TypeSArray *)tx)->dim->toInteger();
                    }
                    if (dim1 != dim2)
                    {
                        exp->error("mismatched array lengths, %d and %d", (int)dim1, (int)dim2);
                        return setError();
                    }
                }

                // May be block or element-wise assignment, so
                // convert e1 to e1[]
                if (exp->op != TOKassign)
                {
                    // If multidimensional static array, treat as one large array
                    dinteger_t dim = t1->numberOfElems(exp->loc);
                    e1x->type = t1->baseElemOf()->sarrayOf(dim);
                }
                SliceExp *sle = new SliceExp(e1x->loc, e1x, NULL, NULL);
                sle->arrayop = true;
                e1x = expressionSemantic(sle, sc);
            }
            if (e1x->op == TOKerror)
            {
                result = e1x;
                return;
            }
            if (e2x->op == TOKerror)
            {
                result = e2x;
                return;
            }

            exp->e1 = e1x;
            exp->e2 = e2x;
            t1 = e1x->type->toBasetype();
        }

        /* Check the mutability of e1.
        */
        if (exp->e1->op == TOKarraylength)
        {
            // e1 is not an lvalue, but we let code generator handle it
            ArrayLengthExp *ale = (ArrayLengthExp *)exp->e1;

            Expression *ale1x = ale->e1;
            ale1x = ale1x->modifiableLvalue(sc, exp->e1);
            if (ale1x->op == TOKerror)
            {
                result = ale1x;
                return;
            }
            ale->e1 = ale1x;

            Type *tn = ale->e1->type->toBasetype()->nextOf();
            checkDefCtor(ale->loc, tn);
            semanticTypeInfo(sc, tn);
        }
        else if (exp->e1->op == TOKslice)
        {
            Type *tn = exp->e1->type->nextOf();
            if (exp->op == TOKassign && !tn->isMutable())
            {
                exp->error("slice %s is not mutable", exp->e1->toChars());
                return setError();
            }

            // For conditional operator, both branches need conversion.
            SliceExp *se = (SliceExp *)exp->e1;
            while (se->e1->op == TOKslice)
                se = (SliceExp *)se->e1;
            if (se->e1->op == TOKquestion &&
                se->e1->type->toBasetype()->ty == Tsarray)
            {
                se->e1 = se->e1->modifiableLvalue(sc, exp->e1);
                if (se->e1->op == TOKerror)
                {
                    result = se->e1;
                    return;
                }
            }
        }
        else
        {
            Expression *e1x = exp->e1;

            // Try to do a decent error message with the expression
            // before it got constant folded
            if (e1x->op != TOKvar)
                e1x = e1x->optimize(WANTvalue);

            if (exp->op == TOKassign)
                e1x = e1x->modifiableLvalue(sc, e1old);

            if (e1x->op == TOKerror)
            {
                result = e1x;
                return;
            }
            exp->e1 = e1x;
        }

        /* Tweak e2 based on the type of e1.
        */
        Expression *e2x = exp->e2;
        Type *t2 = e2x->type->toBasetype();

        // If it is a array, get the element type. Note that it may be
        // multi-dimensional.
        Type *telem = t1;
        while (telem->ty == Tarray)
            telem = telem->nextOf();

        if (exp->e1->op == TOKslice &&
            t1->nextOf() && (telem->ty != Tvoid || e2x->op == TOKnull) &&
            e2x->implicitConvTo(t1->nextOf())
           )
        {
            // Check for block assignment. If it is of type void[], void[][], etc,
            // '= null' is the only allowable block assignment (Bug 7493)
            // memset
            exp->memset |= blockAssign;  // make it easy for back end to tell what this is
            e2x = e2x->implicitCastTo(sc, t1->nextOf());
            if (exp->op != TOKblit && e2x->isLvalue() &&
                exp->e1->checkPostblit(sc, t1->nextOf()))
                return setError();
        }
        else if (exp->e1->op == TOKslice &&
                 (t2->ty == Tarray || t2->ty == Tsarray) &&
                 t2->nextOf()->implicitConvTo(t1->nextOf()))
        {
            // Check element-wise assignment.

            /* If assigned elements number is known at compile time,
             * check the mismatch.
             */
            SliceExp *se1 = (SliceExp *)exp->e1;
            TypeSArray *tsa1 = (TypeSArray *)toStaticArrayType(se1);
            TypeSArray *tsa2 = NULL;
            if (e2x->op == TOKarrayliteral)
                tsa2 = (TypeSArray *)t2->nextOf()->sarrayOf(((ArrayLiteralExp *)e2x)->elements->length);
            else if (e2x->op == TOKslice)
                tsa2 = (TypeSArray *)toStaticArrayType((SliceExp *)e2x);
            else if (t2->ty == Tsarray)
                tsa2 = (TypeSArray *)t2;
            if (tsa1 && tsa2)
            {
                uinteger_t dim1 = tsa1->dim->toInteger();
                uinteger_t dim2 = tsa2->dim->toInteger();
                if (dim1 != dim2)
                {
                    exp->error("mismatched array lengths, %d and %d", (int)dim1, (int)dim2);
                    return setError();
                }
            }

            if (exp->op != TOKblit &&
                ((e2x->op == TOKslice && ((UnaExp *)e2x)->e1->isLvalue()) ||
                 (e2x->op == TOKcast  && ((UnaExp *)e2x)->e1->isLvalue()) ||
                 (e2x->op != TOKslice && e2x->isLvalue())))
            {
                if (exp->e1->checkPostblit(sc, t1->nextOf()))
                    return setError();
            }

            if (0 && global.params.warnings != DIAGNOSTICoff && !global.gag && exp->op == TOKassign &&
                e2x->op != TOKslice && e2x->op != TOKassign &&
                e2x->op != TOKarrayliteral && e2x->op != TOKstring &&
                !(e2x->op == TOKadd || e2x->op == TOKmin ||
                  e2x->op == TOKmul || e2x->op == TOKdiv ||
                  e2x->op == TOKmod || e2x->op == TOKxor ||
                  e2x->op == TOKand || e2x->op == TOKor  ||
                  e2x->op == TOKpow ||
                  e2x->op == TOKtilde || e2x->op == TOKneg))
            {
                const char* e1str = exp->e1->toChars();
                const char* e2str = e2x->toChars();
                exp->warning("explicit element-wise assignment %s = (%s)[] is better than %s = %s",
                    e1str, e2str, e1str, e2str);
            }

            Type *t2n = t2->nextOf();
            Type *t1n = t1->nextOf();
            int offset;
            if (t2n->equivalent(t1n) ||
                (t1n->isBaseOf(t2n, &offset) && offset == 0))
            {
                /* Allow copy of distinct qualifier elements.
                 * eg.
                 *  char[] dst;  const(char)[] src;
                 *  dst[] = src;
                 *
                 *  class C {}   class D : C {}
                 *  C[2] ca;  D[] da;
                 *  ca[] = da;
                 */
                if (isArrayOpValid(e2x))
                {
                    // Don't add CastExp to keep AST for array operations
                    e2x = e2x->copy();
                    e2x->type = exp->e1->type->constOf();
                }
                else
                    e2x = e2x->castTo(sc, exp->e1->type->constOf());
            }
            else
            {
                /* Bugzilla 15778: A string literal has an array type of immutable
                 * elements by default, and normally it cannot be convertible to
                 * array type of mutable elements. But for element-wise assignment,
                 * elements need to be const at best. So we should give a chance
                 * to change code unit size for polysemous string literal.
                 */
                if (e2x->op == TOKstring)
                    e2x = e2x->implicitCastTo(sc, exp->e1->type->constOf());
                else
                    e2x = e2x->implicitCastTo(sc, exp->e1->type);
            }
            if (t1n->toBasetype()->ty == Tvoid && t2n->toBasetype()->ty == Tvoid)
            {
                if (!sc->intypeof && sc->func && sc->func->setUnsafe())
                {
                    exp->error("cannot copy void[] to void[] in @safe code");
                    return setError();
                }
            }
        }
        else
        {
            if (0 && global.params.warnings != DIAGNOSTICoff && !global.gag && exp->op == TOKassign &&
                t1->ty == Tarray && t2->ty == Tsarray &&
                e2x->op != TOKslice &&
                t2->implicitConvTo(t1))
            {   // Disallow ar[] = sa (Converted to ar[] = sa[])
                // Disallow da   = sa (Converted to da   = sa[])
                const char* e1str = exp->e1->toChars();
                const char* e2str = e2x->toChars();
                const char* atypestr = exp->e1->op == TOKslice ? "element-wise" : "slice";
                exp->warning("explicit %s assignment %s = (%s)[] is better than %s = %s",
                    atypestr, e1str, e2str, e1str, e2str);
            }
            if (exp->op == TOKblit)
                e2x = e2x->castTo(sc, exp->e1->type);
            else
                e2x = e2x->implicitCastTo(sc, exp->e1->type);
        }
        if (e2x->op == TOKerror)
        {
            result = e2x;
            return;
        }
        exp->e2 = e2x;
        t2 = exp->e2->type->toBasetype();

        /* Look for array operations
        */
        if ((t2->ty == Tarray || t2->ty == Tsarray) && isArrayOpValid(exp->e2))
        {
            // Look for valid array operations
            if (!(exp->memset & blockAssign) && exp->e1->op == TOKslice &&
                (isUnaArrayOp(exp->e2->op) || isBinArrayOp(exp->e2->op)))
            {
                exp->type = exp->e1->type;
                if (exp->op == TOKconstruct) // Bugzilla 10282: tweak mutability of e1 element
                    exp->e1->type = exp->e1->type->nextOf()->mutableOf()->arrayOf();
                result = arrayOp(exp, sc);
                return;
            }

            // Drop invalid array operations in e2
            //  d = a[] + b[], d = (a[] + b[])[0..2], etc
            if (checkNonAssignmentArrayOp(exp->e2, !(exp->memset & blockAssign) && exp->op == TOKassign))
                return setError();

            // Remains valid array assignments
            //  d = d[], d = [1,2,3], etc
        }

        /* Don't allow assignment to classes that were allocated on the stack with:
         *      scope Class c = new Class();
         */

        if (exp->e1->op == TOKvar && exp->op == TOKassign)
        {
            VarExp *ve = (VarExp *)exp->e1;
            VarDeclaration *vd = ve->var->isVarDeclaration();
            if (vd && (vd->onstack || vd->mynew))
            {
                assert(t1->ty == Tclass);
                exp->error("cannot rebind scope variables");
            }
        }
        if (exp->e1->op == TOKvar && ((VarExp *)exp->e1)->var->ident == Id::ctfe)
        {
            exp->error("cannot modify compiler-generated variable __ctfe");
        }

        exp->type = exp->e1->type;
        assert(exp->type);
        Expression *res = exp->op == TOKassign ? exp->reorderSettingAAElem(sc) : exp;
        checkAssignEscape(sc, res, false);
        result = res;
    }

    void visit(CatAssignExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        //printf("CatAssignExp::semantic() %s\n", toChars());
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (exp->e1->op == TOKslice)
        {
            SliceExp *se = (SliceExp *)exp->e1;
            if (se->e1->type->toBasetype()->ty == Tsarray)
            {
                exp->error("cannot append to static array %s", se->e1->type->toChars());
                return setError();
            }
        }

        exp->e1 = exp->e1->modifiableLvalue(sc, exp->e1);
        if (exp->e1->op == TOKerror)
        {
            result = exp->e1;
            return;
        }
        if (exp->e2->op == TOKerror)
        {
            result = exp->e2;
            return;
        }

        if (checkNonAssignmentArrayOp(exp->e2))
            return setError();

        Type *tb1 = exp->e1->type->toBasetype();
        Type *tb1next = tb1->nextOf();
        Type *tb2 = exp->e2->type->toBasetype();

        if ((tb1->ty == Tarray) &&
            (tb2->ty == Tarray || tb2->ty == Tsarray) &&
            (exp->e2->implicitConvTo(exp->e1->type)
             || (tb2->nextOf()->implicitConvTo(tb1next) &&
                 (tb2->nextOf()->size(Loc()) == tb1next->size(Loc())))
            )
           )
        {
            // Append array
            if (exp->e1->checkPostblit(sc, tb1next))
                return setError();
            exp->e2 = exp->e2->castTo(sc, exp->e1->type);
        }
        else if ((tb1->ty == Tarray) &&
                 exp->e2->implicitConvTo(tb1next)
                )
        {
            // Append element
            if (exp->e2->checkPostblit(sc, tb2))
                return setError();
            exp->e2 = exp->e2->castTo(sc, tb1next);
            exp->e2 = doCopyOrMove(sc, exp->e2);
        }
        else if (tb1->ty == Tarray &&
                 (tb1next->ty == Tchar || tb1next->ty == Twchar) &&
                 exp->e2->type->ty != tb1next->ty &&
                 exp->e2->implicitConvTo(Type::tdchar)
                )
        {   // Append dchar to char[] or wchar[]
            exp->e2 = exp->e2->castTo(sc, Type::tdchar);

            /* Do not allow appending wchar to char[] because if wchar happens
             * to be a surrogate pair, nothing good can result.
             */
        }
        else
        {
            exp->error("cannot append type %s to type %s", tb2->toChars(), tb1->toChars());
            return setError();
        }
        if (exp->e2->checkValue())
            return setError();

        exp->type = exp->e1->type;
        result = exp->reorderSettingAAElem(sc);
    }

    void visit(PowAssignExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (exp->e1->checkReadModifyWrite(exp->op, exp->e2))
            return setError();

        assert(exp->e1->type && exp->e2->type);
        if (exp->e1->op == TOKslice || exp->e1->type->ty == Tarray || exp->e1->type->ty == Tsarray)
        {
            if (checkNonAssignmentArrayOp(exp->e1))
                return setError();

            // T[] ^^= ...
            if (exp->e2->implicitConvTo(exp->e1->type->nextOf()))
            {
                // T[] ^^= T
                exp->e2 = exp->e2->castTo(sc, exp->e1->type->nextOf());
            }
            else if (Expression *ex = typeCombine(exp, sc))
            {
                result = ex;
                return;
            }

            // Check element types are arithmetic
            Type *tb1 = exp->e1->type->nextOf()->toBasetype();
            Type *tb2 = exp->e2->type->toBasetype();
            if (tb2->ty == Tarray || tb2->ty == Tsarray)
                tb2 = tb2->nextOf()->toBasetype();

            if ( (tb1->isintegral() || tb1->isfloating()) &&
                 (tb2->isintegral() || tb2->isfloating()))
            {
                exp->type = exp->e1->type;
                result = arrayOp(exp, sc);
                return;
            }
        }
        else
        {
            exp->e1 = exp->e1->modifiableLvalue(sc, exp->e1);
        }

        if ((exp->e1->type->isintegral() || exp->e1->type->isfloating()) &&
            (exp->e2->type->isintegral() || exp->e2->type->isfloating()))
        {
            Expression *e0 = NULL;
            e = exp->reorderSettingAAElem(sc);
            e = Expression::extractLast(e, &e0);
            assert(e == exp);

            if (exp->e1->op == TOKvar)
            {
                // Rewrite: e1 = e1 ^^ e2
                e = new PowExp(exp->loc, exp->e1->syntaxCopy(), exp->e2);
                e = new AssignExp(exp->loc, exp->e1, e);
            }
            else
            {
                // Rewrite: ref tmp = e1; tmp = tmp ^^ e2
                VarDeclaration *v = copyToTemp(STCref, "__powtmp", exp->e1);
                Expression *de = new DeclarationExp(exp->e1->loc, v);
                VarExp *ve = new VarExp(exp->e1->loc, v);
                e = new PowExp(exp->loc, ve, exp->e2);
                e = new AssignExp(exp->loc, new VarExp(exp->e1->loc, v), e);
                e = new CommaExp(exp->loc, de, e);
            }
            e = Expression::combine(e0, e);
            e = expressionSemantic(e, sc);
            result = e;
            return;
        }
        result = exp->incompatibleTypes();
    }

    void visit(AddExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        Type *tb1 = exp->e1->type->toBasetype();
        Type *tb2 = exp->e2->type->toBasetype();

        bool err = false;
        if (tb1->ty == Tdelegate ||
            (tb1->ty == Tpointer && tb1->nextOf()->ty == Tfunction))
        {
            err |= exp->e1->checkArithmetic();
        }
        if (tb2->ty == Tdelegate ||
            (tb2->ty == Tpointer && tb2->nextOf()->ty == Tfunction))
        {
            err |= exp->e2->checkArithmetic();
        }
        if (err)
            return setError();

        if ((tb1->ty == Tpointer && exp->e2->type->isintegral()) ||
            (tb2->ty == Tpointer && exp->e1->type->isintegral()))
        {
            result = scaleFactor(exp, sc);
            return;
        }

        if (tb1->ty == Tpointer && tb2->ty == Tpointer)
        {
            result = exp->incompatibleTypes();
            return;
        }

        if (Expression *ex = typeCombine(exp, sc))
        {
            result = ex;
            return;
        }

        Type *tb = exp->type->toBasetype();
        if (tb->ty == Tarray || tb->ty == Tsarray)
        {
            if (!isArrayOpValid(exp))
            {
                exp->error("invalid array operation %s (possible missing [])", exp->toChars());
                return setError();
            }
            result = exp;
            return;
        }

        tb1 = exp->e1->type->toBasetype();
        if (!target.isVectorOpSupported(tb1, exp->op, tb2))
        {
            result = exp->incompatibleTypes();
            return;
        }
        if ((tb1->isreal() && exp->e2->type->isimaginary()) ||
            (tb1->isimaginary() && exp->e2->type->isreal()))
        {
            switch (exp->type->toBasetype()->ty)
            {
                case Tfloat32:
                case Timaginary32:
                    exp->type = Type::tcomplex32;
                    break;

                case Tfloat64:
                case Timaginary64:
                    exp->type = Type::tcomplex64;
                    break;

                case Tfloat80:
                case Timaginary80:
                    exp->type = Type::tcomplex80;
                    break;

                default:
                    assert(0);
            }
        }
        result = exp;
    }

    void visit(MinExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        Type *t1 = exp->e1->type->toBasetype();
        Type *t2 = exp->e2->type->toBasetype();

        bool err = false;
        if (t1->ty == Tdelegate ||
            (t1->ty == Tpointer && t1->nextOf()->ty == Tfunction))
        {
            err |= exp->e1->checkArithmetic();
        }
        if (t2->ty == Tdelegate ||
            (t2->ty == Tpointer && t2->nextOf()->ty == Tfunction))
        {
            err |= exp->e2->checkArithmetic();
        }
        if (err)
            return setError();

        if (t1->ty == Tpointer)
        {
            if (t2->ty == Tpointer)
            {
                // Need to divide the result by the stride
                // Replace (ptr - ptr) with (ptr - ptr) / stride
                d_int64 stride;

                // make sure pointer types are compatible
                if (Expression *ex = typeCombine(exp, sc))
                {
                    result = ex;
                    return;
                }

                exp->type = Type::tptrdiff_t;
                stride = t2->nextOf()->size();
                if (stride == 0)
                {
                    e = new IntegerExp(exp->loc, 0, Type::tptrdiff_t);
                }
                else
                {
                    e = new DivExp(exp->loc, exp, new IntegerExp(Loc(), stride, Type::tptrdiff_t));
                    e->type = Type::tptrdiff_t;
                }
            }
            else if (t2->isintegral())
                e = scaleFactor(exp, sc);
            else
            {
                exp->error("can't subtract %s from pointer", t2->toChars());
                e = new ErrorExp();
            }
            result = e;
            return;
        }
        if (t2->ty == Tpointer)
        {
            exp->type = exp->e2->type;
            exp->error("can't subtract pointer from %s", exp->e1->type->toChars());
            return setError();
        }

        if (Expression *ex = typeCombine(exp, sc))
        {
            result = ex;
            return;
        }

        Type *tb = exp->type->toBasetype();
        if (tb->ty == Tarray || tb->ty == Tsarray)
        {
            if (!isArrayOpValid(exp))
            {
                exp->error("invalid array operation %s (possible missing [])", exp->toChars());
                return setError();
            }
            result = exp;
            return;
        }

        t1 = exp->e1->type->toBasetype();
        t2 = exp->e2->type->toBasetype();
        if (!target.isVectorOpSupported(t1, exp->op, t2))
        {
            result = exp->incompatibleTypes();
            return;
        }
        if ((t1->isreal() && t2->isimaginary()) ||
            (t1->isimaginary() && t2->isreal()))
        {
            switch (exp->type->ty)
            {
                case Tfloat32:
                case Timaginary32:
                    exp->type = Type::tcomplex32;
                    break;

                case Tfloat64:
                case Timaginary64:
                    exp->type = Type::tcomplex64;
                    break;

                case Tfloat80:
                case Timaginary80:
                    exp->type = Type::tcomplex80;
                    break;

                default:
                    assert(0);
            }
        }
        result = exp;
    }

    void visit(CatExp *exp)
    {
        //printf("CatExp::semantic() %s\n", exp->toChars());
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        Type *tb1 = exp->e1->type->toBasetype();
        Type *tb2 = exp->e2->type->toBasetype();

        bool f1 = checkNonAssignmentArrayOp(exp->e1);
        bool f2 = checkNonAssignmentArrayOp(exp->e2);
        if (f1 || f2)
            return setError();

        /* BUG: Should handle things like:
         *      char c;
         *      c ~ ' '
         *      ' ' ~ c;
         */
        Type *tb1next = tb1->nextOf();
        Type *tb2next = tb2->nextOf();

        // Check for: array ~ array
        if (tb1next && tb2next &&
            (tb1next->implicitConvTo(tb2next) >= MATCHconst ||
             tb2next->implicitConvTo(tb1next) >= MATCHconst ||
             (exp->e1->op == TOKarrayliteral && exp->e1->implicitConvTo(tb2)) ||
             (exp->e2->op == TOKarrayliteral && exp->e2->implicitConvTo(tb1))
            )
           )
        {
            /* Bugzilla 9248: Here to avoid the case of:
             *    void*[] a = [cast(void*)1];
             *    void*[] b = [cast(void*)2];
             *    a ~ b;
             * becoming:
             *    a ~ [cast(void*)b];
             */

            /* Bugzilla 14682: Also to avoid the case of:
             *    int[][] a;
             *    a ~ [];
             * becoming:
             *    a ~ cast(int[])[];
             */
            goto Lpeer;
        }

        // Check for: array ~ element
        if ((tb1->ty == Tsarray || tb1->ty == Tarray) && tb2->ty != Tvoid)
        {
            if (exp->e1->op == TOKarrayliteral)
            {
                exp->e2 = exp->e2->isLvalue() ? callCpCtor(sc, exp->e2) : valueNoDtor(exp->e2);
                // Bugzilla 14686: Postblit call appears in AST, and this is
                // finally translated  to an ArrayLiteralExp in below otpimize().
            }
            else if (exp->e1->op == TOKstring)
            {
                // No postblit call exists on character (integer) value.
            }
            else
            {
                if (exp->e2->checkPostblit(sc, tb2))
                    return setError();
                // Postblit call will be done in runtime helper function
            }

            if (exp->e1->op == TOKarrayliteral && exp->e1->implicitConvTo(tb2->arrayOf()))
            {
                exp->e1 = exp->e1->implicitCastTo(sc, tb2->arrayOf());
                exp->type = tb2->arrayOf();
                goto L2elem;
            }
            if (exp->e2->implicitConvTo(tb1next) >= MATCHconvert)
            {
                exp->e2 = exp->e2->implicitCastTo(sc, tb1next);
                exp->type = tb1next->arrayOf();
            L2elem:
                if (tb2->ty == Tarray || tb2->ty == Tsarray)
                {
                    // Make e2 into [e2]
                    exp->e2 = new ArrayLiteralExp(exp->e2->loc, exp->type, exp->e2);
                }
                result = exp->optimize(WANTvalue);
                return;
            }
        }
        // Check for: element ~ array
        if ((tb2->ty == Tsarray || tb2->ty == Tarray) && tb1->ty != Tvoid)
        {
            if (exp->e2->op == TOKarrayliteral)
            {
                exp->e1 = exp->e1->isLvalue() ? callCpCtor(sc, exp->e1) : valueNoDtor(exp->e1);
            }
            else if (exp->e2->op == TOKstring)
            {
            }
            else
            {
                if (exp->e1->checkPostblit(sc, tb1))
                    return setError();
            }

            if (exp->e2->op == TOKarrayliteral && exp->e2->implicitConvTo(tb1->arrayOf()))
            {
                exp->e2 = exp->e2->implicitCastTo(sc, tb1->arrayOf());
                exp->type = tb1->arrayOf();
                goto L1elem;
            }
            if (exp->e1->implicitConvTo(tb2next) >= MATCHconvert)
            {
                exp->e1 = exp->e1->implicitCastTo(sc, tb2next);
                exp->type = tb2next->arrayOf();
            L1elem:
                if (tb1->ty == Tarray || tb1->ty == Tsarray)
                {
                    // Make e1 into [e1]
                    exp->e1 = new ArrayLiteralExp(exp->e1->loc, exp->type, exp->e1);
                }
                result = exp->optimize(WANTvalue);
                return;
            }
        }

    Lpeer:
        if ((tb1->ty == Tsarray || tb1->ty == Tarray) &&
            (tb2->ty == Tsarray || tb2->ty == Tarray) &&
            (tb1next->mod || tb2next->mod) &&
            (tb1next->mod != tb2next->mod)
           )
        {
            Type *t1 = tb1next->mutableOf()->constOf()->arrayOf();
            Type *t2 = tb2next->mutableOf()->constOf()->arrayOf();
            if (exp->e1->op == TOKstring && !((StringExp *)exp->e1)->committed)
                exp->e1->type = t1;
            else
                exp->e1 = exp->e1->castTo(sc, t1);
            if (exp->e2->op == TOKstring && !((StringExp *)exp->e2)->committed)
                exp->e2->type = t2;
            else
                exp->e2 = exp->e2->castTo(sc, t2);
        }

        if (Expression *ex = typeCombine(exp, sc))
        {
            result = ex;
            return;
        }
        exp->type = exp->type->toHeadMutable();

        Type *tb = exp->type->toBasetype();
        if (tb->ty == Tsarray)
            exp->type = tb->nextOf()->arrayOf();
        if (exp->type->ty == Tarray && tb1next && tb2next &&
            tb1next->mod != tb2next->mod)
        {
            exp->type = exp->type->nextOf()->toHeadMutable()->arrayOf();
        }
        if (Type *tbn = tb->nextOf())
        {
            if (exp->checkPostblit(sc, tbn))
                return setError();
        }
        Type *t1 = exp->e1->type->toBasetype();
        Type *t2 = exp->e2->type->toBasetype();
        if ((t1->ty == Tarray || t1->ty == Tsarray) &&
            (t2->ty == Tarray || t2->ty == Tsarray))
        {
            // Normalize to ArrayLiteralExp or StringExp as far as possible
            e = exp->optimize(WANTvalue);
        }
        else
        {
            //printf("(%s) ~ (%s)\n", exp->e1->toChars(), exp->e2->toChars());
            result = exp->incompatibleTypes();
            return;
        }
        result = e;
    }

    void visit(MulExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (Expression *ex = typeCombine(exp, sc))
        {
            result = ex;
            return;
        }

        Type *tb = exp->type->toBasetype();
        if (tb->ty == Tarray || tb->ty == Tsarray)
        {
            if (!isArrayOpValid(exp))
            {
                exp->error("invalid array operation %s (possible missing [])", exp->toChars());
                return setError();
            }
            result = exp;
            return;
        }

        if (exp->checkArithmeticBin())
            return setError();

        if (exp->type->isfloating())
        {
            Type *t1 = exp->e1->type;
            Type *t2 = exp->e2->type;

            if (t1->isreal())
            {
                exp->type = t2;
            }
            else if (t2->isreal())
            {
                exp->type = t1;
            }
            else if (t1->isimaginary())
            {
                if (t2->isimaginary())
                {

                    switch (t1->toBasetype()->ty)
                    {
                        case Timaginary32:
                            exp->type = Type::tfloat32;
                            break;

                        case Timaginary64:
                            exp->type = Type::tfloat64;
                            break;

                        case Timaginary80:
                            exp->type = Type::tfloat80;
                            break;

                        default:
                            assert(0);
                    }

                    // iy * iv = -yv
                    exp->e1->type = exp->type;
                    exp->e2->type = exp->type;
                    e = new NegExp(exp->loc, exp);
                    e = expressionSemantic(e, sc);
                    result = e;
                    return;
                }
                else
                    exp->type = t2;      // t2 is complex
            }
            else if (t2->isimaginary())
            {
                exp->type = t1;  // t1 is complex
            }
        }
        else if (!target.isVectorOpSupported(tb, exp->op, exp->e2->type->toBasetype()))
        {
            result = exp->incompatibleTypes();
            return;
        }
        result = exp;
    }

    void visit(DivExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (Expression *ex = typeCombine(exp, sc))
        {
            result = ex;
            return;
        }

        Type *tb = exp->type->toBasetype();
        if (tb->ty == Tarray || tb->ty == Tsarray)
        {
            if (!isArrayOpValid(exp))
            {
                exp->error("invalid array operation %s (possible missing [])", exp->toChars());
                return setError();
            }
            result = exp;
            return;
        }

        if (exp->checkArithmeticBin())
            return setError();

        if (exp->type->isfloating())
        {
            Type *t1 = exp->e1->type;
            Type *t2 = exp->e2->type;

            if (t1->isreal())
            {
                exp->type = t2;
                if (t2->isimaginary())
                {
                    // x/iv = i(-x/v)
                    exp->e2->type = t1;
                    e = new NegExp(exp->loc, exp);
                    e = expressionSemantic(e, sc);
                    result = e;
                    return;
                }
            }
            else if (t2->isreal())
            {
                exp->type = t1;
            }
            else if (t1->isimaginary())
            {
                if (t2->isimaginary())
                {
                    switch (t1->toBasetype()->ty)
                    {
                        case Timaginary32:
                            exp->type = Type::tfloat32;
                            break;

                        case Timaginary64:
                            exp->type = Type::tfloat64;
                            break;

                        case Timaginary80:
                            exp->type = Type::tfloat80;
                            break;

                        default:
                            assert(0);
                    }
                }
                else
                    exp->type = t2;      // t2 is complex
            }
            else if (t2->isimaginary())
            {
                exp->type = t1;  // t1 is complex
            }
        }
        else if (!target.isVectorOpSupported(tb, exp->op, exp->e2->type->toBasetype()))
        {
            result = exp->incompatibleTypes();
            return;
        }
        result = exp;
    }

    void visit(ModExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (Expression *ex = typeCombine(exp, sc))
        {
            result = ex;
            return;
        }

        Type *tb = exp->type->toBasetype();
        if (tb->ty == Tarray || tb->ty == Tsarray)
        {
            if (!isArrayOpValid(exp))
            {
                exp->error("invalid array operation %s (possible missing [])", exp->toChars());
                return setError();
            }
            result = exp;
            return;
        }
        if (!target.isVectorOpSupported(tb, exp->op, exp->e2->type->toBasetype()))
        {
            result = exp->incompatibleTypes();
            return;
        }

        if (exp->checkArithmeticBin())
            return setError();

        if (exp->type->isfloating())
        {
            exp->type = exp->e1->type;
            if (exp->e2->type->iscomplex())
            {
                exp->error("cannot perform modulo complex arithmetic");
                return setError();
            }
        }
        result = exp;
    }

    void visit(PowExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        //printf("PowExp::semantic() %s\n", exp->toChars());
        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (Expression *ex = typeCombine(exp, sc))
        {
            result = ex;
            return;
        }

        Type *tb = exp->type->toBasetype();
        if (tb->ty == Tarray || tb->ty == Tsarray)
        {
            if (!isArrayOpValid(exp))
            {
                exp->error("invalid array operation %s (possible missing [])", exp->toChars());
                return setError();
            }
            result = exp;
            return;
        }

        if (exp->checkArithmeticBin())
            return setError();

        if (!target.isVectorOpSupported(exp->e1->type->toBasetype(), exp->op, exp->e2->type->toBasetype()))
        {
            result = exp->incompatibleTypes();
            return;
        }

        // For built-in numeric types, there are several cases.
        // TODO: backend support, especially for  e1 ^^ 2.

        // First, attempt to fold the expression.
        e = exp->optimize(WANTvalue);
        if (e->op != TOKpow)
        {
            e = expressionSemantic(e, sc);
            result = e;
            return;
        }

        // Determine if we're raising to an integer power.
        sinteger_t intpow = 0;
        if (exp->e2->op == TOKint64 && ((sinteger_t)exp->e2->toInteger() == 2 || (sinteger_t)exp->e2->toInteger() == 3))
            intpow = exp->e2->toInteger();
        else if (exp->e2->op == TOKfloat64 && (exp->e2->toReal() == ldouble((sinteger_t)exp->e2->toReal())))
            intpow = (sinteger_t)(exp->e2->toReal());

        // Deal with x^^2, x^^3 immediately, since they are of practical importance.
        if (intpow == 2 || intpow == 3)
        {
            // Replace x^^2 with (tmp = x, tmp*tmp)
            // Replace x^^3 with (tmp = x, tmp*tmp*tmp)
            VarDeclaration *tmp = copyToTemp(0, "__powtmp", exp->e1);
            Expression *de = new DeclarationExp(exp->loc, tmp);
            Expression *ve = new VarExp(exp->loc, tmp);

            /* Note that we're reusing ve. This should be ok.
            */
            Expression *me = new MulExp(exp->loc, ve, ve);
            if (intpow == 3)
                me = new MulExp(exp->loc, me, ve);
            e = new CommaExp(exp->loc, de, me);
            e = expressionSemantic(e, sc);
            result = e;
            return;
        }

        Module *mmath = loadStdMath();
        if (!mmath)
        {
            //exp->error("requires std.math for ^^ operators");
            //fatal();

            // Leave handling of PowExp to the backend, or throw
            // an error gracefully if no backend support exists.
            if (Expression *ex = typeCombine(exp, sc))
            {
                result = ex;
                return;
            }
            result = exp;
            return;
        }
        e = new ScopeExp(exp->loc, mmath);

        if (exp->e2->op == TOKfloat64 && exp->e2->toReal() == CTFloat::half)
        {
            // Replace e1 ^^ 0.5 with .std.math.sqrt(x)
            e = new CallExp(exp->loc, new DotIdExp(exp->loc, e, Id::_sqrt), exp->e1);
        }
        else
        {
            // Replace e1 ^^ e2 with .std.math.pow(e1, e2)
            e = new CallExp(exp->loc, new DotIdExp(exp->loc, e, Id::_pow), exp->e1, exp->e2);
        }
        e = expressionSemantic(e, sc);
        result = e;
    }

    void visit(ShlExp *exp)
    {
        //printf("ShlExp::semantic(), type = %p\n", exp->type);
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (exp->checkIntegralBin())
            return setError();
        if (!target.isVectorOpSupported(exp->e1->type->toBasetype(), exp->op, exp->e2->type->toBasetype()))
        {
            result = exp->incompatibleTypes();
            return;
        }
        exp->e1 = integralPromotions(exp->e1, sc);
        if (exp->e2->type->toBasetype()->ty != Tvector)
            exp->e2 = exp->e2->castTo(sc, Type::tshiftcnt);

        exp->type = exp->e1->type;
        result = exp;
    }

    void visit(ShrExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (exp->checkIntegralBin())
            return setError();
        if (!target.isVectorOpSupported(exp->e1->type->toBasetype(), exp->op, exp->e2->type->toBasetype()))
        {
            result = exp->incompatibleTypes();
            return;
        }
        exp->e1 = integralPromotions(exp->e1, sc);
        if (exp->e2->type->toBasetype()->ty != Tvector)
            exp->e2 = exp->e2->castTo(sc, Type::tshiftcnt);

        exp->type = exp->e1->type;
        result = exp;
    }

    void visit(UshrExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (exp->checkIntegralBin())
            return setError();
        if (!target.isVectorOpSupported(exp->e1->type->toBasetype(), exp->op, exp->e2->type->toBasetype()))
        {
            result = exp->incompatibleTypes();
            return;
        }
        exp->e1 = integralPromotions(exp->e1, sc);
        if (exp->e2->type->toBasetype()->ty != Tvector)
            exp->e2 = exp->e2->castTo(sc, Type::tshiftcnt);

        exp->type = exp->e1->type;
        result = exp;
    }

    void visit(AndExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (exp->e1->type->toBasetype()->ty == Tbool &&
            exp->e2->type->toBasetype()->ty == Tbool)
        {
            exp->type = exp->e1->type;
            result = exp;
            return;
        }

        if (Expression *ex = typeCombine(exp, sc))
        {
            result = ex;
            return;
        }

        Type *tb = exp->type->toBasetype();
        if (tb->ty == Tarray || tb->ty == Tsarray)
        {
            if (!isArrayOpValid(exp))
            {
                exp->error("invalid array operation %s (possible missing [])", exp->toChars());
                return setError();
            }
            result = exp;
            return;
        }

        if (!target.isVectorOpSupported(tb, exp->op, exp->e2->type->toBasetype()))
        {
            result = exp->incompatibleTypes();
            return;
        }
        if (exp->checkIntegralBin())
            return setError();

        result = exp;
    }

    void visit(OrExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (exp->e1->type->toBasetype()->ty == Tbool &&
            exp->e2->type->toBasetype()->ty == Tbool)
        {
            exp->type = exp->e1->type;
            result = exp;
            return;
        }

        if (Expression *ex = typeCombine(exp, sc))
        {
            result = ex;
            return;
        }

        Type *tb = exp->type->toBasetype();
        if (tb->ty == Tarray || tb->ty == Tsarray)
        {
            if (!isArrayOpValid(exp))
            {
                exp->error("invalid array operation %s (possible missing [])", exp->toChars());
                return setError();
            }
            result = exp;
            return;
        }

        if (!target.isVectorOpSupported(tb, exp->op, exp->e2->type->toBasetype()))
        {
            result = exp->incompatibleTypes();
            return;
        }
        if (exp->checkIntegralBin())
            return setError();

        result = exp;
    }

    void visit(XorExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        if (exp->e1->type->toBasetype()->ty == Tbool &&
            exp->e2->type->toBasetype()->ty == Tbool)
        {
            exp->type = exp->e1->type;
            result = exp;
            return;
        }

        if (Expression *ex = typeCombine(exp, sc))
        {
            result = ex;
            return;
        }

        Type *tb = exp->type->toBasetype();
        if (tb->ty == Tarray || tb->ty == Tsarray)
        {
            if (!isArrayOpValid(exp))
            {
                exp->error("invalid array operation %s (possible missing [])", exp->toChars());
                return setError();
            }
            result = exp;
            return;
        }

        if (!target.isVectorOpSupported(tb, exp->op, exp->e2->type->toBasetype()))
        {
            result = exp->incompatibleTypes();
            return;
        }
        if (exp->checkIntegralBin())
            return setError();

        result = exp;
    }

    void visit(LogicalExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        setNoderefOperands(exp);

        Expression *e1x = expressionSemantic(exp->e1, sc);

        // for static alias this: https://issues.dlang.org/show_bug.cgi?id=17684
        if (e1x->op == TOKtype)
            e1x = resolveAliasThis(sc, e1x);

        e1x = resolveProperties(sc, e1x);
        e1x = e1x->toBoolean(sc);
        unsigned cs1 = sc->callSuper;

        if (sc->flags & SCOPEcondition)
        {
            /* If in static if, don't evaluate e2 if we don't have to.
            */
            e1x = e1x->optimize(WANTvalue);
            if (e1x->isBool(exp->op == TOKoror))
            {
                result = new IntegerExp(exp->loc, exp->op == TOKoror, Type::tbool);
                return;
            }
        }

        Expression *e2x = expressionSemantic(exp->e2, sc);
        sc->mergeCallSuper(exp->loc, cs1);

        // for static alias this: https://issues.dlang.org/show_bug.cgi?id=17684
        if (e2x->op == TOKtype)
            e2x = resolveAliasThis(sc, e2x);

        e2x = resolveProperties(sc, e2x);

        bool f1 = checkNonAssignmentArrayOp(e1x);
        bool f2 = checkNonAssignmentArrayOp(e2x);
        if (f1 || f2)
            return setError();

        // Unless the right operand is 'void', the expression is converted to 'bool'.
        if (e2x->type->ty != Tvoid)
            e2x = e2x->toBoolean(sc);

        if (e2x->op == TOKtype || e2x->op == TOKscope)
        {
            exp->error("%s is not an expression", exp->e2->toChars());
            return setError();
        }
        if (e1x->op == TOKerror || e1x->type->ty == Tnoreturn)
        {
            result = e1x;
            return;
        }
        if (e2x->op == TOKerror)
        {
            result = e2x;
            return;
        }

        // The result type is 'bool', unless the right operand has type 'void'.
        if (e2x->type->ty == Tvoid)
            exp->type = Type::tvoid;
        else
            exp->type = Type::tbool;

        exp->e1 = e1x;
        exp->e2 = e2x;
        result = exp;
    }

    void visit(InExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Expression *e = exp->op_overload(sc);
        if (e)
        {
            result = e;
            return;
        }

        Type *t2b = exp->e2->type->toBasetype();
        switch (t2b->ty)
        {
            case Taarray:
                {
                    TypeAArray *ta = (TypeAArray *)t2b;

                    // Special handling for array keys
                    if (!arrayTypeCompatible(exp->e1->loc, exp->e1->type, ta->index))
                    {
                        // Convert key to type of key
                        exp->e1 = exp->e1->implicitCastTo(sc, ta->index);
                    }

                    semanticTypeInfo(sc, ta->index);

                    // Return type is pointer to value
                    exp->type = ta->nextOf()->pointerTo();
                    break;
                }

            default:
                result = exp->incompatibleTypes();
                return;

            case Terror:
                return setError();
        }
        result = exp;
    }

    void visit(RemoveExp *e)
    {
        if (Expression *ex = binSemantic(e, sc))
        {
            result = ex;
            return;
        }
        result = e;
    }

    void visit(CmpExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        setNoderefOperands(exp);

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }
        Type *t1 = exp->e1->type->toBasetype();
        Type *t2 = exp->e2->type->toBasetype();
        if ((t1->ty == Tclass && exp->e2->op == TOKnull) ||
            (t2->ty == Tclass && exp->e1->op == TOKnull))
        {
            exp->error("do not use null when comparing class types");
            return setError();
        }

        Expression *e = exp->op_overload(sc);
        if (e)
        {
            if (!e->type->isscalar() && e->type->equals(exp->e1->type))
            {
                exp->error("recursive opCmp expansion");
                return setError();
            }
            if (e->op == TOKcall)
            {
                e = new CmpExp(exp->op, exp->loc, e, new IntegerExp(exp->loc, 0, Type::tint32));
                e = expressionSemantic(e, sc);
            }
            result = e;
            return;
        }

        if (Expression *ex = typeCombine(exp, sc))
        {
            result = ex;
            return;
        }

        bool f1 = checkNonAssignmentArrayOp(exp->e1);
        bool f2 = checkNonAssignmentArrayOp(exp->e2);
        if (f1 || f2)
            return setError();

        exp->type = Type::tbool;

        // Special handling for array comparisons
        t1 = exp->e1->type->toBasetype();
        t2 = exp->e2->type->toBasetype();
        if ((t1->ty == Tarray || t1->ty == Tsarray || t1->ty == Tpointer) &&
            (t2->ty == Tarray || t2->ty == Tsarray || t2->ty == Tpointer))
        {
            Type *t1next = t1->nextOf();
            Type *t2next = t2->nextOf();
            if (t1next->implicitConvTo(t2next) < MATCHconst &&
                t2next->implicitConvTo(t1next) < MATCHconst &&
                (t1next->ty != Tvoid && t2next->ty != Tvoid))
            {
                exp->error("array comparison type mismatch, %s vs %s", t1next->toChars(), t2next->toChars());
                return setError();
            }
            if ((t1->ty == Tarray || t1->ty == Tsarray) &&
                (t2->ty == Tarray || t2->ty == Tsarray))
            {
                semanticTypeInfo(sc, t1->nextOf());
            }
        }
        else if (t1->ty == Tstruct || t2->ty == Tstruct ||
                 (t1->ty == Tclass && t2->ty == Tclass))
        {
            if (t2->ty == Tstruct)
                exp->error("need member function opCmp() for %s %s to compare", t2->toDsymbol(sc)->kind(), t2->toChars());
            else
                exp->error("need member function opCmp() for %s %s to compare", t1->toDsymbol(sc)->kind(), t1->toChars());
            return setError();
        }
        else if (t1->iscomplex() || t2->iscomplex())
        {
            exp->error("compare not defined for complex operands");
            return setError();
        }
        else if (t1->ty == Taarray || t2->ty == Taarray)
        {
            exp->error("%s is not defined for associative arrays", Token::toChars(exp->op));
            return setError();
        }
        else if (!target.isVectorOpSupported(t1, exp->op, t2))
        {
            result = exp->incompatibleTypes();
            return;
        }
        else
        {
            bool r1 = exp->e1->checkValue();
            bool r2 = exp->e2->checkValue();
            if (r1 || r2)
                return setError();
        }

        TOK altop;
        switch (exp->op)
        {
            // Refer rel_integral[] table
            case TOKunord:  altop = TOKerror;       break;
            case TOKlg:     altop = TOKnotequal;    break;
            case TOKleg:    altop = TOKerror;       break;
            case TOKule:    altop = TOKle;          break;
            case TOKul:     altop = TOKlt;          break;
            case TOKuge:    altop = TOKge;          break;
            case TOKug:     altop = TOKgt;          break;
            case TOKue:     altop = TOKequal;       break;
            default:        altop = TOKreserved;    break;
        }
        if (altop == TOKerror &&
            (t1->ty == Tarray || t1->ty == Tsarray ||
             t2->ty == Tarray || t2->ty == Tsarray))
        {
            exp->error("`%s` is not defined for array comparisons", Token::toChars(exp->op));
            return setError();
        }
        if (altop != TOKreserved)
        {
            if (!t1->isfloating())
            {
                if (altop == TOKerror)
                {
                    const char *s = exp->op == TOKunord ? "false" : "true";
                    exp->error("floating point operator `%s` always returns %s for non-floating comparisons",
                        Token::toChars(exp->op), s);
                }
                else
                {
                    exp->error("use `%s` for non-floating comparisons rather than floating point operator `%s`",
                        Token::toChars(altop), Token::toChars(exp->op));
                }
            }
            else
            {
                exp->error("use std.math.isNaN to deal with NaN operands rather than floating point operator `%s`",
                    Token::toChars(exp->op));
            }
            return setError();
        }

        //printf("CmpExp: %s, type = %s\n", e->toChars(), e->type->toChars());
        result = exp;
    }

    void visit(EqualExp *exp)
    {
        //printf("EqualExp::semantic('%s')\n", toChars());
        if (exp->type)
        {
            result = exp;
            return;
        }

        setNoderefOperands(exp);

        if (Expression *e = binSemanticProp(exp, sc))
        {
            result = e;
            return;
        }
        if (exp->e1->op == TOKtype || exp->e2->op == TOKtype)
        {
            result = exp->incompatibleTypes();
            return;
        }

        {
            Type *t1 = exp->e1->type;
            Type *t2 = exp->e2->type;
            if (t1->ty == Tenum && t2->ty == Tenum && !t1->equivalent(t2))
                exp->deprecation("Comparison between different enumeration types `%s` and `%s`; If this behavior is intended consider using `std.conv.asOriginalType`",
                    t1->toChars(), t2->toChars());
        }

        /* Before checking for operator overloading, check to see if we're
         * comparing the addresses of two statics. If so, we can just see
         * if they are the same symbol.
         */
        if (exp->e1->op == TOKaddress && exp->e2->op == TOKaddress)
        {
            AddrExp *ae1 = (AddrExp *)exp->e1;
            AddrExp *ae2 = (AddrExp *)exp->e2;
            if (ae1->e1->op == TOKvar && ae2->e1->op == TOKvar)
            {
                VarExp *ve1 = (VarExp *)ae1->e1;
                VarExp *ve2 = (VarExp *)ae2->e1;

                if (ve1->var == ve2->var)
                {
                    // They are the same, result is 'true' for ==, 'false' for !=
                    result = new IntegerExp(exp->loc, (exp->op == TOKequal), Type::tbool);
                    return;
                }
            }
        }

        if (Expression *e = exp->op_overload(sc))
        {
            result = e;
            return;
        }

        if (Expression *e = typeCombine(exp, sc))
        {
            result = e;
            return;
        }

        bool f1 = checkNonAssignmentArrayOp(exp->e1);
        bool f2 = checkNonAssignmentArrayOp(exp->e2);
        if (f1 || f2)
            return setError();

        exp->type = Type::tbool;

        // Special handling for array comparisons
        if (!arrayTypeCompatible(exp->loc, exp->e1->type, exp->e2->type))
        {
            if (exp->e1->type != exp->e2->type && exp->e1->type->isfloating() && exp->e2->type->isfloating())
            {
                // Cast both to complex
                exp->e1 = exp->e1->castTo(sc, Type::tcomplex80);
                exp->e2 = exp->e2->castTo(sc, Type::tcomplex80);
            }
        }
        if (exp->e1->type->toBasetype()->ty == Taarray)
            semanticTypeInfo(sc, exp->e1->type->toBasetype());

        Type *t1 = exp->e1->type->toBasetype();
        Type *t2 = exp->e2->type->toBasetype();

        if (!target.isVectorOpSupported(t1, exp->op, t2))
        {
            result = exp->incompatibleTypes();
            return;
        }

        result = exp;
    }

    void visit(IdentityExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        setNoderefOperands(exp);

        if (Expression *ex = binSemanticProp(exp, sc))
        {
            result = ex;
            return;
        }

        if (Expression *ex = typeCombine(exp, sc))
        {
            result = ex;
            return;
        }

        bool f1 = checkNonAssignmentArrayOp(exp->e1);
        bool f2 = checkNonAssignmentArrayOp(exp->e2);
        if (f1 || f2)
            return setError();

        if (exp->e1->op == TOKtype || exp->e2->op == TOKtype)
        {
            result = exp->incompatibleTypes();
            return;
        }

        exp->type = Type::tbool;

        if (exp->e1->type != exp->e2->type && exp->e1->type->isfloating() && exp->e2->type->isfloating())
        {
            // Cast both to complex
            exp->e1 = exp->e1->castTo(sc, Type::tcomplex80);
            exp->e2 = exp->e2->castTo(sc, Type::tcomplex80);
        }

        Type *tb1 = exp->e1->type->toBasetype();
        Type *tb2 = exp->e2->type->toBasetype();
        if (!target.isVectorOpSupported(tb1, exp->op, tb2))
        {
            result = exp->incompatibleTypes();
            return;
        }

        result = exp;
    }

    void visit(CondExp *exp)
    {
        if (exp->type)
        {
            result = exp;
            return;
        }

        if (exp->econd->op == TOKdotid)
            ((DotIdExp *)exp->econd)->noderef = true;

        Expression *ec = expressionSemantic(exp->econd, sc);
        ec = resolveProperties(sc, ec);
        ec = ec->toBoolean(sc);

        unsigned cs0 = sc->callSuper;
        unsigned *fi0 = sc->saveFieldInit();
        Expression *e1x = expressionSemantic(exp->e1, sc);
        e1x = resolveProperties(sc, e1x);

        unsigned cs1 = sc->callSuper;
        unsigned *fi1 = sc->fieldinit;
        sc->callSuper = cs0;
        sc->fieldinit = fi0;
        Expression *e2x = expressionSemantic(exp->e2, sc);
        e2x = resolveProperties(sc, e2x);

        sc->mergeCallSuper(exp->loc, cs1);
        sc->mergeFieldInit(exp->loc, fi1);

        if (ec->op == TOKerror)
        {
            result = ec;
            return;
        }
        if (ec->type == Type::terror)
            return setError();
        exp->econd = ec;

        if (e1x->op == TOKerror)
        {
            result = e1x;
            return;
        }
        if (e1x->type == Type::terror)
            return setError();
        exp->e1 = e1x;

        if (e2x->op == TOKerror)
        {
            result = e2x;
            return;
        }
        if (e2x->type == Type::terror)
            return setError();
        exp->e2 = e2x;

        bool f0 = checkNonAssignmentArrayOp(exp->econd);
        bool f1 = checkNonAssignmentArrayOp(exp->e1);
        bool f2 = checkNonAssignmentArrayOp(exp->e2);
        if (f0 || f1 || f2)
            return setError();

        Type *t1 = exp->e1->type;
        Type *t2 = exp->e2->type;
        if (t1->ty == Tnoreturn)
        {
            exp->type = t2;
        }
        else if (t2->ty == Tnoreturn)
        {
            exp->type = t1;
        }
        // If either operand is void the result is void, we have to cast both
        // the expression to void so that we explicitly discard the expression
        // value if any (bugzilla 16598)
        else if (t1->ty == Tvoid || t2->ty == Tvoid)
        {
            exp->type = Type::tvoid;
            exp->e1 = exp->e1->castTo(sc, exp->type);
            exp->e2 = exp->e2->castTo(sc, exp->type);
        }
        else if (t1 == t2)
            exp->type = t1;
        else
        {
            if (Expression *ex = typeCombine(exp, sc))
            {
                result = ex;
                return;
            }
            switch (exp->e1->type->toBasetype()->ty)
            {
                case Tcomplex32:
                case Tcomplex64:
                case Tcomplex80:
                    exp->e2 = exp->e2->castTo(sc, exp->e1->type);
                    break;
            }
            switch (exp->e2->type->toBasetype()->ty)
            {
                case Tcomplex32:
                case Tcomplex64:
                case Tcomplex80:
                    exp->e1 = exp->e1->castTo(sc, exp->e2->type);
                    break;
            }
            if (exp->type->toBasetype()->ty == Tarray)
            {
                exp->e1 = exp->e1->castTo(sc, exp->type);
                exp->e2 = exp->e2->castTo(sc, exp->type);
            }
        }
        exp->type = exp->type->merge2();

        /* Bugzilla 14696: If either e1 or e2 contain temporaries which need dtor,
         * make them conditional.
         * Rewrite:
         *      cond ? (__tmp1 = ..., __tmp1) : (__tmp2 = ..., __tmp2)
         * to:
         *      (auto __cond = cond) ? (... __tmp1) : (... __tmp2)
         * and replace edtors of __tmp1 and __tmp2 with:
         *      __tmp1->edtor --> __cond && __tmp1.dtor()
         *      __tmp2->edtor --> __cond || __tmp2.dtor()
         */
        exp->hookDtors(sc);

        result = exp;
    }

    void visit(FileInitExp *e)
    {
        //printf("FileInitExp::semantic()\n");
        e->type = Type::tstring;
        result = e;
    }

    void visit(LineInitExp *e)
    {
        e->type = Type::tint32;
        result = e;
    }

    void visit(ModuleInitExp *e)
    {
        //printf("ModuleInitExp::semantic()\n");
        e->type = Type::tstring;
        result = e;
    }

    void visit(FuncInitExp *e)
    {
        //printf("FuncInitExp::semantic()\n");
        e->type = Type::tstring;
        if (sc->func)
        {
            result = e->resolveLoc(Loc(), sc);
            return;
        }
        result = e;
    }

    void visit(PrettyFuncInitExp *e)
    {
        //printf("PrettyFuncInitExp::semantic()\n");
        e->type = Type::tstring;
        if (sc->func)
        {
            result = e->resolveLoc(Loc(), sc);
            return;
        }
        result = e;
    }
};

/**********************************
 * Try to run semantic routines.
 * If they fail, return NULL.
 */
Expression *trySemantic(Expression *exp, Scope* sc)
{
    //printf("+trySemantic(%s)\n", toChars());
    unsigned errors = global.startGagging();
    Expression *e = expressionSemantic(exp, sc);
    if (global.endGagging(errors))
    {
        e = NULL;
    }
    //printf("-trySemantic(%s)\n", toChars());
    return e;
}

/**************************
 * Helper function for easy error propagation.
 * If error occurs, returns ErrorExp. Otherwise returns NULL.
 */
Expression *unaSemantic(UnaExp *e, Scope *sc)
{
    Expression *e1x = expressionSemantic(e->e1, sc);
    if (e1x->op == TOKerror)
        return e1x;
    e->e1 = e1x;
    return NULL;
}

/**************************
 * Helper function for easy error propagation.
 * If error occurs, returns ErrorExp. Otherwise returns NULL.
 */
Expression *binSemantic(BinExp *e, Scope *sc)
{
    Expression *e1x = expressionSemantic(e->e1, sc);
    Expression *e2x = expressionSemantic(e->e2, sc);

    // for static alias this: https://issues.dlang.org/show_bug.cgi?id=17684
    if (e1x->op == TOKtype)
        e1x = resolveAliasThis(sc, e1x);
    if (e2x->op == TOKtype)
        e2x = resolveAliasThis(sc, e2x);

    if (e1x->op == TOKerror)
        return e1x;
    if (e2x->op == TOKerror)
        return e2x;
    e->e1 = e1x;
    e->e2 = e2x;
    return NULL;
}

Expression *binSemanticProp(BinExp *e, Scope *sc)
{
    if (Expression *ex = binSemantic(e, sc))
        return ex;
    Expression *e1x = resolveProperties(sc, e->e1);
    Expression *e2x = resolveProperties(sc, e->e2);
    if (e1x->op == TOKerror)
        return e1x;
    if (e2x->op == TOKerror)
        return e2x;
    e->e1 = e1x;
    e->e2 = e2x;
    return NULL;
}

// entrypoint for semantic ExpressionSemanticVisitor
Expression *expressionSemantic(Expression *e, Scope *sc)
{
    ExpressionSemanticVisitor v = ExpressionSemanticVisitor(sc);
    e->accept(&v);
    return v.result;
}

Expression *semanticX(DotIdExp *exp, Scope *sc)
{
    //printf("DotIdExp::semanticX(this = %p, '%s')\n", this, toChars());
    if (Expression *ex = unaSemantic(exp, sc))
        return ex;

    if (exp->ident == Id::_mangleof)
    {
        // symbol.mangleof
        Dsymbol *ds;
        switch (exp->e1->op)
        {
            case TOKscope:
                ds = ((ScopeExp *)exp->e1)->sds;
                goto L1;
            case TOKvar:
                ds = ((VarExp *)exp->e1)->var;
                goto L1;
            case TOKdotvar:
                ds = ((DotVarExp *)exp->e1)->var;
                goto L1;
            case TOKoverloadset:
                ds = ((OverExp *)exp->e1)->vars;
                goto L1;
            case TOKtemplate:
                {
                    TemplateExp *te = (TemplateExp *)exp->e1;
                    ds = te->fd ? (Dsymbol *)te->fd : te->td;
                }
            L1:
                {
                    assert(ds);
                    if (FuncDeclaration *f = ds->isFuncDeclaration())
                    {
                        if (f->checkForwardRef(exp->loc))
                            return new ErrorExp();
                    }
                    OutBuffer buf;
                    mangleToBuffer(ds, &buf);
                    const char *s = buf.extractChars();
                    Expression *e = new StringExp(exp->loc, const_cast<char*>(s), strlen(s));
                    e = expressionSemantic(e, sc);
                    return e;
                }
            default:
                break;
        }
    }

    if (exp->e1->op == TOKvar && exp->e1->type->toBasetype()->ty == Tsarray && exp->ident == Id::length)
    {
        // bypass checkPurity
        return exp->e1->type->dotExp(sc, exp->e1, exp->ident, exp->noderef ? 2 : 0);
    }

    if (exp->e1->op == TOKdot)
    {
    }
    else
    {
        exp->e1 = resolvePropertiesX(sc, exp->e1);
    }
    if (exp->e1->op == TOKtuple && exp->ident == Id::offsetof)
    {
        /* 'distribute' the .offsetof to each of the tuple elements.
        */
        TupleExp *te = (TupleExp *)exp->e1;
        Expressions *exps = new Expressions();
        exps->setDim(te->exps->length);
        for (size_t i = 0; i < exps->length; i++)
        {
            Expression *e = (*te->exps)[i];
            e = expressionSemantic(e, sc);
            e = new DotIdExp(e->loc, e, Id::offsetof);
            (*exps)[i] = e;
        }
        // Don't evaluate te->e0 in runtime
        Expression *e = new TupleExp(exp->loc, NULL, exps);
        e = expressionSemantic(e, sc);
        return e;
    }
    if (exp->e1->op == TOKtuple && exp->ident == Id::length)
    {
        TupleExp *te = (TupleExp *)exp->e1;
        // Don't evaluate te->e0 in runtime
        Expression *e = new IntegerExp(exp->loc, te->exps->length, Type::tsize_t);
        return e;
    }

    // Bugzilla 14416: Template has no built-in properties except for 'stringof'.
    if ((exp->e1->op == TOKdottd || exp->e1->op == TOKtemplate) && exp->ident != Id::stringof)
    {
        exp->error("template %s does not have property `%s`", exp->e1->toChars(), exp->ident->toChars());
        return new ErrorExp();
    }

    if (!exp->e1->type)
    {
        exp->error("expression %s does not have property `%s`", exp->e1->toChars(), exp->ident->toChars());
        return new ErrorExp();
    }

    return exp;
}

// Resolve e1.ident without seeing UFCS.
// If flag == 1, stop "not a property" error and return NULL.
Expression *semanticY(DotIdExp *exp, Scope *sc, int flag)
{
    //printf("DotIdExp::semanticY(this = %p, '%s')\n", this, toChars());

    //{ static int z; fflush(stdout); if (++z == 10) *(char*)0=0; }

    /* Special case: rewrite this.id and super.id
     * to be classtype.id and baseclasstype.id
     * if we have no this pointer.
     */
    if ((exp->e1->op == TOKthis || exp->e1->op == TOKsuper) && !hasThis(sc))
    {
        if (AggregateDeclaration *ad = sc->getStructClassScope())
        {
            if (exp->e1->op == TOKthis)
            {
                exp->e1 = new TypeExp(exp->e1->loc, ad->type);
            }
            else
            {
                ClassDeclaration *cd = ad->isClassDeclaration();
                if (cd && cd->baseClass)
                    exp->e1 = new TypeExp(exp->e1->loc, cd->baseClass->type);
            }
        }
    }

    Expression *e = semanticX(exp, sc);
    if (e != exp)
        return e;

    Expression *eleft;
    Expression *eright;
    if (exp->e1->op == TOKdot)
    {
        DotExp *de = (DotExp *)exp->e1;
        eleft = de->e1;
        eright = de->e2;
    }
    else
    {
        eleft = NULL;
        eright = exp->e1;
    }

    Type *t1b = exp->e1->type->toBasetype();

    if (eright->op == TOKscope)        // also used for template alias's
    {
        ScopeExp *ie = (ScopeExp *)eright;
        int flags = SearchLocalsOnly;

        /* Disable access to another module's private imports.
         * The check for 'is sds our current module' is because
         * the current module should have access to its own imports.
         */
        if (ie->sds->isModule() && ie->sds != sc->_module)
            flags |= IgnorePrivateImports;
        if (sc->flags & SCOPEignoresymbolvisibility)
            flags |= IgnoreSymbolVisibility;
        Dsymbol *s = ie->sds->search(exp->loc, exp->ident, flags);
        /* Check for visibility before resolving aliases because public
         * aliases to private symbols are public.
         */
        if (s && !(sc->flags & SCOPEignoresymbolvisibility) && !symbolIsVisible(sc->_module, s))
        {
            s = NULL;
        }
        if (s)
        {
            Package *p = s->isPackage();
            if (p && checkAccess(sc, p))
            {
                s = NULL;
            }
        }
        if (s)
        {
            // if 's' is a tuple variable, the tuple is returned.
            s = s->toAlias();

            exp->checkDeprecated(sc, s);
            exp->checkDisabled(sc, s);

            EnumMember *em = s->isEnumMember();
            if (em)
            {
                return em->getVarExp(exp->loc, sc);
            }

            VarDeclaration *v = s->isVarDeclaration();
            if (v)
            {
                //printf("DotIdExp:: Identifier '%s' is a variable, type '%s'\n", toChars(), v->type->toChars());
                if (!v->type ||
                    (!v->type->deco && v->inuse))
                {
                    if (v->inuse)
                        exp->error("circular reference to %s `%s`", v->kind(), v->toPrettyChars());
                    else
                        exp->error("forward reference to %s `%s`", v->kind(), v->toPrettyChars());
                    return new ErrorExp();
                }
                if (v->type->ty == Terror)
                    return new ErrorExp();

                if ((v->storage_class & STCmanifest) && v->_init && !exp->wantsym)
                {
                    /* Normally, the replacement of a symbol with its initializer is supposed to be in semantic2().
                     * Introduced by https://github.com/dlang/dmd/pull/5588 which should probably
                     * be reverted. `wantsym` is the hack to work around the problem.
                     */
                    if (v->inuse)
                    {
                        ::error(exp->loc, "circular initialization of %s `%s`", v->kind(), v->toPrettyChars());
                        return new ErrorExp();
                    }
                    e = v->expandInitializer(exp->loc);
                    v->inuse++;
                    e = expressionSemantic(e, sc);
                    v->inuse--;
                    return e;
                }

                if (v->needThis())
                {
                    if (!eleft)
                        eleft = new ThisExp(exp->loc);
                    e = new DotVarExp(exp->loc, eleft, v);
                    e = expressionSemantic(e, sc);
                }
                else
                {
                    e = new VarExp(exp->loc, v);
                    if (eleft)
                    {   e = new CommaExp(exp->loc, eleft, e);
                        e->type = v->type;
                    }
                }
                e = e->deref();
                return expressionSemantic(e, sc);
            }

            FuncDeclaration *f = s->isFuncDeclaration();
            if (f)
            {
                //printf("it's a function\n");
                if (!f->functionSemantic())
                    return new ErrorExp();
                if (f->needThis())
                {
                    if (!eleft)
                        eleft = new ThisExp(exp->loc);
                    e = new DotVarExp(exp->loc, eleft, f, true);
                    e = expressionSemantic(e, sc);
                }
                else
                {
                    e = new VarExp(exp->loc, f, true);
                    if (eleft)
                    {   e = new CommaExp(exp->loc, eleft, e);
                        e->type = f->type;
                    }
                }
                return e;
            }
            if (TemplateDeclaration *td = s->isTemplateDeclaration())
            {
                if (eleft)
                    e = new DotTemplateExp(exp->loc, eleft, td);
                else
                    e = new TemplateExp(exp->loc, td);
                e = expressionSemantic(e, sc);
                return e;
            }
            if (OverDeclaration *od = s->isOverDeclaration())
            {
                e = new VarExp(exp->loc, od, true);
                if (eleft)
                {
                    e = new CommaExp(exp->loc, eleft, e);
                    e->type = Type::tvoid;  // ambiguous type?
                }
                return e;
            }
            OverloadSet *o = s->isOverloadSet();
            if (o)
            {   //printf("'%s' is an overload set\n", o->toChars());
                return new OverExp(exp->loc, o);
            }

            if (Type *t = s->getType())
            {
                return expressionSemantic(new TypeExp(exp->loc, t), sc);
            }

            TupleDeclaration *tup = s->isTupleDeclaration();
            if (tup)
            {
                if (eleft)
                {
                    e = new DotVarExp(exp->loc, eleft, tup);
                    e = expressionSemantic(e, sc);
                    return e;
                }
                e = new TupleExp(exp->loc, tup);
                e = expressionSemantic(e, sc);
                return e;
            }

            ScopeDsymbol *sds = s->isScopeDsymbol();
            if (sds)
            {
                //printf("it's a ScopeDsymbol %s\n", exp->ident->toChars());
                e = new ScopeExp(exp->loc, sds);
                e = expressionSemantic(e, sc);
                if (eleft)
                    e = new DotExp(exp->loc, eleft, e);
                return e;
            }

            Import *imp = s->isImport();
            if (imp)
            {
                ie = new ScopeExp(exp->loc, imp->pkg);
                return expressionSemantic(ie, sc);
            }

            // BUG: handle other cases like in IdentifierExp::semantic()
            assert(0);
        }
        else if (exp->ident == Id::stringof)
        {
            const char *p = ie->toChars();
            e = new StringExp(exp->loc, const_cast<char *>(p), strlen(p));
            e = expressionSemantic(e, sc);
            return e;
        }
        if (ie->sds->isPackage() ||
            ie->sds->isImport() ||
            ie->sds->isModule())
        {
            flag = 0;
        }
        if (flag)
            return NULL;
        s = ie->sds->search_correct(exp->ident);
        if (s)
        {
            if (s->isPackage())
                exp->error("undefined identifier `%s` in %s `%s`, perhaps add `static import %s;`",
                    exp->ident->toChars(), ie->sds->kind(), ie->sds->toPrettyChars(), s->toPrettyChars());
            else
                exp->error("undefined identifier `%s` in %s `%s`, did you mean %s `%s`?",
                    exp->ident->toChars(), ie->sds->kind(), ie->sds->toPrettyChars(), s->kind(), s->toChars());
        }
        else
            exp->error("undefined identifier `%s` in %s `%s`",
                       exp->ident->toChars(), ie->sds->kind(), ie->sds->toPrettyChars());
        return new ErrorExp();
    }
    else if (t1b->ty == Tpointer && exp->e1->type->ty != Tenum &&
             exp->ident != Id::_init && exp->ident != Id::__sizeof &&
             exp->ident != Id::__xalignof && exp->ident != Id::offsetof &&
             exp->ident != Id::_mangleof && exp->ident != Id::stringof)
    {
        Type *t1bn = t1b->nextOf();
        if (flag)
        {
            AggregateDeclaration *ad = isAggregate(t1bn);
            if (ad && !ad->members)   // Bugzilla 11312
                return NULL;
        }

        /* Rewrite:
         *   p.ident
         * as:
         *   (*p).ident
         */
        if (flag && t1bn->ty == Tvoid)
            return NULL;
        e = new PtrExp(exp->loc, exp->e1);
        e = expressionSemantic(e, sc);
        return e->type->dotExp(sc, e, exp->ident, flag | (exp->noderef ? 2 : 0));
    }
    else
    {
        if (exp->e1->op == TOKtype || exp->e1->op == TOKtemplate)
            flag = 0;
        e = exp->e1->type->dotExp(sc, exp->e1, exp->ident, flag | (exp->noderef ? 2 : 0));
        if (e)
            e = expressionSemantic(e, sc);
        return e;
    }
}

// Resolve e1.ident!tiargs without seeing UFCS.
// If flag == 1, stop "not a property" error and return NULL.
Expression *semanticY(DotTemplateInstanceExp *exp, Scope *sc, int flag)
{
    DotIdExp *die = new DotIdExp(exp->loc, exp->e1, exp->ti->name);

    Expression *e = semanticX(die, sc);
    if (e == die)
    {
        exp->e1 = die->e1;   // take back

        Type *t1b = exp->e1->type->toBasetype();
        if (t1b->ty == Tarray || t1b->ty == Tsarray || t1b->ty == Taarray ||
            t1b->ty == Tnull  || (t1b->isTypeBasic() && t1b->ty != Tvoid))
        {
            /* No built-in type has templatized properties, so do shortcut.
             * It is necessary in: 1024.max!"a < b"
             */
            if (flag)
                return NULL;
        }
        e = semanticY(die, sc, flag);
        if (flag && e && isDotOpDispatch(e))
        {
            /* opDispatch!tiargs would be a function template that needs IFTI,
             * so it's not a template
             */
            e = NULL;   /* fall down to UFCS */
        }
        if (flag && !e)
            return NULL;
    }
    assert(e);

    if (e->op == TOKerror)
        return e;
    if (e->op == TOKdotvar)
    {
        DotVarExp *dve = (DotVarExp *)e;
        if (FuncDeclaration *fd = dve->var->isFuncDeclaration())
        {
            TemplateDeclaration *td = fd->findTemplateDeclRoot();
            if (td)
            {
                e = new DotTemplateExp(dve->loc, dve->e1, td);
                e = expressionSemantic(e, sc);
            }
        }
        else if (dve->var->isOverDeclaration())
        {
            exp->e1 = dve->e1;   // pull semantic() result
            if (!exp->findTempDecl(sc))
                goto Lerr;
            if (exp->ti->needsTypeInference(sc))
                return exp;
            dsymbolSemantic(exp->ti, sc);
            if (!exp->ti->inst || exp->ti->errors)    // if template failed to expand
                return new ErrorExp();
            Dsymbol *s = exp->ti->toAlias();
            Declaration *v = s->isDeclaration();
            if (v)
            {
                if (v->type && !v->type->deco)
                    v->type = typeSemantic(v->type, v->loc, sc);
                e = new DotVarExp(exp->loc, exp->e1, v);
                e = expressionSemantic(e, sc);
                return e;
            }
            e = new ScopeExp(exp->loc, exp->ti);
            e = new DotExp(exp->loc, exp->e1, e);
            e = expressionSemantic(e, sc);
            return e;
        }
    }
    else if (e->op == TOKvar)
    {
        VarExp *ve = (VarExp *)e;
        if (FuncDeclaration *fd = ve->var->isFuncDeclaration())
        {
            TemplateDeclaration *td = fd->findTemplateDeclRoot();
            if (td)
            {
                e = new TemplateExp(ve->loc, td);
                e = expressionSemantic(e, sc);
            }
        }
        else if (OverDeclaration *od = ve->var->isOverDeclaration())
        {
            exp->ti->tempdecl = od;
            e = new ScopeExp(exp->loc, exp->ti);
            e = expressionSemantic(e, sc);
            return e;
        }
    }
    if (e->op == TOKdottd)
    {
        DotTemplateExp *dte = (DotTemplateExp *)e;
        exp->e1 = dte->e1;   // pull semantic() result

        exp->ti->tempdecl = dte->td;
        if (!exp->ti->semanticTiargs(sc))
            return new ErrorExp();
        if (exp->ti->needsTypeInference(sc))
            return exp;
        dsymbolSemantic(exp->ti, sc);
        if (!exp->ti->inst || exp->ti->errors)    // if template failed to expand
            return new ErrorExp();
        Dsymbol *s = exp->ti->toAlias();
        Declaration *v = s->isDeclaration();
        if (v && (v->isFuncDeclaration() || v->isVarDeclaration()))
        {
            e = new DotVarExp(exp->loc, exp->e1, v);
            e = expressionSemantic(e, sc);
            return e;
        }
        e = new ScopeExp(exp->loc, exp->ti);
        e = new DotExp(exp->loc, exp->e1, e);
        e = expressionSemantic(e, sc);
        return e;
    }
    else if (e->op == TOKtemplate)
    {
        exp->ti->tempdecl = ((TemplateExp *)e)->td;
        e = new ScopeExp(exp->loc, exp->ti);
        e = expressionSemantic(e, sc);
        return e;
    }
    else if (e->op == TOKdot)
    {
        DotExp *de = (DotExp *)e;

        if (de->e2->op == TOKoverloadset)
        {
            if (!exp->findTempDecl(sc) ||
                !exp->ti->semanticTiargs(sc))
            {
                return new ErrorExp();
            }
            if (exp->ti->needsTypeInference(sc))
                return exp;
            dsymbolSemantic(exp->ti, sc);
            if (!exp->ti->inst || exp->ti->errors)    // if template failed to expand
                return new ErrorExp();
            Dsymbol *s = exp->ti->toAlias();
            Declaration *v = s->isDeclaration();
            if (v)
            {
                if (v->type && !v->type->deco)
                    v->type = typeSemantic(v->type, v->loc, sc);
                e = new DotVarExp(exp->loc, exp->e1, v);
                e = expressionSemantic(e, sc);
                return e;
            }
            e = new ScopeExp(exp->loc, exp->ti);
            e = new DotExp(exp->loc, exp->e1, e);
            e = expressionSemantic(e, sc);
            return e;
        }
    }
    else if (e->op == TOKoverloadset)
    {
        OverExp *oe = (OverExp *)e;
        exp->ti->tempdecl = oe->vars;
        e = new ScopeExp(exp->loc, exp->ti);
        e = expressionSemantic(e, sc);
        return e;
    }
Lerr:
    e->error("%s isn't a template", e->toChars());
    return new ErrorExp();
}