projects/ldc: dmd2/mtype.c comparison

comparison dmd2/mtype.c @ 1452:638d16625da2

LDC 2 compiles again.

author	Robert Clipsham <robert@octarineparrot.com>
date	Sat, 30 May 2009 17:23:32 +0100
parents	442ab244c455
children	a5526b7a5ae6

comparison

equal deleted inserted replaced

-:42bd767ec5a4
+:638d16625da2
 // Compiler implementation of the D programming language
-// Copyright (c) 1999-2008 by Digital Mars
+// Copyright (c) 1999-2009 by Digital Mars
 // All Rights Reserved
 // written by Walter Bright
 // http://www.digitalmars.com
 // License for redistribution is by either the Artistic License
 // in artistic.txt, or the GNU General Public License in gnu.txt.
 // See the included readme.txt for details.
+#define __C99FEATURES__ 1	// Needed on Solaris for NaN and more
 #define __USE_ISOC99 1		// so signbit() gets defined
+#if (defined (__SVR4) && defined (__sun))
+#include <alloca.h>
+#endif
 #ifdef __DMC__
 #include <math.h>
 #else
 #include <cmath>
 #endif
 #include <stdio.h>
 #include <assert.h>
 #include <float.h>
-#ifdef __DMC__
-#include <fp.h>
-#endif
 #if _MSC_VER
 #include <malloc.h>
 #include <complex>
 #include <limits>
 #elif __DMC__
 #include <complex.h>
 #elif __MINGW32__
 #include <malloc.h>
-#else
+#endif
-//#define signbit 56
-#endif
+#include "rmem.h"
+#include "port.h"
-#if __GNUC__
-#if !(defined (__SVR4) && defined (__sun))
-#include <bits/nan.h>
-#include <bits/mathdef.h>
-#endif
-#endif
-static double zero = 0;
-#include "mem.h"
 #include "dsymbol.h"
 #include "mtype.h"
 #include "scope.h"
 #include "init.h"
 #include "enum.h"
 #include "import.h"
 #include "aggregate.h"
 #include "hdrgen.h"
-#include "gen/tollvm.h"
+#if IN_LLVM
+//#include "gen/tollvm.h"
+Ir* Type::sir = NULL;
+unsigned GetTypeAlignment(Ir* ir, Type* t);
+#endif
 FuncDeclaration *hasThis(Scope *sc);
 #define LOGDOTEXP	0	// log ::dotExp()
 /* These have default values for 32 bit code, they get
 * adjusted for 64 bit code.
 */
 int PTRSIZE = 4;
-#if IN_LLVM
-int REALSIZE = 8;
+/* REALSIZE = size a real consumes in memory
-int REALPAD = 0;
+* REALPAD = 'padding' added to the CPU real size to bring it up to REALSIZE
-#elif TARGET_LINUX
+* REALALIGNSIZE = alignment for reals
+*/
+#if TARGET_OSX
+int REALSIZE = 16;
+int REALPAD = 6;
+int REALALIGNSIZE = 16;
+#elif TARGET_LINUX || TARGET_FREEBSD || TARGET_SOLARIS
 int REALSIZE = 12;
 int REALPAD = 2;
+int REALALIGNSIZE = 4;
 #else
 int REALSIZE = 10;
 int REALPAD = 0;
-#endif
+int REALALIGNSIZE = 2;
+#endif
 int Tsize_t = Tuns32;
 int Tptrdiff_t = Tint32;
+#if _WIN32 && !defined __MINGW32__
+static double zero = 0;
+double Port::nan = NAN;
+double Port::infinity = 1/zero;
+#endif
 /***************************** Type *****************************/
 ClassDeclaration *Type::typeinfo;
 ClassDeclaration *Type::typeinfoclass;
 ClassDeclaration *Type::typeinfofunction;
 ClassDeclaration *Type::typeinfodelegate;
 ClassDeclaration *Type::typeinfotypelist;
 ClassDeclaration *Type::typeinfoconst;
 ClassDeclaration *Type::typeinfoinvariant;
+ClassDeclaration *Type::typeinfoshared;
 Type *Type::tvoidptr;
 Type *Type::basic[TMAX];
 unsigned char Type::mangleChar[TMAX];
 unsigned char Type::sizeTy[TMAX];
 StringTable Type::stringtable;
+#if IN_LLVM
-Type::Type(TY ty)
+StringTable Type::deco_stringtable;
+#endif
+Type::Type(TY ty/*, Type *next*/)
 {
 this->ty = ty;
 this->mod = 0;
+//this->next = next;
 this->deco = NULL;
 #if DMDV2
 this->cto = NULL;
 this->ito = NULL;
+this->sto = NULL;
+this->scto = NULL;
 #endif
 this->pto = NULL;
 this->rto = NULL;
 this->arrayof = NULL;
 this->vtinfo = NULL;
+#if IN_DMD
 this->ctype = NULL;
+#endif
+#if IN_LLVM
+this->irtype = NULL;
+#endif
 }
 Type *Type::syntaxCopy()
 {
 print();
 char Type::needThisPrefix()
 {
 return 'M';		// name mangling prefix for functions needing 'this'
 }
+#if IN_LLVM
+void Type::init(Ir* _sir)
+#else
 void Type::init()
+#endif
 {   int i;
 int j;
 Lexer::initKeywords();
 }
 basic[Terror] = basic[Tint32];
 tvoidptr = tvoid->pointerTo();
+// LDC
+sir = _sir;
 // set size_t / ptrdiff_t types and pointer size
 if (global.params.is64bit)
 {
 	Tsize_t = Tuns64;
 	Tptrdiff_t = Tint64;
 	PTRSIZE = 8;
 }
 else
 {
+	PTRSIZE = 4;
+#if TARGET_OSX
+	REALSIZE = 16;
+	REALPAD = 6;
+#elif TARGET_LINUX || TARGET_FREEBSD || TARGET_SOLARIS
+	REALSIZE = 12;
+	REALPAD = 2;
+#else
+	REALSIZE = 10;
+	REALPAD = 0;
+#endif
 	Tsize_t = Tuns32;
 	Tptrdiff_t = Tint32;
 	PTRSIZE = 4;
 }
 }
 Type *Type::semantic(Loc loc, Scope *sc)
 {
 return merge();
+}
+Type *Type::trySemantic(Loc loc, Scope *sc)
+{
+unsigned errors = global.errors;
+global.gag++;			// suppress printing of error messages
+Type *t = semantic(loc, sc);
+global.gag--;
+if (errors != global.errors)	// if any errors happened
+{
+	global.errors = errors;
+	t = NULL;
+}
+return t;
 }
 /*******************************
 * Determine if converting 'this' to 'to' is an identity operation,
 * a conversion to const operation, or the types aren't the same.
 if (ty == to->ty && to->mod == MODconst)
 	return MATCHconst;
 return MATCHnomatch;
 }
+/********************************
+* Convert to 'const'.
+*/
 Type *Type::constOf()
 {
+#if 0
 //printf("Type::constOf() %p %s\n", this, toChars());
 if (isConst())
 	return this;
 if (cto)
 	return cto;
 if (ito)
 	ito->cto = t;
 //if (t->nextOf()) assert(t->nextOf()->isConst());
 //printf("-Type::constOf() %p %s\n", t, toChars());
 return t;
-}
+#else
+//printf("Type::constOf() %p %s\n", this, toChars());
+if (mod == MODconst)
+	return this;
+if (cto)
+{	assert(cto->mod == MODconst);
+	return cto;
+}
+Type *t = makeConst();
+t = t->merge();
+t->fixTo(this);
+//printf("-Type::constOf() %p %s\n", t, toChars());
+return t;
+#endif
+}
+/********************************
+* Convert to 'immutable'.
+*/
 Type *Type::invariantOf()
 {
+#if 0
 //printf("Type::invariantOf() %p %s\n", this, toChars());
 if (isInvariant())
 {
 	return this;
 }
 	assert(0);
 }
 #endif
 //printf("\t%p\n", t);
 return t;
-}
+#else
+//printf("Type::invariantOf() %p %s\n", this, toChars());
+if (isInvariant())
+{
+	return this;
+}
+if (ito)
+{
+	assert(ito->isInvariant());
+	return ito;
+}
+Type *t = makeInvariant();
+t = t->merge();
+t->fixTo(this);
+//printf("\t%p\n", t);
+return t;
+#endif
+}
+/********************************
+* Make type mutable.
+*/
 Type *Type::mutableOf()
 {
+#if 0
 //printf("Type::mutableOf() %p, %s\n", this, toChars());
 Type *t = this;
 if (isConst())
 {	t = cto;
 	assert(!t || t->isMutable());
 	t->arrayof = NULL;
 	t->pto = NULL;
 	t->rto = NULL;
 	t->cto = NULL;
 	t->ito = NULL;
+	t->sto = NULL;
+	t->scto = NULL;
 	t->vtinfo = NULL;
 	if (ty == Tsarray)
 	{   TypeSArray *ta = (TypeSArray *)t;
 	    //ta->next = ta->next->mutableOf();
 	}
 	    if (cto)
 		cto->ito = this;
 	}
 }
 return t;
+#else
+//printf("Type::mutableOf() %p, %s\n", this, toChars());
+Type *t = this;
+if (isConst())
+{	if (isShared())
+	    t = sto;		// shared const => shared
+	else
+	    t = cto;
+	assert(!t || t->isMutable());
+}
+else if (isInvariant())
+{	t = ito;
+	assert(!t || (t->isMutable() && !t->isShared()));
+}
+if (!t)
+{
+	unsigned sz = sizeTy[ty];
+	t = (Type *)mem.malloc(sz);
+	memcpy(t, this, sz);
+	t->mod = 0;
+	t->deco = NULL;
+	t->arrayof = NULL;
+	t->pto = NULL;
+	t->rto = NULL;
+	t->cto = NULL;
+	t->ito = NULL;
+	t->sto = NULL;
+	t->scto = NULL;
+	t->vtinfo = NULL;
+	t = t->merge();
+	t->fixTo(this);
+	switch (mod)
+	{
+	    case MODconst:
+		t->cto = this;
+		break;
+	    case MODinvariant:
+		t->ito = this;
+		break;
+	    case MODshared:
+		t->sto = this;
+		break;
+	    case MODshared | MODconst:
+		t->scto = this;
+		break;
+	    default:
+		assert(0);
+	}
+}
+return t;
+#endif
+}
+Type *Type::sharedOf()
+{
+//printf("Type::sharedOf() %p, %s\n", this, toChars());
+if (mod == MODshared)
+{
+	return this;
+}
+if (sto)
+{
+	assert(sto->isShared());
+	return sto;
+}
+Type *t = makeShared();
+t = t->merge();
+t->fixTo(this);
+//printf("\t%p\n", t);
+return t;
+}
+Type *Type::sharedConstOf()
+{
+//printf("Type::sharedConstOf() %p, %s\n", this, toChars());
+if (mod == (MODshared | MODconst))
+{
+	return this;
+}
+if (scto)
+{
+	assert(scto->mod == (MODshared | MODconst));
+	return scto;
+}
+Type *t = makeSharedConst();
+t = t->merge();
+t->fixTo(this);
+//printf("\t%p\n", t);
+return t;
+}
+/**********************************
+* For our new type 'this', which is type-constructed from t,
+* fill in the cto, ito, sto, scto shortcuts.
+*/
+void Type::fixTo(Type *t)
+{
+ito = t->ito;
+#if 0
+/* Cannot do these because these are not fully transitive:
+* there can be a shared ptr to immutable, for example.
+* Immutable subtypes are always immutable, though.
+*/
+cto = t->cto;
+sto = t->sto;
+scto = t->scto;
+#endif
+assert(mod != t->mod);
+#define X(m, n) (((m) << 3) | (n))
+switch (X(mod, t->mod))
+{
+	case X(0, MODconst):
+	    cto = t;
+	    break;
+	case X(0, MODinvariant):
+	    ito = t;
+	    break;
+	case X(0, MODshared):
+	    sto = t;
+	    break;
+	case X(0, MODshared | MODconst):
+	    scto = t;
+	    break;
+	case X(MODconst, 0):
+	    cto = NULL;
+	    goto L2;
+	case X(MODconst, MODinvariant):
+	    ito = t;
+	    goto L2;
+	case X(MODconst, MODshared):
+	    sto = t;
+	    goto L2;
+	case X(MODconst, MODshared | MODconst):
+	    scto = t;
+	L2:
+	    t->cto = this;
+	    break;
+	case X(MODinvariant, 0):
+	    ito = NULL;
+	    goto L3;
+	case X(MODinvariant, MODconst):
+	    cto = t;
+	    goto L3;
+	case X(MODinvariant, MODshared):
+	    sto = t;
+	    goto L3;
+	case X(MODinvariant, MODshared | MODconst):
+	    scto = t;
+	L3:
+	    t->ito = this;
+	    if (t->cto) t->cto->ito = this;
+	    if (t->sto) t->sto->ito = this;
+	    if (t->scto) t->scto->ito = this;
+	    break;
+	case X(MODshared, 0):
+	    sto = NULL;
+	    goto L4;
+	case X(MODshared, MODconst):
+	    cto = t;
+	    goto L4;
+	case X(MODshared, MODinvariant):
+	    ito = t;
+	    goto L4;
+	case X(MODshared, MODshared | MODconst):
+	    scto = t;
+	L4:
+	    t->sto = this;
+	    break;
+	case X(MODshared | MODconst, 0):
+	    scto = NULL;
+	    break;
+	case X(MODshared | MODconst, MODconst):
+	    cto = t;
+	    break;
+	case X(MODshared | MODconst, MODinvariant):
+	    ito = t;
+	    break;
+	case X(MODshared | MODconst, MODshared):
+	    sto = t;
+	L5:
+	    t->scto = this;
+	    break;
+	default:
+	    assert(0);
+}
+#undef X
+check();
+t->check();
+//printf("fixTo: %s, %s\n", toChars(), t->toChars());
+}
+/***************************
+* Look for bugs in constructing types.
+*/
+void Type::check()
+{
+switch (mod)
+{
+	case 0:
+	    if (cto) assert(cto->mod == MODconst);
+	    if (ito) assert(ito->mod == MODinvariant);
+	    if (sto) assert(sto->mod == MODshared);
+	    if (scto) assert(scto->mod == (MODshared | MODconst));
+	    break;
+	case MODconst:
+	    if (cto) assert(cto->mod == 0);
+	    if (ito) assert(ito->mod == MODinvariant);
+	    if (sto) assert(sto->mod == MODshared);
+	    if (scto) assert(scto->mod == (MODshared | MODconst));
+	    break;
+	case MODinvariant:
+	    if (cto) assert(cto->mod == MODconst);
+	    if (ito) assert(ito->mod == 0);
+	    if (sto) assert(sto->mod == MODshared);
+	    if (scto) assert(scto->mod == (MODshared | MODconst));
+	    break;
+	case MODshared:
+	    if (cto) assert(cto->mod == MODconst);
+	    if (ito) assert(ito->mod == MODinvariant);
+	    if (sto) assert(sto->mod == 0);
+	    if (scto) assert(scto->mod == (MODshared | MODconst));
+	    break;
+	case MODshared | MODconst:
+	    if (cto) assert(cto->mod == MODconst);
+	    if (ito) assert(ito->mod == MODinvariant);
+	    if (sto) assert(sto->mod == MODshared);
+	    if (scto) assert(scto->mod == 0);
+	    break;
+	default:
+	    assert(0);
+}
+Type *tn = nextOf();
+if (tn && ty != Tfunction && ty != Tdelegate)
+{	// Verify transitivity
+	switch (mod)
+	{
+	    case 0:
+		break;
+	    case MODconst:
+		assert(tn->mod & MODinvariant || tn->mod & MODconst);
+		break;
+	    case MODinvariant:
+		assert(tn->mod == MODinvariant);
+		break;
+	    case MODshared:
+		assert(tn->mod & MODinvariant || tn->mod & MODshared);
+		break;
+	    case MODshared | MODconst:
+		assert(tn->mod & MODinvariant || tn->mod & (MODshared | MODconst));
+		break;
+	    default:
+		assert(0);
+	}
+	tn->check();
+}
 }
 Type *Type::makeConst()
 {
 //printf("Type::makeConst() %p, %s\n", this, toChars());
 t->arrayof = NULL;
 t->pto = NULL;
 t->rto = NULL;
 t->cto = NULL;
 t->ito = NULL;
+t->sto = NULL;
+t->scto = NULL;
 t->vtinfo = NULL;
 //printf("-Type::makeConst() %p, %s\n", t, toChars());
 return t;
 }
 t->arrayof = NULL;
 t->pto = NULL;
 t->rto = NULL;
 t->cto = NULL;
 t->ito = NULL;
+t->sto = NULL;
+t->scto = NULL;
 t->vtinfo = NULL;
 return t;
+}
+Type *Type::makeShared()
+{
+if (sto)
+	return sto;
+unsigned sz = sizeTy[ty];
+Type *t = (Type *)mem.malloc(sz);
+memcpy(t, this, sz);
+t->mod = MODshared;
+t->deco = NULL;
+t->arrayof = NULL;
+t->pto = NULL;
+t->rto = NULL;
+t->cto = NULL;
+t->ito = NULL;
+t->sto = NULL;
+t->scto = NULL;
+t->vtinfo = NULL;
+return t;
+}
+Type *Type::makeSharedConst()
+{
+if (scto)
+	return scto;
+unsigned sz = sizeTy[ty];
+Type *t = (Type *)mem.malloc(sz);
+memcpy(t, this, sz);
+t->mod = MODshared | MODconst;
+t->deco = NULL;
+t->arrayof = NULL;
+t->pto = NULL;
+t->rto = NULL;
+t->cto = NULL;
+t->ito = NULL;
+t->sto = NULL;
+t->scto = NULL;
+t->vtinfo = NULL;
+return t;
+}
+/************************************
+* Apply MODxxxx bits to existing type.
+*/
+Type *Type::castMod(unsigned mod)
+{   Type *t;
+switch (mod)
+{
+	case 0:
+	    t = mutableOf();
+	    break;
+	case MODconst:
+	    t = constOf();
+	    break;
+	case MODinvariant:
+	    t = invariantOf();
+	    break;
+	case MODshared:
+	    t = sharedOf();
+	    break;
+	case MODshared | MODconst:
+	    t = sharedConstOf();
+	    break;
+	default:
+	    assert(0);
+}
+return t;
+}
+/************************************
+* Add MODxxxx bits to existing type.
+* We're adding, not replacing, so adding const to
+* a shared type => "shared const"
+*/
+Type *Type::addMod(unsigned mod)
+{   Type *t = this;
+/* Add anything to immutable, and it remains immutable
+*/
+if (!t->isInvariant())
+{
+	switch (mod)
+	{
+	    case 0:
+		break;
+	    case MODconst:
+		if (isShared())
+		    t = sharedConstOf();
+		else
+		    t = constOf();
+		break;
+	    case MODinvariant:
+		t = invariantOf();
+		break;
+	    case MODshared:
+		if (isConst())
+		    t = sharedConstOf();
+		else
+		    t = sharedOf();
+		break;
+	    case MODshared | MODconst:
+		t = sharedConstOf();
+		break;
+	    default:
+		assert(0);
+	}
+}
+return t;
+}
+/************************************
+* Add storage class modifiers to type.
+*/
+Type *Type::addStorageClass(unsigned stc)
+{
+/* Just translate to MOD bits and let addMod() do the work
+*/
+unsigned mod = 0;
+if (stc & STCimmutable)
+	mod = MODinvariant;
+else
+{	if (stc & (STCconst | STCin))
+	    mod = MODconst;
+	if (stc & STCshared)
+	    mod |= MODshared;
+}
+return addMod(mod);
 }
 /**************************
 * Return type with the top level of it being mutable.
 */
 * Name mangling.
 * Input:
 *	flag	0x100	do not do const/invariant
 */
-void Type::toDecoBuffer(OutBuffer *buf, int flag)
+void Type::toDecoBuffer(OutBuffer *buf, int flag, bool mangle) // Possible conflict from merge
 {
 if (flag != mod && flag != 0x100)
 {
 	if (mod & MODshared)
 	    buf->writeByte('O');
 void Type::toCBuffer3(OutBuffer *buf, HdrGenState *hgs, int mod)
 {
 if (mod != this->mod)
 {	const char *p;
-	if (mod & MODshared)
+	if (this->mod & MODshared)
 	    buf->writestring("shared(");
 	switch (this->mod & (MODconst | MODinvariant))
 	{
 	    case 0:
 		toCBuffer2(buf, hgs, this->mod);
 		break;
 	    case MODconst:
 		p = "const(";
 		goto L1;
 	    case MODinvariant:
-		p = "invariant(";
+		p = "immutable(";
 	    L1:	buf->writestring(p);
 		toCBuffer2(buf, hgs, this->mod);
 		buf->writeByte(')');
 		break;
 	    default:
 		assert(0);
 	}
-	if (mod & MODshared)
+	if (this->mod & MODshared)
 	    buf->writeByte(')');
 }
 }
 /************************************
 	OutBuffer buf;
 	StringValue *sv;
 	//if (next)
 	    //next = next->merge();
-	toDecoBuffer(&buf);
+	toDecoBuffer(&buf, false);
 	sv = stringtable.update((char *)buf.data, buf.offset);
 	if (sv->ptrvalue)
 	{   t = (Type *) sv->ptrvalue;
 	    assert(t->deco);
 	    //printf("old value, deco = '%s' %p\n", t->deco, t->deco);
 	}
 	else
 	{
 	    sv->ptrvalue = this;
-	    deco = sv->lstring.string;
+// we still need deco strings to be unique
+// or Type::equals fails, which breaks a bunch of stuff,
+// like covariant member function overloads.
+	    OutBuffer mangle;
+	    toDecoBuffer(&mangle, true);
+	    StringValue* sv2 = deco_stringtable.update((char *)mangle.data, mangle.offset);
+	    if (sv2->ptrvalue)
+	    {  Type* t2 = (Type *) sv2->ptrvalue;
+	       assert(t2->deco);
+	       deco = t2->deco;
+	    }
+	    else
+	    {
+	       sv2->ptrvalue = this;
+	       deco = (char *)sv2->lstring.string;
+	    }
 	    //printf("new value, deco = '%s' %p\n", t->deco, t->deco);
 	}
 }
+return t;
+}
+/*************************************
+* This version does a merge even if the deco is already computed.
+* Necessary for types that have a deco, but are not merged.
+*/
+Type *Type::merge2()
+{
+//printf("merge2(%s)\n", toChars());
+Type *t = this;
+assert(t);
+if (!t->deco)
+	return t->merge();
+StringValue *sv = deco_stringtable.lookup((char *)t->deco, strlen(t->deco));
+if (sv && sv->ptrvalue)
+{   t = (Type *) sv->ptrvalue;
+	assert(t->deco);
+}
+else
+	assert(0);
 return t;
 }
 int Type::isintegral()
 {
 printf("Type::defaultInit() '%s'\n", toChars());
 #endif
 return NULL;
 }
-int Type::isZeroInit()
+int Type::isZeroInit(Loc loc)
 {
 return 0;		// assume not
 }
 int Type::isBaseOf(Type *t, int *poffset)
 	e = new IntegerExp(loc, size(loc), Type::tsize_t);
 }
 else if (ident == Id::size)
 {
 	error(loc, ".size property should be replaced with .sizeof");
-	e = new IntegerExp(loc, size(loc), Type::tsize_t);
+	e = new ErrorExp();
 }
 else if (ident == Id::alignof)
 {
 	e = new IntegerExp(loc, alignsize(), Type::tsize_t);
 }
 	if (ty == Tvoid)
 	    error(loc, "void does not have an initializer");
 	e = defaultInit(loc);
 }
 else if (ident == Id::mangleof)
-{
+{	const char *s;
-	assert(deco);
+	if (!deco)
-	e = new StringExp(loc, deco, strlen(deco), 'c');
+	{   s = toChars();
+	    error(loc, "forward reference of type %s.mangleof", s);
+	}
+	else
+	    s = deco;
+	e = new StringExp(loc, (char *)s, strlen(s), 'c');
 	Scope sc;
 	e = e->semantic(&sc);
 }
 else if (ident == Id::stringof)
 {	char *s = toChars();
 	e = e->semantic(&sc);
 }
 else
 {
 	error(loc, "no property '%s' for type '%s'", ident->toChars(), toChars());
-	e = new IntegerExp(loc, 1, Type::tint32);
+	e = new ErrorExp();
 }
 return e;
 }
 Expression *Type::dotExp(Scope *sc, Expression *e, Identifier *ident)
 va_start(ap, format);
 ::verror(loc, format, ap);
 va_end( ap );
 }
+void Type::warning(Loc loc, const char *format, ...)
+{
+if (global.params.warnings && !global.gag)
+{
+	va_list ap;
+	va_start(ap, format);
+	::vwarning(loc, format, ap);
+	va_end( ap );
+}
+}
 Identifier *Type::getTypeInfoIdent(int internal)
 {
 // _init_10TypeInfo_%s
 OutBuffer buf;
 Identifier *id;
 {	buf.writeByte(mangleChar[ty]);
 	if (ty == Tarray)
 	    buf.writeByte(mangleChar[((TypeArray *)this)->next->ty]);
 }
 else
-	toDecoBuffer(&buf);
+	toDecoBuffer(&buf, true);
 len = buf.offset;
 name = (char *)alloca(19 + sizeof(len) * 3 + len + 1);
 buf.writeByte(0);
+#if TARGET_OSX
+// The LINKc will prepend the _
+sprintf(name, "D%dTypeInfo_%s6__initZ", 9 + len, buf.data);
+#else
 sprintf(name, "_D%dTypeInfo_%s6__initZ", 9 + len, buf.data);
+#endif
 // LDC
 // it is not clear where the underscore that's stripped here is added back in
 //    if (global.params.isWindows)
 //	name++;			// C mangling will add it back in
 //printf("name = %s\n", name);
 	: Type(ty)
 {
 this->next = next;
 }
-void TypeNext::toDecoBuffer(OutBuffer *buf, int flag)
+void TypeNext::toDecoBuffer(OutBuffer *buf, int flag, bool mangle)
 {
-Type::toDecoBuffer(buf, flag);
+Type::toDecoBuffer(buf, flag, mangle);
 assert(next != this);
 //printf("this = %p, ty = %d, next = %p, ty = %d\n", this, this->ty, next, next->ty);
-next->toDecoBuffer(buf, (flag & 0x100) ? 0 : mod);
+next->toDecoBuffer(buf, (flag & 0x100) ? 0 : mod, mangle);
 }
 void TypeNext::checkDeprecated(Loc loc, Scope *sc)
 {
 Type::checkDeprecated(loc, sc);
 Type *TypeNext::makeConst()
 {
 //printf("TypeNext::makeConst() %p, %s\n", this, toChars());
 if (cto)
+{	assert(cto->mod == MODconst);
 	return cto;
+}
 TypeNext *t = (TypeNext *)Type::makeConst();
 if (ty != Tfunction && ty != Tdelegate && next->deco &&
-!next->isInvariant())
+!next->isInvariant() && !next->isConst())
-	t->next = next->constOf();
+{	if (next->isShared())
+	    t->next = next->sharedConstOf();
+	else
+	    t->next = next->constOf();
+}
 //printf("TypeNext::makeConst() returns %p, %s\n", t, t->toChars());
 return t;
 }
 Type *TypeNext::makeInvariant()
 if (ito)
 {	assert(ito->isInvariant());
 	return ito;
 }
 TypeNext *t = (TypeNext *)Type::makeInvariant();
-if (ty != Tfunction && ty != Tdelegate && next->deco)
+if (ty != Tfunction && ty != Tdelegate && next->deco &&
+	!next->isInvariant())
 {	t->next = next->invariantOf();
 }
+return t;
+}
+Type *TypeNext::makeShared()
+{
+//printf("TypeNext::makeShared() %s\n", toChars());
+if (sto)
+{	assert(sto->mod == MODshared);
+	return sto;
+}
+TypeNext *t = (TypeNext *)Type::makeShared();
+if (ty != Tfunction && ty != Tdelegate && next->deco &&
+!next->isInvariant() && !next->isShared())
+{
+	if (next->isConst())
+	    t->next = next->sharedConstOf();
+	else
+	    t->next = next->sharedOf();
+}
+//printf("TypeNext::makeShared() returns %p, %s\n", t, t->toChars());
+return t;
+}
+Type *TypeNext::makeSharedConst()
+{
+//printf("TypeNext::makeSharedConst() %s\n", toChars());
+if (scto)
+{	assert(scto->mod == (MODshared | MODconst));
+	return scto;
+}
+TypeNext *t = (TypeNext *)Type::makeSharedConst();
+if (ty != Tfunction && ty != Tdelegate && next->deco &&
+!next->isInvariant() && !next->isSharedConst())
+{
+	t->next = next->sharedConstOf();
+}
+//printf("TypeNext::makeSharedConst() returns %p, %s\n", t, t->toChars());
 return t;
 }
 MATCH TypeNext::constConv(Type *to)
 {   MATCH m = Type::constConv(to);
 next->constConv(((TypeNext *)to)->next) == MATCHnomatch)
 	m = MATCHnomatch;
 return m;
 }
+void TypeNext::transitive()
+{
+/* Invoke transitivity of type attributes
+*/
+next = next->addMod(mod);
+}
 /* ============================= TypeBasic =========================== */
 TypeBasic::TypeBasic(TY ty)
 	: Type(ty)
 unsigned TypeBasic::alignsize()
 {
 if (ty == Tvoid)
 return 1;
-return getABITypeAlign(DtoType(this));
+return GetTypeAlignment(sir, this);
+#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS
+	case Tint64:
+	case Tuns64:
+	case Tfloat64:
+	case Timaginary64:
+	case Tcomplex32:
+	case Tcomplex64:
+	    sz = 4;
+	    break;
+#endif
+#if IN_DMD
+	default:
+	    sz = size(0);
+	    break;
+}
+return sz;
+#endif
 }
 Expression *TypeBasic::getProperty(Loc loc, Identifier *ident)
 {
 	    case Timaginary80:
 	    case Tfloat32:
 	    case Tfloat64:
 	    case Tfloat80:
 	    {
-#if IN_GCC
+		fvalue = Port::nan;
-		// mode doesn't matter, will be converted in RealExp anyway
-		fvalue = real_t::getnan(real_t::LongDouble);
-#elif __GNUC__
-		// gcc nan's have the sign bit set by default, so turn it off
-		// Need the volatile to prevent gcc from doing incorrect
-		// constant folding.
-		volatile d_float80 foo;
-		foo = NAN;
-		if (std::signbit(foo))	// signbit sometimes, not always, set
-		    foo = -foo;		// turn off sign bit
-		fvalue = foo;
-#elif _MSC_VER
-		unsigned long nan[2]= { 0xFFFFFFFF, 0x7FFFFFFF };
-		fvalue = *(double*)nan;
-#else
-		fvalue = NAN;
-#endif
 		goto Lfvalue;
 	    }
 	}
 }
 else if (ident == Id::infinity)
 	    case Timaginary64:
 	    case Timaginary80:
 	    case Tfloat32:
 	    case Tfloat64:
 	    case Tfloat80:
-#if IN_GCC
+		fvalue = Port::infinity;
-		fvalue = real_t::getinfinity();
-#elif __GNUC__
-		fvalue = 1 / zero;
-#elif _MSC_VER
-		fvalue = std::numeric_limits<long double>::infinity();
-#else
-		fvalue = INFINITY;
-#endif
 		goto Lfvalue;
 	}
 }
 else if (ident == Id::dig)
 {
 }
 return e;
 }
 Expression *TypeBasic::defaultInit(Loc loc)
-{   integer_t value = 0;
+{   dinteger_t value = 0;
+#if SNAN_DEFAULT_INIT
+/*
+* Use a payload which is different from the machine NaN,
+* so that uninitialised variables can be
+* detected even if exceptions are disabled.
+*/
+unsigned short snan[8] = { 0, 0, 0, 0xA000, 0x7FFF };
+/*
+* Although long doubles are 10 bytes long, some
+* C ABIs pad them out to 12 or even 16 bytes, so
+* leave enough space in the snan array.
+*/
+assert(REALSIZE <= sizeof(snan));
+d_float80 fvalue = *(long double*)snan;
+#endif
 #if LOGDEFAULTINIT
 printf("TypeBasic::defaultInit() '%s'\n", toChars());
 #endif
 switch (ty)
 {
-	case Tvoid:
-	    return new IntegerExp(loc, value, Type::tbool);
 	case Tchar:
 	    value = 0xFF;
 	    break;
 	case Twchar:
 	case Timaginary64:
 	case Timaginary80:
 	case Tfloat32:
 	case Tfloat64:
 	case Tfloat80:
+#if SNAN_DEFAULT_INIT
+	    return new RealExp(loc, fvalue, this);
+#else
+	    return getProperty(loc, Id::nan);
+#endif
 	case Tcomplex32:
 	case Tcomplex64:
 	case Tcomplex80:
+#if SNAN_DEFAULT_INIT
+	{   // Can't use fvalue + I*fvalue (the im part becomes a quiet NaN).
+	    complex_t cvalue;
+	    ((real_t *)&cvalue)[0] = fvalue;
+	    ((real_t *)&cvalue)[1] = fvalue;
+	    return new ComplexExp(loc, cvalue, this);
+	}
+#else
 	    return getProperty(loc, Id::nan);
+#endif
+	case Tvoid:
+	    error(loc, "void does not have a default initializer");
 }
 return new IntegerExp(loc, value, this);
 }
-int TypeBasic::isZeroInit()
+int TypeBasic::isZeroInit(Loc loc)
 {
 switch (ty)
 {
 	case Tchar:
 	case Twchar:
 	    arguments->push(new IntegerExp(0, size, Type::tsize_t));
 	e = new CallExp(e->loc, ec, arguments);
 	if (ident == Id::idup)
 	{   Type *einv = next->invariantOf();
 	    if (next->implicitConvTo(einv) < MATCHconst)
-		error(e->loc, "cannot implicitly convert element type %s to invariant", next->toChars());
+		error(e->loc, "cannot implicitly convert element type %s to immutable", next->toChars());
 	    e->type = einv->arrayOf();
 	}
 	else
 	    e->type = next->mutableOf()->arrayOf();
 }
 // LDC repaint array type to void[]
 if (n->ty != Tvoid) {
 e = new CastExp(e->loc, e, e->type);
 e->type = Type::tvoid->arrayOf();
 }
-arguments->push(e);
+	arguments->push(e);
-arguments->push(n->getTypeInfo(sc));   // LDC, we don't support the getInternalTypeInfo
+if (next->ty != Tbit)
-// optimization arbitrarily, not yet at least...
+arguments->push(n->getTypeInfo(sc));   // LDC, we don't support the getInternalTypeInfo
+// optimization arbitrarily, not yet at least...
 	e = new CallExp(e->loc, ec, arguments);
 	e->type = next->arrayOf();
 }
 else
 {
 	e = Type::dotExp(sc, e, ident);
 }
 return e;
 }
 /***************************** TypeSArray *****************************/
 TypeSArray::TypeSArray(Type *t, Expression *dim)
 t->mod = mod;
 return t;
 }
 d_uns64 TypeSArray::size(Loc loc)
-{   integer_t sz;
+{   dinteger_t sz;
 if (!dim)
 	return Type::size(loc);
 sz = dim->toInteger();
-{	integer_t n, n2;
+{	dinteger_t n, n2;
 	n = next->size();
 	n2 = n * sz;
 	if (n && (n2 / n) != sz)
 	    goto Loverflow;
 	sz = n2;
 }
 return sz;
 Loverflow:
-error(loc, "index %lld overflow for static array", sz);
+error(loc, "index %jd overflow for static array", sz);
 return 1;
 }
 unsigned TypeSArray::alignsize()
 {
 	    uinteger_t d = dim->toUInteger();
 	    sc = sc->pop();
 	    if (d >= td->objects->dim)
-	    {	error(loc, "tuple index %llu exceeds %u", d, td->objects->dim);
+	    {	error(loc, "tuple index %ju exceeds %u", d, td->objects->dim);
 		goto Ldefault;
 	    }
 	    Object *o = (Object *)td->objects->data[(size_t)d];
 	    if (o->dyncast() == DYNCAST_DSYMBOL)
 	    {
 	dim = semanticLength(sc, sd, dim);
 	dim = dim->optimize(WANTvalue | WANTinterpret);
 	uinteger_t d = dim->toUInteger();
 	if (d >= sd->objects->dim)
-	{   error(loc, "tuple index %llu exceeds %u", d, sd->objects->dim);
+	{   error(loc, "tuple index %ju exceeds %u", d, sd->objects->dim);
 	    return Type::terror;
 	}
 	Object *o = (Object *)sd->objects->data[(size_t)d];
 	if (o->dyncast() != DYNCAST_TYPE)
 	{   error(loc, "%s is not a type", toChars());
 	t = (Type *)o;
 	return t;
 }
 next = next->semantic(loc,sc);
-if (mod == MODconst && !next->isInvariant())
+transitive();
-	next = next->constOf();
-else if (mod == MODinvariant)
-	next = next->invariantOf();
 Type *tbn = next->toBasetype();
 if (dim)
-{	integer_t n, n2;
+{	dinteger_t n, n2;
 	dim = semanticLength(sc, tbn, dim);
 	dim = dim->optimize(WANTvalue | WANTinterpret);
 	if (sc && sc->parameterSpecialization && dim->op == TOKvar &&
 	    /* It could be a template parameter N which has no value yet:
 	     *   template Foo(T : T[N], size_t N);
 	     */
 	    return this;
 	}
-	integer_t d1 = dim->toInteger();
+	dinteger_t d1 = dim->toInteger();
 	dim = dim->castTo(sc, tsize_t);
 	dim = dim->optimize(WANTvalue);
-	integer_t d2 = dim->toInteger();
+	dinteger_t d2 = dim->toInteger();
 	if (d1 != d2)
 	    goto Loverflow;
 	if (tbn->isintegral() ||
 	    if (n2 >= 0x1000000)	// put a 'reasonable' limit on it
 		goto Loverflow;
 	    if (n && n2 / n != d2)
 	    {
 	      Loverflow:
-		error(loc, "index %lld overflow for static array", d1);
+		error(loc, "index %jd overflow for static array", d1);
 		dim = new IntegerExp(0, 1, tsize_t);
 	    }
 	}
 }
 switch (tbn->ty)
 	    assert(dim);
 	    TypeTuple *tt = (TypeTuple *)tbn;
 	    uinteger_t d = dim->toUInteger();
 	    if (d >= tt->arguments->dim)
-	    {	error(loc, "tuple index %llu exceeds %u", d, tt->arguments->dim);
+	    {	error(loc, "tuple index %ju exceeds %u", d, tt->arguments->dim);
 		return Type::terror;
 	    }
 	    Argument *arg = (Argument *)tt->arguments->data[(size_t)d];
 	    return arg->type;
+	}
+	case Tstruct:
+	{   TypeStruct *ts = (TypeStruct *)tbn;
+	    if (ts->sym->isnested)
+		error(loc, "cannot have array of inner structs %s", ts->toChars());
+	    break;
 	}
 	case Tfunction:
 	case Tnone:
 	    error(loc, "can't have array of %s", tbn->toChars());
 	    tbn = next = tint32;
 if (tbn->isauto())
 	error(loc, "cannot have array of auto %s", tbn->toChars());
 return merge();
 }
-void TypeSArray::toDecoBuffer(OutBuffer *buf, int flag)
+void TypeSArray::toDecoBuffer(OutBuffer *buf, int flag, bool mangle)
 {
-Type::toDecoBuffer(buf, flag);
+Type::toDecoBuffer(buf, flag, mangle);
 if (dim)
-	buf->printf("%llu", dim->toInteger());
+	buf->printf("%ju", dim->toInteger());
 if (next)
 	/* Note that static arrays are value types, so
 	 * for a parameter, propagate the 0x100 to the next
 	 * level, since for T[4][3], any const should apply to the T,
 	 * not the [4].
 	 */
-	next->toDecoBuffer(buf,  (flag & 0x100) ? flag : mod);
+	next->toDecoBuffer(buf,  (flag & 0x100) ? flag : mod, mangle);
 }
 void TypeSArray::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
 {
 if (mod != this->mod)
 printf("TypeSArray::defaultInit() '%s'\n", toChars());
 #endif
 return next->defaultInit(loc);
 }
-int TypeSArray::isZeroInit()
+int TypeSArray::isZeroInit(Loc loc)
 {
-return next->isZeroInit();
+return next->isZeroInit(loc);
 }
 Expression *TypeSArray::toExpression()
 {
 	case Tnone:
 	case Ttuple:
 	    error(loc, "can't have array of %s", tbn->toChars());
 	    tn = next = tint32;
 	    break;
+	case Tstruct:
+	{   TypeStruct *ts = (TypeStruct *)tbn;
+	    if (ts->sym->isnested)
+		error(loc, "cannot have array of inner structs %s", ts->toChars());
+	    break;
+	}
 }
 if (tn->isauto())
 	error(loc, "cannot have array of auto %s", tn->toChars());
-if (mod == MODconst && !tn->isInvariant())
-	tn = tn->constOf();
-else if (mod == MODinvariant)
-	tn = tn->invariantOf();
 next = tn;
+transitive();
 return merge();
 }
-void TypeDArray::toDecoBuffer(OutBuffer *buf, int flag)
+void TypeDArray::toDecoBuffer(OutBuffer *buf, int flag, bool mangle)
 {
-Type::toDecoBuffer(buf, flag);
+Type::toDecoBuffer(buf, flag, mangle);
 if (next)
-	next->toDecoBuffer(buf, (flag & 0x100) ? 0 : mod);
+	next->toDecoBuffer(buf, (flag & 0x100) ? 0 : mod, mangle);
 }
 void TypeDArray::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
 {
 if (mod != this->mod)
 e = new NullExp(loc);
 e->type = this;
 return e;
 }
-int TypeDArray::isZeroInit()
+int TypeDArray::isZeroInit(Loc loc)
 {
 return 1;
 }
 int TypeDArray::checkBoolean()
 	index = index->semantic(loc,sc);
 if (index->nextOf() && !index->nextOf()->isInvariant())
 {
 	index = index->constOf()->mutableOf();
+#if 0
+printf("index is %p %s\n", index, index->toChars());
+index->check();
+printf("index->mod = x%x\n", index->mod);
+printf("index->ito = x%x\n", index->ito);
+if (index->ito) {
+printf("index->ito->mod = x%x\n", index->ito->mod);
+printf("index->ito->ito = x%x\n", index->ito->ito);
+}
+#endif
 }
 switch (index->toBasetype()->ty)
 {
 	case Tbool:
 	case Tnone:
 	    error(loc, "can't have associative array key of %s", index->toBasetype()->toChars());
 	    break;
 }
 next = next->semantic(loc,sc);
-if (mod == MODconst && !next->isInvariant())
+transitive();
-	next = next->constOf();
-else if (mod == MODinvariant)
-	next = next->invariantOf();
 switch (next->toBasetype()->ty)
 {
 	case Tfunction:
 	case Tnone:
 	ec = new VarExp(0, aaLen_fd);
 	arguments = new Expressions();
 	arguments->push(e);
 	e = new CallExp(e->loc, ec, arguments);
-	e->type = ((TypeFunction *)aaLen_fd->type)->next;
+	e->type = aaLen_fd->type->nextOf();
 }
 else if (ident == Id::keys)
 {
 	Expression *ec;
 	Expressions *arguments;
 	}
 	ec = new VarExp(0, aaRehash_fd);
 	arguments = new Expressions();
 	arguments->push(e->addressOf(sc));
-arguments->push(index->getInternalTypeInfo(sc));
+	arguments->push(index->getInternalTypeInfo(sc)); // LDC doesn't support getInternalTypeInfo, see above
 	e = new CallExp(e->loc, ec, arguments);
 	e->type = this;
 }
 else
 {
 	e = Type::dotExp(sc, e, ident);
 }
 return e;
 }
-void TypeAArray::toDecoBuffer(OutBuffer *buf, int flag)
+void TypeAArray::toDecoBuffer(OutBuffer *buf, int flag, bool mangle)
 {
-Type::toDecoBuffer(buf, flag);
+Type::toDecoBuffer(buf, flag, mangle);
-index->toDecoBuffer(buf);
+index->toDecoBuffer(buf, mangle);
-next->toDecoBuffer(buf, (flag & 0x100) ? 0 : mod);
+next->toDecoBuffer(buf, (flag & 0x100) ? 0 : mod, mangle);
 }
 void TypeAArray::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
 {
 if (mod != this->mod)
 e = new NullExp(loc);
 e->type = this;
 return e;
 }
-int TypeAArray::isZeroInit()
+int TypeAArray::isZeroInit(Loc loc)
 {
 return TRUE;
 }
 int TypeAArray::checkBoolean()
 	    break;
 }
 if (n != next)
 	deco = NULL;
 next = n;
-if (mod == MODconst && !next->isInvariant())
+transitive();
-	next = next->constOf();
-else if (mod == MODinvariant)
-	next = next->invariantOf();
 return merge();
 }
 d_uns64 TypePointer::size(Loc loc)
 e = new NullExp(loc);
 e->type = this;
 return e;
 }
-int TypePointer::isZeroInit()
+int TypePointer::isZeroInit(Loc loc)
 {
 return 1;
 }
 int TypePointer::hasPointers()
 //printf("TypeReference::semantic()\n");
 Type *n = next->semantic(loc, sc);
 if (n != next)
 	deco = NULL;
 next = n;
-if (mod == MODconst && !next->isInvariant())
+transitive();
-	next = next->constOf();
-else if (mod == MODinvariant)
-	next = next->invariantOf();
 return merge();
 }
 d_uns64 TypeReference::size(Loc loc)
 Expression *e = new NullExp(loc);
 e->type = this;
 return e;
 }
-int TypeReference::isZeroInit()
+int TypeReference::isZeroInit(Loc loc)
 {
 return 1;
 }
 this->inuse = 0;
 this->isnothrow = false;
 this->ispure = false;
 this->isref = false;
-// LDC
+#if IN_LLVM
-this->fty = NULL;
+this->funcdecl = NULL;
+#endif
 }
 Type *TypeFunction::syntaxCopy()
 {
 Type *treturn = next ? next->syntaxCopy() : NULL;
 {
 #if 0
 printf("Type::covariant(t = %s) %s\n", t->toChars(), toChars());
 printf("deco = %p, %p\n", deco, t->deco);
 //    printf("ty = %d\n", next->ty);
+printf("mod = %x, %x\n", mod, t->mod);
 #endif
 int inoutmismatch = 0;
 TypeFunction *t1;
 	goto Lcovariant;
 }
 goto Lnotcovariant;
 Lcovariant:
+/* Can convert mutable to const
+*/
+if (t1->mod != t2->mod)
+{
+	if (!(t1->mod & MODconst) && (t2->mod & MODconst))
+	    goto Lnotcovariant;
+	if (!(t1->mod & MODshared) && (t2->mod & MODshared))
+	    goto Lnotcovariant;
+}
 /* Can convert pure to impure, and nothrow to throw
 */
 if (!t1->ispure && t2->ispure)
 	goto Lnotcovariant;
 Lnotcovariant:
 //printf("\tcovaraint: 2\n");
 return 2;
 }
-void TypeFunction::toDecoBuffer(OutBuffer *buf, int flag)
+void TypeFunction::toDecoBuffer(OutBuffer *buf, int flag, bool mangle)
 {   unsigned char mc;
 //printf("TypeFunction::toDecoBuffer() this = %p %s\n", this, toChars());
 //static int nest; if (++nest == 50) *(char*)0=0;
 if (inuse)
 	default:
 	    assert(0);
 }
 buf->writeByte(mc);
+// Possible conflict from merge
 if (ispure || isnothrow || isref)
 {
 	if (ispure)
 	    buf->writestring("Na");
 	if (isnothrow)
 	    buf->writestring("Nb");
 	if (isref)
 	    buf->writestring("Nc");
 }
 // Write argument types
-Argument::argsToDecoBuffer(buf, parameters);
+Argument::argsToDecoBuffer(buf, parameters, mangle);
 //if (buf->data[buf->offset - 1] == '@') halt();
 buf->writeByte('Z' - varargs);	// mark end of arg list
-next->toDecoBuffer(buf);
+next->toDecoBuffer(buf, mangle);
 inuse--;
 }
 void TypeFunction::toCBuffer(OutBuffer *buf, Identifier *ident, HdrGenState *hgs)
 {
-//printf("TypeFunction::toCBuffer() this = %p %s\n", this, toChars());
+//printf("TypeFunction::toCBuffer() this = %p\n", this);
 const char *p = NULL;
 if (inuse)
 {	inuse = 2;		// flag error to caller
 	return;
 /* Use 'storage class' style for attributes
 */
 if (mod & MODconst)
 	buf->writestring("const ");
 if (mod & MODinvariant)
-	buf->writestring("invariant ");
+	buf->writestring("immutable ");
 if (mod & MODshared)
 	buf->writestring("shared ");
 if (ispure)
 	buf->writestring("pure ");
 inuse--;
 }
 void TypeFunction::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
 {
-//printf("TypeFunction::toCBuffer2() this = %p %s\n", this, toChars());
+//printf("TypeFunction::toCBuffer2() this = %p, ref = %d\n", this, isref);
 const char *p = NULL;
 if (inuse)
 {	inuse = 2;		// flag error to caller
 	return;
 {
 	//printf("already done\n");
 	return this;
 }
 //printf("TypeFunction::semantic() this = %p\n", this);
+//printf("TypeFunction::semantic() %s, sc->stc = %x\n", toChars(), sc->stc);
 TypeFunction *tf = (TypeFunction *)mem.malloc(sizeof(TypeFunction));
 memcpy(tf, this, sizeof(TypeFunction));
 if (parameters)
 {	tf->parameters = (Arguments *)parameters->copy();
 if (tf->next->toBasetype()->ty == Ttuple)
 {	error(loc, "functions cannot return a tuple");
 	tf->next = Type::terror;
 }
 if (tf->next->isauto() && !(sc->flags & SCOPEctor))
-	error(loc, "functions cannot return auto %s", tf->next->toChars());
+	error(loc, "functions cannot return scope %s", tf->next->toChars());
 if (tf->parameters)
 {	size_t dim = Argument::dim(tf->parameters);
 	for (size_t i = 0; i < dim; i++)
 	    tf->inuse++;
 	    arg->type = arg->type->semantic(loc,sc);
 	    if (tf->inuse == 1) tf->inuse--;
-	    if (arg->storageClass & (STCconst | STCin))
+	    arg->type = arg->type->addStorageClass(arg->storageClass);
-	    {
-		if (!arg->type->isInvariant())
-		    arg->type = arg->type->constOf();
-	    }
-	    else if (arg->storageClass & STCinvariant)
-		arg->type = arg->type->invariantOf();
 	    if (arg->storageClass & (STCauto | STCalias | STCstatic))
 	    {
 		if (!arg->type)
 		    continue;
 	    }
+// Possible merge conflict
 	    Type *t = arg->type->toBasetype();
 	    if (arg->storageClass & (STCout | STCref | STClazy))
 	    {
 		if (t->ty == Tsarray)
 	{
 	  L1:
 	    if (varargs == 2 && u + 1 == nparams)	// if last varargs param
 	    {	Type *tb = p->type->toBasetype();
 		TypeSArray *tsa;
-		integer_t sz;
+		dinteger_t sz;
 		switch (tb->ty)
 		{
 		    case Tsarray:
 			tsa = (TypeSArray *)tb;
 e = new NullExp(loc);
 e->type = this;
 return e;
 }
-int TypeDelegate::isZeroInit()
+int TypeDelegate::isZeroInit(Loc loc)
 {
 return 1;
 }
 int TypeDelegate::checkBoolean()
 		t = t->semantic(loc, scx);
 		//((TypeIdentifier *)t)->resolve(loc, scx, pe, &t, ps);
 	    }
 	}
 	if (t->ty == Ttuple)
-	    *pt = t->syntaxCopy();
+	    *pt = t;
 	else
 	    *pt = t->merge();
 }
 if (!s)
 {
 t->syntaxCopyHelper(this);
 t->mod = mod;
 return t;
 }
-void TypeIdentifier::toDecoBuffer(OutBuffer *buf, int flag)
+void TypeIdentifier::toDecoBuffer(OutBuffer *buf, int flag, bool mangle)
 {   unsigned len;
 char *name;
-Type::toDecoBuffer(buf, flag);
+Type::toDecoBuffer(buf, flag, mangle);
 name = ident->toChars();
 len = strlen(name);
 buf->printf("%d%s", len, name);
 }
 Dsymbol *scopesym;
 //printf("TypeIdentifier::resolve(sc = %p, idents = '%s')\n", sc, toChars());
 s = sc->search(loc, ident, &scopesym);
 resolveHelper(loc, sc, s, scopesym, pe, pt, ps);
-if (*pt && mod)
+if (*pt)
-{
+	(*pt) = (*pt)->addMod(mod);
-	if (mod & MODconst)
-	    *pt = (*pt)->constOf();
-	else if (mod & MODinvariant)
-	    *pt = (*pt)->invariantOf();
-}
 }
 /*****************************************
 * See if type resolves to a symbol, if so,
 * return that symbol.
 	{   TypeTypedef *tt = (TypeTypedef *)t;
 	    if (tt->sym->sem == 1)
 		error(loc, "circular reference of typedef %s", tt->toChars());
 	}
-	if (isConst())
+	t = t->addMod(mod);
-	    t = t->constOf();
-	else if (isInvariant())
-	    t = t->invariantOf();
 }
 else
 {
 #ifdef DEBUG
 	if (!global.gag)
 //printf("TypeInstance::resolve(sc = %p, idents = '%s')\n", sc, id->toChars());
 s = tempinst;
 if (s)
 	s->semantic(sc);
 resolveHelper(loc, sc, s, NULL, pe, pt, ps);
-if (*pt && mod)
+if (*pt)
-{
+	*pt = (*pt)->addMod(mod);
-	if (mod & MODconst)
-	    *pt = (*pt)->constOf();
-	else if (mod & MODinvariant)
-	    *pt = (*pt)->invariantOf();
-}
 //printf("pt = '%s'\n", (*pt)->toChars());
 }
 Type *TypeInstance::semantic(Loc loc, Scope *sc)
 {
 	t = tvoid;
 }
 return t;
 }
+Dsymbol *TypeInstance::toDsymbol(Scope *sc)
+{
+Type *t;
+Expression *e;
+Dsymbol *s;
+//printf("TypeInstance::semantic(%s)\n", toChars());
+if (sc->parameterSpecialization)
+{
+	unsigned errors = global.errors;
+	global.gag++;
+	resolve(loc, sc, &e, &t, &s);
+	global.gag--;
+	if (errors != global.errors)
+	{   if (global.gag == 0)
+		global.errors = errors;
+	    return NULL;
+	}
+}
+else
+	resolve(loc, sc, &e, &t, &s);
+return s;
+}
 /***************************** TypeTypeof *****************************/
 TypeTypeof::TypeTypeof(Loc loc, Expression *exp)
 	: TypeQualified(Ttypeof, loc)
 this->exp = exp;
 }
 Type *TypeTypeof::syntaxCopy()
 {
+//printf("TypeTypeof::syntaxCopy() %s\n", toChars());
 TypeTypeof *t;
 t = new TypeTypeof(loc, exp->syntaxCopy());
 t->syntaxCopyHelper(this);
 t->mod = mod;
 	/* typeof should reflect the true type,
 	 * not what 'auto' would have gotten us.
 	 */
 	//t = t->toHeadMutable();
 }
 if (idents.dim)
 {
 	Dsymbol *s = t->toDsymbol(sc);
 	for (size_t i = 0; i < idents.dim; i++)
 	{
 	    if (!s)
 		break;
 	    Identifier *id = (Identifier *)idents.data[i];
 	    s = s->searchX(loc, sc, id);
 	}
 	if (s)
 	{
 	    t = s->getType();
 	    if (!t)
 	    {	error(loc, "%s is not a type", s->toChars());
 if (!sc->func)
 {	error(loc, "typeof(return) must be inside function");
 	goto Lerr;
 }
 t = sc->func->type->nextOf();
+t = t->addMod(mod);
-if (mod & MODinvariant)
-	t = t->invariantOf();
-else if (mod & MODconst)
-	t = t->constOf();
 if (idents.dim)
 {
 	Dsymbol *s = t->toDsymbol(sc);
 	for (size_t i = 0; i < idents.dim; i++)
 	return tint32;
 }
 return sym->memtype->toBasetype();
 }
-void TypeEnum::toDecoBuffer(OutBuffer *buf, int flag)
+void TypeEnum::toDecoBuffer(OutBuffer *buf, int flag, bool mangle)
 {
 const char *name = sym->mangle();
-Type::toDecoBuffer(buf, flag);
+Type::toDecoBuffer(buf, flag, mangle);
 buf->printf("%s", name);
 }
 void TypeEnum::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
 {
 printf("TypeEnum::dotExp(e = '%s', ident = '%s') '%s'\n", e->toChars(), ident->toChars(), toChars());
 #endif
 Dsymbol *s = sym->search(e->loc, ident, 0);
 if (!s)
 {
-	return getProperty(e->loc, ident);
+	if (ident == Id::max ||
+	    ident == Id::min ||
+	    ident == Id::init ||
+	    ident == Id::stringof ||
+	    !sym->memtype
+	   )
+	{
+	    return getProperty(e->loc, ident);
+	}
+	return sym->memtype->dotExp(sc, e, ident);
 }
 EnumMember *m = s->isEnumMember();
 Expression *em = m->value->copy();
 em->loc = e->loc;
 return em;
 }
 return e;
 Lfwd:
 error(loc, "forward reference of %s.%s", toChars(), ident->toChars());
-return new IntegerExp(0, 0, this);
+return new ErrorExp();
 }
 int TypeEnum::isintegral()
 {
 return 1;
 // Initialize to first member of enum
 //printf("%s\n", sym->defaultval->type->toChars());
 if (!sym->defaultval)
 {
 	error(loc, "forward reference of %s.init", toChars());
-	return new IntegerExp(0, 0, this);
+	return new ErrorExp();
 }
 return sym->defaultval;
 }
-int TypeEnum::isZeroInit()
+int TypeEnum::isZeroInit(Loc loc)
 {
+if (!sym->defaultval)
+{
+#ifdef DEBUG
+	printf("3: ");
+#endif
+	error(loc, "enum %s is forward referenced", sym->toChars());
+	return 0;
+}
 return sym->defaultval->isBool(FALSE);
 }
 int TypeEnum::hasPointers()
 {
 	return this;
 else
 	return mutableOf();
 }
-void TypeTypedef::toDecoBuffer(OutBuffer *buf, int flag)
+void TypeTypedef::toDecoBuffer(OutBuffer *buf, int flag, bool mangle)
 {
-Type::toDecoBuffer(buf, flag);
+Type::toDecoBuffer(buf, flag, mangle);
 const char *name = sym->mangle();
 buf->printf("%s", name);
 }
 void TypeTypedef::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
 	return Type::terror;
 }
 sym->inuse = 1;
 Type *t = sym->basetype->toBasetype();
 sym->inuse = 0;
-if (mod == MODconst && !t->isInvariant())
+t = t->addMod(mod);
-	t = t->constOf();
-else if (mod == MODinvariant)
-	t = t->invariantOf();
 return t;
 }
 MATCH TypeTypedef::implicitConvTo(Type *to)
 {   MATCH m;
 	bt = tsa->next->toBasetype();
 }
 return e;
 }
-int TypeTypedef::isZeroInit()
+int TypeTypedef::isZeroInit(Loc loc)
 {
 if (sym->init)
 {
 	if (sym->init->isVoidInitializer())
 	    return 1;		// initialize voids to 0
 {
 	sym->error("circular definition");
 	sym->basetype = Type::terror;
 }
 sym->inuse = 1;
-int result = sym->basetype->isZeroInit();
+int result = sym->basetype->isZeroInit(loc);
 sym->inuse = 0;
 return result;
 }
 int TypeTypedef::hasPointers()
 Dsymbol *TypeStruct::toDsymbol(Scope *sc)
 {
 return sym;
 }
-void TypeStruct::toDecoBuffer(OutBuffer *buf, int flag)
+void TypeStruct::toDecoBuffer(OutBuffer *buf, int flag, bool mangle)
 {
 const char *name = sym->mangle();
 //printf("TypeStruct::toDecoBuffer('%s') = '%s'\n", toChars(), name);
-Type::toDecoBuffer(buf, flag);
+Type::toDecoBuffer(buf, flag, mangle);
 buf->printf("%s", name);
 }
 void TypeStruct::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
 {
 }
 Expression *TypeStruct::dotExp(Scope *sc, Expression *e, Identifier *ident)
 {   unsigned offset;
-Expression *b;
 VarDeclaration *v;
 Dsymbol *s;
 DotVarExp *de;
 Declaration *d;
 printf("TypeStruct::dotExp(e = '%s', ident = '%s')\n", e->toChars(), ident->toChars());
 #endif
 if (!sym->members)
 {
 	error(e->loc, "struct %s is forward referenced", sym->toChars());
-	return new IntegerExp(e->loc, 0, Type::tint32);
+	return new ErrorExp();
 }
 /* If e.tupleof
 */
 if (ident == Id::tupleof)
 	    ident != Id::init &&
 	    ident != Id::mangleof &&
 	    ident != Id::stringof &&
 	    ident != Id::offsetof)
 	{
+	    /* See if we should forward to the alias this.
+	     */
+	    if (sym->aliasthis)
+	    {	/* Rewrite e.ident as:
+		 *	e.aliasthis.ident
+		 */
+		e = new DotIdExp(e->loc, e, sym->aliasthis->ident);
+		e = new DotIdExp(e->loc, e, ident);
+		return e->semantic(sc);
+	    }
 	    /* Look for overloaded opDot() to see if we should forward request
 	     * to it.
 	     */
 	    Dsymbol *fd = search_function(sym, Id::opDot);
 	    if (fd)
 	Expression *de = new DotExp(e->loc, e, new ScopeExp(e->loc, ti));
 	de->type = e->type;
 	return de;
 }
+Import *timp = s->isImport();
+if (timp)
+{
+	e = new DsymbolExp(e->loc, s, 0);
+	e = e->semantic(sc);
+	return e;
+}
+OverloadSet *o = s->isOverloadSet();
+if (o)
+{	/* We really should allow this, triggered by:
+	 *   template c()
+	 *   {
+	 *	void a();
+	 *	void b () { this.a(); }
+	 *   }
+	 *   struct S
+	 *   {
+	 *	mixin c;
+	 *	mixin c;
+	 *  }
+	 *  alias S e;
+	 */
+	error(e->loc, "overload set for %s.%s not allowed in struct declaration", e->toChars(), ident->toChars());
+	return new ErrorExp();
+}
 d = s->isDeclaration();
 #ifdef DEBUG
 if (!d)
 	printf("d = %s '%s'\n", s->kind(), s->toChars());
 #endif
 assert(d);
 if (e->op == TOKtype)
 {	FuncDeclaration *fd = sc->func;
-	if (d->needThis() && fd && fd->vthis)
+	if (d->isTupleDeclaration())
 	{
-	    e = new DotVarExp(e->loc, new ThisExp(e->loc), d);
+	    e = new TupleExp(e->loc, d->isTupleDeclaration());
 	    e = e->semantic(sc);
 	    return e;
 	}
-	if (d->isTupleDeclaration())
+	if (d->needThis() && fd && fd->vthis)
 	{
-	    e = new TupleExp(e->loc, d->isTupleDeclaration());
+	    e = new DotVarExp(e->loc, new ThisExp(e->loc), d);
 	    e = e->semantic(sc);
 	    return e;
 	}
 	return new VarExp(e->loc, d, 1);
 }
 	if (v->toParent() != sym)
 	    sym->error(e->loc, "'%s' is not a member", v->toChars());
 	// *(&e + offset)
 	accessCheck(e->loc, sc, e, d);
+#if 0
-// LDC we don't want dot exprs turned into pointer arithmetic. it complicates things for no apparent gain
+	Expression *b = new AddrExp(e->loc, e);
-#ifndef IN_LLVM
-	b = new AddrExp(e->loc, e);
 	b->type = e->type->pointerTo();
 	b = new AddExp(e->loc, b, new IntegerExp(e->loc, v->offset, Type::tint32));
 	b->type = v->type->pointerTo();
 	b = new PtrExp(e->loc, b);
-	b->type = v->type;
+	b->type = v->type->addMod(e->type->mod);
-	if (e->type->isConst())
-	    b->type = b->type->constOf();
-	else if (e->type->isInvariant())
-	    b->type = b->type->invariantOf();
 	return b;
 #endif
 }
 de = new DotVarExp(e->loc, e, d);
 assert(d);
 d->type = this;
 return new VarExp(sym->loc, d);
 }
-int TypeStruct::isZeroInit()
+int TypeStruct::isZeroInit(Loc loc)
 {
 return sym->zeroInit;
 }
 int TypeStruct::checkBoolean()
 sym->size(0);		// give error for forward references
 for (size_t i = 0; i < s->fields.dim; i++)
 {
 	Dsymbol *sm = (Dsymbol *)s->fields.data[i];
-	if (sm->hasPointers())
+	Declaration *d = sm->isDeclaration();
+	if (d->storage_class & STCref || d->hasPointers())
 	    return TRUE;
 }
 return FALSE;
 }
 		{   Dsymbol *s = (Dsymbol *)sym->fields.data[i];
 		    VarDeclaration *v = s->isVarDeclaration();
 		    assert(v && v->storage_class & STCfield);
 		    // 'from' type
-		    Type *tvf = v->type;
+		    Type *tvf = v->type->addMod(mod);
-		    if (mod == MODconst)
-			tvf = tvf->constOf();
-		    else if (mod == MODinvariant)
-			tvf = tvf->invariantOf();
 		    // 'to' type
-		    Type *tv = v->type;
+		    Type *tv = v->type->castMod(to->mod);
-		    if (to->mod == 0)
-			tv = tv->mutableOf();
-		    else
-		    {	assert(to->mod == MODinvariant);
-			tv = tv->invariantOf();
-		    }
 		    //printf("\t%s => %s, match = %d\n", v->type->toChars(), tv->toChars(), tvf->implicitConvTo(tv));
 		    if (tvf->implicitConvTo(tv) < MATCHconst)
 			return MATCHnomatch;
 		}
 		m = MATCHconst;
 	    }
 	}
 }
+else if (sym->aliasthis)
+{
+	m = MATCHnomatch;
+	Declaration *d = sym->aliasthis->isDeclaration();
+	if (d)
+	{   assert(d->type);
+	    Type *t = d->type->addMod(mod);
+	    m = t->implicitConvTo(to);
+	}
+}
 else
 	m = MATCHnomatch;	// no match
 return m;
 }
 Dsymbol *TypeClass::toDsymbol(Scope *sc)
 {
 return sym;
 }
-void TypeClass::toDecoBuffer(OutBuffer *buf, int flag)
+void TypeClass::toDecoBuffer(OutBuffer *buf, int flag, bool mangle)
 {
 const char *name = sym->mangle();
 //printf("TypeClass::toDecoBuffer('%s' flag=%d mod=%x) = '%s'\n", toChars(), flag, mod, name);
-Type::toDecoBuffer(buf, flag);
+Type::toDecoBuffer(buf, flag, mangle);
 buf->printf("%s", name);
 }
 void TypeClass::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
 {
 		ident != Id::init &&
 		ident != Id::mangleof &&
 		ident != Id::stringof &&
 		ident != Id::offsetof)
 	    {
+		/* See if we should forward to the alias this.
+		 */
+		if (sym->aliasthis)
+		{   /* Rewrite e.ident as:
+		     *	e.aliasthis.ident
+		     */
+		    e = new DotIdExp(e->loc, e, sym->aliasthis->ident);
+		    e = new DotIdExp(e->loc, e, ident);
+		    return e->semantic(sc);
+		}
 		/* Look for overloaded opDot() to see if we should forward request
 		 * to it.
 		 */
 		Dsymbol *fd = search_function(sym, Id::opDot);
 		if (fd)
 	Expression *de = new DotExp(e->loc, e, new ScopeExp(e->loc, ti));
 	de->type = e->type;
 	return de;
 }
+OverloadSet *o = s->isOverloadSet();
+if (o)
+{	/* We really should allow this
+	 */
+	error(e->loc, "overload set for %s.%s not allowed in struct declaration", e->toChars(), ident->toChars());
+	return new ErrorExp();
+}
 Declaration *d = s->isDeclaration();
 if (!d)
 {
 	e->error("%s.%s is not a declaration", e->toChars(), ident->toChars());
-	return new IntegerExp(e->loc, 1, Type::tint32);
+	return new ErrorExp();
 }
 if (e->op == TOKtype)
 {
 	/* It's:
 	 *    Class.d
 	 */
-	if (d->needThis() && (hasThis(sc) || !d->isFuncDeclaration()))
+	if (d->isTupleDeclaration())
+	{
+	    e = new TupleExp(e->loc, d->isTupleDeclaration());
+	    e = e->semantic(sc);
+	    return e;
+	}
+	else if (d->needThis() && (hasThis(sc) || !d->isFuncDeclaration()))
 	{
 	    if (sc->func)
 	    {
 		ClassDeclaration *thiscd;
 		thiscd = sc->func->toParent()->isClassDeclaration();
 	     */
 	    DotVarExp *de = new DotVarExp(e->loc, new ThisExp(e->loc), d);
 	    e = de->semantic(sc);
 	    return e;
 	}
-	else if (d->isTupleDeclaration())
-	{
-	    e = new TupleExp(e->loc, d->isTupleDeclaration());
-	    e = e->semantic(sc);
-	    return e;
-	}
 	else
 	{
 	    VarExp *ve = new VarExp(e->loc, d, 1);
 	    return ve;
 	}
 	// Allow conversion to (void *)
 	if (to->ty == Tpointer && ((TypePointer *)to)->next->ty == Tvoid)
 	    return MATCHconvert;
 }
-return MATCHnomatch;
+m = MATCHnomatch;
+if (sym->aliasthis)
+{
+	Declaration *d = sym->aliasthis->isDeclaration();
+	if (d)
+	{   assert(d->type);
+	    Type *t = d->type->addMod(mod);
+	    m = t->implicitConvTo(to);
+	}
+}
+return m;
 }
 MATCH TypeClass::constConv(Type *to)
 {
 if (equals(to))
 e = new NullExp(loc);
 e->type = this;
 return e;
 }
-int TypeClass::isZeroInit()
+int TypeClass::isZeroInit(Loc loc)
 {
 return 1;
 }
 int TypeClass::checkBoolean()
 void TypeTuple::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
 {
 Argument::argsToCBuffer(buf, hgs, arguments, 0);
 }
-void TypeTuple::toDecoBuffer(OutBuffer *buf, int flag)
+void TypeTuple::toDecoBuffer(OutBuffer *buf, int flag, bool mangle)
 {
 //printf("TypeTuple::toDecoBuffer() this = %p, %s\n", this, toChars());
-Type::toDecoBuffer(buf, flag);
+Type::toDecoBuffer(buf, flag, mangle);
 OutBuffer buf2;
-Argument::argsToDecoBuffer(&buf2, arguments);
+Argument::argsToDecoBuffer(&buf2, arguments, mangle);
 unsigned len = buf2.offset;
 buf->printf("%d%.*s", len, len, (char *)buf2.extractData());
 }
 Expression *TypeTuple::getProperty(Loc loc, Identifier *ident)
 	e = new IntegerExp(loc, arguments->dim, Type::tsize_t);
 }
 else
 {
 	error(loc, "no property '%s' for tuple '%s'", ident->toChars(), toChars());
-	e = new IntegerExp(loc, 1, Type::tint32);
+	e = new ErrorExp();
 }
 return e;
 }
 /***************************** TypeSlice *****************************/
 Type *TypeSlice::semantic(Loc loc, Scope *sc)
 {
 //printf("TypeSlice::semantic() %s\n", toChars());
 next = next->semantic(loc, sc);
-if (mod == MODconst && !next->isInvariant())
+transitive();
-	next = next->constOf();
-else if (mod == MODinvariant)
-	next = next->invariantOf();
 //printf("next: %s\n", next->toChars());
 Type *tbn = next->toBasetype();
 if (tbn->ty != Ttuple)
 {	error(loc, "can only slice tuple types, not %s", tbn->toChars());
 upr = semanticLength(sc, tbn, upr);
 upr = upr->optimize(WANTvalue);
 uinteger_t i2 = upr->toUInteger();
 if (!(i1 <= i2 && i2 <= tt->arguments->dim))
-{	error(loc, "slice [%llu..%llu] is out of range of [0..%u]", i1, i2, tt->arguments->dim);
+{	error(loc, "slice [%ju..%ju] is out of range of [0..%u]", i1, i2, tt->arguments->dim);
 	return Type::terror;
 }
 Arguments *args = new Arguments;
 args->reserve(i2 - i1);
 	    uinteger_t i2 = upr->toUInteger();
 	    sc = sc->pop();
 	    if (!(i1 <= i2 && i2 <= td->objects->dim))
-	    {   error(loc, "slice [%llu..%llu] is out of range of [0..%u]", i1, i2, td->objects->dim);
+	    {   error(loc, "slice [%ju..%ju] is out of range of [0..%u]", i1, i2, td->objects->dim);
 		goto Ldefault;
 	    }
 	    if (i1 == 0 && i2 == td->objects->dim)
 	    {
 	    else if (arg->storageClass & STCalias)
 		buf->writestring("alias ");
 	    else if (arg->storageClass & STCauto)
 		buf->writestring("auto ");
-	    if (arg->storageClass & STCscope)
+	    unsigned stc = arg->storageClass;
-		buf->writestring("scope ");
+	    if (arg->type && arg->type->mod & MODshared)
+		stc &= ~STCshared;
-	    if (arg->storageClass & STCconst)
-		buf->writestring("const ");
+	    StorageClassDeclaration::stcToCBuffer(buf,
-	    if (arg->storageClass & STCinvariant)
+		stc & (STCconst | STCimmutable | STCshared | STCscope));
-		buf->writestring("invariant ");
-	    if (arg->storageClass & STCshared)
-		buf->writestring("shared ");
 	    argbuf.reset();
 	    if (arg->storageClass & STCalias)
 	    {	if (arg->ident)
 		    argbuf.writestring(arg->ident->toChars());
 }
 buf->writeByte(')');
 }
-void Argument::argsToDecoBuffer(OutBuffer *buf, Arguments *arguments)
+void Argument::argsToDecoBuffer(OutBuffer *buf, Arguments *arguments, bool mangle)
 {
 //printf("Argument::argsToDecoBuffer()\n");
 // Write argument types
 if (arguments)
 {
 	size_t dim = Argument::dim(arguments);
 	for (size_t i = 0; i < dim; i++)
 	{
 	    Argument *arg = Argument::getNth(arguments, i);
-	    arg->toDecoBuffer(buf);
+	    arg->toDecoBuffer(buf, mangle);
 	}
 }
 }
 	}
 }
 return NULL;
 }
-void Argument::toDecoBuffer(OutBuffer *buf)
+void Argument::toDecoBuffer(OutBuffer *buf, bool mangle)
 {
 if (storageClass & STCscope)
 	buf->writeByte('M');
 switch (storageClass & (STCin | STCout | STCref | STClazy))
 {   case 0:
 if (type->toBasetype()->ty == Tclass)
 	mod = 0;
 type->toDecoBuffer(buf, mod);
 #else
 //type->toHeadMutable()->toDecoBuffer(buf, 0);
-type->toDecoBuffer(buf, 0);
+type->toDecoBuffer(buf, 0, mangle);
 #endif
 }
 /***************************************
 * Determine number of arguments, folding in tuples.

Mercurial > projects > ldc

comparison dmd2/mtype.c @ 1452:638d16625da2