Now has std::contains_mutable

healytpk · healytpk · commit 94d3089df3f6 · 2025-11-24T23:33:29.000Z
diff --git a/gcc/cp/constraint.cc b/gcc/cp/constraint.cc
@@ -3087,6 +3087,9 @@ diagnose_trait_expr (location_t loc, tree expr, tree args)
 
   switch (TRAIT_EXPR_KIND (expr))
     {
+    case CPTK_CONTAINS_MUTABLE:
+      // Pure boolean trait; diagnostics are handled by the enclosing constraint.
+      break;
     case CPTK_GET_POLYMORPHIC_FACILITATOR:
       /* Never gives a compiler error for any type *
        * because it returns a nullptr if the type  *
diff --git a/gcc/cp/cp-trait.def b/gcc/cp/cp-trait.def
@@ -51,6 +51,7 @@
 DEFTRAIT_TYPE (ADD_LVALUE_REFERENCE, "__add_lvalue_reference", 1)
 DEFTRAIT_TYPE (ADD_POINTER, "__add_pointer", 1)
 DEFTRAIT_TYPE (ADD_RVALUE_REFERENCE, "__add_rvalue_reference", 1)
+DEFTRAIT_EXPR (CONTAINS_MUTABLE, "__builtin_contains_mutable", 1)
 DEFTRAIT_TYPE (DECAY, "__decay", 1)
 DEFTRAIT_EXPR (GET_POLYMORPHIC_FACILITATOR, "__builtin_get_polymorphic_facilitator", 1)
 DEFTRAIT_EXPR (HAS_NOTHROW_ASSIGN, "__has_nothrow_assign", 1)
diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc
@@ -13740,6 +13740,7 @@ trait_expr_value (cp_trait_kind kind, tree type1, tree type2)
     case CPTK_TYPE_ORDER:
     case CPTK_STRUCTURED_BINDING_SIZE:
     case CPTK_GET_POLYMORPHIC_FACILITATOR:
+    case CPTK_CONTAINS_MUTABLE:
       gcc_unreachable ();
 
 #define DEFTRAIT_TYPE(CODE, NAME, ARITY) \
@@ -13889,6 +13890,10 @@ finish_trait_expr (location_t loc, cp_trait_kind kind, tree type1, tree type2)
 	{
 	  TREE_TYPE (trait_expr) = const_ptr_type_node;   // void const *
 	}
+      else if (kind == CPTK_CONTAINS_MUTABLE)
+	{
+	  TREE_TYPE (trait_expr) = boolean_type_node;    // bool
+	}
       else
 	TREE_TYPE (trait_expr) = boolean_type_node;
       TRAIT_EXPR_TYPE1 (trait_expr) = type1;
@@ -13900,6 +13905,80 @@ finish_trait_expr (location_t loc, cp_trait_kind kind, tree type1, tree type2)
 
   switch (kind)
     {
+    case CPTK_CONTAINS_MUTABLE:
+    {
+      tree type = type1;
+
+      /* Reference types are treated as having no mutable subobjects.  */
+      if (TYPE_REF_P (type))
+        return boolean_false_node;
+
+      /* Strip cv-qualifiers and get the main variant.  */
+      type = cv_unqualified (TYPE_MAIN_VARIANT (type));
+
+      /* Only class/union types can contain mutable members.  */
+      if (!CLASS_TYPE_P (type))
+        return boolean_false_node;
+
+      /* Ensure we have a complete type.  */
+      if (complete_type_or_else (type, NULL_TREE) == error_mark_node)
+        return boolean_false_node;
+
+      /* Worklist of types to visit (this type, its bases, and
+         any member subobject types).  */
+      auto_vec<tree, 8> worklist;
+      worklist.safe_push (type);
+
+      while (!worklist.is_empty ())
+        {
+          tree t = worklist.pop ();
+          t = cv_unqualified (TYPE_MAIN_VARIANT (t));
+
+          /* Check non-static data members.  */
+          for (tree fld = TYPE_FIELDS (t); fld; fld = DECL_CHAIN (fld))
+            {
+              if (TREE_CODE (fld) != FIELD_DECL)
+                continue;
+
+              if (DECL_MUTABLE_P (fld))
+                return boolean_true_node;
+
+              tree ftype = TREE_TYPE (fld);
+              ftype = cv_unqualified (TYPE_MAIN_VARIANT (ftype));
+
+              if (TREE_CODE (ftype) == ARRAY_TYPE)
+              {
+                tree elem = TREE_TYPE (ftype);
+                elem = cv_unqualified (TYPE_MAIN_VARIANT (elem));
+                if (CLASS_TYPE_P (elem))
+                  worklist.safe_push (elem);
+              }
+              else if (CLASS_TYPE_P (ftype))
+                worklist.safe_push (ftype);
+            }
+
+          /* Check direct base classes.  */
+          tree binfo = TYPE_BINFO (t);
+          if (!binfo)
+            continue;
+
+          int nbases = BINFO_N_BASE_BINFOS (binfo);
+          for (int i = 0; i < nbases; ++i)
+            {
+              tree base_binfo = BINFO_BASE_BINFO (binfo, i);
+              tree btype = BINFO_TYPE (base_binfo);
+              btype = cv_unqualified (TYPE_MAIN_VARIANT (btype));
+
+              if (CLASS_TYPE_P (btype))
+                worklist.safe_push (btype);
+            }
+        }
+
+      /* No mutable members found anywhere in the hierarchy.  */
+      return boolean_false_node;
+      }
+      break;
+
     case CPTK_GET_POLYMORPHIC_FACILITATOR:
     {
       tree type = type1;
diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
@@ -4690,6 +4690,19 @@ template<typename _Ret, typename _Fn, typename... _Args>
     constexpr auto cw = constant_wrapper<_Tp>{};
 #endif
 
+#if __cplusplus >= 201103L
+/// Determine if a type contains any mutable objects
+template<typename _Tp>
+  struct contains_mutable
+    : integral_constant<bool, __builtin_contains_mutable(_Tp)>
+  { };
+
+#  if __cplusplus >= 201402L
+     template<typename _Tp>
+       constexpr bool contains_mutable_v = contains_mutable<_Tp>::value;
+#  endif
+#endif  // if __cplusplus >= 201103L
+
   /// @} group metaprogramming
 
 _GLIBCXX_END_NAMESPACE_VERSION

Original file line number	Diff line number	Diff line change
`@@ -3087,6 +3087,9 @@ diagnose_trait_expr (location_t loc, tree expr, tree args)`
`3087`	`3087`
`3088`	`3088`	`switch (TRAIT_EXPR_KIND (expr))`
`3089`	`3089`	`{`
	`3090`	`+ case CPTK_CONTAINS_MUTABLE:`
	`3091`	`+ // Pure boolean trait; diagnostics are handled by the enclosing constraint.`
	`3092`	`+ break;`
`3090`	`3093`	`case CPTK_GET_POLYMORPHIC_FACILITATOR:`
`3091`	`3094`	`/* Never gives a compiler error for any type *`
`3092`	`3095`	`* because it returns a nullptr if the type *`