projects/ldc: dmd2/template.c comparison

comparison dmd2/template.c @ 1526:54b3c1394d62

Merged dmdfe 2.031.

author	Robert Clipsham <robert@octarineparrot.com>
date	Tue, 07 Jul 2009 02:26:11 +0100
parents	638d16625da2
children	e4f7b5d9c68a

comparison

equal deleted inserted replaced

-:d28cd7c45267
+:54b3c1394d62
 this->origParameters = parameters;
 this->constraint = constraint;
 this->members = decldefs;
 this->overnext = NULL;
 this->overroot = NULL;
-this->scope = NULL;
+this->semanticRun = 0;
 this->onemember = NULL;
 this->literal = 0;
 }
 Dsymbol *TemplateDeclaration::syntaxCopy(Dsymbol *)
 	e = constraint->syntaxCopy();
 d = Dsymbol::arraySyntaxCopy(members);
 td = new TemplateDeclaration(loc, ident, p, e, d);
 #if IN_LLVM
-// LDC
 td->intrinsicName = intrinsicName;
 #endif
 return td;
 }
 void TemplateDeclaration::semantic(Scope *sc)
 {
 #if LOG
 printf("TemplateDeclaration::semantic(this = %p, id = '%s')\n", this, ident->toChars());
 #endif
-if (scope)
+if (semanticRun)
 	return;		// semantic() already run
+semanticRun = 1;
 if (sc->func)
 {
 #if DMDV1
 	error("cannot declare template at function scope %s", sc->func->toChars());
 	assert(fctor);
 	fparameters = fctor->arguments;
 	fvarargs = fctor->varargs;
 }
-nfparams = Argument::dim(fparameters); // number of function parameters
+nfparams = Argument::dim(fparameters);	// number of function parameters
-nfargs = fargs->dim;		// number of function arguments
+nfargs = fargs ? fargs->dim : 0;		// number of function arguments
 /* Check for match of function arguments with variadic template
 * parameter, such as:
 *
 * template Foo(T, A...) { void Foo(T t, A a); }
 }
 #endif
 for (TemplateDeclaration *td = this; td; td = td->overnext)
 {
-	if (!td->scope)
+	if (!td->semanticRun)
 	{
 	    error("forward reference to template %s", td->toChars());
 	    goto Lerror;
 	}
 	if (!td->onemember || !td->onemember->toAlias()->isFuncDeclaration())
 this->tempdecl = NULL;
 this->inst = NULL;
 this->tinst = NULL;
 this->argsym = NULL;
 this->aliasdecl = NULL;
-this->semanticdone = 0;
+this->semanticRun = 0;
 this->semantictiargsdone = 0;
 this->withsym = NULL;
 this->nest = 0;
 this->havetempdecl = 0;
 this->isnested = NULL;
 this->tempdecl = td;
 this->inst = NULL;
 this->tinst = NULL;
 this->argsym = NULL;
 this->aliasdecl = NULL;
-this->semanticdone = 0;
+this->semanticRun = 0;
 this->semantictiargsdone = 1;
 this->withsym = NULL;
 this->nest = 0;
 this->havetempdecl = 1;
 this->isnested = NULL;
 }
 // get the enclosing template instance from the scope tinst
 tinst = sc->tinst;
-if (semanticdone != 0)
+if (semanticRun != 0)
 {
 	error(loc, "recursive template expansion");
 //	inst = this;
 	return;
 }
-semanticdone = 1;
+semanticRun = 1;
 #if IN_LLVM
 // get the enclosing template instance from the scope tinst
 tinst = sc->tinst;
 // get the module of the outermost enclosing instantiation
 	}
 	else
 	{   Module *m = sc->module->importedFrom;
 	    //printf("\t2: adding to module %s instead of module %s\n", m->toChars(), sc->module->toChars());
 	    a = m->members;
-	    if (m->semanticdone >= 3)
+	    if (m->semanticRun >= 3)
 		dosemantic3 = 1;
 	}
 	for (int i = 0; 1; i++)
 	{
 	    if (i == a->dim)
 // Copy the syntax trees from the TemplateDeclaration
 members = Dsymbol::arraySyntaxCopy(tempdecl->members);
 // Create our own scope for the template parameters
 Scope *scope = tempdecl->scope;
-if (!scope)
+if (!tempdecl->semanticRun)
 {
-	error("forward reference to template declaration %s\n", tempdecl->toChars());
+	error("template instantiation %s forward references template declaration %s\n", toChars(), tempdecl->toChars());
 	return;
 }
 #if LOG
 printf("\tcreate scope for template parameters '%s'\n", toChars());
 		    j--;
 		}
 	    }
 	    else if (ta)
 	    {
+	      Ltype:
 		if (ta->ty == Ttuple)
 		{   // Expand tuple
 		    TypeTuple *tt = (TypeTuple *)ta;
 		    size_t dim = tt->arguments->dim;
 		    tiargs->remove(j);
 	    ea = ea->semantic(sc);
 	    if (ea->op != TOKvar || flags & 1)
 		ea = ea->optimize(WANTvalue | WANTinterpret);
 	    tiargs->data[j] = ea;
 	    if (ea->op == TOKtype)
-		tiargs->data[j] = ea->type;
+	    {	ta = ea->type;
+		goto Ltype;
+	    }
+	    if (ea->op == TOKtuple)
+	    {   // Expand tuple
+		TupleExp *te = (TupleExp *)ea;
+		size_t dim = te->exps->dim;
+		tiargs->remove(j);
+		if (dim)
+		{   tiargs->reserve(dim);
+		    for (size_t i = 0; i < dim; i++)
+			tiargs->insert(j + i, te->exps->data[i]);
+		}
+		j--;
+	    }
 	}
 	else if (sa)
 	{
 	    TemplateDeclaration *td = sa->isTemplateDeclaration();
-	    if (td && !td->scope && td->literal)
+	    if (td && !td->semanticRun && td->literal)
 		td->semantic(sc);
 	}
 	else
 	{
 	    assert(0);
 Objects dedtypes;
 #if LOG
 printf("TemplateInstance::findBestMatch()\n");
 #endif
+// First look for forward references
+for (TemplateDeclaration *td = tempdecl; td; td = td->overnext)
+{
+	if (!td->semanticRun)
+	{
+	    if (td->scope)
+	    {	// Try to fix forward reference
+		td->semantic(td->scope);
+	    }
+	    if (!td->semanticRun)
+	    {
+		error("%s forward references template declaration %s\n", toChars(), td->toChars());
+		return NULL;
+	    }
+	}
+}
 for (TemplateDeclaration *td = tempdecl; td; td = td->overnext)
 {
 	MATCH m;
 //if (tiargs->dim) printf("2: tiargs->dim = %d, data[0] = %p\n", tiargs->dim, tiargs->data[0]);
 		continue;
 	}
 	dedtypes.setDim(td->parameters->dim);
 	dedtypes.zero();
-	if (!td->scope)
+	assert(td->semanticRun);
-	{
-	    error("forward reference to template declaration %s", td->toChars());
-	    return NULL;
-	}
 	m = td->matchWithInstance(this, &dedtypes, 0);
 	//printf("matchWithInstance = %d\n", m);
 	if (!m)			// no match at all
 	    continue;
 /****************************************************
 * Declare parameters of template instance, initialize them with the
 * template instance arguments.
 */
-void TemplateInstance::declareParameters(Scope *scope)
+void TemplateInstance::declareParameters(Scope *sc)
 {
 //printf("TemplateInstance::declareParameters()\n");
 for (int i = 0; i < tdtypes.dim; i++)
 {
 	TemplateParameter *tp = (TemplateParameter *)tempdecl->parameters->data[i];
 	//Object *o = (Object *)tiargs->data[i];
 	Object *o = (Object *)tdtypes.data[i];		// initializer for tp
 	//printf("\ttdtypes[%d] = %p\n", i, o);
-	tempdecl->declareParameter(scope, tp, o);
+	tempdecl->declareParameter(sc, tp, o);
 }
 }
 void TemplateInstance::semantic2(Scope *sc)
 {   int i;
-if (semanticdone >= 2)
+if (semanticRun >= 2)
 	return;
-semanticdone = 2;
+semanticRun = 2;
 #if LOG
 printf("+TemplateInstance::semantic2('%s')\n", toChars());
 #endif
 if (!errors && members)
 {
 }
 void TemplateInstance::semantic3(Scope *sc)
 {
 #if LOG
-printf("TemplateInstance::semantic3('%s'), semanticdone = %d\n", toChars(), semanticdone);
+printf("TemplateInstance::semantic3('%s'), semanticRun = %d\n", toChars(), semanticRun);
 #endif
 //if (toChars()[0] == 'D') *(char*)0=0;
-if (semanticdone >= 3)
+if (semanticRun >= 3)
 	return;
-semanticdone = 3;
+semanticRun = 3;
 if (!errors && members)
 {
 	sc = tempdecl->scope;
 	sc = sc->push(argsym);
 	sc = sc->push(this);
 //printf("TemplateMixin(ident = '%s')\n", ident ? ident->toChars() : "");
 this->ident = ident;
 this->tqual = tqual;
 this->idents = idents;
 this->tiargs = tiargs ? tiargs : new Objects();
-this->scope = NULL;
 }
 Dsymbol *TemplateMixin::syntaxCopy(Dsymbol *s)
 {   TemplateMixin *tm;
 {
 #if LOG
 printf("+TemplateMixin::semantic('%s', this=%p)\n", toChars(), this);
 fflush(stdout);
 #endif
-if (semanticdone &&
+if (semanticRun &&
 	// This for when a class/struct contains mixin members, and
 	// is done over because of forward references
 	(!parent || !toParent()->isAggregateDeclaration()))
 {
 #if LOG
 	printf("\tsemantic done\n");
 #endif
 	return;
 }
-if (!semanticdone)
+if (!semanticRun)
-	semanticdone = 1;
+	semanticRun = 1;
 #if LOG
 printf("\tdo semantic\n");
 #endif
 #if !IN_LLVM
 // Look for forward reference
 assert(tempdecl);
 for (TemplateDeclaration *td = tempdecl; td; td = td->overnext)
 {
-	if (!td->scope)
+	if (!td->semanticRun)
 	{
 	    /* Cannot handle forward references if mixin is a struct member,
 	     * because addField must happen during struct's semantic, not
 	     * during the mixin semantic.
 	     * runDeferred will re-run mixin's semantic outside of the struct's
 	     * semantic.
 	     */
-	    semanticdone = 0;
+	    semanticRun = 0;
 	    AggregateDeclaration *ad = toParent()->isAggregateDeclaration();
 	    if (ad)
 		ad->sizeok = 2;
 	    else
 	    {
 scy = sc->push(this);
 scy->parent = this;
 argsym = new ScopeDsymbol();
 argsym->parent = scy->parent;
-Scope *scope = scy->push(argsym);
+Scope *argscope = scy->push(argsym);
 unsigned errorsave = global.errors;
 // Declare each template parameter as an alias for the argument type
-declareParameters(scope);
+declareParameters(argscope);
 // Add members to enclosing scope, as well as this scope
 for (unsigned i = 0; i < members->dim; i++)
 {   Dsymbol *s;
 	s = (Dsymbol *)members->data[i];
-	s->addMember(scope, this, i);
+	s->addMember(argscope, this, i);
 	//sc->insert(s);
 	//printf("sc->parent = %p, sc->scopesym = %p\n", sc->parent, sc->scopesym);
 	//printf("s->parent = %s\n", s->parent->toChars());
 }
 // Do semantic() analysis on template instance members
 #if LOG
 printf("\tdo semantic() on template instance members '%s'\n", toChars());
 #endif
 Scope *sc2;
-sc2 = scope->push(this);
+sc2 = argscope->push(this);
 sc2->offset = sc->offset;
 static int nest;
 //printf("%d\n", nest);
 if (++nest > 500)
 	error("error instantiating");
 }
 sc2->pop();
-scope->pop();
+argscope->pop();
 //    if (!isAnonymous())
 {
 	scy->pop();
 }
 }
 void TemplateMixin::semantic2(Scope *sc)
 {   int i;
-if (semanticdone >= 2)
+if (semanticRun >= 2)
 	return;
-semanticdone = 2;
+semanticRun = 2;
 #if LOG
 printf("+TemplateMixin::semantic2('%s')\n", toChars());
 #endif
 if (members)
 {
 }
 void TemplateMixin::semantic3(Scope *sc)
 {   int i;
-if (semanticdone >= 3)
+if (semanticRun >= 3)
 	return;
-semanticdone = 3;
+semanticRun = 3;
 #if LOG
 printf("TemplateMixin::semantic3('%s')\n", toChars());
 #endif
 if (members)
 {

Mercurial > projects > ldc

comparison dmd2/template.c @ 1526:54b3c1394d62