Expression *ArrayExp::op_overload(Scope *sc)
{
//printf("ArrayExp::op_overload() (%s)\n", toChars());
AggregateDeclaration *ad = isAggregate(e1->type);
if (ad)
{
Dsymbol *fd = search_function(ad, opId());
if (fd)
{
/* Rewrite op e1[arguments] as:
* e1.opIndex(arguments)
*/
Expression *e = new DotIdExp(loc, e1, fd->ident);
e = new CallExp(loc, e, arguments);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis)
{
/* Rewrite op(e1) as:
* op(e1.aliasthis)
*/
Expression *e1 = new DotIdExp(loc, this->e1, ad->aliasthis->ident);
Expression *e = copy();
((UnaExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
}
return NULL;
}
void Win64TargetABI::rewriteArgument(IrFuncTy& fty, IrFuncTyArg& arg)
{
LLType* originalLType = arg.ltype;
Type* t = arg.type->toBasetype();
if (isPassedWithByvalSemantics(t))
{
// these types are passed byval:
// the caller allocates a copy and then passes a pointer to the copy
arg.rewrite = &byvalRewrite;
arg.ltype = byvalRewrite.type(arg.type, arg.ltype);
// the copy is treated as a local variable of the callee
// hence add the NoAlias and NoCapture attributes
arg.attrs.clear()
.add(LDC_ATTRIBUTE(NoAlias))
.add(LDC_ATTRIBUTE(NoCapture));
}
else if (isAggregate(t) && canRewriteAsInt(t) && !IntegerRewrite::isObsoleteFor(originalLType))
{
arg.rewrite = &integerRewrite;
arg.ltype = integerRewrite.type(arg.type, arg.ltype);
}
IF_LOG if (arg.rewrite)
{
Logger::println("Rewriting argument type %s", t->toChars());
LOG_SCOPE;
Logger::cout() << *originalLType << " => " << *arg.ltype << '\n';
}
}
// Returns true if the D type is passed byval (the callee getting a pointer
// to a dedicated hidden copy).
bool isPassedWithByvalSemantics(Type *t) const {
return
// * aggregates which can NOT be rewritten as integers
// (size > 8 bytes or not a power of 2)
(isAggregate(t) && !canRewriteAsInt(t)) ||
// * 80-bit real and ireal
(realIs80bits() && (t->ty == Tfloat80 || t->ty == Timaginary80));
}
Expression *ArrayExp::op_overload(Scope *sc)
{
//printf("ArrayExp::op_overload() (%s)\n", toChars());
AggregateDeclaration *ad = isAggregate(e1->type);
if (ad)
{
Dsymbol *fd = search_function(ad, opId());
if (fd)
{
for (size_t i = 0; i < arguments->dim; i++)
{ Expression *x = (*arguments)[i];
// Create scope for '$' variable for this dimension
ArrayScopeSymbol *sym = new ArrayScopeSymbol(sc, this);
sym->loc = loc;
sym->parent = sc->scopesym;
sc = sc->push(sym);
lengthVar = NULL; // Create it only if required
currentDimension = i; // Dimension for $, if required
x = x->semantic(sc);
x = resolveProperties(sc, x);
if (!x->type)
error("%s has no value", x->toChars());
if (lengthVar)
{ // If $ was used, declare it now
Expression *av = new DeclarationExp(loc, lengthVar);
x = new CommaExp(0, av, x);
x->semantic(sc);
}
(*arguments)[i] = x;
sc = sc->pop();
}
/* Rewrite op e1[arguments] as:
* e1.opIndex(arguments)
*/
Expression *e = new DotIdExp(loc, e1, fd->ident);
e = new CallExp(loc, e, arguments);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis)
{
/* Rewrite op(e1) as:
* op(e1.aliasthis)
*/
Expression *e1 = new DotIdExp(loc, this->e1, ad->aliasthis->ident);
Expression *e = copy();
((UnaExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
}
return NULL;
}
void visit(NewExp *e)
{
//printf("NewExp::inlineCost3() %s\n", e->toChars());
AggregateDeclaration *ad = isAggregate(e->newtype);
if (ad && ad->isNested())
cost = COST_MAX;
else
cost++;
}
Expression *resolveAliasThis(Scope *sc, Expression *e, bool gag)
{
AggregateDeclaration *ad = isAggregate(e->type);
if (ad && ad->aliasthis)
{
unsigned olderrors = gag ? global.startGagging() : 0;
Loc loc = e->loc;
Type *tthis = (e->op == TOKtype ? e->type : NULL);
e = new DotIdExp(loc, e, ad->aliasthis->ident);
e = e->semantic(sc);
if (tthis && ad->aliasthis->needThis())
{
if (e->op == TOKvar)
{
if (FuncDeclaration *f = ((VarExp *)e)->var->isFuncDeclaration())
{
// Bugzilla 13009: Support better match for the overloaded alias this.
Type *t;
f = f->overloadModMatch(loc, tthis, t);
if (f && t)
{
e = new VarExp(loc, f, 0); // use better match
e = new CallExp(loc, e);
goto L1;
}
}
}
/* non-@property function is not called inside typeof(),
* so resolve it ahead.
*/
{
int save = sc->intypeof;
sc->intypeof = 1; // bypass "need this" error check
e = resolveProperties(sc, e);
sc->intypeof = save;
}
L1:
e = new TypeExp(loc, new TypeTypeof(loc, e));
e = e->semantic(sc);
}
e = resolveProperties(sc, e);
if (gag && global.endGagging(olderrors))
e = NULL;
}
return e;
}
/***********************************************
* This is mostly the same as UnaryExp::op_overload(), but has
* a different rewrite.
*/
Expression *CastExp::op_overload(Scope *sc)
{
//printf("CastExp::op_overload() (%s)\n", toChars());
AggregateDeclaration *ad = isAggregate(e1->type);
if (ad)
{
Dsymbol *fd = NULL;
/* Rewrite as:
* e1.opCast!(T)();
*/
fd = search_function(ad, Id::cast);
if (fd)
{
#if 1 // Backwards compatibility with D1 if opCast is a function, not a template
if (fd->isFuncDeclaration())
{ // Rewrite as: e1.opCast()
return build_overload(loc, sc, e1, NULL, fd);
}
#endif
Objects *targsi = new Objects();
targsi->push(to);
Expression *e = new DotTemplateInstanceExp(loc, e1, fd->ident, targsi);
e = new CallExp(loc, e);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis)
{
/* Rewrite op(e1) as:
* op(e1.aliasthis)
*/
Expression *e1 = new DotIdExp(loc, this->e1, ad->aliasthis->ident);
Expression *e = copy();
((UnaExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
}
return NULL;
}
Expression *ArrayExp::op_overload(Scope *sc)
{
//printf("ArrayExp::op_overload() (%s)\n", toChars());
AggregateDeclaration *ad = isAggregate(e1->type);
if (ad)
{
Dsymbol *fd = search_function(ad, opId());
if (fd)
{
/* Rewrite op e1[arguments] as:
* e1.opIndex(arguments)
*/
Expression *e0 = resolveOpDollar(sc, this);
Expression *e = new DotIdExp(loc, e1, fd->ident);
e = new CallExp(loc, e, arguments);
e = combine(e0, e);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis && this->e1->type != att1)
{
/* Rewrite op(e1) as:
* op(e1.aliasthis)
*/
//printf("att arr e1 = %s\n", this->e1->type->toChars());
Expression *e1 = new DotIdExp(loc, this->e1, ad->aliasthis->ident);
UnaExp *ue = (UnaExp *)copy();
if (!ue->att1 && this->e1->type->checkAliasThisRec())
ue->att1 = this->e1->type;
ue->e1 = e1;
return ue->trySemantic(sc);
}
}
return NULL;
}
/*********************************
* Operator overloading for op=
*/
Expression *BinAssignExp::op_overload(Scope *sc)
{
//printf("BinAssignExp::op_overload() (%s)\n", toChars());
#if DMDV2
if (e1->op == TOKarray)
{
ArrayExp *ae = (ArrayExp *)e1;
ae->e1 = ae->e1->semantic(sc);
ae->e1 = resolveProperties(sc, ae->e1);
AggregateDeclaration *ad = isAggregate(ae->e1->type);
if (ad)
{
/* Rewrite a[args]+=e2 as:
* a.opIndexOpAssign!("+")(e2, args);
*/
Dsymbol *fd = search_function(ad, Id::opIndexOpAssign);
if (fd)
{
Expressions *a = new Expressions();
a->push(e2);
for (size_t i = 0; i < ae->arguments->dim; i++)
a->push(ae->arguments->tdata()[i]);
Objects *targsi = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, ae->e1, fd->ident, targsi);
e = new CallExp(loc, e, a);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis)
{
/* Rewrite a[arguments] op= e2 as:
* a.aliasthis[arguments] op= e2
*/
Expression *e1 = ae->copy();
((ArrayExp *)e1)->e1 = new DotIdExp(loc, ae->e1, ad->aliasthis->ident);
Expression *e = copy();
((UnaExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
}
}
else if (e1->op == TOKslice)
{
SliceExp *se = (SliceExp *)e1;
se->e1 = se->e1->semantic(sc);
se->e1 = resolveProperties(sc, se->e1);
AggregateDeclaration *ad = isAggregate(se->e1->type);
if (ad)
{
/* Rewrite a[lwr..upr]+=e2 as:
* a.opSliceOpAssign!("+")(e2, lwr, upr);
*/
Dsymbol *fd = search_function(ad, Id::opSliceOpAssign);
if (fd)
{
Expressions *a = new Expressions();
a->push(e2);
if (se->lwr)
{ a->push(se->lwr);
a->push(se->upr);
}
Objects *targsi = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, se->e1, fd->ident, targsi);
e = new CallExp(loc, e, a);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis)
{
/* Rewrite a[lwr..upr] op= e2 as:
* a.aliasthis[lwr..upr] op= e2
*/
Expression *e1 = se->copy();
((SliceExp *)e1)->e1 = new DotIdExp(loc, se->e1, ad->aliasthis->ident);
Expression *e = copy();
((UnaExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
}
}
#endif
BinExp::semantic(sc);
e1 = resolveProperties(sc, e1);
e2 = resolveProperties(sc, e2);
Identifier *id = opId();
Expressions args2;
AggregateDeclaration *ad1 = isAggregate(e1->type);
Dsymbol *s = NULL;
#if 1 // the old D1 scheme
if (ad1 && id)
{
s = search_function(ad1, id);
}
#endif
Objects *targsi = NULL;
#if DMDV2
if (!s)
{ /* Try the new D2 scheme, opOpAssign
*/
if (ad1)
s = search_function(ad1, Id::opOpAssign);
// Set targsi, the template argument list, which will be the operator string
if (s)
{
id = Id::opOpAssign;
targsi = opToArg(sc, op);
}
}
#endif
if (s)
{
/* Try:
* a.opOpAssign(b)
*/
args2.setDim(1);
args2.tdata()[0] = e2;
Match m;
memset(&m, 0, sizeof(m));
m.last = MATCHnomatch;
if (s)
{
FuncDeclaration *fd = s->isFuncDeclaration();
if (fd)
{
overloadResolveX(&m, fd, NULL, &args2, sc->module);
}
else
{ TemplateDeclaration *td = s->isTemplateDeclaration();
templateResolve(&m, td, sc, loc, targsi, e1, &args2);
}
}
if (m.count > 1)
{
// Error, ambiguous
error("overloads %s and %s both match argument list for %s",
m.lastf->type->toChars(),
m.nextf->type->toChars(),
m.lastf->toChars());
}
else if (m.last == MATCHnomatch)
{
m.lastf = m.anyf;
if (targsi)
goto L1;
}
// Rewrite (e1 op e2) as e1.opOpAssign(e2)
return build_overload(loc, sc, e1, e2, m.lastf ? m.lastf : s);
}
L1:
#if DMDV2
// Try alias this on first operand
if (ad1 && ad1->aliasthis)
{
/* Rewrite (e1 op e2) as:
* (e1.aliasthis op e2)
*/
Expression *e1 = new DotIdExp(loc, this->e1, ad1->aliasthis->ident);
Expression *e = copy();
((BinExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
// Try alias this on second operand
AggregateDeclaration *ad2 = isAggregate(e2->type);
if (ad2 && ad2->aliasthis)
{
/* Rewrite (e1 op e2) as:
* (e1 op e2.aliasthis)
*/
Expression *e2 = new DotIdExp(loc, this->e2, ad2->aliasthis->ident);
Expression *e = copy();
((BinExp *)e)->e2 = e2;
e = e->trySemantic(sc);
return e;
}
#endif
return NULL;
}
/******************************************
* Common code for overloading of EqualExp and CmpExp
*/
Expression *BinExp::compare_overload(Scope *sc, Identifier *id)
{
//printf("BinExp::compare_overload(id = %s) %s\n", id->toChars(), toChars());
AggregateDeclaration *ad1 = isAggregate(e1->type);
AggregateDeclaration *ad2 = isAggregate(e2->type);
Dsymbol *s = NULL;
Dsymbol *s_r = NULL;
if (ad1)
{
s = search_function(ad1, id);
}
if (ad2)
{
s_r = search_function(ad2, id);
if (s == s_r)
s_r = NULL;
}
Objects *targsi = NULL;
if (s || s_r)
{
/* Try:
* a.opEquals(b)
* b.opEquals(a)
* and see which is better.
*/
Expressions args1;
Expressions args2;
args1.setDim(1);
args1.tdata()[0] = e1;
args2.setDim(1);
args2.tdata()[0] = e2;
Match m;
memset(&m, 0, sizeof(m));
m.last = MATCHnomatch;
if (0 && s && s_r)
{
printf("s : %s\n", s->toPrettyChars());
printf("s_r: %s\n", s_r->toPrettyChars());
}
if (s)
{
FuncDeclaration *fd = s->isFuncDeclaration();
if (fd)
{
overloadResolveX(&m, fd, NULL, &args2, sc->module);
}
else
{ TemplateDeclaration *td = s->isTemplateDeclaration();
templateResolve(&m, td, sc, loc, targsi, NULL, &args2);
}
}
FuncDeclaration *lastf = m.lastf;
int count = m.count;
if (s_r)
{
FuncDeclaration *fd = s_r->isFuncDeclaration();
if (fd)
{
overloadResolveX(&m, fd, NULL, &args1, sc->module);
}
else
{ TemplateDeclaration *td = s_r->isTemplateDeclaration();
templateResolve(&m, td, sc, loc, targsi, NULL, &args1);
}
}
if (m.count > 1)
{
/* The following if says "not ambiguous" if there's one match
* from s and one from s_r, in which case we pick s.
* This doesn't follow the spec, but is a workaround for the case
* where opEquals was generated from templates and we cannot figure
* out if both s and s_r came from the same declaration or not.
* The test case is:
* import std.typecons;
* void main() {
* assert(tuple("has a", 2u) == tuple("has a", 1));
* }
*/
if (!(m.lastf == lastf && m.count == 2 && count == 1))
{
// Error, ambiguous
error("overloads %s and %s both match argument list for %s",
m.lastf->type->toChars(),
m.nextf->type->toChars(),
m.lastf->toChars());
}
}
else if (m.last == MATCHnomatch)
{
m.lastf = m.anyf;
}
Expression *e;
if (lastf && m.lastf == lastf || !s_r && m.last == MATCHnomatch)
// Rewrite (e1 op e2) as e1.opfunc(e2)
e = build_overload(loc, sc, e1, e2, m.lastf ? m.lastf : s);
else
{ // Rewrite (e1 op e2) as e2.opfunc_r(e1)
e = build_overload(loc, sc, e2, e1, m.lastf ? m.lastf : s_r);
// When reversing operands of comparison operators,
// need to reverse the sense of the op
switch (op)
{
case TOKlt: op = TOKgt; break;
case TOKgt: op = TOKlt; break;
case TOKle: op = TOKge; break;
case TOKge: op = TOKle; break;
// Floating point compares
case TOKule: op = TOKuge; break;
case TOKul: op = TOKug; break;
case TOKuge: op = TOKule; break;
case TOKug: op = TOKul; break;
// The rest are symmetric
default:
break;
}
}
return e;
}
// Try alias this on first operand
if (ad1 && ad1->aliasthis)
{
/* Rewrite (e1 op e2) as:
* (e1.aliasthis op e2)
*/
Expression *e1 = new DotIdExp(loc, this->e1, ad1->aliasthis->ident);
Expression *e = copy();
((BinExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
// Try alias this on second operand
if (ad2 && ad2->aliasthis)
{
/* Rewrite (e1 op e2) as:
* (e1 op e2.aliasthis)
*/
Expression *e2 = new DotIdExp(loc, this->e2, ad2->aliasthis->ident);
Expression *e = copy();
((BinExp *)e)->e2 = e2;
e = e->trySemantic(sc);
return e;
}
return NULL;
}
Expression *BinExp::op_overload(Scope *sc)
{
//printf("BinExp::op_overload() (%s)\n", toChars());
Identifier *id = opId();
Identifier *id_r = opId_r();
Expressions args1;
Expressions args2;
int argsset = 0;
AggregateDeclaration *ad1 = isAggregate(e1->type);
AggregateDeclaration *ad2 = isAggregate(e2->type);
Dsymbol *s = NULL;
Dsymbol *s_r = NULL;
#if 1 // the old D1 scheme
if (ad1 && id)
{
s = search_function(ad1, id);
}
if (ad2 && id_r)
{
s_r = search_function(ad2, id_r);
}
#endif
Objects *targsi = NULL;
#if DMDV2
if (op == TOKplusplus || op == TOKminusminus)
{ // Bug4099 fix
if (ad1 && search_function(ad1, Id::opUnary))
return NULL;
}
if (!s && !s_r && op != TOKequal && op != TOKnotequal && op != TOKassign &&
op != TOKplusplus && op != TOKminusminus)
{
/* Try the new D2 scheme, opBinary and opBinaryRight
*/
if (ad1)
s = search_function(ad1, Id::opBinary);
if (ad2)
s_r = search_function(ad2, Id::opBinaryRight);
// Set targsi, the template argument list, which will be the operator string
if (s || s_r)
{
id = Id::opBinary;
id_r = Id::opBinaryRight;
targsi = opToArg(sc, op);
}
}
#endif
if (s || s_r)
{
/* Try:
* a.opfunc(b)
* b.opfunc_r(a)
* and see which is better.
*/
args1.setDim(1);
args1.tdata()[0] = e1;
args2.setDim(1);
args2.tdata()[0] = e2;
argsset = 1;
Match m;
memset(&m, 0, sizeof(m));
m.last = MATCHnomatch;
if (s)
{
FuncDeclaration *fd = s->isFuncDeclaration();
if (fd)
{
overloadResolveX(&m, fd, NULL, &args2, sc->module);
}
else
{ TemplateDeclaration *td = s->isTemplateDeclaration();
templateResolve(&m, td, sc, loc, targsi, e1, &args2);
}
}
FuncDeclaration *lastf = m.lastf;
if (s_r)
{
FuncDeclaration *fd = s_r->isFuncDeclaration();
if (fd)
{
overloadResolveX(&m, fd, NULL, &args1, sc->module);
}
else
{ TemplateDeclaration *td = s_r->isTemplateDeclaration();
templateResolve(&m, td, sc, loc, targsi, e2, &args1);
}
}
if (m.count > 1)
{
// Error, ambiguous
error("overloads %s and %s both match argument list for %s",
m.lastf->type->toChars(),
m.nextf->type->toChars(),
m.lastf->toChars());
}
else if (m.last == MATCHnomatch)
{
m.lastf = m.anyf;
if (targsi)
goto L1;
}
Expression *e;
if (op == TOKplusplus || op == TOKminusminus)
// Kludge because operator overloading regards e++ and e--
// as unary, but it's implemented as a binary.
// Rewrite (e1 ++ e2) as e1.postinc()
// Rewrite (e1 -- e2) as e1.postdec()
e = build_overload(loc, sc, e1, NULL, m.lastf ? m.lastf : s);
else if (lastf && m.lastf == lastf || !s_r && m.last == MATCHnomatch)
// Rewrite (e1 op e2) as e1.opfunc(e2)
e = build_overload(loc, sc, e1, e2, m.lastf ? m.lastf : s);
else
// Rewrite (e1 op e2) as e2.opfunc_r(e1)
e = build_overload(loc, sc, e2, e1, m.lastf ? m.lastf : s_r);
return e;
}
L1:
#if 1 // Retained for D1 compatibility
if (isCommutative() && !targsi)
{
s = NULL;
s_r = NULL;
if (ad1 && id_r)
{
s_r = search_function(ad1, id_r);
}
if (ad2 && id)
{
s = search_function(ad2, id);
}
if (s || s_r)
{
/* Try:
* a.opfunc_r(b)
* b.opfunc(a)
* and see which is better.
*/
if (!argsset)
{ args1.setDim(1);
args1.tdata()[0] = e1;
args2.setDim(1);
args2.tdata()[0] = e2;
}
Match m;
memset(&m, 0, sizeof(m));
m.last = MATCHnomatch;
if (s_r)
{
FuncDeclaration *fd = s_r->isFuncDeclaration();
if (fd)
{
overloadResolveX(&m, fd, NULL, &args2, sc->module);
}
else
{ TemplateDeclaration *td = s_r->isTemplateDeclaration();
templateResolve(&m, td, sc, loc, targsi, e1, &args2);
}
}
FuncDeclaration *lastf = m.lastf;
if (s)
{
FuncDeclaration *fd = s->isFuncDeclaration();
if (fd)
{
overloadResolveX(&m, fd, NULL, &args1, sc->module);
}
else
{ TemplateDeclaration *td = s->isTemplateDeclaration();
templateResolve(&m, td, sc, loc, targsi, e2, &args1);
}
}
if (m.count > 1)
{
// Error, ambiguous
error("overloads %s and %s both match argument list for %s",
m.lastf->type->toChars(),
m.nextf->type->toChars(),
m.lastf->toChars());
}
else if (m.last == MATCHnomatch)
{
m.lastf = m.anyf;
}
Expression *e;
if (lastf && m.lastf == lastf || !s && m.last == MATCHnomatch)
// Rewrite (e1 op e2) as e1.opfunc_r(e2)
e = build_overload(loc, sc, e1, e2, m.lastf ? m.lastf : s_r);
else
// Rewrite (e1 op e2) as e2.opfunc(e1)
e = build_overload(loc, sc, e2, e1, m.lastf ? m.lastf : s);
// When reversing operands of comparison operators,
// need to reverse the sense of the op
switch (op)
{
case TOKlt: op = TOKgt; break;
case TOKgt: op = TOKlt; break;
case TOKle: op = TOKge; break;
case TOKge: op = TOKle; break;
// Floating point compares
case TOKule: op = TOKuge; break;
case TOKul: op = TOKug; break;
case TOKuge: op = TOKule; break;
case TOKug: op = TOKul; break;
// These are symmetric
case TOKunord:
case TOKlg:
case TOKleg:
case TOKue:
break;
}
return e;
}
}
#endif
#if DMDV2
// Try alias this on first operand
if (ad1 && ad1->aliasthis &&
!(op == TOKassign && ad2 && ad1 == ad2)) // See Bugzilla 2943
{
/* Rewrite (e1 op e2) as:
* (e1.aliasthis op e2)
*/
Expression *e1 = new DotIdExp(loc, this->e1, ad1->aliasthis->ident);
Expression *e = copy();
((BinExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
// Try alias this on second operand
if (ad2 && ad2->aliasthis &&
/* Bugzilla 2943: make sure that when we're copying the struct, we don't
* just copy the alias this member
*/
!(op == TOKassign && ad1 && ad1 == ad2))
{
/* Rewrite (e1 op e2) as:
* (e1 op e2.aliasthis)
*/
Expression *e2 = new DotIdExp(loc, this->e2, ad2->aliasthis->ident);
Expression *e = copy();
((BinExp *)e)->e2 = e2;
e = e->trySemantic(sc);
return e;
}
#endif
return NULL;
}
Expression *UnaExp::op_overload(Scope *sc)
{
//printf("UnaExp::op_overload() (%s)\n", toChars());
#if DMDV2
if (e1->op == TOKarray)
{
ArrayExp *ae = (ArrayExp *)e1;
ae->e1 = ae->e1->semantic(sc);
ae->e1 = resolveProperties(sc, ae->e1);
AggregateDeclaration *ad = isAggregate(ae->e1->type);
if (ad)
{
/* Rewrite as:
* a.opIndexUnary!("+")(args);
*/
Dsymbol *fd = search_function(ad, Id::opIndexUnary);
if (fd)
{
Objects *targsi = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, ae->e1, fd->ident, targsi);
e = new CallExp(loc, e, ae->arguments);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis)
{
/* Rewrite op(a[arguments]) as:
* op(a.aliasthis[arguments])
*/
Expression *e1 = ae->copy();
((ArrayExp *)e1)->e1 = new DotIdExp(loc, ae->e1, ad->aliasthis->ident);
Expression *e = copy();
((UnaExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
}
}
else if (e1->op == TOKslice)
{
SliceExp *se = (SliceExp *)e1;
se->e1 = se->e1->semantic(sc);
se->e1 = resolveProperties(sc, se->e1);
AggregateDeclaration *ad = isAggregate(se->e1->type);
if (ad)
{
/* Rewrite as:
* a.opSliceUnary!("+")(lwr, upr);
*/
Dsymbol *fd = search_function(ad, Id::opSliceUnary);
if (fd)
{
Expressions *a = new Expressions();
if (se->lwr)
{ a->push(se->lwr);
a->push(se->upr);
}
Objects *targsi = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, se->e1, fd->ident, targsi);
e = new CallExp(loc, e, a);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis)
{
/* Rewrite op(a[lwr..upr]) as:
* op(a.aliasthis[lwr..upr])
*/
Expression *e1 = se->copy();
((SliceExp *)e1)->e1 = new DotIdExp(loc, se->e1, ad->aliasthis->ident);
Expression *e = copy();
((UnaExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
}
}
#endif
e1 = e1->semantic(sc);
e1 = resolveProperties(sc, e1);
AggregateDeclaration *ad = isAggregate(e1->type);
if (ad)
{
Dsymbol *fd = NULL;
#if 1 // Old way, kept for compatibility with D1
if (op != TOKpreplusplus && op != TOKpreminusminus)
{ fd = search_function(ad, opId());
if (fd)
{
if (op == TOKarray)
{
/* Rewrite op e1[arguments] as:
* e1.fd(arguments)
*/
Expression *e = new DotIdExp(loc, e1, fd->ident);
ArrayExp *ae = (ArrayExp *)this;
e = new CallExp(loc, e, ae->arguments);
e = e->semantic(sc);
return e;
}
else
{
// Rewrite +e1 as e1.add()
return build_overload(loc, sc, e1, NULL, fd);
}
}
}
#endif
#if DMDV2
/* Rewrite as:
* e1.opUnary!("+")();
*/
fd = search_function(ad, Id::opUnary);
if (fd)
{
Objects *targsi = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, e1, fd->ident, targsi);
e = new CallExp(loc, e);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis)
{
/* Rewrite op(e1) as:
* op(e1.aliasthis)
*/
Expression *e1 = new DotIdExp(loc, this->e1, ad->aliasthis->ident);
Expression *e = copy();
((UnaExp *)e)->e1 = e1;
e = e->trySemantic(sc);
return e;
}
#endif
}
return NULL;
}
Dsymbol *ArrayScopeSymbol::search(Loc loc, Identifier *ident, int flags)
{
//printf("ArrayScopeSymbol::search('%s', flags = %d)\n", ident->toChars(), flags);
if (ident == Id::dollar)
{
VarDeclaration **pvar;
Expression *ce;
L1:
if (td)
{
/* $ gives the number of elements in the tuple
*/
VarDeclaration *v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, NULL);
Expression *e = new IntegerExp(Loc(), td->objects->dim, Type::tsize_t);
v->init = new ExpInitializer(Loc(), e);
v->storage_class |= STCtemp | STCstatic | STCconst;
v->semantic(sc);
return v;
}
if (type)
{
/* $ gives the number of type entries in the type tuple
*/
VarDeclaration *v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, NULL);
Expression *e = new IntegerExp(Loc(), type->arguments->dim, Type::tsize_t);
v->init = new ExpInitializer(Loc(), e);
v->storage_class |= STCtemp | STCstatic | STCconst;
v->semantic(sc);
return v;
}
if (exp->op == TOKindex)
{
/* array[index] where index is some function of $
*/
IndexExp *ie = (IndexExp *)exp;
pvar = &ie->lengthVar;
ce = ie->e1;
}
else if (exp->op == TOKslice)
{
/* array[lwr .. upr] where lwr or upr is some function of $
*/
SliceExp *se = (SliceExp *)exp;
pvar = &se->lengthVar;
ce = se->e1;
}
else if (exp->op == TOKarray)
{
/* array[e0, e1, e2, e3] where e0, e1, e2 are some function of $
* $ is a opDollar!(dim)() where dim is the dimension(0,1,2,...)
*/
ArrayExp *ae = (ArrayExp *)exp;
pvar = &ae->lengthVar;
ce = ae->e1;
}
else
{
/* Didn't find $, look in enclosing scope(s).
*/
return NULL;
}
while (ce->op == TOKcomma)
ce = ((CommaExp *)ce)->e2;
/* If we are indexing into an array that is really a type
* tuple, rewrite this as an index into a type tuple and
* try again.
*/
if (ce->op == TOKtype)
{
Type *t = ((TypeExp *)ce)->type;
if (t->ty == Ttuple)
{
type = (TypeTuple *)t;
goto L1;
}
}
/* *pvar is lazily initialized, so if we refer to $
* multiple times, it gets set only once.
*/
if (!*pvar) // if not already initialized
{
/* Create variable v and set it to the value of $
*/
VarDeclaration *v;
Type *t;
if (ce->op == TOKtuple)
{
/* It is for an expression tuple, so the
* length will be a const.
*/
Expression *e = new IntegerExp(Loc(), ((TupleExp *)ce)->exps->dim, Type::tsize_t);
v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, new ExpInitializer(Loc(), e));
v->storage_class |= STCtemp | STCstatic | STCconst;
}
else if (ce->type && (t = ce->type->toBasetype()) != NULL &&
(t->ty == Tstruct || t->ty == Tclass))
{
// Look for opDollar
assert(exp->op == TOKarray || exp->op == TOKslice);
AggregateDeclaration *ad = isAggregate(t);
assert(ad);
Dsymbol *s = ad->search(loc, Id::opDollar);
if (!s) // no dollar exists -- search in higher scope
return NULL;
s = s->toAlias();
Expression *e = NULL;
// Check for multi-dimensional opDollar(dim) template.
if (TemplateDeclaration *td = s->isTemplateDeclaration())
{
dinteger_t dim = 0;
if (exp->op == TOKarray)
{
dim = ((ArrayExp *)exp)->currentDimension;
}
else if (exp->op == TOKslice)
{
dim = 0; // slices are currently always one-dimensional
}
else
{
assert(0);
}
Objects *tiargs = new Objects();
Expression *edim = new IntegerExp(Loc(), dim, Type::tsize_t);
edim = edim->semantic(sc);
tiargs->push(edim);
e = new DotTemplateInstanceExp(loc, ce, td->ident, tiargs);
}
else
{
/* opDollar exists, but it's not a template.
* This is acceptable ONLY for single-dimension indexing.
* Note that it's impossible to have both template & function opDollar,
* because both take no arguments.
*/
if (exp->op == TOKarray && ((ArrayExp *)exp)->arguments->dim != 1)
{
exp->error("%s only defines opDollar for one dimension", ad->toChars());
return NULL;
}
Declaration *d = s->isDeclaration();
assert(d);
e = new DotVarExp(loc, ce, d);
}
e = e->semantic(sc);
if (!e->type)
exp->error("%s has no value", e->toChars());
t = e->type->toBasetype();
if (t && t->ty == Tfunction)
e = new CallExp(e->loc, e);
v = new VarDeclaration(loc, NULL, Id::dollar, new ExpInitializer(Loc(), e));
v->storage_class |= STCtemp | STCctfe;
}
else
{
/* For arrays, $ will either be a compile-time constant
* (in which case its value in set during constant-folding),
* or a variable (in which case an expression is created in
* toir.c).
*/
VoidInitializer *e = new VoidInitializer(Loc());
e->type = Type::tsize_t;
v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, e);
v->storage_class |= STCtemp | STCctfe; // it's never a true static variable
}
*pvar = v;
}
(*pvar)->semantic(sc);
return (*pvar);
}
return NULL;
}
/*********************************
* Operator overloading for op=
*/
Expression *BinAssignExp::op_overload(Scope *sc)
{
//printf("BinAssignExp::op_overload() (%s)\n", toChars());
#if DMDV2
if (e1->op == TOKarray)
{
ArrayExp *ae = (ArrayExp *)e1;
ae->e1 = ae->e1->semantic(sc);
ae->e1 = resolveProperties(sc, ae->e1);
AggregateDeclaration *ad = isAggregate(ae->e1->type);
if (ad)
{
/* Rewrite a[args]+=e2 as:
* a.opIndexOpAssign!("+")(e2, args);
*/
Dsymbol *fd = search_function(ad, Id::opIndexOpAssign);
if (fd)
{
ae = resolveOpDollar(sc, ae);
Expressions *a = (Expressions *)ae->arguments->copy();
a->insert(0, e2);
Objects *tiargs = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, ae->e1, fd->ident, tiargs);
e = new CallExp(loc, e, a);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis && ae->e1->type != att1)
{
/* Rewrite a[arguments] op= e2 as:
* a.aliasthis[arguments] op= e2
*/
Expression *e1 = ae->copy();
((ArrayExp *)e1)->e1 = new DotIdExp(loc, ae->e1, ad->aliasthis->ident);
BinExp *be = (BinExp *)copy();
if (!be->att1 && ae->e1->type->checkAliasThisRec())
be->att1 = ae->e1->type;
be->e1 = e1;
if (Expression *e = be->trySemantic(sc))
return e;
}
att1 = NULL;
}
}
else if (e1->op == TOKslice)
{
SliceExp *se = (SliceExp *)e1;
se->e1 = se->e1->semantic(sc);
se->e1 = resolveProperties(sc, se->e1);
AggregateDeclaration *ad = isAggregate(se->e1->type);
if (ad)
{
/* Rewrite a[lwr..upr]+=e2 as:
* a.opSliceOpAssign!("+")(e2, lwr, upr);
*/
Dsymbol *fd = search_function(ad, Id::opSliceOpAssign);
if (fd)
{
se = resolveOpDollar(sc, se);
Expressions *a = new Expressions();
a->push(e2);
assert(!se->lwr || se->upr);
if (se->lwr)
{ a->push(se->lwr);
a->push(se->upr);
}
Objects *tiargs = opToArg(sc, op);
Expression *e = new DotTemplateInstanceExp(loc, se->e1, fd->ident, tiargs);
e = new CallExp(loc, e, a);
e = e->semantic(sc);
return e;
}
// Didn't find it. Forward to aliasthis
if (ad->aliasthis && se->e1->type != att1)
{
/* Rewrite a[lwr..upr] op= e2 as:
* a.aliasthis[lwr..upr] op= e2
*/
Expression *e1 = se->copy();
((SliceExp *)e1)->e1 = new DotIdExp(loc, se->e1, ad->aliasthis->ident);
BinExp *be = (BinExp *)copy();
if (!be->att1 && se->e1->type->checkAliasThisRec())
be->att1 = se->e1->type;
be->e1 = e1;
if (Expression *e = be->trySemantic(sc))
return e;
}
att1 = NULL;
}
}
#endif
BinExp::semantic(sc);
e1 = resolveProperties(sc, e1);
e2 = resolveProperties(sc, e2);
// Don't attempt 'alias this' if an error occured
if (e1->type->ty == Terror || e2->type->ty == Terror)
return new ErrorExp();
Identifier *id = opId();
Expressions args2;
AggregateDeclaration *ad1 = isAggregate(e1->type);
Dsymbol *s = NULL;
#if 1 // the old D1 scheme
if (ad1 && id)
{
s = search_function(ad1, id);
}
#endif
Objects *tiargs = NULL;
#if DMDV2
if (!s)
{ /* Try the new D2 scheme, opOpAssign
*/
if (ad1)
{
s = search_function(ad1, Id::opOpAssign);
if (s && !s->isTemplateDeclaration())
{ error("%s.opOpAssign isn't a template", e1->toChars());
return new ErrorExp();
}
}
// Set tiargs, the template argument list, which will be the operator string
if (s)
{
id = Id::opOpAssign;
tiargs = opToArg(sc, op);
}
}
#endif
if (s)
{
/* Try:
* a.opOpAssign(b)
*/
args2.setDim(1);
args2[0] = e2;
Match m;
memset(&m, 0, sizeof(m));
m.last = MATCHnomatch;
if (s)
{
FuncDeclaration *fd = s->isFuncDeclaration();
if (fd)
{
overloadResolveX(&m, fd, NULL, &args2);
}
else
{ TemplateDeclaration *td = s->isTemplateDeclaration();
templateResolve(&m, td, loc, sc, tiargs, e1, &args2);
}
}
if (m.count > 1)
{
// Error, ambiguous
error("overloads %s and %s both match argument list for %s",
m.lastf->type->toChars(),
m.nextf->type->toChars(),
m.lastf->toChars());
}
else if (m.last == MATCHnomatch)
{
m.lastf = m.anyf;
if (tiargs)
goto L1;
}
// Rewrite (e1 op e2) as e1.opOpAssign(e2)
return build_overload(loc, sc, e1, e2, m.lastf ? m.lastf : s);
}
L1:
#if DMDV2
// Try alias this on first operand
if (ad1 && ad1->aliasthis)
{
/* Rewrite (e1 op e2) as:
* (e1.aliasthis op e2)
*/
if (att1 && this->e1->type == att1)
return NULL;
//printf("att %s e1 = %s\n", Token::toChars(op), this->e1->type->toChars());
Expression *e1 = new DotIdExp(loc, this->e1, ad1->aliasthis->ident);
BinExp *be = (BinExp *)copy();
if (!be->att1 && this->e1->type->checkAliasThisRec())
be->att1 = this->e1->type;
be->e1 = e1;
return be->trySemantic(sc);
}
// Try alias this on second operand
AggregateDeclaration *ad2 = isAggregate(e2->type);
if (ad2 && ad2->aliasthis)
{
/* Rewrite (e1 op e2) as:
* (e1 op e2.aliasthis)
*/
if (att2 && this->e2->type == att2)
return NULL;
//printf("att %s e2 = %s\n", Token::toChars(op), this->e2->type->toChars());
Expression *e2 = new DotIdExp(loc, this->e2, ad2->aliasthis->ident);
BinExp *be = (BinExp *)copy();
if (!be->att2 && this->e2->type->checkAliasThisRec())
be->att2 = this->e2->type;
be->e2 = e2;
return be->trySemantic(sc);
}
#endif
return NULL;
}
virtual bool aggregate(const ObjectID& id) { return isAggregate(id); }
