
/* 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/checkedint.h"
#include "mars.h"
#include "init.h"
#include "expression.h"
#include "statement.h"
#include "declaration.h"
#include "aggregate.h"
#include "scope.h"
#include "mtype.h"
#include "template.h"
#include "id.h"

FuncDeclaration *isFuncAddress(Expression *e, bool *hasOverloads = NULL);
Initializer *inferType(Initializer *init, Scope *sc);
bool hasNonConstPointers(Expression *e);

class InitializerSemanticVisitor : public Visitor
{
public:
    Initializer *result;
    Scope *sc;
    Type *t;
    NeedInterpret needInterpret;

    InitializerSemanticVisitor(Scope *sc, Type *t, NeedInterpret needInterpret)
    {
        this->result = NULL;
        this->sc = sc;
        this->t = t;
        this->needInterpret = needInterpret;
    }

    void visit(ErrorInitializer *i)
    {
        //printf("ErrorInitializer::semantic(t = %p)\n", t);
        result = i;
    }

    void visit(VoidInitializer *i)
    {
        //printf("VoidInitializer::semantic(t = %p)\n", t);
        i->type = t;
        result = i;
    }

    void visit(StructInitializer *i)
    {
        //printf("StructInitializer::semantic(t = %s) %s\n", t->toChars(), toChars());
        t = t->toBasetype();
        if (t->ty == Tsarray && t->nextOf()->toBasetype()->ty == Tstruct)
            t = t->nextOf()->toBasetype();
        if (t->ty == Tstruct)
        {
            StructDeclaration *sd = ((TypeStruct *)t)->sym;
            if (sd->ctor)
            {
                error(i->loc, "%s %s has constructors, cannot use { initializers }, use %s( initializers ) instead",
                      sd->kind(), sd->toChars(), sd->toChars());
                result = new ErrorInitializer();
                return;
            }
            sd->size(i->loc);
            if (sd->sizeok != SIZEOKdone)
            {
                result = new ErrorInitializer();
                return;
            }
            size_t nfields = sd->fields.length - sd->isNested();

            //expandTuples for non-identity arguments?

            Expressions *elements = new Expressions();
            elements->setDim(nfields);
            for (size_t j = 0; j < elements->length; j++)
                (*elements)[j] = NULL;

            // Run semantic for explicitly given initializers
            // TODO: this part is slightly different from StructLiteralExp::semantic.
            bool errors = false;
            for (size_t fieldi = 0, j = 0; j < i->field.length; j++)
            {
                if (Identifier *id = i->field[j])
                {
                    Dsymbol *s = sd->search(i->loc, id);
                    if (!s)
                    {
                        s = sd->search_correct(id);
                        if (s)
                            error(i->loc, "`%s` is not a member of `%s`, did you mean %s `%s`?",
                                  id->toChars(), sd->toChars(), s->kind(), s->toChars());
                        else
                            error(i->loc, "`%s` is not a member of `%s`", id->toChars(), sd->toChars());
                        result = new ErrorInitializer();
                        return;
                    }
                    s = s->toAlias();

                    // Find out which field index it is
                    for (fieldi = 0; 1; fieldi++)
                    {
                        if (fieldi >= nfields)
                        {
                            error(i->loc, "%s.%s is not a per-instance initializable field",
                                  sd->toChars(), s->toChars());
                            result = new ErrorInitializer();
                            return;
                        }
                        if (s == sd->fields[fieldi])
                            break;
                    }
                }
                else if (fieldi >= nfields)
                {
                    error(i->loc, "too many initializers for %s", sd->toChars());
                    result = new ErrorInitializer();
                    return;
                }

                VarDeclaration *vd = sd->fields[fieldi];
                if ((*elements)[fieldi])
                {
                    error(i->loc, "duplicate initializer for field `%s`", vd->toChars());
                    errors = true;
                    continue;
                }
                for (size_t k = 0; k < nfields; k++)
                {
                    VarDeclaration *v2 = sd->fields[k];
                    if (vd->isOverlappedWith(v2) && (*elements)[k])
                    {
                        error(i->loc, "overlapping initialization for field %s and %s",
                              v2->toChars(), vd->toChars());
                        errors = true;
                        continue;
                    }
                }

                assert(sc);
                Initializer *iz = i->value[j];
                iz = initializerSemantic(iz, sc, vd->type->addMod(t->mod), needInterpret);
                Expression *ex = initializerToExpression(iz);
                if (ex->op == TOKerror)
                {
                    errors = true;
                    continue;
                }
                i->value[j] = iz;
                (*elements)[fieldi] = doCopyOrMove(sc, ex);
                ++fieldi;
            }
            if (errors)
            {
                result = new ErrorInitializer();
                return;
            }

            StructLiteralExp *sle = new StructLiteralExp(i->loc, sd, elements, t);
            if (!sd->fill(i->loc, elements, false))
            {
                result = new ErrorInitializer();
                return;
            }
            sle->type = t;

            ExpInitializer *ie = new ExpInitializer(i->loc, sle);
            result = initializerSemantic(ie, sc, t, needInterpret);
            return;
        }
        else if ((t->ty == Tdelegate || (t->ty == Tpointer && t->nextOf()->ty == Tfunction)) && i->value.length == 0)
        {
            TOK tok = (t->ty == Tdelegate) ? TOKdelegate : TOKfunction;
            /* Rewrite as empty delegate literal { }
            */
            Type *tf = new TypeFunction(ParameterList(), NULL, LINKd);
            FuncLiteralDeclaration *fd = new FuncLiteralDeclaration(i->loc, Loc(), tf, tok, NULL);
            fd->fbody = new CompoundStatement(i->loc, new Statements());
            fd->endloc = i->loc;
            Expression *e = new FuncExp(i->loc, fd);
            ExpInitializer *ie = new ExpInitializer(i->loc, e);
            result = initializerSemantic(ie, sc, t, needInterpret);
            return;
        }

        error(i->loc, "a struct is not a valid initializer for a %s", t->toChars());
        result = new ErrorInitializer();
    }

    void visit(ArrayInitializer *i)
    {
        unsigned length;
        const unsigned amax = 0x80000000;
        bool errors = false;

        //printf("ArrayInitializer::semantic(%s)\n", t->toChars());
        if (i->sem)                            // if semantic() already run
        {
            result = i;
            return;
        }
        i->sem = true;
        t = t->toBasetype();
        switch (t->ty)
        {
            case Tsarray:
            case Tarray:
                break;

            case Tvector:
                t = ((TypeVector *)t)->basetype;
                break;

            case Taarray:
            case Tstruct:   // consider implicit constructor call
                {
                    Expression *e;
                    // note: MyStruct foo = [1:2, 3:4] is correct code if MyStruct has a this(int[int])
                    if (t->ty == Taarray || i->isAssociativeArray())
                        e = i->toAssocArrayLiteral();
                    else
                        e = initializerToExpression(i);
                    if (!e) // Bugzilla 13987
                    {
                        error(i->loc, "cannot use array to initialize %s", t->toChars());
                        goto Lerr;
                    }
                    ExpInitializer *ei = new ExpInitializer(e->loc, e);
                    result = initializerSemantic(ei, sc, t, needInterpret);
                    return;
                }
            case Tpointer:
                if (t->nextOf()->ty != Tfunction)
                    break;
                /* fall through */

            default:
                error(i->loc, "cannot use array to initialize %s", t->toChars());
                goto Lerr;
        }

        i->type = t;

        length = 0;
        for (size_t j = 0; j < i->index.length; j++)
        {
            Expression *idx = i->index[j];
            if (idx)
            {
                sc = sc->startCTFE();
                idx = expressionSemantic(idx, sc);
                sc = sc->endCTFE();
                idx = idx->ctfeInterpret();
                i->index[j] = idx;
                const uinteger_t idxvalue = idx->toInteger();
                if (idxvalue >= amax)
                {
                    error(i->loc, "array index %llu overflow", (ulonglong)idxvalue);
                    errors = true;
                }
                length = (unsigned)idx->toInteger();
                if (idx->op == TOKerror)
                    errors = true;
            }

            Initializer *val = i->value[j];
            ExpInitializer *ei = val->isExpInitializer();
            if (ei && !idx)
                ei->expandTuples = true;
            val = initializerSemantic(val, sc, t->nextOf(), needInterpret);
            if (val->isErrorInitializer())
                errors = true;

            ei = val->isExpInitializer();
            // found a tuple, expand it
            if (ei && ei->exp->op == TOKtuple)
            {
                TupleExp *te = (TupleExp *)ei->exp;
                i->index.remove(j);
                i->value.remove(j);

                for (size_t k = 0; k < te->exps->length; ++k)
                {
                    Expression *e = (*te->exps)[k];
                    i->index.insert(j + k, (Expression *)NULL);
                    i->value.insert(j + k, new ExpInitializer(e->loc, e));
                }
                j--;
                continue;
            }
            else
            {
                i->value[j] = val;
            }

            length++;
            if (length == 0)
            {
                error(i->loc, "array dimension overflow");
                goto Lerr;
            }
            if (length > i->dim)
                i->dim = length;
        }
        if (t->ty == Tsarray)
        {
            uinteger_t edim = ((TypeSArray *)t)->dim->toInteger();
            if (i->dim > edim)
            {
                error(i->loc, "array initializer has %u elements, but array length is %llu", i->dim, (ulonglong)edim);
                goto Lerr;
            }
        }
        if (errors)
            goto Lerr;
        else
        {
            d_uns64 sz = t->nextOf()->size();
            bool overflow = false;
            const d_uns64 max = mulu((d_uns64)i->dim, sz, overflow);
            if (overflow || max > amax)
            {
                error(i->loc, "array dimension %llu exceeds max of %llu", (ulonglong)i->dim, (ulonglong)(amax / sz));
                goto Lerr;
            }
            result = i;
            return;
        }

    Lerr:
        result = new ErrorInitializer();
    }

    void visit(ExpInitializer *i)
    {
        //printf("ExpInitializer::semantic(%s), type = %s\n", i->exp->toChars(), t->toChars());
        if (needInterpret) sc = sc->startCTFE();
        i->exp = expressionSemantic(i->exp, sc);
        i->exp = resolveProperties(sc, i->exp);
        if (needInterpret) sc = sc->endCTFE();
        if (i->exp->op == TOKerror)
        {
            result = new ErrorInitializer();
            return;
        }

        unsigned int olderrors = global.errors;
        if (needInterpret)
        {
            // If the result will be implicitly cast, move the cast into CTFE
            // to avoid premature truncation of polysemous types.
            // eg real [] x = [1.1, 2.2]; should use real precision.
            if (i->exp->implicitConvTo(t))
            {
                i->exp = i->exp->implicitCastTo(sc, t);
            }
            if (!global.gag && olderrors != global.errors)
            {
                result = i;
                return;
            }
            i->exp = i->exp->ctfeInterpret();
        }
        else
        {
            i->exp = i->exp->optimize(WANTvalue);
        }
        if (!global.gag && olderrors != global.errors)
        {
            result = i; // Failed, suppress duplicate error messages
            return;
        }

        if (i->exp->type->ty == Ttuple && ((TypeTuple *)i->exp->type)->arguments->length == 0)
        {
            Type *et = i->exp->type;
            i->exp = new TupleExp(i->exp->loc, new Expressions());
            i->exp->type = et;
        }
        if (i->exp->op == TOKtype)
        {
            i->exp->error("initializer must be an expression, not `%s`", i->exp->toChars());
            result = new ErrorInitializer();
            return;
        }

        // Make sure all pointers are constants
        if (needInterpret && hasNonConstPointers(i->exp))
        {
            i->exp->error("cannot use non-constant CTFE pointer in an initializer `%s`", i->exp->toChars());
            result = new ErrorInitializer();
            return;
        }

        Type *tb = t->toBasetype();
        Type *ti = i->exp->type->toBasetype();

        if (i->exp->op == TOKtuple && i->expandTuples && !i->exp->implicitConvTo(t))
        {
            result = new ExpInitializer(i->loc, i->exp);
            return;
        }

        /* Look for case of initializing a static array with a too-short
         * string literal, such as:
         *  char[5] foo = "abc";
         * Allow this by doing an explicit cast, which will lengthen the string
         * literal.
         */
        if (i->exp->op == TOKstring && tb->ty == Tsarray)
        {
            StringExp *se = (StringExp *)i->exp;
            Type *typeb = se->type->toBasetype();
            TY tynto = tb->nextOf()->ty;
            if (!se->committed &&
                (typeb->ty == Tarray || typeb->ty == Tsarray) &&
                (tynto == Tchar || tynto == Twchar || tynto == Tdchar) &&
                se->numberOfCodeUnits(tynto) < ((TypeSArray *)tb)->dim->toInteger())
            {
                i->exp = se->castTo(sc, t);
                goto L1;
            }
        }

        // Look for implicit constructor call
        if (tb->ty == Tstruct &&
            !(ti->ty == Tstruct && tb->toDsymbol(sc) == ti->toDsymbol(sc)) &&
            !i->exp->implicitConvTo(t))
        {
            StructDeclaration *sd = ((TypeStruct *)tb)->sym;
            if (sd->ctor)
            {
                // Rewrite as S().ctor(exp)
                Expression *e;
                e = new StructLiteralExp(i->loc, sd, NULL);
                e = new DotIdExp(i->loc, e, Id::ctor);
                e = new CallExp(i->loc, e, i->exp);
                e = expressionSemantic(e, sc);
                if (needInterpret)
                    i->exp = e->ctfeInterpret();
                else
                    i->exp = e->optimize(WANTvalue);
            }
        }

        // Look for the case of statically initializing an array
        // with a single member.
        if (tb->ty == Tsarray &&
            !tb->nextOf()->equals(ti->toBasetype()->nextOf()) &&
            i->exp->implicitConvTo(tb->nextOf())
           )
        {
            /* If the variable is not actually used in compile time, array creation is
             * redundant. So delay it until invocation of toExpression() or toDt().
             */
            t = tb->nextOf();
        }

        if (i->exp->implicitConvTo(t))
        {
            i->exp = i->exp->implicitCastTo(sc, t);
        }
        else
        {
            // Look for mismatch of compile-time known length to emit
            // better diagnostic message, as same as AssignExp::semantic.
            if (tb->ty == Tsarray &&
                i->exp->implicitConvTo(tb->nextOf()->arrayOf()) > MATCHnomatch)
            {
                uinteger_t dim1 = ((TypeSArray *)tb)->dim->toInteger();
                uinteger_t dim2 = dim1;
                if (i->exp->op == TOKarrayliteral)
                {
                    ArrayLiteralExp *ale = (ArrayLiteralExp *)i->exp;
                    dim2 = ale->elements ? ale->elements->length : 0;
                }
                else if (i->exp->op == TOKslice)
                {
                    Type *tx = toStaticArrayType((SliceExp *)i->exp);
                    if (tx)
                        dim2 = ((TypeSArray *)tx)->dim->toInteger();
                }
                if (dim1 != dim2)
                {
                    i->exp->error("mismatched array lengths, %d and %d", (int)dim1, (int)dim2);
                    i->exp = new ErrorExp();
                }
            }
            i->exp = i->exp->implicitCastTo(sc, t);
        }
    L1:
        if (i->exp->op == TOKerror)
        {
            result = i;
            return;
        }
        if (needInterpret)
            i->exp = i->exp->ctfeInterpret();
        else
            i->exp = i->exp->optimize(WANTvalue);
        //printf("-ExpInitializer::semantic(): "); i->exp->print();
        result = i;
    }
};

// Performs semantic analisys on Initializer AST nodes
Initializer *initializerSemantic(Initializer *init, Scope *sc, Type *t, NeedInterpret needInterpret)
{
    InitializerSemanticVisitor v = InitializerSemanticVisitor(sc, t, needInterpret);
    init->accept(&v);
    return v.result;
}

class InferTypeVisitor : public Visitor
{
public:
    Initializer *result;
    Scope *sc;

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

    void visit(ErrorInitializer *i)
    {
        result = i;
    }

    void visit(VoidInitializer *i)
    {
        error(i->loc, "cannot infer type from void initializer");
        result = new ErrorInitializer();
    }

    void visit(StructInitializer *i)
    {
        error(i->loc, "cannot infer type from struct initializer");
        result = new ErrorInitializer();
    }

    void visit(ArrayInitializer *init)
    {
        //printf("ArrayInitializer::inferType() %s\n", init->toChars());
        Expressions *keys = NULL;
        Expressions *values;
        if (init->isAssociativeArray())
        {
            keys = new Expressions();
            keys->setDim(init->value.length);
            values = new Expressions();
            values->setDim(init->value.length);

            for (size_t i = 0; i < init->value.length; i++)
            {
                Expression *e = init->index[i];
                if (!e)
                    goto Lno;
                (*keys)[i] = e;

                Initializer *iz = init->value[i];
                if (!iz)
                    goto Lno;
                iz = inferType(iz, sc);
                if (iz->isErrorInitializer())
                {
                    result = iz;
                    return;
                }
                assert(iz->isExpInitializer());
                (*values)[i] = ((ExpInitializer *)iz)->exp;
                assert((*values)[i]->op != TOKerror);
            }

            Expression *e = new AssocArrayLiteralExp(init->loc, keys, values);
            ExpInitializer *ei = new ExpInitializer(init->loc, e);
            result = inferType(ei, sc);
            return;
        }
        else
        {
            Expressions *elements = new Expressions();
            elements->setDim(init->value.length);
            elements->zero();

            for (size_t i = 0; i < init->value.length; i++)
            {
                assert(!init->index[i]);  // already asserted by isAssociativeArray()

                Initializer *iz = init->value[i];
                if (!iz)
                    goto Lno;
                iz = inferType(iz, sc);
                if (iz->isErrorInitializer())
                {
                    result = iz;
                    return;
                }
                assert(iz->isExpInitializer());
                (*elements)[i] = ((ExpInitializer *)iz)->exp;
                assert((*elements)[i]->op != TOKerror);
            }

            Expression *e = new ArrayLiteralExp(init->loc, NULL, elements);
            ExpInitializer *ei = new ExpInitializer(init->loc, e);
            result = inferType(ei, sc);
            return;
        }
    Lno:
        if (keys)
        {
            delete keys;
            delete values;
            error(init->loc, "not an associative array initializer");
        }
        else
        {
            error(init->loc, "cannot infer type from array initializer");
        }
        result = new ErrorInitializer();
    }

    void visit(ExpInitializer *init)
    {
        //printf("ExpInitializer::inferType() %s\n", init->toChars());
        init->exp = expressionSemantic(init->exp, sc);
        init->exp = resolveProperties(sc, init->exp);

        if (init->exp->op == TOKscope)
        {
            ScopeExp *se = (ScopeExp *)init->exp;
            TemplateInstance *ti = se->sds->isTemplateInstance();
            if (ti && ti->semanticRun == PASSsemantic && !ti->aliasdecl)
                se->error("cannot infer type from %s %s, possible circular dependency", se->sds->kind(), se->toChars());
            else
                se->error("cannot infer type from %s %s", se->sds->kind(), se->toChars());
            result = new ErrorInitializer();
            return;
        }

        // Give error for overloaded function addresses
        bool hasOverloads = false;
        if (FuncDeclaration *f = isFuncAddress(init->exp, &hasOverloads))
        {
            if (f->checkForwardRef(init->loc))
            {
                result = new ErrorInitializer();
                return;
            }

            if (hasOverloads && !f->isUnique())
            {
                init->exp->error("cannot infer type from overloaded function symbol %s", init->exp->toChars());
                result = new ErrorInitializer();
                return;
            }
        }
        if (init->exp->op == TOKaddress)
        {
            AddrExp *ae = (AddrExp *)init->exp;
            if (ae->e1->op == TOKoverloadset)
            {
                init->exp->error("cannot infer type from overloaded function symbol %s", init->exp->toChars());
                result = new ErrorInitializer();
                return;
            }
        }

        if (init->exp->op == TOKerror)
        {
            result = new ErrorInitializer();
            return;
        }
        if (!init->exp->type)
        {
            result = new ErrorInitializer();
            return;
        }
        result = init;
    }
};

/* Translates to an expression to infer type.
 * Returns ExpInitializer or ErrorInitializer.
 */
Initializer *inferType(Initializer *init, Scope *sc)
{
    InferTypeVisitor v = InferTypeVisitor(sc);
    init->accept(&v);
    return v.result;
}

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

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

    void visit(ErrorInitializer *)
    {
        result = new ErrorExp();
    }

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

    /***************************************
     * This works by transforming a struct initializer into
     * a struct literal. In the future, the two should be the
     * same thing.
     */
    void visit(StructInitializer *)
    {
        // cannot convert to an expression without target 'ad'
        result = NULL;
    }

    /********************************
     * If possible, convert array initializer to array literal.
     * Otherwise return NULL.
     */

    void visit(ArrayInitializer *init)
    {
        //printf("ArrayInitializer::toExpression(), dim = %d\n", init->length);
        //static int i; if (++i == 2) halt();

        Expressions *elements;
        unsigned edim;
        const unsigned amax = 0x80000000;
        Type *t = NULL;
        if (init->type)
        {
            if (init->type == Type::terror)
            {
                result = new ErrorExp();
                return;
            }

            t = init->type->toBasetype();
            switch (t->ty)
            {
                case Tvector:
                    t = ((TypeVector *)t)->basetype;
                    /* fall through */

                case Tsarray:
                    {
                        uinteger_t adim = ((TypeSArray *)t)->dim->toInteger();
                        if (adim >= amax)
                            goto Lno;
                        edim = (unsigned)adim;
                        break;
                    }

                case Tpointer:
                case Tarray:
                    edim = init->dim;
                    break;

                default:
                    assert(0);
            }
        }
        else
        {
            edim = (unsigned)init->value.length;
            for (size_t i = 0, j = 0; i < init->value.length; i++, j++)
            {
                if (init->index[i])
                {
                    if (init->index[i]->op == TOKint64)
                    {
                        const uinteger_t idxval = init->index[i]->toInteger();
                        if (idxval >= amax)
                            goto Lno;
                        j = (size_t)idxval;
                    }
                    else
                        goto Lno;
                }
                if (j >= edim)
                    edim = (unsigned)(j + 1);
            }
        }

        elements = new Expressions();
        elements->setDim(edim);
        elements->zero();
        for (size_t i = 0, j = 0; i < init->value.length; i++, j++)
        {
            if (init->index[i])
                j = (size_t)(init->index[i])->toInteger();
            assert(j < edim);
            Initializer *iz = init->value[i];
            if (!iz)
                goto Lno;
            Expression *ex = initializerToExpression(iz);
            if (!ex)
            {
                goto Lno;
            }
            (*elements)[j] = ex;
        }

        /* Fill in any missing elements with the default initializer
         */
        {
            Expression *_init = NULL;
            for (size_t i = 0; i < edim; i++)
            {
                if (!(*elements)[i])
                {
                    if (!init->type)
                        goto Lno;
                    if (!_init)
                        _init = ((TypeNext *)t)->next->defaultInit();
                    (*elements)[i] = _init;
                }
            }

            /* Expand any static array initializers that are a single expression
             * into an array of them
             */
            if (t)
            {
                Type *tn = t->nextOf()->toBasetype();
                if (tn->ty == Tsarray)
                {
                    size_t dim = ((TypeSArray *)tn)->dim->toInteger();
                    Type *te = tn->nextOf()->toBasetype();
                    for (size_t i = 0; i < elements->length; i++)
                    {
                        Expression *e = (*elements)[i];
                        if (te->equals(e->type))
                        {
                            Expressions *elements2 = new Expressions();
                            elements2->setDim(dim);
                            for (size_t j = 0; j < dim; j++)
                                (*elements2)[j] = e;
                            e = new ArrayLiteralExp(e->loc, tn, elements2);
                            (*elements)[i] = e;
                        }
                    }
                }
            }

            /* If any elements are errors, then the whole thing is an error
             */
            for (size_t i = 0; i < edim; i++)
            {
                Expression *e = (*elements)[i];
                if (e->op == TOKerror)
                {
                    result = e;
                    return;
                }
            }

            Expression *e = new ArrayLiteralExp(init->loc, init->type, elements);
            result = e;
            return;
        }

    Lno:
        result = NULL;
    }

    void visit(ExpInitializer *i)
    {
        if (itype)
        {
            //printf("ExpInitializer::toExpression(t = %s) exp = %s\n", itype->toChars(), i->exp->toChars());
            Type *tb = itype->toBasetype();
            Expression *e = (i->exp->op == TOKconstruct || i->exp->op == TOKblit) ? ((AssignExp *)i->exp)->e2 : i->exp;
            if (tb->ty == Tsarray && e->implicitConvTo(tb->nextOf()))
            {
                TypeSArray *tsa = (TypeSArray *)tb;
                size_t d = (size_t)tsa->dim->toInteger();
                Expressions *elements = new Expressions();
                elements->setDim(d);
                for (size_t j = 0; j < d; j++)
                    (*elements)[j] = e;
                ArrayLiteralExp *ae = new ArrayLiteralExp(e->loc, itype, elements);
                result = ae;
                return;
            }
        }
        result = i->exp;
    }
};

Expression *initializerToExpression(Initializer *i, Type *t)
{
    InitToExpressionVisitor v = InitToExpressionVisitor(t);
    i->accept(&v);
    return v.result;
}