63 changes: 63 additions & 0 deletions src/module.c
Original file line number Diff line number Diff line change
Expand Up @@ -531,6 +531,69 @@ Module *Module::parse()
error("has non-identifier characters in filename, use module declaration instead");
}

// Add internal used functions in 'object' module members.
if (!parent && ident == Id::object)
{
static const utf8_t code_ArrayEq[] =
"bool _ArrayEq(T1, T2)(T1[] a, T2[] b) {\n"
" if (a.length != b.length) return false;\n"
" foreach (size_t i; 0 .. a.length) { if (a[i] != b[i]) return false; }\n"
" return true; }\n";

static const utf8_t code_ArrayPostblit[] =
"void _ArrayPostblit(T)(T[] a) { foreach (ref T e; a) e.__xpostblit(); }\n";

static const utf8_t code_ArrayDtor[] =
"void _ArrayDtor(T)(T[] a) { foreach_reverse (ref T e; a) e.__xdtor(); }\n";

static const utf8_t code_xopEquals[] =
"bool _xopEquals(in void*, in void*) { throw new Error(\"TypeInfo.equals is not implemented\"); }\n";

static const utf8_t code_xopCmp[] =
"bool _xopCmp(in void*, in void*) { throw new Error(\"TypeInfo.compare is not implemented\"); }\n";

Identifier *arreq = Id::_ArrayEq;
Identifier *xopeq = Identifier::idPool("_xopEquals");
Identifier *xopcmp = Identifier::idPool("_xopCmp");
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *sx = (*members)[i];
if (!sx) continue;
if (arreq && sx->ident == arreq) arreq = NULL;
if (xopeq && sx->ident == xopeq) xopeq = NULL;
if (xopcmp && sx->ident == xopcmp) xopcmp = NULL;
}

if (arreq)
{
Parser p(loc, this, code_ArrayEq, strlen((const char *)code_ArrayEq), 0);
p.nextToken();
members->append(p.parseDeclDefs(0));
}
{
Parser p(loc, this, code_ArrayPostblit, strlen((const char *)code_ArrayPostblit), 0);
p.nextToken();
members->append(p.parseDeclDefs(0));
}
{
Parser p(loc, this, code_ArrayDtor, strlen((const char *)code_ArrayDtor), 0);
p.nextToken();
members->append(p.parseDeclDefs(0));
}
if (xopeq)
{
Parser p(loc, this, code_xopEquals, strlen((const char *)code_xopEquals), 0);
p.nextToken();
members->append(p.parseDeclDefs(0));
}
if (xopcmp)
{
Parser p(loc, this, code_xopCmp, strlen((const char *)code_xopCmp), 0);
p.nextToken();
members->append(p.parseDeclDefs(0));
}
}

// Insert module into the symbol table
Dsymbol *s = this;
if (isPackageFile)
Expand Down
43 changes: 35 additions & 8 deletions src/struct.c
Original file line number Diff line number Diff line change
Expand Up @@ -729,13 +729,10 @@ void StructDeclaration::semantic(Scope *sc)
error("structs, unions cannot be abstract");
userAttribDecl = sc->userAttribDecl;
}
else if (symtab)
else if (symtab && !scx)
{
if (sizeok == SIZEOKdone || !scx)
{
semanticRun = PASSsemanticdone;
return;
}
semanticRun = PASSsemanticdone;
return;
}
semanticRun = PASSsemantic;

Expand All @@ -757,7 +754,6 @@ void StructDeclaration::semantic(Scope *sc)
}
}

sizeok = SIZEOKnone;
Scope *sc2 = sc->push(this);
sc2->stc &= STCsafe | STCtrusted | STCsystem;
sc2->parent = this;
Expand All @@ -768,6 +764,11 @@ void StructDeclaration::semantic(Scope *sc)
sc2->structalign = STRUCTALIGN_DEFAULT;
sc2->userAttribDecl = NULL;

if (sizeok == SIZEOKdone)
goto LafterSizeok;

sizeok = SIZEOKnone;

/* Set scope so if there are forward references, we still might be able to
* resolve individual members like enums.
*/
Expand Down Expand Up @@ -816,10 +817,33 @@ void StructDeclaration::semantic(Scope *sc)
}

Module::dprogress++;
semanticRun = PASSsemanticdone;

//printf("-StructDeclaration::semantic(this=%p, '%s')\n", this, toChars());

LafterSizeok:
// The additions of special member functions should have its own
// sub-semantic analysis pass, and have to be deferred sometimes.
// 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);
Expand Down Expand Up @@ -871,6 +895,9 @@ void StructDeclaration::semantic(Scope *sc)
}
}

Module::dprogress++;
semanticRun = PASSsemanticdone;

TypeTuple *tup = toArgTypes(type);
size_t dim = tup->arguments->dim;
if (dim >= 1)
Expand Down
33 changes: 24 additions & 9 deletions src/template.c
Original file line number Diff line number Diff line change
Expand Up @@ -1927,10 +1927,10 @@ MATCH TemplateDeclaration::deduceFunctionTemplateMatch(
{
// if tuple parameter and
// tuple parameter was not in function parameter list and
// we're one argument short (i.e. no tuple argument)
if (tp &&
// we're one or more arguments short (i.e. no tuple argument)
if (tparam == tp &&
fptupindex == IDX_NOTFOUND &&
ntargs == dedargs->dim - 1)
ntargs <= dedargs->dim - 1)
{
// make tuple argument an empty tuple
oded = (RootObject *)new Tuple();
Expand Down Expand Up @@ -1965,7 +1965,8 @@ MATCH TemplateDeclaration::deduceFunctionTemplateMatch(

/* Bugzilla 7469: Normalize ti->tiargs for the correct mangling of template instance.
*/
if (Tuple *va = isTuple(oded))
Tuple *va = isTuple(oded);
if (va && va->objects.dim)
{
dedargs->setDim(parameters->dim - 1 + va->objects.dim);
for (size_t j = 0; j < va->objects.dim; j++)
Expand Down Expand Up @@ -7887,14 +7888,28 @@ bool TemplateInstance::needsCodegen()
//printf("%s minst = %s, enclosing (%s)->isNonRoot = %d\n",
// toPrettyChars(), minst ? minst->toChars() : NULL,
// enclosing ? enclosing->toPrettyChars() : NULL, enclosing && enclosing->inNonRoot());
if (enclosing && !tinst)
if (enclosing)
{
// Bugzilla 13415: If and only if the enclosing scope needs codegen,
// the nested templates would need code generation.
// Bugzilla 14588: If the captured context is not a function
// (e.g. class), the instance layout determination is guaranteed,
// because the semantic/semantic2 pass will be executed
// even for non-root instances.
if (!enclosing->isFuncDeclaration())
return true;

// Bugzilla 14834: If the captured context is a function,
// this excessive instantiation may cause ODR violation, because
// -allInst and others doesn't guarantee the semantic3 execution
// for that function.

// If the enclosing is also an instantiated function,
// we have to rely on the ancestor's needsCodegen() result.
if (TemplateInstance *ti = enclosing->isInstantiated())
return ti->needsCodegen();
else
return !enclosing->inNonRoot();

// Bugzilla 13415: If and only if the enclosing scope needs codegen,
// this nested templates would also need code generation.
return !enclosing->inNonRoot();
}
return true;
}
Expand Down
91 changes: 91 additions & 0 deletions test/compilable/test14838.d
Original file line number Diff line number Diff line change
@@ -0,0 +1,91 @@
// PERMUTE_ARGS:

struct A(T) { ~this() {} }
class C { A!int[1] array; }

void test14838() pure nothrow @nogc @safe
{
C c;
c.__xdtor(); // C.~this() will also be inferred to
// pure nothrow @nogc @safe

A!int[1] array;
// scope destructor call does not cause attribute violation.
}

// ----

/*
* This is a reduced test case comes from std.container.Array template,
* to fix the semantic analysis order issue for correct destructor attribute inference.
*
* Before the bugfix:
* 1. StructDeclaration('Array!int')->semantic() instantiates
* RangeT!(Array!int) at the `alias Range = ...;`, but
* StructDeclaration('RangeT!(Array!int)')->semantic() exits
* with sizeok == SIZEOKfwd, because the size of _outer_ field is not yet determined.
* 2. StructDeclaration('Array!int')->semantic() succeeds to determine the size
* (sizeok = SIZEOKdone).
* 3. StructDeclaration('Array!int')->buildOpAssign() will generate opAssign because
* Array!int._data field has identity opAssign member function.
* 4. The semantic3 will get called for the generated opAssign, then
* 6-1. Array!int.~this() semantic3, and
* 6-2. RefCounted!(Array!int.Payload).~this() semantic3
* will also get called to infer their attributes.
* 5. In RefCounted!(Array!int.Payload).~this(), destroy(t) will be instantiated.
* At that, TemplateInstance::expandMembers() will invoke runDeferredSemantic()
* and it will re-run StructDeclaration('RangeT!(Array!int)')->semantic().
* 6. StructDeclaration('RangeT!(Array!int)')->semantic() determines the size
* (sizeok = SIZEOKdone). Then, it will generate identity opAssign and run its semantic3.
* It will need to infer RangeT!(Array!int).~this() attribute, then it requires the
* correct attribute of Array!int.~this().
*
* However, the Array!int.~this() attribute is not yet determined! [bug]
* -> it's wongly handled as impure/system/throwable/gc-able.
*
* -> then, the attribute inference results for
* RangeT!(Array!int).~this() and Array!int.~this() will be incorrect.
*
* After the bugfix:
* In 6, StructDeclaration('RangeT!(Array!int)')->semantic() will check that:
* all base struct types of the instance fields have completed addition of
* special functions (dtor, opAssign, etc).
* If not, it will defer the completion of its semantic pass.
*/

void destroy14838(S)(ref S s) if (is(S == struct))
{
s.__xdtor();
}

struct RefCounted14838(T)
{
~this()
{
T t;
.destroy14838(t);
}

void opAssign(typeof(this) rhs) {}
}

struct RangeT14838(A)
{
A[1] _outer_;
}

struct Array14838(T)
{
struct Payload
{
~this() {}
}
RefCounted14838!Payload _data;

alias Range = RangeT14838!Array14838;
}

class Test14838
{
Array14838!int[1] field;
}
57 changes: 57 additions & 0 deletions test/runnable/extra-files/link14834a.d
Original file line number Diff line number Diff line change
@@ -0,0 +1,57 @@
module link14834a;

struct DirIterator
{
int i = 1;

@property bool empty() { return i == 0; }
@property int front() { return 10; }
void popFront() { --i; }
}

auto dirEntries(string path)
{
bool f(int x)
{
assert(path == "."); // should pass
return true;
}
return filter!f(DirIterator());
}

template filter(alias pred)
{
auto filter(R)(R range)
{
return FilterResult!(pred, R)(range);
}
}

struct FilterResult(alias pred, R)
{
R input;

this(R r)
{
input = r;
while (!input.empty && !pred(input.front))
{
input.popFront();
}
}

@property bool empty() { return input.empty; }

@property auto ref front()
{
return input.front;
}

void popFront()
{
do
{
input.popFront();
} while (!input.empty && !pred(input.front));
}
}
9 changes: 9 additions & 0 deletions test/runnable/extra-files/link14834b.d
Original file line number Diff line number Diff line change
@@ -0,0 +1,9 @@
import link14834a;

void main()
{
foreach (n; dirEntries("."))
{
assert(n == 10);
}
}
11 changes: 11 additions & 0 deletions test/runnable/imports/link14814a.d
Original file line number Diff line number Diff line change
@@ -0,0 +1,11 @@
module imports.link14814a;

void fun0()
{
}

void fun4()
{
void function()[TypeInfo] funs;
funs[typeid(int)] = &fun0;
}
10 changes: 10 additions & 0 deletions test/runnable/link14814.d
Original file line number Diff line number Diff line change
@@ -0,0 +1,10 @@
// EXTRA_SOURCES: imports/link14814a.d
// PERMUTE_ARGS: -inline -release -g -O -fPIC
// COMPILE_SEPARATELY

import imports.link14814a;

void main()
{
fun4;
}
25 changes: 25 additions & 0 deletions test/runnable/link14834.sh
Original file line number Diff line number Diff line change
@@ -0,0 +1,25 @@
#!/usr/bin/env bash

src=runnable${SEP}extra-files
dir=${RESULTS_DIR}${SEP}runnable
output_file=${dir}${SEP}link14834.sh.out

rm -f ${output_file}

if [ $OS == "win32" -o $OS == "win64" ]; then
LIBEXT=.lib
else
LIBEXT=.a
fi

libname=${dir}${SEP}link14834${LIBEXT}
exename=${dir}${SEP}link14834${EXE}

$DMD -m${MODEL} -I${src} -lib -of${libname} ${src}${SEP}link14834a.d > ${output_file} || exit 1
$DMD -m${MODEL} -I${src} -inline -debug -of${exename} ${src}${SEP}link14834b.d ${libname} > ${output_file} || exit 1

${dir}/link14834 || exit 1

rm ${libname} ${exename} ${dir}${SEP}link14834${OBJ}

echo Success > ${output_file}
54 changes: 54 additions & 0 deletions test/runnable/sdtor.d
Original file line number Diff line number Diff line change
Expand Up @@ -3985,6 +3985,59 @@ int test14815()
}
static assert(test14815());

/**********************************/
// 14838

int test14838() pure nothrow @safe
{
int dtor;

struct S14838(T)
{
~this() { ++dtor; }
}
struct X14838
{
S14838!int ms;
const S14838!int cs;

S14838!int[2] ma;
const S14838!int[2] ca;

S14838!int[2][2] ma2x2;
const S14838!int[2][2] ca2x2;

// number of S14838 = 1*2 + 2*2 + 4*2 = 14
}

void test(Dg)(scope Dg code)
{
dtor = 0;
code();
}

test(delegate{ S14838!int a; }); assert(dtor == 1);
test(delegate{ const S14838!int a; }); assert(dtor == 1);

test(delegate{ S14838!int[2] a; }); assert(dtor == 2);
test(delegate{ const S14838!int[2] a; }); assert(dtor == 2);

test(delegate{ S14838!int[2][2] a; }); assert(dtor == 4);
test(delegate{ const S14838!int[2][2] a; }); assert(dtor == 4);

test(delegate{ X14838 a; }); assert(dtor == 1 * 14);
test(delegate{ const X14838 a; }); assert(dtor == 1 * 14);

test(delegate{ X14838[2] a; }); assert(dtor == 2 * 14);
test(delegate{ const X14838[2] a; }); assert(dtor == 2 * 14);

test(delegate{ X14838[2][2] a; }); assert(dtor == 4 * 14);
test(delegate{ const X14838[2][2] a; }); assert(dtor == 4 * 14);

return 1;
}
static assert(test14838());

/**********************************/

int main()
Expand Down Expand Up @@ -4102,6 +4155,7 @@ int main()
test13095();
test14264();
test14815();
test14838();

printf("Success\n");
return 0;
Expand Down
24 changes: 24 additions & 0 deletions test/runnable/template9.d
Original file line number Diff line number Diff line change
Expand Up @@ -4485,6 +4485,29 @@ void test14174()
accepter14174b(); // error
}

/******************************************/
// 14836

template a14836x(alias B, C...)
{
int a14836x(D...)() if (D.length == 0) { return 1; }
int a14836x(D...)(D d) if (D.length > 0) { return 2; }
}
template a14836y(alias B, C...)
{
int a14836y(T, D...)(T t) if (D.length == 0) { return 1; }
int a14836y(T, D...)(T t, D d) if (D.length > 0) { return 2; }
}

void test14836()
{
int v;
assert(a14836x!(v)() == 1);
assert(a14836x!(v)(1) == 2);
assert(a14836y!(v)(1) == 1);
assert(a14836y!(v)(1, 2) == 2);
}

/******************************************/
// 14357

Expand Down Expand Up @@ -4707,6 +4730,7 @@ int main()
test13379();
test13484();
test13694();
test14836();
test14735();

printf("Success\n");
Expand Down