projects/ddmd: dmd/CallExp.d comparison

comparison dmd/CallExp.d @ 130:60bb0fe4563e

dmdfe 2.037 first main iteration

author	Eldar Insafutdinov <e.insafutdinov@gmail.com>
date	Thu, 09 Sep 2010 22:51:44 +0100
parents	e28b18c23469
children	af1bebfd96a4

comparison

equal deleted inserted replaced

-:010eb8f0e18d
+:60bb0fe4563e
 import dmd.DelegateExp;
 import dmd.IdentifierExp;
 import dmd.DotVarExp;
 import dmd.DotIdExp;
 import dmd.TY;
+import dmd.TRUST;
 import dmd.Id;
 import dmd.TypeAArray;
 import dmd.RemoveExp;
 import dmd.backend.elem;
 import dmd.UnaExp;
 			{
 				/* Attempt to instantiate ti. If that works, go with it.
 				 * If not, go with partial explicit specialization.
 				 */
 				ti.semanticTiargs(sc);
-				uint errors = global.errors;
+				if (ti.needsTypeInference(sc))
-				global.gag++;
+				{
-				ti.semantic(sc);
+					/* Go with partial explicit specialization
-				global.gag--;
-				if (errors != global.errors)
-				{
-					/* Didn't work, go with partial explicit specialization
 					 */
-					global.errors = errors;
 					targsi = ti.tiargs;
 					tierror = ti;			// for error reporting
 					e1 = new IdentifierExp(loc, ti.name);
 				}
+				else
+				{
+					ti.semantic(sc);
+				}
 			}
 		}
 		/* This recognizes:
 		 *	expr.foo!(tiargs)(funcargs)
 		 */
+Ldotti:
 		if (e1.op == TOK.TOKdotti && !e1.type)
 		{
 			DotTemplateInstanceExp se = cast(DotTemplateInstanceExp)e1;
 			TemplateInstance ti = se.ti;
 			if (!ti.semanticRun)
 			{
 				/* Attempt to instantiate ti. If that works, go with it.
 				 * If not, go with partial explicit specialization.
 				 */
 				ti.semanticTiargs(sc);
+static if (false) {
 				Expression etmp = e1.trySemantic(sc);
 				if (etmp)
 					e1 = etmp;	// it worked
 				else		// didn't work
 				{
 					targsi = ti.tiargs;
 					tierror = ti;		// for error reporting
 					e1 = new DotIdExp(loc, se.e1, ti.name);
 				}
+} else {
+				if (!ti.tempdecl)
+				{
+					se.getTempdecl(sc);
+				}
+				if (ti.tempdecl && ti.needsTypeInference(sc))
+				{
+				/* Go with partial explicit specialization
+				 */
+					targsi = ti.tiargs;
+					tierror = ti;			// for error reporting
+					e1 = new DotIdExp(loc, se.e1, ti.name);
+				}
+				else
+				{
+					e1 = e1.semantic(sc);
+				}
+}
 			}
 		}
 }
 		istemp = 0;
 	Lagain:
 		//printf("Lagain: %s\n", toChars());
+		//printf("test1 %s\n", toChars());
 		f = null;
 		if (e1.op == TOK.TOKthis || e1.op == TOK.TOKsuper)
 		{
 			// semantic() run later for these
 		}
 		else
 		{
-			UnaExp.semantic(sc);
+			if (e1.op == TOK.TOKdot)
+			{
+				auto die = cast(DotIdExp)e1;
+				e1 = die.semantic(sc, 1);
+				/* Look for e1 having been rewritten to expr.opDispatch!(string)
+				 * We handle such earlier, so go back.
+				 * Note that in the rewrite, we carefully did not run semantic() on e1
+				 */
+				if (e1.op == TOK.TOKdotti && !e1.type)
+				{
+					goto Ldotti;
+				}
+			}
+			else
+				UnaExp.semantic(sc);
 			/* Look for e1 being a lazy parameter
 			 */
 			if (e1.op == TOK.TOKvar)
 			{
 				return e;
 			}
 		}
 		arrayExpressionSemantic(arguments, sc);
-		preFunctionArguments(loc, sc, arguments);
+		preFunctionParameters(loc, sc, arguments);
 		if (e1.op == TOK.TOKdotvar && t1.ty == TY.Tfunction ||
 			e1.op == TOK.TOKdottd)
 		{
 			DotVarExp dve;
 			}
 			checkDeprecated(sc, f);
 	version (DMDV2) {
 			checkPurity(sc, f);
+			checkSafety(sc, f);
 	}
 			accessCheck(loc, sc, ue.e1, f);
 			if (!f.needThis())
 			{
 				VarExp ve = new VarExp(loc, f);
 					f = resolveFuncCall(sc, loc, cd.baseClass.ctor, null, null, arguments, 0);
 					checkDeprecated(sc, f);
 version (DMDV2) {
 					checkPurity(sc, f);
+					checkSafety(sc, f);
 }
 					e1 = new DotVarExp(e1.loc, e1, f);
 					e1 = e1.semantic(sc);
 					t1 = e1.type;
 				}
 				f = resolveFuncCall(sc, loc, cd.ctor, null, null, arguments, 0);
 				checkDeprecated(sc, f);
 version (DMDV2) {
 				checkPurity(sc, f);
+				checkSafety(sc, f);
 }
 				e1 = new DotVarExp(e1.loc, e1, f);
 				e1 = e1.semantic(sc);
 				t1 = e1.type;
 				tf = cast(TypeFunction)(td.next);
 				if (sc.func && sc.func.isPure() && !tf.ispure)
 				{
 					error("pure function '%s' cannot call impure delegate '%s'", sc.func.toChars(), e1.toChars());
 				}
+				if (sc.func && sc.func.isSafe() && tf.trust <= TRUST.TRUSTsystem)
+				{
+					error("safe function '%s' cannot call system delegate '%s'", sc.func.toChars(), e1.toChars());
+				}
 				goto Lcheckargs;
 			}
 			else if (t1.ty == TY.Tpointer && (cast(TypePointer)t1).next.ty == TY.Tfunction)
 			{
 				Expression e = new PtrExp(loc, e1);
 				t1 = (cast(TypePointer)t1).next;
 				if (sc.func && sc.func.isPure() && !(cast(TypeFunction)t1).ispure)
 				{
 					error("pure function '%s' cannot call impure function pointer '%s'", sc.func.toChars(), e1.toChars());
+				}
+				if (sc.func && sc.func.isSafe() && !(cast(TypeFunction)t1).trust <= TRUST.TRUSTsystem)
+				{
+					error("safe function '%s' cannot call system function pointer '%s'", sc.func.toChars(), e1.toChars());
 				}
 				e.type = t1;
 				e1 = e;
 			}
 			else if (e1.op == TOK.TOKtemplate)
 				goto Lagain;
 			}
 			else
 			{
 				error("function expected before (), not %s of type %s", e1.toChars(), e1.type.toChars());
-				type = Type.terror;
+				return new ErrorExp();
-				return this;
 			}
 		}
 		else if (e1.op == TOK.TOKvar)
 		{
 			// Do overload resolution
 				f = f.overloadResolve(loc, null, arguments);
 			checkDeprecated(sc, f);
 version (DMDV2) {
 			checkPurity(sc, f);
+			checkSafety(sc, f);
 }
 			if (f.needThis() && hasThis(sc))
 			{
 				// Supply an implicit 'this', as in
 		type = tf.next;
 		if (!arguments)
 			arguments = new Expressions();
-		functionArguments(loc, sc, tf, arguments);
+		functionParameters(loc, sc, tf, arguments);
 		if (!type)
 		{
 			error("forward reference to inferred return type of function call %s", toChars());
 			type = Type.terror;

Mercurial > projects > ddmd

comparison dmd/CallExp.d @ 130:60bb0fe4563e