diff --git a/ddmd/access.d b/ddmd/access.d
index 0d760b13fc..e7d460ba33 100644
--- a/ddmd/access.d
+++ b/ddmd/access.d
@@ -228,10 +228,15 @@ extern (C++) bool isFriendOf(AggregateDeclaration ad, AggregateDeclaration cd)
  * Determine if scope sc has package level access to s.
  */
 extern (C++) bool hasPackageAccess(Scope* sc, Dsymbol s)
+{
+    return hasPackageAccess(sc._module, s);
+}
+
+extern (C++) bool hasPackageAccess(Module mod, Dsymbol s)
 {
     static if (LOG)
     {
-        printf("hasPackageAccess(s = '%s', sc = '%p', s->protection.pkg = '%s')\n", s.toChars(), sc, s.prot().pkg ? s.prot().pkg.toChars() : "NULL");
+        printf("hasPackageAccess(s = '%s', mod = '%s', s->protection.pkg = '%s')\n", s.toChars(), mod.toChars(), s.prot().pkg ? s.prot().pkg.toChars() : "NULL");
     }
     Package pkg = null;
     if (s.prot().pkg)
@@ -265,7 +270,7 @@ extern (C++) bool hasPackageAccess(Scope* sc, Dsymbol s)
     }
     if (pkg)
     {
-        if (pkg == sc._module.parent)
+        if (pkg == mod.parent)
         {
             static if (LOG)
             {
@@ -273,7 +278,7 @@ extern (C++) bool hasPackageAccess(Scope* sc, Dsymbol s)
             }
             return true;
         }
-        if (pkg.isPackageMod() == sc._module)
+        if (pkg.isPackageMod() == mod)
         {
             static if (LOG)
             {
@@ -281,7 +286,7 @@ extern (C++) bool hasPackageAccess(Scope* sc, Dsymbol s)
             }
             return true;
         }
-        Dsymbol ancestor = sc._module.parent;
+        Dsymbol ancestor = mod.parent;
         for (; ancestor; ancestor = ancestor.parent)
         {
             if (ancestor == pkg)
@@ -301,6 +306,25 @@ extern (C++) bool hasPackageAccess(Scope* sc, Dsymbol s)
     return false;
 }
 
+/****************************************
+ * Determine if scope sc has protected level access to cd.
+ */
+bool hasProtectedAccess(Scope *sc, Dsymbol s)
+{
+    if (auto cd = s.isClassMember()) // also includes interfaces
+    {
+        for (auto scx = sc; scx; scx = scx.enclosing)
+        {
+            if (!scx.scopesym)
+                continue;
+            auto cd2 = scx.scopesym.isClassDeclaration();
+            if (cd2 && cd.isBaseOf(cd2, null))
+                return true;
+        }
+    }
+    return sc._module == s.getAccessModule();
+}
+
 /**********************************
  * Determine if smember has access to private members of this declaration.
  */
@@ -393,7 +417,7 @@ extern (C++) bool checkAccess(Loc loc, Scope* sc, Expression e, Declaration d)
     else if (e.type.ty == Tclass)
     {
         // Do access check
-        ClassDeclaration cd = cast(ClassDeclaration)(cast(TypeClass)e.type).sym;
+        ClassDeclaration cd = (cast(TypeClass)e.type).sym;
         if (e.op == TOKsuper)
         {
             ClassDeclaration cd2 = sc.func.toParent().isClassDeclaration();
@@ -405,8 +429,112 @@ extern (C++) bool checkAccess(Loc loc, Scope* sc, Expression e, Declaration d)
     else if (e.type.ty == Tstruct)
     {
         // Do access check
-        StructDeclaration cd = cast(StructDeclaration)(cast(TypeStruct)e.type).sym;
+        StructDeclaration cd = (cast(TypeStruct)e.type).sym;
         return checkAccess(cd, loc, sc, d);
     }
     return false;
 }
+
+/****************************************
+ * Check access to package/module `p` from scope `sc`.
+ *
+ * Params:
+ *   loc = source location for issued error message
+ *   sc = scope from which to access to a fully qualified package name
+ *   p = the package/module to check access for
+ * Returns: true if the package is not accessible.
+ *
+ * Because a global symbol table tree is used for imported packages/modules,
+ * access to them needs to be checked based on the imports in the scope chain
+ * (see Bugzilla 313).
+ *
+ */
+extern (C++) bool checkAccess(Loc loc, Scope* sc, Package p)
+{
+    if (sc._module == p)
+        return false;
+    for (; sc; sc = sc.enclosing)
+    {
+        if (sc.scopesym && sc.scopesym.isPackageAccessible(p))
+            return false;
+    }
+    auto name = p.toPrettyChars();
+    if (p.isPkgMod == PKGmodule || p.isModule())
+        deprecation(loc, "%s %s is not accessible here, perhaps add 'static import %s;'", p.kind(), name, name);
+    else
+        deprecation(loc, "%s %s is not accessible here", p.kind(), name);
+    return true;
+}
+
+/**
+ * Check whether symbols `s` is visible in `mod`.
+ *
+ * Params:
+ *  mod = lookup origin
+ *  s = symbol to check for visibility
+ * Returns: true if s is visible in mod
+ */
+extern (C++) bool symbolIsVisible(Module mod, Dsymbol s)
+{
+    // should sort overloads by ascending protection instead of iterating here
+    if (s.isOverloadable())
+    {
+        // Use the least protected overload to determine visibility
+        // and perform an access check after overload resolution.
+        overloadApply(s, (s2) {
+          if (s.prot().isMoreRestrictiveThan(s2.prot()))
+            s = s2;
+          return 0;
+        });
+    }
+    final switch (s.prot().kind)
+    {
+    case PROTundefined: return true;
+    case PROTnone: return false; // no access
+    case PROTprivate: return s.getAccessModule() == mod;
+    case PROTpackage: return hasPackageAccess(mod, s);
+    case PROTprotected: return s.getAccessModule() == mod;
+    case PROTpublic, PROTexport: return true;
+    }
+}
+
+/**
+ * Same as above, but determines the lookup module from symbols `origin`.
+ */
+extern (C++) bool symbolIsVisible(Dsymbol origin, Dsymbol s)
+{
+    return symbolIsVisible(origin.getAccessModule(), s);
+}
+
+/**
+ * Same as above but also checks for protected symbols visible from scope `sc`.
+ * Used for qualified name lookup.
+ *
+ * Params:
+ *  sc = lookup scope
+ *  s = symbol to check for visibility
+ * Returns: true if s is visible by origin
+ */
+extern (C++) bool symbolIsVisible(Scope *sc, Dsymbol s)
+{
+    // should sort overloads by ascending protection instead of iterating here
+    if (s.isOverloadable())
+    {
+        // Use the least protected overload to determine visibility
+        // and perform an access check after overload resolution.
+        overloadApply(s, (s2) {
+          if (s.prot().isMoreRestrictiveThan(s2.prot()))
+            s = s2;
+          return 0;
+        });
+    }
+    final switch (s.prot().kind)
+    {
+    case PROTundefined: return true;
+    case PROTnone: return false; // no access
+    case PROTprivate: return sc._module == s.getAccessModule();
+    case PROTpackage: return hasPackageAccess(sc._module, s);
+    case PROTprotected: return hasProtectedAccess(sc, s);
+    case PROTpublic, PROTexport: return true;
+    }
+}
diff --git a/ddmd/aggregate.d b/ddmd/aggregate.d
index 8a33043181..07f8bd8179 100644
--- a/ddmd/aggregate.d
+++ b/ddmd/aggregate.d
@@ -122,7 +122,7 @@ public:
 
     override final void semantic2(Scope* sc)
     {
-        //printf("AggregateDeclaration::semantic2(%s) type = %s, errors = %d\n", toChars(), type->toChars(), errors);
+        //printf("AggregateDeclaration::semantic2(%s) type = %s, errors = %d\n", toChars(), type.toChars(), errors);
         if (!members)
             return;
 
@@ -138,7 +138,7 @@ public:
         sc2.stc &= STCsafe | STCtrusted | STCsystem;
         sc2.parent = this;
         //if (isUnionDeclaration())     // TODO
-        //    sc2->inunion = 1;
+        //    sc2.inunion = 1;
         sc2.protection = Prot(PROTpublic);
         sc2.explicitProtection = 0;
         sc2.structalign = STRUCTALIGN_DEFAULT;
@@ -147,7 +147,7 @@ public:
         for (size_t i = 0; i < members.dim; i++)
         {
             Dsymbol s = (*members)[i];
-            //printf("\t[%d] %s\n", i, s->toChars());
+            //printf("\t[%d] %s\n", i, s.toChars());
             s.semantic2(sc2);
         }
 
@@ -215,6 +215,8 @@ public:
             sd.semanticTypeInfoMembers();
     }
 
+    abstract void finalizeSize();
+
     override final uint size(Loc loc)
     {
         //printf("AggregateDeclaration::size() %s, scope = %p\n", toChars(), scope);
@@ -271,7 +273,7 @@ public:
                 if (s.apply(&SV.func, &sv))
                     goto L1;
             }
-            finalizeSize(null);
+            finalizeSize();
 
         L1:
         }
@@ -288,8 +290,6 @@ public:
         return structsize;
     }
 
-    abstract void finalizeSize(Scope* sc);
-
     /***************************************
      * Calculate field[i].overlapped, and check that all of explicit
      * field initializers have unique memory space on instance.
@@ -331,7 +331,7 @@ public:
 
                 // vd and v2 are overlapping. If either has destructors, postblits, etc., then error
                 //printf("overlapping fields %s and %s\n", vd->toChars(), v2->toChars());
-                foreach (k; 0.. 2)
+                foreach (k; 0 .. 2)
                 {
                     auto v = k == 0 ? vd : v2;
                     Type tv = v.type.baseElemOf();
@@ -608,6 +608,8 @@ public:
         return enclosing !is null;
     }
 
+    /* Append vthis field (this.tupleof[$-1]) to make this aggregate type nested.
+     */
     final void makeNested()
     {
         if (enclosing) // if already nested
@@ -620,19 +622,20 @@ public:
             return;
 
         // If nested struct, add in hidden 'this' pointer to outer scope
-        Dsymbol s = toParent2();
+        auto s = toParent2();
         if (!s)
             return;
-        AggregateDeclaration ad = s.isAggregateDeclaration();
-        FuncDeclaration fd = s.isFuncDeclaration();
         Type t = null;
-        if (fd)
+        if (auto fd = s.isFuncDeclaration())
         {
             enclosing = fd;
-            AggregateDeclaration agg = fd.isMember2();
-            t = agg ? agg.handleType() : Type.tvoidptr;
+
+            /* Bugzilla 14422: If a nested class parent is a function, its
+             * context pointer (== `outer`) should be void* always.
+             */
+            t = Type.tvoidptr;
         }
-        else if (ad)
+        else if (auto ad = s.isAggregateDeclaration())
         {
             if (isClassDeclaration() && ad.isClassDeclaration())
             {
@@ -640,7 +643,7 @@ public:
             }
             else if (isStructDeclaration())
             {
-                if (TemplateInstance ti = ad.parent.isTemplateInstance())
+                if (auto ti = ad.parent.isTemplateInstance())
                 {
                     enclosing = ti.enclosing;
                 }
@@ -649,7 +652,7 @@ public:
         }
         if (enclosing)
         {
-            //printf("makeNested %s, enclosing = %s\n", toChars(), enclosing->toChars());
+            //printf("makeNested %s, enclosing = %s\n", toChars(), enclosing.toChars());
             assert(t);
             if (t.ty == Tstruct)
                 t = Type.tvoidptr; // t should not be a ref type
@@ -700,7 +703,7 @@ public:
     Symbol* stag; // tag symbol for debug data
     Symbol* sinit;
 
-    override final AggregateDeclaration isAggregateDeclaration()
+    override final inout(AggregateDeclaration) isAggregateDeclaration() inout
     {
         return this;
     }
diff --git a/ddmd/aggregate.h b/ddmd/aggregate.h
index 0d69f30ab5..d2908eb29d 100644
--- a/ddmd/aggregate.h
+++ b/ddmd/aggregate.h
@@ -115,8 +115,8 @@ public:
     void setScope(Scope *sc);
     void semantic2(Scope *sc);
     void semantic3(Scope *sc);
+    virtual void finalizeSize() = 0;
     unsigned size(Loc loc);
-    virtual void finalizeSize(Scope *sc) = 0;
     bool checkOverlappedFields();
     bool fill(Loc loc, Expressions *elements, bool ctorinit);
     static void alignmember(structalign_t salign, unsigned size, unsigned *poffset);
@@ -185,7 +185,7 @@ public:
     void semanticTypeInfoMembers();
     Dsymbol *search(Loc, Identifier *ident, int flags = IgnoreNone);
     const char *kind();
-    void finalizeSize(Scope *sc);
+    void finalizeSize();
     bool fit(Loc loc, Scope *sc, Expressions *elements, Type *stype);
     bool isPOD();
 
@@ -251,6 +251,7 @@ public:
     static ClassDeclaration *throwable;
     static ClassDeclaration *exception;
     static ClassDeclaration *errorException;
+    static ClassDeclaration *cpp_type_info_ptr;
 
     ClassDeclaration *baseClass;        // NULL only if this is Object
     FuncDeclaration *staticCtor;
@@ -261,8 +262,7 @@ public:
     BaseClasses *baseclasses;           // Array of BaseClass's; first is super,
                                         // rest are Interface's
 
-    size_t interfaces_dim;
-    BaseClass **interfaces;             // interfaces[interfaces_dim] for this class
+    DArray<BaseClass*> interfaces;      // interfaces[interfaces_dim] for this class
                                         // (does not include baseClass)
 
     BaseClasses *vtblInterfaces;        // array of base interfaces that have
@@ -276,6 +276,7 @@ public:
     int inuse;                          // to prevent recursive attempts
     Baseok baseok;                      // set the progress of base classes resolving
     Objc_ClassDeclaration objc;
+    Symbol *cpp_type_info_ptr_sym;      // cached instance of class Id.cpp_type_info_ptr
 
     ClassDeclaration(Loc loc, Identifier *id, BaseClasses *baseclasses, bool inObject = false);
     Dsymbol *syntaxCopy(Dsymbol *s);
@@ -288,17 +289,17 @@ public:
     bool isBaseInfoComplete();
     Dsymbol *search(Loc, Identifier *ident, int flags = IgnoreNone);
     ClassDeclaration *searchBase(Loc, Identifier *ident);
-    void finalizeSize(Scope *sc);
+    void finalizeSize();
     bool isFuncHidden(FuncDeclaration *fd);
     FuncDeclaration *findFunc(Identifier *ident, TypeFunction *tf);
     void interfaceSemantic(Scope *sc);
     unsigned setBaseInterfaceOffsets(unsigned baseOffset);
-    bool isCOMclass();
-    virtual bool isCOMinterface();
-    bool isCPPclass();
-    virtual bool isCPPinterface();
+    bool isCOMclass() const;
+    virtual bool isCOMinterface() const;
+    bool isCPPclass() const;
+    virtual bool isCPPinterface() const;
     bool isAbstract();
-    virtual int vtblOffset();
+    virtual int vtblOffset() const;
     const char *kind();
 
     void addLocalClass(ClassDeclarations *);
@@ -316,13 +317,12 @@ public:
     InterfaceDeclaration(Loc loc, Identifier *id, BaseClasses *baseclasses);
     Dsymbol *syntaxCopy(Dsymbol *s);
     void semantic(Scope *sc);
-    void finalizeSize(Scope *sc);
     bool isBaseOf(ClassDeclaration *cd, int *poffset);
     bool isBaseOf(BaseClass *bc, int *poffset);
     const char *kind();
-    int vtblOffset();
-    bool isCPPinterface();
-    bool isCOMinterface();
+    int vtblOffset() const;
+    bool isCPPinterface() const;
+    bool isCOMinterface() const;
 
     InterfaceDeclaration *isInterfaceDeclaration() { return this; }
     void accept(Visitor *v) { v->visit(this); }
diff --git a/ddmd/aliasthis.d b/ddmd/aliasthis.d
index 4d690f3eeb..1747db4514 100644
--- a/ddmd/aliasthis.d
+++ b/ddmd/aliasthis.d
@@ -98,7 +98,7 @@ public:
         ad.aliasthis = s;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "alias this";
     }
diff --git a/ddmd/argtypes.d b/ddmd/argtypes.d
index b8ca8ec70b..eedfd07b9b 100644
--- a/ddmd/argtypes.d
+++ b/ddmd/argtypes.d
@@ -18,7 +18,11 @@ import ddmd.visitor;
  * This breaks a type down into 'simpler' types that can be passed to a function
  * in registers, and returned in registers.
  * It's highly platform dependent.
- * Returning a tuple of zero length means the type cannot be passed/returned in registers.
+ * Params:
+ *      t = type to break down
+ * Returns:
+ *      tuple of types, each element can be passed in a register.
+ *      A tuple of zero length means the type cannot be passed/returned in registers.
  */
 extern (C++) TypeTuple toArgTypes(Type t)
 {
@@ -173,10 +177,16 @@ extern (C++) TypeTuple toArgTypes(Type t)
 
         /*************************************
          * This merges two types into an 8byte type.
+         * Params:
+         *      t1 = first type (can be null)
+         *      t2 = second type (can be null)
+         *      offset2 = offset of t2 from start of t1
+         * Returns:
+         *      type that encompasses both t1 and t2, null if cannot be done
          */
         static Type argtypemerge(Type t1, Type t2, uint offset2)
         {
-            //printf("argtypemerge(%s, %s, %d)\n", t1 ? t1->toChars() : "", t2 ? t2->toChars() : "", offset2);
+            //printf("argtypemerge(%s, %s, %d)\n", t1 ? t1.toChars() : "", t2 ? t2.toChars() : "", offset2);
             if (!t1)
             {
                 assert(!t2 || offset2 == 0);
@@ -217,14 +227,9 @@ extern (C++) TypeTuple toArgTypes(Type t)
                 case 4:
                     t = Type.tint32;
                     break;
-                case 5:
-                case 6:
-                case 7:
-                case 8:
+                default:
                     t = Type.tint64;
                     break;
-                default:
-                    assert(0);
                 }
             }
             return t;
@@ -270,7 +275,7 @@ extern (C++) TypeTuple toArgTypes(Type t)
 
         override void visit(TypeStruct t)
         {
-            //printf("TypeStruct::toArgTypes() %s\n", t->toChars());
+            //printf("TypeStruct.toArgTypes() %s\n", t.toChars());
             if (!t.sym.isPOD() || t.sym.fields.dim == 0)
             {
             Lmemory:
@@ -293,6 +298,7 @@ extern (C++) TypeTuple toArgTypes(Type t)
             case 3:
                 if (!global.params.is64bit)
                     goto Lmemory;
+                goto case;
             case 4:
                 t1 = Type.tint32;
                 break;
@@ -301,6 +307,7 @@ extern (C++) TypeTuple toArgTypes(Type t)
             case 7:
                 if (!global.params.is64bit)
                     goto Lmemory;
+                goto case;
             case 8:
                 t1 = Type.tint64;
                 break;
@@ -329,7 +336,7 @@ extern (C++) TypeTuple toArgTypes(Type t)
                     for (size_t i = 0; i < t.sym.fields.dim; i++)
                     {
                         VarDeclaration f = t.sym.fields[i];
-                        //printf("f->type = %s\n", f->type->toChars());
+                        //printf("  [%d] %s f.type = %s\n", cast(int)i, f.toChars(), f.type.toChars());
                         TypeTuple tup = toArgTypes(f.type);
                         if (!tup)
                             goto Lmemory;
@@ -364,6 +371,8 @@ extern (C++) TypeTuple toArgTypes(Type t)
                         }
                         // First field in 8byte must be at start of 8byte
                         assert(t1 || f.offset == 0);
+                        //printf("ft1 = %s\n", ft1 ? ft1.toChars() : "null");
+                        //printf("ft2 = %s\n", ft2 ? ft2.toChars() : "null");
                         if (ft1)
                         {
                             t1 = argtypemerge(t1, ft1, f.offset);
diff --git a/ddmd/arrayop.d b/ddmd/arrayop.d
index ab20a87b12..4e5d1602cc 100644
--- a/ddmd/arrayop.d
+++ b/ddmd/arrayop.d
@@ -18,7 +18,6 @@ import ddmd.globals;
 import ddmd.id;
 import ddmd.identifier;
 import ddmd.mtype;
-import ddmd.root.aav;
 import ddmd.root.outbuffer;
 import ddmd.statement;
 import ddmd.tokens;
@@ -27,9 +26,9 @@ import ddmd.visitor;
 /**************************************
  * Hash table of array op functions already generated or known about.
  */
-version(IN_LLVM) {}
-else
-extern (C++) __gshared AA* arrayfuncs;
+version(IN_LLVM) {} else
+private __gshared FuncDeclaration[void*] arrayfuncs;
+
 
 /**************************************
  * Structure to contain information needed to insert an array op call
@@ -179,19 +178,19 @@ extern (C++) Expression arrayOp(BinExp e, Scope* sc)
     /* Append deco of array element type
      */
     buf.writestring(e.type.toBasetype().nextOf().toBasetype().mutableOf().deco);
-    char* name = buf.peekString();
-    Identifier ident = Identifier.idPool(name);
+    auto ident = Identifier.idPool(buf.peekSlice());
+
     version(IN_LLVM)
     {
-        FuncDeclaration* pFd = cast(FuncDeclaration*)dmd_aaGet(&(sc._module.arrayfuncs), cast(void*)ident);
+        auto arrayfuncs = sc._module.arrayfuncs;
     }
+    FuncDeclaration* pFd = cast(void*)ident in arrayfuncs;
+    FuncDeclaration fd;
+    if (pFd)
+        fd = *pFd;
     else
-    {
-        FuncDeclaration* pFd = cast(FuncDeclaration*)dmd_aaGet(&arrayfuncs, cast(void*)ident);
-    }
-    FuncDeclaration fd = *pFd;
-    if (!fd)
         fd = buildArrayOp(ident, e, sc, e.loc);
+
     if (fd && fd.errors)
     {
         const(char)* fmt;
@@ -204,7 +203,8 @@ extern (C++) Expression arrayOp(BinExp e, Scope* sc)
         e.error(fmt, e.toChars(), tbn.toChars());
         return new ErrorExp();
     }
-    *pFd = fd;
+    if (!pFd)
+        arrayfuncs[cast(void*)ident] = fd;
     Expression ev = new VarExp(e.loc, fd);
     Expression ec = new CallExp(e.loc, ev, arguments);
     return ec.semantic(sc);
diff --git a/ddmd/attrib.d b/ddmd/attrib.d
index 5d1ec89a0d..8d3982156d 100644
--- a/ddmd/attrib.d
+++ b/ddmd/attrib.d
@@ -228,7 +228,7 @@ public:
         }
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "attribute";
     }
@@ -310,7 +310,7 @@ public:
         }
     }
 
-    override final AttribDeclaration isAttribDeclaration()
+    override final inout(AttribDeclaration) isAttribDeclaration() inout
     {
         return this;
     }
@@ -340,7 +340,7 @@ public:
         return new StorageClassDeclaration(stc, Dsymbol.arraySyntaxCopy(decl));
     }
 
-    override final Scope* newScope(Scope* sc)
+    override Scope* newScope(Scope* sc)
     {
         StorageClass scstc = sc.stc;
         /* These sets of storage classes are mutually exclusive,
@@ -400,6 +400,7 @@ extern (C++) final class DeprecatedDeclaration : StorageClassDeclaration
 {
 public:
     Expression msg;
+    const(char)* msgstr;
 
     extern (D) this(Expression msg, Dsymbols* decl)
     {
@@ -413,19 +414,67 @@ public:
         return new DeprecatedDeclaration(msg.syntaxCopy(), Dsymbol.arraySyntaxCopy(decl));
     }
 
+    /**
+     * Provides a new scope with `STCdeprecated` and `Scope.depdecl` set
+     *
+     * Calls `StorageClassDeclaration.newScope` (as it must be called or copied
+     * in any function overriding `newScope`), then set the `Scope`'s depdecl.
+     *
+     * Returns:
+     *   Always a new scope, to use for this `DeprecatedDeclaration`'s members.
+     */
+    override Scope* newScope(Scope* sc)
+    {
+        auto scx = super.newScope(sc);
+        // The enclosing scope is deprecated as well
+        if (scx == sc)
+            scx = sc.push();
+        scx.depdecl = this;
+        return scx;
+    }
+
     override void setScope(Scope* sc)
     {
-        assert(msg);
-        char* depmsg = null;
-        StringExp se = msg.toStringExp();
-        if (se)
-            depmsg = se.toStringz();
-        else
-            msg.error("string expected, not '%s'", msg.toChars());
-        Scope* scx = sc.push();
-        scx.depmsg = depmsg;
-        StorageClassDeclaration.setScope(scx);
-        scx.pop();
+        //printf("DeprecatedDeclaration::setScope() %p\n", this);
+        if (decl)
+            Dsymbol.setScope(sc); // for forward reference
+        return AttribDeclaration.setScope(sc);
+    }
+
+    /**
+     * Run the DeprecatedDeclaration's semantic2 phase then its members.
+     *
+     * The message set via a `DeprecatedDeclaration` can be either of:
+     * - a string literal
+     * - an enum
+     * - a static immutable
+     * So we need to call ctfe to resolve it.
+     * Afterward forwards to the members' semantic2.
+     */
+    override void semantic2(Scope* sc)
+    {
+        getMessage();
+        super.semantic2(sc);
+    }
+
+    const(char)* getMessage()
+    {
+        if (auto sc = _scope)
+        {
+            _scope = null;
+
+            sc = sc.startCTFE();
+            msg = msg.semantic(sc);
+            msg = resolveProperties(sc, msg);
+            sc = sc.endCTFE();
+            msg = msg.ctfeInterpret();
+
+            if (auto se = msg.toStringExp())
+                msgstr = se.toStringz();
+            else
+                msg.error("compile time constant expected, not '%s'", msg.toChars());
+        }
+        return msgstr;
     }
 
     override void accept(Visitor v)
@@ -459,9 +508,9 @@ public:
         return createNewScope(sc, sc.stc, this.linkage, sc.protection, sc.explicitProtection, sc.structalign, sc.inlining);
     }
 
-    override char* toChars()
+    override const(char)* toChars() const
     {
-        return cast(char*)"extern ()";
+        return "extern ()";
     }
 
     override void accept(Visitor v)
@@ -542,7 +591,7 @@ public:
         return AttribDeclaration.addMember(sc, sds);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "protection attribute";
     }
@@ -690,27 +739,33 @@ public:
                 anonstructsize = 1;
                 anonalignsize = 1;
             }
+
             /* Given the anon 'member's size and alignment,
              * go ahead and place it.
              */
-            anonoffset = AggregateDeclaration.placeField(poffset, anonstructsize, anonalignsize, alignment, &ad.structsize, &ad.alignsize, isunion);
+            anonoffset = AggregateDeclaration.placeField(
+                poffset,
+                anonstructsize, anonalignsize, alignment,
+                &ad.structsize, &ad.alignsize,
+                isunion);
+
             // Add to the anon fields the base offset of this anonymous aggregate
             //printf("anon fields, anonoffset = %d\n", anonoffset);
             for (size_t i = fieldstart; i < ad.fields.dim; i++)
             {
                 VarDeclaration v = ad.fields[i];
-                //printf("\t[%d] %s %d\n", i, v->toChars(), v->offset);
+                //printf("\t[%d] %s %d\n", i, v.toChars(), v.offset);
                 v.offset += anonoffset;
             }
         }
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return (isunion ? "anonymous union" : "anonymous struct");
     }
 
-    override final AnonDeclaration isAnonDeclaration()
+    override final inout(AnonDeclaration) isAnonDeclaration() inout
     {
         return this;
     }
@@ -776,7 +831,7 @@ public:
                     if (se)
                     {
                         se = se.toUTF8(sc);
-                        fprintf(stderr, "%.*s", cast(int)se.len, cast(char*)se.string);
+                        fprintf(stderr, "%.*s", cast(int)se.len, se.string);
                     }
                     else
                         fprintf(stderr, "%s", e.toChars());
@@ -819,7 +874,7 @@ public:
                         ob.writestring(" (");
                         escapePath(ob, imod.srcfile.toChars());
                         ob.writestring(") : ");
-                        ob.writestring(cast(char*)name);
+                        ob.writestring(name);
                         ob.writenl();
                     }
                     mem.xfree(name);
@@ -893,8 +948,8 @@ public:
                  */
                 for (size_t i = 0; i < se.len;)
                 {
-                    char* p = cast(char*)se.string;
-                    dchar_t c = p[i];
+                    char* p = se.string;
+                    dchar c = p[i];
                     if (c < 0x80)
                     {
                         if (c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || c >= '0' && c <= '9' || c != 0 && strchr("$%().:?@[]_", c))
@@ -908,7 +963,7 @@ public:
                             break;
                         }
                     }
-                    if (const(char)* msg = utf_decodeChar(cast(char*)se.string, se.len, &i, &c))
+                    if (const msg = utf_decodeChar(se.string, se.len, i, c))
                     {
                         error("%s", msg);
                         break;
@@ -1045,7 +1100,7 @@ public:
         return sc;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "pragma";
     }
@@ -1238,7 +1293,7 @@ public:
         Dsymbol.setScope(sc);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "static if";
     }
@@ -1337,7 +1392,7 @@ public:
         AttribDeclaration.semantic(sc);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "mixin";
     }
@@ -1433,9 +1488,8 @@ public:
 
     Expressions* getAttributes()
     {
-        if (_scope)
+        if (auto sc = _scope)
         {
-            Scope* sc = _scope;
             _scope = null;
             arrayExpressionSemantic(atts, sc);
         }
@@ -1447,7 +1501,7 @@ public:
         return exps;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "UserAttribute";
     }
diff --git a/ddmd/canthrow.d b/ddmd/canthrow.d
index ccdcc194e0..c130b94d5d 100644
--- a/ddmd/canthrow.d
+++ b/ddmd/canthrow.d
@@ -8,6 +8,7 @@
 
 module ddmd.canthrow;
 
+import ddmd.aggregate;
 import ddmd.apply;
 import ddmd.arraytypes;
 import ddmd.attrib;
@@ -64,50 +65,119 @@ extern (C++) bool canThrow(Expression e, FuncDeclaration func, bool mustNotThrow
              */
             Type t = ce.e1.type.toBasetype();
             if (ce.f && ce.f == func)
+                return;
+            if (t.ty == Tfunction && (cast(TypeFunction)t).isnothrow)
+                return;
+            if (t.ty == Tdelegate && (cast(TypeFunction)(cast(TypeDelegate)t).next).isnothrow)
+                return;
+
+            if (mustNotThrow)
             {
-            }
-            else if (t.ty == Tfunction && (cast(TypeFunction)t).isnothrow)
-            {
-            }
-            else if (t.ty == Tdelegate && (cast(TypeFunction)(cast(TypeDelegate)t).next).isnothrow)
-            {
-            }
-            else
-            {
-                if (mustNotThrow)
+                if (ce.f)
                 {
-                    const(char)* s;
-                    if (ce.f)
-                        s = ce.f.toPrettyChars();
-                    else if (ce.e1.op == TOKstar)
-                    {
-                        // print 'fp' if ce->e1 is (*fp)
-                        s = (cast(PtrExp)ce.e1).e1.toChars();
-                    }
-                    else
-                        s = ce.e1.toChars();
-                    ce.error("'%s' is not nothrow", s);
+                    ce.error("%s '%s' is not nothrow",
+                        ce.f.kind(), ce.f.toPrettyChars());
+                }
+                else
+                {
+                    auto e1 = ce.e1;
+                    if (e1.op == TOKstar)   // print 'fp' if e1 is (*fp)
+                        e1 = (cast(PtrExp)e1).e1;
+                    ce.error("'%s' is not nothrow", e1.toChars());
                 }
-                stop = true;
             }
+            stop = true;
         }
 
         override void visit(NewExp ne)
         {
             if (ne.member)
             {
+                if (ne.allocator)
+                {
+                    // Bugzilla 14407
+                    Type t = ne.allocator.type.toBasetype();
+                    if (t.ty == Tfunction && !(cast(TypeFunction)t).isnothrow)
+                    {
+                        if (mustNotThrow)
+                        {
+                            ne.error("%s '%s' is not nothrow",
+                                ne.allocator.kind(), ne.allocator.toPrettyChars());
+                        }
+                        stop = true;
+                    }
+                }
                 // See if constructor call can throw
                 Type t = ne.member.type.toBasetype();
                 if (t.ty == Tfunction && !(cast(TypeFunction)t).isnothrow)
                 {
                     if (mustNotThrow)
-                        ne.error("constructor %s is not nothrow", ne.member.toChars());
+                    {
+                        ne.error("%s '%s' is not nothrow",
+                            ne.member.kind(), ne.member.toPrettyChars());
+                    }
                     stop = true;
                 }
             }
             // regard storage allocation failures as not recoverable
         }
 
+        override void visit(DeleteExp de)
+        {
+            Type tb = de.e1.type.toBasetype();
+            AggregateDeclaration ad = null;
+            switch (tb.ty)
+            {
+            case Tclass:
+                ad = (cast(TypeClass)tb).sym;
+                break;
+
+            case Tpointer:
+                tb = (cast(TypePointer)tb).next.toBasetype();
+                if (tb.ty == Tstruct)
+                    ad = (cast(TypeStruct)tb).sym;
+                break;
+
+            case Tarray:
+                Type tv = tb.nextOf().baseElemOf();
+                if (tv.ty == Tstruct)
+                    ad = (cast(TypeStruct)tv).sym;
+                break;
+
+            default:
+                break;
+            }
+            if (!ad)
+                return;
+
+            if (ad.dtor)
+            {
+                Type t = ad.dtor.type.toBasetype();
+                if (t.ty == Tfunction && !(cast(TypeFunction)t).isnothrow)
+                {
+                    if (mustNotThrow)
+                    {
+                        de.error("%s '%s' is not nothrow",
+                            ad.dtor.kind(), ad.dtor.toPrettyChars());
+                    }
+                    stop = true;
+                }
+            }
+            if (ad.aggDelete && tb.ty != Tarray)
+            {
+                Type t = ad.aggDelete.type;
+                if (t.ty == Tfunction && !(cast(TypeFunction)t).isnothrow)
+                {
+                    if (mustNotThrow)
+                    {
+                        de.error("%s '%s' is not nothrow",
+                            ad.aggDelete.kind(), ad.aggDelete.toPrettyChars());
+                    }
+                    stop = true;
+                }
+            }
+        }
+
         override void visit(AssignExp ae)
         {
             // blit-init cannot throw
@@ -138,7 +208,10 @@ extern (C++) bool canThrow(Expression e, FuncDeclaration func, bool mustNotThrow
             else
             {
                 if (mustNotThrow)
-                    ae.error("'%s' is not nothrow", sd.postblit.toPrettyChars());
+                {
+                    ae.error("%s '%s' is not nothrow",
+                        sd.postblit.kind(), sd.postblit.toPrettyChars());
+                }
                 stop = true;
             }
         }
@@ -197,7 +270,7 @@ extern (C++) bool Dsymbol_canThrow(Dsymbol s, FuncDeclaration func, bool mustNot
                 if (ie && canThrow(ie.exp, func, mustNotThrow))
                     return true;
             }
-            if (vd.edtor && !vd.noscope)
+            if (vd.needsScopeDtor())
                 return canThrow(vd.edtor, func, mustNotThrow);
         }
     }
diff --git a/ddmd/clone.d b/ddmd/clone.d
index 1ed5305ecb..a24faeeccb 100644
--- a/ddmd/clone.d
+++ b/ddmd/clone.d
@@ -8,6 +8,7 @@
 
 module ddmd.clone;
 
+import core.stdc.stdio;
 import ddmd.aggregate;
 import ddmd.arraytypes;
 import ddmd.declaration;
@@ -72,6 +73,11 @@ extern (C++) StorageClass mergeFuncAttrs(StorageClass s1, FuncDeclaration f)
 
 /*******************************************
  * Check given aggregate actually has an identity opAssign or not.
+ * Params:
+ *      ad = struct or class
+ *      sc = current scope
+ * Returns:
+ *      if found, returns FuncDeclaration of opAssign, otherwise null
  */
 extern (C++) FuncDeclaration hasIdentityOpAssign(AggregateDeclaration ad, Scope* sc)
 {
@@ -80,23 +86,24 @@ extern (C++) FuncDeclaration hasIdentityOpAssign(AggregateDeclaration ad, Scope*
     {
         /* check identity opAssign exists
          */
-        Expression er = new NullExp(ad.loc, ad.type); // dummy rvalue
-        Expression el = new IdentifierExp(ad.loc, Id.p); // dummy lvalue
+        scope er = new NullExp(ad.loc, ad.type);    // dummy rvalue
+        scope el = new IdentifierExp(ad.loc, Id.p); // dummy lvalue
         el.type = ad.type;
-        auto a = new Expressions();
+        Expressions a;
         a.setDim(1);
-        FuncDeclaration f = null;
-        uint errors = global.startGagging(); // Do not report errors, even if the
+        const errors = global.startGagging(); // Do not report errors, even if the
         sc = sc.push();
         sc.tinst = null;
         sc.minst = null;
-        for (size_t i = 0; i < 2; i++)
+
+        a[0] = er;
+        auto f = resolveFuncCall(ad.loc, sc, assign, null, ad.type, &a, 1);
+        if (!f)
         {
-            (*a)[0] = (i == 0 ? er : el);
-            f = resolveFuncCall(ad.loc, sc, assign, null, ad.type, a, 1);
-            if (f)
-                break;
+            a[0] = el;
+            f = resolveFuncCall(ad.loc, sc, assign, null, ad.type, &a, 1);
         }
+
         sc = sc.pop();
         global.endGagging(errors);
         if (f)
@@ -104,10 +111,10 @@ extern (C++) FuncDeclaration hasIdentityOpAssign(AggregateDeclaration ad, Scope*
             if (f.errors)
                 return null;
             int varargs;
-            Parameters* fparams = f.getParameters(&varargs);
+            auto fparams = f.getParameters(&varargs);
             if (fparams.dim >= 1)
             {
-                Parameter fparam0 = Parameter.getNth(fparams, 0);
+                auto fparam0 = Parameter.getNth(fparams, 0);
                 if (fparam0.type.toDsymbol(null) != ad)
                     f = null;
             }
@@ -126,10 +133,10 @@ extern (C++) FuncDeclaration hasIdentityOpAssign(AggregateDeclaration ad, Scope*
  */
 extern (C++) bool needOpAssign(StructDeclaration sd)
 {
-    //printf("StructDeclaration::needOpAssign() %s\n", sd->toChars());
+    //printf("StructDeclaration::needOpAssign() %s\n", sd.toChars());
     if (sd.hasIdentityAssign)
-        goto Lneed;
-    // because has identity==elaborate opAssign
+        goto Lneed; // because has identity==elaborate opAssign
+
     if (sd.dtor || sd.postblit)
         goto Lneed;
     /* If any of the fields need an opAssign, then we
@@ -186,7 +193,8 @@ extern (C++) FuncDeclaration buildOpAssign(StructDeclaration sd, Scope* sc)
     // will be defined.
     if (!needOpAssign(sd))
         return null;
-    //printf("StructDeclaration::buildOpAssign() %s\n", sd->toChars());
+
+    //printf("StructDeclaration::buildOpAssign() %s\n", sd.toChars());
     StorageClass stc = STCsafe | STCnothrow | STCpure | STCnogc;
     Loc declLoc = sd.loc;
     Loc loc = Loc(); // internal code should have no loc to prevent coverage
@@ -224,7 +232,7 @@ extern (C++) FuncDeclaration buildOpAssign(StructDeclaration sd, Scope* sc)
     }
     else if (sd.dtor || sd.postblit)
     {
-        /* Do swap this and rhs
+        /* Do swap this and rhs.
          *    __swap = this; this = s; __swap.dtor();
          */
         //printf("\tswap copy\n");
@@ -234,7 +242,7 @@ extern (C++) FuncDeclaration buildOpAssign(StructDeclaration sd, Scope* sc)
         if (sd.dtor)
         {
             tmp = new VarDeclaration(loc, sd.type, idtmp, new VoidInitializer(loc));
-            tmp.noscope = 1;
+            tmp.noscope = true;
             tmp.storage_class |= STCtemp | STCctfe;
             e = new DeclarationExp(loc, tmp);
             ec = new BlitExp(loc, new VarExp(loc, tmp), new ThisExp(loc));
@@ -247,21 +255,28 @@ extern (C++) FuncDeclaration buildOpAssign(StructDeclaration sd, Scope* sc)
             /* Instead of running the destructor on s, run it
              * on tmp. This avoids needing to copy tmp back in to s.
              */
-            Expression ec2 = new DotVarExp(loc, new VarExp(loc, tmp), sd.dtor, 0);
+            Expression ec2 = new DotVarExp(loc, new VarExp(loc, tmp), sd.dtor, false);
             ec2 = new CallExp(loc, ec2);
             e = Expression.combine(e, ec2);
         }
     }
     else
     {
-        /* Do memberwise copy
+        /* Do memberwise copy.
+         *
+         * If sd is a nested struct, its vthis field assignment is:
+         * 1. If it's nested in a class, it's a rebind of class reference.
+         * 2. If it's nested in a function or struct, it's an update of void*.
+         * In both cases, it will change the parent context.
          */
         //printf("\tmemberwise copy\n");
         for (size_t i = 0; i < sd.fields.dim; i++)
         {
             VarDeclaration v = sd.fields[i];
             // this.v = s.v;
-            auto ec = new AssignExp(loc, new DotVarExp(loc, new ThisExp(loc), v, 0), new DotVarExp(loc, new IdentifierExp(loc, Id.p), v, 0));
+            auto ec = new AssignExp(loc,
+                new DotVarExp(loc, new ThisExp(loc), v),
+                new DotVarExp(loc, new IdentifierExp(loc, Id.p), v));
             e = Expression.combine(e, ec);
         }
     }
@@ -285,7 +300,7 @@ extern (C++) FuncDeclaration buildOpAssign(StructDeclaration sd, Scope* sc)
     sc2.linkage = LINKd;
     fop.semantic(sc2);
     fop.semantic2(sc2);
-    // Bugzilla 15044: fop->semantic3 isn't run here for lazy forward reference resolution.
+    // Bugzilla 15044: fop.semantic3 isn't run here for lazy forward reference resolution.
 
     sc2.pop();
     if (global.endGagging(errors)) // if errors happened
@@ -294,7 +309,8 @@ extern (C++) FuncDeclaration buildOpAssign(StructDeclaration sd, Scope* sc)
         fop.storage_class |= STCdisable;
         fop.fbody = null; // remove fbody which contains the error
     }
-    //printf("-StructDeclaration::buildOpAssign() %s, errors = %d\n", sd->toChars(), (fop->storage_class & STCdisable) != 0);
+
+    //printf("-StructDeclaration::buildOpAssign() %s, errors = %d\n", sd.toChars(), (fop.storage_class & STCdisable) != 0);
     return fop;
 }
 
@@ -305,7 +321,7 @@ extern (C++) FuncDeclaration buildOpAssign(StructDeclaration sd, Scope* sc)
  */
 extern (C++) bool needOpEquals(StructDeclaration sd)
 {
-    //printf("StructDeclaration::needOpEquals() %s\n", sd->toChars());
+    //printf("StructDeclaration::needOpEquals() %s\n", sd.toChars());
     if (sd.hasIdentityEquals)
         goto Lneed;
     if (sd.isUnionDeclaration())
@@ -360,35 +376,31 @@ extern (C++) FuncDeclaration hasIdentityOpEquals(AggregateDeclaration ad, Scope*
     {
         /* check identity opEquals exists
          */
-        Expression er = new NullExp(ad.loc, null); // dummy rvalue
-        Expression el = new IdentifierExp(ad.loc, Id.p); // dummy lvalue
-        auto a = new Expressions();
+        scope er = new NullExp(ad.loc, null); // dummy rvalue
+        scope el = new IdentifierExp(ad.loc, Id.p); // dummy lvalue
+        Expressions a;
         a.setDim(1);
-        for (size_t i = 0;; i++)
+        foreach (i; 0 .. 5)
         {
             Type tthis = null; // dead-store to prevent spurious warning
-            if (i == 0)
-                tthis = ad.type;
-            if (i == 1)
-                tthis = ad.type.constOf();
-            if (i == 2)
-                tthis = ad.type.immutableOf();
-            if (i == 3)
-                tthis = ad.type.sharedOf();
-            if (i == 4)
-                tthis = ad.type.sharedConstOf();
-            if (i == 5)
-                break;
+            final switch (i)
+            {
+                case 0:  tthis = ad.type;                 break;
+                case 1:  tthis = ad.type.constOf();       break;
+                case 2:  tthis = ad.type.immutableOf();   break;
+                case 3:  tthis = ad.type.sharedOf();      break;
+                case 4:  tthis = ad.type.sharedConstOf(); break;
+            }
             FuncDeclaration f = null;
-            uint errors = global.startGagging(); // Do not report errors, even if the
+            const errors = global.startGagging(); // Do not report errors, even if the
             sc = sc.push();
             sc.tinst = null;
             sc.minst = null;
-            for (size_t j = 0; j < 2; j++)
+            foreach (j; 0 .. 2)
             {
-                (*a)[0] = (j == 0 ? er : el);
-                (*a)[0].type = tthis;
-                f = resolveFuncCall(ad.loc, sc, eq, null, tthis, a, 1);
+                a[0] = (j == 0 ? er : el);
+                a[0].type = tthis;
+                f = resolveFuncCall(ad.loc, sc, eq, null, tthis, &a, 1);
                 if (f)
                     break;
             }
@@ -412,7 +424,7 @@ extern (C++) FuncDeclaration hasIdentityOpEquals(AggregateDeclaration ad, Scope*
  * By fixing bugzilla 3789, opEquals is changed to be never implicitly generated.
  * Now, struct objects comparison s1 == s2 is translated to:
  *      s1.tupleof == s2.tupleof
- * to calculate structural equality. See EqualExp::semantic.
+ * to calculate structural equality. See EqualExp.op_overload.
  */
 extern (C++) FuncDeclaration buildOpEquals(StructDeclaration sd, Scope* sc)
 {
@@ -437,7 +449,8 @@ extern (C++) FuncDeclaration buildXopEquals(StructDeclaration sd, Scope* sc)
 {
     if (!needOpEquals(sd))
         return null; // bitwise comparison would work
-    //printf("StructDeclaration::buildXopEquals() %s\n", sd->toChars());
+
+    //printf("StructDeclaration::buildXopEquals() %s\n", sd.toChars());
     if (Dsymbol eq = search_function(sd, Id.eq))
     {
         if (FuncDeclaration fd = eq.isFuncDeclaration())
@@ -529,9 +542,8 @@ extern (C++) FuncDeclaration buildXopCmp(StructDeclaration sd, Scope* sc)
     }
     else
     {
-        version (none)
+        version (none) // FIXME: doesn't work for recursive alias this
         {
-            // FIXME: doesn't work for recursive alias this
             /* Check opCmp member exists.
              * Consider 'alias this', but except opDispatch.
              */
@@ -621,11 +633,12 @@ extern (C++) FuncDeclaration buildXopCmp(StructDeclaration sd, Scope* sc)
  */
 extern (C++) bool needToHash(StructDeclaration sd)
 {
-    //printf("StructDeclaration::needToHash() %s\n", sd->toChars());
+    //printf("StructDeclaration::needToHash() %s\n", sd.toChars());
     if (sd.xhash)
         goto Lneed;
     if (sd.isUnionDeclaration())
         goto Ldontneed;
+
     /* If any of the fields has an opEquals, then we
      * need it too.
      */
@@ -689,7 +702,8 @@ extern (C++) FuncDeclaration buildXtoHash(StructDeclaration sd, Scope* sc)
     }
     if (!needToHash(sd))
         return null;
-    //printf("StructDeclaration::buildXtoHash() %s\n", sd->toPrettyChars());
+
+    //printf("StructDeclaration::buildXtoHash() %s\n", sd.toPrettyChars());
     Loc declLoc = Loc(); // loc is unnecessary so __xtoHash is never called directly
     Loc loc = Loc(); // internal code should have no loc to prevent coverage
     auto parameters = new Parameters();
@@ -697,7 +711,17 @@ extern (C++) FuncDeclaration buildXtoHash(StructDeclaration sd, Scope* sc)
     auto tf = new TypeFunction(parameters, Type.thash_t, 0, LINKd, STCnothrow | STCtrusted);
     Identifier id = Id.xtoHash;
     auto fop = new FuncDeclaration(declLoc, Loc(), id, STCstatic, tf);
-    const(char)* code = "size_t h = 0;foreach (i, T; typeof(p.tupleof))    h += typeid(T).getHash(cast(const void*)&p.tupleof[i]);return h;";
+
+    /* Do memberwise hashing.
+     *
+     * If sd is a nested struct, and if it's nested in a class, the calculated
+     * hash value will also contain the result of parent class's toHash().
+     */
+    const(char)* code =
+        "size_t h = 0;" ~
+        "foreach (i, T; typeof(p.tupleof))" ~
+        "    h += typeid(T).getHash(cast(const void*)&p.tupleof[i]);" ~
+        "return h;";
     fop.fbody = new CompileStatement(loc, new StringExp(loc, cast(char*)code));
     Scope* sc2 = sc.push();
     sc2.stc = 0;
@@ -705,7 +729,8 @@ extern (C++) FuncDeclaration buildXtoHash(StructDeclaration sd, Scope* sc)
     fop.semantic(sc2);
     fop.semantic2(sc2);
     sc2.pop();
-    //printf("%s fop = %s %s\n", sd->toChars(), fop->toChars(), fop->type->toChars());
+
+    //printf("%s fop = %s %s\n", sd.toChars(), fop.toChars(), fop.type.toChars());
     return fop;
 }
 
@@ -718,7 +743,7 @@ extern (C++) FuncDeclaration buildXtoHash(StructDeclaration sd, Scope* sc)
  */
 extern (C++) FuncDeclaration buildPostBlit(StructDeclaration sd, Scope* sc)
 {
-    //printf("StructDeclaration::buildPostBlit() %s\n", sd->toChars());
+    //printf("StructDeclaration::buildPostBlit() %s\n", sd.toChars());
     StorageClass stc = STCsafe | STCnothrow | STCpure | STCnogc;
     Loc declLoc = sd.postblits.dim ? sd.postblits[0].loc : sd.loc;
     Loc loc = Loc(); // internal code should have no loc to prevent coverage
@@ -750,7 +775,7 @@ extern (C++) FuncDeclaration buildPostBlit(StructDeclaration sd, Scope* sc)
         if (!a)
             a = new Statements();
         Expression ex = new ThisExp(loc);
-        ex = new DotVarExp(loc, ex, v, 0);
+        ex = new DotVarExp(loc, ex, v);
         if (v.type.toBasetype().ty == Tstruct)
         {
             // this.v.__xpostblit()
@@ -760,7 +785,7 @@ extern (C++) FuncDeclaration buildPostBlit(StructDeclaration sd, Scope* sc)
             ex = new PtrExp(loc, ex);
             if (stc & STCsafe)
                 stc = (stc & ~STCsafe) | STCtrusted;
-            ex = new DotVarExp(loc, ex, sdv.postblit, 0);
+            ex = new DotVarExp(loc, ex, sdv.postblit, false);
             ex = new CallExp(loc, ex);
         }
         else
@@ -787,7 +812,7 @@ extern (C++) FuncDeclaration buildPostBlit(StructDeclaration sd, Scope* sc)
         sdv.dtor.functionSemantic();
 
         ex = new ThisExp(loc);
-        ex = new DotVarExp(loc, ex, v, 0);
+        ex = new DotVarExp(loc, ex, v);
         if (v.type.toBasetype().ty == Tstruct)
         {
             // this.v.__xdtor()
@@ -797,7 +822,7 @@ extern (C++) FuncDeclaration buildPostBlit(StructDeclaration sd, Scope* sc)
             ex = new PtrExp(loc, ex);
             if (stc & STCsafe)
                 stc = (stc & ~STCsafe) | STCtrusted;
-            ex = new DotVarExp(loc, ex, sdv.dtor, 0);
+            ex = new DotVarExp(loc, ex, sdv.dtor, false);
             ex = new CallExp(loc, ex);
         }
         else
@@ -842,7 +867,7 @@ extern (C++) FuncDeclaration buildPostBlit(StructDeclaration sd, Scope* sc)
         stc = STCsafe | STCnothrow | STCpure | STCnogc;
         for (size_t i = 0; i < sd.postblits.dim; i++)
         {
-            FuncDeclaration fd = sd.postblits[i];
+            auto fd = sd.postblits[i];
             stc = mergeFuncAttrs(stc, fd);
             if (stc & STCdisable)
             {
@@ -850,7 +875,7 @@ extern (C++) FuncDeclaration buildPostBlit(StructDeclaration sd, Scope* sc)
                 break;
             }
             Expression ex = new ThisExp(loc);
-            ex = new DotVarExp(loc, ex, fd, 0);
+            ex = new DotVarExp(loc, ex, fd, false);
             ex = new CallExp(loc, ex);
             e = Expression.combine(e, ex);
         }
@@ -882,7 +907,7 @@ extern (C++) FuncDeclaration buildPostBlit(StructDeclaration sd, Scope* sc)
  */
 extern (C++) FuncDeclaration buildDtor(AggregateDeclaration ad, Scope* sc)
 {
-    //printf("AggregateDeclaration::buildDtor() %s\n", ad->toChars());
+    //printf("AggregateDeclaration::buildDtor() %s\n", ad.toChars());
     StorageClass stc = STCsafe | STCnothrow | STCpure | STCnogc;
     Loc declLoc = ad.dtors.dim ? ad.dtors[0].loc : ad.loc;
     Loc loc = Loc(); // internal code should have no loc to prevent coverage
@@ -907,7 +932,7 @@ extern (C++) FuncDeclaration buildDtor(AggregateDeclaration ad, Scope* sc)
             break;
         }
         Expression ex = new ThisExp(loc);
-        ex = new DotVarExp(loc, ex, v, 0);
+        ex = new DotVarExp(loc, ex, v);
         if (v.type.toBasetype().ty == Tstruct)
         {
             // this.v.__xdtor()
@@ -917,7 +942,7 @@ extern (C++) FuncDeclaration buildDtor(AggregateDeclaration ad, Scope* sc)
             ex = new PtrExp(loc, ex);
             if (stc & STCsafe)
                 stc = (stc & ~STCsafe) | STCtrusted;
-            ex = new DotVarExp(loc, ex, sdv.dtor, 0);
+            ex = new DotVarExp(loc, ex, sdv.dtor, false);
             ex = new CallExp(loc, ex);
         }
         else
@@ -970,7 +995,7 @@ extern (C++) FuncDeclaration buildDtor(AggregateDeclaration ad, Scope* sc)
                 break;
             }
             Expression ex = new ThisExp(loc);
-            ex = new DotVarExp(loc, ex, fd, 0);
+            ex = new DotVarExp(loc, ex, fd, false);
             ex = new CallExp(loc, ex);
             e = Expression.combine(ex, e);
         }
@@ -1036,7 +1061,7 @@ extern (C++) FuncDeclaration buildInv(AggregateDeclaration ad, Scope* sc)
                     break;
                 }
             }
-            e = Expression.combine(e, new CallExp(loc, new VarExp(loc, ad.invs[i])));
+            e = Expression.combine(e, new CallExp(loc, new VarExp(loc, ad.invs[i], false)));
         }
         InvariantDeclaration inv;
         inv = new InvariantDeclaration(declLoc, Loc(), stc | stcx, Id.classInvariant);
diff --git a/ddmd/cond.d b/ddmd/cond.d
index ffdc40f07e..12f58e4c1d 100644
--- a/ddmd/cond.d
+++ b/ddmd/cond.d
@@ -25,6 +25,20 @@ import ddmd.root.outbuffer;
 import ddmd.tokens;
 import ddmd.visitor;
 
+private __gshared Identifier idUnitTest;
+private __gshared Identifier idAssert;
+
+static this()
+{
+    const(char)* s;
+
+    s = Token.toChars(TOKunittest);
+    idUnitTest = Identifier.idPool(s, strlen(s));
+
+    s = Token.toChars(TOKassert);
+    idAssert   = Identifier.idPool(s, strlen(s));
+}
+
 /***********************************************************
  */
 extern (C++) class Condition
@@ -171,6 +185,9 @@ public:
             "Win64",
             "linux",
             "OSX",
+            "iOS",
+            "TVOS",
+            "WatchOS",
             "FreeBSD",
             "OpenBSD",
             "NetBSD",
@@ -233,7 +250,7 @@ public:
             "ELFv1",
             "ELFv2",
             "CRuntime_Bionic",
-            "CRuntime_Digitalmars",
+            "CRuntime_DigitalMars",
             "CRuntime_Glibc",
             "CRuntime_Microsoft",
             "D_Coverage",
@@ -314,8 +331,11 @@ public:
             }
             else if (level <= global.params.versionlevel || level <= mod.versionlevel)
                 inc = 1;
-            if (!definedInModule && (!ident || (!isPredefined(ident.toChars()) && ident != Identifier.idPool(Token.toChars(TOKunittest)) && ident != Identifier.idPool(Token.toChars(TOKassert)))))
+            if (!definedInModule &&
+                (!ident || (!isPredefined(ident.toChars()) && ident != idUnitTest && ident != idAssert)))
+            {
                 printDepsConditional(sc, this, "depsVersion ");
+            }
         }
         return (inc == 1);
     }
diff --git a/ddmd/cond.h b/ddmd/cond.h
index a3bc16a39e..4b4b49452b 100644
--- a/ddmd/cond.h
+++ b/ddmd/cond.h
@@ -70,11 +70,7 @@ class VersionCondition : public DVCondition
 public:
     static void setGlobalLevel(unsigned level);
     static bool isPredefined(const char *ident);
-    static void checkPredefined(Loc loc, const char *ident)
-    {
-        if (isPredefined(ident))
-            error(loc, "version identifier '%s' is reserved and cannot be set", ident);
-    }
+    static void checkPredefined(Loc loc, const char *ident);
     static void addGlobalIdent(const char *ident);
     static void addPredefinedGlobalIdent(const char *ident);
 
diff --git a/ddmd/constfold.d b/ddmd/constfold.d
index e75e3c3f0a..69f0d9ec24 100644
--- a/ddmd/constfold.d
+++ b/ddmd/constfold.d
@@ -870,11 +870,6 @@ extern (C++) UnionExp Equal(TOK op, Loc loc, Type type, Expression e1, Expressio
                     break;
             }
         }
-        if (cmp && es1.type.needsNested())
-        {
-            if ((es1.sinit !is null) != (es2.sinit !is null))
-                cmp = 0;
-        }
     }
     else if (e1.isConst() != 1 || e2.isConst() != 1)
     {
@@ -1344,9 +1339,8 @@ extern (C++) UnionExp Slice(Type type, Expression e1, Expression lwr, Expression
         {
             size_t len = cast(size_t)(iupr - ilwr);
             ubyte sz = es1.sz;
-            void* s = mem.xmalloc((len + 1) * sz);
-            memcpy(cast(char*)s, cast(char*)es1.string + ilwr * sz, len * sz);
-            memset(cast(char*)s + len * sz, 0, sz);
+            void* s = mem.xmalloc(len * sz);
+            memcpy(cast(char*)s, es1.string + ilwr * sz, len * sz);
             emplaceExp!(StringExp)(&ue, loc, s, len, es1.postfix);
             StringExp es = cast(StringExp)ue.exp();
             es.sz = sz;
@@ -1382,29 +1376,13 @@ extern (C++) UnionExp Slice(Type type, Expression e1, Expression lwr, Expression
 /* Set a slice of char/integer array literal 'existingAE' from a string 'newval'.
  * existingAE[firstIndex..firstIndex+newval.length] = newval.
  */
-extern (C++) void sliceAssignArrayLiteralFromString(ArrayLiteralExp existingAE, StringExp newval, size_t firstIndex)
+extern (C++) void sliceAssignArrayLiteralFromString(ArrayLiteralExp existingAE, const StringExp newval, size_t firstIndex)
 {
-    size_t newlen = newval.len;
-    size_t sz = newval.sz;
-    void* s = newval.string;
+    const len = newval.len;
     Type elemType = existingAE.type.nextOf();
-    for (size_t j = 0; j < newlen; j++)
+    foreach (j; 0 .. len)
     {
-        dinteger_t val;
-        switch (sz)
-        {
-        case 1:
-            val = (cast(char*)s)[j];
-            break;
-        case 2:
-            val = (cast(utf16_t*)s)[j];
-            break;
-        case 4:
-            val = (cast(utf32_t*)s)[j];
-            break;
-        default:
-            assert(0);
-        }
+        const val = newval.getCodeUnit(j);
         (*existingAE.elements)[j + firstIndex] = new IntegerExp(newval.loc, val, elemType);
     }
 }
@@ -1414,76 +1392,44 @@ extern (C++) void sliceAssignArrayLiteralFromString(ArrayLiteralExp existingAE,
  */
 extern (C++) void sliceAssignStringFromArrayLiteral(StringExp existingSE, ArrayLiteralExp newae, size_t firstIndex)
 {
-    void* s = existingSE.string;
-    for (size_t j = 0; j < newae.elements.dim; j++)
+    assert(existingSE.ownedByCtfe != OWNEDcode);
+    foreach (j; 0 .. newae.elements.dim)
     {
-        uint val = cast(uint)newae.getElement(j).toInteger();
-        switch (existingSE.sz)
-        {
-        case 1:
-            (cast(char*)s)[j + firstIndex] = cast(char)val;
-            break;
-        case 2:
-            (cast(utf16_t*)s)[j + firstIndex] = cast(utf16_t)val;
-            break;
-        case 4:
-            (cast(utf32_t*)s)[j + firstIndex] = cast(utf32_t)val;
-            break;
-        default:
-            assert(0);
-        }
+        existingSE.setCodeUnit(firstIndex + j, cast(dchar)newae.getElement(j).toInteger());
     }
 }
 
 /* Set a slice of string 'existingSE' from a string 'newstr'.
  *   existingSE[firstIndex..firstIndex+newstr.length] = newstr.
  */
-extern (C++) void sliceAssignStringFromString(StringExp existingSE, StringExp newstr, size_t firstIndex)
+extern (C++) void sliceAssignStringFromString(StringExp existingSE, const StringExp newstr, size_t firstIndex)
 {
-    void* s = existingSE.string;
+    assert(existingSE.ownedByCtfe != OWNEDcode);
     size_t sz = existingSE.sz;
     assert(sz == newstr.sz);
-    memcpy(cast(char*)s + firstIndex * sz, newstr.string, sz * newstr.len);
+    memcpy(existingSE.string + firstIndex * sz, newstr.string, sz * newstr.len);
 }
 
 /* Compare a string slice with another string slice.
  * Conceptually equivalent to memcmp( se1[lo1..lo1+len],  se2[lo2..lo2+len])
  */
-extern (C++) int sliceCmpStringWithString(StringExp se1, StringExp se2, size_t lo1, size_t lo2, size_t len)
+extern (C++) int sliceCmpStringWithString(const StringExp se1, const StringExp se2, size_t lo1, size_t lo2, size_t len)
 {
-    void* s1 = se1.string;
-    void* s2 = se2.string;
     size_t sz = se1.sz;
     assert(sz == se2.sz);
-    return memcmp(cast(char*)s1 + sz * lo1, cast(char*)s2 + sz * lo2, sz * len);
+    return memcmp(se1.string + sz * lo1, se2.string + sz * lo2, sz * len);
 }
 
 /* Compare a string slice with an array literal slice
  * Conceptually equivalent to memcmp( se1[lo1..lo1+len],  ae2[lo2..lo2+len])
  */
-extern (C++) int sliceCmpStringWithArray(StringExp se1, ArrayLiteralExp ae2, size_t lo1, size_t lo2, size_t len)
+extern (C++) int sliceCmpStringWithArray(const StringExp se1, ArrayLiteralExp ae2, size_t lo1, size_t lo2, size_t len)
 {
-    void* s = se1.string;
-    size_t sz = se1.sz;
-    for (size_t j = 0; j < len; j++)
+    foreach (j; 0 .. len)
     {
-        uint val2 = cast(uint)ae2.getElement(j + lo2).toInteger();
-        uint val1;
-        switch (sz)
-        {
-        case 1:
-            val1 = (cast(char*)s)[j + lo1];
-            break;
-        case 2:
-            val1 = (cast(utf16_t*)s)[j + lo1];
-            break;
-        case 4:
-            val1 = (cast(utf32_t*)s)[j + lo1];
-            break;
-        default:
-            assert(0);
-        }
-        int c = val1 - val2;
+        const val2 = cast(dchar)ae2.getElement(j + lo2).toInteger();
+        const val1 = se1.getCodeUnit(j + lo1);
+        const int c = val1 - val2;
         if (c)
             return c;
     }
@@ -1521,24 +1467,12 @@ extern (C++) UnionExp Cat(Type type, Expression e1, Expression e2)
                 t = t.nextOf().toBasetype();
             ubyte sz = cast(ubyte)t.size();
             dinteger_t v = e.toInteger();
-            size_t len = (t.ty == tn.ty) ? 1 : utf_codeLength(sz, cast(dchar_t)v);
-            void* s = mem.xmalloc((len + 1) * sz);
+            size_t len = (t.ty == tn.ty) ? 1 : utf_codeLength(sz, cast(dchar)v);
+            void* s = mem.xmalloc(len * sz);
             if (t.ty == tn.ty)
-            {
-version(IN_LLVM) {
-    version(LittleEndian) {
-                memcpy(s, &v, sz);
-    } else {
-                memcpy(s, cast(char *)&v + (dinteger_t.sizeof - sz), sz);
-    }
-} else {
-                memcpy(s, &v, sz);
-}
-            }
+                Port.valcpy(s, v, sz);
             else
-                utf_encode(sz, s, cast(dchar_t)v);
-            // Add terminating 0
-            memset(cast(char*)s + len * sz, 0, sz);
+                utf_encode(sz, s, cast(dchar)v);
             emplaceExp!(StringExp)(&ue, loc, s, len);
             StringExp es = cast(StringExp)ue.exp();
             es.sz = sz;
@@ -1601,11 +1535,9 @@ version(IN_LLVM) {
             assert(ue.exp().type);
             return ue;
         }
-        void* s = mem.xmalloc((len + 1) * sz);
+        void* s = mem.xmalloc(len * sz);
         memcpy(cast(char*)s, es1.string, es1.len * sz);
         memcpy(cast(char*)s + es1.len * sz, es2.string, es2.len * sz);
-        // Add terminating 0
-        memset(cast(char*)s + len * sz, 0, sz);
         emplaceExp!(StringExp)(&ue, loc, s, len);
         StringExp es = cast(StringExp)ue.exp();
         es.sz = sz;
@@ -1663,26 +1595,13 @@ version(IN_LLVM) {
         // (char[] ~ char, wchar[]~wchar, or dchar[]~dchar)
         bool homoConcat = (sz == t2.size());
         size_t len = es1.len;
-        len += homoConcat ? 1 : utf_codeLength(sz, cast(dchar_t)v);
-        void* s = mem.xmalloc((len + 1) * sz);
+        len += homoConcat ? 1 : utf_codeLength(sz, cast(dchar)v);
+        void* s = mem.xmalloc(len * sz);
         memcpy(s, es1.string, es1.len * sz);
         if (homoConcat)
-        {
-version(IN_LLVM) {
-    version(LittleEndian) {
-            memcpy(cast(char *)s + (sz * es1.len), &v, sz);
-    } else {
-            memcpy(cast(char *)s + (sz * es1.len),
-                   cast(char *)&v + (dinteger_t.sizeof - sz), sz);
-    }
-} else {
-            memcpy(cast(char*)s + (sz * es1.len), &v, sz);
-}
-        }
+            Port.valcpy(cast(char*)s + (sz * es1.len), v, sz);
         else
-            utf_encode(sz, cast(char*)s + (sz * es1.len), cast(dchar_t)v);
-        // Add terminating 0
-        memset(cast(char*)s + len * sz, 0, sz);
+            utf_encode(sz, cast(char*)s + (sz * es1.len), cast(dchar)v);
         emplaceExp!(StringExp)(&ue, loc, s, len);
         es = cast(StringExp)ue.exp();
         es.sz = sz;
@@ -1698,20 +1617,9 @@ version(IN_LLVM) {
         size_t len = 1 + es2.len;
         ubyte sz = es2.sz;
         dinteger_t v = e1.toInteger();
-        void* s = mem.xmalloc((len + 1) * sz);
-version(IN_LLVM) {
-    version(LittleEndian) {
-        memcpy(cast(char *)s, &v, sz);
-    } else {
-        memcpy(cast(char *)s,
-               cast(char *)&v + (dinteger_t.sizeof - sz), sz);
-    }
-} else {
+        void* s = mem.xmalloc(len * sz);
         memcpy(cast(char*)s, &v, sz);
-}
         memcpy(cast(char*)s + sz, es2.string, es2.len * sz);
-        // Add terminating 0
-        memset(cast(char*)s + len * sz, 0, sz);
         emplaceExp!(StringExp)(&ue, loc, s, len);
         StringExp es = cast(StringExp)ue.exp();
         es.sz = sz;
diff --git a/ddmd/cppmangle.d b/ddmd/cppmangle.d
index 9d5771e8d3..2e34d935aa 100644
--- a/ddmd/cppmangle.d
+++ b/ddmd/cppmangle.d
@@ -1,19 +1,23 @@
-// Compiler implementation of the D programming language
-// Copyright (c) 1999-2015 by Digital Mars
-// All Rights Reserved
-// written by Walter Bright
-// http://www.digitalmars.com
-// Distributed under the Boost Software License, Version 1.0.
-// http://www.boost.org/LICENSE_1_0.txt
+/**
+ * Compiler implementation of the $(LINK2 http://www.dlang.org, D programming language)
+ *
+ * Copyright: Copyright (c) 1999-2016 by Digital Mars, All Rights Reserved
+ * Authors: Walter Bright, http://www.digitalmars.com
+ * License:   $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
+ * Source:    $(DMDSRC cppmangle.d)
+ */
 
 module ddmd.cppmangle;
 
 import core.stdc.string;
+import core.stdc.stdio;
+
 import ddmd.arraytypes;
 import ddmd.declaration;
 import ddmd.dstruct;
 import ddmd.dsymbol;
 import ddmd.dtemplate;
+import ddmd.errors;
 import ddmd.expression;
 import ddmd.func;
 import ddmd.globals;
@@ -69,12 +73,14 @@ static if (IN_LLVM || TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPE
 
         bool substitute(RootObject p)
         {
-            //printf("substitute %s\n", p ? p->toChars() : NULL);
+            //printf("substitute %s\n", p ? p.toChars() : null);
             if (components_on)
                 for (size_t i = 0; i < components.dim; i++)
                 {
+                    //printf("    component[%d] = %s\n", i, components[i] ? components[i].toChars() : null);
                     if (p == components[i])
                     {
+                        //printf("\tmatch\n");
                         /* Sequence is S_, S0_, .., S9_, SA_, ..., SZ_, S10_, ...
                          */
                         buf.writeByte('S');
@@ -89,7 +95,7 @@ static if (IN_LLVM || TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPE
 
         bool exist(RootObject p)
         {
-            //printf("exist %s\n", p ? p->toChars() : NULL);
+            //printf("exist %s\n", p ? p.toChars() : null);
             if (components_on)
                 for (size_t i = 0; i < components.dim; i++)
                 {
@@ -103,14 +109,14 @@ static if (IN_LLVM || TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPE
 
         void store(RootObject p)
         {
-            //printf("store %s\n", p ? p->toChars() : NULL);
+            //printf("store %s\n", p ? p.toChars() : "null");
             if (components_on)
                 components.push(p);
         }
 
         void source_name(Dsymbol s, bool skipname = false)
         {
-            //printf("source_name(%s)\n", s->toChars());
+            //printf("source_name(%s)\n", s.toChars());
             TemplateInstance ti = s.isTemplateInstance();
             if (ti)
             {
@@ -174,11 +180,7 @@ static if (IN_LLVM || TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPE
                         else
                         {
                             s.error("Internal Compiler Error: C++ %s template value parameter is not supported", tv.valType.toChars());
-version(IN_LLVM) {
                             fatal();
-} else {
-                            assert(0);
-}
                         }
                     }
                     else if (!tp || tp.isTemplateTypeParameter())
@@ -194,11 +196,7 @@ version(IN_LLVM) {
                         if (!d && !e)
                         {
                             s.error("Internal Compiler Error: %s is unsupported parameter for C++ template: (%s)", o.toChars());
-version(IN_LLVM) {
                             fatal();
-} else {
-                            assert(0);
-}
                         }
                         if (d && d.isFuncDeclaration())
                         {
@@ -228,21 +226,13 @@ version(IN_LLVM) {
                         else
                         {
                             s.error("Internal Compiler Error: %s is unsupported parameter for C++ template", o.toChars());
-version(IN_LLVM) {
                             fatal();
-} else {
-                            assert(0);
-}
                         }
                     }
                     else
                     {
                         s.error("Internal Compiler Error: C++ templates support only integral value, type parameters, alias templates and alias function parameters");
-version(IN_LLVM) {
                         fatal();
-} else {
-                        assert(0);
-}
                     }
                 }
                 if (is_var_arg)
@@ -261,7 +251,7 @@ version(IN_LLVM) {
 
         void prefix_name(Dsymbol s)
         {
-            //printf("prefix_name(%s)\n", s->toChars());
+            //printf("prefix_name(%s)\n", s.toChars());
             if (!substitute(s))
             {
                 Dsymbol p = s.toParent();
@@ -279,9 +269,13 @@ version(IN_LLVM) {
                 }
                 if (p && !p.isModule())
                 {
-                    prefix_name(p);
+                    if (p.ident == Id.std && is_initial_qualifier(p))
+                        buf.writestring("St");
+                    else
+                        prefix_name(p);
                 }
-                store(s);
+                if (!(s.ident == Id.std && is_initial_qualifier(s)))
+                    store(s);
                 source_name(s);
             }
         }
@@ -304,7 +298,7 @@ version(IN_LLVM) {
 
         void cpp_mangle_name(Dsymbol s, bool qualified)
         {
-            //printf("cpp_mangle_name(%s, %d)\n", s->toChars(), qualified);
+            //printf("cpp_mangle_name(%s, %d)\n", s.toChars(), qualified);
             Dsymbol p = s.toParent();
             Dsymbol se = s;
             bool dont_write_prefix = false;
@@ -340,10 +334,10 @@ version(IN_LLVM) {
                         // Replace ::std::basic_string < char, ::std::char_traits<char>, ::std::allocator<char> >
                         // with Ss
                         //printf("xx: '%.*s'\n", (int)(buf.offset - off), buf.data + off);
-                        if (buf.offset - off >= 26 && memcmp(buf.data + off, cast(char*)"IcSt11char_traitsIcESaIcEE", 26) == 0)
+                        if (buf.offset - off >= 26 && memcmp(buf.data + off, "IcSt11char_traitsIcESaIcEE".ptr, 26) == 0)
                         {
                             buf.remove(off - 2, 28);
-                            buf.insert(off - 2, cast(const(char)*)"Ss", 2);
+                            buf.insert(off - 2, "Ss".ptr, 2);
                             return;
                         }
                         buf.setsize(off);
@@ -361,7 +355,7 @@ version(IN_LLVM) {
                         source_name(se, true);
                         components_on = true;
                         //printf("xx: '%.*s'\n", (int)(buf.offset - off), buf.data + off);
-                        if (buf.offset - off >= 21 && memcmp(buf.data + off, cast(char*)"IcSt11char_traitsIcEE", 21) == 0)
+                        if (buf.offset - off >= 21 && memcmp(buf.data + off, "IcSt11char_traitsIcEE".ptr, 21) == 0)
                         {
                             buf.remove(off, 21);
                             char[2] mbuf;
@@ -403,11 +397,7 @@ version(IN_LLVM) {
             if (!(d.storage_class & (STCextern | STCgshared)))
             {
                 d.error("Internal Compiler Error: C++ static non- __gshared non-extern variables not supported");
-version(IN_LLVM) {
                 fatal();
-} else {
-                assert(0);
-}
             }
             Dsymbol p = d.toParent();
             if (p && !p.isModule()) //for example: char Namespace1::beta[6] should be mangled as "_ZN10Namespace14betaE"
@@ -433,7 +423,7 @@ version(IN_LLVM) {
 
         void mangle_function(FuncDeclaration d)
         {
-            //printf("mangle_function(%s)\n", d->toChars());
+            //printf("mangle_function(%s)\n", d.toChars());
             /*
              * <mangled-name> ::= _Z <encoding>
              * <encoding> ::= <function name> <bare-function-type>
@@ -451,22 +441,27 @@ version(IN_LLVM) {
                 prefix_name(p);
                 // See ABI 5.1.8 Compression
                 // Replace ::std::allocator with Sa
-                if (buf.offset >= 17 && memcmp(buf.data, cast(char*)"_ZN3std9allocator", 17) == 0)
+                if (buf.offset >= 17 && memcmp(buf.data, "_ZN3std9allocator".ptr, 17) == 0)
                 {
                     buf.remove(3, 14);
-                    buf.insert(3, cast(const(char)*)"Sa", 2);
+                    buf.insert(3, "Sa".ptr, 2);
                 }
                 // Replace ::std::basic_string with Sb
-                if (buf.offset >= 21 && memcmp(buf.data, cast(char*)"_ZN3std12basic_string", 21) == 0)
+                if (buf.offset >= 21 && memcmp(buf.data, "_ZN3std12basic_string".ptr, 21) == 0)
                 {
                     buf.remove(3, 18);
-                    buf.insert(3, cast(const(char)*)"Sb", 2);
+                    buf.insert(3, "Sb".ptr, 2);
                 }
                 // Replace ::std with St
-                if (buf.offset >= 7 && memcmp(buf.data, cast(char*)"_ZN3std", 7) == 0)
+                if (buf.offset >= 7 && memcmp(buf.data, "_ZN3std".ptr, 7) == 0)
                 {
                     buf.remove(3, 4);
-                    buf.insert(3, cast(const(char)*)"St", 2);
+                    buf.insert(3, "St".ptr, 2);
+                }
+                if (buf.offset >= 8 && memcmp(buf.data, "_ZNK3std".ptr, 8) == 0)
+                {
+                    buf.remove(4, 4);
+                    buf.insert(4, "St".ptr, 2);
                 }
                 if (d.isDtorDeclaration())
                 {
@@ -508,12 +503,8 @@ version(IN_LLVM) {
                     // Mangle static arrays as pointers
                     t.error(Loc(), "Internal Compiler Error: unable to pass static array to extern(C++) function.");
                     t.error(Loc(), "Use pointer instead.");
-version(IN_LLVM) {
                     fatal();
-} else {
-                    assert(0);
-}
-                    //t = t->nextOf()->pointerTo();
+                    //t = t.nextOf().pointerTo();
                 }
                 /* If it is a basic, enum or struct type,
                  * then don't mark it const
@@ -541,7 +532,7 @@ version(IN_LLVM) {
             this.components_on = true;
         }
 
-        char* mangleOf(Dsymbol s)
+        const(char)* mangleOf(Dsymbol s)
         {
             VarDeclaration vd = s.isVarDeclaration();
             FuncDeclaration fd = s.isFuncDeclaration();
@@ -571,11 +562,7 @@ version(IN_LLVM) {
             {
                 t.error(Loc(), "Internal Compiler Error: unsupported type %s\n", t.toChars());
             }
-version(IN_LLVM) {
-            fatal();
-} else {
-            assert(0); //Assert, because this error should be handled in frontend
-}
+            fatal(); //Fatal, because this error should be handled in frontend
         }
 
         override void visit(TypeBasic t)
@@ -733,7 +720,7 @@ version(IN_LLVM) {
                 buf.writeByte('K');
             assert(t.basetype && t.basetype.ty == Tsarray);
             assert((cast(TypeSArray)t.basetype).dim);
-            //buf.printf("Dv%llu_", ((TypeSArray *)t->basetype)->dim->toInteger());// -- Gnu ABI v.4
+            //buf.printf("Dv%llu_", ((TypeSArray *)t.basetype).dim.toInteger());// -- Gnu ABI v.4
             buf.writestring("U8__vector"); //-- Gnu ABI v.3
             t.basetype.nextOf().accept(this);
         }
@@ -809,7 +796,7 @@ version(IN_LLVM) {
 
              BUG: Right now, types of functions are never merged, so our simplistic
              component matcher always finds them to be different.
-             We should use Type::equals on these, and use different
+             We should use Type.equals on these, and use different
              TypeFunctions for non-static member functions, and non-static
              member functions of different classes.
              */
@@ -834,8 +821,8 @@ version(IN_LLVM) {
 
         override void visit(TypeStruct t)
         {
-            Identifier id = t.sym.ident;
-            //printf("struct id = '%s'\n", id->toChars());
+            const id = t.sym.ident;
+            //printf("struct id = '%s'\n", id.toChars());
             char c;
             if (id == Id.__c_long)
                 c = 'l';
@@ -927,23 +914,37 @@ version(IN_LLVM) {
                 store(null);
             store(t);
         }
+
+        final const(char)* mangle_typeinfo(Dsymbol s)
+        {
+            buf.writestring("_ZTI");
+            cpp_mangle_name(s, false);
+            return buf.extractString();
+        }
     }
 
 version(IN_LLVM) {} else {
-    extern (C++) char* toCppMangle(Dsymbol s)
+    extern (C++) const(char)* toCppMangle(Dsymbol s)
     {
-        //printf("toCppMangle(%s)\n", s->toChars());
+        //printf("toCppMangle(%s)\n", s.toChars());
         scope CppMangleVisitor v = new CppMangleVisitor();
         return v.mangleOf(s);
     }
+
+    extern (C++) const(char)* cppTypeInfoMangle(Dsymbol s)
+    {
+        //printf("cppTypeInfoMangle(%s)\n", s.toChars());
+        scope CppMangleVisitor v = new CppMangleVisitor();
+        return v.mangle_typeinfo(s);
+    }
 }
 
 }
 static if (IN_LLVM || TARGET_WINDOS)
 {
     // Windows DMC and Microsoft Visual C++ mangling
-    enum VC_SAVED_TYPE_CNT = 10;
-    enum VC_SAVED_IDENT_CNT = 10;
+    enum VC_SAVED_TYPE_CNT = 10u;
+    enum VC_SAVED_IDENT_CNT = 10u;
 
     extern (C++) final class VisualCPPMangler : Visitor
     {
@@ -995,11 +996,7 @@ static if (IN_LLVM || TARGET_WINDOS)
             {
                 type.error(Loc(), "Internal Compiler Error: unsupported type %s\n", type.toChars());
             }
-version(IN_LLVM) {
-            fatal();
-} else {
-            assert(0); // Assert, because this error should be handled in frontend
-}
+            fatal(); //Fatal, because this error should be handled in frontend
         }
 
         override void visit(TypeBasic type)
@@ -1023,15 +1020,18 @@ version(IN_LLVM) {
             {
                 switch (type.ty)
                 {
-                    case Tint64:
-                    case Tuns64:
-                    case Tint128:
-                    case Tuns128:
-                    case Tfloat80:
-                    case Twchar:
-                        if (checkTypeSaved(type))
-                            return;
-                    default:
+                case Tint64:
+                case Tuns64:
+                case Tint128:
+                case Tuns128:
+                case Tfloat80:
+                case Twchar:
+                    if (checkTypeSaved(type))
+                        return;
+                    break;
+
+                default:
+                    break;
                 }
             }
             mangleModifier(type);
@@ -1206,7 +1206,7 @@ version(IN_LLVM) {
 
         override void visit(TypeReference type)
         {
-            //printf("visit(TypeReference); type = %s\n", type->toChars());
+            //printf("visit(TypeReference); type = %s\n", type.toChars());
             if (checkTypeSaved(type))
                 return;
             if (type.isImmutable() || type.isShared())
@@ -1247,7 +1247,7 @@ version(IN_LLVM) {
 
         override void visit(TypeStruct type)
         {
-            Identifier id = type.sym.ident;
+            const id = type.sym.ident;
             char c;
             if (id == Id.__c_long_double)
                 c = 'O'; // VC++ long double
@@ -1354,7 +1354,7 @@ version(IN_LLVM) {
             flags &= ~IGNORE_CONST;
         }
 
-        char* mangleOf(Dsymbol s)
+        const(char)* mangleOf(Dsymbol s)
         {
 version(IN_LLVM) {
             buf.writeByte('\01'); // disable further mangling by the backend
@@ -1386,7 +1386,9 @@ version(IN_LLVM) {
             if (d.needThis()) // <flags> ::= <virtual/protection flag> <const/volatile flag> <calling convention flag>
             {
                 // Pivate methods always non-virtual in D and it should be mangled as non-virtual in C++
-                if (d.isVirtual() && d.vtblIndex != -1)
+                //printf("%s: isVirtualMethod = %d, isVirtual = %d, vtblIndex = %d, interfaceVirtual = %p\n",
+                    //d.toChars(), d.isVirtualMethod(), d.isVirtual(), cast(int)d.vtblIndex, d.interfaceVirtual);
+                if (d.isVirtual() && (d.vtblIndex != -1 || d.interfaceVirtual || d.overrideInterface()))
                 {
                     switch (d.protection.kind)
                     {
@@ -1448,7 +1450,7 @@ version(IN_LLVM) {
                 // <flags> ::= Y <calling convention flag>
                 buf.writeByte('Y');
             }
-            const(char)* args = mangleFunctionType(cast(TypeFunction)d.type, cast(bool)d.needThis(), d.isCtorDeclaration() || d.isDtorDeclaration());
+            const(char)* args = mangleFunctionType(cast(TypeFunction)d.type, d.needThis(), d.isCtorDeclaration() || d.isDtorDeclaration());
             buf.writestring(args);
         }
 
@@ -1459,11 +1461,7 @@ version(IN_LLVM) {
             if (!(d.storage_class & (STCextern | STCgshared)))
             {
                 d.error("Internal Compiler Error: C++ static non- __gshared non-extern variables not supported");
-version(IN_LLVM) {
                 fatal();
-} else {
-                assert(0);
-}
             }
             buf.writeByte('?');
             mangleIdent(d);
@@ -1491,7 +1489,7 @@ version(IN_LLVM) {
             Type t = d.type;
             if (t.isImmutable() || t.isShared())
             {
-                visit(cast(Type)t);
+                visit(t);
                 return;
             }
             if (t.isConst())
@@ -1514,7 +1512,7 @@ version(IN_LLVM) {
 
         void mangleName(Dsymbol sym, bool dont_use_back_reference = false)
         {
-            //printf("mangleName('%s')\n", sym->toChars());
+            //printf("mangleName('%s')\n", sym.toChars());
             const(char)* name = null;
             bool is_dmc_template = false;
             if (sym.isDtorDeclaration())
@@ -1587,11 +1585,7 @@ version(IN_LLVM) {
                         else
                         {
                             sym.error("Internal Compiler Error: C++ %s template value parameter is not supported", tv.valType.toChars());
-version(IN_LLVM) {
                             fatal();
-} else {
-                            assert(0);
-}
                         }
                     }
                     else if (!tp || tp.isTemplateTypeParameter())
@@ -1607,11 +1601,7 @@ version(IN_LLVM) {
                         if (!d && !e)
                         {
                             sym.error("Internal Compiler Error: %s is unsupported parameter for C++ template", o.toChars());
-version(IN_LLVM) {
                             fatal();
-} else {
-                            assert(0);
-}
                         }
                         if (d && d.isFuncDeclaration())
                         {
@@ -1652,11 +1642,7 @@ version(IN_LLVM) {
                                 else
                                 {
                                     sym.error("Internal Compiler Error: C++ templates support only integral value, type parameters, alias templates and alias function parameters");
-version(IN_LLVM) {
                                     fatal();
-} else {
-                                    assert(0);
-}
                                 }
                             }
                             tmp.mangleIdent(d);
@@ -1664,21 +1650,13 @@ version(IN_LLVM) {
                         else
                         {
                             sym.error("Internal Compiler Error: %s is unsupported parameter for C++ template: (%s)", o.toChars());
-version(IN_LLVM) {
                             fatal();
-} else {
-                            assert(0);
-}
                         }
                     }
                     else
                     {
                         sym.error("Internal Compiler Error: C++ templates support only integral value, type parameters, alias templates and alias function parameters");
-version(IN_LLVM) {
                         fatal();
-} else {
-                        assert(0);
-}
                     }
                 }
                 name = tmp.buf.extractString();
@@ -1707,7 +1685,7 @@ version(IN_LLVM) {
         // returns true if name already saved
         bool checkAndSaveIdent(const(char)* name)
         {
-            for (uint i = 0; i < VC_SAVED_IDENT_CNT; i++)
+            foreach (i; 0 .. VC_SAVED_IDENT_CNT)
             {
                 if (!saved_idents[i]) // no saved same name
                 {
@@ -1725,7 +1703,7 @@ version(IN_LLVM) {
 
         void saveIdent(const(char)* name)
         {
-            for (size_t i = 0; i < VC_SAVED_IDENT_CNT; i++)
+            foreach (i; 0 .. VC_SAVED_IDENT_CNT)
             {
                 if (!saved_idents[i]) // no saved same name
                 {
@@ -1752,7 +1730,7 @@ version(IN_LLVM) {
             //                ::= <template arg>
             // <template arg>  ::= <type>
             //                ::= $0<encoded integral number>
-            //printf("mangleIdent('%s')\n", sym->toChars());
+            //printf("mangleIdent('%s')\n", sym.toChars());
             Dsymbol p = sym;
             if (p.toParent() && p.toParent().isTemplateInstance())
             {
@@ -1827,7 +1805,7 @@ version(IN_LLVM) {
                 return;
             if (type.isImmutable() || type.isShared())
             {
-                visit(cast(Type)type);
+                visit(type);
                 return;
             }
             if (type.isConst())
@@ -1909,7 +1887,7 @@ version(IN_LLVM) {
                 flags &= ~IGNORE_CONST;
                 if (rettype.ty == Tstruct || rettype.ty == Tenum)
                 {
-                    Identifier id = rettype.toDsymbol(null).ident;
+                    const id = rettype.toDsymbol(null).ident;
                     if (id != Id.__c_long_double && id != Id.__c_long && id != Id.__c_ulong)
                     {
                         tmp.buf.writeByte('?');
@@ -1974,7 +1952,7 @@ version(IN_LLVM) {
     }
 
 version(IN_LLVM) {
-    extern (C++) char *toCppMangle(Dsymbol s)
+    extern (C++) const(char)* toCppMangle(Dsymbol s)
     {
         if (isTargetWindowsMSVC())
         {
@@ -1988,11 +1966,17 @@ version(IN_LLVM) {
         }
     }
 } else {
-    extern (C++) char* toCppMangle(Dsymbol s)
+    extern (C++) const(char)* toCppMangle(Dsymbol s)
     {
         scope VisualCPPMangler v = new VisualCPPMangler(!global.params.mscoff);
         return v.mangleOf(s);
     }
+
+    extern (C++) const(char)* cppTypeInfoMangle(Dsymbol s)
+    {
+        //printf("cppTypeInfoMangle(%s)\n", s.toChars());
+        assert(0);
+    }
 }
 }
 else
diff --git a/ddmd/ctfeexpr.d b/ddmd/ctfeexpr.d
index b5d6b0be38..055905fb6e 100644
--- a/ddmd/ctfeexpr.d
+++ b/ddmd/ctfeexpr.d
@@ -148,9 +148,9 @@ public:
         this.type = var.type;
     }
 
-    override char* toChars()
+    override const(char)* toChars() const
     {
-        return cast(char*)"void";
+        return "void";
     }
 
     override void accept(Visitor v)
@@ -187,9 +187,9 @@ public:
         this.type = victim.type;
     }
 
-    override char* toChars()
+    override const(char)* toChars() const
     {
-        return cast(char*)"CTFE ThrownException";
+        return "CTFE ThrownException";
     }
 
     // Generate an error message when this exception is not caught
@@ -224,20 +224,20 @@ public:
         type = Type.tvoid;
     }
 
-    override char* toChars()
+    override const(char)* toChars() const
     {
         switch (op)
         {
         case TOKcantexp:
-            return cast(char*)"<cant>";
+            return "<cant>";
         case TOKvoidexp:
-            return cast(char*)"<void>";
+            return "<void>";
         case TOKbreak:
-            return cast(char*)"<break>";
+            return "<break>";
         case TOKcontinue:
-            return cast(char*)"<continue>";
+            return "<continue>";
         case TOKgoto:
-            return cast(char*)"<goto>";
+            return "<goto>";
         default:
             assert(0);
         }
@@ -629,10 +629,10 @@ extern (C++) ArrayLiteralExp createBlockDuplicatedArrayLiteral(Loc loc, Type typ
  * Helper for NewExp
  * Create a string literal consisting of 'value' duplicated 'dim' times.
  */
-extern (C++) StringExp createBlockDuplicatedStringLiteral(Loc loc, Type type, uint value, size_t dim, ubyte sz)
+extern (C++) StringExp createBlockDuplicatedStringLiteral(Loc loc, Type type, dchar value, size_t dim, ubyte sz)
 {
-    char* s = cast(char*)mem.xcalloc(dim + 1, sz);
-    for (size_t elemi = 0; elemi < dim; ++elemi)
+    auto s = cast(char*)mem.xcalloc(dim, sz);
+    foreach (elemi; 0 .. dim)
     {
         switch (sz)
         {
@@ -640,10 +640,10 @@ extern (C++) StringExp createBlockDuplicatedStringLiteral(Loc loc, Type type, ui
             s[elemi] = cast(char)value;
             break;
         case 2:
-            (cast(ushort*)s)[elemi] = cast(ushort)value;
+            (cast(wchar*)s)[elemi] = cast(wchar)value;
             break;
         case 4:
-            (cast(uint*)s)[elemi] = value;
+            (cast(dchar*)s)[elemi] = value;
             break;
         default:
             assert(0);
@@ -1026,7 +1026,6 @@ extern (C++) Expression paintFloatInt(Expression fromVal, Type to)
     return Target.paintAsType(fromVal, to);
 }
 
-
 /******** Constant folding, with support for CTFE ***************************/
 /// Return true if non-pointer expression e can be compared
 /// with >,is, ==, etc, using ctfeCmp, ctfeEqual, ctfeIdentity
@@ -1475,16 +1474,7 @@ extern (C++) UnionExp ctfeCat(Loc loc, Type type, Expression e1, Expression e2)
                 return ue;
             }
             dinteger_t v = es2e.toInteger();
-version(IN_LLVM) {
-    version(LittleEndian) {
-            memcpy(cast(char *)s + i * sz, &v, sz);
-    } else {
-            memcpy(cast(char *)s + i * sz,
-                   cast(char *)&v + (dinteger_t.sizeof - sz), sz);
-    }
-} else {
-            memcpy(cast(char*)s + i * sz, &v, sz);
-}
+            Port.valcpy(cast(char*)s + i * sz, v, sz);
         }
         // Add terminating 0
         memset(cast(char*)s + len * sz, 0, sz);
@@ -1514,16 +1504,7 @@ version(IN_LLVM) {
                 return ue;
             }
             dinteger_t v = es2e.toInteger();
-version(IN_LLVM) {
-    version(LittleEndian) {
-            memcpy(cast(char*)s + (es1.len + i) * sz, &v, sz);
-    } else {
-            memcpy(cast(char*)s + (es1.len + i) * sz,
-                   cast(char*)&v + (dinteger_t.sizeof - sz), sz);
-    }
-} else {
-            memcpy(cast(char*)s + (es1.len + i) * sz, &v, sz);
-}
+            Port.valcpy(cast(char*)s + (es1.len + i) * sz, v, sz);
         }
         // Add terminating 0
         memset(cast(char*)s + len * sz, 0, sz);
@@ -1813,10 +1794,10 @@ extern (C++) UnionExp changeArrayLiteralLength(Loc loc, TypeArray arrayType, Exp
                 (cast(char*)s)[cast(size_t)(indxlo + elemi)] = cast(char)defaultValue;
                 break;
             case 2:
-                (cast(utf16_t*)s)[cast(size_t)(indxlo + elemi)] = cast(utf16_t)defaultValue;
+                (cast(wchar*)s)[cast(size_t)(indxlo + elemi)] = cast(wchar)defaultValue;
                 break;
             case 4:
-                (cast(utf32_t*)s)[cast(size_t)(indxlo + elemi)] = cast(utf32_t)defaultValue;
+                (cast(dchar*)s)[cast(size_t)(indxlo + elemi)] = cast(dchar)defaultValue;
                 break;
             default:
                 assert(0);
diff --git a/ddmd/dcast.d b/ddmd/dcast.d
index 66290b3596..0ace1fb600 100644
--- a/ddmd/dcast.d
+++ b/ddmd/dcast.d
@@ -360,6 +360,7 @@ extern (C++) MATCH implicitConvTo(Expression e, Type t)
             case Tchar:
                 if ((oldty == Twchar || oldty == Tdchar) && value > 0x7F)
                     return;
+                goto case Tuns8;
             case Tuns8:
                 //printf("value = %llu %llu\n", (dinteger_t)(unsigned char)value, value);
                 if (cast(ubyte)value != value)
@@ -374,6 +375,7 @@ extern (C++) MATCH implicitConvTo(Expression e, Type t)
             case Twchar:
                 if (oldty == Tdchar && value > 0xD7FF && value < 0xE000)
                     return;
+                goto case Tuns16;
             case Tuns16:
                 if (cast(ushort)value != value)
                     return;
@@ -460,6 +462,7 @@ extern (C++) MATCH implicitConvTo(Expression e, Type t)
                      */
                     break;
                 }
+                goto default;
             default:
                 visit(cast(Expression)e);
                 return;
@@ -600,7 +603,7 @@ extern (C++) MATCH implicitConvTo(Expression e, Type t)
                                 return;
                             }
                         }
-                        /* fall through */
+                        goto case; /+ fall through +/
                     case Tarray:
                     case Tpointer:
                         Type tn = t.nextOf();
@@ -1654,10 +1657,10 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                  */
                 if ((se.len + 1) * se.sz > (e.len + 1) * e.sz)
                 {
-                    void* s = cast(void*)mem.xmalloc((se.len + 1) * se.sz);
+                    void* s = mem.xmalloc((se.len + 1) * se.sz);
                     memcpy(s, se.string, se.len * se.sz);
-                    memset(cast(char*)s + se.len * se.sz, 0, se.sz);
-                    se.string = s;
+                    memset(s + se.len * se.sz, 0, se.sz);
+                    se.string = cast(char*)s;
                 }
                 result = se;
                 return;
@@ -1715,8 +1718,8 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                 case X(Tchar, Twchar):
                     for (size_t u = 0; u < e.len;)
                     {
-                        uint c;
-                        const(char)* p = utf_decodeChar(cast(char*)se.string, e.len, &u, &c);
+                        dchar c;
+                        const p = utf_decodeChar(se.string, e.len, u, c);
                         if (p)
                             e.error("%s", p);
                         else
@@ -1728,8 +1731,8 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                 case X(Tchar, Tdchar):
                     for (size_t u = 0; u < e.len;)
                     {
-                        uint c;
-                        const(char)* p = utf_decodeChar(cast(char*)se.string, e.len, &u, &c);
+                        dchar c;
+                        const p = utf_decodeChar(se.string, e.len, u, c);
                         if (p)
                             e.error("%s", p);
                         buffer.write4(c);
@@ -1740,8 +1743,8 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                 case X(Twchar, Tchar):
                     for (size_t u = 0; u < e.len;)
                     {
-                        uint c;
-                        const(char)* p = utf_decodeWchar(cast(ushort*)se.string, e.len, &u, &c);
+                        dchar c;
+                        const p = utf_decodeWchar(se.wstring, e.len, u, c);
                         if (p)
                             e.error("%s", p);
                         else
@@ -1753,8 +1756,8 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                 case X(Twchar, Tdchar):
                     for (size_t u = 0; u < e.len;)
                     {
-                        uint c;
-                        const(char)* p = utf_decodeWchar(cast(ushort*)se.string, e.len, &u, &c);
+                        dchar c;
+                        const p = utf_decodeWchar(se.wstring, e.len, u, c);
                         if (p)
                             e.error("%s", p);
                         buffer.write4(c);
@@ -1765,7 +1768,7 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                 case X(Tdchar, Tchar):
                     for (size_t u = 0; u < e.len; u++)
                     {
-                        uint c = (cast(uint*)se.string)[u];
+                        uint c = se.dstring[u];
                         if (!utf_isValidDchar(c))
                             e.error("invalid UCS-32 char \\U%08x", c);
                         else
@@ -1778,7 +1781,7 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                 case X(Tdchar, Twchar):
                     for (size_t u = 0; u < e.len; u++)
                     {
-                        uint c = (cast(uint*)se.string)[u];
+                        uint c = se.dstring[u];
                         if (!utf_isValidDchar(c))
                             e.error("invalid UCS-32 char \\U%08x", c);
                         else
@@ -1820,11 +1823,11 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                     // Copy when changing the string literal
                     size_t newsz = se.sz;
                     size_t d = (dim2 < se.len) ? dim2 : se.len;
-                    void* s = cast(void*)mem.xmalloc((dim2 + 1) * newsz);
+                    void* s = mem.xmalloc((dim2 + 1) * newsz);
                     memcpy(s, se.string, d * newsz);
                     // Extend with 0, add terminating 0
-                    memset(cast(char*)s + d * newsz, 0, (dim2 + 1 - d) * newsz);
-                    se.string = s;
+                    memset(s + d * newsz, 0, (dim2 + 1 - d) * newsz);
+                    se.string = cast(char*)s;
                     se.len = dim2;
                 }
             }
@@ -1881,7 +1884,7 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                 if (f)
                 {
                     f.tookAddressOf++;
-                    auto se = new SymOffExp(e.loc, f, 0, 0);
+                    auto se = new SymOffExp(e.loc, f, 0, false);
                     se.semantic(sc);
                     // Let SymOffExp::castTo() do the heavy lifting
                     visit(se);
@@ -1901,7 +1904,7 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                     f = f.overloadExactMatch(tb.nextOf());
                     if (f)
                     {
-                        result = new VarExp(e.loc, f);
+                        result = new VarExp(e.loc, f, false);
                         result.type = f.type;
                         result = new AddrExp(e.loc, result);
                         result.type = t;
@@ -1910,6 +1913,15 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                 }
             }
 
+            if (auto f = isFuncAddress(e))
+            {
+                if (f.checkForwardRef(e.loc))
+                {
+                    result = new ErrorExp();
+                    return;
+                }
+            }
+
             visit(cast(Expression)e);
         }
 
@@ -1922,7 +1934,7 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
             }
             TupleExp te = cast(TupleExp)e.copy();
             te.e0 = e.e0 ? e.e0.copy() : null;
-            te.exps = cast(Expressions*)e.exps.copy();
+            te.exps = e.exps.copy();
             for (size_t i = 0; i < te.exps.dim; i++)
             {
                 Expression ex = (*te.exps)[i];
@@ -2075,8 +2087,10 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                 result = e;
                 return;
             }
+
             Type tb = t.toBasetype();
             Type typeb = e.type.toBasetype();
+
             if (tb.equals(typeb))
             {
                 result = e.copy();
@@ -2084,8 +2098,11 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                 (cast(SymOffExp)result).hasOverloads = false;
                 return;
             }
+
             // Look for pointers to functions where the functions are overloaded.
-            if (e.hasOverloads && typeb.ty == Tpointer && typeb.nextOf().ty == Tfunction && (tb.ty == Tpointer || tb.ty == Tdelegate) && tb.nextOf().ty == Tfunction)
+            if (e.hasOverloads &&
+                typeb.ty == Tpointer && typeb.nextOf().ty == Tfunction &&
+                (tb.ty == Tpointer || tb.ty == Tdelegate) && tb.nextOf().ty == Tfunction)
             {
                 FuncDeclaration f = e.var.isFuncDeclaration();
                 f = f ? f.overloadExactMatch(tb.nextOf()) : null;
@@ -2095,12 +2112,12 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                     {
                         if (f.needThis() && hasThis(sc))
                         {
-                            result = new DelegateExp(e.loc, new ThisExp(e.loc), f);
+                            result = new DelegateExp(e.loc, new ThisExp(e.loc), f, false);
                             result = result.semantic(sc);
                         }
                         else if (f.isNested())
                         {
-                            result = new DelegateExp(e.loc, new IntegerExp(0), f);
+                            result = new DelegateExp(e.loc, new IntegerExp(0), f, false);
                             result = result.semantic(sc);
                         }
                         else if (f.needThis())
@@ -2118,13 +2135,23 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                     }
                     else
                     {
-                        result = new SymOffExp(e.loc, f, 0);
+                        result = new SymOffExp(e.loc, f, 0, false);
                         result.type = t;
                     }
                     f.tookAddressOf++;
                     return;
                 }
             }
+
+            if (auto f = isFuncAddress(e))
+            {
+                if (f.checkForwardRef(e.loc))
+                {
+                    result = new ErrorExp();
+                    return;
+                }
+            }
+
             visit(cast(Expression)e);
         }
 
@@ -2162,7 +2189,7 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                             e.error("%s", msg);
                         if (f != e.func)    // if address not already marked as taken
                             f.tookAddressOf++;
-                        result = new DelegateExp(e.loc, e.e1, f);
+                        result = new DelegateExp(e.loc, e.e1, f, false);
                         result.type = t;
                         return;
                     }
@@ -2171,6 +2198,15 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
                 }
             }
 
+            if (auto f = isFuncAddress(e))
+            {
+                if (f.checkForwardRef(e.loc))
+                {
+                    result = new ErrorExp();
+                    return;
+                }
+            }
+
             visit(cast(Expression)e);
         }
 
@@ -2476,23 +2512,22 @@ extern (C++) bool isVoidArrayLiteral(Expression e, Type other)
 // used by deduceType()
 extern (C++) Type rawTypeMerge(Type t1, Type t2)
 {
-    Type t1b = t1.toBasetype();
-    Type t2b = t2.toBasetype();
-
     if (t1.equals(t2))
-    {
         return t1;
-    }
-    else if (t1b.equals(t2b))
-    {
+    if (t1.equivalent(t2))
+        return t1.castMod(MODmerge(t1.mod, t2.mod));
+
+    auto t1b = t1.toBasetype();
+    auto t2b = t2.toBasetype();
+    if (t1b.equals(t2b))
         return t1b;
-    }
-    else
-    {
-        TY ty = cast(TY)impcnvResult[t1b.ty][t2b.ty];
-        if (ty != Terror)
-            return Type.basic[ty];
-    }
+    if (t1b.equivalent(t2b))
+        return t1b.castMod(MODmerge(t1b.mod, t2b.mod));
+
+    auto ty = cast(TY)impcnvResult[t1b.ty][t2b.ty];
+    if (ty != Terror)
+        return Type.basic[ty];
+
     return null;
 }
 
@@ -2508,7 +2543,7 @@ extern (C++) Type rawTypeMerge(Type t1, Type t2)
  */
 extern (C++) bool typeMerge(Scope* sc, TOK op, Type* pt, Expression* pe1, Expression* pe2)
 {
-    //printf("typeMerge() %s op %s\n", (*pe1)->toChars(), (*pe2)->toChars());
+    //printf("typeMerge() %s op %s\n", pe1.toChars(), pe2.toChars());
     MATCH m;
     Expression e1 = *pe1;
     Expression e2 = *pe2;
@@ -2804,8 +2839,8 @@ Lagain:
                 ClassDeclaration cd2 = tc2.sym.baseClass;
                 if (cd1 && cd2)
                 {
-                    t1 = cd1.type;
-                    t2 = cd2.type;
+                    t1 = cd1.type.castMod(t1.mod);
+                    t2 = cd2.type.castMod(t2.mod);
                 }
                 else if (cd1)
                     t1 = cd1.type;
diff --git a/ddmd/dclass.d b/ddmd/dclass.d
index 23bb7c7b92..a83a3c3bb3 100644
--- a/ddmd/dclass.d
+++ b/ddmd/dclass.d
@@ -8,7 +8,9 @@
 
 module ddmd.dclass;
 
+import core.stdc.stdio;
 import core.stdc.string;
+
 import ddmd.aggregate;
 import ddmd.arraytypes;
 import ddmd.gluelayer;
@@ -47,14 +49,13 @@ struct BaseClass
     // for interfaces: Array of FuncDeclaration's making up the vtbl[]
     FuncDeclarations vtbl;
 
-    size_t baseInterfaces_dim;
     // if BaseClass is an interface, these
-    // are a copy of the InterfaceDeclaration::interfaces
-    BaseClass* baseInterfaces;
+    // are a copy of the InterfaceDeclaration.interfaces
+    BaseClass[] baseInterfaces;
 
     extern (D) this(Type type, Prot protection)
     {
-        //printf("BaseClass(this = %p, '%s')\n", this, type->toChars());
+        //printf("BaseClass(this = %p, '%s')\n", this, type.toChars());
         this.type = type;
         this.protection = protection;
     }
@@ -73,7 +74,7 @@ struct BaseClass
     {
         bool result = false;
 
-        //printf("BaseClass::fillVtbl(this='%s', cd='%s')\n", sym->toChars(), cd->toChars());
+        //printf("BaseClass.fillVtbl(this='%s', cd='%s')\n", sym.toChars(), cd.toChars());
         if (vtbl)
             vtbl.setDim(sym.vtbl.dim);
 
@@ -84,7 +85,7 @@ struct BaseClass
             FuncDeclaration fd;
             TypeFunction tf;
 
-            //printf("        vtbl[%d] is '%s'\n", j, ifd ? ifd->toChars() : "null");
+            //printf("        vtbl[%d] is '%s'\n", j, ifd ? ifd.toChars() : "null");
             assert(ifd);
 
             // Find corresponding function in this class
@@ -99,6 +100,8 @@ struct BaseClass
                     fd.error("linkage doesn't match interface function");
 
                 // Check that it is current
+                //printf("newinstance = %d fd.toParent() = %s ifd.toParent() = %s\n",
+                    //newinstance, fd.toParent().toChars(), ifd.toParent().toChars());
                 if (newinstance && fd.toParent() != cd && ifd.toParent() == sym)
                     cd.error("interface function '%s' is not implemented", ifd.toFullSignature());
 
@@ -107,7 +110,7 @@ struct BaseClass
             }
             else
             {
-                //printf("            not found\n");
+                //printf("            not found %p\n", fd);
                 // BUG: should mark this class as abstract?
                 if (!cd.isAbstract())
                     cd.error("interface function '%s' is not implemented", ifd.toFullSignature());
@@ -122,13 +125,13 @@ struct BaseClass
 
     extern (C++) void copyBaseInterfaces(BaseClasses* vtblInterfaces)
     {
-        //printf("+copyBaseInterfaces(), %s\n", sym->toChars());
+        //printf("+copyBaseInterfaces(), %s\n", sym.toChars());
         //    if (baseInterfaces_dim)
         //      return;
-        baseInterfaces_dim = sym.interfaces_dim;
-        baseInterfaces = cast(BaseClass*)mem.xcalloc(baseInterfaces_dim, BaseClass.sizeof);
-        //printf("%s.copyBaseInterfaces()\n", sym->toChars());
-        for (size_t i = 0; i < baseInterfaces_dim; i++)
+        auto bc = cast(BaseClass*)mem.xcalloc(sym.interfaces.length, BaseClass.sizeof);
+        baseInterfaces = bc[0 .. sym.interfaces.length];
+        //printf("%s.copyBaseInterfaces()\n", sym.toChars());
+        for (size_t i = 0; i < baseInterfaces.length; i++)
         {
             BaseClass* b = &baseInterfaces[i];
             BaseClass* b2 = sym.interfaces[i];
@@ -177,10 +180,15 @@ struct ClassFlags
 extern (C++) class ClassDeclaration : AggregateDeclaration
 {
 public:
-    extern (C++) static __gshared ClassDeclaration object;
-    extern (C++) static __gshared ClassDeclaration throwable;
-    extern (C++) static __gshared ClassDeclaration exception;
-    extern (C++) static __gshared ClassDeclaration errorException;
+    extern (C++) __gshared
+    {
+        // Names found by reading object.d in druntime
+        ClassDeclaration object;
+        ClassDeclaration throwable;
+        ClassDeclaration exception;
+        ClassDeclaration errorException;
+        ClassDeclaration cpp_type_info_ptr;   // Object.__cpp_type_info_ptr
+    }
 
     ClassDeclaration baseClass; // NULL only if this is Object
     FuncDeclaration staticCtor;
@@ -191,9 +199,9 @@ public:
     // Array of BaseClass's; first is super, rest are Interface's
     BaseClasses* baseclasses;
 
-    // interfaces[interfaces_dim] for this class (does not include baseClass)
-    size_t interfaces_dim;
-    BaseClass** interfaces;
+    /* Slice of baseclasses[] that does not include baseClass
+     */
+    BaseClass*[] interfaces;
 
     // array of base interfaces that have their own vtbl[]
     BaseClasses* vtblInterfaces;
@@ -210,6 +218,8 @@ public:
 
     Objc_ClassDeclaration objc;
 
+    Symbol* cpp_type_info_ptr_sym;      // cached instance of class Id.cpp_type_info_ptr
+
     final extern (D) this(Loc loc, Identifier id, BaseClasses* baseclasses, bool inObject = false)
     {
         super(loc, id);
@@ -224,7 +234,7 @@ public:
         else
             this.baseclasses = new BaseClasses();
 
-        //printf("ClassDeclaration(%s), dim = %d\n", id->toChars(), this->baseclasses->dim);
+        //printf("ClassDeclaration(%s), dim = %d\n", id.toChars(), this.baseclasses.dim);
 
         // For forward references
         type = new TypeClass(this);
@@ -277,7 +287,7 @@ public:
                 if (id == Id.TypeInfo_StaticArray)
                 {
                     //if (!inObject)
-                    //    Type::typeinfostaticarray->error("%s", msg);
+                    //    Type.typeinfostaticarray.error("%s", msg);
                     Type.typeinfostaticarray = this;
                 }
                 if (id == Id.TypeInfo_AssociativeArray)
@@ -367,13 +377,19 @@ public:
                     error("%s", msg);
                 errorException = this;
             }
+            if (id == Id.cpp_type_info_ptr)
+            {
+                if (!inObject)
+                    error("%s", msg);
+                cpp_type_info_ptr = this;
+            }
         }
         baseok = BASEOKnone;
     }
 
     override Dsymbol syntaxCopy(Dsymbol s)
     {
-        //printf("ClassDeclaration::syntaxCopy('%s')\n", toChars());
+        //printf("ClassDeclaration.syntaxCopy('%s')\n", toChars());
         ClassDeclaration cd =
             s ? cast(ClassDeclaration)s
               : new ClassDeclaration(loc, ident, null);
@@ -393,9 +409,9 @@ public:
 
     override void semantic(Scope* sc)
     {
-        //printf("ClassDeclaration::semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
-        //printf("\tparent = %p, '%s'\n", sc.parent, sc.parent ? sc->parent.toChars() : "");
-        //printf("sc->stc = %x\n", sc->stc);
+        //printf("ClassDeclaration.semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
+        //printf("\tparent = %p, '%s'\n", sc.parent, sc.parent ? sc.parent.toChars() : "");
+        //printf("sc.stc = %x\n", sc.stc);
 
         //{ static int n;  if (++n == 20) *(char*)0=0; }
 
@@ -404,7 +420,7 @@ public:
         uint dprogress_save = Module.dprogress;
         int errors = global.errors;
 
-        //printf("+ClassDeclaration::semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
+        //printf("+ClassDeclaration.semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
 
         Scope* scx = null;
         if (_scope)
@@ -428,7 +444,7 @@ public:
         assert(parent && !isAnonymous());
 
         if (this.errors)
-           type = Type.terror;
+            type = Type.terror;
         type = type.semantic(loc, sc);
         if (type.ty == Tclass && (cast(TypeClass)type).sym != this)
         {
@@ -470,20 +486,42 @@ public:
 
         if (baseok < BASEOKdone)
         {
+            /* Bugzilla 12078, 12143 and 15733:
+             * While resolving base classes and interfaces, a base may refer
+             * the member of this derived class. In that time, if all bases of
+             * this class can  be determined, we can go forward the semantc process
+             * beyond the Lancestorsdone. To do the recursive semantic analysis,
+             * temporarily set and unset `_scope` around exp().
+             */
+            T resolveBase(T)(lazy T exp)
+            {
+                if (!scx)
+                {
+                    scx = sc.copy();
+                    scx.setNoFree();
+                }
+                static if (!is(T == void))
+                {
+                    _scope = scx;
+                    auto r = exp();
+                    _scope = null;
+                    return r;
+                }
+                else
+                {
+                    _scope = scx;
+                    exp();
+                    _scope = null;
+                }
+            }
+
             baseok = BASEOKin;
 
             // Expand any tuples in baseclasses[]
             for (size_t i = 0; i < baseclasses.dim;)
             {
-                _scope = scx ? scx : sc.copy();
-                _scope.setNoFree();
-
-                BaseClass* b = (*baseclasses)[i];
-                //printf("+ %s [%d] b->type = %s\n", toChars(), i, b->type->toChars());
-                b.type = b.type.semantic(loc, sc);
-                //printf("- %s [%d] b->type = %s\n", toChars(), i, b->type->toChars());
-
-                _scope = null;
+                auto b = (*baseclasses)[i];
+                b.type = resolveBase(b.type.semantic(loc, sc));
 
                 Type tb = b.type.toBasetype();
                 if (tb.ty == Ttuple)
@@ -548,17 +586,17 @@ public:
 
                 /* Bugzilla 11034: Essentially, class inheritance hierarchy
                  * and instance size of each classes are orthogonal information.
-                 * Therefore, even if tc->sym->sizeof == SIZEOKnone,
+                 * Therefore, even if tc.sym.sizeof == SIZEOKnone,
                  * we need to set baseClass field for class covariance check.
                  */
                 baseClass = tc.sym;
                 b.sym = baseClass;
 
                 if (tc.sym._scope && tc.sym.baseok < BASEOKdone)
-                    tc.sym.semantic(null); // Try to resolve forward reference
+                    resolveBase(tc.sym.semantic(null)); // Try to resolve forward reference
                 if (tc.sym.baseok < BASEOKdone)
                 {
-                    //printf("\ttry later, forward reference of base class %s\n", tc->sym->toChars());
+                    //printf("\ttry later, forward reference of base class %s\n", tc.sym.toChars());
                     if (tc.sym._scope)
                         tc.sym._scope._module.addDeferredSemantic(tc.sym);
                     baseok = BASEOKnone;
@@ -605,10 +643,10 @@ public:
                 b.sym = tc.sym;
 
                 if (tc.sym._scope && tc.sym.baseok < BASEOKdone)
-                    tc.sym.semantic(null); // Try to resolve forward reference
+                    resolveBase(tc.sym.semantic(null)); // Try to resolve forward reference
                 if (tc.sym.baseok < BASEOKdone)
                 {
-                    //printf("\ttry later, forward reference of base %s\n", tc->sym->toChars());
+                    //printf("\ttry later, forward reference of base %s\n", tc.sym.toChars());
                     if (tc.sym._scope)
                         tc.sym._scope._module.addDeferredSemantic(tc.sym);
                     baseok = BASEOKnone;
@@ -663,11 +701,9 @@ public:
                 storage_class |= baseClass.storage_class & STC_TYPECTOR;
             }
 
-            interfaces_dim = baseclasses.dim - (baseClass ? 1 : 0);
-            interfaces = baseclasses.tdata() + (baseClass ? 1 : 0);
-            for (size_t i = 0; i < interfaces_dim; i++)
+            interfaces = baseclasses.tdata()[(baseClass ? 1 : 0) .. baseclasses.dim];
+            foreach (b; interfaces)
             {
-                BaseClass* b = interfaces[i];
                 // If this is an interface, and it derives from a COM interface,
                 // then this is a COM interface too.
                 if (b.sym.isCOMinterface())
@@ -681,7 +717,7 @@ public:
             interfaceSemantic(sc);
         }
     Lancestorsdone:
-        //printf("\tClassDeclaration::semantic(%s) baseok = %d\n", toChars(), baseok);
+        //printf("\tClassDeclaration.semantic(%s) baseok = %d\n", toChars(), baseok);
 
         if (!members) // if opaque declaration
         {
@@ -726,7 +762,7 @@ public:
             for (size_t i = 0; i < members.dim; i++)
             {
                 Dsymbol s = (*members)[i];
-                //printf("[%d] setScope %s %s, sc2 = %p\n", i, s->kind(), s->toChars(), sc2);
+                //printf("[%d] setScope %s %s, sc2 = %p\n", i, s.kind(), s.toChars(), sc2);
                 s.setScope(sc2);
             }
 
@@ -758,6 +794,11 @@ public:
             // initialize vtbl
             if (baseClass)
             {
+                if (cpp && baseClass.vtbl.dim == 0)
+                {
+                    error("C++ base class %s needs at least one virtual function", baseClass.toChars());
+                }
+
                 // Copy vtbl[] from base class
                 vtbl.setDim(baseClass.vtbl.dim);
                 memcpy(vtbl.tdata(), baseClass.vtbl.tdata(), (void*).sizeof * vtbl.dim);
@@ -805,13 +846,13 @@ public:
                 makeNested();
         }
 
-        // it might be determined already, by AggregateDeclaration::size().
+        // it might be determined already, by AggregateDeclaration.size().
         if (sizeok != SIZEOKdone)
             sizeok = SIZEOKnone;
 
         Scope* sc2 = sc.push(this);
-        //sc2->stc &= ~(STCfinal | STCauto | STCscope | STCstatic | STCabstract | STCdeprecated | STC_TYPECTOR | STCtls | STCgshared);
-        //sc2->stc |= storage_class & STC_TYPECTOR;
+        //sc2.stc &= ~(STCfinal | STCauto | STCscope | STCstatic | STCabstract | STCdeprecated | STC_TYPECTOR | STCtls | STCgshared);
+        //sc2.stc |= storage_class & STC_TYPECTOR;
         sc2.stc &= STCsafe | STCtrusted | STCsystem;
         sc2.parent = this;
         sc2.inunion = 0;
@@ -832,27 +873,26 @@ public:
         sc2.structalign = STRUCTALIGN_DEFAULT;
         sc2.userAttribDecl = null;
 
-        for (size_t i = 0; i < members.dim; i++)
+        foreach (s; *members)
         {
-            Dsymbol s = (*members)[i];
             s.importAll(sc2);
         }
 
-        for (size_t i = 0; i < members.dim; i++)
+        // Note that members.dim can grow due to tuple expansion during semantic()
+        for (size_t i = 0; i < members.dim; ++i)
         {
-            Dsymbol s = (*members)[i];
+            auto s = (*members)[i];
             s.semantic(sc2);
         }
 
-        finalizeSize(sc2);
+        finalizeSize();
 
         if (sizeok == SIZEOKfwd)
         {
             // semantic() failed due to forward references
             // Unwind what we did, and defer it for later
-            for (size_t i = 0; i < fields.dim; i++)
+            foreach (v; fields)
             {
-                VarDeclaration v = fields[i];
                 v.offset = 0;
             }
             fields.setDim(0);
@@ -871,8 +911,8 @@ public:
 
         Module.dprogress++;
         semanticRun = PASSsemanticdone;
-        //printf("-ClassDeclaration::semantic(%s), type = %p\n", toChars(), type);
-        //members->print();
+        //printf("-ClassDeclaration.semantic(%s), type = %p\n", toChars(), type);
+        //members.print();
 
     version (none)  // FIXME
     {
@@ -908,7 +948,7 @@ public:
         aggNew = cast(NewDeclaration)search(Loc(), Id.classNew);
         aggDelete = cast(DeleteDeclaration)search(Loc(), Id.classDelete);
 
-        // this->ctor is already set in finalizeSize()
+        // this.ctor is already set
 
         if (!ctor && noDefaultCtor)
         {
@@ -999,7 +1039,7 @@ public:
             }
         }
         assert(type.ty != Tclass || (cast(TypeClass)type).sym == this);
-        //printf("-ClassDeclaration::semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
+        //printf("-ClassDeclaration.semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
     }
 
     /*********************************************
@@ -1010,7 +1050,7 @@ public:
     {
         if (!cd)
             return false;
-        //printf("ClassDeclaration::isBaseOf2(this = '%s', cd = '%s')\n", toChars(), cd->toChars());
+        //printf("ClassDeclaration.isBaseOf2(this = '%s', cd = '%s')\n", toChars(), cd.toChars());
         for (size_t i = 0; i < cd.baseclasses.dim; i++)
         {
             BaseClass* b = (*cd.baseclasses)[i];
@@ -1027,12 +1067,12 @@ public:
      */
     bool isBaseOf(ClassDeclaration cd, int* poffset)
     {
-        //printf("ClassDeclaration::isBaseOf(this = '%s', cd = '%s')\n", toChars(), cd->toChars());
+        //printf("ClassDeclaration.isBaseOf(this = '%s', cd = '%s')\n", toChars(), cd.toChars());
         if (poffset)
             *poffset = 0;
         while (cd)
         {
-            /* cd->baseClass might not be set if cd is forward referenced.
+            /* cd.baseClass might not be set if cd is forward referenced.
              */
             if (!cd.baseClass && cd._scope && !cd.isInterfaceDeclaration())
             {
@@ -1053,15 +1093,15 @@ public:
      * Determine if 'this' has complete base class information.
      * This is used to detect forward references in covariant overloads.
      */
-    final bool isBaseInfoComplete()
+    final bool isBaseInfoComplete() const
     {
         return baseok >= BASEOKdone;
     }
 
-    override final Dsymbol search(Loc loc, Identifier ident, int flags = IgnoreNone)
+    override final Dsymbol search(Loc loc, Identifier ident, int flags = SearchLocalsOnly)
     {
-        //printf("%s.ClassDeclaration::search('%s')\n", toChars(), ident->toChars());
-        //if (scope) printf("%s baseok = %d\n", toChars(), baseok);
+        //printf("%s.ClassDeclaration.search('%s', flags=x%x)\n", toChars(), ident.toChars(), flags);
+        //if (_scope) printf("%s baseok = %d\n", toChars(), baseok);
         if (_scope && baseok < BASEOKdone)
         {
             if (!inuse)
@@ -1080,7 +1120,7 @@ public:
             return null;
         }
 
-        Dsymbol s = ScopeDsymbol.search(loc, ident, flags);
+        Dsymbol s = ScopeDsymbol.search(loc, ident, (flags & SearchImportsOnly) ? flags : flags | SearchLocalsOnly);
         if (!s)
         {
             // Search bases classes in depth-first, left to right order
@@ -1093,10 +1133,16 @@ public:
                         error("base %s is forward referenced", b.sym.ident.toChars());
                     else
                     {
-                        s = b.sym.search(loc, ident, flags);
-                        if (s == this) // happens if s is nested in this and derives from this
+                        import ddmd.access : symbolIsVisible;
+
+                        s = b.sym.search(loc, ident, flags | SearchLocalsOnly);
+                        if (!s)
+                            continue;
+                        else if (s == this) // happens if s is nested in this and derives from this
                             s = null;
-                        else if (s)
+                        else if (!(flags & IgnoreSymbolVisibility) && !(s.prot().kind == PROTprotected) && !symbolIsVisible(this, s))
+                            s = null;
+                        else
                             break;
                     }
                 }
@@ -1105,25 +1151,32 @@ public:
         return s;
     }
 
-    final ClassDeclaration searchBase(Loc loc, Identifier ident)
+    /************************************
+     * Search base classes in depth-first, left-to-right order for
+     * a class or interface named 'ident'.
+     * Stops at first found. Does not look for additional matches.
+     * Params:
+     *  ident = identifier to search for
+     * Returns:
+     *  ClassDeclaration if found, null if not
+     */
+    final ClassDeclaration searchBase(Identifier ident)
     {
-        // Search bases classes in depth-first, left to right order
-        for (size_t i = 0; i < baseclasses.dim; i++)
+        foreach (b; *baseclasses)
         {
-            BaseClass* b = (*baseclasses)[i];
-            ClassDeclaration cdb = b.type.isClassHandle();
+            auto cdb = b.type.isClassHandle();
             if (!cdb) // Bugzilla 10616
                 return null;
             if (cdb.ident.equals(ident))
                 return cdb;
-            cdb = cdb.searchBase(loc, ident);
-            if (cdb)
-                return cdb;
+            auto result = cdb.searchBase(ident);
+            if (result)
+                return result;
         }
         return null;
     }
 
-    override void finalizeSize(Scope* sc)
+    final override void finalizeSize()
     {
         if (sizeok != SIZEOKnone)
             return;
@@ -1138,26 +1191,86 @@ public:
             if (cpp && global.params.isWindows)
                 structsize = (structsize + alignsize - 1) & ~(alignsize - 1);
         }
+        else if (isInterfaceDeclaration())
+        {
+            if (interfaces.length == 0)
+            {
+                alignsize = Target.ptrsize;
+                structsize = Target.ptrsize;      // allow room for __vptr
+            }
+        }
         else
         {
             alignsize = Target.ptrsize;
-            if (cpp)
-                structsize = Target.ptrsize; // allow room for __vptr
-            else
-                structsize = Target.ptrsize * 2; // allow room for __vptr and __monitor
+            structsize = Target.ptrsize;      // allow room for __vptr
+            if (!cpp)
+                structsize += Target.ptrsize; // allow room for __monitor
+        }
+
+        //printf("finalizeSize() %s\n", toChars());
+        size_t bi = 0;                  // index into vtblInterfaces[]
+
+        /****
+         * Runs through the inheritance graph to set the BaseClass.offset fields.
+         * Recursive in order to account for the size of the interface classes, if they are
+         * more than just interfaces.
+         * Params:
+         *      cd = interface to look at
+         *      baseOffset = offset of where cd will be placed
+         * Returns:
+         *      subset of instantiated size used by cd for interfaces
+         */
+        uint membersPlace(ClassDeclaration cd, uint baseOffset)
+        {
+            //printf("    membersPlace(%s, %d)\n", cd.toChars(), baseOffset);
+            uint offset = baseOffset;
+
+            foreach (BaseClass* b; cd.interfaces)
+            {
+                if (!b.sym.alignsize)
+                    b.sym.alignsize = Target.ptrsize;
+                alignmember(b.sym.alignsize, b.sym.alignsize, &offset);
+                assert(bi < vtblInterfaces.dim);
+                BaseClass* bv = (*vtblInterfaces)[bi];
+                if (b.sym.interfaces.length == 0)
+                {
+                    //printf("\tvtblInterfaces[%d] b=%p b.sym = %s, offset = %d\n", bi, bv, bv.sym.toChars(), offset);
+                    bv.offset = offset;
+                    ++bi;
+                    // All the base interfaces down the left side share the same offset
+                    for (BaseClass* b2 = bv; b2.baseInterfaces.length; )
+                    {
+                        b2 = &b2.baseInterfaces[0];
+                        b2.offset = offset;
+                        //printf("\tvtblInterfaces[%d] b=%p   sym = %s, offset = %d\n", bi, b2, b2.sym.toChars(), b2.offset);
+                    }
+                }
+                membersPlace(b.sym, offset);
+                //printf(" %s size = %d\n", b.sym.toChars(), b.sym.structsize);
+                offset += b.sym.structsize;
+                if (alignsize < b.sym.alignsize)
+                    alignsize = b.sym.alignsize;
+            }
+            return offset - baseOffset;
+        }
+
+        structsize += membersPlace(this, structsize);
+
+        if (isInterfaceDeclaration())
+        {
+            sizeok = SIZEOKdone;
+            return;
         }
 
         uint offset = structsize;
-        for (size_t i = 0; i < members.dim; i++)
+        foreach (s; *members)
         {
-            Dsymbol s = (*members)[i];
             s.setFieldOffset(this, &offset, false);
         }
+
         if (sizeok == SIZEOKfwd)
             return;
 
-        // Add vptr's for any interfaces implemented by this class
-        structsize += setBaseInterfaceOffsets(structsize);
         sizeok = SIZEOKdone;
 
         // Calculate fields[i].overlapped
@@ -1169,7 +1282,7 @@ public:
             ctor = null; // search() looks through ancestor classes
         if (ctor)
         {
-            // Finish all constructors semantics to determine this->noDefaultCtor.
+            // Finish all constructors semantics to determine this.noDefaultCtor.
             struct SearchCtor
             {
                 extern (C++) static int fp(Dsymbol s, void* ctxt)
@@ -1181,9 +1294,8 @@ public:
                 }
             }
 
-            for (size_t i = 0; i < members.dim; i++)
+            foreach (s; *members)
             {
-                Dsymbol s = (*members)[i];
                 s.apply(&SearchCtor.fp, null);
             }
         }
@@ -1191,13 +1303,13 @@ public:
 
     final bool isFuncHidden(FuncDeclaration fd)
     {
-        //printf("ClassDeclaration::isFuncHidden(class = %s, fd = %s)\n", toChars(), fd->toChars());
+        //printf("ClassDeclaration.isFuncHidden(class = %s, fd = %s)\n", toChars(), fd.toChars());
         Dsymbol s = search(Loc(), fd.ident, IgnoreAmbiguous | IgnoreErrors);
         if (!s)
         {
             //printf("not found\n");
             /* Because, due to a hack, if there are multiple definitions
-             * of fd->ident, NULL is returned.
+             * of fd.ident, NULL is returned.
              */
             return false;
         }
@@ -1225,28 +1337,33 @@ public:
     /****************
      * Find virtual function matching identifier and type.
      * Used to build virtual function tables for interface implementations.
+     * Params:
+     *  ident = function's identifier
+     *  tf = function's type
+     * Returns:
+     *  function symbol if found, null if not
+     * Errors:
+     *  prints error message if more than one match
      */
     final FuncDeclaration findFunc(Identifier ident, TypeFunction tf)
     {
-        //printf("ClassDeclaration::findFunc(%s, %s) %s\n", ident->toChars(), tf->toChars(), toChars());
+        //printf("ClassDeclaration.findFunc(%s, %s) %s\n", ident.toChars(), tf.toChars(), toChars());
         FuncDeclaration fdmatch = null;
         FuncDeclaration fdambig = null;
 
-        ClassDeclaration cd = this;
-        Dsymbols* vtbl = &cd.vtbl;
-        while (1)
+        void searchVtbl(ref Dsymbols vtbl)
         {
-            for (size_t i = 0; i < vtbl.dim; i++)
+            foreach (s; vtbl)
             {
-                FuncDeclaration fd = (*vtbl)[i].isFuncDeclaration();
+                auto fd = s.isFuncDeclaration();
                 if (!fd)
                     continue;
 
                 // the first entry might be a ClassInfo
-                //printf("\t[%d] = %s\n", i, fd->toChars());
+                //printf("\t[%d] = %s\n", i, fd.toChars());
                 if (ident == fd.ident && fd.type.covariant(tf) == 1)
                 {
-                    //printf("fd->parent->isClassDeclaration() = %p\n", fd->parent->isClassDeclaration());
+                    //printf("fd.parent.isClassDeclaration() = %p\n", fd.parent.isClassDeclaration());
                     if (!fdmatch)
                         goto Lfd;
                     if (fd == fdmatch)
@@ -1280,24 +1397,27 @@ public:
                     }
 
                     fdambig = fd;
-                    //printf("Lambig fdambig = %s %s [%s]\n", fdambig->toChars(), fdambig->type->toChars(), fdambig->loc.toChars());
+                    //printf("Lambig fdambig = %s %s [%s]\n", fdambig.toChars(), fdambig.type.toChars(), fdambig.loc.toChars());
                     continue;
 
                 Lfd:
                     fdmatch = fd, fdambig = null;
-                    //printf("Lfd fdmatch = %s %s [%s]\n", fdmatch->toChars(), fdmatch->type->toChars(), fdmatch->loc.toChars());
+                    //printf("Lfd fdmatch = %s %s [%s]\n", fdmatch.toChars(), fdmatch.type.toChars(), fdmatch.loc.toChars());
                     continue;
 
                 Lfdmatch:
                     continue;
                 }
-                //else printf("\t\t%d\n", fd->type->covariant(tf));
+                //else printf("\t\t%d\n", fd.type.covariant(tf));
             }
-            if (!cd)
-                break;
-            vtbl = &cd.vtblFinal;
-            cd = cd.baseClass;
         }
+
+        searchVtbl(vtbl);
+        for (auto cd = this; cd; cd = cd.baseClass)
+        {
+            searchVtbl(cd.vtblFinal);
+        }
+
         if (fdambig)
             error("ambiguous virtual function %s", fdambig.toChars());
 
@@ -1307,65 +1427,33 @@ public:
     final void interfaceSemantic(Scope* sc)
     {
         vtblInterfaces = new BaseClasses();
-        vtblInterfaces.reserve(interfaces_dim);
-        for (size_t i = 0; i < interfaces_dim; i++)
+        vtblInterfaces.reserve(interfaces.length);
+        foreach (b; interfaces)
         {
-            BaseClass* b = interfaces[i];
             vtblInterfaces.push(b);
             b.copyBaseInterfaces(vtblInterfaces);
         }
     }
 
-    final uint setBaseInterfaceOffsets(uint baseOffset)
-    {
-        assert(vtblInterfaces); // Bugzilla 12984
-
-        // set the offset of base interfaces from this (most derived) class/interface.
-        uint offset = baseOffset;
-
-        //if (vtblInterfaces->dim) printf("\n%s->finalizeSize()\n", toChars());
-        for (size_t i = 0; i < vtblInterfaces.dim; i++)
-        {
-            BaseClass* b = (*vtblInterfaces)[i];
-            uint thissize = Target.ptrsize;
-
-            alignmember(STRUCTALIGN_DEFAULT, thissize, &offset);
-            b.offset = offset;
-            //printf("\tvtblInterfaces[%d] b->sym = %s, offset = %d\n", i, b->sym->toChars(), b->offset);
-
-            // Take care of single inheritance offsets
-            while (b.baseInterfaces_dim)
-            {
-                b = &b.baseInterfaces[0];
-                b.offset = offset;
-                //printf("\tvtblInterfaces[%d] +  sym = %s, offset = %d\n", i, b->sym->toChars(), b->offset);
-            }
-
-            offset += thissize;
-            if (alignsize < thissize)
-                alignsize = thissize;
-        }
-        return offset - baseOffset;
-    }
 
     /****************************************
      */
-    final bool isCOMclass()
+    final bool isCOMclass() const
     {
         return com;
     }
 
-    bool isCOMinterface()
+    bool isCOMinterface() const
     {
         return false;
     }
 
-    final bool isCPPclass()
+    final bool isCPPclass() const
     {
         return cpp;
     }
 
-    bool isCPPinterface()
+    bool isCPPinterface() const
     {
         return false;
     }
@@ -1398,14 +1486,14 @@ public:
      *      0       vtbl[0] is first virtual function pointer
      *      1       vtbl[0] is classinfo/interfaceinfo pointer
      */
-    int vtblOffset()
+    int vtblOffset() const
     {
         return cpp ? 0 : 1;
     }
 
     /****************************************
      */
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "class";
     }
@@ -1420,9 +1508,9 @@ public:
     // Back end
     Symbol* vtblsym;
 
-    override final ClassDeclaration isClassDeclaration()
+    override final inout(ClassDeclaration) isClassDeclaration() inout
     {
-        return cast(ClassDeclaration)this;
+        return this;
     }
 
     override void accept(Visitor v)
@@ -1456,7 +1544,7 @@ public:
 
     override void semantic(Scope* sc)
     {
-        //printf("InterfaceDeclaration::semantic(%s), type = %p\n", toChars(), type);
+        //printf("InterfaceDeclaration.semantic(%s), type = %p\n", toChars(), type);
         if (semanticRun >= PASSsemanticdone)
             return;
         int errors = global.errors;
@@ -1477,7 +1565,7 @@ public:
         assert(parent && !isAnonymous());
 
         if (this.errors)
-           type = Type.terror;
+            type = Type.terror;
         type = type.semantic(loc, sc);
         if (type.ty == Tclass && (cast(TypeClass)type).sym != this)
         {
@@ -1511,18 +1599,35 @@ public:
 
         if (baseok < BASEOKdone)
         {
+            T resolveBase(T)(lazy T exp)
+            {
+                if (!scx)
+                {
+                    scx = sc.copy();
+                    scx.setNoFree();
+                }
+                static if (!is(T == void))
+                {
+                    _scope = scx;
+                    auto r = exp();
+                    _scope = null;
+                    return r;
+                }
+                else
+                {
+                    _scope = scx;
+                    exp();
+                    _scope = null;
+                }
+            }
+
             baseok = BASEOKin;
 
             // Expand any tuples in baseclasses[]
             for (size_t i = 0; i < baseclasses.dim;)
             {
-                _scope = scx ? scx : sc.copy();
-                _scope.setNoFree();
-
-                BaseClass* b = (*baseclasses)[i];
-                b.type = b.type.semantic(loc, sc);
-
-                _scope = null;
+                auto b = (*baseclasses)[i];
+                b.type = resolveBase(b.type.semantic(loc, sc));
 
                 Type tb = b.type.toBasetype();
                 if (tb.ty == Ttuple)
@@ -1599,10 +1704,10 @@ public:
                 b.sym = tc.sym;
 
                 if (tc.sym._scope && tc.sym.baseok < BASEOKdone)
-                    tc.sym.semantic(null); // Try to resolve forward reference
+                    resolveBase(tc.sym.semantic(null)); // Try to resolve forward reference
                 if (tc.sym.baseok < BASEOKdone)
                 {
-                    //printf("\ttry later, forward reference of base %s\n", tc->sym->toChars());
+                    //printf("\ttry later, forward reference of base %s\n", tc.sym.toChars());
                     if (tc.sym._scope)
                         tc.sym._scope._module.addDeferredSemantic(tc.sym);
                     baseok = BASEOKnone;
@@ -1619,11 +1724,9 @@ public:
             }
             baseok = BASEOKdone;
 
-            interfaces_dim = baseclasses.dim;
-            interfaces = baseclasses.tdata();
-            for (size_t i = 0; i < interfaces_dim; i++)
+            interfaces = baseclasses.tdata()[0 .. baseclasses.dim];
+            foreach (b; interfaces)
             {
-                BaseClass* b = interfaces[i];
                 // If this is an interface, and it derives from a COM interface,
                 // then this is a COM interface too.
                 if (b.sym.isCOMinterface())
@@ -1671,10 +1774,8 @@ public:
                 vtbl.push(this); // leave room at vtbl[0] for classinfo
 
             // Cat together the vtbl[]'s from base interfaces
-            for (size_t i = 0; i < interfaces_dim; i++)
+            foreach (i, b; interfaces)
             {
-                BaseClass* b = interfaces[i];
-
                 // Skip if b has already appeared
                 for (size_t k = 0; k < i; k++)
                 {
@@ -1723,15 +1824,13 @@ public:
         sc2.structalign = STRUCTALIGN_DEFAULT;
         sc2.userAttribDecl = null;
 
-        finalizeSize(sc2);
-
         /* Set scope so if there are forward references, we still might be able to
          * resolve individual members like enums.
          */
         for (size_t i = 0; i < members.dim; i++)
         {
             Dsymbol s = (*members)[i];
-            //printf("setScope %s %s\n", s->kind(), s->toChars());
+            //printf("setScope %s %s\n", s.kind(), s.toChars());
             s.setScope(sc2);
         }
 
@@ -1747,6 +1846,8 @@ public:
             s.semantic(sc2);
         }
 
+        finalizeSize();
+
         semanticRun = PASSsemanticdone;
 
         if (global.errors != errors)
@@ -1755,10 +1856,10 @@ public:
             type = Type.terror;
         }
 
-        //members->print();
+        //members.print();
         sc2.pop();
 
-        //printf("-InterfaceDeclaration::semantic(%s), type = %p\n", toChars(), type);
+        //printf("-InterfaceDeclaration.semantic(%s), type = %p\n", toChars(), type);
 
         version (none)
         {
@@ -1771,14 +1872,6 @@ public:
         assert(type.ty != Tclass || (cast(TypeClass)type).sym == this);
     }
 
-    override void finalizeSize(Scope* sc)
-    {
-        structsize = Target.ptrsize * 2;
-        sizeok = SIZEOKdone;
-
-        // set the offset of base interfaces
-        setBaseInterfaceOffsets(0);
-    }
 
     /*******************************************
      * Determine if 'this' is a base class of cd.
@@ -1792,38 +1885,20 @@ public:
      */
     override bool isBaseOf(ClassDeclaration cd, int* poffset)
     {
-        //printf("%s.InterfaceDeclaration::isBaseOf(cd = '%s')\n", toChars(), cd->toChars());
+        //printf("%s.InterfaceDeclaration.isBaseOf(cd = '%s')\n", toChars(), cd.toChars());
         assert(!baseClass);
-        for (size_t j = 0; j < cd.interfaces_dim; j++)
+        foreach (j, b; cd.interfaces)
         {
-            BaseClass* b = cd.interfaces[j];
-            //printf("\tX base %s\n", b->sym->toChars());
+            //printf("\tX base %s\n", b.sym.toChars());
             if (this == b.sym)
             {
-                //printf("\tfound at offset %d\n", b->offset);
+                //printf("\tfound at offset %d\n", b.offset);
                 if (poffset)
-                {
                     *poffset = b.offset;
-                    if (j && cd.isInterfaceDeclaration())
-                        *poffset = OFFSET_RUNTIME;
-
-                    /* TODO: Even though it's an interface to base interface upcast,
-                     * I think we can avoid runtime offset determination ultimately.
-                     * (I doubt that it was just a workaround for the bug in the
-                     * inferface to Object downcast)
-                     */
-                }
                 return true;
             }
             if (isBaseOf(b, poffset))
-            {
-                if (poffset)
-                {
-                    if (j && cd.isInterfaceDeclaration())
-                        *poffset = OFFSET_RUNTIME;
-                }
                 return true;
-            }
         }
         if (cd.baseClass && isBaseOf(cd.baseClass, poffset))
             return true;
@@ -1835,14 +1910,14 @@ public:
 
     bool isBaseOf(BaseClass* bc, int* poffset)
     {
-        //printf("%s.InterfaceDeclaration::isBaseOf(bc = '%s')\n", toChars(), bc->sym->toChars());
-        for (size_t j = 0; j < bc.baseInterfaces_dim; j++)
+        //printf("%s.InterfaceDeclaration.isBaseOf(bc = '%s')\n", toChars(), bc.sym.toChars());
+        for (size_t j = 0; j < bc.baseInterfaces.length; j++)
         {
             BaseClass* b = &bc.baseInterfaces[j];
-            //printf("\tY base %s\n", b->sym->toChars());
+            //printf("\tY base %s\n", b.sym.toChars());
             if (this == b.sym)
             {
-                //printf("\tfound at offset %d\n", b->offset);
+                //printf("\tfound at offset %d\n", b.offset);
                 if (poffset)
                 {
                     *poffset = b.offset;
@@ -1862,7 +1937,7 @@ public:
 
     /*******************************************
      */
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "interface";
     }
@@ -1873,24 +1948,24 @@ public:
      * For COM interfaces, no.
      * For non-COM interfaces, yes, this is where the Interface ptr goes.
      */
-    override int vtblOffset()
+    override int vtblOffset() const
     {
         if (isCOMinterface() || isCPPinterface())
             return 0;
         return 1;
     }
 
-    override bool isCPPinterface()
+    override bool isCPPinterface() const
     {
         return cpp;
     }
 
-    override bool isCOMinterface()
+    override bool isCOMinterface() const
     {
         return com;
     }
 
-    override InterfaceDeclaration isInterfaceDeclaration()
+    override inout(InterfaceDeclaration) isInterfaceDeclaration() inout
     {
         return this;
     }
diff --git a/ddmd/declaration.d b/ddmd/declaration.d
index bafe624b55..6b53a1325c 100644
--- a/ddmd/declaration.d
+++ b/ddmd/declaration.d
@@ -55,27 +55,9 @@ extern (C++) bool checkFrameAccess(Loc loc, Scope* sc, AggregateDeclaration ad,
     Dsymbol s = sc.func;
     if (ad.isNested() && s)
     {
-        //printf("ad = %p %s [%s], parent:%p\n", ad, ad->toChars(), ad->loc.toChars(), ad->parent);
-        //printf("sparent = %p %s [%s], parent: %s\n", sparent, sparent->toChars(), sparent->loc.toChars(), sparent->parent->toChars());
-        while (s)
-        {
-            if (s == sparent) // hit!
-                break;
-            if (FuncDeclaration fd = s.isFuncDeclaration())
-            {
-                if (!fd.isThis() && !fd.isNested())
-                    break;
-                if (FuncLiteralDeclaration fld = fd.isFuncLiteralDeclaration())
-                    fld.tok = TOKdelegate;
-            }
-            if (AggregateDeclaration ad2 = s.isAggregateDeclaration())
-            {
-                if (ad2.storage_class & STCstatic)
-                    break;
-            }
-            s = s.toParent2();
-        }
-        if (s != sparent)
+        //printf("ad = %p %s [%s], parent:%p\n", ad, ad.toChars(), ad.loc.toChars(), ad.parent);
+        //printf("sparent = %p %s [%s], parent: %s\n", sparent, sparent.toChars(), sparent.loc.toChars(), sparent.parent,toChars());
+        if (checkNestedRef(s, sparent))
         {
             error(loc, "cannot access frame pointer of %s", ad.toPrettyChars());
             return true;
@@ -209,7 +191,7 @@ public:
     {
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "declaration";
     }
@@ -252,7 +234,7 @@ public:
         return 1;
     }
 
-    override final Dsymbol search(Loc loc, Identifier ident, int flags = IgnoreNone)
+    override final Dsymbol search(Loc loc, Identifier ident, int flags = SearchLocalsOnly)
     {
         Dsymbol s = Dsymbol.search(loc, ident, flags);
         if (!s && type)
@@ -379,7 +361,7 @@ public:
         return protection;
     }
 
-    override final Declaration isDeclaration()
+    override final inout(Declaration) isDeclaration() inout
     {
         return this;
     }
@@ -411,7 +393,7 @@ public:
         assert(0);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "tuple";
     }
@@ -528,7 +510,7 @@ version(IN_LLVM)
     }
 }
 
-    override TupleDeclaration isTupleDeclaration()
+    override inout(TupleDeclaration) isTupleDeclaration() inout
     {
         return this;
     }
@@ -609,9 +591,11 @@ public:
             return;
         }
         inuse = 1;
+
         storage_class |= sc.stc & STCdeprecated;
         protection = sc.protection;
         userAttribDecl = sc.userAttribDecl;
+
         // Given:
         //  alias foo.bar.abc def;
         // it is not knowable from the syntax whether this is an alias
@@ -620,11 +604,10 @@ public:
         // If it is a type, then type is set and getType() will return that
         // type. If it is a symbol, then aliassym is set and type is NULL -
         // toAlias() will return aliasssym.
+
         uint errors = global.errors;
-        Type savedtype = type;
-        Dsymbol s;
-        Type t;
-        Expression e;
+        Type oldtype = type;
+
         // Ungag errors when not instantiated DeclDefs scope alias
         auto ungag = Ungag(global.gag);
         //printf("%s parent = %s, gag = %d, instantiated = %d\n", toChars(), parent, global.gag, isInstantiated());
@@ -633,12 +616,13 @@ public:
             //printf("%s type = %s\n", toPrettyChars(), type->toChars());
             global.gag = 0;
         }
-        /* This section is needed because resolve() will:
+
+        /* This section is needed because Type.resolve() will:
          *   const x = 3;
-         *   alias x y;
-         * try to alias y to 3.
+         *   alias y = x;
+         * try to convert identifier x to 3.
          */
-        s = type.toDsymbol(sc);
+        auto s = type.toDsymbol(sc);
         if (errors != global.errors)
         {
             s = null;
@@ -650,127 +634,67 @@ public:
             s = null;
             type = Type.terror;
         }
-        if (s && ((s.getType() && type.equals(s.getType())) || s.isEnumMember()))
-            goto L2;
-        // it's a symbolic alias
-        type = type.addSTC(storage_class);
-        if (storage_class & (STCref | STCnothrow | STCnogc | STCpure | STCdisable))
+        if (!s || !s.isEnumMember())
         {
-            // For 'ref' to be attached to function types, and picked
-            // up by Type::resolve(), it has to go into sc.
-            sc = sc.push();
-            sc.stc |= storage_class & (STCref | STCnothrow | STCnogc | STCpure | STCshared | STCdisable);
-            type.resolve(loc, sc, &e, &t, &s);
-            sc = sc.pop();
-        }
-        else
-            type.resolve(loc, sc, &e, &t, &s);
-        if (s)
-        {
-            goto L2;
-        }
-        else if (e)
-        {
-            // Try to convert Expression to Dsymbol
-            s = getDsymbol(e);
-            if (s)
-                goto L2;
-            if (e.op != TOKerror)
-                error("cannot alias an expression %s", e.toChars());
-            t = e.type;
-        }
-        else if (t)
-        {
-            type = t.semantic(loc, sc);
-            //printf("\talias resolved to type %s\n", type->toChars());
-        }
-        if (overnext)
-            ScopeDsymbol.multiplyDefined(Loc(), overnext, this);
-        inuse = 0;
-        if (global.gag && errors != global.errors)
-            type = savedtype;
+            Type t;
+            Expression e;
+            Scope* sc2 = sc;
+            if (storage_class & (STCref | STCnothrow | STCnogc | STCpure | STCdisable))
+            {
+                // For 'ref' to be attached to function types, and picked
+                // up by Type.resolve(), it has to go into sc.
+                sc2 = sc.push();
+                sc2.stc |= storage_class & (STCref | STCnothrow | STCnogc | STCpure | STCshared | STCdisable);
+            }
+            type = type.addSTC(storage_class);
+            type.resolve(loc, sc2, &e, &t, &s);
+            if (sc2 != sc)
+                sc2.pop();
 
-        semanticRun = PASSsemanticdone;
-        return;
-    L2:
-        //printf("alias is a symbol %s %s\n", s->kind(), s->toChars());
-        type = null;
-        VarDeclaration v = s.isVarDeclaration();
-        if (0 && v && v.linkage == LINKdefault)
+            if (e)  // Try to convert Expression to Dsymbol
+            {
+                s = getDsymbol(e);
+                if (!s)
+                {
+                    if (e.op != TOKerror)
+                        error("cannot alias an expression %s", e.toChars());
+                    t = Type.terror;
+                }
+            }
+            type = t;
+        }
+        if (s == this)
         {
-            error("forward reference of %s", v.toChars());
+            assert(global.errors);
+            type = Type.terror;
             s = null;
         }
-        else
+        if (!s) // it's a type alias
         {
-            Dsymbol savedovernext = overnext;
-            Dsymbol sa = s.toAlias();
-            if (FuncDeclaration fd = sa.isFuncDeclaration())
-            {
-                if (overnext)
-                {
-                    auto fa = new FuncAliasDeclaration(ident, fd);
-                    if (!fa.overloadInsert(overnext))
-                        ScopeDsymbol.multiplyDefined(Loc(), overnext, fd);
-                    overnext = null;
-                    s = fa;
-                    s.parent = sc.parent;
-                }
-            }
-            else if (TemplateDeclaration td = sa.isTemplateDeclaration())
-            {
-                if (overnext)
-                {
-                    auto od = new OverDeclaration(ident, td);
-                    if (!od.overloadInsert(overnext))
-                        ScopeDsymbol.multiplyDefined(Loc(), overnext, td);
-                    overnext = null;
-                    s = od;
-                    s.parent = sc.parent;
-                }
-            }
-            else if (OverDeclaration od = sa.isOverDeclaration())
-            {
-                if (overnext)
-                {
-                    auto od2 = new OverDeclaration(ident, od);
-                    if (!od2.overloadInsert(overnext))
-                        ScopeDsymbol.multiplyDefined(Loc(), overnext, od);
-                    overnext = null;
-                    s = od2;
-                    s.parent = sc.parent;
-                }
-            }
-            else if (OverloadSet os = sa.isOverloadSet())
-            {
-                if (overnext)
-                {
-                    os = new OverloadSet(ident, os);
-                    os.push(overnext);
-                    overnext = null;
-                    s = os;
-                    s.parent = sc.parent;
-                }
-            }
-            if (overnext)
-                ScopeDsymbol.multiplyDefined(Loc(), overnext, this);
-            if (s == this)
-            {
-                assert(global.errors);
-                s = null;
-            }
-            if (global.gag && errors != global.errors)
-            {
-                type = savedtype;
-                overnext = savedovernext;
-                s = null;
-            }
+            //printf("alias %s resolved to type %s\n", toChars(), type.toChars());
+            type = type.semantic(loc, sc);
+            aliassym = null;
+        }
+        else    // it's a symbolic alias
+        {
+            //printf("alias %s resolved to %s %s\n", toChars(), s.kind(), s.toChars());
+            type = null;
+            aliassym = s;
+        }
+        if (global.gag && errors != global.errors)
+        {
+            type = oldtype;
+            aliassym = null;
         }
-        //printf("setting aliassym %s to %s %s\n", toChars(), s->kind(), s->toChars());
-        aliassym = s;
         inuse = 0;
-
         semanticRun = PASSsemanticdone;
+
+        if (auto sx = overnext)
+        {
+            overnext = null;
+            if (!overloadInsert(sx))
+                ScopeDsymbol.multiplyDefined(Loc(), sx, this);
+        }
     }
 
     override bool overloadInsert(Dsymbol s)
@@ -789,19 +713,40 @@ public:
             /* When s is added in member scope by static if, mixin("code") or others,
              * aliassym is determined already. See the case in: test/compilable/test61.d
              */
-            Dsymbol sa = aliassym.toAlias();
+            auto sa = aliassym.toAlias();
             if (auto fd = sa.isFuncDeclaration())
             {
-                auto fa = new FuncAliasDeclaration(ident, fd);
-                aliassym = fa;
-                return fa.overloadInsert(s);
+                aliassym = new FuncAliasDeclaration(ident, fd);
+                aliassym.parent = parent;
+                return aliassym.overloadInsert(s);
             }
             if (auto td = sa.isTemplateDeclaration())
             {
-                auto od = new OverDeclaration(ident, td);
-                aliassym = od;
+                aliassym = new OverDeclaration(ident, td);
+                aliassym.parent = parent;
+                return aliassym.overloadInsert(s);
+            }
+            if (auto od = sa.isOverDeclaration())
+            {
+                if (sa.ident != ident || sa.parent != parent)
+                {
+                    od = new OverDeclaration(ident, od);
+                    od.parent = parent;
+                    aliassym = od;
+                }
                 return od.overloadInsert(s);
             }
+            if (auto os = sa.isOverloadSet())
+            {
+                if (sa.ident != ident || sa.parent != parent)
+                {
+                    os = new OverloadSet(ident, os);
+                    os.parent = parent;
+                    aliassym = os;
+                }
+                os.push(s);
+                return true;
+            }
             return false;
         }
 
@@ -816,7 +761,7 @@ public:
         return true;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "alias";
     }
@@ -831,7 +776,7 @@ public:
     override Dsymbol toAlias()
     {
         //printf("[%s] AliasDeclaration::toAlias('%s', this = %p, aliassym = %p, kind = '%s', inuse = %d)\n",
-        //    loc.toChars(), toChars(), this, aliassym, aliassym ? aliassym->kind() : "", inuse);
+        //    loc.toChars(), toChars(), this, aliassym, aliassym ? aliassym.kind() : "", inuse);
         assert(this != aliassym);
         //static int count; if (++count == 10) *(char*)0=0;
         if (inuse == 1 && type && _scope)
@@ -872,9 +817,12 @@ public:
             type = Type.terror;
             return aliassym;
         }
-        if (aliassym || type.deco)
+        if (aliassym)
         {
             // semantic is already done.
+
+            // Even if type.deco !is null, "alias T = const int;` needs semantic
+            // call to take the storage class `const` as type qualifier.
         }
         else if (_import && _import._scope)
         {
@@ -884,7 +832,9 @@ public:
             _import.semantic(null);
         }
         else if (_scope)
+        {
             semantic(_scope);
+        }
         inuse = 1;
         Dsymbol s = aliassym ? aliassym.toAlias() : this;
         inuse = 0;
@@ -904,7 +854,7 @@ public:
         return s;
     }
 
-    override AliasDeclaration isAliasDeclaration()
+    override inout(AliasDeclaration) isAliasDeclaration() inout
     {
         return this;
     }
@@ -941,7 +891,7 @@ public:
         }
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "overload alias"; // todo
     }
@@ -981,24 +931,12 @@ public:
     override bool overloadInsert(Dsymbol s)
     {
         //printf("OverDeclaration::overloadInsert('%s') aliassym = %p, overnext = %p\n", s->toChars(), aliassym, overnext);
-        if (overnext is null)
-        {
-            if (s == this)
-            {
-                return true;
-            }
-            overnext = s;
-            return true;
-        }
-        else
-        {
+        if (overnext)
             return overnext.overloadInsert(s);
-        }
-    }
-
-    override Dsymbol toAlias()
-    {
-        return this;
+        if (s == this)
+            return true;
+        overnext = s;
+        return true;
     }
 
     Dsymbol isUnique()
@@ -1029,7 +967,7 @@ public:
         return result;
     }
 
-    override OverDeclaration isOverDeclaration()
+    override inout(OverDeclaration) isOverDeclaration() inout
     {
         return this;
     }
@@ -1047,7 +985,7 @@ extern (C++) class VarDeclaration : Declaration
 public:
     Initializer _init;
     uint offset;
-    bool noscope;                   // no auto semantics
+    bool noscope;                   // if scope destruction is disabled
     FuncDeclarations nestedrefs;    // referenced by these lexically nested functions
     bool isargptr;                  // if parameter that _argptr points to
     structalign_t alignment;
@@ -1331,6 +1269,7 @@ public:
                         te.exps.push(new ErrorExp());
                 }
             }
+
             auto exps = new Objects();
             exps.setDim(nelems);
             for (size_t i = 0; i < nelems; i++)
@@ -1338,8 +1277,8 @@ public:
                 Parameter arg = Parameter.getNth(tt.arguments, i);
                 OutBuffer buf;
                 buf.printf("__%s_field_%llu", ident.toChars(), cast(ulong)i);
-                const(char)* name = buf.extractString();
-                Identifier id = Identifier.idPool(name);
+                auto id = Identifier.idPool(buf.peekSlice());
+
                 Initializer ti;
                 if (ie)
                 {
@@ -1355,18 +1294,22 @@ public:
                 }
                 else
                     ti = _init ? _init.syntaxCopy() : null;
+
                 auto v = new VarDeclaration(loc, arg.type, id, ti);
                 v.storage_class |= STCtemp | storage_class;
                 if (arg.storageClass & STCparameter)
                     v.storage_class |= arg.storageClass;
                 //printf("declaring field %s of type %s\n", v->toChars(), v->type->toChars());
                 v.semantic(sc);
+
                 if (sc.scopesym)
                 {
                     //printf("adding %s to %s\n", v->toChars(), sc->scopesym->toChars());
                     if (sc.scopesym.members)
+                        // Note this prevents using foreach() over members, because the limits can change
                         sc.scopesym.members.push(v);
                 }
+
                 Expression e = new DsymbolExp(loc, v);
                 (*exps)[i] = e;
             }
@@ -1540,17 +1483,17 @@ public:
             // Provide a default initializer
 
             //printf("Providing default initializer for '%s'\n", toChars());
-            if (type.needsNested())
-            {
-                Type tv = type;
-                while (tv.toBasetype().ty == Tsarray)
-                    tv = tv.toBasetype().nextOf();
-                assert(tv.toBasetype().ty == Tstruct);
 
+            Type tv = type;
+            while (tv.ty == Tsarray)    // Don't skip Tenum
+                tv = tv.nextOf();
+            if (tv.needsNested())
+            {
                 /* Nested struct requires valid enclosing frame pointer.
                  * In StructLiteralExp::toElem(), it's calculated.
                  */
-                checkFrameAccess(loc, sc, (cast(TypeStruct)tv.toBasetype()).sym);
+                assert(tbn.ty == Tstruct);
+                checkFrameAccess(loc, sc, (cast(TypeStruct)tbn).sym);
 
                 Expression e = tv.defaultInitLiteral(loc);
                 e = new BlitExp(loc, new VarExp(loc, this), e);
@@ -1558,8 +1501,7 @@ public:
                 _init = new ExpInitializer(loc, e);
                 goto Ldtor;
             }
-            if (type.ty == Tstruct &&
-                (cast(TypeStruct)type).sym.zeroInit == 1)
+            if (tv.ty == Tstruct && (cast(TypeStruct)tv).sym.zeroInit == 1)
             {
                 /* If a struct is all zeros, as a special case
                  * set it's initializer to the integer 0.
@@ -1577,9 +1519,9 @@ public:
             {
                 error("%s does not have a default initializer", type.toChars());
             }
-            else
+            else if (auto e = type.defaultInit(loc))
             {
-                _init = getExpInitializer();
+                _init = new ExpInitializer(loc, e);
             }
 
             // Default initializer is always a blit
@@ -1768,7 +1710,7 @@ public:
 
     override final void setFieldOffset(AggregateDeclaration ad, uint* poffset, bool isunion)
     {
-        //printf("VarDeclaration::setFieldOffset(ad = %s) %s\n", ad->toChars(), toChars());
+        //printf("VarDeclaration::setFieldOffset(ad = %s) %s\n", ad.toChars(), toChars());
         if (aliassym)
         {
             // If this variable was really a tuple, set the offsets for the tuple fields
@@ -1839,16 +1781,19 @@ public:
             ad.sizeok = SIZEOKfwd; // cannot finish; flag as forward referenced
             return;
         }
-        // List in ad->fields. Even if the type is error, it's necessary to avoid
+
+        // List in ad.fields. Even if the type is error, it's necessary to avoid
         // pointless error diagnostic "more initializers than fields" on struct literal.
         ad.fields.push(this);
+
         if (t.ty == Terror)
             return;
+
         uint memsize = cast(uint)t.size(loc); // size of member
         uint memalignsize = Target.fieldalign(t); // size of member for alignment purposes
         offset = AggregateDeclaration.placeField(poffset, memsize, memalignsize, alignment, &ad.structsize, &ad.alignsize, isunion);
         //printf("\t%s: memalignsize = %d\n", toChars(), memalignsize);
-        //printf(" addField '%s' to '%s' at offset %d, size = %d\n", toChars(), ad->toChars(), offset, memsize);
+        //printf(" addField '%s' to '%s' at offset %d, size = %d\n", toChars(), ad.toChars(), offset, memsize);
     }
 
     override final void semantic2(Scope* sc)
@@ -1951,7 +1896,7 @@ public:
         sem = Semantic2Done;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "variable";
     }
@@ -2060,12 +2005,10 @@ public:
     /******************************************
      * Return true if variable needs to call the destructor.
      */
-    final bool needsAutoDtor()
+    final bool needsScopeDtor()
     {
-        //printf("VarDeclaration::needsAutoDtor() %s\n", toChars());
-        if (noscope || !edtor)
-            return false;
-        return true;
+        //printf("VarDeclaration::needsScopeDtor() %s\n", toChars());
+        return edtor && !noscope;
     }
 
     /******************************************
@@ -2097,7 +2040,7 @@ public:
                  * fix properly.
                  */
                 e.type = e.type.mutableOf();
-                e = new DotVarExp(loc, e, sd.dtor, 0);
+                e = new DotVarExp(loc, e, sd.dtor, false);
                 e = new CallExp(loc, e);
             }
             else
@@ -2145,25 +2088,6 @@ public:
         return e;
     }
 
-    /****************************
-     * Get ExpInitializer for a variable, if there is one.
-     */
-    final ExpInitializer getExpInitializer()
-    {
-        ExpInitializer ei;
-        if (_init)
-            ei = _init.isExpInitializer();
-        else
-        {
-            Expression e = type.defaultInit(loc);
-            if (e)
-                ei = new ExpInitializer(loc, e);
-            else
-                ei = null;
-        }
-        return ei;
-    }
-
     /*******************************************
      * If variable has a constant expression initializer, get it.
      * Otherwise, return null.
@@ -2237,91 +2161,80 @@ public:
             return false;
         if (isDataseg() || (storage_class & STCmanifest))
             return false;
+
         // The current function
         FuncDeclaration fdthis = sc.parent.isFuncDeclaration();
         if (!fdthis)
             return false; // out of function scope
+
         Dsymbol p = toParent2();
+
         // Function literals from fdthis to p must be delegates
-        // TODO: here is similar to checkFrameAccess.
-        for (Dsymbol s = fdthis; s && s != p; s = s.toParent2())
+        checkNestedRef(fdthis, p);
+
+        // The function that this variable is in
+        FuncDeclaration fdv = p.isFuncDeclaration();
+        if (!fdv || fdv == fdthis)
+            return false;
+
+        // Add fdthis to nestedrefs[] if not already there
+        for (size_t i = 0; 1; i++)
         {
-            // function literal has reference to enclosing scope is delegate
-            if (FuncLiteralDeclaration fld = s.isFuncLiteralDeclaration())
-                fld.tok = TOKdelegate;
-            if (FuncDeclaration fd = s.isFuncDeclaration())
+            if (i == nestedrefs.dim)
             {
-                if (!fd.isThis() && !fd.isNested())
-                    break;
-            }
-            if (AggregateDeclaration ad2 = s.isAggregateDeclaration())
-            {
-                if (ad2.storage_class & STCstatic)
-                    break;
+                nestedrefs.push(fdthis);
+                break;
             }
+            if (nestedrefs[i] == fdthis)
+                break;
         }
-        if (1)
+
+        /* __require and __ensure will always get called directly,
+         * so they never make outer functions closure.
+         */
+        if (fdthis.ident == Id.require || fdthis.ident == Id.ensure)
+            return false;
+
+        //printf("\tfdv = %s\n", fdv.toChars());
+        //printf("\tfdthis = %s\n", fdthis.toChars());
+        if (loc.filename)
         {
-            // The function that this variable is in
-            FuncDeclaration fdv = p.isFuncDeclaration();
-            if (fdv && fdv != fdthis)
-            {
-                // Add fdthis to nestedrefs[] if not already there
-                for (size_t i = 0; 1; i++)
-                {
-                    if (i == nestedrefs.dim)
-                    {
-                        nestedrefs.push(fdthis);
-                        break;
-                    }
-                    if (nestedrefs[i] == fdthis)
-                        break;
-                }
-                if (fdthis.ident != Id.require && fdthis.ident != Id.ensure)
-                {
-                    /* __require and __ensure will always get called directly,
-                     * so they never make outer functions closure.
-                     */
-                    //printf("\tfdv = %s\n", fdv->toChars());
-                    //printf("\tfdthis = %s\n", fdthis->toChars());
-                    if (loc.filename)
-                    {
-                        int lv = fdthis.getLevel(loc, sc, fdv);
-                        if (lv == -2) // error
-                            return true;
-                    }
-                    // Add this to fdv->closureVars[] if not already there
-                    for (size_t i = 0; 1; i++)
-                    {
-                        if (i == fdv.closureVars.dim)
-                        {
-                            if (!sc.intypeof && !(sc.flags & SCOPEcompile))
-                                fdv.closureVars.push(this);
-                            break;
-                        }
-                        if (fdv.closureVars[i] == this)
-                            break;
-                    }
-                    //printf("fdthis is %s\n", fdthis->toChars());
-                    //printf("var %s in function %s is nested ref\n", toChars(), fdv->toChars());
-                    // __dollar creates problems because it isn't a real variable Bugzilla 3326
-                    if (ident == Id.dollar)
-                    {
-                        .error(loc, "cannnot use $ inside a function literal");
-                        return true;
-                    }
-                    if (ident == Id.withSym) // Bugzilla 1759
-                    {
-                        ExpInitializer ez = _init.isExpInitializer();
-                        assert(ez);
-                        Expression e = ez.exp;
-                        if (e.op == TOKconstruct || e.op == TOKblit)
-                            e = (cast(AssignExp)e).e2;
-                        return lambdaCheckForNestedRef(e, sc);
-                    }
-                }
-            }
+            int lv = fdthis.getLevel(loc, sc, fdv);
+            if (lv == -2) // error
+                return true;
         }
+
+        // Add this to fdv.closureVars[] if not already there
+        for (size_t i = 0; 1; i++)
+        {
+            if (i == fdv.closureVars.dim)
+            {
+                if (!sc.intypeof && !(sc.flags & SCOPEcompile))
+                    fdv.closureVars.push(this);
+                break;
+            }
+            if (fdv.closureVars[i] == this)
+                break;
+        }
+
+        //printf("fdthis is %s\n", fdthis.toChars());
+        //printf("var %s in function %s is nested ref\n", toChars(), fdv.toChars());
+        // __dollar creates problems because it isn't a real variable Bugzilla 3326
+        if (ident == Id.dollar)
+        {
+            .error(loc, "cannnot use $ inside a function literal");
+            return true;
+        }
+        if (ident == Id.withSym) // Bugzilla 1759
+        {
+            ExpInitializer ez = _init.isExpInitializer();
+            assert(ez);
+            Expression e = ez.exp;
+            if (e.op == TOKconstruct || e.op == TOKblit)
+                e = (cast(AssignExp)e).e2;
+            return lambdaCheckForNestedRef(e, sc);
+        }
+
         return false;
     }
 
@@ -2337,9 +2250,9 @@ public:
     }
 
     // Eliminate need for dynamic_cast
-    override final VarDeclaration isVarDeclaration()
+    override final inout(VarDeclaration) isVarDeclaration() inout
     {
-        return cast(VarDeclaration)this;
+        return this;
     }
 
     override void accept(Visitor v)
@@ -2365,9 +2278,9 @@ public:
     }
 
     // Eliminate need for dynamic_cast
-    override SymbolDeclaration isSymbolDeclaration()
+    override inout(SymbolDeclaration) isSymbolDeclaration() inout
     {
-        return cast(SymbolDeclaration)this;
+        return this;
     }
 
     override void accept(Visitor v)
@@ -2407,7 +2320,7 @@ public:
         assert(linkage == LINKc);
     }
 
-    override final char* toChars()
+    override final const(char)* toChars()
     {
         //printf("TypeInfoDeclaration::toChars() tinfo = %s\n", tinfo->toChars());
         OutBuffer buf;
@@ -2417,7 +2330,7 @@ public:
         return buf.extractString();
     }
 
-    override final TypeInfoDeclaration isTypeInfoDeclaration()
+    override final inout(TypeInfoDeclaration) isTypeInfoDeclaration() inout
     {
         return this;
     }
@@ -2853,7 +2766,7 @@ public:
     extern (D) this(Loc loc, Type t)
     {
         super(loc, t, Id.This, null);
-        noscope = 1;
+        noscope = true;
     }
 
     override Dsymbol syntaxCopy(Dsymbol s)
@@ -2861,7 +2774,7 @@ public:
         assert(0); // should never be produced by syntax
     }
 
-    override ThisDeclaration isThisDeclaration()
+    override inout(ThisDeclaration) isThisDeclaration() inout
     {
         return this;
     }
diff --git a/ddmd/declaration.h b/ddmd/declaration.h
index d8ed829d4f..182c08bded 100644
--- a/ddmd/declaration.h
+++ b/ddmd/declaration.h
@@ -251,7 +251,7 @@ class VarDeclaration : public Declaration
 public:
     Initializer *_init;
     unsigned offset;
-    bool noscope;                // no auto semantics
+    bool noscope;               // if scope destruction is disabled
     FuncDeclarations nestedrefs; // referenced by these lexically nested functions
     bool isargptr;              // if parameter that _argptr points to
     structalign_t alignment;
@@ -289,9 +289,8 @@ public:
     bool isOverlappedWith(VarDeclaration *v);
     bool hasPointers();
     bool canTakeAddressOf();
-    bool needsAutoDtor();
+    bool needsScopeDtor();
     Expression *callScopeDtor(Scope *sc);
-    ExpInitializer *getExpInitializer();
     Expression *getConstInitializer(bool needFullType = true);
     void checkCtorConstInit();
     bool checkNestedReference(Scope *sc, Loc loc);
@@ -577,6 +576,7 @@ public:
     // true if errors in semantic3 this function's frame ptr
     bool semantic3Errors;
     ForeachStatement *fes;              // if foreach body, this is the foreach
+    BaseClass* interfaceVirtual;        // if virtual, but only appears in interface vtbl[]
     bool introducing;                   // true if 'introducing' function
     // if !=NULL, then this is the type
     // of the 'introducing' function
@@ -649,7 +649,6 @@ public:
     bool isImportedSymbol();
     bool isCodeseg();
     bool isOverloadable();
-    bool hasOverloads();
     PURE isPure();
     PURE isPureBypassingInference();
     bool setImpure();
@@ -676,6 +675,7 @@ public:
     FuncDeclaration *isUnique();
     bool checkNestedReference(Scope *sc, Loc loc);
     bool needsClosure();
+    bool checkClosure();
     bool hasNestedFrameRefs();
     void buildResultVar(Scope *sc, Type *tret);
 #if IN_LLVM
@@ -723,6 +723,9 @@ public:
     TOK tok;                       // TOKfunction or TOKdelegate
     Type *treq;                         // target of return type inference
 
+    // backend
+    bool deferToObj;
+
     FuncLiteralDeclaration(Loc loc, Loc endloc, Type *type, TOK tok,
         ForeachStatement *fes, Identifier *id = NULL);
     Dsymbol *syntaxCopy(Dsymbol *);
diff --git a/ddmd/delegatize.d b/ddmd/delegatize.d
index 255ad69181..f107d9c47b 100644
--- a/ddmd/delegatize.d
+++ b/ddmd/delegatize.d
@@ -11,6 +11,7 @@ module ddmd.delegatize;
 import ddmd.apply;
 import ddmd.declaration;
 import ddmd.dscope;
+import ddmd.dsymbol;
 import ddmd.expression;
 import ddmd.func;
 import ddmd.globals;
@@ -165,3 +166,29 @@ extern (C++) bool lambdaCheckForNestedRef(Expression e, Scope* sc)
     walkPostorder(e, v);
     return v.result;
 }
+
+bool checkNestedRef(Dsymbol s, Dsymbol p)
+{
+    while (s)
+    {
+        if (s == p) // hit!
+            return false;
+
+        if (auto fd = s.isFuncDeclaration())
+        {
+            if (!fd.isThis() && !fd.isNested())
+                break;
+
+            // Bugzilla 15332: change to delegate if fd is actually nested.
+            if (auto fld = fd.isFuncLiteralDeclaration())
+                fld.tok = TOKdelegate;
+        }
+        if (auto ad = s.isAggregateDeclaration())
+        {
+            if (ad.storage_class & STCstatic)
+                break;
+        }
+        s = s.toParent2();
+    }
+    return true;
+}
diff --git a/ddmd/denum.d b/ddmd/denum.d
index 74034189a7..c8718585c1 100644
--- a/ddmd/denum.d
+++ b/ddmd/denum.d
@@ -303,12 +303,12 @@ public:
         return type;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "enum";
     }
 
-    override Dsymbol search(Loc loc, Identifier ident, int flags = IgnoreNone)
+    override Dsymbol search(Loc loc, Identifier ident, int flags = SearchLocalsOnly)
     {
         //printf("%s.EnumDeclaration::search('%s')\n", toChars(), ident->toChars());
         if (_scope)
@@ -485,7 +485,7 @@ public:
         return memtype;
     }
 
-    override EnumDeclaration isEnumDeclaration()
+    override inout(EnumDeclaration) isEnumDeclaration() inout
     {
         return this;
     }
@@ -532,7 +532,7 @@ public:
         return new EnumMember(loc, ident, value ? value.syntaxCopy() : null, origType ? origType.syntaxCopy() : null);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "enum member";
     }
@@ -755,7 +755,7 @@ public:
         return e.semantic(sc);
     }
 
-    override EnumMember isEnumMember()
+    override inout(EnumMember) isEnumMember() inout
     {
         return this;
     }
diff --git a/ddmd/dimport.d b/ddmd/dimport.d
index 562935a1fc..7a80c49dc8 100644
--- a/ddmd/dimport.d
+++ b/ddmd/dimport.d
@@ -9,6 +9,8 @@
 module ddmd.dimport;
 
 import core.stdc.string;
+import core.stdc.stdio;
+
 import ddmd.arraytypes;
 import ddmd.attrib;
 import ddmd.declaration;
@@ -37,7 +39,7 @@ public:
     Identifier id;          // module Identifier
     Identifier aliasId;
     int isstatic;           // !=0 if static import
-    PROTKIND protection;
+    Prot protection;
 
     // Pairs of alias=name to bind into current namespace
     Identifiers names;
@@ -100,14 +102,14 @@ public:
         aliases.push(_alias);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return isstatic ? cast(char*)"static import" : cast(char*)"import";
     }
 
     override Prot prot()
     {
-        return Prot(protection);
+        return protection;
     }
 
     // copy only syntax trees
@@ -158,6 +160,8 @@ public:
                         {
                             // mod is a package.d, or a normal module which conflicts with the package name.
                             assert(mod.isPackageFile == (p.isPkgMod == PKGmodule));
+                            if (mod.isPackageFile)
+                                mod.tag = p.tag; // reuse the same package tag
                         }
                     }
                     else
@@ -185,7 +189,7 @@ public:
             mod = Module.load(loc, packages, id);
             if (mod)
             {
-                dst.insert(id, mod); // id may be different from mod->ident,
+                dst.insert(id, mod); // id may be different from mod.ident,
                 // if so then insert alias
             }
         }
@@ -212,11 +216,11 @@ public:
                         mod.deprecation(loc, "is deprecated");
                 }
                 mod.importAll(null);
+                if (sc.explicitProtection)
+                    protection = sc.protection;
                 if (!isstatic && !aliasId && !names.dim)
                 {
-                    if (sc.explicitProtection)
-                        protection = sc.protection.kind;
-                    sc.scopesym.importScope(mod, Prot(protection));
+                    sc.scopesym.importScope(mod, protection);
                 }
             }
         }
@@ -224,7 +228,7 @@ public:
 
     override void semantic(Scope* sc)
     {
-        //printf("Import::semantic('%s')\n", toPrettyChars());
+        //printf("Import::semantic('%s') %s\n", toPrettyChars(), id.toChars());
         if (_scope)
         {
             sc = _scope;
@@ -240,43 +244,57 @@ public:
         if (mod)
         {
             // Modules need a list of each imported module
-            //printf("%s imports %s\n", sc->module->toChars(), mod->toChars());
+            //printf("%s imports %s\n", sc.module.toChars(), mod.toChars());
             sc._module.aimports.push(mod);
-            if (!isstatic && !aliasId && !names.dim)
+
+            if (sc.explicitProtection)
+                protection = sc.protection;
+
+            if (!aliasId && !names.dim) // neither a selective nor a renamed import
             {
-                if (sc.explicitProtection)
-                    protection = sc.protection.kind;
+                ScopeDsymbol scopesym;
                 for (Scope* scd = sc; scd; scd = scd.enclosing)
                 {
-                    if (scd.scopesym)
+                    if (!scd.scopesym)
+                        continue;
+                    scopesym = scd.scopesym;
+                    break;
+                }
+
+                if (!isstatic)
+                {
+                    scopesym.importScope(mod, protection);
+                }
+
+                // Mark the imported packages as accessible from the current
+                // scope. This access check is necessary when using FQN b/c
+                // we're using a single global package tree. See Bugzilla 313.
+                if (packages)
+                {
+                    // import a.b.c.d;
+                    auto p = pkg; // a
+                    scopesym.addAccessiblePackage(p);
+                    foreach (id; (*packages)[1 .. packages.dim]) // [b, c]
                     {
-                        scd.scopesym.importScope(mod, Prot(protection));
-                        break;
+                        p = cast(Package) p.symtab.lookup(id);
+                        scopesym.addAccessiblePackage(p);
                     }
                 }
+                scopesym.addAccessiblePackage(mod); // d
             }
+
             mod.semantic();
             if (mod.needmoduleinfo)
             {
-                //printf("module4 %s because of %s\n", sc->module->toChars(), mod->toChars());
+                //printf("module4 %s because of %s\n", sc.module.toChars(), mod.toChars());
                 sc._module.needmoduleinfo = 1;
             }
             sc = sc.push(mod);
-            /* BUG: Protection checks can't be enabled yet. The issue is
-             * that Dsymbol::search errors before overload resolution.
-             */
-            version (none)
-            {
-                sc.protection = protection;
-            }
-            else
-            {
-                sc.protection = Prot(PROTpublic);
-            }
+            sc.protection = protection;
             for (size_t i = 0; i < aliasdecls.dim; i++)
             {
                 AliasDeclaration ad = aliasdecls[i];
-                //printf("\tImport alias semantic('%s')\n", ad->toChars());
+                //printf("\tImport %s alias %s = %s, scope = %p\n", toPrettyChars(), aliases[i].toChars(), names[i].toChars(), ad._scope);
                 if (mod.search(loc, names[i]))
                 {
                     ad.semantic(sc);
@@ -317,9 +335,9 @@ public:
             ob.writestring(" (");
             escapePath(ob, imod.srcfile.toChars());
             ob.writestring(") : ");
-            // use protection instead of sc->protection because it couldn't be
+            // use protection instead of sc.protection because it couldn't be
             // resolved yet, see the comment above
-            protectionToBuffer(ob, Prot(protection));
+            protectionToBuffer(ob, protection);
             ob.writeByte(' ');
             if (isstatic)
             {
@@ -373,7 +391,7 @@ public:
             mod.semantic2();
             if (mod.needmoduleinfo)
             {
-                //printf("module5 %s because of %s\n", sc->module->toChars(), mod->toChars());
+                //printf("module5 %s because of %s\n", sc.module.toChars(), mod.toChars());
                 sc._module.needmoduleinfo = 1;
             }
         }
@@ -391,6 +409,7 @@ public:
      */
     override void addMember(Scope* sc, ScopeDsymbol sd)
     {
+        //printf("Import.addMember(this=%s, sd=%s, sc=%p)\n", toChars(), sd.toChars(), sc);
         if (names.dim == 0)
             return Dsymbol.addMember(sc, sd);
         if (aliasId)
@@ -412,9 +431,25 @@ public:
         }
     }
 
-    override Dsymbol search(Loc loc, Identifier ident, int flags = IgnoreNone)
+    override void setScope(Scope* sc)
     {
-        //printf("%s.Import::search(ident = '%s', flags = x%x)\n", toChars(), ident->toChars(), flags);
+        Dsymbol.setScope(sc);
+        if (aliasdecls.dim)
+        {
+            if (!mod)
+                importAll(sc);
+
+            sc = sc.push(mod);
+            sc.protection = protection;
+            foreach (ad; aliasdecls)
+                ad.setScope(sc);
+            sc = sc.pop();
+        }
+    }
+
+    override Dsymbol search(Loc loc, Identifier ident, int flags = SearchLocalsOnly)
+    {
+        //printf("%s.Import.search(ident = '%s', flags = x%x)\n", toChars(), ident.toChars(), flags);
         if (!pkg)
         {
             load(null);
@@ -438,7 +473,7 @@ public:
             return false;
     }
 
-    override Import isImport()
+    override inout(Import) isImport() inout
     {
         return this;
     }
diff --git a/ddmd/dinifile.d b/ddmd/dinifile.d
index 028918c745..2a1bc6fea2 100644
--- a/ddmd/dinifile.d
+++ b/ddmd/dinifile.d
@@ -219,7 +219,7 @@ void parseConfFile(StringTable* environment, const(char)* filename, const(char)*
         buf.reset();
         // First, expand the macros.
         // Macros are bracketed by % characters.
-      Kloop:
+    Kloop:
         for (size_t k = 0; k < i - linestart; ++k)
         {
             // The line is buffer[linestart..i]
@@ -359,4 +359,3 @@ void parseConfFile(StringTable* environment, const(char)* filename, const(char)*
         }
     }
 }
-
diff --git a/ddmd/dinterpret.d b/ddmd/dinterpret.d
index 52618cec28..ef18eca7b8 100644
--- a/ddmd/dinterpret.d
+++ b/ddmd/dinterpret.d
@@ -710,11 +710,6 @@ extern (C++) Expression ctfeInterpret(Expression e)
 {
     if (e.op == TOKerror)
         return e;
-    if (e.op == TOKscope && !e.type) // workaround Bugzilla 15239
-    {
-        e.error("cannot interpret %s at compile time", e.toChars());
-        return new ErrorExp();
-    }
     assert(e.type); // Bugzilla 14642
     //assert(e->type->ty != Terror);    // FIXME
     if (e.type.ty == Terror)
@@ -1062,6 +1057,19 @@ public:
         return false;
     }
 
+    static Expressions* copyArrayOnWrite(Expressions* exps, Expressions* original)
+    {
+        if (exps is original)
+        {
+            if (!original)
+                exps = new Expressions();
+            else
+                exps = original.copy();
+            ++CtfeStatus.numArrayAllocs;
+        }
+        return exps;
+    }
+
     /******************************** Statement ***************************/
 
     override void visit(Statement s)
@@ -2197,7 +2205,7 @@ public:
         }
         else
         {
-            result = new DelegateExp(e.loc, result, e.func);
+            result = new DelegateExp(e.loc, result, e.func, false);
             result.type = e.type;
         }
     }
@@ -2569,11 +2577,7 @@ public:
              */
             if (ex !is exp)
             {
-                if (expsx is e.exps)
-                {
-                    expsx = e.exps.copy();
-                    ++CtfeStatus.numArrayAllocs;
-                }
+                expsx = copyArrayOnWrite(expsx, e.exps);
                 (*expsx)[i] = ex;
             }
         }
@@ -2600,6 +2604,7 @@ public:
             result = e;
             return;
         }
+
         Type tn = e.type.toBasetype().nextOf().toBasetype();
         bool wantCopy = (tn.ty == Tsarray || tn.ty == Tstruct);
 
@@ -2607,54 +2612,43 @@ public:
         if (exceptionOrCant(basis))
             return;
 
-        Expressions* expsx = null;
-        size_t dim = e.elements ? e.elements.dim : 0;
+        auto expsx = e.elements;
+        size_t dim = expsx ? expsx.dim : 0;
         for (size_t i = 0; i < dim; i++)
         {
-            Expression exp = (*e.elements)[i];
+            Expression exp = (*expsx)[i];
             Expression ex;
             if (!exp)
             {
                 ex = copyLiteral(basis).copy();
-                goto Lcow;
             }
+            else
+            {
+                // segfault bug 6250
+                assert(exp.op != TOKindex || (cast(IndexExp)exp).e1 != e);
 
-            // segfault bug 6250
-            assert(exp.op != TOKindex || (cast(IndexExp)exp).e1 != e);
+                ex = interpret(exp, istate);
+                if (exceptionOrCant(ex))
+                    return;
 
-            ex = interpret(exp, istate);
-            if (exceptionOrCant(ex))
-                return;
-
-            /* Each elements should have distinct CFE memory.
-             *  int[1] z = 7;
-             *  int[1][] pieces = [z,z];    // here
-             */
-            if (wantCopy || ex == exp && expsx)
-                ex = copyLiteral(ex).copy();
-
-            if (ex == exp && !expsx)
-                continue;
+                /* Each elements should have distinct CTFE memory.
+                 *  int[1] z = 7;
+                 *  int[1][] pieces = [z,z];    // here
+                 */
+                if (wantCopy)
+                    ex = copyLiteral(ex).copy();
+            }
 
             /* If any changes, do Copy On Write
              */
-        Lcow:
-            if (!expsx)
+            if (ex !is exp)
             {
-                expsx = new Expressions();
-                ++CtfeStatus.numArrayAllocs;
-                expsx.setDim(dim);
-                for (size_t j = 0; j < i; j++)
-                {
-                    auto el = (*e.elements)[j];
-                    if (!el)
-                        el = e.basis;
-                    (*expsx)[j] = copyLiteral(el).copy();
-                }
+                expsx = copyArrayOnWrite(expsx, e.elements);
+                (*expsx)[i] = ex;
             }
-            (*expsx)[i] = ex;
         }
-        if (expsx)
+
+        if (expsx !is e.elements)
         {
             // todo: all tuple expansions should go in semantic phase.
             expandTuples(expsx);
@@ -2664,19 +2658,18 @@ public:
                 result = CTFEExp.cantexp;
                 return;
             }
-            auto ae = new ArrayLiteralExp(e.loc, basis, expsx);
-            ae.type = e.type;
-            ae.ownedByCtfe = OWNEDctfe;
-            result = ae;
-            return;
+            auto ale = new ArrayLiteralExp(e.loc, basis, expsx);
+            ale.type = e.type;
+            ale.ownedByCtfe = OWNEDctfe;
+            result = ale;
         }
-        if ((cast(TypeNext)e.type).next.mod & (MODconst | MODimmutable))
+        else if ((cast(TypeNext)e.type).next.mod & (MODconst | MODimmutable))
         {
             // If it's immutable, we don't need to dup it
             result = e;
-            return;
         }
-        result = copyLiteral(e).copy();
+        else
+            result = copyLiteral(e).copy();
     }
 
     override void visit(AssocArrayLiteralExp e)
@@ -2710,16 +2703,8 @@ public:
             if (ek !is ekey ||
                 ev !is evalue)
             {
-                if (keysx is e.keys)
-                {
-                    keysx = e.keys.copy();
-                    ++CtfeStatus.numArrayAllocs;
-                }
-                if (valuesx is e.values)
-                {
-                    valuesx = e.values.copy();
-                    ++CtfeStatus.numArrayAllocs;
-                }
+                keysx = copyArrayOnWrite(keysx, e.keys);
+                valuesx = copyArrayOnWrite(valuesx, e.values);
                 (*keysx)[i] = ek;
                 (*valuesx)[i] = ev;
             }
@@ -2747,16 +2732,8 @@ public:
                     continue;
 
                 // Remove ekey
-                if (keysx is e.keys)
-                {
-                    keysx = e.keys.copy();
-                    ++CtfeStatus.numArrayAllocs;
-                }
-                if (valuesx is e.values)
-                {
-                    valuesx = e.values.copy();
-                    ++CtfeStatus.numArrayAllocs;
-                }
+                keysx = copyArrayOnWrite(keysx, e.keys);
+                valuesx = copyArrayOnWrite(valuesx, e.values);
                 keysx.remove(i - 1);
                 valuesx.remove(i - 1);
 
@@ -2790,64 +2767,60 @@ public:
             result = e;
             return;
         }
-        size_t elemdim = e.elements ? e.elements.dim : 0;
-        Expressions* expsx = null;
-        for (size_t i = 0; i < e.sd.fields.dim; i++)
+
+        size_t dim = e.elements ? e.elements.dim : 0;
+        auto expsx = e.elements;
+
+        if (dim != e.sd.fields.dim)
         {
-            VarDeclaration v = e.sd.fields[i];
-            Expression ex = null;
-            Expression exp = null;
-            if (i >= elemdim)
+            // guaranteed by AggregateDeclaration.fill and TypeStruct.defaultInitLiteral
+            assert(e.sd.isNested() && dim == e.sd.fields.dim - 1);
+
+            /* If a nested struct has no initialized hidden pointer,
+             * set it to null to match the runtime behaviour.
+             */
+            auto ne = new NullExp(e.loc);
+            ne.type = e.sd.vthis.type;
+
+            expsx = copyArrayOnWrite(expsx, e.elements);
+            expsx.push(ne);
+            ++dim;
+        }
+        assert(dim == e.sd.fields.dim);
+
+        foreach (i; 0 .. dim)
+        {
+            auto v = e.sd.fields[i];
+            Expression exp = (*expsx)[i];
+            Expression ex;
+            if (!exp)
             {
-                /* If a nested struct has no initialized hidden pointer,
-                 * set it to null to match the runtime behaviour.
-                 */
-                if (i == e.sd.fields.dim - 1 && e.sd.isNested())
-                {
-                    // Context field has not been filled
-                    ex = new NullExp(e.loc);
-                    ex.type = v.type;
-                }
+                ex = voidInitLiteral(v.type, v).copy();
             }
             else
             {
-                exp = (*e.elements)[i];
-                if (!exp)
+                ex = interpret(exp, istate);
+                if (exceptionOrCant(ex))
+                    return;
+                if ((v.type.ty != ex.type.ty) && v.type.ty == Tsarray)
                 {
-                    ex = voidInitLiteral(v.type, v).copy();
-                }
-                else
-                {
-                    ex = interpret(exp, istate);
-                    if (exceptionOrCant(ex))
-                        return;
-                    if ((v.type.ty != ex.type.ty) && v.type.ty == Tsarray)
-                    {
-                        // Block assignment from inside struct literals
-                        TypeSArray tsa = cast(TypeSArray)v.type;
-                        size_t len = cast(size_t)tsa.dim.toInteger();
-                        ex = createBlockDuplicatedArrayLiteral(ex.loc, v.type, ex, len);
-                    }
+                    // Block assignment from inside struct literals
+                    auto tsa = cast(TypeSArray)v.type;
+                    auto len = cast(size_t)tsa.dim.toInteger();
+                    ex = createBlockDuplicatedArrayLiteral(ex.loc, v.type, ex, len);
                 }
             }
+
             /* If any changes, do Copy On Write
              */
-            if (ex != exp)
+            if (ex !is exp)
             {
-                if (!expsx)
-                {
-                    expsx = new Expressions();
-                    ++CtfeStatus.numArrayAllocs;
-                    expsx.setDim(e.sd.fields.dim);
-                    for (size_t j = 0; j < e.elements.dim; j++)
-                    {
-                        (*expsx)[j] = (*e.elements)[j];
-                    }
-                }
+                expsx = copyArrayOnWrite(expsx, e.elements);
                 (*expsx)[i] = ex;
             }
         }
-        if (e.elements && expsx)
+
+        if (expsx !is e.elements)
         {
             expandTuples(expsx);
             if (expsx.dim != e.sd.fields.dim)
@@ -2856,13 +2829,13 @@ public:
                 result = CTFEExp.cantexp;
                 return;
             }
-            auto se = new StructLiteralExp(e.loc, e.sd, expsx);
-            se.type = e.type;
-            se.ownedByCtfe = OWNEDctfe;
-            result = se;
-            return;
+            auto sle = new StructLiteralExp(e.loc, e.sd, expsx);
+            sle.type = e.type;
+            sle.ownedByCtfe = OWNEDctfe;
+            result = sle;
         }
-        result = copyLiteral(e).copy();
+        else
+            result = copyLiteral(e).copy();
     }
 
     // Create an array literal of type 'newtype' with dimensions given by
@@ -3488,7 +3461,11 @@ public:
                 }
 
                 if (fp)
+                {
                     oldval = findKeyInAA(e.loc, existingAA, lastIndex);
+                    if (!oldval)
+                        oldval = copyLiteral(e.e1.type.defaultInitLiteral(e.loc)).copy();
+                }
             }
             else
             {
@@ -3596,21 +3573,23 @@ public:
         Expression newval = interpret(e.e2, istate);
         if (exceptionOrCant(newval))
             return;
-        if (e.type.toBasetype().ty == Tstruct && newval.op == TOKint64)
+        if (e.op == TOKblit && newval.op == TOKint64)
         {
-            /* Look for special case of struct being initialized with 0.
-             */
-            assert(e.op == TOKconstruct || e.op == TOKblit);
-            newval = e.type.defaultInitLiteral(e.loc);
-            if (newval.op != TOKstructliteral)
+            Type tbn = e.type.baseElemOf();
+            if (tbn.ty == Tstruct)
             {
-                e.error("nested structs with constructors are not yet supported in CTFE (Bug 6419)");
-                result = CTFEExp.cantexp;
-                return;
+                /* Look for special case of struct being initialized with 0.
+                 */
+                newval = e.type.defaultInitLiteral(e.loc);
+                if (newval.op == TOKerror)
+                {
+                    result = CTFEExp.cantexp;
+                    return;
+                }
+                newval = interpret(newval, istate); // copy and set ownedByCtfe flag
+                if (exceptionOrCant(newval))
+                    return;
             }
-            newval = interpret(newval, istate); // copy and set ownedByCtfe flag
-            if (exceptionOrCant(newval))
-                return;
         }
 
         // ----------------------------------------------------
@@ -3873,22 +3852,7 @@ public:
                     e.error("cannot modify read-only string literal %s", ie.e1.toChars());
                     return CTFEExp.cantexp;
                 }
-                void* s = existingSE.string;
-                dinteger_t value = newval.toInteger();
-                switch (existingSE.sz)
-                {
-                case 1:
-                    (cast(char*)s)[index] = cast(char)value;
-                    break;
-                case 2:
-                    (cast(utf16_t*)s)[index] = cast(utf16_t)value;
-                    break;
-                case 4:
-                    (cast(utf32_t*)s)[index] = cast(utf32_t)value;
-                    break;
-                default:
-                    assert(0);
-                }
+                existingSE.setCodeUnit(index, cast(dchar)newval.toInteger());
                 return null;
             }
             if (aggregate.op != TOKarrayliteral)
@@ -4037,7 +4001,7 @@ public:
                 uint dim = cast(uint)dollar;
                 lowerbound = cast(int)(lwr ? lwr.toInteger() : 0);
                 upperbound = cast(size_t)(upr ? upr.toInteger() : dim);
-                if (cast(int)lowerbound < 0 || dim < upperbound)
+                if (lowerbound < 0 || dim < upperbound)
                 {
                     e.error("array bounds [0..%d] exceeded in slice [%d..%d]", dim, lowerbound, upperbound);
                     return CTFEExp.cantexp;
@@ -4124,7 +4088,7 @@ public:
             }
             if (newval.op == TOKstring)
             {
-                sliceAssignStringFromString(cast(StringExp)existingSE, cast(StringExp)newval, cast(size_t)firstIndex);
+                sliceAssignStringFromString(existingSE, cast(StringExp)newval, cast(size_t)firstIndex);
                 return newval;
             }
             if (newval.op == TOKarrayliteral)
@@ -4136,24 +4100,10 @@ public:
                 return newval;
             }
             // String literal block slice assign
-            dinteger_t value = newval.toInteger();
-            void* s = existingSE.string;
-            for (size_t i = 0; i < upperbound - lowerbound; i++)
+            const value = cast(dchar)newval.toInteger();
+            foreach (i; 0 .. upperbound - lowerbound)
             {
-                switch (existingSE.sz)
-                {
-                case 1:
-                    (cast(char*)s)[cast(size_t)(i + firstIndex)] = cast(char)value;
-                    break;
-                case 2:
-                    (cast(utf16_t*)s)[cast(size_t)(i + firstIndex)] = cast(utf16_t)value;
-                    break;
-                case 4:
-                    (cast(utf32_t*)s)[cast(size_t)(i + firstIndex)] = cast(utf32_t)value;
-                    break;
-                default:
-                    assert(0);
-                }
+                existingSE.setCodeUnit(cast(size_t)(i + firstIndex), value);
             }
             if (goal == ctfeNeedNothing)
                 return null; // avoid creating an unused literal
@@ -4449,7 +4399,7 @@ public:
         case TOKlt:
         case TOKle:
             ret *= -1;
-            /* fall through */
+            goto case; /+ fall through +/
         case TOKgt:
         case TOKge:
             *p1 = (cast(BinExp)e).e1;
@@ -5483,11 +5433,134 @@ public:
         }
         // We know we still own it, because we interpreted both e1 and e2
         if (result.op == TOKarrayliteral)
-            (cast(ArrayLiteralExp)result).ownedByCtfe = OWNEDctfe;
+        {
+            ArrayLiteralExp ale = cast(ArrayLiteralExp)result;
+            ale.ownedByCtfe = OWNEDctfe;
+
+            // Bugzilla 14686
+            for (size_t i = 0; i < ale.elements.dim; i++)
+            {
+                Expression ex = evaluatePostblit(istate, (*ale.elements)[i]);
+                if (exceptionOrCant(ex))
+                    return;
+            }
+        }
         if (result.op == TOKstring)
             (cast(StringExp)result).ownedByCtfe = OWNEDctfe;
     }
 
+    override void visit(DeleteExp e)
+    {
+        static if (LOG)
+        {
+            printf("%s DeleteExp::interpret() %s\n", e.loc.toChars(), e.toChars());
+        }
+        result = interpret(e.e1, istate);
+        if (exceptionOrCant(result))
+            return;
+
+        if (result.op == TOKnull)
+        {
+            result = CTFEExp.voidexp;
+            return;
+        }
+
+        auto tb = e.e1.type.toBasetype();
+        switch (tb.ty)
+        {
+        case Tclass:
+            if (result.op != TOKclassreference)
+            {
+                e.error("delete on invalid class reference '%s'", result.toChars());
+                result = CTFEExp.cantexp;
+                return;
+            }
+
+            auto cre = cast(ClassReferenceExp)result;
+            auto cd = cre.originalClass();
+            if (cd.aggDelete)
+            {
+                e.error("member deallocators not supported by CTFE");
+                result = CTFEExp.cantexp;
+                return;
+            }
+
+            if (cd.dtor)
+            {
+                result = interpret(cd.dtor, istate, null, cre);
+                if (exceptionOrCant(result))
+                    return;
+            }
+            break;
+
+        case Tpointer:
+            tb = (cast(TypePointer)tb).next.toBasetype();
+            if (tb.ty == Tstruct)
+            {
+                if (result.op != TOKaddress ||
+                    (cast(AddrExp)result).e1.op != TOKstructliteral)
+                {
+                    e.error("delete on invalid struct pointer '%s'", result.toChars());
+                    result = CTFEExp.cantexp;
+                    return;
+                }
+
+                auto sd = (cast(TypeStruct)tb).sym;
+                auto sle = cast(StructLiteralExp)(cast(AddrExp)result).e1;
+                if (sd.aggDelete)
+                {
+                    e.error("member deallocators not supported by CTFE");
+                    result = CTFEExp.cantexp;
+                    return;
+                }
+
+                if (sd.dtor)
+                {
+                    result = interpret(sd.dtor, istate, null, sle);
+                    if (exceptionOrCant(result))
+                        return;
+                }
+            }
+            break;
+
+        case Tarray:
+            auto tv = tb.nextOf().baseElemOf();
+            if (tv.ty == Tstruct)
+            {
+                if (result.op != TOKarrayliteral)
+                {
+                    e.error("delete on invalid struct array '%s'", result.toChars());
+                    result = CTFEExp.cantexp;
+                    return;
+                }
+
+                auto sd = (cast(TypeStruct)tv).sym;
+                if (sd.aggDelete)
+                {
+                    e.error("member deallocators not supported by CTFE");
+                    result = CTFEExp.cantexp;
+                    return;
+                }
+
+                if (sd.dtor)
+                {
+                    auto ale = cast(ArrayLiteralExp)result;
+                    foreach (el; *ale.elements)
+                    {
+                        result = interpret(sd.dtor, istate, null, el);
+                        if (exceptionOrCant(result))
+                            return;
+                    }
+                }
+            }
+            break;
+
+        default:
+            assert(0);
+        }
+        result = CTFEExp.voidexp;
+    }
+
     override void visit(CastExp e)
     {
         static if (LOG)
@@ -5837,7 +5910,7 @@ public:
                 result = e; // optimize: reuse this CTFE reference
             else
             {
-                result = new DotVarExp(e.loc, ex, f);
+                result = new DotVarExp(e.loc, ex, f, false);
                 result.type = e.type;
             }
             return;
@@ -6378,14 +6451,14 @@ extern (C++) Expression foreachApplyUtf(InterState* istate, Expression str, Expr
     Expression eresult = null; // ded-store to prevent spurious warning
     // Buffers for encoding; also used for decoding array literals
     char[4] utf8buf;
-    ushort[2] utf16buf;
+    wchar[2] utf16buf;
     size_t start = rvs ? len : 0;
     size_t end = rvs ? 0 : len;
     for (size_t indx = start; indx != end;)
     {
         // Step 1: Decode the next dchar from the string.
         const(char)* errmsg = null; // Used for reporting decoding errors
-        dchar_t rawvalue; // Holds the decoded dchar
+        dchar rawvalue; // Holds the decoded dchar
         size_t currentIndex = indx; // The index of the decoded character
         if (ale)
         {
@@ -6420,7 +6493,7 @@ extern (C++) Expression foreachApplyUtf(InterState* istate, Expression str, Expr
                     utf8buf[i] = cast(char)(cast(IntegerExp)r).getInteger();
                 }
                 n = 0;
-                errmsg = utf_decodeChar(&utf8buf[0], buflen, &n, &rawvalue);
+                errmsg = utf_decodeChar(&utf8buf[0], buflen, n, rawvalue);
                 break;
             case 2:
                 if (rvs)
@@ -6446,7 +6519,7 @@ extern (C++) Expression foreachApplyUtf(InterState* istate, Expression str, Expr
                     utf16buf[i] = cast(ushort)(cast(IntegerExp)r).getInteger();
                 }
                 n = 0;
-                errmsg = utf_decodeWchar(&utf16buf[0], buflen, &n, &rawvalue);
+                errmsg = utf_decodeWchar(&utf16buf[0], buflen, n, rawvalue);
                 break;
             case 4:
                 {
@@ -6454,7 +6527,7 @@ extern (C++) Expression foreachApplyUtf(InterState* istate, Expression str, Expr
                         --indx;
                     Expression r = (*ale.elements)[indx];
                     assert(r.op == TOKint64);
-                    rawvalue = cast(dchar_t)(cast(IntegerExp)r).getInteger();
+                    rawvalue = cast(dchar)(cast(IntegerExp)r).getInteger();
                     n = 1;
                 }
                 break;
@@ -6474,13 +6547,12 @@ extern (C++) Expression foreachApplyUtf(InterState* istate, Expression str, Expr
                 if (rvs)
                 {
                     // find the start of the string
-                    char* s = cast(char*)se.string;
                     --indx;
-                    while (indx > 0 && ((s[indx] & 0xC0) == 0x80))
+                    while (indx > 0 && ((se.getCodeUnit(indx) & 0xC0) == 0x80))
                         --indx;
                     saveindx = indx;
                 }
-                errmsg = utf_decodeChar(cast(char*)se.string, se.len, &indx, &rawvalue);
+                errmsg = utf_decodeChar(se.string, se.len, indx, rawvalue);
                 if (rvs)
                     indx = saveindx;
                 break;
@@ -6488,20 +6560,20 @@ extern (C++) Expression foreachApplyUtf(InterState* istate, Expression str, Expr
                 if (rvs)
                 {
                     // find the start
-                    ushort* s = cast(ushort*)se.string;
                     --indx;
-                    if (s[indx] >= 0xDC00 && s[indx] <= 0xDFFF)
+                    auto wc = se.getCodeUnit(indx);
+                    if (wc >= 0xDC00 && wc <= 0xDFFF)
                         --indx;
                     saveindx = indx;
                 }
-                errmsg = utf_decodeWchar(cast(ushort*)se.string, se.len, &indx, &rawvalue);
+                errmsg = utf_decodeWchar(se.wstring, se.len, indx, rawvalue);
                 if (rvs)
                     indx = saveindx;
                 break;
             case 4:
                 if (rvs)
                     --indx;
-                rawvalue = (cast(uint*)se.string)[indx];
+                rawvalue = se.getCodeUnit(indx);
                 if (!rvs)
                     ++indx;
                 break;
@@ -6540,7 +6612,7 @@ extern (C++) Expression foreachApplyUtf(InterState* istate, Expression str, Expr
         Expression val = null;
         for (int k = 0; k < charlen; ++k)
         {
-            dchar_t codepoint;
+            dchar codepoint;
             switch (charType.size())
             {
             case 1:
@@ -6606,9 +6678,9 @@ extern (C++) Expression evaluateIfBuiltin(InterState* istate, Loc loc, FuncDecla
             if (nargs == 1 && fd.ident == Id.aaLen)
                 return interpret_length(istate, firstarg);
             if (nargs == 3 && !strcmp(fd.ident.string, "_aaApply"))
-                return interpret_aaApply(istate, firstarg, cast(Expression)arguments.data[2]);
+                return interpret_aaApply(istate, firstarg, arguments.data[2]);
             if (nargs == 3 && !strcmp(fd.ident.string, "_aaApply2"))
-                return interpret_aaApply(istate, firstarg, cast(Expression)arguments.data[2]);
+                return interpret_aaApply(istate, firstarg, arguments.data[2]);
             if (nargs == 1 && !strcmp(fd.ident.string, "keys") && !strcmp(fd.toParent2().ident.string, "object"))
                 return interpret_keys(istate, firstarg, firstAAtype.index.arrayOf());
             if (nargs == 1 && !strcmp(fd.ident.string, "values") && !strcmp(fd.toParent2().ident.string, "object"))
diff --git a/ddmd/dmacro.d b/ddmd/dmacro.d
index ca59ae7305..191057e14d 100644
--- a/ddmd/dmacro.d
+++ b/ddmd/dmacro.d
@@ -209,7 +209,7 @@ public:
                     if (!m)
                     {
                         static __gshared const(char)* undef = "DDOC_UNDEFINED_MACRO";
-                        m = search(cast(const(char)*)undef, strlen(undef));
+                        m = search(undef, strlen(undef));
                         if (m)
                         {
                             // Macro was not defined, so this is an expansion of
diff --git a/ddmd/dmangle.d b/ddmd/dmangle.d
index 0e5b2b93d3..90082c1407 100644
--- a/ddmd/dmangle.d
+++ b/ddmd/dmangle.d
@@ -1,16 +1,18 @@
-// Compiler implementation of the D programming language
-// Copyright (c) 1999-2015 by Digital Mars
-// All Rights Reserved
-// written by Walter Bright
-// http://www.digitalmars.com
-// Distributed under the Boost Software License, Version 1.0.
-// http://www.boost.org/LICENSE_1_0.txt
+/**
+ * Compiler implementation of the $(LINK2 http://www.dlang.org, D programming language)
+ *
+ * Copyright: Copyright (c) 1999-2016 by Digital Mars, All Rights Reserved
+ * Authors: Walter Bright, http://www.digitalmars.com
+ * License:   $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
+ * Source:    $(DMDSRC dmangle.d)
+ */
 
 module ddmd.dmangle;
 
 import core.stdc.ctype;
 import core.stdc.stdio;
 import core.stdc.string;
+
 import ddmd.aggregate;
 import ddmd.arraytypes;
 import ddmd.cppmangle;
@@ -195,14 +197,14 @@ public:
 
     override void visit(TypeFunction t)
     {
-        //printf("TypeFunction::toDecoBuffer() t = %p %s\n", t, t->toChars());
+        //printf("TypeFunction.toDecoBuffer() t = %p %s\n", t, t.toChars());
         //static int nest; if (++nest == 50) *(char*)0=0;
         mangleFuncType(t, t, t.mod, t.next);
     }
 
     void mangleFuncType(TypeFunction t, TypeFunction ta, ubyte modMask, Type tret)
     {
-        //printf("mangleFuncType() %s\n", t->toChars());
+        //printf("mangleFuncType() %s\n", t.toChars());
         if (t.inuse)
         {
             t.inuse = 2; // flag error to caller
@@ -264,7 +266,7 @@ public:
         }
         // Write argument types
         paramsToDecoBuffer(t.parameters);
-        //if (buf->data[buf->offset - 1] == '@') assert(0);
+        //if (buf.data[buf.offset - 1] == '@') assert(0);
         buf.writeByte('Z' - t.varargs); // mark end of arg list
         if (tret !is null)
             visitWithMask(tret, 0);
@@ -287,21 +289,21 @@ public:
 
     override void visit(TypeStruct t)
     {
-        //printf("TypeStruct::toDecoBuffer('%s') = '%s'\n", t->toChars(), name);
+        //printf("TypeStruct.toDecoBuffer('%s') = '%s'\n", t.toChars(), name);
         visit(cast(Type)t);
         t.sym.accept(this);
     }
 
     override void visit(TypeClass t)
     {
-        //printf("TypeClass::toDecoBuffer('%s' mod=%x) = '%s'\n", t->toChars(), mod, name);
+        //printf("TypeClass.toDecoBuffer('%s' mod=%x) = '%s'\n", t.toChars(), mod, name);
         visit(cast(Type)t);
         t.sym.accept(this);
     }
 
     override void visit(TypeTuple t)
     {
-        //printf("TypeTuple::toDecoBuffer() t = %p, %s\n", t, t->toChars());
+        //printf("TypeTuple.toDecoBuffer() t = %p, %s\n", t, t.toChars());
         visit(cast(Type)t);
         OutBuffer buf2;
         buf2.reserve(32);
@@ -359,8 +361,8 @@ public:
 
     void mangleFunc(FuncDeclaration fd, bool inParent)
     {
-        //printf("deco = '%s'\n", fd->type->deco ? fd->type->deco : "null");
-        //printf("fd->type = %s\n", fd->type->toChars());
+        //printf("deco = '%s'\n", fd.type.deco ? fd.type.deco : "null");
+        //printf("fd.type = %s\n", fd.type.toChars());
         if (fd.needThis() || fd.isNested())
             buf.writeByte(Type.needThisPrefix());
         if (inParent)
@@ -397,8 +399,8 @@ public:
 
     override void visit(Declaration d)
     {
-        //printf("Declaration::mangle(this = %p, '%s', parent = '%s', linkage = %d)\n",
-        //        d, d->toChars(), d->parent ? d->parent->toChars() : "null", d->linkage);
+        //printf("Declaration.mangle(this = %p, '%s', parent = '%s', linkage = %d)\n",
+        //        d, d.toChars(), d.parent ? d.parent.toChars() : "null", d.linkage);
         if (!d.parent || d.parent.isModule() || d.linkage == LINKcpp) // if at global scope
         {
             switch (d.linkage)
@@ -446,11 +448,11 @@ public:
      *      void foo(long) {}           // _D4test3fooFlZv
      *      void foo(string) {}         // _D4test3fooFAyaZv
      *
-     *      // from FuncDeclaration::mangle().
+     *      // from FuncDeclaration.mangle().
      *      pragma(msg, foo.mangleof);  // prints unexact mangled name "4test3foo"
-     *                                  // by calling Dsymbol::mangle()
+     *                                  // by calling Dsymbol.mangle()
      *
-     *      // from FuncAliasDeclaration::mangle()
+     *      // from FuncAliasDeclaration.mangle()
      *      pragma(msg, __traits(getOverloads, test, "foo")[0].mangleof);  // "_D4test3fooFlZv"
      *      pragma(msg, __traits(getOverloads, test, "foo")[1].mangleof);  // "_D4test3fooFAyaZv"
      *
@@ -458,7 +460,7 @@ public:
      *
      *      void bar() {}
      *      pragma(msg, bar.mangleof);  // still prints "_D4test3barFZv"
-     *                                  // by calling FuncDeclaration::mangleExact().
+     *                                  // by calling FuncDeclaration.mangleExact().
      */
     override void visit(FuncDeclaration fd)
     {
@@ -566,7 +568,7 @@ public:
     {
         version (none)
         {
-            printf("TemplateInstance::mangle() %p %s", ti, ti.toChars());
+            printf("TemplateInstance.mangle() %p %s", ti, ti.toChars());
             if (ti.parent)
                 printf("  parent = %s %s", ti.parent.kind(), ti.parent.toChars());
             printf("\n");
@@ -578,22 +580,22 @@ public:
         ti.getIdent();
         const(char)* id = ti.ident ? ti.ident.toChars() : ti.toChars();
         toBuffer(id, ti);
-        //printf("TemplateInstance::mangle() %s = %s\n", ti->toChars(), ti->id);
+        //printf("TemplateInstance.mangle() %s = %s\n", ti.toChars(), ti.id);
     }
 
     override void visit(Dsymbol s)
     {
         version (none)
         {
-            printf("Dsymbol::mangle() '%s'", s.toChars());
+            printf("Dsymbol.mangle() '%s'", s.toChars());
             if (s.parent)
                 printf("  parent = %s %s", s.parent.kind(), s.parent.toChars());
             printf("\n");
         }
         mangleParent(s);
-        char* id = s.ident ? s.ident.toChars() : s.toChars();
+        auto id = s.ident ? s.ident.toChars() : s.toChars();
         toBuffer(id, s);
-        //printf("Dsymbol::mangle() %s = %s\n", s->toChars(), id);
+        //printf("Dsymbol.mangle() %s = %s\n", s.toChars(), id);
     }
 
     ////////////////////////////////////////////////////////////////////////////
@@ -654,6 +656,7 @@ public:
                     if (i < 2)
                         break;
                     // skip leading 0X
+                    goto default;
                 default:
                     buf.writeByte(c);
                     break;
@@ -687,15 +690,15 @@ public:
         {
         case 1:
             m = 'a';
-            q = cast(char*)e.string;
+            q = e.string;
             qlen = e.len;
             break;
         case 2:
             m = 'w';
             for (size_t u = 0; u < e.len;)
             {
-                uint c;
-                const(char)* p = utf_decodeWchar(cast(ushort*)e.string, e.len, &u, &c);
+                dchar c;
+                const p = utf_decodeWchar(e.wstring, e.len, u, c);
                 if (p)
                     e.error("%s", p);
                 else
@@ -771,7 +774,7 @@ public:
     ////////////////////////////////////////////////////////////////////////////
     void paramsToDecoBuffer(Parameters* parameters)
     {
-        //printf("Parameter::paramsToDecoBuffer()\n");
+        //printf("Parameter.paramsToDecoBuffer()\n");
 
         int paramsToDecoBufferDg(size_t n, Parameter p)
         {
diff --git a/ddmd/dmodule.d b/ddmd/dmodule.d
index 9aea738b3f..373b62d260 100644
--- a/ddmd/dmodule.d
+++ b/ddmd/dmodule.d
@@ -118,15 +118,18 @@ extern (C++) class Package : ScopeDsymbol
 {
 public:
     PKG isPkgMod;
+    uint tag;        // auto incremented tag, used to mask package tree in scopes
     Module mod;     // !=null if isPkgMod == PKGmodule
 
     final extern (D) this(Identifier ident)
     {
         super(ident);
         this.isPkgMod = PKGunknown;
+        __gshared uint packageTag;
+        this.tag = packageTag++;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "package";
     }
@@ -191,7 +194,7 @@ public:
         return dst;
     }
 
-    override final Package isPackage()
+    override final inout(Package) isPackage() inout
     {
         return this;
     }
@@ -209,25 +212,23 @@ public:
      * Returns:
      *  see description
      */
-    final bool isAncestorPackageOf(Package pkg)
+    final bool isAncestorPackageOf(const Package pkg) const
     {
-        while (pkg)
-        {
-            if (this == pkg)
-                return true;
-            if (!pkg.parent)
-                break;
-            pkg = pkg.parent.isPackage();
-        }
-        return false;
+        if (this == pkg)
+            return true;
+        if (!pkg || !pkg.parent)
+            return false;
+        return isAncestorPackageOf(pkg.parent.isPackage());
     }
 
     override final void semantic(Scope* sc)
     {
     }
 
-    override Dsymbol search(Loc loc, Identifier ident, int flags = IgnoreNone)
+    override Dsymbol search(Loc loc, Identifier ident, int flags = SearchLocalsOnly)
     {
+        //printf("%s Package.search('%s', flags = x%x)\n", toChars(), ident.toChars(), flags);
+        flags &= ~SearchLocalsOnly;  // searching an import is always transitive
         if (!isModule() && mod)
         {
             // Prefer full package name.
@@ -413,7 +414,7 @@ else
         //  foo.bar.baz
         // into:
         //  foo\bar\baz
-        char* filename = ident.toChars();
+        auto filename = ident.toChars();
         if (packages && packages.dim)
         {
             OutBuffer buf;
@@ -432,7 +433,7 @@ else
             }
             buf.writestring(filename);
             buf.writeByte(0);
-            filename = cast(char*)buf.extractData();
+            filename = buf.extractData();
         }
         auto m = new Module(filename, ident, 0, 0);
         m.loc = loc;
@@ -461,7 +462,7 @@ else
         return m;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "module";
     }
@@ -567,7 +568,7 @@ else
     Module parse(bool gen_docs = false)
     {
         //printf("Module::parse(srcfile='%s') this=%p\n", srcfile->name->toChars(), this);
-        char* srcname = srcfile.name.toChars();
+        const(char)* srcname = srcfile.name.toChars();
         //printf("Module::parse(srcname = '%s')\n", srcname);
         isPackageFile = (strcmp(srcfile.name.name(), "package.d") == 0);
         char* buf = cast(char*)srcfile.buffer;
@@ -618,7 +619,7 @@ else
                     }
                     dbuf.writeByte(0); // add 0 as sentinel for scanner
                     buflen = dbuf.offset - 1; // don't include sentinel in count
-                    buf = cast(char*)dbuf.extractData();
+                    buf = dbuf.extractData();
                 }
                 else
                 {
@@ -675,7 +676,7 @@ else
                     }
                     dbuf.writeByte(0); // add 0 as sentinel for scanner
                     buflen = dbuf.offset - 1; // don't include sentinel in count
-                    buf = cast(char*)dbuf.extractData();
+                    buf = dbuf.extractData();
                 }
             }
             else if (buf[0] == 0xFE && buf[1] == 0xFF)
@@ -843,29 +844,29 @@ else
             }
             if (arreq)
             {
-                scope Parser p = new Parser(loc, this, code_ArrayEq, strlen(cast(const(char)*)code_ArrayEq), 0);
+                scope Parser p = new Parser(loc, this, code_ArrayEq, strlen(code_ArrayEq), 0);
                 p.nextToken();
                 members.append(p.parseDeclDefs(0));
             }
             {
-                scope Parser p = new Parser(loc, this, code_ArrayPostblit, strlen(cast(const(char)*)code_ArrayPostblit), 0);
+                scope Parser p = new Parser(loc, this, code_ArrayPostblit, strlen(code_ArrayPostblit), 0);
                 p.nextToken();
                 members.append(p.parseDeclDefs(0));
             }
             {
-                scope Parser p = new Parser(loc, this, code_ArrayDtor, strlen(cast(const(char)*)code_ArrayDtor), 0);
+                scope Parser p = new Parser(loc, this, code_ArrayDtor, strlen(code_ArrayDtor), 0);
                 p.nextToken();
                 members.append(p.parseDeclDefs(0));
             }
             if (xopeq)
             {
-                scope Parser p = new Parser(loc, this, code_xopEquals, strlen(cast(const(char)*)code_xopEquals), 0);
+                scope Parser p = new Parser(loc, this, code_xopEquals, strlen(code_xopEquals), 0);
                 p.nextToken();
                 members.append(p.parseDeclDefs(0));
             }
             if (xopcmp)
             {
-                scope Parser p = new Parser(loc, this, code_xopCmp, strlen(cast(const(char)*)code_xopCmp), 0);
+                scope Parser p = new Parser(loc, this, code_xopCmp, strlen(code_xopCmp), 0);
                 p.nextToken();
                 members.append(p.parseDeclDefs(0));
             }
@@ -895,6 +896,7 @@ else
             p.parent = this.parent;
             p.isPkgMod = PKGmodule;
             p.mod = this;
+            p.tag = this.tag; // reuse the same package tag
             p.symtab = new DsymbolTable();
             s = p;
         }
@@ -925,6 +927,7 @@ else
                      */
                     pkg.isPkgMod = PKGmodule;
                     pkg.mod = this;
+                    pkg.tag = this.tag; // reuse the same package tag
                 }
                 else
                     error(md ? md.loc : loc, "from file %s conflicts with package name %s", srcname, pkg.toChars());
@@ -1023,7 +1026,7 @@ else
         for (size_t i = 0; i < members.dim; i++)
         {
             Dsymbol s = (*members)[i];
-            //printf("\tModule('%s'): '%s'.semantic()\n", toChars(), s->toChars());
+            //printf("\tModule('%s'): '%s'.semantic()\n", toChars(), s.toChars());
             s.semantic(sc);
             runDeferredSemantic();
         }
@@ -1109,15 +1112,22 @@ else
         return needmoduleinfo || global.params.cov;
     }
 
-    override Dsymbol search(Loc loc, Identifier ident, int flags = IgnoreNone)
+    override Dsymbol search(Loc loc, Identifier ident, int flags = SearchLocalsOnly)
     {
         /* Since modules can be circularly referenced,
          * need to stop infinite recursive searches.
          * This is done with the cache.
          */
-        //printf("%s Module::search('%s', flags = %d) insearch = %d\n", toChars(), ident->toChars(), flags, insearch);
+        //printf("%s Module.search('%s', flags = x%x) insearch = %d\n", toChars(), ident.toChars(), flags, insearch);
         if (insearch)
             return null;
+
+        /* Qualified module searches always search their imports,
+         * even if SearchLocalsOnly
+         */
+        if (!(flags & SearchUnqualifiedModule))
+            flags &= ~(SearchUnqualifiedModule | SearchLocalsOnly);
+
         if (searchCacheIdent == ident && searchCacheFlags == flags)
         {
             //printf("%s Module::search('%s', flags = %d) insearch = %d searchCacheSymbol = %s\n",
@@ -1166,7 +1176,8 @@ else
             if (sd == s)
                 return;
         }
-        //printf("Module::addDeferredSemantic('%s')\n", s->toChars());
+
+        //printf("Module::addDeferredSemantic('%s')\n", s.toChars());
         deferred.push(s);
     }
 
@@ -1177,11 +1188,13 @@ else
     {
         if (dprogress == 0)
             return;
+
         static __gshared int nested;
         if (nested)
             return;
         //if (deferred.dim) printf("+Module::runDeferredSemantic(), len = %d\n", deferred.dim);
         nested++;
+
         size_t len;
         do
         {
@@ -1189,6 +1202,7 @@ else
             len = deferred.dim;
             if (!len)
                 break;
+
             Dsymbol* todo;
             Dsymbol* todoalloc = null;
             Dsymbol tmp;
@@ -1204,11 +1218,12 @@ else
             }
             memcpy(todo, deferred.tdata(), len * Dsymbol.sizeof);
             deferred.setDim(0);
+
             for (size_t i = 0; i < len; i++)
             {
                 Dsymbol s = todo[i];
                 s.semantic(null);
-                //printf("deferred: %s, parent = %s\n", s->toChars(), s->parent->toChars());
+                //printf("deferred: %s, parent = %s\n", s.toChars(), s.parent.toChars());
             }
             //printf("\tdeferred.dim = %d, len = %d, dprogress = %d\n", deferred.dim, len, dprogress);
             if (todoalloc)
@@ -1237,8 +1252,9 @@ else
         for (size_t i = 0; i < a.dim; i++)
         {
             Dsymbol s = (*a)[i];
-            //printf("[%d] %s semantic3a\n", i, s->toPrettyChars());
+            //printf("[%d] %s semantic3a\n", i, s.toPrettyChars());
             s.semantic3(null);
+
             if (global.errors)
                 break;
         }
@@ -1328,7 +1344,7 @@ else
                 }
 
                 if (fqnNames) {
-                    char* name = md ? md.toChars() : toChars();
+                    const name = md ? md.toChars() : toChars();
                     argobj = FileName.replaceName(argobj, name);
 
                     // add ext, otherwise forceExt will make nested.module into nested.bc
@@ -1358,7 +1374,8 @@ else
         bool noModuleInfo; /// Do not emit any module metadata.
 
         // array ops emitted in this module already
-        AA* arrayfuncs;
+        import ddmd.func;
+        FuncDeclaration[void*] arrayfuncs;
 
         // Coverage analysis
         void* d_cover_valid;  // llvm::GlobalVariable* --> private immutable size_t[] _d_cover_valid;
@@ -1366,7 +1383,7 @@ else
         Array!size_t d_cover_valid_init; // initializer for _d_cover_valid
     }
 
-    override Module isModule()
+    override inout(Module) isModule() inout
     {
         return this;
     }
@@ -1393,7 +1410,7 @@ struct ModuleDeclaration
         this.id = id;
     }
 
-    extern (C++) char* toChars()
+    extern (C++) const(char)* toChars()
     {
         OutBuffer buf;
         if (packages && packages.dim)
diff --git a/ddmd/doc.d b/ddmd/doc.d
index d827a8cbe3..35ad6353d5 100644
--- a/ddmd/doc.d
+++ b/ddmd/doc.d
@@ -34,7 +34,6 @@ import ddmd.identifier;
 import ddmd.lexer;
 import ddmd.mars;
 import ddmd.mtype;
-import ddmd.root.aav;
 import ddmd.root.array;
 import ddmd.root.file;
 import ddmd.root.filename;
@@ -510,13 +509,13 @@ extern (C++) void gendocfile(Module m)
         time(&t);
         char* p = ctime(&t);
         p = mem.xstrdup(p);
-        Macro.define(&m.macrotable, cast(char*)"DATETIME", 8, cast(char*)p, strlen(p));
-        Macro.define(&m.macrotable, cast(char*)"YEAR", 4, cast(char*)p + 20, 4);
+        Macro.define(&m.macrotable, cast(char*)"DATETIME", 8, p, strlen(p));
+        Macro.define(&m.macrotable, cast(char*)"YEAR", 4, p + 20, 4);
     }
-    char* srcfilename = m.srcfile.toChars();
-    Macro.define(&m.macrotable, cast(char*)"SRCFILENAME", 11, cast(char*)srcfilename, strlen(srcfilename));
-    char* docfilename = m.docfile.toChars();
-    Macro.define(&m.macrotable, cast(char*)"DOCFILENAME", 11, cast(char*)docfilename, strlen(docfilename));
+    const srcfilename = m.srcfile.toChars();
+    Macro.define(&m.macrotable, "SRCFILENAME", 11, srcfilename, strlen(srcfilename));
+    const docfilename = m.docfile.toChars();
+    Macro.define(&m.macrotable, "DOCFILENAME", 11, docfilename, strlen(docfilename));
     if (dc.copyright)
     {
         dc.copyright.nooutput = 1;
@@ -658,25 +657,30 @@ extern (C++) void escapeDdocString(OutBuffer* buf, size_t start)
 extern (C++) void escapeStrayParenthesis(Loc loc, OutBuffer* buf, size_t start)
 {
     uint par_open = 0;
+    bool inCode = 0;
     for (size_t u = start; u < buf.offset; u++)
     {
         char c = buf.data[u];
         switch (c)
         {
         case '(':
-            par_open++;
+            if (!inCode)
+                par_open++;
             break;
         case ')':
-            if (par_open == 0)
+            if (!inCode)
             {
-                //stray ')'
-                warning(loc, "Ddoc: Stray ')'. This may cause incorrect Ddoc output. Use $(RPAREN) instead for unpaired right parentheses.");
-                buf.remove(u, 1); //remove the )
-                buf.insert(u, cast(const(char)*)"$(RPAREN)", 9); //insert this instead
-                u += 8; //skip over newly inserted macro
+                if (par_open == 0)
+                {
+                    //stray ')'
+                    warning(loc, "Ddoc: Stray ')'. This may cause incorrect Ddoc output. Use $(RPAREN) instead for unpaired right parentheses.");
+                    buf.remove(u, 1); //remove the )
+                    buf.insert(u, cast(const(char)*)"$(RPAREN)", 9); //insert this instead
+                    u += 8; //skip over newly inserted macro
+                }
+                else
+                    par_open--;
             }
-            else
-                par_open--;
             break;
             version (none)
             {
@@ -687,6 +691,18 @@ extern (C++) void escapeStrayParenthesis(Loc loc, OutBuffer* buf, size_t start)
                 loc.linnum++;
                 break;
             }
+        case '-':
+            // Issue 15465: don't try to escape unbalanced parens inside code
+            // blocks.
+            int numdash = 0;
+            while (u < buf.offset && buf.data[u] == '-')
+            {
+                numdash++;
+                u++;
+            }
+            if (numdash >= 3)
+                inCode = !inCode;
+            break;
         default:
             break;
         }
@@ -766,21 +782,34 @@ extern (C++) static void emitAnchor(OutBuffer* buf, Dsymbol s, Scope* sc)
     {
         OutBuffer anc;
         emitAnchorName(&anc, s, skipNonQualScopes(sc));
-        ident = Identifier.idPool(anc.peekString());
+        ident = Identifier.idPool(anc.peekSlice());
     }
-    size_t* count = cast(size_t*)dmd_aaGet(&sc.anchorCounts, cast(void*)ident);
-    TemplateDeclaration td = getEponymousParent(s);
-    // don't write an anchor for matching consecutive ditto symbols
-    if (*count > 0 && sc.prevAnchor == ident && sc.lastdc && (isDitto(s.comment) || (td && isDitto(td.comment))))
-        return;
-    (*count)++;
+
+    auto pcount = cast(void*)ident in sc.anchorCounts;
+    typeof(*pcount) count;
+    if (pcount)
+    {
+        // Existing anchor,
+        // don't write an anchor for matching consecutive ditto symbols
+        TemplateDeclaration td = getEponymousParent(s);
+        if (sc.prevAnchor == ident && sc.lastdc && (isDitto(s.comment) || (td && isDitto(td.comment))))
+            return;
+
+        count = ++*pcount;
+    }
+    else
+    {
+        sc.anchorCounts[cast(void*)ident] = 1;
+        count = 1;
+    }
+
     // cache anchor name
     sc.prevAnchor = ident;
     buf.writestring("$(DDOC_ANCHOR ");
     buf.writestring(ident.string);
     // only append count once there's a duplicate
-    if (*count != 1)
-        buf.printf(".%u", *count);
+    if (count > 1)
+        buf.printf(".%u", count);
     buf.writeByte(')');
 }
 
@@ -1860,7 +1889,7 @@ extern (C++) bool isDitto(const(char)* comment)
     if (comment)
     {
         const(char)* p = skipwhitespace(comment);
-        if (Port.memicmp(cast(const(char)*)p, "ditto", 5) == 0 && *skipwhitespace(p + 5) == 0)
+        if (Port.memicmp(p, "ditto", 5) == 0 && *skipwhitespace(p + 5) == 0)
             return true;
     }
     return false;
@@ -1897,9 +1926,9 @@ extern (C++) size_t skiptoident(OutBuffer* buf, size_t i)
 {
     while (i < buf.offset)
     {
-        dchar_t c;
+        dchar c;
         size_t oi = i;
-        if (utf_decodeChar(cast(char*)buf.data, buf.offset, &i, &c))
+        if (utf_decodeChar(cast(char*)buf.data, buf.offset, i, c))
         {
             /* Ignore UTF errors, but still consume input
              */
@@ -1925,9 +1954,9 @@ extern (C++) size_t skippastident(OutBuffer* buf, size_t i)
 {
     while (i < buf.offset)
     {
-        dchar_t c;
+        dchar c;
         size_t oi = i;
-        if (utf_decodeChar(cast(char*)buf.data, buf.offset, &i, &c))
+        if (utf_decodeChar(cast(char*)buf.data, buf.offset, i, c))
         {
             /* Ignore UTF errors, but still consume input
              */
@@ -1959,11 +1988,11 @@ extern (C++) size_t skippastURL(OutBuffer* buf, size_t i)
     char* p = cast(char*)&buf.data[i];
     size_t j;
     uint sawdot = 0;
-    if (length > 7 && Port.memicmp(cast(char*)p, "http://", 7) == 0)
+    if (length > 7 && Port.memicmp(p, "http://", 7) == 0)
     {
         j = 7;
     }
-    else if (length > 8 && Port.memicmp(cast(char*)p, "https://", 8) == 0)
+    else if (length > 8 && Port.memicmp(p, "https://", 8) == 0)
     {
         j = 8;
     }
@@ -2548,7 +2577,6 @@ extern (C++) void highlightCode(Scope* sc, Dsymbols* a, OutBuffer* buf, size_t o
                     static immutable templateParamListMacro = "$(DDOC_TEMPLATE_PARAM_LIST ";
                     size_t paramListEnd = buf.bracket(i, templateParamListMacro.ptr, i + templateParamsLen, ")") - 1;
 
-
                     // We have the parameter list. While we're here we might
                     // as well wrap the parameters themselves as well
 
@@ -2672,13 +2700,13 @@ extern (C++) bool isCVariadicArg(const(char)* p, size_t len)
  */
 extern (C++) bool isIdStart(const(char)* p)
 {
-    uint c = *p;
+    dchar c = *p;
     if (isalpha(c) || c == '_')
         return true;
     if (c >= 0x80)
     {
         size_t i = 0;
-        if (utf_decodeChar(p, 4, &i, &c))
+        if (utf_decodeChar(p, 4, i, c))
             return false; // ignore errors
         if (isUniAlpha(c))
             return true;
@@ -2691,13 +2719,13 @@ extern (C++) bool isIdStart(const(char)* p)
  */
 extern (C++) bool isIdTail(const(char)* p)
 {
-    uint c = *p;
+    dchar c = *p;
     if (isalnum(c) || c == '_')
         return true;
     if (c >= 0x80)
     {
         size_t i = 0;
-        if (utf_decodeChar(p, 4, &i, &c))
+        if (utf_decodeChar(p, 4, i, c))
             return false; // ignore errors
         if (isUniAlpha(c))
             return true;
@@ -2718,10 +2746,10 @@ extern (C++) bool isIndentWS(const(char)* p)
  */
 extern (C++) int utfStride(const(char)* p)
 {
-    uint c = *p;
+    dchar c = *p;
     if (c < 0x80)
         return 1;
     size_t i = 0;
-    utf_decodeChar(p, 4, &i, &c); // ignore errors, but still consume input
+    utf_decodeChar(p, 4, i, c); // ignore errors, but still consume input
     return cast(int)i;
 }
diff --git a/ddmd/dscope.d b/ddmd/dscope.d
index f59299ec09..fb2ce2b4f4 100644
--- a/ddmd/dscope.d
+++ b/ddmd/dscope.d
@@ -26,13 +26,14 @@ import ddmd.globals;
 import ddmd.id;
 import ddmd.identifier;
 import ddmd.mtype;
-import ddmd.root.aav;
 import ddmd.root.outbuffer;
 import ddmd.root.rmem;
 import ddmd.root.speller;
 import ddmd.root.stringtable;
 import ddmd.statement;
 
+//version=LOGSEARCH;
+
 extern (C++) bool mergeFieldInit(Loc loc, ref uint fieldInit, uint fi, bool mustInit)
 {
     if (fi != fieldInit)
@@ -104,6 +105,8 @@ enum SCOPEctfe          = 0x0080;   // inside a ctfe-only expression
 enum SCOPEcompile       = 0x0100;   // inside __traits(compile)
 enum SCOPEfree          = 0x8000;   // is on free list
 
+enum SCOPEfullinst      = 0x10000;  // fully instantiate templates
+
 struct Scope
 {
     Scope* enclosing;               // enclosing Scope
@@ -157,7 +160,7 @@ struct Scope
     int explicitProtection;         // set if in an explicit protection attribute
 
     StorageClass stc;               // storage class
-    char* depmsg;                   // customized deprecation message
+    DeprecatedDeclaration depdecl;  // customized deprecation message
 
     uint flags;
 
@@ -165,8 +168,8 @@ struct Scope
     UserAttributeDeclaration userAttribDecl;
 
     DocComment* lastdc;        // documentation comment for last symbol at this scope
-    AA* anchorCounts;        // lookup duplicate anchor name count
-    Identifier prevAnchor;        // qualified symbol name of last doc anchor
+    uint[void*] anchorCounts;  // lookup duplicate anchor name count
+    Identifier prevAnchor;     // qualified symbol name of last doc anchor
 
     extern (C++) static __gshared Scope* freelist;
 
@@ -256,14 +259,15 @@ struct Scope
         if (enclosing)
         {
             enclosing.callSuper |= callSuper;
-            if (enclosing.fieldinit && fieldinit)
+            if (fieldinit)
             {
-                assert(fieldinit != enclosing.fieldinit);
-                size_t dim = fieldinit_dim;
-                for (size_t i = 0; i < dim; i++)
-                    enclosing.fieldinit[i] |= fieldinit[i];
-                mem.xfree(fieldinit);
-                fieldinit = null;
+                if (enclosing.fieldinit)
+                {
+                    assert(fieldinit != enclosing.fieldinit);
+                    foreach (i; 0 .. fieldinit_dim)
+                        enclosing.fieldinit[i] |= fieldinit[i];
+                }
+                freeFieldinit();
             }
         }
         if (!nofree)
@@ -275,6 +279,20 @@ struct Scope
         return enc;
     }
 
+    void allocFieldinit(size_t dim)
+    {
+        fieldinit = cast(typeof(fieldinit))mem.xcalloc(typeof(*fieldinit).sizeof, dim);
+        fieldinit_dim = dim;
+    }
+
+    void freeFieldinit()
+    {
+        if (fieldinit)
+            mem.xfree(fieldinit);
+        fieldinit = null;
+        fieldinit_dim = 0;
+    }
+
     extern (C++) Scope* startCTFE()
     {
         Scope* sc = this.push();
@@ -412,9 +430,44 @@ else
         return minst ? minst : _module;
     }
 
+    /************************************
+     * Perform unqualified name lookup by following the chain of scopes up
+     * until found.
+     *
+     * Params:
+     *  loc = location to use for error messages
+     *  ident = name to look up
+     *  pscopesym = if supplied and name is found, set to scope that ident was found in
+     *  flags = modify search based on flags
+     *
+     * Returns:
+     *  symbol if found, null if not
+     */
     extern (C++) Dsymbol search(Loc loc, Identifier ident, Dsymbol* pscopesym, int flags = IgnoreNone)
     {
-        //printf("Scope::search(%p, '%s')\n", this, ident->toChars());
+        version (LOGSEARCH)
+        {
+            printf("Scope.search(%p, '%s' flags=x%x)\n", &this, ident.toChars(), flags);
+            // Print scope chain
+            for (Scope* sc = &this; sc; sc = sc.enclosing)
+            {
+                if (!sc.scopesym)
+                    continue;
+                printf("\tscope %s\n", sc.scopesym.toChars());
+            }
+
+            static void printMsg(string txt, Dsymbol s)
+            {
+                printf("%.*s  %s.%s, kind = '%s'\n", cast(int)msg.length, msg.ptr,
+                    s.parent ? s.parent.toChars() : "", s.toChars(), s.kind());
+            }
+        }
+
+        // This function is called only for unqualified lookup
+        assert(!(flags & (SearchLocalsOnly | SearchImportsOnly)));
+
+        /* If ident is "start at module scope", only look at module scope
+         */
         if (ident == Id.empty)
         {
             // Look for module scope
@@ -425,7 +478,7 @@ else
                     continue;
                 if (Dsymbol s = sc.scopesym.isModule())
                 {
-                    //printf("\tfound %s.%s\n", s->parent ? s->parent->toChars() : "", s->toChars());
+                    //printMsg("\tfound", s);
                     if (pscopesym)
                         *pscopesym = sc.scopesym;
                     return s;
@@ -433,25 +486,90 @@ else
             }
             return null;
         }
-        for (Scope* sc = &this; sc; sc = sc.enclosing)
+
+        Dsymbol searchScopes(int flags)
         {
-            assert(sc != sc.enclosing);
-            if (!sc.scopesym)
-                continue;
-            //printf("\tlooking in scopesym '%s', kind = '%s'\n", sc->scopesym->toChars(), sc->scopesym->kind());
-            if (Dsymbol s = sc.scopesym.search(loc, ident, flags))
+            for (Scope* sc = &this; sc; sc = sc.enclosing)
             {
-                if (ident == Id.length && sc.scopesym.isArrayScopeSymbol() && sc.enclosing && sc.enclosing.search(loc, ident, null, flags))
+                assert(sc != sc.enclosing);
+                if (!sc.scopesym)
+                    continue;
+                //printf("\tlooking in scopesym '%s', kind = '%s', flags = x%x\n", sc.scopesym.toChars(), sc.scopesym.kind(), flags);
+
+                if (sc.scopesym.isModule())
+                    flags |= SearchUnqualifiedModule;        // tell Module.search() that SearchLocalsOnly is to be obeyed
+
+                if (Dsymbol s = sc.scopesym.search(loc, ident, flags))
                 {
-                    warning(s.loc, "array 'length' hides other 'length' name in outer scope");
+                    if (!(flags & (SearchImportsOnly | IgnoreErrors)) &&
+                        ident == Id.length && sc.scopesym.isArrayScopeSymbol() &&
+                        sc.enclosing && sc.enclosing.search(loc, ident, null, flags))
+                    {
+                        warning(s.loc, "array 'length' hides other 'length' name in outer scope");
+                    }
+                    //printMsg("\tfound local", s);
+                    if (pscopesym)
+                        *pscopesym = sc.scopesym;
+                    return s;
                 }
-                //printf("\tfound %s.%s, kind = '%s'\n", s->parent ? s->parent->toChars() : "", s->toChars(), s->kind());
-                if (pscopesym)
-                    *pscopesym = sc.scopesym;
-                return s;
+                // Stop when we hit a module, but keep going if that is not just under the global scope
+                if (sc.scopesym.isModule() && !(sc.enclosing && !sc.enclosing.enclosing))
+                    break;
+            }
+            return null;
+        }
+
+        Dsymbol sold = void;
+        if (global.params.bug10378 || global.params.check10378)
+        {
+            sold = searchScopes(flags | IgnoreSymbolVisibility);
+            if (!global.params.check10378)
+                return sold;
+
+            if (ident == Id.dollar) // Bugzilla 15825
+                return sold;
+
+            // Search both ways
+            flags |= SearchCheck10378;
+        }
+
+        // First look in local scopes
+        Dsymbol s = searchScopes(flags | SearchLocalsOnly);
+        version (LOGSEARCH) if (s) printMsg("-Scope.search() found local", s);
+        if (!s)
+        {
+            // Second look in imported modules
+            s = searchScopes(flags | SearchImportsOnly);
+            version (LOGSEARCH) if (s) printMsg("-Scope.search() found import", s);
+
+            /** Still find private symbols, so that symbols that weren't access
+             * checked by the compiler remain usable.  Once the deprecation is over,
+             * this should be moved to search_correct instead.
+             */
+            if (!s)
+            {
+                s = searchScopes(flags | SearchLocalsOnly | IgnoreSymbolVisibility);
+                if (!s)
+                    s = searchScopes(flags | SearchImportsOnly | IgnoreSymbolVisibility);
+
+                if (s && !(flags & IgnoreErrors))
+                    .deprecation(loc, "%s is not visible from module %s", s.toPrettyChars(), _module.toChars());
+                version (LOGSEARCH) if (s) printMsg("-Scope.search() found imported private symbol", s);
             }
         }
-        return null;
+        if (global.params.check10378)
+        {
+            alias snew = s;
+            if (sold !is snew)
+            {
+                deprecation(loc, "local import search method found %s %s instead of %s %s",
+                    sold ? sold.kind() : "nothing", sold ? sold.toPrettyChars() : null,
+                    snew ? snew.kind() : "nothing", snew ? snew.toPrettyChars() : null);
+            }
+            if (global.params.bug10378)
+                s = sold;
+        }
+        return s;
     }
 
     extern (C++) Dsymbol search_correct(Identifier ident)
@@ -609,7 +727,7 @@ else
         this.protection = sc.protection;
         this.explicitProtection = sc.explicitProtection;
         this.stc = sc.stc;
-        this.depmsg = sc.depmsg;
+        this.depdecl = sc.depdecl;
         this.inunion = sc.inunion;
         this.nofree = sc.nofree;
         this.noctor = sc.noctor;
diff --git a/ddmd/dstruct.d b/ddmd/dstruct.d
index 2eb80e76f4..9047465ecd 100644
--- a/ddmd/dstruct.d
+++ b/ddmd/dstruct.d
@@ -270,7 +270,7 @@ public:
 
     override final void semantic(Scope* sc)
     {
-        //printf("StructDeclaration::semantic(this=%p, %s '%s', sizeok = %d)\n", this, parent.toChars(), toChars(), sizeok);
+        //printf("StructDeclaration::semantic(this=%p, '%s', sizeok = %d)\n", this, toPrettyChars(), sizeok);
 
         //static int count; if (++count == 20) assert(0);
 
@@ -279,7 +279,7 @@ public:
         uint dprogress_save = Module.dprogress;
         int errors = global.errors;
 
-        //printf("+StructDeclaration::semantic(this=%p, %s '%s', sizeok = %d)\n", this, parent.toChars(), toChars(), sizeok);
+        //printf("+StructDeclaration::semantic(this=%p, '%s', sizeok = %d)\n", this, toPrettyChars(), sizeok);
         Scope* scx = null;
         if (_scope)
         {
@@ -296,7 +296,7 @@ public:
         assert(parent && !isAnonymous());
 
         if (this.errors)
-           type = Type.terror;
+            type = Type.terror;
         type = type.semantic(loc, sc);
         if (type.ty == Tstruct && (cast(TypeStruct)type).sym != this)
         {
@@ -342,7 +342,7 @@ public:
             for (size_t i = 0; i < members.dim; i++)
             {
                 Dsymbol s = (*members)[i];
-                //printf("adding member '%s' to '%s'\n", s->toChars(), this->toChars());
+                //printf("adding member '%s' to '%s'\n", s.toChars(), this.toChars());
                 s.addMember(sc, this);
             }
         }
@@ -367,7 +367,7 @@ public:
         for (size_t i = 0; i < members.dim; i++)
         {
             Dsymbol s = (*members)[i];
-            //printf("struct: setScope %s %s\n", s->kind(), s->toChars());
+            //printf("struct: setScope %s %s\n", s.kind(), s.toChars());
             s.setScope(sc2);
         }
 
@@ -383,7 +383,7 @@ public:
             s.semantic(sc2);
         }
 
-        finalizeSize(sc2);
+        finalizeSize();
 
         if (sizeok == SIZEOKfwd)
         {
@@ -451,16 +451,6 @@ public:
         xcmp = buildXopCmp(this, sc2);
         xhash = buildXtoHash(this, sc2);
 
-        /* Even if the struct is merely imported and its semantic3 is not run,
-         * the TypeInfo object would be speculatively stored in each object
-         * files. To set correct function pointer, run semantic3 for xeq and xcmp.
-         */
-        //if ((xeq && xeq != xerreq || xcmp && xcmp != xerrcmp) && isImportedSym(this))
-        //    Module::addDeferredSemantic3(this);
-
-        /* Defer requesting semantic3 until TypeInfo generation is actually invoked.
-         * See semanticTypeInfo().
-         */
         inv = buildInv(this, sc2);
 
         sc2.pop();
@@ -580,9 +570,9 @@ public:
         }
     }
 
-    override final Dsymbol search(Loc loc, Identifier ident, int flags = IgnoreNone)
+    override final Dsymbol search(Loc loc, Identifier ident, int flags = SearchLocalsOnly)
     {
-        //printf("%s.StructDeclaration::search('%s')\n", toChars(), ident->toChars());
+        //printf("%s.StructDeclaration::search('%s', flags = x%x)\n", toChars(), ident.toChars(), flags);
         if (_scope && !symtab)
             semantic(_scope);
 
@@ -595,12 +585,12 @@ public:
         return ScopeDsymbol.search(loc, ident, flags);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "struct";
     }
 
-    override final void finalizeSize(Scope* sc)
+    override final void finalizeSize()
     {
         //printf("StructDeclaration::finalizeSize() %s\n", toChars());
         if (sizeok != SIZEOKnone)
@@ -769,7 +759,7 @@ public:
             if (e.op == TOKerror)
                 return false;
 
-            (*elements)[i] = e.isLvalue() ? callCpCtor(sc, e) : valueNoDtor(e);
+            (*elements)[i] = doCopyOrMove(sc, e);
         }
         return true;
     }
@@ -819,7 +809,7 @@ public:
         return (ispod == ISPODyes);
     }
 
-    override final StructDeclaration isStructDeclaration()
+    override final inout(StructDeclaration) isStructDeclaration() inout
     {
         return this;
     }
@@ -847,12 +837,12 @@ public:
         return StructDeclaration.syntaxCopy(ud);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "union";
     }
 
-    override UnionDeclaration isUnionDeclaration()
+    override inout(UnionDeclaration) isUnionDeclaration() inout
     {
         return this;
     }
diff --git a/ddmd/dsymbol.d b/ddmd/dsymbol.d
index 70a90e7bb7..fdf69b8af6 100644
--- a/ddmd/dsymbol.d
+++ b/ddmd/dsymbol.d
@@ -11,6 +11,8 @@ module ddmd.dsymbol;
 import core.stdc.stdarg;
 import core.stdc.stdio;
 import core.stdc.string;
+import core.stdc.stdlib;
+
 import ddmd.aggregate;
 import ddmd.aliasthis;
 import ddmd.arraytypes;
@@ -98,11 +100,13 @@ struct Prot
         this.kind = kind;
     }
 
+    extern (C++):
+
     /**
      * Checks if `this` is superset of `other` restrictions.
      * For example, "protected" is more restrictive than "public".
      */
-    extern (C++) bool isMoreRestrictiveThan(Prot other)
+    bool isMoreRestrictiveThan(const Prot other) const
     {
         return this.kind < other.kind;
     }
@@ -110,7 +114,7 @@ struct Prot
     /**
      * Checks if `this` is absolutely identical protection attribute to `other`
      */
-    extern (C++) bool opEquals(Prot other)
+    bool opEquals(ref const Prot other) const
     {
         if (this.kind == other.kind)
         {
@@ -131,7 +135,7 @@ struct Prot
      *  'true' if parent is already more restrictive than this one and thus
      *  no differentiation is needed.
      */
-    extern (C++) bool isSubsetOf(Prot parent)
+    bool isSubsetOf(ref const Prot parent) const
     {
         if (this.kind != parent.kind)
             return false;
@@ -173,12 +177,21 @@ alias PASSinline = PASS.PASSinline;
 alias PASSinlinedone = PASS.PASSinlinedone;
 alias PASSobj = PASS.PASSobj;
 
+// Search options
 enum : int
 {
     IgnoreNone              = 0x00, // default
-    IgnorePrivateMembers    = 0x01, // don't find private members
+    IgnorePrivateImports    = 0x01, // don't search private imports
     IgnoreErrors            = 0x02, // don't give error messages
     IgnoreAmbiguous         = 0x04, // return NULL if ambiguous
+    SearchLocalsOnly        = 0x08, // only look at locals (don't search imports)
+    SearchImportsOnly       = 0x10, // only look in imports
+    SearchUnqualifiedModule = 0x20, // the module scope search is unqualified,
+                                    // meaning don't search imports in that scope,
+                                    // because qualified module searches search
+                                    // their imports
+    SearchCheck10378        = 0x40, // unqualified search with transition=checkimports switch
+    IgnoreSymbolVisibility  = 0x80, // also find private and package protected symbols
 }
 
 extern (C++) alias Dsymbol_apply_ft_t = int function(Dsymbol, void*);
@@ -195,10 +208,11 @@ public:
     const(char)* comment;   // documentation comment for this Dsymbol
     Loc loc;                // where defined
     Scope* _scope;          // !=null means context to use for semantic()
+    const(char)* prettystring;  // cached value of toPrettyChars()
     bool errors;            // this symbol failed to pass semantic()
     PASS semanticRun;
 
-    char* depmsg;           // customized deprecation message
+    DeprecatedDeclaration depdecl;           // customized deprecation message
     UserAttributeDeclaration userAttribDecl;    // user defined attributes
 
     // !=null means there's a ddoc unittest associated with this symbol
@@ -248,13 +262,13 @@ public:
         return new Dsymbol(ident);
     }
 
-    override char* toChars()
+    override const(char)* toChars()
     {
-        return ident ? ident.toChars() : cast(char*)"__anonymous";
+        return ident ? ident.toChars() : "__anonymous";
     }
 
     // helper to print fully qualified (template) arguments
-    char* toPrettyCharsHelper()
+    const(char)* toPrettyCharsHelper()
     {
         return toChars();
     }
@@ -263,14 +277,14 @@ public:
     {
         if (!loc.filename) // avoid bug 5861.
         {
-            Module m = getModule();
+            auto m = getModule();
             if (m && m.srcfile)
                 loc.filename = m.srcfile.toChars();
         }
         return loc;
     }
 
-    final char* locToChars()
+    final const(char)* locToChars()
     {
         return getLoc().toChars();
     }
@@ -344,7 +358,7 @@ public:
             const(char)* message = null;
             for (Dsymbol p = this; p; p = p.parent)
             {
-                message = p.depmsg;
+                message = p.depdecl ? p.depdecl.getMessage() : null;
                 if (message)
                     break;
             }
@@ -509,34 +523,62 @@ public:
 
     const(char)* toPrettyChars(bool QualifyTypes = false)
     {
-        Dsymbol p;
-        char* s;
-        char* q;
-        size_t len;
+        if (prettystring && !QualifyTypes)
+            return prettystring;
+
         //printf("Dsymbol::toPrettyChars() '%s'\n", toChars());
         if (!parent)
-            return toChars();
-        len = 0;
-        for (p = this; p; p = p.parent)
-            len += strlen(QualifyTypes ? p.toPrettyCharsHelper() : p.toChars()) + 1;
-        s = cast(char*)mem.xmalloc(len);
-        q = s + len - 1;
-        *q = 0;
-        for (p = this; p; p = p.parent)
         {
-            char* t = QualifyTypes ? p.toPrettyCharsHelper() : p.toChars();
-            len = strlen(t);
+            auto s = toChars();
+            if (!QualifyTypes)
+                prettystring = s;
+            return s;
+        }
+
+        // Computer number of components
+        size_t complength = 0;
+        for (Dsymbol p = this; p; p = p.parent)
+            ++complength;
+
+        // Allocate temporary array comp[]
+        alias T = const(char)[];
+        auto compptr = cast(T*)malloc(complength * T.sizeof);
+        if (!compptr)
+            Mem.error();
+        auto comp = compptr[0 .. complength];
+
+        // Fill in comp[] and compute length of final result
+        size_t length = 0;
+        int i;
+        for (Dsymbol p = this; p; p = p.parent)
+        {
+            const s = QualifyTypes ? p.toPrettyCharsHelper() : p.toChars();
+            const len = strlen(s);
+            comp[i] = s[0 .. len];
+            ++i;
+            length += len + 1;
+        }
+
+        auto s = cast(char*)mem.xmalloc(length);
+        auto q = s + length - 1;
+        *q = 0;
+        foreach (j; 0 .. complength)
+        {
+            const t = comp[j].ptr;
+            const len = comp[j].length;
             q -= len;
             memcpy(q, t, len);
             if (q == s)
                 break;
-            q--;
-            *q = '.';
+            *--q = '.';
         }
+        free(comp.ptr);
+        if (!QualifyTypes)
+            prettystring = s;
         return s;
     }
 
-    const(char)* kind()
+    const(char)* kind() const
     {
         return "symbol";
     }
@@ -602,8 +644,8 @@ public:
         if (!sc.nofree)
             sc.setNoFree(); // may need it even after semantic() finishes
         _scope = sc;
-        if (sc.depmsg)
-            depmsg = sc.depmsg;
+        if (sc.depdecl)
+            depdecl = sc.depdecl;
         if (!userAttribDecl)
             userAttribDecl = sc.userAttribDecl;
     }
@@ -638,14 +680,16 @@ public:
 
     /*********************************************
      * Search for ident as member of s.
-     * Input:
-     *      flags:  (see IgnoreXXX declared in dsymbol.h)
+     * Params:
+     *  loc = location to print for error messages
+     *  ident = identifier to search for
+     *  flags = IgnoreXXXX
      * Returns:
-     *      NULL if not found
+     *  null if not found
      */
     Dsymbol search(Loc loc, Identifier ident, int flags = IgnoreNone)
     {
-        //printf("Dsymbol::search(this=%p,%s, ident='%s')\n", this, toChars(), ident->toChars());
+        //printf("Dsymbol::search(this=%p,%s, ident='%s')\n", this, toChars(), ident.toChars());
         return null;
     }
 
@@ -808,11 +852,6 @@ public:
         return false;
     }
 
-    bool hasOverloads()
-    {
-        return false;
-    }
-
     // is this a LabelDsymbol()?
     LabelDsymbol isLabel()
     {
@@ -1007,216 +1046,218 @@ public:
     }
 
     // Eliminate need for dynamic_cast
-    Package isPackage()
+    inout(Package) isPackage() inout
     {
         return null;
     }
 
-    Module isModule()
+    inout(Module) isModule() inout
     {
         return null;
     }
 
-    EnumMember isEnumMember()
+    inout(EnumMember) isEnumMember() inout
     {
         return null;
     }
 
-    TemplateDeclaration isTemplateDeclaration()
+    inout(TemplateDeclaration) isTemplateDeclaration() inout
     {
         return null;
     }
 
-    TemplateInstance isTemplateInstance()
+    inout(TemplateInstance) isTemplateInstance() inout
     {
         return null;
     }
 
-    TemplateMixin isTemplateMixin()
+    inout(TemplateMixin) isTemplateMixin() inout
     {
         return null;
     }
 
-    Nspace isNspace()
+    inout(Nspace) isNspace() inout
     {
         return null;
     }
 
-    Declaration isDeclaration()
+    inout(Declaration) isDeclaration() inout
     {
         return null;
     }
 
-    ThisDeclaration isThisDeclaration()
+    inout(ThisDeclaration) isThisDeclaration() inout
     {
         return null;
     }
 
-    TypeInfoDeclaration isTypeInfoDeclaration()
+    inout(TypeInfoDeclaration) isTypeInfoDeclaration() inout
     {
         return null;
     }
 
-    TupleDeclaration isTupleDeclaration()
+    inout(TupleDeclaration) isTupleDeclaration() inout
     {
         return null;
     }
 
-    AliasDeclaration isAliasDeclaration()
+    inout(AliasDeclaration) isAliasDeclaration() inout
     {
         return null;
     }
 
-    AggregateDeclaration isAggregateDeclaration()
+    inout(AggregateDeclaration) isAggregateDeclaration() inout
     {
         return null;
     }
 
-    FuncDeclaration isFuncDeclaration()
+    inout(FuncDeclaration) isFuncDeclaration() inout
     {
         return null;
     }
 
-    FuncAliasDeclaration isFuncAliasDeclaration()
+    inout(FuncAliasDeclaration) isFuncAliasDeclaration() inout
     {
         return null;
     }
 
-    OverDeclaration isOverDeclaration()
+    inout(OverDeclaration) isOverDeclaration() inout
     {
         return null;
     }
 
-    FuncLiteralDeclaration isFuncLiteralDeclaration()
+    inout(FuncLiteralDeclaration) isFuncLiteralDeclaration() inout
     {
         return null;
     }
 
-    CtorDeclaration isCtorDeclaration()
+    inout(CtorDeclaration) isCtorDeclaration() inout
     {
         return null;
     }
 
-    PostBlitDeclaration isPostBlitDeclaration()
+    inout(PostBlitDeclaration) isPostBlitDeclaration() inout
     {
         return null;
     }
 
-    DtorDeclaration isDtorDeclaration()
+    inout(DtorDeclaration) isDtorDeclaration() inout
     {
         return null;
     }
 
-    StaticCtorDeclaration isStaticCtorDeclaration()
+    inout(StaticCtorDeclaration) isStaticCtorDeclaration() inout
     {
         return null;
     }
 
-    StaticDtorDeclaration isStaticDtorDeclaration()
+    inout(StaticDtorDeclaration) isStaticDtorDeclaration() inout
     {
         return null;
     }
 
-    SharedStaticCtorDeclaration isSharedStaticCtorDeclaration()
+    inout(SharedStaticCtorDeclaration) isSharedStaticCtorDeclaration() inout
     {
         return null;
     }
 
-    SharedStaticDtorDeclaration isSharedStaticDtorDeclaration()
+    inout(SharedStaticDtorDeclaration) isSharedStaticDtorDeclaration() inout
     {
         return null;
     }
 
-    InvariantDeclaration isInvariantDeclaration()
+    inout(InvariantDeclaration) isInvariantDeclaration() inout
     {
         return null;
     }
 
-    UnitTestDeclaration isUnitTestDeclaration()
+    inout(UnitTestDeclaration) isUnitTestDeclaration() inout
     {
         return null;
     }
 
-    NewDeclaration isNewDeclaration()
+    inout(NewDeclaration) isNewDeclaration() inout
     {
         return null;
     }
 
-    VarDeclaration isVarDeclaration()
+    inout(VarDeclaration) isVarDeclaration() inout
     {
         return null;
     }
 
-    ClassDeclaration isClassDeclaration()
+    inout(ClassDeclaration) isClassDeclaration() inout
     {
         return null;
     }
 
-    StructDeclaration isStructDeclaration()
+    inout(StructDeclaration) isStructDeclaration() inout
     {
         return null;
     }
 
-    UnionDeclaration isUnionDeclaration()
+    inout(UnionDeclaration) isUnionDeclaration() inout
     {
         return null;
     }
 
-    InterfaceDeclaration isInterfaceDeclaration()
+    inout(InterfaceDeclaration) isInterfaceDeclaration() inout
     {
         return null;
     }
 
-    ScopeDsymbol isScopeDsymbol()
+    inout(ScopeDsymbol) isScopeDsymbol() inout
     {
         return null;
     }
 
-    WithScopeSymbol isWithScopeSymbol()
+    inout(WithScopeSymbol) isWithScopeSymbol() inout
     {
         return null;
     }
 
-    ArrayScopeSymbol isArrayScopeSymbol()
+    inout(ArrayScopeSymbol) isArrayScopeSymbol() inout
     {
         return null;
     }
 
-    Import isImport()
+    inout(Import) isImport() inout
     {
         return null;
     }
 
-    EnumDeclaration isEnumDeclaration()
+    inout(EnumDeclaration) isEnumDeclaration() inout
     {
         return null;
     }
 
-    DeleteDeclaration isDeleteDeclaration()
+    inout(DeleteDeclaration) isDeleteDeclaration() inout
     {
         return null;
     }
 
-    SymbolDeclaration isSymbolDeclaration()
+    inout(SymbolDeclaration) isSymbolDeclaration() inout
     {
         return null;
     }
 
-    AttribDeclaration isAttribDeclaration()
+    inout(AttribDeclaration) isAttribDeclaration() inout
     {
         return null;
     }
 
-    AnonDeclaration isAnonDeclaration()
+    inout(AnonDeclaration) isAnonDeclaration() inout
     {
         return null;
     }
 
-    OverloadSet isOverloadSet()
+    inout(OverloadSet) isOverloadSet() inout
     {
         return null;
     }
 
+    /************
+     */
     void accept(Visitor v)
     {
         v.visit(this);
@@ -1229,12 +1270,16 @@ public:
 extern (C++) class ScopeDsymbol : Dsymbol
 {
 public:
-    Dsymbols* members;      // all Dsymbol's in this scope
-    DsymbolTable symtab;    // members[] sorted into table
+    Dsymbols* members;          // all Dsymbol's in this scope
+    DsymbolTable symtab;        // members[] sorted into table
 
 private:
-    Dsymbols* imports;      // imported Dsymbol's
-    PROTKIND* prots;        // array of PROTKIND, one for each import
+    /// symbols whose members have been imported, i.e. imported modules and template mixins
+    Dsymbols* importedScopes;
+    PROTKIND* prots;            // array of PROTKIND, one for each import
+
+    import ddmd.root.array : BitArray;
+    BitArray accessiblePackages;// whitelist of accessible (imported) packages
 
 public:
     final extern (D) this()
@@ -1258,34 +1303,69 @@ public:
      * This function is #1 on the list of functions that eat cpu time.
      * Be very, very careful about slowing it down.
      */
-    override Dsymbol search(Loc loc, Identifier ident, int flags = IgnoreNone)
+    override Dsymbol search(Loc loc, Identifier ident, int flags = SearchLocalsOnly)
     {
-        //printf("%s->ScopeDsymbol::search(ident='%s', flags=x%x)\n", toChars(), ident->toChars(), flags);
+        //printf("%s.ScopeDsymbol::search(ident='%s', flags=x%x)\n", toChars(), ident.toChars(), flags);
         //if (strcmp(ident->toChars(),"c") == 0) *(char*)0=0;
+
+        if (global.params.bug10378 && !(flags & SearchCheck10378))
+            flags &= ~(SearchImportsOnly | SearchLocalsOnly);
+
         // Look in symbols declared in this module
-        Dsymbol s1 = symtab ? symtab.lookup(ident) : null;
-        //printf("\ts1 = %p, imports = %p, %d\n", s1, imports, imports ? imports->dim : 0);
-        if (s1)
+        if (symtab && !(flags & SearchImportsOnly))
         {
-            //printf("\ts = '%s.%s'\n",toChars(),s1->toChars());
-            return s1;
+            //printf(" look in locals\n");
+            auto s1 = symtab.lookup(ident);
+            if (s1)
+            {
+                //printf("\tfound in locals = '%s.%s'\n",toChars(),s1.toChars());
+                return s1;
+            }
         }
-        if (imports)
+        //printf(" not found in locals\n");
+
+        // Look in imported scopes
+        if (importedScopes)
         {
+            //printf(" look in imports\n");
             Dsymbol s = null;
             OverloadSet a = null;
-            int sflags = flags & (IgnoreErrors | IgnoreAmbiguous); // remember these in recursive searches
             // Look in imported modules
-            for (size_t i = 0; i < imports.dim; i++)
+            for (size_t i = 0; i < importedScopes.dim; i++)
             {
                 // If private import, don't search it
-                if ((flags & IgnorePrivateMembers) && prots[i] == PROTprivate)
+                if ((flags & IgnorePrivateImports) && prots[i] == PROTprivate)
                     continue;
-                Dsymbol ss = (*imports)[i];
+                int sflags = flags & (IgnoreErrors | IgnoreAmbiguous | IgnoreSymbolVisibility); // remember these in recursive searches
+                Dsymbol ss = (*importedScopes)[i];
                 //printf("\tscanning import '%s', prots = %d, isModule = %p, isImport = %p\n", ss->toChars(), prots[i], ss->isModule(), ss->isImport());
+
+                if (ss.isModule())
+                {
+                    if (flags & SearchLocalsOnly)
+                    {
+                        if (global.params.check10378 && !(flags & SearchCheck10378))
+                        {
+                            auto s3 = ss.search(loc, ident, sflags | IgnorePrivateImports);
+                            if (s3)
+                                deprecation("%s %s found in local import", s3.kind(), s3.toPrettyChars());
+                        }
+                        continue;
+                    }
+                }
+                else
+                {
+                    if (flags & SearchImportsOnly)
+                        continue;
+                    sflags |= SearchLocalsOnly;
+                }
+
                 /* Don't find private members if ss is a module
                  */
-                Dsymbol s2 = ss.search(loc, ident, sflags | (ss.isModule() ? IgnorePrivateMembers : IgnoreNone));
+                Dsymbol s2 = ss.search(loc, ident, sflags | (ss.isModule() ? IgnorePrivateImports : IgnoreNone));
+                import ddmd.access : symbolIsVisible;
+                if (!s2 || !(flags & IgnoreSymbolVisibility) && !symbolIsVisible(this, s2))
+                    continue;
                 if (!s)
                 {
                     s = s2;
@@ -1347,15 +1427,24 @@ public:
                         a = mergeOverloadSet(ident, a, s);
                     s = a;
                 }
-                if (!(flags & IgnoreErrors) && s.prot().kind == PROTprivate && !s.parent.isTemplateMixin())
+                // TODO: remove once private symbol visibility has been deprecated
+                if (!(flags & IgnoreErrors) && s.prot().kind == PROTprivate &&
+                    !s.isOverloadable() && !s.parent.isTemplateMixin() && !s.parent.isNspace())
                 {
-                    if (!s.isImport())
+                    AliasDeclaration ad = void;
+                    // accessing private selective and renamed imports is
+                    // deprecated by restricting the symbol visibility
+                    if (s.isImport() || (ad = s.isAliasDeclaration()) !is null && ad._import !is null)
+                    {}
+                    else
                         error(loc, "%s %s is private", s.kind(), s.toPrettyChars());
                 }
+                //printf("\tfound in imports %s.%s\n", toChars(), s.toChars());
                 return s;
             }
+            //printf(" not found in imports\n");
         }
-        return s1;
+        return null;
     }
 
     final OverloadSet mergeOverloadSet(Identifier ident, OverloadSet os, Dsymbol s)
@@ -1410,13 +1499,13 @@ public:
         // No circular or redundant import's
         if (s != this)
         {
-            if (!imports)
-                imports = new Dsymbols();
+            if (!importedScopes)
+                importedScopes = new Dsymbols();
             else
             {
-                for (size_t i = 0; i < imports.dim; i++)
+                for (size_t i = 0; i < importedScopes.dim; i++)
                 {
-                    Dsymbol ss = (*imports)[i];
+                    Dsymbol ss = (*importedScopes)[i];
                     if (ss == s) // if already imported
                     {
                         if (protection.kind > prots[i])
@@ -1425,12 +1514,25 @@ public:
                     }
                 }
             }
-            imports.push(s);
-            prots = cast(PROTKIND*)mem.xrealloc(prots, imports.dim * (prots[0]).sizeof);
-            prots[imports.dim - 1] = protection.kind;
+            importedScopes.push(s);
+            prots = cast(PROTKIND*)mem.xrealloc(prots, importedScopes.dim * (prots[0]).sizeof);
+            prots[importedScopes.dim - 1] = protection.kind;
         }
     }
 
+    final void addAccessiblePackage(Package p)
+    {
+        if (accessiblePackages.length <= p.tag)
+            accessiblePackages.length = p.tag + 1;
+        accessiblePackages[p.tag] = true;
+    }
+
+    final bool isPackageAccessible(Package p)
+    {
+        return p.tag < accessiblePackages.length &&
+            accessiblePackages[p.tag];
+    }
+
     override final bool isforwardRef()
     {
         return (members is null);
@@ -1454,7 +1556,7 @@ public:
         }
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "ScopeDsymbol";
     }
@@ -1524,6 +1626,7 @@ public:
             ++n;
             return 0;
         }
+
         _foreach(null, members, &dimDg, &n);
         return n;
     }
@@ -1553,7 +1656,7 @@ public:
         return res ? sym : null;
     }
 
-    extern (D)   alias ForeachDg    = int delegate(size_t idx, Dsymbol s);
+    extern (D) alias ForeachDg = int delegate(size_t idx, Dsymbol s);
 
     /***************************************
      * Expands attribute declarations in members in depth first
@@ -1595,7 +1698,7 @@ public:
         return result;
     }
 
-    override final ScopeDsymbol isScopeDsymbol()
+    override final inout(ScopeDsymbol) isScopeDsymbol() inout
     {
         return this;
     }
@@ -1619,8 +1722,11 @@ public:
         this.withstate = withstate;
     }
 
-    override Dsymbol search(Loc loc, Identifier ident, int flags = IgnoreNone)
+    override Dsymbol search(Loc loc, Identifier ident, int flags = SearchLocalsOnly)
     {
+        //printf("WithScopeSymbol.search(%s)\n", ident.toChars());
+        if (flags & SearchImportsOnly)
+            return null;
         // Acts as proxy to the with class declaration
         Dsymbol s = null;
         Expression eold = null;
@@ -1641,7 +1747,7 @@ public:
             }
             if (s)
             {
-                s = s.search(loc, ident);
+                s = s.search(loc, ident, flags);
                 if (s)
                     return s;
             }
@@ -1650,7 +1756,7 @@ public:
         return null;
     }
 
-    override WithScopeSymbol isWithScopeSymbol()
+    override inout(WithScopeSymbol) isWithScopeSymbol() inout
     {
         return this;
     }
@@ -1863,7 +1969,7 @@ public:
         return null;
     }
 
-    override ArrayScopeSymbol isArrayScopeSymbol()
+    override inout(ArrayScopeSymbol) isArrayScopeSymbol() inout
     {
         return this;
     }
@@ -1897,12 +2003,12 @@ public:
         a.push(s);
     }
 
-    override OverloadSet isOverloadSet()
+    override inout(OverloadSet) isOverloadSet() inout
     {
         return this;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "overloadset";
     }
@@ -1922,7 +2028,7 @@ public:
     AA* tab;
 
     // Look up Identifier. Return Dsymbol if found, NULL if not.
-    Dsymbol lookup(Identifier ident)
+    Dsymbol lookup(const Identifier ident)
     {
         //printf("DsymbolTable::lookup(%s)\n", (char*)ident->string);
         return cast(Dsymbol)dmd_aaGetRvalue(tab, cast(void*)ident);
@@ -1932,7 +2038,7 @@ public:
     Dsymbol insert(Dsymbol s)
     {
         //printf("DsymbolTable::insert(this = %p, '%s')\n", this, s->ident->toChars());
-        Identifier ident = s.ident;
+        const ident = s.ident;
         Dsymbol* ps = cast(Dsymbol*)dmd_aaGet(&tab, cast(void*)ident);
         if (*ps)
             return null; // already in table
@@ -1943,14 +2049,14 @@ public:
     // Look for Dsymbol in table. If there, return it. If not, insert s and return that.
     Dsymbol update(Dsymbol s)
     {
-        Identifier ident = s.ident;
+        const ident = s.ident;
         Dsymbol* ps = cast(Dsymbol*)dmd_aaGet(&tab, cast(void*)ident);
         *ps = s;
         return s;
     }
 
     // when ident and s are not the same
-    Dsymbol insert(Identifier ident, Dsymbol s)
+    Dsymbol insert(const Identifier ident, Dsymbol s)
     {
         //printf("DsymbolTable::insert()\n");
         Dsymbol* ps = cast(Dsymbol*)dmd_aaGet(&tab, cast(void*)ident);
@@ -1959,4 +2065,13 @@ public:
         *ps = s;
         return s;
     }
+
+    /*****
+     * Returns:
+     *  number of symbols in symbol table
+     */
+    uint len() const pure
+    {
+        return cast(uint)dmd_aaLen(tab);
+    }
 }
diff --git a/ddmd/dsymbol.h b/ddmd/dsymbol.h
index 68d7b15115..ac00d93b3f 100644
--- a/ddmd/dsymbol.h
+++ b/ddmd/dsymbol.h
@@ -115,9 +115,9 @@ struct Prot
     Prot();
     Prot(PROTKIND kind);
 
-    bool isMoreRestrictiveThan(Prot other);
-    bool operator==(Prot other);
-    bool isSubsetOf(Prot other);
+    bool isMoreRestrictiveThan(const Prot other) const;
+    bool operator==(const Prot& other) const;
+    bool isSubsetOf(const Prot& other) const;
 };
 
 // in hdrgen.c
@@ -145,9 +145,17 @@ enum PASS
 enum
 {
     IgnoreNone              = 0x00, // default
-    IgnorePrivateMembers    = 0x01, // don't find private members
+    IgnorePrivateImports    = 0x01, // don't search private imports
     IgnoreErrors            = 0x02, // don't give error messages
     IgnoreAmbiguous         = 0x04, // return NULL if ambiguous
+    SearchLocalsOnly        = 0x08, // only look at locals (don't search imports)
+    SearchImportsOnly       = 0x10, // only look in imports
+    SearchUnqualifiedModule = 0x20, // the module scope search is unqualified,
+                                    // meaning don't search imports in that scope,
+                                    // because qualified module searches search
+                                    // their imports
+    SearchCheck10378        = 0x40, // unqualified search with transition=checkimports switch
+    IgnoreSymbolVisibility  = 0x80, // also find private and package protected symbols
 };
 
 typedef int (*Dsymbol_apply_ft_t)(Dsymbol *, void *);
@@ -162,6 +170,7 @@ public:
     const utf8_t *comment;      // documentation comment for this Dsymbol
     Loc loc;                    // where defined
     Scope *_scope;               // !=NULL means context to use for semantic()
+    const utf8_t *prettystring;
     bool errors;                // this symbol failed to pass semantic()
     PASS semanticRun;
     char *depmsg;               // customized deprecation message
@@ -229,7 +238,6 @@ public:
     virtual bool isImportedSymbol();            // is Dsymbol imported?
     virtual bool isDeprecated();                // is Dsymbol deprecated?
     virtual bool isOverloadable();
-    virtual bool hasOverloads();
     virtual LabelDsymbol *isLabel();            // is this a LabelDsymbol?
     virtual AggregateDeclaration *isMember();   // is this symbol a member of an AggregateDeclaration?
     virtual Type *getType();                    // is this a type?
@@ -303,9 +311,11 @@ public:
     DsymbolTable *symtab;       // members[] sorted into table
 
 private:
-    Dsymbols *imports;          // imported Dsymbol's
+    Dsymbols *importedScopes;   // imported Dsymbol's
     PROTKIND *prots;            // array of PROTKIND, one for each import
 
+    BitArray accessiblePackages;
+
 public:
     ScopeDsymbol();
     ScopeDsymbol(Identifier *id);
@@ -384,14 +394,14 @@ public:
     DsymbolTable();
 
     // Look up Identifier. Return Dsymbol if found, NULL if not.
-    Dsymbol *lookup(Identifier *ident);
+    Dsymbol *lookup(Identifier const * const ident);
 
     // Insert Dsymbol in table. Return NULL if already there.
     Dsymbol *insert(Dsymbol *s);
 
     // Look for Dsymbol in table. If there, return it. If not, insert s and return that.
     Dsymbol *update(Dsymbol *s);
-    Dsymbol *insert(Identifier *ident, Dsymbol *s);     // when ident and s are not the same
+    Dsymbol *insert(Identifier const * const ident, Dsymbol *s);     // when ident and s are not the same
 };
 
 #endif /* DMD_DSYMBOL_H */
diff --git a/ddmd/dtemplate.d b/ddmd/dtemplate.d
index 9666e78af9..9cb06191c6 100644
--- a/ddmd/dtemplate.d
+++ b/ddmd/dtemplate.d
@@ -162,6 +162,8 @@ extern (C++) Dsymbol getDsymbol(RootObject oarg)
             else
                 sa = (cast(FuncExp)ea).fd;
         }
+        else if (ea.op == TOKtemplate)
+            sa = (cast(TemplateExp)ea).td;
         else
             sa = null;
     }
@@ -394,7 +396,7 @@ public:
         return DYNCAST_TUPLE;
     }
 
-    override char* toChars()
+    override const(char)* toChars()
     {
         return objects.toChars();
     }
@@ -653,12 +655,12 @@ else
         return false; // don't scan uninstantiated templates
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
-        return (onemember && onemember.isAggregateDeclaration()) ? onemember.kind() : cast(char*)"template";
+        return (onemember && onemember.isAggregateDeclaration()) ? onemember.kind() : "template";
     }
 
-    override char* toChars()
+    override const(char)* toChars()
     {
         if (literal)
             return Dsymbol.toChars();
@@ -1687,14 +1689,14 @@ else
                                 else
                                 {
                                     Type vt = tvp.valType.semantic(Loc(), sc);
-                                    MATCH m = cast(MATCH)dim.implicitConvTo(vt);
+                                    MATCH m = dim.implicitConvTo(vt);
                                     if (m <= MATCHnomatch)
                                         goto Lnomatch;
                                     (*dedtypes)[i] = dim;
                                 }
                             }
                         }
-                        /* fall through */
+                        goto case Tarray;
                     }
                 case Tarray:
                     {
@@ -1767,6 +1769,7 @@ else
         {
             TemplateParameter tparam = (*parameters)[i];
             //printf("tparam[%d] = %s\n", i, tparam->ident->toChars());
+
             /* For T:T*, the dedargs is the T*, dedtypes is the T
              * But for function templates, we really need them to match
              */
@@ -1808,7 +1811,9 @@ else
                         // if tuple parameter and
                         // tuple parameter was not in function parameter list and
                         // we're one or more arguments short (i.e. no tuple argument)
-                        if (tparam == tp && fptupindex == IDX_NOTFOUND && ntargs <= dedargs.dim - 1)
+                        if (tparam == tp &&
+                            fptupindex == IDX_NOTFOUND &&
+                            ntargs <= dedargs.dim - 1)
                         {
                             // make tuple argument an empty tuple
                             oded = cast(RootObject)new Tuple();
@@ -1819,6 +1824,7 @@ else
                     if (isError(oded))
                         goto Lerror;
                     ntargs++;
+
                     /* At the template parameter T, the picked default template argument
                      * X!int should be matched to T in order to deduce dependent
                      * template parameter A.
@@ -1839,20 +1845,23 @@ else
                     }
                 }
                 oded = declareParameter(paramscope, tparam, oded);
-                /* Bugzilla 7469: Normalize ti->tiargs for the correct mangling of template instance.
-                 */
-                Tuple va = isTuple(oded);
-                if (va && va.objects.dim)
-                {
-                    dedargs.setDim(parameters.dim - 1 + va.objects.dim);
-                    for (size_t j = 0; j < va.objects.dim; j++)
-                        (*dedargs)[i + j] = va.objects[j];
-                    i = dedargs.dim - 1;
-                }
-                else
-                    (*dedargs)[i] = oded;
+                (*dedargs)[i] = oded;
             }
         }
+
+        /* Bugzilla 7469: As same as the code for 7469 in findBestMatch,
+         * expand a Tuple in dedargs to normalize template arguments.
+         */
+        if (auto d = dedargs.dim)
+        {
+            if (auto va = isTuple((*dedargs)[d - 1]))
+            {
+                dedargs.setDim(d - 1);
+                dedargs.insert(d - 1, &va.objects);
+            }
+        }
+        ti.tiargs = dedargs; // update to the normalized template arguments.
+
         // Partially instantiate function for constraint and fd->leastAsSpecialized()
         {
             assert(paramsym);
@@ -1862,18 +1871,22 @@ else
             sc2.parent = ti;
             sc2.tinst = ti;
             sc2.minst = sc.minst;
+
             fd = doHeaderInstantiation(ti, sc2, fd, tthis, fargs);
+
             sc2 = sc2.pop();
             sc2 = sc2.pop();
+
             if (!fd)
                 goto Lnomatch;
         }
-        ti.tiargs = dedargs; // update to the normalized template arguments.
+
         if (constraint)
         {
             if (!evaluateConstraint(ti, sc, paramscope, dedargs, fd))
                 goto Lnomatch;
         }
+
         version (none)
         {
             for (size_t i = 0; i < dedargs.dim; i++)
@@ -1882,13 +1895,16 @@ else
                 printf("\tdedargs[%d] = %d, %s\n", i, o.dyncast(), o.toChars());
             }
         }
+
         paramscope.pop();
         //printf("\tmatch %d\n", match);
         return cast(MATCH)(match | (matchTiargs << 4));
+
     Lnomatch:
         paramscope.pop();
         //printf("\tnomatch\n");
         return MATCHnomatch;
+
     Lerror:
         // todo: for the future improvement
         paramscope.pop();
@@ -2166,7 +2182,7 @@ else
         --numinstances;
     }
 
-    override TemplateDeclaration isTemplateDeclaration()
+    override inout(TemplateDeclaration) isTemplateDeclaration() inout
     {
         return this;
     }
@@ -2408,6 +2424,7 @@ extern (C++) void functionResolve(Match* m, Dsymbol dstart, Loc loc, Scope* sc,
         }
         return 0;
     }
+
     int applyTemplate(TemplateDeclaration td)
     {
         // skip duplicates
@@ -2454,7 +2471,7 @@ extern (C++) void functionResolve(Match* m, Dsymbol dstart, Loc loc, Scope* sc,
 
             Dsymbol s = ti.inst.toAlias();
             FuncDeclaration fd;
-            if (TemplateDeclaration tdx = s.isTemplateDeclaration())
+            if (auto tdx = s.isTemplateDeclaration())
             {
                 Objects dedtypesX;      // empty tiargs
 
@@ -2501,7 +2518,12 @@ extern (C++) void functionResolve(Match* m, Dsymbol dstart, Loc loc, Scope* sc,
                 return 0;
 
             if (fd.type.ty != Tfunction)
-                goto Lerror;
+            {
+                m.lastf = fd;   // to propagate "error match"
+                m.count = 1;
+                m.last = MATCHnomatch;
+                return 1;
+            }
 
             Type tthis_fd = fd.needThis() && !fd.isCtorDeclaration() ? tthis : null;
 
@@ -2703,21 +2725,6 @@ extern (C++) void functionResolve(Match* m, Dsymbol dstart, Loc loc, Scope* sc,
         if (!tf.callMatch(tthis_best, fargs))
             goto Lnomatch;
 
-        if (auto fld = m.lastf.isFuncLiteralDeclaration())
-        {
-            if ((sc.flags & SCOPEconstraint) || sc.intypeof)
-            {
-                // Inside template constraint, or inside typeof,
-                // nested reference check doesn't work correctly.
-            }
-            else if (fld.tok == TOKreserved)
-            {
-                // change to non-nested
-                fld.tok = TOKfunction;
-                fld.vthis = null;
-            }
-        }
-
         /* As Bugzilla 3682 shows, a template instance can be matched while instantiating
          * that same template. Thus, the function type can be incomplete. Complete it.
          *
@@ -3919,7 +3926,7 @@ extern (C++) MATCH deduceType(RootObject o, Scope* sc, Type tparam, TemplatePara
          * If a match occurs, numBaseClassMatches is incremented, and the new deduced
          * types are ANDed with the current 'best' estimate for dedtypes.
          */
-        static void deduceBaseClassParameters(BaseClass* b, Scope* sc, Type tparam, TemplateParameters* parameters, Objects* dedtypes, Objects* best, ref int numBaseClassMatches)
+        static void deduceBaseClassParameters(ref BaseClass b, Scope* sc, Type tparam, TemplateParameters* parameters, Objects* dedtypes, Objects* best, ref int numBaseClassMatches)
         {
             TemplateInstance parti = b.sym ? b.sym.parent.isTemplateInstance() : null;
             if (parti)
@@ -3947,9 +3954,9 @@ extern (C++) MATCH deduceType(RootObject o, Scope* sc, Type tparam, TemplatePara
                 }
             }
             // Now recursively test the inherited interfaces
-            for (size_t j = 0; j < b.baseInterfaces_dim; ++j)
+            foreach (ref bi; b.baseInterfaces)
             {
-                deduceBaseClassParameters(&b.baseInterfaces[j], sc, tparam, parameters, dedtypes, best, numBaseClassMatches);
+                deduceBaseClassParameters(bi, sc, tparam, parameters, dedtypes, best, numBaseClassMatches);
             }
         }
 
@@ -4012,12 +4019,11 @@ extern (C++) MATCH deduceType(RootObject o, Scope* sc, Type tparam, TemplatePara
                 while (s && s.baseclasses.dim > 0)
                 {
                     // Test the base class
-                    deduceBaseClassParameters((*s.baseclasses)[0], sc, tparam, parameters, dedtypes, best, numBaseClassMatches);
+                    deduceBaseClassParameters(*(*s.baseclasses)[0], sc, tparam, parameters, dedtypes, best, numBaseClassMatches);
                     // Test the interfaces inherited by the base class
-                    for (size_t i = 0; i < s.interfaces_dim; ++i)
+                    foreach (b; s.interfaces)
                     {
-                        BaseClass* b = s.interfaces[i];
-                        deduceBaseClassParameters(b, sc, tparam, parameters, dedtypes, best, numBaseClassMatches);
+                        deduceBaseClassParameters(*b, sc, tparam, parameters, dedtypes, best, numBaseClassMatches);
                     }
                     s = (*s.baseclasses)[0].sym;
                 }
@@ -4367,7 +4373,7 @@ extern (C++) MATCH deduceType(RootObject o, Scope* sc, Type tparam, TemplatePara
 
         override void visit(CommaExp e)
         {
-            (cast(CommaExp)e).e2.accept(this);
+            e.e2.accept(this);
         }
     }
 
@@ -4390,7 +4396,7 @@ extern (C++) MATCH deduceType(RootObject o, Scope* sc, Type tparam, TemplatePara
  *      iStart      = Start index of tparams to limit the tested parameters. If it's
  *                    nonzero, tparams[0..iStart] will be excluded from the test target.
  */
-extern (C++) Type reliesOnTident(Type t, TemplateParameters* tparams = null, size_t iStart = 0)
+extern (C++) bool reliesOnTident(Type t, TemplateParameters* tparams = null, size_t iStart = 0)
 {
     extern (C++) final class ReliesOnTident : Visitor
     {
@@ -4398,7 +4404,7 @@ extern (C++) Type reliesOnTident(Type t, TemplateParameters* tparams = null, siz
     public:
         TemplateParameters* tparams;
         size_t iStart;
-        Type result;
+        bool result;
 
         extern (D) this(TemplateParameters* tparams, size_t iStart)
         {
@@ -4448,7 +4454,7 @@ extern (C++) Type reliesOnTident(Type t, TemplateParameters* tparams = null, siz
                 TemplateParameter tp = (*tparams)[i];
                 if (tp.ident.equals(t.ident))
                 {
-                    result = t;
+                    result = true;
                     return;
                 }
             }
@@ -4461,7 +4467,7 @@ extern (C++) Type reliesOnTident(Type t, TemplateParameters* tparams = null, siz
                 TemplateParameter tp = (*tparams)[i];
                 if (t.tempinst.name == tp.ident)
                 {
-                    result = t;
+                    result = true;
                     return;
                 }
             }
@@ -4479,6 +4485,12 @@ extern (C++) Type reliesOnTident(Type t, TemplateParameters* tparams = null, siz
             }
         }
 
+        override void visit(TypeTypeof t)
+        {
+            //printf("TypeTypeof::reliesOnTident('%s')\n", t.toChars());
+            t.exp.accept(this);
+        }
+
         override void visit(TypeTuple t)
         {
             if (t.arguments)
@@ -4492,10 +4504,256 @@ extern (C++) Type reliesOnTident(Type t, TemplateParameters* tparams = null, siz
                 }
             }
         }
+
+        override void visit(Expression e)
+        {
+            //printf("Expression::reliesOnTident('%s')\n", e.toChars());
+        }
+
+        override void visit(IdentifierExp e)
+        {
+            //printf("IdentifierExp::reliesOnTident('%s')\n", e.toChars());
+            for (size_t i = iStart; i < tparams.dim; i++)
+            {
+                auto tp = (*tparams)[i];
+                if (e.ident == tp.ident)
+                {
+                    result = true;
+                    return;
+                }
+            }
+        }
+
+        override void visit(TupleExp e)
+        {
+            //printf("TupleExp::reliesOnTident('%s')\n", e.toChars());
+            if (e.exps)
+            {
+                foreach (ea; *e.exps)
+                {
+                    ea.accept(this);
+                    if (result)
+                        return;
+                }
+            }
+        }
+
+        override void visit(ArrayLiteralExp e)
+        {
+            //printf("ArrayLiteralExp::reliesOnTident('%s')\n", e.toChars());
+            if (e.elements)
+            {
+                foreach (el; *e.elements)
+                {
+                    el.accept(this);
+                    if (result)
+                        return;
+                }
+            }
+        }
+
+        override void visit(AssocArrayLiteralExp e)
+        {
+            //printf("AssocArrayLiteralExp::reliesOnTident('%s')\n", e.toChars());
+            foreach (ek; *e.keys)
+            {
+                ek.accept(this);
+                if (result)
+                    return;
+            }
+            foreach (ev; *e.values)
+            {
+                ev.accept(this);
+                if (result)
+                    return;
+            }
+        }
+
+        override void visit(StructLiteralExp e)
+        {
+            //printf("StructLiteralExp::reliesOnTident('%s')\n", e.toChars());
+            if (e.elements)
+            {
+                foreach (ea; *e.elements)
+                {
+                    ea.accept(this);
+                    if (result)
+                        return;
+                }
+            }
+        }
+
+        override void visit(TypeExp e)
+        {
+            //printf("TypeExp::reliesOnTident('%s')\n", e.toChars());
+            e.type.accept(this);
+        }
+
+        override void visit(NewExp e)
+        {
+            //printf("NewExp::reliesOnTident('%s')\n", e.toChars());
+            if (e.thisexp)
+                e.thisexp.accept(this);
+            if (!result && e.newargs)
+            {
+                foreach (ea; *e.newargs)
+                {
+                    ea.accept(this);
+                    if (result)
+                        return;
+                }
+            }
+            e.newtype.accept(this);
+            if (!result && e.arguments)
+            {
+                foreach (ea; *e.arguments)
+                {
+                    ea.accept(this);
+                    if (result)
+                        return;
+                }
+            }
+        }
+
+        override void visit(NewAnonClassExp e)
+        {
+            //printf("NewAnonClassExp::reliesOnTident('%s')\n", e.toChars());
+            result = true;
+        }
+
+        override void visit(FuncExp e)
+        {
+            //printf("FuncExp::reliesOnTident('%s')\n", e.toChars());
+            result = true;
+        }
+
+        override void visit(TypeidExp e)
+        {
+            //printf("TypeidExp::reliesOnTident('%s')\n", e.toChars());
+            if (auto ea = isExpression(e.obj))
+                ea.accept(this);
+            else if (auto ta = isType(e.obj))
+                ta.accept(this);
+        }
+
+        override void visit(TraitsExp e)
+        {
+            //printf("TraitsExp::reliesOnTident('%s')\n", e.toChars());
+            if (e.args)
+            {
+                foreach (oa; *e.args)
+                {
+                    if (auto ea = isExpression(oa))
+                        ea.accept(this);
+                    else if (auto ta = isType(oa))
+                        ta.accept(this);
+                    if (result)
+                        return;
+                }
+            }
+        }
+
+        override void visit(IsExp e)
+        {
+            //printf("IsExp::reliesOnTident('%s')\n", e.toChars());
+            e.targ.accept(this);
+        }
+
+        override void visit(UnaExp e)
+        {
+            //printf("UnaExp::reliesOnTident('%s')\n", e.toChars());
+            e.e1.accept(this);
+        }
+
+        override void visit(DotTemplateInstanceExp e)
+        {
+            //printf("DotTemplateInstanceExp::reliesOnTident('%s')\n", e.toChars());
+            visit(cast(UnaExp)e);
+            if (!result && e.ti.tiargs)
+            {
+                foreach (oa; *e.ti.tiargs)
+                {
+                    if (auto ea = isExpression(oa))
+                        ea.accept(this);
+                    else if (auto ta = isType(oa))
+                        ta.accept(this);
+                    if (result)
+                        return;
+                }
+            }
+        }
+
+        override void visit(CallExp e)
+        {
+            //printf("CallExp::reliesOnTident('%s')\n", e.toChars());
+            visit(cast(UnaExp)e);
+            if (!result && e.arguments)
+            {
+                foreach (ea; *e.arguments)
+                {
+                    ea.accept(this);
+                    if (result)
+                        return;
+                }
+            }
+        }
+
+        override void visit(CastExp e)
+        {
+            //printf("CallExp::reliesOnTident('%s')\n", e.toChars());
+            visit(cast(UnaExp)e);
+            if (!result)
+                e.to.accept(this);
+        }
+
+        override void visit(SliceExp e)
+        {
+            //printf("SliceExp::reliesOnTident('%s')\n", e.toChars());
+            visit(cast(UnaExp)e);
+            if (!result && e.lwr)
+                e.lwr.accept(this);
+            if (!result && e.upr)
+                e.upr.accept(this);
+        }
+
+        override void visit(IntervalExp e)
+        {
+            //printf("IntervalExp::reliesOnTident('%s')\n", e.toChars());
+            e.lwr.accept(this);
+            if (!result)
+                e.upr.accept(this);
+        }
+
+        override void visit(ArrayExp e)
+        {
+            //printf("ArrayExp::reliesOnTident('%s')\n", e.toChars());
+            visit(cast(UnaExp)e);
+            if (!result && e.arguments)
+            {
+                foreach (ea; *e.arguments)
+                    ea.accept(this);
+            }
+        }
+
+        override void visit(BinExp e)
+        {
+            //printf("BinExp::reliesOnTident('%s')\n", e.toChars());
+            e.e1.accept(this);
+            if (!result)
+                e.e2.accept(this);
+        }
+
+        override void visit(CondExp e)
+        {
+            //printf("BinExp::reliesOnTident('%s')\n", e.toChars());
+            e.econd.accept(this);
+            if (!result)
+                visit(cast(BinExp)e);
+        }
     }
 
     if (!t)
-        return null;
+        return false;
 
     assert(tparams);
     scope ReliesOnTident v = new ReliesOnTident(tparams, iStart);
@@ -5908,7 +6166,7 @@ public:
         }
         if (global.errors != errorsave)
             goto Laftersemantic;
-        if (sc.func && !tinst)
+        if ((sc.func || (sc.flags & SCOPEfullinst)) && !tinst)
         {
             /* If a template is instantiated inside function, the whole instantiation
              * should be done at that position. But, immediate running semantic3 of
@@ -5928,13 +6186,48 @@ public:
         }
         else if (tinst)
         {
-            /* Template function instantiation should run semantic3 immediately
-             * for attribute inference.
-             */
+            bool doSemantic3 = false;
             if (sc.func && aliasdecl && aliasdecl.toAlias().isFuncDeclaration())
             {
-                trySemantic3(sc2);
+                /* Template function instantiation should run semantic3 immediately
+                 * for attribute inference.
+                 */
+                doSemantic3 = true;
             }
+            else if (sc.func)
+            {
+                /* A lambda function in template arguments might capture the
+                 * instantiated scope context. For the correct context inference,
+                 * all instantiated functions should run the semantic3 immediately.
+                 * See also compilable/test14973.d
+                 */
+                foreach (oarg; tdtypes)
+                {
+                    auto s = getDsymbol(oarg);
+                    if (!s)
+                        continue;
+
+                    if (auto td = s.isTemplateDeclaration())
+                    {
+                        if (!td.literal)
+                            continue;
+                        assert(td.members && td.members.dim == 1);
+                        s = (*td.members)[0];
+                    }
+                    if (auto fld = s.isFuncLiteralDeclaration())
+                    {
+                        if (fld.tok == TOKreserved)
+                        {
+                            doSemantic3 = true;
+                            break;
+                        }
+                    }
+                }
+                //printf("[%s] %s doSemantic3 = %d\n", loc.toChars(), toChars(), doSemantic3);
+            }
+            if (doSemantic3)
+                trySemantic3(sc2);
+
             TemplateInstance ti = tinst;
             int nest = 0;
             while (ti && !ti.deferred && ti.tinst)
@@ -6181,7 +6474,7 @@ public:
         return inst;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "template instance";
     }
@@ -6192,7 +6485,7 @@ public:
         return true;
     }
 
-    override char* toChars()
+    override const(char)* toChars()
     {
         OutBuffer buf;
         toCBufferInstance(this, &buf);
@@ -7197,7 +7490,7 @@ public:
                 {
                     if (!td2.onemember || !td2.onemember.isFuncDeclaration())
                         return 0;
-                    if (tiargs.dim > td.parameters.dim && !td.isVariadic())
+                    if (tiargs.dim >= td.parameters.dim - (td.isVariadic() ? 1 : 0))
                         return 0;
                     return 1;
                 }
@@ -7506,7 +7799,7 @@ public:
         assert(tempdecl);
         //printf("TemplateInstance::genIdent('%s')\n", tempdecl->ident->toChars());
         OutBuffer buf;
-        char* id = tempdecl.ident.toChars();
+        const id = tempdecl.ident.toChars();
         if (!members)
         {
             // Use "__U" for the symbols declared inside template constraint.
@@ -7612,9 +7905,8 @@ public:
                 assert(0);
         }
         buf.writeByte('Z');
-        id = buf.peekString();
-        //printf("\tgenIdent = %s\n", id);
-        return Identifier.idPool(id);
+        //printf("\tgenIdent = %s\n", buf.peekString());
+        return Identifier.idPool(buf.peekSlice());
     }
 
     final void expandMembers(Scope* sc2)
@@ -7674,7 +7966,7 @@ public:
         --nest;
     }
 
-    override final TemplateInstance isTemplateInstance()
+    override final inout(TemplateInstance) isTemplateInstance() inout
     {
         return this;
     }
@@ -7898,8 +8190,7 @@ public:
                 symtab = sc.parent.isScopeDsymbol().symtab;
             L1:
                 assert(symtab);
-                int num = cast(int)dmd_aaLen(symtab.tab) + 1;
-                ident = Identifier.generateId(s, num);
+                ident = Identifier.generateId(s, symtab.len + 1);
                 symtab.insert(this);
             }
         }
@@ -7959,7 +8250,7 @@ public:
         symtab = new DsymbolTable();
         for (Scope* sce = sc; 1; sce = sce.enclosing)
         {
-            ScopeDsymbol sds = cast(ScopeDsymbol)sce.scopesym;
+            ScopeDsymbol sds = sce.scopesym;
             if (sds)
             {
                 sds.importScope(this, Prot(PROTpublic));
@@ -8099,7 +8390,7 @@ public:
         }
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "mixin";
     }
@@ -8160,7 +8451,7 @@ public:
         }
     }
 
-    override char* toChars()
+    override const(char)* toChars()
     {
         OutBuffer buf;
         toCBufferInstance(this, &buf);
@@ -8239,7 +8530,7 @@ public:
         return true;
     }
 
-    override TemplateMixin isTemplateMixin()
+    override inout(TemplateMixin) isTemplateMixin() inout
     {
         return this;
     }
diff --git a/ddmd/dversion.d b/ddmd/dversion.d
index f1a8f2dba7..17d6e5bc42 100644
--- a/ddmd/dversion.d
+++ b/ddmd/dversion.d
@@ -50,7 +50,7 @@ public:
         return ds;
     }
 
-    override char* toChars()
+    override const(char)* toChars() const
     {
         if (ident)
             return ident.toChars();
@@ -104,7 +104,7 @@ public:
         //printf("DebugSymbol::semantic() %s\n", toChars());
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "debug";
     }
@@ -145,7 +145,7 @@ public:
         return ds;
     }
 
-    override char* toChars()
+    override const(char)* toChars()
     {
         if (ident)
             return ident.toChars();
@@ -199,7 +199,7 @@ public:
     {
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "version";
     }
diff --git a/ddmd/errors.d b/ddmd/errors.d
index 7d6b764b50..a27efe6041 100644
--- a/ddmd/errors.d
+++ b/ddmd/errors.d
@@ -187,12 +187,12 @@ extern (C++) void deprecationSupplemental(Loc loc, const(char)* format, ...)
 // Just print, doesn't care about gagging
 extern (C++) void verrorPrint(Loc loc, COLOR headerColor, const(char)* header, const(char)* format, va_list ap, const(char)* p1 = null, const(char)* p2 = null)
 {
-    char* p = loc.toChars();
+    const p = loc.toChars();
     if (global.params.color)
         setConsoleColorBright(true);
     if (*p)
         fprintf(stderr, "%s: ", p);
-    mem.xfree(p);
+    mem.xfree(cast(void*)p);
     if (global.params.color)
         setConsoleColor(headerColor, true);
     fputs(header, stderr);
diff --git a/ddmd/escape.d b/ddmd/escape.d
index 5a69cf3e52..1dbf185778 100644
--- a/ddmd/escape.d
+++ b/ddmd/escape.d
@@ -96,7 +96,7 @@ bool checkEscape(Scope* sc, Expression e, bool gag)
                      */
                     if (tb.ty == Tarray || tb.ty == Tsarray || tb.ty == Tclass || tb.ty == Tdelegate)
                     {
-                        if ((!v.noscope || tb.ty == Tclass))
+                        if (v.needsScopeDtor() || tb.ty == Tclass)
                         {
                             error(e.loc, "escaping reference to scope local %s", v);
                             return;
diff --git a/ddmd/expression.d b/ddmd/expression.d
index 3bd883f9b7..093e1e6b78 100644
--- a/ddmd/expression.d
+++ b/ddmd/expression.d
@@ -55,7 +55,6 @@ import ddmd.nspace;
 import ddmd.opover;
 import ddmd.optimize;
 import ddmd.parse;
-import ddmd.root.aav;
 import ddmd.root.file;
 import ddmd.root.filename;
 import ddmd.root.longdouble;
@@ -363,16 +362,10 @@ extern (C++) Expression resolvePropertiesX(Scope* sc, Expression e1, Expression
     else if (e1.op == TOKscope)
     {
         s = (cast(ScopeExp)e1).sds;
-        if (s.isTemplateDeclaration())
-        {
-            tiargs = null;
-            tthis = null;
-            goto Lfd;
-        }
         TemplateInstance ti = s.isTemplateInstance();
         if (ti && !ti.semanticRun && ti.tempdecl)
         {
-            //assert(ti->needsTypeInference(sc));
+            //assert(ti.needsTypeInference(sc));
             if (!ti.semanticTiargs(sc))
                 goto Leprop;
             tiargs = ti.tiargs;
@@ -607,9 +600,6 @@ extern (C++) Expression resolvePropertiesOnly(Scope* sc, Expression e1)
     else if (e1.op == TOKscope)
     {
         Dsymbol s = (cast(ScopeExp)e1).sds;
-        td = s.isTemplateDeclaration();
-        if (td)
-            goto Ltd;
         TemplateInstance ti = s.isTemplateInstance();
         if (ti && !ti.semanticRun && ti.tempdecl)
         {
@@ -652,31 +642,97 @@ extern (C++) Expression resolvePropertiesOnly(Scope* sc, Expression e1)
  */
 extern (C++) Expression searchUFCS(Scope* sc, UnaExp ue, Identifier ident)
 {
+    //printf("searchUFCS(ident = %s)\n", ident.toChars());
     Loc loc = ue.loc;
-    Dsymbol s = null;
-    for (Scope* scx = sc; scx; scx = scx.enclosing)
+
+    // TODO: merge with Scope.search.searchScopes()
+    Dsymbol searchScopes(int flags)
     {
-        if (!scx.scopesym)
-            continue;
-        s = scx.scopesym.search(loc, ident);
-        if (s)
+        Dsymbol s = null;
+        for (Scope* scx = sc; scx; scx = scx.enclosing)
         {
-            // overload set contains only module scope symbols.
-            if (s.isOverloadSet())
-                break;
-            // selective/renamed imports also be picked up
-            if (AliasDeclaration ad = s.isAliasDeclaration())
+            if (!scx.scopesym)
+                continue;
+            if (scx.scopesym.isModule())
+                flags |= SearchUnqualifiedModule;    // tell Module.search() that SearchLocalsOnly is to be obeyed
+            s = scx.scopesym.search(loc, ident, flags);
+            if (s)
             {
-                if (ad._import)
+                // overload set contains only module scope symbols.
+                if (s.isOverloadSet())
+                    break;
+                // selective/renamed imports also be picked up
+                if (AliasDeclaration ad = s.isAliasDeclaration())
+                {
+                    if (ad._import)
+                        break;
+                }
+                // See only module scope symbols for UFCS target.
+                Dsymbol p = s.toParent2();
+                if (p && p.isModule())
                     break;
             }
-            // See only module scope symbols for UFCS target.
-            Dsymbol p = s.toParent2();
-            if (p && p.isModule())
+            s = null;
+
+            // Stop when we hit a module, but keep going if that is not just under the global scope
+            if (scx.scopesym.isModule() && !(scx.enclosing && !scx.enclosing.enclosing))
                 break;
         }
-        s = null;
+        return s;
     }
+
+    int flags = 0;
+    Dsymbol s;
+
+    Dsymbol sold = void;
+    if (global.params.bug10378 || global.params.check10378)
+    {
+        sold = searchScopes(flags | IgnoreSymbolVisibility);
+        if (!global.params.check10378)
+        {
+            s = sold;
+            goto Lsearchdone;
+        }
+
+        // Search both ways
+        flags |= SearchCheck10378;
+    }
+
+    // First look in local scopes
+    s = searchScopes(flags | SearchLocalsOnly);
+    if (!s)
+    {
+        // Second look in imported modules
+        s = searchScopes(flags | SearchImportsOnly);
+
+        /** Still find private symbols, so that symbols that weren't access
+         * checked by the compiler remain usable.  Once the deprecation is over,
+         * this should be moved to search_correct instead.
+         */
+        if (!s)
+        {
+            s = searchScopes(flags | SearchLocalsOnly | IgnoreSymbolVisibility);
+            if (!s)
+                s = searchScopes(flags | SearchImportsOnly | IgnoreSymbolVisibility);
+
+            if (s)
+                .deprecation(loc, "%s is not visible from module %s", s.toPrettyChars(), sc._module.toChars());
+        }
+    }
+    if (global.params.check10378)
+    {
+        alias snew = s;
+        if (sold !is snew)
+        {
+            deprecation(loc, "local import search method found %s %s instead of %s %s",
+                sold ? sold.kind() : "nothing", sold ? sold.toPrettyChars() : null,
+                snew ? snew.kind() : "nothing", snew ? snew.toPrettyChars() : null);
+        }
+        if (global.params.bug10378)
+            s = sold;
+    }
+Lsearchdone:
+
     if (!s)
         return ue.e1.type.Type.getProperty(loc, ident, 0);
     FuncDeclaration f = s.isFuncDeclaration();
@@ -701,7 +757,8 @@ extern (C++) Expression searchUFCS(Scope* sc, UnaExp ue, Identifier ident)
     }
     else
     {
-        return new DsymbolExp(loc, s, 1);
+        //printf("-searchUFCS() %s\n", s.toChars());
+        return new DsymbolExp(loc, s);
     }
 }
 
@@ -1048,6 +1105,7 @@ extern (C++) bool arrayExpressionToCommonType(Scope* sc, Expressions* exps, Type
     //printf("arrayExpressionToCommonType()\n");
     scope IntegerExp integerexp = new IntegerExp(0);
     scope CondExp condexp = new CondExp(Loc(), integerexp, null, null);
+
     Type t0 = null;
     Expression e0 = null;
     size_t j0 = ~0;
@@ -1077,7 +1135,7 @@ extern (C++) bool arrayExpressionToCommonType(Scope* sc, Expressions* exps, Type
             continue;
         }
 
-        e = e.isLvalue() ? callCpCtor(sc, e) : valueNoDtor(e);
+        e = doCopyOrMove(sc, e);
 
         if (t0 && !t0.equals(e.type))
         {
@@ -1103,6 +1161,7 @@ extern (C++) bool arrayExpressionToCommonType(Scope* sc, Expressions* exps, Type
         if (e.op != TOKerror)
             (*exps)[i] = e;
     }
+
     if (!t0)
         t0 = Type.tvoid; // [] is typed as void[]
     else if (t0.ty != Terror)
@@ -1129,6 +1188,7 @@ extern (C++) bool arrayExpressionToCommonType(Scope* sc, Expressions* exps, Type
     }
     if (pt)
         *pt = t0;
+
     return (t0 == Type.terror);
 }
 
@@ -1214,7 +1274,7 @@ extern (C++) Expression valueNoDtor(Expression e)
                         VarDeclaration ctmp = ve.var.isVarDeclaration();
                         if (ctmp)
                         {
-                            ctmp.noscope = 1;
+                            ctmp.noscope = true;
                             assert(!ce.isLvalue());
                         }
                     }
@@ -1224,10 +1284,10 @@ extern (C++) Expression valueNoDtor(Expression e)
     }
     else if (e.op == TOKvar)
     {
-        VarDeclaration vtmp = (cast(VarExp)e).var.isVarDeclaration();
-        if (vtmp && vtmp.storage_class & STCrvalue)
+        auto vtmp = (cast(VarExp)e).var.isVarDeclaration();
+        if (vtmp && (vtmp.storage_class & STCrvalue))
         {
-            vtmp.noscope = 1;
+            vtmp.noscope = true;
         }
     }
     return e;
@@ -1275,10 +1335,10 @@ extern (C++) Expression callCpCtor(Scope* sc, Expression e)
              * This is not the most efficent, ideally tmp would be constructed
              * directly onto the stack.
              */
-            Identifier idtmp = Identifier.generateId("__copytmp");
+            auto idtmp = Identifier.generateId("__copytmp");
             auto tmp = new VarDeclaration(e.loc, e.type, idtmp, new ExpInitializer(e.loc, e));
             tmp.storage_class |= STCtemp | STCctfe;
-            tmp.noscope = 1;
+            tmp.noscope = true;
             tmp.semantic(sc);
             Expression de = new DeclarationExp(e.loc, tmp);
             Expression ve = new VarExp(e.loc, tmp);
@@ -1290,6 +1350,24 @@ extern (C++) Expression callCpCtor(Scope* sc, Expression e)
     return e;
 }
 
+/************************************************
+ * Handle the postblit call on lvalue, or the move of rvalue.
+ */
+extern (C++) Expression doCopyOrMove(Scope *sc, Expression e)
+{
+    if (e.op == TOKquestion)
+    {
+        auto ce = cast(CondExp)e;
+        ce.e1 = doCopyOrMove(sc, ce.e1);
+        ce.e2 = doCopyOrMove(sc, ce.e2);
+    }
+    else
+    {
+        e = e.isLvalue() ? callCpCtor(sc, e) : valueNoDtor(e);
+    }
+    return e;
+}
+
 /****************************************
  * Now that we know the exact type of the function we're calling,
  * the arguments[] need to be adjusted:
@@ -1500,21 +1578,26 @@ extern (C++) bool functionParameters(Loc loc, Scope* sc, TypeFunction tf, Type t
              *   S().bar() = 1;      // bad!
              * }
              */
-            FuncDeclaration f;
-            if (AggregateDeclaration ad = fd.isThis())
+            Dsymbol s = null;
+            if (fd.isThis() || fd.isNested())
+                s = fd.toParent2();
+            for (; s; s = s.toParent2())
             {
-                f = ad.toParent2().isFuncDeclaration();
-                goto Linoutnest;
-            }
-            else if (fd.isNested())
-            {
-                f = fd.toParent2().isFuncDeclaration();
-            Linoutnest:
-                for (; f; f = f.toParent2().isFuncDeclaration())
+                if (auto ad = s.isAggregateDeclaration())
                 {
-                    if ((cast(TypeFunction)f.type).iswild)
-                        goto Linouterr;
+                    if (ad.isNested())
+                        continue;
+                    break;
                 }
+                if (auto ff = s.isFuncDeclaration())
+                {
+                    if ((cast(TypeFunction)ff.type).iswild)
+                        goto Linouterr;
+
+                    if (ff.isNested() || ff.isThis())
+                        continue;
+                }
+                break;
             }
         }
         else if (tf.isWild())
@@ -1576,12 +1659,9 @@ extern (C++) bool functionParameters(Loc loc, Scope* sc, TypeFunction tf, Type t
                 else
                     arg = toDelegate(arg, arg.type, sc);
             }
-            else
-            {
-                //                arg = arg->isLvalue() ? callCpCtor(sc, arg) : valueNoDtor(arg);
-            }
             //printf("arg: %s\n", arg->toChars());
             //printf("type: %s\n", arg->type->toChars());
+
             /* Look for arguments that cannot 'escape' from the called
              * function.
              */
@@ -1694,6 +1774,7 @@ extern (C++) bool functionParameters(Loc loc, Scope* sc, TypeFunction tf, Type t
         }
         (*arguments)[i] = arg;
     }
+
     /* Remaining problems:
      * 1. order of evaluation - some function push L-to-R, others R-to-L. Until we resolve what array assignment does (which is
      *    implemented by calling a function) we'll defer this for now.
@@ -1705,120 +1786,152 @@ extern (C++) bool functionParameters(Loc loc, Scope* sc, TypeFunction tf, Type t
      */
     if (1)
     {
-        /* Compute indices of first and last throwing argument.
-         * Used to not set up destructors unless a throw can happen in a later argument.
+        /* TODO: tackle problem 1)
          */
-        bool anythrow = false;
-        size_t firstthrow = ~0;
-        size_t lastthrow = ~0;
-        for (size_t i = 0; i < arguments.dim; ++i)
+        const bool leftToRight = true; // TODO: something like !fd.isArrayOp
+        if (!leftToRight)
+            assert(nargs == nparams); // no variadics for RTL order, as they would probably be evaluated LTR and so add complexity
+
+        const ptrdiff_t start = (leftToRight ? 0 : cast(ptrdiff_t)nargs - 1);
+        const ptrdiff_t end = (leftToRight ? cast(ptrdiff_t)nargs : -1);
+        const ptrdiff_t step = (leftToRight ? 1 : -1);
+
+        /* Compute indices of last throwing argument and first arg needing destruction.
+         * Used to not set up destructors unless an arg needs destruction on a throw
+         * in a later argument.
+         */
+        ptrdiff_t lastthrow = -1;
+        ptrdiff_t firstdtor = -1;
+        for (ptrdiff_t i = start; i != end; i += step)
         {
             Expression arg = (*arguments)[i];
             if (canThrow(arg, sc.func, false))
-            {
-                if (!anythrow)
-                {
-                    anythrow = true;
-                    firstthrow = i;
-                }
                 lastthrow = i;
+            if (firstdtor == -1 && arg.type.needsDestruction())
+            {
+                Parameter p = (i >= nparams ? null : Parameter.getNth(tf.parameters, i));
+                if (!(p && (p.storageClass & (STClazy | STCref | STCout))))
+                    firstdtor = i;
             }
         }
-        bool appendToPrefix = false;
+
+        /* Does problem 3) apply to this call?
+         */
+        const bool needsPrefix = (firstdtor >= 0 && lastthrow >= 0
+            && (lastthrow - firstdtor) * step > 0);
+
+        /* If so, initialize 'eprefix' by declaring the gate
+         */
         VarDeclaration gate = null;
-        for (size_t i = 0; i < arguments.dim; ++i)
+        if (needsPrefix)
+        {
+            // eprefix => bool __gate [= false]
+            Identifier idtmp = Identifier.generateId("__gate");
+            gate = new VarDeclaration(loc, Type.tbool, idtmp, null);
+            gate.storage_class |= STCtemp | STCctfe | STCvolatile;
+            gate.semantic(sc);
+
+            auto ae = new DeclarationExp(loc, gate);
+            eprefix = ae.semantic(sc);
+        }
+
+        for (ptrdiff_t i = start; i != end; i += step)
         {
             Expression arg = (*arguments)[i];
-            /* Skip reference parameters
+
+            Parameter parameter = (i >= nparams ? null : Parameter.getNth(tf.parameters, i));
+            const bool isRef = (parameter && (parameter.storageClass & (STCref | STCout)));
+            const bool isLazy = (parameter && (parameter.storageClass & STClazy));
+
+            /* Skip lazy parameters
              */
-            if (i < nparams)
+            if (isLazy)
+                continue;
+
+            /* Do we have a gate? Then we have a prefix and we're not yet past the last throwing arg.
+             * Declare a temporary variable for this arg and append that declaration to 'eprefix',
+             * which will implicitly take care of potential problem 2) for this arg.
+             * 'eprefix' will therefore finally contain all args up to and including the last
+             * potentially throwing arg, excluding all lazy parameters.
+             */
+            if (gate)
             {
-                Parameter p = Parameter.getNth(tf.parameters, i);
-                if (p.storageClass & (STClazy | STCref | STCout))
-                    continue;
-            }
-            TypeStruct ts = null;
-            Type tv = arg.type.baseElemOf();
-            if (tv.ty == Tstruct)
-                ts = cast(TypeStruct)tv;
-            if (anythrow && i < lastthrow) // if there are throws after this arg
-            {
-                if (ts && ts.sym.dtor)
+                const bool needsDtor = (!isRef && arg.type.needsDestruction() && i != lastthrow);
+
+                /* Declare temporary 'auto __pfx = arg' (needsDtor) or 'auto __pfy = arg' (!needsDtor)
+                 */
+                Identifier idtmp = Identifier.generateId(needsDtor ? "__pfx" : "__pfy");
+                VarDeclaration tmp = (!isRef
+                    ? new VarDeclaration(loc, arg.type, idtmp, new ExpInitializer(loc, arg))
+                    : new VarDeclaration(loc, arg.type.pointerTo(), idtmp, new ExpInitializer(loc, arg.addressOf())));
+                tmp.storage_class |= STCtemp | STCctfe;
+                tmp.semantic(sc);
+
+                /* Modify the destructor so it only runs if gate==false, i.e.,
+                 * only if there was a throw while constructing the args
+                 */
+                if (!needsDtor)
                 {
-                    appendToPrefix = true;
-                    // Need the gate because throws may occur after this arg is constructed
-                    if (!gate)
+                    if (tmp.edtor)
                     {
-                        Identifier idtmp = Identifier.generateId("__gate");
-                        gate = new VarDeclaration(loc, Type.tbool, idtmp, null);
-                        gate.storage_class |= STCtemp | STCctfe | STCvolatile;
-                        gate.semantic(sc);
-                        Expression ae = new DeclarationExp(loc, gate);
-                        ae = ae.semantic(sc);
-                        eprefix = Expression.combine(eprefix, ae);
+                        assert(i == lastthrow);
+                        tmp.edtor = null;
                     }
                 }
-            }
-            if (anythrow && i == lastthrow)
-            {
-                appendToPrefix = false;
-            }
-            if (appendToPrefix) // don't need to add to prefix until there's something to destruct
-            {
-                Identifier idtmp = Identifier.generateId("__pfx");
-                auto tmp = new VarDeclaration(loc, arg.type, idtmp, new ExpInitializer(loc, arg));
-                tmp.storage_class |= STCtemp | STCctfe;
-                tmp.semantic(sc);
-                /* Modify the destructor so it only runs if gate==false
-                 */
-                if (tmp.edtor)
+                else
                 {
+                    // edtor => (__gate || edtor)
+                    assert(tmp.edtor);
                     Expression e = tmp.edtor;
-                    e = new OrOrExp(e.loc, new VarExp(e.loc, gate), e); // (gate || destructor)
+                    e = new OrOrExp(e.loc, new VarExp(e.loc, gate), e);
                     tmp.edtor = e.semantic(sc);
-                    //printf("edtor: %s\n", tmp->edtor->toChars());
+                    //printf("edtor: %s\n", tmp.edtor.toChars());
                 }
-                // auto __pfx = arg
-                Expression ae = new DeclarationExp(loc, tmp);
-                ae = ae.semantic(sc);
-                eprefix = Expression.combine(eprefix, ae);
+
+                // eprefix => (eprefix, auto __pfx/y = arg)
+                auto ae = new DeclarationExp(loc, tmp);
+                eprefix = Expression.combine(eprefix, ae.semantic(sc));
+
+                // arg => __pfx/y
                 arg = new VarExp(loc, tmp);
                 arg = arg.semantic(sc);
-            }
-            else if (ts)
-            {
-                arg = arg.isLvalue() ? callCpCtor(sc, arg) : valueNoDtor(arg);
-            }
-            else if (anythrow && firstthrow <= i && i <= lastthrow && gate)
-            {
-                Identifier id = Identifier.generateId("__pfy");
-                auto tmp = new VarDeclaration(loc, arg.type, id, new ExpInitializer(loc, arg));
-                tmp.storage_class |= STCtemp | STCctfe;
-                tmp.semantic(sc);
-                Expression ae = new DeclarationExp(loc, tmp);
-                ae = ae.semantic(sc);
-                eprefix = Expression.combine(eprefix, ae);
-                arg = new VarExp(loc, tmp);
-                arg = arg.semantic(sc);
-            }
-            if (anythrow && i == lastthrow)
-            {
-                /* Set gate to true after prefix runs
-                 */
-                if (eprefix)
+                if (isRef)
                 {
-                    assert(gate);
-                    // (gate = true)
-                    Expression e = new AssignExp(gate.loc, new VarExp(gate.loc, gate), new IntegerExp(gate.loc, 1, Type.tbool));
-                    e = e.semantic(sc);
-                    eprefix = Expression.combine(eprefix, e);
+                    arg = new PtrExp(loc, arg);
+                    arg = arg.semantic(sc);
+                }
+
+                /* Last throwing arg? Then finalize eprefix => (eprefix, gate = true),
+                 * i.e., disable the dtors right after constructing the last throwing arg.
+                 * From now on, the callee will take care of destructing the args because
+                 * the args are implicitly moved into function parameters.
+                 *
+                 * Set gate to null to let the next iterations know they don't need to
+                 * append to eprefix anymore.
+                 */
+                if (i == lastthrow)
+                {
+                    auto e = new AssignExp(gate.loc, new VarExp(gate.loc, gate), new IntegerExp(gate.loc, 1, Type.tbool));
+                    eprefix = Expression.combine(eprefix, e.semantic(sc));
                     gate = null;
                 }
             }
+            else
+            {
+                /* No gate, no prefix to append to.
+                 * Handle problem 2) by calling the copy constructor for value structs
+                 * (or static arrays of them) if appropriate.
+                 */
+                Type tv = arg.type.baseElemOf();
+                if (!isRef && tv.ty == Tstruct)
+                    arg = doCopyOrMove(sc, arg);
+            }
+
             (*arguments)[i] = arg;
         }
     }
     //if (eprefix) printf("eprefix: %s\n", eprefix->toChars());
+
     // If D linkage and variadic, add _arguments[] as first argument
     if (!IN_LLVM && tf.linkage == LINKd && tf.varargs == 1)
     {
@@ -2352,7 +2465,7 @@ public:
         fflush(stderr);
     }
 
-    override char* toChars()
+    override const(char)* toChars()
     {
         OutBuffer buf;
         HdrGenState hgs;
@@ -2372,7 +2485,7 @@ public:
         printf("%s %s\n", Token.toChars(op), type ? type.toChars() : "");
     }
 
-    final void error(const(char)* format, ...)
+    final void error(const(char)* format, ...) const
     {
         if (type != Type.terror)
         {
@@ -2383,7 +2496,7 @@ public:
         }
     }
 
-    final void warning(const(char)* format, ...)
+    final void warning(const(char)* format, ...) const
     {
         if (type != Type.terror)
         {
@@ -2394,7 +2507,7 @@ public:
         }
     }
 
-    final void deprecation(const(char)* format, ...)
+    final void deprecation(const(char)* format, ...) const
     {
         if (type != Type.terror)
         {
@@ -2578,16 +2691,31 @@ public:
         return this;
     }
 
+    /****************************************
+     * Check that the expression has a valid type.
+     * If not, generates an error "... has no type".
+     * Returns:
+     *      true if the expression is not valid.
+     * Note:
+     *      When this function returns true, `checkValue()` should also return true.
+     */
+    bool checkType()
+    {
+        return false;
+    }
+
+    /****************************************
+     * Check that the expression has a valid value.
+     * If not, generates an error "... has no value".
+     * Returns:
+     *      true if the expression is not valid or has void type.
+     */
     bool checkValue()
     {
         if (type && type.toBasetype().ty == Tvoid)
         {
             error("expression %s is void and has no value", toChars());
-            version (none)
-            {
-                print();
-                assert(0);
-            }
+            //print(); assert(0);
             if (!global.gag)
                 type = Type.terror;
             return true;
@@ -2735,7 +2863,8 @@ public:
             FuncDeclaration ff = outerfunc;
             if (sc.flags & SCOPEcompile ? ff.isPureBypassingInference() >= PUREweak : ff.setImpure())
             {
-                error("pure function '%s' cannot call impure function '%s'", ff.toPrettyChars(), f.toPrettyChars());
+                error("pure %s '%s' cannot call impure %s '%s'",
+                    ff.kind(), ff.toPrettyChars(), f.kind(), f.toPrettyChars());
                 return true;
             }
         }
@@ -2795,7 +2924,8 @@ public:
                     break;
                 if (sc.flags & SCOPEcompile ? ff.isPureBypassingInference() >= PUREweak : ff.setImpure())
                 {
-                    error("pure function '%s' cannot access mutable static data '%s'", ff.toPrettyChars(), v.toChars());
+                    error("pure %s '%s' cannot access mutable static data '%s'",
+                        ff.kind(), ff.toPrettyChars(), v.toChars());
                     err = true;
                     break;
                 }
@@ -2841,7 +2971,8 @@ public:
                 {
                     if (ff.type.isImmutable())
                     {
-                        error("pure immutable nested function '%s' cannot access mutable data '%s'", ff.toPrettyChars(), v.toChars());
+                        error("pure immutable %s '%s' cannot access mutable data '%s'",
+                            ff.kind(), ff.toPrettyChars(), v.toChars());
                         err = true;
                         break;
                     }
@@ -2851,7 +2982,8 @@ public:
                 {
                     if (ff.type.isImmutable())
                     {
-                        error("pure immutable member function '%s' cannot access mutable data '%s'", ff.toPrettyChars(), v.toChars());
+                        error("pure immutable %s '%s' cannot access mutable data '%s'",
+                            ff.kind(), ff.toPrettyChars(), v.toChars());
                         err = true;
                         break;
                     }
@@ -2866,7 +2998,8 @@ public:
         {
             if (sc.func.setUnsafe())
             {
-                error("safe function '%s' cannot access __gshared data '%s'", sc.func.toChars(), v.toChars());
+                error("safe %s '%s' cannot access __gshared data '%s'",
+                    sc.func.kind(), sc.func.toChars(), v.toChars());
                 err = true;
             }
         }
@@ -2895,7 +3028,8 @@ public:
             {
                 if (loc.linnum == 0) // e.g. implicitly generated dtor
                     loc = sc.func.loc;
-                error("safe function '%s' cannot call system function '%s'", sc.func.toPrettyChars(), f.toPrettyChars());
+                error("safe %s '%s' cannot call system %s '%s'",
+                    sc.func.kind(), sc.func.toPrettyChars(), f.kind(), f.toPrettyChars());
                 return true;
             }
         }
@@ -2924,7 +3058,8 @@ public:
             {
                 if (loc.linnum == 0) // e.g. implicitly generated dtor
                     loc = sc.func.loc;
-                error("@nogc function '%s' cannot call non-@nogc function '%s'", sc.func.toPrettyChars(), f.toPrettyChars());
+                error("@nogc %s '%s' cannot call non-@nogc %s '%s'",
+                    sc.func.kind(), sc.func.toPrettyChars(), f.kind(), f.toPrettyChars());
                 return true;
             }
         }
@@ -3669,6 +3804,8 @@ public:
 }
 
 /***********************************************************
+ * Won't be generated by parser.
+ * A placeholder expression to call DsymbolExp.resolve on specific symbol.
  */
 extern (C++) final class DsymbolExp : Expression
 {
@@ -3676,7 +3813,7 @@ public:
     Dsymbol s;
     bool hasOverloads;
 
-    extern (D) this(Loc loc, Dsymbol s, bool hasOverloads = false)
+    extern (D) this(Loc loc, Dsymbol s, bool hasOverloads = true)
     {
         super(loc, TOKdsymbol, __traits(classInstanceSize, DsymbolExp));
         this.s = s;
@@ -3688,6 +3825,13 @@ public:
         return resolve(loc ,sc, s, hasOverloads);
     }
 
+    /****************************************
+     * Resolve a symbol `s` and wraps it in an expression object.
+     * Params:
+     *      hasOverloads = works if the aliased symbol is a function.
+     *          true:  it's overloaded and will be resolved later.
+     *          false: it's exact function symbol.
+     */
     static Expression resolve(Loc loc, Scope *sc, Dsymbol s, bool hasOverloads)
     {
         static if (LOGSEMANTIC)
@@ -3697,7 +3841,7 @@ public:
     Lagain:
         Expression e;
         //printf("DsymbolExp:: %p '%s' is a symbol\n", this, toChars());
-        //printf("s = '%s', s->kind = '%s'\n", s->toChars(), s->kind());
+        //printf("s = '%s', s.kind = '%s'\n", s.toChars(), s.kind());
         Dsymbol olds = s;
         Declaration d = s.isDeclaration();
         if (d && (d.storage_class & STCtemplateparameter))
@@ -3712,7 +3856,7 @@ public:
             // Bugzilla 12023: if 's' is a tuple variable, the tuple is returned.
             s = s.toAlias();
 
-            //printf("s = '%s', s->kind = '%s', s->needThis() = %p\n", s->toChars(), s->kind(), s->needThis());
+            //printf("s = '%s', s.kind = '%s', s.needThis() = %p\n", s.toChars(), s.kind(), s.needThis());
             if (s != olds && !s.isFuncDeclaration())
                 s.checkDeprecated(loc, sc);
         }
@@ -3723,7 +3867,7 @@ public:
         }
         if (VarDeclaration v = s.isVarDeclaration())
         {
-            //printf("Identifier '%s' is a variable, type '%s'\n", toChars(), v->type->toChars());
+            //printf("Identifier '%s' is a variable, type '%s'\n", toChars(), v.type.toChars());
             if (!v.type)
             {
                 .error(loc, "forward reference of %s %s", v.kind(), v.toChars());
@@ -3756,7 +3900,7 @@ public:
         }
         if (auto fld = s.isFuncLiteralDeclaration())
         {
-            //printf("'%s' is a function literal\n", fld->toChars());
+            //printf("'%s' is a function literal\n", fld.toChars());
             e = new FuncExp(loc, fld);
             return e.semantic(sc);
         }
@@ -3766,25 +3910,22 @@ public:
             if (!f.functionSemantic())
                 return new ErrorExp();
 
-            if (!f.type.deco)
-            {
-                const(char)* trailMsg = f.inferRetType ? "inferred return type of function call " : "";
-                .error(loc, "forward reference to %s'%s'", trailMsg, f.toChars());
+            if (!hasOverloads && f.checkForwardRef(loc))
                 return new ErrorExp();
-            }
-            FuncDeclaration fd = s.isFuncDeclaration();
+
+            auto fd = s.isFuncDeclaration();
             fd.type = f.type;
             return new VarExp(loc, fd, hasOverloads);
         }
         if (OverDeclaration od = s.isOverDeclaration())
         {
-            e = new VarExp(loc, od, 1);
+            e = new VarExp(loc, od, true);
             e.type = Type.tvoid;
             return e;
         }
         if (OverloadSet o = s.isOverloadSet())
         {
-            //printf("'%s' is an overload set\n", o->toChars());
+            //printf("'%s' is an overload set\n", o.toChars());
             return new OverExp(loc, o);
         }
         if (Import imp = s.isImport())
@@ -4134,8 +4275,13 @@ public:
 extern (C++) final class StringExp : Expression
 {
 public:
-    void* string;       // char, wchar, or dchar data
-    size_t len;         // number of chars, wchars, or dchars
+    union
+    {
+        char* string;   // if sz == 1
+        wchar* wstring; // if sz == 2
+        dchar* dstring; // if sz == 4
+    }                   // (const if ownedByCtfe == OWNEDcode)
+    size_t len;         // number of code units
     ubyte sz = 1;       // 1: char, 2: wchar, 4: dchar
     ubyte committed;    // !=0 if type is committed
     char postfix = 0;   // 'c', 'w', 'd'
@@ -4146,21 +4292,24 @@ public:
         super(loc, TOKstring, __traits(classInstanceSize, StringExp));
         this.string = string;
         this.len = strlen(string);
+        this.sz = 1;                    // work around LDC bug #1286
     }
 
     extern (D) this(Loc loc, void* string, size_t len)
     {
         super(loc, TOKstring, __traits(classInstanceSize, StringExp));
-        this.string = string;
+        this.string = cast(char*)string;
         this.len = len;
+        this.sz = 1;                    // work around LDC bug #1286
     }
 
     extern (D) this(Loc loc, void* string, size_t len, char postfix)
     {
         super(loc, TOKstring, __traits(classInstanceSize, StringExp));
-        this.string = string;
+        this.string = cast(char*)string;
         this.len = len;
         this.postfix = postfix;
+        this.sz = 1;                    // work around LDC bug #1286
     }
 
     static StringExp create(Loc loc, char* s)
@@ -4194,13 +4343,13 @@ public:
         size_t newlen = 0;
         const(char)* p;
         size_t u;
-        uint c;
+        dchar c;
         switch (postfix)
         {
         case 'd':
             for (u = 0; u < len;)
             {
-                p = utf_decodeChar(cast(char*)string, len, &u, &c);
+                p = utf_decodeChar(string, len, u, c);
                 if (p)
                 {
                     error("%s", p);
@@ -4213,7 +4362,7 @@ public:
                 }
             }
             buffer.write4(0);
-            string = buffer.extractData();
+            dstring = cast(dchar*)buffer.extractData();
             len = newlen;
             sz = 4;
             type = new TypeDArray(Type.tdchar.immutableOf());
@@ -4222,7 +4371,7 @@ public:
         case 'w':
             for (u = 0; u < len;)
             {
-                p = utf_decodeChar(cast(char*)string, len, &u, &c);
+                p = utf_decodeChar(string, len, u, c);
                 if (p)
                 {
                     error("%s", p);
@@ -4237,7 +4386,7 @@ public:
                 }
             }
             buffer.writeUTF16(0);
-            string = buffer.extractData();
+            wstring = cast(wchar*)buffer.extractData();
             len = newlen;
             sz = 2;
             type = new TypeDArray(Type.twchar.immutableOf());
@@ -4245,6 +4394,7 @@ public:
             break;
         case 'c':
             committed = 1;
+            goto default;
         default:
             type = new TypeDArray(Type.tchar.immutableOf());
             break;
@@ -4263,7 +4413,7 @@ public:
      * Returns:
      *      number of code units
      */
-    final size_t numberOfCodeUnits(int tynto = 0)
+    final size_t numberOfCodeUnits(int tynto = 0) const
     {
         int encSize;
         switch (tynto)
@@ -4278,13 +4428,13 @@ public:
         if (sz == encSize)
             return len;
         size_t result = 0;
-        dchar_t c;
+        dchar c;
         switch (sz)
         {
         case 1:
             for (size_t u = 0; u < len;)
             {
-                if (const(char)* p = utf_decodeChar(cast(char*)string, len, &u, &c))
+                if (const p = utf_decodeChar(string, len, u, c))
                 {
                     error("%s", p);
                     return 0;
@@ -4295,7 +4445,7 @@ public:
         case 2:
             for (size_t u = 0; u < len;)
             {
-                if (const(char)* p = utf_decodeWchar(cast(utf16_t*)string, len, &u, &c))
+                if (const p = utf_decodeWchar(wstring, len, u, c))
                 {
                     error("%s", p);
                     return 0;
@@ -4304,11 +4454,9 @@ public:
             }
             break;
         case 4:
-            for (size_t u = 0; u < len;)
+            foreach (u; 0 .. len)
             {
-                c = *(cast(utf32_t*)(cast(char*)string + u));
-                u += 4;
-                result += utf_codeLength(encSize, c);
+                result += utf_codeLength(encSize, dstring[u]);
             }
             break;
         default:
@@ -4325,7 +4473,7 @@ public:
      *  tyto = encoding type of the result
      *  zero = add terminating 0
      */
-    void writeTo(void* dest, bool zero, int tyto = 0)
+    void writeTo(void* dest, bool zero, int tyto = 0) const
     {
         int encSize;
         switch (tyto)
@@ -4347,6 +4495,50 @@ public:
             assert(0);
     }
 
+    /*********************************************
+     * Get the code unit at index i
+     * Params:
+     *  i = index
+     * Returns:
+     *  code unit at index i
+     */
+    final dchar getCodeUnit(size_t i) const pure
+    {
+        assert(i < len);
+        final switch (sz)
+        {
+        case 1:
+            return string[i];
+        case 2:
+            return wstring[i];
+        case 4:
+            return dstring[i];
+        }
+    }
+
+    /*********************************************
+     * Set the code unit at index i to c
+     * Params:
+     *  i = index
+     *  c = code unit to set it to
+     */
+    final void setCodeUnit(size_t i, dchar c)
+    {
+        assert(i < len);
+        final switch (sz)
+        {
+        case 1:
+            string[i] = cast(char)c;
+            break;
+        case 2:
+            wstring[i] = cast(wchar)c;
+            break;
+        case 4:
+            dstring[i] = c;
+            break;
+        }
+    }
+
     /**************************************************
      * If the string data is UTF-8 and can be accessed directly,
      * return a pointer to it.
@@ -4356,7 +4548,7 @@ public:
      */
     char* toPtr()
     {
-        return (sz == 1) ? cast(char*)string : null;
+        return (sz == 1) ? string : null;
     }
 
     override StringExp toStringExp()
@@ -4401,7 +4593,7 @@ public:
             switch (sz)
             {
             case 1:
-                return memcmp(cast(char*)string, cast(char*)se2.string, len1);
+                return memcmp(string, se2.string, len1);
             case 2:
                 {
                     wchar* s1 = cast(wchar*)string;
@@ -4456,7 +4648,7 @@ public:
         return new ErrorExp();
     }
 
-    uint charAt(uinteger_t i)
+    uint charAt(uinteger_t i) const
     {
         uint value;
         switch (sz)
@@ -4480,7 +4672,7 @@ public:
      * Convert string contents to a 0 terminated string,
      * allocated by mem.xmalloc().
      */
-    final char* toStringz()
+    final const(char)* toStringz() const
     {
         auto nbytes = len * sz;
         char* s = cast(char*)mem.xmalloc(nbytes + sz);
@@ -4488,6 +4680,12 @@ public:
         return s;
     }
 
+    extern (D) const(char)[] peekSlice() const
+    {
+        assert(sz == 1);
+        return this.string[0 .. len];
+    }
+
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -4543,7 +4741,8 @@ public:
             }
             else if (o.dyncast() == DYNCAST_EXPRESSION)
             {
-                Expression e = cast(Expression)o;
+                auto e = (cast(Expression)o).copy();
+                e.loc = loc;    // Bugzilla 15669
                 this.exps.push(e);
             }
             else if (o.dyncast() == DYNCAST_TYPE)
@@ -4978,18 +5177,11 @@ public:
         // A global variable for taking the address of this struct literal constant,
         // if it already exists. Used to resolve self-references.
         void* globalVar; // llvm::GlobalVariable*
-
-        /// Set if this is really the result of a struct .init access and should be
-        /// resolved codegen'd as an access to the given SymbolDeclaration.
-        // LDC_FIXME: Figure out whether this, i.e. imitating the DMD behavior, is
-        // really the best way to fix the nested struct constant folding issue.
-        SymbolDeclaration sinit;
     }
-    else
-    Symbol* sinit;          // if this is a defaultInitLiteral, this symbol contains the default initializer
+
+    bool useStaticInit;     // if this is true, use the StructDeclaration's init symbol
     Symbol* sym;            // back end symbol to initialize with literal
-    size_t soffset;         // offset from start of s
-    int fillHoles = 1;      // fill alignment 'holes' with zero
+    bool fillHoles = true;  // fill alignment 'holes' with zero
     OwnedBy ownedByCtfe = OWNEDcode;
 
     // pointer to the origin instance of the expression.
@@ -5128,15 +5320,11 @@ public:
                     e = e.copy();
                     e.type = type;
                 }
-version(IN_LLVM) {}
-else
-{
-                if (sinit && e.op == TOKstructliteral && e.type.needsNested())
+                if (useStaticInit && e.op == TOKstructliteral && e.type.needsNested())
                 {
                     StructLiteralExp se = cast(StructLiteralExp)e;
-                    se.sinit = toInitializer(se.sd);
+                    se.useStaticInit = true;
                 }
-}
             }
         }
         return e;
@@ -5248,7 +5436,7 @@ public:
         else if (s)
         {
             //printf("s = %s %s\n", s->kind(), s->toChars());
-            e = DsymbolExp.resolve(loc, sc, s, s.hasOverloads());
+            e = DsymbolExp.resolve(loc, sc, s, true);
         }
         else
             assert(0);
@@ -5257,6 +5445,12 @@ public:
         return e;
     }
 
+    override bool checkType()
+    {
+        error("type %s is not an expression", toChars());
+        return true;
+    }
+
     override bool checkValue()
     {
         error("type %s has no value", toChars());
@@ -5270,19 +5464,25 @@ public:
 }
 
 /***********************************************************
- * Mainly just a placeholder
+ * Mainly just a placeholder of
+ *  Package, Module, Nspace, and TemplateInstance (including TemplateMixin)
+ *
+ * A template instance that requires IFTI:
+ *      foo!tiargs(fargs)       // foo!tiargs
+ * is left until CallExp::semantic() or resolveProperties()
  */
 extern (C++) final class ScopeExp : Expression
 {
 public:
     ScopeDsymbol sds;
 
-    extern (D) this(Loc loc, ScopeDsymbol pkg)
+    extern (D) this(Loc loc, ScopeDsymbol sds)
     {
         super(loc, TOKscope, __traits(classInstanceSize, ScopeExp));
-        //printf("ScopeExp::ScopeExp(sds = '%s')\n", pkg->toChars());
+        //printf("ScopeExp::ScopeExp(sds = '%s')\n", sds.toChars());
         //static int count; if (++count == 38) *(char*)0=0;
-        this.sds = pkg;
+        this.sds = sds;
+        assert(!sds.isTemplateDeclaration());   // instead, you should use TemplateExp
     }
 
     override Expression syntaxCopy()
@@ -5296,8 +5496,8 @@ public:
         {
             printf("+ScopeExp::semantic(%p '%s')\n", this, toChars());
         }
-        //if (type == Type::tvoid)
-        //    return this;
+        if (type)
+            return this;
 
         ScopeDsymbol sds2 = sds;
         TemplateInstance ti = sds2.isTemplateInstance();
@@ -5337,6 +5537,9 @@ public:
                         return e.semantic(sc);
                     }
                 }
+                // ti is an instance which requires IFTI.
+                sds = ti;
+                type = Type.tvoid;
                 return this;
             }
             ti.semantic(sc);
@@ -5395,7 +5598,7 @@ public:
             }
 
             //printf("s = %s, '%s'\n", s.kind(), s.toChars());
-            auto e = DsymbolExp.resolve(loc, sc, s, s.hasOverloads());
+            auto e = DsymbolExp.resolve(loc, sc, s, true);
             //printf("-1ScopeExp::semantic()\n");
             return e;
         }
@@ -5404,8 +5607,11 @@ public:
         //printf("\tparent = '%s'\n", sds2.parent.toChars());
         sds2.semantic(sc);
 
-        if (auto ad = sds2.isAggregateDeclaration())
-            return (new TypeExp(loc, ad.type)).semantic(sc);
+        if (auto t = sds2.getType())    // (Aggregate|Enum)Declaration
+            return (new TypeExp(loc, t)).semantic(sc);
+
+        if (auto td = sds2.isTemplateDeclaration())
+            return (new TemplateExp(loc, td)).semantic(sc);
 
         sds = sds2;
         type = Type.tvoid;
@@ -5413,6 +5619,33 @@ public:
         return this;
     }
 
+    override bool checkType()
+    {
+        if (sds.isPackage())
+        {
+            error("%s %s has no type", sds.kind(), sds.toChars());
+            return true;
+        }
+        if (auto ti = sds.isTemplateInstance())
+        {
+            //assert(ti.needsTypeInference(sc));
+            if (ti.tempdecl &&
+                ti.semantictiargsdone &&
+                ti.semanticRun == PASSinit)
+            {
+                error("partial %s %s has no type", sds.kind(), toChars());
+                return true;
+            }
+        }
+        return false;
+    }
+
+    override bool checkValue()
+    {
+        error("%s %s has no value", sds.kind(), sds.toChars());
+        return true;
+    }
+
     override void accept(Visitor v)
     {
         v.visit(this);
@@ -5449,9 +5682,15 @@ public:
         return DsymbolExp.resolve(loc, sc, fd, true);
     }
 
+    override bool checkType()
+    {
+        error("%s %s has no type", td.kind(), toChars());
+        return true;
+    }
+
     override bool checkValue()
     {
-        error("template %s has no value", toChars());
+        error("%s %s has no value", td.kind(), toChars());
         return true;
     }
 
@@ -5487,7 +5726,11 @@ public:
 
     override Expression syntaxCopy()
     {
-        return new NewExp(loc, thisexp ? thisexp.syntaxCopy() : null, arraySyntaxCopy(newargs), newtype.syntaxCopy(), arraySyntaxCopy(arguments));
+        return new NewExp(loc,
+            thisexp ? thisexp.syntaxCopy() : null,
+            arraySyntaxCopy(newargs),
+            newtype.syntaxCopy(),
+            arraySyntaxCopy(arguments));
     }
 
     override Expression semantic(Scope* sc)
@@ -5501,57 +5744,84 @@ public:
         }
         if (type) // if semantic() already run
             return this;
-        Type tb;
+
+        // Bugzilla 11581: With the syntax `new T[edim]` or `thisexp.new T[edim]`,
+        // T should be analyzed first and edim should go into arguments iff it's
+        // not a tuple.
+        Expression edim = null;
+        if (!arguments && newtype.ty == Tsarray)
+        {
+            edim = (cast(TypeSArray)newtype).dim;
+            newtype = (cast(TypeNext)newtype).next;
+        }
+
         ClassDeclaration cdthis = null;
-        size_t nargs;
-        Expression newprefix = null;
-    Lagain:
         if (thisexp)
         {
             thisexp = thisexp.semantic(sc);
+            if (thisexp.op == TOKerror)
+                return new ErrorExp();
             cdthis = thisexp.type.isClassHandle();
-            if (cdthis)
-            {
-                sc = sc.push(cdthis);
-                type = newtype.semantic(loc, sc);
-                sc = sc.pop();
-                if (type.ty == Terror)
-                    goto Lerr;
-                if (!MODimplicitConv(thisexp.type.mod, newtype.mod))
-                {
-                    error("nested type %s should have the same or weaker constancy as enclosing type %s", newtype.toChars(), thisexp.type.toChars());
-                    goto Lerr;
-                }
-            }
-            else
+            if (!cdthis)
             {
                 error("'this' for nested class must be a class type, not %s", thisexp.type.toChars());
-                goto Lerr;
+                return new ErrorExp();
             }
+
+            sc = sc.push(cdthis);
+            type = newtype.semantic(loc, sc);
+            sc = sc.pop();
         }
         else
         {
             type = newtype.semantic(loc, sc);
-            if (type.ty == Terror)
-                goto Lerr;
         }
+        if (type.ty == Terror)
+            return new ErrorExp();
+
+        if (edim)
+        {
+            if (type.toBasetype().ty == Ttuple)
+            {
+                // --> new T[edim]
+                type = new TypeSArray(type, edim);
+                type = type.semantic(loc, sc);
+                if (type.ty == Terror)
+                    return new ErrorExp();
+            }
+            else
+            {
+                // --> new T[](edim)
+                arguments = new Expressions();
+                arguments.push(edim);
+                type = type.arrayOf();
+            }
+        }
+
         newtype = type; // in case type gets cast to something else
-        tb = type.toBasetype();
-        //printf("tb: %s, deco = %s\n", tb->toChars(), tb->deco);
-        if (arrayExpressionSemantic(newargs, sc) || preFunctionParameters(loc, sc, newargs))
+        Type tb = type.toBasetype();
+        //printf("tb: %s, deco = %s\n", tb.toChars(), tb.deco);
+
+        if (arrayExpressionSemantic(newargs, sc) ||
+            preFunctionParameters(loc, sc, newargs))
         {
-            goto Lerr;
+            return new ErrorExp();
         }
-        if (arrayExpressionSemantic(arguments, sc) || preFunctionParameters(loc, sc, arguments))
+        if (arrayExpressionSemantic(arguments, sc) ||
+            preFunctionParameters(loc, sc, arguments))
         {
-            goto Lerr;
+            return new ErrorExp();
         }
-        nargs = arguments ? arguments.dim : 0;
+
         if (thisexp && tb.ty != Tclass)
         {
             error("e.new is only for allocating nested classes, not %s", tb.toChars());
-            goto Lerr;
+            return new ErrorExp();
         }
+
+        size_t nargs = arguments ? arguments.dim : 0;
+        Expression newprefix = null;
+
         if (tb.ty == Tclass)
         {
             ClassDeclaration cd = (cast(TypeClass)tb).sym;
@@ -5561,12 +5831,13 @@ public:
             if (cd.noDefaultCtor && !nargs && !cd.defaultCtor)
             {
                 error("default construction is disabled for type %s", cd.type.toChars());
-                goto Lerr;
+                return new ErrorExp();
             }
+
             if (cd.isInterfaceDeclaration())
             {
                 error("cannot create instance of interface %s", cd.toChars());
-                goto Lerr;
+                return new ErrorExp();
             }
             if (cd.isAbstract())
             {
@@ -5575,21 +5846,23 @@ public:
                 {
                     FuncDeclaration fd = cd.vtbl[i].isFuncDeclaration();
                     if (fd && fd.isAbstract())
-                        errorSupplemental(loc, "function '%s' is not implemented", fd.toFullSignature());
+                    {
+                        errorSupplemental(loc, "function '%s' is not implemented",
+                            fd.toFullSignature());
+                    }
                 }
-                goto Lerr;
+                return new ErrorExp();
             }
             // checkDeprecated() is already done in newtype->semantic().
+
             if (cd.isNested())
             {
                 /* We need a 'this' pointer for the nested class.
                  * Ensure we have the right one.
                  */
                 Dsymbol s = cd.toParent2();
-                ClassDeclaration cdn = s.isClassDeclaration();
-                FuncDeclaration fdn = s.isFuncDeclaration();
-                //printf("cd isNested, cdn = %s\n", cdn ? cdn->toChars() : "null");
-                if (cdn)
+                //printf("cd isNested, parent = %s '%s'\n", s.kind(), s.toPrettyChars());
+                if (auto cdn = s.isClassDeclaration())
                 {
                     if (!cdthis)
                     {
@@ -5599,8 +5872,9 @@ public:
                         {
                             if (!sp)
                             {
-                                error("outer class %s 'this' needed to 'new' nested class %s", cdn.toChars(), cd.toChars());
-                                goto Lerr;
+                                error("outer class %s 'this' needed to 'new' nested class %s",
+                                    cdn.toChars(), cd.toChars());
+                                return new ErrorExp();
                             }
                             ClassDeclaration cdp = sp.isClassDeclaration();
                             if (!cdp)
@@ -5610,41 +5884,39 @@ public:
                             // Add a '.outer' and try again
                             thisexp = new DotIdExp(loc, thisexp, Id.outer);
                         }
-                        if (!global.errors)
-                            goto Lagain;
+
+                        thisexp = thisexp.semantic(sc);
+                        if (thisexp.op == TOKerror)
+                            return new ErrorExp();
+                        cdthis = thisexp.type.isClassHandle();
                     }
-                    if (cdthis)
+                    if (cdthis != cdn && !cdn.isBaseOf(cdthis, null))
                     {
-                        //printf("cdthis = %s\n", cdthis->toChars());
-                        if (cdthis != cdn && !cdn.isBaseOf(cdthis, null))
-                        {
-                            error("'this' for nested class must be of type %s, not %s", cdn.toChars(), thisexp.type.toChars());
-                            goto Lerr;
-                        }
+                        //printf("cdthis = %s\n", cdthis.toChars());
+                        error("'this' for nested class must be of type %s, not %s",
+                            cdn.toChars(), thisexp.type.toChars());
+                        return new ErrorExp();
+                    }
+                    if (!MODimplicitConv(thisexp.type.mod, newtype.mod))
+                    {
+                        error("nested type %s should have the same or weaker constancy as enclosing type %s",
+                            newtype.toChars(), thisexp.type.toChars());
+                        return new ErrorExp();
                     }
                 }
                 else if (thisexp)
                 {
                     error("e.new is only for allocating nested classes");
-                    goto Lerr;
+                    return new ErrorExp();
                 }
-                else if (fdn)
+                else if (auto fdn = s.isFuncDeclaration())
                 {
                     // make sure the parent context fdn of cd is reachable from sc
-                    for (Dsymbol sp = sc.parent; 1; sp = sp.parent)
+                    if (checkNestedRef(sc.parent, fdn))
                     {
-                        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());
-                            goto Lerr;
-                        }
-                        else if (FuncLiteralDeclaration fld = sp.isFuncLiteralDeclaration())
-                        {
-                            fld.tok = TOKdelegate;
-                        }
+                        error("outer function context of %s is needed to 'new' nested class %s",
+                            fdn.toPrettyChars(), cd.toPrettyChars());
+                        return new ErrorExp();
                     }
                 }
                 else
@@ -5653,8 +5925,9 @@ public:
             else if (thisexp)
             {
                 error("e.new is only for allocating nested classes");
-                goto Lerr;
+                return new ErrorExp();
             }
+
             if (cd.aggNew)
             {
                 // Prepend the size argument to newargs[]
@@ -5662,18 +5935,21 @@ public:
                 if (!newargs)
                     newargs = new Expressions();
                 newargs.shift(e);
+
                 FuncDeclaration f = resolveFuncCall(loc, sc, cd.aggNew, null, tb, newargs);
                 if (!f || f.errors)
-                    goto Lerr;
+                    return new ErrorExp();
                 checkDeprecated(sc, f);
                 checkPurity(sc, f);
                 checkSafety(sc, f);
                 checkNogc(sc, f);
                 checkAccess(cd, loc, sc, f);
+
                 TypeFunction tf = cast(TypeFunction)f.type;
                 Type rettype;
                 if (functionParameters(loc, sc, tf, null, newargs, f, &rettype, &newprefix))
                     return new ErrorExp();
+
                 allocator = f.isNewDeclaration();
                 assert(allocator);
             }
@@ -5682,24 +5958,27 @@ public:
                 if (newargs && newargs.dim)
                 {
                     error("no allocator for %s", cd.toChars());
-                    goto Lerr;
+                    return new ErrorExp();
                 }
             }
+
             if (cd.ctor)
             {
                 FuncDeclaration f = resolveFuncCall(loc, sc, cd.ctor, null, tb, arguments, 0);
                 if (!f || f.errors)
-                    goto Lerr;
+                    return new ErrorExp();
                 checkDeprecated(sc, f);
                 checkPurity(sc, f);
                 checkSafety(sc, f);
                 checkNogc(sc, f);
                 checkAccess(cd, loc, sc, f);
+
                 TypeFunction tf = cast(TypeFunction)f.type;
                 if (!arguments)
                     arguments = new Expressions();
                 if (functionParameters(loc, sc, tf, type, arguments, f, &type, &argprefix))
                     return new ErrorExp();
+
                 member = f.isCtorDeclaration();
                 assert(member);
             }
@@ -5708,7 +5987,7 @@ public:
                 if (nargs)
                 {
                     error("no constructor for %s", cd.toChars());
-                    goto Lerr;
+                    return new ErrorExp();
                 }
             }
         }
@@ -5721,9 +6000,10 @@ public:
             if (sd.noDefaultCtor && !nargs)
             {
                 error("default construction is disabled for type %s", sd.type.toChars());
-                goto Lerr;
+                return new ErrorExp();
             }
             // checkDeprecated() is already done in newtype->semantic().
+
             if (sd.aggNew)
             {
                 // Prepend the uint size argument to newargs[]
@@ -5731,18 +6011,21 @@ public:
                 if (!newargs)
                     newargs = new Expressions();
                 newargs.shift(e);
+
                 FuncDeclaration f = resolveFuncCall(loc, sc, sd.aggNew, null, tb, newargs);
                 if (!f || f.errors)
-                    goto Lerr;
+                    return new ErrorExp();
                 checkDeprecated(sc, f);
                 checkPurity(sc, f);
                 checkSafety(sc, f);
                 checkNogc(sc, f);
                 checkAccess(sd, loc, sc, f);
+
                 TypeFunction tf = cast(TypeFunction)f.type;
                 Type rettype;
                 if (functionParameters(loc, sc, tf, null, newargs, f, &rettype, &newprefix))
                     return new ErrorExp();
+
                 allocator = f.isNewDeclaration();
                 assert(allocator);
             }
@@ -5751,26 +6034,30 @@ public:
                 if (newargs && newargs.dim)
                 {
                     error("no allocator for %s", sd.toChars());
-                    goto Lerr;
+                    return new ErrorExp();
                 }
             }
+
             if (sd.ctor && nargs)
             {
                 FuncDeclaration f = resolveFuncCall(loc, sc, sd.ctor, null, tb, arguments, 0);
                 if (!f || f.errors)
-                    goto Lerr;
+                    return new ErrorExp();
                 checkDeprecated(sc, f);
                 checkPurity(sc, f);
                 checkSafety(sc, f);
                 checkNogc(sc, f);
                 checkAccess(sd, loc, sc, f);
+
                 TypeFunction tf = cast(TypeFunction)f.type;
                 if (!arguments)
                     arguments = new Expressions();
                 if (functionParameters(loc, sc, tf, type, arguments, f, &type, &argprefix))
                     return new ErrorExp();
+
                 member = f.isCtorDeclaration();
                 assert(member);
+
                 if (checkFrameAccess(loc, sc, sd, sd.fields.dim))
                     return new ErrorExp();
             }
@@ -5778,13 +6065,17 @@ public:
             {
                 if (!arguments)
                     arguments = new Expressions();
+
                 if (!sd.fit(loc, sc, arguments, tb))
                     return new ErrorExp();
+
                 if (!sd.fill(loc, arguments, false))
                     return new ErrorExp();
+
                 if (checkFrameAccess(loc, sc, sd, arguments ? arguments.dim : 0))
                     return new ErrorExp();
             }
+
             type = type.pointerTo();
         }
         else if (tb.ty == Tarray && nargs)
@@ -5795,15 +6086,16 @@ public:
             if (ad && ad.noDefaultCtor)
             {
                 error("default construction is disabled for type %s", tb.nextOf().toChars());
-                goto Lerr;
+                return new ErrorExp();
             }
             for (size_t i = 0; i < nargs; i++)
             {
                 if (tb.ty != Tarray)
                 {
                     error("too many arguments for array");
-                    goto Lerr;
+                    return new ErrorExp();
                 }
+
                 Expression arg = (*arguments)[i];
                 arg = resolveProperties(sc, arg);
                 arg = arg.implicitCastTo(sc, Type.tsize_t);
@@ -5811,7 +6103,7 @@ public:
                 if (arg.op == TOKint64 && cast(sinteger_t)arg.toInteger() < 0)
                 {
                     error("negative array index %s", arg.toChars());
-                    goto Lerr;
+                    return new ErrorExp();
                 }
                 (*arguments)[i] = arg;
                 tb = (cast(TypeDArray)tb).next.toBasetype();
@@ -5831,23 +6123,24 @@ public:
             else
             {
                 error("more than one argument for construction of %s", type.toChars());
-                goto Lerr;
+                return new ErrorExp();
             }
+
             type = type.pointerTo();
         }
         else
         {
             error("new can only create structs, dynamic arrays or class objects, not %s's", type.toChars());
-            goto Lerr;
+            return new ErrorExp();
         }
+
         //printf("NewExp: '%s'\n", toChars());
         //printf("NewExp:type '%s'\n", type->toChars());
         semanticTypeInfo(sc, type);
+
         if (newprefix)
             return combine(newprefix, this);
         return this;
-    Lerr:
-        return new ErrorExp();
     }
 
     override void accept(Visitor v)
@@ -5948,13 +6241,18 @@ extern (C++) final class SymOffExp : SymbolExp
 public:
     dinteger_t offset;
 
-    extern (D) this(Loc loc, Declaration var, dinteger_t offset, bool hasOverloads = false)
+    extern (D) this(Loc loc, Declaration var, dinteger_t offset, bool hasOverloads = true)
     {
+        if (auto v = var.isVarDeclaration())
+        {
+            // FIXME: This error report will never be handled anyone.
+            // It should be done before the SymOffExp construction.
+            if (v.needThis())
+                .error(loc, "need 'this' for address of %s", v.toChars());
+            hasOverloads = false;
+        }
         super(loc, TOKsymoff, __traits(classInstanceSize, SymOffExp), var, hasOverloads);
         this.offset = offset;
-        VarDeclaration v = var.isVarDeclaration();
-        if (v && v.needThis())
-            error("need 'this' for address of %s", v.toChars());
     }
 
     override Expression semantic(Scope* sc)
@@ -5966,16 +6264,18 @@ public:
         //var->semantic(sc);
         if (!type)
             type = var.type.pointerTo();
-        if (VarDeclaration v = var.isVarDeclaration())
+
+        if (auto v = var.isVarDeclaration())
         {
             if (v.checkNestedReference(sc, loc))
                 return new ErrorExp();
         }
-        else if (FuncDeclaration f = var.isFuncDeclaration())
+        else if (auto f = var.isFuncDeclaration())
         {
             if (f.checkNestedReference(sc, loc))
                 return new ErrorExp();
         }
+
         return this;
     }
 
@@ -6005,15 +6305,18 @@ version(IN_LLVM)
 extern (C++) final class VarExp : SymbolExp
 {
 public:
-    extern (D) this(Loc loc, Declaration var, bool hasOverloads = false)
+    extern (D) this(Loc loc, Declaration var, bool hasOverloads = true)
     {
+        if (var.isVarDeclaration())
+            hasOverloads = false;
+
         super(loc, TOKvar, __traits(classInstanceSize, VarExp), var, hasOverloads);
         //printf("VarExp(this = %p, '%s', loc = %s)\n", this, var->toChars(), loc.toChars());
         //if (strcmp(var->ident->toChars(), "func") == 0) assert(0);
         this.type = var.type;
     }
 
-    static VarExp create(Loc loc, Declaration var, bool hasOverloads = false)
+    static VarExp create(Loc loc, Declaration var, bool hasOverloads = true)
     {
         return new VarExp(loc, var, hasOverloads);
     }
@@ -6039,31 +6342,34 @@ public:
         {
             printf("VarExp::semantic(%s)\n", toChars());
         }
-        if (FuncDeclaration fd = var.isFuncDeclaration())
+        if (auto fd = var.isFuncDeclaration())
         {
             //printf("L%d fd = %s\n", __LINE__, f->toChars());
             if (!fd.functionSemantic())
                 return new ErrorExp();
         }
+
         if (!type)
             type = var.type;
         if (type && !type.deco)
             type = type.semantic(loc, sc);
+
         /* Fix for 1161 doesn't work because it causes protection
          * problems when instantiating imported templates passing private
          * variables as alias template parameters.
          */
         //checkAccess(loc, sc, NULL, var);
-        if (VarDeclaration vd = var.isVarDeclaration())
+
+        if (auto vd = var.isVarDeclaration())
         {
-            hasOverloads = 0;
             if (vd.checkNestedReference(sc, loc))
                 return new ErrorExp();
+
             // Bugzilla 12025: If the variable is not actually used in runtime code,
             // the purity violation error is redundant.
             //checkPurity(sc, vd);
         }
-        else if (FuncDeclaration fd = var.isFuncDeclaration())
+        else if (auto fd = var.isFuncDeclaration())
         {
             // TODO: If fd isn't yet resolved its overload, the checkNestedReference
             // call would cause incorrect validation.
@@ -6071,10 +6377,11 @@ public:
             if (fd.checkNestedReference(sc, loc))
                 return new ErrorExp();
         }
-        else if (OverDeclaration od = var.isOverDeclaration())
+        else if (auto od = var.isOverDeclaration())
         {
             type = Type.tvoid; // ambiguous type?
         }
+
         return this;
     }
 
@@ -6245,8 +6552,7 @@ public:
                 symtab = sds.symtab;
             }
             assert(symtab);
-            int num = cast(int)dmd_aaLen(symtab.tab) + 1;
-            Identifier id = Identifier.generateId(s, num);
+            Identifier id = Identifier.generateId(s, symtab.len() + 1);
             fd.ident = id;
             if (td)
                 td.ident = id;
@@ -6554,11 +6860,21 @@ public:
         return m;
     }
 
-    override char* toChars()
+    override const(char)* toChars()
     {
         return fd.toChars();
     }
 
+    override bool checkType()
+    {
+        if (td)
+        {
+            error("template lambda has no type");
+            return true;
+        }
+        return false;
+    }
+
     override bool checkValue()
     {
         if (td)
@@ -6898,6 +7214,7 @@ public:
         Scope* sc2 = sc.copy(); // keep sc->flags
         sc2.tinst = null;
         sc2.minst = null;
+        sc2.flags |= SCOPEfullinst;
         Type t = targ.trySemantic(loc, sc2);
         sc2.pop();
         if (!t)
@@ -7679,7 +7996,7 @@ public:
         }
         se = se.toUTF8(sc);
         uint errors = global.errors;
-        scope Parser p = new Parser(loc, sc._module, cast(char*)se.string, se.len, 0);
+        scope Parser p = new Parser(loc, sc._module, se.toStringz(), se.len, 0);
         p.nextToken();
         //printf("p.loc.linnum = %d\n", p.loc.linnum);
         Expression e = p.parseExpression();
@@ -7719,7 +8036,7 @@ public:
             printf("ImportExp::semantic('%s')\n", toChars());
         }
         const(char)* name;
-        char* namez;
+        const(char)* namez;
         StringExp se;
 
         sc = sc.startCTFE();
@@ -7835,6 +8152,12 @@ public:
             return e1;
         if (msg && msg.op == TOKerror)
             return msg;
+
+        auto f1 = checkNonAssignmentArrayOp(e1);
+        auto f2 = msg && checkNonAssignmentArrayOp(msg);
+        if (f1 || f2)
+            return new ErrorExp();
+
         if (e1.isBool(false))
         {
             FuncDeclaration fd = sc.parent.isFuncDeclaration();
@@ -7942,13 +8265,10 @@ public:
             L1:
                 {
                     assert(ds);
-                    if (FuncDeclaration f = ds.isFuncDeclaration())
+                    if (auto f = ds.isFuncDeclaration())
                     {
-                        if (!f.type.deco)
-                        {
-                            error("forward reference to %s", f.toChars());
+                        if (f.checkForwardRef(loc))
                             return new ErrorExp();
-                        }
                     }
                     const(char)* s = mangle(ds);
                     Expression e = new StringExp(loc, cast(void*)s, strlen(s));
@@ -8061,14 +8381,23 @@ public:
              * The check for 'is sds our current module' is because
              * the current module should have access to its own imports.
              */
-            Dsymbol s = ie.sds.search(loc, ident, (ie.sds.isModule() && ie.sds != sc._module) ? IgnorePrivateMembers : IgnoreNone);
+            Dsymbol s = ie.sds.search(loc, ident,
+                (ie.sds.isModule() && ie.sds != sc._module) ? IgnorePrivateImports | SearchLocalsOnly : SearchLocalsOnly);
+            /* Check for visibility before resolving aliases because public
+             * aliases to private symbols are public.
+             */
+            if (s && !symbolIsVisible(sc._module, s))
+            {
+                if (s.isDeclaration())
+                    .error(loc, "%s is not visible from module %s", s.toPrettyChars(), sc._module.toChars());
+                else
+                    .deprecation(loc, "%s is not visible from module %s", s.toPrettyChars(), sc._module.toChars());
+                // s = null;
+            }
             if (s)
             {
-                /* Check for access before resolving aliases because public
-                 * aliases to private symbols are public.
-                 */
-                if (Declaration d = s.isDeclaration())
-                    checkAccess(loc, sc, null, d);
+                if (auto p = s.isPackage())
+                    checkAccess(loc, sc, p);
 
                 // if 's' is a tuple variable, the tuple is returned.
                 s = s.toAlias();
@@ -8118,12 +8447,12 @@ public:
                     {
                         if (!eleft)
                             eleft = new ThisExp(loc);
-                        e = new DotVarExp(loc, eleft, f);
+                        e = new DotVarExp(loc, eleft, f, true);
                         e = e.semantic(sc);
                     }
                     else
                     {
-                        e = new VarExp(loc, f, 1);
+                        e = new VarExp(loc, f, true);
                         if (eleft)
                         {
                             e = new CommaExp(loc, eleft, e);
@@ -8132,9 +8461,18 @@ public:
                     }
                     return e;
                 }
+                if (auto td = s.isTemplateDeclaration())
+                {
+                    if (eleft)
+                        e = new DotTemplateExp(loc, eleft, td);
+                    else
+                        e = new TemplateExp(loc, td);
+                    e = e.semantic(sc);
+                    return e;
+                }
                 if (OverDeclaration od = s.isOverDeclaration())
                 {
-                    e = new VarExp(loc, od, 1);
+                    e = new VarExp(loc, od, true);
                     if (eleft)
                     {
                         e = new CommaExp(loc, eleft, e);
@@ -8189,8 +8527,8 @@ public:
             }
             else if (ident == Id.stringof)
             {
-                char* p = ie.toChars();
-                e = new StringExp(loc, p, strlen(p));
+                const p = ie.toChars();
+                e = new StringExp(loc, cast(char*)p, strlen(p));
                 e = e.semantic(sc);
                 return e;
             }
@@ -8279,11 +8617,14 @@ public:
     Declaration var;
     bool hasOverloads;
 
-    extern (D) this(Loc loc, Expression e, Declaration v, bool hasOverloads = false)
+    extern (D) this(Loc loc, Expression e, Declaration var, bool hasOverloads = true)
     {
+        if (var.isVarDeclaration())
+            hasOverloads = false;
+
         super(loc, TOKdotvar, __traits(classInstanceSize, DotVarExp), e);
         //printf("DotVarExp()\n");
-        this.var = v;
+        this.var = var;
         this.hasOverloads = hasOverloads;
     }
 
@@ -8620,7 +8961,7 @@ public:
                 TemplateDeclaration td = fd.findTemplateDeclRoot();
                 if (td)
                 {
-                    e = new ScopeExp(ve.loc, td);
+                    e = new TemplateExp(ve.loc, td);
                     e = e.semantic(sc);
                 }
             }
@@ -8652,26 +8993,14 @@ public:
                 e = e.semantic(sc);
                 return e;
             }
-            if (e1.op == TOKtype)
-            {
-                e = DsymbolExp.resolve(loc, sc, s, false);
-                return e;
-            }
             e = new ScopeExp(loc, ti);
             e = new DotExp(loc, e1, e);
             e = e.semantic(sc);
             return e;
         }
-        else if (e.op == TOKscope)
+        else if (e.op == TOKtemplate)
         {
-            ScopeExp se = cast(ScopeExp)e;
-            TemplateDeclaration td = se.sds.isTemplateDeclaration();
-            if (!td)
-            {
-                error("%s is not a template", e.toChars());
-                return new ErrorExp();
-            }
-            ti.tempdecl = td;
+            ti.tempdecl = (cast(TemplateExp)e).td;
             e = new ScopeExp(loc, ti);
             e = e.semantic(sc);
             return e;
@@ -8679,7 +9008,7 @@ public:
         else if (e.op == TOKdot)
         {
             DotExp de = cast(DotExp)e;
-            e1 = de.e1; // pull semantic() result
+
             if (de.e2.op == TOKoverloadset)
             {
                 if (!findTempDecl(sc) || !ti.semanticTiargs(sc))
@@ -8706,23 +9035,6 @@ public:
                 e = e.semantic(sc);
                 return e;
             }
-            if (de.e2.op == TOKscope)
-            {
-                // This should *really* be moved to ScopeExp::semantic()
-                ScopeExp se = cast(ScopeExp)de.e2;
-                de.e2 = DsymbolExp.resolve(loc, sc, se.sds, false);
-            }
-            if (de.e2.op == TOKtemplate)
-            {
-                TemplateExp te = cast(TemplateExp)de.e2;
-                e = new DotTemplateExp(loc, de.e1, te.td);
-            }
-            else
-                goto Lerr;
-            e = e.semantic(sc);
-            if (e == de)
-                goto Lerr;
-            goto L1;
         }
         else if (e.op == TOKoverloadset)
         {
@@ -8751,7 +9063,7 @@ public:
     FuncDeclaration func;
     bool hasOverloads;
 
-    extern (D) this(Loc loc, Expression e, FuncDeclaration f, bool hasOverloads = false)
+    extern (D) this(Loc loc, Expression e, FuncDeclaration f, bool hasOverloads = true)
     {
         super(loc, TOKdelegate, __traits(classInstanceSize, DelegateExp), e);
         this.func = f;
@@ -8907,26 +9219,26 @@ public:
                     earg.type.print();
             }
         }
+
         Type t1;
         Objects* tiargs = null; // initial list of template arguments
         Expression ethis = null;
         Type tthis = null;
         Expression e1org = e1;
+
         if (e1.op == TOKcomma)
         {
             /* Rewrite (a,b)(args) as (a,(b(args)))
              */
-            CommaExp ce = cast(CommaExp)e1;
+            auto ce = cast(CommaExp)e1;
             e1 = ce.e2;
-            e1.type = ce.type;
             ce.e2 = this;
-            ce.type = null;
             return ce.semantic(sc);
         }
         if (e1.op == TOKdelegate)
         {
             DelegateExp de = cast(DelegateExp)e1;
-            e1 = new DotVarExp(de.loc, de.e1, de.func);
+            e1 = new DotVarExp(de.loc, de.e1, de.func, de.hasOverloads);
             return semantic(sc);
         }
         if (e1.op == TOKfunction)
@@ -8941,12 +9253,14 @@ public:
             if (e1.op == TOKerror)
                 return e1;
         }
+
         if (Expression ex = resolveUFCS(sc, this))
             return ex;
+
         /* This recognizes:
          *  foo!(tiargs)(funcargs)
          */
-        if (e1.op == TOKscope && !e1.type)
+        if (e1.op == TOKscope)
         {
             ScopeExp se = cast(ScopeExp)e1;
             TemplateInstance ti = se.sds.isTemplateInstance();
@@ -8988,6 +9302,7 @@ public:
                 }
             }
         }
+
         /* This recognizes:
          *  expr.foo!(tiargs)(funcargs)
          */
@@ -9014,7 +9329,7 @@ public:
                         e1 = new DotTemplateExp(loc, se.e1, td);
                     else if (OverDeclaration od = ti.tempdecl.isOverDeclaration())
                     {
-                        e1 = new DotVarExp(loc, se.e1, od);
+                        e1 = new DotVarExp(loc, se.e1, od, true);
                     }
                     else
                         e1 = new DotExp(loc, se.e1, new OverExp(loc, ti.tempdecl.isOverloadSet()));
@@ -9028,6 +9343,7 @@ public:
                 }
             }
         }
+
     Lagain:
         //printf("Lagain: %s\n", toChars());
         f = null;
@@ -9064,6 +9380,7 @@ public:
                 if (ex)
                     return ex;
             }
+
             /* Look for e1 being a lazy parameter
              */
             if (e1.op == TOKvar)
@@ -9083,16 +9400,11 @@ public:
                 if (v && ve.checkPurity(sc, v))
                     return new ErrorExp();
             }
-            if (e1.op == TOKscope)
-            {
-                // Perhaps this should be moved to ScopeExp::semantic()
-                ScopeExp se = cast(ScopeExp)e1;
-                e1 = DsymbolExp.resolve(loc, sc, se.sds, false);
-            }
-            else if (e1.op == TOKsymoff && (cast(SymOffExp)e1).hasOverloads)
+
+            if (e1.op == TOKsymoff && (cast(SymOffExp)e1).hasOverloads)
             {
                 SymOffExp se = cast(SymOffExp)e1;
-                e1 = new VarExp(se.loc, se.var, 1);
+                e1 = new VarExp(se.loc, se.var, true);
                 e1 = e1.semantic(sc);
             }
             else if (e1.op == TOKdot)
@@ -9104,17 +9416,6 @@ public:
                     tthis = de.e1.type;
                     e1 = de.e2;
                 }
-                if (de.e2.op == TOKscope)
-                {
-                    // This should *really* be moved to ScopeExp::semantic()
-                    ScopeExp se = cast(ScopeExp)de.e2;
-                    de.e2 = DsymbolExp.resolve(loc, sc, se.sds, false);
-                }
-                if (de.e2.op == TOKtemplate)
-                {
-                    TemplateExp te = cast(TemplateExp)de.e2;
-                    e1 = new DotTemplateExp(loc, de.e1, te.td);
-                }
             }
             else if (e1.op == TOKstar && e1.type.ty == Tfunction)
             {
@@ -9122,13 +9423,16 @@ public:
                 e1 = (cast(PtrExp)e1).e1;
             }
         }
+
         t1 = e1.type ? e1.type.toBasetype() : null;
+
         if (e1.op == TOKerror)
             return e1;
         if (arrayExpressionSemantic(arguments, sc) || preFunctionParameters(loc, sc, arguments))
         {
             return new ErrorExp();
         }
+
         // Check for call operator overload
         if (t1)
         {
@@ -9154,12 +9458,12 @@ public:
                     /* Constructor takes a mutable object, so don't use
                      * the immutable initializer symbol.
                      */
-                    sle.sinit = null;
+                    sle.useStaticInit = false;
 
                     Expression e = sle;
                     if (CtorDeclaration cf = sd.ctor.isCtorDeclaration())
                     {
-                        e = new DotVarExp(loc, e, cf, 1);
+                        e = new DotVarExp(loc, e, cf, true);
                     }
                     else if (TemplateDeclaration td = sd.ctor.isTemplateDeclaration())
                     {
@@ -9229,6 +9533,37 @@ public:
                 return e;
             }
         }
+
+        static FuncDeclaration resolveOverloadSet(Loc loc, Scope* sc,
+            OverloadSet os, Objects* tiargs, Type tthis, Expressions* arguments)
+        {
+            FuncDeclaration f = null;
+            foreach (s; os.a)
+            {
+                if (tiargs && s.isFuncDeclaration())
+                    continue;
+                if (auto f2 = resolveFuncCall(loc, sc, s, tiargs, tthis, arguments, 1))
+                {
+                    if (f2.errors)
+                        return null;
+                    if (f)
+                    {
+                        /* Error if match in more than one overload set,
+                         * even if one is a 'better' match than the other.
+                         */
+                        ScopeDsymbol.multiplyDefined(loc, f, f2);
+                    }
+                    else
+                        f = f2;
+                }
+            }
+            if (!f)
+                .error(loc, "no overload matches for %s", os.toChars());
+            else if (f.errors)
+                f = null;
+            return f;
+        }
+
         if (e1.op == TOKdotvar && t1.ty == Tfunction || e1.op == TOKdottd)
         {
             UnaExp ue = cast(UnaExp)e1;
@@ -9260,6 +9595,20 @@ public:
             f = resolveFuncCall(loc, sc, s, tiargs, ue1 ? ue1.type : null, arguments);
             if (!f || f.errors || f.type.ty == Terror)
                 return new ErrorExp();
+            if (f.interfaceVirtual)
+            {
+                /* Cast 'this' to the type of the interface, and replace f with the interface's equivalent
+                 */
+                auto b = f.interfaceVirtual;
+                auto ad2 = b.sym;
+                ue.e1 = ue.e1.castTo(sc, ad2.type.addMod(ue.e1.type.mod));
+                ue.e1 = ue.e1.semantic(sc);
+                ue1 = ue.e1;
+                auto vi = f.findVtblIndex(&ad2.vtbl, cast(int)ad2.vtbl.dim);
+                assert(vi >= 0);
+                f = ad2.vtbl[vi].isFuncDeclaration();
+                assert(f);
+            }
             if (f.needThis())
             {
                 AggregateDeclaration ad = f.toParent2().isAggregateDeclaration();
@@ -9284,12 +9633,7 @@ public:
             checkAccess(loc, sc, ue.e1, f);
             if (!f.needThis())
             {
-                auto ve = new VarExp(loc, f);
-                if (ue.e1.op == TOKtype) // just a FQN
-                    e1 = ve;
-                else // things like (new Foo).bar()
-                    e1 = new CommaExp(loc, ue.e1, ve);
-                e1.type = f.type;
+                e1 = Expression.combine(ue.e1, new VarExp(loc, f, false));
             }
             else
             {
@@ -9302,7 +9646,7 @@ public:
                 }
                 else
                 {
-                    e1 = new DotVarExp(loc, dte.e1, f);
+                    e1 = new DotVarExp(loc, dte.e1, f, false);
                     e1 = e1.semantic(sc);
                     if (e1.op == TOKerror)
                         return new ErrorExp();
@@ -9342,9 +9686,8 @@ public:
         else if (e1.op == TOKsuper)
         {
             // Base class constructor call
-            ClassDeclaration cd = null;
-            if (sc.func && sc.func.isThis())
-                cd = sc.func.isThis().isClassDeclaration();
+            auto ad = sc.func ? sc.func.isThis() : null;
+            auto cd = ad ? ad.isClassDeclaration() : null;
             if (!cd || !cd.baseClass || !sc.func.isCtorDeclaration())
             {
                 error("super class constructor call must be in a constructor");
@@ -9355,6 +9698,7 @@ public:
                 error("no super class constructor for %s", cd.baseClass.toChars());
                 return new ErrorExp();
             }
+
             if (!sc.intypeof && !(sc.callSuper & CSXhalt))
             {
                 if (sc.noctor || sc.callSuper & CSXlabel)
@@ -9365,8 +9709,12 @@ public:
                     error("an earlier return statement skips constructor");
                 sc.callSuper |= CSXany_ctor | CSXsuper_ctor;
             }
+
             tthis = cd.type.addMod(sc.func.type.mod);
-            f = resolveFuncCall(loc, sc, cd.baseClass.ctor, null, tthis, arguments, 0);
+            if (auto os = cd.baseClass.ctor.isOverloadSet())
+                f = resolveOverloadSet(loc, sc, os, null, tthis, arguments);
+            else
+                f = resolveFuncCall(loc, sc, cd.baseClass.ctor, null, tthis, arguments, 0);
             if (!f || f.errors)
                 return new ErrorExp();
             checkDeprecated(sc, f);
@@ -9374,21 +9722,21 @@ public:
             checkSafety(sc, f);
             checkNogc(sc, f);
             checkAccess(loc, sc, null, f);
-            e1 = new DotVarExp(e1.loc, e1, f);
+
+            e1 = new DotVarExp(e1.loc, e1, f, false);
             e1 = e1.semantic(sc);
             t1 = e1.type;
         }
         else if (e1.op == TOKthis)
         {
             // same class constructor call
-            AggregateDeclaration cd = null;
-            if (sc.func && sc.func.isThis())
-                cd = sc.func.isThis().isAggregateDeclaration();
-            if (!cd || !sc.func.isCtorDeclaration())
+            auto ad = sc.func ? sc.func.isThis() : null;
+            if (!ad || !sc.func.isCtorDeclaration())
             {
                 error("constructor call must be in a constructor");
                 return new ErrorExp();
             }
+
             if (!sc.intypeof && !(sc.callSuper & CSXhalt))
             {
                 if (sc.noctor || sc.callSuper & CSXlabel)
@@ -9399,8 +9747,12 @@ public:
                     error("an earlier return statement skips constructor");
                 sc.callSuper |= CSXany_ctor | CSXthis_ctor;
             }
-            tthis = cd.type.addMod(sc.func.type.mod);
-            f = resolveFuncCall(loc, sc, cd.ctor, null, tthis, arguments, 0);
+
+            tthis = ad.type.addMod(sc.func.type.mod);
+            if (auto os = ad.ctor.isOverloadSet())
+                f = resolveOverloadSet(loc, sc, os, null, tthis, arguments);
+            else
+                f = resolveFuncCall(loc, sc, ad.ctor, null, tthis, arguments, 0);
             if (!f || f.errors)
                 return new ErrorExp();
             checkDeprecated(sc, f);
@@ -9408,9 +9760,11 @@ public:
             checkSafety(sc, f);
             checkNogc(sc, f);
             //checkAccess(loc, sc, NULL, f);    // necessary?
-            e1 = new DotVarExp(e1.loc, e1, f);
+
+            e1 = new DotVarExp(e1.loc, e1, f, false);
             e1 = e1.semantic(sc);
             t1 = e1.type;
+
             // BUG: this should really be done by checking the static
             // call graph
             if (f == sc.func)
@@ -9421,41 +9775,14 @@ public:
         }
         else if (e1.op == TOKoverloadset)
         {
-            OverExp eo = cast(OverExp)e1;
-            FuncDeclaration f = null;
-            Dsymbol s = null;
-            for (size_t i = 0; i < eo.vars.a.dim; i++)
-            {
-                s = eo.vars.a[i];
-                if (tiargs && s.isFuncDeclaration())
-                    continue;
-                FuncDeclaration f2 = resolveFuncCall(loc, sc, s, tiargs, tthis, arguments, 1);
-                if (f2)
-                {
-                    if (f2.errors)
-                        return new ErrorExp();
-                    if (f)
-                    {
-                        /* Error if match in more than one overload set,
-                         * even if one is a 'better' match than the other.
-                         */
-                        ScopeDsymbol.multiplyDefined(loc, f, f2);
-                    }
-                    else
-                        f = f2;
-                }
-            }
+            auto os = (cast(OverExp)e1).vars;
+            f = resolveOverloadSet(loc, sc, os, tiargs, tthis, arguments);
             if (!f)
-            {
-                /* No overload matches
-                 */
-                error("no overload matches for %s", s.toChars());
                 return new ErrorExp();
-            }
             if (ethis)
-                e1 = new DotVarExp(loc, ethis, f);
+                e1 = new DotVarExp(loc, ethis, f, false);
             else
-                e1 = new VarExp(loc, f);
+                e1 = new VarExp(loc, f, false);
             goto Lagain;
         }
         else if (!t1)
@@ -9503,10 +9830,10 @@ public:
                 {
                     dve.var = f;
                     dve.type = f.type;
-                    dve.hasOverloads = 0;
+                    dve.hasOverloads = false;
                     goto Lagain;
                 }
-                e1 = new VarExp(dve.loc, f, 0);
+                e1 = new VarExp(dve.loc, f, false);
                 Expression e = new CommaExp(loc, dve.e1, this);
                 return e.semantic(sc);
             }
@@ -9528,7 +9855,7 @@ public:
                     {
                         // Supply an implicit 'this', as in
                         //    this.ident
-                        e1 = new DotVarExp(loc, (new ThisExp(loc)).semantic(sc), f);
+                        e1 = new DotVarExp(loc, (new ThisExp(loc)).semantic(sc), f, false);
                         goto Lagain;
                     }
                     else if (isNeedThisScope(sc, f))
@@ -9537,7 +9864,7 @@ public:
                         return new ErrorExp();
                     }
                 }
-                e1 = new VarExp(e1.loc, f, 0);
+                e1 = new VarExp(e1.loc, f, false);
                 goto Lagain;
             }
             else
@@ -9571,17 +9898,20 @@ public:
                 bool err = false;
                 if (!tf.purity && !(sc.flags & SCOPEdebug) && sc.func.setImpure())
                 {
-                    error("pure function '%s' cannot call impure %s '%s'", sc.func.toPrettyChars(), p, e1.toChars());
+                    error("pure %s '%s' cannot call impure %s '%s'",
+                        sc.func.kind(), sc.func.toPrettyChars(), p, e1.toChars());
                     err = true;
                 }
                 if (!tf.isnogc && sc.func.setGC())
                 {
-                    error("@nogc function '%s' cannot call non-@nogc %s '%s'", sc.func.toPrettyChars(), p, e1.toChars());
+                    error("@nogc %s '%s' cannot call non-@nogc %s '%s'",
+                        sc.func.kind(), sc.func.toPrettyChars(), p, e1.toChars());
                     err = true;
                 }
                 if (tf.trust <= TRUSTsystem && sc.func.setUnsafe())
                 {
-                    error("safe function '%s' cannot call system %s '%s'", sc.func.toPrettyChars(), p, e1.toChars());
+                    error("safe %s '%s' cannot call system %s '%s'",
+                        sc.func.kind(), sc.func.toPrettyChars(), p, e1.toChars());
                     err = true;
                 }
                 if (err)
@@ -9631,6 +9961,8 @@ public:
                     // Supply an implicit 'this', as in
                     //    this.ident
                     e1 = new DotVarExp(loc, (new ThisExp(loc)).semantic(sc), ve.var);
+                    // Note: we cannot use f directly, because further overload resolution
+                    // through the supplied 'this' may cause different result.
                     goto Lagain;
                 }
                 else if (isNeedThisScope(sc, f))
@@ -9650,23 +9982,26 @@ public:
             tthis = null;
             if (ve.hasOverloads)
             {
-                e1 = new VarExp(ve.loc, f, 0);
+                e1 = new VarExp(ve.loc, f, false);
                 e1.type = f.type;
             }
             t1 = f.type;
         }
         assert(t1.ty == Tfunction);
+
         Expression argprefix;
         if (!arguments)
             arguments = new Expressions();
         if (functionParameters(loc, sc, cast(TypeFunction)t1, tthis, arguments, f, &type, &argprefix))
             return new ErrorExp();
+
         if (!type)
         {
             e1 = e1org; // Bugzilla 10922, avoid recursive expression printing
-            error("forward reference to inferred return type of function call %s", toChars());
+            error("forward reference to inferred return type of function call '%s'", toChars());
             return new ErrorExp();
         }
+
         if (f && f.tintro)
         {
             Type t = type;
@@ -9678,11 +10013,13 @@ public:
                 return combine(argprefix, castTo(sc, t));
             }
         }
+
         // Handle the case of a direct lambda call
         if (f && f.isFuncLiteralDeclaration() && sc.func && !sc.intypeof)
         {
             f.tookAddressOf = 0;
         }
+
         return combine(argprefix, this);
     }
 
@@ -9747,6 +10084,46 @@ public:
     }
 }
 
+FuncDeclaration isFuncAddress(Expression e, bool* hasOverloads = null)
+{
+    if (e.op == TOKaddress)
+    {
+        auto ae1 = (cast(AddrExp)e).e1;
+        if (ae1.op == TOKvar)
+        {
+            auto ve = cast(VarExp)ae1;
+            if (hasOverloads)
+                *hasOverloads = ve.hasOverloads;
+            return ve.var.isFuncDeclaration();
+        }
+        if (ae1.op == TOKdotvar)
+        {
+            auto dve = cast(DotVarExp)ae1;
+            if (hasOverloads)
+                *hasOverloads = dve.hasOverloads;
+            return dve.var.isFuncDeclaration();
+        }
+    }
+    else
+    {
+        if (e.op == TOKsymoff)
+        {
+            auto soe = cast(SymOffExp)e;
+            if (hasOverloads)
+                *hasOverloads = soe.hasOverloads;
+            return soe.var.isFuncDeclaration();
+        }
+        if (e.op == TOKdelegate)
+        {
+            auto dge = cast(DelegateExp)e;
+            if (hasOverloads)
+                *hasOverloads = dge.hasOverloads;
+            return dge.func.isFuncDeclaration();
+        }
+    }
+    return null;
+}
+
 /***********************************************************
  */
 extern (C++) final class AddrExp : UnaExp
@@ -9773,7 +10150,7 @@ public:
             DotTemplateInstanceExp dti = cast(DotTemplateInstanceExp)e1;
             TemplateInstance ti = dti.ti;
             {
-                //assert(ti->needsTypeInference(sc));
+                //assert(ti.needsTypeInference(sc));
                 ti.semantic(sc);
                 if (!ti.inst || ti.errors) // if template failed to expand
                     return new ErrorExp();
@@ -9791,7 +10168,7 @@ public:
             TemplateInstance ti = (cast(ScopeExp)e1).sds.isTemplateInstance();
             if (ti)
             {
-                //assert(ti->needsTypeInference(sc));
+                //assert(ti.needsTypeInference(sc));
                 ti.semantic(sc);
                 if (!ti.inst || ti.errors) // if template failed to expand
                     return new ErrorExp();
@@ -9807,19 +10184,23 @@ public:
         e1 = e1.toLvalue(sc, null);
         if (e1.op == TOKerror)
             return e1;
+        if (checkNonAssignmentArrayOp(e1))
+            return new ErrorExp();
+
         if (!e1.type)
         {
             error("cannot take address of %s", e1.toChars());
             return new ErrorExp();
         }
-        if (!e1.type.deco)
+
+        bool hasOverloads;
+        if (auto f = isFuncAddress(this, &hasOverloads))
+        {
+            if (!hasOverloads && f.checkForwardRef(loc))
+                return new ErrorExp();
+        }
+        else 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.
-             */
             if (e1.op == TOKvar)
             {
                 VarExp ve = cast(VarExp)e1;
@@ -9845,7 +10226,7 @@ public:
                 if (f.needThis())
                     e = new DelegateExp(loc, dve.e1, f, dve.hasOverloads);
                 else // It is a function pointer. Convert &v.f() --> (v, &V.f())
-                    e = new CommaExp(loc, dve.e1, new AddrExp(loc, new VarExp(loc, f)));
+                    e = new CommaExp(loc, dve.e1, new AddrExp(loc, new VarExp(loc, f, dve.hasOverloads)));
                 e = e.semantic(sc);
                 return e;
             }
@@ -9980,12 +10361,15 @@ public:
             break;
         case Tsarray:
         case Tarray:
+            if (isNonAssignmentArrayOp(e1))
+                goto default;
             error("using * on an array is no longer supported; use *(%s).ptr instead", e1.toChars());
             type = (cast(TypeArray)tb).next;
             e1 = e1.castTo(sc, type.pointerTo());
             break;
         default:
             error("can only * a pointer, not a '%s'", e1.type.toChars());
+            goto case Terror;
         case Terror:
             return new ErrorExp();
         }
@@ -10235,33 +10619,35 @@ public:
         if (e1.op == TOKerror)
             return e1;
         type = Type.tvoid;
+
+        AggregateDeclaration ad = null;
         Type tb = e1.type.toBasetype();
         switch (tb.ty)
         {
         case Tclass:
             {
-                TypeClass tc = cast(TypeClass)tb;
-                ClassDeclaration cd = tc.sym;
+                auto cd = (cast(TypeClass)tb).sym;
                 if (cd.isCOMinterface())
                 {
                     /* Because COM classes are deleted by IUnknown.Release()
                      */
                     error("cannot delete instance of COM interface %s", cd.toChars());
-                    goto Lerr;
+                    return new ErrorExp();
                 }
+
+                ad = cd;
                 break;
             }
         case Tpointer:
             tb = (cast(TypePointer)tb).next.toBasetype();
             if (tb.ty == Tstruct)
             {
-                TypeStruct ts = cast(TypeStruct)tb;
-                StructDeclaration sd = ts.sym;
-                FuncDeclaration f = sd.aggDelete;
-                FuncDeclaration fd = sd.dtor;
+                ad = (cast(TypeStruct)tb).sym;
+                auto f = ad.aggDelete;
+                auto fd = ad.dtor;
                 if (!f)
                 {
-                    semanticTypeInfo(sc, ts);
+                    semanticTypeInfo(sc, tb);
                     break;
                 }
                 /* Construct:
@@ -10286,7 +10672,7 @@ public:
                 if (fd)
                 {
                     Expression e = ea ? new VarExp(loc, v) : e1;
-                    e = new DotVarExp(Loc(), e, fd, 0);
+                    e = new DotVarExp(Loc(), e, fd, false);
                     eb = new CallExp(loc, e);
                     eb = eb.semantic(sc);
                 }
@@ -10294,7 +10680,7 @@ public:
                 {
                     Type tpv = Type.tvoid.pointerTo();
                     Expression e = ea ? new VarExp(loc, v) : e1.castTo(sc, tpv);
-                    e = new CallExp(loc, new VarExp(loc, f), e);
+                    e = new CallExp(loc, new VarExp(loc, f, false), e);
                     ec = e.semantic(sc);
                 }
                 ea = combine(ea, eb);
@@ -10308,20 +10694,37 @@ public:
                 Type tv = tb.nextOf().baseElemOf();
                 if (tv.ty == Tstruct)
                 {
-                    TypeStruct ts = cast(TypeStruct)tv;
-                    StructDeclaration sd = ts.sym;
-                    if (sd.dtor)
-                        semanticTypeInfo(sc, ts);
+                    ad = (cast(TypeStruct)tv).sym;
+                    if (ad.dtor)
+                        semanticTypeInfo(sc, ad.type);
                 }
                 break;
             }
         default:
             error("cannot delete type %s", e1.type.toChars());
-            goto Lerr;
+            return new ErrorExp();
         }
+
+        if (ad)
+        {
+            bool err = false;
+            if (ad.dtor)
+            {
+                err |= checkPurity(sc, ad.dtor);
+                err |= checkSafety(sc, ad.dtor);
+                err |= checkNogc(sc, ad.dtor);
+            }
+            if (ad.aggDelete && tb.ty != Tarray)
+            {
+                err |= checkPurity(sc, ad.aggDelete);
+                err |= checkSafety(sc, ad.aggDelete);
+                err |= checkNogc(sc, ad.aggDelete);
+            }
+            if (err)
+                return new ErrorExp();
+        }
+
         return this;
-    Lerr:
-        return new ErrorExp();
     }
 
     override Expression toBoolean(Scope* sc)
@@ -10374,11 +10777,24 @@ public:
         if (type)
             return this;
 
-        if (Expression ex = unaSemantic(sc))
-            return ex;
-        Expression e1x = resolveProperties(sc, e1);
+        if (to)
+        {
+            to = to.semantic(loc, sc);
+            if (to == Type.terror)
+                return new ErrorExp();
+
+            // When e1 is a template lambda, this cast may instantiate it with
+            // the type 'to'.
+            e1 = inferType(e1, to);
+        }
+
+        if (auto e = unaSemantic(sc))
+            return e;
+        auto e1x = resolveProperties(sc, e1);
         if (e1x.op == TOKerror)
             return e1x;
+        if (e1x.checkType())
+            return new ErrorExp();
         e1 = e1x;
 
         if (!e1.type)
@@ -10388,25 +10804,19 @@ public:
         }
 
         if (!to) // Handle cast(const) and cast(immutable), etc.
+        {
             to = e1.type.castMod(mod);
-        to = to.semantic(loc, sc);
-        if (to == Type.terror)
-            return new ErrorExp();
+            to = to.semantic(loc, sc);
+            if (to == Type.terror)
+                return new ErrorExp();
+        }
+
         if (to.ty == Ttuple)
         {
             error("cannot cast %s to tuple type %s", e1.toChars(), to.toChars());
             return new ErrorExp();
         }
 
-        if (e1.type.ty != Tvoid ||
-            e1.op == TOKfunction && to.ty == Tvoid ||
-            e1.op == TOKtype ||
-            e1.op == TOKtemplate)
-        {
-            if (e1.checkValue())
-                return new ErrorExp();
-        }
-
         // cast(void) is used to mark e1 as unused, so it is safe
         if (to.ty == Tvoid)
         {
@@ -11022,19 +11432,18 @@ public:
         }
         e1 = e1.semantic(sc);
         e2 = e2.semantic(sc);
-        if (e2.op == TOKscope)
-        {
-            ScopeExp se = cast(ScopeExp)e2;
-            TemplateDeclaration td = se.sds.isTemplateDeclaration();
-            if (td)
-            {
-                Expression e = new DotTemplateExp(loc, e1, td);
-                e = e.semantic(sc);
-                return e;
-            }
-        }
+
+        if (e1.op == TOKtype)
+            return e2;
         if (e2.op == TOKtype)
             return e2;
+
+        if (e2.op == TOKtemplate)
+        {
+            auto td = (cast(TemplateExp)e2).td;
+            Expression e = new DotTemplateExp(loc, e1, td);
+            return e.semantic(sc);
+        }
         if (!type)
             type = e2.type;
         return this;
@@ -11063,6 +11472,10 @@ public:
         if (Expression ex = binSemanticProp(sc))
             return ex;
         e1 = e1.addDtorHook(sc);
+
+        if (checkNonAssignmentArrayOp(e1))
+            return new ErrorExp();
+
         type = e2.type;
         return this;
     }
@@ -11094,6 +11507,15 @@ public:
         return e2.isBool(result);
     }
 
+    override Expression toBoolean(Scope* sc)
+    {
+        auto ex2 = e2.toBoolean(sc);
+        if (ex2.op == TOKerror)
+            return ex2;
+        e2 = ex2;
+        return this;
+    }
+
     override Expression addDtorHook(Scope* sc)
     {
         e2 = e2.addDtorHook(sc);
@@ -11323,6 +11745,10 @@ public:
             sc = sc.pop();
         if (e2.type == Type.terror)
             return new ErrorExp();
+
+        if (checkNonAssignmentArrayOp(e1))
+            return new ErrorExp();
+
         switch (t1b.ty)
         {
         case Tpointer:
@@ -11713,7 +12139,7 @@ public:
                     /* Rewrite (a[arguments] = e2) as:
                      *      a.opIndexAssign(e2, arguments)
                      */
-                    Expressions* a = cast(Expressions*)ae.arguments.copy();
+                    Expressions* a = ae.arguments.copy();
                     a.insert(0, e2);
                     result = new DotIdExp(loc, ae.e1, Id.indexass);
                     result = new CallExp(loc, result, a);
@@ -12065,7 +12491,7 @@ public:
                             Expression e = e1x.copy();
                             e.type = e.type.mutableOf();
                             e = new BlitExp(loc, e, e2x);
-                            e = new DotVarExp(loc, e, sd.postblit, 0);
+                            e = new DotVarExp(loc, e, sd.postblit, false);
                             e = new CallExp(loc, e);
                             return e.semantic(sc);
                         }
@@ -12490,7 +12916,18 @@ public:
                     e2x = e2x.castTo(sc, e1.type.constOf());
             }
             else
-                e2x = e2x.implicitCastTo(sc, e1.type);
+            {
+                /* Bugzilla 15778: A string literal has an array type of immutable
+                 * elements by default, and normally it cannot be convertible to
+                 * array type of mutable elements. But for element-wise assignment,
+                 * elements need to be const at best. So we should give a chance
+                 * to change code unit size for polysemous string literal.
+                 */
+                if (e2x.op == TOKstring)
+                    e2x = e2x.implicitCastTo(sc, e1.type.constOf());
+                else
+                    e2x = e2x.implicitCastTo(sc, e1.type);
+            }
         }
         else
         {
@@ -12930,10 +13367,12 @@ public:
     {
         if (type)
             return this;
+
         //printf("CatAssignExp::semantic() %s\n", toChars());
         Expression e = op_overload(sc);
         if (e)
             return e;
+
         if (e1.op == TOKslice)
         {
             SliceExp se = cast(SliceExp)e1;
@@ -12943,17 +13382,25 @@ public:
                 return new ErrorExp();
             }
         }
+
         e1 = e1.modifiableLvalue(sc, e1);
         if (e1.op == TOKerror)
             return e1;
         if (e2.op == TOKerror)
             return e2;
+
         if (checkNonAssignmentArrayOp(e2))
             return new ErrorExp();
+
         Type tb1 = e1.type.toBasetype();
         Type tb1next = tb1.nextOf();
         Type tb2 = e2.type.toBasetype();
-        if ((tb1.ty == Tarray) && (tb2.ty == Tarray || tb2.ty == Tsarray) && (e2.implicitConvTo(e1.type) || (tb2.nextOf().implicitConvTo(tb1next) && (tb2.nextOf().size(Loc()) == tb1next.size(Loc())))))
+
+        if ((tb1.ty == Tarray) &&
+            (tb2.ty == Tarray || tb2.ty == Tsarray) &&
+            (e2.implicitConvTo(e1.type) ||
+             (tb2.nextOf().implicitConvTo(tb1next) &&
+              (tb2.nextOf().size(Loc()) == tb1next.size(Loc())))))
         {
             // Append array
             if (e1.checkPostblit(sc, tb1next))
@@ -12966,12 +13413,16 @@ public:
             if (e2.checkPostblit(sc, tb2))
                 return new ErrorExp();
             e2 = e2.castTo(sc, tb1next);
-            e2 = e2.isLvalue() ? callCpCtor(sc, e2) : valueNoDtor(e2);
+            e2 = doCopyOrMove(sc, e2);
         }
-        else if (tb1.ty == Tarray && (tb1next.ty == Tchar || tb1next.ty == Twchar) && e2.type.ty != tb1next.ty && e2.implicitConvTo(Type.tdchar))
+        else if (tb1.ty == Tarray &&
+                 (tb1next.ty == Tchar || tb1next.ty == Twchar) &&
+                 e2.type.ty != tb1next.ty &&
+                 e2.implicitConvTo(Type.tdchar))
         {
             // Append dchar to char[] or wchar[]
             e2 = e2.castTo(sc, Type.tdchar);
+
             /* Do not allow appending wchar to char[] because if wchar happens
              * to be a surrogate pair, nothing good can result.
              */
@@ -12983,6 +13434,7 @@ public:
         }
         if (e2.checkValue())
             return new ErrorExp();
+
         type = e1.type;
         return reorderSettingAAElem(sc);
     }
@@ -13225,6 +13677,12 @@ public:
             return e;
         Type tb1 = e1.type.toBasetype();
         Type tb2 = e2.type.toBasetype();
+
+        auto f1 = checkNonAssignmentArrayOp(e1);
+        auto f2 = checkNonAssignmentArrayOp(e2);
+        if (f1 || f2)
+            return new ErrorExp();
+
         /* BUG: Should handle things like:
          *      char c;
          *      c ~ ' '
@@ -13258,18 +13716,31 @@ public:
         // Check for: array ~ element
         if ((tb1.ty == Tsarray || tb1.ty == Tarray) && tb2.ty != Tvoid)
         {
-            if (e1.op == TOKarrayliteral && e1.implicitConvTo(tb2.arrayOf()))
+            if (e1.op == TOKarrayliteral)
+            {
+                e2 = doCopyOrMove(sc, e2);
+                // Bugzilla 14686: Postblit call appears in AST, and this is
+                // finally translated  to an ArrayLiteralExp in below optimize().
+            }
+            else if (e1.op == TOKstring)
+            {
+                // No postblit call exists on character (integer) value.
+            }
+            else
             {
                 if (e2.checkPostblit(sc, tb2))
                     return new ErrorExp();
+                // Postblit call will be done in runtime helper function
+            }
+
+            if (e1.op == TOKarrayliteral && e1.implicitConvTo(tb2.arrayOf()))
+            {
                 e1 = e1.implicitCastTo(sc, tb2.arrayOf());
                 type = tb2.arrayOf();
                 goto L2elem;
             }
             if (e2.implicitConvTo(tb1next) >= MATCHconvert)
             {
-                if (e2.checkPostblit(sc, tb2))
-                    return new ErrorExp();
                 e2 = e2.implicitCastTo(sc, tb1next);
                 type = tb1next.arrayOf();
             L2elem:
@@ -13279,24 +13750,33 @@ public:
                     e2 = new ArrayLiteralExp(e2.loc, e2);
                     e2.type = type;
                 }
-                return this;
+                return optimize(WANTvalue);
             }
         }
         // Check for: element ~ array
         if ((tb2.ty == Tsarray || tb2.ty == Tarray) && tb1.ty != Tvoid)
         {
-            if (e2.op == TOKarrayliteral && e2.implicitConvTo(tb1.arrayOf()))
+            if (e2.op == TOKarrayliteral)
+            {
+                e1 = doCopyOrMove(sc, e1);
+            }
+            else if (e2.op == TOKstring)
+            {
+            }
+            else
             {
                 if (e1.checkPostblit(sc, tb1))
                     return new ErrorExp();
+            }
+
+            if (e2.op == TOKarrayliteral && e2.implicitConvTo(tb1.arrayOf()))
+            {
                 e2 = e2.implicitCastTo(sc, tb1.arrayOf());
                 type = tb1.arrayOf();
                 goto L1elem;
             }
             if (e1.implicitConvTo(tb2next) >= MATCHconvert)
             {
-                if (e1.checkPostblit(sc, tb1))
-                    return new ErrorExp();
                 e1 = e1.implicitCastTo(sc, tb2next);
                 type = tb2next.arrayOf();
             L1elem:
@@ -13306,7 +13786,7 @@ public:
                     e1 = new ArrayLiteralExp(e1.loc, e1);
                     e1.type = type;
                 }
-                return this;
+                return optimize(WANTvalue);
             }
         }
     Lpeer:
@@ -13347,20 +13827,17 @@ public:
         }
         Type t1 = e1.type.toBasetype();
         Type t2 = e2.type.toBasetype();
-        if (e1.op == TOKstring && e2.op == TOKstring)
+        if ((t1.ty == Tarray || t1.ty == Tsarray) &&
+            (t2.ty == Tarray || t2.ty == Tsarray))
         {
+            // Normalize to ArrayLiteralExp or StringExp as far as possible
             e = optimize(WANTvalue);
         }
-        else if ((t1.ty == Tarray || t1.ty == Tsarray) && (t2.ty == Tarray || t2.ty == Tsarray))
-        {
-            e = this;
-        }
         else
         {
             //printf("(%s) ~ (%s)\n", e1->toChars(), e2->toChars());
             return incompatibleTypes();
         }
-        e.type = e.type.semantic(loc, sc);
         return e;
     }
 
@@ -14022,6 +14499,11 @@ public:
         sc.mergeCallSuper(loc, cs1);
         e2 = resolveProperties(sc, e2);
 
+        auto f1 = checkNonAssignmentArrayOp(e1);
+        auto f2 = checkNonAssignmentArrayOp(e2);
+        if (f1 || f2)
+            return new ErrorExp();
+
         if (e2.type.ty == Tvoid)
             type = Type.tvoid;
         else
@@ -14044,7 +14526,10 @@ public:
 
     override Expression toBoolean(Scope* sc)
     {
-        e2 = e2.toBoolean(sc);
+        auto ex2 = e2.toBoolean(sc);
+        if (ex2.op == TOKerror)
+            return ex2;
+        e2 = ex2;
         return this;
     }
 
@@ -14090,6 +14575,11 @@ public:
         sc.mergeCallSuper(loc, cs1);
         e2 = resolveProperties(sc, e2);
 
+        auto f1 = checkNonAssignmentArrayOp(e1);
+        auto f2 = checkNonAssignmentArrayOp(e2);
+        if (f1 || f2)
+            return new ErrorExp();
+
         if (e2.type.ty == Tvoid)
             type = Type.tvoid;
         else
@@ -14112,7 +14602,10 @@ public:
 
     override Expression toBoolean(Scope* sc)
     {
-        e2 = e2.toBoolean(sc);
+        auto ex2 = e2.toBoolean(sc);
+        if (ex2.op == TOKerror)
+            return ex2;
+        e2 = ex2;
         return this;
     }
 
@@ -14164,9 +14657,17 @@ public:
             }
             return e;
         }
+
         if (Expression ex = typeCombine(this, sc))
             return ex;
+
+        auto f1 = checkNonAssignmentArrayOp(e1);
+        auto f2 = checkNonAssignmentArrayOp(e2);
+        if (f1 || f2)
+            return new ErrorExp();
+
         type = Type.tbool;
+
         // Special handling for array comparisons
         t1 = e1.type.toBasetype();
         t2 = e2.type.toBasetype();
@@ -14317,6 +14818,7 @@ public:
             }
         default:
             error("rvalue of in expression must be an associative array, not %s", e2.type.toChars());
+            goto case Terror;
         case Terror:
             return new ErrorExp();
         }
@@ -14403,6 +14905,11 @@ public:
         if (auto e = typeCombine(this, sc))
             return e;
 
+        auto f1 = checkNonAssignmentArrayOp(e1);
+        auto f2 = checkNonAssignmentArrayOp(e2);
+        if (f1 || f2)
+            return new ErrorExp();
+
         type = Type.tbool;
 
         // Special handling for array comparisons
@@ -14445,11 +14952,20 @@ public:
     {
         if (type)
             return this;
-        if (Expression ex = binSemanticProp(sc))
-            return ex;
+
+        if (auto e = binSemanticProp(sc))
+            return e;
+
+        if (auto e = typeCombine(this, sc))
+            return e;
+
+        auto f1 = checkNonAssignmentArrayOp(e1);
+        auto f2 = checkNonAssignmentArrayOp(e2);
+        if (f1 || f2)
+            return new ErrorExp();
+
         type = Type.tbool;
-        if (Expression ex = typeCombine(this, sc))
-            return ex;
+
         if (e1.type != e2.type && e1.type.isfloating() && e2.type.isfloating())
         {
             // Cast both to complex
@@ -14493,36 +15009,50 @@ public:
         }
         if (type)
             return this;
+
         Expression ec = econd.semantic(sc);
         ec = resolveProperties(sc, ec);
         ec = ec.toBoolean(sc);
+
         uint cs0 = sc.callSuper;
         uint* fi0 = sc.saveFieldInit();
         Expression e1x = e1.semantic(sc);
         e1x = resolveProperties(sc, e1x);
+
         uint cs1 = sc.callSuper;
         uint* fi1 = sc.fieldinit;
         sc.callSuper = cs0;
         sc.fieldinit = fi0;
         Expression e2x = e2.semantic(sc);
         e2x = resolveProperties(sc, e2x);
+
         sc.mergeCallSuper(loc, cs1);
         sc.mergeFieldInit(loc, fi1);
+
         if (ec.op == TOKerror)
             return ec;
         if (ec.type == Type.terror)
             return new ErrorExp();
         econd = ec;
+
         if (e1x.op == TOKerror)
             return e1x;
         if (e1x.type == Type.terror)
             return new ErrorExp();
         e1 = e1x;
+
         if (e2x.op == TOKerror)
             return e2x;
         if (e2x.type == Type.terror)
             return new ErrorExp();
         e2 = e2x;
+
+        auto f0 = checkNonAssignmentArrayOp(econd);
+        auto f1 = checkNonAssignmentArrayOp(e1);
+        auto f2 = checkNonAssignmentArrayOp(e2);
+        if (f0 || f1 || f2)
+            return new ErrorExp();
+
         // If either operand is void, the result is void
         Type t1 = e1.type;
         Type t2 = e2.type;
@@ -14534,6 +15064,7 @@ public:
         {
             if (Expression ex = typeCombine(this, sc))
                 return ex;
+
             switch (e1.type.toBasetype().ty)
             {
             case Tcomplex32:
@@ -14567,6 +15098,7 @@ public:
             printf("e1 : %s\n", e1.type.toChars());
             printf("e2 : %s\n", e2.type.toChars());
         }
+
         /* Bugzilla 14696: If either e1 or e2 contain temporaries which need dtor,
          * make them conditional.
          * Rewrite:
@@ -14578,6 +15110,7 @@ public:
          *      __tmp2->edtor --> __cond || __tmp2.dtor()
          */
         hookDtors(sc);
+
         return this;
     }
 
@@ -14611,8 +15144,14 @@ public:
 
     override Expression toBoolean(Scope* sc)
     {
-        e1 = e1.toBoolean(sc);
-        e2 = e2.toBoolean(sc);
+        auto ex1 = e1.toBoolean(sc);
+        auto ex2 = e2.toBoolean(sc);
+        if (ex1.op == TOKerror)
+            return ex1;
+        if (ex2.op == TOKerror)
+            return ex2;
+        e1 = ex1;
+        e2 = ex2;
         return this;
     }
 
@@ -14640,27 +15179,32 @@ public:
 
             override void visit(DeclarationExp e)
             {
-                VarDeclaration v = e.declaration.isVarDeclaration();
-                if (v && !v.noscope && !v.isDataseg())
+                auto v = e.declaration.isVarDeclaration();
+                if (v && !v.isDataseg())
                 {
                     if (v._init)
                     {
-                        ExpInitializer ei = v._init.isExpInitializer();
-                        if (ei)
+                        if (auto ei = v._init.isExpInitializer())
                             ei.exp.accept(this);
                     }
-                    if (v.edtor)
+
+                    if (v.needsScopeDtor())
                     {
                         if (!vcond)
                         {
-                            vcond = new VarDeclaration(ce.econd.loc, ce.econd.type, Identifier.generateId("__cond"), new ExpInitializer(ce.econd.loc, ce.econd));
+                            auto ei = new ExpInitializer(ce.econd.loc, ce.econd);
+                            auto id = Identifier.generateId("__cond");
+                            vcond = new VarDeclaration(ce.econd.loc, ce.econd.type, id, ei);
                             vcond.storage_class |= STCtemp | STCctfe | STCvolatile;
                             vcond.semantic(sc);
+
                             Expression de = new DeclarationExp(ce.econd.loc, vcond);
                             de = de.semantic(sc);
+
                             Expression ve = new VarExp(ce.econd.loc, vcond);
                             ce.econd = Expression.combine(de, ve);
                         }
+
                         //printf("\t++v = %s, v->edtor = %s\n", v->toChars(), v->edtor->toChars());
                         Expression ve = new VarExp(vcond.loc, vcond);
                         if (isThen)
diff --git a/ddmd/expression.h b/ddmd/expression.h
index 2fb9d18c63..a247631042 100644
--- a/ddmd/expression.h
+++ b/ddmd/expression.h
@@ -75,7 +75,7 @@ TemplateDeclaration *getFuncTemplateDecl(Dsymbol *s);
 Expression *valueNoDtor(Expression *e);
 int modifyFieldVar(Loc loc, Scope *sc, VarDeclaration *var, Expression *e1);
 Expression *resolveAliasThis(Scope *sc, Expression *e, bool gag = false);
-Expression *callCpCtor(Scope *sc, Expression *e);
+Expression *doCopyOrMove(Scope *sc, Expression *e);
 Expression *resolveOpDollar(Scope *sc, ArrayExp *ae, Expression **pe0);
 Expression *resolveOpDollar(Scope *sc, ArrayExp *ae, IntervalExp *ie, Expression **pe0);
 Expression *integralPromotions(Expression *e, Scope *sc);
@@ -152,9 +152,9 @@ public:
     void print();
     char *toChars();
     virtual void printAST(int ident = 0);
-    void error(const char *format, ...);
-    void warning(const char *format, ...);
-    void deprecation(const char *format, ...);
+    void error(const char *format, ...) const;
+    void warning(const char *format, ...) const;
+    void deprecation(const char *format, ...) const;
 
     // creates a single expression which is effectively (e1, e2)
     // this new expression does not necessarily need to have valid D source code representation,
@@ -185,6 +185,7 @@ public:
         return ::castTo(this, sc, t);
     }
     virtual Expression *resolveLoc(Loc loc, Scope *sc);
+    virtual bool checkType();
     virtual bool checkValue();
     bool checkScalar();
     bool checkNoBool();
@@ -321,7 +322,7 @@ public:
     Dsymbol *s;
     bool hasOverloads;
 
-    DsymbolExp(Loc loc, Dsymbol *s, bool hasOverloads = false);
+    DsymbolExp(Loc loc, Dsymbol *s, bool hasOverloads = true);
     Expression *semantic(Scope *sc);
     static Expression resolve(Loc loc, Scope *sc, Dsymbol *s, bool hasOverloads);
     bool isLvalue();
@@ -388,11 +389,11 @@ public:
     bool isLvalue();
     Expression *toLvalue(Scope *sc, Expression *e);
     Expression *modifiableLvalue(Scope *sc, Expression *e);
-    unsigned charAt(uinteger_t i);
+    unsigned charAt(uinteger_t i) const;
     void accept(Visitor *v) { v->visit(this); }
-    char *toStringz();
-    size_t numberOfCodeUnits(int tynto = 0);
-    void writeTo(void* dest, bool zero, int tyto = 0);
+    const char *toStringz() const;
+    size_t numberOfCodeUnits(int tynto = 0) const;
+    void writeTo(void* dest, bool zero, int tyto = 0) const;
     char *toPtr();
 };
 
@@ -490,18 +491,11 @@ public:
     // A global variable for taking the address of this struct literal constant,
     // if it already exists. Used to resolve self-references.
     llvm::GlobalVariable *globalVar;
-
-    /// Set if this is really the result of a struct .init access and should be
-    /// resolved codegen'd as an access to the given SymbolDeclaration.
-    // LDC_FIXME: Figure out whether this, i.e. imitating the DMD behavior, is
-    // really the best way to fix the nested struct constant folding issue.
-    SymbolDeclaration *sinit;
-#else
-    Symbol *sinit;              // if this is a defaultInitLiteral, this symbol contains the default initializer
 #endif
+
+    bool useStaticInit;         // if this is true, use the StructDeclaration's init symbol
     Symbol *sym;                // back end symbol to initialize with literal
-    size_t soffset;             // offset from start of s
-    int fillHoles;              // fill alignment 'holes' with zero
+    bool fillHoles;             // fill alignment 'holes' with zero
     OwnedBy ownedByCtfe;
 
     // pointer to the origin instance of the expression.
@@ -540,6 +534,7 @@ public:
     TypeExp(Loc loc, Type *type);
     Expression *syntaxCopy();
     Expression *semantic(Scope *sc);
+    bool checkType();
     bool checkValue();
     void accept(Visitor *v) { v->visit(this); }
 };
@@ -564,6 +559,7 @@ public:
     TemplateExp(Loc loc, TemplateDeclaration *td, FuncDeclaration *fd = NULL);
     bool isLvalue();
     Expression *toLvalue(Scope *sc, Expression *e);
+    bool checkType();
     bool checkValue();
     void accept(Visitor *v) { v->visit(this); }
 };
@@ -627,7 +623,7 @@ class SymOffExp : public SymbolExp
 public:
     dinteger_t offset;
 
-    SymOffExp(Loc loc, Declaration *var, dinteger_t offset, bool hasOverloads = false);
+    SymOffExp(Loc loc, Declaration *var, dinteger_t offset, bool hasOverloads = true);
     Expression *semantic(Scope *sc);
     bool isBool(bool result);
 
@@ -639,8 +635,8 @@ public:
 class VarExp : public SymbolExp
 {
 public:
-    VarExp(Loc loc, Declaration *var, bool hasOverloads = false);
-    static VarExp *create(Loc loc, Declaration *var, bool hasOverloads = false);
+    VarExp(Loc loc, Declaration *var, bool hasOverloads = true);
+    static VarExp *create(Loc loc, Declaration *var, bool hasOverloads = true);
     bool equals(RootObject *o);
     Expression *semantic(Scope *sc);
     int checkModifiable(Scope *sc, int flag);
@@ -681,6 +677,7 @@ public:
     Expression *semantic(Scope *sc, Expressions *arguments);
     MATCH matchType(Type *to, Scope *sc, FuncExp **pfe, int flag = 0);
     char *toChars();
+    bool checkType();
     bool checkValue();
 
     void accept(Visitor *v) { v->visit(this); }
@@ -876,7 +873,7 @@ public:
     Declaration *var;
     bool hasOverloads;
 
-    DotVarExp(Loc loc, Expression *e, Declaration *var, bool hasOverloads = false);
+    DotVarExp(Loc loc, Expression *e, Declaration *var, bool hasOverloads = true);
     Expression *semantic(Scope *sc);
     int checkModifiable(Scope *sc, int flag);
     bool checkReadModifyWrite();
@@ -906,7 +903,7 @@ public:
     FuncDeclaration *func;
     bool hasOverloads;
 
-    DelegateExp(Loc loc, Expression *e, FuncDeclaration *func, bool hasOverloads = false);
+    DelegateExp(Loc loc, Expression *e, FuncDeclaration *func, bool hasOverloads = true);
     Expression *semantic(Scope *sc);
 
     void accept(Visitor *v) { v->visit(this); }
@@ -1198,8 +1195,8 @@ public:
 
 enum MemorySet
 {
-    MemorySet_blockAssign     = 1,    // setting the contents of an array
-    MemorySet_referenceInit   = 2,    // setting the reference of STCref variable
+    blockAssign     = 1,    // setting the contents of an array
+    referenceInit   = 2,    // setting the reference of STCref variable
 };
 
 class AssignExp : public BinExp
diff --git a/ddmd/func.d b/ddmd/func.d
index cbbb66aa35..7c4ea669f7 100644
--- a/ddmd/func.d
+++ b/ddmd/func.d
@@ -18,6 +18,7 @@ import ddmd.builtin;
 import ddmd.ctfeexpr;
 import ddmd.dclass;
 import ddmd.declaration;
+import ddmd.delegatize;
 import ddmd.dinterpret;
 import ddmd.dmodule;
 import ddmd.doc;
@@ -393,6 +394,7 @@ enum FUNCFLAGnogcInprocess    = 8;      // working on determining @nogc
 enum FUNCFLAGreturnInprocess  = 0x10;   // working on inferring 'return' for parameters
 enum FUNCFLAGinlineScanned    = 0x20;   // function has been scanned for inline possibilities
 
+
 /***********************************************************
  */
 extern (C++) class FuncDeclaration : Declaration
@@ -460,6 +462,7 @@ public:
     // true if errors in semantic3 this function's frame ptr
     bool semantic3Errors;
     ForeachStatement fes;               // if foreach body, this is the foreach
+    BaseClass* interfaceVirtual;        // if virtual, but only appears in base interface vtbl[]
     bool introducing;                   // true if 'introducing' function
     // if !=NULL, then this is the type
     // of the 'introducing' function
@@ -924,7 +927,7 @@ public:
             /* Find index of existing function in base class's vtbl[] to override
              * (the index will be the same as in cd's current vtbl[])
              */
-            int vi = cd.baseClass ? findVtblIndex(cast(Dsymbols*)&cd.baseClass.vtbl, cast(int)cd.baseClass.vtbl.dim) : -1;
+            int vi = cd.baseClass ? findVtblIndex(&cd.baseClass.vtbl, cast(int)cd.baseClass.vtbl.dim) : -1;
             bool doesoverride = false;
             switch (vi)
             {
@@ -949,6 +952,24 @@ public:
                         }
                     }
                 }
+
+                /* These quirky conditions mimic what VC++ appears to do
+                 */
+                if (global.params.mscoff && cd.cpp &&
+                    cd.baseClass && cd.baseClass.vtbl.dim)
+                {
+                    /* if overriding an interface function, then this is not
+                     * introducing and don't put it in the class vtbl[]
+                     */
+                    interfaceVirtual = overrideInterface();
+                    if (interfaceVirtual)
+                    {
+                        //printf("\tinterface function %s\n", toChars());
+                        cd.vtblFinal.push(this);
+                        goto Linterfaces;
+                    }
+                }
+
                 if (isFinalFunc())
                 {
                     // Don't check here, as it may override an interface function
@@ -958,7 +979,7 @@ public:
                 }
                 else
                 {
-                    //printf("\tintroducing function\n");
+                    //printf("\tintroducing function %s\n", toChars());
                     introducing = 1;
                     if (cd.cpp && Target.reverseCppOverloads)
                     {
@@ -1069,10 +1090,10 @@ public:
              * If this function is covariant with any members of those interface
              * functions, set the tintro.
              */
-            for (size_t i = 0; i < cd.interfaces_dim; i++)
+        Linterfaces:
+            foreach (b; cd.interfaces)
             {
-                BaseClass* b = cd.interfaces[i];
-                vi = findVtblIndex(cast(Dsymbols*)&b.sym.vtbl, cast(int)b.sym.vtbl.dim);
+                vi = findVtblIndex(&b.sym.vtbl, cast(int)b.sym.vtbl.dim);
                 switch (vi)
                 {
                 case -1:
@@ -1151,9 +1172,8 @@ public:
             /* Go through all the interface bases.
              * Disallow overriding any final functions in the interface(s).
              */
-            for (size_t i = 0; i < cd.interfaces_dim; i++)
+            foreach (b; cd.interfaces)
             {
-                BaseClass* b = cd.interfaces[i];
                 if (b.sym)
                 {
                     Dsymbol s = search_function(b.sym, ident);
@@ -1270,11 +1290,11 @@ public:
                 Statement s1 = new ExpStatement(loc, fd);
                 version(IN_LLVM)
                 {
-                    Expression e = new CallExp(loc, new VarExp(loc, fd, 0), fdrequireParams);
+                    Expression e = new CallExp(loc, new VarExp(loc, fd, false), fdrequireParams);
                 }
                 else
                 {
-                    Expression e = new CallExp(loc, new VarExp(loc, fd, 0), cast(Expressions*)null);
+                    Expression e = new CallExp(loc, new VarExp(loc, fd, false), cast(Expressions*)null);
                 }
                 Statement s2 = new ExpStatement(loc, e);
                 frequire = new CompoundStatement(loc, s1, s2);
@@ -1332,14 +1352,14 @@ public:
                 Statement s1 = new ExpStatement(loc, fd);
                 version(IN_LLVM)
                 {
-                    Expression e = new CallExp(loc, new VarExp(loc, fd, 0), fdensureParams);
+                    Expression e = new CallExp(loc, new VarExp(loc, fd, false), fdensureParams);
                 }
                 else
                 {
                     Expression eresult = null;
                     if (outId)
                         eresult = new IdentifierExp(loc, outId);
-                    Expression e = new CallExp(loc, new VarExp(loc, fd, 0), eresult);
+                    Expression e = new CallExp(loc, new VarExp(loc, fd, false), eresult);
                 }
                 Statement s2 = new ExpStatement(loc, e);
                 fensure = new CompoundStatement(loc, s1, s2);
@@ -1732,19 +1752,14 @@ public:
                 sym.parent = sc2.scopesym;
                 sc2 = sc2.push(sym);
                 AggregateDeclaration ad2 = isAggregateMember2();
-                uint* fieldinit = null;
                 /* If this is a class constructor
                  */
                 if (ad2 && isCtorDeclaration())
                 {
-                    fieldinit = cast(uint*)mem.xmalloc(uint.sizeof * ad2.fields.dim);
-                    sc2.fieldinit = fieldinit;
-                    sc2.fieldinit_dim = ad2.fields.dim;
-                    for (size_t i = 0; i < ad2.fields.dim; i++)
+                    sc2.allocFieldinit(ad2.fields.dim);
+                    foreach (v; ad2.fields)
                     {
-                        VarDeclaration v = ad2.fields[i];
                         v.ctorinit = 0;
-                        sc2.fieldinit[i] = 0;
                     }
                 }
                 if (!inferRetType && retStyle(f) != RETstack)
@@ -1841,8 +1856,7 @@ public:
                             }
                         }
                     }
-                    sc2.fieldinit = null;
-                    sc2.fieldinit_dim = 0;
+                    sc2.freeFieldinit();
                     if (cd && !(sc2.callSuper & CSXany_ctor) && cd.baseClass && cd.baseClass.ctor)
                     {
                         sc2.callSuper = 0;
@@ -1936,7 +1950,7 @@ public:
                         fbody = new CompoundStatement(Loc(), fbody, s);
                     }
                 }
-                if (returns && !fbody.isErrorStatement())
+                if (returns)
                 {
                     bool implicit0 = (f.next.ty == Tvoid && isMain());
                     Type tret = implicit0 ? Type.tint32 : f.next;
@@ -1951,6 +1965,15 @@ public:
                     {
                         ReturnStatement rs = (*returns)[i];
                         Expression exp = rs.exp;
+                        if (exp.op == TOKerror)
+                            continue;
+                        if (tret.ty == Terror)
+                        {
+                            // Bugzilla 13702
+                            exp = checkGC(sc2, exp);
+                            continue;
+                        }
+
                         if (!exp.implicitConvTo(tret) && parametersIntersect(exp.type))
                         {
                             if (exp.type.immutableOf().implicitConvTo(tret))
@@ -1959,6 +1982,7 @@ public:
                                 exp = exp.castTo(sc2, exp.type.wildOf());
                         }
                         exp = exp.implicitCastTo(sc2, tret);
+
                         if (f.isref)
                         {
                             // Function returns a reference
@@ -1972,16 +1996,20 @@ public:
                             /* Bugzilla 10789:
                              * If NRVO is not possible, all returned lvalues should call their postblits.
                              */
-                            if (!nrvo_can && exp.isLvalue())
-                                exp = callCpCtor(sc2, exp);
+                            if (!nrvo_can)
+                                exp = doCopyOrMove(sc2, exp);
+
                             checkEscape(sc2, exp, false);
                         }
+
                         exp = checkGC(sc2, exp);
+
                         if (vresult)
                         {
                             // Create: return vresult = exp;
                             exp = new BlitExp(rs.loc, vresult, exp);
                             exp.type = vresult.type;
+
                             if (rs.caseDim)
                                 exp = Expression.combine(exp, new IntegerExp(rs.caseDim));
                         }
@@ -1999,8 +2027,6 @@ public:
                     nw.sc = sc2;
                     nw.visitStmt(fbody);
                 }
-                if (fieldinit)
-                    mem.xfree(fieldinit);
                 sc2 = sc2.pop();
             }
             Statement freq = frequire;
@@ -2127,7 +2153,7 @@ static if (!IN_LLVM) {
                             if (global.params.is64bit && global.params.isWindows)
                             {
                                 offset += Target.ptrsize;
-                                if (p.storage_class & STClazy || p.type.size() > Target.ptrsize)
+                                if ((p.storage_class & STClazy) || p.type.size() > Target.ptrsize)
                                 {
                                     /* Necessary to offset the extra level of indirection the Win64
                                      * ABI demands
@@ -2231,23 +2257,25 @@ else
                     Statement s = new ReturnStatement(Loc(), new IntegerExp(0));
                     a.push(s);
                 }
+
                 Statement sbody = new CompoundStatement(Loc(), a);
+
                 /* Append destructor calls for parameters as finally blocks.
                  */
                 if (parameters)
                 {
-                    for (size_t i = 0; i < parameters.dim; i++)
+                    foreach (v; *parameters)
                     {
-                        VarDeclaration v = (*parameters)[i];
                         if (v.storage_class & (STCref | STCout | STClazy))
                             continue;
-                        if (v.noscope)
-                            continue;
-                        Expression e = v.edtor;
-                        if (e)
+                        if (v.needsScopeDtor())
                         {
-                            Statement s = new ExpStatement(Loc(), e);
+                            // same with ExpStatement.scopeCode()
+                            Statement s = new DtorExpStatement(Loc(), v.edtor, v);
+                            v.noscope = true;
+
                             s = s.semantic(sc2);
+
                             uint nothrowErrors = global.errors;
                             bool isnothrow = f.isnothrow & !(flags & FUNCFLAGnothrowInprocess);
                             int blockexit = s.blockExit(this, isnothrow);
@@ -2255,6 +2283,7 @@ else
                                 .error(loc, "%s '%s' is nothrow yet may throw", kind(), toPrettyChars());
                             if (flags & FUNCFLAGnothrowInprocess && blockexit & BEthrow)
                                 f.isnothrow = false;
+
                             if (sbody.blockExit(this, f.isnothrow) == BEfallthru)
                                 sbody = new CompoundStatement(Loc(), sbody, s);
                             else
@@ -2264,6 +2293,7 @@ else
                 }
                 // from this point on all possible 'throwers' are checked
                 flags &= ~FUNCFLAGnothrowInprocess;
+
                 if (isSynchronized())
                 {
                     /* Wrap the entire function body in a synchronized statement
@@ -2318,13 +2348,13 @@ else
             sc2.callSuper = 0;
             sc2.pop();
         }
-        if (needsClosure())
+
+        if (checkClosure())
         {
-            if (setGC())
-                error("@nogc function allocates a closure with the GC");
-            else
-                printGCUsage(loc, "using closure causes GC allocation");
+            // We should be setting errors here instead of relying on the global error count.
+            //errors = true;
         }
+
         /* If function survived being marked as impure, then it is pure
          */
         if (flags & FUNCFLAGpurityInprocess)
@@ -2461,6 +2491,29 @@ else
         return !errors && !semantic3Errors;
     }
 
+    /****************************************************
+     * Check that this function type is properly resolved.
+     * If not, report "forward reference error" and return true.
+     */
+    final bool checkForwardRef(Loc loc)
+    {
+        if (!functionSemantic())
+            return true;
+
+        /* No deco means the functionSemantic() call could not resolve
+         * forward referenes in the type of this function.
+         */
+        if (!type.deco)
+        {
+            bool inSemantic3 = (inferRetType && semanticRun >= PASSsemantic3);
+            .error(loc, "forward reference to %s'%s'",
+                (inSemantic3 ? "inferred return type of function " : "").ptr,
+                toChars());
+            return true;
+        }
+        return false;
+    }
+
     // called from semantic3
     final VarDeclaration declareThis(Scope* sc, AggregateDeclaration ad)
     {
@@ -2628,6 +2681,26 @@ else
         return bestvi;
     }
 
+    /*********************************
+     * If function a function in a base class,
+     * return that base class.
+     * Params:
+     *  cd = class that function is in
+     * Returns:
+     *  base class if overriding, null if not
+     */
+    final BaseClass* overrideInterface()
+    {
+        ClassDeclaration cd = parent.isClassDeclaration();
+        foreach (b; cd.interfaces)
+        {
+            auto v = findVtblIndex(&b.sym.vtbl, cast(int)b.sym.vtbl.dim);
+            if (v >= 0)
+                return b;
+        }
+        return null;
+    }
+
     /****************************************************
      * Overload this FuncDeclaration with the new one f.
      * Return true if successful; i.e. no conflict.
@@ -2928,7 +3001,7 @@ else
                 e = p.type.defaultInitLiteral(Loc());
             args[u] = e;
         }
-        MATCH m = cast(MATCH)tg.callMatch(null, &args, 1);
+        MATCH m = tg.callMatch(null, &args, 1);
         if (m > MATCHnomatch)
         {
             /* A variadic parameter list is less specialized than a
@@ -3020,7 +3093,7 @@ else
         int level;
         Dsymbol s;
         Dsymbol fdparent;
-        //printf("FuncDeclaration::getLevel(fd = '%s')\n", fd->toChars());
+        //printf("FuncDeclaration::getLevel(fd = '%s')\n", fd.toChars());
         fdparent = fd.toParent2();
         if (fdparent == this)
             return -1;
@@ -3028,7 +3101,7 @@ else
         level = 0;
         while (fd != s && fdparent != s.toParent2())
         {
-            //printf("\ts = %s, '%s'\n", s->kind(), s->toChars());
+            //printf("\ts = %s, '%s'\n", s.kind(), s.toChars());
             FuncDeclaration thisfd = s.isFuncDeclaration();
             if (thisfd)
             {
@@ -3141,11 +3214,6 @@ else
         return true; // functions can be overloaded
     }
 
-    override final bool hasOverloads()
-    {
-        return overnext !is null;
-    }
-
     final PURE isPure()
     {
         //printf("FuncDeclaration::isPure() '%s'\n", toChars());
@@ -3413,7 +3481,7 @@ else
         return (ad && !(cd && cd.isCPPclass()) && ad.inv && global.params.useInvariants && (protection.kind == PROTprotected || protection.kind == PROTpublic || protection.kind == PROTexport) && !naked);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "function";
     }
@@ -3456,73 +3524,71 @@ else
     final bool checkNestedReference(Scope* sc, Loc loc)
     {
         //printf("FuncDeclaration::checkNestedReference() %s\n", toPrettyChars());
+
+        if (auto fld = this.isFuncLiteralDeclaration())
+        {
+            if (fld.tok == TOKreserved)
+            {
+                fld.tok = TOKfunction;
+                fld.vthis = null;
+            }
+        }
+
         if (!parent || parent == sc.parent)
             return false;
         if (ident == Id.require || ident == Id.ensure)
             return false;
         if (!isThis() && !isNested())
             return false;
+
         // The current function
         FuncDeclaration fdthis = sc.parent.isFuncDeclaration();
         if (!fdthis)
             return false; // out of function scope
+
         Dsymbol p = toParent2();
+
         // Function literals from fdthis to p must be delegates
-        // TODO: here is similar to checkFrameAccess.
-        for (Dsymbol s = fdthis; s && s != p; s = s.toParent2())
-        {
-            // function literal has reference to enclosing scope is delegate
-            if (FuncLiteralDeclaration fld = s.isFuncLiteralDeclaration())
-                fld.tok = TOKdelegate;
-            if (FuncDeclaration fd = s.isFuncDeclaration())
-            {
-                if (!fd.isThis() && !fd.isNested())
-                    break;
-            }
-            if (AggregateDeclaration ad2 = s.isAggregateDeclaration())
-            {
-                if (ad2.storage_class & STCstatic)
-                    break;
-            }
-        }
+        checkNestedRef(fdthis, p);
+
         if (isNested())
         {
             // The function that this function is in
-            FuncDeclaration fdv2 = p.isFuncDeclaration();
-            //printf("this = %s in [%s]\n", this->toChars(), this->loc.toChars());
-            //printf("fdv2 = %s in [%s]\n", fdv2->toChars(), fdv2->loc.toChars());
-            //printf("fdthis = %s in [%s]\n", fdthis->toChars(), fdthis->loc.toChars());
-            if (fdv2 && fdv2 != fdthis)
+            FuncDeclaration fdv = p.isFuncDeclaration();
+            if (!fdv)
+                return false;
+            if (fdv == fdthis)
+                return false;
+
+            //printf("this = %s in [%s]\n", this.toChars(), this.loc.toChars());
+            //printf("fdv  = %s in [%s]\n", fdv .toChars(), fdv .loc.toChars());
+            //printf("fdthis = %s in [%s]\n", fdthis.toChars(), fdthis.loc.toChars());
+
+            // Add this function to the list of those which called us
+            if (fdthis != this)
             {
-                // Add this function to the list of those which called us
-                if (fdthis != this)
+                bool found = false;
+                for (size_t i = 0; i < siblingCallers.dim; ++i)
                 {
-                    bool found = false;
-                    for (size_t i = 0; i < siblingCallers.dim; ++i)
-                    {
-                        if (siblingCallers[i] == fdthis)
-                            found = true;
-                    }
-                    if (!found)
-                    {
-                        //printf("\tadding sibling %s\n", fdthis->toPrettyChars());
-                        if (!sc.intypeof && !(sc.flags & SCOPEcompile))
-                            siblingCallers.push(fdthis);
-                    }
+                    if (siblingCallers[i] == fdthis)
+                        found = true;
+                }
+                if (!found)
+                {
+                    //printf("\tadding sibling %s\n", fdthis.toPrettyChars());
+                    if (!sc.intypeof && !(sc.flags & SCOPEcompile))
+                        siblingCallers.push(fdthis);
                 }
             }
-            FuncDeclaration fdv = p.isFuncDeclaration();
-            if (fdv && fdthis && fdv != fdthis)
-            {
-                int lv = fdthis.getLevel(loc, sc, fdv);
-                if (lv == -2)
-                    return true; // error
-                if (lv == -1)
-                    return false; // downlevel call
-                if (lv == 0)
-                    return false; // same level call
-                // Uplevel call
-            }
+
+            int lv = fdthis.getLevel(loc, sc, fdv);
+            if (lv == -2)
+                return true; // error
+            if (lv == -1)
+                return false; // downlevel call
+            if (lv == 0)
+                return false; // same level call
+            // Uplevel call
         }
         return false;
     }
@@ -3557,7 +3623,6 @@ else
         for (size_t i = 0; i < closureVars.dim; i++)
         {
             VarDeclaration v = closureVars[i];
-            assert(v.isVarDeclaration());
             //printf("\tv = %s\n", v->toChars());
             for (size_t j = 0; j < v.nestedrefs.dim; j++)
             {
@@ -3626,6 +3691,65 @@ else
         return true;
     }
 
+    /***********************************************
+     * Check that the function contains any closure.
+     * If it's @nogc, report suitable errors.
+     * This is mostly consistent with FuncDeclaration::needsClosure().
+     *
+     * Returns:
+     *      true if any errors occur.
+     */
+    final bool checkClosure()
+    {
+        if (!needsClosure())
+            return false;
+
+        if (setGC())
+        {
+            error("is @nogc yet allocates closures with the GC");
+            if (global.gag)     // need not report supplemental errors
+                return true;
+        }
+        else
+        {
+            printGCUsage(loc, "using closure causes GC allocation");
+            return false;
+        }
+
+        FuncDeclarations a;
+        foreach (v; closureVars)
+        {
+            foreach (f; v.nestedrefs)
+            {
+                assert(f !is this);
+
+            LcheckAncestorsOfANestedRef:
+                for (Dsymbol s = f; s && s !is this; s = s.parent)
+                {
+                    auto fx = s.isFuncDeclaration();
+                    if (!fx)
+                        continue;
+                    if (fx.isThis() ||
+                        fx.tookAddressOf ||
+                        checkEscapingSiblings(fx, this))
+                    {
+                        foreach (f2; a)
+                        {
+                            if (f2 == f)
+                                break LcheckAncestorsOfANestedRef;
+                        }
+                        a.push(f);
+                        .errorSupplemental(f.loc, "%s closes over variable %s at %s",
+                            f.toPrettyChars(), v.toChars(), v.loc.toChars());
+                        break LcheckAncestorsOfANestedRef;
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
     /***********************************************
      * Determine if function's variables are referenced by a function
      * nested within it.
@@ -3769,7 +3893,7 @@ version(IN_LLVM)
 else
 {
                 Expression eresult = null;
-                Expression e = new CallExp(loc, new VarExp(loc, fdv.fdrequire, 0), eresult);
+                Expression e = new CallExp(loc, new VarExp(loc, fdv.fdrequire, false), eresult);
 }
                 Statement s2 = new ExpStatement(loc, e);
                 auto c = new Catch(loc, null, null, sf);
@@ -3865,7 +3989,7 @@ version(IN_LLVM)
 }
 else
 {
-                Expression e = new CallExp(loc, new VarExp(loc, fdv.fdensure, 0), eresult);
+                Expression e = new CallExp(loc, new VarExp(loc, fdv.fdensure, false), eresult);
 }
                 Statement s2 = new ExpStatement(loc, e);
                 if (sf)
@@ -3904,7 +4028,7 @@ else
      */
     final static FuncDeclaration genCfunc(Parameters* fparams, Type treturn, const(char)* name, StorageClass stc = 0)
     {
-        return genCfunc(fparams, treturn, Identifier.idPool(name), stc);
+        return genCfunc(fparams, treturn, Identifier.idPool(name, strlen(name)), stc);
     }
 
     final static FuncDeclaration genCfunc(Parameters* fparams, Type treturn, Identifier id, StorageClass stc = 0)
@@ -3936,7 +4060,7 @@ else
         return fd;
     }
 
-    override final FuncDeclaration isFuncDeclaration()
+    override final inout(FuncDeclaration) isFuncDeclaration() inout
     {
         return this;
     }
@@ -3993,7 +4117,7 @@ extern (C++) Expression addInvariant(Loc loc, Scope* sc, AggregateDeclaration ad
              */
             e = new ThisExp(Loc());
             e.type = vthis.type;
-            e = new DotVarExp(Loc(), e, inv, 0);
+            e = new DotVarExp(Loc(), e, inv, false);
             e.type = inv.type;
             e = new CallExp(Loc(), e);
             e.type = Type.tvoid;
@@ -4141,10 +4265,12 @@ extern (C++) static void MODMatchToBuffer(OutBuffer* buf, ubyte lhsMod, ubyte rh
  *      flags           1: do not issue error message on no match, just return NULL
  *                      2: overloadResolve only
  */
-extern (C++) FuncDeclaration resolveFuncCall(Loc loc, Scope* sc, Dsymbol s, Objects* tiargs, Type tthis, Expressions* fargs, int flags = 0)
+extern (C++) FuncDeclaration resolveFuncCall(Loc loc, Scope* sc, Dsymbol s,
+    Objects* tiargs, Type tthis, Expressions* fargs, int flags = 0)
 {
     if (!s)
         return null; // no match
+
     version (none)
     {
         printf("resolveFuncCall('%s')\n", s.toChars());
@@ -4159,13 +4285,18 @@ extern (C++) FuncDeclaration resolveFuncCall(Loc loc, Scope* sc, Dsymbol s, Obje
             }
         }
     }
-    if (tiargs && arrayObjectIsError(tiargs) || fargs && arrayObjectIsError(cast(Objects*)fargs))
+
+    if (tiargs && arrayObjectIsError(tiargs) ||
+        fargs && arrayObjectIsError(cast(Objects*)fargs))
     {
         return null;
     }
+
     Match m;
     m.last = MATCHnomatch;
+
     functionResolve(&m, s, loc, sc, tiargs, tthis, fargs);
+
     if (m.last > MATCHnomatch && m.lastf)
     {
         if (m.count == 1) // exactly one match
@@ -4179,6 +4310,7 @@ extern (C++) FuncDeclaration resolveFuncCall(Loc loc, Scope* sc, Dsymbol s, Obje
             return m.lastf;
         }
     }
+
     /* Failed to find a best match.
      * Do nothing or print error.
      */
@@ -4187,16 +4319,21 @@ extern (C++) FuncDeclaration resolveFuncCall(Loc loc, Scope* sc, Dsymbol s, Obje
         // error was caused on matched function
         if (m.count == 1)
             return m.lastf;
+
         // if do not print error messages
         if (flags & 1)
             return null; // no match
     }
-    FuncDeclaration fd = s.isFuncDeclaration();
-    TemplateDeclaration td = s.isTemplateDeclaration();
+
+    auto fd = s.isFuncDeclaration();
+    auto od = s.isOverDeclaration();
+    auto td = s.isTemplateDeclaration();
     if (td && td.funcroot)
         s = fd = td.funcroot;
+
     OutBuffer tiargsBuf;
     arrayObjectsToBuffer(&tiargsBuf, tiargs);
+
     OutBuffer fargsBuf;
     fargsBuf.writeByte('(');
     argExpTypesToCBuffer(&fargsBuf, fargs);
@@ -4211,7 +4348,9 @@ extern (C++) FuncDeclaration resolveFuncCall(Loc loc, Scope* sc, Dsymbol s, Obje
     {
         if (td && !fd) // all of overloads are templates
         {
-            .error(loc, "%s %s.%s cannot deduce function from argument types !(%s)%s, candidates are:", td.kind(), td.parent.toPrettyChars(), td.ident.toChars(), tiargsBuf.peekString(), fargsBuf.peekString());
+            .error(loc, "%s %s.%s cannot deduce function from argument types !(%s)%s, candidates are:",
+                td.kind(), td.parent.toPrettyChars(), td.ident.toChars(),
+                tiargsBuf.peekString(), fargsBuf.peekString());
 
             // Display candidate templates (even if there are no multiple overloads)
             int numToDisplay = numOverloadsDisplay;
@@ -4227,17 +4366,23 @@ extern (C++) FuncDeclaration resolveFuncCall(Loc loc, Scope* sc, Dsymbol s, Obje
                 // Too many overloads to sensibly display.
                 // Just show count of remaining overloads.
                 int num = 0;
-                overloadApply(td.overnext, (s){ ++num; return 0; });
+                overloadApply(td.overnext, (s) { ++num; return 0; });
                 if (num > 0)
                     .errorSupplemental(loc, "... (%d more, -v to show) ...", num);
                 return 1;   // stop iterating
             });
         }
+        else if (od)
+        {
+            .error(loc, "none of the overloads of '%s' are callable using argument types !(%s)%s",
+                od.ident.toChars(), tiargsBuf.peekString(), fargsBuf.peekString());
+        }
         else
         {
             assert(fd);
+
             bool hasOverloads = fd.overnext !is null;
-            TypeFunction tf = cast(TypeFunction)fd.type;
+            auto tf = cast(TypeFunction)fd.type;
             if (tthis && !MODimplicitConv(tthis.mod, tf.mod)) // modifier mismatch
             {
                 OutBuffer thisBuf, funcBuf;
@@ -4245,7 +4390,7 @@ extern (C++) FuncDeclaration resolveFuncCall(Loc loc, Scope* sc, Dsymbol s, Obje
                 MODMatchToBuffer(&funcBuf, tf.mod, tthis.mod);
                 if (hasOverloads)
                 {
-                    .error(loc, "None of the overloads of '%s' are callable using a %sobject, candidates are:",
+                    .error(loc, "none of the overloads of '%s' are callable using a %sobject, candidates are:",
                         fd.ident.toChars(), thisBuf.peekString());
                 }
                 else
@@ -4260,7 +4405,7 @@ extern (C++) FuncDeclaration resolveFuncCall(Loc loc, Scope* sc, Dsymbol s, Obje
                 //printf("tf = %s, args = %s\n", tf->deco, (*fargs)[0]->type->deco);
                 if (hasOverloads)
                 {
-                    .error(loc, "None of the overloads of '%s' are callable using argument types %s, candidates are:",
+                    .error(loc, "none of the overloads of '%s' are callable using argument types %s, candidates are:",
                         fd.ident.toChars(), fargsBuf.peekString());
                 }
                 else
@@ -4299,7 +4444,11 @@ extern (C++) FuncDeclaration resolveFuncCall(Loc loc, Scope* sc, Dsymbol s, Obje
         TypeFunction tf2 = cast(TypeFunction)m.nextf.type;
         const(char)* lastprms = parametersTypeToChars(tf1.parameters, tf1.varargs);
         const(char)* nextprms = parametersTypeToChars(tf2.parameters, tf2.varargs);
-        .error(loc, "%s.%s called with argument types %s matches both:\n%s:     %s%s\nand:\n%s:     %s%s", s.parent.toPrettyChars(), s.ident.toChars(), fargsBuf.peekString(), m.lastf.loc.toChars(), m.lastf.toPrettyChars(), lastprms, m.nextf.loc.toChars(), m.nextf.toPrettyChars(), nextprms);
+        .error(loc, "%s.%s called with argument types %s matches both:\n%s:     %s%s\nand:\n%s:     %s%s",
+            s.parent.toPrettyChars(), s.ident.toChars(),
+            fargsBuf.peekString(),
+            m.lastf.loc.toChars(), m.lastf.toPrettyChars(), lastprms,
+            m.nextf.loc.toChars(), m.nextf.toPrettyChars(), nextprms);
     }
     return null;
 }
@@ -4483,12 +4632,12 @@ public:
         userAttribDecl = funcalias.userAttribDecl;
     }
 
-    override FuncAliasDeclaration isFuncAliasDeclaration()
+    override inout(FuncAliasDeclaration) isFuncAliasDeclaration() inout
     {
         return this;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "function alias";
     }
@@ -4512,6 +4661,9 @@ public:
     TOK tok;        // TOKfunction or TOKdelegate
     Type treq;      // target of return type inference
 
+    // backend
+    bool deferToObj;
+
     extern (D) this(Loc loc, Loc endloc, Type type, TOK tok, ForeachStatement fes, Identifier id = null)
     {
         super(loc, endloc, null, STCundefined, type);
@@ -4598,12 +4750,12 @@ public:
             (cast(TypeFunction)type).next = tret;
     }
 
-    override FuncLiteralDeclaration isFuncLiteralDeclaration()
+    override inout(FuncLiteralDeclaration) isFuncLiteralDeclaration() inout
     {
         return this;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         // GCC requires the (char*) casts
         return (tok != TOKfunction) ? cast(char*)"delegate" : cast(char*)"function";
@@ -4686,7 +4838,7 @@ public:
                 {
                     if (fbody || !(storage_class & STCdisable))
                     {
-                        error("default constructor for structs only allowed "
+                        error("default constructor for structs only allowed " ~
                             "with @disable, no body, and no parameters");
                         storage_class |= STCdisable;
                         fbody = null;
@@ -4717,14 +4869,14 @@ public:
         }
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "constructor";
     }
 
-    override char* toChars()
+    override const(char)* toChars() const
     {
-        return cast(char*)"this";
+        return "this";
     }
 
     override bool isVirtual()
@@ -4742,7 +4894,7 @@ public:
         return (isThis() && vthis && global.params.useInvariants);
     }
 
-    override CtorDeclaration isCtorDeclaration()
+    override inout(CtorDeclaration) isCtorDeclaration() inout
     {
         return this;
     }
@@ -4823,7 +4975,7 @@ public:
         return false; // cannot overload postblits
     }
 
-    override PostBlitDeclaration isPostBlitDeclaration()
+    override inout(PostBlitDeclaration) isPostBlitDeclaration() inout
     {
         return this;
     }
@@ -4883,19 +5035,20 @@ public:
             type = new TypeFunction(null, Type.tvoid, false, LINKd, storage_class);
         sc = sc.push();
         sc.stc &= ~STCstatic; // not a static destructor
-        sc.linkage = LINKd;
+        if (sc.linkage != LINKcpp)
+            sc.linkage = LINKd;
         FuncDeclaration.semantic(sc);
         sc.pop();
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "destructor";
     }
 
-    override char* toChars()
+    override const(char)* toChars() const
     {
-        return cast(char*)"~this";
+        return "~this";
     }
 
     override bool isVirtual()
@@ -4919,7 +5072,7 @@ public:
         return false; // cannot overload destructors
     }
 
-    override DtorDeclaration isDtorDeclaration()
+    override inout(DtorDeclaration) isDtorDeclaration() inout
     {
         return this;
     }
@@ -5037,7 +5190,7 @@ public:
         return true;
     }
 
-    override final StaticCtorDeclaration isStaticCtorDeclaration()
+    override final inout(StaticCtorDeclaration) isStaticCtorDeclaration() inout
     {
         return this;
     }
@@ -5065,7 +5218,7 @@ public:
         return FuncDeclaration.syntaxCopy(scd);
     }
 
-    override SharedStaticCtorDeclaration isSharedStaticCtorDeclaration()
+    override inout(SharedStaticCtorDeclaration) isSharedStaticCtorDeclaration() inout
     {
         return this;
     }
@@ -5186,7 +5339,7 @@ public:
         return false;
     }
 
-    override final StaticDtorDeclaration isStaticDtorDeclaration()
+    override final inout(StaticDtorDeclaration) isStaticDtorDeclaration() inout
     {
         return this;
     }
@@ -5214,7 +5367,7 @@ public:
         return FuncDeclaration.syntaxCopy(sdd);
     }
 
-    override SharedStaticDtorDeclaration isSharedStaticDtorDeclaration()
+    override inout(SharedStaticDtorDeclaration) isSharedStaticDtorDeclaration() inout
     {
         return this;
     }
@@ -5289,7 +5442,7 @@ public:
         return false;
     }
 
-    override InvariantDeclaration isInvariantDeclaration()
+    override inout(InvariantDeclaration) isInvariantDeclaration() inout
     {
         return this;
     }
@@ -5399,7 +5552,7 @@ public:
         return false;
     }
 
-    override UnitTestDeclaration isUnitTestDeclaration()
+    override inout(UnitTestDeclaration) isUnitTestDeclaration() inout
     {
         return this;
     }
@@ -5471,7 +5624,7 @@ public:
         FuncDeclaration.semantic(sc);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "allocator";
     }
@@ -5491,7 +5644,7 @@ public:
         return false;
     }
 
-    override NewDeclaration isNewDeclaration()
+    override inout(NewDeclaration) isNewDeclaration() inout
     {
         return this;
     }
@@ -5560,7 +5713,7 @@ public:
         FuncDeclaration.semantic(sc);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "deallocator";
     }
@@ -5585,7 +5738,7 @@ public:
         return false;
     }
 
-    override DeleteDeclaration isDeleteDeclaration()
+    override inout(DeleteDeclaration) isDeleteDeclaration() inout
     {
         return this;
     }
diff --git a/ddmd/globals.d b/ddmd/globals.d
index fefa000c53..8dbc0c7044 100644
--- a/ddmd/globals.d
+++ b/ddmd/globals.d
@@ -130,6 +130,8 @@ struct Param
     bool addMain;           // add a default main() function
     bool allInst;           // generate code for all template instantiations
     bool dwarfeh;           // generate dwarf eh exception handling
+    bool check10378;        // check for issues transitioning to 10738
+    bool bug10378;          // use pre-bugzilla 10378 search strategy
 
     BOUNDSCHECK useArrayBounds;
 
@@ -432,7 +434,7 @@ struct Loc
         this.filename = filename;
     }
 
-    extern (C++) char* toChars()
+    extern (C++) const(char)* toChars() const
     {
         OutBuffer buf;
         if (filename)
@@ -457,65 +459,65 @@ struct Loc
 
 enum LINK : int
 {
-    LINKdefault,
-    LINKd,
-    LINKc,
-    LINKcpp,
-    LINKwindows,
-    LINKpascal,
-    LINKobjc,
+    def,        // default
+    d,
+    c,
+    cpp,
+    windows,
+    pascal,
+    objc,
 }
 
-alias LINKdefault = LINK.LINKdefault;
-alias LINKd = LINK.LINKd;
-alias LINKc = LINK.LINKc;
-alias LINKcpp = LINK.LINKcpp;
-alias LINKwindows = LINK.LINKwindows;
-alias LINKpascal = LINK.LINKpascal;
-alias LINKobjc = LINK.LINKobjc;
+alias LINKdefault = LINK.def;
+alias LINKd = LINK.d;
+alias LINKc = LINK.c;
+alias LINKcpp = LINK.cpp;
+alias LINKwindows = LINK.windows;
+alias LINKpascal = LINK.pascal;
+alias LINKobjc = LINK.objc;
 
 enum DYNCAST : int
 {
-    DYNCAST_OBJECT,
-    DYNCAST_EXPRESSION,
-    DYNCAST_DSYMBOL,
-    DYNCAST_TYPE,
-    DYNCAST_IDENTIFIER,
-    DYNCAST_TUPLE,
-    DYNCAST_PARAMETER,
+    object,
+    expression,
+    dsymbol,
+    type,
+    identifier,
+    tuple,
+    parameter,
 }
 
-alias DYNCAST_OBJECT = DYNCAST.DYNCAST_OBJECT;
-alias DYNCAST_EXPRESSION = DYNCAST.DYNCAST_EXPRESSION;
-alias DYNCAST_DSYMBOL = DYNCAST.DYNCAST_DSYMBOL;
-alias DYNCAST_TYPE = DYNCAST.DYNCAST_TYPE;
-alias DYNCAST_IDENTIFIER = DYNCAST.DYNCAST_IDENTIFIER;
-alias DYNCAST_TUPLE = DYNCAST.DYNCAST_TUPLE;
-alias DYNCAST_PARAMETER = DYNCAST.DYNCAST_PARAMETER;
+alias DYNCAST_OBJECT = DYNCAST.object;
+alias DYNCAST_EXPRESSION = DYNCAST.expression;
+alias DYNCAST_DSYMBOL = DYNCAST.dsymbol;
+alias DYNCAST_TYPE = DYNCAST.type;
+alias DYNCAST_IDENTIFIER = DYNCAST.identifier;
+alias DYNCAST_TUPLE = DYNCAST.tuple;
+alias DYNCAST_PARAMETER = DYNCAST.parameter;
 
 enum MATCH : int
 {
-    MATCHnomatch,   // no match
-    MATCHconvert,   // match with conversions
-    MATCHconst,     // match with conversion to const
-    MATCHexact,     // exact match
+    nomatch,   // no match
+    convert,   // match with conversions
+    constant,  // match with conversion to const
+    exact,     // exact match
 }
 
-alias MATCHnomatch = MATCH.MATCHnomatch;
-alias MATCHconvert = MATCH.MATCHconvert;
-alias MATCHconst = MATCH.MATCHconst;
-alias MATCHexact = MATCH.MATCHexact;
+alias MATCHnomatch = MATCH.nomatch;
+alias MATCHconvert = MATCH.convert;
+alias MATCHconst = MATCH.constant;
+alias MATCHexact = MATCH.exact;
 
 enum PINLINE : int
 {
-    PINLINEdefault, // as specified on the command line
-    PINLINEnever,   // never inline
-    PINLINEalways,  // always inline
+    def,     // as specified on the command line
+    never,   // never inline
+    always,  // always inline
 }
 
-alias PINLINEdefault = PINLINE.PINLINEdefault;
-alias PINLINEnever = PINLINE.PINLINEnever;
-alias PINLINEalways = PINLINE.PINLINEalways;
+alias PINLINEdefault = PINLINE.def;
+alias PINLINEnever = PINLINE.never;
+alias PINLINEalways = PINLINE.always;
 
 alias StorageClass = uinteger_t;
 
diff --git a/ddmd/globals.h b/ddmd/globals.h
index 76c40b2828..0c2d3faef8 100644
--- a/ddmd/globals.h
+++ b/ddmd/globals.h
@@ -130,6 +130,8 @@ struct Param
     bool allInst;       // generate code for all template instantiations
 // LDC_FIXME: Implement "addMain" and "allInst".
     bool dwarfeh;       // generate dwarf eh exception handling
+    bool check10378;    // check for issues transitioning to 10738
+    bool bug10378;      // use pre-bugzilla 10378 search strategy
 
     BOUNDSCHECK useArrayBounds;
 
@@ -315,6 +317,14 @@ typedef double real_t;
 typedef longdouble real_t;
 #endif
 
+// Represents a D [ ] array
+template<typename T>
+struct DArray
+{
+    size_t length;
+    T *ptr;
+};
+
 // file location
 struct Loc
 {
@@ -339,7 +349,7 @@ struct Loc
     Loc(const char *filename, unsigned linnum, unsigned charnum);
 #endif
 
-    char *toChars();
+    const char *toChars() const;
     bool equals(const Loc& loc);
 };
 
diff --git a/ddmd/gluelayer.d b/ddmd/gluelayer.d
index 8fff4f9592..bdd8adb550 100644
--- a/ddmd/gluelayer.d
+++ b/ddmd/gluelayer.d
@@ -31,69 +31,32 @@ version (IN_LLVM)
     extern (C++) RET retStyle(TypeFunction tf);
     extern (C++) Statement asmSemantic(AsmStatement s, Scope* sc);
 
-    extern(C++) void objc_initSymbols()
-    {
-    }
+    extern(C++) void objc_initSymbols() {}
 }
 else version (NoBackend)
 {
-    // tocsym
-
-    extern (C++) Symbol* toInitializer(AggregateDeclaration ad)
+    extern (C++)
     {
-        return null;
-    }
+        // glue
+        void obj_write_deferred(Library library)        {}
+        void obj_start(char* srcfile)                   {}
+        void obj_end(Library library, File* objfile)    {}
+        void genObjFile(Module m, bool multiobj)        {}
 
-    // glue
+        // msc
+        void backend_init() {}
+        void backend_term() {}
 
-    extern (C++) void obj_write_deferred(Library library)
-    {
-    }
+        // iasm
+        Statement asmSemantic(AsmStatement s, Scope* sc) { assert(0); }
 
-    extern (C++) void obj_start(char* srcfile)
-    {
-    }
+        // toir
+        RET retStyle(TypeFunction tf)               { return RETregs; }
+        void toObjFile(Dsymbol ds, bool multiobj)   {}
 
-    extern (C++) void obj_end(Library library, File* objfile)
-    {
-    }
-
-    extern (C++) void genObjFile(Module m, bool multiobj)
-    {
-    }
-
-    // msc
-
-    extern (C++) void backend_init()
-    {
-    }
-
-    extern (C++) void backend_term()
-    {
-    }
-
-    // iasm
-
-    extern (C++) Statement asmSemantic(AsmStatement s, Scope* sc)
-    {
-        assert(0);
-    }
-
-    // toir
-
-    extern (C++) RET retStyle(TypeFunction tf)
-    {
-        return RETregs;
-    }
-
-    extern (C++) void toObjFile(Dsymbol ds, bool multiobj)
-    {
-    }
-
-    version (OSX)
-    {
-        extern(C++) void objc_initSymbols()
+        version (OSX)
         {
+            void objc_initSymbols() {}
         }
     }
 }
@@ -108,23 +71,24 @@ else
     alias elem = ddmd.backend.elem;
     alias type = ddmd.backend.type;
 
-    extern extern (C++) Symbol* toInitializer(AggregateDeclaration sd);
-
-    extern extern (C++) void obj_write_deferred(Library library);
-    extern extern (C++) void obj_start(char* srcfile);
-    extern extern (C++) void obj_end(Library library, File* objfile);
-    extern extern (C++) void genObjFile(Module m, bool multiobj);
-
-    extern extern (C++) void backend_init();
-    extern extern (C++) void backend_term();
-
-    extern extern (C++) Statement asmSemantic(AsmStatement s, Scope* sc);
-
-    extern extern (C++) RET retStyle(TypeFunction tf);
-    extern extern (C++) void toObjFile(Dsymbol ds, bool multiobj);
-
-    version (OSX)
+    extern (C++)
     {
-        extern(C++) void objc_initSymbols();
+        void obj_write_deferred(Library library);
+        void obj_start(char* srcfile);
+        void obj_end(Library library, File* objfile);
+        void genObjFile(Module m, bool multiobj);
+
+        void backend_init();
+        void backend_term();
+
+        Statement asmSemantic(AsmStatement s, Scope* sc);
+
+        RET retStyle(TypeFunction tf);
+        void toObjFile(Dsymbol ds, bool multiobj);
+
+        version (OSX)
+        {
+            void objc_initSymbols();
+        }
     }
 }
diff --git a/ddmd/hdrgen.d b/ddmd/hdrgen.d
index 7beba54909..b427b3ad9a 100644
--- a/ddmd/hdrgen.d
+++ b/ddmd/hdrgen.d
@@ -106,22 +106,17 @@ public:
 
     override void visit(ExpStatement s)
     {
+        if (s.exp && s.exp.op == TOKdeclaration)
+        {
+            // bypass visit(DeclarationExp)
+            (cast(DeclarationExp)s.exp).declaration.accept(this);
+            return;
+        }
         if (s.exp)
-        {
             s.exp.accept(this);
-            if (s.exp.op != TOKdeclaration)
-            {
-                buf.writeByte(';');
-                if (!hgs.forStmtInit)
-                    buf.writenl();
-            }
-        }
-        else
-        {
-            buf.writeByte(';');
-            if (!hgs.forStmtInit)
-                buf.writenl();
-        }
+        buf.writeByte(';');
+        if (!hgs.forStmtInit)
+            buf.writenl();
     }
 
     override void visit(CompileStatement s)
@@ -135,9 +130,8 @@ public:
 
     override void visit(CompoundStatement s)
     {
-        for (size_t i = 0; i < s.statements.dim; i++)
+        foreach (sx; *s.statements)
         {
-            Statement sx = (*s.statements)[i];
             if (sx)
                 sx.accept(this);
         }
@@ -146,15 +140,14 @@ public:
     override void visit(CompoundDeclarationStatement s)
     {
         bool anywritten = false;
-        for (size_t i = 0; i < s.statements.dim; i++)
+        foreach (sx; *s.statements)
         {
-            Statement sx = (*s.statements)[i];
-            ExpStatement ds = sx ? sx.isExpStatement() : null;
+            auto ds = sx ? sx.isExpStatement() : null;
             if (ds && ds.exp.op == TOKdeclaration)
             {
-                Dsymbol d = (cast(DeclarationExp)ds.exp).declaration;
+                auto d = (cast(DeclarationExp)ds.exp).declaration;
                 assert(d.isDeclaration());
-                if (VarDeclaration v = d.isVarDeclaration())
+                if (auto v = d.isVarDeclaration())
                     visitVarDecl(v, anywritten);
                 else
                     d.accept(this);
@@ -171,9 +164,8 @@ public:
         buf.writestring("unrolled {");
         buf.writenl();
         buf.level++;
-        for (size_t i = 0; i < s.statements.dim; i++)
+        foreach (sx; *s.statements)
         {
-            Statement sx = (*s.statements)[i];
             if (sx)
                 sx.accept(this);
         }
@@ -253,9 +245,8 @@ public:
     {
         buf.writestring(Token.toChars(s.op));
         buf.writestring(" (");
-        for (size_t i = 0; i < s.parameters.dim; i++)
+        foreach (i, p; *s.parameters)
         {
-            Parameter p = (*s.parameters)[i];
             if (i)
                 buf.writestring(", ");
             if (stcToBuffer(buf, p.storageClass))
@@ -539,9 +530,8 @@ public:
         buf.writenl();
         if (s._body)
             s._body.accept(this);
-        for (size_t i = 0; i < s.catches.dim; i++)
+        foreach (c; *s.catches)
         {
-            Catch c = (*s.catches)[i];
             visit(c);
         }
     }
@@ -636,9 +626,8 @@ public:
 
     override void visit(ImportStatement s)
     {
-        for (size_t i = 0; i < s.imports.dim; i++)
+        foreach (imp; *s.imports)
         {
-            Dsymbol imp = (*s.imports)[i];
             imp.accept(this);
         }
     }
@@ -904,11 +893,11 @@ public:
         if (td)
         {
             buf.writeByte('(');
-            for (size_t i = 0; i < td.origParameters.dim; i++)
+            foreach (i, p; *td.origParameters)
             {
                 if (i)
                     buf.writestring(", ");
-                (*td.origParameters)[i].accept(this);
+                p.accept(this);
             }
             buf.writeByte(')');
         }
@@ -923,9 +912,8 @@ public:
 
     void visitTypeQualifiedHelper(TypeQualified t)
     {
-        for (size_t i = 0; i < t.idents.dim; i++)
+        foreach (id; t.idents)
         {
-            RootObject id = t.idents[i];
             if (id.dyncast() == DYNCAST_DSYMBOL)
             {
                 buf.writeByte('.');
@@ -1093,9 +1081,8 @@ public:
         }
         if (imp.packages && imp.packages.dim)
         {
-            for (size_t i = 0; i < imp.packages.dim; i++)
+            foreach (const pid; *imp.packages)
             {
-                Identifier pid = (*imp.packages)[i];
                 buf.printf("%s.", pid.toChars());
             }
         }
@@ -1103,12 +1090,11 @@ public:
         if (imp.names.dim)
         {
             buf.writestring(" : ");
-            for (size_t i = 0; i < imp.names.dim; i++)
+            foreach (const i, const name; imp.names)
             {
                 if (i)
                     buf.writestring(", ");
-                Identifier name = imp.names[i];
-                Identifier _alias = imp.aliases[i];
+                const _alias = imp.aliases[i];
                 if (_alias)
                     buf.printf("%s = %s", _alias.toChars(), name.toChars());
                 else
@@ -1152,8 +1138,8 @@ public:
             buf.writeByte('{');
             buf.writenl();
             buf.level++;
-            for (size_t i = 0; i < d.decl.dim; i++)
-                (*d.decl)[i].accept(this);
+            foreach (de; *d.decl)
+                de.accept(this);
             buf.level--;
             buf.writeByte('}');
         }
@@ -1232,8 +1218,8 @@ public:
         buf.level++;
         if (d.decl)
         {
-            for (size_t i = 0; i < d.decl.dim; i++)
-                (*d.decl)[i].accept(this);
+            foreach (de; *d.decl)
+                de.accept(this);
         }
         buf.level--;
         buf.writestring("}");
@@ -1263,8 +1249,8 @@ public:
             buf.level++;
             if (d.decl)
             {
-                for (size_t i = 0; i < d.decl.dim; i++)
-                    (*d.decl)[i].accept(this);
+                foreach (de; *d.decl)
+                    de.accept(this);
             }
             buf.level--;
             buf.writeByte('}');
@@ -1276,8 +1262,8 @@ public:
                 buf.writeByte('{');
                 buf.writenl();
                 buf.level++;
-                for (size_t i = 0; i < d.elsedecl.dim; i++)
-                    (*d.elsedecl)[i].accept(this);
+                foreach (de; *d.elsedecl)
+                    de.accept(this);
                 buf.level--;
                 buf.writeByte('}');
             }
@@ -1330,8 +1316,8 @@ public:
             buf.writeByte('{');
             buf.writenl();
             buf.level++;
-            for (size_t i = 0; i < d.members.dim; i++)
-                (*d.members)[i].accept(this);
+            foreach (s; *d.members)
+                s.accept(this);
             buf.level--;
             buf.writeByte('}');
             buf.writenl();
@@ -1375,8 +1361,8 @@ public:
                 buf.writeByte('{');
                 buf.writenl();
                 buf.level++;
-                for (size_t i = 0; i < ad.members.dim; i++)
-                    (*ad.members)[i].accept(this);
+                foreach (s; *ad.members)
+                    s.accept(this);
                 buf.level--;
                 buf.writeByte('}');
             }
@@ -1419,11 +1405,11 @@ public:
     {
         if (!parameters || !parameters.dim)
             return;
-        for (size_t i = 0; i < parameters.dim; i++)
+        foreach (i, p; *parameters)
         {
             if (i)
                 buf.writestring(", ");
-            (*parameters)[i].accept(this);
+            p.accept(this);
         }
     }
 
@@ -1491,11 +1477,11 @@ public:
         }
         buf.writeByte('(');
         ti.nest++;
-        for (size_t i = 0; i < ti.tiargs.dim; i++)
+        foreach (i, arg; *ti.tiargs)
         {
             if (i)
                 buf.writestring(", ");
-            objectToBuffer((*ti.tiargs)[i]);
+            objectToBuffer(arg);
         }
         ti.nest--;
         buf.writeByte(')');
@@ -1513,12 +1499,12 @@ public:
          * (see Bugzilla 7375).
          * Perhaps it would be better to demangle what genIdent() does.
          */
-        if (Type t = isType(oarg))
+        if (auto t = isType(oarg))
         {
             //printf("\tt: %s ty = %d\n", t->toChars(), t->ty);
             typeToBuffer(t, null);
         }
-        else if (Expression e = isExpression(oarg))
+        else if (auto e = isExpression(oarg))
         {
             if (e.op == TOKvar)
                 e = e.optimize(WANTvalue); // added to fix Bugzilla 7375
@@ -1526,17 +1512,17 @@ public:
         }
         else if (Dsymbol s = isDsymbol(oarg))
         {
-            const(char)* p = s.ident ? s.ident.toChars() : s.toChars();
+            const p = s.ident ? s.ident.toChars() : s.toChars();
             buf.writestring(p);
         }
-        else if (Tuple v = isTuple(oarg))
+        else if (auto v = isTuple(oarg))
         {
-            Objects* args = &v.objects;
-            for (size_t i = 0; i < args.dim; i++)
+            auto args = &v.objects;
+            foreach (i, arg; *args)
             {
                 if (i)
                     buf.writestring(", ");
-                objectToBuffer((*args)[i]);
+                objectToBuffer(arg);
             }
         }
         else if (!oarg)
@@ -1576,9 +1562,8 @@ public:
         buf.writeByte('{');
         buf.writenl();
         buf.level++;
-        for (size_t i = 0; i < d.members.dim; i++)
+        foreach (em; *d.members)
         {
-            EnumMember em = (*d.members)[i].isEnumMember();
             if (!em)
                 continue;
             em.accept(this);
@@ -1599,8 +1584,8 @@ public:
         buf.writeByte('{');
         buf.writenl();
         buf.level++;
-        for (size_t i = 0; i < d.members.dim; i++)
-            (*d.members)[i].accept(this);
+        foreach (s; *d.members)
+            s.accept(this);
         buf.level--;
         buf.writeByte('}');
         buf.writenl();
@@ -1621,8 +1606,8 @@ public:
         buf.writeByte('{');
         buf.writenl();
         buf.level++;
-        for (size_t i = 0; i < d.members.dim; i++)
-            (*d.members)[i].accept(this);
+        foreach (s; *d.members)
+            s.accept(this);
         buf.level--;
         buf.writeByte('}');
         buf.writenl();
@@ -1643,8 +1628,8 @@ public:
             buf.writeByte('{');
             buf.writenl();
             buf.level++;
-            for (size_t i = 0; i < d.members.dim; i++)
-                (*d.members)[i].accept(this);
+            foreach (s; *d.members)
+                s.accept(this);
             buf.level--;
             buf.writeByte('}');
         }
@@ -1658,11 +1643,10 @@ public:
         if (!d || !d.baseclasses.dim)
             return;
         buf.writestring(" : ");
-        for (size_t i = 0; i < d.baseclasses.dim; i++)
+        foreach (i, b; *d.baseclasses)
         {
             if (i)
                 buf.writestring(", ");
-            BaseClass* b = (*d.baseclasses)[i];
             typeToBuffer(b.type, null);
         }
     }
@@ -1724,7 +1708,7 @@ public:
         if (v._init)
         {
             buf.writestring(" = ");
-            ExpInitializer ie = v._init.isExpInitializer();
+            auto ie = v._init.isExpInitializer();
             if (ie && (ie.exp.op == TOKconstruct || ie.exp.op == TOKblit))
                 (cast(AssignExp)ie.exp).e2.accept(this);
             else
@@ -1949,16 +1933,16 @@ public:
     {
         //printf("StructInitializer::toCBuffer()\n");
         buf.writeByte('{');
-        for (size_t i = 0; i < si.field.dim; i++)
+        foreach (i, const id; si.field)
         {
             if (i)
                 buf.writestring(", ");
-            if (Identifier id = si.field[i])
+            if (id)
             {
                 buf.writestring(id.toChars());
                 buf.writeByte(':');
             }
-            if (Initializer iz = si.value[i])
+            if (auto iz = si.value[i])
                 iz.accept(this);
         }
         buf.writeByte('}');
@@ -1967,16 +1951,16 @@ public:
     override void visit(ArrayInitializer ai)
     {
         buf.writeByte('[');
-        for (size_t i = 0; i < ai.index.dim; i++)
+        foreach (i, ex; ai.index)
         {
             if (i)
                 buf.writestring(", ");
-            if (Expression ex = ai.index[i])
+            if (ex)
             {
                 ex.accept(this);
                 buf.writeByte(':');
             }
-            if (Initializer iz = ai.value[i])
+            if (auto iz = ai.value[i])
                 iz.accept(this);
         }
         buf.writeByte(']');
@@ -2113,6 +2097,7 @@ public:
                     buf.printf("'\\U%08x'", v);
                     break;
                 }
+                goto case;
             case Tchar:
                 {
                     size_t o = buf.offset;
@@ -2291,6 +2276,7 @@ public:
             case '"':
             case '\\':
                 buf.writeByte('\\');
+                goto default;
             default:
                 if (c <= 0xFF)
                 {
@@ -2323,14 +2309,13 @@ public:
     override void visit(AssocArrayLiteralExp e)
     {
         buf.writeByte('[');
-        for (size_t i = 0; i < e.keys.dim; i++)
+        foreach (i, key; *e.keys)
         {
-            Expression key = (*e.keys)[i];
-            Expression value = (*e.values)[i];
             if (i)
                 buf.writestring(", ");
             expToBuffer(key, PREC_assign);
             buf.writeByte(':');
+            auto value = (*e.values)[i];
             expToBuffer(value, PREC_assign);
         }
         buf.writeByte(']');
@@ -2483,7 +2468,23 @@ public:
 
     override void visit(DeclarationExp e)
     {
-        e.declaration.accept(this);
+        /* Normal dmd execution won't reach here - regular variable declarations
+         * are handled in visit(ExpStatement), so here would be used only when
+         * we'll directly call Expression.toChars() for debugging.
+         */
+        if (auto v = e.declaration.isVarDeclaration())
+        {
+            // For debugging use:
+            // - Avoid printing newline.
+            // - Intentionally use the format (Type var;)
+            //   which isn't correct as regular D code.
+            buf.writeByte('(');
+            visitVarDecl(v, false);
+            buf.writeByte(';');
+            buf.writeByte(')');
+        }
+        else
+            e.declaration.accept(this);
     }
 
     override void visit(TypeidExp e)
@@ -2499,10 +2500,10 @@ public:
         buf.writestring(e.ident.toChars());
         if (e.args)
         {
-            for (size_t i = 0; i < e.args.dim; i++)
+            foreach (arg; *e.args)
             {
                 buf.writestring(", ");
-                objectToBuffer((*e.args)[i]);
+                objectToBuffer(arg);
             }
         }
         buf.writeByte(')');
@@ -2914,7 +2915,7 @@ public:
         if (parameters)
         {
             size_t dim = Parameter.dim(parameters);
-            for (size_t i = 0; i < dim; i++)
+            foreach (i; 0 .. dim)
             {
                 if (i)
                     buf.writestring(", ");
@@ -2958,9 +2959,8 @@ public:
             buf.writeByte(';');
             buf.writenl();
         }
-        for (size_t i = 0; i < m.members.dim; i++)
+        foreach (s; *m.members)
         {
-            Dsymbol s = (*m.members)[i];
             s.accept(this);
         }
     }
@@ -3004,13 +3004,13 @@ extern (C++) bool stcToBuffer(OutBuffer* buf, StorageClass stc)
     bool result = false;
     while (stc)
     {
+        const(char)* p = stcToChars(stc);
+        if (!p) // there's no visible storage classes
+            break;
         if (!result)
             result = true;
         else
             buf.writeByte(' ');
-        const(char)* p = stcToChars(stc);
-        if (!p)
-            break;
         buf.writestring(p);
     }
     return result;
@@ -3208,11 +3208,11 @@ extern (C++) void argExpTypesToCBuffer(OutBuffer* buf, Expressions* arguments)
         return;
     HdrGenState hgs;
     scope PrettyPrintVisitor v = new PrettyPrintVisitor(buf, &hgs);
-    for (size_t i = 0; i < arguments.dim; i++)
+    foreach (i, arg; *arguments)
     {
         if (i)
             buf.writestring(", ");
-        v.typeToBuffer((*arguments)[i].type, null);
+        v.typeToBuffer(arg.type, null);
     }
 }
 
@@ -3228,11 +3228,11 @@ extern (C++) void arrayObjectsToBuffer(OutBuffer* buf, Objects* objects)
         return;
     HdrGenState hgs;
     scope PrettyPrintVisitor v = new PrettyPrintVisitor(buf, &hgs);
-    for (size_t i = 0; i < objects.dim; i++)
+    foreach (i, o; *objects)
     {
         if (i)
             buf.writestring(", ");
-        v.objectToBuffer((*objects)[i]);
+        v.objectToBuffer(o);
     }
 }
 
diff --git a/ddmd/identifier.d b/ddmd/identifier.d
index 272607de08..eac72ba3cf 100644
--- a/ddmd/identifier.d
+++ b/ddmd/identifier.d
@@ -41,27 +41,27 @@ public:
         return new Identifier(string, value);
     }
 
-    override bool equals(RootObject o)
+    override bool equals(RootObject o) const
     {
         return this == o || strncmp(string, o.toChars(), len + 1) == 0;
     }
 
-    override int compare(RootObject o)
+    override int compare(RootObject o) const
     {
         return strncmp(string, o.toChars(), len + 1);
     }
 
-    override void print()
+    override void print() const
     {
         fprintf(stderr, "%s", string);
     }
 
-    override char* toChars()
+    override const(char)* toChars() const
     {
-        return cast(char*)string;
+        return string;
     }
 
-    const(char)* toHChars2()
+    const(char)* toHChars2() const
     {
         const(char)* p = null;
         if (this == Id.ctor)
@@ -94,7 +94,7 @@ public:
         return p;
     }
 
-    override int dyncast()
+    override int dyncast() const
     {
         return DYNCAST_IDENTIFIER;
     }
@@ -112,16 +112,15 @@ public:
         OutBuffer buf;
         buf.writestring(prefix);
         buf.printf("%llu", cast(ulong)i);
-        char* id = buf.peekString();
-        return idPool(id);
+        return idPool(buf.peekSlice());
     }
 
     /********************************************
      * Create an identifier in the string table.
      */
-    static Identifier idPool(const(char)* s)
+    extern (D) static Identifier idPool(const(char)[] s)
     {
-        return idPool(s, strlen(s));
+        return idPool(s.ptr, s.length);
     }
 
     static Identifier idPool(const(char)* s, size_t len)
@@ -153,8 +152,8 @@ public:
         idx = 0;
         while (p[idx])
         {
-            dchar_t dc;
-            const(char)* q = utf_decodeChar(cast(char*)p, len, &idx, &dc);
+            dchar dc;
+            const q = utf_decodeChar(p, len, idx, dc);
             if (q)
                 goto Linvalid;
             if (!((dc >= 0x80 && isUniAlpha(dc)) || isalnum(dc) || dc == '_'))
diff --git a/ddmd/identifier.h b/ddmd/identifier.h
index 7e90211bed..60d88edf86 100644
--- a/ddmd/identifier.h
+++ b/ddmd/identifier.h
@@ -38,7 +38,6 @@ public:
     static StringTable stringtable;
     static Identifier *generateId(const char *prefix);
     static Identifier *generateId(const char *prefix, size_t i);
-    static Identifier *idPool(const char *s);
     static Identifier *idPool(const char *s, size_t len);
     static bool isValidIdentifier(const char *p);
     static Identifier *lookup(const char *s, size_t len);
diff --git a/ddmd/idgen.d b/ddmd/idgen.d
index 8eb2b1e381..62323d977d 100644
--- a/ddmd/idgen.d
+++ b/ddmd/idgen.d
@@ -87,6 +87,7 @@ Msgtable[] msgtable =
     { "__c_long" },
     { "__c_ulong" },
     { "__c_long_double" },
+    { "cpp_type_info_ptr", "__cpp_type_info_ptr" },
 
     { "TypeInfo" },
     { "TypeInfo_Class" },
diff --git a/ddmd/init.d b/ddmd/init.d
index 2e791ce840..4792cf2bd0 100644
--- a/ddmd/init.d
+++ b/ddmd/init.d
@@ -76,7 +76,7 @@ public:
 
     abstract Expression toExpression(Type t = null);
 
-    override final char* toChars()
+    override final const(char)* toChars()
     {
         OutBuffer buf;
         HdrGenState hgs;
@@ -533,6 +533,7 @@ public:
         case Tpointer:
             if (t.nextOf().ty != Tfunction)
                 break;
+            goto default;
         default:
             error(loc, "cannot use array to initialize %s", t.toChars());
             goto Lerr;
@@ -784,20 +785,14 @@ public:
                 se.error("cannot infer type from %s %s", se.sds.kind(), se.toChars());
             return new ErrorInitializer();
         }
+
         // Give error for overloaded function addresses
-        if (exp.op == TOKsymoff)
+        bool hasOverloads;
+        if (auto f = isFuncAddress(exp, &hasOverloads))
         {
-            SymOffExp se = cast(SymOffExp)exp;
-            if (se.hasOverloads && !se.var.isFuncDeclaration().isUnique())
-            {
-                exp.error("cannot infer type from overloaded function symbol %s", exp.toChars());
+            if (f.checkForwardRef(loc))
                 return new ErrorInitializer();
-            }
-        }
-        if (exp.op == TOKdelegate)
-        {
-            DelegateExp se = cast(DelegateExp)exp;
-            if (se.hasOverloads && se.func.isFuncDeclaration() && !se.func.isFuncDeclaration().isUnique())
+            if (hasOverloads && !f.isUnique())
             {
                 exp.error("cannot infer type from overloaded function symbol %s", exp.toChars());
                 return new ErrorInitializer();
diff --git a/ddmd/inline.d b/ddmd/inline.d
index bd717bdbfa..e24a84b8ec 100644
--- a/ddmd/inline.d
+++ b/ddmd/inline.d
@@ -35,8 +35,10 @@ import ddmd.tokens;
 import ddmd.visitor;
 
 private:
+
 enum LOG = false;
 enum CANINLINE_LOG = false;
+enum EXPANDINLINE_LOG = false;
 
 /* ========== Compute cost of inlining =============== */
 
@@ -45,11 +47,11 @@ enum CANINLINE_LOG = false;
  */
 enum COST_MAX = 250;
 enum STATEMENT_COST = 0x1000;
-enum STATEMENT_COST_MAX = 250 * 0x1000;
+enum STATEMENT_COST_MAX = 250 * STATEMENT_COST;
 
 // STATEMENT_COST be power of 2 and greater than COST_MAX
-//static assert((STATEMENT_COST & (STATEMENT_COST - 1)) == 0);
-//static assert(STATEMENT_COST > COST_MAX);
+static assert((STATEMENT_COST & (STATEMENT_COST - 1)) == 0);
+static assert(STATEMENT_COST > COST_MAX);
 
 bool tooCostly(int cost)
 {
@@ -736,7 +738,7 @@ Expression doInline(Expression e, InlineDoState ids)
                 return null;
             auto newa = new Expressions();
             newa.setDim(a.dim);
-            foreach (i;  0 .. a.dim)
+            foreach (i; 0 .. a.dim)
             {
                 Expression e = (*a)[i];
                 if (e)
@@ -1200,36 +1202,59 @@ public:
         {
             printf("ExpStatement.inlineScan(%s)\n", s.toChars());
         }
-        if (s.exp)
+        if (!s.exp)
+            return;
+
+        Statement inlineScanExpAsStatement(ref Expression exp)
         {
-            /* TODO: It's a problematic inlineScan call. If s.exp is a TOKcall,
-             * CallExp.inlineScan would try to expand the call as expression.
-             * If it's impossible, a false "cannot inline function" error
-             * would be reported.
-             */
-            inlineScan(s.exp); // inline as an expression
-
-            /* If there's a TOKcall at the top, then it failed to inline
+            /* If there's a TOKcall at the top, then it may fail to inline
              * as an Expression. Try to inline as a Statement instead.
-             * Note that inline scanning of s.exp.e1 and s.exp.arguments was already done.
              */
-            if (s.exp && s.exp.op == TOKcall)
+            if (exp.op == TOKcall)
             {
-                CallExp ce = cast(CallExp)s.exp;
-
-                /* Workaround for Bugzilla 15296.
-                 *
-                 * Before the PR#5121, here was inlined a function call only
-                 * when ce.e1.op == TOKvar.
-                 * After the PR, visitCallExp has started to handle TOKdotvar
-                 * and TOKstar. However it was not good for the issue case.
-                 *
-                 * Revive a restriction which was in previous code to avoid regression.
-                 */
-                if (ce.e1.op == TOKvar)
-                    visitCallExp(ce, null, true);
+                visitCallExp(cast(CallExp)exp, null, true);
+                if (eresult)
+                    exp = eresult;
+                auto s = sresult;
+                sresult = null;
+                eresult = null;
+                return s;
             }
+
+            /* If there's a CondExp or CommaExp at the top, then its
+             * sub-expressions may be inlined as statements.
+             */
+            if (exp.op == TOKquestion)
+            {
+                auto e = cast(CondExp)exp;
+                inlineScan(e.econd);
+                auto s1 = inlineScanExpAsStatement(e.e1);
+                auto s2 = inlineScanExpAsStatement(e.e2);
+                if (!s1 && !s2)
+                    return null;
+                auto ifbody   = !s1 ? new ExpStatement(e.e1.loc, e.e1) : s1;
+                auto elsebody = !s2 ? new ExpStatement(e.e2.loc, e.e2) : s2;
+                return new IfStatement(exp.loc, null, e.econd, ifbody, elsebody);
+            }
+            if (exp.op == TOKcomma)
+            {
+                auto e = cast(CommaExp)exp;
+                auto s1 = inlineScanExpAsStatement(e.e1);
+                auto s2 = inlineScanExpAsStatement(e.e2);
+                if (!s1 && !s2)
+                    return null;
+                auto a = new Statements();
+                a.push(!s1 ? new ExpStatement(e.e1.loc, e.e1) : s1);
+                a.push(!s2 ? new ExpStatement(e.e2.loc, e.e2) : s2);
+                return new CompoundStatement(exp.loc, a);
+            }
+
+            // inline as an expression
+            inlineScan(exp);
+            return null;
         }
+
+        sresult = inlineScanExpAsStatement(s.exp);
     }
 
     override void visit(CompoundStatement s)
@@ -1483,8 +1508,7 @@ public:
                      */
                     inlineScan(e.e1);
                 }
-                inlineScan(ce.e1);
-                arrayInlineScan(ce.arguments);
+
                 visitCallExp(ce, e.e1, false);
                 if (eresult)
                 {
@@ -1500,8 +1524,6 @@ public:
     override void visit(CallExp e)
     {
         //printf("CallExp.inlineScan() %s\n", e.toChars());
-        inlineScan(e.e1);
-        arrayInlineScan(e.arguments);
         visitCallExp(e, null, false);
     }
 
@@ -1512,18 +1534,23 @@ public:
      *  e = the function call
      *  eret = if !null, then this is the lvalue of the nrvo function result
      *  asStatements = if inline as statements rather than as an Expression
+     * Returns:
+     *  this.eresult if asStatements == false
+     *  this.sresult if asStatements == true
      */
     void visitCallExp(CallExp e, Expression eret, bool asStatements)
     {
-        //printf("visitCallExp() %s\n", e.toChars());
+        inlineScan(e.e1);
+        arrayInlineScan(e.arguments);
 
+        //printf("visitCallExp() %s\n", e.toChars());
         FuncDeclaration fd;
 
         void inlineFd()
         {
             if (fd && fd != parent && canInline(fd, false, false, asStatements))
             {
-                expandInline(fd, parent, eret, null, e.arguments, asStatements, eresult, sresult, again);
+                expandInline(e.loc, fd, parent, eret, null, e.arguments, asStatements, eresult, sresult, again);
             }
         }
 
@@ -1586,7 +1613,7 @@ public:
                 }
                 else
                 {
-                    expandInline(fd, parent, eret, dve.e1, e.arguments, asStatements, eresult, sresult, again);
+                    expandInline(e.loc, fd, parent, eret, dve.e1, e.arguments, asStatements, eresult, sresult, again);
                 }
             }
         }
@@ -2017,6 +2044,7 @@ public void inlineScanModule(Module m)
  *      ethis.fd(arguments)
  *
  * Params:
+ *      callLoc = location of CallExp
  *      fd = function to expand
  *      parent = function that the call to fd is being expanded into
  *      eret = expression describing the lvalue of where the return value goes
@@ -2027,120 +2055,128 @@ public void inlineScanModule(Module m)
  *      sresult = if expanding to a statement, this is where the statement is written to
  *      again = if true, then fd can be inline scanned again because there may be
  *           more opportunities for inlining
- * Returns:
- *      Expression it expanded to (null if ps is not null)
  */
-void expandInline(FuncDeclaration fd, FuncDeclaration parent, Expression eret,
+void expandInline(Loc callLoc, FuncDeclaration fd, FuncDeclaration parent, Expression eret,
         Expression ethis, Expressions* arguments, bool asStatements,
         out Expression eresult, out Statement sresult, out bool again)
 {
-    Expression e = null;
-    Statements* as = null;
     TypeFunction tf = cast(TypeFunction)fd.type;
-    static if (LOG || CANINLINE_LOG)
-    {
+    static if (LOG || CANINLINE_LOG || EXPANDINLINE_LOG)
         printf("FuncDeclaration.expandInline('%s')\n", fd.toChars());
+    static if (EXPANDINLINE_LOG)
+    {
+        if (eret) printf("\teret = %s\n", eret.toChars());
+        if (ethis) printf("\tethis = %s\n", ethis.toChars());
     }
     scope ids = new InlineDoState(parent, fd);
 
-    if (asStatements)
-        as = new Statements();
-
-    VarDeclaration vret = null;
+    VarDeclaration vret;    // will be set the function call result
     if (eret)
     {
         if (eret.op == TOKvar)
         {
             vret = (cast(VarExp)eret).var.isVarDeclaration();
             assert(!(vret.storage_class & (STCout | STCref)));
+            eret = null;
         }
         else
         {
             /* Inlining:
              *   this.field = foo();   // inside constructor
              */
-            vret = new VarDeclaration(fd.loc, eret.type, Identifier.generateId("_satmp"), null);
+            auto ei = new ExpInitializer(callLoc, null);
+            auto tmp = Identifier.generateId("__retvar");
+            vret = new VarDeclaration(fd.loc, eret.type, tmp, ei);
             vret.storage_class |= STCtemp | STCforeach | STCref;
             vret.linkage = LINKd;
             vret.parent = parent;
 
-            Expression de = new DeclarationExp(fd.loc, vret);
-            de.type = Type.tvoid;
-            e = Expression.combine(e, de);
+            ei.exp = new ConstructExp(fd.loc, vret, eret);
+            ei.exp.type = vret.type;
 
-            Expression ex = new ConstructExp(fd.loc, vret, eret);
-            ex.type = vret.type;
-            e = Expression.combine(e, ex);
+            auto de = new DeclarationExp(fd.loc, vret);
+            de.type = Type.tvoid;
+            eret = de;
+        }
+
+        if (!asStatements && fd.nrvo_var)
+        {
+            ids.from.push(fd.nrvo_var);
+            ids.to.push(vret);
+        }
+    }
+    else
+    {
+        if (!asStatements && fd.nrvo_var)
+        {
+            auto tmp = Identifier.generateId("__retvar");
+            vret = new VarDeclaration(fd.loc, fd.nrvo_var.type, tmp, new VoidInitializer(fd.loc));
+            assert(!tf.isref);
+            vret.storage_class = STCtemp | STCrvalue;
+            vret.linkage = tf.linkage;
+            vret.parent = parent;
+
+            auto de = new DeclarationExp(fd.loc, vret);
+            de.type = Type.tvoid;
+            eret = de;
+
+            ids.from.push(fd.nrvo_var);
+            ids.to.push(vret);
         }
     }
 
     // Set up vthis
+    VarDeclaration vthis;
     if (ethis)
     {
-        if (ethis.type.ty == Tpointer)
+        Expression e0;
+        ethis = Expression.extractLast(ethis, &e0);
+        if (ethis.op == TOKvar)
         {
-            Type t = ethis.type.nextOf();
-            ethis = new PtrExp(ethis.loc, ethis);
-            ethis.type = t;
+            vthis = (cast(VarExp)ethis).var.isVarDeclaration();
         }
-        auto ei = new ExpInitializer(ethis.loc, ethis);
-
-        auto vthis = new VarDeclaration(ethis.loc, ethis.type, Id.This, ei);
-        if (ethis.type.ty != Tclass)
-            vthis.storage_class = STCref;
         else
-            vthis.storage_class = STCin;
-        vthis.linkage = LINKd;
-        vthis.parent = parent;
+        {
+            //assert(ethis.type.ty != Tpointer);
+            if (ethis.type.ty == Tpointer)
+            {
+                Type t = ethis.type.nextOf();
+                ethis = new PtrExp(ethis.loc, ethis);
+                ethis.type = t;
+            }
 
-        ei.exp = new ConstructExp(vthis.loc, vthis, ethis);
-        ei.exp.type = vthis.type;
+            auto ei = new ExpInitializer(fd.loc, ethis);
+            vthis = new VarDeclaration(fd.loc, ethis.type, Id.This, ei);
+            if (ethis.type.ty != Tclass)
+                vthis.storage_class = STCref;
+            else
+                vthis.storage_class = STCin;
+            vthis.linkage = LINKd;
+            vthis.parent = parent;
+
+            ei.exp = new ConstructExp(fd.loc, vthis, ethis);
+            ei.exp.type = vthis.type;
+
+            auto de = new DeclarationExp(fd.loc, vthis);
+            de.type = Type.tvoid;
+            e0 = Expression.combine(e0, de);
+        }
+        ethis = e0;
 
         ids.vthis = vthis;
     }
 
     // Set up parameters
-    if (ethis)
-    {
-        Expression de = new DeclarationExp(Loc(), ids.vthis);
-        de.type = Type.tvoid;
-        e = Expression.combine(e, de);
-    }
-
-    if (!asStatements && fd.nrvo_var)
-    {
-        if (vret)
-        {
-            ids.from.push(fd.nrvo_var);
-            ids.to.push(vret);
-        }
-        else
-        {
-            Identifier tmp = Identifier.generateId("__nrvoretval");
-            auto vd = new VarDeclaration(fd.loc, fd.nrvo_var.type, tmp, new VoidInitializer(fd.loc));
-            assert(!tf.isref);
-            vd.storage_class = STCtemp | STCrvalue;
-            vd.linkage = tf.linkage;
-            vd.parent = parent;
-
-            ids.from.push(fd.nrvo_var);
-            ids.to.push(vd);
-
-            Expression de = new DeclarationExp(Loc(), vd);
-            de.type = Type.tvoid;
-            e = Expression.combine(e, de);
-        }
-    }
+    Expression eparams;
     if (arguments && arguments.dim)
     {
         assert(fd.parameters.dim == arguments.dim);
         foreach (i; 0 .. arguments.dim)
         {
             auto vfrom = (*fd.parameters)[i];
-
             auto arg = (*arguments)[i];
-            auto ei = new ExpInitializer(arg.loc, arg);
 
+            auto ei = new ExpInitializer(vfrom.loc, arg);
             auto vto = new VarDeclaration(vfrom.loc, vfrom.type, vfrom.ident, ei);
             vto.storage_class |= vfrom.storage_class & (STCtemp | STCin | STCout | STClazy | STCref);
             vto.linkage = vfrom.linkage;
@@ -2157,9 +2193,9 @@ void expandInline(FuncDeclaration fd, FuncDeclaration parent, Expression eret,
             ids.from.push(vfrom);
             ids.to.push(vto);
 
-            auto de = new DeclarationExp(Loc(), vto);
+            auto de = new DeclarationExp(vto.loc, vto);
             de.type = Type.tvoid;
-            e = Expression.combine(e, de);
+            eparams = Expression.combine(eparams, de);
 
             /* If function pointer or delegate parameters are present,
              * inline scan again because if they are initialized to a symbol,
@@ -2188,26 +2224,62 @@ void expandInline(FuncDeclaration fd, FuncDeclaration parent, Expression eret,
 
     if (asStatements)
     {
-        if (e)
+        /* Construct:
+         *  { eret; ethis; eparams; fd.fbody; }
+         * or:
+         *  { eret; ethis; try { eparams; fd.fbody; } finally { vthis.edtor; } }
+         */
+
+        auto as = new Statements();
+        if (eret)
+            as.push(new ExpStatement(callLoc, eret));
+        if (ethis)
+            as.push(new ExpStatement(callLoc, ethis));
+
+        auto as2 = as;
+        if (vthis && !vthis.isDataseg())
         {
-            as.push(new ExpStatement(Loc(), e));
-            e = null;
+            if (vthis.needsScopeDtor())
+            {
+                // same with ExpStatement.scopeCode()
+                as2 = new Statements();
+                vthis.noscope = 1;
+            }
         }
+
+        if (eparams)
+            as2.push(new ExpStatement(callLoc, eparams));
+
         fd.inlineNest++;
         Statement s = inlineAsStatement(fd.fbody, ids);
-        as.push(s);
-        sresult = new ScopeStatement(Loc(), new CompoundStatement(Loc(), as));
         fd.inlineNest--;
+        as2.push(s);
+
+        if (as2 != as)
+        {
+            as.push(new TryFinallyStatement(callLoc,
+                        new CompoundStatement(callLoc, as2),
+                        new DtorExpStatement(callLoc, vthis.edtor, vthis)));
+        }
+
+        sresult = new ScopeStatement(callLoc, new CompoundStatement(callLoc, as));
+
+        static if (EXPANDINLINE_LOG)
+            printf("\n[%s] %s expandInline sresult =\n%s\n",
+                callLoc.toChars(), fd.toPrettyChars(), sresult.toChars());
     }
     else
     {
+        /* Construct:
+         *  (eret, ethis, eparams, fd.fbody)
+         */
+
         fd.inlineNest++;
-        Expression eb = doInline(fd.fbody, ids);
-        e = Expression.combine(e, eb);
+        auto e = doInline(fd.fbody, ids);
         fd.inlineNest--;
-        //eb.type.print();
-        //eb.print();
-        //eb.print();
+        //e.type.print();
+        //e.print();
+        //e.print();
 
         // Bugzilla 11322:
         if (tf.isref)
@@ -2232,23 +2304,22 @@ void expandInline(FuncDeclaration fd, FuncDeclaration parent, Expression eret,
              * inlined body of the function:
              *   tret __inlineretval = e;
              */
-            auto ei = new ExpInitializer(fd.loc, e);
-
-            Identifier tmp = Identifier.generateId("__inlineretval");
-            auto vd = new VarDeclaration(fd.loc, tf.next, tmp, ei);
+            auto ei = new ExpInitializer(callLoc, e);
+            auto tmp = Identifier.generateId("__inlineretval");
+            auto vd = new VarDeclaration(callLoc, tf.next, tmp, ei);
             vd.storage_class = (tf.isref ? STCref : 0) | STCtemp | STCrvalue;
             vd.linkage = tf.linkage;
             vd.parent = parent;
 
-            ei.exp = new ConstructExp(fd.loc, vd, e);
+            ei.exp = new ConstructExp(callLoc, vd, e);
             ei.exp.type = vd.type;
 
-            auto de = new DeclarationExp(Loc(), vd);
+            auto de = new DeclarationExp(callLoc, vd);
             de.type = Type.tvoid;
 
             // Chain the two together:
             //   ( typeof(return) __inlineretval = ( inlined body )) , __inlineretval
-            e = Expression.combine(de, new VarExp(fd.loc, vd));
+            e = Expression.combine(de, new VarExp(callLoc, vd));
 
             //fprintf(stderr, "CallExp.inlineScan: e = "); e.print();
         }
@@ -2256,13 +2327,19 @@ void expandInline(FuncDeclaration fd, FuncDeclaration parent, Expression eret,
         // Bugzilla 15210
         if (tf.next.ty == Tvoid && e && e.type.ty != Tvoid)
         {
-            e = new CastExp(e.loc, e, Type.tvoid);
+            e = new CastExp(callLoc, e, Type.tvoid);
             e.type = Type.tvoid;
         }
 
-        eresult = e;
+        eresult = Expression.combine(eresult, eret);
+        eresult = Expression.combine(eresult, ethis);
+        eresult = Expression.combine(eresult, eparams);
+        eresult = Expression.combine(eresult, e);
+
+        static if (EXPANDINLINE_LOG)
+            printf("\n[%s] %s expandInline eresult = %s\n",
+                callLoc.toChars(), fd.toPrettyChars(), eresult.toChars());
     }
-    //printf("[%s] %s expandInline = { %s }\n", fd.loc.toChars(), fd.toPrettyChars(), e.toChars());
 
     // Need to reevaluate whether parent can now be inlined
     // in expressions, as we might have inlined statements
diff --git a/ddmd/json.d b/ddmd/json.d
index 123fb85c78..02a1bd4426 100644
--- a/ddmd/json.d
+++ b/ddmd/json.d
@@ -410,7 +410,7 @@ public:
             if (em.origValue)
                 property("value", em.origValue.toChars());
         }
-        property("comment", cast(const(char)*)s.comment);
+        property("comment", s.comment);
         property("line", "char", &s.loc);
     }
 
@@ -459,7 +459,7 @@ public:
         property("kind", s.kind());
         filename = s.srcfile.toChars();
         property("file", filename);
-        property("comment", cast(const(char)*)s.comment);
+        property("comment", s.comment);
         propertyStart("members");
         arrayStart();
         for (size_t i = 0; i < s.members.dim; i++)
@@ -490,7 +490,7 @@ public:
         stringEnd();
         comma();
         property("kind", s.kind());
-        property("comment", cast(const(char)*)s.comment);
+        property("comment", s.comment);
         property("line", "char", &s.loc);
         if (s.prot().kind != PROTpublic)
             property("protection", protectionToChars(s.prot().kind));
@@ -586,13 +586,12 @@ public:
             {
                 property("base", cd.baseClass.toPrettyChars(true));
             }
-            if (cd.interfaces_dim)
+            if (cd.interfaces.length)
             {
                 propertyStart("interfaces");
                 arrayStart();
-                for (size_t i = 0; i < cd.interfaces_dim; i++)
+                foreach (b; cd.interfaces)
                 {
-                    BaseClass* b = cd.interfaces[i];
                     item(b.sym.toPrettyChars(true));
                 }
                 arrayEnd();
diff --git a/ddmd/lexer.d b/ddmd/lexer.d
index 7b547c1d9e..fa8126f779 100644
--- a/ddmd/lexer.d
+++ b/ddmd/lexer.d
@@ -258,7 +258,7 @@ public:
      */
     final void scan(Token* t)
     {
-        uint lastLine = scanloc.linnum;
+        const lastLine = scanloc.linnum;
         Loc startLoc;
         t.blockComment = null;
         t.lineComment = null;
@@ -327,6 +327,7 @@ public:
                 if (p[1] != '"')
                     goto case_ident;
                 p++;
+                goto case '`';
             case '`':
                 t.value = wysiwygStringConstant(t, *p);
                 return;
@@ -408,16 +409,15 @@ public:
             case '_':
             case_ident:
                 {
-                    char c;
                     while (1)
                     {
-                        c = *++p;
+                        const c = *++p;
                         if (isidchar(c))
                             continue;
                         else if (c & 0x80)
                         {
-                            const(char)* s = p;
-                            uint u = decodeUTF();
+                            const s = p;
+                            const u = decodeUTF();
                             if (isUniAlpha(u))
                                 continue;
                             error("char 0x%04x not allowed in identifier", u);
@@ -440,7 +440,7 @@ public:
                             initdone = true;
                             time_t ct;
                             .time(&ct);
-                            char* p = ctime(&ct);
+                            const p = ctime(&ct);
                             assert(p);
                             sprintf(&date[0], "%.6s %.4s", p + 4, p + 20);
                             sprintf(&time[0], "%.8s", p + 11);
@@ -448,26 +448,26 @@ public:
                         }
                         if (id == Id.DATE)
                         {
-                            t.ustring = cast(char*)date;
+                            t.ustring = date.ptr;
                             goto Lstr;
                         }
                         else if (id == Id.TIME)
                         {
-                            t.ustring = cast(char*)time;
+                            t.ustring = time.ptr;
                             goto Lstr;
                         }
                         else if (id == Id.VENDOR)
                         {
-                            t.ustring = cast(char*)global.compiler.vendor;
+                            t.ustring = global.compiler.vendor;
                             goto Lstr;
                         }
                         else if (id == Id.TIMESTAMP)
                         {
-                            t.ustring = cast(char*)timestamp;
+                            t.ustring = timestamp.ptr;
                         Lstr:
                             t.value = TOKstring;
                             t.postfix = 0;
-                            t.len = cast(uint)strlen(cast(char*)t.ustring);
+                            t.len = cast(uint)strlen(t.ustring);
                         }
                         else if (id == Id.VERSIONX)
                         {
@@ -476,7 +476,7 @@ public:
                             bool point = false;
                             for (const(char)* p = global._version + 1; 1; p++)
                             {
-                                c = *p;
+                                const c = *p;
                                 if (isdigit(cast(char)c))
                                     minor = minor * 10 + c - '0';
                                 else if (c == '.')
@@ -520,7 +520,7 @@ public:
                     {
                         while (1)
                         {
-                            char c = *p;
+                            const c = *p;
                             switch (c)
                             {
                             case '/':
@@ -544,7 +544,7 @@ public:
                             default:
                                 if (c & 0x80)
                                 {
-                                    uint u = decodeUTF();
+                                    const u = decodeUTF();
                                     if (u == PS || u == LS)
                                         endOfLine();
                                 }
@@ -574,7 +574,7 @@ public:
                     startLoc = loc();
                     while (1)
                     {
-                        char c = *++p;
+                        const c = *++p;
                         switch (c)
                         {
                         case '\n':
@@ -601,7 +601,7 @@ public:
                         default:
                             if (c & 0x80)
                             {
-                                uint u = decodeUTF();
+                                const u = decodeUTF();
                                 if (u == PS || u == LS)
                                     break;
                             }
@@ -1021,7 +1021,7 @@ public:
                 }
             default:
                 {
-                    uint c = *p;
+                    dchar c = *p;
                     if (c & 0x80)
                     {
                         c = decodeUTF();
@@ -1110,7 +1110,6 @@ public:
     final uint escapeSequence()
     {
         uint c = *p;
-        int n;
         int ndigits;
         switch (c)
         {
@@ -1155,9 +1154,8 @@ public:
             c = *p;
             if (ishex(cast(char)c))
             {
-                uint v;
-                n = 0;
-                v = 0;
+                uint v = 0;
+                int n = 0;
                 while (1)
                 {
                     if (isdigit(cast(char)c))
@@ -1188,7 +1186,7 @@ public:
             break;
         case '&':
             // named character entity
-            for (const(char)* idstart = ++p; 1; p++)
+            for (const idstart = ++p; 1; p++)
             {
                 switch (*p)
                 {
@@ -1218,9 +1216,8 @@ public:
         default:
             if (isoctal(cast(char)c))
             {
-                uint v;
-                n = 0;
-                v = 0;
+                uint v = 0;
+                int n = 0;
                 do
                 {
                     v = v * 8 + (c - '0');
@@ -1242,13 +1239,12 @@ public:
      */
     final TOK wysiwygStringConstant(Token* t, int tc)
     {
-        uint c;
         Loc start = loc();
         p++;
         stringbuffer.reset();
         while (1)
         {
-            c = *p++;
+            dchar c = *p++;
             switch (c)
             {
             case '\n':
@@ -1264,18 +1260,13 @@ public:
             case 0:
             case 0x1A:
                 error("unterminated string constant starting at %s", start.toChars());
-                t.ustring = cast(char*)"";
-                t.len = 0;
-                t.postfix = 0;
+                t.setString();
                 return TOKstring;
             case '"':
             case '`':
                 if (c == tc)
                 {
-                    t.len = cast(uint)stringbuffer.offset;
-                    stringbuffer.writeByte(0);
-                    t.ustring = cast(char*)mem.xmalloc(stringbuffer.offset);
-                    memcpy(t.ustring, stringbuffer.data, stringbuffer.offset);
+                    t.setString(stringbuffer);
                     stringPostfix(t);
                     return TOKstring;
                 }
@@ -1284,7 +1275,7 @@ public:
                 if (c & 0x80)
                 {
                     p--;
-                    uint u = decodeUTF();
+                    const u = decodeUTF();
                     p++;
                     if (u == PS || u == LS)
                         endOfLine();
@@ -1303,7 +1294,6 @@ public:
      */
     final TOK hexStringConstant(Token* t)
     {
-        uint c;
         Loc start = loc();
         uint n = 0;
         uint v = ~0; // dead assignment, needed to suppress warning
@@ -1311,29 +1301,26 @@ public:
         stringbuffer.reset();
         while (1)
         {
-            c = *p++;
+            dchar c = *p++;
             switch (c)
             {
             case ' ':
             case '\t':
             case '\v':
             case '\f':
-                continue;
-                // skip white space
+                continue; // skip white space
             case '\r':
                 if (*p == '\n')
-                    continue;
-                // ignore
+                    continue; // ignore '\r' if followed by '\n'
                 // Treat isolated '\r' as if it were a '\n'
+                goto case '\n';
             case '\n':
                 endOfLine();
                 continue;
             case 0:
             case 0x1A:
                 error("unterminated string constant starting at %s", start.toChars());
-                t.ustring = cast(char*)"";
-                t.len = 0;
-                t.postfix = 0;
+                t.setString();
                 return TOKxstring;
             case '"':
                 if (n & 1)
@@ -1341,10 +1328,7 @@ public:
                     error("odd number (%d) of hex characters in hex string", n);
                     stringbuffer.writeByte(v);
                 }
-                t.len = cast(uint)stringbuffer.offset;
-                stringbuffer.writeByte(0);
-                t.ustring = cast(char*)mem.xmalloc(stringbuffer.offset);
-                memcpy(t.ustring, stringbuffer.data, stringbuffer.offset);
+                t.setString(stringbuffer);
                 stringPostfix(t);
                 return TOKxstring;
             default:
@@ -1357,7 +1341,7 @@ public:
                 else if (c & 0x80)
                 {
                     p--;
-                    uint u = decodeUTF();
+                    const u = decodeUTF();
                     p++;
                     if (u == PS || u == LS)
                         endOfLine();
@@ -1377,6 +1361,7 @@ public:
                 break;
             }
         }
+        assert(0); // see bug 15731
     }
 
     /**************************************
@@ -1392,10 +1377,9 @@ public:
      */
     final TOK delimitedStringConstant(Token* t)
     {
-        uint c;
         Loc start = loc();
-        uint delimleft = 0;
-        uint delimright = 0;
+        dchar delimleft = 0;
+        dchar delimright = 0;
         uint nest = 1;
         uint nestcount = ~0; // dead assignment, needed to suppress warning
         Identifier hereid = null;
@@ -1405,7 +1389,7 @@ public:
         stringbuffer.reset();
         while (1)
         {
-            c = *p++;
+            dchar c = *p++;
             //printf("c = '%c'\n", c);
             switch (c)
             {
@@ -1433,9 +1417,7 @@ public:
             case 0:
             case 0x1A:
                 error("unterminated delimited string constant starting at %s", start.toChars());
-                t.ustring = cast(char*)"";
-                t.len = 0;
-                t.postfix = 0;
+                t.setString();
                 return TOKstring;
             default:
                 if (c & 0x80)
@@ -1535,10 +1517,7 @@ public:
             error("delimited string must end in %s\"", hereid.toChars());
         else
             error("delimited string must end in %c\"", delimright);
-        t.len = cast(uint)stringbuffer.offset;
-        stringbuffer.writeByte(0);
-        t.ustring = cast(char*)mem.xmalloc(stringbuffer.offset);
-        memcpy(t.ustring, stringbuffer.data, stringbuffer.offset);
+        t.setString(stringbuffer);
         stringPostfix(t);
         return TOKstring;
     }
@@ -1554,8 +1533,8 @@ public:
     final TOK tokenStringConstant(Token* t)
     {
         uint nest = 1;
-        Loc start = loc();
-        const(char)* pstart = ++p;
+        const start = loc();
+        const pstart = ++p;
         while (1)
         {
             Token tok;
@@ -1568,19 +1547,14 @@ public:
             case TOKrcurly:
                 if (--nest == 0)
                 {
-                    t.len = cast(uint)(p - 1 - pstart);
-                    t.ustring = cast(char*)mem.xmalloc(t.len + 1);
-                    memcpy(t.ustring, pstart, t.len);
-                    t.ustring[t.len] = 0;
+                    t.setString(pstart, p - 1 - pstart);
                     stringPostfix(t);
                     return TOKstring;
                 }
                 continue;
             case TOKeof:
                 error("unterminated token string constant starting at %s", start.toChars());
-                t.ustring = cast(char*)"";
-                t.len = 0;
-                t.postfix = 0;
+                t.setString();
                 return TOKstring;
             default:
                 continue;
@@ -1592,13 +1566,12 @@ public:
      */
     final TOK escapeStringConstant(Token* t, int wide)
     {
-        uint c;
-        Loc start = loc();
+        const start = loc();
         p++;
         stringbuffer.reset();
         while (1)
         {
-            c = *p++;
+            dchar c = *p++;
             switch (c)
             {
             case '\\':
@@ -1626,19 +1599,14 @@ public:
                 endOfLine();
                 break;
             case '"':
-                t.len = cast(uint)stringbuffer.offset;
-                stringbuffer.writeByte(0);
-                t.ustring = cast(char*)mem.xmalloc(stringbuffer.offset);
-                memcpy(t.ustring, stringbuffer.data, stringbuffer.offset);
+                t.setString(stringbuffer);
                 stringPostfix(t);
                 return TOKstring;
             case 0:
             case 0x1A:
                 p--;
                 error("unterminated string constant starting at %s", start.toChars());
-                t.ustring = cast(char*)"";
-                t.len = 0;
-                t.postfix = 0;
+                t.setString();
                 return TOKstring;
             default:
                 if (c & 0x80)
@@ -1664,11 +1632,10 @@ public:
      */
     final TOK charConstant(Token* t)
     {
-        uint c;
-        TOK tk = TOKcharv;
+        auto tk = TOKcharv;
         //printf("Lexer::charConstant\n");
         p++;
-        c = *p++;
+        dchar c = *p++;
         switch (c)
         {
         case '\\':
@@ -1691,6 +1658,7 @@ public:
         case '\n':
         L1:
             endOfLine();
+            goto case;
         case '\r':
         case 0:
         case 0x1A:
@@ -1756,13 +1724,12 @@ public:
     final TOK number(Token* t)
     {
         int base = 10;
-        const(char)* start = p;
-        uint c;
+        const start = p;
         uinteger_t n = 0; // unsigned >=64 bit integer type
         int d;
         bool err = false;
         bool overflow = false;
-        c = *p;
+        dchar c = *p;
         if (c == '0')
         {
             ++p;
@@ -1908,7 +1875,8 @@ public:
                 n = n * base + d;
             else
             {
-                import core.checkedint;
+                import core.checkedint : mulu, addu;
+
                 n = mulu(n, base, overflow);
                 n = addu(n, d, overflow);
             }
@@ -1934,10 +1902,10 @@ public:
 
         FLAGS flags = (base == 10) ? FLAGS_decimal : FLAGS_none;
         // Parse trailing 'u', 'U', 'l' or 'L' in any combination
-        const(char)* psuffix = p;
+        const psuffix = p;
         while (1)
         {
-            char f;
+            FLAGS f;
             switch (*p)
             {
             case 'U':
@@ -2056,9 +2024,9 @@ public:
             assert(*p == '.' || isdigit(*p));
         }
         stringbuffer.reset();
-        const(char)* pstart = p;
-        char hex = 0;
-        uint c = *p++;
+        auto pstart = p;
+        bool hex = false;
+        dchar c = *p++;
         // Leading '0x'
         if (c == '0')
         {
@@ -2130,15 +2098,16 @@ public:
             ++pstart;
         }
         stringbuffer.writeByte(0);
+        auto sbufptr = cast(const(char)*)stringbuffer.data;
         TOK result;
-        t.float80value = Port.strtold(cast(char*)stringbuffer.data, null);
+        t.float80value = Port.strtold(sbufptr, null);
         errno = 0;
         switch (*p)
         {
         case 'F':
         case 'f':
             // Only interested in errno return
-            cast(void)Port.strtof(cast(char*)stringbuffer.data, null);
+            cast(void)Port.strtof(sbufptr, null);
             result = TOKfloat32v;
             p++;
             break;
@@ -2148,11 +2117,12 @@ public:
              * 2.22508e-308. Not sure who is right.
              */
             // Only interested in errno return
-            cast(void)Port.strtod(cast(char*)stringbuffer.data, null);
+            cast(void)Port.strtod(sbufptr, null);
             result = TOKfloat64v;
             break;
         case 'l':
             error("use 'L' suffix instead of 'l'");
+            goto case 'L';
         case 'L':
             result = TOKfloat80v;
             p++;
@@ -2180,8 +2150,8 @@ public:
         }
         if (errno == ERANGE)
         {
-            const(char)* suffix = (result == TOKfloat32v || result == TOKimaginary32v) ? "f" : "";
-            error(scanloc, "number '%s%s' is not representable", cast(char*)stringbuffer.data, suffix);
+            const char* suffix = (result == TOKfloat32v || result == TOKimaginary32v) ? "f" : "";
+            error(scanloc, "number '%s%s' is not representable", sbufptr, suffix);
         }
         debug
         {
@@ -2242,14 +2212,14 @@ public:
      */
     final void poundLine()
     {
+        auto linnum = this.scanloc.linnum;
+        const(char)* filespec = null;
+        const loc = this.loc();
         Token tok;
-        int linnum = this.scanloc.linnum;
-        char* filespec = null;
-        Loc loc = this.loc();
         scan(&tok);
         if (tok.value == TOKint32v || tok.value == TOKint64v)
         {
-            int lin = cast(int)(tok.uns64value - 1);
+            const lin = cast(int)(tok.uns64value - 1);
             if (lin != tok.uns64value - 1)
                 error("line number %lld out of range", cast(ulong)tok.uns64value);
             else
@@ -2288,7 +2258,7 @@ public:
                 continue;
                 // skip white space
             case '_':
-                if (memcmp(p, cast(char*)"__FILE__", 8) == 0)
+                if (memcmp(p, "__FILE__".ptr, 8) == 0)
                 {
                     p += 8;
                     filespec = mem.xstrdup(scanloc.filename);
@@ -2313,7 +2283,7 @@ public:
                         goto Lerr;
                     case '"':
                         stringbuffer.writeByte(0);
-                        filespec = mem.xstrdup(cast(char*)stringbuffer.data);
+                        filespec = mem.xstrdup(cast(const(char)*)stringbuffer.data);
                         p++;
                         break;
                     default:
@@ -2351,20 +2321,16 @@ public:
      */
     final uint decodeUTF()
     {
-        dchar_t u;
-        char c;
-        const(char)* s = p;
-        size_t len;
-        size_t idx;
-        const(char)* msg;
-        c = *s;
-        assert(c & 0x80);
+        const s = p;
+        assert(*s & 0x80);
         // Check length of remaining string up to 6 UTF-8 characters
+        size_t len;
         for (len = 1; len < 6 && s[len]; len++)
         {
         }
-        idx = 0;
-        msg = utf_decodeChar(s, len, &idx, &u);
+        size_t idx = 0;
+        dchar u;
+        const msg = utf_decodeChar(s, len, idx, u);
         p += idx - 1;
         if (msg)
         {
@@ -2385,7 +2351,7 @@ public:
     {
         /* ct tells us which kind of comment it is: '/', '*', or '+'
          */
-        char ct = t.ptr[2];
+        const ct = t.ptr[2];
         /* Start of comment text skips over / * *, / + +, or / / /
          */
         const(char)* q = t.ptr + 3; // start of comment text
@@ -2475,6 +2441,7 @@ public:
                 break;
             Lnewline:
                 c = '\n'; // replace all newlines with \n
+                goto case;
             case '\n':
                 linestart = 1;
                 /* Trim trailing whitespace
@@ -2501,9 +2468,9 @@ public:
         const(char)** dc = (lineComment && anyToken) ? &t.lineComment : &t.blockComment;
         // Combine with previous doc comment, if any
         if (*dc)
-            *dc = combineComments(*dc, cast(char*)buf.data);
+            *dc = combineComments(*dc, cast(const(char)*)buf.data);
         else
-            *dc = cast(char*)buf.extractData();
+            *dc = cast(const(char)*)buf.extractData();
     }
 
     /********************************************
@@ -2513,21 +2480,21 @@ public:
     final static const(char)* combineComments(const(char)* c1, const(char)* c2)
     {
         //printf("Lexer::combineComments('%s', '%s')\n", c1, c2);
-        const(char)* c = c2;
+        auto c = c2;
         if (c1)
         {
             c = c1;
             if (c2)
             {
-                size_t len1 = strlen(cast(char*)c1);
-                size_t len2 = strlen(cast(char*)c2);
+                size_t len1 = strlen(c1);
+                size_t len2 = strlen(c2);
                 int insertNewLine = 0;
                 if (len1 && c1[len1 - 1] != '\n')
                 {
                     ++len1;
                     insertNewLine = 1;
                 }
-                char* p = cast(char*)mem.xmalloc(len1 + 1 + len2 + 1);
+                auto p = cast(char*)mem.xmalloc(len1 + 1 + len2 + 1);
                 memcpy(p, c1, len1 - insertNewLine);
                 if (insertNewLine)
                     p[len1 - 1] = '\n';
diff --git a/ddmd/mars.d b/ddmd/mars.d
index d13a266647..18e2f8abdf 100644
--- a/ddmd/mars.d
+++ b/ddmd/mars.d
@@ -1,10 +1,17 @@
-// Compiler implementation of the D programming language
-// Copyright (c) 1999-2015 by Digital Mars
-// All Rights Reserved
-// written by Walter Bright
-// http://www.digitalmars.com
-// Distributed under the Boost Software License, Version 1.0.
-// http://www.boost.org/LICENSE_1_0.txt
+/**
+ * Compiler implementation of the
+ * $(LINK2 http://www.dlang.org, D programming language).
+ * Entry point for DMD.
+ *
+ * This modules defines the entry point (main) for DMD, as well as related
+ * utilities needed for arguments parsing, path manipulation, etc...
+ * This file is not shared with other compilers which use the DMD front-end.
+ *
+ * Copyright:   Copyright (c) 1999-2015 by Digital Mars, All Rights Reserved
+ * Authors:     $(LINK2 http://www.digitalmars.com, Walter Bright)
+ * License:     $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
+ * Source:      $(DMDSRC mars.d)
+ */
 
 module ddmd.mars;
 
@@ -50,7 +57,16 @@ import ddmd.target;
 import ddmd.tokens;
 import ddmd.traits;
 
-/** Normalize path by turning forward slashes into backslashes */
+
+/**
+ * Normalize path by turning forward slashes into backslashes
+ *
+ * Params:
+ *   src = Source path, using unix-style ('/') path separators
+ *
+ * Returns:
+ *   A newly-allocated string with '/' turned into backslashes
+ */
 extern (C++) const(char)* toWinPath(const(char)* src)
 {
     if (src is null)
@@ -66,6 +82,14 @@ extern (C++) const(char)* toWinPath(const(char)* src)
     return result;
 }
 
+
+/**
+ * Reads a file, terminate the program on error
+ *
+ * Params:
+ *   loc = The line number information from where the call originates
+ *   f = a `ddmd.root.file.File` handle to read
+ */
 extern (C++) void readFile(Loc loc, File* f)
 {
     if (f.read())
@@ -75,6 +99,14 @@ extern (C++) void readFile(Loc loc, File* f)
     }
 }
 
+
+/**
+ * Writes a file, terminate the program on error
+ *
+ * Params:
+ *   loc = The line number information from where the call originates
+ *   f = a `ddmd.root.file.File` handle to write
+ */
 extern (C++) void writeFile(Loc loc, File* f)
 {
     if (f.write())
@@ -84,6 +116,15 @@ extern (C++) void writeFile(Loc loc, File* f)
     }
 }
 
+
+/**
+ * Ensure the root path (the path minus the name) of the provided path
+ * exists, and terminate the process if it doesn't.
+ *
+ * Params:
+ *   loc = The line number information from where the call originates
+ *   name = a path to check (the name is stripped)
+ */
 extern (C++) void ensurePathToNameExists(Loc loc, const(char)* name)
 {
     const(char)* pt = FileName.path(name);
@@ -98,7 +139,11 @@ extern (C++) void ensurePathToNameExists(Loc loc, const(char)* name)
     FileName.free(pt);
 }
 
-extern (C++) static void logo()
+
+/**
+ * Print DMD's logo on stdout
+ */
+private void logo()
 {
     printf("DMD%llu D Compiler %s\n%s %s\n", cast(ulong)size_t.sizeof * 8, global._version, global.copyright, global.written);
 }
@@ -109,8 +154,10 @@ version(IN_LLVM)
 }
 else
 {
-
-extern (C++) static void usage()
+/**
+ * Print DMD's usage message on stdout
+ */
+private  void usage()
 {
     static if (TARGET_LINUX)
     {
@@ -189,7 +236,7 @@ Usage:
   -release       compile release version
   -run srcfile args...   run resulting program, passing args
   -shared        generate shared library (DLL)
-  -transition=id show additional info about language change identified by 'id'
+  -transition=id help with language change identified by 'id'
   -transition=?  list all language changes
   -unittest      compile in unit tests
   -v             verbose
@@ -207,14 +254,25 @@ Usage:
 ", FileName.canonicalName(global.inifilename), fpic, m32mscoff);
 }
 
+/// DMD-generated module `__entrypoint` where the C main resides
 extern (C++) __gshared Module entrypoint = null;
+/// Module in which the D main is
 extern (C++) __gshared Module rootHasMain = null;
 
-/************************************
+
+/**
  * Generate C main() in response to seeing D main().
+ *
+ * This function will generate a module called `__entrypoint`,
+ * and set the globals `entrypoint` and `rootHasMain`.
+ *
  * This used to be in druntime, but contained a reference to _Dmain
  * which didn't work when druntime was made into a dll and was linked
  * to a program, such as a C++ program, that didn't have a _Dmain.
+ *
+ * Params:
+ *   sc = Scope which triggered the generation of the C main,
+ *        used to get the module where the D main is.
  */
 extern (C++) void genCmain(Scope* sc)
 {
@@ -238,7 +296,7 @@ extern (C++) void genCmain(Scope* sc)
     };
     Identifier id = Id.entrypoint;
     auto m = new Module("__entrypoint.d", id, 0, 0);
-    scope Parser p = new Parser(m, cmaincode, strlen(cast(const(char)*)cmaincode), 0);
+    scope Parser p = new Parser(m, cmaincode, strlen(cmaincode), 0);
     p.scanloc = Loc();
     p.nextToken();
     m.members = p.parseModule();
@@ -256,11 +314,24 @@ extern (C++) void genCmain(Scope* sc)
     rootHasMain = sc._module;
 }
 
-extern (C++) int tryMain(size_t argc, const(char)** argv)
+
+/**
+ * DMD's real entry point
+ *
+ * Parses command line arguments and config file, open and read all
+ * provided source file and do semantic analysis on them.
+ *
+ * Params:
+ *   argc = Number of arguments passed via command line
+ *   argv = Array of string arguments passed via command line
+ *
+ * Returns:
+ *   Application return code
+ */
+private int tryMain(size_t argc, const(char)** argv)
 {
     Strings files;
     Strings libmodules;
-    size_t argcstart = argc;
     bool setdebuglib = false;
     static if (TARGET_WINDOS)
     {
@@ -312,74 +383,12 @@ extern (C++) int tryMain(size_t argc, const(char)** argv)
     global.params.ddocfiles = new Strings();
     // Default to -m32 for 32 bit dmd, -m64 for 64 bit dmd
     global.params.is64bit = (size_t.sizeof == 8);
+    global.params.mscoff = false;
+
+    // Temporary: Use 32 bits as the default on Windows, for config parsing
     static if (TARGET_WINDOS)
-    {
-        global.params.mscoff = false;
         global.params.is64bit = false;
-        global.params.defaultlibname = "phobos";
-    }
-    else static if (TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS)
-    {
-        global.params.defaultlibname = "libphobos2.a";
-    }
-    else static if (TARGET_OSX)
-    {
-        global.params.defaultlibname = "phobos2";
-    }
-    else
-    {
-        static assert(0, "fix this");
-    }
-    // Predefine version identifiers
-    VersionCondition.addPredefinedGlobalIdent("DigitalMars");
-    static if (TARGET_WINDOS)
-    {
-        VersionCondition.addPredefinedGlobalIdent("Windows");
-        global.params.isWindows = true;
-    }
-    else static if (TARGET_LINUX)
-    {
-        VersionCondition.addPredefinedGlobalIdent("Posix");
-        VersionCondition.addPredefinedGlobalIdent("linux");
-        VersionCondition.addPredefinedGlobalIdent("ELFv1");
-        global.params.isLinux = true;
-    }
-    else static if (TARGET_OSX)
-    {
-        VersionCondition.addPredefinedGlobalIdent("Posix");
-        VersionCondition.addPredefinedGlobalIdent("OSX");
-        global.params.isOSX = true;
-        // For legacy compatibility
-        VersionCondition.addPredefinedGlobalIdent("darwin");
-    }
-    else static if (TARGET_FREEBSD)
-    {
-        VersionCondition.addPredefinedGlobalIdent("Posix");
-        VersionCondition.addPredefinedGlobalIdent("FreeBSD");
-        VersionCondition.addPredefinedGlobalIdent("ELFv1");
-        global.params.isFreeBSD = true;
-    }
-    else static if (TARGET_OPENBSD)
-    {
-        VersionCondition.addPredefinedGlobalIdent("Posix");
-        VersionCondition.addPredefinedGlobalIdent("OpenBSD");
-        VersionCondition.addPredefinedGlobalIdent("ELFv1");
-        global.params.isFreeBSD = true;
-    }
-    else static if (TARGET_SOLARIS)
-    {
-        VersionCondition.addPredefinedGlobalIdent("Posix");
-        VersionCondition.addPredefinedGlobalIdent("Solaris");
-        VersionCondition.addPredefinedGlobalIdent("ELFv1");
-        global.params.isSolaris = true;
-    }
-    else
-    {
-        static assert(0, "fix this");
-    }
-    VersionCondition.addPredefinedGlobalIdent("LittleEndian");
-    VersionCondition.addPredefinedGlobalIdent("D_Version2");
-    VersionCondition.addPredefinedGlobalIdent("all");
+
     global.inifilename = parse_conf_arg(&arguments);
     if (global.inifilename)
     {
@@ -547,7 +556,10 @@ extern (C++) int tryMain(size_t argc, const(char)** argv)
             else if (strcmp(p + 1, "m64") == 0)
             {
                 global.params.is64bit = true;
-                global.params.mscoff = true;
+                static if (TARGET_WINDOS)
+                {
+                    global.params.mscoff = true;
+                }
             }
             else if (strcmp(p + 1, "m32mscoff") == 0)
             {
@@ -595,7 +607,6 @@ extern (C++) int tryMain(size_t argc, const(char)** argv)
                     num = strtol(p + 9, cast(char**)&p, 10);
                     if (*p || errno || num > INT_MAX)
                         goto Lerror;
-                    // Bugzilla issue number
                     global.errorLimit = cast(uint)num;
                 }
                 else
@@ -612,8 +623,10 @@ extern (C++) int tryMain(size_t argc, const(char)** argv)
                         printf("
 Language changes listed by -transition=id:
   =all           list information on all language changes
+  =checkimports  give deprecation messages about 10378 anomalies
   =complex,14488 list all usages of complex or imaginary types
   =field,3449    list all non-mutable fields which occupy an object instance
+  =import,10378  revert to single phase name lookup
   =tls           list all variables going into thread local storage
 ");
                         return EXIT_FAILURE;
@@ -631,6 +644,9 @@ Language changes listed by -transition=id:
                         case 3449:
                             global.params.vfield = true;
                             break;
+                        case 10378:
+                            global.params.bug10378 = true;
+                            break;
                         case 14488:
                             global.params.vcomplex = true;
                             break;
@@ -640,37 +656,29 @@ Language changes listed by -transition=id:
                     }
                     else if (Identifier.isValidIdentifier(p + 12))
                     {
-                        const(char)* ident = p + 12;
-                        switch (strlen(ident))
+                        const ident = p + 12;
+                        switch (ident[0 .. strlen(ident)])
                         {
-                        case 3:
-                            if (strcmp(ident, "all") == 0)
-                            {
-                                global.params.vtls = true;
-                                global.params.vfield = true;
-                                global.params.vcomplex = true;
-                                break;
-                            }
-                            if (strcmp(ident, "tls") == 0)
-                            {
-                                global.params.vtls = true;
-                                break;
-                            }
-                            goto Lerror;
-                        case 5:
-                            if (strcmp(ident, "field") == 0)
-                            {
-                                global.params.vfield = true;
-                                break;
-                            }
-                            goto Lerror;
-                        case 7:
-                            if (strcmp(ident, "complex") == 0)
-                            {
-                                global.params.vcomplex = true;
-                                break;
-                            }
-                            goto Lerror;
+                        case "all":
+                            global.params.vtls = true;
+                            global.params.vfield = true;
+                            global.params.vcomplex = true;
+                            break;
+                        case "checkimports":
+                            global.params.check10378 = true;
+                            break;
+                        case "complex":
+                            global.params.vcomplex = true;
+                            break;
+                        case "field":
+                            global.params.vfield = true;
+                            break;
+                        case "import":
+                            global.params.bug10378 = true;
+                            break;
+                        case "tls":
+                            global.params.vtls = true;
+                            break;
                         default:
                             goto Lerror;
                         }
@@ -926,15 +934,10 @@ Language changes listed by -transition=id:
             }
             else if (memcmp(p + 1, cast(char*)"defaultlib=", 11) == 0)
             {
-                static if (TARGET_WINDOS)
-                {
-                    setdefaultlib = true;
-                }
                 global.params.defaultlibname = p + 1 + 11;
             }
             else if (memcmp(p + 1, cast(char*)"debuglib=", 9) == 0)
             {
-                setdebuglib = true;
                 global.params.debuglibname = p + 1 + 9;
             }
             else if (memcmp(p + 1, cast(char*)"deps", 4) == 0)
@@ -988,7 +991,7 @@ Language changes listed by -transition=id:
             else if (strcmp(p + 1, "run") == 0)
             {
                 global.params.run = true;
-                size_t length = ((i >= argcstart) ? argc : argcstart) - i - 1;
+                size_t length = argc - i - 1;
                 if (length)
                 {
                     const(char)* ext = FileName.ext(arguments[i + 1]);
@@ -1064,8 +1067,6 @@ Language changes listed by -transition=id:
         usage();
         return EXIT_FAILURE;
     }
-    if (!setdebuglib)
-        global.params.debuglibname = global.params.defaultlibname;
     static if (TARGET_OSX)
     {
         global.params.pic = 1;
@@ -1134,70 +1135,13 @@ Language changes listed by -transition=id:
             //fatal();
         }
     }
-    if (global.params.is64bit)
-    {
-        VersionCondition.addPredefinedGlobalIdent("D_InlineAsm_X86_64");
-        VersionCondition.addPredefinedGlobalIdent("X86_64");
-        VersionCondition.addPredefinedGlobalIdent("D_SIMD");
-        static if (TARGET_WINDOS)
-        {
-            VersionCondition.addPredefinedGlobalIdent("Win64");
-            if (!setdefaultlib)
-            {
-                global.params.defaultlibname = "phobos64";
-                if (!setdebuglib)
-                    global.params.debuglibname = global.params.defaultlibname;
-            }
-        }
-    }
-    else
-    {
-        VersionCondition.addPredefinedGlobalIdent("D_InlineAsm"); //legacy
-        VersionCondition.addPredefinedGlobalIdent("D_InlineAsm_X86");
-        VersionCondition.addPredefinedGlobalIdent("X86");
-        static if (TARGET_OSX)
-        {
-            VersionCondition.addPredefinedGlobalIdent("D_SIMD");
-        }
-        static if (TARGET_WINDOS)
-        {
-            VersionCondition.addPredefinedGlobalIdent("Win32");
-            if (!setdefaultlib && global.params.mscoff)
-            {
-                global.params.defaultlibname = "phobos32mscoff";
-                if (!setdebuglib)
-                    global.params.debuglibname = global.params.defaultlibname;
-            }
-        }
-    }
-    static if (TARGET_WINDOS)
-    {
-        if (global.params.mscoff)
-            VersionCondition.addPredefinedGlobalIdent("CRuntime_Microsoft");
-        else
-            VersionCondition.addPredefinedGlobalIdent("CRuntime_DigitalMars");
-    }
-    else static if (TARGET_LINUX)
-    {
-        VersionCondition.addPredefinedGlobalIdent("CRuntime_Glibc");
-    }
-    if (global.params.isLP64)
-        VersionCondition.addPredefinedGlobalIdent("D_LP64");
-    if (global.params.doDocComments)
-        VersionCondition.addPredefinedGlobalIdent("D_Ddoc");
-    if (global.params.cov)
-        VersionCondition.addPredefinedGlobalIdent("D_Coverage");
-    if (global.params.pic)
-        VersionCondition.addPredefinedGlobalIdent("D_PIC");
-    if (global.params.useUnitTests)
-        VersionCondition.addPredefinedGlobalIdent("unittest");
-    if (global.params.useAssert)
-        VersionCondition.addPredefinedGlobalIdent("assert");
-    if (global.params.useArrayBounds == BOUNDSCHECKoff)
-        VersionCondition.addPredefinedGlobalIdent("D_NoBoundsChecks");
-    VersionCondition.addPredefinedGlobalIdent("D_HardFloat");
+
+    // Predefined version identifiers
+    addDefaultVersionIdentifiers();
     objc_tryMain_dObjc();
 
+    setDefaultLibrary();
+
     // Initialization
     Type._init();
     Id.initialize();
@@ -1354,7 +1298,7 @@ Language changes listed by -transition=id:
         /* At this point, name is the D source file name stripped of
          * its path and extension.
          */
-        Identifier id = Identifier.idPool(name);
+        auto id = Identifier.idPool(name, strlen(name));
         auto m = new Module(files[i], id, global.params.doDocComments, global.params.doHdrGeneration);
         modules.push(m);
         if (firstmodule)
@@ -1618,7 +1562,7 @@ Language changes listed by -transition=id:
     else if (global.params.oneobj)
     {
         if (modules.dim)
-            obj_start(modules[0].srcfile.toChars());
+            obj_start(cast(char*)modules[0].srcfile.toChars());
         for (size_t i = 0; i < modules.dim; i++)
         {
             Module m = modules[i];
@@ -1640,7 +1584,7 @@ Language changes listed by -transition=id:
             Module m = modules[i];
             if (global.params.verbose)
                 fprintf(global.stdmsg, "code      %s\n", m.toChars());
-            obj_start(m.srcfile.toChars());
+            obj_start(cast(char*)m.srcfile.toChars());
             genObjFile(m, global.params.multiobj);
             if (entrypoint && m == rootHasMain)
                 genObjFile(entrypoint, global.params.multiobj);
@@ -1685,6 +1629,13 @@ Language changes listed by -transition=id:
     return status;
 }
 
+
+/**
+ * Entry point which forwards to `tryMain`.
+ *
+ * Returns:
+ *   Return code of the application
+ */
 int main()
 {
     import core.memory;
@@ -1702,11 +1653,19 @@ int main()
     return tryMain(args.argc, cast(const(char)**)args.argv);
 }
 
-/***********************************
- * Parse and append contents of command line string envvalue to args[].
- * The string is separated into arguments, processing \ and ".
+
+/**
+ * Parses an environment variable containing command-line flags
+ * and append them to `args`.
+ *
+ * This function is used to read the content of DFLAGS.
+ * Flags are separated based on spaces and tabs.
+ *
+ * Params:
+ *   envvalue = The content of an environment variable
+ *   args     = Array to append the flags to, if any.
  */
-extern (C++) void getenv_setargv(const(char)* envvalue, Strings* args)
+private void getenv_setargv(const(char)* envvalue, Strings* args)
 {
     if (!envvalue)
         return;
@@ -1778,6 +1737,14 @@ extern (C++) void getenv_setargv(const(char)* envvalue, Strings* args)
 
 } // !IN_LLVM
 
+
+/**
+ * Takes a path, and escapes '(', ')' and backslashes
+ *
+ * Params:
+ *   buf = Buffer to write the escaped path to
+ *   fname = Path to escape
+ */
 extern (C++) void escapePath(OutBuffer* buf, const(char)* fname)
 {
     while (1)
@@ -1790,6 +1757,7 @@ extern (C++) void escapePath(OutBuffer* buf, const(char)* fname)
         case ')':
         case '\\':
             buf.writeByte('\\');
+            goto default;
         default:
             buf.writeByte(*fname);
             break;
@@ -1798,11 +1766,21 @@ extern (C++) void escapePath(OutBuffer* buf, const(char)* fname)
     }
 }
 
-/***********************************
+
+/**
  * Parse command line arguments for -m32 or -m64
  * to detect the desired architecture.
+ *
+ * Params:
+ *   args = Command line arguments
+ *   arch = Default value to use for architecture.
+ *          Should be "32" or "64"
+ *
+ * Returns:
+ *   "32", "64" or "32mscoff" if the "-m32", "-m64", "-m32mscoff" flags were passed,
+ *   respectively. If they weren't, return `arch`.
  */
-extern (C++) static const(char)* parse_arch_arg(Strings* args, const(char)* arch)
+private const(char)* parse_arch_arg(Strings* args, const(char)* arch)
 {
     for (size_t i = 0; i < args.dim; ++i)
     {
@@ -1818,10 +1796,17 @@ extern (C++) static const(char)* parse_arch_arg(Strings* args, const(char)* arch
     return arch;
 }
 
-/***********************************
+
+/**
  * Parse command line arguments for -conf=path.
+ *
+ * Params:
+ *   args = Command line arguments
+ *
+ * Returns:
+ *   Path to the config file to use
  */
-extern (C++) static const(char)* parse_conf_arg(Strings* args)
+private const(char)* parse_conf_arg(Strings* args)
 {
     const(char)* conf = null;
     for (size_t i = 0; i < args.dim; ++i)
@@ -1838,17 +1823,190 @@ extern (C++) static const(char)* parse_conf_arg(Strings* args)
     return conf;
 }
 
+
+/**
+ * Helper function used by the glue layer
+ *
+ * Returns:
+ *   A new array of Dsymbol
+ */
 extern (C++) Dsymbols* Dsymbols_create()
 {
     return new Dsymbols();
 }
 
+
+/**
+ * Helper function used by the glue layer
+ *
+ * Returns:
+ *   A new array of VarDeclaration
+ */
 extern (C++) VarDeclarations* VarDeclarations_create()
 {
     return new VarDeclarations();
 }
 
+
+/**
+ * Helper function used by the glue layer
+ *
+ * Returns:
+ *   A new array of Expression
+ */
 extern (C++) Expressions* Expressions_create()
 {
     return new Expressions();
 }
+
+/**
+ * Set the default and debug libraries to link against, if not already set
+ *
+ * Must be called after argument parsing is done, as it won't
+ * override any value.
+ * Note that if `-defaultlib=` or `-debuglib=` was used,
+ * we don't override that either.
+ */
+private void setDefaultLibrary()
+{
+    if (global.params.defaultlibname is null)
+    {
+        static if (TARGET_WINDOS)
+        {
+            if (global.params.is64bit)
+                global.params.defaultlibname = "phobos64";
+            else if (global.params.mscoff)
+                global.params.defaultlibname = "phobos32mscoff";
+            else
+                global.params.defaultlibname = "phobos";
+        }
+        else static if (TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS)
+        {
+            global.params.defaultlibname = "libphobos2.a";
+        }
+        else static if (TARGET_OSX)
+        {
+            global.params.defaultlibname = "phobos2";
+        }
+        else
+        {
+            static assert(0, "fix this");
+        }
+    }
+    if (global.params.debuglibname is null)
+        global.params.debuglibname = global.params.defaultlibname;
+}
+
+
+/**
+ * Add default `version` identifier for ddmd, and set the
+ * target platform in `global`.
+ *
+ * Needs to be run after all arguments parsing (command line, DFLAGS environment
+ * variable and config file) in order to add final flags (such as `X86_64` or
+ * the `CRuntime` used).
+ */
+private void addDefaultVersionIdentifiers()
+{
+    VersionCondition.addPredefinedGlobalIdent("DigitalMars");
+    static if (TARGET_WINDOS)
+    {
+        VersionCondition.addPredefinedGlobalIdent("Windows");
+        global.params.isWindows = true;
+    }
+    else static if (TARGET_LINUX)
+    {
+        VersionCondition.addPredefinedGlobalIdent("Posix");
+        VersionCondition.addPredefinedGlobalIdent("linux");
+        VersionCondition.addPredefinedGlobalIdent("ELFv1");
+        global.params.isLinux = true;
+    }
+    else static if (TARGET_OSX)
+    {
+        VersionCondition.addPredefinedGlobalIdent("Posix");
+        VersionCondition.addPredefinedGlobalIdent("OSX");
+        global.params.isOSX = true;
+        // For legacy compatibility
+        VersionCondition.addPredefinedGlobalIdent("darwin");
+    }
+    else static if (TARGET_FREEBSD)
+    {
+        VersionCondition.addPredefinedGlobalIdent("Posix");
+        VersionCondition.addPredefinedGlobalIdent("FreeBSD");
+        VersionCondition.addPredefinedGlobalIdent("ELFv1");
+        global.params.isFreeBSD = true;
+    }
+    else static if (TARGET_OPENBSD)
+    {
+        VersionCondition.addPredefinedGlobalIdent("Posix");
+        VersionCondition.addPredefinedGlobalIdent("OpenBSD");
+        VersionCondition.addPredefinedGlobalIdent("ELFv1");
+        global.params.isFreeBSD = true;
+    }
+    else static if (TARGET_SOLARIS)
+    {
+        VersionCondition.addPredefinedGlobalIdent("Posix");
+        VersionCondition.addPredefinedGlobalIdent("Solaris");
+        VersionCondition.addPredefinedGlobalIdent("ELFv1");
+        global.params.isSolaris = true;
+    }
+    else
+    {
+        static assert(0, "fix this");
+    }
+    VersionCondition.addPredefinedGlobalIdent("LittleEndian");
+    VersionCondition.addPredefinedGlobalIdent("D_Version2");
+    VersionCondition.addPredefinedGlobalIdent("all");
+
+    if (global.params.is64bit)
+    {
+        VersionCondition.addPredefinedGlobalIdent("D_InlineAsm_X86_64");
+        VersionCondition.addPredefinedGlobalIdent("X86_64");
+        VersionCondition.addPredefinedGlobalIdent("D_SIMD");
+        static if (TARGET_WINDOS)
+        {
+            VersionCondition.addPredefinedGlobalIdent("Win64");
+        }
+    }
+    else
+    {
+        VersionCondition.addPredefinedGlobalIdent("D_InlineAsm"); //legacy
+        VersionCondition.addPredefinedGlobalIdent("D_InlineAsm_X86");
+        VersionCondition.addPredefinedGlobalIdent("X86");
+        static if (TARGET_OSX)
+        {
+            VersionCondition.addPredefinedGlobalIdent("D_SIMD");
+        }
+        static if (TARGET_WINDOS)
+        {
+            VersionCondition.addPredefinedGlobalIdent("Win32");
+        }
+    }
+    static if (TARGET_WINDOS)
+    {
+        if (global.params.mscoff)
+            VersionCondition.addPredefinedGlobalIdent("CRuntime_Microsoft");
+        else
+            VersionCondition.addPredefinedGlobalIdent("CRuntime_DigitalMars");
+    }
+    else static if (TARGET_LINUX)
+    {
+        VersionCondition.addPredefinedGlobalIdent("CRuntime_Glibc");
+    }
+
+    if (global.params.isLP64)
+        VersionCondition.addPredefinedGlobalIdent("D_LP64");
+    if (global.params.doDocComments)
+        VersionCondition.addPredefinedGlobalIdent("D_Ddoc");
+    if (global.params.cov)
+        VersionCondition.addPredefinedGlobalIdent("D_Coverage");
+    if (global.params.pic)
+        VersionCondition.addPredefinedGlobalIdent("D_PIC");
+    if (global.params.useUnitTests)
+        VersionCondition.addPredefinedGlobalIdent("unittest");
+    if (global.params.useAssert)
+        VersionCondition.addPredefinedGlobalIdent("assert");
+    if (global.params.useArrayBounds == BOUNDSCHECKoff)
+        VersionCondition.addPredefinedGlobalIdent("D_NoBoundsChecks");
+    VersionCondition.addPredefinedGlobalIdent("D_HardFloat");
+}
diff --git a/ddmd/module.h b/ddmd/module.h
index 184da84bff..5479269cb6 100644
--- a/ddmd/module.h
+++ b/ddmd/module.h
@@ -49,6 +49,7 @@ class Package : public ScopeDsymbol
 {
 public:
     PKG isPkgMod;
+    unsigned tag;       // auto incremented tag, used to mask package tree in scopes
     Module *mod;        // != NULL if isPkgMod == PKGmodule
 
     Package(Identifier *ident);
@@ -58,7 +59,7 @@ public:
 
     Package *isPackage() { return this; }
 
-    bool isAncestorPackageOf(Package *pkg);
+    bool isAncestorPackageOf(const Package * const pkg) const;
 
     void semantic(Scope *sc) { }
     Dsymbol *search(Loc loc, Identifier *ident, int flags = IgnoreNone);
diff --git a/ddmd/mtype.d b/ddmd/mtype.d
index 6c023491da..b168fdfa62 100644
--- a/ddmd/mtype.d
+++ b/ddmd/mtype.d
@@ -20,6 +20,7 @@ import ddmd.access;
 import ddmd.aggregate;
 import ddmd.aliasthis;
 import ddmd.argtypes;
+import ddmd.arrayop;
 import ddmd.arraytypes;
 import ddmd.attrib;
 import ddmd.gluelayer;
@@ -175,21 +176,21 @@ extern (C++) void MODtoBuffer(OutBuffer* buf, MOD mod)
     case MODshared | MODconst:
         buf.writestring(Token.tochars[TOKshared]);
         buf.writeByte(' ');
-        /* fall through */
+        goto case; /+ fall through +/
     case MODconst:
         buf.writestring(Token.tochars[TOKconst]);
         break;
     case MODshared | MODwild:
         buf.writestring(Token.tochars[TOKshared]);
         buf.writeByte(' ');
-        /* fall through */
+        goto case; /+ fall through +/
     case MODwild:
         buf.writestring(Token.tochars[TOKwild]);
         break;
     case MODshared | MODwildconst:
         buf.writestring(Token.tochars[TOKshared]);
         buf.writeByte(' ');
-        /* fall through */
+        goto case; /+ fall through +/
     case MODwildconst:
         buf.writestring(Token.tochars[TOKwild]);
         buf.writeByte(' ');
@@ -593,7 +594,7 @@ public:
         this.ty = ty;
     }
 
-    const(char)* kind()
+    const(char)* kind() const
     {
         assert(false); // should be overridden
     }
@@ -802,7 +803,7 @@ public:
     /********************************
      * For pretty-printing a type.
      */
-    override char* toChars()
+    final override const(char)* toChars()
     {
         OutBuffer buf;
         buf.reserve(16);
@@ -1013,7 +1014,7 @@ public:
         assert(t);
         if (!t.deco)
             return t.merge();
-        StringValue* sv = stringtable.lookup(cast(char*)t.deco, strlen(t.deco));
+        StringValue* sv = stringtable.lookup(t.deco, strlen(t.deco));
         if (sv && sv.ptrvalue)
         {
             t = cast(Type)sv.ptrvalue;
@@ -1142,47 +1143,47 @@ public:
             s.checkDeprecated(loc, sc);
     }
 
-    final bool isConst()
+    final bool isConst() const
     {
         return (mod & MODconst) != 0;
     }
 
-    final bool isImmutable()
+    final bool isImmutable() const
     {
         return (mod & MODimmutable) != 0;
     }
 
-    final bool isMutable()
+    final bool isMutable() const
     {
         return (mod & (MODconst | MODimmutable | MODwild)) == 0;
     }
 
-    final bool isShared()
+    final bool isShared() const
     {
         return (mod & MODshared) != 0;
     }
 
-    final bool isSharedConst()
+    final bool isSharedConst() const
     {
         return (mod & (MODshared | MODconst)) == (MODshared | MODconst);
     }
 
-    final bool isWild()
+    final bool isWild() const
     {
         return (mod & MODwild) != 0;
     }
 
-    final bool isWildConst()
+    final bool isWildConst() const
     {
         return (mod & MODwildconst) == MODwildconst;
     }
 
-    final bool isSharedWild()
+    final bool isSharedWild() const
     {
         return (mod & (MODshared | MODwild)) == (MODshared | MODwild);
     }
 
-    final bool isNaked()
+    final bool isNaked() const
     {
         return mod == 0;
     }
@@ -2425,14 +2426,7 @@ public:
             if (tb.ty == Tstruct && tb.needsNested())
             {
                 StructLiteralExp se = cast(StructLiteralExp)e;
-version(IN_LLVM)
-{
-                se.sinit = cast(SymbolDeclaration) (cast(VarExp) defaultInit(loc)).var;
-}
-else
-{
-                se.sinit = toInitializer(se.sd);
-}
+                se.useStaticInit = true;
             }
         }
         else if (ident == Id._mangleof)
@@ -2444,15 +2438,15 @@ else
             }
             else
             {
-                e = new StringExp(loc, cast(char*)deco, strlen(deco));
+                e = new StringExp(loc, deco);
                 Scope sc;
                 e = e.semantic(&sc);
             }
         }
         else if (ident == Id.stringof)
         {
-            char* s = toChars();
-            e = new StringExp(loc, s, strlen(s));
+            const s = toChars();
+            e = new StringExp(loc, cast(char*)s);
             Scope sc;
             e = e.semantic(&sc);
         }
@@ -2516,27 +2510,13 @@ else
             }
             else if (ident == Id._init)
             {
-version(IN_LLVM)
-{
-                // LDC_FIXME: Port the below (from 2.061).
-                if (toBasetype.ty == Tstruct &&
-                    (cast(TypeStruct)toBasetype()).sym.isNested())
-                {
-                    e = defaultInit(e.loc);
-                }
-                else
-                    e = defaultInitLiteral(e.loc);
-}
-else
-{
                 Type tb = toBasetype();
                 e = defaultInitLiteral(e.loc);
                 if (tb.ty == Tstruct && tb.needsNested())
                 {
                     StructLiteralExp se = cast(StructLiteralExp)e;
-                    se.sinit = toInitializer(se.sd);
+                    se.useStaticInit = true;
                 }
-}
                 goto Lreturn;
             }
         }
@@ -2545,8 +2525,8 @@ else
             /* Bugzilla 3796: this should demangle e->type->deco rather than
              * pretty-printing the type.
              */
-            char* s = e.toChars();
-            e = new StringExp(e.loc, s, strlen(s));
+            const s = e.toChars();
+            e = new StringExp(e.loc, cast(char*)s);
         }
         else
             e = getProperty(e.loc, ident, flag);
@@ -2615,7 +2595,7 @@ else
                     fd.error("must be a template opDispatch(string s), not a %s", fd.kind());
                     return new ErrorExp();
                 }
-                auto se = new StringExp(e.loc, ident.toChars());
+                auto se = new StringExp(e.loc, cast(char*)ident.toChars());
                 auto tiargs = new Objects();
                 tiargs.push(se);
                 auto dti = new DotTemplateInstanceExp(e.loc, e, Id.opDispatch, tiargs);
@@ -2686,7 +2666,7 @@ else
         // Allocate buffer on stack, fail over to using malloc()
         char[128] namebuf;
         size_t namelen = 19 + len.sizeof * 3 + len + 1;
-        char* name = namelen <= namebuf.sizeof ? namebuf.ptr : cast(char*)malloc(namelen);
+        char* name = namelen <= namebuf.length ? namebuf.ptr : cast(char*)malloc(namelen);
         assert(name);
         sprintf(name, "_D%lluTypeInfo_%s6__initZ", cast(ulong)9 + len, buf.data);
         //printf("%p, deco = %s, name = %s\n", this, deco, name);
@@ -2697,7 +2677,7 @@ else
             if (global.params.isOSX || global.params.isWindows && !global.params.is64bit)
                 ++off; // C mangling will add '_' back in
         }
-        Identifier id = Identifier.idPool(name + off);
+        auto id = Identifier.idPool(name + off, strlen(name + off));
         if (name != namebuf.ptr)
             free(name);
         return id;
@@ -2782,7 +2762,7 @@ else
     /***************************************
      * Return !=0 if the type or any of its subtypes is wild.
      */
-    int hasWild()
+    int hasWild() const
     {
         return mod & MODwild;
     }
@@ -3016,7 +2996,7 @@ public:
             next.checkDeprecated(loc, sc);
     }
 
-    override final int hasWild()
+    override final int hasWild() const
     {
         if (ty == Tfunction)
             return 0;
@@ -3408,7 +3388,7 @@ public:
         merge();
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return dstring;
     }
@@ -3419,7 +3399,7 @@ public:
         return this;
     }
 
-    override d_uns64 size(Loc loc)
+    override d_uns64 size(Loc loc) const
     {
         uint size;
         //printf("TypeBasic::size()\n");
@@ -3996,32 +3976,32 @@ else
         return (flags & TFLAGSintegral) != 0;
     }
 
-    override bool isfloating()
+    override bool isfloating() const
     {
         return (flags & TFLAGSfloating) != 0;
     }
 
-    override bool isreal()
+    override bool isreal() const
     {
         return (flags & TFLAGSreal) != 0;
     }
 
-    override bool isimaginary()
+    override bool isimaginary() const
     {
         return (flags & TFLAGSimaginary) != 0;
     }
 
-    override bool iscomplex()
+    override bool iscomplex() const
     {
         return (flags & TFLAGScomplex) != 0;
     }
 
-    override bool isscalar()
+    override bool isscalar() const
     {
         return (flags & (TFLAGSintegral | TFLAGSfloating)) != 0;
     }
 
-    override bool isunsigned()
+    override bool isunsigned() const
     {
         return (flags & TFLAGSunsigned) != 0;
     }
@@ -4137,7 +4117,7 @@ else
         return new IntegerExp(loc, value, this);
     }
 
-    override bool isZeroInit(Loc loc)
+    override bool isZeroInit(Loc loc) const
     {
         switch (ty)
         {
@@ -4162,7 +4142,7 @@ else
     // For eliminating dynamic_cast
     override TypeBasic isTypeBasic()
     {
-        return cast(TypeBasic)this;
+        return this;
     }
 
     override void accept(Visitor v)
@@ -4188,7 +4168,7 @@ public:
         this.basetype = basetype;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "vector";
     }
@@ -4302,7 +4282,7 @@ else
         return basetype.nextOf().isunsigned();
     }
 
-    override bool isBoolean()
+    override bool isBoolean() const
     {
         return false;
     }
@@ -4406,7 +4386,7 @@ public:
                 params.push(new Parameter(0, arrty, null, null));
                 reverseFd[i] = FuncDeclaration.genCfunc(params, arrty, reverseName[i]);
             }
-            Expression ec = new VarExp(Loc(), reverseFd[i]);
+            Expression ec = new VarExp(Loc(), reverseFd[i], false);
             e = e.castTo(sc, n.arrayOf()); // convert to dynamic array
             auto arguments = new Expressions();
             arguments.push(e);
@@ -4427,7 +4407,7 @@ public:
                 params.push(new Parameter(0, arrty, null, null));
                 sortFd[i] = FuncDeclaration.genCfunc(params, arrty, sortName[i]);
             }
-            Expression ec = new VarExp(Loc(), sortFd[i]);
+            Expression ec = new VarExp(Loc(), sortFd[i], false);
             e = e.castTo(sc, n.arrayOf()); // convert to dynamic array
             auto arguments = new Expressions();
             arguments.push(e);
@@ -4451,7 +4431,7 @@ public:
                 adReverse_fd = FuncDeclaration.genCfunc(params, Type.tvoid.arrayOf(), Id.adReverse);
             }
             fd = adReverse_fd;
-            ec = new VarExp(Loc(), fd);
+            ec = new VarExp(Loc(), fd, false);
             e = e.castTo(sc, n.arrayOf()); // convert to dynamic array
             arguments = new Expressions();
             arguments.push(e);
@@ -4472,7 +4452,7 @@ public:
                 params.push(new Parameter(0, Type.dtypeinfo.type, null, null));
                 fd = FuncDeclaration.genCfunc(params, Type.tvoid.arrayOf(), "_adSort");
             }
-            ec = new VarExp(Loc(), fd);
+            ec = new VarExp(Loc(), fd, false);
             e = e.castTo(sc, n.arrayOf()); // convert to dynamic array
             arguments = new Expressions();
             arguments.push(e);
@@ -4515,7 +4495,7 @@ public:
         this.dim = dim;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "sarray";
     }
@@ -4681,7 +4661,7 @@ public:
         {
             // It's really an index expression
             if (Dsymbol s = getDsymbol(*pe))
-                *pe = new DsymbolExp(loc, s, 1);
+                *pe = new DsymbolExp(loc, s);
             *pe = new ArrayExp(loc, *pe, dim);
         }
         else if (*ps)
@@ -4947,7 +4927,7 @@ public:
         //printf("TypeDArray(t = %p)\n", t);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "darray";
     }
@@ -4965,13 +4945,13 @@ public:
         return t;
     }
 
-    override d_uns64 size(Loc loc)
+    override d_uns64 size(Loc loc) const
     {
         //printf("TypeDArray::size()\n");
         return Target.ptrsize * 2;
     }
 
-    override uint alignsize()
+    override uint alignsize() const
     {
         // A DArray consists of two ptr-sized values, so align it on pointer size
         // boundary
@@ -5014,7 +4994,7 @@ public:
         {
             // It's really a slice expression
             if (Dsymbol s = getDsymbol(*pe))
-                *pe = new DsymbolExp(loc, s, 1);
+                *pe = new DsymbolExp(loc, s);
             *pe = new ArrayExp(loc, *pe);
         }
         else if (*ps)
@@ -5055,6 +5035,8 @@ public:
             }
             if (e.op == TOKnull)
                 return new IntegerExp(e.loc, 0, Type.tsize_t);
+            if (checkNonAssignmentArrayOp(e))
+                return new ErrorExp();
             e = new ArrayLengthExp(e.loc, e);
             e.type = Type.tsize_t;
             return e;
@@ -5077,12 +5059,12 @@ public:
         return nty == Tchar || nty == Twchar || nty == Tdchar;
     }
 
-    override bool isZeroInit(Loc loc)
+    override bool isZeroInit(Loc loc) const
     {
         return true;
     }
 
-    override bool isBoolean()
+    override bool isBoolean() const
     {
         return true;
     }
@@ -5123,7 +5105,7 @@ public:
         return new NullExp(loc, this);
     }
 
-    override bool hasPointers()
+    override bool hasPointers() const
     {
         return true;
     }
@@ -5154,7 +5136,7 @@ public:
         return new TypeAArray(t, index);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "aarray";
     }
@@ -5236,6 +5218,7 @@ public:
         case Tnone:
         case Ttuple:
             error(loc, "can't have associative array key of %s", index.toBasetype().toChars());
+            goto case Terror;
         case Terror:
             return Type.terror;
         default:
@@ -5346,6 +5329,7 @@ public:
         case Tnone:
         case Ttuple:
             error(loc, "can't have associative array of %s", next.toChars());
+            goto case Terror;
         case Terror:
             return Type.terror;
         default:
@@ -5405,7 +5389,7 @@ public:
                 tf.isnothrow = true;
                 tf.isnogc = false;
             }
-            Expression ev = new VarExp(e.loc, fd_aaLen);
+            Expression ev = new VarExp(e.loc, fd_aaLen, false);
             e = new CallExp(e.loc, ev, e);
             e.type = (cast(TypeFunction)fd_aaLen.type).next;
         }
@@ -5423,12 +5407,12 @@ public:
         return new NullExp(loc, this);
     }
 
-    override bool isZeroInit(Loc loc)
+    override bool isZeroInit(Loc loc) const
     {
         return true;
     }
 
-    override bool isBoolean()
+    override bool isBoolean() const
     {
         return true;
     }
@@ -5445,7 +5429,7 @@ public:
         return null;
     }
 
-    override bool hasPointers()
+    override bool hasPointers() const
     {
         return true;
     }
@@ -5501,7 +5485,7 @@ public:
         super(Tpointer, t);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "pointer";
     }
@@ -5529,6 +5513,7 @@ public:
         {
         case Ttuple:
             error(loc, "can't have pointer to %s", n.toChars());
+            goto case Terror;
         case Terror:
             return Type.terror;
         default:
@@ -5559,7 +5544,7 @@ public:
         }
     }
 
-    override d_uns64 size(Loc loc)
+    override d_uns64 size(Loc loc) const
     {
         return Target.ptrsize;
     }
@@ -5639,7 +5624,7 @@ public:
         return TypeNext.constConv(to);
     }
 
-    override bool isscalar()
+    override bool isscalar() const
     {
         return true;
     }
@@ -5653,12 +5638,12 @@ public:
         return new NullExp(loc, this);
     }
 
-    override bool isZeroInit(Loc loc)
+    override bool isZeroInit(Loc loc) const
     {
         return true;
     }
 
-    override bool hasPointers()
+    override bool hasPointers() const
     {
         return true;
     }
@@ -5680,7 +5665,7 @@ public:
         // BUG: what about references to static arrays?
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "reference";
     }
@@ -5709,7 +5694,7 @@ public:
         return merge();
     }
 
-    override d_uns64 size(Loc loc)
+    override d_uns64 size(Loc loc) const
     {
         return Target.ptrsize;
     }
@@ -5733,7 +5718,7 @@ public:
         return new NullExp(loc, this);
     }
 
-    override bool isZeroInit(Loc loc)
+    override bool isZeroInit(Loc loc) const
     {
         return true;
     }
@@ -5847,7 +5832,7 @@ public:
         return new TypeFunction(parameters, treturn, varargs, linkage, stc);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "function";
     }
@@ -6047,6 +6032,7 @@ public:
                     }
                     else
                     {
+                        e = inferType(e, fparam.type);
                         Initializer iz = new ExpInitializer(e.loc, e);
                         iz = iz.semantic(argsc, fparam.type, INITnointerpret);
                         e = iz.toExpression();
@@ -6057,7 +6043,7 @@ public:
                         // Replace function literal with a function symbol,
                         // since default arg expression must be copied when used
                         // and copying the literal itself is wrong.
-                        e = new VarExp(e.loc, fe.fd, 0);
+                        e = new VarExp(e.loc, fe.fd, false);
                         e = new AddrExp(e.loc, e);
                         e = e.semantic(argsc);
                     }
@@ -6620,6 +6606,7 @@ public:
                         sz = tsa.dim.toInteger();
                         if (sz != nargs - u)
                             goto Nomatch;
+                        goto case Tarray;
                     case Tarray:
                         {
                             TypeArray ta = cast(TypeArray)tb;
@@ -6701,7 +6688,7 @@ public:
         return false;
     }
 
-    override Expression defaultInit(Loc loc)
+    override Expression defaultInit(Loc loc) const
     {
         error(loc, "function does not have a default initializer");
         return new ErrorExp();
@@ -6726,7 +6713,7 @@ public:
         ty = Tdelegate;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "delegate";
     }
@@ -6773,12 +6760,12 @@ public:
         }
     }
 
-    override d_uns64 size(Loc loc)
+    override d_uns64 size(Loc loc) const
     {
         return Target.ptrsize * 2;
     }
 
-    override uint alignsize()
+    override uint alignsize() const
     {
         return Target.ptrsize;
     }
@@ -6823,12 +6810,12 @@ public:
         return new NullExp(loc, this);
     }
 
-    override bool isZeroInit(Loc loc)
+    override bool isZeroInit(Loc loc) const
     {
         return true;
     }
 
-    override bool isBoolean()
+    override bool isBoolean() const
     {
         return true;
     }
@@ -6856,7 +6843,7 @@ public:
         return e;
     }
 
-    override bool hasPointers()
+    override bool hasPointers() const
     {
         return true;
     }
@@ -7092,6 +7079,11 @@ public:
                 Type t = s.getType(); // type symbol, type alias, or type tuple?
                 uint errorsave = global.errors;
                 Dsymbol sm = s.searchX(loc, sc, id);
+                if (sm && !symbolIsVisible(sc, sm))
+                {
+                    .deprecation(loc, "%s is not visible from module %s", sm.toPrettyChars(), sc._module.toChars());
+                    // sm = null;
+                }
                 if (global.errors != errorsave)
                 {
                     *pt = Type.terror;
@@ -7140,9 +7132,9 @@ public:
                         VarDeclaration v = s.isVarDeclaration();
                         FuncDeclaration f = s.isFuncDeclaration();
                         if (intypeid || !v && !f)
-                            e = DsymbolExp.resolve(loc, sc, s, false);
+                            e = DsymbolExp.resolve(loc, sc, s, true);
                         else
-                            e = new VarExp(loc, s.isDeclaration());
+                            e = new VarExp(loc, s.isDeclaration(), true);
 
                         e = toExpressionHelper(e, i);
                         e = e.semantic(sc);
@@ -7220,7 +7212,7 @@ public:
             {
                 if (FuncDeclaration fd = s.isFuncDeclaration())
                 {
-                    *pe = new DsymbolExp(loc, fd, 1);
+                    *pe = new DsymbolExp(loc, fd);
                     return;
                 }
             }
@@ -7294,7 +7286,7 @@ public:
         this.ident = ident;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "identifier";
     }
@@ -7425,7 +7417,7 @@ public:
         this.tempinst = tempinst;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "instance";
     }
@@ -7538,7 +7530,7 @@ public:
         this.exp = exp;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "typeof";
     }
@@ -7597,19 +7589,29 @@ public:
         exp = resolvePropertiesOnly(sc2, exp);
         sc2.pop();
 
-        if (exp.op == TOKtype)
+        if (exp.op == TOKtype ||
+            exp.op == TOKscope)
         {
-            error(loc, "argument %s to typeof is not an expression", exp.toChars());
-            goto Lerr;
-        }
-        if (exp.op == TOKscope)
-        {
-            ScopeDsymbol sds = (cast(ScopeExp)exp).sds;
-            if (sds.isPackage())
-            {
-                error(loc, "%s has no type", exp.toChars());
+            if (exp.checkType())
+                goto Lerr;
+
+            /* Today, 'typeof(func)' returns void if func is a
+             * function template (TemplateExp), or
+             * template lambda (FuncExp).
+             * It's actually used in Phobos as an idiom, to branch code for
+             * template functions.
+             */
+        }
+        if (auto f = exp.op == TOKvar    ? (cast(   VarExp)exp).var.isFuncDeclaration()
+                   : exp.op == TOKdotvar ? (cast(DotVarExp)exp).var.isFuncDeclaration() : null)
+        {
+            if (f.checkForwardRef(loc))
+                goto Lerr;
+        }
+        if (auto f = isFuncAddress(exp))
+        {
+            if (f.checkForwardRef(loc))
                 goto Lerr;
-            }
         }
 
         Type t = exp.type;
@@ -7683,7 +7685,7 @@ public:
         super(Treturn, loc);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "return";
     }
@@ -7812,7 +7814,7 @@ public:
         this.sym = sym;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "struct";
     }
@@ -7933,6 +7935,11 @@ public:
             if (!s)
                 return noMember(sc, e, ident, flag);
         }
+        if (!symbolIsVisible(sc, s))
+        {
+            .deprecation(e.loc, "%s is not visible from module %s", s.toPrettyChars(), sc._module.toPrettyChars());
+            // return noMember(sc, e, ident, flag);
+        }
         if (!s.isFuncDeclaration()) // because of overloading
             s.checkDeprecated(e.loc, sc);
         s = s.toAlias();
@@ -7980,7 +7987,7 @@ public:
         if (td)
         {
             if (e.op == TOKtype)
-                e = new ScopeExp(e.loc, td);
+                e = new TemplateExp(e.loc, td);
             else
                 e = new DotTemplateExp(e.loc, e, td);
             e = e.semantic(sc);
@@ -8050,7 +8057,7 @@ public:
             if (d.semanticRun == PASSinit && d._scope)
                 d.semantic(d._scope);
             checkAccess(e.loc, sc, e, d);
-            auto ve = new VarExp(e.loc, d, 1);
+            auto ve = new VarExp(e.loc, d);
             if (d.isVarDeclaration() && d.needThis())
                 ve.type = d.type.addMod(e.type.mod);
             return ve;
@@ -8065,8 +8072,10 @@ public:
             e = e.semantic(sc);
             return e;
         }
-        auto de = new DotVarExp(e.loc, e, d);
-        return de.semantic(sc);
+
+        e = new DotVarExp(e.loc, e, d);
+        e = e.semantic(sc);
+        return e;
     }
 
     override structalign_t alignment()
@@ -8131,22 +8140,17 @@ public:
                 offset = vd.offset + cast(uint)vd.type.size();
             (*structelems)[j] = e;
         }
-        auto structinit = new StructLiteralExp(loc, cast(StructDeclaration)sym, structelems);
+        auto structinit = new StructLiteralExp(loc, sym, structelems);
         /* Copy from the initializer symbol for larger symbols,
          * otherwise the literals expressed as code get excessively large.
          */
         if (size(loc) > Target.ptrsize * 4 && !needsNested())
-        {
-            version(IN_LLVM)
-                structinit.sinit = cast(SymbolDeclaration) (cast(VarExp)defaultInit(loc)).var;
-            else
-                structinit.sinit = toInitializer(sym);
-        }
+            structinit.useStaticInit = true;
         structinit.type = this;
         return structinit;
     }
 
-    override bool isZeroInit(Loc loc)
+    override bool isZeroInit(Loc loc) const
     {
         return sym.zeroInit != 0;
     }
@@ -8186,12 +8190,12 @@ public:
         return assignable;
     }
 
-    override bool isBoolean()
+    override bool isBoolean() const
     {
         return false;
     }
 
-    override bool needsDestruction()
+    override bool needsDestruction() const
     {
         return sym.dtor !is null;
     }
@@ -8332,7 +8336,7 @@ public:
         this.sym = sym;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "enum";
     }
@@ -8429,8 +8433,8 @@ public:
         }
         else if (ident == Id.stringof)
         {
-            char* s = toChars();
-            e = new StringExp(loc, s, strlen(s));
+            const s = toChars();
+            e = new StringExp(loc, cast(char*)s);
             Scope sc;
             e = e.semantic(&sc);
         }
@@ -8583,12 +8587,12 @@ public:
         this.sym = sym;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "class";
     }
 
-    override d_uns64 size(Loc loc)
+    override d_uns64 size(Loc loc) const
     {
         return Target.ptrsize;
     }
@@ -8701,7 +8705,7 @@ public:
                     return Type.getProperty(e.loc, ident, 0);
                 return new DotTypeExp(e.loc, e, sym);
             }
-            if (ClassDeclaration cbase = sym.searchBase(e.loc, ident))
+            if (ClassDeclaration cbase = sym.searchBase(ident))
             {
                 if (e.op == TOKtype)
                     return Type.getProperty(e.loc, ident, 0);
@@ -8783,7 +8787,7 @@ public:
                 if (sym.vthis._scope)
                     sym.vthis.semantic(null);
                 ClassDeclaration cdp = sym.toParent2().isClassDeclaration();
-                auto de = new DotVarExp(e.loc, e, sym.vthis, 0);
+                auto de = new DotVarExp(e.loc, e, sym.vthis);
                 de.type = (cdp ? cdp.type : sym.vthis.type).addMod(e.type.mod);
                 return de;
             }
@@ -8792,6 +8796,11 @@ public:
                 return noMember(sc, e, ident, flag);
             }
         }
+        if (!symbolIsVisible(sc, s))
+        {
+            .deprecation(e.loc, "%s is not visible from module %s", s.toPrettyChars(), sc._module.toChars());
+            // return noMember(sc, e, ident, flag);
+        }
         if (!s.isFuncDeclaration()) // because of overloading
             s.checkDeprecated(e.loc, sc);
         s = s.toAlias();
@@ -8839,7 +8848,7 @@ public:
         if (td)
         {
             if (e.op == TOKtype)
-                e = new ScopeExp(e.loc, td);
+                e = new TemplateExp(e.loc, td);
             else
                 e = new DotTemplateExp(e.loc, e, td);
             e = e.semantic(sc);
@@ -8942,7 +8951,7 @@ public:
                             }
                             else
                             {
-                                e = new VarExp(e.loc, d, 1);
+                                e = new VarExp(e.loc, d);
                                 return e;
                             }
                         }
@@ -8963,7 +8972,7 @@ public:
             if (d.semanticRun == PASSinit && d._scope)
                 d.semantic(d._scope);
             checkAccess(e.loc, sc, e, d);
-            auto ve = new VarExp(e.loc, d, 1);
+            auto ve = new VarExp(e.loc, d);
             if (d.isVarDeclaration() && d.needThis())
                 ve.type = d.type.addMod(e.type.mod);
             return ve;
@@ -8981,13 +8990,15 @@ public:
         if (d.parent && d.toParent().isModule())
         {
             // (e, d)
-            auto ve = new VarExp(e.loc, d, 1);
+            auto ve = new VarExp(e.loc, d);
             e = new CommaExp(e.loc, e, ve);
             e.type = d.type;
             return e;
         }
-        auto de = new DotVarExp(e.loc, e, d, d.hasOverloads());
-        return de.semantic(sc);
+
+        e = new DotVarExp(e.loc, e, d);
+        e = e.semantic(sc);
+        return e;
     }
 
     override ClassDeclaration isClassHandle()
@@ -9085,22 +9096,22 @@ public:
         return new NullExp(loc, this);
     }
 
-    override bool isZeroInit(Loc loc)
+    override bool isZeroInit(Loc loc) const
     {
         return true;
     }
 
-    override bool isscope()
+    override bool isscope() const
     {
         return sym.isscope;
     }
 
-    override bool isBoolean()
+    override bool isBoolean() const
     {
         return true;
     }
 
-    override bool hasPointers()
+    override bool hasPointers() const
     {
         return true;
     }
@@ -9190,7 +9201,7 @@ public:
         arguments.push(new Parameter(0, t2, null, null));
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "tuple";
     }
@@ -9305,7 +9316,7 @@ public:
         this.upr = upr;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "slice";
     }
@@ -9363,7 +9374,7 @@ public:
         {
             // It's really a slice expression
             if (Dsymbol s = getDsymbol(*pe))
-                *pe = new DsymbolExp(loc, s, 1);
+                *pe = new DsymbolExp(loc, s);
             *pe = new ArrayExp(loc, *pe, new IntervalExp(loc, lwr, upr));
         }
         else if (*ps)
@@ -9436,7 +9447,7 @@ public:
         super(Tnull);
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "null";
     }
@@ -9465,17 +9476,17 @@ public:
         return MATCHnomatch;
     }
 
-    override bool isBoolean()
+    override bool isBoolean() const
     {
         return true;
     }
 
-    override d_uns64 size(Loc loc)
+    override d_uns64 size(Loc loc) const
     {
         return tvoidptr.size(loc);
     }
 
-    override Expression defaultInit(Loc loc)
+    override Expression defaultInit(Loc loc) const
     {
         return new NullExp(Loc(), Type.tnull);
     }
diff --git a/ddmd/mtype.h b/ddmd/mtype.h
index 6ec4b5c18e..a5df647d6b 100644
--- a/ddmd/mtype.h
+++ b/ddmd/mtype.h
@@ -275,15 +275,15 @@ public:
     virtual bool isAssignable();
     virtual bool isBoolean();
     virtual void checkDeprecated(Loc loc, Scope *sc);
-    bool isConst()       { return (mod & MODconst) != 0; }
-    bool isImmutable()   { return (mod & MODimmutable) != 0; }
-    bool isMutable()     { return (mod & (MODconst | MODimmutable | MODwild)) == 0; }
-    bool isShared()      { return (mod & MODshared) != 0; }
-    bool isSharedConst() { return (mod & (MODshared | MODconst)) == (MODshared | MODconst); }
-    bool isWild()        { return (mod & MODwild) != 0; }
-    bool isWildConst()   { return (mod & MODwildconst) == MODwildconst; }
-    bool isSharedWild()  { return (mod & (MODshared | MODwild)) == (MODshared | MODwild); }
-    bool isNaked()       { return mod == 0; }
+    bool isConst() const       { return (mod & MODconst) != 0; }
+    bool isImmutable() const   { return (mod & MODimmutable) != 0; }
+    bool isMutable() const     { return (mod & (MODconst | MODimmutable | MODwild)) == 0; }
+    bool isShared() const      { return (mod & MODshared) != 0; }
+    bool isSharedConst() const { return (mod & (MODshared | MODconst)) == (MODshared | MODconst); }
+    bool isWild() const        { return (mod & MODwild) != 0; }
+    bool isWildConst() const   { return (mod & MODwildconst) == MODwildconst; }
+    bool isSharedWild() const  { return (mod & (MODshared | MODwild)) == (MODshared | MODwild); }
+    bool isNaked() const       { return mod == 0; }
     Type *nullAttributes();
     Type *constOf();
     Type *immutableOf();
@@ -337,7 +337,7 @@ public:
     virtual bool isZeroInit(Loc loc = Loc());                // if initializer is 0
     Identifier *getTypeInfoIdent(int internal);
     virtual void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps, bool intypeid = false);
-    virtual int hasWild();
+    virtual int hasWild() const;
     virtual Expression *toExpression();
     virtual bool hasPointers();
     virtual Type *nextOf();
@@ -377,7 +377,7 @@ public:
 
     TypeNext(TY ty, Type *next);
     void checkDeprecated(Loc loc, Scope *sc);
-    int hasWild();
+    int hasWild() const;
     Type *nextOf();
     Type *makeConst();
     Type *makeImmutable();
@@ -403,7 +403,7 @@ public:
     TypeBasic(TY ty);
     const char *kind();
     Type *syntaxCopy();
-    d_uns64 size(Loc loc);
+    d_uns64 size(Loc loc) const;
     unsigned alignsize();
 #if IN_LLVM
     uint32_t alignment();
@@ -411,15 +411,15 @@ public:
     Expression *getProperty(Loc loc, Identifier *ident, int flag);
     Expression *dotExp(Scope *sc, Expression *e, Identifier *ident, int flag);
     bool isintegral();
-    bool isfloating();
-    bool isreal();
-    bool isimaginary();
-    bool iscomplex();
-    bool isscalar();
-    bool isunsigned();
+    bool isfloating() const;
+    bool isreal() const;
+    bool isimaginary() const;
+    bool iscomplex() const;
+    bool isscalar() const;
+    bool isunsigned() const;
     MATCH implicitConvTo(Type *to);
     Expression *defaultInit(Loc loc);
-    bool isZeroInit(Loc loc);
+    bool isZeroInit(Loc loc) const;
 
     // For eliminating dynamic_cast
     TypeBasic *isTypeBasic();
@@ -443,7 +443,7 @@ public:
     bool isfloating();
     bool isscalar();
     bool isunsigned();
-    bool isBoolean();
+    bool isBoolean() const;
     MATCH implicitConvTo(Type *to);
     Expression *defaultInit(Loc loc);
     Expression *defaultInitLiteral(Loc loc);
@@ -497,17 +497,17 @@ public:
     TypeDArray(Type *t);
     const char *kind();
     Type *syntaxCopy();
-    d_uns64 size(Loc loc);
-    unsigned alignsize();
+    d_uns64 size(Loc loc) const;
+    unsigned alignsize() const;
     Type *semantic(Loc loc, Scope *sc);
     void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps, bool intypeid = false);
     Expression *dotExp(Scope *sc, Expression *e, Identifier *ident, int flag);
     bool isString();
-    bool isZeroInit(Loc loc);
-    bool isBoolean();
+    bool isZeroInit(Loc loc) const;
+    bool isBoolean() const;
     MATCH implicitConvTo(Type *to);
     Expression *defaultInit(Loc loc);
-    bool hasPointers();
+    bool hasPointers() const;
 
     void accept(Visitor *v) { v->visit(this); }
 };
@@ -528,10 +528,10 @@ public:
     void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps, bool intypeid = false);
     Expression *dotExp(Scope *sc, Expression *e, Identifier *ident, int flag);
     Expression *defaultInit(Loc loc);
-    bool isZeroInit(Loc loc);
-    bool isBoolean();
+    bool isZeroInit(Loc loc) const;
+    bool isBoolean() const;
     Expression *toExpression();
-    bool hasPointers();
+    bool hasPointers() const;
     MATCH implicitConvTo(Type *to);
     MATCH constConv(Type *to);
 
@@ -545,13 +545,13 @@ public:
     const char *kind();
     Type *syntaxCopy();
     Type *semantic(Loc loc, Scope *sc);
-    d_uns64 size(Loc loc);
+    d_uns64 size(Loc loc) const;
     MATCH implicitConvTo(Type *to);
     MATCH constConv(Type *to);
-    bool isscalar();
+    bool isscalar() const;
     Expression *defaultInit(Loc loc);
-    bool isZeroInit(Loc loc);
-    bool hasPointers();
+    bool isZeroInit(Loc loc) const;
+    bool hasPointers() const;
 
     void accept(Visitor *v) { v->visit(this); }
 };
@@ -563,10 +563,10 @@ public:
     const char *kind();
     Type *syntaxCopy();
     Type *semantic(Loc loc, Scope *sc);
-    d_uns64 size(Loc loc);
+    d_uns64 size(Loc loc) const;
     Expression *dotExp(Scope *sc, Expression *e, Identifier *ident, int flag);
     Expression *defaultInit(Loc loc);
-    bool isZeroInit(Loc loc);
+    bool isZeroInit(Loc loc) const;
     void accept(Visitor *v) { v->visit(this); }
 };
 
@@ -642,7 +642,7 @@ public:
     MATCH callMatch(Type *tthis, Expressions *toargs, int flag = 0);
     bool checkRetType(Loc loc);
 
-    Expression *defaultInit(Loc loc);
+    Expression *defaultInit(Loc loc) const;
     void accept(Visitor *v) { v->visit(this); }
 };
 
@@ -655,14 +655,14 @@ public:
     const char *kind();
     Type *syntaxCopy();
     Type *semantic(Loc loc, Scope *sc);
-    d_uns64 size(Loc loc);
-    unsigned alignsize();
+    d_uns64 size(Loc loc) const;
+    unsigned alignsize() const;
     MATCH implicitConvTo(Type *to);
     Expression *defaultInit(Loc loc);
-    bool isZeroInit(Loc loc);
-    bool isBoolean();
+    bool isZeroInit(Loc loc) const;
+    bool isBoolean() const;
     Expression *dotExp(Scope *sc, Expression *e, Identifier *ident, int flag);
-    bool hasPointers();
+    bool hasPointers() const;
 
     void accept(Visitor *v) { v->visit(this); }
 };
@@ -788,10 +788,10 @@ public:
     structalign_t alignment();
     Expression *defaultInit(Loc loc);
     Expression *defaultInitLiteral(Loc loc);
-    bool isZeroInit(Loc loc);
+    bool isZeroInit(Loc loc) const;
     bool isAssignable();
-    bool isBoolean();
-    bool needsDestruction();
+    bool isBoolean() const;
+    bool needsDestruction() const;
     bool needsNested();
     bool hasPointers();
     MATCH implicitConvTo(Type *to);
@@ -847,7 +847,7 @@ public:
 
     TypeClass(ClassDeclaration *sym);
     const char *kind();
-    d_uns64 size(Loc loc);
+    d_uns64 size(Loc loc) const;
     Type *syntaxCopy();
     Type *semantic(Loc loc, Scope *sc);
     Dsymbol *toDsymbol(Scope *sc);
@@ -859,10 +859,10 @@ public:
     unsigned char deduceWild(Type *t, bool isRef);
     Type *toHeadMutable();
     Expression *defaultInit(Loc loc);
-    bool isZeroInit(Loc loc);
-    bool isscope();
-    bool isBoolean();
-    bool hasPointers();
+    bool isZeroInit(Loc loc) const;
+    bool isscope() const;
+    bool isBoolean() const;
+    bool hasPointers() const;
 
     void accept(Visitor *v) { v->visit(this); }
 };
@@ -909,10 +909,10 @@ public:
 
     Type *syntaxCopy();
     MATCH implicitConvTo(Type *to);
-    bool isBoolean();
+    bool isBoolean() const;
 
-    d_uns64 size(Loc loc);
-    Expression *defaultInit(Loc loc);
+    d_uns64 size(Loc loc) const;
+    Expression *defaultInit(Loc loc) const;
     void accept(Visitor *v) { v->visit(this); }
 };
 
diff --git a/ddmd/nogc.d b/ddmd/nogc.d
index 5d31055b90..8af30dfc9c 100644
--- a/ddmd/nogc.d
+++ b/ddmd/nogc.d
@@ -8,6 +8,7 @@
 
 module ddmd.nogc;
 
+import ddmd.aggregate;
 import ddmd.apply;
 import ddmd.declaration;
 import ddmd.dscope;
@@ -71,7 +72,8 @@ public:
             return;
         if (f.setGC())
         {
-            e.error("array literal in @nogc function %s may cause GC allocation", f.toChars());
+            e.error("array literal in @nogc %s '%s' may cause GC allocation",
+                f.kind(), f.toPrettyChars());
             err = true;
             return;
         }
@@ -84,7 +86,8 @@ public:
             return;
         if (f.setGC())
         {
-            e.error("associative array literal in @nogc function %s may cause GC allocation", f.toChars());
+            e.error("associative array literal in @nogc %s '%s' may cause GC allocation",
+                f.kind(), f.toPrettyChars());
             err = true;
             return;
         }
@@ -104,7 +107,8 @@ public:
             return;
         if (f.setGC())
         {
-            e.error("cannot use 'new' in @nogc function %s", f.toChars());
+            e.error("cannot use 'new' in @nogc %s '%s'",
+                f.kind(), f.toPrettyChars());
             err = true;
             return;
         }
@@ -119,9 +123,31 @@ public:
             if (v && v.onstack)
                 return; // delete for scope allocated class object
         }
+
+        Type tb = e.e1.type.toBasetype();
+        AggregateDeclaration ad = null;
+        switch (tb.ty)
+        {
+        case Tclass:
+            ad = (cast(TypeClass)tb).sym;
+            break;
+
+        case Tpointer:
+            tb = (cast(TypePointer)tb).next.toBasetype();
+            if (tb.ty == Tstruct)
+                ad = (cast(TypeStruct)tb).sym;
+            break;
+
+        default:
+            break;
+        }
+        if (ad && ad.aggDelete)
+            return;
+
         if (f.setGC())
         {
-            e.error("cannot use 'delete' in @nogc function %s", f.toChars());
+            e.error("cannot use 'delete' in @nogc %s '%s'",
+                f.kind(), f.toPrettyChars());
             err = true;
             return;
         }
@@ -135,7 +161,8 @@ public:
         {
             if (f.setGC())
             {
-                e.error("indexing an associative array in @nogc function %s may cause GC allocation", f.toChars());
+                e.error("indexing an associative array in @nogc %s '%s' may cause GC allocation",
+                    f.kind(), f.toPrettyChars());
                 err = true;
                 return;
             }
@@ -149,7 +176,8 @@ public:
         {
             if (f.setGC())
             {
-                e.error("setting 'length' in @nogc function %s may cause GC allocation", f.toChars());
+                e.error("setting 'length' in @nogc %s '%s' may cause GC allocation",
+                    f.kind(), f.toPrettyChars());
                 err = true;
                 return;
             }
@@ -161,7 +189,8 @@ public:
     {
         if (f.setGC())
         {
-            e.error("cannot use operator ~= in @nogc function %s", f.toChars());
+            e.error("cannot use operator ~= in @nogc %s '%s'",
+                f.kind(), f.toPrettyChars());
             err = true;
             return;
         }
@@ -172,7 +201,8 @@ public:
     {
         if (f.setGC())
         {
-            e.error("cannot use operator ~ in @nogc function %s", f.toChars());
+            e.error("cannot use operator ~ in @nogc %s '%s'",
+                f.kind(), f.toPrettyChars());
             err = true;
             return;
         }
diff --git a/ddmd/nspace.d b/ddmd/nspace.d
index 8a9d52137f..ffbe0eb01b 100644
--- a/ddmd/nspace.d
+++ b/ddmd/nspace.d
@@ -17,6 +17,7 @@ import ddmd.hdrgen;
 import ddmd.identifier;
 import ddmd.root.outbuffer;
 import ddmd.visitor;
+import core.stdc.stdio;
 
 private enum LOG = false;
 
@@ -41,6 +42,53 @@ public:
         return ScopeDsymbol.syntaxCopy(ns);
     }
 
+    override void addMember(Scope* sc, ScopeDsymbol sds)
+    {
+        ScopeDsymbol.addMember(sc, sds);
+        if (members)
+        {
+            if (!symtab)
+                symtab = new DsymbolTable();
+            // The namespace becomes 'imported' into the enclosing scope
+            for (Scope* sce = sc; 1; sce = sce.enclosing)
+            {
+                ScopeDsymbol sds2 = sce.scopesym;
+                if (sds2)
+                {
+                    sds2.importScope(this, Prot(PROTpublic));
+                    break;
+                }
+            }
+            assert(sc);
+            sc = sc.push(this);
+            sc.linkage = LINKcpp; // namespaces default to C++ linkage
+            sc.parent = this;
+            foreach (s; *members)
+            {
+                //printf("add %s to scope %s\n", s->toChars(), toChars());
+                s.addMember(sc, this);
+            }
+            sc.pop();
+        }
+    }
+
+    override void setScope(Scope* sc)
+    {
+        ScopeDsymbol.setScope(sc);
+        if (members)
+        {
+            assert(sc);
+            sc = sc.push(this);
+            sc.linkage = LINKcpp; // namespaces default to C++ linkage
+            sc.parent = this;
+            foreach (s; *members)
+            {
+                s.setScope(sc);
+            }
+            sc.pop();
+        }
+    }
+
     override void semantic(Scope* sc)
     {
         if (semanticRun >= PASSsemantic)
@@ -58,32 +106,11 @@ public:
         parent = sc.parent;
         if (members)
         {
-            if (!symtab)
-                symtab = new DsymbolTable();
-            // The namespace becomes 'imported' into the enclosing scope
-            for (Scope* sce = sc; 1; sce = sce.enclosing)
-            {
-                ScopeDsymbol sds = cast(ScopeDsymbol)sce.scopesym;
-                if (sds)
-                {
-                    sds.importScope(this, Prot(PROTpublic));
-                    break;
-                }
-            }
             assert(sc);
             sc = sc.push(this);
             sc.linkage = LINKcpp; // note that namespaces imply C++ linkage
             sc.parent = this;
             foreach (s; *members)
-            {
-                //printf("add %s to scope %s\n", s->toChars(), toChars());
-                s.addMember(sc, this);
-            }
-            foreach (s; *members)
-            {
-                s.setScope(sc);
-            }
-            foreach (s; *members)
             {
                 s.importAll(sc);
             }
@@ -159,7 +186,7 @@ public:
         return Dsymbol.oneMember(ps, ident);
     }
 
-    override final Dsymbol search(Loc loc, Identifier ident, int flags = IgnoreNone)
+    override final Dsymbol search(Loc loc, Identifier ident, int flags = SearchLocalsOnly)
     {
         //printf("%s.Nspace.search('%s')\n", toChars(), ident.toChars());
         if (_scope && !symtab)
@@ -222,12 +249,12 @@ public:
         }
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "namespace";
     }
 
-    override Nspace isNspace()
+    override inout(Nspace) isNspace() inout
     {
         return this;
     }
diff --git a/ddmd/opover.d b/ddmd/opover.d
index 9da8fdaf35..b1a9940733 100644
--- a/ddmd/opover.d
+++ b/ddmd/opover.d
@@ -508,7 +508,7 @@ extern (C++) Expression op_overload(Expression e, Scope* sc)
                         /* Rewrite op(a[arguments]) as:
                          *      a.opIndexUnary!(op)(arguments)
                          */
-                        Expressions* a = cast(Expressions*)ae.arguments.copy();
+                        Expressions* a = ae.arguments.copy();
                         Objects* tiargs = opToArg(sc, e.op);
                         result = new DotTemplateInstanceExp(e.loc, ae.e1, Id.opIndexUnary, tiargs);
                         result = new CallExp(e.loc, result, a);
@@ -676,7 +676,7 @@ extern (C++) Expression op_overload(Expression e, Scope* sc)
                     /* Rewrite e1[arguments] as:
                      *      e1.opIndex(arguments)
                      */
-                    Expressions* a = cast(Expressions*)ae.arguments.copy();
+                    Expressions* a = ae.arguments.copy();
                     result = new DotIdExp(ae.loc, ae.e1, Id.index);
                     result = new CallExp(ae.loc, result, a);
                     if (maybeSlice) // a[] might be: a.opSlice()
@@ -1238,10 +1238,15 @@ extern (C++) Expression op_overload(Expression e, Scope* sc)
                     return;
                 }
 
-                /* Rewrite:
+                /* Do memberwise equality.
+                 * Rewrite:
                  *      e1 == e2
                  * as:
                  *      e1.tupleof == e2.tupleof
+                 *
+                 * If sd is a nested struct, and if it's nested in a class, it will
+                 * also compare the parent class's equality. Otherwise, compares
+                 * the identity of parent context through void*.
                  */
                 if (e.att1 && t1 == e.att1) return;
                 if (e.att2 && t2 == e.att2) return;
@@ -1365,7 +1370,7 @@ extern (C++) Expression op_overload(Expression e, Scope* sc)
                         /* Rewrite a[arguments] op= e2 as:
                          *      a.opIndexOpAssign!(op)(e2, arguments)
                          */
-                        Expressions* a = cast(Expressions*)ae.arguments.copy();
+                        Expressions* a = ae.arguments.copy();
                         a.insert(0, e.e2);
                         Objects* tiargs = opToArg(sc, e.op);
                         result = new DotTemplateInstanceExp(e.loc, ae.e1, Id.opIndexOpAssign, tiargs);
@@ -1719,7 +1724,7 @@ extern (C++) Expression build_overload(Loc loc, Scope* sc, Expression ethis, Exp
     //earg->type->print();
     Declaration decl = d.isDeclaration();
     if (decl)
-        e = new DotVarExp(loc, ethis, decl, 0);
+        e = new DotVarExp(loc, ethis, decl, false);
     else
         e = new DotIdExp(loc, ethis, d.ident);
     e = new CallExp(loc, e, earg);
diff --git a/ddmd/parse.d b/ddmd/parse.d
index c67881baae..ef8db63170 100644
--- a/ddmd/parse.d
+++ b/ddmd/parse.d
@@ -266,11 +266,12 @@ public:
 
     Dsymbols* parseModule()
     {
-        const(char)* comment = token.blockComment;
+        const comment = token.blockComment;
         bool isdeprecated = false;
         Expression msg = null;
         Expressions* udas = null;
         Dsymbols* decldefs;
+        Dsymbol lastDecl = mod; // for attaching ddoc unittests to module decl
         Token* tk;
         if (skipAttributes(&token, &tk) && tk.value == TOKmodule)
         {
@@ -301,7 +302,7 @@ public:
                 case TOKat:
                     {
                         Expressions* exps = null;
-                        StorageClass stc = parseAttribute(&exps);
+                        const stc = parseAttribute(&exps);
                         if (stc == STCproperty || stc == STCnogc || stc == STCdisable || stc == STCsafe || stc == STCtrusted || stc == STCsystem)
                         {
                             error("@%s attribute for module declaration is not supported", token.toChars());
@@ -332,7 +333,7 @@ public:
         // ModuleDeclation leads off
         if (token.value == TOKmodule)
         {
-            Loc loc = token.loc;
+            const loc = token.loc;
             nextToken();
             if (token.value != TOKidentifier)
             {
@@ -342,8 +343,7 @@ public:
             else
             {
                 Identifiers* a = null;
-                Identifier id;
-                id = token.ident;
+                Identifier id = token.ident;
                 while (nextToken() == TOKdot)
                 {
                     if (!a)
@@ -366,7 +366,7 @@ public:
                 addComment(mod, comment);
             }
         }
-        decldefs = parseDeclDefs(0);
+        decldefs = parseDeclDefs(0, &lastDecl);
         if (token.value != TOKeof)
         {
             error(token.loc, "unrecognized declaration");
@@ -385,7 +385,7 @@ public:
         Dsymbol lastDecl = null; // used to link unittest to its previous declaration
         if (!pLastDecl)
             pLastDecl = &lastDecl;
-        LINK linksave = linkage; // save global state
+        const linksave = linkage; // save global state
         //printf("Parser::parseDeclDefs()\n");
         auto decldefs = new Dsymbols();
         do
@@ -434,7 +434,7 @@ public:
                 break;
             case TOKmixin:
                 {
-                    Loc loc = token.loc;
+                    const loc = token.loc;
                     switch (peekNext())
                     {
                     case TOKlparen:
@@ -580,7 +580,7 @@ public:
                 return decldefs;
             case TOKstatic:
                 {
-                    TOK next = peekNext();
+                    const next = peekNext();
                     if (next == TOKthis)
                         s = parseStaticCtor(pAttrs);
                     else if (next == TOKtilde)
@@ -595,7 +595,7 @@ public:
                             athen = parseBlock(pLastDecl);
                         else
                         {
-                            Loc lookingForElseSave = lookingForElse;
+                            const lookingForElseSave = lookingForElse;
                             lookingForElse = token.loc;
                             athen = parseBlock(pLastDecl);
                             lookingForElse = lookingForElseSave;
@@ -603,7 +603,7 @@ public:
                         Dsymbols* aelse = null;
                         if (token.value == TOKelse)
                         {
-                            Loc elseloc = token.loc;
+                            const elseloc = token.loc;
                             nextToken();
                             aelse = parseBlock(pLastDecl);
                             checkDanglingElse(elseloc);
@@ -634,7 +634,7 @@ public:
                 goto Lstc;
             case TOKshared:
                 {
-                    TOK next = peekNext();
+                    const next = peekNext();
                     if (next == TOKlparen)
                         goto Ldeclaration;
                     if (next == TOKstatic)
@@ -798,9 +798,9 @@ public:
                         stc = STCextern;
                         goto Lstc;
                     }
-                    Loc linkLoc = token.loc;
+                    const linkLoc = token.loc;
                     Identifiers* idents = null;
-                    LINK link = parseLinkage(&idents);
+                    const link = parseLinkage(&idents);
                     if (pAttrs.link != LINKdefault)
                     {
                         if (pAttrs.link != link)
@@ -882,7 +882,7 @@ public:
                             break;
                         }
                     }
-                    Loc attrloc = token.loc;
+                    const attrloc = token.loc;
                     a = parseBlock(pLastDecl, pAttrs);
                     if (pAttrs.protection.kind != PROTundefined)
                     {
@@ -952,7 +952,7 @@ public:
             case TOKpragma:
                 {
                     Expressions* args = null;
-                    Loc loc = token.loc;
+                    const loc = token.loc;
                     nextToken();
                     check(TOKlparen);
                     if (token.value != TOKidentifier)
@@ -1034,7 +1034,7 @@ public:
                         athen = parseBlock(pLastDecl);
                     else
                     {
-                        Loc lookingForElseSave = lookingForElse;
+                        const lookingForElseSave = lookingForElse;
                         lookingForElse = token.loc;
                         athen = parseBlock(pLastDecl);
                         lookingForElse = lookingForElseSave;
@@ -1042,7 +1042,7 @@ public:
                     Dsymbols* aelse = null;
                     if (token.value == TOKelse)
                     {
-                        Loc elseloc = token.loc;
+                        const elseloc = token.loc;
                         nextToken();
                         aelse = parseBlock(pLastDecl);
                         checkDanglingElse(elseloc);
@@ -1095,7 +1095,7 @@ public:
         auto a = new Dsymbols();
         while (1)
         {
-            Loc loc = token.loc;
+            const loc = token.loc;
             Identifier ident = token.ident;
             nextToken(); // skip over ident
             TemplateParameters* tpl = null;
@@ -1156,7 +1156,7 @@ public:
             break;
         case TOKlcurly:
             {
-                Loc lookingForElseSave = lookingForElse;
+                const lookingForElseSave = lookingForElse;
                 lookingForElse = Loc();
                 nextToken();
                 a = parseDeclDefs(0, pLastDecl);
@@ -1255,7 +1255,7 @@ public:
                 Expression exp = parsePrimaryExp();
                 if (token.value == TOKlparen)
                 {
-                    Loc loc = token.loc;
+                    const loc = token.loc;
                     exp = new CallExp(loc, exp, parseArguments());
                 }
                 udas = new Expressions();
@@ -1402,7 +1402,7 @@ public:
         TemplateParameters* tpl;
         Dsymbols* decldefs;
         Expression constraint = null;
-        Loc loc = token.loc;
+        const loc = token.loc;
         nextToken();
         if (token.value != TOKidentifier)
         {
@@ -1616,9 +1616,9 @@ public:
         Identifier id;
         Objects* tiargs;
         //printf("parseMixin()\n");
-        Loc locMixin = token.loc;
+        const locMixin = token.loc;
         nextToken(); // skip 'mixin'
-        Loc loc = token.loc;
+        auto loc = token.loc;
         TypeQualified tqual = null;
         if (token.value == TOKdot)
         {
@@ -1909,7 +1909,7 @@ public:
      */
     StaticAssert parseStaticAssert()
     {
-        Loc loc = token.loc;
+        const loc = token.loc;
         Expression exp;
         Expression msg = null;
         //printf("parseStaticAssert()\n");
@@ -1920,7 +1920,12 @@ public:
         if (token.value == TOKcomma)
         {
             nextToken();
-            msg = parseAssignExp();
+            if (token.value != TOKrparen)
+            {
+                msg = parseAssignExp();
+                if (token.value == TOKcomma)
+                    nextToken();
+            }
         }
         check(TOKrparen);
         check(TOKsemicolon);
@@ -1934,7 +1939,7 @@ public:
     TypeQualified parseTypeof()
     {
         TypeQualified t;
-        Loc loc = token.loc;
+        const loc = token.loc;
         nextToken();
         check(TOKlparen);
         if (token.value == TOKreturn) // typeof(return)
@@ -1957,7 +1962,7 @@ public:
      */
     Type parseVector()
     {
-        Loc loc = token.loc;
+        const loc = token.loc;
         nextToken();
         check(TOKlparen);
         Type tb = parseType();
@@ -2133,9 +2138,9 @@ public:
             else if (token.value == TOKint32v || token.value == TOKint64v)
                 level = cast(uint)token.uns64value;
             else if (token.value == TOKunittest)
-                id = Identifier.idPool(Token.toChars(TOKunittest));
+                id = Identifier.idPool(Token.toChars(TOKunittest), strlen(Token.toChars(TOKunittest)));
             else if (token.value == TOKassert)
-                id = Identifier.idPool(Token.toChars(TOKassert));
+                id = Identifier.idPool(Token.toChars(TOKassert), strlen(Token.toChars(TOKassert)));
             else
                 error("identifier or integer expected, not %s", token.toChars());
             nextToken();
@@ -2158,7 +2163,7 @@ public:
     {
         Expression exp;
         Condition condition;
-        Loc loc = token.loc;
+        const loc = token.loc;
         nextToken();
         nextToken();
         if (token.value == TOKlparen)
@@ -2188,7 +2193,7 @@ public:
     Dsymbol parseCtor(PrefixAttributes* pAttrs)
     {
         Expressions* udas = null;
-        Loc loc = token.loc;
+        const loc = token.loc;
         StorageClass stc = pAttrs ? pAttrs.storageClass : STCundefined;
         nextToken();
         if (token.value == TOKlparen && peekNext() == TOKthis && peekNext2() == TOKrparen)
@@ -2269,7 +2274,7 @@ public:
     Dsymbol parseDtor(PrefixAttributes* pAttrs)
     {
         Expressions* udas = null;
-        Loc loc = token.loc;
+        const loc = token.loc;
         StorageClass stc = pAttrs ? pAttrs.storageClass : STCundefined;
         nextToken();
         check(TOKthis);
@@ -2304,7 +2309,7 @@ public:
     Dsymbol parseStaticCtor(PrefixAttributes* pAttrs)
     {
         //Expressions *udas = NULL;
-        Loc loc = token.loc;
+        const loc = token.loc;
         StorageClass stc = pAttrs ? pAttrs.storageClass : STCundefined;
         nextToken();
         nextToken();
@@ -2337,7 +2342,7 @@ public:
     Dsymbol parseStaticDtor(PrefixAttributes* pAttrs)
     {
         Expressions* udas = null;
-        Loc loc = token.loc;
+        const loc = token.loc;
         StorageClass stc = pAttrs ? pAttrs.storageClass : STCundefined;
         nextToken();
         nextToken();
@@ -2377,7 +2382,7 @@ public:
     Dsymbol parseSharedStaticCtor(PrefixAttributes* pAttrs)
     {
         //Expressions *udas = NULL;
-        Loc loc = token.loc;
+        const loc = token.loc;
         StorageClass stc = pAttrs ? pAttrs.storageClass : STCundefined;
         nextToken();
         nextToken();
@@ -2409,7 +2414,7 @@ public:
     Dsymbol parseSharedStaticDtor(PrefixAttributes* pAttrs)
     {
         Expressions* udas = null;
-        Loc loc = token.loc;
+        const loc = token.loc;
         StorageClass stc = pAttrs ? pAttrs.storageClass : STCundefined;
         nextToken();
         nextToken();
@@ -2447,7 +2452,7 @@ public:
      */
     Dsymbol parseInvariant(PrefixAttributes* pAttrs)
     {
-        Loc loc = token.loc;
+        const loc = token.loc;
         StorageClass stc = pAttrs ? pAttrs.storageClass : STCundefined;
         nextToken();
         if (token.value == TOKlparen) // optional ()
@@ -2469,7 +2474,7 @@ public:
      */
     Dsymbol parseUnitTest(PrefixAttributes* pAttrs)
     {
-        Loc loc = token.loc;
+        const loc = token.loc;
         StorageClass stc = pAttrs ? pAttrs.storageClass : STCundefined;
         nextToken();
         const(char)* begPtr = token.ptr + 1; // skip '{'
@@ -2508,7 +2513,7 @@ public:
      */
     Dsymbol parseNew(PrefixAttributes* pAttrs)
     {
-        Loc loc = token.loc;
+        const loc = token.loc;
         StorageClass stc = pAttrs ? pAttrs.storageClass : STCundefined;
         nextToken();
         int varargs;
@@ -2527,7 +2532,7 @@ public:
      */
     Dsymbol parseDelete(PrefixAttributes* pAttrs)
     {
-        Loc loc = token.loc;
+        const loc = token.loc;
         StorageClass stc = pAttrs ? pAttrs.storageClass : STCundefined;
         nextToken();
         int varargs;
@@ -2662,7 +2667,7 @@ public:
                         if (tpl && token.value == TOKidentifier && (t = peek(&token), (t.value == TOKcomma || t.value == TOKrparen || t.value == TOKdotdotdot)))
                         {
                             Identifier id = Identifier.generateId("__T");
-                            Loc loc = token.loc;
+                            const loc = token.loc;
                             at = new TypeIdentifier(loc, id);
                             if (!*tpl)
                                 *tpl = new TemplateParameters();
@@ -2723,7 +2728,7 @@ public:
         EnumDeclaration e;
         Identifier id;
         Type memtype;
-        Loc loc = token.loc;
+        auto loc = token.loc;
         //printf("Parser::parseEnum()\n");
         nextToken();
         if (token.value == TOKidentifier)
@@ -2737,7 +2742,7 @@ public:
         {
             nextToken();
             int alt = 0;
-            Loc typeLoc = token.loc;
+            const typeLoc = token.loc;
             memtype = parseBasicType();
             memtype = parseDeclarator(memtype, &alt, null);
             checkCstyleTypeSyntax(typeLoc, memtype, alt, null);
@@ -2827,7 +2832,7 @@ public:
         Identifier id;
         TemplateParameters* tpl = null;
         Expression constraint = null;
-        Loc loc = token.loc;
+        const loc = token.loc;
         TOK tok = token.value;
         //printf("Parser::parseAggregate()\n");
         nextToken();
@@ -2996,7 +3001,7 @@ public:
                 error("identifier expected following import");
                 break;
             }
-            Loc loc = token.loc;
+            const loc = token.loc;
             Identifier id = token.ident;
             Identifiers* a = null;
             nextToken();
@@ -3121,7 +3126,7 @@ public:
             }
             break;
         }
-        Loc typeLoc = token.loc;
+        const typeLoc = token.loc;
         Type t;
         t = parseBasicType();
         int alt = 0;
@@ -3273,7 +3278,7 @@ public:
             break;
         default:
             error("basic type expected, not %s", token.toChars());
-            t = Type.tint32;
+            t = Type.terror;
             break;
         }
         return t;
@@ -3338,7 +3343,7 @@ public:
                         }
                         maybeArray = null;
                     }
-                    Loc loc = token.loc;
+                    const loc = token.loc;
                     Identifier id = token.ident;
                     nextToken();
                     if (token.value == TOKnot)
@@ -3804,7 +3809,7 @@ public:
         TOK tok = TOKreserved;
         LINK link = linkage;
         uint structalign = 0;
-        Loc loc = token.loc;
+        auto loc = token.loc;
         Expressions* udas = null;
         Token* tk;
         //printf("parseDeclarations() %s\n", token.toChars());
@@ -4224,7 +4229,7 @@ public:
 
     Dsymbol parseFunctionLiteral()
     {
-        Loc loc = token.loc;
+        const loc = token.loc;
         TemplateParameters* tpl = null;
         Parameters* parameters = null;
         int varargs = 0;
@@ -4255,7 +4260,7 @@ public:
                 // delegate { statements... }
                 break;
             }
-            /* fall through to TOKlparen */
+            goto case TOKlparen;
         case TOKlparen:
             {
                 // (parameters) => expression
@@ -4302,7 +4307,7 @@ public:
         if (token.value == TOKgoesto)
         {
             check(TOKgoesto);
-            Loc returnloc = token.loc;
+            const returnloc = token.loc;
             Expression ae = parseAssignExp();
             fd.fbody = new ReturnStatement(returnloc, ae);
             fd.endloc = token.loc;
@@ -4406,7 +4411,7 @@ public:
                 nextToken();
                 break;
             }
-            /* fall through */
+            goto default;
         default:
             if (literal)
             {
@@ -4463,7 +4468,7 @@ public:
         Statement ifbody;
         Statement elsebody;
         bool isfinal;
-        Loc loc = token.loc;
+        const loc = token.loc;
         //printf("parseStatement()\n");
         if (flags & PScurly && token.value != TOKlcurly)
             error("statement expected to be { }, not %s", token.toChars());
@@ -4500,7 +4505,7 @@ public:
                     s = new LabelStatement(loc, ident, s);
                     break;
                 }
-                // fallthrough to TOKdot
+                goto case TOKdot;
             }
         case TOKdot:
         case TOKtypeof:
@@ -4625,6 +4630,7 @@ public:
                 goto Lexp;
             if (peekNext() == TOKlparen)
                 goto Lexp;
+            goto case;
         case TOKtypedef:
         case TOKalias:
         case TOKconst:
@@ -4722,7 +4728,7 @@ public:
             }
         case TOKlcurly:
             {
-                Loc lookingForElseSave = lookingForElse;
+                const lookingForElseSave = lookingForElse;
                 lookingForElse = Loc();
                 nextToken();
                 //if (token.value == TOKsemicolon)
@@ -4771,7 +4777,7 @@ public:
                 Statement _body;
                 Expression condition;
                 nextToken();
-                Loc lookingForElseSave = lookingForElse;
+                const lookingForElseSave = lookingForElse;
                 lookingForElse = Loc();
                 _body = parseStatement(PSscope);
                 lookingForElse = lookingForElseSave;
@@ -4800,7 +4806,7 @@ public:
                 }
                 else
                 {
-                    Loc lookingForElseSave = lookingForElse;
+                    const lookingForElseSave = lookingForElse;
                     lookingForElse = Loc();
                     _init = parseStatement(0);
                     lookingForElse = lookingForElseSave;
@@ -4999,18 +5005,16 @@ public:
                     param = new Parameter(storageClass, at, ai, null);
                 }
                 condition = parseExpression();
-                if (condition.op == TOKassign)
-                    error("assignment cannot be used as a condition, perhaps == was meant?");
                 check(TOKrparen);
                 {
-                    Loc lookingForElseSave = lookingForElse;
+                    const lookingForElseSave = lookingForElse;
                     lookingForElse = loc;
                     ifbody = parseStatement(PSscope);
                     lookingForElse = lookingForElseSave;
                 }
                 if (token.value == TOKelse)
                 {
-                    Loc elseloc = token.loc;
+                    const elseloc = token.loc;
                     nextToken();
                     elsebody = parseStatement(PSscope);
                     checkDanglingElse(elseloc);
@@ -5076,7 +5080,7 @@ public:
             goto Lcondition;
         Lcondition:
             {
-                Loc lookingForElseSave = lookingForElse;
+                const lookingForElseSave = lookingForElse;
                 lookingForElse = loc;
                 ifbody = parseStatement(0);
                 lookingForElse = lookingForElseSave;
@@ -5084,7 +5088,7 @@ public:
             elsebody = null;
             if (token.value == TOKelse)
             {
-                Loc elseloc = token.loc;
+                const elseloc = token.loc;
                 nextToken();
                 elsebody = parseStatement(0);
                 checkDanglingElse(elseloc);
@@ -5319,7 +5323,7 @@ public:
                 Catches* catches = null;
                 Statement finalbody = null;
                 nextToken();
-                Loc lookingForElseSave = lookingForElse;
+                const lookingForElseSave = lookingForElse;
                 lookingForElse = Loc();
                 _body = parseStatement(PSscope);
                 lookingForElse = lookingForElseSave;
@@ -5329,7 +5333,7 @@ public:
                     Catch c;
                     Type t;
                     Identifier id;
-                    Loc catchloc = token.loc;
+                    const catchloc = token.loc;
                     nextToken();
                     if (token.value == TOKlcurly || token.value != TOKlparen)
                     {
@@ -5510,7 +5514,7 @@ public:
         Identifier id;
         Initializer value;
         int comma;
-        Loc loc = token.loc;
+        const loc = token.loc;
         Token* t;
         int braces;
         int brackets;
@@ -6507,15 +6511,13 @@ public:
 
     Expression parseExpression()
     {
-        Expression e;
-        Expression e2;
-        Loc loc = token.loc;
+        auto loc = token.loc;
         //printf("Parser::parseExpression() loc = %d\n", loc.linnum);
-        e = parseAssignExp();
+        auto e = parseAssignExp();
         while (token.value == TOKcomma)
         {
             nextToken();
-            e2 = parseAssignExp();
+            auto e2 = parseAssignExp();
             e = new CommaExp(loc, e, e2);
             loc = token.loc;
         }
@@ -6528,7 +6530,7 @@ public:
         Expression e;
         Type t;
         Identifier id;
-        Loc loc = token.loc;
+        const loc = token.loc;
         //printf("parsePrimaryExp(): loc = %d\n", loc.linnum);
         switch (token.value)
         {
@@ -6628,7 +6630,7 @@ public:
         case TOKfile:
             {
                 const(char)* s = loc.filename ? loc.filename : mod.ident.toChars();
-                e = new StringExp(loc, cast(char*)s, strlen(s), 0);
+                e = new StringExp(loc, cast(char*)s);
                 nextToken();
                 break;
             }
@@ -6639,7 +6641,7 @@ public:
         case TOKmodulestring:
             {
                 const(char)* s = md ? md.toChars() : mod.toChars();
-                e = new StringExp(loc, cast(char*)s, strlen(s), 0);
+                e = new StringExp(loc, cast(char*)s);
                 nextToken();
                 break;
             }
@@ -6675,9 +6677,9 @@ public:
         case TOKxstring:
             {
                 // cat adjacent strings
-                char* s = token.ustring;
-                size_t len = token.len;
-                ubyte postfix = token.postfix;
+                auto s = token.ustring;
+                auto len = token.len;
+                auto postfix = token.postfix;
                 while (1)
                 {
                     nextToken();
@@ -6689,18 +6691,18 @@ public:
                                 error("mismatched string literal postfixes '%c' and '%c'", postfix, token.postfix);
                             postfix = token.postfix;
                         }
-                        size_t len1 = len;
-                        size_t len2 = token.len;
+                        const len1 = len;
+                        const len2 = token.len;
                         len = len1 + len2;
-                        char* s2 = cast(char*)mem.xmalloc((len + 1) * char.sizeof);
+                        auto s2 = cast(char*)mem.xmalloc(len * char.sizeof);
                         memcpy(s2, s, len1 * char.sizeof);
-                        memcpy(s2 + len1, token.ustring, (len2 + 1) * char.sizeof);
+                        memcpy(s2 + len1, token.ustring, len2 * char.sizeof);
                         s = s2;
                     }
                     else
                         break;
                 }
-                e = new StringExp(loc, s, len, postfix);
+                e = new StringExp(loc, cast(char*)s, len, postfix);
                 break;
             }
         case TOKvoid:
@@ -6904,7 +6906,12 @@ public:
                 if (token.value == TOKcomma)
                 {
                     nextToken();
-                    msg = parseAssignExp();
+                    if (token.value != TOKrparen)
+                    {
+                        msg = parseAssignExp();
+                        if (token.value == TOKcomma)
+                            nextToken();
+                    }
                 }
                 check(TOKrparen);
                 e = new AssertExp(loc, e, msg);
@@ -7007,7 +7014,7 @@ public:
     Expression parseUnaryExp()
     {
         Expression e;
-        Loc loc = token.loc;
+        const loc = token.loc;
         switch (token.value)
         {
         case TOKand:
@@ -7149,8 +7156,7 @@ public:
             }
         case TOKlparen:
             {
-                Token* tk;
-                tk = peek(&token);
+                auto tk = peek(&token);
                 static if (CCASTSYNTAX)
                 {
                     // If cast
@@ -7163,6 +7169,7 @@ public:
                             tk = peek(tk);
                             if (tk.value == TOKis || tk.value == TOKin) // !is or !in
                                 break;
+                            goto case;
                         case TOKdot:
                         case TOKplusplus:
                         case TOKminusminus:
@@ -7234,9 +7241,8 @@ public:
                         case TOKvoid:
                             {
                                 // (type) una_exp
-                                Type t;
                                 nextToken();
-                                t = parseType();
+                                auto t = parseType();
                                 check(TOKrparen);
                                 // if .identifier
                                 // or .identifier!( ... )
@@ -7285,10 +7291,9 @@ public:
 
     Expression parsePostExp(Expression e)
     {
-        Loc loc;
         while (1)
         {
-            loc = token.loc;
+            const loc = token.loc;
             switch (token.value)
             {
             case TOKdot:
@@ -7364,27 +7369,25 @@ public:
 
     Expression parseMulExp()
     {
-        Expression e;
-        Expression e2;
-        Loc loc = token.loc;
-        e = parseUnaryExp();
+        const loc = token.loc;
+        auto e = parseUnaryExp();
         while (1)
         {
             switch (token.value)
             {
             case TOKmul:
                 nextToken();
-                e2 = parseUnaryExp();
+                auto e2 = parseUnaryExp();
                 e = new MulExp(loc, e, e2);
                 continue;
             case TOKdiv:
                 nextToken();
-                e2 = parseUnaryExp();
+                auto e2 = parseUnaryExp();
                 e = new DivExp(loc, e, e2);
                 continue;
             case TOKmod:
                 nextToken();
-                e2 = parseUnaryExp();
+                auto e2 = parseUnaryExp();
                 e = new ModExp(loc, e, e2);
                 continue;
             default:
@@ -7397,27 +7400,25 @@ public:
 
     Expression parseAddExp()
     {
-        Expression e;
-        Expression e2;
-        Loc loc = token.loc;
-        e = parseMulExp();
+        const loc = token.loc;
+        auto e = parseMulExp();
         while (1)
         {
             switch (token.value)
             {
             case TOKadd:
                 nextToken();
-                e2 = parseMulExp();
+                auto e2 = parseMulExp();
                 e = new AddExp(loc, e, e2);
                 continue;
             case TOKmin:
                 nextToken();
-                e2 = parseMulExp();
+                auto e2 = parseMulExp();
                 e = new MinExp(loc, e, e2);
                 continue;
             case TOKtilde:
                 nextToken();
-                e2 = parseMulExp();
+                auto e2 = parseMulExp();
                 e = new CatExp(loc, e, e2);
                 continue;
             default:
@@ -7430,27 +7431,25 @@ public:
 
     Expression parseShiftExp()
     {
-        Expression e;
-        Expression e2;
-        Loc loc = token.loc;
-        e = parseAddExp();
+        const loc = token.loc;
+        auto e = parseAddExp();
         while (1)
         {
             switch (token.value)
             {
             case TOKshl:
                 nextToken();
-                e2 = parseAddExp();
+                auto e2 = parseAddExp();
                 e = new ShlExp(loc, e, e2);
                 continue;
             case TOKshr:
                 nextToken();
-                e2 = parseAddExp();
+                auto e2 = parseAddExp();
                 e = new ShrExp(loc, e, e2);
                 continue;
             case TOKushr:
                 nextToken();
-                e2 = parseAddExp();
+                auto e2 = parseAddExp();
                 e = new UshrExp(loc, e, e2);
                 continue;
             default:
@@ -7463,31 +7462,29 @@ public:
 
     Expression parseCmpExp()
     {
-        Expression e;
-        Expression e2;
-        Token* t;
-        Loc loc = token.loc;
-        e = parseShiftExp();
+        const loc = token.loc;
+        auto e = parseShiftExp();
         TOK op = token.value;
         switch (op)
         {
         case TOKequal:
         case TOKnotequal:
             nextToken();
-            e2 = parseShiftExp();
+            auto e2 = parseShiftExp();
             e = new EqualExp(op, loc, e, e2);
             break;
         case TOKis:
             op = TOKidentity;
             goto L1;
         case TOKnot:
+        {
             // Attempt to identify '!is'
-            t = peek(&token);
+            auto t = peek(&token);
             if (t.value == TOKin)
             {
                 nextToken();
                 nextToken();
-                e2 = parseShiftExp();
+                auto e2 = parseShiftExp();
                 e = new InExp(loc, e, e2);
                 e = new NotExp(loc, e);
                 break;
@@ -7497,9 +7494,10 @@ public:
             nextToken();
             op = TOKnotidentity;
             goto L1;
+        }
         L1:
             nextToken();
-            e2 = parseShiftExp();
+            auto e2 = parseShiftExp();
             e = new IdentityExp(op, loc, e, e2);
             break;
         case TOKlt:
@@ -7515,12 +7513,12 @@ public:
         case TOKug:
         case TOKue:
             nextToken();
-            e2 = parseShiftExp();
+            auto e2 = parseShiftExp();
             e = new CmpExp(op, loc, e, e2);
             break;
         case TOKin:
             nextToken();
-            e2 = parseShiftExp();
+            auto e2 = parseShiftExp();
             e = new InExp(loc, e, e2);
             break;
         default:
@@ -7532,12 +7530,12 @@ public:
     Expression parseAndExp()
     {
         Loc loc = token.loc;
-        Expression e = parseCmpExp();
+        auto e = parseCmpExp();
         while (token.value == TOKand)
         {
             checkParens(TOKand, e);
             nextToken();
-            Expression e2 = parseCmpExp();
+            auto e2 = parseCmpExp();
             checkParens(TOKand, e2);
             e = new AndExp(loc, e, e2);
             loc = token.loc;
@@ -7547,13 +7545,13 @@ public:
 
     Expression parseXorExp()
     {
-        Loc loc = token.loc;
-        Expression e = parseAndExp();
+        const loc = token.loc;
+        auto e = parseAndExp();
         while (token.value == TOKxor)
         {
             checkParens(TOKxor, e);
             nextToken();
-            Expression e2 = parseAndExp();
+            auto e2 = parseAndExp();
             checkParens(TOKxor, e2);
             e = new XorExp(loc, e, e2);
         }
@@ -7562,13 +7560,13 @@ public:
 
     Expression parseOrExp()
     {
-        Loc loc = token.loc;
-        Expression e = parseXorExp();
+        const loc = token.loc;
+        auto e = parseXorExp();
         while (token.value == TOKor)
         {
             checkParens(TOKor, e);
             nextToken();
-            Expression e2 = parseXorExp();
+            auto e2 = parseXorExp();
             checkParens(TOKor, e2);
             e = new OrExp(loc, e, e2);
         }
@@ -7577,14 +7575,12 @@ public:
 
     Expression parseAndAndExp()
     {
-        Expression e;
-        Expression e2;
-        Loc loc = token.loc;
-        e = parseOrExp();
+        const loc = token.loc;
+        auto e = parseOrExp();
         while (token.value == TOKandand)
         {
             nextToken();
-            e2 = parseOrExp();
+            auto e2 = parseOrExp();
             e = new AndAndExp(loc, e, e2);
         }
         return e;
@@ -7592,14 +7588,12 @@ public:
 
     Expression parseOrOrExp()
     {
-        Expression e;
-        Expression e2;
-        Loc loc = token.loc;
-        e = parseAndAndExp();
+        const loc = token.loc;
+        auto e = parseAndAndExp();
         while (token.value == TOKoror)
         {
             nextToken();
-            e2 = parseAndAndExp();
+            auto e2 = parseAndAndExp();
             e = new OrOrExp(loc, e, e2);
         }
         return e;
@@ -7607,17 +7601,14 @@ public:
 
     Expression parseCondExp()
     {
-        Expression e;
-        Expression e1;
-        Expression e2;
-        Loc loc = token.loc;
-        e = parseOrOrExp();
+        const loc = token.loc;
+        auto e = parseOrOrExp();
         if (token.value == TOKquestion)
         {
             nextToken();
-            e1 = parseExpression();
+            auto e1 = parseExpression();
             check(TOKcolon);
-            e2 = parseCondExp();
+            auto e2 = parseCondExp();
             e = new CondExp(loc, e, e1, e2);
         }
         return e;
@@ -7625,83 +7616,80 @@ public:
 
     Expression parseAssignExp()
     {
-        Expression e;
-        Expression e2;
-        Loc loc;
-        e = parseCondExp();
+        auto e = parseCondExp();
         while (1)
         {
-            loc = token.loc;
+            const loc = token.loc;
             switch (token.value)
             {
             case TOKassign:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new AssignExp(loc, e, e2);
                 continue;
             case TOKaddass:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new AddAssignExp(loc, e, e2);
                 continue;
             case TOKminass:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new MinAssignExp(loc, e, e2);
                 continue;
             case TOKmulass:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new MulAssignExp(loc, e, e2);
                 continue;
             case TOKdivass:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new DivAssignExp(loc, e, e2);
                 continue;
             case TOKmodass:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new ModAssignExp(loc, e, e2);
                 continue;
             case TOKpowass:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new PowAssignExp(loc, e, e2);
                 continue;
             case TOKandass:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new AndAssignExp(loc, e, e2);
                 continue;
             case TOKorass:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new OrAssignExp(loc, e, e2);
                 continue;
             case TOKxorass:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new XorAssignExp(loc, e, e2);
                 continue;
             case TOKshlass:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new ShlAssignExp(loc, e, e2);
                 continue;
             case TOKshrass:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new ShrAssignExp(loc, e, e2);
                 continue;
             case TOKushrass:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new UshrAssignExp(loc, e, e2);
                 continue;
             case TOKcatass:
                 nextToken();
-                e2 = parseAssignExp();
+                auto e2 = parseAssignExp();
                 e = new CatAssignExp(loc, e, e2);
                 continue;
             default:
@@ -7720,7 +7708,6 @@ public:
     {
         // function call
         Expressions* arguments;
-        Expression arg;
         TOK endtok;
         arguments = new Expressions();
         if (token.value == TOKlbracket)
@@ -7731,7 +7718,7 @@ public:
             nextToken();
             while (token.value != endtok && token.value != TOKeof)
             {
-                arg = parseAssignExp();
+                auto arg = parseAssignExp();
                 arguments.push(arg);
                 if (token.value == endtok)
                     break;
@@ -7746,12 +7733,10 @@ public:
      */
     Expression parseNewExp(Expression thisexp)
     {
-        Type t;
-        Expressions* newargs;
-        Expressions* arguments = null;
-        Loc loc = token.loc;
+        const loc = token.loc;
         nextToken();
-        newargs = null;
+        Expressions* newargs = null;
+        Expressions* arguments = null;
         if (token.value == TOKlparen)
         {
             newargs = parseArguments();
@@ -7781,43 +7766,33 @@ public:
                 nextToken();
                 cd.members = decl;
             }
-            Expression e = new NewAnonClassExp(loc, thisexp, newargs, cd, arguments);
+            auto e = new NewAnonClassExp(loc, thisexp, newargs, cd, arguments);
             return e;
         }
-        StorageClass stc = parseTypeCtor();
-        t = parseBasicType(true);
+        const stc = parseTypeCtor();
+        auto t = parseBasicType(true);
         t = parseBasicType2(t);
         t = t.addSTC(stc);
         if (t.ty == Taarray)
         {
             TypeAArray taa = cast(TypeAArray)t;
             Type index = taa.index;
-            Expression e = index.toExpression();
-            if (e)
-            {
-                arguments = new Expressions();
-                arguments.push(e);
-                t = new TypeDArray(taa.next);
-            }
-            else
+            auto edim = index.toExpression();
+            if (!edim)
             {
                 error("need size of rightmost array, not type %s", index.toChars());
                 return new NullExp(loc);
             }
+            t = new TypeSArray(taa.next, edim);
         }
         else if (t.ty == Tsarray)
         {
-            TypeSArray tsa = cast(TypeSArray)t;
-            Expression e = tsa.dim;
-            arguments = new Expressions();
-            arguments.push(e);
-            t = new TypeDArray(tsa.next);
         }
         else if (token.value == TOKlparen)
         {
             arguments = parseArguments();
         }
-        Expression e = new NewExp(loc, thisexp, newargs, t, arguments);
+        auto e = new NewExp(loc, thisexp, newargs, t, arguments);
         return e;
     }
 
diff --git a/ddmd/root/aav.d b/ddmd/root/aav.d
index cedc644157..1c7dd81e8e 100644
--- a/ddmd/root/aav.d
+++ b/ddmd/root/aav.d
@@ -39,7 +39,7 @@ struct AA
 /****************************************************
  * Determine number of entries in associative array.
  */
-extern (C++) size_t dmd_aaLen(AA* aa)
+extern (C++) size_t dmd_aaLen(const AA* aa) pure
 {
     return aa ? aa.nodes : 0;
 }
diff --git a/ddmd/root/aav.h b/ddmd/root/aav.h
deleted file mode 100644
index d418250341..0000000000
--- a/ddmd/root/aav.h
+++ /dev/null
@@ -1,19 +0,0 @@
-
-/* Copyright (c) 2010-2014 by Digital Mars
- * All Rights Reserved, written by Walter Bright
- * http://www.digitalmars.com
- * Distributed under the Boost Software License, Version 1.0.
- * (See accompanying file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
- * https://github.com/D-Programming-Language/dmd/blob/master/src/root/aav.h
- */
-
-typedef void* Value;
-typedef void* Key;
-
-struct AA;
-
-size_t dmd_aaLen(AA* aa);
-Value* dmd_aaGet(AA** aa, Key key);
-Value dmd_aaGetRvalue(AA* aa, Key key);
-void dmd_aaRehash(AA** paa);
-
diff --git a/ddmd/root/array.d b/ddmd/root/array.d
index 8208a7b4c7..da7800e1fd 100644
--- a/ddmd/root/array.d
+++ b/ddmd/root/array.d
@@ -30,11 +30,11 @@ public:
             mem.xfree(data);
     }
 
-    char* toChars()
+    const(char)* toChars()
     {
         static if (is(typeof(T.init.toChars())))
         {
-            char** buf = cast(char**)mem.xmalloc(dim * (char*).sizeof);
+            const(char)** buf = cast(const(char)**)mem.xmalloc(dim * (char*).sizeof);
             size_t len = 2;
             for (size_t u = 0; u < dim; u++)
             {
@@ -145,19 +145,19 @@ public:
         dim = newdim;
     }
 
-    ref T opIndex(size_t i)
+    ref inout(T) opIndex(size_t i) inout
     {
         return data[i];
     }
 
-    T* tdata()
+    inout(T)* tdata() inout
     {
         return data;
     }
 
-    typeof(this)* copy()
+    Array!T* copy() const
     {
-        auto a = new typeof(this)();
+        auto a = new Array!T();
         a.setDim(dim);
         memcpy(a.data, data, dim * (void*).sizeof);
         return a;
@@ -200,8 +200,62 @@ public:
             assert(0);
     }
 
-    extern (D) T[] opSlice()
+    extern (D) inout(T)[] opSlice() inout
     {
         return data[0 .. dim];
     }
+
+    extern (D) inout(T)[] opSlice(size_t a, size_t b) inout
+    {
+        assert(a <= b && b <= dim);
+        return data[a .. b];
+    }
+}
+
+struct BitArray
+{
+    size_t length() const
+    {
+        return len;
+    }
+
+    void length(size_t nlen)
+    {
+        immutable obytes = (len + 7) / 8;
+        immutable nbytes = (nlen + 7) / 8;
+        ptr = cast(size_t*)mem.xrealloc(ptr, nbytes);
+        if (nbytes > obytes)
+            (cast(ubyte*)ptr)[obytes .. nbytes] = 0;
+        len = nlen;
+    }
+
+    bool opIndex(size_t idx) const
+    {
+        import core.bitop : bt;
+
+        assert(idx < length);
+        return !!bt(ptr, idx);
+    }
+
+    void opIndexAssign(bool val, size_t idx)
+    {
+        import core.bitop : btc, bts;
+
+        assert(idx < length);
+        if (val)
+            bts(ptr, idx);
+        else
+            btc(ptr, idx);
+    }
+
+    @disable this(this);
+
+    ~this()
+    {
+        mem.xfree(ptr);
+    }
+
+private:
+    size_t len;
+    size_t *ptr;
 }
diff --git a/ddmd/root/array.h b/ddmd/root/array.h
index 13399d3a3d..4438a208ae 100644
--- a/ddmd/root/array.h
+++ b/ddmd/root/array.h
@@ -363,4 +363,23 @@ struct Array
 #endif
 };
 
+struct BitArray
+{
+    BitArray()
+      : len(0)
+      , ptr(NULL)
+    {}
+
+    ~BitArray()
+    {
+        mem.xfree(ptr);
+    }
+
+    size_t len;
+    size_t *ptr;
+
+private:
+    BitArray(const BitArray&);
+};
+
 #endif
diff --git a/ddmd/root/file.d b/ddmd/root/file.d
index e40c39191e..edfbbebcb4 100644
--- a/ddmd/root/file.d
+++ b/ddmd/root/file.d
@@ -20,7 +20,7 @@ struct File
     int _ref; // != 0 if this is a reference to someone else's buffer
     ubyte* buffer; // data for our file
     size_t len; // amount of data in buffer[]
-    FileName* name; // name of our file
+    const(FileName)* name; // name of our file
 
     extern (D) this(const(char)* n)
     {
@@ -40,7 +40,7 @@ struct File
         _ref = 0;
         buffer = null;
         len = 0;
-        name = cast(FileName*)n;
+        name = n;
     }
 
     extern (C++) ~this()
@@ -57,7 +57,7 @@ struct File
         }
     }
 
-    extern (C++) char* toChars()
+    extern (C++) const(char)* toChars()
     {
         return name.toChars();
     }
@@ -73,7 +73,7 @@ struct File
             size_t size;
             stat_t buf;
             ssize_t numread;
-            char* name = this.name.toChars();
+            const(char)* name = this.name.toChars();
             //printf("File::read('%s')\n",name);
             int fd = open(name, O_RDONLY);
             if (fd == -1)
@@ -126,7 +126,7 @@ struct File
         {
             DWORD size;
             DWORD numread;
-            char* name = this.name.toChars();
+            const(char)* name = this.name.toChars();
             HANDLE h = CreateFileA(name, GENERIC_READ, FILE_SHARE_READ, null, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, null);
             if (h == INVALID_HANDLE_VALUE)
                 goto err1;
@@ -173,7 +173,7 @@ struct File
         version (Posix)
         {
             ssize_t numwritten;
-            char* name = this.name.toChars();
+            const(char)* name = this.name.toChars();
             int fd = open(name, O_CREAT | O_WRONLY | O_TRUNC, (6 << 6) | (4 << 3) | 4);
             if (fd == -1)
                 goto err;
@@ -192,7 +192,7 @@ struct File
         else version (Windows)
         {
             DWORD numwritten;
-            char* name = this.name.toChars();
+            const(char)* name = this.name.toChars();
             HANDLE h = CreateFileA(name, GENERIC_WRITE, 0, null, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, null);
             if (h == INVALID_HANDLE_VALUE)
                 goto err;
diff --git a/ddmd/root/file.h b/ddmd/root/file.h
index ca7c108b70..ad296095e0 100644
--- a/ddmd/root/file.h
+++ b/ddmd/root/file.h
@@ -35,7 +35,7 @@ struct File
     File(const FileName *);
     ~File();
 
-    char *toChars();
+    const char *toChars();
 
     /* Read file, return true if error
      */
diff --git a/ddmd/root/filename.d b/ddmd/root/filename.d
index b473bfc6e9..427f180ba0 100644
--- a/ddmd/root/filename.d
+++ b/ddmd/root/filename.d
@@ -15,7 +15,7 @@ version (Windows) extern (C) int mkdir(const char*);
 version (Windows) alias _mkdir = mkdir;
 version (Posix) extern (C) char* canonicalize_file_name(const char*);
 version (Windows) extern (C) int stricmp(const char*, const char*);
-version (Windows) extern (Windows) DWORD GetFullPathNameA(LPCTSTR lpFileName, DWORD nBufferLength, LPTSTR lpBuffer, LPTSTR* lpFilePart);
+version (Windows) extern (Windows) DWORD GetFullPathNameA(LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR* lpFilePart);
 
 alias Strings = Array!(const(char)*);
 alias Files = Array!(File*);
@@ -31,7 +31,7 @@ struct FileName
         this.str = mem.xstrdup(str);
     }
 
-    extern (C++) bool equals(RootObject obj)
+    extern (C++) bool equals(const RootObject obj) const
     {
         return compare(obj) == 0;
     }
@@ -41,7 +41,7 @@ struct FileName
         return compare(name1, name2) == 0;
     }
 
-    extern (C++) int compare(RootObject obj)
+    extern (C++) int compare(const RootObject obj) const
     {
         return compare(str, (cast(FileName*)obj).str);
     }
@@ -114,7 +114,7 @@ struct FileName
         }
     }
 
-    extern (C++) const(char)* ext()
+    extern (C++) const(char)* ext() const
     {
         return ext(str);
     }
@@ -165,6 +165,7 @@ struct FileName
                      */
                     if (e == str + 1 || e == str + len - 1)
                         return e + 1;
+                    goto default;
                 }
             default:
                 if (e == str)
@@ -174,9 +175,10 @@ struct FileName
             }
             return e;
         }
+        assert(0);
     }
 
-    extern (C++) const(char)* name()
+    extern (C++) const(char)* name() const
     {
         return name(str);
     }
@@ -422,7 +424,7 @@ struct FileName
     /******************************
      * Return !=0 if extensions match.
      */
-    extern (C++) bool equalsExt(const(char)* ext)
+    extern (C++) bool equalsExt(const(char)* ext) const
     {
         return equalsExt(str, ext);
     }
@@ -675,7 +677,7 @@ struct FileName
         mem.xfree(cast(void*)str);
     }
 
-    extern (C++) char* toChars()
+    extern (C++) const(char)* toChars() const
     {
         return cast(char*)str; // toChars() should really be const
     }
diff --git a/ddmd/root/filename.h b/ddmd/root/filename.h
index 9416ce0a2e..59743ad632 100644
--- a/ddmd/root/filename.h
+++ b/ddmd/root/filename.h
@@ -53,7 +53,7 @@ struct FileName
     static const char *canonicalName(const char *name);
 
     static void free(const char *str);
-    char *toChars();
+    const char *toChars() const;
 };
 
 #endif
diff --git a/ddmd/root/outbuffer.d b/ddmd/root/outbuffer.d
index d9d8088684..728293e03f 100644
--- a/ddmd/root/outbuffer.d
+++ b/ddmd/root/outbuffer.d
@@ -276,7 +276,7 @@ struct OutBuffer
         offset += 4;
     }
 
-    extern (C++) void write(OutBuffer* buf)
+    extern (C++) void write(const OutBuffer* buf)
     {
         if (buf)
         {
@@ -401,6 +401,11 @@ struct OutBuffer
         this.offset -= nbytes;
     }
 
+    extern (D) const(char)[] peekSlice()
+    {
+        return (cast(const char*)data)[0 .. offset];
+    }
+
     // Append terminating null if necessary and get view of internal buffer
     extern (C++) char* peekString()
     {
diff --git a/ddmd/root/port.d b/ddmd/root/port.d
index 944681fb29..cf2d947194 100644
--- a/ddmd/root/port.d
+++ b/ddmd/root/port.d
@@ -362,13 +362,15 @@ extern (C++) struct Port
     }
 
     version(IN_LLVM)
-    {   // LDC_FIXME: look at the old port.c how to implement this with system calls for some OSses
+    {   
+        // LDC_FIXME: Move this into our C++ code, since only driver/gen is
+        // still using this.
         static int stricmp(const(char)* s1, const(char)* s2)
         {
             int result = 0;
-
             for (;;)
-            {   char c1 = *s1;
+            {   
+                char c1 = *s1;
                 char c2 = *s2;
 
                 result = c1 - c2;
@@ -386,4 +388,16 @@ extern (C++) struct Port
             return result;
         }
     }
+
+    static void valcpy(void *dst, ulong val, size_t size)
+    {
+        switch (size)
+        {
+            case 1: *cast(ubyte *)dst = cast(ubyte)val; break;
+            case 2: *cast(ushort *)dst = cast(ushort)val; break;
+            case 4: *cast(uint *)dst = cast(uint)val; break;
+            case 8: *cast(ulong *)dst = cast(ulong)val; break;
+            default: assert(0);
+        }
+    }
 }
diff --git a/ddmd/root/port.h b/ddmd/root/port.h
index e3b06ef34e..4116ac5eac 100644
--- a/ddmd/root/port.h
+++ b/ddmd/root/port.h
@@ -79,6 +79,7 @@ struct Port
     static unsigned readlongBE(void* buffer);
     static unsigned readwordLE(void* buffer);
     static unsigned readwordBE(void* buffer);
+    static void valcpy(void *dst, uint64_t val, size_t size);
 };
 
 #endif
diff --git a/ddmd/root/rmem.d b/ddmd/root/rmem.d
index e55d7bd228..a0a0cfd36b 100644
--- a/ddmd/root/rmem.d
+++ b/ddmd/root/rmem.d
@@ -16,26 +16,26 @@ version (GC)
 
     extern (C++) struct Mem
     {
-        char* xstrdup(const(char)* p)
+        static char* xstrdup(const(char)* p) nothrow
         {
             return p[0 .. strlen(p) + 1].dup.ptr;
         }
 
-        void xfree(void* p)
+        static void xfree(void* p) nothrow
         {
         }
 
-        void* xmalloc(size_t n)
+        static void* xmalloc(size_t n) nothrow
         {
             return GC.malloc(n);
         }
 
-        void* xcalloc(size_t size, size_t n)
+        static void* xcalloc(size_t size, size_t n) nothrow
         {
             return GC.calloc(size * n);
         }
 
-        void* xrealloc(void* p, size_t size)
+        static void* xrealloc(void* p, size_t size) nothrow
         {
             return GC.realloc(p, size);
         }
@@ -50,7 +50,7 @@ else
 
     extern (C++) struct Mem
     {
-        char* xstrdup(const(char)* s)
+        static char* xstrdup(const(char)* s) nothrow
         {
             if (s)
             {
@@ -62,13 +62,13 @@ else
             return null;
         }
 
-        void xfree(void* p)
+        static void xfree(void* p) nothrow
         {
             if (p)
                 .free(p);
         }
 
-        void* xmalloc(size_t size)
+        static void* xmalloc(size_t size) nothrow
         {
             if (!size)
                 return null;
@@ -79,7 +79,7 @@ else
             return p;
         }
 
-        void* xcalloc(size_t size, size_t n)
+        static void* xcalloc(size_t size, size_t n) nothrow
         {
             if (!size || !n)
                 return null;
@@ -90,7 +90,7 @@ else
             return p;
         }
 
-        void* xrealloc(void* p, size_t size)
+        static void* xrealloc(void* p, size_t size) nothrow
         {
             if (!size)
             {
@@ -113,7 +113,7 @@ else
             return p;
         }
 
-        void error()
+        static void error() nothrow
         {
             printf("Error: out of memory\n");
             exit(EXIT_FAILURE);
@@ -127,7 +127,7 @@ else
     __gshared size_t heapleft = 0;
     __gshared void* heapp;
 
-    extern (C) void* allocmemory(size_t m_size)
+    extern (C) void* allocmemory(size_t m_size) nothrow
     {
         // 16 byte alignment is better (and sometimes needed) for doubles
         m_size = (m_size + 15) & ~15;
@@ -165,26 +165,26 @@ else
 
     version(DigitalMars)
     {
-        extern (C) void* _d_allocmemory(size_t m_size)
+        extern (C) void* _d_allocmemory(size_t m_size) nothrow
         {
             return allocmemory(m_size);
         }
 
-        extern (C) Object _d_newclass(const ClassInfo ci)
+        extern (C) Object _d_newclass(const ClassInfo ci) nothrow
         {
             auto p = allocmemory(ci.init.length);
             p[0 .. ci.init.length] = cast(void[])ci.init[];
             return cast(Object)p;
         }
 
-        extern (C) void* _d_newitemT(TypeInfo ti)
+        extern (C) void* _d_newitemT(TypeInfo ti) nothrow
         {
             auto p = allocmemory(ti.tsize);
             (cast(ubyte*)p)[0 .. ti.init.length] = 0;
             return p;
         }
 
-        extern (C) void* _d_newitemiT(TypeInfo ti)
+        extern (C) void* _d_newitemiT(TypeInfo ti) nothrow
         {
             auto p = allocmemory(ti.tsize);
             p[0 .. ti.init.length] = ti.init[];
diff --git a/ddmd/root/rmem.h b/ddmd/root/rmem.h
index 4353fe2cd7..a9037c265b 100644
--- a/ddmd/root/rmem.h
+++ b/ddmd/root/rmem.h
@@ -25,17 +25,13 @@ struct Mem
 {
     Mem() { }
 
-#if IN_LLVM
-    char *xstrdup(const char *s);
-#else
-    char *xstrdup(const char *s);
-#endif
-    void *xmalloc(d_size_t size);
-    void *xcalloc(d_size_t size, d_size_t n);
-    void *xrealloc(void *p, d_size_t size);
-    void xfree(void *p);
-    void *xmallocdup(void *o, d_size_t size);
-    void error();
+    static char *xstrdup(const char *s);
+    static void *xmalloc(d_size_t size);
+    static void *xcalloc(d_size_t size, d_size_t n);
+    static void *xrealloc(void *p, d_size_t size);
+    static void xfree(void *p);
+    static void *xmallocdup(void *o, d_size_t size);
+    static void error();
 };
 
 extern Mem mem;
diff --git a/ddmd/root/rootobject.d b/ddmd/root/rootobject.d
index cdca45535b..729b794014 100644
--- a/ddmd/root/rootobject.d
+++ b/ddmd/root/rootobject.d
@@ -35,7 +35,7 @@ extern (C++) class RootObject
         printf("%s %p\n", toChars(), this);
     }
 
-    char* toChars()
+    const(char)* toChars()
     {
         assert(0);
     }
diff --git a/ddmd/root/stringtable.d b/ddmd/root/stringtable.d
index 8f3810e690..0a1c3b4a36 100644
--- a/ddmd/root/stringtable.d
+++ b/ddmd/root/stringtable.d
@@ -42,11 +42,14 @@ private uint calcHash(const(char)* key, size_t len) pure nothrow @nogc
     {
     case 3:
         h ^= data[2] << 16;
+        goto case;
     case 2:
         h ^= data[1] << 8;
+        goto case;
     case 1:
         h ^= data[0];
         h *= m;
+        goto default;
     default:
         break;
     }
@@ -86,12 +89,12 @@ struct StringValue
         return cast(char*)(&this + 1);
     }
 
-    extern (C++) const(size_t) len()
+    extern (C++) size_t len() const
     {
         return length;
     }
 
-    extern (C++) const(const(char)*) toDchars()
+    extern (C++) const(char)* toDchars() const
     {
         return cast(const(char)*)(&this + 1);
     }
diff --git a/ddmd/statement.d b/ddmd/statement.d
index 203f1d73bc..f84d6e7028 100644
--- a/ddmd/statement.d
+++ b/ddmd/statement.d
@@ -10,6 +10,7 @@ module ddmd.statement;
 
 import core.stdc.stdarg;
 import core.stdc.stdio;
+
 import ddmd.aggregate;
 import ddmd.aliasthis;
 import ddmd.arrayop;
@@ -66,8 +67,7 @@ extern (C++) Identifier fixupLabelName(Scope* sc, Identifier ident)
         const(char)* prefix = flags == SCOPErequire ? "__in_" : "__out_";
         OutBuffer buf;
         buf.printf("%s%s", prefix, ident.toChars());
-        const(char)* name = buf.extractString();
-        ident = Identifier.idPool(name);
+        ident = Identifier.idPool(buf.peekSlice());
     }
     return ident;
 }
@@ -81,6 +81,27 @@ extern (C++) LabelStatement checkLabeledLoop(Scope* sc, Statement statement)
     return null;
 }
 
+/***********************************************************
+ * Check an assignment is used as a condition.
+ * Intended to be use before the `semantic` call on `e`.
+ * Params:
+ *  e = condition expression which is not yet run semantic analysis.
+ * Returns:
+ *  `e` or ErrorExp.
+ */
+Expression checkAssignmentAsCondition(Expression e)
+{
+    auto ec = e;
+    while (ec.op == TOKcomma)
+        ec = (cast(CommaExp)ec).e2;
+    if (ec.op == TOKassign)
+    {
+        ec.error("assignment cannot be used as a condition, perhaps == was meant?");
+        return new ErrorExp();
+    }
+    return e;
+}
+
 enum BE : int
 {
     BEnone = 0,
@@ -131,7 +152,7 @@ public:
         fflush(stderr);
     }
 
-    override final char* toChars()
+    override final const(char)* toChars()
     {
         HdrGenState hgs;
         OutBuffer buf;
@@ -1137,27 +1158,19 @@ public:
     {
         if (exp)
         {
-            //printf("ExpStatement::semantic() %s\n", exp->toChars());
-            version (none)
-            {
-                // Doesn't work because of difficulty dealing with things like a.b.c!(args).Foo!(args)
-                // See if this should be rewritten as a TemplateMixin
-                if (exp.op == TOKdeclaration)
-                {
-                    DeclarationExp de = cast(DeclarationExp)exp;
-                    Dsymbol s = de.declaration;
-                    printf("s: %s %s\n", s.kind(), s.toChars());
-                    VarDeclaration v = s.isVarDeclaration();
-                    if (v)
-                    {
-                        printf("%s, %d\n", v.type.toChars(), v.type.ty);
-                    }
-                }
-            }
+            //printf("ExpStatement::semantic() %s\n", exp.toChars());
             exp = exp.semantic(sc);
             exp = resolveProperties(sc, exp);
             exp = exp.addDtorHook(sc);
+            if (checkNonAssignmentArrayOp(exp))
+                exp = new ErrorExp();
+            if (auto f = isFuncAddress(exp))
+            {
+                if (f.checkForwardRef(exp.loc))
+                    exp = new ErrorExp();
+            }
             discardValue(exp);
+
             exp = exp.optimize(WANTvalue);
             exp = checkGC(sc, exp);
             if (exp.op == TOKerror)
@@ -1173,42 +1186,17 @@ public:
         *sentry = null;
         *sexception = null;
         *sfinally = null;
-        if (exp)
+        if (exp && exp.op == TOKdeclaration)
         {
-            if (exp.op == TOKdeclaration)
+            auto de = cast(DeclarationExp)exp;
+            auto v = de.declaration.isVarDeclaration();
+            if (v && !v.isDataseg())
             {
-                DeclarationExp de = cast(DeclarationExp)exp;
-                VarDeclaration v = de.declaration.isVarDeclaration();
-                if (v && !v.noscope && !v.isDataseg())
+                if (v.needsScopeDtor())
                 {
-                    Expression e = v.edtor;
-                    if (e)
-                    {
-                        //printf("dtor is: "); e->print();
-                        version (none)
-                        {
-                            if (v.type.toBasetype().ty == Tstruct)
-                            {
-                                /* Need a 'gate' to turn on/off destruction,
-                                 * in case v gets moved elsewhere.
-                                 */
-                                Identifier id = Identifier.generateId("__runDtor");
-                                auto ie = new ExpInitializer(loc, new IntegerExp(1));
-                                auto rd = new VarDeclaration(loc, Type.tint32, id, ie);
-                                rd.storage_class |= STCtemp;
-                                *sentry = new ExpStatement(loc, rd);
-                                v.rundtor = rd;
-                                /* Rewrite e as:
-                                 *  rundtor && e
-                                 */
-                                Expression ve = new VarExp(loc, v.rundtor);
-                                e = new AndAndExp(loc, ve, e);
-                                e.type = Type.tbool;
-                            }
-                        }
-                        *sfinally = new DtorExpStatement(loc, e, v);
-                    }
-                    v.noscope = 1; // don't add in dtor again
+                    //printf("dtor is: "); v.edtor.print();
+                    *sfinally = new DtorExpStatement(loc, v.edtor, v);
+                    v.noscope = true; // don't add in dtor again
                 }
             }
         }
@@ -1328,7 +1316,7 @@ public:
             {
                 se = se.toUTF8(sc);
                 uint errors = global.errors;
-                scope Parser p = new Parser(loc, sc._module, cast(char*)se.string, se.len, 0);
+                scope Parser p = new Parser(loc, sc._module, se.toStringz(), se.len, 0);
                 p.nextToken();
                 while (p.token.value != TOKeof)
                 {
@@ -1819,7 +1807,10 @@ public:
 
     override Statement syntaxCopy()
     {
-        return new WhileStatement(loc, condition.syntaxCopy(), _body ? _body.syntaxCopy() : null, endloc);
+        return new WhileStatement(loc,
+            condition.syntaxCopy(),
+            _body ? _body.syntaxCopy() : null,
+            endloc);
     }
 
     override Statement semantic(Scope* sc)
@@ -1864,7 +1855,9 @@ public:
 
     override Statement syntaxCopy()
     {
-        return new DoStatement(loc, _body ? _body.syntaxCopy() : null, condition.syntaxCopy());
+        return new DoStatement(loc,
+            _body ? _body.syntaxCopy() : null,
+            condition.syntaxCopy());
     }
 
     override Statement semantic(Scope* sc)
@@ -1873,15 +1866,24 @@ public:
         if (_body)
             _body = _body.semanticScope(sc, this, this);
         sc.noctor--;
+
+        // check in syntax level
+        condition = checkAssignmentAsCondition(condition);
+
         condition = condition.semantic(sc);
         condition = resolveProperties(sc, condition);
+        if (checkNonAssignmentArrayOp(condition))
+            condition = new ErrorExp();
         condition = condition.optimize(WANTvalue);
         condition = checkGC(sc, condition);
+
         condition = condition.toBoolean(sc);
+
         if (condition.op == TOKerror)
             return new ErrorStatement();
         if (_body && _body.isErrorStatement())
             return _body;
+
         return this;
     }
 
@@ -1929,12 +1931,18 @@ public:
 
     override Statement syntaxCopy()
     {
-        return new ForStatement(loc, _init ? _init.syntaxCopy() : null, condition ? condition.syntaxCopy() : null, increment ? increment.syntaxCopy() : null, _body.syntaxCopy(), endloc);
+        return new ForStatement(loc,
+            _init ? _init.syntaxCopy() : null,
+            condition ? condition.syntaxCopy() : null,
+            increment ? increment.syntaxCopy() : null,
+            _body.syntaxCopy(),
+            endloc);
     }
 
     override Statement semantic(Scope* sc)
     {
         //printf("ForStatement::semantic %s\n", toChars());
+
         if (_init)
         {
             /* Rewrite:
@@ -1965,33 +1973,50 @@ public:
             return s;
         }
         assert(_init is null);
+
         auto sym = new ScopeDsymbol();
         sym.parent = sc.scopesym;
         sc = sc.push(sym);
+
         sc.noctor++;
         if (condition)
         {
+            // check in syntax level
+            condition = checkAssignmentAsCondition(condition);
+
             condition = condition.semantic(sc);
             condition = resolveProperties(sc, condition);
+            if (checkNonAssignmentArrayOp(condition))
+                condition = new ErrorExp();
             condition = condition.optimize(WANTvalue);
             condition = checkGC(sc, condition);
+
             condition = condition.toBoolean(sc);
         }
         if (increment)
         {
             increment = increment.semantic(sc);
             increment = resolveProperties(sc, increment);
+            if (checkNonAssignmentArrayOp(increment))
+                increment = new ErrorExp();
             increment = increment.optimize(WANTvalue);
             increment = checkGC(sc, increment);
         }
+
         sc.sbreak = this;
         sc.scontinue = this;
         if (_body)
             _body = _body.semanticNoScope(sc);
         sc.noctor--;
+
         sc.pop();
-        if (condition && condition.op == TOKerror || increment && increment.op == TOKerror || _body && _body.isErrorStatement())
+
+        if (condition && condition.op == TOKerror ||
+            increment && increment.op == TOKerror ||
+            _body && _body.isErrorStatement())
+        {
             return new ErrorStatement();
+        }
         return this;
     }
 
@@ -2055,7 +2080,11 @@ public:
 
     override Statement syntaxCopy()
     {
-        return new ForeachStatement(loc, op, Parameter.arraySyntaxCopy(parameters), aggr.syntaxCopy(), _body ? _body.syntaxCopy() : null, endloc);
+        return new ForeachStatement(loc, op,
+            Parameter.arraySyntaxCopy(parameters),
+            aggr.syntaxCopy(),
+            _body ? _body.syntaxCopy() : null,
+            endloc);
     }
 
     override Statement semantic(Scope* sc)
@@ -2066,11 +2095,14 @@ public:
         size_t dim = parameters.dim;
         TypeAArray taa = null;
         Dsymbol sapply = null;
+
         Type tn = null;
         Type tnv = null;
+
         func = sc.func;
         if (func.fes)
             func = func.fes.func;
+
         VarDeclaration vinit = null;
         aggr = aggr.semantic(sc);
         aggr = resolveProperties(sc, aggr);
@@ -2078,7 +2110,8 @@ public:
         if (aggr.op == TOKerror)
             return new ErrorStatement();
         Expression oaggr = aggr;
-        if (aggr.type && aggr.type.toBasetype().ty == Tstruct && aggr.op != TOKtype && !aggr.isLvalue())
+        if (aggr.type && aggr.type.toBasetype().ty == Tstruct &&
+            aggr.op != TOKtype && !aggr.isLvalue())
         {
             // Bugzilla 14653: Extend the life of rvalue aggregate till the end of foreach.
             vinit = new VarDeclaration(loc, aggr.type, Identifier.generateId("__aggr"), new ExpInitializer(loc, aggr));
@@ -2086,6 +2119,7 @@ public:
             vinit.semantic(sc);
             aggr = new VarExp(aggr.loc, vinit);
         }
+
         if (!inferAggregate(this, sc, sapply))
         {
             const(char)* msg = "";
@@ -2096,7 +2130,9 @@ public:
             error("invalid foreach aggregate %s%s", oaggr.toChars(), msg);
             return new ErrorStatement();
         }
+
         Dsymbol sapplyOld = sapply; // 'sapply' will be NULL if and after 'inferApplyArgTypes' errors
+
         /* Check for inference errors
          */
         if (!inferApplyArgTypes(this, sc, sapply))
@@ -2113,11 +2149,14 @@ public:
                 {
                     int fvarargs; // ignored (opApply shouldn't take variadics)
                     Parameters* fparameters = fd.getParameters(&fvarargs);
+
                     if (Parameter.dim(fparameters) == 1)
                     {
                         // first param should be the callback function
                         Parameter fparam = Parameter.getNth(fparameters, 0);
-                        if ((fparam.type.ty == Tpointer || fparam.type.ty == Tdelegate) && fparam.type.nextOf().ty == Tfunction)
+                        if ((fparam.type.ty == Tpointer ||
+                             fparam.type.ty == Tdelegate) &&
+                            fparam.type.nextOf().ty == Tfunction)
                         {
                             TypeFunction tf = cast(TypeFunction)fparam.type.nextOf();
                             foreachParamCount = Parameter.dim(tf.parameters);
@@ -2126,17 +2165,22 @@ public:
                     }
                 }
             }
+
             //printf("dim = %d, parameters->dim = %d\n", dim, parameters->dim);
             if (foundMismatch && dim != foreachParamCount)
             {
                 const(char)* plural = foreachParamCount > 1 ? "s" : "";
-                error("cannot infer argument types, expected %d argument%s, not %d", foreachParamCount, plural, dim);
+                error("cannot infer argument types, expected %d argument%s, not %d",
+                    foreachParamCount, plural, dim);
             }
             else
                 error("cannot uniquely infer foreach argument types");
+
             return new ErrorStatement();
         }
+
         Type tab = aggr.type.toBasetype();
+
         if (tab.ty == Ttuple) // don't generate new scope for tuple loops
         {
             if (dim < 1 || dim > 2)
@@ -2144,6 +2188,7 @@ public:
                 error("only one (value) or two (key,value) arguments for tuple foreach");
                 return new ErrorStatement();
             }
+
             Type paramtype = (*parameters)[dim - 1].type;
             if (paramtype)
             {
@@ -2151,6 +2196,7 @@ public:
                 if (paramtype.ty == Terror)
                     return new ErrorStatement();
             }
+
             TypeTuple tuple = cast(TypeTuple)tab;
             auto statements = new Statements();
             //printf("aggr: op = %d, %s\n", aggr->op, aggr->toChars());
@@ -2178,6 +2224,7 @@ public:
                     t = Parameter.getNth(tuple.arguments, k).type;
                 Parameter p = (*parameters)[0];
                 auto st = new Statements();
+
                 if (dim == 2)
                 {
                     // Declare key
@@ -2211,7 +2258,8 @@ public:
                     p = (*parameters)[1]; // value
                 }
                 // Declare value
-                if (p.storageClass & (STCout | STClazy) || p.storageClass & STCref && !te)
+                if (p.storageClass & (STCout | STClazy) ||
+                    p.storageClass & STCref && !te)
                 {
                     error("no storage class for value %s", p.ident.toChars());
                     return new ErrorStatement();
@@ -2229,9 +2277,10 @@ public:
                         ds = (cast(ScopeExp)e).sds;
                     else if (e.op == TOKfunction)
                     {
-                        FuncExp fe = cast(FuncExp)e;
+                        auto fe = cast(FuncExp)e;
                         ds = fe.td ? cast(Dsymbol)fe.td : fe.fd;
                     }
+
                     if (ds)
                     {
                         var = new AliasDeclaration(loc, p.ident, ds);
@@ -2264,7 +2313,10 @@ public:
                         auto v = new VarDeclaration(loc, p.type, p.ident, ie);
                         if (p.storageClass & STCref)
                             v.storage_class |= STCref | STCforeach;
-                        if (e.isConst() || e.op == TOKstring || e.op == TOKstructliteral || e.op == TOKarrayliteral)
+                        if (e.isConst() ||
+                            e.op == TOKstring ||
+                            e.op == TOKstructliteral ||
+                            e.op == TOKarrayliteral)
                         {
                             if (v.storage_class & STCref)
                             {
@@ -2287,11 +2339,13 @@ public:
                     }
                 }
                 st.push(new ExpStatement(loc, var));
+
                 st.push(_body.syntaxCopy());
                 s = new CompoundStatement(loc, st);
                 s = new ScopeStatement(loc, s);
                 statements.push(s);
             }
+
             s = new UnrolledLoopStatement(loc, statements);
             if (LabelStatement ls = checkLabeledLoop(sc, this))
                 ls.gotoTarget = s;
@@ -2302,10 +2356,11 @@ public:
             s = s.semantic(sc);
             return s;
         }
+
         sym = new ScopeDsymbol();
         sym.parent = sc.scopesym;
-        sc = sc.push(sym);
-        sc.noctor++;
+        auto sc2 = sc.push(sym);
+        sc2.noctor++;
         switch (tab.ty)
         {
         case Tarray:
@@ -2313,11 +2368,13 @@ public:
             {
                 if (checkForArgTypes())
                     return this;
+
                 if (dim < 1 || dim > 2)
                 {
                     error("only one or two arguments for array foreach");
                     goto Lerror2;
                 }
+
                 /* Look for special case of parsing char types out of char type
                  * array.
                  */
@@ -2326,10 +2383,11 @@ public:
                 {
                     int i = (dim == 1) ? 0 : 1; // index of value
                     Parameter p = (*parameters)[i];
-                    p.type = p.type.semantic(loc, sc);
+                    p.type = p.type.semantic(loc, sc2);
                     p.type = p.type.addStorageClass(p.storageClass);
                     tnv = p.type.toBasetype();
-                    if (tnv.ty != tn.ty && (tnv.ty == Tchar || tnv.ty == Twchar || tnv.ty == Tdchar))
+                    if (tnv.ty != tn.ty &&
+                        (tnv.ty == Tchar || tnv.ty == Twchar || tnv.ty == Tdchar))
                     {
                         if (p.storageClass & STCref)
                         {
@@ -2348,25 +2406,29 @@ public:
                         goto Lapply;
                     }
                 }
+
                 foreach (i; 0 .. dim)
                 {
                     // Declare parameterss
                     Parameter p = (*parameters)[i];
-                    p.type = p.type.semantic(loc, sc);
+                    p.type = p.type.semantic(loc, sc2);
                     p.type = p.type.addStorageClass(p.storageClass);
                     VarDeclaration var;
+
                     if (dim == 2 && i == 0)
                     {
                         var = new VarDeclaration(loc, p.type.mutableOf(), Identifier.generateId("__key"), null);
                         var.storage_class |= STCtemp | STCforeach;
                         if (var.storage_class & (STCref | STCout))
                             var.storage_class |= STCnodtor;
+
                         key = var;
                         if (p.storageClass & STCref)
                         {
                             if (var.type.constConv(p.type) <= MATCHnomatch)
                             {
-                                error("key type mismatch, %s to ref %s", var.type.toChars(), p.type.toChars());
+                                error("key type mismatch, %s to ref %s",
+                                    var.type.toChars(), p.type.toChars());
                                 goto Lerror2;
                             }
                         }
@@ -2376,7 +2438,8 @@ public:
                             IntRange dimrange = getIntRange(ta.dim);
                             if (!IntRange.fromType(var.type).contains(dimrange))
                             {
-                                error("index type '%s' cannot cover index range 0..%llu", p.type.toChars(), ta.dim.toInteger());
+                                error("index type '%s' cannot cover index range 0..%llu",
+                                    p.type.toChars(), ta.dim.toInteger());
                                 goto Lerror2;
                             }
                             key.range = new IntRange(SignExtendedNumber(0), dimrange.imax);
@@ -2389,20 +2452,24 @@ public:
                         var.storage_class |= p.storageClass & (STCin | STCout | STCref | STC_TYPECTOR);
                         if (var.storage_class & (STCref | STCout))
                             var.storage_class |= STCnodtor;
+
                         value = var;
                         if (var.storage_class & STCref)
                         {
-                            if (aggr.checkModifiable(sc, 1) == 2)
+                            if (aggr.checkModifiable(sc2, 1) == 2)
                                 var.storage_class |= STCctorinit;
+
                             Type t = tab.nextOf();
                             if (t.constConv(p.type) <= MATCHnomatch)
                             {
-                                error("argument type mismatch, %s to ref %s", t.toChars(), p.type.toChars());
+                                error("argument type mismatch, %s to ref %s",
+                                    t.toChars(), p.type.toChars());
                                 goto Lerror2;
                             }
                         }
                     }
                 }
+
                 /* Convert to a ForStatement
                  *   foreach (key, value; a) body =>
                  *   for (T[] tmp = a[], size_t key; key < tmp.length; ++key)
@@ -2415,18 +2482,22 @@ public:
                 Identifier id = Identifier.generateId("__r");
                 auto ie = new ExpInitializer(loc, new SliceExp(loc, aggr, null, null));
                 VarDeclaration tmp;
-                if (aggr.op == TOKarrayliteral && !((*parameters)[dim - 1].storageClass & STCref))
+                if (aggr.op == TOKarrayliteral &&
+                    !((*parameters)[dim - 1].storageClass & STCref))
                 {
-                    ArrayLiteralExp ale = cast(ArrayLiteralExp)aggr;
+                    auto ale = cast(ArrayLiteralExp)aggr;
                     size_t edim = ale.elements ? ale.elements.dim : 0;
                     aggr.type = tab.nextOf().sarrayOf(edim);
+
                     // for (T[edim] tmp = a, ...)
                     tmp = new VarDeclaration(loc, aggr.type, id, ie);
                 }
                 else
                     tmp = new VarDeclaration(loc, tab.nextOf().arrayOf(), id, ie);
                 tmp.storage_class |= STCtemp;
+
                 Expression tmp_length = new DotIdExp(loc, new VarExp(loc, tmp), Id.length);
+
                 if (!key)
                 {
                     Identifier idkey = Identifier.generateId("__key");
@@ -2437,12 +2508,14 @@ public:
                     key._init = new ExpInitializer(loc, tmp_length);
                 else
                     key._init = new ExpInitializer(loc, new IntegerExp(loc, 0, key.type));
+
                 auto cs = new Statements();
                 if (vinit)
                     cs.push(new ExpStatement(loc, vinit));
                 cs.push(new ExpStatement(loc, tmp));
                 cs.push(new ExpStatement(loc, key));
                 Statement forinit = new CompoundDeclarationStatement(loc, cs);
+
                 Expression cond;
                 if (op == TOKforeach_reverse)
                 {
@@ -2454,15 +2527,20 @@ public:
                     // key < tmp.length
                     cond = new CmpExp(TOKlt, loc, new VarExp(loc, key), tmp_length);
                 }
+
                 Expression increment = null;
                 if (op == TOKforeach)
                 {
                     // key += 1
                     increment = new AddAssignExp(loc, new VarExp(loc, key), new IntegerExp(loc, 1, key.type));
                 }
+
                 // T value = tmp[key];
-                value._init = new ExpInitializer(loc, new IndexExp(loc, new VarExp(loc, tmp), new VarExp(loc, key)));
+                IndexExp indexExp = new IndexExp(loc, new VarExp(loc, tmp), new VarExp(loc, key));
+                indexExp.indexIsInBounds = true; // disabling bounds checking in foreach statements.
+                value._init = new ExpInitializer(loc, indexExp);
                 Statement ds = new ExpStatement(loc, value);
+
                 if (dim == 2)
                 {
                     Parameter p = (*parameters)[0];
@@ -2487,10 +2565,11 @@ public:
                     }
                 }
                 _body = new CompoundStatement(loc, ds, _body);
+
                 s = new ForStatement(loc, forinit, cond, increment, _body, endloc);
-                if (LabelStatement ls = checkLabeledLoop(sc, this))
+                if (auto ls = checkLabeledLoop(sc, this))   // Bugzilla 15450: don't use sc2
                     ls.gotoTarget = s;
-                s = s.semantic(sc);
+                s = s.semantic(sc2);
                 break;
             }
         case Taarray:
@@ -2498,6 +2577,7 @@ public:
                 warning("cannot use foreach_reverse with an associative array");
             if (checkForArgTypes())
                 return this;
+
             taa = cast(TypeAArray)tab;
             if (dim < 1 || dim > 2)
             {
@@ -2505,6 +2585,7 @@ public:
                 goto Lerror2;
             }
             goto Lapply;
+
         case Tclass:
         case Tstruct:
             /* Prefer using opApply, if it exists
@@ -2521,7 +2602,9 @@ public:
                  *        ...
                  *    }
                  */
-                AggregateDeclaration ad = (tab.ty == Tclass) ? cast(AggregateDeclaration)(cast(TypeClass)tab).sym : cast(AggregateDeclaration)(cast(TypeStruct)tab).sym;
+                auto ad = (tab.ty == Tclass) ?
+                    cast(AggregateDeclaration)(cast(TypeClass)tab).sym :
+                    cast(AggregateDeclaration)(cast(TypeStruct)tab).sym;
                 Identifier idfront;
                 Identifier idpopFront;
                 if (op == TOKforeach)
@@ -2534,9 +2617,10 @@ public:
                     idfront = Id.Fback;
                     idpopFront = Id.FpopBack;
                 }
-                Dsymbol sfront = ad.search(Loc(), idfront);
+                auto sfront = ad.search(Loc(), idfront);
                 if (!sfront)
                     goto Lapply;
+
                 /* Generate a temporary __r and initialize it with the aggregate.
                  */
                 VarDeclaration r;
@@ -2548,20 +2632,23 @@ public:
                 }
                 else
                 {
-                    Identifier rid = Identifier.generateId("__r");
+                    auto rid = Identifier.generateId("__r");
                     r = new VarDeclaration(loc, null, rid, new ExpInitializer(loc, aggr));
                     r.storage_class |= STCtemp;
                     _init = new ExpStatement(loc, r);
                     if (vinit)
                         _init = new CompoundStatement(loc, new ExpStatement(loc, vinit), _init);
                 }
+
                 // !__r.empty
                 Expression e = new VarExp(loc, r);
                 e = new DotIdExp(loc, e, Id.Fempty);
                 Expression condition = new NotExp(loc, e);
+
                 // __r.idpopFront()
                 e = new VarExp(loc, r);
                 Expression increment = new CallExp(loc, new DotIdExp(loc, e, idpopFront));
+
                 /* Declaration statement for e:
                  *    auto e = __r.idfront;
                  */
@@ -2570,33 +2657,54 @@ public:
                 Statement makeargs, forbody;
                 if (dim == 1)
                 {
-                    Parameter p = (*parameters)[0];
+                    auto p = (*parameters)[0];
                     auto ve = new VarDeclaration(loc, p.type, p.ident, new ExpInitializer(loc, einit));
                     ve.storage_class |= STCforeach;
                     ve.storage_class |= p.storageClass & (STCin | STCout | STCref | STC_TYPECTOR);
+
                     makeargs = new ExpStatement(loc, ve);
                 }
                 else
                 {
-                    Identifier id = Identifier.generateId("__front");
+                    auto id = Identifier.generateId("__front");
                     auto ei = new ExpInitializer(loc, einit);
                     auto vd = new VarDeclaration(loc, null, id, ei);
                     vd.storage_class |= STCtemp | STCctfe | STCref | STCforeach;
+
                     makeargs = new ExpStatement(loc, vd);
-                    Declaration d = sfront.isDeclaration();
-                    if (FuncDeclaration f = d.isFuncDeclaration())
+
+                    Type tfront;
+                    if (auto fd = sfront.isFuncDeclaration())
                     {
-                        if (!f.functionSemantic())
+                        if (!fd.functionSemantic())
                             goto Lrangeerr;
+                        tfront = fd.type;
                     }
-                    Expression ve = new VarExp(loc, vd);
-                    ve.type = d.type;
-                    if (ve.type.toBasetype().ty == Tfunction)
-                        ve.type = ve.type.toBasetype().nextOf();
-                    if (!ve.type || ve.type.ty == Terror)
+                    else if (auto td = sfront.isTemplateDeclaration())
+                    {
+                        Expressions a;
+                        if (auto f = resolveFuncCall(loc, sc, td, null, tab, &a, 1))
+                            tfront = f.type;
+                    }
+                    else if (auto d = sfront.isDeclaration())
+                    {
+                        tfront = d.type;
+                    }
+                    if (!tfront || tfront.ty == Terror)
                         goto Lrangeerr;
+                    if (tfront.toBasetype().ty == Tfunction)
+                        tfront = tfront.toBasetype().nextOf();
+                    if (tfront.ty == Tvoid)
+                    {
+                        error("%s.front is void and has no value", oaggr.toChars());
+                        goto Lerror2;
+                    }
                     // Resolve inout qualifier of front type
-                    ve.type = ve.type.substWildTo(tab.mod);
+                    tfront = tfront.substWildTo(tab.mod);
+
+                    Expression ve = new VarExp(loc, vd);
+                    ve.type = tfront;
+
                     auto exps = new Expressions();
                     exps.push(ve);
                     int pos = 0;
@@ -2609,31 +2717,39 @@ public:
                     if (exps.dim != dim)
                     {
                         const(char)* plural = exps.dim > 1 ? "s" : "";
-                        error("cannot infer argument types, expected %d argument%s, not %d", exps.dim, plural, dim);
+                        error("cannot infer argument types, expected %d argument%s, not %d",
+                            exps.dim, plural, dim);
                         goto Lerror2;
                     }
+
                     foreach (i; 0 .. dim)
                     {
-                        Parameter p = (*parameters)[i];
-                        Expression exp = (*exps)[i];
+                        auto p = (*parameters)[i];
+                        auto exp = (*exps)[i];
                         version (none)
                         {
-                            printf("[%d] p = %s %s, exp = %s %s\n", i, p.type ? p.type.toChars() : "?", p.ident.toChars(), exp.type.toChars(), exp.toChars());
+                            printf("[%d] p = %s %s, exp = %s %s\n", i,
+                                p.type ? p.type.toChars() : "?", p.ident.toChars(),
+                                exp.type.toChars(), exp.toChars());
                         }
                         if (!p.type)
                             p.type = exp.type;
-                        p.type = p.type.addStorageClass(p.storageClass).semantic(loc, sc);
+                        p.type = p.type.addStorageClass(p.storageClass).semantic(loc, sc2);
                         if (!exp.implicitConvTo(p.type))
                             goto Lrangeerr;
+
                         auto var = new VarDeclaration(loc, p.type, p.ident, new ExpInitializer(loc, exp));
                         var.storage_class |= STCctfe | STCref | STCforeach;
                         makeargs = new CompoundStatement(loc, makeargs, new ExpStatement(loc, var));
                     }
                 }
+
                 forbody = new CompoundStatement(loc, makeargs, this._body);
+
                 s = new ForStatement(loc, _init, condition, increment, forbody, endloc);
-                if (LabelStatement ls = checkLabeledLoop(sc, this))
+                if (auto ls = checkLabeledLoop(sc, this))
                     ls.gotoTarget = s;
+
                 version (none)
                 {
                     printf("init: %s\n", _init.toChars());
@@ -2641,8 +2757,9 @@ public:
                     printf("increment: %s\n", increment.toChars());
                     printf("body: %s\n", forbody.toChars());
                 }
-                s = s.semantic(sc);
+                s = s.semantic(sc2);
                 break;
+
             Lrangeerr:
                 error("cannot infer argument types");
                 goto Lerror2;
@@ -2654,9 +2771,10 @@ public:
             {
                 if (checkForArgTypes())
                 {
-                    _body = _body.semanticNoScope(sc);
+                    _body = _body.semanticNoScope(sc2);
                     return this;
                 }
+
                 TypeFunction tfld = null;
                 if (sapply)
                 {
@@ -2664,7 +2782,7 @@ public:
                     if (fdapply)
                     {
                         assert(fdapply.type && fdapply.type.ty == Tfunction);
-                        tfld = cast(TypeFunction)fdapply.type.semantic(loc, sc);
+                        tfld = cast(TypeFunction)fdapply.type.semantic(loc, sc2);
                         goto Lget;
                     }
                     else if (tab.ty == Tdelegate)
@@ -2677,13 +2795,14 @@ public:
                             Parameter p = Parameter.getNth(tfld.parameters, 0);
                             if (p.type && p.type.ty == Tdelegate)
                             {
-                                Type t = p.type.semantic(loc, sc);
+                                auto t = p.type.semantic(loc, sc2);
                                 assert(t.ty == Tdelegate);
                                 tfld = cast(TypeFunction)t.nextOf();
                             }
                         }
                     }
                 }
+
                 /* Turn body into the function literal:
                  *  int delegate(ref T param) { body }
                  */
@@ -2693,7 +2812,8 @@ public:
                     Parameter p = (*parameters)[i];
                     StorageClass stc = STCref;
                     Identifier id;
-                    p.type = p.type.semantic(loc, sc);
+
+                    p.type = p.type.semantic(loc, sc2);
                     p.type = p.type.addStorageClass(p.storageClass);
 version(IN_LLVM)
 {
@@ -2771,8 +2891,9 @@ else
                 auto fld = new FuncLiteralDeclaration(loc, Loc(), tfld, TOKdelegate, this);
                 fld.fbody = _body;
                 Expression flde = new FuncExp(loc, fld);
-                flde = flde.semantic(sc);
+                flde = flde.semantic(sc2);
                 fld.tookAddressOf = 0;
+
                 // Resolve any forward referenced goto's
                 foreach (i; 0 .. gotos.dim)
                 {
@@ -2785,15 +2906,17 @@ else
                         (*gotos)[i].statement = s;
                     }
                 }
+
                 Expression e = null;
                 Expression ec;
                 if (vinit)
                 {
                     e = new DeclarationExp(loc, vinit);
-                    e = e.semantic(sc);
+                    e = e.semantic(sc2);
                     if (e.op == TOKerror)
                         goto Lerror2;
                 }
+
                 if (taa)
                 {
                     // Check types
@@ -2805,7 +2928,8 @@ else
                         Type ti = (isRef ? taa.index.addMod(MODconst) : taa.index);
                         if (isRef ? !ti.constConv(ta) : !ti.implicitConvTo(ta))
                         {
-                            error("foreach: index must be type %s, not %s", ti.toChars(), ta.toChars());
+                            error("foreach: index must be type %s, not %s",
+                                ti.toChars(), ta.toChars());
                             goto Lerror2;
                         }
                         p = (*parameters)[1];
@@ -2815,9 +2939,11 @@ else
                     Type taav = taa.nextOf();
                     if (isRef ? !taav.constConv(ta) : !taav.implicitConvTo(ta))
                     {
-                        error("foreach: value must be type %s, not %s", taav.toChars(), ta.toChars());
+                        error("foreach: value must be type %s, not %s",
+                            taav.toChars(), ta.toChars());
                         goto Lerror2;
                     }
+
                     /* Call:
                      *  extern(C) int _aaApply(void*, in size_t, int delegate(void*))
                      *      _aaApply(aggr, keysize, flde)
@@ -2828,6 +2954,7 @@ else
                     static __gshared const(char)** name = ["_aaApply", "_aaApply2"];
                     static __gshared FuncDeclaration* fdapply = [null, null];
                     static __gshared TypeDelegate* fldeTy = [null, null];
+
                     ubyte i = (dim == 2 ? 1 : 0);
                     if (!fdapply[i])
                     {
@@ -2842,6 +2969,7 @@ else
                         params.push(new Parameter(0, fldeTy[i], null, null));
                         fdapply[i] = FuncDeclaration.genCfunc(params, Type.tint32, name[i]);
                     }
+
                     auto exps = new Expressions();
                     exps.push(aggr);
                     size_t keysize = cast(size_t)taa.index.size();
@@ -2854,7 +2982,7 @@ else
                     }
                     exps.push(new IntegerExp(Loc(), keysize, Type.tsize_t));
                     exps.push(flde);
-                    ec = new VarExp(Loc(), fdapply[i]);
+                    ec = new VarExp(Loc(), fdapply[i], false);
                     ec = new CallExp(loc, ec, exps);
                     ec.type = Type.tint32; // don't run semantic() on ec
                 }
@@ -2863,41 +2991,37 @@ else
                     /* Call:
                      *      _aApply(aggr, flde)
                      */
-                    static __gshared const(char)** fntab = ["cc", "cw", "cd", "wc", "cc", "wd", "dc", "dw", "dd"];
+                    static __gshared const(char)** fntab =
+                    [
+                        "cc", "cw", "cd",
+                        "wc", "cc", "wd",
+                        "dc", "dw", "dd"
+                    ];
+
                     const(size_t) BUFFER_LEN = 7 + 1 + 2 + dim.sizeof * 3 + 1;
                     char[BUFFER_LEN] fdname;
                     int flag;
+
                     switch (tn.ty)
                     {
-                    case Tchar:
-                        flag = 0;
-                        break;
-                    case Twchar:
-                        flag = 3;
-                        break;
-                    case Tdchar:
-                        flag = 6;
-                        break;
+                        case Tchar:     flag = 0;   break;
+                        case Twchar:    flag = 3;   break;
+                        case Tdchar:    flag = 6;   break;
                     default:
                         assert(0);
                     }
                     switch (tnv.ty)
                     {
-                    case Tchar:
-                        flag += 0;
-                        break;
-                    case Twchar:
-                        flag += 1;
-                        break;
-                    case Tdchar:
-                        flag += 2;
-                        break;
+                        case Tchar:     flag += 0;  break;
+                        case Twchar:    flag += 1;  break;
+                        case Tdchar:    flag += 2;  break;
                     default:
                         assert(0);
                     }
                     const(char)* r = (op == TOKforeach_reverse) ? "R" : "";
                     int j = sprintf(fdname.ptr, "_aApply%s%.*s%llu", r, 2, fntab[flag], cast(ulong)dim);
                     assert(j < BUFFER_LEN);
+
                     FuncDeclaration fdapply;
                     TypeDelegate dgty;
                     params = new Parameters();
@@ -2909,15 +3033,16 @@ else
                     dgty = new TypeDelegate(new TypeFunction(dgparams, Type.tint32, 0, LINKd));
                     params.push(new Parameter(0, dgty, null, null));
                     fdapply = FuncDeclaration.genCfunc(params, Type.tint32, fdname.ptr);
+
                     if (tab.ty == Tsarray)
-                        aggr = aggr.castTo(sc, tn.arrayOf());
+                        aggr = aggr.castTo(sc2, tn.arrayOf());
                     // paint delegate argument to the type runtime expects
                     if (!dgty.equals(flde.type))
                     {
                         flde = new CastExp(loc, flde, flde.type);
                         flde.type = dgty;
                     }
-                    ec = new VarExp(Loc(), fdapply);
+                    ec = new VarExp(Loc(), fdapply, false);
                     ec = new CallExp(loc, ec, aggr, flde);
                     ec.type = Type.tint32; // don't run semantic() on ec
                 }
@@ -2932,7 +3057,7 @@ else
                         aggr = (cast(DelegateExp)aggr).e1;
                     }
                     ec = new CallExp(loc, aggr, flde);
-                    ec = ec.semantic(sc);
+                    ec = ec.semantic(sc2);
                     if (ec.op == TOKerror)
                         goto Lerror2;
                     if (ec.type != Type.tint32)
@@ -2950,7 +3075,7 @@ else
                      */
                     ec = new DotIdExp(loc, aggr, sapply.ident);
                     ec = new CallExp(loc, ec, flde);
-                    ec = ec.semantic(sc);
+                    ec = ec.semantic(sc2);
                     if (ec.op == TOKerror)
                         goto Lerror2;
                     if (ec.type != Type.tint32)
@@ -2960,6 +3085,7 @@ else
                     }
                 }
                 e = Expression.combine(e, ec);
+
                 if (!cases.dim)
                 {
                     // Easy case, a clean exit from the loop
@@ -2971,32 +3097,36 @@ else
                     // Construct a switch statement around the return value
                     // of the apply function.
                     auto a = new Statements();
+
                     // default: break; takes care of cases 0 and 1
                     s = new BreakStatement(Loc(), null);
                     s = new DefaultStatement(Loc(), s);
                     a.push(s);
+
                     // cases 2...
                     foreach (i, c; *cases)
                     {
                         s = new CaseStatement(Loc(), new IntegerExp(i + 2), c);
                         a.push(s);
                     }
+
                     s = new CompoundStatement(loc, a);
                     s = new SwitchStatement(loc, e, s, false);
                 }
-                s = s.semantic(sc);
+                s = s.semantic(sc2);
                 break;
             }
         case Terror:
         Lerror2:
             s = new ErrorStatement();
             break;
+
         default:
             error("foreach: %s is not an aggregate type", aggr.type.toChars());
             goto Lerror2;
         }
-        sc.noctor--;
-        sc.pop();
+        sc2.noctor--;
+        sc2.pop();
         return s;
     }
 
@@ -3273,7 +3403,11 @@ public:
 
     override Statement syntaxCopy()
     {
-        return new IfStatement(loc, prm ? prm.syntaxCopy() : null, condition.syntaxCopy(), ifbody ? ifbody.syntaxCopy() : null, elsebody ? elsebody.syntaxCopy() : null);
+        return new IfStatement(loc,
+            prm ? prm.syntaxCopy() : null,
+            condition.syntaxCopy(),
+            ifbody ? ifbody.syntaxCopy() : null,
+            elsebody ? elsebody.syntaxCopy() : null);
     }
 
     override Statement semantic(Scope* sc)
@@ -3284,6 +3418,9 @@ public:
         uint* fi0 = sc.saveFieldInit();
         uint* fi1 = null;
 
+        // check in syntax level
+        condition = checkAssignmentAsCondition(condition);
+
         auto sym = new ScopeDsymbol();
         sym.parent = sc.scopesym;
         Scope* scd = sc.push(sym);
@@ -3292,7 +3429,8 @@ public:
             /* Declare prm, which we will set to be the
              * result of condition.
              */
-            match = new VarDeclaration(loc, prm.type, prm.ident, new ExpInitializer(loc, condition));
+            auto ei = new ExpInitializer(loc, condition);
+            match = new VarDeclaration(loc, prm.type, prm.ident, ei);
             match.parent = scd.func;
             match.storage_class |= prm.storageClass;
             match.semantic(scd);
@@ -3304,10 +3442,10 @@ public:
 
             if (match.edtor)
             {
-                Statement sdtor = new ExpStatement(loc, match.edtor);
+                Statement sdtor = new DtorExpStatement(loc, match.edtor, match);
                 sdtor = new OnScopeStatement(loc, TOKon_scope_exit, sdtor);
                 ifbody = new CompoundStatement(loc, sdtor, ifbody);
-                match.noscope = 1;
+                match.noscope = true;
             }
         }
         else
@@ -3316,6 +3454,8 @@ public:
             condition = resolveProperties(scd, condition);
             condition = condition.addDtorHook(scd);
         }
+        if (checkNonAssignmentArrayOp(condition))
+            condition = new ErrorExp();
         condition = checkGC(scd, condition);
 
         // Convert to boolean after declaring prm so this works:
@@ -3483,7 +3623,7 @@ public:
                     if (se)
                     {
                         se = se.toUTF8(sc);
-                        fprintf(stderr, "%.*s", cast(int)se.len, cast(char*)se.string);
+                        fprintf(stderr, "%.*s", cast(int)se.len, se.string);
                     }
                     else
                         fprintf(stderr, "%s", e.toChars());
@@ -3524,11 +3664,7 @@ public:
                     }
                     else if (global.params.verbose)
                     {
-                        char* name = cast(char*)mem.malloc(se.len + 1);
-                        memcpy(name, se.string, se.len);
-                        name[se.len] = 0;
-                        fprintf(global.stdmsg, "library   %s\n", name);
-                        mem.free(name);
+                        fprintf(global.stdmsg, "library   %.*s\n", cast(int)se.len, se.string);
                     }
                 }
             }
@@ -3733,10 +3869,13 @@ public:
                 break;
             }
         }
+        if (checkNonAssignmentArrayOp(condition))
+            condition = new ErrorExp();
         condition = condition.optimize(WANTvalue);
         condition = checkGC(sc, condition);
         if (condition.op == TOKerror)
             conditionError = true;
+
         bool needswitcherror = false;
         sc = sc.push();
         sc.sbreak = this;
@@ -4167,6 +4306,11 @@ public:
             error("goto default not in switch statement");
             return new ErrorStatement();
         }
+        if (sw.isFinal)
+        {
+            error("goto default not allowed in final switch statement");
+            return new ErrorStatement();
+        }
         return this;
     }
 
@@ -4335,13 +4479,11 @@ public:
 
             exp = exp.semantic(sc);
             exp = resolveProperties(sc, exp);
-            if (exp.type && exp.type.ty != Tvoid ||
-                exp.op == TOKfunction ||
-                exp.op == TOKtype ||
-                exp.op == TOKtemplate)
+            if (exp.checkType())
+                exp = new ErrorExp();
+            if (auto f = isFuncAddress(exp))
             {
-                // don't make error for void expression
-                if (exp.checkValue())
+                if (fd.inferRetType && f.checkForwardRef(exp.loc))
                     exp = new ErrorExp();
             }
             if (checkNonAssignmentArrayOp(exp))
@@ -4809,6 +4951,7 @@ public:
             exp = checkGC(sc, exp);
             if (exp.op == TOKerror)
                 goto Lbody;
+
             ClassDeclaration cd = exp.type.isClassHandle();
             if (!cd)
             {
@@ -4825,9 +4968,11 @@ public:
                     error("missing or corrupt object.d");
                     fatal();
                 }
+
                 Type t = ClassDeclaration.object.type;
                 t = t.semantic(Loc(), sc).toBasetype();
                 assert(t.ty == Tclass);
+
                 exp = new CastExp(loc, exp, t);
                 exp = exp.semantic(sc);
             }
@@ -4842,20 +4987,25 @@ public:
                 auto ie = new ExpInitializer(loc, exp);
                 auto tmp = new VarDeclaration(loc, exp.type, id, ie);
                 tmp.storage_class |= STCtemp;
+
                 auto cs = new Statements();
                 cs.push(new ExpStatement(loc, tmp));
+
                 auto args = new Parameters();
                 args.push(new Parameter(0, ClassDeclaration.object.type, null, null));
+
                 FuncDeclaration fdenter = FuncDeclaration.genCfunc(args, Type.tvoid, Id.monitorenter);
-                Expression e = new CallExp(loc, new VarExp(loc, fdenter), new VarExp(loc, tmp));
+                Expression e = new CallExp(loc, new VarExp(loc, fdenter, false), new VarExp(loc, tmp));
                 e.type = Type.tvoid; // do not run semantic on e
+
                 cs.push(new ExpStatement(loc, e));
                 FuncDeclaration fdexit = FuncDeclaration.genCfunc(args, Type.tvoid, Id.monitorexit);
-                e = new CallExp(loc, new VarExp(loc, fdexit), new VarExp(loc, tmp));
+                e = new CallExp(loc, new VarExp(loc, fdexit, false), new VarExp(loc, tmp));
                 e.type = Type.tvoid; // do not run semantic on e
                 Statement s = new ExpStatement(loc, e);
                 s = new TryFinallyStatement(loc, _body, s);
                 cs.push(s);
+
                 s = new CompoundStatement(loc, cs);
                 return s.semantic(sc);
             }
@@ -4871,30 +5021,36 @@ public:
             Type t = new TypeSArray(Type.tint8, new IntegerExp(Target.ptrsize + Target.critsecsize()));
             auto tmp = new VarDeclaration(loc, t, id, null);
             tmp.storage_class |= STCtemp | STCgshared | STCstatic;
+
             auto cs = new Statements();
             cs.push(new ExpStatement(loc, tmp));
+
             /* This is just a dummy variable for "goto skips declaration" error.
              * Backend optimizer could remove this unused variable.
              */
             auto v = new VarDeclaration(loc, Type.tvoidptr, Identifier.generateId("__sync"), null);
             v.semantic(sc);
             cs.push(new ExpStatement(loc, v));
+
             auto args = new Parameters();
             args.push(new Parameter(0, t.pointerTo(), null, null));
+
             FuncDeclaration fdenter = FuncDeclaration.genCfunc(args, Type.tvoid, Id.criticalenter, STCnothrow);
             Expression e = new DotIdExp(loc, new VarExp(loc, tmp), Id.ptr);
             e = e.semantic(sc);
-            e = new CallExp(loc, new VarExp(loc, fdenter), e);
+            e = new CallExp(loc, new VarExp(loc, fdenter, false), e);
             e.type = Type.tvoid; // do not run semantic on e
             cs.push(new ExpStatement(loc, e));
+
             FuncDeclaration fdexit = FuncDeclaration.genCfunc(args, Type.tvoid, Id.criticalexit, STCnothrow);
             e = new DotIdExp(loc, new VarExp(loc, tmp), Id.ptr);
             e = e.semantic(sc);
-            e = new CallExp(loc, new VarExp(loc, fdexit), e);
+            e = new CallExp(loc, new VarExp(loc, fdexit, false), e);
             e.type = Type.tvoid; // do not run semantic on e
             Statement s = new ExpStatement(loc, e);
             s = new TryFinallyStatement(loc, _body, s);
             cs.push(s);
+
             s = new CompoundStatement(loc, cs);
             return s.semantic(sc);
         }
@@ -5073,6 +5229,10 @@ public:
 
     override Statement semantic(Scope* sc)
     {
+        uint flags;
+        enum FLAGcpp = 1;
+        enum FLAGd = 2;
+
         _body = _body.semanticScope(sc, null, null);
         assert(_body);
         /* Even if body is empty, still do semantic analysis on catches
@@ -5081,17 +5241,20 @@ public:
         foreach (i, c; *catches)
         {
             c.semantic(sc);
-            if (c.type.ty == Terror)
+            if (c.errors)
             {
                 catchErrors = true;
                 continue;
             }
+            auto cd = c.type.toBasetype().isClassHandle();
+            flags |= cd.isCPPclass() ? FLAGcpp : FLAGd;
+
             // Determine if current catch 'hides' any previous catches
             foreach (j; 0 .. i)
             {
                 Catch cj = (*catches)[j];
-                char* si = c.loc.toChars();
-                char* sj = cj.loc.toChars();
+                const si = c.loc.toChars();
+                const sj = cj.loc.toChars();
                 if (c.type.toBasetype().implicitConvTo(cj.type.toBasetype()))
                 {
                     error("catch at %s hides catch at %s", sj, si);
@@ -5099,6 +5262,16 @@ public:
                 }
             }
         }
+
+        if (sc.func)
+        {
+            if (flags == (FLAGcpp | FLAGd))
+            {
+                error("cannot mix catching D and C++ exceptions in the same try-catch");
+                catchErrors = true;
+            }
+        }
+
         if (catchErrors)
             return new ErrorStatement();
         if (_body.isErrorStatement())
@@ -5147,6 +5320,8 @@ public:
     VarDeclaration var;
     Statement handler;
 
+    bool errors;                // set if semantic processing errors
+
     // was generated by the compiler, wasn't present in source code
     bool internalCatch;
 
@@ -5175,6 +5350,7 @@ public:
             {
                 // If enclosing is scope(success) or scope(exit), this will be placed in finally block.
                 error(loc, "cannot put catch statement inside %s", Token.toChars(sc.os.tok));
+                errors = true;
             }
             if (sc.tf)
             {
@@ -5185,6 +5361,7 @@ public:
                  * body into a nested function.
                  */
                 error(loc, "cannot put catch statement inside finally block");
+                errors = true;
             }
         }
         auto sym = new ScopeDsymbol();
@@ -5199,27 +5376,52 @@ public:
             type = tid;
         }
         type = type.semantic(loc, sc);
-        ClassDeclaration cd = type.toBasetype().isClassHandle();
-        if (!cd || ((cd != ClassDeclaration.throwable) && !ClassDeclaration.throwable.isBaseOf(cd, null)))
+        if (type == Type.terror)
+            errors = true;
+        else
         {
-            if (type != Type.terror)
+            auto cd = type.toBasetype().isClassHandle();
+            if (!cd)
+            {
+                error(loc, "can only catch class objects, not '%s'", type.toChars());
+                errors = true;
+            }
+            else if (cd.isCPPclass())
+            {
+                if (!Target.cppExceptions)
+                {
+                    error(loc, "catching C++ class objects not supported for this target");
+                    errors = true;
+                }
+                if (sc.func && !sc.intypeof && !internalCatch && sc.func.setUnsafe())
+                {
+                    error(loc, "cannot catch C++ class objects in @safe code");
+                    errors = true;
+                }
+            }
+            else if (cd != ClassDeclaration.throwable && !ClassDeclaration.throwable.isBaseOf(cd, null))
             {
                 error(loc, "can only catch class objects derived from Throwable, not '%s'", type.toChars());
-                type = Type.terror;
+                errors = true;
             }
+            else if (sc.func && !sc.intypeof && !internalCatch &&
+                     cd != ClassDeclaration.exception && !ClassDeclaration.exception.isBaseOf(cd, null) &&
+                     sc.func.setUnsafe())
+            {
+                error(loc, "can only catch class objects derived from Exception in @safe code, not '%s'", type.toChars());
+                errors = true;
+            }
+
+            if (ident)
+            {
+                var = new VarDeclaration(loc, type, ident, null);
+                var.semantic(sc);
+                sc.insert(var);
+            }
+            handler = handler.semantic(sc);
+            if (handler && handler.isErrorStatement())
+                errors = true;
         }
-        else if (sc.func && !sc.intypeof && !internalCatch && cd != ClassDeclaration.exception && !ClassDeclaration.exception.isBaseOf(cd, null) && sc.func.setUnsafe())
-        {
-            error(loc, "can only catch class objects derived from Exception in @safe code, not '%s'", type.toChars());
-            type = Type.terror;
-        }
-        else if (ident)
-        {
-            var = new VarDeclaration(loc, type, ident, null);
-            var.semantic(sc);
-            sc.insert(var);
-        }
-        handler = handler.semantic(sc);
         sc.pop();
     }
 }
diff --git a/ddmd/staticassert.d b/ddmd/staticassert.d
index fe4183fdba..2a4822734a 100644
--- a/ddmd/staticassert.d
+++ b/ddmd/staticassert.d
@@ -92,7 +92,7 @@ public:
                 {
                     // same with pragma(msg)
                     se = se.toUTF8(sc);
-                    error("\"%.*s\"", cast(int)se.len, cast(char*)se.string);
+                    error("\"%.*s\"", cast(int)se.len, se.string);
                 }
                 else
                     error("%s", msg.toChars());
@@ -117,7 +117,7 @@ public:
         return true;
     }
 
-    override const(char)* kind()
+    override const(char)* kind() const
     {
         return "static assert";
     }
diff --git a/ddmd/target.d b/ddmd/target.d
index fd307de352..14f3057ae3 100644
--- a/ddmd/target.d
+++ b/ddmd/target.d
@@ -27,6 +27,7 @@ extern(C++) struct Target
     static __gshared int realpad;              // 'padding' added to the CPU real size to bring it up to realsize
     static __gshared int realalignsize;        // alignment for reals
     static __gshared bool reverseCppOverloads; // with dmc and cl, overloaded functions are grouped and in reverse order
+    static __gshared bool cppExceptions;       // set if catching C++ exceptions is supported
     static __gshared int c_longsize;           // size of a C 'long' or 'unsigned long' type
     static __gshared int c_long_doublesize;    // size of a C 'long double'
     static __gshared int classinfosize;        // size of 'ClassInfo'
@@ -58,6 +59,7 @@ struct Target
     extern (C++) static __gshared int realpad;              // 'padding' added to the CPU real size to bring it up to realsize
     extern (C++) static __gshared int realalignsize;        // alignment for reals
     extern (C++) static __gshared bool reverseCppOverloads; // with dmc and cl, overloaded functions are grouped and in reverse order
+    extern (C++) static __gshared bool cppExceptions;       // set if catching C++ exceptions is supported
     extern (C++) static __gshared int c_longsize;           // size of a C 'long' or 'unsigned long' type
     extern (C++) static __gshared int c_long_doublesize;    // size of a C 'long double'
     extern (C++) static __gshared int classinfosize;        // size of 'ClassInfo'
@@ -114,6 +116,9 @@ struct Target
         c_long_doublesize = realsize;
         if (global.params.is64bit && global.params.isWindows)
             c_long_doublesize = 8;
+
+        cppExceptions = global.params.dwarfeh || global.params.isLinux || global.params.isFreeBSD ||
+            (global.params.isOSX && global.params.is64bit);
     }
 
     /******************************
@@ -295,7 +300,6 @@ struct Target
         default:
             assert(0);
         }
-        return null; // avoid warning
     }
 
     /******************************
diff --git a/ddmd/target.h b/ddmd/target.h
index 9860439c39..a1b6184ff8 100644
--- a/ddmd/target.h
+++ b/ddmd/target.h
@@ -29,6 +29,7 @@ struct Target
     static int realpad;              // 'padding' added to the CPU real size to bring it up to realsize
     static int realalignsize;        // alignment for reals
     static bool reverseCppOverloads; // with dmc and cl, overloaded functions are grouped and in reverse order
+    static bool cppExceptions;       // set if catching C++ exceptions is supported
     static int c_longsize;           // size of a C 'long' or 'unsigned long' type
     static int c_long_doublesize;    // size of a C 'long double'
     static int classinfosize;        // size of 'ClassInfo'
diff --git a/ddmd/tokens.d b/ddmd/tokens.d
index 5422855e5f..b67565cf9f 100644
--- a/ddmd/tokens.d
+++ b/ddmd/tokens.d
@@ -569,7 +569,7 @@ extern (C++) struct Token
 
         struct
         {
-            char* ustring; // UTF8 string
+            const(char)* ustring; // UTF8 string
             uint len;
             ubyte postfix; // 'c', 'w', 'd'
         }
@@ -587,7 +587,7 @@ extern (C++) struct Token
             //printf("keyword[%d] = '%s'\n",u, keywords[u].name);
             const(char)* s = kw.name;
             TOK v = kw.value;
-            Identifier id = Identifier.idPool(s);
+            auto id = Identifier.idPool(s, strlen(s));
             id.value = v;
             //printf("tochars[%d] = '%s'\n",v, s);
             Token.tochars[v] = s;
@@ -719,7 +719,7 @@ extern (C++) struct Token
         freelist = &this;
     }
 
-    int isKeyword()
+    int isKeyword() const
     {
         foreach (kw; keywords)
         {
@@ -737,7 +737,43 @@ extern (C++) struct Token
         }
     }
 
-    extern (C++) const(char)* toChars()
+    /****
+     * Set to contents of ptr[0..length]
+     * Params:
+     *  ptr = pointer to string
+     *  length = length of string
+     */
+    final void setString(const(char)* ptr, size_t length)
+    {
+        auto s = cast(char*)mem.xmalloc(length + 1);
+        memcpy(s, ptr, length);
+        s[length] = 0;
+        ustring = s;
+        len = cast(uint)length;
+        postfix = 0;
+    }
+
+    /****
+     * Set to contents of buf
+     * Params:
+     *  buf = string (not zero terminated)
+     */
+    final void setString(const ref OutBuffer buf)
+    {
+        setString(cast(const(char)*)buf.data, buf.offset);
+    }
+
+    /****
+     * Set to empty string
+     */
+    final void setString()
+    {
+        ustring = "";
+        len = 0;
+        postfix = 0;
+    }
+
+    extern (C++) const(char)* toChars() const
     {
         __gshared char[3 + 3 * float80value.sizeof + 1] buffer;
         const(char)* p = &buffer[0];
@@ -787,8 +823,8 @@ extern (C++) struct Token
                 buf.writeByte('"');
                 for (size_t i = 0; i < len;)
                 {
-                    uint c;
-                    utf_decodeChar(cast(char*)ustring, len, &i, &c);
+                    dchar c;
+                    utf_decodeChar(ustring, len, i, c);
                     switch (c)
                     {
                     case 0:
@@ -796,6 +832,7 @@ extern (C++) struct Token
                     case '"':
                     case '\\':
                         buf.writeByte('\\');
+                        goto default;
                     default:
                         if (c <= 0x7F)
                         {
@@ -833,7 +870,7 @@ extern (C++) struct Token
                 if (postfix)
                     buf.writeByte(postfix);
                 buf.writeByte(0);
-                p = cast(char*)buf.extractData();
+                p = buf.extractData();
                 break;
             }
         case TOKidentifier:
diff --git a/ddmd/tokens.h b/ddmd/tokens.h
index f55e6b4074..edb4a81ece 100644
--- a/ddmd/tokens.h
+++ b/ddmd/tokens.h
@@ -228,7 +228,7 @@ struct Token
 #ifdef DEBUG
     void print();
 #endif
-    const char *toChars();
+    const char *toChars() const;
     static const char *toChars(TOK);
 };
 
diff --git a/ddmd/traits.d b/ddmd/traits.d
index fc6f044a46..682220d7f5 100644
--- a/ddmd/traits.d
+++ b/ddmd/traits.d
@@ -31,7 +31,6 @@ import ddmd.id;
 import ddmd.identifier;
 import ddmd.mtype;
 import ddmd.nogc;
-import ddmd.root.aav;
 import ddmd.root.array;
 import ddmd.root.rootobject;
 import ddmd.root.speller;
@@ -393,6 +392,7 @@ extern (C++) Expression semanticTraits(TraitsExp e, Scope* sc)
     Lfalse:
         return new IntegerExp(e.loc, result, Type.tbool);
     }
+
     alias isTypeX = isX!Type;
     alias isDsymX = isX!Dsymbol;
     alias isDeclX = isX!Declaration;
@@ -564,7 +564,7 @@ extern (C++) Expression semanticTraits(TraitsExp e, Scope* sc)
             id = s.ident;
         }
 
-        auto se = new StringExp(e.loc, id.toChars());
+        auto se = new StringExp(e.loc, cast(char*)id.toChars());
         return se.semantic(sc);
     }
     if (e.ident == Id.getProtection)
@@ -628,7 +628,7 @@ extern (C++) Expression semanticTraits(TraitsExp e, Scope* sc)
             if (auto fld = f.isFuncLiteralDeclaration())
             {
                 // Directly translate to VarExp instead of FuncExp
-                Expression ex = new VarExp(e.loc, fld, 1);
+                Expression ex = new VarExp(e.loc, fld, true);
                 return ex.semantic(sc);
             }
         }
@@ -665,7 +665,7 @@ extern (C++) Expression semanticTraits(TraitsExp e, Scope* sc)
             e.error("string must be chars");
             return new ErrorExp();
         }
-        Identifier id = Identifier.idPool(cast(char*)se.string);
+        auto id = Identifier.idPool(se.peekSlice());
 
         /* Prefer dsymbol, because it might need some runtime contexts.
          */
@@ -747,10 +747,13 @@ extern (C++) Expression semanticTraits(TraitsExp e, Scope* sc)
                     return 0;
                 if (e.ident == Id.getVirtualMethods && !fd.isVirtualMethod())
                     return 0;
-                auto fa = new FuncAliasDeclaration(fd.ident, fd, 0);
+
+                auto fa = new FuncAliasDeclaration(fd.ident, fd, false);
                 fa.protection = fd.protection;
-                Expression e = ex ? new DotVarExp(Loc(), ex, fa)
-                                  : new DsymbolExp(Loc(), fa);
+
+                auto e = ex ? new DotVarExp(Loc(), ex, fa, false)
+                            : new DsymbolExp(Loc(), fa, false);
+
                 exps.push(e);
                 return 0;
             });
@@ -803,7 +806,7 @@ extern (C++) Expression semanticTraits(TraitsExp e, Scope* sc)
 
         auto exps = new Expressions();
         if (ad.aliasthis)
-            exps.push(new StringExp(e.loc, ad.aliasthis.ident.toChars()));
+            exps.push(new StringExp(e.loc, cast(char*)ad.aliasthis.ident.toChars()));
         Expression ex = new TupleExp(e.loc, exps);
         ex = ex.semantic(sc);
         return ex;
@@ -981,7 +984,7 @@ extern (C++) Expression semanticTraits(TraitsExp e, Scope* sc)
         auto exps = cast(Expressions*)idents;
         foreach (i, id; *idents)
         {
-            auto se = new StringExp(e.loc, id.toChars());
+            auto se = new StringExp(e.loc, cast(char*)id.toChars());
             (*exps)[i] = se;
         }
 
@@ -1007,7 +1010,7 @@ extern (C++) Expression semanticTraits(TraitsExp e, Scope* sc)
             Scope* sc2 = sc.push();
             sc2.tinst = null;
             sc2.minst = null;
-            sc2.flags = (sc.flags & ~(SCOPEctfe | SCOPEcondition)) | SCOPEcompile;
+            sc2.flags = (sc.flags & ~(SCOPEctfe | SCOPEcondition)) | SCOPEcompile | SCOPEfullinst;
 
             bool err = false;
 
@@ -1132,7 +1135,7 @@ extern (C++) Expression semanticTraits(TraitsExp e, Scope* sc)
         auto exps = new Expressions();
         if (global.params.useUnitTests)
         {
-            AA* uniqueUnitTests = null;
+            bool[void*] uniqueUnitTests;
 
             void collectUnitTests(Dsymbols* a)
             {
@@ -1147,20 +1150,20 @@ extern (C++) Expression semanticTraits(TraitsExp e, Scope* sc)
                     }
                     if (auto ud = s.isUnitTestDeclaration())
                     {
-                        if (dmd_aaGetRvalue(uniqueUnitTests, cast(void*)ud))
+                        if (cast(void*)ud in uniqueUnitTests)
                             continue;
 
-                        auto ad = new FuncAliasDeclaration(ud.ident, ud, 0);
+                        auto ad = new FuncAliasDeclaration(ud.ident, ud, false);
                         ad.protection = ud.protection;
 
-                        auto e = new DsymbolExp(Loc(), ad);
+                        auto e = new DsymbolExp(Loc(), ad, false);
                         exps.push(e);
 
-                        auto pv = cast(bool*)dmd_aaGet(&uniqueUnitTests, cast(void*)ud);
-                        *pv = true;
+                        uniqueUnitTests[cast(void*)ud] = true;
                     }
                 }
             }
+
             collectUnitTests(sds.members);
         }
         auto te = new TupleExp(e.loc, exps);
@@ -1197,7 +1200,7 @@ extern (C++) Expression semanticTraits(TraitsExp e, Scope* sc)
             return null;
         cost = 0;
         StringValue* sv = traitsStringTable.lookup(seed, len);
-        return sv ? cast(void*)sv.ptrvalue : null;
+        return sv ? sv.ptrvalue : null;
     }
 
     if (auto sub = cast(const(char)*)speller(e.ident.toChars(), &trait_search_fp, idchars))
diff --git a/ddmd/utf.d b/ddmd/utf.d
index dc31895daa..6e50285843 100644
--- a/ddmd/utf.d
+++ b/ddmd/utf.d
@@ -8,17 +8,12 @@
 
 module ddmd.utf;
 
-/// A UTF-16 code unit
-alias utf16_t = ushort;
-
-/// A UTF-32 code unit
-alias utf32_t = uint;
-alias dchar_t = utf32_t;
+nothrow pure @nogc:
 
 /// The Unicode code space is the range of code points [0x000000,0x10FFFF]
 /// except the UTF-16 surrogate pairs in the range [0xD800,0xDFFF]
 /// and non-characters (which end in 0xFFFE or 0xFFFF).
-bool utf_isValidDchar(dchar_t c)
+bool utf_isValidDchar(dchar c)
 {
     // TODO: Whether non-char code points should be rejected is pending review
     // largest character code point
@@ -37,9 +32,9 @@ bool utf_isValidDchar(dchar_t c)
  * Return !=0 if unicode alpha.
  * Use table from C99 Appendix D.
  */
-bool isUniAlpha(dchar_t c)
+bool isUniAlpha(dchar c)
 {
-    static immutable utf16_t[2][] ALPHA_TABLE =
+    static immutable wchar[2][] ALPHA_TABLE =
     [
         [0x00AA, 0x00AA],
         [0x00B5, 0x00B5],
@@ -311,12 +306,12 @@ bool isUniAlpha(dchar_t c)
 /**
  * Returns the code length of c in code units.
  */
-int utf_codeLengthChar(dchar_t c)
+int utf_codeLengthChar(dchar c)
 {
     return c <= 0x7F ? 1 : c <= 0x7FF ? 2 : c <= 0xFFFF ? 3 : c <= 0x10FFFF ? 4 : (assert(false), 6);
 }
 
-int utf_codeLengthWchar(dchar_t c)
+int utf_codeLengthWchar(dchar c)
 {
     return c <= 0xFFFF ? 1 : 2;
 }
@@ -325,7 +320,7 @@ int utf_codeLengthWchar(dchar_t c)
  * Returns the code length of c in code units for the encoding.
  * sz is the encoding: 1 = utf8, 2 = utf16, 4 = utf32.
  */
-int utf_codeLength(int sz, dchar_t c)
+int utf_codeLength(int sz, dchar c)
 {
     if (sz == 1)
         return utf_codeLengthChar(c);
@@ -335,7 +330,7 @@ int utf_codeLength(int sz, dchar_t c)
     return 1;
 }
 
-void utf_encodeChar(char* s, dchar_t c)
+void utf_encodeChar(char* s, dchar c)
 {
     assert(s !is null);
     assert(utf_isValidDchar(c));
@@ -365,41 +360,45 @@ void utf_encodeChar(char* s, dchar_t c)
         assert(0);
 }
 
-void utf_encodeWchar(utf16_t* s, dchar_t c)
+void utf_encodeWchar(wchar* s, dchar c)
 {
     assert(s !is null);
     assert(utf_isValidDchar(c));
     if (c <= 0xFFFF)
     {
-        s[0] = cast(utf16_t)c;
+        s[0] = cast(wchar)c;
     }
     else
     {
-        s[0] = cast(utf16_t)((((c - 0x010000) >> 10) & 0x03FF) + 0xD800);
-        s[1] = cast(utf16_t)(((c - 0x010000) & 0x03FF) + 0xDC00);
+        s[0] = cast(wchar)((((c - 0x010000) >> 10) & 0x03FF) + 0xD800);
+        s[1] = cast(wchar)(((c - 0x010000) & 0x03FF) + 0xDC00);
     }
 }
 
-void utf_encode(int sz, void* s, dchar_t c)
+void utf_encode(int sz, void* s, dchar c)
 {
     if (sz == 1)
         utf_encodeChar(cast(char*)s, c);
     else if (sz == 2)
-        utf_encodeWchar(cast(utf16_t*)s, c);
+        utf_encodeWchar(cast(wchar*)s, c);
     else
     {
         assert(sz == 4);
-        *(cast(utf32_t*)s) = c;
+        *(cast(dchar*)s) = c;
     }
 }
 
 /********************************************
  * Decode a UTF-8 sequence as a single UTF-32 code point.
+ * Params:
+ *      s = UTF-8 sequence
+ *      len = number of code units in s[]
+ *      ridx = starting index in s[], updated to reflect number of code units decoded
+ *      rresult = set to character decoded
  * Returns:
- *      NULL    success
- *      !=NULL  error message string
+ *      null on success, otherwise error message string
  */
-immutable(char*) utf_decodeChar(const(char)* s, size_t len, size_t* pidx, dchar_t* presult)
+immutable(char*) utf_decodeChar(const(char)* s, size_t len, ref size_t ridx, out dchar rresult)
 {
     // UTF-8 decoding errors
     static immutable char* UTF8_DECODE_OK = null; // no error
@@ -679,13 +678,11 @@ immutable(char*) utf_decodeChar(const(char)* s, size_t len, size_t* pidx, dchar_
     ];
 
     assert(s !is null);
-    assert(pidx !is null);
-    assert(presult !is null);
-    size_t i = (*pidx)++;
+    size_t i = ridx++;
     assert(i < len);
     char u = s[i];
     // Pre-stage results for ASCII and error cases
-    *presult = u;
+    rresult = u;
     //printf("utf_decodeChar(s = %02x, %02x, %02x len = %d)\n", u, s[1], s[2], len);
     // Get expected sequence length
     size_t n = UTF8_STRIDE[u];
@@ -706,7 +703,7 @@ immutable(char*) utf_decodeChar(const(char)* s, size_t len, size_t* pidx, dchar_
     if (len < i + n) // source too short
         return UTF8_DECODE_TRUNCATED_SEQUENCE;
     // Pick off 7 - n low bits from first code unit
-    utf32_t c = u & ((1 << (7 - n)) - 1);
+    dchar c = u & ((1 << (7 - n)) - 1);
     /* The following combinations are overlong, and illegal:
      *      1100000x (10xxxxxx)
      *      11100000 100xxxxx (10xxxxxx)
@@ -728,18 +725,22 @@ immutable(char*) utf_decodeChar(const(char)* s, size_t len, size_t* pidx, dchar_
     }
     if (!utf_isValidDchar(c))
         return UTF8_DECODE_INVALID_CODE_POINT;
-    *pidx = i;
-    *presult = c;
+    ridx = i;
+    rresult = c;
     return UTF8_DECODE_OK;
 }
 
 /********************************************
  * Decode a UTF-16 sequence as a single UTF-32 code point.
+ * Params:
+ *      s = UTF-16 sequence
+ *      len = number of code units in s[]
+ *      ridx = starting index in s[], updated to reflect number of code units decoded
+ *      rresult = set to character decoded
  * Returns:
- *      NULL    success
- *      !=NULL  error message string
+ *      null on success, otherwise error message string
  */
-immutable(char*) utf_decodeWchar(const(utf16_t)* s, size_t len, size_t* pidx, dchar_t* presult)
+immutable(char*) utf_decodeWchar(const(wchar)* s, size_t len, ref size_t ridx, out dchar rresult)
 {
     // UTF-16 decoding errors
     static immutable char* UTF16_DECODE_OK = null; // no error
@@ -749,28 +750,26 @@ immutable(char*) utf_decodeWchar(const(utf16_t)* s, size_t len, size_t* pidx, dc
     static immutable char* UTF16_DECODE_INVALID_CODE_POINT = "Invalid code point decoded";
 
     assert(s !is null);
-    assert(pidx !is null);
-    assert(presult !is null);
-    size_t i = (*pidx)++;
+    size_t i = ridx++;
     assert(i < len);
     // Pre-stage results for ASCII and error cases
-    utf32_t u = *presult = s[i];
+    dchar u = rresult = s[i];
     if (u < 0x80) // ASCII
         return UTF16_DECODE_OK;
     if (0xD800 <= u && u <= 0xDBFF) // Surrogate pair
     {
         if (len <= i + 1)
             return UTF16_DECODE_TRUNCATED_SEQUENCE;
-        utf16_t u2 = s[i + 1];
+        wchar u2 = s[i + 1];
         if (u2 < 0xDC00 || 0xDFFF < u)
             return UTF16_DECODE_INVALID_SURROGATE;
         u = ((u - 0xD7C0) << 10) + (u2 - 0xDC00);
-        ++*pidx;
+        ++ridx;
     }
     else if (0xDC00 <= u && u <= 0xDFFF)
         return UTF16_DECODE_UNPAIRED_SURROGATE;
     if (!utf_isValidDchar(u))
         return UTF16_DECODE_INVALID_CODE_POINT;
-    *presult = u;
+    rresult = u;
     return UTF16_DECODE_OK;
 }
diff --git a/driver/main.cpp b/driver/main.cpp
index 6032db8f95..58b5bea6c7 100644
--- a/driver/main.cpp
+++ b/driver/main.cpp
@@ -1143,7 +1143,7 @@ int cppmain(int argc, char **argv) {
       name = p;
     }
 
-    id = Identifier::idPool(name);
+    id = Identifier::idPool(name, strlen(name));
     auto m = Module::create(files.data[i], id, global.params.doDocComments,
                             global.params.doHdrGeneration);
     modules.push(m);
diff --git a/gen/abi-aarch64.cpp b/gen/abi-aarch64.cpp
index d2fc6e98bb..4a7e539aaf 100644
--- a/gen/abi-aarch64.cpp
+++ b/gen/abi-aarch64.cpp
@@ -151,7 +151,8 @@ struct AArch64TargetABI : TargetABI {
     // using TypeIdentifier here is a bit wonky but works, as long as the name
     // is actually available in the scope (this is what DMD does, so if a better
     // solution is found there, this should be adapted).
-    return (createTypeIdentifier(Loc(), Identifier::idPool("__va_list")));
+    static const llvm::StringRef ident = "__va_list";
+    return (createTypeIdentifier(Loc(), Identifier::idPool(ident.data(), ident.size())));
   }
 };
 
diff --git a/gen/abi-arm.cpp b/gen/abi-arm.cpp
index 3041732d50..b7025e8444 100644
--- a/gen/abi-arm.cpp
+++ b/gen/abi-arm.cpp
@@ -86,7 +86,7 @@ struct ArmTargetABI : TargetABI {
     // Revist and determine if the byval problem is only for small
     // structs, say 16-bytes or less, that can entirely fit in
     // registers.
-    
+
     // Note: the codegen is horrible for Tsarrays passed this way -
     // does a copy without a loop for huge arrays.  Could be better if
     // byval was always used for sarrays, and maybe can if above
@@ -152,7 +152,9 @@ struct ArmTargetABI : TargetABI {
     // using TypeIdentifier here is a bit wonky but works, as long as the name
     // is actually available in the scope (this is what DMD does, so if a better
     // solution is found there, this should be adapted).
-    return (createTypeIdentifier(Loc(), Identifier::idPool("__va_list")));
+    static const llvm::StringRef ident = "__va_list";
+    return (createTypeIdentifier(
+        Loc(), Identifier::idPool(ident.data(), ident.size())));
   }
 };
 
diff --git a/gen/abi-x86-64.cpp b/gen/abi-x86-64.cpp
index d93466804c..1b893020d6 100644
--- a/gen/abi-x86-64.cpp
+++ b/gen/abi-x86-64.cpp
@@ -416,6 +416,8 @@ Type *X86_64TargetABI::vaListType() {
   // using TypeIdentifier here is a bit wonky but works, as long as the name
   // is actually available in the scope (this is what DMD does, so if a better
   // solution is found there, this should be adapted).
-  return (createTypeIdentifier(Loc(), Identifier::idPool("__va_list_tag")))
+  static const llvm::StringRef ident = "__va_list_tag";
+  return (createTypeIdentifier(Loc(),
+                               Identifier::idPool(ident.data(), ident.size())))
       ->pointerTo();
 }
diff --git a/gen/asm-x86.h b/gen/asm-x86.h
index fb96da59cf..7e76222675 100644
--- a/gen/asm-x86.h
+++ b/gen/asm-x86.h
@@ -178,7 +178,7 @@ static const int N_Regs = /*gp*/ 8 + /*fp*/ 8 + /*mmx*/ 8 + /*sse*/ 8 +
 #define NULL_TREE ""
 
 static struct {
-  const char *name;
+  llvm::StringRef name;
   std::string gccName; // GAS will take upper case, but GCC won't (needed for
                        // the clobber list)
   Identifier *ident;
@@ -2056,23 +2056,25 @@ struct AsmProcessor {
       char buf[8], *p;
 
       for (int i = 0; i < N_Regs; i++) {
-        strncpy(buf, regInfo[i].name, sizeof(buf) - 1);
+        strncpy(buf, regInfo[i].name.data(), sizeof(buf) - 1);
         for (p = buf; *p; p++) {
           *p = std::tolower(*p);
         }
         regInfo[i].gccName = std::string(buf, p - buf);
         if ((i <= Reg_ST || i > Reg_ST7) && i != Reg_EFLAGS) {
-          regInfo[i].ident = Identifier::idPool(regInfo[i].name);
+          regInfo[i].ident =
+              Identifier::idPool(regInfo[i].name.data(), regInfo[i].name.size());
         }
       }
 
       for (int i = 0; i < N_PtrNames; i++) {
-        ptrTypeIdentTable[i] = Identifier::idPool(ptrTypeNameTable[i]);
+        ptrTypeIdentTable[i] = Identifier::idPool(ptrTypeNameTable[i],
+                                                  std::strlen(ptrTypeNameTable[i]));
       }
 
       Handled = createExpression(Loc(), TOKvoid, sizeof(Expression));
 
-      ident_seg = Identifier::idPool("seg");
+      ident_seg = Identifier::idPool("seg", std::strlen("seg"));
 
       eof_tok.value = TOKeof;
       eof_tok.next = nullptr;
diff --git a/gen/nested.cpp b/gen/nested.cpp
index 3e28acfbb3..01699ee638 100644
--- a/gen/nested.cpp
+++ b/gen/nested.cpp
@@ -503,7 +503,7 @@ void DtoCreateNestedContext(FuncDeclaration *fd) {
 
     // go through all nested vars and assign addresses where possible.
     for (auto vd : fd->closureVars) {
-      if (needsClosure && vd->needsAutoDtor()) {
+      if (needsClosure && vd->needsScopeDtor()) {
         // This should really be a front-end, not a glue layer error,
         // but we need to fix this in DMD too.
         vd->error("has scoped destruction, cannot build closure");
diff --git a/gen/target.cpp b/gen/target.cpp
index c4bee629b8..fd486399fc 100644
--- a/gen/target.cpp
+++ b/gen/target.cpp
@@ -43,6 +43,9 @@ void Target::_init() {
 
   // according to DMD, only for MSVC++:
   reverseCppOverloads = global.params.targetTriple->isWindowsMSVCEnvironment();
+
+  // LDC_FIXME: Set once we support it.
+  cppExceptions = false;
 }
 
 /******************************
diff --git a/gen/toconstelem.cpp b/gen/toconstelem.cpp
index 7cea0ecfa9..bc695294b3 100644
--- a/gen/toconstelem.cpp
+++ b/gen/toconstelem.cpp
@@ -574,15 +574,9 @@ public:
                          e->toChars(), e->type ? e->type->toChars() : "(null)");
     LOG_SCOPE;
 
-    if (e->sinit) {
-      // Copied from VarExp::toConstElem, need to clean this mess up.
-      Type *sdecltype = e->sinit->type->toBasetype();
-      IF_LOG Logger::print("Sym: type=%s\n", sdecltype->toChars());
-      assert(sdecltype->ty == Tstruct);
-      TypeStruct *ts = static_cast<TypeStruct *>(sdecltype);
-      DtoResolveStruct(ts->sym);
-
-      result = getIrAggr(ts->sym)->getDefaultInit();
+    if (e->useStaticInit) {
+      DtoResolveStruct(e->sd);
+      result = getIrAggr(e->sd)->getDefaultInit();
     } else {
       // make sure the struct is resolved
       DtoResolveStruct(e->sd);
diff --git a/gen/toir.cpp b/gen/toir.cpp
index 3b25e0536c..4e53aac3e1 100644
--- a/gen/toir.cpp
+++ b/gen/toir.cpp
@@ -331,7 +331,7 @@ public:
     result = DtoDeclarationExp(e->declaration);
 
     if (auto vd = e->declaration->isVarDeclaration()) {
-      if (!vd->isDataseg() && vd->edtor && !vd->noscope) {
+      if (!vd->isDataseg() && vd->needsScopeDtor()) {
         pushVarDtorCleanup(p, vd);
       }
     }
@@ -504,7 +504,7 @@ public:
     // Can't just override ConstructExp::toElem because not all TOKconstruct
     // operations are actually instances of ConstructExp... Long live the DMD
     // coding style!
-    if (e->memset & MemorySet_referenceInit) {
+    if (e->memset & referenceInit) {
       assert(e->op == TOKconstruct || e->op == TOKblit);
       assert(e->e1->op == TOKvar);
 
@@ -898,7 +898,7 @@ public:
         if (ce->e1->op == TOKdeclaration && ce->e2->op == TOKvar) {
           VarExp *ve = static_cast<VarExp *>(ce->e2);
           if (VarDeclaration *vd = ve->var->isVarDeclaration()) {
-            if (vd->edtor && !vd->noscope) {
+            if (vd->needsScopeDtor()) {
               Logger::println("Delaying edtor");
               delayedDtorVar = vd;
               delayedDtorExp = vd->edtor;
@@ -2495,17 +2495,10 @@ public:
                          e->type->toChars());
     LOG_SCOPE;
 
-    if (e->sinit) {
-      // Copied from VarExp::toElem, need to clean this mess up.
-      Type *sdecltype = e->sinit->type->toBasetype();
-      IF_LOG Logger::print("Sym: type = %s\n", sdecltype->toChars());
-      assert(sdecltype->ty == Tstruct);
-      TypeStruct *ts = static_cast<TypeStruct *>(sdecltype);
-      assert(ts->sym);
-      DtoResolveStruct(ts->sym);
-
-      LLValue *initsym = getIrAggr(ts->sym)->getInitSymbol();
-      initsym = DtoBitCast(initsym, DtoType(ts->pointerTo()));
+    if (e->useStaticInit) {
+      DtoResolveStruct(e->sd);
+      LLValue *initsym = getIrAggr(e->sd)->getInitSymbol();
+      initsym = DtoBitCast(initsym, DtoType(e->type->pointerTo()));
       result = new DVarValue(e->type, initsym);
       return;
     }
diff --git a/ir/irtypeclass.cpp b/ir/irtypeclass.cpp
index 695b36b6ae..bc96d62b37 100644
--- a/ir/irtypeclass.cpp
+++ b/ir/irtypeclass.cpp
@@ -231,8 +231,8 @@ void IrTypeClass::addInterfaceToMap(ClassDeclaration *inter, size_t index) {
 
   // add the direct base interfaces recursively - they
   // are accessed through the same index
-  if (inter->interfaces_dim > 0) {
-    BaseClass *b = inter->interfaces[0];
+  if (inter->interfaces.length > 0) {
+    BaseClass *b = inter->interfaces.ptr[0];
     addInterfaceToMap(b->sym, index);
   }
 }
diff --git a/runtime/druntime b/runtime/druntime
index a01b84c957..ff4e6d69e5 160000
--- a/runtime/druntime
+++ b/runtime/druntime
@@ -1 +1 @@
-Subproject commit a01b84c957b585fafaf04886f55545f24d58d704
+Subproject commit ff4e6d69e5dcdd4e2f416190dc8ee0fbfa522d65
diff --git a/runtime/phobos b/runtime/phobos
index 85ffe9dd02..c5dcaa2198 160000
--- a/runtime/phobos
+++ b/runtime/phobos
@@ -1 +1 @@
-Subproject commit 85ffe9dd02a228db502e65dca29ed9d28adef221
+Subproject commit c5dcaa2198c921cebd5b01a664a1f4b09de909c5
diff --git a/tests/d2/dmd-testsuite b/tests/d2/dmd-testsuite
index 71ee66ec55..c786194a04 160000
--- a/tests/d2/dmd-testsuite
+++ b/tests/d2/dmd-testsuite
@@ -1 +1 @@
-Subproject commit 71ee66ec55b874487fb38738dc0f14a0bc736446
+Subproject commit c786194a04e6ee0a08e206602a64717063b79b00