root/trunk/rebuild/declaration.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 "init.h"
#include "declaration.h"
#include "attrib.h"
#include "mtype.h"
#include "template.h"
#include "scope.h"
#include "aggregate.h"
#include "module.h"
#include "id.h"
#include "expression.h"
#include "hdrgen.h"
#include "dsymbol.h"

/********************************* Declaration ****************************/

Declaration::Declaration(Identifier *id)
    : Dsymbol(id)
{
    type = NULL;
    originalType = NULL;
    storage_class = STCundefined;
    protection = PROTundefined;
    linkage = LINKdefault;
}

void Declaration::semantic(Scope *sc)
{
}

const char *Declaration::kind()
{
    return "declaration";
}

unsigned Declaration::size(Loc loc)
{
    assert(type);
    return type->size();
}

int Declaration::isStaticConstructor()
{
    return FALSE;
}

int Declaration::isStaticDestructor()
{
    return FALSE;
}

int Declaration::isDelete()
{
    return FALSE;
}

int Declaration::isDataseg()
{
    return FALSE;
}

int Declaration::isCodeseg()
{
    return FALSE;
}

enum PROT Declaration::prot()
{
    return protection;
}

/*************************************
 * Check to see if declaration can be modified in this context (sc).
 * Issue error if not.
 */

#if V2
void Declaration::checkModify(Loc loc, Scope *sc, Type *t)
{
    /* if (sc->incontract && isParameter())
    error(loc, "cannot modify parameter '%s' in contract", toChars()); */

    if (isCtorinit())
    {   // It's only modifiable if inside the right constructor
    Dsymbol *s = sc->func;
    while (1)
    {
        FuncDeclaration *fd = NULL;
        if (s)
        fd = s->isFuncDeclaration();
        if (fd &&
        ((fd->isCtorDeclaration() && storage_class & STCfield) ||
         (fd->isStaticCtorDeclaration() && !(storage_class & STCfield))) &&
        fd->toParent() == toParent()
           )
        {
        VarDeclaration *v = isVarDeclaration();
        assert(v);
        v->ctorinit = 1;
        //printf("setting ctorinit\n");
        }
        else
        {
        if (s)
        {   s = s->toParent2();
            continue;
        }
        else
        {
            const char *p = isStatic() ? "static " : "";
            /* error(loc, "can only initialize %sconst %s inside %sconstructor",
            p, toChars(), p); */
        }
        }
        break;
    }
    }
    else
    {
    VarDeclaration *v = isVarDeclaration();
    if (v && v->canassign == 0)
    {
        const char *p = NULL;
        if (isConst())
        p = "const";
        else if (isInvariant())
        p = "invariant";
        else if (storage_class & STCmanifest)
        p = "manifest constant";
        else if (!t->isAssignable())
        p = "struct with immutable members";
        /* if (p)
        {   error(loc, "cannot modify %s", p);
        halt();
        } */
    }
    }
}
#endif


/********************************* TupleDeclaration ****************************/

TupleDeclaration::TupleDeclaration(Loc loc, Identifier *id, Objects *objects)
    : Declaration(id)
{
    this->type = NULL;
    this->objects = objects;
    this->isexp = 0;
    this->tupletype = NULL;
}

Dsymbol *TupleDeclaration::syntaxCopy(Dsymbol *s)
{
    assert(0);
    return NULL;
}

const char *TupleDeclaration::kind()
{
    return "tuple";
}

Type *TupleDeclaration::getType()
{
    /* If this tuple represents a type, return that type
     */

    //printf("TupleDeclaration::getType() %s\n", toChars());
    if (isexp)
    return NULL;
    if (!tupletype)
    {
    /* It's only a type tuple if all the Object's are types
     */
    for (size_t i = 0; i < objects->dim; i++)
    {   Object *o = (Object *)objects->data[i];

        if (o->dyncast() != DYNCAST_TYPE)
        {
        //printf("\tnot[%d], %p, %d\n", i, o, o->dyncast());
        return NULL;
        }
    }

    /* We know it's a type tuple, so build the TypeTuple
     */
    Arguments *args = new Arguments();
    args->setDim(objects->dim);
    OutBuffer buf;
    for (size_t i = 0; i < objects->dim; i++)
    {   Type *t = (Type *)objects->data[i];

        //printf("type = %s\n", t->toChars());
#if 0
        buf.printf("_%s_%d", ident->toChars(), i);
        char *name = (char *)buf.extractData();
        Identifier *id = new Identifier(name, TOKidentifier);
        Argument *arg = new Argument(STCin, t, id, NULL);
#else
        Argument *arg = new Argument(0, t, NULL, NULL);
#endif
        args->data[i] = (void *)arg;
    }

    tupletype = new TypeTuple(args);
    }

    return tupletype;
}

int TupleDeclaration::needThis()
{
    //printf("TupleDeclaration::needThis(%s)\n", toChars());
    for (size_t i = 0; i < objects->dim; i++)
    {   Object *o = (Object *)objects->data[i];
    if (o->dyncast() == DYNCAST_EXPRESSION)
    {   Expression *e = (Expression *)o;
        if (e->op == TOKdsymbol)
        {   DsymbolExp *ve = (DsymbolExp *)e;
        Declaration *d = ve->s->isDeclaration();
        if (d && d->needThis())
        {
            return 1;
        }
        }
    }
    }
    return 0;
}

/********************************* TypedefDeclaration ****************************/

TypedefDeclaration::TypedefDeclaration(Loc loc, Identifier *id, Type *basetype, Initializer *init)
    : Declaration(id)
{
    this->type = new TypeTypedef(this);
    this->basetype = basetype->toBasetype();
    this->init = init;
#ifdef _DH
    this->htype = NULL;
    this->hbasetype = NULL;
#endif
    this->sem = 0;
    this->inuse = 0;
    this->loc = loc;
    this->sinit = NULL;
}

Dsymbol *TypedefDeclaration::syntaxCopy(Dsymbol *s)
{
    Type *basetype = this->basetype->syntaxCopy();

    Initializer *init = NULL;
    if (this->init)
    init = this->init->syntaxCopy();

    assert(!s);
    TypedefDeclaration *st;
    st = new TypedefDeclaration(loc, ident, basetype, init);
#ifdef _DH
    // Syntax copy for header file
    if (!htype)      // Don't overwrite original
    {   if (type)    // Make copy for both old and new instances
    {   htype = type->syntaxCopy();
        st->htype = type->syntaxCopy();
    }
    }
    else            // Make copy of original for new instance
        st->htype = htype->syntaxCopy();
    if (!hbasetype)
    {   if (basetype)
    {   hbasetype = basetype->syntaxCopy();
        st->hbasetype = basetype->syntaxCopy();
    }
    }
    else
        st->hbasetype = hbasetype->syntaxCopy();
#endif
    return st;
}

void TypedefDeclaration::semantic(Scope *sc)
{
    //printf("TypedefDeclaration::semantic(%s) sem = %d\n", toChars(), sem);
    if (sem == 0)
    {   sem = 1;
    basetype = basetype->semantic(loc, sc);
    sem = 2;
    type = type->semantic(loc, sc);
    if (sc->parent->isFuncDeclaration() && init)
        semantic2(sc);
    storage_class |= sc->stc & STCdeprecated;
    }
    else if (sem == 1)
    {
    //error("circular definition");
    }
}

void TypedefDeclaration::semantic2(Scope *sc)
{
    //printf("TypedefDeclaration::semantic2(%s) sem = %d\n", toChars(), sem);
    if (sem == 2)
    {   sem = 3;
    if (init)
    {
        init = init->semantic(sc, basetype);

        ExpInitializer *ie = init->isExpInitializer();
        if (ie)
        {
        if (ie->exp->type == basetype)
            ie->exp->type = type;
        }
    }
    }
}

const char *TypedefDeclaration::kind()
{
    return "typedef";
}

Type *TypedefDeclaration::getType()
{
    return type;
}

void TypedefDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
{
    buf->writestring("typedef ");
    basetype->toCBuffer(buf, ident, hgs);
    if (init)
    {
    buf->writestring(" = ");
    init->toCBuffer(buf, hgs);
    }
    buf->writeByte(';');
    buf->writenl();
}

/********************************* AliasDeclaration ****************************/

AliasDeclaration::AliasDeclaration(Loc loc, Identifier *id, Type *type)
    : Declaration(id)
{
    //printf("AliasDeclaration(id = '%s', type = %p)\n", id->toChars(), type);
    //printf("type = '%s'\n", type->toChars());
    this->loc = loc;
    this->type = type;
    this->aliassym = NULL;
#ifdef _DH
    this->htype = NULL;
    this->haliassym = NULL;
#endif
    this->overnext = NULL;
    this->inSemantic = 0;
    assert(type);
}

AliasDeclaration::AliasDeclaration(Loc loc, Identifier *id, Dsymbol *s)
    : Declaration(id)
{
    //printf("AliasDeclaration(id = '%s', s = %p)\n", id->toChars(), s);
    assert(s != this);
    this->loc = loc;
    this->type = NULL;
    this->aliassym = s;
#ifdef _DH
    this->htype = NULL;
    this->haliassym = NULL;
#endif
    this->overnext = NULL;
    this->inSemantic = 0;
    assert(s);
}

Dsymbol *AliasDeclaration::syntaxCopy(Dsymbol *s)
{
    //printf("AliasDeclaration::syntaxCopy()\n");
    assert(!s);
    AliasDeclaration *sa;
    if (type)
    sa = new AliasDeclaration(loc, ident, type->syntaxCopy());
    else
    sa = new AliasDeclaration(loc, ident, aliassym->syntaxCopy(NULL));
#ifdef _DH
    // Syntax copy for header file
    if (!htype)     // Don't overwrite original
    {   if (type)   // Make copy for both old and new instances
    {   htype = type->syntaxCopy();
        sa->htype = type->syntaxCopy();
    }
    }
    else            // Make copy of original for new instance
    sa->htype = htype->syntaxCopy();
    if (!haliassym)
    {   if (aliassym)
    {   haliassym = aliassym->syntaxCopy(s);
        sa->haliassym = aliassym->syntaxCopy(s);
    }
    }
    else
    sa->haliassym = haliassym->syntaxCopy(s);
#endif
    return sa;
}

void AliasDeclaration::semantic(Scope *sc)
{
    //printf("AliasDeclaration::semantic() %s\n", toChars());
    if (aliassym)
    {
    if (aliassym->isTemplateInstance())
        aliassym->semantic(sc);
    return;
    }
    this->inSemantic = 1;

    /*if (storage_class & STCconst)
    error("cannot be const"); */

    storage_class |= sc->stc & STCdeprecated;

    // Given:
    //  alias foo.bar.abc def;
    // it is not knowable from the syntax whether this is an alias
    // for a type or an alias for a symbol. It is up to the semantic()
    // pass to distinguish.
    // If it is a type, then type is set and getType() will return that
    // type. If it is a symbol, then aliassym is set and type is NULL -
    // toAlias() will return aliasssym.

    Dsymbol *s;
    Type *t;
    Expression *e;

    /* This section is needed because resolve() will:
     *   const x = 3;
     *   alias x y;
     * try to alias y to 3.
     */
    s = type->toDsymbol(sc);
    if (s && ((s->getType() && type->equals(s->getType())) || s->isEnumMember()))
    goto L2;            // it's a symbolic alias

    //printf("alias type is %s\n", type->toChars());
    type->resolve(loc, sc, &e, &t, &s);
    if (s)
    {
    goto L2;
    }
    else if (e)
    {
    // Try to convert Expression to Dsymbol
    s = getDsymbol(e);
    if (s)
        goto L2;
    // error("cannot alias an expression %s", e->toChars());
    t = e->type;
    }
    else if (t)
    type = t;
    if (overnext)
    ScopeDsymbol::multiplyDefined(0, this, overnext);
    this->inSemantic = 0;
    return;

  L2:
    //printf("alias is a symbol %s %s\n", s->kind(), s->toChars());
    type = NULL;
    VarDeclaration *v = s->isVarDeclaration();
    if (v && v->linkage == LINKdefault)
    {
    //error("forward reference of %s", v->toChars());
    s = NULL;
    }
    else
    {
    FuncDeclaration *f = s->toAlias()->isFuncDeclaration();
    if (f)
    {
        if (overnext)
        {
        FuncAliasDeclaration *fa = new FuncAliasDeclaration(f);
        if (!fa->overloadInsert(overnext))
            ScopeDsymbol::multiplyDefined(0, f, overnext);
        overnext = NULL;
        s = fa;
        s->parent = sc->parent;
        }
    }
    if (overnext)
        ScopeDsymbol::multiplyDefined(0, s, overnext);
    if (s == this)
    {
        assert(global.errors);
        s = NULL;
    }
    }
    aliassym = s;
    this->inSemantic = 0;
}

int AliasDeclaration::overloadInsert(Dsymbol *s)
{
    /* Don't know yet what the aliased symbol is, so assume it can
     * be overloaded and check later for correctness.
     */

    //printf("AliasDeclaration::overloadInsert('%s')\n", s->toChars());
    if (overnext == NULL)
    {   overnext = s;
    return TRUE;
    }
    else
    {
    return overnext->overloadInsert(s);
    }
}

const char *AliasDeclaration::kind()
{
    return "alias";
}

Type *AliasDeclaration::getType()
{
    return type;
}

Dsymbol *AliasDeclaration::toAlias()
{
    //printf("AliasDeclaration::toAlias('%s', this = %p, aliassym = %p, kind = '%s')\n", toChars(), this, aliassym, aliassym ? aliassym->kind() : "");
    assert(this != aliassym);
    //static int count; if (++count == 10) *(char*)0=0;
    if (inSemantic)
    {   //error("recursive alias declaration");
//  return this;
    }
    Dsymbol *s = aliassym ? aliassym->toAlias() : this;
    return s;
}

void AliasDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
{
    buf->writestring("alias ");
#if 0 && _DH
    if (hgs->hdrgen)
    {
    if (haliassym)
    {
        haliassym->toCBuffer(buf, hgs);
        buf->writeByte(' ');
        buf->writestring(ident->toChars());
    }
    else
        htype->toCBuffer(buf, ident, hgs);
    }
    else
#endif
    {
    if (aliassym)
    {
        aliassym->toCBuffer(buf, hgs);
        buf->writeByte(' ');
        buf->writestring(ident->toChars());
    }
    else
        type->toCBuffer(buf, ident, hgs);
    }
    buf->writeByte(';');
    buf->writenl();
}

/********************************* VarDeclaration ****************************/

VarDeclaration::VarDeclaration(Loc loc, Type *type, Identifier *id, Initializer *init)
    : Declaration(id)
{
    //printf("VarDeclaration('%s')\n", id->toChars());
#ifdef DEBUG
    if (!type && !init)
    {   printf("VarDeclaration('%s')\n", id->toChars());
    //*(char*)0=0;
    }
#endif
    assert(type || init);
    this->type = type;
    this->init = init;
#ifdef _DH
    this->htype = NULL;
    this->hinit = NULL;
#endif
    this->loc = loc;
    offset = 0;
    noauto = 0;
    inuse = 0;
    ctorinit = 0;
    aliassym = NULL;
    onstack = 0;
    canassign = 0;
    value = NULL;
    scope = NULL;
}

Dsymbol *VarDeclaration::syntaxCopy(Dsymbol *s)
{
    //printf("VarDeclaration::syntaxCopy(%s)\n", toChars());

    VarDeclaration *sv;
    if (s)
    {   sv = (VarDeclaration *)s;
    }
    else
    {
    Initializer *init = NULL;
    if (this->init)
    {   init = this->init->syntaxCopy();
        //init->isExpInitializer()->exp->print();
        //init->isExpInitializer()->exp->dump(0);
    }

    sv = new VarDeclaration(loc, type ? type->syntaxCopy() : NULL, ident, init);
    sv->storage_class = storage_class;
    }
#ifdef _DH
    // Syntax copy for header file
    if (!htype)      // Don't overwrite original
    {   if (type)    // Make copy for both old and new instances
    {   htype = type->syntaxCopy();
        sv->htype = type->syntaxCopy();
    }
    }
    else            // Make copy of original for new instance
        sv->htype = htype->syntaxCopy();
    if (!hinit)
    {   if (init)
    {   hinit = init->syntaxCopy();
        sv->hinit = init->syntaxCopy();
    }
    }
    else
        sv->hinit = hinit->syntaxCopy();
#endif
    return sv;
}

void VarDeclaration::semantic(Scope *sc)
{
#if 0
    printf("VarDeclaration::semantic('%s', parent = '%s')\n", toChars(), sc->parent->toChars());
    printf(" type = %s\n", type ? type->toChars() : "null");
    printf(" stc = x%x\n", sc->stc);
    printf(" storage_class = x%x\n", storage_class);
    printf("linkage = %d\n", sc->linkage);
    //if (strcmp(toChars(), "mul") == 0) halt();
#endif

    storage_class |= sc->stc;
    /*if (storage_class & STCextern && init)
    error("extern symbols cannot have initializers"); */

    /* If auto type inference, do the inference
     */
    int inferred = 0;
    if (!type)
    {   inuse++;
    type = init->inferType(sc);
    inuse--;
    inferred = 1;

    /* This is a kludge to support the existing syntax for RAII
     * declarations.
     */
    storage_class &= ~STCauto;
    originalType = type;
    }
    else
    {   if (!originalType)
        originalType = type;
    type = type->semantic(loc, sc);
    }
    //printf(" semantic type = %s\n", type ? type->toChars() : "null");

    type->checkDeprecated(loc, sc);
    linkage = sc->linkage;
    this->parent = sc->parent;
    //printf("this = %p, parent = %p, '%s'\n", this, parent, parent->toChars());
    protection = sc->protection;
    //printf("sc->stc = %x\n", sc->stc);
    //printf("storage_class = x%x\n", storage_class);

    Dsymbol *parent = toParent();
    FuncDeclaration *fd = parent->isFuncDeclaration();

    Type *tb = type->toBasetype();
    if (tb->ty == Tvoid &&