| |
| /* Compiler implementation of the D programming language |
| * Copyright (C) 1999-2021 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/template.c |
| */ |
| |
| // Handle template implementation |
| |
| #include "root/dsystem.h" |
| #include "root/root.h" |
| #include "root/aav.h" |
| #include "root/rmem.h" |
| #include "root/stringtable.h" |
| #include "root/hash.h" |
| |
| #include "mangle.h" |
| #include "mtype.h" |
| #include "template.h" |
| #include "init.h" |
| #include "expression.h" |
| #include "scope.h" |
| #include "module.h" |
| #include "aggregate.h" |
| #include "declaration.h" |
| #include "dsymbol.h" |
| #include "mars.h" |
| #include "dsymbol.h" |
| #include "identifier.h" |
| #include "hdrgen.h" |
| #include "id.h" |
| #include "attrib.h" |
| #include "cond.h" |
| #include "tokens.h" |
| |
| #define IDX_NOTFOUND (0x12345678) // index is not found |
| |
| Type *rawTypeMerge(Type *t1, Type *t2); |
| bool MODimplicitConv(MOD modfrom, MOD modto); |
| MATCH MODmethodConv(MOD modfrom, MOD modto); |
| MOD MODmerge(MOD mod1, MOD mod2); |
| |
| static size_t templateParameterLookup(Type *tparam, TemplateParameters *parameters); |
| static int arrayObjectMatch(Objects *oa1, Objects *oa2); |
| static unsigned char deduceWildHelper(Type *t, Type **at, Type *tparam); |
| static MATCH deduceTypeHelper(Type *t, Type **at, Type *tparam); |
| bool reliesOnTident(Type *t, TemplateParameters *tparams = NULL, size_t iStart = 0); |
| bool evalStaticCondition(Scope *sc, Expression *exp, Expression *e, bool &errors); |
| |
| /******************************************** |
| * These functions substitute for dynamic_cast. dynamic_cast does not work |
| * on earlier versions of gcc. |
| */ |
| |
| Expression *isExpression(RootObject *o) |
| { |
| //return dynamic_cast<Expression *>(o); |
| if (!o || o->dyncast() != DYNCAST_EXPRESSION) |
| return NULL; |
| return (Expression *)o; |
| } |
| |
| Dsymbol *isDsymbol(RootObject *o) |
| { |
| //return dynamic_cast<Dsymbol *>(o); |
| if (!o || o->dyncast() != DYNCAST_DSYMBOL) |
| return NULL; |
| return (Dsymbol *)o; |
| } |
| |
| Type *isType(RootObject *o) |
| { |
| //return dynamic_cast<Type *>(o); |
| if (!o || o->dyncast() != DYNCAST_TYPE) |
| return NULL; |
| return (Type *)o; |
| } |
| |
| Tuple *isTuple(RootObject *o) |
| { |
| //return dynamic_cast<Tuple *>(o); |
| if (!o || o->dyncast() != DYNCAST_TUPLE) |
| return NULL; |
| return (Tuple *)o; |
| } |
| |
| Parameter *isParameter(RootObject *o) |
| { |
| //return dynamic_cast<Parameter *>(o); |
| if (!o || o->dyncast() != DYNCAST_PARAMETER) |
| return NULL; |
| return (Parameter *)o; |
| } |
| |
| /************************************** |
| * Is this Object an error? |
| */ |
| bool isError(RootObject *o) |
| { |
| Type *t = isType(o); |
| if (t) |
| return (t->ty == Terror); |
| Expression *e = isExpression(o); |
| if (e) |
| return (e->op == TOKerror || !e->type || e->type->ty == Terror); |
| Tuple *v = isTuple(o); |
| if (v) |
| return arrayObjectIsError(&v->objects); |
| Dsymbol *s = isDsymbol(o); |
| assert(s); |
| if (s->errors) |
| return true; |
| return s->parent ? isError(s->parent) : false; |
| } |
| |
| /************************************** |
| * Are any of the Objects an error? |
| */ |
| bool arrayObjectIsError(Objects *args) |
| { |
| for (size_t i = 0; i < args->length; i++) |
| { |
| RootObject *o = (*args)[i]; |
| if (isError(o)) |
| return true; |
| } |
| return false; |
| } |
| |
| /*********************** |
| * Try to get arg as a type. |
| */ |
| |
| Type *getType(RootObject *o) |
| { |
| Type *t = isType(o); |
| if (!t) |
| { |
| Expression *e = isExpression(o); |
| if (e) |
| t = e->type; |
| } |
| return t; |
| } |
| |
| Dsymbol *getDsymbol(RootObject *oarg) |
| { |
| //printf("getDsymbol()\n"); |
| //printf("e %p s %p t %p v %p\n", isExpression(oarg), isDsymbol(oarg), isType(oarg), isTuple(oarg)); |
| |
| Dsymbol *sa; |
| Expression *ea = isExpression(oarg); |
| if (ea) |
| { |
| // Try to convert Expression to symbol |
| if (VarExp *ve = ea->isVarExp()) |
| sa = ve->var; |
| else if (FuncExp *fe = ea->isFuncExp()) |
| sa = fe->td ? (Dsymbol *)fe->td : (Dsymbol *)fe->fd; |
| else if (TemplateExp *te = ea->isTemplateExp()) |
| sa = te->td; |
| else if (ScopeExp *se = ea->isScopeExp()) |
| sa = se->sds; |
| else |
| sa = NULL; |
| } |
| else |
| { |
| // Try to convert Type to symbol |
| Type *ta = isType(oarg); |
| if (ta) |
| sa = ta->toDsymbol(NULL); |
| else |
| sa = isDsymbol(oarg); // if already a symbol |
| } |
| return sa; |
| } |
| |
| /*********************** |
| * Try to get value from manifest constant |
| */ |
| |
| static Expression *getValue(Expression *e) |
| { |
| if (e && e->op == TOKvar) |
| { |
| VarDeclaration *v = ((VarExp *)e)->var->isVarDeclaration(); |
| if (v && v->storage_class & STCmanifest) |
| { |
| e = v->getConstInitializer(); |
| } |
| } |
| return e; |
| } |
| |
| static Expression *getValue(Dsymbol *&s) |
| { |
| Expression *e = NULL; |
| if (s) |
| { |
| VarDeclaration *v = s->isVarDeclaration(); |
| if (v && v->storage_class & STCmanifest) |
| { |
| e = v->getConstInitializer(); |
| } |
| } |
| return e; |
| } |
| |
| /********************************** |
| * Return true if e could be valid only as a template value parameter. |
| * Return false if it might be an alias or tuple. |
| * (Note that even in this case, it could still turn out to be a value). |
| */ |
| bool definitelyValueParameter(Expression *e) |
| { |
| // None of these can be value parameters |
| if (e->op == TOKtuple || e->op == TOKscope || |
| e->op == TOKtype || e->op == TOKdottype || |
| e->op == TOKtemplate || e->op == TOKdottd || |
| e->op == TOKfunction || e->op == TOKerror || |
| e->op == TOKthis || e->op == TOKsuper || |
| e->op == TOKdot) |
| return false; |
| |
| if (e->op != TOKdotvar) |
| return true; |
| |
| /* Template instantiations involving a DotVar expression are difficult. |
| * In most cases, they should be treated as a value parameter, and interpreted. |
| * But they might also just be a fully qualified name, which should be treated |
| * as an alias. |
| */ |
| |
| // x.y.f cannot be a value |
| FuncDeclaration *f = ((DotVarExp *)e)->var->isFuncDeclaration(); |
| if (f) |
| return false; |
| |
| while (e->op == TOKdotvar) |
| { |
| e = ((DotVarExp *)e)->e1; |
| } |
| // this.x.y and super.x.y couldn't possibly be valid values. |
| if (e->op == TOKthis || e->op == TOKsuper) |
| return false; |
| |
| // e.type.x could be an alias |
| if (e->op == TOKdottype) |
| return false; |
| |
| // var.x.y is the only other possible form of alias |
| if (e->op != TOKvar) |
| return true; |
| |
| VarDeclaration *v = ((VarExp *)e)->var->isVarDeclaration(); |
| |
| // func.x.y is not an alias |
| if (!v) |
| return true; |
| |
| // TODO: Should we force CTFE if it is a global constant? |
| |
| return false; |
| } |
| |
| static Expression *getExpression(RootObject *o) |
| { |
| Dsymbol *s = isDsymbol(o); |
| return s ? getValue(s) : getValue(isExpression(o)); |
| } |
| |
| /****************************** |
| * If o1 matches o2, return true. |
| * Else, return false. |
| */ |
| |
| static bool match(RootObject *o1, RootObject *o2) |
| { |
| //printf("match() o1 = %p %s (%d), o2 = %p %s (%d)\n", |
| // o1, o1->toChars(), o1->dyncast(), o2, o2->toChars(), o2->dyncast()); |
| |
| /* A proper implementation of the various equals() overrides |
| * should make it possible to just do o1->equals(o2), but |
| * we'll do that another day. |
| */ |
| |
| /* Manifest constants should be compared by their values, |
| * at least in template arguments. |
| */ |
| |
| if (Type *t1 = isType(o1)) |
| { |
| Type *t2 = isType(o2); |
| if (!t2) |
| goto Lnomatch; |
| |
| //printf("\tt1 = %s\n", t1->toChars()); |
| //printf("\tt2 = %s\n", t2->toChars()); |
| if (!t1->equals(t2)) |
| goto Lnomatch; |
| |
| goto Lmatch; |
| } |
| if (Expression *e1 = getExpression(o1)) |
| { |
| Expression *e2 = getExpression(o2); |
| if (!e2) |
| goto Lnomatch; |
| |
| //printf("\te1 = %s %s %s\n", e1->type->toChars(), Token::toChars(e1->op), e1->toChars()); |
| //printf("\te2 = %s %s %s\n", e2->type->toChars(), Token::toChars(e2->op), e2->toChars()); |
| |
| // two expressions can be equal although they do not have the same |
| // type; that happens when they have the same value. So check type |
| // as well as expression equality to ensure templates are properly |
| // matched. |
| if (!e1->type->equals(e2->type) || !e1->equals(e2)) |
| goto Lnomatch; |
| |
| goto Lmatch; |
| } |
| if (Dsymbol *s1 = isDsymbol(o1)) |
| { |
| Dsymbol *s2 = isDsymbol(o2); |
| if (!s2) |
| goto Lnomatch; |
| |
| //printf("\ts1 = %s\n", s1->toChars()); |
| //printf("\ts2 = %s\n", s2->toChars()); |
| if (!s1->equals(s2)) |
| goto Lnomatch; |
| if (s1->parent != s2->parent && !s1->isFuncDeclaration() && !s2->isFuncDeclaration()) |
| goto Lnomatch; |
| |
| goto Lmatch; |
| } |
| if (Tuple *u1 = isTuple(o1)) |
| { |
| Tuple *u2 = isTuple(o2); |
| if (!u2) |
| goto Lnomatch; |
| |
| //printf("\tu1 = %s\n", u1->toChars()); |
| //printf("\tu2 = %s\n", u2->toChars()); |
| if (!arrayObjectMatch(&u1->objects, &u2->objects)) |
| goto Lnomatch; |
| |
| goto Lmatch; |
| } |
| Lmatch: |
| //printf("\t-> match\n"); |
| return true; |
| |
| Lnomatch: |
| //printf("\t-> nomatch\n"); |
| return false; |
| } |
| |
| |
| /************************************ |
| * Match an array of them. |
| */ |
| int arrayObjectMatch(Objects *oa1, Objects *oa2) |
| { |
| if (oa1 == oa2) |
| return 1; |
| if (oa1->length != oa2->length) |
| return 0; |
| for (size_t j = 0; j < oa1->length; j++) |
| { |
| RootObject *o1 = (*oa1)[j]; |
| RootObject *o2 = (*oa2)[j]; |
| if (!match(o1, o2)) |
| { |
| return 0; |
| } |
| } |
| return 1; |
| } |
| |
| |
| /************************************ |
| * Computes hash of expression. |
| * Handles all Expression classes and MUST match their equals method, |
| * i.e. e1->equals(e2) implies expressionHash(e1) == expressionHash(e2). |
| */ |
| static hash_t expressionHash(Expression *e) |
| { |
| switch (e->op) |
| { |
| case TOKint64: |
| return (size_t) ((IntegerExp *)e)->getInteger(); |
| |
| case TOKfloat64: |
| return CTFloat::hash(((RealExp *)e)->value); |
| |
| case TOKcomplex80: |
| { |
| ComplexExp *ce = (ComplexExp *)e; |
| return mixHash(CTFloat::hash(ce->toReal()), CTFloat::hash(ce->toImaginary())); |
| } |
| |
| case TOKidentifier: |
| return (size_t)(void *) ((IdentifierExp *)e)->ident; |
| |
| case TOKnull: |
| return (size_t)(void *) ((NullExp *)e)->type; |
| |
| case TOKstring: |
| { |
| StringExp *se = (StringExp *)e; |
| return calcHash((const char *)se->string, se->len * se->sz); |
| } |
| |
| case TOKtuple: |
| { |
| TupleExp *te = (TupleExp *)e; |
| size_t hash = 0; |
| hash += te->e0 ? expressionHash(te->e0) : 0; |
| for (size_t i = 0; i < te->exps->length; i++) |
| { |
| Expression *elem = (*te->exps)[i]; |
| hash = mixHash(hash, expressionHash(elem)); |
| } |
| return hash; |
| } |
| |
| case TOKarrayliteral: |
| { |
| ArrayLiteralExp *ae = (ArrayLiteralExp *)e; |
| size_t hash = 0; |
| for (size_t i = 0; i < ae->elements->length; i++) |
| hash = mixHash(hash, expressionHash(ae->getElement(i))); |
| return hash; |
| } |
| |
| case TOKassocarrayliteral: |
| { |
| AssocArrayLiteralExp *ae = (AssocArrayLiteralExp *)e; |
| size_t hash = 0; |
| for (size_t i = 0; i < ae->keys->length; i++) |
| // reduction needs associative op as keys are unsorted (use XOR) |
| hash ^= mixHash(expressionHash((*ae->keys)[i]), expressionHash((*ae->values)[i])); |
| return hash; |
| } |
| |
| case TOKstructliteral: |
| { |
| StructLiteralExp *se = (StructLiteralExp *)e; |
| size_t hash = 0; |
| for (size_t i = 0; i < se->elements->length; i++) |
| { |
| Expression *elem = (*se->elements)[i]; |
| hash = mixHash(hash, elem ? expressionHash(elem) : 0); |
| } |
| return hash; |
| } |
| |
| case TOKvar: |
| return (size_t)(void *) ((VarExp *)e)->var; |
| |
| case TOKfunction: |
| return (size_t)(void *) ((FuncExp *)e)->fd; |
| |
| default: |
| // no custom equals for this expression |
| // equals based on identity |
| return (size_t)(void *) e; |
| } |
| } |
| |
| |
| /************************************ |
| * Return hash of Objects. |
| */ |
| static hash_t arrayObjectHash(Objects *oa1) |
| { |
| hash_t hash = 0; |
| for (size_t j = 0; j < oa1->length; j++) |
| { |
| /* Must follow the logic of match() |
| */ |
| RootObject *o1 = (*oa1)[j]; |
| if (Type *t1 = isType(o1)) |
| hash = mixHash(hash, (size_t)t1->deco); |
| else if (Expression *e1 = getExpression(o1)) |
| hash = mixHash(hash, expressionHash(e1)); |
| else if (Dsymbol *s1 = isDsymbol(o1)) |
| { |
| FuncAliasDeclaration *fa1 = s1->isFuncAliasDeclaration(); |
| if (fa1) |
| s1 = fa1->toAliasFunc(); |
| hash = mixHash(hash, mixHash((size_t)(void *)s1->getIdent(), (size_t)(void *)s1->parent)); |
| } |
| else if (Tuple *u1 = isTuple(o1)) |
| hash = mixHash(hash, arrayObjectHash(&u1->objects)); |
| } |
| return hash; |
| } |
| |
| RootObject *objectSyntaxCopy(RootObject *o) |
| { |
| if (!o) |
| return NULL; |
| if (Type *t = isType(o)) |
| return t->syntaxCopy(); |
| if (Expression *e = isExpression(o)) |
| return e->syntaxCopy(); |
| return o; |
| } |
| |
| |
| /* ======================== TemplateDeclaration ============================= */ |
| |
| TemplateDeclaration::TemplateDeclaration(Loc loc, Identifier *id, |
| TemplateParameters *parameters, Expression *constraint, Dsymbols *decldefs, bool ismixin, bool literal) |
| : ScopeDsymbol(id) |
| { |
| this->loc = loc; |
| this->parameters = parameters; |
| this->origParameters = parameters; |
| this->constraint = constraint; |
| this->members = decldefs; |
| this->overnext = NULL; |
| this->overroot = NULL; |
| this->funcroot = NULL; |
| this->onemember = NULL; |
| this->literal = literal; |
| this->ismixin = ismixin; |
| this->isstatic = true; |
| this->isTrivialAliasSeq = false; |
| this->isTrivialAlias = false; |
| this->previous = NULL; |
| this->protection = Prot(Prot::undefined); |
| this->inuse = 0; |
| this->instances = NULL; |
| |
| // Compute in advance for Ddoc's use |
| // Bugzilla 11153: ident could be NULL if parsing fails. |
| if (!members || !ident) |
| return; |
| |
| Dsymbol *s; |
| if (!Dsymbol::oneMembers(members, &s, ident) || !s) |
| return; |
| |
| onemember = s; |
| s->parent = this; |
| |
| /* Set isTrivialAliasSeq if this fits the pattern: |
| * template AliasSeq(T...) { alias AliasSeq = T; } |
| * or set isTrivialAlias if this fits the pattern: |
| * template Alias(T) { alias Alias = qualifiers(T); } |
| */ |
| if (!(parameters && parameters->length == 1)) |
| return; |
| |
| AliasDeclaration *ad = s->isAliasDeclaration(); |
| if (!ad || !ad->type) |
| return; |
| |
| TypeIdentifier *ti = ad->type->isTypeIdentifier(); |
| if (!ti || ti->idents.length != 0) |
| return; |
| |
| if (TemplateTupleParameter *ttp = (*parameters)[0]->isTemplateTupleParameter()) |
| { |
| if (ti->ident == ttp->ident && ti->mod == 0) |
| { |
| //printf("found isAliasSeq %s %s\n", s->toChars(), ad->type->toChars()); |
| isTrivialAliasSeq = true; |
| } |
| } |
| else if (TemplateTypeParameter *ttp = (*parameters)[0]->isTemplateTypeParameter()) |
| { |
| if (ti->ident == ttp->ident) |
| { |
| //printf("found isAlias %s %s\n", s->toChars(), ad->type->toChars()); |
| isTrivialAlias = true; |
| } |
| } |
| } |
| |
| Dsymbol *TemplateDeclaration::syntaxCopy(Dsymbol *) |
| { |
| //printf("TemplateDeclaration::syntaxCopy()\n"); |
| TemplateParameters *p = NULL; |
| if (parameters) |
| { |
| p = new TemplateParameters(); |
| p->setDim(parameters->length); |
| for (size_t i = 0; i < p->length; i++) |
| (*p)[i] = (*parameters)[i]->syntaxCopy(); |
| } |
| return new TemplateDeclaration(loc, ident, p, |
| constraint ? constraint->syntaxCopy() : NULL, |
| Dsymbol::arraySyntaxCopy(members), ismixin, literal); |
| } |
| |
| const char *TemplateDeclaration::kind() const |
| { |
| return (onemember && onemember->isAggregateDeclaration()) |
| ? onemember->kind() |
| : "template"; |
| } |
| |
| /********************************** |
| * Overload existing TemplateDeclaration 'this' with the new one 's'. |
| * Return true if successful; i.e. no conflict. |
| */ |
| |
| bool TemplateDeclaration::overloadInsert(Dsymbol *s) |
| { |
| FuncDeclaration *fd = s->isFuncDeclaration(); |
| if (fd) |
| { |
| if (funcroot) |
| return funcroot->overloadInsert(fd); |
| funcroot = fd; |
| return funcroot->overloadInsert(this); |
| } |
| |
| TemplateDeclaration *td = s->isTemplateDeclaration(); |
| if (!td) |
| return false; |
| |
| TemplateDeclaration *pthis = this; |
| TemplateDeclaration **ptd; |
| for (ptd = &pthis; *ptd; ptd = &(*ptd)->overnext) |
| { |
| } |
| |
| td->overroot = this; |
| *ptd = td; |
| return true; |
| } |
| |
| /**************************** |
| * Check to see if constraint is satisfied. |
| */ |
| bool TemplateDeclaration::evaluateConstraint( |
| TemplateInstance *ti, Scope *sc, Scope *paramscope, |
| Objects *dedargs, FuncDeclaration *fd) |
| { |
| /* Detect recursive attempts to instantiate this template declaration, |
| * Bugzilla 4072 |
| * void foo(T)(T x) if (is(typeof(foo(x)))) { } |
| * static assert(!is(typeof(foo(7)))); |
| * Recursive attempts are regarded as a constraint failure. |
| */ |
| /* There's a chicken-and-egg problem here. We don't know yet if this template |
| * instantiation will be a local one (enclosing is set), and we won't know until |
| * after selecting the correct template. Thus, function we're nesting inside |
| * is not on the sc scope chain, and this can cause errors in FuncDeclaration::getLevel(). |
| * Workaround the problem by setting a flag to relax the checking on frame errors. |
| */ |
| |
| for (TemplatePrevious *p = previous; p; p = p->prev) |
| { |
| if (arrayObjectMatch(p->dedargs, dedargs)) |
| { |
| //printf("recursive, no match p->sc=%p %p %s\n", p->sc, this, this->toChars()); |
| /* It must be a subscope of p->sc, other scope chains are not recursive |
| * instantiations. |
| */ |
| for (Scope *scx = sc; scx; scx = scx->enclosing) |
| { |
| if (scx == p->sc) |
| return false; |
| } |
| } |
| /* BUG: should also check for ref param differences |
| */ |
| } |
| |
| TemplatePrevious pr; |
| pr.prev = previous; |
| pr.sc = paramscope; |
| pr.dedargs = dedargs; |
| previous = ≺ // add this to threaded list |
| |
| Scope *scx = paramscope->push(ti); |
| scx->parent = ti; |
| scx->tinst = NULL; |
| scx->minst = NULL; |
| |
| assert(!ti->symtab); |
| if (fd) |
| { |
| /* Declare all the function parameters as variables and add them to the scope |
| * Making parameters is similar to FuncDeclaration::semantic3 |
| */ |
| TypeFunction *tf = (TypeFunction *)fd->type; |
| assert(tf->ty == Tfunction); |
| |
| scx->parent = fd; |
| |
| Parameters *fparameters = tf->parameterList.parameters; |
| VarArg fvarargs = tf->parameterList.varargs; |
| |
| size_t nfparams = Parameter::dim(fparameters); |
| for (size_t i = 0; i < nfparams; i++) |
| { |
| Parameter *fparam = Parameter::getNth(fparameters, i); |
| fparam->storageClass &= (STCin | STCout | STCref | STClazy | STCfinal | STC_TYPECTOR | STCnodtor); |
| fparam->storageClass |= STCparameter; |
| if (fvarargs == VARARGtypesafe && i + 1 == nfparams) |
| fparam->storageClass |= STCvariadic; |
| } |
| for (size_t i = 0; i < fparameters->length; i++) |
| { |
| Parameter *fparam = (*fparameters)[i]; |
| if (!fparam->ident) |
| continue; // don't add it, if it has no name |
| VarDeclaration *v = new VarDeclaration(loc, fparam->type, fparam->ident, NULL); |
| v->storage_class = fparam->storageClass; |
| dsymbolSemantic(v, scx); |
| if (!ti->symtab) |
| ti->symtab = new DsymbolTable(); |
| if (!scx->insert(v)) |
| error("parameter %s.%s is already defined", toChars(), v->toChars()); |
| else |
| v->parent = fd; |
| } |
| if (isstatic) |
| fd->storage_class |= STCstatic; |
| |
| fd->vthis = fd->declareThis(scx, fd->isThis()); |
| } |
| |
| Expression *e = constraint->syntaxCopy(); |
| |
| assert(ti->inst == NULL); |
| ti->inst = ti; // temporary instantiation to enable genIdent() |
| |
| scx->flags |= SCOPEconstraint; |
| bool errors = false; |
| bool result = evalStaticCondition(scx, constraint, e, errors); |
| ti->inst = NULL; |
| ti->symtab = NULL; |
| scx = scx->pop(); |
| previous = pr.prev; // unlink from threaded list |
| if (errors) |
| return false; |
| return result; |
| } |
| |
| /*************************************** |
| * Given that ti is an instance of this TemplateDeclaration, |
| * deduce the types of the parameters to this, and store |
| * those deduced types in dedtypes[]. |
| * Input: |
| * flag 1: don't do semantic() because of dummy types |
| * 2: don't change types in matchArg() |
| * Output: |
| * dedtypes deduced arguments |
| * Return match level. |
| */ |
| |
| MATCH TemplateDeclaration::matchWithInstance(Scope *sc, TemplateInstance *ti, |
| Objects *dedtypes, Expressions *fargs, int flag) |
| { |
| MATCH m; |
| size_t dedtypes_dim = dedtypes->length; |
| |
| dedtypes->zero(); |
| |
| if (errors) |
| return MATCHnomatch; |
| |
| size_t parameters_dim = parameters->length; |
| int variadic = isVariadic() != NULL; |
| |
| // If more arguments than parameters, no match |
| if (ti->tiargs->length > parameters_dim && !variadic) |
| { |
| return MATCHnomatch; |
| } |
| |
| assert(dedtypes_dim == parameters_dim); |
| assert(dedtypes_dim >= ti->tiargs->length || variadic); |
| |
| assert(_scope); |
| |
| // Set up scope for template parameters |
| ScopeDsymbol *paramsym = new ScopeDsymbol(); |
| paramsym->parent = _scope->parent; |
| Scope *paramscope = _scope->push(paramsym); |
| paramscope->tinst = ti; |
| paramscope->minst = sc->minst; |
| paramscope->callsc = sc; |
| paramscope->stc = 0; |
| |
| // Attempt type deduction |
| m = MATCHexact; |
| for (size_t i = 0; i < dedtypes_dim; i++) |
| { |
| MATCH m2; |
| TemplateParameter *tp = (*parameters)[i]; |
| Declaration *sparam; |
| |
| //printf("\targument [%d]\n", i); |
| inuse++; |
| m2 = tp->matchArg(ti->loc, paramscope, ti->tiargs, i, parameters, dedtypes, &sparam); |
| inuse--; |
| //printf("\tm2 = %d\n", m2); |
| |
| if (m2 == MATCHnomatch) |
| { |
| goto Lnomatch; |
| } |
| |
| if (m2 < m) |
| m = m2; |
| |
| if (!flag) |
| dsymbolSemantic(sparam, paramscope); |
| if (!paramscope->insert(sparam)) // TODO: This check can make more early |
| goto Lnomatch; // in TemplateDeclaration::semantic, and |
| // then we don't need to make sparam if flags == 0 |
| } |
| |
| if (!flag) |
| { |
| /* Any parameter left without a type gets the type of |
| * its corresponding arg |
| */ |
| for (size_t i = 0; i < dedtypes_dim; i++) |
| { |
| if (!(*dedtypes)[i]) |
| { |
| assert(i < ti->tiargs->length); |
| (*dedtypes)[i] = (Type *)(*ti->tiargs)[i]; |
| } |
| } |
| } |
| |
| if (m > MATCHnomatch && constraint && !flag) |
| { |
| if (ti->hasNestedArgs(ti->tiargs, this->isstatic)) // TODO: should gag error |
| ti->parent = ti->enclosing; |
| else |
| ti->parent = this->parent; |
| |
| // Similar to doHeaderInstantiation |
| FuncDeclaration *fd = onemember ? onemember->isFuncDeclaration() : NULL; |
| if (fd) |
| { |
| assert(fd->type->ty == Tfunction); |
| TypeFunction *tf = (TypeFunction *)fd->type->syntaxCopy(); |
| |
| fd = new FuncDeclaration(fd->loc, fd->endloc, fd->ident, fd->storage_class, tf); |
| fd->parent = ti; |
| fd->inferRetType = true; |
| |
| // Shouldn't run semantic on default arguments and return type. |
| for (size_t i = 0; i < tf->parameterList.parameters->length; i++) |
| (*tf->parameterList.parameters)[i]->defaultArg = NULL; |
| tf->next = NULL; |
| |
| // Resolve parameter types and 'auto ref's. |
| tf->fargs = fargs; |
| unsigned olderrors = global.startGagging(); |
| fd->type = typeSemantic(tf, loc, paramscope); |
| if (global.endGagging(olderrors)) |
| { |
| assert(fd->type->ty != Tfunction); |
| goto Lnomatch; |
| } |
| assert(fd->type->ty == Tfunction); |
| fd->originalType = fd->type; // for mangling |
| } |
| |
| // TODO: dedtypes => ti->tiargs ? |
| if (!evaluateConstraint(ti, sc, paramscope, dedtypes, fd)) |
| goto Lnomatch; |
| } |
| |
| goto Lret; |
| |
| Lnomatch: |
| m = MATCHnomatch; |
| |
| Lret: |
| paramscope->pop(); |
| return m; |
| } |
| |
| /******************************************** |
| * Determine partial specialization order of 'this' vs td2. |
| * Returns: |
| * match this is at least as specialized as td2 |
| * 0 td2 is more specialized than this |
| */ |
| |
| MATCH TemplateDeclaration::leastAsSpecialized(Scope *sc, TemplateDeclaration *td2, Expressions *fargs) |
| { |
| /* This works by taking the template parameters to this template |
| * declaration and feeding them to td2 as if it were a template |
| * instance. |
| * If it works, then this template is at least as specialized |
| * as td2. |
| */ |
| |
| TemplateInstance ti(Loc(), ident); // create dummy template instance |
| // Set type arguments to dummy template instance to be types |
| // generated from the parameters to this template declaration |
| ti.tiargs = new Objects(); |
| ti.tiargs->reserve(parameters->length); |
| for (size_t i = 0; i < parameters->length; i++) |
| { |
| TemplateParameter *tp = (*parameters)[i]; |
| if (tp->dependent) |
| break; |
| RootObject *p = (RootObject *)tp->dummyArg(); |
| if (!p) |
| break; |
| |
| ti.tiargs->push(p); |
| } |
| |
| // Temporary Array to hold deduced types |
| Objects dedtypes; |
| dedtypes.setDim(td2->parameters->length); |
| |
| // Attempt a type deduction |
| MATCH m = td2->matchWithInstance(sc, &ti, &dedtypes, fargs, 1); |
| if (m > MATCHnomatch) |
| { |
| /* A non-variadic template is more specialized than a |
| * variadic one. |
| */ |
| TemplateTupleParameter *tp = isVariadic(); |
| if (tp && !tp->dependent && !td2->isVariadic()) |
| goto L1; |
| |
| return m; |
| } |
| L1: |
| return MATCHnomatch; |
| } |
| |
| static Expression *emptyArrayElement = NULL; |
| |
| class TypeDeduced : public Type |
| { |
| public: |
| Type *tded; |
| Expressions argexps; // corresponding expressions |
| Types tparams; // tparams[i]->mod |
| |
| TypeDeduced(Type *tt, Expression *e, Type *tparam) |
| : Type(Tnone) |
| { |
| tded = tt; |
| argexps.push(e); |
| tparams.push(tparam); |
| } |
| |
| virtual ~TypeDeduced() |
| { |
| } |
| |
| void update(Expression *e, Type *tparam) |
| { |
| argexps.push(e); |
| tparams.push(tparam); |
| } |
| void update(Type *tt, Expression *e, Type *tparam) |
| { |
| tded = tt; |
| argexps.push(e); |
| tparams.push(tparam); |
| } |
| MATCH matchAll(Type *tt) |
| { |
| MATCH match = MATCHexact; |
| for (size_t j = 0; j < argexps.length; j++) |
| { |
| Expression *e = argexps[j]; |
| assert(e); |
| if (e == emptyArrayElement) |
| continue; |
| |
| Type *t = tt->addMod(tparams[j]->mod)->substWildTo(MODconst); |
| |
| MATCH m = e->implicitConvTo(t); |
| if (match > m) |
| match = m; |
| if (match <= MATCHnomatch) |
| break; |
| } |
| return match; |
| } |
| }; |
| |
| /************************************************* |
| * Match function arguments against a specific template function. |
| * Input: |
| * ti |
| * sc instantiation scope |
| * fd |
| * tthis 'this' argument if !NULL |
| * fargs arguments to function |
| * Output: |
| * fd Partially instantiated function declaration |
| * ti->tdtypes Expression/Type deduced template arguments |
| * Returns: |
| * match level |
| * bit 0-3 Match template parameters by inferred template arguments |
| * bit 4-7 Match template parameters by initial template arguments |
| */ |
| |
| MATCH TemplateDeclaration::deduceFunctionTemplateMatch( |
| TemplateInstance *ti, Scope *sc, |
| FuncDeclaration *&fd, Type *tthis, Expressions *fargs) |
| { |
| size_t nfparams; |
| size_t nfargs; |
| size_t ntargs; // array size of tiargs |
| size_t fptupindex = IDX_NOTFOUND; |
| MATCH match = MATCHexact; |
| MATCH matchTiargs = MATCHexact; |
| ParameterList fparameters; // function parameter list |
| unsigned wildmatch = 0; |
| size_t inferStart = 0; |
| |
| Loc instLoc = ti->loc; |
| Objects *tiargs = ti->tiargs; |
| Objects *dedargs = new Objects(); |
| Objects* dedtypes = &ti->tdtypes; // for T:T*, the dedargs is the T*, dedtypes is the T |
| |
| assert(_scope); |
| |
| dedargs->setDim(parameters->length); |
| dedargs->zero(); |
| |
| dedtypes->setDim(parameters->length); |
| dedtypes->zero(); |
| |
| if (errors || fd->errors) |
| return MATCHnomatch; |
| |
| // Set up scope for parameters |
| ScopeDsymbol *paramsym = new ScopeDsymbol(); |
| paramsym->parent = _scope->parent; // should use hasnestedArgs and enclosing? |
| Scope *paramscope = _scope->push(paramsym); |
| paramscope->tinst = ti; |
| paramscope->minst = sc->minst; |
| paramscope->callsc = sc; |
| paramscope->stc = 0; |
| |
| TemplateTupleParameter *tp = isVariadic(); |
| Tuple *declaredTuple = NULL; |
| |
| ntargs = 0; |
| if (tiargs) |
| { |
| // Set initial template arguments |
| ntargs = tiargs->length; |
| size_t n = parameters->length; |
| if (tp) |
| n--; |
| if (ntargs > n) |
| { |
| if (!tp) |
| goto Lnomatch; |
| |
| /* The extra initial template arguments |
| * now form the tuple argument. |
| */ |
| Tuple *t = new Tuple(); |
| assert(parameters->length); |
| (*dedargs)[parameters->length - 1] = t; |
| |
| t->objects.setDim(ntargs - n); |
| for (size_t i = 0; i < t->objects.length; i++) |
| { |
| t->objects[i] = (*tiargs)[n + i]; |
| } |
| declareParameter(paramscope, tp, t); |
| declaredTuple = t; |
| } |
| else |
| n = ntargs; |
| |
| memcpy(dedargs->tdata(), tiargs->tdata(), n * sizeof(*dedargs->tdata())); |
| |
| for (size_t i = 0; i < n; i++) |
| { |
| assert(i < parameters->length); |
| Declaration *sparam = NULL; |
| MATCH m = (*parameters)[i]->matchArg(instLoc, paramscope, dedargs, i, parameters, dedtypes, &sparam); |
| //printf("\tdeduceType m = %d\n", m); |
| if (m <= MATCHnomatch) |
| goto Lnomatch; |
| if (m < matchTiargs) |
| matchTiargs = m; |
| |
| dsymbolSemantic(sparam, paramscope); |
| if (!paramscope->insert(sparam)) |
| goto Lnomatch; |
| } |
| if (n < parameters->length && !declaredTuple) |
| { |
| inferStart = n; |
| } |
| else |
| inferStart = parameters->length; |
| //printf("tiargs matchTiargs = %d\n", matchTiargs); |
| } |
| |
| fparameters = fd->getParameterList(); |
| nfparams = fparameters.length(); // number of function parameters |
| nfargs = fargs ? fargs->length : 0; // number of function arguments |
| |
| /* Check for match of function arguments with variadic template |
| * parameter, such as: |
| * |
| * void foo(T, A...)(T t, A a); |
| * void main() { foo(1,2,3); } |
| */ |
| if (tp) // if variadic |
| { |
| // TemplateTupleParameter always makes most lesser matching. |
| matchTiargs = MATCHconvert; |
| |
| if (nfparams == 0 && nfargs != 0) // if no function parameters |
| { |
| if (!declaredTuple) |
| { |
| Tuple *t = new Tuple(); |
| //printf("t = %p\n", t); |
| (*dedargs)[parameters->length - 1] = t; |
| declareParameter(paramscope, tp, t); |
| declaredTuple = t; |
| } |
| } |
| else |
| { |
| /* Figure out which of the function parameters matches |
| * the tuple template parameter. Do this by matching |
| * type identifiers. |
| * Set the index of this function parameter to fptupindex. |
| */ |
| for (fptupindex = 0; fptupindex < nfparams; fptupindex++) |
| { |
| Parameter *fparam = (*fparameters.parameters)[fptupindex]; |
| if (fparam->type->ty != Tident) |
| continue; |
| TypeIdentifier *tid = (TypeIdentifier *)fparam->type; |
| if (!tp->ident->equals(tid->ident) || tid->idents.length) |
| continue; |
| |
| if (fparameters.varargs != VARARGnone) // variadic function doesn't |
| goto Lnomatch; // go with variadic template |
| |
| goto L1; |
| } |
| fptupindex = IDX_NOTFOUND; |
| L1: |
| ; |
| } |
| } |
| |
| if (toParent()->isModule() || (_scope->stc & STCstatic)) |
| tthis = NULL; |
| if (tthis) |
| { |
| bool hasttp = false; |
| |
| // Match 'tthis' to any TemplateThisParameter's |
| for (size_t i = 0; i < parameters->length; i++) |
| { |
| TemplateThisParameter *ttp = (*parameters)[i]->isTemplateThisParameter(); |
| if (ttp) |
| { |
| hasttp = true; |
| |
| Type *t = new TypeIdentifier(Loc(), ttp->ident); |
| MATCH m = deduceType(tthis, paramscope, t, parameters, dedtypes); |
| if (m <= MATCHnomatch) |
| goto Lnomatch; |
| if (m < match) |
| match = m; // pick worst match |
| } |
| } |
| |
| // Match attributes of tthis against attributes of fd |
| if (fd->type && !fd->isCtorDeclaration()) |
| { |
| StorageClass stc = _scope->stc | fd->storage_class2; |
| // Propagate parent storage class (see bug 5504) |
| Dsymbol *p = parent; |
| while (p->isTemplateDeclaration() || p->isTemplateInstance()) |
| p = p->parent; |
| AggregateDeclaration *ad = p->isAggregateDeclaration(); |
| if (ad) |
| stc |= ad->storage_class; |
| |
| unsigned char mod = fd->type->mod; |
| if (stc & STCimmutable) |
| mod = MODimmutable; |
| else |
| { |
| if (stc & (STCshared | STCsynchronized)) |
| mod |= MODshared; |
| if (stc & STCconst) |
| mod |= MODconst; |
| if (stc & STCwild) |
| mod |= MODwild; |
| } |
| |
| unsigned char thismod = tthis->mod; |
| if (hasttp) |
| mod = MODmerge(thismod, mod); |
| MATCH m = MODmethodConv(thismod, mod); |
| if (m <= MATCHnomatch) |
| goto Lnomatch; |
| if (m < match) |
| match = m; |
| } |
| } |
| |
| // Loop through the function parameters |
| { |
| //printf("%s\n\tnfargs = %d, nfparams = %d, tuple_dim = %d\n", toChars(), nfargs, nfparams, declaredTuple ? declaredTuple->objects.length : 0); |
| //printf("\ttp = %p, fptupindex = %d, found = %d, declaredTuple = %s\n", tp, fptupindex, fptupindex != IDX_NOTFOUND, declaredTuple ? declaredTuple->toChars() : NULL); |
| size_t argi = 0; |
| size_t nfargs2 = nfargs; // nfargs + supplied defaultArgs |
| for (size_t parami = 0; parami < nfparams; parami++) |
| { |
| Parameter *fparam = fparameters[parami]; |
| |
| // Apply function parameter storage classes to parameter types |
| Type *prmtype = fparam->type->addStorageClass(fparam->storageClass); |
| |
| Expression *farg; |
| |
| /* See function parameters which wound up |
| * as part of a template tuple parameter. |
| */ |
| if (fptupindex != IDX_NOTFOUND && parami == fptupindex) |
| { |
| assert(prmtype->ty == Tident); |
| TypeIdentifier *tid = (TypeIdentifier *)prmtype; |
| if (!declaredTuple) |
| { |
| /* The types of the function arguments |
| * now form the tuple argument. |
| */ |
| declaredTuple = new Tuple(); |
| (*dedargs)[parameters->length - 1] = declaredTuple; |
| |
| /* Count function parameters following a tuple parameter. |
| * void foo(U, T...)(int y, T, U, int) {} // rem == 2 (U, int) |
| */ |
| size_t rem = 0; |
| for (size_t j = parami + 1; j < nfparams; j++) |
| { |
| Parameter *p = fparameters[j]; |
| if (!reliesOnTident(p->type, parameters, inferStart)) |
| { |
| Type *pt = typeSemantic(p->type->syntaxCopy(), fd->loc, paramscope); |
| rem += pt->ty == Ttuple ? ((TypeTuple *)pt)->arguments->length : 1; |
| } |
| else |
| { |
| ++rem; |
| } |
| } |
| |
| if (nfargs2 - argi < rem) |
| goto Lnomatch; |
| declaredTuple->objects.setDim(nfargs2 - argi - rem); |
| for (size_t i = 0; i < declaredTuple->objects.length; i++) |
| { |
| farg = (*fargs)[argi + i]; |
| |
| // Check invalid arguments to detect errors early. |
| if (farg->op == TOKerror || farg->type->ty == Terror) |
| goto Lnomatch; |
| |
| if (!(fparam->storageClass & STClazy) && farg->type->ty == Tvoid) |
| goto Lnomatch; |
| |
| Type *tt; |
| MATCH m; |
| if (unsigned char wm = deduceWildHelper(farg->type, &tt, tid)) |
| { |
| wildmatch |= wm; |
| m = MATCHconst; |
| } |
| else |
| { |
| m = deduceTypeHelper(farg->type, &tt, tid); |
| } |
| if (m <= MATCHnomatch) |
| goto Lnomatch; |
| if (m < match) |
| match = m; |
| |
| /* Remove top const for dynamic array types and pointer types |
| */ |
| if ((tt->ty == Tarray || tt->ty == Tpointer) && |
| !tt->isMutable() && |
| (!(fparam->storageClass & STCref) || |
| ((fparam->storageClass & STCauto) && !farg->isLvalue()))) |
| { |
| tt = tt->mutableOf(); |
| } |
| declaredTuple->objects[i] = tt; |
| } |
| declareParameter(paramscope, tp, declaredTuple); |
| } |
| else |
| { |
| // Bugzilla 6810: If declared tuple is not a type tuple, |
| // it cannot be function parameter types. |
| for (size_t i = 0; i < declaredTuple->objects.length; i++) |
| { |
| if (!isType(declaredTuple->objects[i])) |
| goto Lnomatch; |
| } |
| } |
| assert(declaredTuple); |
| argi += declaredTuple->objects.length; |
| continue; |
| } |
| |
| // If parameter type doesn't depend on inferred template parameters, |
| // semantic it to get actual type. |
| if (!reliesOnTident(prmtype, parameters, inferStart)) |
| { |
| // should copy prmtype to avoid affecting semantic result |
| prmtype = typeSemantic(prmtype->syntaxCopy(), fd->loc, paramscope); |
| |
| if (prmtype->ty == Ttuple) |
| { |
| TypeTuple *tt = (TypeTuple *)prmtype; |
| size_t tt_dim = tt->arguments->length; |
| for (size_t j = 0; j < tt_dim; j++, ++argi) |
| { |
| Parameter *p = (*tt->arguments)[j]; |
| if (j == tt_dim - 1 && fparameters.varargs == VARARGtypesafe && |
| parami + 1 == nfparams && argi < nfargs) |
| { |
| prmtype = p->type; |
| goto Lvarargs; |
| } |
| if (argi >= nfargs) |
| { |
| if (p->defaultArg) |
| continue; |
| goto Lnomatch; |
| } |
| farg = (*fargs)[argi]; |
| if (!farg->implicitConvTo(p->type)) |
| goto Lnomatch; |
| } |
| continue; |
| } |
| } |
| |
| if (argi >= nfargs) // if not enough arguments |
| { |
| if (!fparam->defaultArg) |
| goto Lvarargs; |
| |
| /* Bugzilla 2803: Before the starting of type deduction from the function |
| * default arguments, set the already deduced parameters into paramscope. |
| * It's necessary to avoid breaking existing acceptable code. Cases: |
| * |
| * 1. Already deduced template parameters can appear in fparam->defaultArg: |
| * auto foo(A, B)(A a, B b = A.stringof); |
| * foo(1); |
| * // at fparam == 'B b = A.string', A is equivalent with the deduced type 'int' |
| * |
| * 2. If prmtype depends on default-specified template parameter, the |
| * default type should be preferred. |
| * auto foo(N = size_t, R)(R r, N start = 0) |
| * foo([1,2,3]); |
| * // at fparam `N start = 0`, N should be 'size_t' before |
| * // the deduction result from fparam->defaultArg. |
| */ |
| if (argi == nfargs) |
| { |
| for (size_t i = 0; i < dedtypes->length; i++) |
| { |
| Type *at = isType((*dedtypes)[i]); |
| if (at && at->ty == Tnone) |
| { |
| TypeDeduced *xt = (TypeDeduced *)at; |
| (*dedtypes)[i] = xt->tded; // 'unbox' |
| delete xt; |
| } |
| } |
| for (size_t i = ntargs; i < dedargs->length; i++) |
| { |
| TemplateParameter *tparam = (*parameters)[i]; |
| |
| RootObject *oarg = (*dedargs)[i]; |
| RootObject *oded = (*dedtypes)[i]; |
| if (!oarg) |
| { |
| if (oded) |
| { |
| if (tparam->specialization() || !tparam->isTemplateTypeParameter()) |
| { |
| /* The specialization can work as long as afterwards |
| * the oded == oarg |
| */ |
| (*dedargs)[i] = oded; |
| MATCH m2 = tparam->matchArg(instLoc, paramscope, dedargs, i, parameters, dedtypes, NULL); |
| //printf("m2 = %d\n", m2); |
| if (m2 <= MATCHnomatch) |
| goto Lnomatch; |
| if (m2 < matchTiargs) |
| matchTiargs = m2; // pick worst match |
| if (!(*dedtypes)[i]->equals(oded)) |
| error("specialization not allowed for deduced parameter %s", tparam->ident->toChars()); |
| } |
| else |
| { |
| if (MATCHconvert < matchTiargs) |
| matchTiargs = MATCHconvert; |
| } |
| (*dedargs)[i] = declareParameter(paramscope, tparam, oded); |
| } |
| else |
| { |
| inuse++; |
| oded = tparam->defaultArg(instLoc, paramscope); |
| inuse--; |
| if (oded) |
| (*dedargs)[i] = declareParameter(paramscope, tparam, oded); |
| } |
| } |
| } |
| } |
| nfargs2 = argi + 1; |
| |
| /* If prmtype does not depend on any template parameters: |
| * |
| * auto foo(T)(T v, double x = 0); |
| * foo("str"); |
| * // at fparam == 'double x = 0' |
| * |
| * or, if all template parameters in the prmtype are already deduced: |
| * |
| * auto foo(R)(R range, ElementType!R sum = 0); |
| * foo([1,2,3]); |
| * // at fparam == 'ElementType!R sum = 0' |
| * |
| * Deducing prmtype from fparam->defaultArg is not necessary. |
| */ |
| if (prmtype->deco || |
| prmtype->syntaxCopy()->trySemantic(loc, paramscope)) |
| { |
| ++argi; |
| continue; |
| } |
| |
| // Deduce prmtype from the defaultArg. |
| farg = fparam->defaultArg->syntaxCopy(); |
| farg = expressionSemantic(farg, paramscope); |
| farg = resolveProperties(paramscope, farg); |
| } |
| else |
| { |
| farg = (*fargs)[argi]; |
| } |
| { |
| // Check invalid arguments to detect errors early. |
| if (farg->op == TOKerror || farg->type->ty == Terror) |
| goto Lnomatch; |
| |
| Type *att = NULL; |
| Lretry: |
| Type *argtype = farg->type; |
| |
| if (!(fparam->storageClass & STClazy) && argtype->ty == Tvoid && farg->op != TOKfunction) |
| goto Lnomatch; |
| |
| // Bugzilla 12876: optimize arugument to allow CT-known length matching |
| farg = farg->optimize(WANTvalue, (fparam->storageClass & (STCref | STCout)) != 0); |
| //printf("farg = %s %s\n", farg->type->toChars(), farg->toChars()); |
| |
| RootObject *oarg = farg; |
| if ((fparam->storageClass & STCref) && |
| (!(fparam->storageClass & STCauto) || farg->isLvalue())) |
| { |
| /* Allow expressions that have CT-known boundaries and type [] to match with [dim] |
| */ |
| Type *taai; |
| if (argtype->ty == Tarray && |
| (prmtype->ty == Tsarray || |
| (prmtype->ty == Taarray && (taai = ((TypeAArray *)prmtype)->index)->ty == Tident && |
| ((TypeIdentifier *)taai)->idents.length == 0))) |
| { |
| if (farg->op == TOKstring) |
| { |
| StringExp *se = (StringExp *)farg; |
| argtype = se->type->nextOf()->sarrayOf(se->len); |
| } |
| else if (farg->op == TOKarrayliteral) |
| { |
| ArrayLiteralExp *ae = (ArrayLiteralExp *)farg; |
| argtype = ae->type->nextOf()->sarrayOf(ae->elements->length); |
| } |
| else if (farg->op == TOKslice) |
| { |
| SliceExp *se = (SliceExp *)farg; |
| if (Type *tsa = toStaticArrayType(se)) |
| argtype = tsa; |
| } |
| } |
| |
| oarg = argtype; |
| } |
| else if ((fparam->storageClass & STCout) == 0 && |
| (argtype->ty == Tarray || argtype->ty == Tpointer) && |
| templateParameterLookup(prmtype, parameters) != IDX_NOTFOUND && |
| ((TypeIdentifier *)prmtype)->idents.length == 0) |
| { |
| /* The farg passing to the prmtype always make a copy. Therefore, |
| * we can shrink the set of the deduced type arguments for prmtype |
| * by adjusting top-qualifier of the argtype. |
| * |
| * prmtype argtype ta |
| * T <- const(E)[] const(E)[] |
| * T <- const(E[]) const(E)[] |
| * qualifier(T) <- const(E)[] const(E[]) |
| * qualifier(T) <- const(E[]) const(E[]) |
| */ |
| Type *ta = argtype->castMod(prmtype->mod ? argtype->nextOf()->mod : 0); |
| if (ta != argtype) |
| { |
| Expression *ea = farg->copy(); |
| ea->type = ta; |
| oarg = ea; |
| } |
| } |
| |
| if (fparameters.varargs == VARARGtypesafe && parami + 1 == nfparams && argi + 1 < nfargs) |
| goto Lvarargs; |
| |
| unsigned wm = 0; |
| MATCH m = deduceType(oarg, paramscope, prmtype, parameters, dedtypes, &wm, inferStart); |
| //printf("\tL%d deduceType m = %d, wm = x%x, wildmatch = x%x\n", __LINE__, m, wm, wildmatch); |
| wildmatch |= wm; |
| |
| /* If no match, see if the argument can be matched by using |
| * implicit conversions. |
| */ |
| if (m == MATCHnomatch && prmtype->deco) |
| m = farg->implicitConvTo(prmtype); |
| |
| if (m == MATCHnomatch) |
| { |
| AggregateDeclaration *ad = isAggregate(farg->type); |
| if (ad && ad->aliasthis && argtype != att) |
| { |
| if (!att && argtype->checkAliasThisRec()) // Bugzilla 12537 |
| att = argtype; |
| |
| /* If a semantic error occurs while doing alias this, |
| * eg purity(bug 7295), just regard it as not a match. |
| */ |
| if (Expression *e = resolveAliasThis(sc, farg, true)) |
| { |
| farg = e; |
| goto Lretry; |
| } |
| } |
| } |
| |
| if (m > MATCHnomatch && (fparam->storageClass & (STCref | STCauto)) == STCref) |
| { |
| if (!farg->isLvalue()) |
| { |
| if ((farg->op == TOKstring || farg->op == TOKslice) && |
| (prmtype->ty == Tsarray || prmtype->ty == Taarray)) |
| { |
| // Allow conversion from T[lwr .. upr] to ref T[upr-lwr] |
| } |
| else |
| goto Lnomatch; |
| } |
| } |
| if (m > MATCHnomatch && (fparam->storageClass & STCout)) |
| { |
| if (!farg->isLvalue()) |
| goto Lnomatch; |
| if (!farg->type->isMutable()) // Bugzilla 11916 |
| goto Lnomatch; |
| } |
| if (m == MATCHnomatch && (fparam->storageClass & STClazy) && prmtype->ty == Tvoid && |
| farg->type->ty != Tvoid) |
| m = MATCHconvert; |
| |
| if (m != MATCHnomatch) |
| { |
| if (m < match) |
| match = m; // pick worst match |
| argi++; |
| continue; |
| } |
| } |
| |
| Lvarargs: |
| /* The following code for variadic arguments closely |
| * matches TypeFunction::callMatch() |
| */ |
| if (!(fparameters.varargs == VARARGtypesafe && parami + 1 == nfparams)) |
| goto Lnomatch; |
| |
| /* Check for match with function parameter T... |
| */ |
| Type *tb = prmtype->toBasetype(); |
| switch (tb->ty) |
| { |
| // 6764 fix - TypeAArray may be TypeSArray have not yet run semantic(). |
| case Tsarray: |
| case Taarray: |
| // Perhaps we can do better with this, see TypeFunction::callMatch() |
| if (tb->ty == Tsarray) |
| { |
| TypeSArray *tsa = (TypeSArray *)tb; |
| dinteger_t sz = tsa->dim->toInteger(); |
| if (sz != nfargs - argi) |
| goto Lnomatch; |
| } |
| else if (tb->ty == Taarray) |
| { |
| TypeAArray *taa = (TypeAArray *)tb; |
| Expression *dim = new IntegerExp(instLoc, nfargs - argi, Type::tsize_t); |
| |
| size_t i = templateParameterLookup(taa->index, parameters); |
| if (i == IDX_NOTFOUND) |
| { |
| Expression *e; |
| Type *t; |
| Dsymbol *s; |
| Scope *sco; |
| |
| unsigned errors = global.startGagging(); |
| /* ref: https://issues.dlang.org/show_bug.cgi?id=11118 |
| * The parameter isn't part of the template |
| * ones, let's try to find it in the |
| * instantiation scope 'sc' and the one |
| * belonging to the template itself. */ |
| sco = sc; |
| taa->index->resolve(instLoc, sco, &e, &t, &s); |
| if (!e) |
| { |
| sco = paramscope; |
| taa->index->resolve(instLoc, sco, &e, &t, &s); |
| } |
| global.endGagging(errors); |
| |
| if (!e) |
| { |
| goto Lnomatch; |
| } |
| |
| e = e->ctfeInterpret(); |
| e = e->implicitCastTo(sco, Type::tsize_t); |
| e = e->optimize(WANTvalue); |
| if (!dim->equals(e)) |
| goto Lnomatch; |
| } |
| else |
| { |
| // This code matches code in TypeInstance::deduceType() |
| TemplateParameter *tprm = (*parameters)[i]; |
| TemplateValueParameter *tvp = tprm->isTemplateValueParameter(); |
| if (!tvp) |
| goto Lnomatch; |
| Expression *e = (Expression *)(*dedtypes)[i]; |
| if (e) |
| { |
| if (!dim->equals(e)) |
| goto Lnomatch; |
| } |
| else |
| { |
| Type *vt = typeSemantic(tvp->valType, Loc(), sc); |
| MATCH m = (MATCH)dim->implicitConvTo(vt); |
| if (m <= MATCHnomatch) |
| goto Lnomatch; |
| (*dedtypes)[i] = dim; |
| } |
| } |
| } |
| /* fall through */ |
| case Tarray: |
| { |
| TypeArray *ta = (TypeArray *)tb; |
| Type *tret = fparam->isLazyArray(); |
| for (; argi < nfargs; argi++) |
| { |
| Expression *arg = (*fargs)[argi]; |
| assert(arg); |
| |
| MATCH m; |
| /* If lazy array of delegates, |
| * convert arg(s) to delegate(s) |
| */ |
| if (tret) |
| { |
| if (ta->next->equals(arg->type)) |
| { |
| m = MATCHexact; |
| } |
| else |
| { |
| m = arg->implicitConvTo(tret); |
| if (m == MATCHnomatch) |
| { |
| if (tret->toBasetype()->ty == Tvoid) |
| m = MATCHconvert; |
| } |
| } |
| } |
| else |
| { |
| unsigned wm = 0; |
| m = deduceType(arg, paramscope, ta->next, parameters, dedtypes, &wm, inferStart); |
| wildmatch |= wm; |
| } |
| if (m == MATCHnomatch) |
| goto Lnomatch; |
| if (m < match) |
| match = m; |
| } |
| goto Lmatch; |
| } |
| case Tclass: |
| case Tident: |
| goto Lmatch; |
| |
| default: |
| goto Lnomatch; |
| } |
| ++argi; |
| } |
| //printf("-> argi = %d, nfargs = %d, nfargs2 = %d\n", argi, nfargs, nfargs2); |
| if (argi != nfargs2 && fparameters.varargs == VARARGnone) |
| goto Lnomatch; |
| } |
| |
| Lmatch: |
| |
| for (size_t i = 0; i < dedtypes->length; i++) |
| { |
| Type *at = isType((*dedtypes)[i]); |
| if (at) |
| { |
| if (at->ty == Tnone) |
| { |
| TypeDeduced *xt = (TypeDeduced *)at; |
| at = xt->tded; // 'unbox' |
| delete xt; |
| } |
| (*dedtypes)[i] = at->merge2(); |
| } |
| } |
| for (size_t i = ntargs; i < dedargs->length; i++) |
| { |
| TemplateParameter *tparam = (*parameters)[i]; |
| //printf("tparam[%d] = %s\n", i, tparam->ident->toChars()); |
| /* For T:T*, the dedargs is the T*, dedtypes is the T |
| * But for function templates, we really need them to match |
| */ |
| RootObject *oarg = (*dedargs)[i]; |
| RootObject *oded = (*dedtypes)[i]; |
| //printf("1dedargs[%d] = %p, dedtypes[%d] = %p\n", i, oarg, i, oded); |
| //if (oarg) printf("oarg: %s\n", oarg->toChars()); |
| //if (oded) printf("oded: %s\n", oded->toChars()); |
| if (!oarg) |
| { |
| if (oded) |
| { |
| if (tparam->specialization() || !tparam->isTemplateTypeParameter()) |
| { |
| /* The specialization can work as long as afterwards |
| * the oded == oarg |
| */ |
| (*dedargs)[i] = oded; |
| MATCH m2 = tparam->matchArg(instLoc, paramscope, dedargs, i, parameters, dedtypes, NULL); |
| //printf("m2 = %d\n", m2); |
| if (m2 <= MATCHnomatch) |
| goto Lnomatch; |
| if (m2 < matchTiargs) |
| matchTiargs = m2; // pick worst match |
| if (!(*dedtypes)[i]->equals(oded)) |
| error("specialization not allowed for deduced parameter %s", tparam->ident->toChars()); |
| } |
| else |
| { |
| if (MATCHconvert < matchTiargs) |
| matchTiargs = MATCHconvert; |
| } |
| } |
| else |
| { |
| inuse++; |
| oded = tparam->defaultArg(instLoc, paramscope); |
| inuse--; |
| if (!oded) |
| { |
| // if tuple parameter and |
| // tuple parameter was not in function parameter list and |
| // we're one or more arguments short (i.e. no tuple argument) |
| if (tparam == tp && |
| fptupindex == IDX_NOTFOUND && |
| ntargs <= dedargs->length - 1) |
| { |
| // make tuple argument an empty tuple |
| oded = (RootObject *)new Tuple(); |
| } |
| else |
| goto Lnomatch; |
| } |
| if (isError(oded)) |
| goto Lerror; |
| ntargs++; |
| |
| /* At the template parameter T, the picked default template argument |
| * X!int should be matched to T in order to deduce dependent |
| * template parameter A. |
| * auto foo(T : X!A = X!int, A...)() { ... } |
| * foo(); // T <-- X!int, A <-- (int) |
| */ |
| if (tparam->specialization()) |
| { |
| (*dedargs)[i] = oded; |
| MATCH m2 = tparam->matchArg(instLoc, paramscope, dedargs, i, parameters, dedtypes, NULL); |
| //printf("m2 = %d\n", m2); |
| if (m2 <= MATCHnomatch) |
| goto Lnomatch; |
| if (m2 < matchTiargs) |
| matchTiargs = m2; // pick worst match |
| if (!(*dedtypes)[i]->equals(oded)) |
| error("specialization not allowed for deduced parameter %s", tparam->ident->toChars()); |
| } |
| } |
| oded = declareParameter(paramscope, tparam, oded); |
| (*dedargs)[i] = oded; |
| } |
| } |
| |
| /* Bugzilla 7469: As same as the code for 7469 in findBestMatch, |
| * expand a Tuple in dedargs to normalize template arguments. |
| */ |
| if (size_t d = dedargs->length) |
| { |
| if (Tuple *va = isTuple((*dedargs)[d - 1])) |
| { |
| if (va->objects.length) |
| { |
| dedargs->setDim(d - 1); |
| dedargs->insert(d - 1, &va->objects); |
| } |
| } |
| } |
| ti->tiargs = dedargs; // update to the normalized template arguments. |
| |
| // Partially instantiate function for constraint and fd->leastAsSpecialized() |
| { |
| assert(paramsym); |
| Scope *sc2 = _scope; |
| sc2 = sc2->push(paramsym); |
| sc2 = sc2->push(ti); |
| sc2->parent = ti; |
| sc2->tinst = ti; |
| sc2->minst = sc->minst; |
| |
| fd = doHeaderInstantiation(ti, sc2, fd, tthis, fargs); |
| |
| sc2 = sc2->pop(); |
| sc2 = sc2->pop(); |
| |
| if (!fd) |
| goto Lnomatch; |
| } |
| |
| if (constraint) |
| { |
| if (!evaluateConstraint(ti, sc, paramscope, dedargs, fd)) |
| goto Lnomatch; |
| } |
| |
| paramscope->pop(); |
| //printf("\tmatch %d\n", match); |
| return (MATCH)(match | (matchTiargs<<4)); |
| |
| Lnomatch: |
| paramscope->pop(); |
| //printf("\tnomatch\n"); |
| return MATCHnomatch; |
| |
| Lerror: // todo: for the future improvement |
| paramscope->pop(); |
| //printf("\terror\n"); |
| return MATCHnomatch; |
| } |
| |
| /************************************************** |
| * Declare template parameter tp with value o, and install it in the scope sc. |
| */ |
| |
| RootObject *TemplateDeclaration::declareParameter(Scope *sc, TemplateParameter *tp, RootObject *o) |
| { |
| //printf("TemplateDeclaration::declareParameter('%s', o = %p)\n", tp->ident->toChars(), o); |
| |
| Type *ta = isType(o); |
| Expression *ea = isExpression(o); |
| Dsymbol *sa = isDsymbol(o); |
| Tuple *va = isTuple(o); |
| |
| Declaration *d; |
| VarDeclaration *v = NULL; |
| |
| if (ea && ea->op == TOKtype) |
| ta = ea->type; |
| else if (ea && ea->op == TOKscope) |
| sa = ((ScopeExp *)ea)->sds; |
| else if (ea && (ea->op == TOKthis || ea->op == TOKsuper)) |
| sa = ((ThisExp *)ea)->var; |
| else if (ea && ea->op == TOKfunction) |
| { |
| if (((FuncExp *)ea)->td) |
| sa = ((FuncExp *)ea)->td; |
| else |
| sa = ((FuncExp *)ea)->fd; |
| } |
| |
| if (ta) |
| { |
| //printf("type %s\n", ta->toChars()); |
| d = new AliasDeclaration(Loc(), tp->ident, ta); |
| } |
| else if (sa) |
| { |
| //printf("Alias %s %s;\n", sa->ident->toChars(), tp->ident->toChars()); |
| d = new AliasDeclaration(Loc(), tp->ident, sa); |
| } |
| else if (ea) |
| { |
| // tdtypes.data[i] always matches ea here |
| Initializer *init = new ExpInitializer(loc, ea); |
| TemplateValueParameter *tvp = tp->isTemplateValueParameter(); |
| |
| Type *t = tvp ? tvp->valType : NULL; |
| |
| v = new VarDeclaration(loc, t, tp->ident, init); |
| v->storage_class = STCmanifest | STCtemplateparameter; |
| d = v; |
| } |
| else if (va) |
| { |
| //printf("\ttuple\n"); |
| d = new TupleDeclaration(loc, tp->ident, &va->objects); |
| } |
| else |
| { |
| assert(0); |
| } |
| |
| d->storage_class |= STCtemplateparameter; |
| if (ta) |
| { |
| Type *t = ta; |
| // consistent with Type::checkDeprecated() |
| while (t->ty != Tenum) |
| { |
| if (!t->nextOf()) break; |
| t = ((TypeNext *)t)->next; |
| } |
| if (Dsymbol *s = t->toDsymbol(sc)) |
| { |
| if (s->isDeprecated()) |
| d->storage_class |= STCdeprecated; |
| } |
| } |
| else if (sa) |
| { |
| if (sa->isDeprecated()) |
| d->storage_class |= STCdeprecated; |
| } |
| |
| if (!sc->insert(d)) |
| error("declaration %s is already defined", tp->ident->toChars()); |
| dsymbolSemantic(d, sc); |
| |
| /* So the caller's o gets updated with the result of semantic() being run on o |
| */ |
| if (v) |
| o = initializerToExpression(v->_init); |
| return o; |
| } |
| |
| /************************************** |
| * Determine if TemplateDeclaration is variadic. |
| */ |
| |
| TemplateTupleParameter *isVariadic(TemplateParameters *parameters) |
| { |
| size_t dim = parameters->length; |
| TemplateTupleParameter *tp = NULL; |
| |
| if (dim) |
| tp = ((*parameters)[dim - 1])->isTemplateTupleParameter(); |
| return tp; |
| } |
| |
| TemplateTupleParameter *TemplateDeclaration::isVariadic() |
| { |
| return ::isVariadic(parameters); |
| } |
| |
| /*********************************** |
| * We can overload templates. |
| */ |
| |
| bool TemplateDeclaration::isOverloadable() |
| { |
| return true; |
| } |
| |
| /************************************************* |
| * Given function arguments, figure out which template function |
| * to expand, and return matching result. |
| * Params: |
| * m = matching result |
| * dstart = the root of overloaded function templates |
| * loc = instantiation location |
| * sc = instantiation scope |
| * tiargs = initial list of template arguments |
| * tthis = if !NULL, the 'this' pointer argument |
| * fargs = arguments to function |
| * pMessage = address to store error message, or null |
| */ |
| |
| void functionResolve(Match *m, Dsymbol *dstart, Loc loc, Scope *sc, |
| Objects *tiargs, Type *tthis, Expressions *fargs, const char **pMessage) |
| { |
| struct ParamDeduce |
| { |
| // context |
| Loc loc; |
| Scope *sc; |
| Type *tthis; |
| Objects *tiargs; |
| Expressions *fargs; |
| const char **pMessage; |
| // result |
| Match *m; |
| int property; // 0: unintialized |
| // 1: seen @property |
| // 2: not @property |
| size_t ov_index; |
| TemplateDeclaration *td_best; |
| TemplateInstance *ti_best; |
| MATCH ta_last; |
| Type *tthis_best; |
| |
| static int fp(void *param, Dsymbol *s) |
| { |
| if (s->errors) |
| return 0; |
| if (FuncDeclaration *fd = s->isFuncDeclaration()) |
| return ((ParamDeduce *)param)->applyFunction(fd); |
| if (TemplateDeclaration *td = s->isTemplateDeclaration()) |
| return ((ParamDeduce *)param)->applyTemplate(td); |
| return 0; |
| } |
| |
| int applyFunction(FuncDeclaration *fd) |
| { |
| // skip duplicates |
| if (fd == m->lastf) |
| return 0; |
| // explicitly specified tiargs never match to non template function |
| if (tiargs && tiargs->length > 0) |
| return 0; |
| |
| // constructors need a valid scope in order to detect semantic errors |
| if (!fd->isCtorDeclaration() && |
| fd->semanticRun < PASSsemanticdone) |
| { |
| Ungag ungag = fd->ungagSpeculative(); |
| dsymbolSemantic(fd, NULL); |
| } |
| if (fd->semanticRun < PASSsemanticdone) |
| { |
| ::error(loc, "forward reference to template %s", fd->toChars()); |
| return 1; |
| } |
| //printf("fd = %s %s, fargs = %s\n", fd->toChars(), fd->type->toChars(), fargs->toChars()); |
| m->anyf = fd; |
| TypeFunction *tf = (TypeFunction *)fd->type; |
| |
| int prop = (tf->isproperty) ? 1 : 2; |
| if (property == 0) |
| property = prop; |
| else if (property != prop) |
| error(fd->loc, "cannot overload both property and non-property functions"); |
| |
| /* For constructors, qualifier check will be opposite direction. |
| * Qualified constructor always makes qualified object, then will be checked |
| * that it is implicitly convertible to tthis. |
| */ |
| Type *tthis_fd = fd->needThis() ? tthis : NULL; |
| bool isCtorCall = tthis_fd && fd->isCtorDeclaration(); |
| if (isCtorCall) |
| { |
| //printf("%s tf->mod = x%x tthis_fd->mod = x%x %d\n", tf->toChars(), |
| // tf->mod, tthis_fd->mod, fd->isolateReturn()); |
| if (MODimplicitConv(tf->mod, tthis_fd->mod) || |
| (tf->isWild() && tf->isShared() == tthis_fd->isShared()) || |
| fd->isolateReturn()) |
| { |
| /* && tf->isShared() == tthis_fd->isShared()*/ |
| // Uniquely constructed object can ignore shared qualifier. |
| // TODO: Is this appropriate? |
| tthis_fd = NULL; |
| } |
| else |
| return 0; // MATCHnomatch |
| } |
| MATCH mfa = tf->callMatch(tthis_fd, fargs, 0, pMessage); |
| //printf("test1: mfa = %d\n", mfa); |
| if (mfa > MATCHnomatch) |
| { |
| if (mfa > m->last) goto LfIsBetter; |
| if (mfa < m->last) goto LlastIsBetter; |
| |
| /* See if one of the matches overrides the other. |
| */ |
| assert(m->lastf); |
| if (m->lastf->overrides(fd)) goto LlastIsBetter; |
| if (fd->overrides(m->lastf)) goto LfIsBetter; |
| |
| /* Try to disambiguate using template-style partial ordering rules. |
| * In essence, if f() and g() are ambiguous, if f() can call g(), |
| * but g() cannot call f(), then pick f(). |
| * This is because f() is "more specialized." |
| */ |
| { |
| MATCH c1 = fd->leastAsSpecialized(m->lastf); |
| MATCH c2 = m->lastf->leastAsSpecialized(fd); |
| //printf("c1 = %d, c2 = %d\n", c1, c2); |
| if (c1 > c2) goto LfIsBetter; |
| if (c1 < c2) goto LlastIsBetter; |
| } |
| |
| /* The 'overrides' check above does covariant checking only |
| * for virtual member functions. It should do it for all functions, |
| * but in order to not risk breaking code we put it after |
| * the 'leastAsSpecialized' check. |
| * In the future try moving it before. |
| * I.e. a not-the-same-but-covariant match is preferred, |
| * as it is more restrictive. |
| */ |
| if (!m->lastf->type->equals(fd->type)) |
| { |
| //printf("cov: %d %d\n", m->lastf->type->covariant(fd->type), fd->type->covariant(m->lastf->type)); |
| if (m->lastf->type->covariant(fd->type) == 1) goto LlastIsBetter; |
| if (fd->type->covariant(m->lastf->type) == 1) goto LfIsBetter; |
| } |
| |
| /* If the two functions are the same function, like: |
| * int foo(int); |
| * int foo(int x) { ... } |
| * then pick the one with the body. |
| */ |
| if (tf->equals(m->lastf->type) && |
| fd->storage_class == m->lastf->storage_class && |
| fd->parent == m->lastf->parent && |
| fd->protection == m->lastf->protection && |
| fd->linkage == m->lastf->linkage) |
| { |
| if ( fd->fbody && !m->lastf->fbody) goto LfIsBetter; |
| if (!fd->fbody && m->lastf->fbody) goto LlastIsBetter; |
| } |
| |
| // Bugzilla 14450: Prefer exact qualified constructor for the creating object type |
| if (isCtorCall && tf->mod != m->lastf->type->mod) |
| { |
| if (tthis->mod == tf->mod) goto LfIsBetter; |
| if (tthis->mod == m->lastf->type->mod) goto LlastIsBetter; |
| } |
| |
| m->nextf = fd; |
| m->count++; |
| return 0; |
| |
| LlastIsBetter: |
| return 0; |
| |
| LfIsBetter: |
| td_best = NULL; |
| ti_best = NULL; |
| ta_last = MATCHexact; |
| m->last = mfa; |
| m->lastf = fd; |
| tthis_best = tthis_fd; |
| ov_index = 0; |
| m->count = 1; |
| return 0; |
| } |
| return 0; |
| } |
| |
| int applyTemplate(TemplateDeclaration *td) |
| { |
| //printf("applyTemplate()\n"); |
| if (td->inuse) |
| { |
| td->error(loc, "recursive template expansion"); |
| return 1; |
| } |
| if (td == td_best) // skip duplicates |
| return 0; |
| |
| if (!sc) |
| sc = td->_scope; // workaround for Type::aliasthisOf |
| |
| if (td->semanticRun == PASSinit && td->_scope) |
| { |
| // Try to fix forward reference. Ungag errors while doing so. |
| Ungag ungag = td->ungagSpeculative(); |
| dsymbolSemantic(td, td->_scope); |
| } |
| if (td->semanticRun == PASSinit) |
| { |
| ::error(loc, "forward reference to template %s", td->toChars()); |
| Lerror: |
| m->lastf = NULL; |
| m->count = 0; |
| m->last = MATCHnomatch; |
| return 1; |
| } |
| //printf("td = %s\n", td->toChars()); |
| |
| FuncDeclaration *f; |
| f = td->onemember ? td->onemember->isFuncDeclaration() : NULL; |
| if (!f) |
| { |
| if (!tiargs) |
| tiargs = new Objects(); |
| TemplateInstance *ti = new TemplateInstance(loc, td, tiargs); |
| Objects dedtypes; |
| dedtypes.setDim(td->parameters->length); |
| assert(td->semanticRun != PASSinit); |
| MATCH mta = td->matchWithInstance(sc, ti, &dedtypes, fargs, 0); |
| //printf("matchWithInstance = %d\n", mta); |
| if (mta <= MATCHnomatch || mta < ta_last) // no match or less match |
| return 0; |
| |
| templateInstanceSemantic(ti, sc, fargs); |
| if (!ti->inst) // if template failed to expand |
| return 0; |
| |
| Dsymbol *s = ti->inst->toAlias(); |
| FuncDeclaration *fd; |
| if (TemplateDeclaration *tdx = s->isTemplateDeclaration()) |
| { |
| Objects dedtypesX; // empty tiargs |
| |
| // Bugzilla 11553: Check for recursive instantiation of tdx. |
| for (TemplatePrevious *p = tdx->previous; p; p = p->prev) |
| { |
| if (arrayObjectMatch(p->dedargs, &dedtypesX)) |
| { |
| //printf("recursive, no match p->sc=%p %p %s\n", p->sc, this, this->toChars()); |
| /* It must be a subscope of p->sc, other scope chains are not recursive |
| * instantiations. |
| */ |
| for (Scope *scx = sc; scx; scx = scx->enclosing) |
| { |
| if (scx == p->sc) |
| { |
| error(loc, "recursive template expansion while looking for %s.%s", ti->toChars(), tdx->toChars()); |
| goto Lerror; |
| } |
| } |
| } |
| /* BUG: should also check for ref param differences |
| */ |
| } |
| |
| TemplatePrevious pr; |
| pr.prev = tdx->previous; |
| pr.sc = sc; |
| pr.dedargs = &dedtypesX; |
| tdx->previous = ≺ // add this to threaded list |
| |
| fd = resolveFuncCall(loc, sc, s, NULL, tthis, fargs, 1); |
| |
| tdx->previous = pr.prev; // unlink from threaded list |
| } |
| else if (s->isFuncDeclaration()) |
| { |
| fd = resolveFuncCall(loc, sc, s, NULL, tthis, fargs, 1); |
| } |
| else |
| goto Lerror; |
| |
| if (!fd) |
| return 0; |
| |
| if (fd->type->ty != Tfunction) |
| { |
| m->lastf = fd; // to propagate "error match" |
| m->count = 1; |
| m->last = MATCHnomatch; |
| return 1; |
| } |
| |
| Type *tthis_fd = fd->needThis() && !fd->isCtorDeclaration() ? tthis : NULL; |
| |
| TypeFunction *tf = (TypeFunction *)fd->type; |
| MATCH mfa = tf->callMatch(tthis_fd, fargs); |
| if (mfa < m->last) |
| return 0; |
| |
| if (mta < ta_last) goto Ltd_best2; |
| if (mta > ta_last) goto Ltd2; |
| |
| if (mfa < m->last) goto Ltd_best2; |
| if (mfa > m->last) goto Ltd2; |
| |
| //printf("Lambig2\n"); |
| m->nextf = fd; |
| m->count++; |
| return 0; |
| |
| Ltd_best2: |
| return 0; |
| |
| Ltd2: |
| // td is the new best match |
| assert(td->_scope); |
| td_best = td; |
| ti_best = NULL; |
| property = 0; // (backward compatibility) |
| ta_last = mta; |
| m->last = mfa; |
| m->lastf = fd; |
| tthis_best = tthis_fd; |
| ov_index = 0; |
| m->nextf = NULL; |
| m->count = 1; |
| return 0; |
| } |
| |
| //printf("td = %s\n", td->toChars()); |
| for (size_t ovi = 0; f; f = f->overnext0, ovi++) |
| { |
| if (f->type->ty != Tfunction || f->errors) |
| goto Lerror; |
| |
| /* This is a 'dummy' instance to evaluate constraint properly. |
| */ |
| TemplateInstance *ti = new TemplateInstance(loc, td, tiargs); |
| ti->parent = td->parent; // Maybe calculating valid 'enclosing' is unnecessary. |
| |
| FuncDeclaration *fd = f; |
| int x = td->deduceFunctionTemplateMatch(ti, sc, fd, tthis, fargs); |
| MATCH mta = (MATCH)(x >> 4); |
| MATCH mfa = (MATCH)(x & 0xF); |
| //printf("match:t/f = %d/%d\n", mta, mfa); |
| if (!fd || mfa == MATCHnomatch) |
| continue; |
| |
| Type *tthis_fd = fd->needThis() ? tthis : NULL; |
| |
| bool isCtorCall = tthis_fd && fd->isCtorDeclaration(); |
| if (isCtorCall) |
| { |
| // Constructor call requires additional check. |
| |
| TypeFunction *tf = (TypeFunction *)fd->type; |
| assert(tf->next); |
| if (MODimplicitConv(tf->mod, tthis_fd->mod) || |
| (tf->isWild() && tf->isShared() == tthis_fd->isShared()) || |
| fd->isolateReturn()) |
| { |
| tthis_fd = NULL; |
| } |
| else |
| continue; // MATCHnomatch |
| } |
| |
| if (mta < ta_last) goto Ltd_best; |
| if (mta > ta_last) goto Ltd; |
| |
| if (mfa < m->last) goto Ltd_best; |
| if (mfa > m->last) goto Ltd; |
| |
| if (td_best) |
| { |
| // Disambiguate by picking the most specialized TemplateDeclaration |
| MATCH c1 = td->leastAsSpecialized(sc, td_best, fargs); |
| MATCH c2 = td_best->leastAsSpecialized(sc, td, fargs); |
| //printf("1: c1 = %d, c2 = %d\n", c1, c2); |
| if (c1 > c2) goto Ltd; |
| if (c1 < c2) goto Ltd_best; |
| } |
| assert(fd && m->lastf); |
| { |
| // Disambiguate by tf->callMatch |
| TypeFunction *tf1 = (TypeFunction *)fd->type; |
| assert(tf1->ty == Tfunction); |
| TypeFunction *tf2 = (TypeFunction *)m->lastf->type; |
| assert(tf2->ty == Tfunction); |
| MATCH c1 = tf1->callMatch(tthis_fd, fargs); |
| MATCH c2 = tf2->callMatch(tthis_best, fargs); |
| //printf("2: c1 = %d, c2 = %d\n", c1, c2); |
| if (c1 > c2) goto Ltd; |
| if (c1 < c2) goto Ltd_best; |
| } |
| { |
| // Disambiguate by picking the most specialized FunctionDeclaration |
| MATCH c1 = fd->leastAsSpecialized(m->lastf); |
| MATCH c2 = m->lastf->leastAsSpecialized(fd); |
| //printf("3: c1 = %d, c2 = %d\n", c1, c2); |
| if (c1 > c2) goto Ltd; |
| if (c1 < c2) goto Ltd_best; |
| } |
| |
| // Bugzilla 14450: Prefer exact qualified constructor for the creating object type |
| if (isCtorCall && fd->type->mod != m->lastf->type->mod) |
| { |
| if (tthis->mod == fd->type->mod) goto Ltd; |
| if (tthis->mod == m->lastf->type->mod) goto Ltd_best; |
| } |
| |
| m->nextf = fd; |
| m->count++; |
| continue; |
| |
| Ltd_best: // td_best is the best match so far |
| //printf("Ltd_best\n"); |
| continue; |
| |
| Ltd: // td is the new best match |
| //printf("Ltd\n"); |
| assert(td->_scope); |
| td_best = td; |
| ti_best = ti; |
| property = 0; // (backward compatibility) |
| ta_last = mta; |
| m->last = mfa; |
| m->lastf = fd; |
| tthis_best = tthis_fd; |
| ov_index = ovi; |
| m->nextf = NULL; |
| m->count = 1; |
| continue; |
| } |
| return 0; |
| } |
| }; |
| ParamDeduce p; |
| // context |
| p.loc = loc; |
| p.sc = sc; |
| p.tthis = tthis; |
| p.tiargs = tiargs; |
| p.fargs = fargs; |
| p.pMessage = pMessage; |
| |
| // result |
| p.m = m; |
| p.property = 0; |
| p.ov_index = 0; |
| p.td_best = NULL; |
| p.ti_best = NULL; |
| p.ta_last = m->last != MATCHnomatch ? MATCHexact : MATCHnomatch; |
| p.tthis_best = NULL; |
| |
| TemplateDeclaration *td = dstart->isTemplateDeclaration(); |
| if (td && td->funcroot) |
| dstart = td->funcroot; |
| |
| overloadApply(dstart, &p, &ParamDeduce::fp); |
| |
| //printf("td_best = %p, m->lastf = %p\n", p.td_best, m->lastf); |
| if (p.td_best && p.ti_best && m->count == 1) |
| { |
| // Matches to template function |
| assert(p.td_best->onemember && p.td_best->onemember->isFuncDeclaration()); |
| |
| /* The best match is td_best with arguments tdargs. |
| * Now instantiate the template. |
| */ |
| assert(p.td_best->_scope); |
| if (!sc) |
| sc = p.td_best->_scope; // workaround for Type::aliasthisOf |
| |
| TemplateInstance *ti = new TemplateInstance(loc, p.td_best, p.ti_best->tiargs); |
| templateInstanceSemantic(ti, sc, fargs); |
| |
| m->lastf = ti->toAlias()->isFuncDeclaration(); |
| if (!m->lastf) |
| goto Lnomatch; |
| if (ti->errors) |
| { |
| Lerror: |
| m->count = 1; |
| assert(m->lastf); |
| m->last = MATCHnomatch; |
| return; |
| } |
| |
| // look forward instantiated overload function |
| // Dsymbol::oneMembers is alredy called in TemplateInstance::semantic. |
| // it has filled overnext0d |
| while (p.ov_index--) |
| { |
| m->lastf = m->lastf->overnext0; |
| assert(m->lastf); |
| } |
| |
| p.tthis_best = m->lastf->needThis() && !m->lastf->isCtorDeclaration() ? tthis : NULL; |
| |
| TypeFunction *tf = (TypeFunction *)m->lastf->type; |
| if (tf->ty == Terror) |
| goto Lerror; |
| assert(tf->ty == Tfunction); |
| if (!tf->callMatch(p.tthis_best, fargs)) |
| goto Lnomatch; |
| |
| /* As Bugzilla 3682 shows, a template instance can be matched while instantiating |
| * that same template. Thus, the function type can be incomplete. Complete it. |
| * |
| * Bugzilla 9208: For auto function, completion should be deferred to the end of |
| * its semantic3. Should not complete it in here. |
| */ |
| if (tf->next && !m->lastf->inferRetType) |
| { |
| m->lastf->type = typeSemantic(tf, loc, sc); |
| } |
| } |
| else if (m->lastf) |
| { |
| // Matches to non template function, |
| // or found matches were ambiguous. |
| assert(m->count >= 1); |
| } |
| else |
| { |
| Lnomatch: |
| m->count = 0; |
| m->lastf = NULL; |
| m->last = MATCHnomatch; |
| } |
| } |
| |
| /************************************************* |
| * Limited function template instantiation for using fd->leastAsSpecialized() |
| */ |
| FuncDeclaration *TemplateDeclaration::doHeaderInstantiation( |
| TemplateInstance *ti, Scope *sc2, |
| FuncDeclaration *fd, Type *tthis, Expressions *fargs) |
| { |
| assert(fd); |
| |
| // function body and contracts are not need |
| if (fd->isCtorDeclaration()) |
| fd = new CtorDeclaration(fd->loc, fd->endloc, fd->storage_class, fd->type->syntaxCopy()); |
| else |
| fd = new FuncDeclaration(fd->loc, fd->endloc, fd->ident, fd->storage_class, fd->type->syntaxCopy()); |
| fd->parent = ti; |
| |
| assert(fd->type->ty == Tfunction); |
| TypeFunction *tf = (TypeFunction *)fd->type; |
| tf->fargs = fargs; |
| |
| if (tthis) |
| { |
| // Match 'tthis' to any TemplateThisParameter's |
| bool hasttp = false; |
| for (size_t i = 0; i < parameters->length; i++) |
| { |
| TemplateParameter *tp = (*parameters)[i]; |
| TemplateThisParameter *ttp = tp->isTemplateThisParameter(); |
| if (ttp) |
| hasttp = true; |
| } |
| if (hasttp) |
| { |
| tf = (TypeFunction *)tf->addSTC(ModToStc(tthis->mod)); |
| assert(!tf->deco); |
| } |
| } |
| |
| Scope *scx = sc2->push(); |
| |
| // Shouldn't run semantic on default arguments and return type. |
| for (size_t i = 0; i < tf->parameterList.parameters->length; i++) |
| (*tf->parameterList.parameters)[i]->defaultArg = NULL; |
| if (fd->isCtorDeclaration()) |
| { |
| // For constructors, emitting return type is necessary for |
| // isolateReturn() in functionResolve. |
| scx->flags |= SCOPEctor; |
| |
| Dsymbol *parent = toParent2(); |
| Type *tret; |
| AggregateDeclaration *ad = parent->isAggregateDeclaration(); |
| if (!ad || parent->isUnionDeclaration()) |
| { |
| tret = Type::tvoid; |
| } |
| else |
| { |
| tret = ad->handleType(); |
| assert(tret); |
| tret = tret->addStorageClass(fd->storage_class | scx->stc); |
| tret = tret->addMod(tf->mod); |
| } |
| tf->next = tret; |
| if (ad && ad->isStructDeclaration()) |
| tf->isref = 1; |
| //printf("tf = %s\n", tf->toChars()); |
| } |
| else |
| tf->next = NULL; |
| fd->type = tf; |
| fd->type = fd->type->addSTC(scx->stc); |
| fd->type = typeSemantic(fd->type, fd->loc, scx); |
| scx = scx->pop(); |
| |
| if (fd->type->ty != Tfunction) |
| return NULL; |
| |
| fd->originalType = fd->type; // for mangling |
| //printf("\t[%s] fd->type = %s, mod = %x, ", loc.toChars(), fd->type->toChars(), fd->type->mod); |
| //printf("fd->needThis() = %d\n", fd->needThis()); |
| |
| return fd; |
| } |
| |
| bool TemplateDeclaration::hasStaticCtorOrDtor() |
| { |
| return false; // don't scan uninstantiated templates |
| } |
| |
| const char *TemplateDeclaration::toChars() |
| { |
| if (literal) |
| return Dsymbol::toChars(); |
| |
| OutBuffer buf; |
| HdrGenState hgs; |
| |
| buf.writestring(ident->toChars()); |
| buf.writeByte('('); |
| for (size_t i = 0; i < parameters->length; i++) |
| { |
| TemplateParameter *tp = (*parameters)[i]; |
| if (i) |
| buf.writestring(", "); |
| ::toCBuffer(tp, &buf, &hgs); |
| } |
| buf.writeByte(')'); |
| |
| if (onemember) |
| { |
| FuncDeclaration *fd = onemember->isFuncDeclaration(); |
| if (fd && fd->type) |
| { |
| TypeFunction *tf = (TypeFunction *)fd->type; |
| buf.writestring(parametersTypeToChars(tf->parameterList)); |
| } |
| } |
| |
| if (constraint) |
| { |
| buf.writestring(" if ("); |
| ::toCBuffer(constraint, &buf, &hgs); |
| buf.writeByte(')'); |
| } |
| return buf.extractChars(); |
| } |
| |
| Prot TemplateDeclaration::prot() |
| { |
| return protection; |
| } |
| |
| /**************************************************** |
| * Given a new instance tithis of this TemplateDeclaration, |
| * see if there already exists an instance. |
| * If so, return that existing instance. |
| */ |
| |
| TemplateInstance *TemplateDeclaration::findExistingInstance(TemplateInstance *tithis, Expressions *fargs) |
| { |
| //printf("findExistingInstance(%p)\n", tithis); |
| tithis->fargs = fargs; |
| TemplateInstances *tinstances = (TemplateInstances *)dmd_aaGetRvalue((AA *)instances, (void *)tithis->toHash()); |
| if (tinstances) |
| { |
| for (size_t i = 0; i < tinstances->length; i++) |
| { |
| TemplateInstance *ti = (*tinstances)[i]; |
| if (tithis->compare(ti) == 0) |
| return ti; |
| } |
| } |
| return NULL; |
| } |
| |
| /******************************************** |
| * Add instance ti to TemplateDeclaration's table of instances. |
| * Return a handle we can use to later remove it if it fails instantiation. |
| */ |
| |
| TemplateInstance *TemplateDeclaration::addInstance(TemplateInstance *ti) |
| { |
| //printf("addInstance() %p %p\n", instances, ti); |
| TemplateInstances **ptinstances = (TemplateInstances **)dmd_aaGet((AA **)&instances, (void *)ti->toHash()); |
| if (!*ptinstances) |
| *ptinstances = new TemplateInstances(); |
| (*ptinstances)->push(ti); |
| return ti; |
| } |
| |
| /******************************************* |
| * Remove TemplateInstance from table of instances. |
| * Input: |
| * handle returned by addInstance() |
| */ |
| |
| void TemplateDeclaration::removeInstance(TemplateInstance *handle) |
| { |
| //printf("removeInstance()\n"); |
| TemplateInstances *tinstances = (TemplateInstances *)dmd_aaGetRvalue((AA *)instances, (void *)handle->toHash()); |
| if (tinstances) |
| { |
| for (size_t i = 0; i < tinstances->length; i++) |
| { |
| TemplateInstance *ti = (*tinstances)[i]; |
| if (handle == ti) |
| { |
| tinstances->remove(i); |
| break; |
| } |
| } |
| } |
| } |
| |
| /* ======================== Type ============================================ */ |
| |
| /**** |
| * Given an identifier, figure out which TemplateParameter it is. |
| * Return IDX_NOTFOUND if not found. |
| */ |
| |
| static size_t templateIdentifierLookup(Identifier *id, TemplateParameters *parameters) |
| { |
| for (size_t i = 0; i < parameters->length; i++) |
| { |
| TemplateParameter *tp = (*parameters)[i]; |
| if (tp->ident->equals(id)) |
| return i; |
| } |
| return IDX_NOTFOUND; |
| } |
| |
| size_t templateParameterLookup(Type *tparam, TemplateParameters *parameters) |
| { |
| if (tparam->ty == Tident) |
| { |
| TypeIdentifier *tident = (TypeIdentifier *)tparam; |
| //printf("\ttident = '%s'\n", tident->toChars()); |
| return templateIdentifierLookup(tident->ident, parameters); |
| } |
| return IDX_NOTFOUND; |
| } |
| |
| unsigned char deduceWildHelper(Type *t, Type **at, Type *tparam) |
| { |
| if ((tparam->mod & MODwild) == 0) |
| return 0; |
| |
| *at = NULL; |
| |
| #define X(U,T) ((U) << 4) | (T) |
| switch (X(tparam->mod, t->mod)) |
| { |
| case X(MODwild, 0): |
| case X(MODwild, MODconst): |
| case X(MODwild, MODshared): |
| case X(MODwild, MODshared | MODconst): |
| case X(MODwild, MODimmutable): |
| case X(MODwildconst, 0): |
| case X(MODwildconst, MODconst): |
| case X(MODwildconst, MODshared): |
| case X(MODwildconst, MODshared | MODconst): |
| case X(MODwildconst, MODimmutable): |
| case X(MODshared | MODwild, MODshared): |
| case X(MODshared | MODwild, MODshared | MODconst): |
| case X(MODshared | MODwild, MODimmutable): |
| case X(MODshared | MODwildconst, MODshared): |
| case X(MODshared | MODwildconst, MODshared | MODconst): |
| case X(MODshared | MODwildconst, MODimmutable): |
| { |
| unsigned char wm = (t->mod & ~MODshared); |
| if (wm == 0) |
| wm = MODmutable; |
| unsigned char m = (t->mod & (MODconst | MODimmutable)) | (tparam->mod & t->mod & MODshared); |
| *at = t->unqualify(m); |
| return wm; |
| } |
| |
| case X(MODwild, MODwild): |
| case X(MODwild, MODwildconst): |
| case X(MODwild, MODshared | MODwild): |
| case X(MODwild, MODshared | MODwildconst): |
| case X(MODwildconst, MODwild): |
| case X(MODwildconst, MODwildconst): |
| case X(MODwildconst, MODshared | MODwild): |
| case X(MODwildconst, MODshared | MODwildconst): |
| case X(MODshared | MODwild, MODshared | MODwild): |
| case X(MODshared | MODwild, MODshared | MODwildconst): |
| case X(MODshared | MODwildconst, MODshared | MODwild): |
| case X(MODshared | MODwildconst, MODshared | MODwildconst): |
| { |
| *at = t->unqualify(tparam->mod & t->mod); |
| return MODwild; |
| } |
| |
| default: |
| return 0; |
| } |
| #undef X |
| } |
| |
| MATCH deduceTypeHelper(Type *t, Type **at, Type *tparam) |
| { |
| // 9*9 == 81 cases |
| |
| #define X(U,T) ((U) << 4) | (T) |
| switch (X(tparam->mod, t->mod)) |
| { |
| case X(0, 0): |
| case X(0, MODconst): |
| case X(0, MODwild): |
| case X(0, MODwildconst): |
| case X(0, MODshared): |
| case X(0, MODshared | MODconst): |
| case X(0, MODshared | MODwild): |
| case X(0, MODshared | MODwildconst): |
| case X(0, MODimmutable): |
| // foo(U) T => T |
| // foo(U) const(T) => const(T) |
| // foo(U) inout(T) => inout(T) |
| // foo(U) inout(const(T)) => inout(const(T)) |
| // foo(U) shared(T) => shared(T) |
| // foo(U) shared(const(T)) => shared(const(T)) |
| // foo(U) shared(inout(T)) => shared(inout(T)) |
| // foo(U) shared(inout(const(T))) => shared(inout(const(T))) |
| // foo(U) immutable(T) => immutable(T) |
| { |
| *at = t; |
| return MATCHexact; |
| } |
| |
| case X(MODconst, MODconst): |
| case X(MODwild, MODwild): |
| case X(MODwildconst, MODwildconst): |
| case X(MODshared, MODshared): |
| case X(MODshared | MODconst, MODshared | MODconst): |
| case X(MODshared | MODwild, MODshared | MODwild): |
| case X(MODshared | MODwildconst, MODshared | MODwildconst): |
| case X(MODimmutable, MODimmutable): |
| // foo(const(U)) const(T) => T |
| // foo(inout(U)) inout(T) => T |
| // foo(inout(const(U))) inout(const(T)) => T |
| // foo(shared(U)) shared(T) => T |
| // foo(shared(const(U))) shared(const(T)) => T |
| // foo(shared(inout(U))) shared(inout(T)) => T |
| // foo(shared(inout(const(U)))) shared(inout(const(T))) => T |
| // foo(immutable(U)) immutable(T) => T |
| { |
| *at = t->mutableOf()->unSharedOf(); |
| return MATCHexact; |
| } |
| |
| case X(MODconst, 0): |
| case X(MODconst, MODwild): |
| case X(MODconst, MODwildconst): |
| case X(MODconst, MODshared | MODconst): |
| case X(MODconst, MODshared | MODwild): |
| case X(MODconst, MODshared | MODwildconst): |
| case X(MODconst, MODimmutable): |
| case X(MODwild, MODshared | MODwild): |
| case X(MODwildconst, MODshared | MODwildconst): |
| case X(MODshared | MODconst, MODimmutable): |
| // foo(const(U)) T => T |
| // foo(const(U)) inout(T) => T |
| // foo(const(U)) inout(const(T)) => T |
| // foo(const(U)) shared(const(T)) => shared(T) |
| // foo(const(U)) shared(inout(T)) => shared(T) |
| // foo(const(U)) shared(inout(const(T))) => shared(T) |
| // foo(const(U)) immutable(T) => T |
| // foo(inout(U)) shared(inout(T)) => shared(T) |
| // foo(inout(const(U))) shared(inout(const(T))) => shared(T) |
| // foo(shared(const(U))) immutable(T) => T |
| { |
| *at = t->mutableOf(); |
| return MATCHconst; |
| } |
| |
| case X(MODconst, MODshared): |
| // foo(const(U)) shared(T) => shared(T) |
| { |
| *at = t; |
| return MATCHconst; |
| } |
| |
| case X(MODshared, MODshared | MODconst): |
| case X(MODshared, MODshared | MODwild): |
| case X(MODshared, MODshared | MODwildconst): |
| case X(MODshared | MODconst, MODshared): |
| // foo(shared(U)) shared(const(T)) => const(T) |
| // foo(shared(U)) shared(inout(T)) => inout(T) |
| // foo(shared(U)) shared(inout(const(T))) => inout(const(T)) |
| // foo(shared(const(U))) shared(T) => T |
| { |
| *at = t->unSharedOf(); |
| return MATCHconst; |
| } |
| |
| case X(MODwildconst, MODimmutable): |
| case X(MODshared | MODconst, MODshared | MODwildconst): |
| case X(MODshared | MODwildconst, MODimmutable): |
| case X(MODshared | MODwildconst, MODshared | MODwild): |
| // foo(inout(const(U))) immutable(T) => T |
| // foo(shared(const(U))) shared(inout(const(T))) => T |
| // foo(shared(inout(const(U)))) immutable(T) => T |
| // foo(shared(inout(const(U)))) shared(inout(T)) => T |
| { |
| *at = t->unSharedOf()->mutableOf(); |
| return MATCHconst; |
| } |
| |
| case X(MODshared | MODconst, MODshared | MODwild): |
| // foo(shared(const(U))) shared(inout(T)) => T |
| { |
| *at = t->unSharedOf()->mutableOf(); |
| return MATCHconst; |
| } |
| |
| case X(MODwild, 0): |
| case X(MODwild, MODconst): |
| case X(MODwild, MODwildconst): |
| case X(MODwild, MODimmutable): |
| case X(MODwild, MODshared): |
| case X(MODwild, MODshared | MODconst): |
| case X(MODwild, MODshared | MODwildconst): |
| case X(MODwildconst, 0): |
| case X(MODwildconst, MODconst): |
| case X(MODwildconst, MODwild): |
| case X(MODwildconst, MODshared): |
| case X(MODwildconst, MODshared | MODconst): |
| case X(MODwildconst, MODshared | MODwild): |
| case X(MODshared, 0): |
| case X(MODshared, MODconst): |
| case X(MODshared, MODwild): |
| case X(MODshared, MODwildconst): |
| case X(MODshared, MODimmutable): |
| case X(MODshared | MODconst, 0): |
| case X(MODshared | MODconst, MODconst): |
| case X(MODshared | MODconst, MODwild): |
| case X(MODshared | MODconst, MODwildconst): |
| case X(MODshared | MODwild, 0): |
| case X(MODshared | MODwild, MODconst): |
| case X(MODshared | MODwild, MODwild): |
| case X(MODshared | MODwild, MODwildconst): |
| case X(MODshared | MODwild, MODimmutable): |
| case X(MODshared | MODwild, MODshared): |
| case X(MODshared | MODwild, MODshared | MODconst): |
| case X(MODshared | MODwild, MODshared | MODwildconst): |
| case X(MODshared | MODwildconst, 0): |
| case X(MODshared | MODwildconst, MODconst): |
| case X(MODshared | MODwildconst, MODwild): |
| case X(MODshared | MODwildconst, MODwildconst): |
| case X(MODshared | MODwildconst, MODshared): |
| case X(MODshared | MODwildconst, MODshared | MODconst): |
| case X(MODimmutable, 0): |
| case X(MODimmutable, MODconst): |
| case X(MODimmutable, MODwild): |
| case X(MODimmutable, MODwildconst): |
| case X(MODimmutable, MODshared): |
| case X(MODimmutable, MODshared | MODconst): |
| case X(MODimmutable, MODshared | MODwild): |
| case X(MODimmutable, MODshared | MODwildconst): |
| // foo(inout(U)) T => nomatch |
| // foo(inout(U)) const(T) => nomatch |
| // foo(inout(U)) inout(const(T)) => nomatch |
| // foo(inout(U)) immutable(T) => nomatch |
| // foo(inout(U)) shared(T) => nomatch |
| // foo(inout(U)) shared(const(T)) => nomatch |
| // foo(inout(U)) shared(inout(const(T))) => nomatch |
| // foo(inout(const(U))) T => nomatch |
| // foo(inout(const(U))) const(T) => nomatch |
| // foo(inout(const(U))) inout(T) => nomatch |
| // foo(inout(const(U))) shared(T) => nomatch |
| // foo(inout(const(U))) shared(const(T)) => nomatch |
| // foo(inout(const(U))) shared(inout(T)) => nomatch |
| // foo(shared(U)) T => nomatch |
| // foo(shared(U)) const(T) => nomatch |
| // foo(shared(U)) inout(T) => nomatch |
| // foo(shared(U)) inout(const(T)) => nomatch |
| // foo(shared(U)) immutable(T) => nomatch |
| // foo(shared(const(U))) T => nomatch |
| // foo(shared(const(U))) const(T) => nomatch |
| // foo(shared(const(U))) inout(T) => nomatch |
| // foo(shared(const(U))) inout(const(T)) => nomatch |
| // foo(shared(inout(U))) T => nomatch |
| // foo(shared(inout(U))) const(T) => nomatch |
| // foo(shared(inout(U))) inout(T) => nomatch |
| // foo(shared(inout(U))) inout(const(T)) => nomatch |
| // foo(shared(inout(U))) immutable(T) => nomatch |
| // foo(shared(inout(U))) shared(T) => nomatch |
| // foo(shared(inout(U))) shared(const(T)) => nomatch |
| // foo(shared(inout(U))) shared(inout(const(T))) => nomatch |
| // foo(shared(inout(const(U)))) T => nomatch |
| // foo(shared(inout(const(U)))) const(T) => nomatch |
| // foo(shared(inout(const(U)))) inout(T) => nomatch |
| // foo(shared(inout(const(U)))) inout(const(T)) => nomatch |
| // foo(shared(inout(const(U)))) shared(T) => nomatch |
| // foo(shared(inout(const(U)))) shared(const(T)) => nomatch |
| // foo(immutable(U)) T => nomatch |
| // foo(immutable(U)) const(T) => nomatch |
| // foo(immutable(U)) inout(T) => nomatch |
| // foo(immutable(U)) inout(const(T)) => nomatch |
| // foo(immutable(U)) shared(T) => nomatch |
| // foo(immutable(U)) shared(const(T)) => nomatch |
| // foo(immutable(U)) shared(inout(T)) => nomatch |
| // foo(immutable(U)) shared(inout(const(T))) => nomatch |
| return MATCHnomatch; |
| |
| default: |
| assert(0); |
| return MATCHnomatch; // silence compiler warning about missing return |
| } |
| #undef X |
| } |
| |
| /* These form the heart of template argument deduction. |
| * Given 'this' being the type argument to the template instance, |
| * it is matched against the template declaration parameter specialization |
| * 'tparam' to determine the type to be used for the parameter. |
| * Example: |
| * template Foo(T:T*) // template declaration |
| * Foo!(int*) // template instantiation |
| * Input: |
| * this = int* |
| * tparam = T* |
| * parameters = [ T:T* ] // Array of TemplateParameter's |
| * Output: |
| * dedtypes = [ int ] // Array of Expression/Type's |
| */ |
| MATCH deduceType(RootObject *o, Scope *sc, Type *tparam, TemplateParameters *parameters, |
| Objects *dedtypes, unsigned *wm, size_t inferStart) |
| { |
| class DeduceType : public Visitor |
| { |
| public: |
| Scope *sc; |
| Type *tparam; |
| TemplateParameters *parameters; |
| Objects *dedtypes; |
| unsigned *wm; |
| size_t inferStart; |
| MATCH result; |
| |
| DeduceType(Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wm, size_t inferStart) |
| : sc(sc), tparam(tparam), parameters(parameters), dedtypes(dedtypes), wm(wm), inferStart(inferStart) |
| { |
| result = MATCHnomatch; |
| } |
| |
| void visit(Type *t) |
| { |
| if (!tparam) |
| goto Lnomatch; |
| |
| if (t == tparam) |
| goto Lexact; |
| |
| if (tparam->ty == Tident) |
| { |
| // Determine which parameter tparam is |
| size_t i = templateParameterLookup(tparam, parameters); |
| if (i == IDX_NOTFOUND) |
| { |
| if (!sc) |
| goto Lnomatch; |
| |
| /* Need a loc to go with the semantic routine. |
| */ |
| Loc loc; |
| if (parameters->length) |
| { |
| TemplateParameter *tp = (*parameters)[0]; |
| loc = tp->loc; |
| } |
| |
| /* BUG: what if tparam is a template instance, that |
| * has as an argument another Tident? |
| */ |
| tparam = typeSemantic(tparam, loc, sc); |
| assert(tparam->ty != Tident); |
| result = deduceType(t, sc, tparam, parameters, dedtypes, wm); |
| return; |
| } |
| |
| TemplateParameter *tp = (*parameters)[i]; |
| |
| TypeIdentifier *tident = (TypeIdentifier *)tparam; |
| if (tident->idents.length > 0) |
| { |
| //printf("matching %s to %s\n", tparam->toChars(), t->toChars()); |
| Dsymbol *s = t->toDsymbol(sc); |
| for (size_t j = tident->idents.length; j-- > 0; ) |
| { |
| RootObject *id = tident->idents[j]; |
| if (id->dyncast() == DYNCAST_IDENTIFIER) |
| { |
| if (!s || !s->parent) |
| goto Lnomatch; |
| Dsymbol *s2 = s->parent->search(Loc(), (Identifier *)id); |
| if (!s2) |
| goto Lnomatch; |
| s2 = s2->toAlias(); |
| //printf("[%d] s = %s %s, s2 = %s %s\n", j, s->kind(), s->toChars(), s2->kind(), s2->toChars()); |
| if (s != s2) |
| { |
| if (Type *tx = s2->getType()) |
| { |
| if (s != tx->toDsymbol(sc)) |
| goto Lnomatch; |
| } |
| else |
| goto Lnomatch; |
| } |
| s = s->parent; |
| } |
| else |
| goto Lnomatch; |
| } |
| //printf("[e] s = %s\n", s?s->toChars():"(null)"); |
| if (tp->isTemplateTypeParameter()) |
| { |
| Type *tt = s->getType(); |
| if (!tt) |
| goto Lnomatch; |
| Type *at = (Type *)(*dedtypes)[i]; |
| if (at && at->ty == Tnone) |
| at = ((TypeDeduced *)at)->tded; |
| if (!at || tt->equals(at)) |
| { |
| (*dedtypes)[i] = tt; |
| goto Lexact; |
| } |
| } |
| if (tp->isTemplateAliasParameter()) |
| { |
| Dsymbol *s2 = (Dsymbol *)(*dedtypes)[i]; |
| if (!s2 || s == s2) |
| { |
| (*dedtypes)[i] = s; |
| goto Lexact; |
| } |
| } |
| goto Lnomatch; |
| } |
| |
| // Found the corresponding parameter tp |
| if (!tp->isTemplateTypeParameter()) |
| goto Lnomatch; |
| |
| Type *at = (Type *)(*dedtypes)[i]; |
| Type *tt; |
| if (unsigned char wx = wm ? deduceWildHelper(t, &tt, tparam) : 0) |
| { |
| // type vs (none) |
| if (!at) |
| { |
| (*dedtypes)[i] = tt; |
| *wm |= wx; |
| result = MATCHconst; |
| return; |
| } |
| |
| // type vs expressions |
| if (at->ty == Tnone) |
| { |
| TypeDeduced *xt = (TypeDeduced *)at; |
| result = xt->matchAll(tt); |
| if (result > MATCHnomatch) |
| { |
| (*dedtypes)[i] = tt; |
| if (result > MATCHconst) |
| result = MATCHconst; // limit level for inout matches |
| delete xt; |
| } |
| return; |
| } |
| |
| // type vs type |
| if (tt->equals(at)) |
| { |
| (*dedtypes)[i] = tt; // Prefer current type match |
| goto Lconst; |
| } |
| if (tt->implicitConvTo(at->constOf())) |
| { |
| (*dedtypes)[i] = at->constOf()->mutableOf(); |
| *wm |= MODconst; |
| goto Lconst; |
| } |
| if (at->implicitConvTo(tt->constOf())) |
| { |
| (*dedtypes)[i] = tt->constOf()->mutableOf(); |
| *wm |= MODconst; |
| goto Lconst; |
| } |
| goto Lnomatch; |
| } |
| else if (MATCH m = deduceTypeHelper(t, &tt, tparam)) |
| { |
| // type vs (none) |
| if (!at) |
| { |
| (*dedtypes)[i] = tt; |
| result = m; |
| return; |
| } |
| |
| // type vs expressions |
| if (at->ty == Tnone) |
| { |
| TypeDeduced *xt = (TypeDeduced *)at; |
| result = xt->matchAll(tt); |
| if (result > MATCHnomatch) |
| { |
| (*dedtypes)[i] = tt; |
| delete xt; |
| } |
| return; |
| } |
| |
| // type vs type |
| if (tt->equals(at)) |
| { |
| goto Lexact; |
| } |
| if (tt->ty == Tclass && at->ty == Tclass) |
| { |
| result = tt->implicitConvTo(at); |
| return; |
| } |
| if (tt->ty == Tsarray && at->ty == Tarray && |
| tt->nextOf()->implicitConvTo(at->nextOf()) >= MATCHconst) |
| { |
| goto Lexact; |
| } |
| } |
| goto Lnomatch; |
| } |
| |
| if (tparam->ty == Ttypeof) |
| { |
| /* Need a loc to go with the semantic routine. |
| */ |
| Loc loc; |
| if (parameters->length) |
| { |
| TemplateParameter *tp = (*parameters)[0]; |
| loc = tp->loc; |
| } |
| |
| tparam = typeSemantic(tparam, loc, sc); |
| } |
| if (t->ty != tparam->ty) |
| { |
| if (Dsymbol *sym = t->toDsymbol(sc)) |
| { |
| if (sym->isforwardRef() && !tparam->deco) |
| goto Lnomatch; |
| } |
| |
| MATCH m = t->implicitConvTo(tparam); |
| if (m == MATCHnomatch) |
| { |
| if (t->ty == Tclass) |
| { |
| TypeClass *tc = (TypeClass *)t; |
| if (tc->sym->aliasthis && !(tc->att & RECtracingDT)) |
| { |
| tc->att = (AliasThisRec)(tc->att | RECtracingDT); |
| m = deduceType(t->aliasthisOf(), sc, tparam, parameters, dedtypes, wm); |
| tc->att = (AliasThisRec)(tc->att & ~RECtracingDT); |
| } |
| } |
| else if (t->ty == Tstruct) |
| { |
| TypeStruct *ts = (TypeStruct *)t; |
| if (ts->sym->aliasthis && !(ts->att & RECtracingDT)) |
| { |
| ts->att = (AliasThisRec)(ts->att | RECtracingDT); |
| m = deduceType(t->aliasthisOf(), sc, tparam, parameters, dedtypes, wm); |
| ts->att = (AliasThisRec)(ts->att & ~RECtracingDT); |
| } |
| } |
| } |
| result = m; |
| return; |
| } |
| |
| if (t->nextOf()) |
| { |
| if (tparam->deco && !tparam->hasWild()) |
| { |
| result = t->implicitConvTo(tparam); |
| return; |
| } |
| |
| Type *tpn = tparam->nextOf(); |
| if (wm && t->ty == Taarray && tparam->isWild()) |
| { |
| // Bugzilla 12403: In IFTI, stop inout matching on transitive part of AA types. |
| tpn = tpn->substWildTo(MODmutable); |
| } |
| |
| result = deduceType(t->nextOf(), sc, tpn, parameters, dedtypes, wm); |
| return; |
| } |
| |
| Lexact: |
| result = MATCHexact; |
| return; |
| |
| Lnomatch: |
| result = MATCHnomatch; |
| return; |
| |
| Lconst: |
| result = MATCHconst; |
| } |
| |
| void visit(TypeVector *t) |
| { |
| if (tparam->ty == Tvector) |
| { |
| TypeVector *tp = (TypeVector *)tparam; |
| result = deduceType(t->basetype, sc, tp->basetype, parameters, dedtypes, wm); |
| return; |
| } |
| visit((Type *)t); |
| } |
| |
| void visit(TypeDArray *t) |
| { |
| visit((Type *)t); |
| } |
| |
| void visit(TypeSArray *t) |
| { |
| // Extra check that array dimensions must match |
| if (tparam) |
| { |
| if (tparam->ty == Tarray) |
| { |
| MATCH m = deduceType(t->next, sc, tparam->nextOf(), parameters, dedtypes, wm); |
| result = (m >= MATCHconst) ? MATCHconvert : MATCHnomatch; |
| return; |
| } |
| |
| TemplateParameter *tp = NULL; |
| Expression *edim = NULL; |
| size_t i; |
| if (tparam->ty == Tsarray) |
| { |
| TypeSArray *tsa = (TypeSArray *)tparam; |
| if (tsa->dim->op == TOKvar && |
| ((VarExp *)tsa->dim)->var->storage_class & STCtemplateparameter) |
| { |
| Identifier *id = ((VarExp *)tsa->dim)->var->ident; |
| i = templateIdentifierLookup(id, parameters); |
| assert(i != IDX_NOTFOUND); |
| tp = (*parameters)[i]; |
| } |
| else |
| edim = tsa->dim; |
| } |
| else if (tparam->ty == Taarray) |
| { |
| TypeAArray *taa = (TypeAArray *)tparam; |
| i = templateParameterLookup(taa->index, parameters); |
| if (i != IDX_NOTFOUND) |
| tp = (*parameters)[i]; |
| else |
| { |
| Expression *e; |
| Type *tx; |
| Dsymbol *s; |
| taa->index->resolve(Loc(), sc, &e, &tx, &s); |
| edim = s ? getValue(s) : getValue(e); |
| } |
| } |
| if ((tp && tp->matchArg(sc, t->dim, i, parameters, dedtypes, NULL)) || |
| (edim && edim->toInteger() == t->dim->toInteger())) |
| { |
| result = deduceType(t->next, sc, tparam->nextOf(), parameters, dedtypes, wm); |
| return; |
| } |
| } |
| visit((Type *)t); |
| return; |
| |
| result = MATCHnomatch; |
| } |
| |
| void visit(TypeAArray *t) |
| { |
| // Extra check that index type must match |
| if (tparam && tparam->ty == Taarray) |
| { |
| TypeAArray *tp = (TypeAArray *)tparam; |
| if (!deduceType(t->index, sc, tp->index, parameters, dedtypes)) |
| { |
| result = MATCHnomatch; |
| return; |
| } |
| } |
| visit((Type *)t); |
| } |
| |
| void visit(TypeFunction *t) |
| { |
| //printf("TypeFunction::deduceType()\n"); |
| //printf("\tthis = %d, ", t->ty); t->print(); |
| //printf("\ttparam = %d, ", tparam->ty); tparam->print(); |
| |
| // Extra check that function characteristics must match |
| if (tparam && tparam->ty == Tfunction) |
| { |
| TypeFunction *tp = (TypeFunction *)tparam; |
| if (t->parameterList.varargs != tp->parameterList.varargs || |
| t->linkage != tp->linkage) |
| { |
| result = MATCHnomatch; |
| return; |
| } |
| |
| size_t nfargs = t->parameterList.length(); |
| size_t nfparams = tp->parameterList.length(); |
| |
| // bug 2579 fix: Apply function parameter storage classes to parameter types |
| for (size_t i = 0; i < nfparams; i++) |
| { |
| Parameter *fparam = tp->parameterList[i]; |
| fparam->type = fparam->type->addStorageClass(fparam->storageClass); |
| fparam->storageClass &= ~(STC_TYPECTOR | STCin); |
| } |
| //printf("\t-> this = %d, ", t->ty); t->print(); |
| //printf("\t-> tparam = %d, ", tparam->ty); tparam->print(); |
| |
| /* See if tuple match |
| */ |
| if (nfparams > 0 && nfargs >= nfparams - 1) |
| { |
| /* See if 'A' of the template parameter matches 'A' |
| * of the type of the last function parameter. |
| */ |
| Parameter *fparam = tp->parameterList[nfparams - 1]; |
| assert(fparam); |
| assert(fparam->type); |
| if (fparam->type->ty != Tident) |
| goto L1; |
| TypeIdentifier *tid = (TypeIdentifier *)fparam->type; |
| if (tid->idents.length) |
| goto L1; |
| |
| /* Look through parameters to find tuple matching tid->ident |
| */ |
| size_t tupi = 0; |
| for (; 1; tupi++) |
| { |
| if (tupi == parameters->length) |
| goto L1; |
| TemplateParameter *tx = (*parameters)[tupi]; |
| TemplateTupleParameter *tup = tx->isTemplateTupleParameter(); |
| if (tup && tup->ident->equals(tid->ident)) |
| break; |
| } |
| |
| /* The types of the function arguments [nfparams - 1 .. nfargs] |
| * now form the tuple argument. |
| */ |
| size_t tuple_dim = nfargs - (nfparams - 1); |
| |
| /* See if existing tuple, and whether it matches or not |
| */ |
| RootObject *o = (*dedtypes)[tupi]; |
| if (o) |
| { |
| // Existing deduced argument must be a tuple, and must match |
| Tuple *tup = isTuple(o); |
| if (!tup || tup->objects.length != tuple_dim) |
| { |
| result = MATCHnomatch; |
| return; |
| } |
| for (size_t i = 0; i < tuple_dim; i++) |
| { |
| Parameter *arg = t->parameterList[nfparams - 1 + i]; |
| if (!arg->type->equals(tup->objects[i])) |
| { |
| result = MATCHnomatch; |
| return; |
| } |
| } |
| } |
| else |
| { |
| // Create new tuple |
| Tuple *tup = new Tuple(); |
| tup->objects.setDim(tuple_dim); |
| for (size_t i = 0; i < tuple_dim; i++) |
| { |
| Parameter *arg = t->parameterList[nfparams - 1 + i]; |
| tup->objects[i] = arg->type; |
| } |
| (*dedtypes)[tupi] = tup; |
| } |
| nfparams--; // don't consider the last parameter for type deduction |
| goto L2; |
| } |
| |
| L1: |
| if (nfargs != nfparams) |
| { |
| result = MATCHnomatch; |
| return; |
| } |
| L2: |
| for (size_t i = 0; i < nfparams; i++) |
| { |
| Parameter *a = t->parameterList[i]; |
| Parameter *ap = tp->parameterList[i]; |
| |
| if (!a->isCovariant(t->isref, ap) || |
| !deduceType(a->type, sc, ap->type, parameters, dedtypes)) |
| { |
| result = MATCHnomatch; |
| return; |
| } |
| } |
| } |
| visit((Type *)t); |
| } |
| |
| void visit(TypeIdentifier *t) |
| { |
| // Extra check |
| if (tparam && tparam->ty == Tident) |
| { |
| TypeIdentifier *tp = (TypeIdentifier *)tparam; |
| |
| for (size_t i = 0; i < t->idents.length; i++) |
| { |
| RootObject *id1 = t->idents[i]; |
| RootObject *id2 = tp->idents[i]; |
| |
| if (!id1->equals(id2)) |
| { |
| result = MATCHnomatch; |
| return; |
| } |
| } |
| } |
| visit((Type *)t); |
| } |
| |
| void visit(TypeInstance *t) |
| { |
| // Extra check |
| if (tparam && tparam->ty == Tinstance && t->tempinst->tempdecl) |
| { |
| TemplateDeclaration *tempdecl = t->tempinst->tempdecl->isTemplateDeclaration(); |
| assert(tempdecl); |
| |
| TypeInstance *tp = (TypeInstance *)tparam; |
| |
| //printf("tempinst->tempdecl = %p\n", tempdecl); |
| //printf("tp->tempinst->tempdecl = %p\n", tp->tempinst->tempdecl); |
| if (!tp->tempinst->tempdecl) |
| { |
| //printf("tp->tempinst->name = '%s'\n", tp->tempinst->name->toChars()); |
| |
| /* Handle case of: |
| * template Foo(T : sa!(T), alias sa) |
| */ |
| size_t i = templateIdentifierLookup(tp->tempinst->name, parameters); |
| if (i == IDX_NOTFOUND) |
| { |
| /* Didn't find it as a parameter identifier. Try looking |
| * it up and seeing if is an alias. See Bugzilla 1454 |
| */ |
| TypeIdentifier *tid = new TypeIdentifier(tp->loc, tp->tempinst->name); |
| Type *tx; |
| Expression *e; |
| Dsymbol *s; |
| tid->resolve(tp->loc, sc, &e, &tx, &s); |
| if (tx) |
| { |
| s = tx->toDsymbol(sc); |
| if (TemplateInstance *ti = s ? s->parent->isTemplateInstance() : NULL) |
| { |
| // Bugzilla 14290: Try to match with ti->tempecl, |
| // only when ti is an enclosing instance. |
| Dsymbol *p = sc->parent; |
| while (p && p != ti) |
| p = p->parent; |
| if (p) |
| s = ti->tempdecl; |
| } |
| } |
| if (s) |
| { |
| s = s->toAlias(); |
| TemplateDeclaration *td = s->isTemplateDeclaration(); |
| if (td) |
| { |
| if (td->overroot) |
| td = td->overroot; |
| for (; td; td = td->overnext) |
| { |
| if (td == tempdecl) |
| goto L2; |
| } |
| } |
| } |
| goto Lnomatch; |
| } |
| TemplateParameter *tpx = (*parameters)[i]; |
| if (!tpx->matchArg(sc, tempdecl, i, parameters, dedtypes, NULL)) |
| goto Lnomatch; |
| } |
| else if (tempdecl != tp->tempinst->tempdecl) |
| goto Lnomatch; |
| |
| L2: |
| |
| for (size_t i = 0; 1; i++) |
| { |
| //printf("\ttest: tempinst->tiargs[%d]\n", i); |
| RootObject *o1 = NULL; |
| if (i < t->tempinst->tiargs->length) |
| o1 = (*t->tempinst->tiargs)[i]; |
| else if (i < t->tempinst->tdtypes.length && i < tp->tempinst->tiargs->length) |
| { |
| // Pick up default arg |
| o1 = t->tempinst->tdtypes[i]; |
| } |
| else if (i >= tp->tempinst->tiargs->length) |
| break; |
| |
| if (i >= tp->tempinst->tiargs->length) |
| { |
| size_t dim = tempdecl->parameters->length - (tempdecl->isVariadic() ? 1 : 0); |
| while (i < dim && ((*tempdecl->parameters)[i]->dependent || |
| (*tempdecl->parameters)[i]->hasDefaultArg())) |
| { |
| i++; |
| } |
| if (i >= dim) |
| break; // match if all remained parameters are dependent |
| goto Lnomatch; |
| } |
| |
| RootObject *o2 = (*tp->tempinst->tiargs)[i]; |
| Type *t2 = isType(o2); |
| |
| size_t j = (t2 && t2->ty == Tident && i == tp->tempinst->tiargs->length - 1) |
| ? templateParameterLookup(t2, parameters) : IDX_NOTFOUND; |
| if (j != IDX_NOTFOUND && j == parameters->length - 1 && |
| (*parameters)[j]->isTemplateTupleParameter()) |
| { |
| /* Given: |
| * struct A(B...) {} |
| * alias A!(int, float) X; |
| * static if (is(X Y == A!(Z), Z...)) {} |
| * deduce that Z is a tuple(int, float) |
| */ |
| |
| /* Create tuple from remaining args |
| */ |
| Tuple *vt = new Tuple(); |
| size_t vtdim = (tempdecl->isVariadic() |
| ? t->tempinst->tiargs->length : t->tempinst->tdtypes.length) - i; |
| vt->objects.setDim(vtdim); |
| for (size_t k = 0; k < vtdim; k++) |
| { |
| RootObject *o; |
| if (k < t->tempinst->tiargs->length) |
| o = (*t->tempinst->tiargs)[i + k]; |
| else // Pick up default arg |
| o = t->tempinst->tdtypes[i + k]; |
| vt->objects[k] = o; |
| } |
| |
| Tuple *v = (Tuple *)(*dedtypes)[j]; |
| if (v) |
| { |
| if (!match(v, vt)) |
| goto Lnomatch; |
| } |
| else |
| (*dedtypes)[j] = vt; |
| break; |
| } |
| else if (!o1) |
| break; |
| |
| Type *t1 = isType(o1); |
| Dsymbol *s1 = isDsymbol(o1); |
| Dsymbol *s2 = isDsymbol(o2); |
| Expression *e1 = s1 ? getValue(s1) : getValue(isExpression(o1)); |
| Expression *e2 = isExpression(o2); |
| |
| if (t1 && t2) |
| { |
| if (!deduceType(t1, sc, t2, parameters, dedtypes)) |
| goto Lnomatch; |
| } |
| else if (e1 && e2) |
| { |
| Le: |
| e1 = e1->ctfeInterpret(); |
| |
| /* If it is one of the template parameters for this template, |
| * we should not attempt to interpret it. It already has a value. |
| */ |
| if (e2->op == TOKvar && |
| (((VarExp *)e2)->var->storage_class & STCtemplateparameter)) |
| { |
| /* |
| * (T:Number!(e2), int e2) |
| */ |
| j = templateIdentifierLookup(((VarExp *)e2)->var->ident, parameters); |
| if (j != IDX_NOTFOUND) |
| goto L1; |
| // The template parameter was not from this template |
| // (it may be from a parent template, for example) |
| } |
| |
| e2 = expressionSemantic(e2, sc); // Bugzilla 13417 |
| e2 = e2->ctfeInterpret(); |
| |
| //printf("e1 = %s, type = %s %d\n", e1->toChars(), e1->type->toChars(), e1->type->ty); |
| //printf("e2 = %s, type = %s %d\n", e2->toChars(), e2->type->toChars(), e2->type->ty); |
| if (!e1->equals(e2)) |
| { |
| if (!e2->implicitConvTo(e1->type)) |
| goto Lnomatch; |
| |
| e2 = e2->implicitCastTo(sc, e1->type); |
| e2 = e2->ctfeInterpret(); |
| if (!e1->equals(e2)) |
| goto Lnomatch; |
| } |
| } |
| else if (e1 && t2 && t2->ty == Tident) |
| { |
| j = templateParameterLookup(t2, parameters); |
| L1: |
| if (j == IDX_NOTFOUND) |
| { |
| t2->resolve(((TypeIdentifier *)t2)->loc, sc, &e2, &t2, &s2); |
| if (e2) |
| goto Le; |
| goto Lnomatch; |
| } |
| if (!(*parameters)[j]->matchArg(sc, e1, j, parameters, dedtypes, NULL)) |
| goto Lnomatch; |
| } |
| else if (s1 && s2) |
| { |
| Ls: |
| if (!s1->equals(s2)) |
| goto Lnomatch; |
| } |
| else if (s1 && t2 && t2->ty == Tident) |
| { |
| j = templateParameterLookup(t2, parameters); |
| if (j == IDX_NOTFOUND) |
| { |
| t2->resolve(((TypeIdentifier *)t2)->loc, sc, &e2, &t2, &s2); |
| if (s2) |
| goto Ls; |
| goto Lnomatch; |
| } |
| if (!(*parameters)[j]->matchArg(sc, s1, j, parameters, dedtypes, NULL)) |
| goto Lnomatch; |
| } |
| else |
| goto Lnomatch; |
| } |
| } |
| visit((Type *)t); |
| return; |
| |
| Lnomatch: |
| //printf("no match\n"); |
| result = MATCHnomatch; |
| } |
| |
| void visit(TypeStruct *t) |
| { |
| /* If this struct is a template struct, and we're matching |
| * it against a template instance, convert the struct type |
| * to a template instance, too, and try again. |
| */ |
| TemplateInstance *ti = t->sym->parent->isTemplateInstance(); |
| |
| if (tparam && tparam->ty == Tinstance) |
| { |
| if (ti && ti->toAlias() == t->sym) |
| { |
| TypeInstance *tx = new TypeInstance(Loc(), ti); |
| result = deduceType(tx, sc, tparam, parameters, dedtypes, wm); |
| return; |
| } |
| |
| /* Match things like: |
| * S!(T).foo |
| */ |
| TypeInstance *tpi = (TypeInstance *)tparam; |
| if (tpi->idents.length) |
| { |
| RootObject *id = tpi->idents[tpi->idents.length - 1]; |
| if (id->dyncast() == DYNCAST_IDENTIFIER && t->sym->ident->equals((Identifier *)id)) |
| { |
| Type *tparent = t->sym->parent->getType(); |
| if (tparent) |
| { |
| /* Slice off the .foo in S!(T).foo |
| */ |
| tpi->idents.length--; |
| result = deduceType(tparent, sc, tpi, parameters, dedtypes, wm); |
| tpi->idents.length++; |
| return; |
| } |
| } |
| } |
| } |
| |
| // Extra check |
| if (tparam && tparam->ty == Tstruct) |
| { |
| TypeStruct *tp = (TypeStruct *)tparam; |
| |
| //printf("\t%d\n", (MATCH) t->implicitConvTo(tp)); |
| if (wm && t->deduceWild(tparam, false)) |
| { |
| result = MATCHconst; |
| return; |
| } |
| result = t->implicitConvTo(tp); |
| return; |
| } |
| visit((Type *)t); |
| } |
| |
| void visit(TypeEnum *t) |
| { |
| // Extra check |
| if (tparam && tparam->ty == Tenum) |
| { |
| TypeEnum *tp = (TypeEnum *)tparam; |
| if (t->sym == tp->sym) |
| visit((Type *)t); |
| else |
| result = MATCHnomatch; |
| return; |
| } |
| Type *tb = t->toBasetype(); |
| if (tb->ty == tparam->ty || |
| (tb->ty == Tsarray && tparam->ty == Taarray)) |
| { |
| result = deduceType(tb, sc, tparam, parameters, dedtypes, wm); |
| return; |
| } |
| visit((Type *)t); |
| } |
| |
| /* Helper for TypeClass::deduceType(). |
| * Classes can match with implicit conversion to a base class or interface. |
| * This is complicated, because there may be more than one base class which |
| * matches. In such cases, one or more parameters remain ambiguous. |
| * For example, |
| * |
| * interface I(X, Y) {} |
| * class C : I(uint, double), I(char, double) {} |
| * C x; |
| * foo(T, U)( I!(T, U) x) |
| * |
| * deduces that U is double, but T remains ambiguous (could be char or uint). |
| * |
| * Given a baseclass b, and initial deduced types 'dedtypes', this function |
| * tries to match tparam with b, and also tries all base interfaces of b. |
| * If a match occurs, numBaseClassMatches is incremented, and the new deduced |
| * types are ANDed with the current 'best' estimate for dedtypes. |
| */ |
| static void deduceBaseClassParameters(BaseClass *b, |
| Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, |
| Objects *best, int &numBaseClassMatches) |
| { |
| TemplateInstance *parti = b->sym ? b->sym->parent->isTemplateInstance() : NULL; |
| if (parti) |
| { |
| // Make a temporary copy of dedtypes so we don't destroy it |
| Objects *tmpdedtypes = new Objects(); |
| tmpdedtypes->setDim(dedtypes->length); |
| memcpy(tmpdedtypes->tdata(), dedtypes->tdata(), dedtypes->length * sizeof(void *)); |
| |
| TypeInstance *t = new TypeInstance(Loc(), parti); |
| MATCH m = deduceType(t, sc, tparam, parameters, tmpdedtypes); |
| if (m > MATCHnomatch) |
| { |
| // If this is the first ever match, it becomes our best estimate |
| if (numBaseClassMatches==0) |
| memcpy(best->tdata(), tmpdedtypes->tdata(), tmpdedtypes->length * sizeof(void *)); |
| else for (size_t k = 0; k < tmpdedtypes->length; ++k) |
| { |
| // If we've found more than one possible type for a parameter, |
| // mark it as unknown. |
| if ((*tmpdedtypes)[k] != (*best)[k]) |
| (*best)[k] = (*dedtypes)[k]; |
| } |
| ++numBaseClassMatches; |
| } |
| } |
| // Now recursively test the inherited interfaces |
| for (size_t j = 0; j < b->baseInterfaces.length; ++j) |
| { |
| BaseClass *bi = &b->baseInterfaces.ptr[j]; |
| deduceBaseClassParameters(bi, |
| sc, tparam, parameters, dedtypes, |
| best, numBaseClassMatches); |
| } |
| |
| } |
| |
| void visit(TypeClass *t) |
| { |
| //printf("TypeClass::deduceType(this = %s)\n", t->toChars()); |
| |
| /* If this class is a template class, and we're matching |
| * it against a template instance, convert the class type |
| * to a template instance, too, and try again. |
| */ |
| TemplateInstance *ti = t->sym->parent->isTemplateInstance(); |
| |
| if (tparam && tparam->ty == Tinstance) |
| { |
| if (ti && ti->toAlias() == t->sym) |
| { |
| TypeInstance *tx = new TypeInstance(Loc(), ti); |
| MATCH m = deduceType(tx, sc, tparam, parameters, dedtypes, wm); |
| // Even if the match fails, there is still a chance it could match |
| // a base class. |
| if (m != MATCHnomatch) |
| { |
| result = m; |
| return; |
| } |
| } |
| |
| /* Match things like: |
| * S!(T).foo |
| */ |
| TypeInstance *tpi = (TypeInstance *)tparam; |
| if (tpi->idents.length) |
| { |
| RootObject *id = tpi->idents[tpi->idents.length - 1]; |
| if (id->dyncast() == DYNCAST_IDENTIFIER && t->sym->ident->equals((Identifier *)id)) |
| { |
| Type *tparent = t->sym->parent->getType(); |
| if (tparent) |
| { |
| /* Slice off the .foo in S!(T).foo |
| */ |
| tpi->idents.length--; |
| result = deduceType(tparent, sc, tpi, parameters, dedtypes, wm); |
| tpi->idents.length++; |
| return; |
| } |
| } |
| } |
| |
| // If it matches exactly or via implicit conversion, we're done |
| visit((Type *)t); |
| if (result != MATCHnomatch) |
| return; |
| |
| /* There is still a chance to match via implicit conversion to |
| * a base class or interface. Because there could be more than one such |
| * match, we need to check them all. |
| */ |
| |
| int numBaseClassMatches = 0; // Have we found an interface match? |
| |
| // Our best guess at dedtypes |
| Objects *best = new Objects(); |
| best->setDim(dedtypes->length); |
| |
| ClassDeclaration *s = t->sym; |
| while (s && s->baseclasses->length > 0) |
| { |
| // Test the base class |
| deduceBaseClassParameters((*s->baseclasses)[0], |
| sc, tparam, parameters, dedtypes, |
| best, numBaseClassMatches); |
| |
| // Test the interfaces inherited by the base class |
| for (size_t i = 0; i < s->interfaces.length; ++i) |
| { |
| BaseClass *b = s->interfaces.ptr[i]; |
| deduceBaseClassParameters(b, sc, tparam, parameters, dedtypes, |
| best, numBaseClassMatches); |
| } |
| s = (*s->baseclasses)[0]->sym; |
| } |
| |
| if (numBaseClassMatches == 0) |
| { |
| result = MATCHnomatch; |
| return; |
| } |
| |
| // If we got at least one match, copy the known types into dedtypes |
| memcpy(dedtypes->tdata(), best->tdata(), best->length * sizeof(void *)); |
| result = MATCHconvert; |
| return; |
| } |
| |
| // Extra check |
| if (tparam && tparam->ty == Tclass) |
| { |
| TypeClass *tp = (TypeClass *)tparam; |
| |
| //printf("\t%d\n", (MATCH) t->implicitConvTo(tp)); |
| if (wm && t->deduceWild(tparam, false)) |
| { |
| result = MATCHconst; |
| return; |
| } |
| result = t->implicitConvTo(tp); |
| return; |
| } |
| visit((Type *)t); |
| } |
| |
| void visit(Expression *e) |
| { |
| //printf("Expression::deduceType(e = %s)\n", e->toChars()); |
| size_t i = templateParameterLookup(tparam, parameters); |
| if (i == IDX_NOTFOUND || ((TypeIdentifier *)tparam)->idents.length > 0) |
| { |
| if (e == emptyArrayElement && tparam->ty == Tarray) |
| { |
| Type *tn = ((TypeNext *)tparam)->next; |
| result = deduceType(emptyArrayElement, sc, tn, parameters, dedtypes, wm); |
| return; |
| } |
| e->type->accept(this); |
| return; |
| } |
| |
| TemplateTypeParameter *tp = (*parameters)[i]->isTemplateTypeParameter(); |
| if (!tp) |
| return; // nomatch |
| |
| if (e == emptyArrayElement) |
| { |
| if ((*dedtypes)[i]) |
| { |
| result = MATCHexact; |
| return; |
| } |
| if (tp->defaultType) |
| { |
| tp->defaultType->accept(this); |
| return; |
| } |
| } |
| |
| Type *at = (Type *)(*dedtypes)[i]; |
| Type *tt; |
| if (unsigned char wx = deduceWildHelper(e->type, &tt, tparam)) |
| { |
| *wm |= wx; |
| result = MATCHconst; |
| } |
| else if (MATCH m = deduceTypeHelper(e->type, &tt, tparam)) |
| { |
| result = m; |
| } |
| else |
| return; // nomatch |
| |
| // expression vs (none) |
| if (!at) |
| { |
| (*dedtypes)[i] = new TypeDeduced(tt, e, tparam); |
| return; |
| } |
| |
| TypeDeduced *xt = NULL; |
| if (at->ty == Tnone) |
| { |
| xt = (TypeDeduced *)at; |
| at = xt->tded; |
| } |
| |
| // From previous matched expressions to current deduced type |
| MATCH match1 = xt ? xt->matchAll(tt) : MATCHnomatch; |
| |
| // From current expresssion to previous deduced type |
| Type *pt = at->addMod(tparam->mod); |
| if (*wm) |
| pt = pt->substWildTo(*wm); |
| MATCH match2 = e->implicitConvTo(pt); |
| |
| if (match1 > MATCHnomatch && match2 > MATCHnomatch) |
| { |
| if (at->implicitConvTo(tt) <= MATCHnomatch) |
| match1 = MATCHnomatch; // Prefer at |
| else if (tt->implicitConvTo(at) <= MATCHnomatch) |
| match2 = MATCHnomatch; // Prefer tt |
| else if (tt->isTypeBasic() && tt->ty == at->ty && tt->mod != at->mod) |
| { |
| if (!tt->isMutable() && !at->isMutable()) |
| tt = tt->mutableOf()->addMod(MODmerge(tt->mod, at->mod)); |
| else if (tt->isMutable()) |
| { |
| if (at->mod == 0) // Prefer unshared |
| match1 = MATCHnomatch; |
| else |
| match2 = MATCHnomatch; |
| } |
| else if (at->isMutable()) |
| { |
| if (tt->mod == 0) // Prefer unshared |
| match2 = MATCHnomatch; |
| else |
| match1 = MATCHnomatch; |
| } |
| //printf("tt = %s, at = %s\n", tt->toChars(), at->toChars()); |
| } |
| else |
| { |
| match1 = MATCHnomatch; |
| match2 = MATCHnomatch; |
| } |
| } |
| if (match1 > MATCHnomatch) |
| { |
| // Prefer current match: tt |
| if (xt) |
| xt->update(tt, e, tparam); |
| else |
| (*dedtypes)[i] = tt; |
| result = match1; |
| return; |
| } |
| if (match2 > MATCHnomatch) |
| { |
| // Prefer previous match: (*dedtypes)[i] |
| if (xt) |
| xt->update(e, tparam); |
| result = match2; |
| return; |
| } |
| |
| /* Deduce common type |
| */ |
| if (Type *t = rawTypeMerge(at, tt)) |
| { |
| if (xt) |
| xt->update(t, e, tparam); |
| else |
| (*dedtypes)[i] = t; |
| |
| pt = tt->addMod(tparam->mod); |
| if (*wm) |
| pt = pt->substWildTo(*wm); |
| result = e->implicitConvTo(pt); |
| return; |
| } |
| |
| result = MATCHnomatch; |
| } |
| |
| MATCH deduceEmptyArrayElement() |
| { |
| if (!emptyArrayElement) |
| { |
| emptyArrayElement = new IdentifierExp(Loc(), Id::p); // dummy |
| emptyArrayElement->type = Type::tvoid; |
| } |
| assert(tparam->ty == Tarray); |
| |
| Type *tn = ((TypeNext *)tparam)->next; |
| return deduceType(emptyArrayElement, sc, tn, parameters, dedtypes, wm); |
| } |
| |
| void visit(NullExp *e) |
| { |
| if (tparam->ty == Tarray && e->type->ty == Tnull) |
| { |
| // tparam:T[] <- e:null (void[]) |
| result = deduceEmptyArrayElement(); |
| return; |
| } |
| visit((Expression *)e); |
| } |
| |
| void visit(StringExp *e) |
| { |
| Type *taai; |
| if (e->type->ty == Tarray && |
| (tparam->ty == Tsarray || |
| (tparam->ty == Taarray && (taai = ((TypeAArray *)tparam)->index)->ty == Tident && |
| ((TypeIdentifier *)taai)->idents.length == 0))) |
| { |
| // Consider compile-time known boundaries |
| e->type->nextOf()->sarrayOf(e->len)->accept(this); |
| return; |
| } |
| visit((Expression *)e); |
| } |
| |
| void visit(ArrayLiteralExp *e) |
| { |
| // https://issues.dlang.org/show_bug.cgi?id=20092 |
| if (e->elements && e->elements->length && |
| e->type->toBasetype()->nextOf()->ty == Tvoid) |
| { |
| result = deduceEmptyArrayElement(); |
| return; |
| } |
| if ((!e->elements || !e->elements->length) && |
| e->type->toBasetype()->nextOf()->ty == Tvoid && |
| tparam->ty == Tarray) |
| { |
| // tparam:T[] <- e:[] (void[]) |
| result = deduceEmptyArrayElement(); |
| return; |
| } |
| |
| if (tparam->ty == Tarray && e->elements && e->elements->length) |
| { |
| Type *tn = ((TypeDArray *)tparam)->next; |
| result = MATCHexact; |
| if (e->basis) |
| { |
| MATCH m = deduceType(e->basis, sc, tn, parameters, dedtypes, wm); |
| if (m < result) |
| result = m; |
| } |
| for (size_t i = 0; i < e->elements->length; i++) |
| { |
| if (result <= MATCHnomatch) |
| break; |
| Expression *el = (*e->elements)[i]; |
| if (!el) |
| continue; |
| MATCH m = deduceType(el, sc, tn, parameters, dedtypes, wm); |
| if (m < result) |
| result = m; |
| } |
| return; |
| } |
| |
| Type *taai; |
| if (e->type->ty == Tarray && |
| (tparam->ty == Tsarray || |
| (tparam->ty == Taarray && (taai = ((TypeAArray *)tparam)->index)->ty == Tident && |
| ((TypeIdentifier *)taai)->idents.length == 0))) |
| { |
| // Consider compile-time known boundaries |
| e->type->nextOf()->sarrayOf(e->elements->length)->accept(this); |
| return; |
| } |
| visit((Expression *)e); |
| } |
| |
| void visit(AssocArrayLiteralExp *e) |
| { |
| if (tparam->ty == Taarray && e->keys && e->keys->length) |
| { |
| TypeAArray *taa = (TypeAArray *)tparam; |
| result = MATCHexact; |
| for (size_t i = 0; i < e->keys->length; i++) |
| { |
| MATCH m1 = deduceType((*e->keys)[i], sc, taa->index, parameters, dedtypes, wm); |
| if (m1 < result) |
| result = m1; |
| if (result <= MATCHnomatch) |
| break; |
| MATCH m2 = deduceType((*e->values)[i], sc, taa->next, parameters, dedtypes, wm); |
| if (m2 < result) |
| result = m2; |
| if (result <= MATCHnomatch) |
| break; |
| } |
| return; |
| } |
| visit((Expression *)e); |
| } |
| |
| void visit(FuncExp *e) |
| { |
| //printf("e->type = %s, tparam = %s\n", e->type->toChars(), tparam->toChars()); |
| if (e->td) |
| { |
| Type *to = tparam; |
| if (!to->nextOf() || to->nextOf()->ty != Tfunction) |
| return; |
| TypeFunction *tof = (TypeFunction *)to->nextOf(); |
| |
| // Parameter types inference from 'tof' |
| assert(e->td->_scope); |
| TypeFunction *tf = (TypeFunction *)e->fd->type; |
| //printf("\ttof = %s\n", tof->toChars()); |
| //printf("\ttf = %s\n", tf->toChars()); |
| size_t dim = tf->parameterList.length(); |
| |
| if (tof->parameterList.length() != dim || |
| tof->parameterList.varargs != tf->parameterList.varargs) |
| return; |
| |
| Objects *tiargs = new Objects(); |
| tiargs->reserve(e->td->parameters->length); |
| |
| for (size_t i = 0; i < e->td->parameters->length; i++) |
| { |
| TemplateParameter *tp = (*e->td->parameters)[i]; |
| size_t u = 0; |
| for (; u < dim; u++) |
| { |
| Parameter *p = tf->parameterList[u]; |
| if (p->type->ty == Tident && |
| ((TypeIdentifier *)p->type)->ident == tp->ident) |
| { |
| break; |
| } |
| } |
| assert(u < dim); |
| Parameter *pto = tof->parameterList[u]; |
| if (!pto) |
| break; |
| Type *t = pto->type->syntaxCopy(); // Bugzilla 11774 |
| if (reliesOnTident(t, parameters, inferStart)) |
| return; |
| t = typeSemantic(t, e->loc, sc); |
| if (t->ty == Terror) |
| return; |
| tiargs->push(t); |
| } |
| |
| // Set target of return type inference |
| if (!tf->next && tof->next) |
| e->fd->treq = tparam; |
| |
| TemplateInstance *ti = new TemplateInstance(e->loc, e->td, tiargs); |
| Expression *ex = new ScopeExp(e->loc, ti); |
| ex = expressionSemantic(ex, e->td->_scope); |
| |
| // Reset inference target for the later re-semantic |
| e->fd->treq = NULL; |
| |
| if (ex->op == TOKerror) |
| return; |
| if (ex->op != TOKfunction) |
| return; |
| visit(ex->type); |
| return; |
| } |
| |
| Type *t = e->type; |
| |
| if (t->ty == Tdelegate && tparam->ty == Tpointer) |
| return; |
| |
| // Allow conversion from implicit function pointer to delegate |
| if (e->tok == TOKreserved && |
| t->ty == Tpointer && tparam->ty == Tdelegate) |
| { |
| TypeFunction *tf = (TypeFunction *)t->nextOf(); |
| t = (new TypeDelegate(tf))->merge(); |
| } |
| //printf("tparam = %s <= e->type = %s, t = %s\n", tparam->toChars(), e->type->toChars(), t->toChars()); |
| visit(t); |
| } |
| |
| void visit(SliceExp *e) |
| { |
| Type *taai; |
| if (e->type->ty == Tarray && |
| (tparam->ty == Tsarray || |
| (tparam->ty == Taarray && (taai = ((TypeAArray *)tparam)->index)->ty == Tident && |
| ((TypeIdentifier *)taai)->idents.length == 0))) |
| { |
| // Consider compile-time known boundaries |
| if (Type *tsa = toStaticArrayType(e)) |
| { |
| tsa->accept(this); |
| return; |
| } |
| } |
| visit((Expression *)e); |
| } |
| |
| void visit(CommaExp *e) |
| { |
| ((CommaExp *)e)->e2->accept(this); |
| } |
| }; |
| |
| DeduceType v(sc, tparam, parameters, dedtypes, wm, inferStart); |
| if (Type *t = isType(o)) |
| t->accept(&v); |
| else |
| { |
| assert(isExpression(o) && wm); |
| ((Expression *)o)->accept(&v); |
| } |
| return v.result; |
| } |
| |
| /******************************* |
| * Input: |
| * t Tested type, if NULL, returns NULL. |
| * tparams Optional template parameters. |
| * == NULL: |
| * If one of the subtypes of this type is a TypeIdentifier, |
| * i.e. it's an unresolved type, return that type. |
| * != NULL: |
| * Only when the TypeIdentifier is one of template parameters, |
| * return that type. |
| */ |
| |
| bool reliesOnTident(Type *t, TemplateParameters *tparams, size_t iStart) |
| { |
| class ReliesOnTident : public Visitor |
| { |
| public: |
| TemplateParameters *tparams; |
| size_t iStart; |
| bool result; |
| |
| ReliesOnTident(TemplateParameters *tparams, size_t iStart) |
| : tparams(tparams), iStart(iStart) |
| { |
| result = false; |
| } |
| |
| void visit(Type *) |
| { |
| } |
| |
| void visit(TypeNext *t) |
| { |
| t->next->accept(this); |
| } |
| |
| void visit(TypeVector *t) |
| { |
| t->basetype->accept(this); |
| } |
| |
| void visit(TypeAArray *t) |
| { |
| visit((TypeNext *)t); |
| if (!result) |
| t->index->accept(this); |
| } |
| |
| void visit(TypeFunction *t) |
| { |
| size_t dim = t->parameterList.length(); |
| for (size_t i = 0; i < dim; i++) |
| { |
| Parameter *fparam = t->parameterList[i]; |
| fparam->type->accept(this); |
| if (result) |
| return; |
| } |
| if (t->next) |
| t->next->accept(this); |
| } |
| |
| void visit(TypeIdentifier *t) |
| { |
| if (!tparams) |
| { |
| result = true; |
| return; |
| } |
| |
| for (size_t i = iStart; i < tparams->length; i++) |
| { |
| TemplateParameter *tp = (*tparams)[i]; |
| if (tp->ident->equals(t->ident)) |
| { |
| result = true; |
| return; |
| } |
| } |
| } |
| |
| void visit(TypeInstance *t) |
| { |
| if (!tparams) |
| return; |
| |
| for (size_t i = iStart; i < tparams->length; i++) |
| { |
| TemplateParameter *tp = (*tparams)[i]; |
| if (t->tempinst->name == tp->ident) |
| { |
| result = true; |
| return; |
| } |
| } |
| if (!t->tempinst->tiargs) |
| return; |
| for (size_t i = 0; i < t->tempinst->tiargs->length; i++) |
| { |
| Type *ta = isType((*t->tempinst->tiargs)[i]); |
| if (ta) |
| { |
| ta->accept(this); |
| if (result) |
| return; |
| } |
| } |
| } |
| |
| void visit(TypeTypeof *t) |
| { |
| //printf("TypeTypeof::reliesOnTident('%s')\n", t->toChars()); |
| t->exp->accept(this); |
| } |
| |
| void visit(TypeTuple *t) |
| { |
| if (t->arguments) |
| { |
| for (size_t i = 0; i < t->arguments->length; i++) |
| { |
| Parameter *arg = (*t->arguments)[i]; |
| arg->type->accept(this); |
| if (result) |
| return; |
| } |
| } |
| } |
| |
| void visit(Expression *) |
| { |
| //printf("Expression::reliesOnTident('%s')\n", e->toChars()); |
| } |
| |
| void visit(IdentifierExp *e) |
| { |
| //printf("IdentifierExp::reliesOnTident('%s')\n", e->toChars()); |
| for (size_t i = iStart; i < tparams->length; i++) |
| { |
| TemplateParameter *tp = (*tparams)[i]; |
| if (e->ident == tp->ident) |
| { |
| result = true; |
| return; |
| } |
| } |
| } |
| |
| void visit(TupleExp *e) |
| { |
| //printf("TupleExp::reliesOnTident('%s')\n", e->toChars()); |
| if (e->exps) |
| { |
| for (size_t i = 0; i < e->exps->length; i++) |
| { |
| Expression *ea = (*e->exps)[i]; |
| ea->accept(this); |
| if (result) |
| return; |
| } |
| } |
| } |
| |
| void visit(ArrayLiteralExp *e) |
| { |
| //printf("ArrayLiteralExp::reliesOnTident('%s')\n", e->toChars()); |
| if (e->elements) |
| { |
| for (size_t i = 0; i < e->elements->length; i++) |
| { |
| Expression *el = (*e->elements)[i]; |
| el->accept(this); |
| if (result) |
| return; |
| } |
| } |
| } |
| |
| void visit(AssocArrayLiteralExp *e) |
| { |
| //printf("AssocArrayLiteralExp::reliesOnTident('%s')\n", e->toChars()); |
| for (size_t i = 0; i < e->keys->length; i++) |
| { |
| Expression *ek = (*e->keys)[i]; |
| ek->accept(this); |
| if (result) |
| return; |
| } |
| for (size_t i = 0; i < e->values->length; i++) |
| { |
| Expression *ev = (*e->values)[i]; |
| ev->accept(this); |
| if (result) |
| return; |
| } |
| } |
| |
| void visit(StructLiteralExp *e) |
| { |
| //printf("StructLiteralExp::reliesOnTident('%s')\n", e->toChars()); |
| if (e->elements) |
| { |
| for (size_t i = 0; i < e->elements->length; i++) |
| { |
| Expression *ea = (*e->elements)[i]; |
| ea->accept(this); |
| if (result) |
| return; |
| } |
| } |
| } |
| |
| void visit(TypeExp *e) |
| { |
| //printf("TypeExp::reliesOnTident('%s')\n", e->toChars()); |
| e->type->accept(this); |
| } |
| |
| void visit(NewExp *e) |
| { |
| //printf("NewExp::reliesOnTident('%s')\n", e->toChars()); |
| if (e->thisexp) |
| e->thisexp->accept(this); |
| if (!result && e->newargs) |
| { |
| for (size_t i = 0; i < e->newargs->length; i++) |
| { |
| Expression *ea = (*e->newargs)[i]; |
| ea->accept(this); |
| if (result) |
| return; |
| } |
| } |
| e->newtype->accept(this); |
| if (!result && e->arguments) |
| { |
| for (size_t i = 0; i < e->arguments->length; i++) |
| { |
| Expression *ea = (*e->arguments)[i]; |
| ea->accept(this); |
| if (result) |
| return; |
| } |
| } |
| } |
| |
| void visit(NewAnonClassExp *) |
| { |
| //printf("NewAnonClassExp::reliesOnTident('%s')\n", e->toChars()); |
| result = true; |
| } |
| |
| void visit(FuncExp *) |
| { |
| //printf("FuncExp::reliesOnTident('%s')\n", e->toChars()); |
| result = true; |
| } |
| |
| void visit(TypeidExp *e) |
| { |
| //printf("TypeidExp::reliesOnTident('%s')\n", e->toChars()); |
| if (Expression *ea = isExpression(e->obj)) |
| ea->accept(this); |
| else if (Type *ta = isType(e->obj)) |
| ta->accept(this); |
| } |
| |
| void visit(TraitsExp *e) |
| { |
| //printf("TraitsExp::reliesOnTident('%s')\n", e->toChars()); |
| if (e->args) |
| { |
| for (size_t i = 0; i < e->args->length; i++) |
| { |
| RootObject *oa = (*e->args)[i]; |
| if (Expression *ea = isExpression(oa)) |
| ea->accept(this); |
| else if (Type *ta = isType(oa)) |
| ta->accept(this); |
| if (result) |
| return; |
| } |
| } |
| } |
| |
| void visit(IsExp *e) |
| { |
| //printf("IsExp::reliesOnTident('%s')\n", e->toChars()); |
| e->targ->accept(this); |
| } |
| |
| void visit(UnaExp *e) |
| { |
| //printf("UnaExp::reliesOnTident('%s')\n", e->toChars()); |
| e->e1->accept(this); |
| } |
| |
| void visit(DotTemplateInstanceExp *e) |
| { |
| //printf("DotTemplateInstanceExp::reliesOnTident('%s')\n", e->toChars()); |
| visit((UnaExp *)e); |
| if (!result && e->ti->tiargs) |
| { |
| for (size_t i = 0; i < e->ti->tiargs->length; i++) |
| { |
| RootObject *oa = (*e->ti->tiargs)[i]; |
| if (Expression *ea = isExpression(oa)) |
| ea->accept(this); |
| else if (Type *ta = isType(oa)) |
| ta->accept(this); |
| if (result) |
| return; |
| } |
| } |
| } |
| |
| void visit(CallExp *e) |
| { |
| //printf("CallExp::reliesOnTident('%s')\n", e->toChars()); |
| visit((UnaExp *)e); |
| if (!result && e->arguments) |
| { |
| for (size_t i = 0; i < e->arguments->length; i++) |
| { |
| Expression *ea = (*e->arguments)[i]; |
| ea->accept(this); |
| if (result) |
| return; |
| } |
| } |
| } |
| |
| void visit(CastExp *e) |
| { |
| //printf("CastExp::reliesOnTident('%s')\n", e->toChars()); |
| visit((UnaExp *)e); |
| // e.to can be null for cast() with no type |
| if (!result && e->to) |
| e->to->accept(this); |
| } |
| |
| void visit(SliceExp *e) |
| { |
| //printf("SliceExp::reliesOnTident('%s')\n", e->toChars()); |
| visit((UnaExp *)e); |
| if (!result && e->lwr) |
| e->lwr->accept(this); |
| if (!result && e->upr) |
| e->upr->accept(this); |
| } |
| |
| void visit(IntervalExp *e) |
| { |
| //printf("IntervalExp::reliesOnTident('%s')\n", e->toChars()); |
| e->lwr->accept(this); |
| if (!result) |
| e->upr->accept(this); |
| } |
| |
| void visit(ArrayExp *e) |
| { |
| //printf("ArrayExp::reliesOnTident('%s')\n", e->toChars()); |
| visit((UnaExp *)e); |
| if (!result && e->arguments) |
| { |
| for (size_t i = 0; i < e->arguments->length; i++) |
| { |
| Expression *ea = (*e->arguments)[i]; |
| ea->accept(this); |
| } |
| } |
| } |
| |
| void visit(BinExp *e) |
| { |
| //printf("BinExp::reliesOnTident('%s')\n", e->toChars()); |
| e->e1->accept(this); |
| if (!result) |
| e->e2->accept(this); |
| } |
| |
| void visit(CondExp *e) |
| { |
| //printf("BinExp::reliesOnTident('%s')\n", e->toChars()); |
| e->econd->accept(this); |
| if (!result) |
| visit((BinExp *)e); |
| } |
| }; |
| |
| if (!t) |
| return false; |
| |
| ReliesOnTident v(tparams, iStart); |
| t->accept(&v); |
| return v.result; |
| } |
| |
| /* ======================== TemplateParameter =============================== */ |
| |
| TemplateParameter::TemplateParameter(Loc loc, Identifier *ident) |
| { |
| this->loc = loc; |
| this->ident = ident; |
| this->dependent = false; |
| } |
| |
| TemplateTypeParameter *TemplateParameter::isTemplateTypeParameter() |
| { |
| return NULL; |
| } |
| |
| TemplateValueParameter *TemplateParameter::isTemplateValueParameter() |
| { |
| return NULL; |
| } |
| |
| TemplateAliasParameter *TemplateParameter::isTemplateAliasParameter() |
| { |
| return NULL; |
| } |
| |
| TemplateTupleParameter *TemplateParameter::isTemplateTupleParameter() |
| { |
| return NULL; |
| } |
| |
| TemplateThisParameter *TemplateParameter::isTemplateThisParameter() |
| { |
| return NULL; |
| } |
| |
| /******************************************* |
| * Match to a particular TemplateParameter. |
| * Input: |
| * instLoc location that the template is instantiated. |
| * tiargs[] actual arguments to template instance |
| * i i'th argument |
| * parameters[] template parameters |
| * dedtypes[] deduced arguments to template instance |
| * *psparam set to symbol declared and initialized to dedtypes[i] |
| */ |
| MATCH TemplateParameter::matchArg(Loc instLoc, Scope *sc, Objects *tiargs, |
| size_t i, TemplateParameters *parameters, Objects *dedtypes, |
| Declaration **psparam) |
| { |
| RootObject *oarg; |
| |
| if (i < tiargs->length) |
| oarg = (*tiargs)[i]; |
| else |
| { |
| // Get default argument instead |
| oarg = defaultArg(instLoc, sc); |
| if (!oarg) |
| { |
| assert(i < dedtypes->length); |
| // It might have already been deduced |
| oarg = (*dedtypes)[i]; |
| if (!oarg) |
| goto Lnomatch; |
| } |
| } |
| return matchArg(sc, oarg, i, parameters, dedtypes, psparam); |
| |
| Lnomatch: |
| if (psparam) |
| *psparam = NULL; |
| return MATCHnomatch; |
| } |
| |
| /* ======================== TemplateTypeParameter =========================== */ |
| |
| // type-parameter |
| |
| Type *TemplateTypeParameter::tdummy = NULL; |
| |
| TemplateTypeParameter::TemplateTypeParameter(Loc loc, Identifier *ident, Type *specType, |
| Type *defaultType) |
| : TemplateParameter(loc, ident) |
| { |
| this->ident = ident; |
| this->specType = specType; |
| this->defaultType = defaultType; |
| } |
| |
| TemplateTypeParameter *TemplateTypeParameter::isTemplateTypeParameter() |
| { |
| return this; |
| } |
| |
| TemplateParameter *TemplateTypeParameter::syntaxCopy() |
| { |
| return new TemplateTypeParameter(loc, ident, |
| specType ? specType->syntaxCopy() : NULL, |
| defaultType ? defaultType->syntaxCopy() : NULL); |
| } |
| |
| bool TemplateTypeParameter::declareParameter(Scope *sc) |
| { |
| //printf("TemplateTypeParameter::declareParameter('%s')\n", ident->toChars()); |
| TypeIdentifier *ti = new TypeIdentifier(loc, ident); |
| Declaration *ad = new AliasDeclaration(loc, ident, ti); |
| return sc->insert(ad) != NULL; |
| } |
| |
| MATCH TemplateTypeParameter::matchArg(Scope *sc, RootObject *oarg, |
| size_t i, TemplateParameters *parameters, Objects *dedtypes, |
| Declaration **psparam) |
| { |
| //printf("TemplateTypeParameter::matchArg('%s')\n", ident->toChars()); |
| MATCH m = MATCHexact; |
| Type *ta = isType(oarg); |
| if (!ta) |
| { |
| //printf("%s %p %p %p\n", oarg->toChars(), isExpression(oarg), isDsymbol(oarg), isTuple(oarg)); |
| goto Lnomatch; |
| } |
| //printf("ta is %s\n", ta->toChars()); |
| |
| if (specType) |
| { |
| if (!ta || ta == tdummy) |
| goto Lnomatch; |
| |
| //printf("\tcalling deduceType(): ta is %s, specType is %s\n", ta->toChars(), specType->toChars()); |
| MATCH m2 = deduceType(ta, sc, specType, parameters, dedtypes); |
| if (m2 <= MATCHnomatch) |
| { |
| //printf("\tfailed deduceType\n"); |
| goto Lnomatch; |
| } |
| |
| if (m2 < m) |
| m = m2; |
| if ((*dedtypes)[i]) |
| { |
| Type *t = (Type *)(*dedtypes)[i]; |
| |
| if (dependent && !t->equals(ta)) // Bugzilla 14357 |
| goto Lnomatch; |
| |
| /* This is a self-dependent parameter. For example: |
| * template X(T : T*) {} |
| * template X(T : S!T, alias S) {} |
| */ |
| //printf("t = %s ta = %s\n", t->toChars(), ta->toChars()); |
| ta = t; |
| } |
| } |
| else |
| { |
| if ((*dedtypes)[i]) |
| { |
| // Must match already deduced type |
| Type *t = (Type *)(*dedtypes)[i]; |
| |
| if (!t->equals(ta)) |
| { |
| //printf("t = %s ta = %s\n", t->toChars(), ta->toChars()); |
| goto Lnomatch; |
| } |
| } |
| else |
| { |
| // So that matches with specializations are better |
| m = MATCHconvert; |
| } |
| } |
| (*dedtypes)[i] = ta; |
| |
| if (psparam) |
| *psparam = new AliasDeclaration(loc, ident, ta); |
| //printf("\tm = %d\n", m); |
| return dependent ? MATCHexact : m; |
| |
| Lnomatch: |
| if (psparam) |
| *psparam = NULL; |
| //printf("\tm = %d\n", MATCHnomatch); |
| return MATCHnomatch; |
| } |
| |
| |
| void TemplateTypeParameter::print(RootObject *oarg, RootObject *oded) |
| { |
| printf(" %s\n", ident->toChars()); |
| |
| Type *t = isType(oarg); |
| Type *ta = isType(oded); |
| |
| assert(ta); |
| |
| if (specType) |
| printf("\tSpecialization: %s\n", specType->toChars()); |
| if (defaultType) |
| printf("\tDefault: %s\n", defaultType->toChars()); |
| printf("\tParameter: %s\n", t ? t->toChars() : "NULL"); |
| printf("\tDeduced Type: %s\n", ta->toChars()); |
| } |
| |
| void *TemplateTypeParameter::dummyArg() |
| { |
| Type *t = specType; |
| if (!t) |
| { |
| // Use this for alias-parameter's too (?) |
| if (!tdummy) |
| tdummy = new TypeIdentifier(loc, ident); |
| t = tdummy; |
| } |
| return (void *)t; |
| } |
| |
| |
| RootObject *TemplateTypeParameter::specialization() |
| { |
| return specType; |
| } |
| |
| RootObject *TemplateTypeParameter::defaultArg(Loc, Scope *sc) |
| { |
| Type *t = defaultType; |
| if (t) |
| { |
| t = t->syntaxCopy(); |
| t = typeSemantic(t, loc, sc); // use the parameter loc |
| } |
| return t; |
| } |
| |
| bool TemplateTypeParameter::hasDefaultArg() |
| { |
| return defaultType != NULL; |
| } |
| |
| /* ======================== TemplateThisParameter =========================== */ |
| |
| // this-parameter |
| |
| TemplateThisParameter::TemplateThisParameter(Loc loc, Identifier *ident, |
| Type *specType, |
| Type *defaultType) |
| : TemplateTypeParameter(loc, ident, specType, defaultType) |
| { |
| } |
| |
| TemplateThisParameter *TemplateThisParameter::isTemplateThisParameter() |
| { |
| return this; |
| } |
| |
| TemplateParameter *TemplateThisParameter::syntaxCopy() |
| { |
| return new TemplateThisParameter(loc, ident, |
| specType ? specType->syntaxCopy() : NULL, |
| defaultType ? defaultType->syntaxCopy() : NULL); |
| } |
| |
| /* ======================== TemplateAliasParameter ========================== */ |
| |
| // alias-parameter |
| |
| Dsymbol *TemplateAliasParameter::sdummy = NULL; |
| |
| TemplateAliasParameter::TemplateAliasParameter(Loc loc, Identifier *ident, |
| Type *specType, RootObject *specAlias, RootObject *defaultAlias) |
| : TemplateParameter(loc, ident) |
| { |
| this->ident = ident; |
| this->specType = specType; |
| this->specAlias = specAlias; |
| this->defaultAlias = defaultAlias; |
| } |
| |
| TemplateAliasParameter *TemplateAliasParameter::isTemplateAliasParameter() |
| { |
| return this; |
| } |
| |
| TemplateParameter *TemplateAliasParameter::syntaxCopy() |
| { |
| return new TemplateAliasParameter(loc, ident, |
| specType ? specType->syntaxCopy() : NULL, |
| objectSyntaxCopy(specAlias), |
| objectSyntaxCopy(defaultAlias)); |
| } |
| |
| bool TemplateAliasParameter::declareParameter(Scope *sc) |
| { |
| TypeIdentifier *ti = new TypeIdentifier(loc, ident); |
| Declaration *ad = new AliasDeclaration(loc, ident, ti); |
| return sc->insert(ad) != NULL; |
| } |
| |
| MATCH TemplateAliasParameter::matchArg(Scope *sc, RootObject *oarg, |
| size_t i, TemplateParameters *parameters, Objects *dedtypes, |
| Declaration **psparam) |
| { |
| //printf("TemplateAliasParameter::matchArg('%s')\n", ident->toChars()); |
| MATCH m = MATCHexact; |
| Type *ta = isType(oarg); |
| RootObject *sa = ta && !ta->deco ? NULL : getDsymbol(oarg); |
| Expression *ea = isExpression(oarg); |
| if (ea && (ea->op == TOKthis || ea->op == TOKsuper)) |
| sa = ((ThisExp *)ea)->var; |
| else if (ea && ea->op == TOKscope) |
| sa = ((ScopeExp *)ea)->sds; |
| if (sa) |
| { |
| if (((Dsymbol *)sa)->isAggregateDeclaration()) |
| m = MATCHconvert; |
| |
| /* specType means the alias must be a declaration with a type |
| * that matches specType. |
| */ |
| if (specType) |
| { |
| Declaration *d = ((Dsymbol *)sa)->isDeclaration(); |
| if (!d) |
| goto Lnomatch; |
| if (!d->type->equals(specType)) |
| goto Lnomatch; |
| } |
| } |
| else |
| { |
| sa = oarg; |
| if (ea) |
| { |
| if (specType) |
| { |
| if (!ea->type->equals(specType)) |
| goto Lnomatch; |
| } |
| } |
| else if (ta && ta->ty == Tinstance && !specAlias) |
| { |
| /* Bugzilla xxxxx: Specialized parameter should be prefeerd |
| * match to the template type parameter. |
| * template X(alias a) {} // a == this |
| * template X(alias a : B!A, alias B, A...) {} // B!A => ta |
| */ |
| } |
| else if (sa && sa == TemplateTypeParameter::tdummy) |
| { |
| /* Bugzilla 2025: Aggregate Types should preferentially |
| * match to the template type parameter. |
| * template X(alias a) {} // a == this |
| * template X(T) {} // T => sa |
| */ |
| } |
| else if (ta && ta->ty != Tident) |
| { |
| /* Match any type that's not a TypeIdentifier to alias parameters, |
| * but prefer type parameter. |
| * template X(alias a) { } // a == ta |
| * |
| * TypeIdentifiers are excluded because they might be not yet resolved aliases. |
| */ |
| m = MATCHconvert; |
| } |
| else |
| goto Lnomatch; |
| } |
| |
| if (specAlias) |
| { |
| if (sa == sdummy) |
| goto Lnomatch; |
| Dsymbol *sx = isDsymbol(sa); |
| if (sa != specAlias && sx) |
| { |
| Type *talias = isType(specAlias); |
| if (!talias) |
| goto Lnomatch; |
| |
| TemplateInstance *ti = sx->isTemplateInstance(); |
| if (!ti && sx->parent) |
| { |
| ti = sx->parent->isTemplateInstance(); |
| if (ti && ti->name != sx->ident) |
| goto Lnomatch; |
| } |
| if (!ti) |
| goto Lnomatch; |
| |
| Type *t = new TypeInstance(Loc(), ti); |
| MATCH m2 = deduceType(t, sc, talias, parameters, dedtypes); |
| if (m2 <= MATCHnomatch) |
| goto Lnomatch; |
| } |
| } |
| else if ((*dedtypes)[i]) |
| { |
| // Must match already deduced symbol |
| RootObject *si = (*dedtypes)[i]; |
| if (!sa || si != sa) |
| goto Lnomatch; |
| } |
| (*dedtypes)[i] = sa; |
| |
| if (psparam) |
| { |
| if (Dsymbol *s = isDsymbol(sa)) |
| { |
| *psparam = new AliasDeclaration(loc, ident, s); |
| } |
| else if (Type *t = isType(sa)) |
| { |
| *psparam = new AliasDeclaration(loc, ident, t); |
| } |
| else |
| { |
| assert(ea); |
| |
| // Declare manifest constant |
| Initializer *init = new ExpInitializer(loc, ea); |
| VarDeclaration *v = new VarDeclaration(loc, NULL, ident, init); |
| v->storage_class = STCmanifest; |
| dsymbolSemantic(v, sc); |
| *psparam = v; |
| } |
| } |
| return dependent ? MATCHexact : m; |
| |
| Lnomatch: |
| if (psparam) |
| *psparam = NULL; |
| //printf("\tm = %d\n", MATCHnomatch); |
| return MATCHnomatch; |
| } |
| |
| |
| void TemplateAliasParameter::print(RootObject *, RootObject *oded) |
| { |
| printf(" %s\n", ident->toChars()); |
| |
| Dsymbol *sa = isDsymbol(oded); |
| assert(sa); |
| |
| printf("\tParameter alias: %s\n", sa->toChars()); |
| } |
| |
| void *TemplateAliasParameter::dummyArg() |
| { |
| RootObject *s = specAlias; |
| if (!s) |
| { |
| if (!sdummy) |
| sdummy = new Dsymbol(); |
| s = sdummy; |
| } |
| return (void*)s; |
| } |
| |
| |
| RootObject *TemplateAliasParameter::specialization() |
| { |
| return specAlias; |
| } |
| |
| RootObject *TemplateAliasParameter::defaultArg(Loc, Scope *sc) |
| { |
| RootObject *da = defaultAlias; |
| Type *ta = isType(defaultAlias); |
| if (ta) |
| { |
| if (ta->ty == Tinstance) |
| { |
| // If the default arg is a template, instantiate for each type |
| da = ta->syntaxCopy(); |
| } |
| } |
| |
| RootObject *o = aliasParameterSemantic(loc, sc, da, NULL); // use the parameter loc |
| return o; |
| } |
| |
| bool TemplateAliasParameter::hasDefaultArg() |
| { |
| return defaultAlias != NULL; |
| } |
| |
| /* ======================== TemplateValueParameter ========================== */ |
| |
| // value-parameter |
| |
| AA *TemplateValueParameter::edummies = NULL; |
| |
| TemplateValueParameter::TemplateValueParameter(Loc loc, Identifier *ident, Type *valType, |
| Expression *specValue, Expression *defaultValue) |
| : TemplateParameter(loc, ident) |
| { |
| this->ident = ident; |
| this->valType = valType; |
| this->specValue = specValue; |
| this->defaultValue = defaultValue; |
| } |
| |
| TemplateValueParameter *TemplateValueParameter::isTemplateValueParameter() |
| { |
| return this; |
| } |
| |
| TemplateParameter *TemplateValueParameter::syntaxCopy() |
| { |
| return new TemplateValueParameter(loc, ident, |
| valType->syntaxCopy(), |
| specValue ? specValue->syntaxCopy() : NULL, |
| defaultValue ? defaultValue->syntaxCopy() : NULL); |
| } |
| |
| bool TemplateValueParameter::declareParameter(Scope *sc) |
| { |
| VarDeclaration *v = new VarDeclaration(loc, valType, ident, NULL); |
| v->storage_class = STCtemplateparameter; |
| return sc->insert(v) != NULL; |
| } |
| |
| MATCH TemplateValueParameter::matchArg(Scope *sc, RootObject *oarg, |
| size_t i, TemplateParameters *, Objects *dedtypes, Declaration **psparam) |
| { |
| //printf("TemplateValueParameter::matchArg('%s')\n", ident->toChars()); |
| |
| MATCH m = MATCHexact; |
| |
| Expression *ei = isExpression(oarg); |
| Type *vt; |
| |
| if (!ei && oarg) |
| { |
| Dsymbol *si = isDsymbol(oarg); |
| FuncDeclaration *f = si ? si->isFuncDeclaration() : NULL; |
| if (!f || !f->fbody || f->needThis()) |
| goto Lnomatch; |
| |
| ei = new VarExp(loc, f); |
| ei = expressionSemantic(ei, sc); |
| |
| /* If a function is really property-like, and then |
| * it's CTFEable, ei will be a literal expression. |
| */ |
| unsigned int olderrors = global.startGagging(); |
| ei = resolveProperties(sc, ei); |
| ei = ei->ctfeInterpret(); |
| if (global.endGagging(olderrors) || ei->op == TOKerror) |
| goto Lnomatch; |
| |
| /* Bugzilla 14520: A property-like function can match to both |
| * TemplateAlias and ValueParameter. But for template overloads, |
| * it should always prefer alias parameter to be consistent |
| * template match result. |
| * |
| * template X(alias f) { enum X = 1; } |
| * template X(int val) { enum X = 2; } |
| * int f1() { return 0; } // CTFEable |
| * int f2(); // body-less function is not CTFEable |
| * enum x1 = X!f1; // should be 1 |
| * enum x2 = X!f2; // should be 1 |
| * |
| * e.g. The x1 value must be same even if the f1 definition will be moved |
| * into di while stripping body code. |
| */ |
| m = MATCHconvert; |
| } |
| |
| if (ei && ei->op == TOKvar) |
| { |
| // Resolve const variables that we had skipped earlier |
| ei = ei->ctfeInterpret(); |
| } |
| |
| //printf("\tvalType: %s, ty = %d\n", valType->toChars(), valType->ty); |
| vt = typeSemantic(valType, loc, sc); |
| //printf("ei: %s, ei->type: %s\n", ei->toChars(), ei->type->toChars()); |
| //printf("vt = %s\n", vt->toChars()); |
| |
| if (ei->type) |
| { |
| MATCH m2 = ei->implicitConvTo(vt); |
| //printf("m: %d\n", m); |
| if (m2 < m) |
| m = m2; |
| if (m <= MATCHnomatch) |
| goto Lnomatch; |
| ei = ei->implicitCastTo(sc, vt); |
| ei = ei->ctfeInterpret(); |
| } |
| |
| if (specValue) |
| { |
| if (!ei || (Expression *)dmd_aaGetRvalue(edummies, (void *)ei->type) == ei) |
| goto Lnomatch; |
| |
| Expression *e = specValue; |
| |
| sc = sc->startCTFE(); |
| e = expressionSemantic(e, sc); |
| e = resolveProperties(sc, e); |
| sc = sc->endCTFE(); |
| e = e->implicitCastTo(sc, vt); |
| e = e->ctfeInterpret(); |
| |
| ei = ei->syntaxCopy(); |
| sc = sc->startCTFE(); |
| ei = expressionSemantic(ei, sc); |
| sc = sc->endCTFE(); |
| ei = ei->implicitCastTo(sc, vt); |
| ei = ei->ctfeInterpret(); |
| //printf("\tei: %s, %s\n", ei->toChars(), ei->type->toChars()); |
| //printf("\te : %s, %s\n", e->toChars(), e->type->toChars()); |
| if (!ei->equals(e)) |
| goto Lnomatch; |
| } |
| else |
| { |
| if ((*dedtypes)[i]) |
| { |
| // Must match already deduced value |
| Expression *e = (Expression *)(*dedtypes)[i]; |
| |
| if (!ei || !ei->equals(e)) |
| goto Lnomatch; |
| } |
| } |
| (*dedtypes)[i] = ei; |
| |
| if (psparam) |
| { |
| Initializer *init = new ExpInitializer(loc, ei); |
| Declaration *sparam = new VarDeclaration(loc, vt, ident, init); |
| sparam->storage_class = STCmanifest; |
| *psparam = sparam; |
| } |
| return dependent ? MATCHexact : m; |
| |
| Lnomatch: |
| //printf("\tno match\n"); |
| if (psparam) |
| *psparam = NULL; |
| return MATCHnomatch; |
| } |
| |
| |
| void TemplateValueParameter::print(RootObject *, RootObject *oded) |
| { |
| printf(" %s\n", ident->toChars()); |
| |
| Expression *ea = isExpression(oded); |
| |
| if (specValue) |
| printf("\tSpecialization: %s\n", specValue->toChars()); |
| printf("\tParameter Value: %s\n", ea ? ea->toChars() : "NULL"); |
| } |
| |
| void *TemplateValueParameter::dummyArg() |
| { |
| Expression *e = specValue; |
| if (!e) |
| { |
| // Create a dummy value |
| Expression **pe = (Expression **)dmd_aaGet(&edummies, (void *)valType); |
| if (!*pe) |
| *pe = valType->defaultInit(); |
| e = *pe; |
| } |
| return (void *)e; |
| } |
| |
| |
| RootObject *TemplateValueParameter::specialization() |
| { |
| return specValue; |
| } |
| |
| RootObject *TemplateValueParameter::defaultArg(Loc instLoc, Scope *sc) |
| { |
| Expression *e = defaultValue; |
| if (e) |
| { |
| e = e->syntaxCopy(); |
| unsigned olderrs = global.errors; |
| if ((e = expressionSemantic(e, sc)) == NULL) |
| return NULL; |
| if ((e = resolveProperties(sc, e)) == NULL) |
| return NULL; |
| e = e->resolveLoc(instLoc, sc); // use the instantiated loc |
| e = e->optimize(WANTvalue); |
| if (global.errors != olderrs) |
| e = new ErrorExp(); |
| } |
| return e; |
| } |
| |
| bool TemplateValueParameter::hasDefaultArg() |
| { |
| return defaultValue != NULL; |
| } |
| |
| /* ======================== TemplateTupleParameter ========================== */ |
| |
| // variadic-parameter |
| |
| TemplateTupleParameter::TemplateTupleParameter(Loc loc, Identifier *ident) |
| : TemplateParameter(loc, ident) |
| { |
| this->ident = ident; |
| } |
| |
| TemplateTupleParameter *TemplateTupleParameter::isTemplateTupleParameter() |
| { |
| return this; |
| } |
| |
| TemplateParameter *TemplateTupleParameter::syntaxCopy() |
| { |
| return new TemplateTupleParameter(loc, ident); |
| } |
| |
| bool TemplateTupleParameter::declareParameter(Scope *sc) |
| { |
| TypeIdentifier *ti = new TypeIdentifier(loc, ident); |
| Declaration *ad = new AliasDeclaration(loc, ident, ti); |
| return sc->insert(ad) != NULL; |
| } |
| |
| MATCH TemplateTupleParameter::matchArg(Loc, Scope *sc, Objects *tiargs, |
| size_t i, TemplateParameters *parameters, Objects *dedtypes, |
| Declaration **psparam) |
| { |
| /* The rest of the actual arguments (tiargs[]) form the match |
| * for the variadic parameter. |
| */ |
| assert(i + 1 == dedtypes->length); // must be the last one |
| Tuple *ovar; |
| |
| if (Tuple *u = isTuple((*dedtypes)[i])) |
| { |
| // It has already been deduced |
| ovar = u; |
| } |
| else if (i + 1 == tiargs->length && isTuple((*tiargs)[i])) |
| ovar = isTuple((*tiargs)[i]); |
| else |
| { |
| ovar = new Tuple(); |
| //printf("ovar = %p\n", ovar); |
| if (i < tiargs->length) |
| { |
| //printf("i = %d, tiargs->length = %d\n", i, tiargs->length); |
| ovar->objects.setDim(tiargs->length - i); |
| for (size_t j = 0; j < ovar->objects.length; j++) |
| ovar->objects[j] = (*tiargs)[i + j]; |
| } |
| } |
| return matchArg(sc, ovar, i, parameters, dedtypes, psparam); |
| } |
| |
| MATCH TemplateTupleParameter::matchArg(Scope *, RootObject *oarg, |
| size_t i, TemplateParameters *, Objects *dedtypes, Declaration **psparam) |
| { |
| //printf("TemplateTupleParameter::matchArg('%s')\n", ident->toChars()); |
| Tuple *ovar = isTuple(oarg); |
| if (!ovar) |
| return MATCHnomatch; |
| if ((*dedtypes)[i]) |
| { |
| Tuple *tup = isTuple((*dedtypes)[i]); |
| if (!tup) |
| return MATCHnomatch; |
| if (!match(tup, ovar)) |
| return MATCHnomatch; |
| } |
| (*dedtypes)[i] = ovar; |
| |
| if (psparam) |
| *psparam = new TupleDeclaration(loc, ident, &ovar->objects); |
| return dependent ? MATCHexact : MATCHconvert; |
| } |
| |
| |
| void TemplateTupleParameter::print(RootObject *, RootObject *oded) |
| { |
| printf(" %s... [", ident->toChars()); |
| Tuple *v = isTuple(oded); |
| assert(v); |
| |
| //printf("|%d| ", v->objects.length); |
| for (size_t i = 0; i < v->objects.length; i++) |
| { |
| if (i) |
| printf(", "); |
| |
| RootObject *o = v->objects[i]; |
| |
| Dsymbol *sa = isDsymbol(o); |
| if (sa) |
| printf("alias: %s", sa->toChars()); |
| |
| Type *ta = isType(o); |
| if (ta) |
| printf("type: %s", ta->toChars()); |
| |
| Expression *ea = isExpression(o); |
| if (ea) |
| printf("exp: %s", ea->toChars()); |
| |
| assert(!isTuple(o)); // no nested Tuple arguments |
| } |
| |
| printf("]\n"); |
| } |
| |
| void *TemplateTupleParameter::dummyArg() |
| { |
| return NULL; |
| } |
| |
| |
| RootObject *TemplateTupleParameter::specialization() |
| { |
| return NULL; |
| } |
| |
| RootObject *TemplateTupleParameter::defaultArg(Loc, Scope *) |
| { |
| return NULL; |
| } |
| |
| bool TemplateTupleParameter::hasDefaultArg() |
| { |
| return false; |
| } |
| |
| /* ======================== TemplateInstance ================================ */ |
| |
| TemplateInstance::TemplateInstance(Loc loc, Identifier *ident) |
| : ScopeDsymbol(NULL) |
| { |
| this->loc = loc; |
| this->name = ident; |
| this->tiargs = NULL; |
| this->tempdecl = NULL; |
| this->inst = NULL; |
| this->tinst = NULL; |
| this->tnext = NULL; |
| this->minst = NULL; |
| this->deferred = NULL; |
| this->memberOf = NULL; |
| this->argsym = NULL; |
| this->aliasdecl = NULL; |
| this->semantictiargsdone = false; |
| this->inuse = 0; |
| this->nest = 0; |
| this->havetempdecl = false; |
| this->enclosing = NULL; |
| this->gagged = false; |
| this->hash = 0; |
| this->fargs = NULL; |
| } |
| |
| /***************** |
| * This constructor is only called when we figured out which function |
| * template to instantiate. |
| */ |
| |
| TemplateInstance::TemplateInstance(Loc loc, TemplateDeclaration *td, Objects *tiargs) |
| : ScopeDsymbol(NULL) |
| { |
| this->loc = loc; |
| this->name = td->ident; |
| this->tiargs = tiargs; |
| this->tempdecl = td; |
| this->inst = NULL; |
| this->tinst = NULL; |
| this->tnext = NULL; |
| this->minst = NULL; |
| this->deferred = NULL; |
| this->memberOf = NULL; |
| this->argsym = NULL; |
| this->aliasdecl = NULL; |
| this->semantictiargsdone = true; |
| this->inuse = 0; |
| this->nest = 0; |
| this->havetempdecl = true; |
| this->enclosing = NULL; |
| this->gagged = false; |
| this->hash = 0; |
| this->fargs = NULL; |
| |
| assert(tempdecl->_scope); |
| } |
| |
| |
| Objects *TemplateInstance::arraySyntaxCopy(Objects *objs) |
| { |
| Objects *a = NULL; |
| if (objs) |
| { |
| a = new Objects(); |
| a->setDim(objs->length); |
| for (size_t i = 0; i < objs->length; i++) |
| (*a)[i] = objectSyntaxCopy((*objs)[i]); |
| } |
| return a; |
| } |
| |
| Dsymbol *TemplateInstance::syntaxCopy(Dsymbol *s) |
| { |
| TemplateInstance *ti = |
| s ? (TemplateInstance *)s |
| : new TemplateInstance(loc, name); |
| ti->tiargs = arraySyntaxCopy(tiargs); |
| TemplateDeclaration *td; |
| if (inst && tempdecl && (td = tempdecl->isTemplateDeclaration()) != NULL) |
| td->ScopeDsymbol::syntaxCopy(ti); |
| else |
| ScopeDsymbol::syntaxCopy(ti); |
| return ti; |
| } |
| |
| void TemplateInstance::expandMembers(Scope *sc2) |
| { |
| for (size_t i = 0; i < members->length; i++) |
| { |
| Dsymbol *s = (*members)[i]; |
| s->setScope(sc2); |
| } |
| |
| for (size_t i = 0; i < members->length; i++) |
| { |
| Dsymbol *s = (*members)[i]; |
| s->importAll(sc2); |
| } |
| |
| for (size_t i = 0; i < members->length; i++) |
| { |
| Dsymbol *s = (*members)[i]; |
| //printf("\t[%d] semantic on '%s' %p kind %s in '%s'\n", i, s->toChars(), s, s->kind(), this->toChars()); |
| //printf("test: enclosing = %d, sc2->parent = %s\n", enclosing, sc2->parent->toChars()); |
| // if (enclosing) |
| // s->parent = sc->parent; |
| //printf("test3: enclosing = %d, s->parent = %s\n", enclosing, s->parent->toChars()); |
| dsymbolSemantic(s, sc2); |
| //printf("test4: enclosing = %d, s->parent = %s\n", enclosing, s->parent->toChars()); |
| Module::runDeferredSemantic(); |
| } |
| } |
| |
| void TemplateInstance::tryExpandMembers(Scope *sc2) |
| { |
| static int nest; |
| // extracted to a function to allow windows SEH to work without destructors in the same function |
| //printf("%d\n", nest); |
| if (++nest > global.recursionLimit) |
| { |
| global.gag = 0; // ensure error message gets printed |
| error("recursive expansion exceeded allowed nesting limit"); |
| fatal(); |
| } |
| |
| expandMembers(sc2); |
| |
| nest--; |
| } |
| |
| void TemplateInstance::trySemantic3(Scope *sc2) |
| { |
| // extracted to a function to allow windows SEH to work without destructors in the same function |
| static int nest; |
| //printf("%d\n", nest); |
| if (++nest > global.recursionLimit) |
| { |
| global.gag = 0; // ensure error message gets printed |
| error("recursive expansion exceeded allowed nesting limit"); |
| fatal(); |
| } |
| semantic3(this, sc2); |
| |
| --nest; |
| } |
| |
| /********************************************** |
| * Find template declaration corresponding to template instance. |
| * |
| * Returns: |
| * false if finding fails. |
| * Note: |
| * This function is reentrant against error occurrence. If returns false, |
| * any members of this object won't be modified, and repetition call will |
| * reproduce same error. |
| */ |
| |
| bool TemplateInstance::findTempDecl(Scope *sc, WithScopeSymbol **pwithsym) |
| { |
| if (pwithsym) |
| *pwithsym = NULL; |
| |
| if (havetempdecl) |
| return true; |
| |
| //printf("TemplateInstance::findTempDecl() %s\n", toChars()); |
| if (!tempdecl) |
| { |
| /* Given: |
| * foo!( ... ) |
| * figure out which TemplateDeclaration foo refers to. |
| */ |
| Identifier *id = name; |
| Dsymbol *scopesym; |
| Dsymbol *s = sc->search(loc, id, &scopesym); |
| if (!s) |
| { |
| s = sc->search_correct(id); |
| if (s) |
| error("template `%s` is not defined, did you mean %s?", id->toChars(), s->toChars()); |
| else |
| error("template `%s` is not defined", id->toChars()); |
| return false; |
| } |
| |
| if (pwithsym) |
| *pwithsym = scopesym->isWithScopeSymbol(); |
| |
| /* We might have found an alias within a template when |
| * we really want the template. |
| */ |
| TemplateInstance *ti; |
| if (s->parent && |
| (ti = s->parent->isTemplateInstance()) != NULL) |
| { |
| if (ti->tempdecl && ti->tempdecl->ident == id) |
| { |
| /* This is so that one can refer to the enclosing |
| * template, even if it has the same name as a member |
| * of the template, if it has a !(arguments) |
| */ |
| TemplateDeclaration *td = ti->tempdecl->isTemplateDeclaration(); |
| assert(td); |
| if (td->overroot) // if not start of overloaded list of TemplateDeclaration's |
| td = td->overroot; // then get the start |
| s = td; |
| } |
| } |
| |
| if (!updateTempDecl(sc, s)) |
| { |
| return false; |
| } |
| } |
| assert(tempdecl); |
| |
| struct ParamFwdTi |
| { |
| static int fp(void *param, Dsymbol *s) |
| { |
| TemplateDeclaration *td = s->isTemplateDeclaration(); |
| if (!td) |
| return 0; |
| |
| TemplateInstance *ti = (TemplateInstance *)param; |
| if (td->semanticRun == PASSinit) |
| { |
| if (td->_scope) |
| { |
| // Try to fix forward reference. Ungag errors while doing so. |
| Ungag ungag = td->ungagSpeculative(); |
| dsymbolSemantic(td, td->_scope); |
| } |
| if (td->semanticRun == PASSinit) |
| { |
| ti->error("%s forward references template declaration %s", ti->toChars(), td->toChars()); |
| return 1; |
| } |
| } |
| return 0; |
| } |
| }; |
| // Look for forward references |
| OverloadSet *tovers = tempdecl->isOverloadSet(); |
| size_t overs_dim = tovers ? tovers->a.length : 1; |
| for (size_t oi = 0; oi < overs_dim; oi++) |
| { |
| if (overloadApply(tovers ? tovers->a[oi] : tempdecl, (void *)this, &ParamFwdTi::fp)) |
| return false; |
| } |
| return true; |
| } |
| |
| /********************************************** |
| * Confirm s is a valid template, then store it. |
| * Input: |
| * sc |
| * s candidate symbol of template. It may be: |
| * TemplateDeclaration |
| * FuncDeclaration with findTemplateDeclRoot() != NULL |
| * OverloadSet which contains candidates |
| * Returns: |
| * true if updating succeeds. |
| */ |
| |
| bool TemplateInstance::updateTempDecl(Scope *sc, Dsymbol *s) |
| { |
| if (s) |
| { |
| Identifier *id = name; |
| s = s->toAlias(); |
| |
| /* If an OverloadSet, look for a unique member that is a template declaration |
| */ |
| OverloadSet *os = s->isOverloadSet(); |
| if (os) |
| { |
| s = NULL; |
| for (size_t i = 0; i < os->a.length; i++) |
| { |
| Dsymbol *s2 = os->a[i]; |
| if (FuncDeclaration *f = s2->isFuncDeclaration()) |
| s2 = f->findTemplateDeclRoot(); |
| else |
| s2 = s2->isTemplateDeclaration(); |
| if (s2) |
| { |
| if (s) |
| { |
| tempdecl = os; |
| return true; |
| } |
| s = s2; |
| } |
| } |
| if (!s) |
| { |
| error("template `%s` is not defined", id->toChars()); |
| return false; |
| } |
| } |
| |
| OverDeclaration *od = s->isOverDeclaration(); |
| if (od) |
| { |
| tempdecl = od; // TODO: more strict check |
| return true; |
| } |
| |
| /* It should be a TemplateDeclaration, not some other symbol |
| */ |
| if (FuncDeclaration *f = s->isFuncDeclaration()) |
| tempdecl = f->findTemplateDeclRoot(); |
| else |
| tempdecl = s->isTemplateDeclaration(); |
| if (!tempdecl) |
| { |
| if (!s->parent && global.errors) |
| return false; |
| if (!s->parent && s->getType()) |
| { |
| Dsymbol *s2 = s->getType()->toDsymbol(sc); |
| if (!s2) |
| { |
| error("%s is not a template declaration, it is a %s", id->toChars(), s->kind()); |
| return false; |
| } |
| s = s2; |
| } |
| //assert(s->parent); |
| TemplateInstance *ti = s->parent ? s->parent->isTemplateInstance() : NULL; |
| if (ti && |
| (ti->name == s->ident || |
| ti->toAlias()->ident == s->ident) |
| && |
| ti->tempdecl) |
| { |
| /* This is so that one can refer to the enclosing |
| * template, even if it has the same name as a member |
| * of the template, if it has a !(arguments) |
| */ |
| TemplateDeclaration *td = ti->tempdecl->isTemplateDeclaration(); |
| assert(td); |
| if (td->overroot) // if not start of overloaded list of TemplateDeclaration's |
| td = td->overroot; // then get the start |
| tempdecl = td; |
| } |
| else |
| { |
| error("%s is not a template declaration, it is a %s", id->toChars(), s->kind()); |
| return false; |
| } |
| } |
| } |
| return (tempdecl != NULL); |
| } |
| |
| /********************************** |
| * Run semantic on the elements of tiargs. |
| * Input: |
| * sc |
| * Returns: |
| * false if one or more arguments have errors. |
| * Note: |
| * This function is reentrant against error occurrence. If returns false, |
| * all elements of tiargs won't be modified. |
| */ |
| |
| bool TemplateInstance::semanticTiargs(Scope *sc) |
| { |
| //printf("+TemplateInstance::semanticTiargs() %s\n", toChars()); |
| if (semantictiargsdone) |
| return true; |
| if (semanticTiargs(loc, sc, tiargs, 0)) |
| { |
| // cache the result iff semantic analysis succeeded entirely |
| semantictiargsdone = 1; |
| return true; |
| } |
| return false; |
| } |
| |
| /********************************** |
| * Run semantic of tiargs as arguments of template. |
| * Input: |
| * loc |
| * sc |
| * tiargs array of template arguments |
| * flags 1: replace const variables with their initializers |
| * 2: don't devolve Parameter to Type |
| * Returns: |
| * false if one or more arguments have errors. |
| */ |
| |
| bool TemplateInstance::semanticTiargs(Loc loc, Scope *sc, Objects *tiargs, int flags) |
| { |
| // Run semantic on each argument, place results in tiargs[] |
| //printf("+TemplateInstance::semanticTiargs()\n"); |
| if (!tiargs) |
| return true; |
| bool err = false; |
| for (size_t j = 0; j < tiargs->length; j++) |
| { |
| RootObject *o = (*tiargs)[j]; |
| Type *ta = isType(o); |
| Expression *ea = isExpression(o); |
| Dsymbol *sa = isDsymbol(o); |
| |
| //printf("1: (*tiargs)[%d] = %p, s=%p, v=%p, ea=%p, ta=%p\n", j, o, isDsymbol(o), isTuple(o), ea, ta); |
| if (ta) |
| { |
| //printf("type %s\n", ta->toChars()); |
| |
| // It might really be an Expression or an Alias |
| ta->resolve(loc, sc, &ea, &ta, &sa, (flags & 1) != 0); |
| if (ea) goto Lexpr; |
| if (sa) goto Ldsym; |
| if (ta == NULL) |
| { |
| assert(global.errors); |
| ta = Type::terror; |
| } |
| |
| Ltype: |
| if (ta->ty == Ttuple) |
| { |
| // Expand tuple |
| TypeTuple *tt = (TypeTuple *)ta; |
| size_t dim = tt->arguments->length; |
| tiargs->remove(j); |
| if (dim) |
| { |
| tiargs->reserve(dim); |
| for (size_t i = 0; i < dim; i++) |
| { |
| Parameter *arg = (*tt->arguments)[i]; |
| if (flags & 2 && (arg->ident || arg->userAttribDecl)) |
| tiargs->insert(j + i, arg); |
| else |
| tiargs->insert(j + i, arg->type); |
| } |
| } |
| j--; |
| continue; |
| } |
| if (ta->ty == Terror) |
| { |
| err = true; |
| continue; |
| } |
| (*tiargs)[j] = ta->merge2(); |
| } |
| else if (ea) |
| { |
| Lexpr: |
| //printf("+[%d] ea = %s %s\n", j, Token::toChars(ea->op), ea->toChars()); |
| if (flags & 1) // only used by __traits |
| { |
| ea = expressionSemantic(ea, sc); |
| |
| // must not interpret the args, excepting template parameters |
| if (ea->op != TOKvar || |
| (((VarExp *)ea)->var->storage_class & STCtemplateparameter)) |
| { |
| ea = ea->optimize(WANTvalue); |
| } |
| } |
| else |
| { |
| sc = sc->startCTFE(); |
| ea = expressionSemantic(ea, sc); |
| sc = sc->endCTFE(); |
| |
| if (ea->op == TOKvar) |
| { |
| /* This test is to skip substituting a const var with |
| * its initializer. The problem is the initializer won't |
| * match with an 'alias' parameter. Instead, do the |
| * const substitution in TemplateValueParameter::matchArg(). |
| */ |
| } |
| else if (definitelyValueParameter(ea)) |
| { |
| if (ea->checkValue()) // check void expression |
| ea = new ErrorExp(); |
| unsigned int olderrs = global.errors; |
| ea = ea->ctfeInterpret(); |
| if (global.errors != olderrs) |
| ea = new ErrorExp(); |
| } |
| } |
| //printf("-[%d] ea = %s %s\n", j, Token::toChars(ea->op), ea->toChars()); |
| if (ea->op == TOKtuple) |
| { |
| // Expand tuple |
| TupleExp *te = (TupleExp *)ea; |
| size_t dim = te->exps->length; |
| tiargs->remove(j); |
| if (dim) |
| { |
| tiargs->reserve(dim); |
| for (size_t i = 0; i < dim; i++) |
| tiargs->insert(j + i, (*te->exps)[i]); |
| } |
| j--; |
| continue; |
| } |
| if (ea->op == TOKerror) |
| { |
| err = true; |
| continue; |
| } |
| (*tiargs)[j] = ea; |
| |
| if (ea->op == TOKtype) |
| { |
| ta = ea->type; |
| goto Ltype; |
| } |
| if (ea->op == TOKscope) |
| { |
| sa = ((ScopeExp *)ea)->sds; |
| goto Ldsym; |
| } |
| if (ea->op == TOKfunction) |
| { |
| FuncExp *fe = (FuncExp *)ea; |
| /* A function literal, that is passed to template and |
| * already semanticed as function pointer, never requires |
| * outer frame. So convert it to global function is valid. |
| */ |
| if (fe->fd->tok == TOKreserved && fe->type->ty == Tpointer) |
| { |
| // change to non-nested |
| fe->fd->tok = TOKfunction; |
| fe->fd->vthis = NULL; |
| } |
| else if (fe->td) |
| { |
| /* If template argument is a template lambda, |
| * get template declaration itself. */ |
| //sa = fe->td; |
| //goto Ldsym; |
| } |
| } |
| if (ea->op == TOKdotvar && !(flags & 1)) |
| { |
| // translate expression to dsymbol. |
| sa = ((DotVarExp *)ea)->var; |
| goto Ldsym; |
| } |
| if (ea->op == TOKtemplate) |
| { |
| sa = ((TemplateExp *)ea)->td; |
| goto Ldsym; |
| } |
| if (ea->op == TOKdottd && !(flags & 1)) |
| { |
| // translate expression to dsymbol. |
| sa = ((DotTemplateExp *)ea)->td; |
| goto Ldsym; |
| } |
| if (ea->op == TOKdot) |
| { |
| if (ScopeExp *se = ((DotExp *)ea)->e2->isScopeExp()) |
| { |
| sa = se->sds; |
| goto Ldsym; |
| } |
| } |
| } |
| else if (sa) |
| { |
| Ldsym: |
| //printf("dsym %s %s\n", sa->kind(), sa->toChars()); |
| if (sa->errors) |
| { |
| err = true; |
| continue; |
| } |
| |
| TupleDeclaration *d = sa->toAlias()->isTupleDeclaration(); |
| if (d) |
| { |
| // Expand tuple |
| tiargs->remove(j); |
| tiargs->insert(j, d->objects); |
| j--; |
| continue; |
| } |
| if (FuncAliasDeclaration *fa = sa->isFuncAliasDeclaration()) |
| { |
| FuncDeclaration *f = fa->toAliasFunc(); |
| if (!fa->hasOverloads && f->isUnique()) |
| { |
| // Strip FuncAlias only when the aliased function |
| // does not have any overloads. |
| sa = f; |
| } |
| } |
| (*tiargs)[j] = sa; |
| |
| TemplateDeclaration *td = sa->isTemplateDeclaration(); |
| if (td && td->semanticRun == PASSinit && td->literal) |
| { |
| dsymbolSemantic(td, sc); |
| } |
| FuncDeclaration *fd = sa->isFuncDeclaration(); |
| if (fd) |
| fd->functionSemantic(); |
| } |
| else if (isParameter(o)) |
| { |
| } |
| else |
| { |
| assert(0); |
| } |
| //printf("1: (*tiargs)[%d] = %p\n", j, (*tiargs)[j]); |
| } |
| return !err; |
| } |
| |
| bool TemplateInstance::findBestMatch(Scope *sc, Expressions *fargs) |
| { |
| if (havetempdecl) |
| { |
| TemplateDeclaration *tempdecl = this->tempdecl->isTemplateDeclaration(); |
| assert(tempdecl); |
| assert(tempdecl->_scope); |
| // Deduce tdtypes |
| tdtypes.setDim(tempdecl->parameters->length); |
| if (!tempdecl->matchWithInstance(sc, this, &tdtypes, fargs, 2)) |
| { |
| error("incompatible arguments for template instantiation"); |
| return false; |
| } |
| // TODO: Normalizing tiargs for bugzilla 7469 is necessary? |
| return true; |
| } |
| |
| unsigned errs = global.errors; |
| TemplateDeclaration *td_last = NULL; |
| |
| struct ParamBest |
| { |
| // context |
| Scope *sc; |
| TemplateInstance *ti; |
| Objects dedtypes; |
| // result |
| TemplateDeclaration *td_best; |
| TemplateDeclaration *td_ambig; |
| MATCH m_best; |
| |
| static int fp(void *param, Dsymbol *s) |
| { |
| return ((ParamBest *)param)->fp(s); |
| } |
| int fp(Dsymbol *s) |
| { |
| TemplateDeclaration *td = s->isTemplateDeclaration(); |
| if (!td) |
| return 0; |
| if (td->inuse) |
| { |
| td->error(ti->loc, "recursive template expansion"); |
| return 1; |
| } |
| if (td == td_best) // skip duplicates |
| return 0; |
| |
| //printf("td = %s\n", td->toPrettyChars()); |
| |
| // If more arguments than parameters, |
| // then this is no match. |
| if (td->parameters->length < ti->tiargs->length) |
| { |
| if (!td->isVariadic()) |
| return 0; |
| } |
| |
| dedtypes.setDim(td->parameters->length); |
| dedtypes.zero(); |
| assert(td->semanticRun != PASSinit); |
| MATCH m = td->matchWithInstance(sc, ti, &dedtypes, ti->fargs, 0); |
| //printf("matchWithInstance = %d\n", m); |
| if (m <= MATCHnomatch) // no match at all |
| return 0; |
| |
| if (m < m_best) goto Ltd_best; |
| if (m > m_best) goto Ltd; |
| |
| { |
| // Disambiguate by picking the most specialized TemplateDeclaration |
| MATCH c1 = td->leastAsSpecialized(sc, td_best, ti->fargs); |
| MATCH c2 = td_best->leastAsSpecialized(sc, td, ti->fargs); |
| //printf("c1 = %d, c2 = %d\n", c1, c2); |
| if (c1 > c2) goto Ltd; |
| if (c1 < c2) goto Ltd_best; |
| } |
| |
| td_ambig = td; |
| return 0; |
| |
| Ltd_best: // td_best is the best match so far |
| td_ambig = NULL; |
| return 0; |
| |
| Ltd: // td is the new best match |
| td_ambig = NULL; |
| td_best = td; |
| m_best = m; |
| ti->tdtypes.setDim(dedtypes.length); |
| memcpy(ti->tdtypes.tdata(), dedtypes.tdata(), ti->tdtypes.length * sizeof(void *)); |
| return 0; |
| } |
| }; |
| ParamBest p; |
| // context |
| p.ti = this; |
| p.sc = sc; |
| |
| /* Since there can be multiple TemplateDeclaration's with the same |
| * name, look for the best match. |
| */ |
| OverloadSet *tovers = tempdecl->isOverloadSet(); |
| size_t overs_dim = tovers ? tovers->a.length : 1; |
| for (size_t oi = 0; oi < overs_dim; oi++) |
| { |
| // result |
| p.td_best = NULL; |
| p.td_ambig = NULL; |
| p.m_best = MATCHnomatch; |
| |
| Dsymbol *dstart = tovers ? tovers->a[oi] : tempdecl; |
| overloadApply(dstart, &p, &ParamBest::fp); |
| |
| if (p.td_ambig) |
| { |
| ::error(loc, "%s %s.%s matches more than one template declaration:\n%s: %s\nand\n%s: %s", |
| p.td_best->kind(), p.td_best->parent->toPrettyChars(), p.td_best->ident->toChars(), |
| p.td_best->loc.toChars() , p.td_best->toChars(), |
| p.td_ambig->loc.toChars(), p.td_ambig->toChars()); |
| return false; |
| } |
| if (p.td_best) |
| { |
| if (!td_last) |
| td_last = p.td_best; |
| else if (td_last != p.td_best) |
| { |
| ScopeDsymbol::multiplyDefined(loc, td_last, p.td_best); |
| return false; |
| } |
| } |
| } |
| |
| if (td_last) |
| { |
| /* Bugzilla 7469: Normalize tiargs by using corresponding deduced |
| * template value parameters and tuples for the correct mangling. |
| * |
| * By doing this before hasNestedArgs, CTFEable local variable will be |
| * accepted as a value parameter. For example: |
| * |
| * void foo() { |
| * struct S(int n) {} // non-global template |
| * const int num = 1; // CTFEable local variable |
| * S!num s; // S!1 is instantiated, not S!num |
| * } |
| */ |
| size_t dim = td_last->parameters->length - (td_last->isVariadic() ? 1 : 0); |
| for (size_t i = 0; i < dim; i++) |
| { |
| if (tiargs->length <= i) |
| tiargs->push(tdtypes[i]); |
| assert(i < tiargs->length); |
| |
| TemplateValueParameter *tvp = (*td_last->parameters)[i]->isTemplateValueParameter(); |
| if (!tvp) |
| continue; |
| assert(tdtypes[i]); |
| // tdtypes[i] is already normalized to the required type in matchArg |
| |
| (*tiargs)[i] = tdtypes[i]; |
| } |
| if (td_last->isVariadic() && tiargs->length == dim && tdtypes[dim]) |
| { |
| Tuple *va = isTuple(tdtypes[dim]); |
| assert(va); |
| for (size_t i = 0; i < va->objects.length; i++) |
| tiargs->push(va->objects[i]); |
| } |
| } |
| else if (errors && inst) |
| { |
| // instantiation was failed with error reporting |
| assert(global.errors); |
| return false; |
| } |
| else |
| { |
| TemplateDeclaration *tdecl = tempdecl->isTemplateDeclaration(); |
| |
| if (errs != global.errors) |
| errorSupplemental(loc, "while looking for match for %s", toChars()); |
| else if (tdecl && !tdecl->overnext) |
| { |
| // Only one template, so we can give better error message |
| error("does not match template declaration %s", tdecl->toChars()); |
| } |
| else |
| ::error(loc, "%s %s.%s does not match any template declaration", |
| tempdecl->kind(), tempdecl->parent->toPrettyChars(), tempdecl->ident->toChars()); |
| return false; |
| } |
| |
| /* The best match is td_last |
| */ |
| tempdecl = td_last; |
| |
| return (errs == global.errors); |
| } |
| |
| /***************************************************** |
| * Determine if template instance is really a template function, |
| * and that template function needs to infer types from the function |
| * arguments. |
| * |
| * Like findBestMatch, iterate possible template candidates, |
| * but just looks only the necessity of type inference. |
| */ |
| |
| bool TemplateInstance::needsTypeInference(Scope *sc, int flag) |
| { |
| //printf("TemplateInstance::needsTypeInference() %s\n", toChars()); |
| if (semanticRun != PASSinit) |
| return false; |
| |
| struct ParamNeedsInf |
| { |
| // context |
| Scope *sc; |
| TemplateInstance *ti; |
| int flag; |
| // result |
| Objects dedtypes; |
| size_t count; |
| |
| static int fp(void *param, Dsymbol *s) |
| { |
| return ((ParamNeedsInf *)param)->fp(s); |
| } |
| int fp(Dsymbol *s) |
| { |
| TemplateDeclaration *td = s->isTemplateDeclaration(); |
| if (!td) |
| return 0; |
| if (td->inuse) |
| { |
| td->error(ti->loc, "recursive template expansion"); |
| return 1; |
| } |
| |
| /* If any of the overloaded template declarations need inference, |
| * then return true |
| */ |
| FuncDeclaration *fd; |
| if (!td->onemember) |
| return 0; |
| if (TemplateDeclaration *td2 = td->onemember->isTemplateDeclaration()) |
| { |
| if (!td2->onemember || !td2->onemember->isFuncDeclaration()) |
| return 0; |
| if (ti->tiargs->length >= td->parameters->length - (td->isVariadic() ? 1 : 0)) |
| return 0; |
| return 1; |
| } |
| if ((fd = td->onemember->isFuncDeclaration()) == NULL || |
| fd->type->ty != Tfunction) |
| { |
| return 0; |
| } |
| |
| for (size_t i = 0; i < td->parameters->length; i++) |
| { |
| if ((*td->parameters)[i]->isTemplateThisParameter()) |
| return 1; |
| } |
| |
| /* Determine if the instance arguments, tiargs, are all that is necessary |
| * to instantiate the template. |
| */ |
| //printf("tp = %p, td->parameters->length = %d, tiargs->length = %d\n", tp, td->parameters->length, ti->tiargs->length); |
| TypeFunction *tf = (TypeFunction *)fd->type; |
| if (size_t dim = tf->parameterList.length()) |
| { |
| TemplateParameter *tp = td->isVariadic(); |
| if (tp && td->parameters->length > 1) |
| return 1; |
| |
| if (!tp && ti->tiargs->length < td->parameters->length) |
| { |
| // Can remain tiargs be filled by default arguments? |
| for (size_t i = ti->tiargs->length; i < td->parameters->length; i++) |
| { |
| if (!(*td->parameters)[i]->hasDefaultArg()) |
| return 1; |
| } |
| } |
| |
| for (size_t i = 0; i < dim; i++) |
| { |
| // 'auto ref' needs inference. |
| if (tf->parameterList[i]->storageClass & STCauto) |
| return 1; |
| } |
| } |
| |
| if (!flag) |
| { |
| /* Calculate the need for overload resolution. |
| * When only one template can match with tiargs, inference is not necessary. |
| */ |
| dedtypes.setDim(td->parameters->length); |
| dedtypes.zero(); |
| if (td->semanticRun == PASSinit) |
| { |
| if (td->_scope) |
| { |
| // Try to fix forward reference. Ungag errors while doing so. |
| Ungag ungag = td->ungagSpeculative(); |
| dsymbolSemantic(td, td->_scope); |
| } |
| if (td->semanticRun == PASSinit) |
| { |
| ti->error("%s forward references template declaration %s", ti->toChars(), td->toChars()); |
| return 1; |
| } |
| } |
| assert(td->semanticRun != PASSinit); |
| MATCH m = td->matchWithInstance(sc, ti, &dedtypes, NULL, 0); |
| if (m <= MATCHnomatch) |
| return 0; |
| } |
| |
| /* If there is more than one function template which matches, we may |
| * need type inference (see Bugzilla 4430) |
| */ |
| if (++count > 1) |
| return 1; |
| |
| return 0; |
| } |
| }; |
| ParamNeedsInf p; |
| // context |
| p.ti = this; |
| p.sc = sc; |
| p.flag = flag; |
| // result |
| p.count = 0; |
| |
| OverloadSet *tovers = tempdecl->isOverloadSet(); |
| size_t overs_dim = tovers ? tovers->a.length : 1; |
| unsigned olderrs = global.errors; |
| for (size_t oi = 0; oi < overs_dim; oi++) |
| { |
| if (overloadApply(tovers ? tovers->a[oi] : tempdecl, &p, &ParamNeedsInf::fp)) |
| return true; |
| } |
| if (olderrs != global.errors) |
| { |
| if (!global.gag) |
| { |
| errorSupplemental(loc, "while looking for match for %s", toChars()); |
| semanticRun = PASSsemanticdone; |
| inst = this; |
| } |
| errors = true; |
| } |
| //printf("false\n"); |
| return false; |
| } |
| |
| |
| /***************************************** |
| * Determines if a TemplateInstance will need a nested |
| * generation of the TemplateDeclaration. |
| * Sets enclosing property if so, and returns != 0; |
| */ |
| |
| bool TemplateInstance::hasNestedArgs(Objects *args, bool isstatic) |
| { |
| int nested = 0; |
| //printf("TemplateInstance::hasNestedArgs('%s')\n", tempdecl->ident->toChars()); |
| |
| /* A nested instance happens when an argument references a local |
| * symbol that is on the stack. |
| */ |
| for (size_t i = 0; i < args->length; i++) |
| { |
| RootObject *o = (*args)[i]; |
| Expression *ea = isExpression(o); |
| Dsymbol *sa = isDsymbol(o); |
| Tuple *va = isTuple(o); |
| if (ea) |
| { |
| if (ea->op == TOKvar) |
| { |
| sa = ((VarExp *)ea)->var; |
| goto Lsa; |
| } |
| if (ea->op == TOKthis) |
| { |
| sa = ((ThisExp *)ea)->var; |
| goto Lsa; |
| } |
| if (ea->op == TOKfunction) |
| { |
| if (((FuncExp *)ea)->td) |
| sa = ((FuncExp *)ea)->td; |
| else |
| sa = ((FuncExp *)ea)->fd; |
| goto Lsa; |
| } |
| // Emulate Expression::toMangleBuffer call that had exist in TemplateInstance::genIdent. |
| if (ea->op != TOKint64 && |
| ea->op != TOKfloat64 && |
| ea->op != TOKcomplex80 && |
| ea->op != TOKnull && |
| ea->op != TOKstring && |
| ea->op != TOKarrayliteral && |
| ea->op != TOKassocarrayliteral && |
| ea->op != TOKstructliteral) |
| { |
| ea->error("expression %s is not a valid template value argument", ea->toChars()); |
| errors = true; |
| } |
| } |
| else if (sa) |
| { |
| Lsa: |
| sa = sa->toAlias(); |
| TemplateDeclaration *td = sa->isTemplateDeclaration(); |
| if (td) |
| { |
| TemplateInstance *ti = sa->toParent()->isTemplateInstance(); |
| if (ti && ti->enclosing) |
| sa = ti; |
| } |
| TemplateInstance *ti = sa->isTemplateInstance(); |
| Declaration *d = sa->isDeclaration(); |
| if ((td && td->literal) || |
| (ti && ti->enclosing) || |
| (d && !d->isDataseg() && |
| !(d->storage_class & STCmanifest) && |
| (!d->isFuncDeclaration() || d->isFuncDeclaration()->isNested()) && |
| !isTemplateMixin() |
| )) |
| { |
| // if module level template |
| if (isstatic) |
| { |
| Dsymbol *dparent = sa->toParent2(); |
| if (!enclosing) |
| enclosing = dparent; |
| else if (enclosing != dparent) |
| { |
| /* Select the more deeply nested of the two. |
| * Error if one is not nested inside the other. |
| */ |
| for (Dsymbol *p = enclosing; p; p = p->parent) |
| { |
| if (p == dparent) |
| goto L1; // enclosing is most nested |
| } |
| for (Dsymbol *p = dparent; p; p = p->parent) |
| { |
| if (p == enclosing) |
| { |
| enclosing = dparent; |
| goto L1; // dparent is most nested |
| } |
| } |
| error("%s is nested in both %s and %s", |
| toChars(), enclosing->toChars(), dparent->toChars()); |
| errors = true; |
| } |
| L1: |
| //printf("\tnested inside %s\n", enclosing->toChars()); |
| nested |= 1; |
| } |
| else |
| { |
| error("cannot use local `%s` as parameter to non-global template %s", sa->toChars(), tempdecl->toChars()); |
| errors = true; |
| } |
| } |
| } |
| else if (va) |
| { |
| nested |= (int)hasNestedArgs(&va->objects, isstatic); |
| } |
| } |
| //printf("-TemplateInstance::hasNestedArgs('%s') = %d\n", tempdecl->ident->toChars(), nested); |
| return nested != 0; |
| } |
| |
| /***************************************** |
| * Append 'this' to the specific module members[] |
| */ |
| Dsymbols *TemplateInstance::appendToModuleMember() |
| { |
| Module *mi = minst; // instantiated -> inserted module |
| |
| if (global.params.useUnitTests) |
| { |
| // Turn all non-root instances to speculative |
| if (mi && !mi->isRoot()) |
| mi = NULL; |
| } |
| |
| //printf("%s->appendToModuleMember() enclosing = %s mi = %s\n", |
| // toPrettyChars(), |
| // enclosing ? enclosing->toPrettyChars() : NULL, |
| // mi ? mi->toPrettyChars() : NULL); |
| if (!mi || mi->isRoot()) |
| { |
| /* If the instantiated module is speculative or root, insert to the |
| * member of a root module. Then: |
| * - semantic3 pass will get called on the instance members. |
| * - codegen pass will get a selection chance to do/skip it. |
| */ |
| |
| struct N |
| { |
| static Dsymbol *getStrictEnclosing(TemplateInstance *ti) |
| { |
| do |
| { |
| if (ti->enclosing) |
| return ti->enclosing; |
| ti = ti->tempdecl->isInstantiated(); |
| } |
| while (ti); |
| return NULL; |
| } |
| }; |
| Dsymbol *enc = N::getStrictEnclosing(this); |
| |
| // insert target is made stable by using the module |
| // where tempdecl is declared. |
| mi = (enc ? enc : tempdecl)->getModule(); |
| if (!mi->isRoot()) |
| mi = mi->importedFrom; |
| assert(mi->isRoot()); |
| } |
| else |
| { |
| /* If the instantiated module is non-root, insert to the member of the |
| * non-root module. Then: |
| * - semantic3 pass won't be called on the instance. |
| * - codegen pass won't reach to the instance. |
| */ |
| } |
| //printf("\t--> mi = %s\n", mi->toPrettyChars()); |
| |
| if (memberOf == mi) // already a member |
| { |
| return NULL; |
| } |
| |
| Dsymbols *a = mi->members; |
| a->push(this); |
| memberOf = mi; |
| if (mi->semanticRun >= PASSsemantic2done && mi->isRoot()) |
| Module::addDeferredSemantic2(this); |
| if (mi->semanticRun >= PASSsemantic3done && mi->isRoot()) |
| Module::addDeferredSemantic3(this); |
| return a; |
| } |
| |
| /**************************************** |
| * This instance needs an identifier for name mangling purposes. |
| * Create one by taking the template declaration name and adding |
| * the type signature for it. |
| */ |
| |
| Identifier *TemplateInstance::genIdent(Objects *args) |
| { |
| //printf("TemplateInstance::genIdent('%s')\n", tempdecl->ident->toChars()); |
| assert(args == tiargs); |
| OutBuffer buf; |
| mangleToBuffer(this, &buf); |
| //printf("\tgenIdent = %s\n", id); |
| return Identifier::idPool(buf.peekChars()); |
| } |
| |
| /************************************* |
| * Lazily generate identifier for template instance. |
| * This is because 75% of the ident's are never needed. |
| */ |
| |
| Identifier *TemplateInstance::getIdent() |
| { |
| if (!ident && inst && !errors) |
| ident = genIdent(tiargs); // need an identifier for name mangling purposes. |
| return ident; |
| } |
| |
| /**************************************************** |
| * Declare parameters of template instance, initialize them with the |
| * template instance arguments. |
| */ |
| |
| void TemplateInstance::declareParameters(Scope *sc) |
| { |
| TemplateDeclaration *tempdecl = this->tempdecl->isTemplateDeclaration(); |
| assert(tempdecl); |
| |
| //printf("TemplateInstance::declareParameters()\n"); |
| for (size_t i = 0; i < tdtypes.length; i++) |
| { |
| TemplateParameter *tp = (*tempdecl->parameters)[i]; |
| //RootObject *o = (*tiargs)[i]; |
| RootObject *o = tdtypes[i]; // initializer for tp |
| |
| //printf("\ttdtypes[%d] = %p\n", i, o); |
| tempdecl->declareParameter(sc, tp, o); |
| } |
| } |
| |
| /************************************** |
| * Given an error instantiating the TemplateInstance, |
| * give the nested TemplateInstance instantiations that got |
| * us here. Those are a list threaded into the nested scopes. |
| */ |
| void TemplateInstance::printInstantiationTrace() |
| { |
| if (global.gag) |
| return; |
| |
| const unsigned max_shown = 6; |
| const char format[] = "instantiated from here: %s"; |
| |
| // determine instantiation depth and number of recursive instantiations |
| unsigned n_instantiations = 1; |
| unsigned n_totalrecursions = 0; |
| for (TemplateInstance *cur = this; cur; cur = cur->tinst) |
| { |
| ++n_instantiations; |
| // If two instantiations use the same declaration, they are recursive. |
| // (this works even if they are instantiated from different places in the |
| // same template). |
| // In principle, we could also check for multiple-template recursion, but it's |
| // probably not worthwhile. |
| if (cur->tinst && cur->tempdecl && cur->tinst->tempdecl |
| && cur->tempdecl->loc.equals(cur->tinst->tempdecl->loc)) |
| ++n_totalrecursions; |
| } |
| |
| // show full trace only if it's short or verbose is on |
| if (n_instantiations <= max_shown || global.params.verbose) |
| { |
| for (TemplateInstance *cur = this; cur; cur = cur->tinst) |
| { |
| cur->errors = true; |
| errorSupplemental(cur->loc, format, cur->toChars()); |
| } |
| } |
| else if (n_instantiations - n_totalrecursions <= max_shown) |
| { |
| // By collapsing recursive instantiations into a single line, |
| // we can stay under the limit. |
| int recursionDepth=0; |
| for (TemplateInstance *cur = this; cur; cur = cur->tinst) |
| { |
| cur->errors = true; |
| if (cur->tinst && cur->tempdecl && cur->tinst->tempdecl |
| && cur->tempdecl->loc.equals(cur->tinst->tempdecl->loc)) |
| { |
| ++recursionDepth; |
| } |
| else |
| { |
| if (recursionDepth) |
| errorSupplemental(cur->loc, "%d recursive instantiations from here: %s", recursionDepth+2, cur->toChars()); |
| else |
| errorSupplemental(cur->loc, format, cur->toChars()); |
| recursionDepth = 0; |
| } |
| } |
| } |
| else |
| { |
| // Even after collapsing the recursions, the depth is too deep. |
| // Just display the first few and last few instantiations. |
| unsigned i = 0; |
| for (TemplateInstance *cur = this; cur; cur = cur->tinst) |
| { |
| cur->errors = true; |
| |
| if (i == max_shown / 2) |
| errorSupplemental(cur->loc, "... (%d instantiations, -v to show) ...", n_instantiations - max_shown); |
| |
| if (i < max_shown / 2 || |
| i >= n_instantiations - max_shown + max_shown / 2) |
| errorSupplemental(cur->loc, format, cur->toChars()); |
| ++i; |
| } |
| } |
| } |
| |
| Dsymbol *TemplateInstance::toAlias() |
| { |
| if (!inst) |
| { |
| // Maybe we can resolve it |
| if (_scope) |
| { |
| dsymbolSemantic(this, _scope); |
| } |
| if (!inst) |
| { |
| error("cannot resolve forward reference"); |
| errors = true; |
| return this; |
| } |
| } |
| |
| if (inst != this) |
| return inst->toAlias(); |
| |
| if (aliasdecl) |
| { |
| return aliasdecl->toAlias(); |
| } |
| |
| return inst; |
| } |
| |
| const char *TemplateInstance::kind() const |
| { |
| return "template instance"; |
| } |
| |
| bool TemplateInstance::oneMember(Dsymbol **ps, Identifier *) |
| { |
| *ps = NULL; |
| return true; |
| } |
| |
| const char *TemplateInstance::toChars() |
| { |
| OutBuffer buf; |
| toCBufferInstance(this, &buf); |
| return buf.extractChars(); |
| } |
| |
| const char *TemplateInstance::toPrettyCharsHelper() |
| { |
| OutBuffer buf; |
| toCBufferInstance(this, &buf, true); |
| return buf.extractChars(); |
| } |
| |
| /************************************* |
| * Compare proposed template instantiation with existing template instantiation. |
| * Note that this is not commutative because of the auto ref check. |
| * Params: |
| * this = proposed template instantiation |
| * o = existing template instantiation |
| * Returns: |
| * 0 for match, 1 for no match |
| */ |
| int TemplateInstance::compare(RootObject *o) |
| { |
| TemplateInstance *ti = (TemplateInstance *)o; |
| |
| //printf("this = %p, ti = %p\n", this, ti); |
| assert(tdtypes.length == ti->tdtypes.length); |
| |
| // Nesting must match |
| if (enclosing != ti->enclosing) |
| { |
| //printf("test2 enclosing %s ti->enclosing %s\n", enclosing ? enclosing->toChars() : "", ti->enclosing ? ti->enclosing->toChars() : ""); |
| goto Lnotequals; |
| } |
| //printf("parent = %s, ti->parent = %s\n", parent->toPrettyChars(), ti->parent->toPrettyChars()); |
| |
| if (!arrayObjectMatch(&tdtypes, &ti->tdtypes)) |
| goto Lnotequals; |
| |
| /* Template functions may have different instantiations based on |
| * "auto ref" parameters. |
| */ |
| if (FuncDeclaration *fd = ti->toAlias()->isFuncDeclaration()) |
| { |
| if (!fd->errors) |
| { |
| ParameterList fparameters = fd->getParameterList(); |
| size_t nfparams = fparameters.length(); // Num function parameters |
| for (size_t j = 0; j < nfparams; j++) |
| { |
| Parameter *fparam = fparameters[j]; |
| if (fparam->storageClass & STCautoref) // if "auto ref" |
| { |
| if (!fargs) |
| goto Lnotequals; |
| if (fargs->length <= j) |
| break; |
| Expression *farg = (*fargs)[j]; |
| if (farg->isLvalue()) |
| { |
| if (!(fparam->storageClass & STCref)) |
| goto Lnotequals; // auto ref's don't match |
| } |
| else |
| { |
| if (fparam->storageClass & STCref) |
| goto Lnotequals; // auto ref's don't match |
| } |
| } |
| } |
| } |
| } |
| return 0; |
| |
| Lnotequals: |
| return 1; |
| } |
| |
| hash_t TemplateInstance::toHash() |
| { |
| if (!hash) |
| { |
| hash = (size_t)(void *)enclosing; |
| hash += arrayObjectHash(&tdtypes); |
| hash += hash == 0; |
| } |
| return hash; |
| } |
| |
| /************************************** |
| * IsExpression can evaluate the specified type speculatively, and even if |
| * it instantiates any symbols, they are normally unnecessary for the |
| * final executable. |
| * However, if those symbols leak to the actual code, compiler should remark |
| * them as non-speculative to generate their code and link to the final executable. |
| */ |
| void unSpeculative(Scope *sc, RootObject *o) |
| { |
| if (!o) |
| return; |
| |
| if (Tuple *tup = isTuple(o)) |
| { |
| for (size_t i = 0; i < tup->objects.length; i++) |
| { |
| unSpeculative(sc, tup->objects[i]); |
| } |
| return; |
| } |
| |
| Dsymbol *s = getDsymbol(o); |
| if (!s) |
| return; |
| |
| if (Declaration *d = s->isDeclaration()) |
| { |
| if (VarDeclaration *vd = d->isVarDeclaration()) |
| o = vd->type; |
| else if (AliasDeclaration *ad = d->isAliasDeclaration()) |
| { |
| o = ad->getType(); |
| if (!o) |
| o = ad->toAlias(); |
| } |
| else |
| o = d->toAlias(); |
| |
| s = getDsymbol(o); |
| if (!s) |
| return; |
| } |
| |
| if (TemplateInstance *ti = s->isTemplateInstance()) |
| { |
| // If the instance is already non-speculative, |
| // or it is leaked to the speculative scope. |
| if (ti->minst != NULL || sc->minst == NULL) |
| return; |
| |
| // Remark as non-speculative instance. |
| ti->minst = sc->minst; |
| if (!ti->tinst) |
| ti->tinst = sc->tinst; |
| |
| unSpeculative(sc, ti->tempdecl); |
| } |
| |
| if (TemplateInstance *ti = s->isInstantiated()) |
| unSpeculative(sc, ti); |
| } |
| |
| /** |
| Returns: true if the instances' innards are discardable. |
| |
| The idea of this function is to see if the template instantiation |
| can be 100% replaced with its eponymous member. All other members |
| can be discarded, even in the compiler to free memory (for example, |
| the template could be expanded in a region allocator, deemed trivial, |
| the end result copied back out independently and the entire region freed), |
| and can be elided entirely from the binary. |
| |
| The current implementation affects code that generally looks like: |
| |
| --- |
| template foo(args...) { |
| some_basic_type_or_string helper() { .... } |
| enum foo = helper(); |
| } |
| --- |
| |
| since it was the easiest starting point of implementation but it can and |
| should be expanded more later. |
| */ |
| static bool isDiscardable(TemplateInstance *ti) |
| { |
| if (ti->aliasdecl == NULL) |
| return false; |
| |
| VarDeclaration *v = ti->aliasdecl->isVarDeclaration(); |
| if (v == NULL) |
| return false; |
| |
| if (!(v->storage_class & STCmanifest)) |
| return false; |
| |
| // Currently only doing basic types here because it is the easiest proof-of-concept |
| // implementation with minimal risk of side effects, but it could likely be |
| // expanded to any type that already exists outside this particular instance. |
| if (!(v->type->equals(Type::tstring) || (v->type->isTypeBasic() != NULL))) |
| return false; |
| |
| // Static ctors and dtors, even in an eponymous enum template, are still run, |
| // so if any of them are in here, we'd better not assume it is trivial lest |
| // we break useful code |
| for (size_t i = 0; i < ti->members->length; i++) |
| { |
| Dsymbol *member = (*ti->members)[i]; |
| if (member->hasStaticCtorOrDtor()) |
| return false; |
| if (member->isStaticDtorDeclaration()) |
| return false; |
| if (member->isStaticCtorDeclaration()) |
| return false; |
| } |
| |
| // but if it passes through this gauntlet... it should be fine. D code will |
| // see only the eponymous member, outside stuff can never access it, even through |
| // reflection; the outside world ought to be none the wiser. Even dmd should be |
| // able to simply free the memory of everything except the final result. |
| |
| return true; |
| } |
| |
| /*********************************************** |
| * Returns true if this is not instantiated in non-root module, and |
| * is a part of non-speculative instantiatiation. |
| * |
| * Note: minst does not stabilize until semantic analysis is completed, |
| * so don't call this function during semantic analysis to return precise result. |
| */ |
| bool TemplateInstance::needsCodegen() |
| { |
| if (!minst) |
| { |
| // If this is a speculative instantiation, |
| // 1. do codegen if ancestors really needs codegen. |
| // 2. become non-speculative if siblings are not speculative |
| |
| TemplateInstance *tnext = this->tnext; |
| TemplateInstance *tinst = this->tinst; |
| // At first, disconnect chain first to prevent infinite recursion. |
| this->tnext = NULL; |
| this->tinst = NULL; |
| |
| // Determine necessity of tinst before tnext. |
| if (tinst && tinst->needsCodegen()) |
| { |
| minst = tinst->minst; // cache result |
| if (global.params.allInst && minst) |
| { |
| return true; |
| } |
| assert(minst); |
| assert(minst->isRoot() || minst->rootImports()); |
| return true; |
| } |
| if (tnext && (tnext->needsCodegen() || tnext->minst)) |
| { |
| minst = tnext->minst; // cache result |
| if (global.params.allInst && minst) |
| { |
| return true; |
| } |
| assert(minst); |
| return minst->isRoot() || minst->rootImports(); |
| } |
| |
| // Elide codegen because this is really speculative. |
| return false; |
| } |
| |
| if (global.params.allInst) |
| { |
| return true; |
| } |
| |
| if (isDiscardable(this)) |
| { |
| return false; |
| } |
| |
| /* Even when this is reached to the codegen pass, |
| * a non-root nested template should not generate code, |
| * due to avoid ODR violation. |
| */ |
| if (enclosing && enclosing->inNonRoot()) |
| { |
| if (tinst) |
| { |
| bool r = tinst->needsCodegen(); |
| minst = tinst->minst; // cache result |
| return r; |
| } |
| if (tnext) |
| { |
| bool r = tnext->needsCodegen(); |
| minst = tnext->minst; // cache result |
| return r; |
| } |
| return false; |
| } |
| |
| if (global.params.useUnitTests) |
| { |
| // Prefer instantiations from root modules, to maximize link-ability. |
| if (minst->isRoot()) |
| return true; |
| |
| TemplateInstance *tnext = this->tnext; |
| TemplateInstance *tinst = this->tinst; |
| this->tnext = NULL; |
| this->tinst = NULL; |
| |
| if (tinst && tinst->needsCodegen()) |
| { |
| minst = tinst->minst; // cache result |
| assert(minst); |
| assert(minst->isRoot() || minst->rootImports()); |
| return true; |
| } |
| if (tnext && tnext->needsCodegen()) |
| { |
| minst = tnext->minst; // cache result |
| assert(minst); |
| assert(minst->isRoot() || minst->rootImports()); |
| return true; |
| } |
| |
| // Bugzilla 2500 case |
| if (minst->rootImports()) |
| return true; |
| |
| // Elide codegen because this is not included in root instances. |
| return false; |
| } |
| else |
| { |
| // Prefer instantiations from non-root module, to minimize object code size. |
| |
| /* If a TemplateInstance is ever instantiated by non-root modules, |
| * we do not have to generate code for it, |
| * because it will be generated when the non-root module is compiled. |
| * |
| * But, if the non-root 'minst' imports any root modules, it might still need codegen. |
| * |
| * The problem is if A imports B, and B imports A, and both A |
| * and B instantiate the same template, does the compilation of A |
| * or the compilation of B do the actual instantiation? |
| * |
| * See Bugzilla 2500. |
| */ |
| if (!minst->isRoot() && !minst->rootImports()) |
| return false; |
| |
| TemplateInstance *tnext = this->tnext; |
| this->tnext = NULL; |
| |
| if (tnext && !tnext->needsCodegen() && tnext->minst) |
| { |
| minst = tnext->minst; // cache result |
| assert(!minst->isRoot()); |
| return false; |
| } |
| |
| // Do codegen because this is not included in non-root instances. |
| return true; |
| } |
| } |
| |
| /* ======================== TemplateMixin ================================ */ |
| |
| TemplateMixin::TemplateMixin(Loc loc, Identifier *ident, TypeQualified *tqual, Objects *tiargs) |
| : TemplateInstance(loc, tqual->idents.length ? (Identifier *)tqual->idents[tqual->idents.length - 1] |
| : ((TypeIdentifier *)tqual)->ident) |
| { |
| //printf("TemplateMixin(ident = '%s')\n", ident ? ident->toChars() : ""); |
| this->ident = ident; |
| this->tqual = tqual; |
| this->tiargs = tiargs ? tiargs : new Objects(); |
| } |
| |
| Dsymbol *TemplateMixin::syntaxCopy(Dsymbol *) |
| { |
| TemplateMixin *tm = new TemplateMixin(loc, ident, |
| (TypeQualified *)tqual->syntaxCopy(), tiargs); |
| return TemplateInstance::syntaxCopy(tm); |
| } |
| |
| bool TemplateMixin::findTempDecl(Scope *sc) |
| { |
| // Follow qualifications to find the TemplateDeclaration |
| if (!tempdecl) |
| { |
| Expression *e; |
| Type *t; |
| Dsymbol *s; |
| tqual->resolve(loc, sc, &e, &t, &s); |
| if (!s) |
| { |
| error("is not defined"); |
| return false; |
| } |
| s = s->toAlias(); |
| tempdecl = s->isTemplateDeclaration(); |
| OverloadSet *os = s->isOverloadSet(); |
| |
| /* If an OverloadSet, look for a unique member that is a template declaration |
| */ |
| if (os) |
| { |
| Dsymbol *ds = NULL; |
| for (size_t i = 0; i < os->a.length; i++) |
| { |
| Dsymbol *s2 = os->a[i]->isTemplateDeclaration(); |
| if (s2) |
| { |
| if (ds) |
| { |
| tempdecl = os; |
| break; |
| } |
| ds = s2; |
| } |
| } |
| } |
| if (!tempdecl) |
| { |
| error("%s isn't a template", s->toChars()); |
| return false; |
| } |
| } |
| assert(tempdecl); |
| |
| struct ParamFwdResTm |
| { |
| static int fp(void *param, Dsymbol *s) |
| { |
| TemplateDeclaration *td = s->isTemplateDeclaration(); |
| if (!td) |
| return 0; |
| |
| TemplateMixin *tm = (TemplateMixin *)param; |
| if (td->semanticRun == PASSinit) |
| { |
| if (td->_scope) |
| dsymbolSemantic(td, td->_scope); |
| else |
| { |
| tm->semanticRun = PASSinit; |
| return 1; |
| } |
| } |
| return 0; |
| } |
| }; |
| // Look for forward references |
| OverloadSet *tovers = tempdecl->isOverloadSet(); |
| size_t overs_dim = tovers ? tovers->a.length : 1; |
| for (size_t oi = 0; oi < overs_dim; oi++) |
| { |
| if (overloadApply(tovers ? tovers->a[oi] : tempdecl, (void *)this, &ParamFwdResTm::fp)) |
| return false; |
| } |
| return true; |
| } |
| |
| const char *TemplateMixin::kind() const |
| { |
| return "mixin"; |
| } |
| |
| bool TemplateMixin::oneMember(Dsymbol **ps, Identifier *ident) |
| { |
| return Dsymbol::oneMember(ps, ident); |
| } |
| |
| int TemplateMixin::apply(Dsymbol_apply_ft_t fp, void *param) |
| { |
| if (_scope) // if fwd reference |
| dsymbolSemantic(this, NULL); // try to resolve it |
| if (members) |
| { |
| for (size_t i = 0; i < members->length; i++) |
| { |
| Dsymbol *s = (*members)[i]; |
| if (s) |
| { |
| if (s->apply(fp, param)) |
| return 1; |
| } |
| } |
| } |
| return 0; |
| } |
| |
| bool TemplateMixin::hasPointers() |
| { |
| //printf("TemplateMixin::hasPointers() %s\n", toChars()); |
| |
| if (members) |
| { |
| for (size_t i = 0; i < members->length; i++) |
| { |
| Dsymbol *s = (*members)[i]; |
| //printf(" s = %s %s\n", s->kind(), s->toChars()); |
| if (s->hasPointers()) |
| { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| void TemplateMixin::setFieldOffset(AggregateDeclaration *ad, unsigned *poffset, bool isunion) |
| { |
| //printf("TemplateMixin::setFieldOffset() %s\n", toChars()); |
| if (_scope) // if fwd reference |
| dsymbolSemantic(this, NULL); // try to resolve it |
| if (members) |
| { |
| for (size_t i = 0; i < members->length; i++) |
| { |
| Dsymbol *s = (*members)[i]; |
| //printf("\t%s\n", s->toChars()); |
| s->setFieldOffset(ad, poffset, isunion); |
| } |
| } |
| } |
| |
| const char *TemplateMixin::toChars() |
| { |
| OutBuffer buf; |
| toCBufferInstance(this, &buf); |
| return buf.extractChars(); |
| } |
