mirrors/dmd
1
0
Fork 0
mirror of https://github.com/dlang/dmd.git synced 2025-04-27 13:40:11 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 11
dmd/src/declaration.c
k-hara 3a5c42c44d fix Issue 13860 - template required forward reference for typeof(member) 
In a struct member function S.foo, 'this' is declared as a ref variable by `declareThis()` in `FuncDeclaration::semantic3()`.
But in `VarDeclaration::semantic`, `type->hasPointer()` will needlessly try to resolve struct fwdref.

All parameter variables won't be declared with void initializer, so the reordering fixes the issue.
2015-01-20 13:56:02 +09:00

2397 lines
70 KiB
C
Raw Blame History

/* Compiler implementation of the D programming language
* Copyright (c) 1999-2014 by Digital Mars
* 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 <stdio.h>
#include <assert.h>
#include "init.h"
#include "declaration.h"
#include "attrib.h"
#include "mtype.h"
#include "template.h"
#include "scope.h"
#include "aggregate.h"
#include "module.h"
#include "import.h"
#include "id.h"
#include "expression.h"
#include "statement.h"
#include "ctfe.h"
#include "target.h"
Expression *getTypeInfo(Type *t, Scope *sc);
bool checkFrameAccess(Loc loc, Scope *sc, AggregateDeclaration *ad, size_t iStart = 0)
{
if (!ad->isNested())
return true;
Dsymbol *s = sc->func;
if (s)
{
Dsymbol *sparent = ad->toParent2();
//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());
while (s)
{
if (s == sparent) // hit!
{
bool result = true;
for (size_t i = iStart; i < ad->fields.dim; i++)
{
VarDeclaration *vd = ad->fields[i];
if (AggregateDeclaration *ad2 = isAggregate(vd->type))
{
if (ad2->isStructDeclaration())
{
bool r = checkFrameAccess(loc, sc, ad2);
result = result && r;
}
}
}
return result;
}
if (FuncDeclaration *fd = s->isFuncDeclaration())
{
if (!fd->isThis() && !fd->isNested())
break;
}
if (AggregateDeclaration *ad2 = s->isAggregateDeclaration())
{
if (ad2->storage_class & STCstatic)
break;
}
s = s->toParent2();
}
}
error(loc, "cannot access frame pointer of %s", ad->toPrettyChars());
return false;
}
/********************************* Declaration ****************************/
Declaration::Declaration(Identifier *id)
: Dsymbol(id)
{
type = NULL;
originalType = NULL;
storage_class = STCundefined;
protection = Prot(PROTundefined);
linkage = LINKdefault;
inuse = 0;
sem = SemanticStart;
mangleOverride = NULL;
}
void Declaration::semantic(Scope *sc)
{
}
const char *Declaration::kind()
{
return "declaration";
}
unsigned Declaration::size(Loc loc)
{
assert(type);
return (unsigned)type->size();
}
bool Declaration::isDelete()
{
return false;
}
bool Declaration::isDataseg()
{
return false;
}
bool Declaration::isThreadlocal()
{
return false;
}
bool Declaration::isCodeseg()
{
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 *t, 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(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 *s)
{
assert(0);
return NULL;
}
const char *TupleDeclaration::kind()
{
return "tuple";
}
Type *TupleDeclaration::getType()
{
/* If this tuple represents a type, return that type
*/
//printf("TupleDeclaration::getType() %s\n", toChars());
if (isexp)
return NULL;
if (!tupletype)
{
/* It's only a type tuple if all the Object's are types
*/
for (size_t i = 0; i < objects->dim; i++)
{ 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());
#if 0
buf.printf("_%s_%d", ident->toChars(), i);
char *name = (char *)buf.extractData();
Identifier *id = new Identifier(name, TOKidentifier);
Parameter *arg = new Parameter(STCin, t, id, NULL);
#else
Parameter *arg = new Parameter(0, t, NULL, NULL);
#endif
(*args)[i] = arg;
if (!t->deco)
hasdeco = 0;
}
tupletype = new TypeTuple(args);
if (hasdeco)
return tupletype->semantic(Loc(), NULL);
}
return tupletype;
}
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;
this->inSemantic = 0;
assert(type);
}
AliasDeclaration::AliasDeclaration(Loc loc, Identifier *id, Dsymbol *s)
: Declaration(id)
{
//printf("AliasDeclaration(id = '%s', s = %p)\n", id->toChars(), s);
assert(s != this);
this->loc = loc;
this->type = NULL;
this->aliassym = s;
this->import = NULL;
this->overnext = NULL;
this->inSemantic = 0;
assert(s);
}
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)
{
//printf("AliasDeclaration::semantic() %s\n", toChars());
if (aliassym)
{
if (aliassym->isTemplateInstance())
aliassym->semantic(sc);
return;
}
this->inSemantic = 1;
storage_class |= sc->stc & STCdeprecated;
protection = sc->protection;
userAttribDecl = sc->userAttribDecl;
// 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 *savedtype = type;
Dsymbol *s;
Type *t;
Expression *e;
// 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 resolve() will:
* const x = 3;
* alias x y;
* try to alias y to 3.
*/
s = type->toDsymbol(sc);
if (s && s == this)
{
error("cannot resolve");
s = NULL;
type = Type::terror;
}
if (s && ((s->getType() && type->equals(s->getType())) || s->isEnumMember()))
goto L2; // it's a symbolic alias
type = type->addStorageClass(storage_class);
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.
sc = sc->push();
sc->stc |= storage_class & (STCref | STCnothrow | STCnogc | STCpure | STCshared | STCdisable);
type->resolve(loc, sc, &e, &t, &s);
sc = sc->pop();
}
else
type->resolve(loc, sc, &e, &t, &s);
if (s)
{
goto L2;
}
else if (e)
{
// Try to convert Expression to Dsymbol
s = getDsymbol(e);
if (s)
goto L2;
if (e->op != TOKerror)
error("cannot alias an expression %s", e->toChars());
t = e->type;
}
else if (t)
{
type = t->semantic(loc, sc);
//printf("\talias resolved to type %s\n", type->toChars());
}
if (overnext)
ScopeDsymbol::multiplyDefined(Loc(), overnext, this);
this->inSemantic = 0;
if (global.gag && errors != global.errors)
type = savedtype;
return;
L2:
//printf("alias is a symbol %s %s\n", s->kind(), s->toChars());
type = NULL;
VarDeclaration *v = s->isVarDeclaration();
if (0 && v && v->linkage == LINKdefault)
{
error("forward reference of %s", v->toChars());
s = NULL;
}
else
{
Dsymbol *savedovernext = overnext;
Dsymbol *sa = s->toAlias();
if (FuncDeclaration *fd = sa->isFuncDeclaration())
{
if (overnext)
{
FuncAliasDeclaration *fa = new FuncAliasDeclaration(fd);
if (!fa->overloadInsert(overnext))
ScopeDsymbol::multiplyDefined(Loc(), overnext, fd);
overnext = NULL;
s = fa;
s->parent = sc->parent;
}
}
else if (TemplateDeclaration *td = sa->isTemplateDeclaration())
{
if (overnext)
{
OverDeclaration *od = new OverDeclaration(td);
if (!od->overloadInsert(overnext))
ScopeDsymbol::multiplyDefined(Loc(), overnext, td);
overnext = NULL;
s = od;
s->parent = sc->parent;
}
}
else if (OverDeclaration *od = sa->isOverDeclaration())
{
if (overnext)
{
OverDeclaration *od2 = new OverDeclaration(od);
if (!od2->overloadInsert(overnext))
ScopeDsymbol::multiplyDefined(Loc(), overnext, od);
overnext = NULL;
s = od2;
s->parent = sc->parent;
}
}
else if (OverloadSet *os = sa->isOverloadSet())
{
if (overnext)
{
os->push(overnext);
overnext = NULL;
s = os;
s->parent = sc->parent;
}
}
if (overnext)
ScopeDsymbol::multiplyDefined(Loc(), overnext, this);
if (s == this)
{
assert(global.errors);
s = NULL;
}
if (global.gag && errors != global.errors)
{
type = savedtype;
overnext = savedovernext;
s = NULL;
}
}
//printf("setting aliassym %s to %s %s\n", toChars(), s->kind(), s->toChars());
aliassym = s;
this->inSemantic = 0;
}
bool AliasDeclaration::overloadInsert(Dsymbol *s)
{
/* Don't know yet what the aliased symbol is, so assume it can
* be overloaded and check later for correctness.
*/
//printf("AliasDeclaration::overloadInsert('%s')\n", s->toChars());
if (aliassym) // see test/test56.d
{
Dsymbol *sa = aliassym->toAlias();
if (FuncDeclaration *fd = sa->isFuncDeclaration())
{
FuncAliasDeclaration *fa = new FuncAliasDeclaration(fd);
aliassym = fa;
return fa->overloadInsert(s);
}
if (TemplateDeclaration *td = sa->isTemplateDeclaration())
{
OverDeclaration *od = new OverDeclaration(td);
aliassym = od;
return od->overloadInsert(s);
}
}
if (overnext == NULL)
{
if (s == this)
{
return true;
}
overnext = s;
return true;
}
else
{
return overnext->overloadInsert(s);
}
}
const char *AliasDeclaration::kind()
{
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', inSemantic = %d)\n",
// loc.toChars(), toChars(), this, aliassym, aliassym ? aliassym->kind() : "", inSemantic);
assert(this != aliassym);
//static int count; if (++count == 10) *(char*)0=0;
if (inSemantic == 1 && type && scope)
{
inSemantic = 2;
unsigned olderrors = global.errors;
Dsymbol *s = type->toDsymbol(scope);
//printf("[%s] %s, s = %p, this = %p\n", loc.toChars(), type->toChars(), s, this);
if (!s || global.errors != olderrors)
goto Lerr;
s = s->toAlias();
if (global.errors != olderrors)
goto Lerr;
aliassym = s;
inSemantic = 0;
}
if (inSemantic)
{
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 (aliassym || type->deco)
; // semantic is already done.
else if (import && import->scope)
{
/* If this is an internal alias for selective/renamed import,
* resolve it under the correct scope.
*/
import->semantic(NULL);
}
else if (scope)
semantic(scope);
inSemantic = 1;
Dsymbol *s = aliassym ? aliassym->toAlias() : this;
inSemantic = 0;
return s;
}
/****************************** OverDeclaration **************************/
OverDeclaration::OverDeclaration(Dsymbol *s, bool hasOverloads)
: Declaration(s->ident)
{
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()
{
return "overload alias"; // todo
}
void OverDeclaration::semantic(Scope *sc)
{
}
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 == NULL)
{
if (s == this)
{
return true;
}
overnext = s;
return true;
}
else
{
return overnext->overloadInsert(s);
}
}
Dsymbol *OverDeclaration::toAlias()
{
return this;
}
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);
#ifdef DEBUG
if (!type && !init)
{ printf("VarDeclaration('%s')\n", id->toChars());
//*(char*)0=0;
}
#endif
assert(type || init);
this->type = type;
this->init = init;
this->loc = loc;
offset = 0;
noscope = 0;
isargptr = false;
alignment = 0;
ctorinit = 0;
aliassym = NULL;
onstack = 0;
canassign = 0;
overlapped = false;
lastVar = NULL;
ctfeAdrOnStack = -1;
rundtor = NULL;
edtor = NULL;
range = NULL;
}
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 0
printf("VarDeclaration::semantic('%s', parent = '%s') sem = %d\n", toChars(), sc->parent ? sc->parent->toChars() : NULL, sem);
printf(" type = %s\n", type ? type->toChars() : "null");
printf(" stc = x%x\n", sc->stc);
printf(" storage_class = x%llx\n", storage_class);
printf("linkage = %d\n", sc->linkage);
//if (strcmp(toChars(), "mul") == 0) halt();
#endif
// if (sem > SemanticStart)
// return;
// sem = SemanticIn;
if (sem >= SemanticDone)
return;
Scope *scx = NULL;
if (scope)
{
sc = scope;
scx = sc;
scope = NULL;
}
/* Pick up storage classes from context, but skip synchronized
*/
storage_class |= (sc->stc & ~STCsynchronized);
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 = init->inferType(sc);
type = init->toExpression()->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");
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->structalign;
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);
// Calculate type size + safety checks
if (sc->func && !sc->intypeof && !isMember())
{
if (storage_class & STCgshared)
{
if (sc->func->setUnsafe())
error("__gshared not allowed in safe functions; use shared");
}
if (init && init->isVoidInitializer() &&
type->hasPointers()) // get type size
{
if (sc->func->setUnsafe())
error("void initializers for pointers not allowed in safe functions");
}
}
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()) ? init->toExpression() : NULL;
if (ie) ie = ie->semantic(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))
{
Identifier *id = Identifier::generateId("__tup");
ExpInitializer *ei = new ExpInitializer(e->loc, e);
VarDeclaration *v = new VarDeclaration(loc, NULL, id, ei);
v->storage_class = STCtemp | STCctfe | STCref | STCforeach;
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;
sem = SemanticDone;
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 (storage_class & (STCmanifest | STCstatic | STCgshared))
{
}
else if (isSynchronized())
{
error("variable %s cannot be synchronized", toChars());
}
else if (isOverride())
{
error("override cannot be applied to variable");
}
else if (isAbstract())
{
error("abstract cannot be applied to variable");
}
else if (storage_class & STCfinal)
{
error("final cannot be applied to variable, perhaps you meant const?");
}
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 *p = loc.toChars();
const char *s = (storage_class & STCimmutable) ? "immutable" : "const";
fprintf(global.stdmsg, "%s: %s.%s is %s field\n", p ? p : "", 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");
}
/* 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)) == 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() && !noscope)
{
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");
}
}
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;
if (!init && !sc->inunion && !(storage_class & (STCstatic | STCgshared | STCextern)) && fd &&
(!(storage_class & (STCfield | STCin | STCforeach | STCparameter | STCresult))
|| (storage_class & STCout)) &&
type->size() != 0)
{
// Provide a default initializer
//printf("Providing default initializer for '%s'\n", toChars());
if (type->needsNested())
{
Type *tv = type;
while (tv->toBasetype()->ty == Tsarray)
tv = tv->toBasetype()->nextOf();
assert(tv->toBasetype()->ty == Tstruct);
/* Nested struct requires valid enclosing frame pointer.
* In StructLiteralExp::toElem(), it's calculated.
*/
checkFrameAccess(loc, sc, ((TypeStruct *)tv->toBasetype())->sym);
Expression *e = tv->defaultInitLiteral(loc);
Expression *e1 = new VarExp(loc, this);
e = new BlitExp(loc, e1, e);
e = e->semantic(sc);
init = new ExpInitializer(loc, e);
goto Ldtor;
}
else if (type->ty == Tstruct &&
((TypeStruct *)type)->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);
Expression *e1;
e1 = new VarExp(loc, this);
e = new BlitExp(loc, e1, e);
e->type = e1->type; // don't type check this, it would fail
init = new ExpInitializer(loc, e);
goto Ldtor;
}
else if (type->baseElemOf()->ty == Tvoid)
{
error("%s does not have a default initializer", type->toChars());
}
else
{
init = getExpInitializer();
}
// 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)
{
// 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 = init->toExpression();
if (!e)
{
// Run semantic, but don't need to interpret
init = init->semantic(sc, type, INITnointerpret);
e = init->toExpression();
if (!e)
{
error("is not a static and cannot have static initializer");
return;
}
}
ei = new ExpInitializer(init->loc, e);
init = ei;
}
Expression *e1 = new VarExp(loc, this);
if (isBlit)
ei->exp = new BlitExp(loc, e1, ei->exp);
else
ei->exp = new ConstructExp(loc, e1, ei->exp);
canassign++;
ei->exp = ei->exp->semantic(sc);
canassign--;
ei->exp->optimize(WANTvalue);
if (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 (!(ne->newargs && ne->newargs->dim > 1) && type->toBasetype()->ty == Tclass)
{
ne->onstack = 1;
onstack = 1;
if (type->isBaseOf(ne->newtype->semantic(loc, sc), NULL))
onstack = 2;
}
}
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
{
init = init->semantic(sc, type, 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 = exp->semantic(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 = init->semantic(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 = edtor->semantic(sc->module->scope);
else
edtor = edtor->semantic(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
}
sem = SemanticDone;
if (type->toBasetype()->ty == Terror)
errors = true;
}
void VarDeclaration::semantic2(Scope *sc)
{
if (sem < SemanticDone && inuse)
return;
//printf("VarDeclaration::semantic2('%s')\n", toChars());
// Inside unions, default to void initializers
if (!init && sc->inunion && !toParent()->isFuncDeclaration())
{
AggregateDeclaration *aad = parent->isAggregateDeclaration();
if (aad)
{
if (aad->fields[0] == this)
{
int hasinit = 0;
for (size_t i = 1; i < aad->fields.dim; i++)
{
if (aad->fields[i]->init &&
!aad->fields[i]->init->isVoidInitializer())
{
hasinit = 1;
break;
}
}
if (!hasinit)
init = new ExpInitializer(loc, type->defaultInitLiteral(loc));
}
else
init = new VoidInitializer(loc);
}
}
if (init && !toParent()->isFuncDeclaration())
{
inuse++;
#if 0
ExpInitializer *ei = init->isExpInitializer();
if (ei)
{
ei->exp->print();
printf("type = %p\n", ei->exp->type);
}
#endif
init = init->semantic(sc, type, INITinterpret);
inuse--;
}
if (storage_class & STCmanifest)
{
#if 0
if ((type->ty == Tclass)&&type->isMutable())
{
error("is mutable. Only const and immutable class enum are allowed, not %s", type->toChars());
}
else if (type->ty == Tpointer && type->nextOf()->ty == Tstruct && type->nextOf()->isMutable())
{
ExpInitializer *ei = init->isExpInitializer();
if (ei->exp->op == TOKaddress && ((AddrExp *)ei->exp)->e1->op == TOKstructliteral)
{
error("is a pointer to mutable struct. Only pointers to const or immutable struct enum are allowed, not %s", type->toChars());
}
}
#else
if (type->ty == Tclass && init)
{
ExpInitializer *ei = init->isExpInitializer();
if (ei->exp->op == TOKclassreference)
error(": Unable to initialize enum with class or pointer to struct. Use static const variable instead.");
}
else if (type->ty == Tpointer && type->nextOf()->ty == Tstruct)
{
ExpInitializer *ei = init->isExpInitializer();
if (ei && ei->exp->op == TOKaddress && ((AddrExp *)ei->exp)->e1->op == TOKstructliteral)
{
error(": Unable to initialize enum with class or pointer to struct. Use static const variable instead.");
}
}
#endif
}
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());
}
}
}
sem = Semantic2Done;
}
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)));
/* 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;
}
if (t->ty == Tstruct || t->ty == Tsarray)
{
Type *tv = t->baseElemOf();
if (tv->ty == Tstruct)
{
TypeStruct *ts = (TypeStruct *)tv;
if (ts->sym == ad)
{
const char *s = (t->ty == Tsarray) ? "static array of " : "";
ad->error("cannot have field %s with %ssame struct type", toChars(), s);
}
if (ts->sym->sizeok != SIZEOKdone && ts->sym->scope)
ts->sym->semantic(NULL);
if (ts->sym->sizeok != SIZEOKdone)
{
ad->sizeok = SIZEOKfwd; // cannot finish; flag as forward referenced
return;
}
}
}
if (t->ty == Tident)
{
ad->sizeok = SIZEOKfwd; // cannot finish; flag as forward referenced
return;
}
if (t->ty == Terror)
return;
unsigned memsize = (unsigned)t->size(loc); // 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);
ad->fields.push(this);
}
const char *VarDeclaration::kind()
{
return "variable";
}
Dsymbol *VarDeclaration::toAlias()
{
//printf("VarDeclaration::toAlias('%s', this = %p, aliassym = %p)\n", toChars(), this, aliassym);
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()
{
return protection.kind == PROTexport;
}
bool VarDeclaration::isImportedSymbol()
{
if (protection.kind == PROTexport && !init &&
(storage_class & STCstatic || parent->isModule()))
return true;
return false;
}
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
}
/************************************
* Check to see if this variable is actually in an enclosing function
* rather than the current one.
*/
void VarDeclaration::checkNestedReference(Scope *sc, Loc loc)
{
//printf("VarDeclaration::checkNestedReference() %s\n", toChars());
if (parent && !isDataseg() && parent != sc->parent &&
!(storage_class & STCmanifest))
{
// The function that this variable is in
FuncDeclaration *fdv = toParent()->isFuncDeclaration();
// The current function
FuncDeclaration *fdthis = sc->parent->isFuncDeclaration();
if (fdv && fdthis && fdv != fdthis)
{
// 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;
}
if (fdthis->ident != Id::ensure)
{
/* __ensure is always called directly,
* so it never becomes closure.
*/
//printf("\tfdv = %s\n", fdv->toChars());
//printf("\tfdthis = %s\n", fdthis->toChars());
if (loc.filename)
fdthis->getLevel(loc, sc, fdv);
// Function literals from fdthis to fdv must be delegates
for (Dsymbol *s = fdthis; s && s != fdv; s = s->toParent2())
{
// function literal has reference to enclosing scope is delegate
if (FuncLiteralDeclaration *fld = s->isFuncLiteralDeclaration())
{
fld->tok = TOKdelegate;
#if 0
/* This is necessary to avoid breaking tests for 8751 & 8793.
* See: compilable/testInference.d
*/
// if is a mutable variable or
// has any mutable indirections or
// does not belong to pure function
if (type->isMutable() ||
!type->implicitConvTo(type->immutableOf()) ||
!fdv->isPureBypassingInference())
{
fld->setImpure(); // Bugzilla 9415
}
#endif
}
}
// 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");
}
}
}
}
/****************************
* Get ExpInitializer for a variable, if there is one.
*/
ExpInitializer *VarDeclaration::getExpInitializer()
{
ExpInitializer *ei;
if (init)
ei = init->isExpInitializer();
else
{
Expression *e = type->defaultInit(loc);
if (e)
ei = new ExpInitializer(loc, e);
else
ei = NULL;
}
return ei;
}
/*******************************************
* 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 = init->semantic(scope, type, INITinterpret);
scope = NULL;
inuse--;
}
Expression *e = init->toExpression(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 0
printf("VarDeclaration::isDataseg(%p, '%s')\n", this, toChars());
printf("%llx, isModule: %p, isTemplateInstance: %p\n", storage_class & (STCstatic | STCconst), parent->isModule(), parent->isTemplateInstance());
printf("parent = '%s'\n", parent->toChars());
#endif
if (!canTakeAddressOf())
return false;
Dsymbol *parent = toParent();
if (!parent && !(storage_class & STCstatic))
{
error("forward referenced");
type = Type::terror;
return false;
}
return (storage_class & (STCstatic | STCextern | STCtls | STCgshared) ||
parent->isModule() ||
parent->isTemplateInstance());
}
/************************************
* 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::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::needsAutoDtor()
{
//printf("VarDeclaration::needsAutoDtor() %s\n", toChars());
if (noscope || !edtor)
return false;
return true;
}
/******************************************
* If a variable has a scope destructor call, return call for it.
* Otherwise, return NULL.
*/
Expression *VarDeclaration::callScopeDtor(Scope *sc)
{ Expression *e = NULL;
//printf("VarDeclaration::callScopeDtor() %s\n", toChars());
// Destruction of STCfield's is handled by buildDtor()
if (noscope || storage_class & (STCnodtor | STCref | STCout | STCfield))
{
return NULL;
}
// Destructors for structs and arrays of structs
Type *tv = type->baseElemOf();
if (tv->ty == Tstruct)
{
TypeStruct *ts = (TypeStruct *)tv;
StructDeclaration *sd = ts->sym;
if (sd->dtor)
{
if (type->toBasetype()->ty == Tsarray)
{
// Typeinfo.destroy(cast(void*)&v);
Expression *ea = new SymOffExp(loc, this, 0, 0);
ea = new CastExp(loc, ea, Type::tvoid->pointerTo());
Expressions *args = new Expressions();
args->push(ea);
Expression *et = getTypeInfo(type, sc);
et = new DotIdExp(loc, et, Id::destroy);
e = new CallExp(loc, et, args);
}
else
{
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();
e = new DotVarExp(loc, e, sd->dtor, 0);
e = new CallExp(loc, e);
}
return e;
}
}
// Destructors for classes
if (storage_class & (STCauto | STCscope))
{
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());
if (cd->cpp)
{
// Destructors are not supported on extern(C++) classes
break;
}
if (1 || onstack || cd->dtors.dim) // if any destructors
{
// delete this;
Expression *ec;
ec = new VarExp(loc, this);
e = new DeleteExp(loc, ec);
e->type = Type::tvoid;
break;
}
}
}
return e;
}
/******************************************
*/
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;
}
/********************************* ClassInfoDeclaration ****************************/
ClassInfoDeclaration::ClassInfoDeclaration(ClassDeclaration *cd)
: VarDeclaration(Loc(), Type::typeinfoclass->type, cd->ident, NULL)
{
this->cd = cd;
storage_class = STCstatic | STCgshared;
}
Dsymbol *ClassInfoDeclaration::syntaxCopy(Dsymbol *s)
{
assert(0); // should never be produced by syntax
return NULL;
}
void ClassInfoDeclaration::semantic(Scope *sc)
{
}
/********************************* TypeInfoDeclaration ****************************/
TypeInfoDeclaration::TypeInfoDeclaration(Type *tinfo, int internal)
: VarDeclaration(Loc(), Type::dtypeinfo->type, tinfo->getTypeInfoIdent(internal), NULL)
{
this->tinfo = tinfo;
storage_class = STCstatic | STCgshared;
protection = Prot(PROTpublic);
linkage = LINKc;
}
TypeInfoDeclaration *TypeInfoDeclaration::create(Type *tinfo, int internal)
{
return new TypeInfoDeclaration(tinfo, internal);
}
Dsymbol *TypeInfoDeclaration::syntaxCopy(Dsymbol *s)
{
assert(0); // should never be produced by syntax
return NULL;
}
void TypeInfoDeclaration::semantic(Scope *sc)
{
assert(linkage == LINKc);
}
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, 0)
{
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, 0)
{
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, 0)
{
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, 0)
{
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, 0)
{
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, 0)
{
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, 0)
{
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, 0)
{
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, 0)
{
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, 0)
{
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, 0)
{
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, 0)
{
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, 0)
{
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, 0)
{
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, 0)
{
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, 0)
{
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)
{
noscope = 1;
}
Dsymbol *ThisDeclaration::syntaxCopy(Dsymbol *s)
{
assert(0); // should never be produced by syntax
return NULL;
}
Reference in a new issue View git blame Copy permalink