{-# LANGUAGE ExistentialQuantification #-} module GHC.Types.Hint ( GhcHint(..) , AvailableBindings(..) , InstantiationSuggestion(..) , LanguageExtensionHint(..) , ImportSuggestion(..) , HowInScope(..) , SimilarName(..) , StarIsType(..) , UntickedPromotedThing(..) , pprUntickedConstructor, isBareSymbol , suggestExtension , suggestExtensionWithInfo , suggestExtensions , suggestExtensionsWithInfo , suggestAnyExtension , suggestAnyExtensionWithInfo , useExtensionInOrderTo , noStarIsTypeHints ) where import GHC.Prelude import qualified Data.List.NonEmpty as NE import GHC.Utils.Outputable import qualified GHC.LanguageExtensions as LangExt import Data.Typeable import GHC.Unit.Module (ModuleName, Module) import GHC.Hs.Extension (GhcTc) import GHC.Core.Coercion import GHC.Core.Type (PredType) import GHC.Types.Fixity (LexicalFixity(..)) import GHC.Types.Name (Name, NameSpace, OccName (occNameFS), isSymOcc, nameOccName) import GHC.Types.Name.Reader (RdrName (Unqual), ImpDeclSpec) import GHC.Types.SrcLoc (SrcSpan) import GHC.Types.Basic (Activation, RuleName) import {-# SOURCE #-} GHC.Tc.Types.Origin ( ClsInstOrQC(..) ) import GHC.Parser.Errors.Basic import {-# SOURCE #-} Language.Haskell.Syntax.Expr import GHC.Unit.Module.Imported (ImportedModsVal) import GHC.Data.FastString (fsLit) -- This {-# SOURCE #-} import should be removable once -- 'Language.Haskell.Syntax.Bind' no longer depends on 'GHC.Tc.Types.Evidence'. -- | The bindings we have available in scope when -- suggesting an explicit type signature. data AvailableBindings = NamedBindings (NE.NonEmpty Name) | UnnamedBinding -- ^ An unknown binding (i.e. too complicated to turn into a 'Name') data LanguageExtensionHint = -- | Suggest to enable the input extension. This is the hint that -- GHC emits if this is not a \"known\" fix, i.e. this is GHC giving -- its best guess on what extension might be necessary to make a -- certain program compile. For example, GHC might suggests to -- enable 'BlockArguments' when the user simply formatted incorrectly -- the input program, so GHC here is trying to be as helpful as -- possible. -- If the input 'SDoc' is not empty, it will contain some extra -- information about the why the extension is required, but -- it's totally irrelevant/redundant for IDEs and other tools. SuggestSingleExtension !SDoc !LangExt.Extension -- | Suggest to enable the input extensions. The list -- is to be intended as /disjunctive/ i.e. the user is -- suggested to enable /any/ of the extensions listed. If -- the input 'SDoc' is not empty, it will contain some extra -- information about the why the extensions are required, but -- it's totally irrelevant/redundant for IDEs and other tools. | SuggestAnyExtension !SDoc [LangExt.Extension] -- | Suggest to enable the input extensions. The list -- is to be intended as /conjunctive/ i.e. the user is -- suggested to enable /all/ the extensions listed. If -- the input 'SDoc' is not empty, it will contain some extra -- information about the why the extensions are required, but -- it's totally irrelevant/redundant for IDEs and other tools. | SuggestExtensions !SDoc [LangExt.Extension] -- | Suggest to enable the input extension in order to fix -- a certain problem. This is the suggestion that GHC emits when -- is more-or-less clear \"what's going on\". For example, if -- both 'DeriveAnyClass' and 'GeneralizedNewtypeDeriving' are -- turned on, the right thing to do is to enabled 'DerivingStrategies', -- so in contrast to 'SuggestSingleExtension' GHC will be a bit more -- \"imperative\" (i.e. \"Use X Y Z in order to ... \"). -- If the input 'SDoc' is not empty, it will contain some extra -- information about the why the extensions are required, but -- it's totally irrelevant/redundant for IDEs and other tools. | SuggestExtensionInOrderTo !SDoc !LangExt.Extension -- | Suggests a single extension without extra user info. suggestExtension :: LangExt.Extension -> GhcHint suggestExtension :: Extension -> GhcHint suggestExtension Extension ext = LanguageExtensionHint -> GhcHint SuggestExtension (SDoc -> Extension -> LanguageExtensionHint SuggestSingleExtension SDoc forall doc. IsOutput doc => doc empty Extension ext) -- | Like 'suggestExtension' but allows supplying extra info for the user. suggestExtensionWithInfo :: SDoc -> LangExt.Extension -> GhcHint suggestExtensionWithInfo :: SDoc -> Extension -> GhcHint suggestExtensionWithInfo SDoc extraInfo Extension ext = LanguageExtensionHint -> GhcHint SuggestExtension (SDoc -> Extension -> LanguageExtensionHint SuggestSingleExtension SDoc extraInfo Extension ext) -- | Suggests to enable /every/ extension in the list. suggestExtensions :: [LangExt.Extension] -> GhcHint suggestExtensions :: [Extension] -> GhcHint suggestExtensions [Extension] exts = LanguageExtensionHint -> GhcHint SuggestExtension (SDoc -> [Extension] -> LanguageExtensionHint SuggestExtensions SDoc forall doc. IsOutput doc => doc empty [Extension] exts) -- | Like 'suggestExtensions' but allows supplying extra info for the user. suggestExtensionsWithInfo :: SDoc -> [LangExt.Extension] -> GhcHint suggestExtensionsWithInfo :: SDoc -> [Extension] -> GhcHint suggestExtensionsWithInfo SDoc extraInfo [Extension] exts = LanguageExtensionHint -> GhcHint SuggestExtension (SDoc -> [Extension] -> LanguageExtensionHint SuggestExtensions SDoc extraInfo [Extension] exts) -- | Suggests to enable /any/ extension in the list. suggestAnyExtension :: [LangExt.Extension] -> GhcHint suggestAnyExtension :: [Extension] -> GhcHint suggestAnyExtension [Extension] exts = LanguageExtensionHint -> GhcHint SuggestExtension (SDoc -> [Extension] -> LanguageExtensionHint SuggestAnyExtension SDoc forall doc. IsOutput doc => doc empty [Extension] exts) -- | Like 'suggestAnyExtension' but allows supplying extra info for the user. suggestAnyExtensionWithInfo :: SDoc -> [LangExt.Extension] -> GhcHint suggestAnyExtensionWithInfo :: SDoc -> [Extension] -> GhcHint suggestAnyExtensionWithInfo SDoc extraInfo [Extension] exts = LanguageExtensionHint -> GhcHint SuggestExtension (SDoc -> [Extension] -> LanguageExtensionHint SuggestAnyExtension SDoc extraInfo [Extension] exts) useExtensionInOrderTo :: SDoc -> LangExt.Extension -> GhcHint useExtensionInOrderTo :: SDoc -> Extension -> GhcHint useExtensionInOrderTo SDoc extraInfo Extension ext = LanguageExtensionHint -> GhcHint SuggestExtension (SDoc -> Extension -> LanguageExtensionHint SuggestExtensionInOrderTo SDoc extraInfo Extension ext) -- | A type for hints emitted by GHC. -- A /hint/ suggests a possible way to deal with a particular warning or error. data GhcHint = {-| An \"unknown\" hint. This type constructor allows arbitrary -- hints to be embedded. The typical use case would be GHC plugins -- willing to emit hints alongside their custom diagnostics. -} forall a. (Outputable a, Typeable a) => UnknownHint a {-| Suggests adding a particular language extension. GHC will do its best trying to guess when the user is using the syntax of a particular language extension without having the relevant extension enabled. Example: If the user uses the keyword \"mdo\" (and we are in a monadic block), but the relevant extension is not enabled, GHC will emit a 'SuggestExtension RecursiveDo'. Test case(s): parser/should_fail/T12429, parser/should_fail/T8501c, parser/should_fail/T18251e, ... (and many more) -} | SuggestExtension !LanguageExtensionHint {-| Suggests possible corrections of a misspelled pragma. Its argument represents all applicable suggestions. Example: {-# LNGUAGE BangPatterns #-} Test case(s): parser/should_compile/T21589 -} | SuggestCorrectPragmaName ![String] {-| Suggests that a monadic code block is probably missing a \"do\" keyword. Example: main = putStrLn "hello" putStrLn "world" Test case(s): parser/should_fail/T8501a, parser/should_fail/readFail007, parser/should_fail/InfixAppPatErr, parser/should_fail/T984 -} | SuggestMissingDo {-| Suggests that a \"let\" expression is needed in a \"do\" block. Test cases: None (that explicitly test this particular hint is emitted). -} | SuggestLetInDo {-| Suggests to add an \".hsig\" signature file to the Cabal manifest. Triggered by: 'GHC.Driver.Errors.Types.DriverUnexpectedSignature', if Cabal is being used. Example: See comment of 'DriverUnexpectedSignature'. Test case(s): driver/T12955 -} | SuggestAddSignatureCabalFile !ModuleName {-| Suggests to explicitly list the instantiations for the signatures in the GHC invocation command. Triggered by: 'GHC.Driver.Errors.Types.DriverUnexpectedSignature', if Cabal is /not/ being used. Example: See comment of 'DriverUnexpectedSignature'. Test case(s): driver/T12955 -} | SuggestSignatureInstantiations !ModuleName [InstantiationSuggestion] {-| Suggests to use spaces instead of tabs. Triggered by: 'GHC.Parser.Errors.Types.PsWarnTab'. Examples: None Test Case(s): None -} | SuggestUseSpaces {-| Suggests adding a whitespace after the given symbol. Examples: None Test Case(s): parser/should_compile/T18834a.hs -} | SuggestUseWhitespaceAfter !OperatorWhitespaceSymbol {-| Suggests adding a whitespace around the given operator symbol, as it might be repurposed as special syntax by a future language extension. The second parameter is how such operator occurred, if in a prefix, suffix or tight infix position. Triggered by: 'GHC.Parser.Errors.Types.PsWarnOperatorWhitespace'. Example: h a b = a+b -- not OK, no spaces around '+'. Test Case(s): parser/should_compile/T18834b.hs -} | SuggestUseWhitespaceAround !String !OperatorWhitespaceOccurrence {-| Suggests wrapping an expression in parentheses Examples: None Test Case(s): None -} | SuggestParentheses {-| Suggests to increase the -fmax-pmcheck-models limit for the pattern match checker. Triggered by: 'GHC.HsToCore.Errors.Types.DsMaxPmCheckModelsReached' Test case(s): pmcheck/should_compile/TooManyDeltas pmcheck/should_compile/TooManyDeltas pmcheck/should_compile/T11822 -} | SuggestIncreaseMaxPmCheckModels {-| Suggests adding a type signature, typically to resolve ambiguity or help GHC inferring types. -} | SuggestAddTypeSignatures AvailableBindings {-| Suggests to explicitly discard the result of a monadic action by binding the result to the '_' wilcard. Example: main = do _ <- getCurrentTime -} | SuggestBindToWildcard !(LHsExpr GhcTc) | SuggestAddInlineOrNoInlinePragma !Var !Activation | SuggestAddPhaseToCompetingRule !RuleName {-| Suggests adding an identifier to the export list of a signature. -} | SuggestAddToHSigExportList !Name !(Maybe Module) {-| Suggests increasing the limit for the number of iterations in the simplifier. -} | SuggestIncreaseSimplifierIterations {-| Suggests to explicitly import 'Type' from the 'Data.Kind' module, because using "*" to mean 'Data.Kind.Type' relies on the StarIsType extension, which will become deprecated in the future. Triggered by: 'GHC.Parser.Errors.Types.PsWarnStarIsType' Example: None Test case(s): wcompat-warnings/WCompatWarningsOn.hs -} | SuggestUseTypeFromDataKind (Maybe RdrName) {-| Suggests placing the 'qualified' keyword /after/ the module name. Triggered by: 'GHC.Parser.Errors.Types.PsWarnImportPreQualified' Example: None Test case(s): module/mod184.hs -} | SuggestQualifiedAfterModuleName {-| Suggests using TemplateHaskell quotation syntax. Triggered by: 'GHC.Parser.Errors.Types.PsErrEmptyDoubleQuotes' only if TemplateHaskell is enabled. Example: None Test case(s): parser/should_fail/T13450TH.hs -} | SuggestThQuotationSyntax {-| Suggests alternative roles in case we found an illegal one. Triggered by: 'GHC.Parser.Errors.Types.PsErrIllegalRoleName' Example: None Test case(s): roles/should_fail/Roles7.hs -} | SuggestRoles [Role] {-| Suggests qualifying the '*' operator in modules where StarIsType is enabled. Triggered by: 'GHC.Parser.Errors.Types.PsWarnStarBinder' Test case(s): warnings/should_compile/StarBinder.hs -} | SuggestQualifyStarOperator {-| Suggests that a type signature should have form <variable> :: <type> in order to be accepted by GHC. Triggered by: 'GHC.Parser.Errors.Types.PsErrInvalidTypeSignature' Test case(s): parser/should_fail/T3811 -} | SuggestTypeSignatureForm {-| Suggests to move an orphan instance or to newtype-wrap it. Triggered by: 'GHC.Tc.Errors.Types.TcRnOrphanInstance' Test cases(s): warnings/should_compile/T9178 typecheck/should_compile/T4912 -} | SuggestFixOrphanInstance {-| Suggests to use a standalone deriving declaration when GHC can't derive a typeclass instance in a trivial way. Triggered by: 'GHC.Tc.Errors.Types.DerivBadErrConstructor' Test cases(s): typecheck/should_fail/tcfail086 -} | SuggestAddStandaloneDerivation {-| Suggests the user to fill in the wildcard constraint to disambiguate which constraint that is. Example: deriving instance _ => Eq (Foo f a) Triggered by: 'GHC.Tc.Errors.Types.DerivBadErrConstructor' Test cases(s): partial-sigs/should_fail/T13324_fail2 -} | SuggestFillInWildcardConstraint {-| Suggests to use an identifier other than 'forall' Triggered by: 'GHC.Tc.Errors.Types.TcRnForallIdentifier' -} | SuggestRenameForall {-| Suggests to use the appropriate Template Haskell tick: a single tick for a term-level 'NameSpace', or a double tick for a type-level 'NameSpace'. Triggered by: 'GHC.Tc.Errors.Types.TcRnIncorrectNameSpace'. -} | SuggestAppropriateTHTick NameSpace {-| Suggests enabling -ddump-splices to help debug an issue when a 'Name' is not in scope or is used in multiple different namespaces (e.g. both as a data constructor and a type constructor). Concomitant with 'NoExactName' or 'SameName' errors, see e.g. "GHC.Rename.Env.lookupExactOcc_either". Test cases: T5971, T7241, T13937. -} | SuggestDumpSlices {-| Suggests adding a tick to refer to something which has been promoted to the type level, e.g. a data constructor. Test cases: T9778, T19984. -} | SuggestAddTick UntickedPromotedThing {-| Something is split off from its corresponding declaration. For example, a datatype is given a role declaration in a different module. Test cases: T495, T8485, T2713, T5533. -} | SuggestMoveToDeclarationSite -- TODO: remove the SDoc argument. SDoc -- ^ fixity declaration, role annotation, type signature, ... RdrName -- ^ the 'RdrName' for the declaration site {-| Suggest a similar name that the user might have meant, e.g. suggest 'traverse' when the user has written @travrese@. Test case: mod73. -} | SuggestSimilarNames RdrName (NE.NonEmpty SimilarName) {-| Remind the user that the field selector has been suppressed because of -XNoFieldSelectors. Test cases: NFSSuppressed, records-nofieldselectors. -} | RemindFieldSelectorSuppressed { GhcHint -> RdrName suppressed_selector :: RdrName , GhcHint -> [Name] suppressed_parents :: [Name] } {-| Suggest importing from a module, removing a @hiding@ clause, or explain to the user that we couldn't find a module with the given 'ModuleName'. Test cases: mod28, mod36, mod87, mod114, ... -} | ImportSuggestion ImportSuggestion {-| Suggest importing a data constructor to bring it into scope Triggered by: 'GHC.Tc.Errors.Types.TcRnTypeCannotBeMarshaled' Test cases: ccfail004 -} | SuggestImportingDataCon {- Found a pragma in the body of a module, suggest placing it in the header -} | SuggestPlacePragmaInHeader {-| Suggest using pattern matching syntax for a non-bidirectional pattern synonym Test cases: patsyn/should_fail/record-exquant typecheck/should_fail/T3176 -} | SuggestPatternMatchingSyntax {-| Suggest tips for making a definition visible for the purpose of writing a SPECIALISE pragma for it in a different module. Test cases: none -} | SuggestSpecialiseVisibilityHints Name | LoopySuperclassSolveHint PredType ClsInstOrQC {-| Suggest binding explicitly; e.g data T @k (a :: F k) = .... -} | SuggestBindTyVarExplicitly Name -- | An 'InstantiationSuggestion' for a '.hsig' file. This is generated -- by GHC in case of a 'DriverUnexpectedSignature' and suggests a way -- to instantiate a particular signature, where the first argument is -- the signature name and the second is the module where the signature -- was defined. -- Example: -- -- src/MyStr.hsig:2:11: error: -- Unexpected signature: ‘MyStr’ -- (Try passing -instantiated-with="MyStr=<MyStr>" -- replacing <MyStr> as necessary.) data InstantiationSuggestion = InstantiationSuggestion !ModuleName !Module -- | Suggest how to fix an import. data ImportSuggestion -- | Some module exports what we want, but we aren't explicitly importing it. = CouldImportFrom (NE.NonEmpty (Module, ImportedModsVal)) OccName -- | Some module exports what we want, but we are explicitly hiding it. | CouldUnhideFrom (NE.NonEmpty (Module, ImportedModsVal)) OccName -- | Explain how something is in scope. data HowInScope -- | It was locally bound at this particular source location. = LocallyBoundAt SrcSpan -- | It was imported by this particular import declaration. | ImportedBy ImpDeclSpec data SimilarName = SimilarName Name | SimilarRdrName RdrName HowInScope -- | Something is promoted to the type-level without a promotion tick. data UntickedPromotedThing = UntickedConstructor LexicalFixity Name | UntickedExplicitList pprUntickedConstructor :: LexicalFixity -> Name -> SDoc pprUntickedConstructor :: LexicalFixity -> Name -> SDoc pprUntickedConstructor LexicalFixity fixity Name nm = case LexicalFixity fixity of LexicalFixity Prefix -> Bool -> SDoc -> SDoc pprPrefixVar Bool is_op SDoc ppr_nm -- e.g. (:) and '(:) LexicalFixity Infix -> Bool -> SDoc -> SDoc pprInfixVar Bool is_op SDoc ppr_nm -- e.g. `Con` and '`Con` where ppr_nm :: SDoc ppr_nm = Name -> SDoc forall a. Outputable a => a -> SDoc ppr Name nm is_op :: Bool is_op = OccName -> Bool isSymOcc (Name -> OccName nameOccName Name nm) -- | Whether a constructor name is printed out as a bare symbol, e.g. @:@. -- -- True for symbolic names in infix position. -- -- Used for pretty-printing. isBareSymbol :: LexicalFixity -> Name -> Bool isBareSymbol :: LexicalFixity -> Name -> Bool isBareSymbol LexicalFixity fixity Name nm | OccName -> Bool isSymOcc (Name -> OccName nameOccName Name nm) , LexicalFixity Infix <- LexicalFixity fixity = Bool True | Bool otherwise = Bool False -------------------------------------------------------------------------------- -- | Whether '*' is a synonym for 'Data.Kind.Type'. data StarIsType = StarIsNotType | StarIsType -- | Display info about the treatment of '*' under NoStarIsType. -- -- With StarIsType, three properties of '*' hold: -- -- (a) it is not an infix operator -- (b) it is always in scope -- (c) it is a synonym for Data.Kind.Type -- -- However, the user might not know that they are working on a module with -- NoStarIsType and write code that still assumes (a), (b), and (c), which -- actually do not hold in that module. -- -- Violation of (a) shows up in the parser. For instance, in the following -- examples, we have '*' not applied to enough arguments: -- -- data A :: * -- data F :: * -> * -- -- Violation of (b) or (c) show up in the renamer and the typechecker -- respectively. For instance: -- -- type K = Either * Bool -- -- This will parse differently depending on whether StarIsType is enabled, -- but it will parse nonetheless. With NoStarIsType it is parsed as a type -- operator, thus we have ((*) Either Bool). Now there are two cases to -- consider: -- -- 1. There is no definition of (*) in scope. In this case the renamer will -- fail to look it up. This is a violation of assumption (b). -- -- 2. There is a definition of the (*) type operator in scope (for example -- coming from GHC.TypeNats). In this case the user will get a kind -- mismatch error. This is a violation of assumption (c). -- -- The user might unknowingly be working on a module with NoStarIsType -- or use '*' as 'Data.Kind.Type' out of habit. So it is important to give a -- hint whenever an assumption about '*' is violated. Unfortunately, it is -- somewhat difficult to deal with (c), so we limit ourselves to (a) and (b). -- -- 'noStarIsTypeHints' returns appropriate hints to the user depending on the -- extensions enabled in the module and the name that triggered the error. -- That is, if we have NoStarIsType and the error is related to '*' or its -- Unicode variant, we will suggest using 'Data.Kind.Type'; otherwise we won't -- suggest anything. noStarIsTypeHints :: StarIsType -> RdrName -> [GhcHint] noStarIsTypeHints :: StarIsType -> RdrName -> [GhcHint] noStarIsTypeHints StarIsType is_star_type RdrName rdr_name -- One might ask: if can use `sdocOption sdocStarIsType` here, why bother to -- take star_is_type as input? Why not refactor? -- -- The reason is that `sdocOption sdocStarIsType` would indicate that -- StarIsType is enabled in the module that tries to load the problematic -- definition, not in the module that is being loaded. -- -- So if we have 'data T :: *' in a module with NoStarIsType, then the hint -- must be displayed even if we load this definition from a module (or GHCi) -- with StarIsType enabled! -- | Bool isUnqualStar , StarIsType StarIsNotType <- StarIsType is_star_type = [Maybe RdrName -> GhcHint SuggestUseTypeFromDataKind (RdrName -> Maybe RdrName forall a. a -> Maybe a Just RdrName rdr_name)] | Bool otherwise = [] where -- Does rdr_name look like the user might have meant the '*' kind by it? -- We focus on unqualified stars specifically, because qualified stars are -- treated as type operators even under StarIsType. isUnqualStar :: Bool isUnqualStar | Unqual OccName occName <- RdrName rdr_name = let fs :: FastString fs = OccName -> FastString occNameFS OccName occName in FastString fs FastString -> FastString -> Bool forall a. Eq a => a -> a -> Bool == String -> FastString fsLit String "*" Bool -> Bool -> Bool || FastString fs FastString -> FastString -> Bool forall a. Eq a => a -> a -> Bool == String -> FastString fsLit String "★" | Bool otherwise = Bool False