Implement C++11 inheriting constructors.

	* cp-tree.h (cpp0x_warn_str): Add CPP0X_INHERITING_CTORS.
	(DECL_INHERITED_CTOR_BASE, SET_DECL_INHERITED_CTOR_BASE): New.
	(special_function_kind): Add sfk_inheriting_constructor.
	* class.c (add_method): An inheriting ctor is hidden by a
	user-declared one.
	(one_inheriting_sig, one_inherited_ctor): New.
	(add_implicitly_declared_members): Handle inheriting ctors.
	* error.c (maybe_warn_cpp0x): Handle CPP0X_INHERITING_CTORS.
	* init.c (emit_mem_initializers): Don't set LOOKUP_DEFAULTED
	for an inheriting constructor.
	* method.c (type_has_trivial_fn): Handle sfk_inheriting_constructor.
	(type_set_nontrivial_flag): Likewise.
	(add_one_base_init): Split out from...
	(do_build_copy_constructor): ...here.  Handle inheriting constructors.
	(locate_fn_flags): Handle a list of arg types.
	(synthesized_method_walk): Handle inheriting constructors.
	(maybe_explain_implicit_delete): Likewise.
	(deduce_inheriting_ctor): New.
	(implicitly_declare_fn): Handle inheriting constructors.
	* name-lookup.c (push_class_level_binding_1): An inheriting constructor
	does not declare the base's name.
	(do_class_using_decl): Allow inheriting constructors.
	* pt.c (template_parms_to_args): Split from current_template_args.
	(add_inherited_template_parms): New.
	(tsubst_decl): Handle inheriting constructors.
	* tree.c (special_function_p): Handle inheriting constructors.

Co-Authored-By: Ville Voutilainen <ville.voutilainen@gmail.com>

From-SVN: r192448

gcc/cp/ChangeLog

+2012-10-14  Jason Merrill  <jason@redhat.com>
+	    Ville Voutilainen  <ville.voutilainen@gmail.com>
+
+	Implement C++11 inheriting constructors.
+	* cp-tree.h (cpp0x_warn_str): Add CPP0X_INHERITING_CTORS.
+	(DECL_INHERITED_CTOR_BASE, SET_DECL_INHERITED_CTOR_BASE): New.
+	(special_function_kind): Add sfk_inheriting_constructor.
+	* class.c (add_method): An inheriting ctor is hidden by a
+	user-declared one.
+	(one_inheriting_sig, one_inherited_ctor): New.
+	(add_implicitly_declared_members): Handle inheriting ctors.
+	* error.c (maybe_warn_cpp0x): Handle CPP0X_INHERITING_CTORS.
+	* init.c (emit_mem_initializers): Don't set LOOKUP_DEFAULTED
+	for an inheriting constructor.
+	* method.c (type_has_trivial_fn): Handle sfk_inheriting_constructor.
+	(type_set_nontrivial_flag): Likewise.
+	(add_one_base_init): Split out from...
+	(do_build_copy_constructor): ...here.  Handle inheriting constructors.
+	(locate_fn_flags): Handle a list of arg types.
+	(synthesized_method_walk): Handle inheriting constructors.
+	(maybe_explain_implicit_delete): Likewise.
+	(deduce_inheriting_ctor): New.
+	(implicitly_declare_fn): Handle inheriting constructors.
+	* name-lookup.c (push_class_level_binding_1): An inheriting constructor
+	does not declare the base's name.
+	(do_class_using_decl): Allow inheriting constructors.
+	* pt.c (template_parms_to_args): Split from current_template_args.
+	(add_inherited_template_parms): New.
+	(tsubst_decl): Handle inheriting constructors.
+	* tree.c (special_function_p): Handle inheriting constructors.
+
 2012-10-12  Jakub Jelinek  <jakub@redhat.com>
 
 	PR c/54381

gcc/cp/class.c

@@ -132,7 +132,7 @@ static void finish_struct_methods (tree);
 static void maybe_warn_about_overly_private_class (tree);
 static int method_name_cmp (const void *, const void *);
 static int resort_method_name_cmp (const void *, const void *);
-static void add_implicitly_declared_members (tree, int, int);
+static void add_implicitly_declared_members (tree, tree*, int, int);
 static tree fixed_type_or_null (tree, int *, int *);
 static tree build_simple_base_path (tree expr, tree binfo);
 static tree build_vtbl_ref_1 (tree, tree);
@@ -1087,6 +1087,20 @@ add_method (tree type, tree method, tree using_decl)
 	      || same_type_p (TREE_TYPE (fn_type),
 			      TREE_TYPE (method_type))))
 	{
+	  if (DECL_INHERITED_CTOR_BASE (method))
+	    {
+	      if (DECL_INHERITED_CTOR_BASE (fn))
+		{
+		  error_at (DECL_SOURCE_LOCATION (method),
+			    "%q#D inherited from %qT", method,
+			    DECL_INHERITED_CTOR_BASE (method));
+		  error_at (DECL_SOURCE_LOCATION (fn),
+			    "conflicts with version inherited from %qT",
+			    DECL_INHERITED_CTOR_BASE (fn));
+		}
+	      /* Otherwise defer to the other function.  */
+	      return false;
+	    }
 	  if (using_decl)
 	    {
 	      if (DECL_CONTEXT (fn) == type)
@@ -2750,6 +2764,51 @@ declare_virt_assop_and_dtor (tree t)
 		NULL, t);
 }
 
+/* Declare the inheriting constructor for class T inherited from base
+   constructor CTOR with the parameter array PARMS of size NPARMS.  */
+
+static void
+one_inheriting_sig (tree t, tree ctor, tree *parms, int nparms)
+{
+  /* We don't declare an inheriting ctor that would be a default,
+     copy or move ctor.  */
+  if (nparms == 0
+      || (nparms == 1
+	  && TREE_CODE (parms[0]) == REFERENCE_TYPE
+	  && TYPE_MAIN_VARIANT (TREE_TYPE (parms[0])) == t))
+    return;
+  int i;
+  tree parmlist = void_list_node;
+  for (i = nparms - 1; i >= 0; i--)
+    parmlist = tree_cons (NULL_TREE, parms[i], parmlist);
+  tree fn = implicitly_declare_fn (sfk_inheriting_constructor,
+				   t, false, ctor, parmlist);
+  if (add_method (t, fn, NULL_TREE))
+    {
+      DECL_CHAIN (fn) = TYPE_METHODS (t);
+      TYPE_METHODS (t) = fn;
+    }
+}
+
+/* Declare all the inheriting constructors for class T inherited from base
+   constructor CTOR.  */
+
+static void
+one_inherited_ctor (tree ctor, tree t)
+{
+  tree parms = FUNCTION_FIRST_USER_PARMTYPE (ctor);
+
+  tree *new_parms = XALLOCAVEC (tree, list_length (parms));
+  int i = 0;
+  for (; parms && parms != void_list_node; parms = TREE_CHAIN (parms))
+    {
+      if (TREE_PURPOSE (parms))
+	one_inheriting_sig (t, ctor, new_parms, i);
+      new_parms[i++] = TREE_VALUE (parms);
+    }
+  one_inheriting_sig (t, ctor, new_parms, i);
+}
+
 /* Create default constructors, assignment operators, and so forth for
    the type indicated by T, if they are needed.  CANT_HAVE_CONST_CTOR,
    and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason,
@@ -2758,7 +2817,7 @@ declare_virt_assop_and_dtor (tree t)
    a const reference, respectively.  */
 
 static void
-add_implicitly_declared_members (tree t,
+add_implicitly_declared_members (tree t, tree* access_decls,
 				 int cant_have_const_cctor,
 				 int cant_have_const_assignment)
 {
@@ -2826,6 +2885,26 @@ add_implicitly_declared_members (tree t,
   /* We can't be lazy about declaring functions that might override
      a virtual function from a base class.  */
   declare_virt_assop_and_dtor (t);
+
+  while (*access_decls)
+    {
+      tree using_decl = TREE_VALUE (*access_decls);
+      tree decl = USING_DECL_DECLS (using_decl);
+      if (DECL_SELF_REFERENCE_P (decl))
+	{
+	  /* declare, then remove the decl */
+	  tree ctor_list = CLASSTYPE_CONSTRUCTORS (TREE_TYPE (decl));
+	  location_t loc = input_location;
+	  input_location = DECL_SOURCE_LOCATION (using_decl);
+	  if (ctor_list)
+	    for (; ctor_list; ctor_list = OVL_NEXT (ctor_list))
+	      one_inherited_ctor (OVL_CURRENT (ctor_list), t);
+	  *access_decls = TREE_CHAIN (*access_decls);
+	  input_location = loc;
+	}
+      else
+	access_decls = &TREE_CHAIN (*access_decls);
+    }
 }
 
 /* Subroutine of insert_into_classtype_sorted_fields.  Recursively
@@ -4342,7 +4421,8 @@ deduce_noexcept_on_destructor (tree dtor)
     {
       tree ctx = DECL_CONTEXT (dtor);
       tree implicit_fn = implicitly_declare_fn (sfk_destructor, ctx,
-						/*const_p=*/false);
+						/*const_p=*/false,
+						NULL, NULL);
       tree eh_spec = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (implicit_fn));
       TREE_TYPE (dtor) = build_exception_variant (TREE_TYPE (dtor), eh_spec);
     }
@@ -5135,14 +5215,14 @@ check_bases_and_members (tree t)
     }
 
   /* Synthesize any needed methods.  */
-  add_implicitly_declared_members (t,
+  add_implicitly_declared_members (t, &access_decls,
 				   cant_have_const_ctor,
 				   no_const_asn_ref);
 
   /* Check defaulted declarations here so we have cant_have_const_ctor
      and don't need to worry about clones.  */
   for (fn = TYPE_METHODS (t); fn; fn = DECL_CHAIN (fn))
-    if (DECL_DEFAULTED_IN_CLASS_P (fn))
+    if (!DECL_ARTIFICIAL (fn) && DECL_DEFAULTED_IN_CLASS_P (fn))
       {
 	int copy = copy_fn_p (fn);
 	if (copy > 0)

gcc/cp/cp-tree.h

@@ -420,6 +420,8 @@ typedef enum cpp0x_warn_str
   CPP0X_USER_DEFINED_LITERALS,
   /* delegating constructors */
   CPP0X_DELEGATING_CTORS,
+  /* inheriting constructors */
+  CPP0X_INHERITING_CTORS,
   /* C++11 attributes */
   CPP0X_ATTRIBUTES
 } cpp0x_warn_str;
@@ -2384,6 +2386,15 @@ struct GTY((variable_size)) lang_decl {
 #define SET_DECL_THUNKS(NODE,THUNKS) \
   (LANG_DECL_FN_CHECK (NODE)->context = (THUNKS))
 
+/* If NODE, a FUNCTION_DECL, is a C++11 inheriting constructor, then this
+   is the base it inherits from.  */
+#define DECL_INHERITED_CTOR_BASE(NODE) \
+  (DECL_CONSTRUCTOR_P (NODE) ? LANG_DECL_FN_CHECK (NODE)->context : NULL_TREE)
+
+/* Set the inherited base.  */
+#define SET_DECL_INHERITED_CTOR_BASE(NODE,INH) \
+  (LANG_DECL_FN_CHECK (NODE)->context = (INH))
+
 /* Nonzero if NODE is a thunk, rather than an ordinary function.  */
 #define DECL_THUNK_P(NODE)			\
   (TREE_CODE (NODE) == FUNCTION_DECL		\
@@ -4142,7 +4153,8 @@ typedef enum special_function_kind {
   sfk_deleting_destructor, /* A destructor for complete objects that
 			      deletes the object after it has been
 			      destroyed.  */
-  sfk_conversion	   /* A conversion operator.  */
+  sfk_conversion,	   /* A conversion operator.  */
+  sfk_inheriting_constructor /* An inheriting constructor */
 } special_function_kind;
 
 /* The various kinds of linkage.  From [basic.link],
@@ -5323,6 +5335,7 @@ extern void use_thunk				(tree, bool);
 extern bool trivial_fn_p			(tree);
 extern bool maybe_explain_implicit_delete	(tree);
 extern void explain_implicit_non_constexpr	(tree);
+extern void deduce_inheriting_ctor		(tree);
 extern void synthesize_method			(tree);
 extern tree lazily_declare_fn			(special_function_kind,
 						 tree);
@@ -5335,7 +5348,7 @@ extern tree get_default_ctor			(tree);
 extern tree get_dtor				(tree, tsubst_flags_t);
 extern tree locate_ctor				(tree);
 extern tree implicitly_declare_fn               (special_function_kind, tree,
-						 bool);
+						 bool, tree, tree);
 
 /* In optimize.c */
 extern bool maybe_clone_body			(tree);
@@ -5370,6 +5383,7 @@ extern tree maybe_update_decl_type		(tree, tree);
 extern bool check_default_tmpl_args             (tree, tree, bool, bool, int);
 extern tree push_template_decl			(tree);
 extern tree push_template_decl_real		(tree, bool);
+extern tree add_inherited_template_parms	(tree, tree);
 extern bool redeclare_class_template		(tree, tree);
 extern tree lookup_template_class		(tree, tree, tree, tree,
 						 int, tsubst_flags_t);

gcc/cp/error.c

@@ -3374,6 +3374,11 @@ maybe_warn_cpp0x (cpp0x_warn_str str)
 		 "delegating constructors "
 		 "only available with -std=c++11 or -std=gnu++11");
         break;
+      case CPP0X_INHERITING_CTORS:
+	pedwarn (input_location, 0,
+		 "inheriting constructors "
+		 "only available with -std=c++11 or -std=gnu++11");
+        break;
       case CPP0X_ATTRIBUTES:
 	pedwarn (input_location, 0,
 		 "c++11 attributes "

gcc/cp/init.c

@@ -1036,7 +1036,8 @@ emit_mem_initializers (tree mem_inits)
       return;
     }
 
-  if (DECL_DEFAULTED_FN (current_function_decl))
+  if (DECL_DEFAULTED_FN (current_function_decl)
+      && ! DECL_INHERITED_CTOR_BASE (current_function_decl))
     flags |= LOOKUP_DEFAULTED;
 
   /* Sort the mem-initializers into the order in which the

gcc/cp/name-lookup.c

@@ -3026,6 +3026,14 @@ push_class_level_binding_1 (tree name, tree x)
       && TREE_TYPE (decl) == error_mark_node)
     decl = TREE_VALUE (decl);
 
+  if (TREE_CODE (decl) == USING_DECL
+      && TREE_CODE (USING_DECL_SCOPE (decl)) == TEMPLATE_TYPE_PARM
+      && DECL_NAME (decl) == TYPE_IDENTIFIER (USING_DECL_SCOPE (decl)))
+    /* This using-declaration declares constructors that inherit from the
+       constructors for the template parameter.  It does not redeclare the
+       name of the template parameter.  */
+    return true;
+
   if (!check_template_shadow (decl))
     return false;
 
@@ -3218,10 +3226,7 @@ do_class_using_decl (tree scope, tree name)
       return NULL_TREE;
     }
   if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
-    {
-      error ("%<%T::%D%> names constructor", scope, name);
-      return NULL_TREE;
-    }
+    maybe_warn_cpp0x (CPP0X_INHERITING_CTORS);
   if (constructor_name_p (name, current_class_type))
     {
       error ("%<%T::%D%> names constructor in %qT",

gcc/cp/pt.c

@@ -3847,17 +3847,16 @@ arg_from_parm_pack_p (tree arg_pack, tree parm_pack)
   return false;
 }
 
-/* Within the declaration of a template, return all levels of template
-   parameters that apply.  The template parameters are represented as
-   a TREE_VEC, in the form documented in cp-tree.h for template
-   arguments.  */
+/* Given a set of template parameters, return them as a set of template
+   arguments.  The template parameters are represented as a TREE_VEC, in
+   the form documented in cp-tree.h for template arguments.  */
 
 static tree
-current_template_args (void)
+template_parms_to_args (tree parms)
 {
   tree header;
   tree args = NULL_TREE;
-  int length = TMPL_PARMS_DEPTH (current_template_parms);
+  int length = TMPL_PARMS_DEPTH (parms);
   int l = length;
 
   /* If there is only one level of template parameters, we do not
@@ -3866,7 +3865,7 @@ current_template_args (void)
   if (length > 1)
     args = make_tree_vec (length);
 
-  for (header = current_template_parms; header; header = TREE_CHAIN (header))
+  for (header = parms; header; header = TREE_CHAIN (header))
     {
       tree a = copy_node (TREE_VALUE (header));
       int i;
@@ -3903,6 +3902,15 @@ current_template_args (void)
   return args;
 }
 
+/* Within the declaration of a template, return the currently active
+   template parameters as an argument TREE_VEC.  */
+
+static tree
+current_template_args (void)
+{
+  return template_parms_to_args (current_template_parms);
+}
+
 /* Update the declared TYPE by doing any lookups which were thought to be
    dependent, but are not now that we know the SCOPE of the declarator.  */
 
@@ -4904,6 +4912,29 @@ push_template_decl (tree decl)
   return push_template_decl_real (decl, false);
 }
 
+/* FN is an inheriting constructor that inherits from the constructor
+   template INHERITED; turn FN into a constructor template with a matching
+   template header.  */
+
+tree
+add_inherited_template_parms (tree fn, tree inherited)
+{
+  tree inner_parms
+    = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (inherited));
+  inner_parms = copy_node (inner_parms);
+  tree parms
+    = tree_cons (size_int (processing_template_decl + 1),
+		 inner_parms, current_template_parms);
+  tree tmpl = build_template_decl (fn, parms, /*member*/true);
+  tree args = template_parms_to_args (parms);
+  DECL_TEMPLATE_INFO (fn) = build_template_info (tmpl, args);
+  TREE_TYPE (tmpl) = TREE_TYPE (fn);
+  DECL_TEMPLATE_RESULT (tmpl) = fn;
+  DECL_ARTIFICIAL (tmpl) = true;
+  DECL_PRIMARY_TEMPLATE (tmpl) = tmpl;
+  return tmpl;
+}
+
 /* Called when a class template TYPE is redeclared with the indicated
    template PARMS, e.g.:
 
@@ -10136,6 +10167,8 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain)
 	    maybe_retrofit_in_chrg (r);
 	    if (DECL_CONSTRUCTOR_P (r))
 	      grok_ctor_properties (ctx, r);
+	    if (DECL_INHERITED_CTOR_BASE (r))
+	      deduce_inheriting_ctor (r);
 	    /* If this is an instantiation of a member template, clone it.
 	       If it isn't, that'll be handled by
 	       clone_constructors_and_destructors.  */
@@ -10336,9 +10369,14 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain)
       if (DECL_DEPENDENT_P (t)
 	  || uses_template_parms (USING_DECL_SCOPE (t)))
 	{
-	  r = do_class_using_decl
-	    (tsubst_copy (USING_DECL_SCOPE (t), args, complain, in_decl),
-	     tsubst_copy (DECL_NAME (t), args, complain, in_decl));
+	  tree scope = USING_DECL_SCOPE (t);
+	  tree inst_scope = tsubst_copy (USING_DECL_SCOPE (t), args,
+					 complain, in_decl);
+	  tree name = tsubst_copy (DECL_NAME (t), args, complain, in_decl);
+	  if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM
+	      && name == TYPE_IDENTIFIER (scope))
+	    name = TYPE_IDENTIFIER (inst_scope);
+	  r = do_class_using_decl (inst_scope, name);
 	  if (!r)
 	    r = error_mark_node;
 	  else

gcc/cp/tree.c

@@ -3337,6 +3337,8 @@ special_function_p (const_tree decl)
   /* Rather than doing all this stuff with magic names, we should
      probably have a field of type `special_function_kind' in
      DECL_LANG_SPECIFIC.  */
+  if (DECL_INHERITED_CTOR_BASE (decl))
+    return sfk_inheriting_constructor;
   if (DECL_COPY_CONSTRUCTOR_P (decl))
     return sfk_copy_constructor;
   if (DECL_MOVE_CONSTRUCTOR_P (decl))

gcc/testsuite/ChangeLog

+2012-10-14  Jason Merrill  <jason@redhat.com>
+
+	* g++.dg/cpp0x/inh-ctor1.C: New.
+	* g++.dg/cpp0x/inh-ctor2.C: New.
+	* g++.dg/cpp0x/inh-ctor3.C: New.
+	* g++.dg/cpp0x/inh-ctor4.C: New.
+	* g++.dg/cpp0x/inh-ctor5.C: New.
+	* g++.dg/cpp0x/inh-ctor6.C: New.
+	* g++.dg/cpp0x/inh-ctor7.C: New.
+	* g++.dg/cpp0x/inh-ctor8.C: New.
+	* g++.dg/cpp0x/inh-ctor9.C: New.
+	* g++.dg/cpp0x/inh-ctor10.C: New.
+	* g++.dg/cpp0x/inh-ctor11.C: New.
+	* g++.dg/cpp0x/inh-ctor12.C: New.
+	* g++.dg/cpp0x/inh-ctor13.C: New.
+
 2012-10-14  Steven Bosscher  <steven@gcc.gnu.org>
 
 	PR rtl-optimization/54919

gcc/testsuite/g++.dg/cpp0x/inh-ctor1.C

+// { dg-options -std=c++11 }
+
+struct A
+{
+  int i;
+  constexpr A(int i): i(i) {}
+};
+
+struct B: A
+{
+  using A::A;
+};
+
+constexpr B b(42);
+
+#define SA(X) static_assert((X),#X)
+SA(b.i == 42);

gcc/testsuite/g++.dg/cpp0x/inh-ctor10.C

+// { dg-options "-std=c++11" }
+
+struct A
+{
+  template <class... Ts> A(Ts...);
+};
+
+struct B: A
+{
+  using A::A;
+};
+
+B b1(42);
+B b2(1.0, 42, (void*)0);

gcc/testsuite/g++.dg/cpp0x/inh-ctor11.C

+// { dg-options "-std=c++11" }
+
+struct A
+{
+  A(int, ...);
+};
+
+struct B: A
+{
+  using A::A;
+};
+
+B b1(42);
+B b2(42, 1.0);			// { dg-error "no match" }

gcc/testsuite/g++.dg/cpp0x/inh-ctor12.C

+// { dg-options "-std=c++11" }
+// { dg-do run }
+
+struct A
+{
+  int i;
+  template <class T>
+  A(T t) noexcept : i(t) {}
+};
+
+struct C
+{
+  C() { throw 42; }
+};
+
+struct B: A, C
+{
+  using A::A;
+};
+
+int main()
+{
+  try { B b(24); }
+  catch (int) { return 0; }
+  __builtin_abort();
+}

gcc/testsuite/g++.dg/cpp0x/inh-ctor13.C

+// { dg-options "-std=c++11" }
+
+struct A
+{
+  int i;
+  template <class T> A(T t);
+};
+
+struct C
+{
+  C() = delete;			// { dg-error "declared here" }
+};
+
+struct B: A, C
+{
+  using A::A;			// { dg-error "C::C" }
+};
+
+int main()
+{
+  B b(24);			// { dg-error "B::B" }
+}

gcc/testsuite/g++.dg/cpp0x/inh-ctor2.C

+// { dg-options -std=c++11 }
+
+struct A
+{
+  int i;
+  constexpr A(int, int i = num): i(i) {}
+private:
+  static const int num = 42;
+};
+
+struct B: A
+{
+  using A::A;
+};
+
+constexpr B b(24);
+
+#define SA(X) static_assert((X),#X)
+SA(b.i == 42);

gcc/testsuite/g++.dg/cpp0x/inh-ctor3.C

+// { dg-options -std=c++11 }
+
+struct B1 {
+  B1(int);
+};
+struct B2 {
+  B2(int);
+};
+struct D1 : B1, B2 {
+  using B1::B1;			// { dg-error "inherited" }
+  using B2::B2;			// { dg-error "inherited" }
+};			   // ill-formed: attempts to declare D1(int) twice
+struct D2 : B1, B2 {
+  using B1::B1;
+  using B2::B2;
+  D2(int);    // OK: user declaration supersedes both implicit declarations
+};

gcc/testsuite/g++.dg/cpp0x/inh-ctor4.C

+// From N3337
+// { dg-options -std=c++11 }
+
+struct B1 {
+  B1(int);
+};
+struct B2 {
+  B2(int = 13, int = 42);
+};
+struct D1 : B1 {
+  using B1::B1;
+};
+struct D2 : B2 {
+  using B2::B2;
+};
+
+D1 d1(1);
+D2 d2a(2), d2b(3,4);

gcc/testsuite/g++.dg/cpp0x/inh-ctor5.C

+// { dg-options "-std=c++11" }
+
+struct B1 {
+  B1(int) { }
+};
+struct B2 {
+  B2(double) { }
+};
+struct D1 : B1 {    // { dg-error "no match" }
+  using B1::B1;	    // implicitly declares D1(int)
+  int x;
+};
+void test() {
+  D1 d(6);	    // OK: d.x is not initialized
+  D1 e;		    // { dg-error "deleted" } D1 has no default constructor
+}
+struct D2 : B2 {
+  using B2::B2;	    // { dg-error "no match" } implicitly declares D2(double)
+  B1 b;
+};
+D2 f(1.0);	    // { dg-error "deleted" } B1 has no default constructor

gcc/testsuite/g++.dg/cpp0x/inh-ctor6.C

+// { dg-options "-std=c++11" }
+
+extern "C" int printf (const char *, ...);
+template< class T >
+struct D : T {
+  using T::T;
+  // declares all constructors from class T
+  ~D() { printf ("Destroying wrapper\n"); }
+};
+
+struct A {
+  A(int);
+};
+
+D<A> d(42);

gcc/testsuite/g++.dg/cpp0x/inh-ctor7.C

+// { dg-options "-std=c++11" }
+
+struct A
+{
+  int i;
+  template <class T>
+  constexpr A(T t): i(t) {}
+};
+
+struct B: A
+{
+  using A::A;
+};
+
+constexpr B b(42);
+
+#define SA(X) static_assert((X),#X)
+SA(b.i == 42);

gcc/testsuite/g++.dg/cpp0x/inh-ctor8.C

+// { dg-options "-std=c++11" }
+
+struct A
+{
+  int i;
+  explicit A(int i): i(i) {}
+};
+
+struct B: A
+{
+  using A::A;
+};
+
+void f(B);
+
+int main()
+{
+  f(B(42));			// OK
+  f(42);			// { dg-error "could not convert" }
+}

gcc/testsuite/g++.dg/cpp0x/inh-ctor9.C

+// { dg-options "-std=c++11" }
+
+class A
+{
+  int i;
+protected:
+  A(int i): i(i) {}
+};
+
+struct B: A
+{
+  using A::A;			// { dg-error "protected" }
+};
+
+B b(42);			// { dg-error "this context" }