root/branches/dmdfe-2.0/func.c

// Compiler implementation of the D programming language
// Copyright (c) 1999-2008 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)
{
    //printf("FuncDeclaration(id = '%s', type = %p)\n", id->toChars(), type);
    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;
    fes = NULL;
    introducing = 0;
    tintro = NULL;
    /* The type given for "infer the return type" is a TypeFunction with
     * NULL for the return type.
     */
    inferRetType = (type && type->nextOf() == NULL);
    scope = NULL;
    hasReturnExp = 0;
    nrvo_can = 1;
    nrvo_var = NULL;
    shidden = NULL;
    builtin = BUILTINunknown;
    tookAddressOf = 0;
}

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;
    Dsymbol *pd;

#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: %p, %s\n", type, type->toChars());
#endif

    storage_class |= sc->stc;
    //printf("function storage_class = x%x\n", storage_class);

    if (!originalType)
    originalType = type;
    if (!type->deco && type->nextOf())
    {
#if 1
    /* Apply const and invariant storage class
     * to the function type
     */
    type = type->semantic(loc, sc);
    if (storage_class & STCinvariant)
    {   // Don't use toInvariant(), as that will do a merge()
        type = type->makeInvariant();
        type->deco = type->merge()->deco;
    }
    else if (storage_class & STCconst)
    {
        if (!type->isInvariant())
        {   // Don't use toConst(), as that will do a merge()
        type = type->makeConst();
        type->deco = type->merge()->deco;
        }
    }
#else
    if (storage_class & (STCconst | STCinvariant))
    {
        /* Apply const and invariant storage class
         * to the function's return type
         */
        Type *tn = type->nextOf();
        if (storage_class & STCconst)
        tn = tn->makeConst();
        if (storage_class & STCinvariant)
        tn = tn->makeInvariant();
        ((TypeNext *)type)->next = tn;
    }

    type = type->semantic(loc, sc);
#endif
    }
    //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;
    Dsymbol *parent = toParent();

    if (storage_class & STCscope)
    error("functions cannot be scope");

    if (isAbstract() && !isVirtual())
    error("non-virtual functions cannot be abstract");

    if ((f->isConst() || f->isInvariant()) && !isThis())
    error("without 'this' cannot be const/invariant");

    if (isAbstract() && isFinal())
    error("cannot be both final and 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)
    {
    if (isCtorDeclaration())
    {
        return;
    }
#if 0
    // Verify no constructors, destructors, etc.
    if (isCtorDeclaration()
        //||isDtorDeclaration()
        //|| isInvariantDeclaration()
        //|| isUnitTestDeclaration()
       )
    {
        error("special member functions not allowed for %ss", sd->kind());
    }

    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() ||
        isPostBlitDeclaration() ||
        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());
    }

    /* Template member functions aren't virtual:
     *   interface TestInterface { void tpl(T)(); }
     * and so won't work in interfaces
     */
    if ((pd = toParent()) != NULL &&
    pd->isTemplateInstance() &&
    (pd = toParent2()) != NULL &&
    (id = pd->isInterfaceDeclaration()) != NULL)
    {
    error("template member function not allowed 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");
        goto Ldone;
    }

    // Find index of existing function in vtbl[] to override
    vi = findVtblIndex(&cd->vtbl, cd->baseClass ? cd->baseClass->vtbl.dim : 0);
    switch (vi)
    {
        case -1:
        /* Didn't find one, so
         * This is an 'introducing' function which gets a new
         * slot in the vtbl[].
         */

        // 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;
        }
        break;

        case -2:    // can't determine because of fwd refs
        cd->sizeok = 2; // can't finish due to forward reference
        return;

        default:
        {   FuncDeclaration *fdv = (FuncDeclaration *)cd->vtbl.data[vi];
        // This function is covariant with fdv
        if (fdv->isFinal())
            error("cannot override final function %s", fdv->toPrettyChars());

#if V2
        if (!isOverride() && global.params.warnings)
            error("overrides base class function %s, but is not marked with 'override'", fdv->toPrettyChars());
#endif

        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())
            break;
            if (!this->parent->isClassDeclaration()
#if !BREAKABI
            && !isDtorDeclaration()
#endif
#if V2
            && !isPostBlitDeclaration()
#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;
            }
        }
        break;
        }
    }

    /* 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];
        vi = findVtblIndex(&b->base->vtbl, b->base->vtbl.dim);
        switch (vi)
        {
        case -1:
            break;

        case -2:
            cd->sizeok = 2; // can't finish due to forward reference
            return;

        default:
        {   FuncDeclaration *fdv = (FuncDeclaration *)b->base->vtbl.data[vi];
            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->nextOf()->ty == Tclass)
                {   ClassDeclaration *cdn = ((TypeClass *)type->nextOf())->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 (introducing && isOverride())
    {
        error("does not override any function");
    }

    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->nextOf()->ty != Tarray ||
            arg0->type->nextOf()->nextOf()->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;
        }
    }
    }

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

Lassignerr:
    if (sd)
    {
    sd->hasIdentityAssign = 1;  // don't need to generate it
    goto Ldone;
    }
    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)
    {
    if (global.errors)
        return;
    //printf("FuncDeclaration::semantic3(%s '%s', sc = %p)\n", kind(), toChars(), sc);
    assert(0);
    }
    //printf("FuncDeclaration::semantic3('%s.%s', sc = %p, loc = %s)\n", parent->toChars(), toChars(), sc, loc.toChars());
    //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);

    // Check the 'throws' clause
    if (fthrows)
    {
    for (int 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)
    {
    /* Symbol table into which we place parameters and nested functions,
     * solely to diagnose name collisions.
     */
    localsymtab = new DsymbolTable();

    // Establish function scope
    ScopeDsymbol *ss = new ScopeDsymbol();
    ss->parent = sc->scopesym;
    Scope *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 | STCconst | STCfinal | STCinvariant | STCtls);
    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);
        Type *thandle = ad->handle;
        if (storage_class & STCconst || type->isConst())
        {
            if (thandle->ty == Tclass)
            thandle = thandle->constOf();
            else
            {   assert(thandle->ty == Tpointer);
            thandle = thandle->nextOf()->constOf()->pointerTo();
            }
        }
        else if (storage_class & STCinvariant || type->