Mercurial > projects > ldc

diff dmd/mtype.c @ 1607:207a8a438dea

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge DMD r253: refactor: Argument => Parameter --- dmd/arrayop.c | 30 ++++---- dmd/arraytypes.h | 2 +- dmd/class.c | 8 +- dmd/declaration.c | 10 ++-- dmd/declaration.h | 16 ++-- dmd/doc.c | 12 ++-- dmd/dsymbol.c | 4 +- dmd/expression.c | 48 +++++++------- dmd/expression.h | 32 +++++----- dmd/func.c | 78 +++++++++++----------- dmd/init.c | 2 +- dmd/interpret.c | 8 +- dmd/mtype.c | 190 ++++++++++++++++++++++++++-------------------------- dmd/mtype.h | 32 +++++----- dmd/opover.c | 34 +++++----- dmd/parse.c | 40 ++++++------ dmd/parse.h | 2 +- dmd/statement.c | 90 +++++++++++++------------- dmd/statement.h | 14 ++-- dmd/struct.c | 8 +- dmd/template.c | 30 ++++---- gen/functions.cpp | 10 ++-- gen/functions.h | 2 +- gen/tocall.cpp | 10 ++-- gen/typinf.cpp | 6 +- 25 files changed, 359 insertions(+), 359 deletions(-)
author Leandro Lucarella <llucax@gmail.com>
date Wed, 06 Jan 2010 15:18:20 -0300
parents def7a1d494fd
children 081c48283153
line wrap: on
line diff
--- a/dmd/mtype.c	Wed Jan 06 15:18:19 2010 -0300
+++ b/dmd/mtype.c	Wed Jan 06 15:18:20 2010 -0300
@@ -1594,16 +1594,16 @@
 	//LDC: Build arguments.
 	static FuncDeclaration *adReverseChar_fd = NULL;
 	if(!adReverseChar_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
 	    Type* arrty = Type::tchar->arrayOf();
-	    args->push(new Argument(STCin, arrty, NULL, NULL));
+	    args->push(new Parameter(STCin, arrty, NULL, NULL));
 	    adReverseChar_fd = FuncDeclaration::genCfunc(args, arrty, "_adReverseChar");
 	}
 	static FuncDeclaration *adReverseWchar_fd = NULL;
 	if(!adReverseWchar_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
 	    Type* arrty = Type::twchar->arrayOf();
-	    args->push(new Argument(STCin, arrty, NULL, NULL));
+	    args->push(new Parameter(STCin, arrty, NULL, NULL));
 	    adReverseWchar_fd = FuncDeclaration::genCfunc(args, arrty, "_adReverseWchar");
 	}
 
@@ -1625,16 +1625,16 @@
 	//LDC: Build arguments.
 	static FuncDeclaration *adSortChar_fd = NULL;
 	if(!adSortChar_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
 	    Type* arrty = Type::tchar->arrayOf();
-	    args->push(new Argument(STCin, arrty, NULL, NULL));
+	    args->push(new Parameter(STCin, arrty, NULL, NULL));
 	    adSortChar_fd = FuncDeclaration::genCfunc(args, arrty, "_adSortChar");
 	}
 	static FuncDeclaration *adSortWchar_fd = NULL;
 	if(!adSortWchar_fd) {
-	    Arguments* args = new Arguments;
+	    Parameters* args = new Parameters;
 	    Type* arrty = Type::twchar->arrayOf();
-	    args->push(new Argument(STCin, arrty, NULL, NULL));
+	    args->push(new Parameter(STCin, arrty, NULL, NULL));
 	    adSortWchar_fd = FuncDeclaration::genCfunc(args, arrty, "_adSortWchar");
 	}
 
@@ -1660,16 +1660,16 @@
 	//LDC: Build arguments.
 	static FuncDeclaration *adDup_fd = NULL;
 	if(!adDup_fd) {
-	    Arguments* args = new Arguments;
-	    args->push(new Argument(STCin, Type::typeinfo->type, NULL, NULL));
-	    args->push(new Argument(STCin, Type::tvoid->arrayOf(), NULL, NULL));
+	    Parameters* args = new Parameters;
+	    args->push(new Parameter(STCin, Type::typeinfo->type, NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tvoid->arrayOf(), NULL, NULL));
 	    adDup_fd = FuncDeclaration::genCfunc(args, Type::tvoid->arrayOf(), Id::adDup);
 	}
 	static FuncDeclaration *adReverse_fd = NULL;
 	if(!adReverse_fd) {
-	    Arguments* args = new Arguments;
-	    args->push(new Argument(STCin, Type::tvoid->arrayOf(), NULL, NULL));
-	    args->push(new Argument(STCin, Type::tsize_t, NULL, NULL));
+	    Parameters* args = new Parameters;
+	    args->push(new Parameter(STCin, Type::tvoid->arrayOf(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tsize_t, NULL, NULL));
 	    adReverse_fd = FuncDeclaration::genCfunc(args, Type::tvoid->arrayOf(), Id::adReverse);
 	}
 
@@ -1703,16 +1703,16 @@
 	//LDC: Build arguments.
 	static FuncDeclaration *adSort_fd = NULL;
 	if(!adSort_fd) {
-	    Arguments* args = new Arguments;
-	    args->push(new Argument(STCin, Type::tvoid->arrayOf(), NULL, NULL));
-	    args->push(new Argument(STCin, Type::typeinfo->type, NULL, NULL));
+	    Parameters* args = new Parameters;
+	    args->push(new Parameter(STCin, Type::tvoid->arrayOf(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::typeinfo->type, NULL, NULL));
 	    adSort_fd = FuncDeclaration::genCfunc(args, Type::tvoid->arrayOf(), "_adSort");
 	}
 	static FuncDeclaration *adSortBit_fd = NULL;
 	if(!adSortBit_fd) {
-	    Arguments* args = new Arguments;
-	    args->push(new Argument(STCin, Type::tvoid->arrayOf(), NULL, NULL));
-	    args->push(new Argument(STCin, Type::typeinfo->type, NULL, NULL));
+	    Parameters* args = new Parameters;
+	    args->push(new Parameter(STCin, Type::tvoid->arrayOf(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::typeinfo->type, NULL, NULL));
 	    adSortBit_fd = FuncDeclaration::genCfunc(args, Type::tvoid->arrayOf(), "_adSortBit");
 	}
 
@@ -1981,7 +1981,7 @@
 	    {	error(loc, "tuple index %ju exceeds %u", d, tt->arguments->dim);
 		return Type::terror;
 	    }
-	    Argument *arg = (Argument *)tt->arguments->data[(size_t)d];
+	    Parameter *arg = (Parameter *)tt->arguments->data[(size_t)d];
 	    return arg->type;
 	}
 	case Tfunction:
@@ -2401,8 +2401,8 @@
 	//LDC: Build arguments.
 	static FuncDeclaration *aaLen_fd = NULL;
 	if(!aaLen_fd) {
-	    Arguments* args = new Arguments;
-	    args->push(new Argument(STCin, Type::tvoid->pointerTo(), NULL, NULL));
+	    Parameters* args = new Parameters;
+	    args->push(new Parameter(STCin, Type::tvoid->pointerTo(), NULL, NULL));
 	    aaLen_fd = FuncDeclaration::genCfunc(args, Type::tsize_t, Id::aaLen);
 	}
 
@@ -2422,9 +2422,9 @@
 	//LDC: Build arguments.
 	static FuncDeclaration *aaKeys_fd = NULL;
 	if(!aaKeys_fd) {
-	    Arguments* args = new Arguments;
-	    args->push(new Argument(STCin, Type::tvoid->pointerTo(), NULL, NULL));
-	    args->push(new Argument(STCin, Type::tsize_t, NULL, NULL));
+	    Parameters* args = new Parameters;
+	    args->push(new Parameter(STCin, Type::tvoid->pointerTo(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tsize_t, NULL, NULL));
 	    aaKeys_fd = FuncDeclaration::genCfunc(args, Type::tvoid->arrayOf(), Id::aaKeys);
 	}
 
@@ -2443,10 +2443,10 @@
 	//LDC: Build arguments.
 	static FuncDeclaration *aaValues_fd = NULL;
 	if(!aaValues_fd) {
-	    Arguments* args = new Arguments;
-	    args->push(new Argument(STCin, Type::tvoid->pointerTo(), NULL, NULL));
-	    args->push(new Argument(STCin, Type::tsize_t, NULL, NULL));
-	    args->push(new Argument(STCin, Type::tsize_t, NULL, NULL));
+	    Parameters* args = new Parameters;
+	    args->push(new Parameter(STCin, Type::tvoid->pointerTo(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tsize_t, NULL, NULL));
+	    args->push(new Parameter(STCin, Type::tsize_t, NULL, NULL));
 	    aaValues_fd = FuncDeclaration::genCfunc(args, Type::tvoid->arrayOf(), Id::aaValues);
 	}
 
@@ -2468,9 +2468,9 @@
 	//LDC: Build arguments.
 	static FuncDeclaration *aaRehash_fd = NULL;
 	if(!aaRehash_fd) {
-	    Arguments* args = new Arguments;
-	    args->push(new Argument(STCin, Type::tvoid->pointerTo(), NULL, NULL));
-	    args->push(new Argument(STCin, Type::typeinfo->type, NULL, NULL));
+	    Parameters* args = new Parameters;
+	    args->push(new Parameter(STCin, Type::tvoid->pointerTo(), NULL, NULL));
+	    args->push(new Parameter(STCin, Type::typeinfo->type, NULL, NULL));
 	    aaRehash_fd = FuncDeclaration::genCfunc(args, Type::tvoidptr, Id::aaRehash);
 	}
 
@@ -2708,7 +2708,7 @@
 
 /***************************** TypeFunction *****************************/
 
-TypeFunction::TypeFunction(Arguments *parameters, Type *treturn, int varargs, enum LINK linkage)
+TypeFunction::TypeFunction(Parameters *parameters, Type *treturn, int varargs, enum LINK linkage)
     : Type(Tfunction, treturn)
 {
 //if (!treturn) *(char*)0=0;
@@ -2726,8 +2726,8 @@
 Type *TypeFunction::syntaxCopy()
 {
     Type *treturn = next ? next->syntaxCopy() : NULL;
-    Arguments *params = Argument::arraySyntaxCopy(parameters);
-    TypeFunction *t = new TypeFunction(params, treturn, varargs, linkage);
+    Parameters *params = Parameter::arraySyntaxCopy(parameters);
+    Type *t = new TypeFunction(params, treturn, varargs, linkage);
     return t;
 }
 
@@ -2764,13 +2764,13 @@
 
     if (t1->parameters && t2->parameters)
     {
-	size_t dim = Argument::dim(t1->parameters);
-	if (dim != Argument::dim(t2->parameters))
+	size_t dim = Parameter::dim(t1->parameters);
+	if (dim != Parameter::dim(t2->parameters))
 	    goto Ldistinct;
 
 	for (size_t i = 0; i < dim; i++)
-	{   Argument *arg1 = Argument::getNth(t1->parameters, i);
-	    Argument *arg2 = Argument::getNth(t2->parameters, i);
+	{   Parameter *arg1 = Parameter::getNth(t1->parameters, i);
+	    Parameter *arg2 = Parameter::getNth(t2->parameters, i);
 
 	    if (!arg1->type->equals(arg2->type))
 		goto Ldistinct;
@@ -2875,7 +2875,7 @@
     }
 
     // Write argument types
-    Argument::argsToDecoBuffer(buf, parameters, mangle);
+    Parameter::argsToDecoBuffer(buf, parameters, mangle);
     //if (buf->data[buf->offset - 1] == '@') halt();
     buf->writeByte('Z' - varargs);	// mark end of arg list
     next->toDecoBuffer(buf, mangle);
@@ -2917,7 +2917,7 @@
     {   buf->writeByte(' ');
 	buf->writestring(ident->toHChars2());
     }
-    Argument::argsToCBuffer(buf, hgs, parameters, varargs);
+    Parameter::argsToCBuffer(buf, hgs, parameters, varargs);
     inuse--;
 }
 
@@ -2953,7 +2953,7 @@
     if (!hgs->hdrgen && p)
 	buf->writestring(p);
     buf->writestring(" function");
-    Argument::argsToCBuffer(buf, hgs, parameters, varargs);
+    Parameter::argsToCBuffer(buf, hgs, parameters, varargs);
     inuse--;
 }
 
@@ -2969,11 +2969,11 @@
     TypeFunction *tf = (TypeFunction *)mem.malloc(sizeof(TypeFunction));
     memcpy(tf, this, sizeof(TypeFunction));
     if (parameters)
-    {	tf->parameters = (Arguments *)parameters->copy();
+    {	tf->parameters = (Parameters *)parameters->copy();
 	for (size_t i = 0; i < parameters->dim; i++)
-	{   Argument *arg = (Argument *)parameters->data[i];
-	    Argument *cpy = (Argument *)mem.malloc(sizeof(Argument));
-	    memcpy(cpy, arg, sizeof(Argument));
+	{   Parameter *arg = (Parameter *)parameters->data[i];
+	    Parameter *cpy = (Parameter *)mem.malloc(sizeof(Parameter));
+	    memcpy(cpy, arg, sizeof(Parameter));
 	    tf->parameters->data[i] = (void *)cpy;
 	}
     }
@@ -3006,9 +3006,9 @@
 	argsc->stc = 0;			// don't inherit storage class
 	argsc->protection = PROTpublic;
 
-	size_t dim = Argument::dim(tf->parameters);
+	size_t dim = Parameter::dim(tf->parameters);
 	for (size_t i = 0; i < dim; i++)
-	{   Argument *arg = Argument::getNth(tf->parameters, i);
+	{   Parameter *arg = Parameter::getNth(tf->parameters, i);
 
 	    tf->inuse++;
 	    arg->type = arg->type->semantic(loc, argsc);
@@ -3044,7 +3044,7 @@
 	     * change.
 	     */
 	    if (t->ty == Ttuple)
-	    {	dim = Argument::dim(tf->parameters);
+	    {	dim = Parameter::dim(tf->parameters);
 		i--;
 	    }
 	}
@@ -3059,7 +3059,7 @@
 	return terror;
     }
 
-    if (tf->varargs == 1 && tf->linkage != LINKd && Argument::dim(tf->parameters) == 0)
+    if (tf->varargs == 1 && tf->linkage != LINKd && Parameter::dim(tf->parameters) == 0)
 	error(loc, "variadic functions with non-D linkage must have at least one parameter");
 
     /* Don't return merge(), because arg identifiers and default args
@@ -3081,7 +3081,7 @@
     //printf("TypeFunction::callMatch()\n");
     int match = MATCHexact;		// assume exact match
 
-    size_t nparams = Argument::dim(parameters);
+    size_t nparams = Parameter::dim(parameters);
     size_t nargs = args ? args->dim : 0;
     if (nparams == nargs)
 	;
@@ -3098,7 +3098,7 @@
 
 	// BUG: what about out and ref?
 
-	Argument *p = Argument::getNth(parameters, u);
+	Parameter *p = Parameter::getNth(parameters, u);
 	assert(p);
 	if (u >= nargs)
 	{
@@ -3196,7 +3196,7 @@
     if (parameters)
     {
 	for (size_t i = 0; i < parameters->dim; i++)
-	{   Argument *arg = (Argument *)parameters->data[i];
+	{   Parameter *arg = (Parameter *)parameters->data[i];
 	    Type *t = arg->type->reliesOnTident();
 	    if (t)
 		return t;
@@ -3257,7 +3257,7 @@
 
     tf->next->toCBuffer2(buf, hgs, 0);
     buf->writestring(" delegate");
-    Argument::argsToCBuffer(buf, hgs, tf->parameters, tf->varargs);
+    Parameter::argsToCBuffer(buf, hgs, tf->parameters, tf->varargs);
 }
 
 Expression *TypeDelegate::defaultInit(Loc loc)
@@ -5173,7 +5173,7 @@
 
 /***************************** TypeTuple *****************************/
 
-TypeTuple::TypeTuple(Arguments *arguments)
+TypeTuple::TypeTuple(Parameters *arguments)
     : Type(Ttuple, NULL)
 {
     //printf("TypeTuple(this = %p)\n", this);
@@ -5184,7 +5184,7 @@
     {
 	for (size_t i = 0; i < arguments->dim; i++)
 	{
-	    Argument *arg = (Argument *)arguments->data[i];
+	    Parameter *arg = (Parameter *)arguments->data[i];
 	    assert(arg && arg->type);
 	}
     }
@@ -5199,7 +5199,7 @@
 TypeTuple::TypeTuple(Expressions *exps)
     : Type(Ttuple, NULL)
 {
-    Arguments *arguments = new Arguments;
+    Parameters *arguments = new Parameters;
     if (exps)
     {
 	arguments->setDim(exps->dim);
@@ -5207,7 +5207,7 @@
 	{   Expression *e = (Expression *)exps->data[i];
 	    if (e->type->ty == Ttuple)
 		e->error("cannot form tuple of tuples");
-	    Argument *arg = new Argument(STCin, e->type, NULL, NULL);
+	    Parameter *arg = new Parameter(STCin, e->type, NULL, NULL);
 	    arguments->data[i] = (void *)arg;
 	}
     }
@@ -5216,7 +5216,7 @@
 
 Type *TypeTuple::syntaxCopy()
 {
-    Arguments *args = Argument::arraySyntaxCopy(arguments);
+    Parameters *args = Parameter::arraySyntaxCopy(arguments);
     Type *t = new TypeTuple(args);
     return t;
 }
@@ -5249,8 +5249,8 @@
 	if (arguments->dim == tt->arguments->dim)
 	{
 	    for (size_t i = 0; i < tt->arguments->dim; i++)
-	    {   Argument *arg1 = (Argument *)arguments->data[i];
-		Argument *arg2 = (Argument *)tt->arguments->data[i];
+	    {   Parameter *arg1 = (Parameter *)arguments->data[i];
+		Parameter *arg2 = (Parameter *)tt->arguments->data[i];
 
 		if (!arg1->type->equals(arg2->type))
 		    return 0;
@@ -5267,7 +5267,7 @@
     {
 	for (size_t i = 0; i < arguments->dim; i++)
 	{
-	    Argument *arg = (Argument *)arguments->data[i];
+	    Parameter *arg = (Parameter *)arguments->data[i];
 	    Type *t = arg->type->reliesOnTident();
 	    if (t)
 		return t;
@@ -5278,14 +5278,14 @@
 
 void TypeTuple::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
 {
-    Argument::argsToCBuffer(buf, hgs, arguments, 0);
+    Parameter::argsToCBuffer(buf, hgs, arguments, 0);
 }
 
 void TypeTuple::toDecoBuffer(OutBuffer *buf, bool mangle)
 {
     //printf("TypeTuple::toDecoBuffer() this = %p\n", this);
     OutBuffer buf2;
-    Argument::argsToDecoBuffer(&buf2, arguments, mangle);
+    Parameter::argsToDecoBuffer(&buf2, arguments, mangle);
     unsigned len = buf2.offset;
     buf->printf("%c%d%.*s", mangleChar[ty], len, len, (char *)buf2.extractData());
 }
@@ -5352,10 +5352,10 @@
 	return Type::terror;
     }
 
-    Arguments *args = new Arguments;
+    Parameters *args = new Parameters;
     args->reserve(i2 - i1);
     for (size_t i = i1; i < i2; i++)
-    {	Argument *arg = (Argument *)tt->arguments->data[i];
+    {	Parameter *arg = (Parameter *)tt->arguments->data[i];
 	args->push(arg);
     }
 
@@ -5438,9 +5438,9 @@
     buf->printf("%s]", upr->toChars());
 }
 
-/***************************** Argument *****************************/
-
-Argument::Argument(unsigned storageClass, Type *type, Identifier *ident, Expression *defaultArg)
+/***************************** Parameter *****************************/
+
+Parameter::Parameter(unsigned storageClass, Type *type, Identifier *ident, Expression *defaultArg)
 {
     this->type = type;
     this->ident = ident;
@@ -5448,24 +5448,24 @@
     this->defaultArg = defaultArg;
 }
 
-Argument *Argument::syntaxCopy()
-{
-    Argument *a = new Argument(storageClass,
+Parameter *Parameter::syntaxCopy()
+{
+    Parameter *a = new Parameter(storageClass,
 		type ? type->syntaxCopy() : NULL,
 		ident,
 		defaultArg ? defaultArg->syntaxCopy() : NULL);
     return a;
 }
 
-Arguments *Argument::arraySyntaxCopy(Arguments *args)
-{   Arguments *a = NULL;
+Parameters *Parameter::arraySyntaxCopy(Parameters *args)
+{   Parameters *a = NULL;
 
     if (args)
     {
-	a = new Arguments();
+	a = new Parameters();
 	a->setDim(args->dim);
 	for (size_t i = 0; i < a->dim; i++)
-	{   Argument *arg = (Argument *)args->data[i];
+	{   Parameter *arg = (Parameter *)args->data[i];
 
 	    arg = arg->syntaxCopy();
 	    a->data[i] = (void *)arg;
@@ -5474,7 +5474,7 @@
     return a;
 }
 
-char *Argument::argsTypesToChars(Arguments *args, int varargs)
+char *Parameter::argsTypesToChars(Parameters *args, int varargs)
 {   OutBuffer *buf;
 
     buf = new OutBuffer();
@@ -5486,11 +5486,11 @@
 	HdrGenState hgs;
 
 	for (i = 0; i < args->dim; i++)
-	{   Argument *arg;
+	{   Parameter *arg;
 
 	    if (i)
 		buf->writeByte(',');
-	    arg = (Argument *)args->data[i];
+	    arg = (Parameter *)args->data[i];
 	    argbuf.reset();
 	    arg->type->toCBuffer2(&argbuf, &hgs, 0);
 	    buf->write(&argbuf);
@@ -5507,7 +5507,7 @@
     return buf->toChars();
 }
 
-void Argument::argsToCBuffer(OutBuffer *buf, HdrGenState *hgs, Arguments *arguments, int varargs)
+void Parameter::argsToCBuffer(OutBuffer *buf, HdrGenState *hgs, Parameters *arguments, int varargs)
 {
     buf->writeByte('(');
     if (arguments)
@@ -5515,11 +5515,11 @@
 	OutBuffer argbuf;
 
 	for (i = 0; i < arguments->dim; i++)
-	{   Argument *arg;
+	{   Parameter *arg;
 
 	    if (i)
 		buf->writestring(", ");
-	    arg = (Argument *)arguments->data[i];
+	    arg = (Parameter *)arguments->data[i];
 	    if (arg->storageClass & STCout)
 		buf->writestring("out ");
 	    else if (arg->storageClass & STCref)
@@ -5547,17 +5547,17 @@
 }
 
 
-void Argument::argsToDecoBuffer(OutBuffer *buf, Arguments *arguments, bool mangle)
-{
-    //printf("Argument::argsToDecoBuffer()\n");
+void Parameter::argsToDecoBuffer(OutBuffer *buf, Parameters *arguments, bool mangle)
+{
+    //printf("Parameter::argsToDecoBuffer()\n");
 
     // Write argument types
     if (arguments)
     {
-	size_t dim = Argument::dim(arguments);
+	size_t dim = Parameter::dim(arguments);
 	for (size_t i = 0; i < dim; i++)
 	{
-	    Argument *arg = Argument::getNth(arguments, i);
+	    Parameter *arg = Parameter::getNth(arguments, i);
 	    arg->toDecoBuffer(buf, mangle);
 	}
     }
@@ -5569,7 +5569,7 @@
  * If not, return NULL.
  */
 
-Type *Argument::isLazyArray()
+Type *Parameter::isLazyArray()
 {
 //    if (inout == Lazy)
     {
@@ -5582,7 +5582,7 @@
 		TypeDelegate *td = (TypeDelegate *)tel;
 		TypeFunction *tf = (TypeFunction *)td->next;
 
-		if (!tf->varargs && Argument::dim(tf->parameters) == 0)
+		if (!tf->varargs && Parameter::dim(tf->parameters) == 0)
 		{
 		    return tf->next;	// return type of delegate
 		}
@@ -5592,7 +5592,7 @@
     return NULL;
 }
 
-void Argument::toDecoBuffer(OutBuffer *buf, bool mangle)
+void Parameter::toDecoBuffer(OutBuffer *buf, bool mangle)
 {
     switch (storageClass & (STCin | STCout | STCref | STClazy))
     {   case 0:
@@ -5620,13 +5620,13 @@
  * Determine number of arguments, folding in tuples.
  */
 
-size_t Argument::dim(Arguments *args)
+size_t Parameter::dim(Parameters *args)
 {
     size_t n = 0;
     if (args)
     {
 	for (size_t i = 0; i < args->dim; i++)
-	{   Argument *arg = (Argument *)args->data[i];
+	{   Parameter *arg = (Parameter *)args->data[i];
 	    Type *t = arg->type->toBasetype();
 
 	    if (t->ty == Ttuple)
@@ -5641,21 +5641,21 @@
 }
 
 /***************************************
- * Get nth Argument, folding in tuples.
+ * Get nth Parameter, folding in tuples.
  * Returns:
- *	Argument*	nth Argument
+ *	Parameter*	nth Parameter
  *	NULL		not found, *pn gets incremented by the number
- *			of Arguments
+ *			of Parameters
  */
 
-Argument *Argument::getNth(Arguments *args, size_t nth, size_t *pn)
+Parameter *Parameter::getNth(Parameters *args, size_t nth, size_t *pn)
 {
     if (!args)
 	return NULL;
 
     size_t n = 0;
     for (size_t i = 0; i < args->dim; i++)
-    {   Argument *arg = (Argument *)args->data[i];
+    {   Parameter *arg = (Parameter *)args->data[i];
 	Type *t = arg->type->toBasetype();
 
 	if (t->ty == Ttuple)