c++: modules and std::source_location::current() def arg [PR100881]

We currently declare __builtin_source_location with a const void* return
type instead of the actual type const std::source_location::__impl*, and
later when folding this builtin we obtain the actual type via name lookup.

But the below testcase demonstrates this approach seems to interact
poorly with modules, since we may import an entity that uses
std::source_location::current() in its default argument (or DMI) without
necessarily importing <source_location>, and thus the name lookup for
std::source_location will fail at the call site (when using the default
argument) unless we also import <source_location>.

This patch fixes this by instead initially declaring the builtin with an
auto return type and updating it appropriately upon its first use (in
standard code the first/only use would be in the definition of
std::source_location).  Thus when folding calls to this builtin we can
get at its return type through the type of the CALL_EXPR and avoid
needing to do a name lookup.

	PR c++/100881

gcc/cp/ChangeLog:

	* constexpr.cc (cxx_eval_builtin_function_call): Adjust calls
	to fold_builtin_source_location.
	* cp-gimplify.cc (cp_gimplify_expr): Likewise.
	(cp_fold): Likewise.
	(get_source_location_impl_type): Remove location_t parameter and
	adjust accordingly.  No longer static.
	(fold_builtin_source_location): Take a CALL_EXPR tree instead of a
	location and obtain the impl type from its return type.
	* cp-tree.h (enum cp_tree_index): Remove CPTI_SOURCE_LOCATION_IMPL
	enumerator.
	(source_location_impl): Remove.
	(fold_builtin_source_location): Adjust parameter type.
	(get_source_location_impl_type): Declare.
	* decl.cc (cxx_init_decl_processing): Declare
	__builtin_source_location with auto return type instead of
	const void*.
	(require_deduced_type): Update the return type of
	__builtin_source_location.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp2a/srcloc3.C: Adjust expected note s/evaluating/using.
	* g++.dg/cpp2a/srcloc4.C: Likewise.
	* g++.dg/cpp2a/srcloc5.C: Likewise.
	* g++.dg/cpp2a/srcloc6.C: Likewise.
	* g++.dg/cpp2a/srcloc7.C: Likewise.
	* g++.dg/cpp2a/srcloc8.C: Likewise.
	* g++.dg/cpp2a/srcloc9.C: Likewise.
	* g++.dg/cpp2a/srcloc10.C: Likewise.
	* g++.dg/cpp2a/srcloc11.C: Likewise.
	* g++.dg/cpp2a/srcloc12.C: Likewise.
	* g++.dg/cpp2a/srcloc13.C: Likewise.
	* g++.dg/modules/pr100881_a.C: New test.
	* g++.dg/modules/pr100881_b.C: New test.

1 files changed, 23 insertions, 2 deletions

diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index 5081563..df74d88 100644
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -4670,9 +4670,13 @@ cxx_init_decl_processing (void)
 			    BUILT_IN_FRONTEND, NULL, NULL_TREE);
   set_call_expr_flags (decl, ECF_CONST | ECF_NOTHROW | ECF_LEAF);
 
-  tree cptr_ftype = build_function_type_list (const_ptr_type_node, NULL_TREE);
+  /* The concrete return type of __builtin_source_location is
+     const std::source_location::__impl*, but we can't form the type
+     at this point.  So we initially declare it with an auto return
+     type which we then "deduce" from require_deduced_type upon first use.  */
+  tree auto_ftype = build_function_type_list (make_auto (), NULL_TREE);
   decl = add_builtin_function ("__builtin_source_location",
-			       cptr_ftype, CP_BUILT_IN_SOURCE_LOCATION,
+			       auto_ftype, CP_BUILT_IN_SOURCE_LOCATION,
 			       BUILT_IN_FRONTEND, NULL, NULL_TREE);
   set_call_expr_flags (decl, ECF_CONST | ECF_NOTHROW | ECF_LEAF);
 
@@ -18752,6 +18756,23 @@ require_deduced_type (tree decl, tsubst_flags_t complain)
 {
   if (undeduced_auto_decl (decl))
     {
+      if (TREE_CODE (decl) == FUNCTION_DECL
+	  && fndecl_built_in_p (decl, BUILT_IN_FRONTEND)
+	  && DECL_FE_FUNCTION_CODE (decl) == CP_BUILT_IN_SOURCE_LOCATION)
+	{
+	  /* Set the return type of __builtin_source_location.  */
+	  tree type = get_source_location_impl_type ();
+	  if (type == error_mark_node)
+	    {
+	      inform (input_location, "using %qs", "__builtin_source_location");
+	      return false;
+	    }
+	  type = cp_build_qualified_type (type, TYPE_QUAL_CONST);
+	  type = build_pointer_type (type);
+	  apply_deduced_return_type (decl, type);
+	  return true;
+	}
+
       if (warning_suppressed_p (decl) && seen_error ())
 	/* We probably already complained about deduction failure.  */;
       else if (complain & tf_error)