Mercurial > hg > CbC > CbC_gcc
diff gcc/d/dmd/declaration.c @ 145:1830386684a0
gcc-9.2.0
| author | anatofuz |
|---|---|
| date | Thu, 13 Feb 2020 11:34:05 +0900 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gcc/d/dmd/declaration.c Thu Feb 13 11:34:05 2020 +0900 @@ -0,0 +1,2544 @@ + +/* Compiler implementation of the D programming language + * Copyright (C) 1999-2019 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 + * https://github.com/D-Programming-Language/dmd/blob/master/src/declaration.c + */ + +#include "root/dsystem.h" +#include "root/checkedint.h" + +#include "errors.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 "import.h" +#include "id.h" +#include "expression.h" +#include "statement.h" +#include "ctfe.h" +#include "target.h" +#include "hdrgen.h" + +bool checkNestedRef(Dsymbol *s, Dsymbol *p); +VarDeclaration *copyToTemp(StorageClass stc, const char *name, Expression *e); +Expression *semantic(Expression *e, Scope *sc); +Initializer *inferType(Initializer *init, Scope *sc); +Initializer *semantic(Initializer *init, Scope *sc, Type *t, NeedInterpret needInterpret); + +/************************************ + * Check to see the aggregate type is nested and its context pointer is + * accessible from the current scope. + * Returns true if error occurs. + */ +bool checkFrameAccess(Loc loc, Scope *sc, AggregateDeclaration *ad, size_t iStart = 0) +{ + Dsymbol *sparent = ad->toParent2(); + Dsymbol *s = sc->func; + if (ad->isNested() && s) + { + //printf("ad = %p %s [%s], parent:%p\n", ad, ad->toChars(), ad->loc.toChars(), ad->parent); + //printf("sparent = %p %s [%s], parent: %s\n", sparent, sparent->toChars(), sparent->loc.toChars(), sparent->parent->toChars()); + if (checkNestedRef(s, sparent)) + { + error(loc, "cannot access frame pointer of %s", ad->toPrettyChars()); + return true; + } + } + + bool result = false; + for (size_t i = iStart; i < ad->fields.dim; i++) + { + VarDeclaration *vd = ad->fields[i]; + Type *tb = vd->type->baseElemOf(); + if (tb->ty == Tstruct) + { + result |= checkFrameAccess(loc, sc, ((TypeStruct *)tb)->sym); + } + } + return result; +} + +/********************************* Declaration ****************************/ + +Declaration::Declaration(Identifier *id) + : Dsymbol(id) +{ + type = NULL; + originalType = NULL; + storage_class = STCundefined; + protection = Prot(PROTundefined); + linkage = LINKdefault; + inuse = 0; + mangleOverride = NULL; +} + +void Declaration::semantic(Scope *) +{ +} + +const char *Declaration::kind() const +{ + return "declaration"; +} + +d_uns64 Declaration::size(Loc) +{ + assert(type); + return type->size(); +} + +bool Declaration::isDelete() +{ + return false; +} + +bool Declaration::isDataseg() +{ + return false; +} + +bool Declaration::isThreadlocal() +{ + return false; +} + +bool Declaration::isCodeseg() const +{ + return false; +} + +Prot Declaration::prot() +{ + return protection; +} + +/************************************* + * Check to see if declaration can be modified in this context (sc). + * Issue error if not. + */ + +int Declaration::checkModify(Loc loc, Scope *sc, Type *, Expression *e1, int flag) +{ + VarDeclaration *v = isVarDeclaration(); + if (v && v->canassign) + return 2; + + if (isParameter() || isResult()) + { + for (Scope *scx = sc; scx; scx = scx->enclosing) + { + if (scx->func == parent && (scx->flags & SCOPEcontract)) + { + const char *s = isParameter() && parent->ident != Id::ensure ? "parameter" : "result"; + if (!flag) error(loc, "cannot modify %s '%s' in contract", s, toChars()); + return 2; // do not report type related errors + } + } + } + + if (v && (isCtorinit() || isField())) + { + // It's only modifiable if inside the right constructor + if ((storage_class & (STCforeach | STCref)) == (STCforeach | STCref)) + return 2; + return modifyFieldVar(loc, sc, v, e1) ? 2 : 1; + } + return 1; +} + +Dsymbol *Declaration::search(const Loc &loc, Identifier *ident, int flags) +{ + Dsymbol *s = Dsymbol::search(loc, ident, flags); + if (!s && type) + { + s = type->toDsymbol(_scope); + if (s) + s = s->search(loc, ident, flags); + } + return s; +} + + +/********************************* TupleDeclaration ****************************/ + +TupleDeclaration::TupleDeclaration(Loc loc, Identifier *id, Objects *objects) + : Declaration(id) +{ + this->loc = loc; + this->type = NULL; + this->objects = objects; + this->isexp = false; + this->tupletype = NULL; +} + +Dsymbol *TupleDeclaration::syntaxCopy(Dsymbol *) +{ + assert(0); + return NULL; +} + +const char *TupleDeclaration::kind() const +{ + 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++) + { + RootObject *o = (*objects)[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 + */ + Types *types = (Types *)objects; + Parameters *args = new Parameters(); + args->setDim(objects->dim); + OutBuffer buf; + int hasdeco = 1; + for (size_t i = 0; i < types->dim; i++) + { + Type *t = (*types)[i]; + //printf("type = %s\n", t->toChars()); + Parameter *arg = new Parameter(0, t, NULL, NULL); + (*args)[i] = arg; + if (!t->deco) + hasdeco = 0; + } + + tupletype = new TypeTuple(args); + if (hasdeco) + return tupletype->semantic(Loc(), NULL); + } + + return tupletype; +} + +Dsymbol *TupleDeclaration::toAlias2() +{ + //printf("TupleDeclaration::toAlias2() '%s' objects = %s\n", toChars(), objects->toChars()); + + for (size_t i = 0; i < objects->dim; i++) + { + RootObject *o = (*objects)[i]; + if (Dsymbol *s = isDsymbol(o)) + { + s = s->toAlias2(); + (*objects)[i] = s; + } + } + return this; +} + +bool TupleDeclaration::needThis() +{ + //printf("TupleDeclaration::needThis(%s)\n", toChars()); + for (size_t i = 0; i < objects->dim; i++) + { + RootObject *o = (*objects)[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 true; + } + } + } + } + return false; +} + +/********************************* 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; + this->_import = NULL; + this->overnext = NULL; + 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; + this->_import = NULL; + this->overnext = NULL; + assert(s); +} + +AliasDeclaration *AliasDeclaration::create(Loc loc, Identifier *id, Type *type) +{ + return new AliasDeclaration(loc, id, type); +} + +Dsymbol *AliasDeclaration::syntaxCopy(Dsymbol *s) +{ + //printf("AliasDeclaration::syntaxCopy()\n"); + assert(!s); + AliasDeclaration *sa = + type ? new AliasDeclaration(loc, ident, type->syntaxCopy()) + : new AliasDeclaration(loc, ident, aliassym->syntaxCopy(NULL)); + sa->storage_class = storage_class; + return sa; +} + +void AliasDeclaration::semantic(Scope *sc) +{ + if (semanticRun >= PASSsemanticdone) + return; + assert(semanticRun <= PASSsemantic); + + storage_class |= sc->stc & STCdeprecated; + protection = sc->protection; + userAttribDecl = sc->userAttribDecl; + + if (!sc->func && inNonRoot()) + return; + + aliasSemantic(sc); +} + +void AliasDeclaration::aliasSemantic(Scope *sc) +{ + //printf("AliasDeclaration::semantic() %s\n", toChars()); + if (aliassym) + { + FuncDeclaration *fd = aliassym->isFuncLiteralDeclaration(); + TemplateDeclaration *td = aliassym->isTemplateDeclaration(); + if (fd || (td && td->literal)) + { + if (fd && fd->semanticRun >= PASSsemanticdone) + return; + + Expression *e = new FuncExp(loc, aliassym); + e = ::semantic(e, sc); + if (e->op == TOKfunction) + { + FuncExp *fe = (FuncExp *)e; + aliassym = fe->td ? (Dsymbol *)fe->td : fe->fd; + } + else + { + aliassym = NULL; + type = Type::terror; + } + return; + } + + if (aliassym->isTemplateInstance()) + aliassym->semantic(sc); + return; + } + inuse = 1; + + // 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. + + unsigned int errors = global.errors; + Type *oldtype = type; + + // Ungag errors when not instantiated DeclDefs scope alias + Ungag ungag(global.gag); + //printf("%s parent = %s, gag = %d, instantiated = %d\n", toChars(), parent, global.gag, isInstantiated()); + if (parent && global.gag && !isInstantiated() && !toParent2()->isFuncDeclaration()) + { + //printf("%s type = %s\n", toPrettyChars(), type->toChars()); + global.gag = 0; + } + + /* This section is needed because Type::resolve() will: + * const x = 3; + * alias y = x; + * try to convert identifier x to 3. + */ + Dsymbol *s = type->toDsymbol(sc); + if (errors != global.errors) + { + s = NULL; + type = Type::terror; + } + if (s && s == this) + { + error("cannot resolve"); + s = NULL; + type = Type::terror; + } + if (!s || !s->isEnumMember()) + { + Type *t; + Expression *e; + Scope *sc2 = sc; + if (storage_class & (STCref | STCnothrow | STCnogc | STCpure | STCdisable)) + { + // For 'ref' to be attached to function types, and picked + // up by Type::resolve(), it has to go into sc. + sc2 = sc->push(); + sc2->stc |= storage_class & (STCref | STCnothrow | STCnogc | STCpure | STCshared | STCdisable); + } + type = type->addSTC(storage_class); + type->resolve(loc, sc2, &e, &t, &s); + if (sc2 != sc) + sc2->pop(); + + if (e) // Try to convert Expression to Dsymbol + { + s = getDsymbol(e); + if (!s) + { + if (e->op != TOKerror) + error("cannot alias an expression %s", e->toChars()); + t = Type::terror; + } + } + type = t; + } + if (s == this) + { + assert(global.errors); + type = Type::terror; + s = NULL; + } + if (!s) // it's a type alias + { + //printf("alias %s resolved to type %s\n", toChars(), type->toChars()); + type = type->semantic(loc, sc); + aliassym = NULL; + } + else // it's a symbolic alias + { + //printf("alias %s resolved to %s %s\n", toChars(), s->kind(), s->toChars()); + type = NULL; + aliassym = s; + } + if (global.gag && errors != global.errors) + { + type = oldtype; + aliassym = NULL; + } + inuse = 0; + semanticRun = PASSsemanticdone; + + if (Dsymbol *sx = overnext) + { + overnext = NULL; + + if (!overloadInsert(sx)) + ScopeDsymbol::multiplyDefined(Loc(), sx, this); + } +} + +bool AliasDeclaration::overloadInsert(Dsymbol *s) +{ + //printf("[%s] AliasDeclaration::overloadInsert('%s') s = %s %s @ [%s]\n", + // loc.toChars(), toChars(), s->kind(), s->toChars(), s->loc.toChars()); + + /** Aliases aren't overloadable themselves, but if their Aliasee is + * overloadable they are converted to an overloadable Alias (either + * FuncAliasDeclaration or OverDeclaration). + * + * This is done by moving the Aliasee into such an overloadable alias + * which is then used to replace the existing Aliasee. The original + * Alias (_this_) remains a useless shell. + * + * This is a horrible mess. It was probably done to avoid replacing + * existing AST nodes and references, but it needs a major + * simplification b/c it's too complex to maintain. + * + * A simpler approach might be to merge any colliding symbols into a + * simple Overload class (an array) and then later have that resolve + * all collisions. + */ + if (semanticRun >= PASSsemanticdone) + { + /* Semantic analysis is already finished, and the aliased entity + * is not overloadable. + */ + if (type) + return false; + + /* When s is added in member scope by static if, mixin("code") or others, + * aliassym is determined already. See the case in: test/compilable/test61.d + */ + Dsymbol *sa = aliassym->toAlias(); + if (FuncDeclaration *fd = sa->isFuncDeclaration()) + { + FuncAliasDeclaration *fa = new FuncAliasDeclaration(ident, fd); + fa->protection = protection; + fa->parent = parent; + aliassym = fa; + return aliassym->overloadInsert(s); + } + if (TemplateDeclaration *td = sa->isTemplateDeclaration()) + { + OverDeclaration *od = new OverDeclaration(ident, td); + od->protection = protection; + od->parent = parent; + aliassym = od; + return aliassym->overloadInsert(s); + } + if (OverDeclaration *od = sa->isOverDeclaration()) + { + if (sa->ident != ident || sa->parent != parent) + { + od = new OverDeclaration(ident, od); + od->protection = protection; + od->parent = parent; + aliassym = od; + } + return od->overloadInsert(s); + } + if (OverloadSet *os = sa->isOverloadSet()) + { + if (sa->ident != ident || sa->parent != parent) + { + os = new OverloadSet(ident, os); + // TODO: protection is lost here b/c OverloadSets have no protection attribute + // Might no be a practical issue, b/c the code below fails to resolve the overload anyhow. + // ---- + // module os1; + // import a, b; + // private alias merged = foo; // private alias to overload set of a.foo and b.foo + // ---- + // module os2; + // import a, b; + // public alias merged = bar; // public alias to overload set of a.bar and b.bar + // ---- + // module bug; + // import os1, os2; + // void test() { merged(123); } // should only look at os2.merged + // + // os.protection = protection; + os->parent = parent; + aliassym = os; + } + os->push(s); + return true; + } + return false; + } + + /* Don't know yet what the aliased symbol is, so assume it can + * be overloaded and check later for correctness. + */ + if (overnext) + return overnext->overloadInsert(s); + if (s == this) + return true; + overnext = s; + return true; +} + +const char *AliasDeclaration::kind() const +{ + return "alias"; +} + +Type *AliasDeclaration::getType() +{ + if (type) + return type; + return toAlias()->getType(); +} + +Dsymbol *AliasDeclaration::toAlias() +{ + //printf("[%s] AliasDeclaration::toAlias('%s', this = %p, aliassym = %p, kind = '%s', inuse = %d)\n", + // loc.toChars(), toChars(), this, aliassym, aliassym ? aliassym->kind() : "", inuse); + assert(this != aliassym); + //static int count; if (++count == 10) *(char*)0=0; + if (inuse == 1 && type && _scope) + { + inuse = 2; + unsigned olderrors = global.errors; + Dsymbol *s = type->toDsymbol(_scope); + //printf("[%s] type = %s, s = %p, this = %p\n", loc.toChars(), type->toChars(), s, this); + if (global.errors != olderrors) + goto Lerr; + if (s) + { + s = s->toAlias(); + if (global.errors != olderrors) + goto Lerr; + aliassym = s; + inuse = 0; + } + else + { + Type *t = type->semantic(loc, _scope); + if (t->ty == Terror) + goto Lerr; + if (global.errors != olderrors) + goto Lerr; + //printf("t = %s\n", t->toChars()); + inuse = 0; + } + } + if (inuse) + { + error("recursive alias declaration"); + + Lerr: + // Avoid breaking "recursive alias" state during errors gagged + if (global.gag) + return this; + + aliassym = new AliasDeclaration(loc, ident, Type::terror); + type = Type::terror; + return aliassym; + } + + if (semanticRun >= PASSsemanticdone) + { + // semantic is already done. + + // Do not see aliassym !is null, because of lambda aliases. + + // Do not see type.deco !is null, even so "alias T = const int;` needs + // semantic analysis to take the storage class `const` as type qualifier. + } + else + { + if (_import && _import->_scope) + { + /* If this is an internal alias for selective/renamed import, + * load the module first. + */ + _import->semantic(NULL); + } + if (_scope) + { + aliasSemantic(_scope); + } + } + + inuse = 1; + Dsymbol *s = aliassym ? aliassym->toAlias() : this; + inuse = 0; + return s; +} + +Dsymbol *AliasDeclaration::toAlias2() +{ + if (inuse) + { + error("recursive alias declaration"); + return this; + } + inuse = 1; + Dsymbol *s = aliassym ? aliassym->toAlias2() : this; + inuse = 0; + return s; +} + +bool AliasDeclaration::isOverloadable() +{ + // assume overloadable until alias is resolved + return semanticRun < PASSsemanticdone || + (aliassym && aliassym->isOverloadable()); +} + +/****************************** OverDeclaration **************************/ + +OverDeclaration::OverDeclaration(Identifier *ident, Dsymbol *s, bool hasOverloads) + : Declaration(ident) +{ + this->overnext = NULL; + this->aliassym = s; + + this->hasOverloads = hasOverloads; + if (hasOverloads) + { + if (OverDeclaration *od = aliassym->isOverDeclaration()) + this->hasOverloads = od->hasOverloads; + } + else + { + // for internal use + assert(!aliassym->isOverDeclaration()); + } +} + +const char *OverDeclaration::kind() const +{ + return "overload alias"; // todo +} + +void OverDeclaration::semantic(Scope *) +{ +} + +bool OverDeclaration::equals(RootObject *o) +{ + if (this == o) + return true; + + Dsymbol *s = isDsymbol(o); + if (!s) + return false; + + OverDeclaration *od1 = this; + if (OverDeclaration *od2 = s->isOverDeclaration()) + { + return od1->aliassym->equals(od2->aliassym) && + od1->hasOverloads == od2->hasOverloads; + } + if (aliassym == s) + { + if (hasOverloads) + return true; + if (FuncDeclaration *fd = s->isFuncDeclaration()) + { + return fd->isUnique() != NULL; + } + if (TemplateDeclaration *td = s->isTemplateDeclaration()) + { + return td->overnext == NULL; + } + } + return false; +} + +bool OverDeclaration::overloadInsert(Dsymbol *s) +{ + //printf("OverDeclaration::overloadInsert('%s') aliassym = %p, overnext = %p\n", s->toChars(), aliassym, overnext); + if (overnext) + return overnext->overloadInsert(s); + if (s == this) + return true; + overnext = s; + return true; +} + +Dsymbol *OverDeclaration::toAlias() +{ + return this; +} + +bool OverDeclaration::isOverloadable() +{ + return true; +} + +Dsymbol *OverDeclaration::isUnique() +{ + if (!hasOverloads) + { + if (aliassym->isFuncDeclaration() || + aliassym->isTemplateDeclaration()) + { + return aliassym; + } + } + + struct ParamUniqueSym + { + static int fp(void *param, Dsymbol *s) + { + Dsymbol **ps = (Dsymbol **)param; + if (*ps) + { + *ps = NULL; + return 1; // ambiguous, done + } + else + { + *ps = s; + return 0; + } + } + }; + Dsymbol *result = NULL; + overloadApply(aliassym, &result, &ParamUniqueSym::fp); + return result; +} + +/********************************* VarDeclaration ****************************/ + +VarDeclaration::VarDeclaration(Loc loc, Type *type, Identifier *id, Initializer *init) + : Declaration(id) +{ + //printf("VarDeclaration('%s')\n", id->toChars()); + assert(id); + assert(type || init); + this->type = type; + this->_init = init; + this->loc = loc; + offset = 0; + isargptr = false; + alignment = 0; + ctorinit = 0; + aliassym = NULL; + onstack = false; + mynew = false; + canassign = 0; + overlapped = false; + overlapUnsafe = false; + doNotInferScope = false; + isdataseg = 0; + lastVar = NULL; + endlinnum = 0; + ctfeAdrOnStack = -1; + edtor = NULL; + range = NULL; + + static unsigned nextSequenceNumber = 0; + this->sequenceNumber = ++nextSequenceNumber; +} + +VarDeclaration *VarDeclaration::create(Loc loc, Type *type, Identifier *id, Initializer *init) +{ + return new VarDeclaration(loc, type, id, init); +} + +Dsymbol *VarDeclaration::syntaxCopy(Dsymbol *s) +{ + //printf("VarDeclaration::syntaxCopy(%s)\n", toChars()); + assert(!s); + VarDeclaration *v = new VarDeclaration(loc, + type ? type->syntaxCopy() : NULL, + ident, + _init ? _init->syntaxCopy() : NULL); + v->storage_class = storage_class; + return v; +} + + +void VarDeclaration::semantic(Scope *sc) +{ +// if (semanticRun > PASSinit) +// return; +// semanticRun = PASSsemantic; + + if (semanticRun >= PASSsemanticdone) + return; + + Scope *scx = NULL; + if (_scope) + { + sc = _scope; + scx = sc; + _scope = NULL; + } + + if (!sc) + return; + + semanticRun = PASSsemantic; + + /* Pick up storage classes from context, but except synchronized, + * override, abstract, and final. + */ + storage_class |= (sc->stc & ~(STCsynchronized | STCoverride | STCabstract | STCfinal)); + if (storage_class & STCextern && _init) + error("extern symbols cannot have initializers"); + + userAttribDecl = sc->userAttribDecl; + + AggregateDeclaration *ad = isThis(); + if (ad) + storage_class |= ad->storage_class & STC_TYPECTOR; + + /* If auto type inference, do the inference + */ + int inferred = 0; + if (!type) + { + inuse++; + + // Infering the type requires running semantic, + // so mark the scope as ctfe if required + bool needctfe = (storage_class & (STCmanifest | STCstatic)) != 0; + if (needctfe) sc = sc->startCTFE(); + + //printf("inferring type for %s with init %s\n", toChars(), _init->toChars()); + _init = inferType(_init, sc); + type = initializerToExpression(_init)->type; + + if (needctfe) sc = sc->endCTFE(); + + inuse--; + inferred = 1; + + /* This is a kludge to support the existing syntax for RAII + * declarations. + */ + storage_class &= ~STCauto; + originalType = type->syntaxCopy(); + } + else + { + if (!originalType) + originalType = type->syntaxCopy(); + + /* Prefix function attributes of variable declaration can affect + * its type: + * pure nothrow void function() fp; + * static assert(is(typeof(fp) == void function() pure nothrow)); + */ + Scope *sc2 = sc->push(); + sc2->stc |= (storage_class & STC_FUNCATTR); + inuse++; + type = type->semantic(loc, sc2); + inuse--; + sc2->pop(); + } + //printf(" semantic type = %s\n", type ? type->toChars() : "null"); + if (type->ty == Terror) + errors = true; + + 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; + + /* If scope's alignment is the default, use the type's alignment, + * otherwise the scope overrrides. + */ + alignment = sc->alignment(); + if (alignment == STRUCTALIGN_DEFAULT) + alignment = type->alignment(); // use type's alignment + + //printf("sc->stc = %x\n", sc->stc); + //printf("storage_class = x%x\n", storage_class); + + if (global.params.vcomplex) + type->checkComplexTransition(loc); + + // Calculate type size + safety checks + if (sc->func && !sc->intypeof) + { + if ((storage_class & STCgshared) && !isMember()) + { + if (sc->func->setUnsafe()) + error("__gshared not allowed in safe functions; use shared"); + } + } + + Dsymbol *parent = toParent(); + + Type *tb = type->toBasetype(); + Type *tbn = tb->baseElemOf(); + if (tb->ty == Tvoid && !(storage_class & STClazy)) + { + if (inferred) + { + error("type %s is inferred from initializer %s, and variables cannot be of type void", + type->toChars(), _init->toChars()); + } + else + error("variables cannot be of type void"); + type = Type::terror; + tb = type; + } + if (tb->ty == Tfunction) + { + error("cannot be declared to be a function"); + type = Type::terror; + tb = type; + } + if (tb->ty == Tstruct) + { + TypeStruct *ts = (TypeStruct *)tb; + if (!ts->sym->members) + { + error("no definition of struct %s", ts->toChars()); + } + } + if ((storage_class & STCauto) && !inferred) + error("storage class 'auto' has no effect if type is not inferred, did you mean 'scope'?"); + + if (tb->ty == Ttuple) + { + /* Instead, declare variables for each of the tuple elements + * and add those. + */ + TypeTuple *tt = (TypeTuple *)tb; + size_t nelems = Parameter::dim(tt->arguments); + Expression *ie = (_init && !_init->isVoidInitializer()) ? initializerToExpression(_init) : NULL; + if (ie) + ie = ::semantic(ie, sc); + + if (nelems > 0 && ie) + { + Expressions *iexps = new Expressions(); + iexps->push(ie); + + Expressions *exps = new Expressions(); + + for (size_t pos = 0; pos < iexps->dim; pos++) + { + Lexpand1: + Expression *e = (*iexps)[pos]; + Parameter *arg = Parameter::getNth(tt->arguments, pos); + arg->type = arg->type->semantic(loc, sc); + //printf("[%d] iexps->dim = %d, ", pos, iexps->dim); + //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 (e != ie) + { + if (iexps->dim > nelems) + goto Lnomatch; + if (e->type->implicitConvTo(arg->type)) + continue; + } + + if (e->op == TOKtuple) + { + TupleExp *te = (TupleExp *)e; + if (iexps->dim - 1 + te->exps->dim > nelems) + goto Lnomatch; + + iexps->remove(pos); + iexps->insert(pos, te->exps); + (*iexps)[pos] = Expression::combine(te->e0, (*iexps)[pos]); + goto Lexpand1; + } + else if (isAliasThisTuple(e)) + { + VarDeclaration *v = copyToTemp(0, "__tup", e); + v->semantic(sc); + VarExp *ve = new VarExp(loc, v); + ve->type = e->type; + + exps->setDim(1); + (*exps)[0] = ve; + expandAliasThisTuples(exps, 0); + + for (size_t u = 0; u < exps->dim ; u++) + { + Lexpand2: + Expression *ee = (*exps)[u]; + arg = Parameter::getNth(tt->arguments, pos + u); + arg->type = arg->type->semantic(loc, sc); + //printf("[%d+%d] exps->dim = %d, ", pos, u, exps->dim); + //printf("ee = (%s %s, %s), ", Token::tochars[ee->op], ee->toChars(), ee->type->toChars()); + //printf("arg = (%s, %s)\n", arg->toChars(), arg->type->toChars()); + + size_t iexps_dim = iexps->dim - 1 + exps->dim; + if (iexps_dim > nelems) + goto Lnomatch; + if (ee->type->implicitConvTo(arg->type)) + continue; + + if (expandAliasThisTuples(exps, u) != -1) + goto Lexpand2; + } + + if ((*exps)[0] != ve) + { + Expression *e0 = (*exps)[0]; + (*exps)[0] = new CommaExp(loc, new DeclarationExp(loc, v), e0); + (*exps)[0]->type = e0->type; + + iexps->remove(pos); + iexps->insert(pos, exps); + goto Lexpand1; + } + } + } + if (iexps->dim < nelems) + goto Lnomatch; + + ie = new TupleExp(_init->loc, iexps); + } +Lnomatch: + + if (ie && ie->op == TOKtuple) + { + TupleExp *te = (TupleExp *)ie; + size_t tedim = te->exps->dim; + if (tedim != nelems) + { + ::error(loc, "tuple of %d elements cannot be assigned to tuple of %d elements", (int)tedim, (int)nelems); + for (size_t u = tedim; u < nelems; u++) // fill dummy expression + te->exps->push(new ErrorExp()); + } + } + + Objects *exps = new Objects(); + exps->setDim(nelems); + for (size_t i = 0; i < nelems; i++) + { + Parameter *arg = Parameter::getNth(tt->arguments, i); + + OutBuffer buf; + buf.printf("__%s_field_%llu", ident->toChars(), (ulonglong)i); + const char *name = buf.extractString(); + Identifier *id = Identifier::idPool(name); + + Initializer *ti; + if (ie) + { + Expression *einit = ie; + if (ie->op == TOKtuple) + { + TupleExp *te = (TupleExp *)ie; + einit = (*te->exps)[i]; + if (i == 0) + einit = Expression::combine(te->e0, einit); + } + ti = new ExpInitializer(einit->loc, einit); + } + else + ti = _init ? _init->syntaxCopy() : NULL; + + VarDeclaration *v = new VarDeclaration(loc, arg->type, id, ti); + v->storage_class |= STCtemp | storage_class; + if (arg->storageClass & STCparameter) + v->storage_class |= arg->storageClass; + //printf("declaring field %s of type %s\n", v->toChars(), v->type->toChars()); + v->semantic(sc); + + if (sc->scopesym) + { + //printf("adding %s to %s\n", v->toChars(), sc->scopesym->toChars()); + if (sc->scopesym->members) + sc->scopesym->members->push(v); + } + + Expression *e = new DsymbolExp(loc, v); + (*exps)[i] = e; + } + TupleDeclaration *v2 = new TupleDeclaration(loc, ident, exps); + v2->parent = this->parent; + v2->isexp = true; + aliassym = v2; + semanticRun = PASSsemanticdone; + return; + } + + /* Storage class can modify the type + */ + type = type->addStorageClass(storage_class); + + /* Adjust storage class to reflect type + */ + if (type->isConst()) + { + storage_class |= STCconst; + if (type->isShared()) + storage_class |= STCshared; + } + else if (type->isImmutable()) + storage_class |= STCimmutable; + else if (type->isShared()) + storage_class |= STCshared; + else if (type->isWild()) + storage_class |= STCwild; + + if (StorageClass stc = storage_class & (STCsynchronized | STCoverride | STCabstract | STCfinal)) + { + if (stc == STCfinal) + error("cannot be final, perhaps you meant const?"); + else + { + OutBuffer buf; + stcToBuffer(&buf, stc); + error("cannot be %s", buf.peekString()); + } + storage_class &= ~stc; // strip off + } + + if (storage_class & STCscope) + { + StorageClass stc = storage_class & (STCstatic | STCextern | STCmanifest | STCtls | STCgshared); + if (stc) + { + OutBuffer buf; + stcToBuffer(&buf, stc); + error("cannot be 'scope' and '%s'", buf.peekString()); + } + else if (isMember()) + { + error("field cannot be 'scope'"); + } + else if (!type->hasPointers()) + { + storage_class &= ~STCscope; // silently ignore; may occur in generic code + } + } + + if (storage_class & (STCstatic | STCextern | STCmanifest | STCtemplateparameter | STCtls | STCgshared | STCctfe)) + { + } + else + { + AggregateDeclaration *aad = parent->isAggregateDeclaration(); + if (aad) + { + if (global.params.vfield && + storage_class & (STCconst | STCimmutable) && _init && !_init->isVoidInitializer()) + { + const char *s = (storage_class & STCimmutable) ? "immutable" : "const"; + message(loc, "`%s.%s` is `%s` field", ad->toPrettyChars(), toChars(), s); + } + storage_class |= STCfield; + if (tbn->ty == Tstruct && ((TypeStruct *)tbn)->sym->noDefaultCtor) + { + if (!isThisDeclaration() && !_init) + aad->noDefaultCtor = true; + } + } + + InterfaceDeclaration *id = parent->isInterfaceDeclaration(); + if (id) + { + error("field not allowed in interface"); + } + else if (aad && aad->sizeok == SIZEOKdone) + { + error("cannot be further field because it will change the determined %s size", aad->toChars()); + } + + /* Templates cannot add fields to aggregates + */ + 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 + AggregateDeclaration *ad2 = ti->tempdecl->isMember(); + if (ad2 && storage_class != STCundefined) + { + error("cannot use template to add field to aggregate '%s'", ad2->toChars()); + } + } + } + + if ((storage_class & (STCref | STCparameter | STCforeach | STCtemp | STCresult)) == STCref && ident != Id::This) + { + error("only parameters or foreach declarations can be ref"); + } + + if (type->hasWild()) + { + if (storage_class & (STCstatic | STCextern | STCtls | STCgshared | STCmanifest | STCfield) || + isDataseg() + ) + { + error("only parameters or stack based variables can be inout"); + } + FuncDeclaration *func = sc->func; + if (func) + { + if (func->fes) + func = func->fes->func; + bool isWild = false; + for (FuncDeclaration *fd = func; fd; fd = fd->toParent2()->isFuncDeclaration()) + { + if (((TypeFunction *)fd->type)->iswild) + { + isWild = true; + break; + } + } + if (!isWild) + { + error("inout variables can only be declared inside inout functions"); + } + } + } + + if (!(storage_class & (STCctfe | STCref | STCresult)) && tbn->ty == Tstruct && + ((TypeStruct *)tbn)->sym->noDefaultCtor) + { + if (!_init) + { + if (isField()) + { + /* For fields, we'll check the constructor later to make sure it is initialized + */ + storage_class |= STCnodefaultctor; + } + else if (storage_class & STCparameter) + ; + else + error("default construction is disabled for type %s", type->toChars()); + } + } + + FuncDeclaration *fd = parent->isFuncDeclaration(); + if (type->isscope() && !(storage_class & STCnodtor)) + { + if (storage_class & (STCfield | STCout | STCref | STCstatic | STCmanifest | STCtls | STCgshared) || !fd) + { + error("globals, statics, fields, manifest constants, ref and out parameters cannot be scope"); + } + + if (!(storage_class & STCscope)) + { + if (!(storage_class & STCparameter) && ident != Id::withSym) + error("reference to scope class must be scope"); + } + } + + // Calculate type size + safety checks + if (sc->func && !sc->intypeof) + { + if (_init && _init->isVoidInitializer() && type->hasPointers()) // get type size + { + if (sc->func->setUnsafe()) + error("void initializers for pointers not allowed in safe functions"); + } + else if (!_init && + !(storage_class & (STCstatic | STCextern | STCtls | STCgshared | STCmanifest | STCfield | STCparameter)) && + type->hasVoidInitPointers()) + { + if (sc->func->setUnsafe()) + error("void initializers for pointers not allowed in safe functions"); + } + } + + if (!_init && !fd) + { + // If not mutable, initializable by constructor only + storage_class |= STCctorinit; + } + + if (_init) + storage_class |= STCinit; // remember we had an explicit initializer + else if (storage_class & STCmanifest) + error("manifest constants must have initializers"); + + bool isBlit = false; + d_uns64 sz = 0; + if (!_init && !sc->inunion && !(storage_class & (STCstatic | STCgshared | STCextern)) && fd && + (!(storage_class & (STCfield | STCin | STCforeach | STCparameter | STCresult)) + || (storage_class & STCout)) && + (sz = type->size()) != 0) + { + // Provide a default initializer + //printf("Providing default initializer for '%s'\n", toChars()); + if (sz == SIZE_INVALID && type->ty != Terror) + error("size of type %s is invalid", type->toChars()); + + Type *tv = type; + while (tv->ty == Tsarray) // Don't skip Tenum + tv = tv->nextOf(); + if (tv->needsNested()) + { + /* Nested struct requires valid enclosing frame pointer. + * In StructLiteralExp::toElem(), it's calculated. + */ + assert(tv->toBasetype()->ty == Tstruct); + checkFrameAccess(loc, sc, ((TypeStruct *)tbn)->sym); + + Expression *e = tv->defaultInitLiteral(loc); + e = new BlitExp(loc, new VarExp(loc, this), e); + e = ::semantic(e, sc); + _init = new ExpInitializer(loc, e); + goto Ldtor; + } + if (tv->ty == Tstruct && ((TypeStruct *)tv)->sym->zeroInit == 1) + { + /* If a struct is all zeros, as a special case + * set it's initializer to the integer 0. + * In AssignExp::toElem(), we check for this and issue + * a memset() to initialize the struct. + * Must do same check in interpreter. + */ + Expression *e = new IntegerExp(loc, 0, Type::tint32); + e = new BlitExp(loc, new VarExp(loc, this), e); + e->type = type; // don't type check this, it would fail + _init = new ExpInitializer(loc, e); + goto Ldtor; + } + if (type->baseElemOf()->ty == Tvoid) + { + error("%s does not have a default initializer", type->toChars()); + } + else if (Expression *e = type->defaultInit(loc)) + { + _init = new ExpInitializer(loc, e); + } + // Default initializer is always a blit + isBlit = true; + } + + if (_init) + { + sc = sc->push(); + sc->stc &= ~(STC_TYPECTOR | STCpure | STCnothrow | STCnogc | STCref | STCdisable); + + ExpInitializer *ei = _init->isExpInitializer(); + if (ei) // Bugzilla 13424: Preset the required type to fail in FuncLiteralDeclaration::semantic3 + ei->exp = inferType(ei->exp, type); + + // If inside function, there is no semantic3() call + if (sc->func || sc->intypeof == 1) + { + // If local variable, use AssignExp to handle all the various + // possibilities. + if (fd && + !(storage_class & (STCmanifest | STCstatic | STCtls | STCgshared | STCextern)) && + !_init->isVoidInitializer()) + { + //printf("fd = '%s', var = '%s'\n", fd->toChars(), toChars()); + if (!ei) + { + ArrayInitializer *ai = _init->isArrayInitializer(); + Expression *e; + if (ai && tb->ty == Taarray) + e = ai->toAssocArrayLiteral(); + else + e = initializerToExpression(_init); + if (!e) + { + // Run semantic, but don't need to interpret + _init = ::semantic(_init, sc, type, INITnointerpret); + e = initializerToExpression(_init); + if (!e) + { + error("is not a static and cannot have static initializer"); + e = new ErrorExp(); + } + } + ei = new ExpInitializer(_init->loc, e); + _init = ei; + } + + Expression *exp = ei->exp; + Expression *e1 = new VarExp(loc, this); + if (isBlit) + exp = new BlitExp(loc, e1, exp); + else + exp = new ConstructExp(loc, e1, exp); + canassign++; + exp = ::semantic(exp, sc); + canassign--; + exp = exp->optimize(WANTvalue); + + if (exp->op == TOKerror) + { + _init = new ErrorInitializer(); + ei = NULL; + } + else + ei->exp = exp; + + if (ei && isScope()) + { + Expression *ex = ei->exp; + while (ex->op == TOKcomma) + ex = ((CommaExp *)ex)->e2; + if (ex->op == TOKblit || ex->op == TOKconstruct) + ex = ((AssignExp *)ex)->e2; + if (ex->op == TOKnew) + { + // See if initializer is a NewExp that can be allocated on the stack + NewExp *ne = (NewExp *)ex; + if (type->toBasetype()->ty == Tclass) + { + if (ne->newargs && ne->newargs->dim > 1) + { + mynew = true; + } + else + { + ne->onstack = true; + onstack = true; + } + } + } + else if (ex->op == TOKfunction) + { + // or a delegate that doesn't escape a reference to the function + FuncDeclaration *f = ((FuncExp *)ex)->fd; + f->tookAddressOf--; + } + } + } + else + { + // Bugzilla 14166: Don't run CTFE for the temporary variables inside typeof + _init = ::semantic(_init, sc, type, sc->intypeof == 1 ? INITnointerpret : INITinterpret); + } + } + else if (parent->isAggregateDeclaration()) + { + _scope = scx ? scx : sc->copy(); + _scope->setNoFree(); + } + else if (storage_class & (STCconst | STCimmutable | STCmanifest) || + type->isConst() || type->isImmutable()) + { + /* Because we may need the results of a const declaration in a + * subsequent type, such as an array dimension, before semantic2() + * gets ordinarily run, try to run semantic2() now. + * Ignore failure. + */ + + if (!inferred) + { + unsigned errors = global.errors; + inuse++; + if (ei) + { + Expression *exp = ei->exp->syntaxCopy(); + + bool needctfe = isDataseg() || (storage_class & STCmanifest); + if (needctfe) sc = sc->startCTFE(); + exp = ::semantic(exp, sc); + exp = resolveProperties(sc, exp); + if (needctfe) sc = sc->endCTFE(); + + Type *tb2 = type->toBasetype(); + Type *ti = exp->type->toBasetype(); + + /* The problem is the following code: + * struct CopyTest { + * double x; + * this(double a) { x = a * 10.0;} + * this(this) { x += 2.0; } + * } + * const CopyTest z = CopyTest(5.3); // ok + * const CopyTest w = z; // not ok, postblit not run + * static assert(w.x == 55.0); + * because the postblit doesn't get run on the initialization of w. + */ + if (ti->ty == Tstruct) + { + StructDeclaration *sd = ((TypeStruct *)ti)->sym; + /* Look to see if initializer involves a copy constructor + * (which implies a postblit) + */ + // there is a copy constructor + // and exp is the same struct + if (sd->postblit && + tb2->toDsymbol(NULL) == sd) + { + // The only allowable initializer is a (non-copy) constructor + if (exp->isLvalue()) + error("of type struct %s uses this(this), which is not allowed in static initialization", tb2->toChars()); + } + } + ei->exp = exp; + } + _init = ::semantic(_init, sc, type, INITinterpret); + inuse--; + if (global.errors > errors) + { + _init = new ErrorInitializer(); + type = Type::terror; + } + } + else + { + _scope = scx ? scx : sc->copy(); + _scope->setNoFree(); + } + } + sc = sc->pop(); + } + +Ldtor: + /* Build code to execute destruction, if necessary + */ + edtor = callScopeDtor(sc); + if (edtor) + { + if (sc->func && storage_class & (STCstatic | STCgshared)) + edtor = ::semantic(edtor, sc->_module->_scope); + else + edtor = ::semantic(edtor, sc); + +#if 0 // currently disabled because of std.stdio.stdin, stdout and stderr + if (isDataseg() && !(storage_class & STCextern)) + error("static storage variables cannot have destructors"); +#endif + } + + semanticRun = PASSsemanticdone; + + if (type->toBasetype()->ty == Terror) + errors = true; + + if (sc->scopesym && !sc->scopesym->isAggregateDeclaration()) + { + for (ScopeDsymbol *sym = sc->scopesym; sym && endlinnum == 0; + sym = sym->parent ? sym->parent->isScopeDsymbol() : NULL) + endlinnum = sym->endlinnum; + } +} + +void VarDeclaration::semantic2(Scope *sc) +{ + if (semanticRun < PASSsemanticdone && inuse) + return; + + //printf("VarDeclaration::semantic2('%s')\n", toChars()); + + if (_init && !toParent()->isFuncDeclaration()) + { + inuse++; + // Bugzilla 14166: Don't run CTFE for the temporary variables inside typeof + _init = ::semantic(_init, sc, type, sc->intypeof == 1 ? INITnointerpret : INITinterpret); + inuse--; + } + if (_init && storage_class & STCmanifest) + { + /* Cannot initializer enums with CTFE classreferences and addresses of struct literals. + * Scan initializer looking for them. Issue error if found. + */ + if (ExpInitializer *ei = _init->isExpInitializer()) + { + struct EnumInitializer + { + static bool arrayHasInvalidEnumInitializer(Expressions *elems) + { + for (size_t i = 0; i < elems->dim; i++) + { + Expression *e = (*elems)[i]; + if (e && hasInvalidEnumInitializer(e)) + return true; + } + return false; + } + + static bool hasInvalidEnumInitializer(Expression *e) + { + if (e->op == TOKclassreference) + return true; + if (e->op == TOKaddress && ((AddrExp *)e)->e1->op == TOKstructliteral) + return true; + if (e->op == TOKarrayliteral) + return arrayHasInvalidEnumInitializer(((ArrayLiteralExp *)e)->elements); + if (e->op == TOKstructliteral) + return arrayHasInvalidEnumInitializer(((StructLiteralExp *)e)->elements); + if (e->op == TOKassocarrayliteral) + { + AssocArrayLiteralExp *ae = (AssocArrayLiteralExp *)e; + return arrayHasInvalidEnumInitializer(ae->values) || + arrayHasInvalidEnumInitializer(ae->keys); + } + return false; + } + }; + if (EnumInitializer::hasInvalidEnumInitializer(ei->exp)) + error(": Unable to initialize enum with class or pointer to struct. Use static const variable instead."); + } + } + else if (_init && isThreadlocal()) + { + if ((type->ty == Tclass) && type->isMutable() && !type->isShared()) + { + ExpInitializer *ei = _init->isExpInitializer(); + if (ei && ei->exp->op == TOKclassreference) + error("is mutable. Only const or immutable class thread local variable are allowed, not %s", type->toChars()); + } + else if (type->ty == Tpointer && type->nextOf()->ty == Tstruct && type->nextOf()->isMutable() &&!type->nextOf()->isShared()) + { + ExpInitializer *ei = _init->isExpInitializer(); + if (ei && ei->exp->op == TOKaddress && ((AddrExp *)ei->exp)->e1->op == TOKstructliteral) + { + error("is a pointer to mutable struct. Only pointers to const, immutable or shared struct thread local variable are allowed, not %s", type->toChars()); + } + } + } + semanticRun = PASSsemantic2done; +} + +void VarDeclaration::setFieldOffset(AggregateDeclaration *ad, unsigned *poffset, bool isunion) +{ + //printf("VarDeclaration::setFieldOffset(ad = %s) %s\n", ad->toChars(), toChars()); + + if (aliassym) + { + // If this variable was really a tuple, set the offsets for the tuple fields + TupleDeclaration *v2 = aliassym->isTupleDeclaration(); + assert(v2); + for (size_t i = 0; i < v2->objects->dim; i++) + { + RootObject *o = (*v2->objects)[i]; + assert(o->dyncast() == DYNCAST_EXPRESSION); + Expression *e = (Expression *)o; + assert(e->op == TOKdsymbol); + DsymbolExp *se = (DsymbolExp *)e; + se->s->setFieldOffset(ad, poffset, isunion); + } + return; + } + + if (!isField()) + return; + assert(!(storage_class & (STCstatic | STCextern | STCparameter | STCtls))); + + //printf("+VarDeclaration::setFieldOffset(ad = %s) %s\n", ad->toChars(), toChars()); + + /* Fields that are tuples appear both as part of TupleDeclarations and + * as members. That means ignore them if they are already a field. + */ + if (offset) + { + // already a field + *poffset = ad->structsize; // Bugzilla 13613 + return; + } + for (size_t i = 0; i < ad->fields.dim; i++) + { + if (ad->fields[i] == this) + { + // already a field + *poffset = ad->structsize; // Bugzilla 13613 + return; + } + } + + // Check for forward referenced types which will fail the size() call + Type *t = type->toBasetype(); + if (storage_class & STCref) + { + // References are the size of a pointer + t = Type::tvoidptr; + } + Type *tv = t->baseElemOf(); + if (tv->ty == Tstruct) + { + TypeStruct *ts = (TypeStruct *)tv; + assert(ts->sym != ad); // already checked in ad->determineFields() + if (!ts->sym->determineSize(loc)) + { + type = Type::terror; + errors = true; + return; + } + } + + // List in ad->fields. Even if the type is error, it's necessary to avoid + // pointless error diagnostic "more initializers than fields" on struct literal. + ad->fields.push(this); + + if (t->ty == Terror) + return; + + const d_uns64 sz = t->size(loc); + assert(sz != SIZE_INVALID && sz < UINT32_MAX); + unsigned memsize = (unsigned)sz; // size of member + unsigned memalignsize = Target::fieldalign(t); // size of member for alignment purposes + + offset = AggregateDeclaration::placeField(poffset, memsize, memalignsize, alignment, + &ad->structsize, &ad->alignsize, isunion); + + //printf("\t%s: memalignsize = %d\n", toChars(), memalignsize); + + //printf(" addField '%s' to '%s' at offset %d, size = %d\n", toChars(), ad->toChars(), offset, memsize); +} + +const char *VarDeclaration::kind() const +{ + return "variable"; +} + +Dsymbol *VarDeclaration::toAlias() +{ + //printf("VarDeclaration::toAlias('%s', this = %p, aliassym = %p)\n", toChars(), this, aliassym); + if ((!type || !type->deco) && _scope) + semantic(_scope); + + assert(this != aliassym); + Dsymbol *s = aliassym ? aliassym->toAlias() : this; + return s; +} + +AggregateDeclaration *VarDeclaration::isThis() +{ + AggregateDeclaration *ad = NULL; + + if (!(storage_class & (STCstatic | STCextern | STCmanifest | STCtemplateparameter | + STCtls | STCgshared | STCctfe))) + { + for (Dsymbol *s = this; s; s = s->parent) + { + ad = s->isMember(); + if (ad) + break; + if (!s->parent || !s->parent->isTemplateMixin()) break; + } + } + return ad; +} + +bool VarDeclaration::needThis() +{ + //printf("VarDeclaration::needThis(%s, x%x)\n", toChars(), storage_class); + return isField(); +} + +bool VarDeclaration::isExport() const +{ + return protection.kind == PROTexport; +} + +bool VarDeclaration::isImportedSymbol() const +{ + if (protection.kind == PROTexport && !_init && + (storage_class & STCstatic || parent->isModule())) + return true; + return false; +} + +/******************************************* + * Helper function for the expansion of manifest constant. + */ +Expression *VarDeclaration::expandInitializer(Loc loc) +{ + assert((storage_class & STCmanifest) && _init); + + Expression *e = getConstInitializer(); + if (!e) + { + ::error(loc, "cannot make expression out of initializer for %s", toChars()); + return new ErrorExp(); + } + + e = e->copy(); + e->loc = loc; // for better error message + return e; +} + +void VarDeclaration::checkCtorConstInit() +{ +#if 0 /* doesn't work if more than one static ctor */ + if (ctorinit == 0 && isCtorinit() && !isField()) + error("missing initializer in static constructor for const variable"); +#endif +} + +bool lambdaCheckForNestedRef(Expression *e, Scope *sc); + +/************************************ + * Check to see if this variable is actually in an enclosing function + * rather than the current one. + * Returns true if error occurs. + */ +bool VarDeclaration::checkNestedReference(Scope *sc, Loc loc) +{ + //printf("VarDeclaration::checkNestedReference() %s\n", toChars()); + if (sc->intypeof == 1 || (sc->flags & SCOPEctfe)) + return false; + if (!parent || parent == sc->parent) + return false; + if (isDataseg() || (storage_class & STCmanifest)) + return false; + + // The current function + FuncDeclaration *fdthis = sc->parent->isFuncDeclaration(); + if (!fdthis) + return false; // out of function scope + + Dsymbol *p = toParent2(); + + // Function literals from fdthis to p must be delegates + checkNestedRef(fdthis, p); + + // The function that this variable is in + FuncDeclaration *fdv = p->isFuncDeclaration(); + if (!fdv || fdv == fdthis) + return false; + + // Add fdthis to nestedrefs[] if not already there + for (size_t i = 0; 1; i++) + { + if (i == nestedrefs.dim) + { + nestedrefs.push(fdthis); + break; + } + if (nestedrefs[i] == fdthis) + break; + } + + /* __require and __ensure will always get called directly, + * so they never make outer functions closure. + */ + if (fdthis->ident == Id::require || fdthis->ident == Id::ensure) + return false; + + //printf("\tfdv = %s\n", fdv->toChars()); + //printf("\tfdthis = %s\n", fdthis->toChars()); + if (loc.filename) + { + int lv = fdthis->getLevel(loc, sc, fdv); + if (lv == -2) // error + return true; + } + + // Add this to fdv->closureVars[] if not already there + for (size_t i = 0; 1; i++) + { + if (i == fdv->closureVars.dim) + { + if (!sc->intypeof && !(sc->flags & SCOPEcompile)) + fdv->closureVars.push(this); + break; + } + if (fdv->closureVars[i] == this) + break; + } + + //printf("fdthis is %s\n", fdthis->toChars()); + //printf("var %s in function %s is nested ref\n", toChars(), fdv->toChars()); + // __dollar creates problems because it isn't a real variable Bugzilla 3326 + if (ident == Id::dollar) + { + ::error(loc, "cannnot use $ inside a function literal"); + return true; + } + + if (ident == Id::withSym) // Bugzilla 1759 + { + ExpInitializer *ez = _init->isExpInitializer(); + assert(ez); + Expression *e = ez->exp; + if (e->op == TOKconstruct || e->op == TOKblit) + e = ((AssignExp *)e)->e2; + return lambdaCheckForNestedRef(e, sc); + } + + return false; +} + +/******************************************* + * If variable has a constant expression initializer, get it. + * Otherwise, return NULL. + */ + +Expression *VarDeclaration::getConstInitializer(bool needFullType) +{ + assert(type && _init); + + // Ungag errors when not speculative + unsigned oldgag = global.gag; + if (global.gag) + { + Dsymbol *sym = toParent()->isAggregateDeclaration(); + if (sym && !sym->isSpeculative()) + global.gag = 0; + } + + if (_scope) + { + inuse++; + _init = ::semantic(_init, _scope, type, INITinterpret); + _scope = NULL; + inuse--; + } + Expression *e = initializerToExpression(_init, needFullType ? type : NULL); + + global.gag = oldgag; + return e; +} + +/************************************* + * Return true if we can take the address of this variable. + */ + +bool VarDeclaration::canTakeAddressOf() +{ + return !(storage_class & STCmanifest); +} + + +/******************************* + * Does symbol go into data segment? + * Includes extern variables. + */ + +bool VarDeclaration::isDataseg() +{ + if (isdataseg == 0) // the value is not cached + { + isdataseg = 2; // The Variables does not go into the datasegment + + if (!canTakeAddressOf()) + { + return false; + } + + Dsymbol *parent = toParent(); + if (!parent && !(storage_class & STCstatic)) + { + error("forward referenced"); + type = Type::terror; + } + else if (storage_class & (STCstatic | STCextern | STCtls | STCgshared) || + parent->isModule() || parent->isTemplateInstance() || parent->isNspace()) + { + assert(!isParameter() && !isResult()); + isdataseg = 1; // It is in the DataSegment + } + } + + return (isdataseg == 1); +} + +/************************************ + * Does symbol go into thread local storage? + */ + +bool VarDeclaration::isThreadlocal() +{ + //printf("VarDeclaration::isThreadlocal(%p, '%s')\n", this, toChars()); + /* Data defaults to being thread-local. It is not thread-local + * if it is immutable, const or shared. + */ + bool i = isDataseg() && + !(storage_class & (STCimmutable | STCconst | STCshared | STCgshared)); + //printf("\treturn %d\n", i); + return i; +} + +/******************************************** + * Can variable be read and written by CTFE? + */ + +bool VarDeclaration::isCTFE() +{ + return (storage_class & STCctfe) != 0; // || !isDataseg(); +} + +bool VarDeclaration::isOverlappedWith(VarDeclaration *v) +{ + const d_uns64 vsz = v->type->size(); + const d_uns64 tsz = type->size(); + assert(vsz != SIZE_INVALID && tsz != SIZE_INVALID); + return offset < v->offset + vsz && + v->offset < offset + tsz; +} + +bool VarDeclaration::hasPointers() +{ + //printf("VarDeclaration::hasPointers() %s, ty = %d\n", toChars(), type->ty); + return (!isDataseg() && type->hasPointers()); +} + +/****************************************** + * Return true if variable needs to call the destructor. + */ + +bool VarDeclaration::needsScopeDtor() +{ + //printf("VarDeclaration::needsScopeDtor() %s\n", toChars()); + return edtor && !(storage_class & STCnodtor); +} + + +/****************************************** + * If a variable has a scope destructor call, return call for it. + * Otherwise, return NULL. + */ + +Expression *VarDeclaration::callScopeDtor(Scope *) +{ + //printf("VarDeclaration::callScopeDtor() %s\n", toChars()); + + // Destruction of STCfield's is handled by buildDtor() + if (storage_class & (STCnodtor | STCref | STCout | STCfield)) + { + return NULL; + } + + Expression *e = NULL; + + // Destructors for structs and arrays of structs + Type *tv = type->baseElemOf(); + if (tv->ty == Tstruct) + { + StructDeclaration *sd = ((TypeStruct *)tv)->sym; + if (!sd->dtor || sd->errors) + return NULL; + + const d_uns64 sz = type->size(); + assert(sz != SIZE_INVALID); + if (!sz) + return NULL; + + if (type->toBasetype()->ty == Tstruct) + { + // v.__xdtor() + e = new VarExp(loc, this); + + /* This is a hack so we can call destructors on const/immutable objects. + * Need to add things like "const ~this()" and "immutable ~this()" to + * fix properly. + */ + e->type = e->type->mutableOf(); + + // Enable calling destructors on shared objects. + // The destructor is always a single, non-overloaded function, + // and must serve both shared and non-shared objects. + e->type = e->type->unSharedOf(); + + e = new DotVarExp(loc, e, sd->dtor, false); + e = new CallExp(loc, e); + } + else + { + // __ArrayDtor(v[0 .. n]) + e = new VarExp(loc, this); + + const d_uns64 sdsz = sd->type->size(); + assert(sdsz != SIZE_INVALID && sdsz != 0); + const d_uns64 n = sz / sdsz; + e = new SliceExp(loc, e, new IntegerExp(loc, 0, Type::tsize_t), + new IntegerExp(loc, n, Type::tsize_t)); + // Prevent redundant bounds check + ((SliceExp *)e)->upperIsInBounds = true; + ((SliceExp *)e)->lowerIsLessThanUpper = true; + + // This is a hack so we can call destructors on const/immutable objects. + e->type = sd->type->arrayOf(); + + e = new CallExp(loc, new IdentifierExp(loc, Id::__ArrayDtor), e); + } + return e; + } + + // Destructors for classes + if (storage_class & (STCauto | STCscope) && !(storage_class & STCparameter)) + { + for (ClassDeclaration *cd = type->isClassHandle(); + cd; + cd = cd->baseClass) + { + /* We can do better if there's a way with onstack + * classes to determine if there's no way the monitor + * could be set. + */ + //if (cd->isInterfaceDeclaration()) + //error("interface %s cannot be scope", cd->toChars()); + + // Destroying C++ scope classes crashes currently. Since C++ class dtors are not currently supported, simply do not run dtors for them. + // See https://issues.dlang.org/show_bug.cgi?id=13182 + if (cd->cpp) + { + break; + } + if (mynew || onstack) // if any destructors + { + // delete this; + Expression *ec; + + ec = new VarExp(loc, this); + e = new DeleteExp(loc, ec, true); + e->type = Type::tvoid; + break; + } + } + } + return e; +} + +/********************************** + * Determine if `this` has a lifetime that lasts past + * the destruction of `v` + * Params: + * v = variable to test against + * Returns: + * true if it does + */ +bool VarDeclaration::enclosesLifetimeOf(VarDeclaration *v) const +{ + return sequenceNumber < v->sequenceNumber; +} + +/****************************************** + */ + +void ObjectNotFound(Identifier *id) +{ + Type::error(Loc(), "%s not found. object.d may be incorrectly installed or corrupt.", id->toChars()); + fatal(); +} + +/******************************** SymbolDeclaration ********************************/ + +SymbolDeclaration::SymbolDeclaration(Loc loc, StructDeclaration *dsym) + : Declaration(dsym->ident) +{ + this->loc = loc; + this->dsym = dsym; + storage_class |= STCconst; +} + +/********************************* TypeInfoDeclaration ****************************/ + +TypeInfoDeclaration::TypeInfoDeclaration(Type *tinfo) + : VarDeclaration(Loc(), Type::dtypeinfo->type, tinfo->getTypeInfoIdent(), NULL) +{ + this->tinfo = tinfo; + storage_class = STCstatic | STCgshared; + protection = Prot(PROTpublic); + linkage = LINKc; + alignment = Target::ptrsize; +} + +TypeInfoDeclaration *TypeInfoDeclaration::create(Type *tinfo) +{ + return new TypeInfoDeclaration(tinfo); +} + +Dsymbol *TypeInfoDeclaration::syntaxCopy(Dsymbol *) +{ + assert(0); // should never be produced by syntax + return NULL; +} + +void TypeInfoDeclaration::semantic(Scope *) +{ + assert(linkage == LINKc); +} + +const char *TypeInfoDeclaration::toChars() +{ + //printf("TypeInfoDeclaration::toChars() tinfo = %s\n", tinfo->toChars()); + OutBuffer buf; + buf.writestring("typeid("); + buf.writestring(tinfo->toChars()); + buf.writeByte(')'); + return buf.extractString(); +} + +/***************************** TypeInfoConstDeclaration **********************/ + +TypeInfoConstDeclaration::TypeInfoConstDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfoconst) + { + ObjectNotFound(Id::TypeInfo_Const); + } + type = Type::typeinfoconst->type; +} + +TypeInfoConstDeclaration *TypeInfoConstDeclaration::create(Type *tinfo) +{ + return new TypeInfoConstDeclaration(tinfo); +} + +/***************************** TypeInfoInvariantDeclaration **********************/ + +TypeInfoInvariantDeclaration::TypeInfoInvariantDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfoinvariant) + { + ObjectNotFound(Id::TypeInfo_Invariant); + } + type = Type::typeinfoinvariant->type; +} + +TypeInfoInvariantDeclaration *TypeInfoInvariantDeclaration::create(Type *tinfo) +{ + return new TypeInfoInvariantDeclaration(tinfo); +} + +/***************************** TypeInfoSharedDeclaration **********************/ + +TypeInfoSharedDeclaration::TypeInfoSharedDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfoshared) + { + ObjectNotFound(Id::TypeInfo_Shared); + } + type = Type::typeinfoshared->type; +} + +TypeInfoSharedDeclaration *TypeInfoSharedDeclaration::create(Type *tinfo) +{ + return new TypeInfoSharedDeclaration(tinfo); +} + +/***************************** TypeInfoWildDeclaration **********************/ + +TypeInfoWildDeclaration::TypeInfoWildDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfowild) + { + ObjectNotFound(Id::TypeInfo_Wild); + } + type = Type::typeinfowild->type; +} + +TypeInfoWildDeclaration *TypeInfoWildDeclaration::create(Type *tinfo) +{ + return new TypeInfoWildDeclaration(tinfo); +} + +/***************************** TypeInfoStructDeclaration **********************/ + +TypeInfoStructDeclaration::TypeInfoStructDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfostruct) + { + ObjectNotFound(Id::TypeInfo_Struct); + } + type = Type::typeinfostruct->type; +} + +TypeInfoStructDeclaration *TypeInfoStructDeclaration::create(Type *tinfo) +{ + return new TypeInfoStructDeclaration(tinfo); +} + +/***************************** TypeInfoClassDeclaration ***********************/ + +TypeInfoClassDeclaration::TypeInfoClassDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfoclass) + { + ObjectNotFound(Id::TypeInfo_Class); + } + type = Type::typeinfoclass->type; +} + +TypeInfoClassDeclaration *TypeInfoClassDeclaration::create(Type *tinfo) +{ + return new TypeInfoClassDeclaration(tinfo); +} + +/***************************** TypeInfoInterfaceDeclaration *******************/ + +TypeInfoInterfaceDeclaration::TypeInfoInterfaceDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfointerface) + { + ObjectNotFound(Id::TypeInfo_Interface); + } + type = Type::typeinfointerface->type; +} + +TypeInfoInterfaceDeclaration *TypeInfoInterfaceDeclaration::create(Type *tinfo) +{ + return new TypeInfoInterfaceDeclaration(tinfo); +} + +/***************************** TypeInfoPointerDeclaration *********************/ + +TypeInfoPointerDeclaration::TypeInfoPointerDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfopointer) + { + ObjectNotFound(Id::TypeInfo_Pointer); + } + type = Type::typeinfopointer->type; +} + +TypeInfoPointerDeclaration *TypeInfoPointerDeclaration::create(Type *tinfo) +{ + return new TypeInfoPointerDeclaration(tinfo); +} + +/***************************** TypeInfoArrayDeclaration ***********************/ + +TypeInfoArrayDeclaration::TypeInfoArrayDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfoarray) + { + ObjectNotFound(Id::TypeInfo_Array); + } + type = Type::typeinfoarray->type; +} + +TypeInfoArrayDeclaration *TypeInfoArrayDeclaration::create(Type *tinfo) +{ + return new TypeInfoArrayDeclaration(tinfo); +} + +/***************************** TypeInfoStaticArrayDeclaration *****************/ + +TypeInfoStaticArrayDeclaration::TypeInfoStaticArrayDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfostaticarray) + { + ObjectNotFound(Id::TypeInfo_StaticArray); + } + type = Type::typeinfostaticarray->type; +} + +TypeInfoStaticArrayDeclaration *TypeInfoStaticArrayDeclaration::create(Type *tinfo) +{ + return new TypeInfoStaticArrayDeclaration(tinfo); +} + +/***************************** TypeInfoAssociativeArrayDeclaration ************/ + +TypeInfoAssociativeArrayDeclaration::TypeInfoAssociativeArrayDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfoassociativearray) + { + ObjectNotFound(Id::TypeInfo_AssociativeArray); + } + type = Type::typeinfoassociativearray->type; +} + +TypeInfoAssociativeArrayDeclaration *TypeInfoAssociativeArrayDeclaration::create(Type *tinfo) +{ + return new TypeInfoAssociativeArrayDeclaration(tinfo); +} + +/***************************** TypeInfoVectorDeclaration ***********************/ + +TypeInfoVectorDeclaration::TypeInfoVectorDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfovector) + { + ObjectNotFound(Id::TypeInfo_Vector); + } + type = Type::typeinfovector->type; +} + +TypeInfoVectorDeclaration *TypeInfoVectorDeclaration::create(Type *tinfo) +{ + return new TypeInfoVectorDeclaration(tinfo); +} + +/***************************** TypeInfoEnumDeclaration ***********************/ + +TypeInfoEnumDeclaration::TypeInfoEnumDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfoenum) + { + ObjectNotFound(Id::TypeInfo_Enum); + } + type = Type::typeinfoenum->type; +} + +TypeInfoEnumDeclaration *TypeInfoEnumDeclaration::create(Type *tinfo) +{ + return new TypeInfoEnumDeclaration(tinfo); +} + +/***************************** TypeInfoFunctionDeclaration ********************/ + +TypeInfoFunctionDeclaration::TypeInfoFunctionDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfofunction) + { + ObjectNotFound(Id::TypeInfo_Function); + } + type = Type::typeinfofunction->type; +} + +TypeInfoFunctionDeclaration *TypeInfoFunctionDeclaration::create(Type *tinfo) +{ + return new TypeInfoFunctionDeclaration(tinfo); +} + +/***************************** TypeInfoDelegateDeclaration ********************/ + +TypeInfoDelegateDeclaration::TypeInfoDelegateDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfodelegate) + { + ObjectNotFound(Id::TypeInfo_Delegate); + } + type = Type::typeinfodelegate->type; +} + +TypeInfoDelegateDeclaration *TypeInfoDelegateDeclaration::create(Type *tinfo) +{ + return new TypeInfoDelegateDeclaration(tinfo); +} + +/***************************** TypeInfoTupleDeclaration **********************/ + +TypeInfoTupleDeclaration::TypeInfoTupleDeclaration(Type *tinfo) + : TypeInfoDeclaration(tinfo) +{ + if (!Type::typeinfotypelist) + { + ObjectNotFound(Id::TypeInfo_Tuple); + } + type = Type::typeinfotypelist->type; +} + +TypeInfoTupleDeclaration *TypeInfoTupleDeclaration::create(Type *tinfo) +{ + return new TypeInfoTupleDeclaration(tinfo); +} + +/********************************* ThisDeclaration ****************************/ + +// For the "this" parameter to member functions + +ThisDeclaration::ThisDeclaration(Loc loc, Type *t) + : VarDeclaration(loc, t, Id::This, NULL) +{ + storage_class |= STCnodtor; +} + +Dsymbol *ThisDeclaration::syntaxCopy(Dsymbol *) +{ + assert(0); // should never be produced by syntax + return NULL; +} +