blob: d9a9055cb99b69c6c2e4eb0e3d3351930be35a37 [file] [log] [blame]
/* 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/clone.c
*/
#include "root/dsystem.h"
#include "root/root.h"
#include "aggregate.h"
#include "scope.h"
#include "mtype.h"
#include "declaration.h"
#include "module.h"
#include "id.h"
#include "expression.h"
#include "statement.h"
#include "init.h"
#include "template.h"
#include "tokens.h"
Expression *semantic(Expression *e, Scope *sc);
/*******************************************
* Merge function attributes pure, nothrow, @safe, @nogc, and @disable
*/
StorageClass mergeFuncAttrs(StorageClass s1, FuncDeclaration *f)
{
if (!f)
return s1;
StorageClass s2 = (f->storage_class & STCdisable);
TypeFunction *tf = (TypeFunction *)f->type;
if (tf->trust == TRUSTsafe)
s2 |= STCsafe;
else if (tf->trust == TRUSTsystem)
s2 |= STCsystem;
else if (tf->trust == TRUSTtrusted)
s2 |= STCtrusted;
if (tf->purity != PUREimpure)
s2 |= STCpure;
if (tf->isnothrow)
s2 |= STCnothrow;
if (tf->isnogc)
s2 |= STCnogc;
StorageClass stc = 0;
StorageClass sa = s1 & s2;
StorageClass so = s1 | s2;
if (so & STCsystem)
stc |= STCsystem;
else if (sa & STCtrusted)
stc |= STCtrusted;
else if ((so & (STCtrusted | STCsafe)) == (STCtrusted | STCsafe))
stc |= STCtrusted;
else if (sa & STCsafe)
stc |= STCsafe;
if (sa & STCpure)
stc |= STCpure;
if (sa & STCnothrow)
stc |= STCnothrow;
if (sa & STCnogc)
stc |= STCnogc;
if (so & STCdisable)
stc |= STCdisable;
return stc;
}
/*******************************************
* Check given aggregate actually has an identity opAssign or not.
* Params:
* ad = struct or class
* sc = current scope
* Returns:
* if found, returns FuncDeclaration of opAssign, otherwise null
*/
FuncDeclaration *hasIdentityOpAssign(AggregateDeclaration *ad, Scope *sc)
{
Dsymbol *assign = search_function(ad, Id::assign);
if (assign)
{
/* check identity opAssign exists
*/
UnionExp er; new(&er) NullExp(ad->loc, ad->type); // dummy rvalue
UnionExp el; new(&el) IdentifierExp(ad->loc, Id::p); // dummy lvalue
el.exp()->type = ad->type;
Expressions a;
a.setDim(1);
unsigned errors = global.startGagging(); // Do not report errors, even if the template opAssign fbody makes it.
sc = sc->push();
sc->tinst = NULL;
sc->minst = NULL;
a[0] = er.exp();
FuncDeclaration *f = resolveFuncCall(ad->loc, sc, assign, NULL, ad->type, &a, 1);
if (!f)
{
a[0] = el.exp();
f = resolveFuncCall(ad->loc, sc, assign, NULL, ad->type, &a, 1);
}
sc = sc->pop();
global.endGagging(errors);
if (f)
{
if (f->errors)
return NULL;
int varargs;
Parameters *fparams = f->getParameters(&varargs);
if (fparams->dim >= 1)
{
Parameter *fparam0 = Parameter::getNth(fparams, 0);
if (fparam0->type->toDsymbol(NULL) != ad)
f = NULL;
}
}
// BUGS: This detection mechanism cannot find some opAssign-s like follows:
// struct S { void opAssign(ref immutable S) const; }
return f;
}
return NULL;
}
/*******************************************
* We need an opAssign for the struct if
* it has a destructor or a postblit.
* We need to generate one if a user-specified one does not exist.
*/
bool needOpAssign(StructDeclaration *sd)
{
//printf("StructDeclaration::needOpAssign() %s\n", sd->toChars());
if (sd->isUnionDeclaration())
return false;
if (sd->hasIdentityAssign)
goto Lneed; // because has identity==elaborate opAssign
if (sd->dtor || sd->postblit)
goto Lneed;
/* If any of the fields need an opAssign, then we
* need it too.
*/
for (size_t i = 0; i < sd->fields.dim; i++)
{
VarDeclaration *v = sd->fields[i];
if (v->storage_class & STCref)
continue;
if (v->overlapped) // if field of a union
continue; // user must handle it themselves
Type *tv = v->type->baseElemOf();
if (tv->ty == Tstruct)
{
TypeStruct *ts = (TypeStruct *)tv;
if (ts->sym->isUnionDeclaration())
continue;
if (needOpAssign(ts->sym))
goto Lneed;
}
}
//printf("\tdontneed\n");
return false;
Lneed:
//printf("\tneed\n");
return true;
}
/******************************************
* Build opAssign for struct.
* ref S opAssign(S s) { ... }
*
* Note that s will be constructed onto the stack, and probably
* copy-constructed in caller site.
*
* If S has copy copy construction and/or destructor,
* the body will make bit-wise object swap:
* S __swap = this; // bit copy
* this = s; // bit copy
* __swap.dtor();
* Instead of running the destructor on s, run it on tmp instead.
*
* Otherwise, the body will make member-wise assignments:
* Then, the body is:
* this.field1 = s.field1;
* this.field2 = s.field2;
* ...;
*/
FuncDeclaration *buildOpAssign(StructDeclaration *sd, Scope *sc)
{
if (FuncDeclaration *f = hasIdentityOpAssign(sd, sc))
{
sd->hasIdentityAssign = true;
return f;
}
// Even if non-identity opAssign is defined, built-in identity opAssign
// will be defined.
if (!needOpAssign(sd))
return NULL;
//printf("StructDeclaration::buildOpAssign() %s\n", sd->toChars());
StorageClass stc = STCsafe | STCnothrow | STCpure | STCnogc;
Loc declLoc = sd->loc;
Loc loc = Loc(); // internal code should have no loc to prevent coverage
// One of our sub-field might have `@disable opAssign` so we need to
// check for it.
// In this event, it will be reflected by having `stc` (opAssign's
// storage class) include `STCdisabled`.
for (size_t i = 0; i < sd->fields.dim; i++)
{
VarDeclaration *v = sd->fields[i];
if (v->storage_class & STCref)
continue;
if (v->overlapped)
continue;
Type *tv = v->type->baseElemOf();
if (tv->ty != Tstruct)
continue;
StructDeclaration *sdv = ((TypeStruct *)tv)->sym;
stc = mergeFuncAttrs(stc, hasIdentityOpAssign(sdv, sc));
}
if (sd->dtor || sd->postblit)
{
if (!sd->type->isAssignable()) // Bugzilla 13044
return NULL;
stc = mergeFuncAttrs(stc, sd->dtor);
if (stc & STCsafe)
stc = (stc & ~STCsafe) | STCtrusted;
}
Parameters *fparams = new Parameters;
fparams->push(new Parameter(STCnodtor, sd->type, Id::p, NULL));
TypeFunction *tf = new TypeFunction(fparams, sd->handleType(), 0, LINKd, stc | STCref);
FuncDeclaration *fop = new FuncDeclaration(declLoc, Loc(), Id::assign, stc, tf);
fop->storage_class |= STCinference;
fop->generated = true;
Expression *e = NULL;
if (stc & STCdisable)
{
}
else if (sd->dtor || sd->postblit)
{
/* Do swap this and rhs.
* __swap = this; this = s; __swap.dtor();
*/
//printf("\tswap copy\n");
Identifier *idtmp = Identifier::generateId("__swap");
VarDeclaration *tmp = NULL;
AssignExp *ec = NULL;
if (sd->dtor)
{
tmp = new VarDeclaration(loc, sd->type, idtmp, new VoidInitializer(loc));
tmp->storage_class |= STCnodtor | STCtemp | STCctfe;
e = new DeclarationExp(loc, tmp);
ec = new BlitExp(loc, new VarExp(loc, tmp), new ThisExp(loc));
e = Expression::combine(e, ec);
}
ec = new BlitExp(loc, new ThisExp(loc), new IdentifierExp(loc, Id::p));
e = Expression::combine(e, ec);
if (sd->dtor)
{
/* Instead of running the destructor on s, run it
* on tmp. This avoids needing to copy tmp back in to s.
*/
Expression *ec2 = new DotVarExp(loc, new VarExp(loc, tmp), sd->dtor, false);
ec2 = new CallExp(loc, ec2);
e = Expression::combine(e, ec2);
}
}
else
{
/* Do memberwise copy.
*
* If sd is a nested struct, its vthis field assignment is:
* 1. If it's nested in a class, it's a rebind of class reference.
* 2. If it's nested in a function or struct, it's an update of void*.
* In both cases, it will change the parent context.
*/
//printf("\tmemberwise copy\n");
for (size_t i = 0; i < sd->fields.dim; i++)
{
VarDeclaration *v = sd->fields[i];
// this.v = s.v;
AssignExp *ec = new AssignExp(loc,
new DotVarExp(loc, new ThisExp(loc), v),
new DotVarExp(loc, new IdentifierExp(loc, Id::p), v));
e = Expression::combine(e, ec);
}
}
if (e)
{
Statement *s1 = new ExpStatement(loc, e);
/* Add:
* return this;
*/
e = new ThisExp(loc);
Statement *s2 = new ReturnStatement(loc, e);
fop->fbody = new CompoundStatement(loc, s1, s2);
tf->isreturn = true;
}
sd->members->push(fop);
fop->addMember(sc, sd);
sd->hasIdentityAssign = true; // temporary mark identity assignable
unsigned errors = global.startGagging(); // Do not report errors, even if the template opAssign fbody makes it.
Scope *sc2 = sc->push();
sc2->stc = 0;
sc2->linkage = LINKd;
fop->semantic(sc2);
fop->semantic2(sc2);
// Bugzilla 15044: fop->semantic3 isn't run here for lazy forward reference resolution.
sc2->pop();
if (global.endGagging(errors)) // if errors happened
{
// Disable generated opAssign, because some members forbid identity assignment.
fop->storage_class |= STCdisable;
fop->fbody = NULL; // remove fbody which contains the error
}
//printf("-StructDeclaration::buildOpAssign() %s, errors = %d\n", sd->toChars(), (fop->storage_class & STCdisable) != 0);
return fop;
}
/*******************************************
* We need an opEquals for the struct if
* any fields has an opEquals.
* Generate one if a user-specified one does not exist.
*/
bool needOpEquals(StructDeclaration *sd)
{
//printf("StructDeclaration::needOpEquals() %s\n", sd->toChars());
if (sd->isUnionDeclaration())
goto Ldontneed;
if (sd->hasIdentityEquals)
goto Lneed;
/* If any of the fields has an opEquals, then we
* need it too.
*/
for (size_t i = 0; i < sd->fields.dim; i++)
{
VarDeclaration *v = sd->fields[i];
if (v->storage_class & STCref)
continue;
if (v->overlapped)
continue;
Type *tv = v->type->toBasetype();
Type *tvbase = tv->baseElemOf();
if (tvbase->ty == Tstruct)
{
TypeStruct *ts = (TypeStruct *)tvbase;
if (ts->sym->isUnionDeclaration())
continue;
if (needOpEquals(ts->sym))
goto Lneed;
if (ts->sym->aliasthis) // Bugzilla 14806
goto Lneed;
}
if (tv->isfloating())
{
// This is necessray for:
// 1. comparison of +0.0 and -0.0 should be true.
// 2. comparison of NANs should be false always.
goto Lneed;
}
if (tv->ty == Tarray)
goto Lneed;
if (tv->ty == Taarray)
goto Lneed;
if (tv->ty == Tclass)
goto Lneed;
}
Ldontneed:
//printf("\tdontneed\n");
return false;
Lneed:
//printf("\tneed\n");
return true;
}
/*******************************************
* Check given aggregate actually has an identity opEquals or not.
*/
FuncDeclaration *hasIdentityOpEquals(AggregateDeclaration *ad, Scope *sc)
{
Dsymbol *eq = search_function(ad, Id::eq);
if (eq)
{
/* check identity opEquals exists
*/
UnionExp er; new(&er) NullExp(ad->loc, NULL); // dummy rvalue
UnionExp el; new(&el) IdentifierExp(ad->loc, Id::p); // dummy lvalue
Expressions a;
a.setDim(1);
for (size_t i = 0; i < 5; i++)
{
Type *tthis = NULL; // dead-store to prevent spurious warning
switch (i)
{
case 0: tthis = ad->type; break;
case 1: tthis = ad->type->constOf(); break;
case 2: tthis = ad->type->immutableOf(); break;
case 3: tthis = ad->type->sharedOf(); break;
case 4: tthis = ad->type->sharedConstOf(); break;
default: assert(0);
}
FuncDeclaration *f = NULL;
unsigned errors = global.startGagging(); // Do not report errors, even if the template opAssign fbody makes it.
sc = sc->push();
sc->tinst = NULL;
sc->minst = NULL;
for (size_t j = 0; j < 2; j++)
{
a[0] = (j == 0 ? er.exp() : el.exp());
a[0]->type = tthis;
f = resolveFuncCall(ad->loc, sc, eq, NULL, tthis, &a, 1);
if (f)
break;
}
sc = sc->pop();
global.endGagging(errors);
if (f)
{
if (f->errors)
return NULL;
return f;
}
}
}
return NULL;
}
/******************************************
* Build opEquals for struct.
* const bool opEquals(const S s) { ... }
*
* By fixing bugzilla 3789, opEquals is changed to be never implicitly generated.
* Now, struct objects comparison s1 == s2 is translated to:
* s1.tupleof == s2.tupleof
* to calculate structural equality. See EqualExp::op_overload.
*/
FuncDeclaration *buildOpEquals(StructDeclaration *sd, Scope *sc)
{
if (hasIdentityOpEquals(sd, sc))
{
sd->hasIdentityEquals = true;
}
return NULL;
}
/******************************************
* Build __xopEquals for TypeInfo_Struct
* static bool __xopEquals(ref const S p, ref const S q)
* {
* return p == q;
* }
*
* This is called by TypeInfo.equals(p1, p2). If the struct does not support
* const objects comparison, it will throw "not implemented" Error in runtime.
*/
FuncDeclaration *buildXopEquals(StructDeclaration *sd, Scope *sc)
{
if (!needOpEquals(sd))
return NULL; // bitwise comparison would work
//printf("StructDeclaration::buildXopEquals() %s\n", sd->toChars());
if (Dsymbol *eq = search_function(sd, Id::eq))
{
if (FuncDeclaration *fd = eq->isFuncDeclaration())
{
TypeFunction *tfeqptr;
{
Scope scx;
/* const bool opEquals(ref const S s);
*/
Parameters *parameters = new Parameters;
parameters->push(new Parameter(STCref | STCconst, sd->type, NULL, NULL));
tfeqptr = new TypeFunction(parameters, Type::tbool, 0, LINKd);
tfeqptr->mod = MODconst;
tfeqptr = (TypeFunction *)tfeqptr->semantic(Loc(), &scx);
}
fd = fd->overloadExactMatch(tfeqptr);
if (fd)
return fd;
}
}
if (!sd->xerreq)
{
// object._xopEquals
Identifier *id = Identifier::idPool("_xopEquals");
Expression *e = new IdentifierExp(sd->loc, Id::empty);
e = new DotIdExp(sd->loc, e, Id::object);
e = new DotIdExp(sd->loc, e, id);
e = semantic(e, sc);
Dsymbol *s = getDsymbol(e);
assert(s);
sd->xerreq = s->isFuncDeclaration();
}
Loc declLoc = Loc(); // loc is unnecessary so __xopEquals is never called directly
Loc loc = Loc(); // loc is unnecessary so errors are gagged
Parameters *parameters = new Parameters;
parameters->push(new Parameter(STCref | STCconst, sd->type, Id::p, NULL));
parameters->push(new Parameter(STCref | STCconst, sd->type, Id::q, NULL));
TypeFunction *tf = new TypeFunction(parameters, Type::tbool, 0, LINKd);
Identifier *id = Id::xopEquals;
FuncDeclaration *fop = new FuncDeclaration(declLoc, Loc(), id, STCstatic, tf);
fop->generated = true;
Expression *e1 = new IdentifierExp(loc, Id::p);
Expression *e2 = new IdentifierExp(loc, Id::q);
Expression *e = new EqualExp(TOKequal, loc, e1, e2);
fop->fbody = new ReturnStatement(loc, e);
unsigned errors = global.startGagging(); // Do not report errors
Scope *sc2 = sc->push();
sc2->stc = 0;
sc2->linkage = LINKd;
fop->semantic(sc2);
fop->semantic2(sc2);
sc2->pop();
if (global.endGagging(errors)) // if errors happened
fop = sd->xerreq;
return fop;
}
/******************************************
* Build __xopCmp for TypeInfo_Struct
* static bool __xopCmp(ref const S p, ref const S q)
* {
* return p.opCmp(q);
* }
*
* This is called by TypeInfo.compare(p1, p2). If the struct does not support
* const objects comparison, it will throw "not implemented" Error in runtime.
*/
FuncDeclaration *buildXopCmp(StructDeclaration *sd, Scope *sc)
{
//printf("StructDeclaration::buildXopCmp() %s\n", toChars());
if (Dsymbol *cmp = search_function(sd, Id::cmp))
{
if (FuncDeclaration *fd = cmp->isFuncDeclaration())
{
TypeFunction *tfcmpptr;
{
Scope scx;
/* const int opCmp(ref const S s);
*/
Parameters *parameters = new Parameters;
parameters->push(new Parameter(STCref | STCconst, sd->type, NULL, NULL));
tfcmpptr = new TypeFunction(parameters, Type::tint32, 0, LINKd);
tfcmpptr->mod = MODconst;
tfcmpptr = (TypeFunction *)tfcmpptr->semantic(Loc(), &scx);
}
fd = fd->overloadExactMatch(tfcmpptr);
if (fd)
return fd;
}
}
else
{
// FIXME: doesn't work for recursive alias this
return NULL;
}
if (!sd->xerrcmp)
{
// object._xopCmp
Identifier *id = Identifier::idPool("_xopCmp");
Expression *e = new IdentifierExp(sd->loc, Id::empty);
e = new DotIdExp(sd->loc, e, Id::object);
e = new DotIdExp(sd->loc, e, id);
e = semantic(e, sc);
Dsymbol *s = getDsymbol(e);
assert(s);
sd->xerrcmp = s->isFuncDeclaration();
}
Loc declLoc = Loc(); // loc is unnecessary so __xopCmp is never called directly
Loc loc = Loc(); // loc is unnecessary so errors are gagged
Parameters *parameters = new Parameters;
parameters->push(new Parameter(STCref | STCconst, sd->type, Id::p, NULL));
parameters->push(new Parameter(STCref | STCconst, sd->type, Id::q, NULL));
TypeFunction *tf = new TypeFunction(parameters, Type::tint32, 0, LINKd);
Identifier *id = Id::xopCmp;
FuncDeclaration *fop = new FuncDeclaration(declLoc, Loc(), id, STCstatic, tf);
fop->generated = true;
Expression *e1 = new IdentifierExp(loc, Id::p);
Expression *e2 = new IdentifierExp(loc, Id::q);
#ifdef IN_GCC
Expression *e = new CallExp(loc, new DotIdExp(loc, e1, Id::cmp), e2);
#else
Expression *e = new CallExp(loc, new DotIdExp(loc, e2, Id::cmp), e1);
#endif
fop->fbody = new ReturnStatement(loc, e);
unsigned errors = global.startGagging(); // Do not report errors
Scope *sc2 = sc->push();
sc2->stc = 0;
sc2->linkage = LINKd;
fop->semantic(sc2);
fop->semantic2(sc2);
sc2->pop();
if (global.endGagging(errors)) // if errors happened
fop = sd->xerrcmp;
return fop;
}
/*******************************************
* We need a toHash for the struct if
* any fields has a toHash.
* Generate one if a user-specified one does not exist.
*/
bool needToHash(StructDeclaration *sd)
{
//printf("StructDeclaration::needToHash() %s\n", sd->toChars());
if (sd->isUnionDeclaration())
goto Ldontneed;
if (sd->xhash)
goto Lneed;
/* If any of the fields has an opEquals, then we
* need it too.
*/
for (size_t i = 0; i < sd->fields.dim; i++)
{
VarDeclaration *v = sd->fields[i];
if (v->storage_class & STCref)
continue;
if (v->overlapped)
continue;
Type *tv = v->type->toBasetype();
Type *tvbase = tv->baseElemOf();
if (tvbase->ty == Tstruct)
{
TypeStruct *ts = (TypeStruct *)tvbase;
if (ts->sym->isUnionDeclaration())
continue;
if (needToHash(ts->sym))
goto Lneed;
if (ts->sym->aliasthis) // Bugzilla 14948
goto Lneed;
}
if (tv->isfloating())
{
// This is necessray for:
// 1. comparison of +0.0 and -0.0 should be true.
goto Lneed;
}
if (tv->ty == Tarray)
goto Lneed;
if (tv->ty == Taarray)
goto Lneed;
if (tv->ty == Tclass)
goto Lneed;
}
Ldontneed:
//printf("\tdontneed\n");
return false;
Lneed:
//printf("\tneed\n");
return true;
}
/******************************************
* Build __xtoHash for non-bitwise hashing
* static hash_t xtoHash(ref const S p) nothrow @trusted;
*/
FuncDeclaration *buildXtoHash(StructDeclaration *sd, Scope *sc)
{
if (Dsymbol *s = search_function(sd, Id::tohash))
{
static TypeFunction *tftohash;
if (!tftohash)
{
tftohash = new TypeFunction(NULL, Type::thash_t, 0, LINKd);
tftohash->mod = MODconst;
tftohash = (TypeFunction *)tftohash->merge();
}
if (FuncDeclaration *fd = s->isFuncDeclaration())
{
fd = fd->overloadExactMatch(tftohash);
if (fd)
return fd;
}
}
if (!needToHash(sd))
return NULL;
//printf("StructDeclaration::buildXtoHash() %s\n", sd->toPrettyChars());
Loc declLoc = Loc(); // loc is unnecessary so __xtoHash is never called directly
Loc loc = Loc(); // internal code should have no loc to prevent coverage
Parameters *parameters = new Parameters();
parameters->push(new Parameter(STCref | STCconst, sd->type, Id::p, NULL));
TypeFunction *tf = new TypeFunction(parameters, Type::thash_t, 0, LINKd, STCnothrow | STCtrusted);
Identifier *id = Id::xtoHash;
FuncDeclaration *fop = new FuncDeclaration(declLoc, Loc(), id, STCstatic, tf);
fop->generated = true;
/* Do memberwise hashing.
*
* If sd is a nested struct, and if it's nested in a class, the calculated
* hash value will also contain the result of parent class's toHash().
*/
const char *code =
"size_t h = 0;"
"foreach (i, T; typeof(p.tupleof))"
" h += typeid(T).getHash(cast(const void*)&p.tupleof[i]);"
"return h;";
fop->fbody = new CompileStatement(loc, new StringExp(loc, const_cast<char *>(code)));
Scope *sc2 = sc->push();
sc2->stc = 0;
sc2->linkage = LINKd;
fop->semantic(sc2);
fop->semantic2(sc2);
sc2->pop();
//printf("%s fop = %s %s\n", sd->toChars(), fop->toChars(), fop->type->toChars());
return fop;
}
/*****************************************
* Create inclusive postblit for struct by aggregating
* all the postblits in postblits[] with the postblits for
* all the members.
* Note the close similarity with AggregateDeclaration::buildDtor(),
* and the ordering changes (runs forward instead of backwards).
*/
FuncDeclaration *buildPostBlit(StructDeclaration *sd, Scope *sc)
{
//printf("StructDeclaration::buildPostBlit() %s\n", sd->toChars());
if (sd->isUnionDeclaration())
return NULL;
StorageClass stc = STCsafe | STCnothrow | STCpure | STCnogc;
Loc declLoc = sd->postblits.dim ? sd->postblits[0]->loc : sd->loc;
Loc loc = Loc(); // internal code should have no loc to prevent coverage
for (size_t i = 0; i < sd->postblits.dim; i++)
{
stc |= sd->postblits[i]->storage_class & STCdisable;
}
Statements *a = new Statements();
for (size_t i = 0; i < sd->fields.dim && !(stc & STCdisable); i++)
{
VarDeclaration *v = sd->fields[i];
if (v->storage_class & STCref)
continue;
if (v->overlapped)
continue;
Type *tv = v->type->baseElemOf();
if (tv->ty != Tstruct)
continue;
StructDeclaration *sdv = ((TypeStruct *)tv)->sym;
if (!sdv->postblit)
continue;
assert(!sdv->isUnionDeclaration());
sdv->postblit->functionSemantic();
stc = mergeFuncAttrs(stc, sdv->postblit);
stc = mergeFuncAttrs(stc, sdv->dtor);
if (stc & STCdisable)
{
a->setDim(0);
break;
}
Expression *ex = NULL;
tv = v->type->toBasetype();
if (tv->ty == Tstruct)
{
// this.v.__xpostblit()
ex = new ThisExp(loc);
ex = new DotVarExp(loc, ex, v);
// This is a hack so we can call postblits on const/immutable objects.
ex = new AddrExp(loc, ex);
ex = new CastExp(loc, ex, v->type->mutableOf()->pointerTo());
ex = new PtrExp(loc, ex);
if (stc & STCsafe)
stc = (stc & ~STCsafe) | STCtrusted;
ex = new DotVarExp(loc, ex, sdv->postblit, false);
ex = new CallExp(loc, ex);
}
else
{
// __ArrayPostblit((cast(S*)this.v.ptr)[0 .. n])
uinteger_t n = 1;
while (tv->ty == Tsarray)
{
n *= ((TypeSArray *)tv)->dim->toUInteger();
tv = tv->nextOf()->toBasetype();
}
if (n == 0)
continue;
ex = new ThisExp(loc);
ex = new DotVarExp(loc, ex, v);
// This is a hack so we can call postblits on const/immutable objects.
ex = new DotIdExp(loc, ex, Id::ptr);
ex = new CastExp(loc, ex, sdv->type->pointerTo());
if (stc & STCsafe)
stc = (stc & ~STCsafe) | STCtrusted;
ex = new SliceExp(loc, ex, new IntegerExp(loc, 0, Type::tsize_t),
new IntegerExp(loc, n, Type::tsize_t));
// Prevent redundant bounds check
((SliceExp *)ex)->upperIsInBounds = true;
((SliceExp *)ex)->lowerIsLessThanUpper = true;
ex = new CallExp(loc, new IdentifierExp(loc, Id::__ArrayPostblit), ex);
}
a->push(new ExpStatement(loc, ex)); // combine in forward order
/* Bugzilla 10972: When the following field postblit calls fail,
* this field should be destructed for Exception Safety.
*/
if (!sdv->dtor)
continue;
sdv->dtor->functionSemantic();
tv = v->type->toBasetype();
if (v->type->toBasetype()->ty == Tstruct)
{
// this.v.__xdtor()
ex = new ThisExp(loc);
ex = new DotVarExp(loc, ex, v);
// This is a hack so we can call destructors on const/immutable objects.
ex = new AddrExp(loc, ex);
ex = new CastExp(loc, ex, v->type->mutableOf()->pointerTo());
ex = new PtrExp(loc, ex);
if (stc & STCsafe)
stc = (stc & ~STCsafe) | STCtrusted;
ex = new DotVarExp(loc, ex, sdv->dtor, false);
ex = new CallExp(loc, ex);
}
else
{
// __ArrayDtor((cast(S*)this.v.ptr)[0 .. n])
uinteger_t n = 1;
while (tv->ty == Tsarray)
{
n *= ((TypeSArray *)tv)->dim->toUInteger();
tv = tv->nextOf()->toBasetype();
}
//if (n == 0)
// continue;
ex = new ThisExp(loc);
ex = new DotVarExp(loc, ex, v);
// This is a hack so we can call destructors on const/immutable objects.
ex = new DotIdExp(loc, ex, Id::ptr);
ex = new CastExp(loc, ex, sdv->type->pointerTo());
if (stc & STCsafe)
stc = (stc & ~STCsafe) | STCtrusted;
ex = new SliceExp(loc, ex, new IntegerExp(loc, 0, Type::tsize_t),
new IntegerExp(loc, n, Type::tsize_t));
// Prevent redundant bounds check
((SliceExp *)ex)->upperIsInBounds = true;
((SliceExp *)ex)->lowerIsLessThanUpper = true;
ex = new CallExp(loc, new IdentifierExp(loc, Id::__ArrayDtor), ex);
}
a->push(new OnScopeStatement(loc, TOKon_scope_failure, new ExpStatement(loc, ex)));
}
// Build our own "postblit" which executes a, but only if needed.
if (a->dim || (stc & STCdisable))
{
//printf("Building __fieldPostBlit()\n");
PostBlitDeclaration *dd = new PostBlitDeclaration(declLoc, Loc(), stc, Id::__fieldPostblit);
dd->generated = true;
dd->storage_class |= STCinference;
dd->fbody = (stc & STCdisable) ? NULL : new CompoundStatement(loc, a);
sd->postblits.shift(dd);
sd->members->push(dd);
dd->semantic(sc);
}
FuncDeclaration *xpostblit = NULL;
switch (sd->postblits.dim)
{
case 0:
break;
case 1:
xpostblit = sd->postblits[0];
break;
default:
Expression *e = NULL;
stc = STCsafe | STCnothrow | STCpure | STCnogc;
for (size_t i = 0; i < sd->postblits.dim; i++)
{
FuncDeclaration *fd = sd->postblits[i];
stc = mergeFuncAttrs(stc, fd);
if (stc & STCdisable)
{
e = NULL;
break;
}
Expression *ex = new ThisExp(loc);
ex = new DotVarExp(loc, ex, fd, false);
ex = new CallExp(loc, ex);
e = Expression::combine(e, ex);
}
PostBlitDeclaration *dd = new PostBlitDeclaration(declLoc, Loc(), stc, Id::__aggrPostblit);
dd->storage_class |= STCinference;
dd->fbody = new ExpStatement(loc, e);
sd->members->push(dd);
dd->semantic(sc);
xpostblit = dd;
break;
}
// Add an __xpostblit alias to make the inclusive postblit accessible
if (xpostblit)
{
AliasDeclaration *alias = new AliasDeclaration(Loc(), Id::__xpostblit, xpostblit);
alias->semantic(sc);
sd->members->push(alias);
alias->addMember(sc, sd); // add to symbol table
}
return xpostblit;
}
/*****************************************
* Create inclusive destructor for struct/class by aggregating
* all the destructors in dtors[] with the destructors for
* all the members.
* Note the close similarity with StructDeclaration::buildPostBlit(),
* and the ordering changes (runs backward instead of forwards).
*/
FuncDeclaration *buildDtor(AggregateDeclaration *ad, Scope *sc)
{
//printf("AggregateDeclaration::buildDtor() %s\n", ad->toChars());
if (ad->isUnionDeclaration())
return NULL;
StorageClass stc = STCsafe | STCnothrow | STCpure | STCnogc;
Loc declLoc = ad->dtors.dim ? ad->dtors[0]->loc : ad->loc;
Loc loc = Loc(); // internal code should have no loc to prevent coverage
Expression *e = NULL;
for (size_t i = 0; i < ad->fields.dim; i++)
{
VarDeclaration *v = ad->fields[i];
if (v->storage_class & STCref)
continue;
if (v->overlapped)
continue;
Type *tv = v->type->baseElemOf();
if (tv->ty != Tstruct)
continue;
StructDeclaration *sdv = ((TypeStruct *)tv)->sym;
if (!sdv->dtor)
continue;
sdv->dtor->functionSemantic();
stc = mergeFuncAttrs(stc, sdv->dtor);
if (stc & STCdisable)
{
e = NULL;
break;
}
Expression *ex = NULL;
tv = v->type->toBasetype();
if (tv->ty == Tstruct)
{
// this.v.__xdtor()
ex = new ThisExp(loc);
ex = new DotVarExp(loc, ex, v);
// This is a hack so we can call destructors on const/immutable objects.
ex = new AddrExp(loc, ex);
ex = new CastExp(loc, ex, v->type->mutableOf()->pointerTo());
ex = new PtrExp(loc, ex);
if (stc & STCsafe)
stc = (stc & ~STCsafe) | STCtrusted;
ex = new DotVarExp(loc, ex, sdv->dtor, false);
ex = new CallExp(loc, ex);
}
else
{
// __ArrayDtor((cast(S*)this.v.ptr)[0 .. n])
uinteger_t n = 1;
while (tv->ty == Tsarray)
{
n *= ((TypeSArray *)tv)->dim->toUInteger();
tv = tv->nextOf()->toBasetype();
}
if (n == 0)
continue;
ex = new ThisExp(loc);
ex = new DotVarExp(loc, ex, v);
// This is a hack so we can call destructors on const/immutable objects.
ex = new DotIdExp(loc, ex, Id::ptr);
ex = new CastExp(loc, ex, sdv->type->pointerTo());
if (stc & STCsafe)
stc = (stc & ~STCsafe) | STCtrusted;
ex = new SliceExp(loc, ex, new IntegerExp(loc, 0, Type::tsize_t),
new IntegerExp(loc, n, Type::tsize_t));
// Prevent redundant bounds check
((SliceExp *)ex)->upperIsInBounds = true;
((SliceExp *)ex)->lowerIsLessThanUpper = true;
ex = new CallExp(loc, new IdentifierExp(loc, Id::__ArrayDtor), ex);
}
e = Expression::combine(ex, e); // combine in reverse order
}
/* Build our own "destructor" which executes e
*/
if (e || (stc & STCdisable))
{
//printf("Building __fieldDtor()\n");
DtorDeclaration *dd = new DtorDeclaration(declLoc, Loc(), stc, Id::__fieldDtor);
dd->generated = true;
dd->storage_class |= STCinference;
dd->fbody = new ExpStatement(loc, e);
ad->dtors.shift(dd);
ad->members->push(dd);
dd->semantic(sc);
}
FuncDeclaration *xdtor = NULL;
switch (ad->dtors.dim)
{
case 0:
break;
case 1:
xdtor = ad->dtors[0];
break;
default:
e = NULL;
stc = STCsafe | STCnothrow | STCpure | STCnogc;
for (size_t i = 0; i < ad->dtors.dim; i++)
{
FuncDeclaration *fd = ad->dtors[i];
stc = mergeFuncAttrs(stc, fd);
if (stc & STCdisable)
{
e = NULL;
break;
}
Expression *ex = new ThisExp(loc);
ex = new DotVarExp(loc, ex, fd, false);
ex = new CallExp(loc, ex);
e = Expression::combine(ex, e);
}
DtorDeclaration *dd = new DtorDeclaration(declLoc, Loc(), stc, Id::__aggrDtor);
dd->generated = true;
dd->storage_class |= STCinference;
dd->fbody = new ExpStatement(loc, e);
ad->members->push(dd);
dd->semantic(sc);
xdtor = dd;
break;
}
// Add an __xdtor alias to make the inclusive dtor accessible
if (xdtor)
{
AliasDeclaration *alias = new AliasDeclaration(Loc(), Id::__xdtor, xdtor);
alias->semantic(sc);
ad->members->push(alias);
alias->addMember(sc, ad); // add to symbol table
}
return xdtor;
}
/******************************************
* Create inclusive invariant for struct/class by aggregating
* all the invariants in invs[].
* void __invariant() const [pure nothrow @trusted]
* {
* invs[0](), invs[1](), ...;
* }
*/
FuncDeclaration *buildInv(AggregateDeclaration *ad, Scope *sc)
{
StorageClass stc = STCsafe | STCnothrow | STCpure | STCnogc;
Loc declLoc = ad->loc;
Loc loc = Loc(); // internal code should have no loc to prevent coverage
switch (ad->invs.dim)
{
case 0:
return NULL;
case 1:
// Don't return invs[0] so it has uniquely generated name.
/* fall through */
default:
Expression *e = NULL;
StorageClass stcx = 0;
for (size_t i = 0; i < ad->invs.dim; i++)
{
stc = mergeFuncAttrs(stc, ad->invs[i]);
if (stc & STCdisable)
{
// What should do?
}
StorageClass stcy = (ad->invs[i]->storage_class & STCsynchronized) |
(ad->invs[i]->type->mod & MODshared ? STCshared : 0);
if (i == 0)
stcx = stcy;
else if (stcx ^ stcy)
{
#if 1 // currently rejects
ad->error(ad->invs[i]->loc, "mixing invariants with shared/synchronized differene is not supported");
e = NULL;
break;
#endif
}
e = Expression::combine(e, new CallExp(loc, new VarExp(loc, ad->invs[i], false)));
}
InvariantDeclaration *inv;
inv = new InvariantDeclaration(declLoc, Loc(), stc | stcx, Id::classInvariant);
inv->fbody = new ExpStatement(loc, e);
ad->members->push(inv);
inv->semantic(sc);
return inv;
}
}