root/branches/dmdfe/func.c

// Compiler implementation of the D programming language
// Copyright (c) 1999-2007 by Digital Mars
// All Rights Reserved
// written by Walter Bright
// http://www.digitalmars.com
// License for redistribution is by either the Artistic License
// in artistic.txt, or the GNU General Public License in gnu.txt.
// See the included readme.txt for details.

#include <stdio.h>
#include <assert.h>

#include "mars.h"
#include "init.h"
#include "declaration.h"
#include "attrib.h"
#include "expression.h"
#include "scope.h"
#include "mtype.h"
#include "aggregate.h"
#include "identifier.h"
#include "id.h"
#include "module.h"
#include "statement.h"
#include "template.h"
#include "hdrgen.h"

#ifdef IN_GCC
#include "d-dmd-gcc.h"
#endif

/********************************* FuncDeclaration ****************************/

FuncDeclaration::FuncDeclaration(Loc loc, Loc endloc, Identifier *id, enum STC storage_class, Type *type)
    : Declaration(id)
{
    this->storage_class = storage_class;
    this->type = type;
    this->loc = loc;
    this->endloc = endloc;
    fthrows = NULL;
    frequire = NULL;
    outId = NULL;
    vresult = NULL;
    returnLabel = NULL;
    fensure = NULL;
    fbody = NULL;
    localsymtab = NULL;
    vthis = NULL;
    v_arguments = NULL;
#if IN_GCC
    v_argptr = NULL;
#endif
    parameters = NULL;
    labtab = NULL;
    overnext = NULL;
    vtblIndex = -1;
    hasReturnExp = 0;
    naked = 0;
    inlineStatus = ILSuninitialized;
    inlineNest = 0;
    inlineAsm = 0;
    cantInterpret = 0;
    semanticRun = 0;
    nestedFrameRef = 0;
    fes = NULL;
    introducing = 0;
    tintro = NULL;
    inferRetType = (type && type->nextOf() == NULL);
    scope = NULL;
    hasReturnExp = 0;
    nrvo_can = 1;
    nrvo_var = NULL;
    shidden = NULL;
}

Dsymbol *FuncDeclaration::syntaxCopy(Dsymbol *s)
{
    FuncDeclaration *f;

    //printf("FuncDeclaration::syntaxCopy('%s')\n", toChars());
    if (s)
    f = (FuncDeclaration *)s;
    else
    f = new FuncDeclaration(loc, endloc, ident, (enum STC) storage_class, type->syntaxCopy());
    f->outId = outId;
    f->frequire = frequire ? frequire->syntaxCopy() : NULL;
    f->fensure  = fensure  ? fensure->syntaxCopy()  : NULL;
    f->fbody    = fbody    ? fbody->syntaxCopy()    : NULL;
    assert(!fthrows); // deprecated
    return f;
}


// Do the semantic analysis on the external interface to the function.

void FuncDeclaration::semantic(Scope *sc)
{   TypeFunction *f;
    StructDeclaration *sd;
    ClassDeclaration *cd;
    InterfaceDeclaration *id;

#if 0
    printf("FuncDeclaration::semantic(sc = %p, this = %p, '%s', linkage = %d)\n", sc, this, toPrettyChars(), sc->linkage);
    if (isFuncLiteralDeclaration())
    printf("\tFuncLiteralDeclaration()\n");
    printf("sc->parent = %s\n", sc->parent->toChars());
    printf("type: %s\n", type->toChars());
#endif

    if (type->nextOf())
    type = type->semantic(loc, sc);
    //type->print();
    if (type->ty != Tfunction)
    {
    error("%s must be a function", toChars());
    return;
    }
    f = (TypeFunction *)(type);
    size_t nparams = Argument::dim(f->parameters);

    linkage = sc->linkage;
//    if (!parent)
    {
    //parent = sc->scopesym;
    parent = sc->parent;
    }
    protection = sc->protection;
    storage_class |= sc->stc;
    //printf("function storage_class = x%x\n", storage_class);
    Dsymbol *parent = toParent();

    if (isConst() || isAuto() || isScope())
    error("functions cannot be const or auto");

    if (isAbstract() && !isVirtual())
    error("non-virtual functions cannot be abstract");
#if 0
    if (isAbstract() && fbody)
    error("abstract functions cannot have bodies");
#endif

#if 0
    if (isStaticConstructor() || isStaticDestructor())
    {
    if (!isStatic() || type->nextOf()->ty != Tvoid)
        error("static constructors / destructors must be static void");
    if (f->arguments && f->arguments->dim)
        error("static constructors / destructors must have empty parameter list");
    // BUG: check for invalid storage classes
    }
#endif

#ifdef IN_GCC
    AggregateDeclaration *ad;

    ad = parent->isAggregateDeclaration();
    if (ad)
    ad->methods.push(this);
#endif
    sd = parent->isStructDeclaration();
    if (sd)
    {
    // Verify no constructors, destructors, etc.
    if (isCtorDeclaration() ||
        isDtorDeclaration()
        //|| isInvariantDeclaration()
        //|| isUnitTestDeclaration()
       )
    {
        error("special member functions not allowed for %ss", sd->kind());
    }

#if 0
    if (!sd->inv)
        sd->inv = isInvariantDeclaration();

    if (!sd->aggNew)
        sd->aggNew = isNewDeclaration();

    if (isDelete())
    {
        if (sd->aggDelete)
        error("multiple delete's for struct %s", sd->toChars());
        sd->aggDelete = (DeleteDeclaration *)(this);
    }
#endif
    }

    id = parent->isInterfaceDeclaration();
    if (id)
    {
    storage_class |= STCabstract;

    if (isCtorDeclaration() ||
        isDtorDeclaration() ||
        isInvariantDeclaration() ||
        isUnitTestDeclaration() || isNewDeclaration() || isDelete())
        error("special function not allowed in interface %s", id->toChars());
    if (fbody)
        error("function body is not abstract in interface %s", id->toChars());
    }

    cd = parent->isClassDeclaration();
    if (cd)
    {   int vi;
    CtorDeclaration *ctor;
    DtorDeclaration *dtor;
    InvariantDeclaration *inv;

    if (isCtorDeclaration())
    {
//      ctor = (CtorDeclaration *)this;
//      if (!cd->ctor)
//      cd->ctor = ctor;
        return;
    }

#if 0
    dtor = isDtorDeclaration();
    if (dtor)
    {
        if (cd->dtor)
        error("multiple destructors for class %s", cd->toChars());
        cd->dtor = dtor;
    }

    inv = isInvariantDeclaration();
    if (inv)
    {
        cd->inv = inv;
    }

    if (isNewDeclaration())
    {
        if (!cd->aggNew)
        cd->aggNew = (NewDeclaration *)(this);
    }

    if (isDelete())
    {
        if (cd->aggDelete)
        error("multiple delete's for class %s", cd->toChars());
        cd->aggDelete = (DeleteDeclaration *)(this);
    }
#endif

    if (storage_class & STCabstract)
        cd->isabstract = 1;

    // if static function, do not put in vtbl[]
    if (!isVirtual())
    {
        //printf("\tnot virtual\n");
        return;
    }

    // Find index of existing function in vtbl[] to override
    if (cd->baseClass)
    {
        for (vi = 0; vi < cd->baseClass->vtbl.dim; vi++)
        {
        FuncDeclaration *fdv = ((Dsymbol *)cd->vtbl.data[vi])->isFuncDeclaration();

        // BUG: should give error if argument types match,
        // but return type does not?

        //printf("\tvtbl[%d] = '%s'\n", vi, fdv ? fdv->ident->toChars() : "");
        if (fdv && fdv->ident == ident)
        {
            int cov = type->covariant(fdv->type);
            //printf("\tbaseclass cov = %d\n", cov);
            if (cov == 2)
            {
            //type->print();
            //fdv->type->print();
            //printf("%s %s\n", type->deco, fdv->type->deco);
            error("of type %s overrides but is not covariant with %s of type %s",
                type->toChars(), fdv->toPrettyChars(), fdv->type->toChars());
            }
            if (cov == 1)
            {
            if (fdv->isFinal())
                error("cannot override final function %s", fdv->toPrettyChars());
            if (fdv->toParent() == parent)
            {
                // If both are mixins, then error.
                // If either is not, the one that is not overrides
                // the other.
                if (fdv->parent->isClassDeclaration())
                goto L1;
                if (!this->parent->isClassDeclaration()
#if !BREAKABI
                && !isDtorDeclaration()
#endif
                )
                error("multiple overrides of same function");
            }
            cd->vtbl.data[vi] = (void *)this;
            vtblIndex = vi;

            /* This works by whenever this function is called,
             * it actually returns tintro, which gets dynamically
             * cast to type. But we know that tintro is a base
             * of type, so we could optimize it by not doing a
             * dynamic cast, but just subtracting the isBaseOf()
             * offset if the value is != null.
             */

            if (fdv->tintro)
                tintro = fdv->tintro;
            else if (!type->equals(fdv->type))
            {
                /* Only need to have a tintro if the vptr
                 * offsets differ
                 */
                int offset;
                if (fdv->type->nextOf()->isBaseOf(type->nextOf(), &offset))
                {
                tintro = fdv->type;
                }
            }
            goto L1;
            }
            if (cov == 3)
            {
            cd->sizeok = 2; // can't finish due to forward reference
            return;
            }
        }
        }
    }

    // This is an 'introducing' function.

    // Verify this doesn't override previous final function
    if (cd->baseClass)
    {   Dsymbol *s = cd->baseClass->search(loc, ident, 0);
        if (s)
        {
        FuncDeclaration *f = s->isFuncDeclaration();
        f = f->overloadExactMatch(type);
        if (f && f->isFinal() && f->prot() != PROTprivate)
            error("cannot override final function %s", f->toPrettyChars());
        }
    }

    if (isFinal())
    {
        cd->vtblFinal.push(this);
    }
    else
    {
        // Append to end of vtbl[]
        //printf("\tintroducing function\n");
        introducing = 1;
        vi = cd->vtbl.dim;
        cd->vtbl.push(this);
        vtblIndex = vi;
    }

    L1: ;

    /* Go through all the interface bases.
     * If this function is covariant with any members of those interface
     * functions, set the tintro.
     */
    for (int i = 0; i < cd->interfaces_dim; i++)
    {
        BaseClass *b = cd->interfaces[i];
        for (vi = 0; vi < b->base->vtbl.dim; vi++)
        {
        Dsymbol *s = (Dsymbol *)b->base->vtbl.data[vi];
        //printf("interface %d vtbl[%d] %p %s\n", i, vi, s, s->toChars());
        FuncDeclaration *fdv = s->isFuncDeclaration();
        if (fdv && fdv->ident == ident)
        {
            int cov = type->covariant(fdv->type);
            //printf("\tcov = %d\n", cov);
            if (cov == 2)
            {
            //type->print();
            //fdv->type->print();
            //printf("%s %s\n", type->deco, fdv->type->deco);
            error("of type %s overrides but is not covariant with %s of type %s",
                type->toChars(), fdv->toPrettyChars(), fdv->type->toChars());
            }
            if (cov == 1)
            {   Type *ti = NULL;

            if (fdv->tintro)
                ti = fdv->tintro;
            else if (!type->equals(fdv->type))
            {
                /* Only need to have a tintro if the vptr
                 * offsets differ
                 */
                int offset;
                if (fdv->type->nextOf()->isBaseOf(type->nextOf(), &offset))
                {
                ti = fdv->type;
#if 0
                if (offset)
                    ti = fdv->type;
                else if (type->next->ty == Tclass)
                {   ClassDeclaration *cdn = ((TypeClass *)type->next)->sym;
                    if (cdn && cdn->sizeok != 1)
                    ti = fdv->type;
                }
#endif
                }
            }
            if (ti)
            {
                if (tintro && !tintro->equals(ti))
                {
                error("incompatible covariant types %s and %s", tintro->toChars(), ti->toChars());
                }
                tintro = ti;
            }
            goto L2;
            }
            if (cov == 3)
            {
            cd->sizeok = 2; // can't finish due to forward reference
            return;
            }
        }
        }
    }

    if (introducing && isOverride())
    {
        error("function %s does not override any", toChars());
    }

    L2: ;
    }
    else if (isOverride() && !parent->isTemplateInstance())
    error("override only applies to class member functions");

    /* Do not allow template instances to add virtual functions
     * to a class.
     */
    if (isVirtual())
    {
    TemplateInstance *ti = parent->isTemplateInstance();
    if (ti)
    {
        // Take care of nested templates
        while (1)
        {
        TemplateInstance *ti2 = ti->tempdecl->parent->isTemplateInstance();
        if (!ti2)
            break;
        ti = ti2;
        }

        // If it's a member template
        ClassDeclaration *cd = ti->tempdecl->isClassMember();
        if (cd)
        {
        error("cannot use template to add virtual function to class '%s'", cd->toChars());
        }
    }
    }

    if (isMain())
    {
    // Check parameters to see if they are either () or (char[][] args)
    switch (nparams)
    {
        case 0:
        break;

        case 1:
        {
        Argument *arg0 = Argument::getNth(f->parameters, 0);
        if (arg0->type->ty != Tarray ||
            arg0->type->next->ty != Tarray ||
            arg0->type->next->next->ty != Tchar ||
            arg0->storageClass & (STCout | STCref | STClazy))
            goto Lmainerr;
        break;
        }

        default:
        goto Lmainerr;
    }

    if (f->nextOf()->ty != Tint32 && f->nextOf()->ty != Tvoid)
        error("must return int or void, not %s", f->nextOf()->toChars());
    if (f->varargs)
    {
    Lmainerr:
        error("parameters must be main() or main(char[][] args)");
    }
    }

    if (ident == Id::assign && (sd || cd))
    {   // Disallow identity assignment operator.

    // opAssign(...)
    if (nparams == 0)
    {   if (f->varargs == 1)
        goto Lassignerr;
    }
    else
    {
        Argument *arg0 = Argument::getNth(f->parameters, 0);
        Type *t0 = arg0->type->toBasetype();
        Type *tb = sd ? sd->type : cd->type;
        if (arg0->type->implicitConvTo(tb) ||
        (sd && t0->ty == Tpointer && t0->nextOf()->implicitConvTo(tb))
           )
        {
        if (nparams == 1)
            goto Lassignerr;
        Argument *arg1 = Argument::getNth(f->parameters, 1);
        if (arg1->defaultArg)
            goto Lassignerr;
        }
    }
    }

    /* Save scope for possible later use (if we need the
     * function internals)
     */
    scope = new Scope(*sc);
    scope->setNoFree();
    return;

Lassignerr:
    error("identity assignment operator overload is illegal");
}

void FuncDeclaration::semantic2(Scope *sc)
{
}

// Do the semantic analysis on the internals of the function.

void FuncDeclaration::semantic3(Scope *sc)
{   TypeFunction *f;
    AggregateDeclaration *ad;
    VarDeclaration *argptr = NULL;
    VarDeclaration *_arguments = NULL;

    if (!parent)
    {
    printf("FuncDeclaration::semantic3(%s '%s', sc = %p)\n", kind(), toChars(), sc);
    assert(0);
    }
    //printf("FuncDeclaration::semantic3('%s.%s', sc = %p)\n", parent->toChars(), toChars(), sc);
    //fflush(stdout);
    //{ static int x; if (++x == 2) *(char*)0=0; }
    //printf("\tlinkage = %d\n", sc->linkage);

    //printf(" sc->incontract = %d\n", sc->incontract);
    if (semanticRun)
    return;
    semanticRun = 1;

    if (!type || type->ty != Tfunction)
    return;
    f = (TypeFunction *)(type);
    size_t nparams = Argument::dim(f->parameters);

    // Check the 'throws' clause
    if (fthrows)
    {   int i;

    for (i = 0; i < fthrows->dim; i++)
    {
        Type *t = (Type *)fthrows->data[i];

        t = t->semantic(loc, sc);
        if (!t->isClassHandle())
        error("can only throw classes, not %s", t->toChars());
    }
    }

    if (fbody || frequire)
    {
    // Establish function scope
    ScopeDsymbol *ss;
    Scope *sc2;

    localsymtab = new DsymbolTable();

    ss = new ScopeDsymbol();
    ss->parent = sc->scopesym;
    sc2 = sc->push(ss);
    sc2->func = this;
    sc2->parent = this;
    sc2->callSuper = 0;
    sc2->sbreak = NULL;
    sc2->scontinue = NULL;
    sc2->sw = NULL;
    sc2->fes = fes;
    sc2->linkage = LINKd;
    sc2->stc &= ~(STCauto | STCscope | STCstatic | STCabstract | STCdeprecated);
    sc2->protection = PROTpublic;
    sc2->explicitProtection = 0;
    sc2->structalign = 8;
    sc2->incontract = 0;
    sc2->tf = NULL;
    sc2->noctor = 0;

    // Declare 'this'
    ad = isThis();
    if (ad)
    {   VarDeclaration *v;

        if (isFuncLiteralDeclaration() && isNested())
        {
        error("literals cannot be class members");
        return;
        }
        else
        {
        assert(!isNested());    // can't be both member and nested
        assert(ad->handle);
        v = new ThisDeclaration(ad->handle);
        v->storage_class |= STCparameter | STCin;
        v->semantic(sc2);
        if (!sc2->insert(v))
            assert(0);
        v->parent = this;
        vthis = v;
        }
    }
    else if (isNested())
    {
        VarDeclaration *v;

        v = new ThisDeclaration(Type::tvoid->pointerTo());
        v->storage_class |= STCparameter | STCin;
        v->semantic(sc2);
        if (!sc2->insert(v))
        assert(0);
        v->parent = this;
        vthis = v;
    }

    // Declare hidden variable _arguments[] and _argptr
    if (f->varargs == 1)
    {   Type *t;

        if (f->linkage == LINKd)
        {   // Declare _arguments[]
#if BREAKABI
        v_arguments = new VarDeclaration(0, Type::typeinfotypelist->type, Id::_arguments_typeinfo, NULL);
        v_arguments->storage_class = STCparameter | STCin;
        v_arguments->semantic(sc2);
        sc2->insert(v_arguments);
        v_arguments->parent = this;

        t = Type::typeinfo->type->arrayOf();
        _arguments = new VarDeclaration(0, t, Id::_arguments, NULL);
        _arguments->semantic(sc2);
        sc2->insert(_arguments);
        _arguments->parent = this;
#else
        t = Type::typeinfo->type->arrayOf();
        v_arguments = new VarDeclaration(0, t, Id::_arguments, NULL);
        v_arguments->storage_class = STCparameter | STCin;
        v_arguments