blob: 1338e1f69b04ed99d450d434c975e23da606a692 [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/struct.c
*/
#include "root/dsystem.h"
#include "root/root.h"
#include "errors.h"
#include "aggregate.h"
#include "scope.h"
#include "mtype.h"
#include "init.h"
#include "declaration.h"
#include "module.h"
#include "id.h"
#include "statement.h"
#include "template.h"
#include "tokens.h"
Type *getTypeInfoType(Loc loc, Type *t, Scope *sc);
TypeTuple *toArgTypes(Type *t);
void unSpeculative(Scope *sc, RootObject *o);
bool MODimplicitConv(MOD modfrom, MOD modto);
Expression *resolve(Loc loc, Scope *sc, Dsymbol *s, bool hasOverloads);
FuncDeclaration *StructDeclaration::xerreq; // object.xopEquals
FuncDeclaration *StructDeclaration::xerrcmp; // object.xopCmp
/***************************************
* Search toString member function for TypeInfo_Struct.
* string toString();
*/
FuncDeclaration *search_toString(StructDeclaration *sd)
{
Dsymbol *s = search_function(sd, Id::tostring);
FuncDeclaration *fd = s ? s->isFuncDeclaration() : NULL;
if (fd)
{
static TypeFunction *tftostring;
if (!tftostring)
{
tftostring = new TypeFunction(NULL, Type::tstring, 0, LINKd);
tftostring = tftostring->merge()->toTypeFunction();
}
fd = fd->overloadExactMatch(tftostring);
}
return fd;
}
/***************************************
* Request additonal semantic analysis for TypeInfo generation.
*/
void semanticTypeInfo(Scope *sc, Type *t)
{
class FullTypeInfoVisitor : public Visitor
{
public:
Scope *sc;
void visit(Type *t)
{
Type *tb = t->toBasetype();
if (tb != t)
tb->accept(this);
}
void visit(TypeNext *t)
{
if (t->next)
t->next->accept(this);
}
void visit(TypeBasic *) { }
void visit(TypeVector *t)
{
t->basetype->accept(this);
}
void visit(TypeAArray *t)
{
t->index->accept(this);
visit((TypeNext *)t);
}
void visit(TypeFunction *t)
{
visit((TypeNext *)t);
// Currently TypeInfo_Function doesn't store parameter types.
}
void visit(TypeStruct *t)
{
//printf("semanticTypeInfo::visit(TypeStruct = %s)\n", t->toChars());
StructDeclaration *sd = t->sym;
/* Step 1: create TypeInfoDeclaration
*/
if (!sc) // inline may request TypeInfo.
{
Scope scx;
scx._module = sd->getModule();
getTypeInfoType(sd->loc, t, &scx);
sd->requestTypeInfo = true;
}
else if (!sc->minst)
{
// don't yet have to generate TypeInfo instance if
// the typeid(T) expression exists in speculative scope.
}
else
{
getTypeInfoType(sd->loc, t, sc);
sd->requestTypeInfo = true;
// Bugzilla 15149, if the typeid operand type comes from a
// result of auto function, it may be yet speculative.
unSpeculative(sc, sd);
}
/* Step 2: If the TypeInfo generation requires sd.semantic3, run it later.
* This should be done even if typeid(T) exists in speculative scope.
* Because it may appear later in non-speculative scope.
*/
if (!sd->members)
return; // opaque struct
if (!sd->xeq && !sd->xcmp && !sd->postblit &&
!sd->dtor && !sd->xhash && !search_toString(sd))
return; // none of TypeInfo-specific members
// If the struct is in a non-root module, run semantic3 to get
// correct symbols for the member function.
if (sd->semanticRun >= PASSsemantic3)
{
// semantic3 is already done
}
else if (TemplateInstance *ti = sd->isInstantiated())
{
if (ti->minst && !ti->minst->isRoot())
Module::addDeferredSemantic3(sd);
}
else
{
if (sd->inNonRoot())
{
//printf("deferred sem3 for TypeInfo - sd = %s, inNonRoot = %d\n", sd->toChars(), sd->inNonRoot());
Module::addDeferredSemantic3(sd);
}
}
}
void visit(TypeClass *) { }
void visit(TypeTuple *t)
{
if (t->arguments)
{
for (size_t i = 0; i < t->arguments->dim; i++)
{
Type *tprm = (*t->arguments)[i]->type;
if (tprm)
tprm->accept(this);
}
}
}
};
if (sc)
{
if (!sc->func)
return;
if (sc->intypeof)
return;
if (sc->flags & (SCOPEctfe | SCOPEcompile))
return;
}
FullTypeInfoVisitor v;
v.sc = sc;
t->accept(&v);
}
/********************************* AggregateDeclaration ****************************/
AggregateDeclaration::AggregateDeclaration(Loc loc, Identifier *id)
: ScopeDsymbol(id)
{
this->loc = loc;
storage_class = 0;
protection = Prot(PROTpublic);
type = NULL;
structsize = 0; // size of struct
alignsize = 0; // size of struct for alignment purposes
sizeok = SIZEOKnone; // size not determined yet
deferred = NULL;
isdeprecated = false;
inv = NULL;
aggNew = NULL;
aggDelete = NULL;
stag = NULL;
sinit = NULL;
enclosing = NULL;
vthis = NULL;
ctor = NULL;
defaultCtor = NULL;
aliasthis = NULL;
noDefaultCtor = false;
dtor = NULL;
getRTInfo = NULL;
}
Prot AggregateDeclaration::prot()
{
return protection;
}
/***************************************
* Create a new scope from sc.
* semantic, semantic2 and semantic3 will use this for aggregate members.
*/
Scope *AggregateDeclaration::newScope(Scope *sc)
{
Scope *sc2 = sc->push(this);
sc2->stc &= STCsafe | STCtrusted | STCsystem;
sc2->parent = this;
if (isUnionDeclaration())
sc2->inunion = 1;
sc2->protection = Prot(PROTpublic);
sc2->explicitProtection = 0;
sc2->aligndecl = NULL;
sc2->userAttribDecl = NULL;
return sc2;
}
void AggregateDeclaration::setScope(Scope *sc)
{
// Might need a scope to resolve forward references. The check for
// semanticRun prevents unnecessary setting of _scope during deferred
// setScope phases for aggregates which already finished semantic().
// Also see https://issues.dlang.org/show_bug.cgi?id=16607
if (semanticRun < PASSsemanticdone)
ScopeDsymbol::setScope(sc);
}
void AggregateDeclaration::semantic2(Scope *sc)
{
//printf("AggregateDeclaration::semantic2(%s) type = %s, errors = %d\n", toChars(), type->toChars(), errors);
if (!members)
return;
if (_scope)
{
error("has forward references");
return;
}
Scope *sc2 = newScope(sc);
determineSize(loc);
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
//printf("\t[%d] %s\n", i, s->toChars());
s->semantic2(sc2);
}
sc2->pop();
}
void AggregateDeclaration::semantic3(Scope *sc)
{
//printf("AggregateDeclaration::semantic3(%s) type = %s, errors = %d\n", toChars(), type->toChars(), errors);
if (!members)
return;
StructDeclaration *sd = isStructDeclaration();
if (!sc) // from runDeferredSemantic3 for TypeInfo generation
{
assert(sd);
sd->semanticTypeInfoMembers();
return;
}
Scope *sc2 = newScope(sc);
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
s->semantic3(sc2);
}
sc2->pop();
// don't do it for unused deprecated types
// or error types
if (!getRTInfo && Type::rtinfo &&
(!isDeprecated() || global.params.useDeprecated != DIAGNOSTICerror) &&
(type && type->ty != Terror))
{
// Evaluate: RTinfo!type
Objects *tiargs = new Objects();
tiargs->push(type);
TemplateInstance *ti = new TemplateInstance(loc, Type::rtinfo, tiargs);
Scope *sc3 = ti->tempdecl->_scope->startCTFE();
sc3->tinst = sc->tinst;
sc3->minst = sc->minst;
if (isDeprecated())
sc3->stc |= STCdeprecated;
ti->semantic(sc3);
ti->semantic2(sc3);
ti->semantic3(sc3);
Expression *e = resolve(Loc(), sc3, ti->toAlias(), false);
sc3->endCTFE();
e = e->ctfeInterpret();
getRTInfo = e;
}
if (sd)
sd->semanticTypeInfoMembers();
}
/***************************************
* Find all instance fields, then push them into `fields`.
*
* Runs semantic() for all instance field variables, but also
* the field types can reamin yet not resolved forward references,
* except direct recursive definitions.
* After the process sizeok is set to SIZEOKfwd.
*
* Returns:
* false if any errors occur.
*/
bool AggregateDeclaration::determineFields()
{
if (sizeok != SIZEOKnone)
return true;
//printf("determineFields() %s, fields.dim = %d\n", toChars(), fields.dim);
fields.setDim(0);
struct SV
{
AggregateDeclaration *agg;
static int func(Dsymbol *s, void *param)
{
VarDeclaration *v = s->isVarDeclaration();
if (!v)
return 0;
if (v->storage_class & STCmanifest)
return 0;
AggregateDeclaration *ad = ((SV *)param)->agg;
if (v->_scope)
v->semantic(NULL);
// Note: Aggregate fields or size could have determined during v->semantic.
if (ad->sizeok != SIZEOKnone)
return 1;
if (v->aliassym)
return 0; // If this variable was really a tuple, skip it.
if (v->storage_class & (STCstatic | STCextern | STCtls | STCgshared | STCmanifest | STCctfe | STCtemplateparameter))
return 0;
if (!v->isField() || v->semanticRun < PASSsemanticdone)
return 1; // unresolvable forward reference
ad->fields.push(v);
if (v->storage_class & STCref)
return 0;
Type *tv = v->type->baseElemOf();
if (tv->ty != Tstruct)
return 0;
if (ad == ((TypeStruct *)tv)->sym)
{
const char *psz = (v->type->toBasetype()->ty == Tsarray) ? "static array of " : "";
ad->error("cannot have field %s with %ssame struct type", v->toChars(), psz);
ad->type = Type::terror;
ad->errors = true;
return 1;
}
return 0;
}
};
SV sv;
sv.agg = this;
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
if (s->apply(&SV::func, &sv))
{
if (sizeok != SIZEOKnone)
return true;
return false;
}
}
if (sizeok != SIZEOKdone)
sizeok = SIZEOKfwd;
return true;
}
/***************************************
* Collect all instance fields, then determine instance size.
* Returns:
* false if failed to determine the size.
*/
bool AggregateDeclaration::determineSize(Loc loc)
{
//printf("AggregateDeclaration::determineSize() %s, sizeok = %d\n", toChars(), sizeok);
// The previous instance size finalizing had:
if (type->ty == Terror)
return false; // failed already
if (sizeok == SIZEOKdone)
return true; // succeeded
if (!members)
{
error(loc, "unknown size");
return false;
}
if (_scope)
semantic(NULL);
// Determine the instance size of base class first.
if (ClassDeclaration *cd = isClassDeclaration())
{
cd = cd->baseClass;
if (cd && !cd->determineSize(loc))
goto Lfail;
}
// Determine instance fields when sizeok == SIZEOKnone
if (!determineFields())
goto Lfail;
if (sizeok != SIZEOKdone)
finalizeSize();
// this aggregate type has:
if (type->ty == Terror)
return false; // marked as invalid during the finalizing.
if (sizeok == SIZEOKdone)
return true; // succeeded to calculate instance size.
Lfail:
// There's unresolvable forward reference.
if (type != Type::terror)
error(loc, "no size because of forward reference");
// Don't cache errors from speculative semantic, might be resolvable later.
// https://issues.dlang.org/show_bug.cgi?id=16574
if (!global.gag)
{
type = Type::terror;
errors = true;
}
return false;
}
void StructDeclaration::semanticTypeInfoMembers()
{
if (xeq &&
xeq->_scope &&
xeq->semanticRun < PASSsemantic3done)
{
unsigned errors = global.startGagging();
xeq->semantic3(xeq->_scope);
if (global.endGagging(errors))
xeq = xerreq;
}
if (xcmp &&
xcmp->_scope &&
xcmp->semanticRun < PASSsemantic3done)
{
unsigned errors = global.startGagging();
xcmp->semantic3(xcmp->_scope);
if (global.endGagging(errors))
xcmp = xerrcmp;
}
FuncDeclaration *ftostr = search_toString(this);
if (ftostr &&
ftostr->_scope &&
ftostr->semanticRun < PASSsemantic3done)
{
ftostr->semantic3(ftostr->_scope);
}
if (xhash &&
xhash->_scope &&
xhash->semanticRun < PASSsemantic3done)
{
xhash->semantic3(xhash->_scope);
}
if (postblit &&
postblit->_scope &&
postblit->semanticRun < PASSsemantic3done)
{
postblit->semantic3(postblit->_scope);
}
if (dtor &&
dtor->_scope &&
dtor->semanticRun < PASSsemantic3done)
{
dtor->semantic3(dtor->_scope);
}
}
d_uns64 AggregateDeclaration::size(Loc loc)
{
//printf("+AggregateDeclaration::size() %s, scope = %p, sizeok = %d\n", toChars(), _scope, sizeok);
bool ok = determineSize(loc);
//printf("-AggregateDeclaration::size() %s, scope = %p, sizeok = %d\n", toChars(), _scope, sizeok);
return ok ? structsize : SIZE_INVALID;
}
Type *AggregateDeclaration::getType()
{
return type;
}
bool AggregateDeclaration::isDeprecated()
{
return isdeprecated;
}
bool AggregateDeclaration::isExport() const
{
return protection.kind == PROTexport;
}
/***************************************
* Calculate field[i].overlapped and overlapUnsafe, and check that all of explicit
* field initializers have unique memory space on instance.
* Returns:
* true if any errors happen.
*/
bool AggregateDeclaration::checkOverlappedFields()
{
//printf("AggregateDeclaration::checkOverlappedFields() %s\n", toChars());
assert(sizeok == SIZEOKdone);
size_t nfields = fields.dim;
if (isNested())
{
ClassDeclaration *cd = isClassDeclaration();
if (!cd || !cd->baseClass || !cd->baseClass->isNested())
nfields--;
}
bool errors = false;
// Fill in missing any elements with default initializers
for (size_t i = 0; i < nfields; i++)
{
VarDeclaration *vd = fields[i];
if (vd->errors)
{
errors = true;
continue;
}
VarDeclaration *vx = vd;
if (vd->_init && vd->_init->isVoidInitializer())
vx = NULL;
// Find overlapped fields with the hole [vd->offset .. vd->offset->size()].
for (size_t j = 0; j < nfields; j++)
{
if (i == j)
continue;
VarDeclaration *v2 = fields[j];
if (v2->errors)
{
errors = true;
continue;
}
if (!vd->isOverlappedWith(v2))
continue;
// vd and v2 are overlapping.
vd->overlapped = true;
v2->overlapped = true;
if (!MODimplicitConv(vd->type->mod, v2->type->mod))
v2->overlapUnsafe = true;
if (!MODimplicitConv(v2->type->mod, vd->type->mod))
vd->overlapUnsafe = true;
if (!vx)
continue;
if (v2->_init && v2->_init->isVoidInitializer())
continue;
if (vx->_init && v2->_init)
{
::error(loc, "overlapping default initialization for field %s and %s", v2->toChars(), vd->toChars());
errors = true;
}
}
}
return errors;
}
/***************************************
* Fill out remainder of elements[] with default initializers for fields[].
* Input:
* loc: location
* elements: explicit arguments which given to construct object.
* ctorinit: true if the elements will be used for default initialization.
* Returns:
* false if any errors occur.
* Otherwise, returns true and the missing arguments will be pushed in elements[].
*/
bool AggregateDeclaration::fill(Loc loc, Expressions *elements, bool ctorinit)
{
//printf("AggregateDeclaration::fill() %s\n", toChars());
assert(sizeok == SIZEOKdone);
assert(elements);
size_t nfields = fields.dim - isNested();
bool errors = false;
size_t dim = elements->dim;
elements->setDim(nfields);
for (size_t i = dim; i < nfields; i++)
(*elements)[i] = NULL;
// Fill in missing any elements with default initializers
for (size_t i = 0; i < nfields; i++)
{
if ((*elements)[i])
continue;
VarDeclaration *vd = fields[i];
VarDeclaration *vx = vd;
if (vd->_init && vd->_init->isVoidInitializer())
vx = NULL;
// Find overlapped fields with the hole [vd->offset .. vd->offset->size()].
size_t fieldi = i;
for (size_t j = 0; j < nfields; j++)
{
if (i == j)
continue;
VarDeclaration *v2 = fields[j];
if (!vd->isOverlappedWith(v2))
continue;
if ((*elements)[j])
{
vx = NULL;
break;
}
if (v2->_init && v2->_init->isVoidInitializer())
continue;
if (1)
{
/* Prefer first found non-void-initialized field
* union U { int a; int b = 2; }
* U u; // Error: overlapping initialization for field a and b
*/
if (!vx)
{
vx = v2;
fieldi = j;
}
else if (v2->_init)
{
::error(loc, "overlapping initialization for field %s and %s",
v2->toChars(), vd->toChars());
errors = true;
}
}
else
{
// Will fix Bugzilla 1432 by enabling this path always
/* Prefer explicitly initialized field
* union U { int a; int b = 2; }
* U u; // OK (u.b == 2)
*/
if (!vx || (!vx->_init && v2->_init))
{
vx = v2;
fieldi = j;
}
else if (vx != vd && !vx->isOverlappedWith(v2))
{
// Both vx and v2 fills vd, but vx and v2 does not overlap
}
else if (vx->_init && v2->_init)
{
::error(loc, "overlapping default initialization for field %s and %s",
v2->toChars(), vd->toChars());
errors = true;
}
else
assert(vx->_init || (!vx->_init && !v2->_init));
}
}
if (vx)
{
Expression *e;
if (vx->type->size() == 0)
{
e = NULL;
}
else if (vx->_init)
{
assert(!vx->_init->isVoidInitializer());
if (vx->inuse) // https://issues.dlang.org/show_bug.cgi?id=18057
{
vx->error(loc, "recursive initialization of field");
errors = true;
e = NULL;
}
else
e = vx->getConstInitializer(false);
}
else
{
if ((vx->storage_class & STCnodefaultctor) && !ctorinit)
{
::error(loc, "field %s.%s must be initialized because it has no default constructor",
type->toChars(), vx->toChars());
errors = true;
}
/* Bugzilla 12509: Get the element of static array type.
*/
Type *telem = vx->type;
if (telem->ty == Tsarray)
{
/* We cannot use Type::baseElemOf() here.
* If the bottom of the Tsarray is an enum type, baseElemOf()
* will return the base of the enum, and its default initializer
* would be different from the enum's.
*/
while (telem->toBasetype()->ty == Tsarray)
telem = ((TypeSArray *)telem->toBasetype())->next;
if (telem->ty == Tvoid)
telem = Type::tuns8->addMod(telem->mod);
}
if (telem->needsNested() && ctorinit)
e = telem->defaultInit(loc);
else
e = telem->defaultInitLiteral(loc);
}
(*elements)[fieldi] = e;
}
}
for (size_t i = 0; i < elements->dim; i++)
{
Expression *e = (*elements)[i];
if (e && e->op == TOKerror)
return false;
}
return !errors;
}
/****************************
* Do byte or word alignment as necessary.
* Align sizes of 0, as we may not know array sizes yet.
*
* alignment: struct alignment that is in effect
* size: alignment requirement of field
*/
void AggregateDeclaration::alignmember(
structalign_t alignment,
unsigned size,
unsigned *poffset)
{
//printf("alignment = %d, size = %d, offset = %d\n",alignment,size,offset);
switch (alignment)
{
case (structalign_t) 1:
// No alignment
break;
case (structalign_t) STRUCTALIGN_DEFAULT:
// Alignment in Target::fieldalignsize must match what the
// corresponding C compiler's default alignment behavior is.
assert(size > 0 && !(size & (size - 1)));
*poffset = (*poffset + size - 1) & ~(size - 1);
break;
default:
// Align on alignment boundary, which must be a positive power of 2
assert(alignment > 0 && !(alignment & (alignment - 1)));
*poffset = (*poffset + alignment - 1) & ~(alignment - 1);
break;
}
}
/****************************************
* Place a member (mem) into an aggregate (agg), which can be a struct, union or class
* Returns:
* offset to place field at
*
* nextoffset: next location in aggregate
* memsize: size of member
* memalignsize: natural alignment of member
* alignment: alignment in effect for this member
* paggsize: size of aggregate (updated)
* paggalignsize: alignment of aggregate (updated)
* isunion: the aggregate is a union
*/
unsigned AggregateDeclaration::placeField(
unsigned *nextoffset,
unsigned memsize,
unsigned memalignsize,
structalign_t alignment,
unsigned *paggsize,
unsigned *paggalignsize,
bool isunion
)
{
unsigned ofs = *nextoffset;
const unsigned actualAlignment =
alignment == STRUCTALIGN_DEFAULT ? memalignsize : alignment;
alignmember(alignment, memalignsize, &ofs);
unsigned memoffset = ofs;
ofs += memsize;
if (ofs > *paggsize)
*paggsize = ofs;
if (!isunion)
*nextoffset = ofs;
if (*paggalignsize < actualAlignment)
*paggalignsize = actualAlignment;
return memoffset;
}
/****************************************
* Returns true if there's an extra member which is the 'this'
* pointer to the enclosing context (enclosing aggregate or function)
*/
bool AggregateDeclaration::isNested()
{
return enclosing != NULL;
}
/* Append vthis field (this->tupleof[$-1]) to make this aggregate type nested.
*/
void AggregateDeclaration::makeNested()
{
if (enclosing) // if already nested
return;
if (sizeok == SIZEOKdone)
return;
if (isUnionDeclaration() || isInterfaceDeclaration())
return;
if (storage_class & STCstatic)
return;
// If nested struct, add in hidden 'this' pointer to outer scope
Dsymbol *s = toParent2();
if (!s)
return;
Type *t = NULL;
if (FuncDeclaration *fd = s->isFuncDeclaration())
{
enclosing = fd;
/* Bugzilla 14422: If a nested class parent is a function, its
* context pointer (== `outer`) should be void* always.
*/
t = Type::tvoidptr;
}
else if (AggregateDeclaration *ad = s->isAggregateDeclaration())
{
if (isClassDeclaration() && ad->isClassDeclaration())
{
enclosing = ad;
}
else if (isStructDeclaration())
{
if (TemplateInstance *ti = ad->parent->isTemplateInstance())
{
enclosing = ti->enclosing;
}
}
t = ad->handleType();
}
if (enclosing)
{
//printf("makeNested %s, enclosing = %s\n", toChars(), enclosing->toChars());
assert(t);
if (t->ty == Tstruct)
t = Type::tvoidptr; // t should not be a ref type
assert(!vthis);
vthis = new ThisDeclaration(loc, t);
//vthis->storage_class |= STCref;
// Emulate vthis->addMember()
members->push(vthis);
// Emulate vthis->semantic()
vthis->storage_class |= STCfield;
vthis->parent = this;
vthis->protection = Prot(PROTpublic);
vthis->alignment = t->alignment();
vthis->semanticRun = PASSsemanticdone;
if (sizeok == SIZEOKfwd)
fields.push(vthis);
}
}
/*******************************************
* Look for constructor declaration.
*/
Dsymbol *AggregateDeclaration::searchCtor()
{
Dsymbol *s = search(Loc(), Id::ctor);
if (s)
{
if (!(s->isCtorDeclaration() ||
s->isTemplateDeclaration() ||
s->isOverloadSet()))
{
s->error("is not a constructor; identifiers starting with __ are reserved for the implementation");
errors = true;
s = NULL;
}
}
if (s && s->toParent() != this)
s = NULL; // search() looks through ancestor classes
if (s)
{
// Finish all constructors semantics to determine this->noDefaultCtor.
struct SearchCtor
{
static int fp(Dsymbol *s, void *)
{
CtorDeclaration *f = s->isCtorDeclaration();
if (f && f->semanticRun == PASSinit)
f->semantic(NULL);
return 0;
}
};
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *sm = (*members)[i];
sm->apply(&SearchCtor::fp, NULL);
}
}
return s;
}
/********************************* StructDeclaration ****************************/
StructDeclaration::StructDeclaration(Loc loc, Identifier *id, bool inObject)
: AggregateDeclaration(loc, id)
{
zeroInit = 0; // assume false until we do semantic processing
hasIdentityAssign = false;
hasIdentityEquals = false;
postblit = NULL;
xeq = NULL;
xcmp = NULL;
xhash = NULL;
alignment = 0;
ispod = ISPODfwd;
arg1type = NULL;
arg2type = NULL;
requestTypeInfo = false;
// For forward references
type = new TypeStruct(this);
if (inObject)
{
if (id == Id::ModuleInfo && !Module::moduleinfo)
Module::moduleinfo = this;
}
}
StructDeclaration *StructDeclaration::create(Loc loc, Identifier *id, bool inObject)
{
return new StructDeclaration(loc, id, inObject);
}
Dsymbol *StructDeclaration::syntaxCopy(Dsymbol *s)
{
StructDeclaration *sd =
s ? (StructDeclaration *)s
: new StructDeclaration(loc, ident, false);
return ScopeDsymbol::syntaxCopy(sd);
}
void StructDeclaration::semantic(Scope *sc)
{
//printf("StructDeclaration::semantic(this=%p, %s '%s', sizeok = %d)\n", this, parent->toChars(), toChars(), sizeok);
//static int count; if (++count == 20) halt();
if (semanticRun >= PASSsemanticdone)
return;
unsigned errors = global.errors;
//printf("+StructDeclaration::semantic(this=%p, %s '%s', sizeok = %d)\n", this, parent->toChars(), toChars(), sizeok);
Scope *scx = NULL;
if (_scope)
{
sc = _scope;
scx = _scope; // save so we don't make redundant copies
_scope = NULL;
}
if (!parent)
{
assert(sc->parent && sc->func);
parent = sc->parent;
}
assert(parent && !isAnonymous());
if (this->errors)
type = Type::terror;
if (semanticRun == PASSinit)
type = type->addSTC(sc->stc | storage_class);
type = type->semantic(loc, sc);
if (type->ty == Tstruct && ((TypeStruct *)type)->sym != this)
{
TemplateInstance *ti = ((TypeStruct *)type)->sym->isInstantiated();
if (ti && isError(ti))
((TypeStruct *)type)->sym = this;
}
// Ungag errors when not speculative
Ungag ungag = ungagSpeculative();
if (semanticRun == PASSinit)
{
protection = sc->protection;
alignment = sc->alignment();
storage_class |= sc->stc;
if (storage_class & STCdeprecated)
isdeprecated = true;
if (storage_class & STCabstract)
error("structs, unions cannot be abstract");
userAttribDecl = sc->userAttribDecl;
}
else if (symtab && !scx)
{
return;
}
semanticRun = PASSsemantic;
if (!members) // if opaque declaration
{
semanticRun = PASSsemanticdone;
return;
}
if (!symtab)
{
symtab = new DsymbolTable();
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
//printf("adding member '%s' to '%s'\n", s->toChars(), this->toChars());
s->addMember(sc, this);
}
}
Scope *sc2 = newScope(sc);
/* Set scope so if there are forward references, we still might be able to
* resolve individual members like enums.
*/
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
//printf("struct: setScope %s %s\n", s->kind(), s->toChars());
s->setScope(sc2);
}
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
s->importAll(sc2);
}
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
s->semantic(sc2);
}
if (!determineFields())
{
assert(type->ty == Terror);
sc2->pop();
semanticRun = PASSsemanticdone;
return;
}
/* Following special member functions creation needs semantic analysis
* completion of sub-structs in each field types. For example, buildDtor
* needs to check existence of elaborate dtor in type of each fields.
* See the case in compilable/test14838.d
*/
for (size_t i = 0; i < fields.dim; i++)
{
VarDeclaration *v = fields[i];
Type *tb = v->type->baseElemOf();
if (tb->ty != Tstruct)
continue;
StructDeclaration *sd = ((TypeStruct *)tb)->sym;
if (sd->semanticRun >= PASSsemanticdone)
continue;
sc2->pop();
_scope = scx ? scx : sc->copy();
_scope->setNoFree();
_scope->_module->addDeferredSemantic(this);
//printf("\tdeferring %s\n", toChars());
return;
}
/* Look for special member functions.
*/
aggNew = (NewDeclaration *)search(Loc(), Id::classNew);
aggDelete = (DeleteDeclaration *)search(Loc(), Id::classDelete);
// Look for the constructor
ctor = searchCtor();
dtor = buildDtor(this, sc2);
postblit = buildPostBlit(this, sc2);
buildOpAssign(this, sc2);
buildOpEquals(this, sc2);
if (global.params.useTypeInfo && Type::dtypeinfo) // these functions are used for TypeInfo
{
xeq = buildXopEquals(this, sc2);
xcmp = buildXopCmp(this, sc2);
xhash = buildXtoHash(this, sc2);
}
inv = buildInv(this, sc2);
Module::dprogress++;
semanticRun = PASSsemanticdone;
//printf("-StructDeclaration::semantic(this=%p, '%s')\n", this, toChars());
sc2->pop();
if (ctor)
{
Dsymbol *scall = search(Loc(), Id::call);
if (scall)
{
unsigned xerrors = global.startGagging();
sc = sc->push();
sc->tinst = NULL;
sc->minst = NULL;
FuncDeclaration *fcall = resolveFuncCall(loc, sc, scall, NULL, NULL, NULL, 1);
sc = sc->pop();
global.endGagging(xerrors);
if (fcall && fcall->isStatic())
{
error(fcall->loc, "static opCall is hidden by constructors and can never be called");
errorSupplemental(fcall->loc, "Please use a factory method instead, or replace all constructors with static opCall.");
}
}
}
if (global.errors != errors)
{
// The type is no good.
type = Type::terror;
this->errors = true;
if (deferred)
deferred->errors = true;
}
if (deferred && !global.gag)
{
deferred->semantic2(sc);
deferred->semantic3(sc);
}
assert(type->ty != Tstruct || ((TypeStruct *)type)->sym == this);
}
Dsymbol *StructDeclaration::search(const Loc &loc, Identifier *ident, int flags)
{
//printf("%s.StructDeclaration::search('%s', flags = x%x)\n", toChars(), ident->toChars(), flags);
if (_scope && !symtab)
semantic(_scope);
if (!members || !symtab) // opaque or semantic() is not yet called
{
error("is forward referenced when looking for '%s'", ident->toChars());
return NULL;
}
return ScopeDsymbol::search(loc, ident, flags);
}
void StructDeclaration::finalizeSize()
{
//printf("StructDeclaration::finalizeSize() %s, sizeok = %d\n", toChars(), sizeok);
assert(sizeok != SIZEOKdone);
//printf("+StructDeclaration::finalizeSize() %s, fields.dim = %d, sizeok = %d\n", toChars(), fields.dim, sizeok);
fields.setDim(0); // workaround
// Set the offsets of the fields and determine the size of the struct
unsigned offset = 0;
bool isunion = isUnionDeclaration() != NULL;
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
s->setFieldOffset(this, &offset, isunion);
}
if (type->ty == Terror)
return;
// 0 sized struct's are set to 1 byte
if (structsize == 0)
{
structsize = 1;
alignsize = 1;
}
// Round struct size up to next alignsize boundary.
// This will ensure that arrays of structs will get their internals
// aligned properly.
if (alignment == STRUCTALIGN_DEFAULT)
structsize = (structsize + alignsize - 1) & ~(alignsize - 1);
else
structsize = (structsize + alignment - 1) & ~(alignment - 1);
sizeok = SIZEOKdone;
//printf("-StructDeclaration::finalizeSize() %s, fields.dim = %d, structsize = %d\n", toChars(), fields.dim, structsize);
if (errors)
return;
// Calculate fields[i]->overlapped
if (checkOverlappedFields())
{
errors = true;
return;
}
// Determine if struct is all zeros or not
zeroInit = 1;
for (size_t i = 0; i < fields.dim; i++)
{
VarDeclaration *vd = fields[i];
if (vd->_init)
{
// Should examine init to see if it is really all 0's
zeroInit = 0;
break;
}
else if (!vd->type->isZeroInit(loc))
{
zeroInit = 0;
break;
}
}
TypeTuple *tt = toArgTypes(type);
size_t dim = tt->arguments->dim;
if (dim >= 1)
{
assert(dim <= 2);
arg1type = (*tt->arguments)[0]->type;
if (dim == 2)
arg2type = (*tt->arguments)[1]->type;
}
}
/***************************************
* Fit elements[] to the corresponding type of field[].
* Input:
* loc
* sc
* elements The explicit arguments that given to construct object.
* stype The constructed object type.
* Returns false if any errors occur.
* Otherwise, returns true and elements[] are rewritten for the output.
*/
bool StructDeclaration::fit(Loc loc, Scope *sc, Expressions *elements, Type *stype)
{
if (!elements)
return true;
size_t nfields = fields.dim - isNested();
size_t offset = 0;
for (size_t i = 0; i < elements->dim; i++)
{
Expression *e = (*elements)[i];
if (!e)
continue;
e = resolveProperties(sc, e);
if (i >= nfields)
{
if (i == fields.dim - 1 && isNested() && e->op == TOKnull)
{
// CTFE sometimes creates null as hidden pointer; we'll allow this.
continue;
}
::error(loc, "more initializers than fields (%d) of %s", (int)nfields, toChars());
return false;
}
VarDeclaration *v = fields[i];
if (v->offset < offset)
{
::error(loc, "overlapping initialization for %s", v->toChars());
return false;
}
offset = (unsigned)(v->offset + v->type->size());
Type *t = v->type;
if (stype)
t = t->addMod(stype->mod);
Type *origType = t;
Type *tb = t->toBasetype();
/* Look for case of initializing a static array with a too-short
* string literal, such as:
* char[5] foo = "abc";
* Allow this by doing an explicit cast, which will lengthen the string
* literal.
*/
if (e->op == TOKstring && tb->ty == Tsarray)
{
StringExp *se = (StringExp *)e;
Type *typeb = se->type->toBasetype();
TY tynto = tb->nextOf()->ty;
if (!se->committed &&
(typeb->ty == Tarray || typeb->ty == Tsarray) &&
(tynto == Tchar || tynto == Twchar || tynto == Tdchar) &&
se->numberOfCodeUnits(tynto) < ((TypeSArray *)tb)->dim->toInteger())
{
e = se->castTo(sc, t);
goto L1;
}
}
while (!e->implicitConvTo(t) && tb->ty == Tsarray)
{
/* Static array initialization, as in:
* T[3][5] = e;
*/
t = tb->nextOf();
tb = t->toBasetype();
}
if (!e->implicitConvTo(t))
t = origType; // restore type for better diagnostic
e = e->implicitCastTo(sc, t);
L1:
if (e->op == TOKerror)
return false;
(*elements)[i] = doCopyOrMove(sc, e);
}
return true;
}
/***************************************
* Return true if struct is POD (Plain Old Data).
* This is defined as:
* not nested
* no postblits, destructors, or assignment operators
* no 'ref' fields or fields that are themselves non-POD
* The idea being these are compatible with C structs.
*/
bool StructDeclaration::isPOD()
{
// If we've already determined whether this struct is POD.
if (ispod != ISPODfwd)
return (ispod == ISPODyes);
ispod = ISPODyes;
if (enclosing || postblit || dtor)
ispod = ISPODno;
// Recursively check all fields are POD.
for (size_t i = 0; i < fields.dim; i++)
{
VarDeclaration *v = fields[i];
if (v->storage_class & STCref)
{
ispod = ISPODno;
break;
}
Type *tv = v->type->baseElemOf();
if (tv->ty == Tstruct)
{
TypeStruct *ts = (TypeStruct *)tv;
StructDeclaration *sd = ts->sym;
if (!sd->isPOD())
{
ispod = ISPODno;
break;
}
}
}
return (ispod == ISPODyes);
}
const char *StructDeclaration::kind() const
{
return "struct";
}
/********************************* UnionDeclaration ****************************/
UnionDeclaration::UnionDeclaration(Loc loc, Identifier *id)
: StructDeclaration(loc, id, false)
{
}
Dsymbol *UnionDeclaration::syntaxCopy(Dsymbol *s)
{
assert(!s);
UnionDeclaration *ud = new UnionDeclaration(loc, ident);
return StructDeclaration::syntaxCopy(ud);
}
const char *UnionDeclaration::kind() const
{
return "union";
}