[Ada] Illegal formal objects associated with anonymous acc-to-subp args

The compiler was incorrectly accepting generic instantiations with
formal objects of named access-to-subprogram types associated with an
actual of an anonymous access-to-subprogram type.
Analyze_Object_Declaration tests for objects initialized anonymous
access-to-subprogram values, and wraps a conversion around the argument,
which normally will result in error checks during resolution in
Valid_Conversion, but the conversion was only created when the
initialization expression Comes_From_Source, which prevented the
conversion wrapping from happening for constant declarations resulting
from generic expansion. The test for Comes_From_Source was removed.

The following test must report the error output given further below for
the three constructs marked as errors when compiled with this command:

gcc -c -gnatj70 bad_anon_access_instance.adb

procedure Bad_Anon_Access_Instance (Anon_Acc : access procedure) is

   type Ref is access procedure;

   Ref_1 : Ref := Anon_Acc;           -- ERROR (flagged by GNAT)

   Ref_2 : constant Ref := Anon_Acc;  -- ERROR (flagged by GNAT)

   generic
      Formal_Ref : Ref;
   package Gen is
   end Gen;

   package Inst
     is new Gen (Formal_Ref => Anon_Acc); -- ERROR (but not flagged by GNAT)

begin
   null;
end Bad_Anon_Access_Instance;

-------------
Error output:
-------------

bad_anon_access_instance.adb:4:19: illegal attempt to store anonymous
                                   access to subprogram, value has
                                   deeper accessibility than any
                                   master (RM 3.10.2 (13)), use named
                                   access type for "Anon_Acc" instead
                                   of access parameter
bad_anon_access_instance.adb:6:28: illegal attempt to store anonymous
                                   access to subprogram, value has
                                   deeper accessibility than any
                                   master (RM 3.10.2 (13)), use named
                                   access type for "Anon_Acc" instead
                                   of access parameter
bad_anon_access_instance.adb:14:32: illegal attempt to store
                                    anonymous access to subprogram,
                                    value has deeper accessibility
                                    than any master (RM 3.10.2 (13)),
                                    use named access type for
                                    "Anon_Acc" instead of access
                                    parameter

2018-09-26  Gary Dismukes  <dismukes@adacore.com>

gcc/ada/

	* sem_ch3.adb (Analyze_Object_Declaration): Remove test for
	Comes_From_Source, which prevented implicit conversions from
	being applied to anonymous access-to-subprogram formals in
	constant declartions that arise from instance associations for
	generic formal objects.  Add RM and AARM references to comment.

From-SVN: r264618

gcc/ada/ChangeLog

+2018-09-26  Gary Dismukes  <dismukes@adacore.com>
+
+	* sem_ch3.adb (Analyze_Object_Declaration): Remove test for
+	Comes_From_Source, which prevented implicit conversions from
+	being applied to anonymous access-to-subprogram formals in
+	constant declartions that arise from instance associations for
+	generic formal objects.  Add RM and AARM references to comment.
+
 2018-09-26  Olivier Hainque  <hainque@adacore.com>
 
 	* opt.ads (OpenAcc_Enabled): New flag. False by default. True

gcc/ada/sem_ch3.adb

@@ -4286,12 +4286,11 @@ package body Sem_Ch3 is
          else
 
             --  If the expression is a formal that is a "subprogram pointer"
-            --  this is illegal in accessibility terms. Add an explicit
-            --  conversion to force the corresponding check, as is done for
-            --  assignments.
+            --  this is illegal in accessibility terms (see RM 3.10.2 (13.1/2)
+            --  and AARM 3.10.2 (13.b/2)). Add an explicit conversion to force
+            --  the corresponding check, as is done for assignments.
 
-            if Comes_From_Source (N)
-              and then Is_Entity_Name (E)
+            if Is_Entity_Name (E)
               and then Present (Entity (E))
               and then Is_Formal (Entity (E))
               and then