GNAT warns about primitive operations appearing too late in the text.
In the following example, though, F is not meant to be a primitive
operation of A.Some_Tagged, but instead one of type B.Plain.

Can I ignore the warning?

gcc -gnatl -c rt_warn.ads

GNAT 11.2.0
Copyright 1992-2021, Free Software Foundation, Inc.
cannot generate code for file rt_warn.ads (package spec)

Compiling: rt_warn.ads
Source file time stamp: 2022-07-10 08:34:32
Compiled at: 2022-07-10 10:34:39

1. package Rt_Warn is
2.
3. package A is
4.
5. type Some_Tagged is interface;
6.
7. end A;
8.
9. package B is
10.
11. type Plain is private;
12.
13. function F (Param : A.Some_Tagged) return Plain;
|
>>> warning: declaration of "F" is too late
>>> warning: spec should appear immediately after declaration of "Some_Tagged"

14. function FC (Param : A.Some_Tagged'Class) return Plain;
15. private
16. type Plain is record
17. null;
18. end record;
19. end B;
20.
21. end Rt_Warn;

21 lines: No errors, 2 warnings

On 2022-07-10 10:45, G.B. wrote:
> GNAT warns about primitive operations appearing too late in the text.
> In the following example, though, F is not meant to be a primitive
> operation of A.Some_Tagged, but instead one of type B.Plain.
>
> Can I ignore the warning?
>
> gcc -gnatl -c rt_warn.ads
>
> GNAT 11.2.0
> Copyright 1992-2021, Free Software Foundation, Inc.
> cannot generate code for file rt_warn.ads (package spec)
>
>
> Compiling: rt_warn.ads
> Source file time stamp: 2022-07-10 08:34:32
> Compiled at: 2022-07-10 10:34:39
>
>      1. package Rt_Warn is
>      2.
>      3.     package A is
>      4.
>      5.         type Some_Tagged is interface;
>      6.
>      7.     end A;
>      8.
>      9.     package B is
>     10.
>     11.         type Plain is private;
>     12.
>     13.         function F (Param : A.Some_Tagged) return Plain;
>                          |
>         >>> warning: declaration of "F" is too late
>         >>> warning: spec should appear immediately after declaration
> of "Some_Tagged"

Some_Tagged is an interface, it cannot have implementations anyway.
Should be an error rather than just warning to me.

--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

"G.B." <bauhaus@notmyhomepage.invalid> writes:

> GNAT warns about primitive operations appearing too late in the text.
> In the following example, though, F is not meant to be a primitive
> operation of A.Some_Tagged, but instead one of type B.Plain.
>
> Can I ignore the warning?

It's best to never ignore warnings, but instead fix them. Even if the
only way to "fix" it is to add "pragma Warnings (Off ...)"; that at
least tells the reader you have considered the warning.

Since B.F is declared in a sibling package, it cannot a primitive of
A.Some_Tagged, so the error message is wrong.

Since A.Some_Tagged is an interface, you can only declare abstract
primitive subprograms for it. So I suspect GNAT knows there's an error, but is
giving a confusing error message.

How are you intending F to be different from FC?

--
-- Stephe

On 11.07.22 06:27, Stephen Leake wrote:

> Since B.F is declared in a sibling package, it cannot a primitive of
> A.Some_Tagged, so the error message is wrong.
>
> Since A.Some_Tagged is an interface, you can only declare abstract
> primitive subprograms for it. So I suspect GNAT knows there's an error, but is
> giving a confusing error message.

It seems possible to write programs declaring B.F (Param : A.Some_Tagged)...,
but hardly one that isn't pointless! Adding "in out" to the
function's Param allows 'Access using 'Class renames Ref'(Param'Access).all
and then 'Unchecked_Access---so twisted I shan't repeat it here.
Adding (... : access A.Some_Tagged) works a lot better (of course <:-|),
and still has the warning.

But, GNAT is right, I think!

> How are you intending F to be different from FC?

The first F was a bad choice, I guess; I had wanted to exclude a potentially
larger interface. FC was the beginning of dropping F.
FC now takes an access to class-wide.

With Op1 added to the interface of Some_Tagged,

package B is
type Plain(<>) is private;

function FC (Param : access A.Some_Tagged'Class) return Plain;
procedure G (Item : in out Plain; Param : in Character);
-- Calls Op1 of Item.Client
private
type Plain (Client : access A.Some_Tagged'Class) is record
null;
end record;
end B;

No F, no warning.