with its record fields, in the form of a list of Int indices into...

   - IntMap FieldOcc, an IntMap of record fields.

 in GHC.Types.GREInfo.)

 This allows us to do the following (see GHC.Rename.Names.getLocalNonValBinders.new_tc):

 -- See Note [Collecting record fields in data declarations].

 data LConsWithFields p =

   LConsWithFields

     , consFields :: IntMap (LFieldOcc (GhcPass p))

     }

                 LConsWithFields ns fs = go seen' rs

     get_flds_h98 :: FieldIndices p -> HsConDeclH98Details (GhcPass p)

     get_flds_gadt :: FieldIndices p -> HsConDeclGADTDetails (GhcPass p)

     get_flds :: FieldIndices p -> LocatedA [LHsConDeclRecField (GhcPass p)]

              -> ([Located Int], FieldIndices p)

   = do { info <- lookupGREInfo_GRE con_name

        ; case info of

             IAmConLike con_info -> return con_info

             IAmTyCon {}         -> failIllegalTyCon WL_ConLike qcon

             _ -> pprPanic "lookupConstructorInfo: not a ConLike" $

                       vcat [ text "name:" <+> ppr con_name ]

 import GHC.Types.Hint

 import GHC.Types.SourceFile

 import GHC.Types.SrcLoc as SrcLoc

 import GHC.Types.Id

 import GHC.Types.PkgQual

 import GHC.Types.GREInfo (ConInfo(..), ConFieldInfo (..), ConLikeInfo (ConIsData))

     --

     -- The information we needed was all set up for us:

     -- see Note [Collecting record fields in data declarations] in GHC.Hs.Utils.

                -> [(ConLikeName, ConInfo)]

     mk_fld_env names flds =

       [ (DataConName con, ConInfo (ConIsData (map fst names)) fld_info)

     new_assoc :: DuplicateRecordFields -> FieldSelectors -> LInstDecl GhcPs

               -> RnM [GlobalRdrElt]

     -- Add errors if a constructor has a duplicate record field.

     add_dup_fld_errs :: IntMap FieldLabel

                      -> IOEnv (Env TcGblEnv TcLclEnv) ()

       , let (_, dups) = removeDups (comparing unLoc) con_flds

       = for_ dups $ \ dup_flds ->

           -- Report the error at the location of the second occurrence

            ; checkErr dd_flag (needFlagDotDot ctxt)

            ; (rdr_env, lcl_env) <- getRdrEnvs

            ; conInfo <- lookupConstructorInfo qcon

            ; let present_flds = mkOccSet $ map rdrNameOcc (getFieldRdrs flds)

                    -- For constructor uses (but not patterns)

       -> mkSimpleDecorated $ vcat [text "Illegal view pattern: " <+> ppr pat]

     TcRnCharLiteralOutOfRange c

       -> mkSimpleDecorated $ text "character literal out of range: '\\" <> char c  <> char '\''

       -> mkSimpleDecorated $

            text "The data constructor" <+> quotes (ppr con)

              <+> text "does not have named record fields, so the record"

       -> [suggestExtension LangExt.ViewPatterns]

     TcRnCharLiteralOutOfRange{}

       -> noHints

       -> case ctx of

     TcRnIgnoringAnnotations{}

       -> noHints

     TcRnAnnotationInSafeHaskell

       worded accordingly. Constructors with no fields at all do not trigger

       this error: since GHC proposal 496 ("Nullary record wildcards"),

       @C {..}@ is legal for nullary constructors.

       Example(s):

        rename/should_fail/T9815bghci.hs

        rename/should_fail/T21101.hs

   -}

   {-| TcRnIgnoringAnnotations is a warning that occurs when the source code

       contains annotation pragmas but the platform in use does not support an

 -- See Note [Local constructor info in the renamer]

 data ConFieldInfo

   = ConHasRecordFields (NonEmpty FieldLabel)

   | ConIsNullary

   deriving stock Eq

   deriving Data

 instance NFData ConFieldInfo where

   rnf ConIsNullary = ()

   rnf (ConHasRecordFields flds) = rnf flds

 mkConInfo :: ConLikeInfo -> VisArity -> [FieldLabel] -> ConInfo

   ConInfo { conLikeInfo  = con_ty

           , conFieldInfo = mkConFieldInfo n flds }

 mkConFieldInfo 0 _ = ConIsNullary

                    $ NonEmpty.nonEmpty fields

 conInfoFields :: ConInfo -> [FieldLabel]

 conFieldInfoFields :: ConFieldInfo -> [FieldLabel]

 conFieldInfoFields (ConHasRecordFields fields) = NonEmpty.toList fields

 conFieldInfoFields ConIsNullary = []

 instance Outputable ConInfo where

 instance Outputable ConFieldInfo where

   ppr ConIsNullary = text "ConIsNullary"

   ppr (ConHasRecordFields fieldLabels) =

     text "ConHasRecordFields" <+> braces (ppr fieldLabels)

 import GHC.Types.Name (Name, NameSpace, OccName (occNameFS), isSymOcc, nameOccName)

 import GHC.Types.Name.Reader (RdrName (Unqual), ImpDeclSpec, GlobalRdrElt)

 import GHC.Types.SrcLoc (SrcSpan)

 import GHC.Parser.Errors.Basic

 import GHC.Utils.Outputable

 import GHC.Data.FastString (fsLit)

       of record syntax, for constructors without labelled fields.

       Triggered by 'GHC.Tc.Errors.Types.TcRnIllegalWildcardsInConstructor'

   -}

 -- | What the user should upgrade to resolve an @-jsem@ semaphore

 --   protocol version mismatch.

     SuggestEmptyRecordBraces con

       -> text "Use" <+> quotes (ppr con <> text "{}") <+> text "instead,"

          <+> text "which matches" <+> quotes (ppr con) <+> text "regardless of its fields"

 perhapsAsPat :: SDoc

 perhapsAsPat = text "Perhaps you meant an as-pattern, which must not be surrounded by whitespace"

 T21101.hs:7:3: error: [GHC-47217]

     The data constructor ‘D’ does not have named record fields, so the record pattern ‘D{..}’ is invalid.

 T9815.hs:6:13: error: [GHC-47217]

     The data constructor ‘N’ does not have named record fields, so the record construction ‘N{..}’ is invalid.

 T9815.hs:6:13: error: [GHC-47217]

     The data constructor ‘N’ does not have named record fields, so the record construction ‘N{..}’ is invalid.

 <interactive>:5:7: error: [GHC-47217]

     The data constructor ‘Arg’ does not have named record fields, so the record construction ‘Arg{..}’ is invalid.

 <interactive>:3:7: error: [GHC-47217]

     The data constructor ‘Data.Semigroup.Arg’ does not have named record fields, so the record construction ‘Data.Semigroup.Arg{..}’ is invalid.