+lookupSubBndrOcc_helper :: Bool          -- ^ must have a parent

+                        -> Bool          -- ^ look up in all namespaces

+lookupSubBndrOcc_helper must_have_parent all_ns warn_if_deprec parent_gre rdr_name

+  let original_gres = lookupGRE gre_env (LookupChildren parent_gre (rdrNameOcc rdr_name) all_ns)

+    do { child <- lookupSubBndrOcc_helper True True warn_if_deprec the_parent rdr_name

+        mkBadExportSubordinate,

+-- | Assuming a subordinate item could not be found, do another lookup for a

+-- more specific error message.

+mkBadExportSubordinate :: [GlobalRdrElt] -> LIEWrappedName GhcPs -> BadExportSubordinate

+mkBadExportSubordinate child_gres n =

+  case lookupChildren child_gres [n] of

+    (LookupChildNonType {lce_nontype_item = g} : _, _) -> BadExportSubordinateNonType g

+    (LookupChildNonData {lce_nondata_item = g} : _, _) -> BadExportSubordinateNonData g

+    _ -> BadExportSubordinateNotFound n

+

+    TcRnExportedSubordinateNotFound parent_gre k _ ->

+      mkSimpleDecorated $

+      case k of

+        BadExportSubordinateNotFound wname ->

+          let child_name      = lieWrappedName wname

+              child_name_fs   = occNameFS (rdrNameOcc child_name)

+              suggest_patsyn  = allow_patsyn && could_be_patsyn

+              could_be_patsyn =

+                case unLoc wname of

+                  IEName{} -> isLexCon child_name_fs

+                  IEData{} -> isLexCon child_name_fs

+                  IEPattern{} -> True

+                  IEType{}    -> False

+                  IEDefault{} -> False

+              basic_msg =

+                what_parent <+> quotes (ppr parent_name)

+                <+> "does not define a child named" <+> quotes (ppr child_name)

+              patsyn_msg =

+                text "nor is there a pattern synonym of that name in scope"

+              combined_msg

+                | suggest_patsyn = basic_msg <> comma $$ patsyn_msg <> dot

+                | otherwise      = basic_msg <> dot

+          in combined_msg

+        BadExportSubordinateNonType gre ->

+          let child_name = greName gre

+          in what_parent <+> quotes (ppr parent_name) <+> "defines a child named" <+> quotes (ppr child_name) <> comma

+             $$ text "but it is not in the type namespace."

+        BadExportSubordinateNonData gre ->

+          let child_name = greName gre

+          in what_parent <+> quotes (ppr parent_name) <+> "defines a child named" <+> quotes (ppr child_name) <> comma

+             $$ text "but it is not in the data namespace."

+      where

+        parent_name = greName parent_gre

+        (what_parent, allow_patsyn) = case greInfo parent_gre of

+          IAmTyCon ClassFlavour -> (text "The class", False)

+          IAmTyCon _            -> (text "The data type", True)

+          _                     -> (text "The item", False)

+    TcRnExportedSubordinateNotFound{}

+      -> ErrorWithoutFlag

+    TcRnExportedSubordinateNotFound _ k similar_names

+      -> ns_spec_hints ++ similar_names

+      where

+        ns_spec_hints = case k of

+          BadExportSubordinateNotFound{} -> noHints

+          BadExportSubordinateNonType{}  -> [SuggestChangeExportItem ExportItemRemoveSubordinateType]

+          BadExportSubordinateNonData{}  -> [SuggestChangeExportItem ExportItemRemoveSubordinateData]

+  , BadExportSubordinate(..)

+  {-| TcRnExportedSubordinateNotFound is an error that occurs when the name of a

+      subordinate export item is not in scope.

+

+      Example:

+        module M (T(X)) where  -- X is not in scope

+        data T = Y

+

+      Test cases: module/mod4

+                  rename/should_fail/T12488a

+                  rename/should_fail/T12488a_foo

+                  rename/should_fail/T12488e

+                  rename/should_fail/T12488g

+                  rename/should_fail/T25899e2

+  -}

+  TcRnExportedSubordinateNotFound

+    :: GlobalRdrElt                  -- ^ parent

+    -> BadExportSubordinate

+    -> [GhcHint]                     -- ^ similar name suggestions

+    -> TcRnMessage

+

+data BadExportSubordinate

+  = BadExportSubordinateNotFound !(LIEWrappedName GhcPs)

+  | BadExportSubordinateNonType  !GlobalRdrElt

+  | BadExportSubordinateNonData  !GlobalRdrElt

+

+import GHC.Rename.Unbound ( mkUnboundNameRdr )

+import GHC.Utils.Misc (fuzzyLookup)

+import GHC.Types.Hint

+      do { let child_gres = findChildren kids_env (greName gre)

+         ; kids <- lookupChildrenExport gre child_gres sub_rdrs

+         ; return (unzip kids) }

+                     -> [GlobalRdrElt]

+lookupChildrenExport parent_gre child_gres rdr_items = mapAndReportM doOne rdr_items

+          let all_ns = case unLoc n of

+                IEName{} -> True    -- Ignore the namespace iff the name is unadorned

+                _        -> False

+          let bareName = lieWrappedName n

+          name <-  lookupSubBndrOcc_helper False all_ns ExportDeprecationWarnings

+              do { let err = mkBadExportSubordinate child_gres n

+                       similar_names = subordinateExportSimilarNames bareName child_gres

+                 ; addDiagnosticTc (TcRnExportedSubordinateNotFound parent_gre err similar_names)

+                 ; let ub  = mkUnboundNameRdr bareName

+                 ; return (replaceLWrappedName n ub, gre)}

+subordinateExportSimilarNames :: RdrName -> [GlobalRdrElt] -> [GhcHint]

+subordinateExportSimilarNames rdr_name child_gres =

+  -- At the moment, we only suggest other children of the same parent.

+  -- One possible improvement would be to suggest bundling pattern synonyms with

+  -- data types, but not with classes or type data.

+  case NE.nonEmpty similar_names of

+    Nothing  -> []

+    Just nms -> [SuggestSimilarNames rdr_name (fmap SimilarName nms)]

+  where

+    occ_name = rdrNameOcc rdr_name

+    similar_names =

+      fuzzyLookup (occNameString occ_name)

+                  [(occNameString child_occ_name, greName gre)

+                    | gre <- child_gres

+                    , let child_occ_name = greOccName gre

+                    , occNameFS occ_name /= occNameFS child_occ_name ]

+  GhcDiagnosticCode "TcRnExportedSubordinateNotFound"               = 11592

+  , ExportItemSuggestion(..)

+  {-| Suggest to change an export item, e.g. to remove a namespace specifier.

+

+      Test cases: T12488a, T12488a_foo, T12488e, T12488g, T25899e2

+  -}

+  | SuggestChangeExportItem ExportItemSuggestion

+

+-- | Suggest to change an export item.

+data ExportItemSuggestion =

+    ExportItemRemoveSubordinateType

+  | ExportItemRemoveSubordinateData

+

+    SuggestChangeExportItem export_item_suggestion

+      -> case export_item_suggestion of

+           ExportItemRemoveSubordinateType -> text "Remove the" <+> quotes (text "type") <+> text "keyword"

+           ExportItemRemoveSubordinateData -> text "Remove the" <+> quotes (text "data") <+> text "keyword"

+    :: { lookupParentGRE :: ParentGRE     -- ^ the parent

+       , lookupChildOccName :: OccName    -- ^ the child 'OccName' to look up

+       , lookupChildrenInAllNameSpaces :: Bool

+          -- ^ whether to look in *all* 'NameSpace's, or just

+          -- in the 'NameSpace' of the 'OccName'

+       }

+  LookupChildren { lookupParentGRE = parent

+                 , lookupChildOccName = child_occ

+                 , lookupChildrenInAllNameSpaces = all_ns } ->

+      highestPriorityGREs (childGREPriority parent ns) $

+      concat $ lkup env child_occ

+    where

+      ns = occNameSpace child_occ

+      lkup | all_ns    = lookupOccEnv_AllNameSpaces

+           | otherwise = lookupOccEnv_WithFields

+mod4.hs:2:10: error: [GHC-11592]

+    • The data type ‘T’ does not define a child named ‘K2’,

+      nor is there a pattern synonym of that name in scope.

+    Suggested fix: Perhaps use ‘K1’ (Defined at mod4.hs:3:10)

+

+{-# LANGUAGE PatternSynonyms #-}

+module T12488c ( T (pattern A) ) where

+

+data T = A

+T12488c.hs:2:21: error: [GHC-58481] parse error on input ‘pattern’

+

+{-# LANGUAGE NamedDefaults #-}

+module T12488d ( T (default C) ) where

+

+class C a where

+

+data T = A

+T12488d.hs:2:21: error: [GHC-58481] parse error on input ‘default’

+

+test('T12488c', normal, compile_fail, [''])

+test('T12488d', normal, compile_fail, [''])

+{-# LANGUAGE ExplicitNamespaces #-}

+{-# LANGUAGE TypeFamilies #-}

+

+module T12488b

+  ( T ( data A,       -- data constructor (alphanumeric name)

+        data fld,     -- record field (alphanumeric name)

+        data (:!!),   -- data constructor (symbolic name)

+        data (///)    -- record field (symbolic name)

+      ),

+    C ( type F,       -- associated type (alphanumeric name)

+        data meth,    -- class method (alphanumeric name)

+        type (+++),   -- associated type (symbolic name)

+        data (***)    -- class method (symbolic name)

+      ),

+  ) where

+

+data T = A { fld :: Int }

+       | (:!!) { (///) :: Int -> Int  }

+

+class C a where

+  type F a

+  type (+++) a

+  meth :: a -> a

+  (***) :: a -> a -> a

+{-# LANGUAGE ExplicitNamespaces #-}

+{-# LANGUAGE TypeFamilies #-}

+

+module T12488f

+  ( C ( type (+++),   -- associated type (symbolic name)

+        data (++-)    -- class method (symbolic name)

+      ),

+  ) where

+

+class C a where

+  type (+++) a      -- exported

+  type (++-) a      -- not exported

+  (+++) :: a -> a   -- not exported

+  (++-) :: a -> a   -- exported

+test('T12488b', normal, compile, [''])

+test('T12488f', normal, compile, [''])

+{-# LANGUAGE ExplicitNamespaces #-}

+module T12488a

+  ( T (type A)

+  , (:!) (type (:/))

+  ) where

+

+data T = A

+

+data (:!) = (:/)

+T12488a.hs:3:5: error: [GHC-11592]

+    • The data type ‘T’ defines a child named ‘A’,

+      but it is not in the type namespace.

+    • In the export: T(type A)

+    Suggested fix: Remove the ‘type’ keyword

+

+T12488a.hs:4:5: error: [GHC-11592]

+    • The data type ‘:!’ defines a child named ‘:/’,

+      but it is not in the type namespace.

+    • In the export: (:!)(type (:/))

+    Suggested fix: Remove the ‘type’ keyword

+

+{-# LANGUAGE ExplicitNamespaces #-}

+{-# LANGUAGE TypeFamilies #-}

+module T12488a_foo ( T (type A) ) where

+

+data T = A

+

+class Foo a where

+  type A a

+  foo :: a -> Int

+T12488a_foo.hs:3:22: error: [GHC-11592]

+    • The data type ‘T’ defines a child named ‘A’,

+      but it is not in the type namespace.

+    • In the export: T(type A)

+    Suggested fix: Remove the ‘type’ keyword

+

+{-# LANGUAGE ExplicitNamespaces #-}

+{-# LANGUAGE TypeFamilies #-}

+module T12488e

+  ( C (data A)

+  , D (data (+++))

+  ) where

+

+class C a where

+  type A a

+

+class D a where

+  type (+++) a

+T12488e.hs:4:5: error: [GHC-11592]

+    • The class ‘C’ defines a child named ‘A’,

+      but it is not in the data namespace.

+    • In the export: C(data A)

+    Suggested fix: Remove the ‘data’ keyword

+

+T12488e.hs:5:5: error: [GHC-11592]

+    • The class ‘D’ defines a child named ‘+++’,

+      but it is not in the data namespace.

+    • In the export: D(data (+++))

+    Suggested fix: Remove the ‘data’ keyword

+

+{-# LANGUAGE ExplicitNamespaces #-}

+{-# LANGUAGE TypeFamilies #-}

+module T12488g

+  ( C (data (+++),

+       type (++-))

+  ) where

+

+class C a where

+  type (+++) a

+  (++-) :: a -> a

+T12488g.hs:4:5: error: [GHC-11592]

+    • The class ‘C’ defines a child named ‘++-’,

+      but it is not in the type namespace.

+    • In the export: C(data (+++), type (++-))

+    Suggested fixes:

+      • Remove the ‘type’ keyword

+      • Perhaps use ‘+++’ (Defined at T12488g.hs:9:3)

+

+T12488g.hs:4:5: error: [GHC-11592]

+    • The class ‘C’ defines a child named ‘+++’,

+      but it is not in the data namespace.

+    • In the export: C(data (+++), type (++-))

+    Suggested fixes:

+      • Remove the ‘data’ keyword

+      • Perhaps use ‘++-’ (Defined at T12488g.hs:10:3)

+

+T25899e2.hs:5:5: error: [GHC-11592]

+    • The data type ‘T’ defines a child named ‘MkT’,

+      but it is not in the data namespace.

+    Suggested fix: Remove the ‘data’ keyword

+test('T12488a', normal, compile_fail, [''])

+test('T12488a_foo', normal, compile_fail, [''])

+test('T12488e', normal, compile_fail, [''])

+test('T12488g', normal, compile_fail, [''])