Private extension of a synchronized interface

[Jere <jhb.chat@gmail.com>]

I'll get to my ultimate goal later, but while following various
rabbit trails, I came across a situation I couldn't solve.  GNAT
allows you to make private extensions to synchronized interfaces
and it allows you to complete those private extensions with 
protected types.  I can't, however, figure out how it overrides
the abstract procedures and functions of the synchronized interface.

If I don't specify an override and try to call the procedure, it complains
that the procedure is abstract.  If I try to override the abstract
function, it complains that the signature doesn't match the one in
the protected body.  I don't know if this is a GNAT issue or 
something that Ada doesn't allow.  Here is some test code.  It
compiles as is, but there are two parts that if you uncomment 
either one of those it fails to compile.

***********************************************************

with Ada.Text_IO; use Ada.Text_IO;

procedure Hello is

    package Example is
    
        type An_Interface is synchronized interface;
        procedure p1(Self : in out An_Interface) is abstract;
        
        type Instance is synchronized new An_Interface with private;
        
        -- The following lines give the errors:
        -- "p1" conflicts with declaration at line xxx
        -- and
        -- missing body for "p1"
        
        --overriding
        --procedure p1(Self : in out Instance);
        
    private
    
        -- Some hidden implementation types, constants, etc.
    
        -- Instance full view is a protected type
        protected type Instance is new An_Interface with
            procedure p1;
        private
            -- some hidden stuff;
        end Instance;
    
    end Example;
    
    package body Example is
    
        protected body Instance is
            procedure p1 is
            begin
                Put_Line("Did Something");
            end p1;
        end Instance;
    
    end Example;
    
    v : Example.Instance;
    
begin
  Put_Line("Hello, world!");
  
  -- The following line gives the error:
  -- call to abstract procedure must be dispatching
  
  --v.p1;
end Hello;

***********************************************************

My ultimate goal is not having to declare a bunch of extra
types and packages in the public view to only use them in the
private view of the protected object.  I'd prefer that all
of the private stuff actually be in a private section.  So
I'm not tied to interfaces, but it was one attempt at getting
stuff moved down to the private section.  But while I went
down the interfaces rabbit hole, I just found the issue I 
ran into odd.

Does anyone know how to create the correct overrides for
the example above?