/* 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());
// as AliasDeclaration::semantic, in case we're called first.
// see https://issues.dlang.org/show_bug.cgi?id=21001
storage_class |= sc->stc & STCdeprecated;
protection = sc->protection;
userAttribDecl = sc->userAttribDecl;
// TypeTraits needs to know if it's located in an AliasDeclaration
sc->flags |= SCOPEalias;
if (aliassym)
{
FuncDeclaration *fd = aliassym->isFuncLiteralDeclaration();
TemplateDeclaration *td = aliassym->isTemplateDeclaration();
if (fd || (td && td->literal))
{
if (fd && fd->semanticRun >= PASSsemanticdone)
{
sc->flags &= ~SCOPEalias;
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;
}
sc->flags &= ~SCOPEalias;
return;
}
if (aliassym->isTemplateInstance())
aliassym->semantic(sc);
sc->flags &= ~SCOPEalias;
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);
}
sc->flags &= ~SCOPEalias;
}
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->isCPPclass())
{
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;
}