Type *ArrayInitializer::inferType(Scope *sc)
{
for (size_t i = 0; i < value.dim; i++)
{
if (index.data[i])
goto Laa;
}
if (value.dim)
{
Initializer *iz = (Initializer *)value.data[0];
if (iz)
{ Type *t = iz->inferType(sc);
t = new TypeSArray(t, new IntegerExp(value.dim));
t = t->semantic(loc, sc);
return t;
}
}
Laa:
/* It's possibly an associative array initializer
*/
Initializer *iz = (Initializer *)value.data[0];
Expression *indexinit = (Expression *)index.data[0];
if (iz && indexinit)
{ Type *t = iz->inferType(sc);
indexinit = indexinit->semantic(sc);
Type *indext = indexinit->type;
t = new TypeAArray(t, indext);
type = t->semantic(loc, sc);
}
else
error(loc, "cannot infer type from this array initializer");
return type;
}
Type *ArrayInitializer::inferType(Scope *sc)
{
//printf("ArrayInitializer::inferType() %s\n", toChars());
assert(0);
return NULL;
#if 0
type = Type::terror;
for (size_t i = 0; i < value.dim; i++)
{
if (index.data[i])
goto Laa;
}
for (size_t i = 0; i < value.dim; i++)
{
Initializer *iz = (Initializer *)value.data[i];
if (iz)
{ Type *t = iz->inferType(sc);
if (i == 0)
{ /* BUG: This gets the type from the first element.
* Fix to use all the elements to figure out the type.
*/
t = new TypeSArray(t, new IntegerExp(value.dim));
t = t->semantic(loc, sc);
type = t;
}
}
}
return type;
Laa:
/* It's possibly an associative array initializer.
* BUG: inferring type from first member.
*/
Initializer *iz = (Initializer *)value.data[0];
Expression *indexinit = (Expression *)index.data[0];
if (iz && indexinit)
{ Type *t = iz->inferType(sc);
indexinit = indexinit->semantic(sc);
Type *indext = indexinit->type;
t = new TypeAArray(t, indext);
type = t->semantic(loc, sc);
}
else
error(loc, "cannot infer type from this array initializer");
return type;
#endif
}
Type *ArrayInitializer::inferType(Scope *sc)
{
for (size_t i = 0; i < value.dim; i++)
{
if (index.data[i])
goto Lno;
}
if (value.dim)
{
Initializer *iz = (Initializer *)value.data[0];
if (iz)
{ Type *t = iz->inferType(sc);
t = new TypeSArray(t, new IntegerExp(value.dim));
t = t->semantic(loc, sc);
return t;
}
}
Lno:
//error(loc, "cannot infer type from this array initializer");
return Type::terror;
}
Initializer *ArrayInitializer::inferType(Scope *sc)
{
//printf("ArrayInitializer::inferType() %s\n", toChars());
Expressions *keys = NULL;
Expressions *values;
if (isAssociativeArray())
{
keys = new Expressions();
keys->setDim(value.dim);
values = new Expressions();
values->setDim(value.dim);
for (size_t i = 0; i < value.dim; i++)
{
Expression *e = index[i];
if (!e)
goto Lno;
(*keys)[i] = e;
Initializer *iz = value[i];
if (!iz)
goto Lno;
iz = iz->inferType(sc);
if (iz->isErrorInitializer())
return iz;
assert(iz->isExpInitializer());
(*values)[i] = ((ExpInitializer *)iz)->exp;
assert((*values)[i]->op != TOKerror);
}
Expression *e = new AssocArrayLiteralExp(loc, keys, values);
ExpInitializer *ei = new ExpInitializer(loc, e);
return ei->inferType(sc);
}
else
{
Expressions *elements = new Expressions();
elements->setDim(value.dim);
elements->zero();
for (size_t i = 0; i < value.dim; i++)
{
assert(!index[i]); // already asserted by isAssociativeArray()
Initializer *iz = value[i];
if (!iz)
goto Lno;
iz = iz->inferType(sc);
if (iz->isErrorInitializer())
return iz;
assert(iz->isExpInitializer());
(*elements)[i] = ((ExpInitializer *)iz)->exp;
assert((*elements)[i]->op != TOKerror);
}
Expression *e = new ArrayLiteralExp(loc, elements);
ExpInitializer *ei = new ExpInitializer(loc, e);
return ei->inferType(sc);
}
Lno:
if (keys)
{
delete keys;
delete values;
error(loc, "not an associative array initializer");
}
else
{
error(loc, "cannot infer type from array initializer");
}
return new ErrorInitializer();
}
Initializer *ArrayInitializer::inferType(Scope *sc, Type *tx)
{
//printf("ArrayInitializer::inferType() %s\n", toChars());
Expressions *keys = NULL;
Expressions *values;
if (tx ? (tx->ty == Taarray ||
tx->ty != Tarray && tx->ty != Tsarray && isAssociativeArray())
: isAssociativeArray())
{
Type *tidx = NULL;
Type *tval = NULL;
if (tx && tx->ty == Taarray)
{
tidx = ((TypeAArray *)tx)->index;
tval = ((TypeAArray *)tx)->next;
}
keys = new Expressions();
keys->setDim(value.dim);
values = new Expressions();
values->setDim(value.dim);
for (size_t i = 0; i < value.dim; i++)
{
Expression *e = index[i];
if (!e)
goto Lno;
if (tidx)
{
e = ::inferType(e, tidx);
e = e->semantic(sc);
e = resolveProperties(sc, e);
if (tidx->deco) // tidx may be partial type
e = e->implicitCastTo(sc, tidx);
}
(*keys)[i] = e;
Initializer *iz = value[i];
if (!iz)
goto Lno;
iz = iz->inferType(sc, tval);
if (iz->isErrorInitializer())
return iz;
assert(iz->isExpInitializer());
(*values)[i] = ((ExpInitializer *)iz)->exp;
assert((*values)[i]->op != TOKerror);
}
Expression *e = new AssocArrayLiteralExp(loc, keys, values);
ExpInitializer *ei = new ExpInitializer(loc, e);
return ei->inferType(sc, tx);
}
else
{
Type *tn = NULL;
if (tx && (tx->ty == Tarray || tx->ty == Tsarray))
tn = ((TypeNext *)tx)->next;
Expressions *elements = new Expressions();
elements->setDim(value.dim);
elements->zero();
for (size_t i = 0; i < value.dim; i++)
{
assert(!index[i]); // already asserted by isAssociativeArray()
Initializer *iz = value[i];
if (!iz)
goto Lno;
iz = iz->inferType(sc, tn);
if (iz->isErrorInitializer())
return iz;
assert(iz->isExpInitializer());
(*elements)[i] = ((ExpInitializer *)iz)->exp;
assert((*elements)[i]->op != TOKerror);
}
Expression *e = new ArrayLiteralExp(loc, elements);
ExpInitializer *ei = new ExpInitializer(loc, e);
return ei->inferType(sc, tx);
}
Lno:
if (keys)
{
delete keys;
delete values;
error(loc, "not an associative array initializer");
}
else
{
error(loc, "cannot infer type from array initializer");
}
return new ErrorInitializer();
}
