Importing a bundled pattern "infects" all other imports of that pattern

Consider:

{-# LANGUAGE PatternSynonyms #-}
unit p where
    module A0 where
        data G = G Int
    module A1 where
        import A0
        pattern X x = G x
    module A(G(X)) where
        import A0
        import A1
    module B(G) where
        import A
    module C(pattern X) where
        import A
    module D(N.G, pattern N.X) where
        import B
        import C
        import qualified A0 as N
        import qualified A1 as N

When we look at the interface for D, we see that X is bundled with G. This is a little surprising because I explicitly exported the G and X from A0 and A1, where no bundling took place.

I suppose the current semantics might also be alright, but we should explicitly say so. The spec in the wiki is silent in this respect: https://ghc.haskell.org/trac/ghc/wiki/PatternSynonyms/AssociatingSynonyms

changed weight to 3

added Tbug Trac import typechecker labels

I don't really understand this example sorry.

What is a unit? How can N be bundled with anything (it isn't a pattern synonym)?

Replying to [ticket:13321#comment:132388 mpickering]:

What is a unit?

A backpack thing. You can save this source as a single file U.bkp and build it with ghc --backpack U.bkp. In this case it's equivalent to just writing six .hs files. (I just learned about this from this ticket.)

How can N be bundled with anything (it isn't a pattern synonym)?

It should read "When we look at the interface for D, we see that X is bundled with G", I assume.

Yes, rwbarton is exactly right. Here's a self-contained example that doesn't involve looking at the interface file:

{-# LANGUAGE PatternSynonyms #-}
unit p where
    module A0 where
        data G = G Int
    module A1 where
        import A0
        pattern X x = G x
    module A(G(X)) where
        import A0
        import A1
    module B(G) where
        import A
    module C(pattern X) where
        import A
    module D(N.G, pattern N.X) where
        import B
        import C
        import qualified A0 as N
        import qualified A1 as N
    module E where
        import D(G(..))
        f (X x) = x -- X is in scope

changed the description

added Plow label