projects/ldc: dmd2/expression.c comparison

comparison dmd2/expression.c @ 1526:54b3c1394d62

Merged dmdfe 2.031.

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

comparison

equal deleted inserted replaced

-:d28cd7c45267
+:54b3c1394d62
 	else if (e->op == TOKdotexp)
 	{
 	    e->error("expression has no value");
 	}
+}
+else if (e->op == TOKdottd)
+{
+	e = new CallExp(e->loc, e);
+	e = e->semantic(sc);
 }
 return e;
 }
 /******************************
 {	error("expression %s is void and has no value", toChars());
 #if 0
 	dump(0);
 	halt();
 #endif
-	type = Type::tint32;
+	type = Type::terror;
 }
 }
 Expression *Expression::combine(Expression *e1, Expression *e2)
 {
 }
 void Expression::toMangleBuffer(OutBuffer *buf)
 {
 error("expression %s is not a valid template value argument", toChars());
+#ifdef DEBUG
+dump(0);
+#endif
 }
 /***************************************
 * Return !=0 if expression is an lvalue.
 */
 void Expression::checkScalar()
 {
 if (!type->isscalar())
 	error("'%s' is not a scalar, it is a %s", toChars(), type->toChars());
+rvalue();
 }
 void Expression::checkNoBool()
 {
 if (type->toBasetype()->ty == Tbool)
 {
 if (!type->isintegral())
 {	error("'%s' is not of integral type, it is a %s", toChars(), type->toChars());
 	return new ErrorExp();
 }
+rvalue();
 return this;
 }
 Expression *Expression::checkArithmetic()
 {
 if (!type->isintegral() && !type->isfloating())
 {	error("'%s' is not of arithmetic type, it is a %s", toChars(), type->toChars());
 	return new ErrorExp();
 }
+rvalue();
 return this;
 }
 void Expression::checkDeprecated(Scope *sc, Dsymbol *s)
 {
 	/* See if the symbol was a member of an enclosing 'with'
 	 */
 	withsym = scopesym->isWithScopeSymbol();
 	if (withsym)
 	{
+#if DMDV2
+	    /* Disallow shadowing
+	     */
+	    // First find the scope of the with
+	    Scope *scwith = sc;
+	    while (scwith->scopesym != scopesym)
+	    {	scwith = scwith->enclosing;
+		assert(scwith);
+	    }
+	    // Look at enclosing scopes for symbols with the same name,
+	    // in the same function
+	    for (Scope *scx = scwith; scx && scx->func == scwith->func; scx = scx->enclosing)
+	    {   Dsymbol *s2;
+		if (scx->scopesym && scx->scopesym->symtab &&
+		    (s2 = scx->scopesym->symtab->lookup(s->ident)) != NULL &&
+		    s != s2)
+		{
+		    error("with symbol %s is shadowing local symbol %s", s->toPrettyChars(), s2->toPrettyChars());
+		}
+	    }
+#endif
 	    s = s->toAlias();
 	    // Same as wthis.ident
 	    if (s->needThis() || s->isTemplateDeclaration())
 	    {
 {
 	//printf("Identifier '%s' is a variable, type '%s'\n", toChars(), v->type->toChars());
 	if (!type)
 	{   type = v->type;
 	    if (!v->type)
-	    {	error("forward reference of %s", v->toChars());
+	    {	error("forward reference of %s %s", v->kind(), v->toChars());
 		type = Type::terror;
 	    }
 	}
 	e = new VarExp(loc, v);
 	e->type = type;
 	return e->semantic(sc);
 }
 f = s->isFuncDeclaration();
 if (f)
 {	//printf("'%s' is a function\n", f->toChars());
+	if (!f->type->deco)
+	{
+	    error("forward reference to %s", toChars());
+	}
 	return new VarExp(loc, f, hasOverloads);
 }
 o = s->isOverloadSet();
 if (o)
 {	//printf("'%s' is an overload set\n", o->toChars());
 	return e;
 }
 TemplateInstance *ti = s->isTemplateInstance();
 if (ti && !global.errors)
-{   if (!ti->semanticdone)
+{   if (!ti->semanticRun)
 	    ti->semantic(sc);
 	s = ti->inst->toAlias();
 	if (!s->isTemplateInstance())
 	    goto Lagain;
 	e = new ScopeExp(loc, ti);
 // Run semantic() on each element
 for (int i = 0; i < elements->dim; i++)
 {	e = (Expression *)elements->data[i];
 	e = e->semantic(sc);
+	assert(e->type);
 	elements->data[i] = (void *)e;
 }
 expandTuples(elements);
 for (int i = 0; i < elements->dim; i++)
 {	e = (Expression *)elements->data[i];
 //printf("TypeExp::semantic(%s)\n", type->toChars());
 type = type->semantic(loc, sc);
 return this;
 }
+void TypeExp::rvalue()
+{
+error("type %s has no value", toChars());
+}
 void TypeExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 type->toCBuffer(buf, NULL, hgs);
 }
 #endif
 Lagain:
 ti = sds->isTemplateInstance();
 if (ti && !global.errors)
 {	Dsymbol *s;
-	if (!ti->semanticdone)
+	if (!ti->semanticRun)
 	    ti->semantic(sc);
 	s = ti->inst->toAlias();
 	sds2 = s->isScopeDsymbol();
 	if (!sds2)
 	{   Expression *e;
 			    break;
 		    }
 		}
 #endif
 	    }
-	    else if (fdn) // Possible problems here, no obvious solution when merging
+#if 1
+	    else if (thisexp)
+		error("e.new is only for allocating nested classes");
+	    else if (fdn)
+	    {
+		// make sure the parent context fdn of cd is reachable from sc
+		for (Dsymbol *sp = sc->parent; 1; sp = sp->parent)
+		{
+		    if (fdn == sp)
+			break;
+		    FuncDeclaration *fsp = sp ? sp->isFuncDeclaration() : NULL;
+		    if (!sp || (fsp && fsp->isStatic()))
+		    {
+			error("outer function context of %s is needed to 'new' nested class %s", fdn->toPrettyChars(), cd->toPrettyChars());
+			break;
+		    }
+		}
+	    }
+#else
+	    else if (fdn)
 	    {	/* The nested class cd is nested inside a function,
 		 * we'll let getEthis() look for errors.
 		 */
 		//printf("nested class %s is nested inside function %s, we're in %s\n", cd->toChars(), fdn->toChars(), sc->func->toChars());
 		if (thisexp)
 		    // Because thisexp cannot be a function frame pointer
 		    error("e.new is only for allocating nested classes");
 	    }
+#endif
 	    else
 		assert(0);
 	}
 	else if (thisexp)
 	    error("e.new is only for allocating nested classes");
 	    type = new TypeDelegate(tf);
 	    type = type->semantic(loc, sc);
 	}
 #endif
 }
 /* Fix for 1161 doesn't work because it causes protection
 * problems when instantiating imported templates passing private
 * variables as alias template parameters.
 */
 //accessCheck(loc, sc, NULL, var);
 	e = new FuncExp(loc, fd);
 	e->type = type;
 	return e;
 }
 #endif
 return this;
 }
 char *VarExp::toChars()
 {
 if (0 && exps->dim == 1)
 {
 	return (Expression *)exps->data[0];
 }
 type = new TypeTuple(exps);
+type = type->semantic(loc, sc);
 //printf("-TupleExp::semantic(%s)\n", toChars());
 return this;
 }
 void TupleExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 *	foo!(tiargs)(funcargs)
 */
 if (e1->op == TOKimport && !e1->type)
 {	ScopeExp *se = (ScopeExp *)e1;
 	TemplateInstance *ti = se->sds->isTemplateInstance();
-	if (ti && !ti->semanticdone)
+	if (ti && !ti->semanticRun)
 	{
 	    /* Attempt to instantiate ti. If that works, go with it.
 	     * If not, go with partial explicit specialization.
 	     */
 	    ti->semanticTiargs(sc);
 *	expr.foo!(tiargs)(funcargs)
 */
 if (e1->op == TOKdotti && !e1->type)
 {	DotTemplateInstanceExp *se = (DotTemplateInstanceExp *)e1;
 	TemplateInstance *ti = se->ti;
-	if (!ti->semanticdone)
+	if (!ti->semanticRun)
 	{
 	    /* Attempt to instantiate ti. If that works, go with it.
 	     * If not, go with partial explicit specialization.
 	     */
 	    ti->semanticTiargs(sc);
 /************************************************************/
 AddrExp::AddrExp(Loc loc, Expression *e)
 	: UnaExp(loc, TOKaddress, sizeof(AddrExp), e)
 {
+#if IN_LLVM
 m = NULL;
+#endif
 }
 Expression *AddrExp::semantic(Scope *sc)
 {
 #if LOGSEMANTIC
 printf("AddrExp::semantic('%s')\n", toChars());
 #endif
 if (!type)
 {
+#if IN_LLVM
 	m = sc->module;
+#endif
 	UnaExp::semantic(sc);
 	e1 = e1->toLvalue(sc, NULL);
 	if (!e1->type)
 	{
 	    error("cannot take address of %s", e1->toChars());
-	    type = Type::tint32;
+	    return new ErrorExp();
-	    return this;
+	}
-	}
+	if (!e1->type->deco)
+	{
+	    /* No deco means semantic() was not run on the type.
+	     * We have to run semantic() on the symbol to get the right type:
+	     *	auto x = &bar;
+	     *	pure: int bar() { return 1;}
+	     * otherwise the 'pure' is missing from the type assigned to x.
+	     */
+	    error("forward reference to %s", e1->toChars());
+	    return new ErrorExp();
+	}
+//printf("test3 deco = %p\n", e1->type->deco);
 	type = e1->type->pointerTo();
 	// See if this should really be a delegate
 	if (e1->op == TOKdotvar)
 	{
 /************************************************************/
 PtrExp::PtrExp(Loc loc, Expression *e)
 	: UnaExp(loc, TOKstar, sizeof(PtrExp), e)
 {
-if (e->type)
+//    if (e->type)
-	type = ((TypePointer *)e->type)->next;
+//	type = ((TypePointer *)e->type)->next;
 }
 PtrExp::PtrExp(Loc loc, Expression *e, Type *t)
 	: UnaExp(loc, TOKstar, sizeof(PtrExp), e)
 {
 type = t;
 }
 Expression *PtrExp::semantic(Scope *sc)
-{   Type *tb;
+{
 #if LOGSEMANTIC
 printf("PtrExp::semantic('%s')\n", toChars());
 #endif
 if (!type)
 {
 	if (!e1->type)
 	    printf("PtrExp::semantic('%s')\n", toChars());
 	Expression *e = op_overload(sc);
 	if (e)
 	    return e;
-	tb = e1->type->toBasetype();
+	Type *tb = e1->type->toBasetype();
 	switch (tb->ty)
 	{
 	    case Tpointer:
 		type = ((TypePointer *)tb)->next;
 		break;
 		e1 = e1->castTo(sc, type->pointerTo());
 		break;
 	    default:
 		error("can only * a pointer, not a '%s'", e1->type->toChars());
-		type = Type::tint32;
+		return new ErrorExp();
-		break;
 	}
 	rvalue();
 }
 return this;
 }
 	error("compare not defined for complex operands");
 	e = new ErrorExp();
 }
 #endif
 else
+{	e1->rvalue();
+	e2->rvalue();
 	e = this;
-//printf("CmpExp: %s\n", e->toChars());
+}
+//printf("CmpExp: %s, type = %s\n", e->toChars(), e->type->toChars());
 return e;
 }
 int CmpExp::isBit()
 {

Mercurial > projects > ldc

comparison dmd2/expression.c @ 1526:54b3c1394d62