projects/ddmd: dmd/expression/Util.d comparison

comparison dmd/expression/Util.d @ 135:af1bebfd96a4 dmd2037

dmd 2.038

author	Eldar Insafutdinov <e.insafutdinov@gmail.com>
date	Mon, 13 Sep 2010 22:19:42 +0100
parents	60bb0fe4563e
children	ea6325d0edd9

comparison

equal deleted inserted replaced

-:4251f96733f4
+:af1bebfd96a4
 *	1. implicitly convert argument to the corresponding parameter type
 *	2. add default arguments for any missing arguments
 *	3. do default promotions on arguments corresponding to ...
 *	4. add hidden _arguments[] argument
 *	5. call copy constructor for struct value arguments
-*/
+* Returns:
+*	return type from function
-void functionParameters(Loc loc, Scope sc, TypeFunction tf, Expressions arguments)
+*/
-{
-	uint n;
+Type functionParameters(Loc loc, Scope sc, TypeFunction tf, Expressions arguments)
+{
 //printf("functionParameters()\n");
 assert(arguments);
 size_t nargs = arguments ? arguments.dim : 0;
 size_t nparams = Parameter.dim(tf.parameters);
 if (nargs > nparams && tf.varargs == 0)
 	error(loc, "expected %zu arguments, not %zu for non-variadic function type %s", nparams, nargs, tf.toChars());
-n = (nargs > nparams) ? nargs : nparams;	// n = max(nargs, nparams)
+uint n = (nargs > nparams) ? nargs : nparams;	// n = max(nargs, nparams)
+uint wildmatch = 0;
 int done = 0;
 for (size_t i = 0; i < n; i++)
 {
 		Expression arg;
 				{
 					if (tf.varargs == 2 && i + 1 == nparams)
 						goto L2;
 					error(loc, "expected %d function arguments, not %d", nparams, nargs);
-					return;
+					return tf.next;
 				}
 				arg = p.defaultArg;
 				arg = arg.copy();
 version (DMDV2)
 {
 				if (arg.implicitConvTo(p.type))
 				{
 					if (nargs != nparams)
 					{
 						error(loc, "expected %zu function arguments, not %zu", nparams, nargs);
-						return;
+						return tf.next;
 					}
 					goto L1;
 				}
 				 L2:
 				tb = p.type.toBasetype();		///
 }
 						Identifier id = Lexer.uniqueId("__arrayArg");
 						Type t = new TypeSArray((cast(TypeArray)tb).next, new IntegerExp(nargs - i));
 						t = t.semantic(loc, sc);
 						VarDeclaration v = new VarDeclaration(loc, t, id, new VoidInitializer(loc));
+			            v.storage_class |= STCctfe;
 						v.semantic(sc);
 						v.parent = sc.parent;
 						//sc.insert(v);
 						Expression c = new DeclarationExp(Loc(0), v);
 					default:
 						if (!arg)
 						{
 							error(loc, "not enough arguments");
-							return;
+							return tf.next;
 						}
 						break;
 				}
 				arg = arg.semantic(sc);
 				if (p.type != arg.type)
 				{
 					//printf("arg.type = %s, p.type = %s\n", arg.type.toChars(), p.type.toChars());
 					if (arg.op == TOKtype)
 						arg.error("cannot pass type %s as function argument", arg.toChars());
-					arg = arg.implicitCastTo(sc, p.type);
+		            if (p.type.isWild() && tf.next.isWild())
+		            {
+Type t = p.type;
+			            MATCH m = arg.implicitConvTo(t);
+			            if (m == MATCH.MATCHnomatch)
+			            {
+t = t.constOf();
+			                m = arg.implicitConvTo(t);
+			                if (m == MATCHnomatch)
+			                {
+t = t.sharedConstOf();
+				                m = arg.implicitConvTo(t);
+			                }
+			                wildmatch |= p.type.wildMatch(arg.type);
+			            }
+			            arg = arg.implicitCastTo(sc, t);
+		            }
+		            else
+					arg = arg.implicitCastTo(sc, p.type);
 					arg = arg.optimize(WANT.WANTvalue);
 				}
 			}
 			if (p.storageClass & STC.STCref)
 			{
 			if (tb.ty == TY.Tsarray)
 			{
 				TypeSArray ts = cast(TypeSArray)tb;
 				Type ta = ts.next.arrayOf();
 				if (ts.size(arg.loc) == 0)
-				{
+					arg = new NullExp(arg.loc, ta);
-					arg = new NullExp(arg.loc);
-					arg.type = ta;
-				}
 				else
-				{
 					arg = arg.castTo(sc, ta);
-				}
 			}
 version (DMDV2) {
 			if (tb.ty == Tstruct)
 			{
 				arg = callCpCtor(loc, sc, arg);
 {
 		assert(arguments.dim >= nparams);
 		auto e = createTypeInfoArray(sc, &arguments[nparams], arguments.dim - nparams);
 		arguments.insert(0, e);
 }
+Type tret = tf.next;
+if (wildmatch)
+{	/* Adjust function return type based on wildmatch
+	 */
+	    //printf("wildmatch = x%x\n", wildmatch);
+	    assert(tret.isWild());
+	    if (wildmatch & MOD.MODconst || wildmatch & (wildmatch - 1))
+	        tret = tret.constOf();
+	    else if (wildmatch & MOD.MODimmutable)
+	        tret = tret.invariantOf();
+	    else
+	    {
+assert(wildmatch & MOD.MODmutable);
+	        tret = tret.mutableOf();
+	    }
+}
+return tret;
 }
 /******************************
 * Perform canThrow() on an array of Expressions.
 */
 Expression e = null;
 if (!v)
 		return e;
-if (v.isConst() || v.isInvariant() || v.storage_class & STC.STCmanifest)
+if (v.isConst() || v.isImmutable() || v.storage_class & STC.STCmanifest)
 {
 		if (!v.type)
 		{
 			//error("ICE");
 			return e;
 		auto arg = arguments[u];
 		if (!arg.type)
 			break;
 }
+Dsymbol s;
 AggregateDeclaration ad;
 auto arg = arguments[0];
 Type taggr = aggr.type;
 if (!taggr)
 		case TY.Tstruct:
 			ad = (cast(TypeStruct)tab).sym;
 			goto Laggr;
 		Laggr:
+	        s = search_function(ad, (op == TOKforeach_reverse) ? Id.applyReverse : Id.apply);
+	        if (s)
+		        goto Lapply;			// prefer opApply
 			if (arguments.dim == 1)
 			{
 				if (!arg.type)
 				{
 					/* Look for a head() or rear() overload
 					 */
 					Identifier id = (op == TOK.TOKforeach) ? Id.Fhead : Id.Ftoe;
-					Dsymbol s = search_function(ad, id);
+					Dsymbol s1 = search_function(ad, id);
-					FuncDeclaration fd = s ? s.isFuncDeclaration() : null;
+					FuncDeclaration fd = s1 ? s1.isFuncDeclaration() : null;
 					if (!fd)
 					{
-						if (s && s.isTemplateDeclaration())
+						if (s1 && s1.isTemplateDeclaration())
 							break;
 						goto Lapply;
 					}
 					arg.type = fd.type.nextOf();
 				}
 		Lapply:
 		{   /* Look for an
 			 *	int opApply(int delegate(ref Type [, ...]) dg);
 			 * overload
 			 */
-			Dsymbol s = search_function(ad, (op == TOK.TOKforeach_reverse) ? Id.applyReverse : Id.apply);
 			if (s)
 			{
 				FuncDeclaration fd = s.isFuncDeclaration();
 				if (fd)
 				{

Mercurial > projects > ddmd

comparison dmd/expression/Util.d @ 135:af1bebfd96a4 dmd2037