ada: New Local_Restrictions and User_Aspect aspects.

A GNAT-defined aspect, Local_Restrictions, is defined.
This provides a way of enforcing a given restriction for an individual
subprogram (and its call-closure) without requiring that the entire
program satisfy the restriction.
A GNAT-defined aspect, User_Aspect, is defined.
This (along with the new User_Aspect_Definition configuration pragma) provides
a way of naming a set of aspect specifications which can then be applied
to multiple declarations without textual repetition of the set.

gcc/ada/

	* local_restrict.ads: A new package. Declares Local_Restriction
	enumeration type and provides operations to check for local
	restriction violations.
	* local_restrict.adb: Corresponding package body. Replace "not
	Present (X)" calls with "No (X)" calls.
	* aspects.ads: Add a new enumeration elements,
	Aspect_Local_Restrictions and Aspect_User_Aspect, to the Aspect_Id
	enumeration type. Update Aspect_Id-indexed aggregates. Add nested
	package User_Aspect_Support to manage two pieces of state. One is
	a map from identifiers to User_Aspect_Definition pragmas (updated
	when such a pragma is encountered). The other is an
	access-to-subprogram variable that is introduced in order to keep
	the bulk of semantics out of the closure of package Aspects while
	allowing a call from aspects.adb to the sem_ch13 procedure that
	analyzes a User_Aspect aspect specification.
	* aspects.adb (Find_Aspect): Cope with a case of a block statement
	with an empty parent. It is not clear whether this is papering
	over a compiler bug. Add indirect call through the aforementioned
	access-to-subprogram variable when Find_Aspect enounters an
	unanalyzed User_Aspect aspect specification. If Find_Aspect is
	called looking for aspect Foo, then a User_Aspect specification
	might generate (during analysis) a Foo aspect specification. So
	the Find_Aspect call needs to trigger that analysis if it has not
	already taken place. Provide a body for package
	User_Aspect_Support. Replace "not Present (X)" call with "No (X)"
	call.
	* freeze.adb (Freeze_Subprogram): Check local restriction
	compatibility when a dispatching operation is overridden.
	* par-prag.adb: Add support for parsing a User_Aspect_Definition
	pragma.
	* restrict.ads: We'd like to have the body of package Restrict
	include a call to a procedure declared in package Local_Restrict.
	Doing that in the obvious way pulls most of semantics into the
	closure of package Restrict, and that turns out to cause problems.
	So we introduce a level of indirection and instead call through an
	access-to-subprogram value. In this unit, we declare the
	access-to-subprogram type and object.
	* restrict.adb (Check Restriction): When a construct is
	encountered that could violate a global restriction (depending on
	whether the given restriction is in effect), Check_Restriction is
	called. At this point, we also check for a violation of any
	corresponding local restriction that is in effect. For reasons
	described above, this check is performed via an indirect call.
	* sem_ch13.ads (Parse_Aspect_Local_Restrictions): A new function,
	similar to the existing Parse_Aspect_Xxx subprograms.
	* sem_ch13.adb: Perform semantic analysis of Local_Restrictions
	and User_Aspect aspect specifications. Declare and call new
	Validate_Aspect_Local_Restrictions and
	Analyze_User_Aspect_Aspect_Specification procedures (a reference
	to the latter is registered during package elaboration). In
	Analyze_Aspect_Specifications, do not set the Analyzed flag of a
	User_Aspect aspect specification. Replace "not Present (X)" call
	with "No (X)" call. Replace 'Image with 'Img in a case where the
	prefix of the attribute reference is an object; this is done to
	accomodate older compilers.
	* sem_ch6.adb (Check_Subtype_Conformant): Include in subtype
	conformance check a check for overriding-related compatibility of
	local restrictions.
	* sem_ch8.adb (Analyze_Subprogram_Renaming): In the case of an
	instance of a generic that takes a formal subprogram, check that
	formal and actual are compatible with respect to local
	restrictions.
	* sem_prag.adb: Add support for User_Aspect_Definition pragma.
	* sem_res.adb (Resolve_Call): Check caller/callee compatibility
	with respect to local restrictions.
	* snames.ads-tmpl: Add Name_Local_Restrictions, Name_User_Aspect,
	and Name_User_Aspect_Definition constants.
	* doc/gnat_rm/implementation_defined_aspects.rst: Document new
	aspects.
	* doc/gnat_rm/implementation_defined_pragmas.rst: Document new
	pragma.
	* doc/gnat_ugn/the_gnat_compilation_model.rst: Add
	User_Aspect_Definition to list of GNAT pragmas.
	* gcc-interface/Make-lang.in: Add local_restrict.o.
	* gnat-style.texi: Regenerate.
	* gnat_rm.texi: Regenerate.
	* gnat_ugn.texi: Regenerate.

1 files changed, 8 insertions, 0 deletions

diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb
index b8d8e70..e7b0b8b 100644
--- a/gcc/ada/sem_res.adb
+++ b/gcc/ada/sem_res.adb
@@ -46,6 +46,7 @@ with Inline;         use Inline;
 with Itypes;         use Itypes;
 with Lib;            use Lib;
 with Lib.Xref;       use Lib.Xref;
+with Local_Restrict;
 with Namet;          use Namet;
 with Nmake;          use Nmake;
 with Nlists;         use Nlists;
@@ -6783,6 +6784,13 @@ package body Sem_Res is
          Check_Ghost_Context (Nam, N);
       end if;
 
+      if Is_Entity_Name (Subp) then
+         Local_Restrict.Check_Call
+           (Call => N, Callee => Ultimate_Alias (Nam));
+      else
+         Local_Restrict.Check_Call (Call => N);
+      end if;
+
       --  If we are calling the current subprogram from immediately within its
       --  body, then that is the case where we can sometimes detect cases of
       --  infinite recursion statically. Do not try this in case restriction