Index: init.c
===================================================================
--- init.c	(revision 128602)
+++ init.c	(working copy)
@@ -313,6 +313,29 @@ build_default_init (tree type, tree nelt
   return build_zero_init (type, nelts, /*static_storage_p=*/false);
 }
 
+/* Initialize current class with INIT, a TREE_LIST of
+   arguments for a target constructor. If TREE_LIST is void_type_node,
+   an empty initializer list was given.  */
+
+static void
+perform_target_ctor (tree init)
+{
+  tree decl = current_class_ref;
+  tree type = current_class_type;
+
+  if (init == void_type_node)
+    init = NULL_TREE;
+
+  finish_expr_stmt (build_aggr_init (decl, init, 0));
+  if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
+    {
+      tree expr = build_delete (type, decl, sfk_complete_destructor,
+              LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
+      if (expr != error_mark_node)
+   finish_eh_cleanup (expr);
+    }
+}
+
 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
    arguments.  If TREE_LIST is void_type_node, an empty initializer
    list was given; if NULL_TREE no initializer was given.  */
@@ -667,6 +690,16 @@ emit_mem_initializers (tree mem_inits)
   if (!COMPLETE_TYPE_P (current_class_type))
     return;
 
+  if (cxx_dialect == cxx0x
+      && mem_inits
+      && TYPE_P (TREE_PURPOSE (mem_inits))
+      && same_type_p (TREE_PURPOSE (mem_inits), current_class_type))
+    {
+   gcc_assert (TREE_CHAIN (mem_inits) == NULL_TREE);
+   perform_target_ctor (TREE_VALUE (mem_inits));
+   return;
+    }
+
   /* Sort the mem-initializers into the order in which the
      initializations should be performed.  */
   mem_inits = sort_mem_initializers (current_class_type, mem_inits);
@@ -977,11 +1010,18 @@ expand_member_init (tree name)
     }
   else if (TYPE_P (name))
     {
+      if (cxx_dialect == cxx0x && same_type_p (name, current_class_type))
+        return name;
       basetype = TYPE_MAIN_VARIANT (name);
       name = TYPE_NAME (name);
     }
   else if (TREE_CODE (name) == TYPE_DECL)
-    basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
+    {
+      if (cxx_dialect == cxx0x
+         && same_type_p (TREE_TYPE (name), current_class_type))
+        return TREE_TYPE (name);
+      basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
+    }
   else
     basetype = NULL_TREE;
 
Index: parser.c
===================================================================
--- parser.c	(revision 128602)
+++ parser.c	(working copy)
@@ -8717,6 +8717,7 @@ static void
 cp_parser_mem_initializer_list (cp_parser* parser)
 {
   tree mem_initializer_list = NULL_TREE;
+  tree target_ctor = error_mark_node;
 
   /* Let the semantic analysis code know that we are starting the
      mem-initializer-list.  */
@@ -8750,6 +8751,32 @@ cp_parser_mem_initializer_list (cp_parse
           if (mem_initializer != error_mark_node)
             mem_initializer = make_pack_expansion (mem_initializer);
         }
+
+  if (target_ctor != error_mark_node
+     && mem_initializer != error_mark_node)
+   {
+     error ("seeing initializer for member %<%D%>; "
+        "previous target constructor for %T must be sole initializer",
+        TREE_PURPOSE (mem_initializer),
+        TREE_PURPOSE (target_ctor));
+     mem_initializer = error_mark_node;
+   }
+      /* Look for a target constructor. */
+   if (cxx_dialect == cxx0x
+     && mem_initializer != error_mark_node
+     && TYPE_P (TREE_PURPOSE (mem_initializer))
+     && same_type_p (TREE_PURPOSE (mem_initializer), current_class_type))
+   {
+     if (mem_initializer_list)
+       {
+         error ("target constructor for %T must be sole initializer; "
+            "saw previous initializer for member %<%D%>",
+            TREE_PURPOSE (mem_initializer),
+            TREE_PURPOSE (mem_initializer_list));
+         mem_initializer = error_mark_node;
+       }
+     target_ctor = mem_initializer;
+   }
       /* Add it to the list, unless it was erroneous.  */
       if (mem_initializer != error_mark_node)
 	{