diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,18 @@ `extensions` uses [PVP Versioning][1]. The changelog is available [on GitHub][2]. + +## 0.1.0.0 — Oct 14, 2022 + +* [#74](https://github.com/kowainik/extensions/issues/74): + Support GHC-9.2. +* [#83](https://github.com/kowainik/extensions/issues/83): + Support GHC-9.4. +* Support `Cabal` `3.4`, `3.6` and `3.8`. +* [#70](https://github.com/kowainik/extensions/issues/70): + Parse empty lines and spaces in before comments and pragmas in the beginning + of the file. + ## 0.0.0.1 — May 9, 2020 🎖️ * Handle one more parsing case. diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ ## Goals -The `extensions` library provides a lighweight way to get Haskell +The `extensions` library provides a lightweight way to get Haskell LANGUAGE pragmas for Haskell modules. It has the following goals: 1. Be **lightweight**. Dependency footprint is extremely small, @@ -82,10 +82,16 @@ cabal install extensions ``` -or Stack +Stack ``` stack install extensions +``` + +or the nix package manager which allows you to use it ad-hoc via `nix-shell -p haskellPackages.extensions --run extensions` or to install via + +``` +nix-env -iA nixpkgs.haskellPackages.extensions ``` The tool can be used to inspect language extensions in your Haskell diff --git a/extensions.cabal b/extensions.cabal --- a/extensions.cabal +++ b/extensions.cabal @@ -1,6 +1,6 @@ cabal-version: 2.4 name: extensions -version: 0.0.0.1 +version: 0.1.0.0 synopsis: Parse Haskell Language Extensions description: Parse Haskell Language Extensions. See [README.md](https://github.com/kowainik/extensions#extensions) for more details. @@ -10,20 +10,28 @@ license-file: LICENSE author: Veronika Romashkina, Dmitrii Kovanikov maintainer: Kowainik -copyright: 2020 Kowainik +copyright: 2020-2022 Kowainik category: GHC, Parsing, Haskell build-type: Simple extra-doc-files: README.md CHANGELOG.md -tested-with: GHC == 8.8.3 - GHC == 8.10.1 +tested-with: GHC == 8.8.4 + GHC == 8.10.7 + GHC == 9.0.2 + GHC == 9.2.4 + GHC == 9.4.2 +flag executable + description: Build the extensions executable + default: True + manual: True + source-repository head type: git location: https://github.com/kowainik/extensions.git common common-options - build-depends: base >= 4.13.0.0 && < 4.15 + build-depends: base >= 4.13.0.0 && < 4.18 ghc-options: -Wall -Wcompat @@ -41,6 +49,11 @@ ghc-options: -Wmissing-deriving-strategies if impl(ghc >= 8.10.1) ghc-options: -Wunused-packages + if impl(ghc >= 9.0) + ghc-options: -Winvalid-haddock + if impl(ghc >= 9.2) + ghc-options: -Woperator-whitespace + -Wredundant-bang-patterns default-language: Haskell2010 default-extensions: ConstraintKinds @@ -67,27 +80,29 @@ Extensions.Package Extensions.Types - build-depends: bytestring ^>= 0.10 - , Cabal >= 3.0 && < 3.3 + build-depends: bytestring >= 0.10 && < 0.12 + , Cabal >= 3.0 && < 3.9 , containers ^>= 0.6 , directory ^>= 1.3 , filepath ^>= 1.4 - , ghc-boot-th >= 8.8.1 && < 8.11 + , ghc-boot-th >= 8.8.1 && < 9.5 , parsec ^>= 3.1 - , text ^>= 1.2.3 + , text >= 1.2.3 && < 2.1 executable extensions import: common-options + if !flag(executable) + buildable: False hs-source-dirs: app main-is: Main.hs other-modules: Cli build-depends: extensions , base - , colourista ^>= 0.1.0.0 + , colourista >= 0.1 && < 0.3 , containers , directory , filepath - , optparse-applicative ^>= 0.15 + , optparse-applicative >= 0.15 && < 0.18 , text test-suite extensions-test @@ -103,10 +118,10 @@ , bytestring , containers , ghc-boot-th - , hedgehog ^>= 1.0 + , hedgehog >= 1.0 && < 1.3 , hspec , hspec-hedgehog ^>= 0.0.1 - , text ^>= 1.2 + , text ghc-options: -threaded -rtsopts -with-rtsopts=-N diff --git a/src/Extensions.hs b/src/Extensions.hs --- a/src/Extensions.hs +++ b/src/Extensions.hs @@ -1,5 +1,5 @@ {- | -Copyright: (c) 2020 Kowainik +Copyright: (c) 2020-2022 Kowainik SPDX-License-Identifier: MPL-2.0 Maintainer: Kowainik diff --git a/src/Extensions/Cabal.hs b/src/Extensions/Cabal.hs --- a/src/Extensions/Cabal.hs +++ b/src/Extensions/Cabal.hs @@ -1,7 +1,7 @@ {-# LANGUAGE CPP #-} {- | -Copyright: (c) 2020 Kowainik +Copyright: (c) 2020-2022 Kowainik SPDX-License-Identifier: MPL-2.0 Maintainer: Kowainik @@ -28,7 +28,7 @@ import Data.Map.Strict (Map) import Data.Maybe (catMaybes, mapMaybe) import Data.Text (Text) -import Distribution.ModuleName (ModuleName (..), toFilePath) +import Distribution.ModuleName (ModuleName, toFilePath) import Distribution.PackageDescription.Parsec (parseGenericPackageDescription, runParseResult) import Distribution.Parsec.Error (PError, showPError) import Distribution.Types.Benchmark (Benchmark (..)) @@ -41,6 +41,9 @@ import Distribution.Types.Library (Library (..)) import Distribution.Types.TestSuite (TestSuite (..)) import Distribution.Types.TestSuiteInterface (TestSuiteInterface (..)) +#if MIN_VERSION_Cabal(3,6,0) +import Distribution.Utils.Path (getSymbolicPath) +#endif import GHC.LanguageExtensions.Type (Extension (..)) import System.Directory (doesFileExist) import System.FilePath ((<.>), ()) @@ -144,7 +147,11 @@ condTreeToExtensions extractModules extractBuildInfo condTree = do let comp = condTreeData condTree let buildInfo = extractBuildInfo comp +#if MIN_VERSION_Cabal(3,6,0) + let srcDirs = getSymbolicPath <$> hsSourceDirs buildInfo +#else let srcDirs = hsSourceDirs buildInfo +#endif let modules = extractModules comp ++ map toModulePath (otherModules buildInfo ++ autogenModules buildInfo) let (safeExts, parsedExtensionsAll) = partitionEithers $ mapMaybe cabalToGhcExtension $ defaultExtensions buildInfo @@ -213,143 +220,168 @@ -- | Convert 'Cabal.KnownExtension' to 'OnOffExtension'. toGhcExtension :: Cabal.KnownExtension -> Maybe Extension toGhcExtension = \case - Cabal.OverlappingInstances -> Just OverlappingInstances - Cabal.UndecidableInstances -> Just UndecidableInstances - Cabal.IncoherentInstances -> Just IncoherentInstances - Cabal.DoRec -> Just RecursiveDo - Cabal.RecursiveDo -> Just RecursiveDo - Cabal.ParallelListComp -> Just ParallelListComp - Cabal.MultiParamTypeClasses -> Just MultiParamTypeClasses - Cabal.MonomorphismRestriction -> Just MonomorphismRestriction - Cabal.FunctionalDependencies -> Just FunctionalDependencies - Cabal.Rank2Types -> Just RankNTypes - Cabal.RankNTypes -> Just RankNTypes - Cabal.PolymorphicComponents -> Just RankNTypes - Cabal.ExistentialQuantification -> Just ExistentialQuantification - Cabal.ScopedTypeVariables -> Just ScopedTypeVariables - Cabal.PatternSignatures -> Just ScopedTypeVariables - Cabal.ImplicitParams -> Just ImplicitParams - Cabal.FlexibleContexts -> Just FlexibleContexts - Cabal.FlexibleInstances -> Just FlexibleInstances - Cabal.EmptyDataDecls -> Just EmptyDataDecls - Cabal.CPP -> Just Cpp - Cabal.KindSignatures -> Just KindSignatures - Cabal.BangPatterns -> Just BangPatterns - Cabal.TypeSynonymInstances -> Just TypeSynonymInstances - Cabal.TemplateHaskell -> Just TemplateHaskell - Cabal.ForeignFunctionInterface -> Just ForeignFunctionInterface - Cabal.Arrows -> Just Arrows - Cabal.ImplicitPrelude -> Just ImplicitPrelude - Cabal.PatternGuards -> Just PatternGuards - Cabal.GeneralizedNewtypeDeriving -> Just GeneralizedNewtypeDeriving - Cabal.GeneralisedNewtypeDeriving -> Just GeneralizedNewtypeDeriving - Cabal.MagicHash -> Just MagicHash - Cabal.TypeFamilies -> Just TypeFamilies - Cabal.StandaloneDeriving -> Just StandaloneDeriving - Cabal.UnicodeSyntax -> Just UnicodeSyntax - Cabal.UnliftedFFITypes -> Just UnliftedFFITypes - Cabal.InterruptibleFFI -> Just InterruptibleFFI - Cabal.CApiFFI -> Just CApiFFI - Cabal.LiberalTypeSynonyms -> Just LiberalTypeSynonyms - Cabal.TypeOperators -> Just TypeOperators - Cabal.RecordWildCards -> Just RecordWildCards - Cabal.RecordPuns -> Just RecordPuns - Cabal.NamedFieldPuns -> Just RecordPuns - Cabal.DisambiguateRecordFields -> Just DisambiguateRecordFields - Cabal.TraditionalRecordSyntax -> Just TraditionalRecordSyntax - Cabal.OverloadedStrings -> Just OverloadedStrings - Cabal.GADTs -> Just GADTs - Cabal.GADTSyntax -> Just GADTSyntax - Cabal.RelaxedPolyRec -> Just RelaxedPolyRec - Cabal.ExtendedDefaultRules -> Just ExtendedDefaultRules - Cabal.UnboxedTuples -> Just UnboxedTuples - Cabal.DeriveDataTypeable -> Just DeriveDataTypeable - Cabal.AutoDeriveTypeable -> Just DeriveDataTypeable - Cabal.DeriveGeneric -> Just DeriveGeneric - Cabal.DefaultSignatures -> Just DefaultSignatures - Cabal.InstanceSigs -> Just InstanceSigs - Cabal.ConstrainedClassMethods -> Just ConstrainedClassMethods - Cabal.PackageImports -> Just PackageImports - Cabal.ImpredicativeTypes -> Just ImpredicativeTypes - Cabal.PostfixOperators -> Just PostfixOperators - Cabal.QuasiQuotes -> Just QuasiQuotes - Cabal.TransformListComp -> Just TransformListComp - Cabal.MonadComprehensions -> Just MonadComprehensions - Cabal.ViewPatterns -> Just ViewPatterns - Cabal.TupleSections -> Just TupleSections - Cabal.GHCForeignImportPrim -> Just GHCForeignImportPrim - Cabal.NPlusKPatterns -> Just NPlusKPatterns - Cabal.DoAndIfThenElse -> Just DoAndIfThenElse - Cabal.MultiWayIf -> Just MultiWayIf - Cabal.LambdaCase -> Just LambdaCase - Cabal.RebindableSyntax -> Just RebindableSyntax - Cabal.ExplicitForAll -> Just ExplicitForAll - Cabal.DatatypeContexts -> Just DatatypeContexts - Cabal.MonoLocalBinds -> Just MonoLocalBinds - Cabal.DeriveFunctor -> Just DeriveFunctor - Cabal.DeriveTraversable -> Just DeriveTraversable - Cabal.DeriveFoldable -> Just DeriveFoldable - Cabal.NondecreasingIndentation -> Just NondecreasingIndentation - Cabal.ConstraintKinds -> Just ConstraintKinds - Cabal.PolyKinds -> Just PolyKinds - Cabal.DataKinds -> Just DataKinds - Cabal.ParallelArrays -> Just ParallelArrays - Cabal.RoleAnnotations -> Just RoleAnnotations - Cabal.OverloadedLists -> Just OverloadedLists - Cabal.EmptyCase -> Just EmptyCase - Cabal.NegativeLiterals -> Just NegativeLiterals - Cabal.BinaryLiterals -> Just BinaryLiterals - Cabal.NumDecimals -> Just NumDecimals - Cabal.NullaryTypeClasses -> Just NullaryTypeClasses - Cabal.ExplicitNamespaces -> Just ExplicitNamespaces - Cabal.AllowAmbiguousTypes -> Just AllowAmbiguousTypes - Cabal.JavaScriptFFI -> Just JavaScriptFFI - Cabal.PatternSynonyms -> Just PatternSynonyms - Cabal.PartialTypeSignatures -> Just PartialTypeSignatures - Cabal.NamedWildCards -> Just NamedWildCards - Cabal.DeriveAnyClass -> Just DeriveAnyClass - Cabal.DeriveLift -> Just DeriveLift - Cabal.StaticPointers -> Just StaticPointers - Cabal.StrictData -> Just StrictData - Cabal.Strict -> Just Strict - Cabal.ApplicativeDo -> Just ApplicativeDo - Cabal.DuplicateRecordFields -> Just DuplicateRecordFields - Cabal.TypeApplications -> Just TypeApplications - Cabal.TypeInType -> Just TypeInType - Cabal.UndecidableSuperClasses -> Just UndecidableSuperClasses - Cabal.MonadFailDesugaring -> Just MonadFailDesugaring - Cabal.TemplateHaskellQuotes -> Just TemplateHaskellQuotes - Cabal.OverloadedLabels -> Just OverloadedLabels - Cabal.TypeFamilyDependencies -> Just TypeFamilyDependencies - Cabal.DerivingStrategies -> Just DerivingStrategies - Cabal.DerivingVia -> Just DerivingVia - Cabal.UnboxedSums -> Just UnboxedSums - Cabal.HexFloatLiterals -> Just HexFloatLiterals - Cabal.BlockArguments -> Just BlockArguments - Cabal.NumericUnderscores -> Just NumericUnderscores - Cabal.QuantifiedConstraints -> Just QuantifiedConstraints - Cabal.StarIsType -> Just StarIsType - Cabal.EmptyDataDeriving -> Just EmptyDataDeriving + Cabal.OverlappingInstances -> Just OverlappingInstances + Cabal.UndecidableInstances -> Just UndecidableInstances + Cabal.IncoherentInstances -> Just IncoherentInstances + Cabal.DoRec -> Just RecursiveDo + Cabal.RecursiveDo -> Just RecursiveDo + Cabal.ParallelListComp -> Just ParallelListComp + Cabal.MultiParamTypeClasses -> Just MultiParamTypeClasses + Cabal.MonomorphismRestriction -> Just MonomorphismRestriction + Cabal.FunctionalDependencies -> Just FunctionalDependencies + Cabal.Rank2Types -> Just RankNTypes + Cabal.RankNTypes -> Just RankNTypes + Cabal.PolymorphicComponents -> Just RankNTypes + Cabal.ExistentialQuantification -> Just ExistentialQuantification + Cabal.ScopedTypeVariables -> Just ScopedTypeVariables + Cabal.PatternSignatures -> Just ScopedTypeVariables + Cabal.ImplicitParams -> Just ImplicitParams + Cabal.FlexibleContexts -> Just FlexibleContexts + Cabal.FlexibleInstances -> Just FlexibleInstances + Cabal.EmptyDataDecls -> Just EmptyDataDecls + Cabal.CPP -> Just Cpp + Cabal.KindSignatures -> Just KindSignatures + Cabal.BangPatterns -> Just BangPatterns + Cabal.TypeSynonymInstances -> Just TypeSynonymInstances + Cabal.TemplateHaskell -> Just TemplateHaskell + Cabal.ForeignFunctionInterface -> Just ForeignFunctionInterface + Cabal.Arrows -> Just Arrows + Cabal.ImplicitPrelude -> Just ImplicitPrelude + Cabal.PatternGuards -> Just PatternGuards + Cabal.GeneralizedNewtypeDeriving -> Just GeneralizedNewtypeDeriving + Cabal.GeneralisedNewtypeDeriving -> Just GeneralizedNewtypeDeriving + Cabal.MagicHash -> Just MagicHash + Cabal.TypeFamilies -> Just TypeFamilies + Cabal.StandaloneDeriving -> Just StandaloneDeriving + Cabal.UnicodeSyntax -> Just UnicodeSyntax + Cabal.UnliftedFFITypes -> Just UnliftedFFITypes + Cabal.InterruptibleFFI -> Just InterruptibleFFI + Cabal.CApiFFI -> Just CApiFFI + Cabal.LiberalTypeSynonyms -> Just LiberalTypeSynonyms + Cabal.TypeOperators -> Just TypeOperators + Cabal.RecordWildCards -> Just RecordWildCards +#if MIN_VERSION_ghc_boot_th(9,4,1) + Cabal.RecordPuns -> Just NamedFieldPuns + Cabal.NamedFieldPuns -> Just NamedFieldPuns +#else + Cabal.RecordPuns -> Just RecordPuns + Cabal.NamedFieldPuns -> Just RecordPuns +#endif + Cabal.DisambiguateRecordFields -> Just DisambiguateRecordFields + Cabal.TraditionalRecordSyntax -> Just TraditionalRecordSyntax + Cabal.OverloadedStrings -> Just OverloadedStrings + Cabal.GADTs -> Just GADTs + Cabal.GADTSyntax -> Just GADTSyntax + Cabal.RelaxedPolyRec -> Just RelaxedPolyRec + Cabal.ExtendedDefaultRules -> Just ExtendedDefaultRules + Cabal.UnboxedTuples -> Just UnboxedTuples + Cabal.DeriveDataTypeable -> Just DeriveDataTypeable + Cabal.AutoDeriveTypeable -> Just DeriveDataTypeable + Cabal.DeriveGeneric -> Just DeriveGeneric + Cabal.DefaultSignatures -> Just DefaultSignatures + Cabal.InstanceSigs -> Just InstanceSigs + Cabal.ConstrainedClassMethods -> Just ConstrainedClassMethods + Cabal.PackageImports -> Just PackageImports + Cabal.ImpredicativeTypes -> Just ImpredicativeTypes + Cabal.PostfixOperators -> Just PostfixOperators + Cabal.QuasiQuotes -> Just QuasiQuotes + Cabal.TransformListComp -> Just TransformListComp + Cabal.MonadComprehensions -> Just MonadComprehensions + Cabal.ViewPatterns -> Just ViewPatterns + Cabal.TupleSections -> Just TupleSections + Cabal.GHCForeignImportPrim -> Just GHCForeignImportPrim + Cabal.NPlusKPatterns -> Just NPlusKPatterns + Cabal.DoAndIfThenElse -> Just DoAndIfThenElse + Cabal.MultiWayIf -> Just MultiWayIf + Cabal.LambdaCase -> Just LambdaCase + Cabal.RebindableSyntax -> Just RebindableSyntax + Cabal.ExplicitForAll -> Just ExplicitForAll + Cabal.DatatypeContexts -> Just DatatypeContexts + Cabal.MonoLocalBinds -> Just MonoLocalBinds + Cabal.DeriveFunctor -> Just DeriveFunctor + Cabal.DeriveTraversable -> Just DeriveTraversable + Cabal.DeriveFoldable -> Just DeriveFoldable + Cabal.NondecreasingIndentation -> Just NondecreasingIndentation + Cabal.ConstraintKinds -> Just ConstraintKinds + Cabal.PolyKinds -> Just PolyKinds + Cabal.DataKinds -> Just DataKinds + Cabal.ParallelArrays -> Just ParallelArrays + Cabal.RoleAnnotations -> Just RoleAnnotations + Cabal.OverloadedLists -> Just OverloadedLists + Cabal.EmptyCase -> Just EmptyCase + Cabal.NegativeLiterals -> Just NegativeLiterals + Cabal.BinaryLiterals -> Just BinaryLiterals + Cabal.NumDecimals -> Just NumDecimals + Cabal.NullaryTypeClasses -> Just NullaryTypeClasses + Cabal.ExplicitNamespaces -> Just ExplicitNamespaces + Cabal.AllowAmbiguousTypes -> Just AllowAmbiguousTypes + Cabal.JavaScriptFFI -> Just JavaScriptFFI + Cabal.PatternSynonyms -> Just PatternSynonyms + Cabal.PartialTypeSignatures -> Just PartialTypeSignatures + Cabal.NamedWildCards -> Just NamedWildCards + Cabal.DeriveAnyClass -> Just DeriveAnyClass + Cabal.DeriveLift -> Just DeriveLift + Cabal.StaticPointers -> Just StaticPointers + Cabal.StrictData -> Just StrictData + Cabal.Strict -> Just Strict + Cabal.ApplicativeDo -> Just ApplicativeDo + Cabal.DuplicateRecordFields -> Just DuplicateRecordFields + Cabal.TypeApplications -> Just TypeApplications + Cabal.TypeInType -> Just TypeInType + Cabal.UndecidableSuperClasses -> Just UndecidableSuperClasses +#if MIN_VERSION_ghc_boot_th(9,2,1) + Cabal.MonadFailDesugaring -> Nothing +#else + Cabal.MonadFailDesugaring -> Just MonadFailDesugaring +#endif + Cabal.TemplateHaskellQuotes -> Just TemplateHaskellQuotes + Cabal.OverloadedLabels -> Just OverloadedLabels + Cabal.TypeFamilyDependencies -> Just TypeFamilyDependencies + Cabal.DerivingStrategies -> Just DerivingStrategies + Cabal.DerivingVia -> Just DerivingVia + Cabal.UnboxedSums -> Just UnboxedSums + Cabal.HexFloatLiterals -> Just HexFloatLiterals + Cabal.BlockArguments -> Just BlockArguments + Cabal.NumericUnderscores -> Just NumericUnderscores + Cabal.QuantifiedConstraints -> Just QuantifiedConstraints + Cabal.StarIsType -> Just StarIsType + Cabal.EmptyDataDeriving -> Just EmptyDataDeriving #if __GLASGOW_HASKELL__ >= 810 - Cabal.CUSKs -> Just CUSKs - Cabal.ImportQualifiedPost -> Just ImportQualifiedPost - Cabal.StandaloneKindSignatures -> Just StandaloneKindSignatures - Cabal.UnliftedNewtypes -> Just UnliftedNewtypes + Cabal.CUSKs -> Just CUSKs + Cabal.ImportQualifiedPost -> Just ImportQualifiedPost + Cabal.StandaloneKindSignatures -> Just StandaloneKindSignatures + Cabal.UnliftedNewtypes -> Just UnliftedNewtypes #endif +#if __GLASGOW_HASKELL__ >= 900 + Cabal.LexicalNegation -> Just LexicalNegation + Cabal.QualifiedDo -> Just QualifiedDo + Cabal.LinearTypes -> Just LinearTypes +#endif +#if __GLASGOW_HASKELL__ >= 902 + Cabal.FieldSelectors -> Just FieldSelectors + Cabal.OverloadedRecordDot -> Just OverloadedRecordDot + Cabal.UnliftedDatatypes -> Just UnliftedDatatypes +#endif +#if __GLASGOW_HASKELL__ >= 904 + Cabal.OverloadedRecordUpdate -> Just OverloadedRecordUpdate + Cabal.AlternativeLayoutRule -> Just AlternativeLayoutRule + Cabal.AlternativeLayoutRuleTransitional -> Just AlternativeLayoutRuleTransitional + Cabal.RelaxedLayout -> Just RelaxedLayout +#endif -- GHC extensions, parsed by both Cabal and GHC, but don't have an Extension constructor - Cabal.Safe -> Nothing - Cabal.Trustworthy -> Nothing - Cabal.Unsafe -> Nothing + Cabal.Safe -> Nothing + Cabal.Trustworthy -> Nothing + Cabal.Unsafe -> Nothing -- non-GHC extensions - Cabal.Generics -> Nothing - Cabal.ExtensibleRecords -> Nothing - Cabal.RestrictedTypeSynonyms -> Nothing - Cabal.HereDocuments -> Nothing - Cabal.MonoPatBinds -> Nothing - Cabal.XmlSyntax -> Nothing - Cabal.RegularPatterns -> Nothing - Cabal.SafeImports -> Nothing - Cabal.NewQualifiedOperators -> Nothing + Cabal.Generics -> Nothing + Cabal.ExtensibleRecords -> Nothing + Cabal.RestrictedTypeSynonyms -> Nothing + Cabal.HereDocuments -> Nothing + Cabal.MonoPatBinds -> Nothing + Cabal.XmlSyntax -> Nothing + Cabal.RegularPatterns -> Nothing + Cabal.SafeImports -> Nothing + Cabal.NewQualifiedOperators -> Nothing -- | Convert 'Cabal.KnownExtension' to 'SafeHaskellExtension'. toSafeExtensions :: Cabal.KnownExtension -> Maybe SafeHaskellExtension diff --git a/src/Extensions/Module.hs b/src/Extensions/Module.hs --- a/src/Extensions/Module.hs +++ b/src/Extensions/Module.hs @@ -1,5 +1,5 @@ {- | -Copyright: (c) 2020 Kowainik +Copyright: (c) 2020-2022 Kowainik SPDX-License-Identifier: MPL-2.0 Maintainer: Kowainik @@ -31,7 +31,7 @@ import Data.List.NonEmpty (NonEmpty (..)) import System.Directory (doesFileExist) import Text.Parsec (alphaNum, between, char, eof, many, many1, manyTill, noneOf, oneOf, parse, - sepBy1, try, (<|>)) + sepBy1, skipMany, try, (<|>)) import Text.Parsec.ByteString (Parser) import Text.Parsec.Char (anyChar, endOfLine, letter, newline, space, spaces, string) import Text.Read (readMaybe) @@ -106,9 +106,12 @@ the function/import/module name. -} extensionsP :: Parser [ParsedExtension] -extensionsP = concat <$> manyTill - (try singleExtensionsP <|> try optionsGhcP <|> try commentP <|> try cppP) - (eof <|> (() <$ manyTill endOfLine letter)) +extensionsP = concat <$> + ( newLines *> + manyTill + (try singleExtensionsP <|> try optionsGhcP <|> try commentP <|> try cppP) + (eof <|> (() <$ manyTill endOfLine letter)) + ) {- | Single LANGUAGE pragma parser. @@ -124,7 +127,7 @@ languagePragmaP (commaSep (nonExtP *> extensionP <* nonExtP) <* spaces) nonExtP :: Parser () -nonExtP = () <$ many (try cppP <|> try commentP) +nonExtP = skipMany (try cppP <|> try commentP) {- | Parses all known and unknown 'OnOffExtension's or 'SafeHaskellExtension's. -} @@ -165,7 +168,7 @@ -- | Comma separated parser. Newlines and spaces are allowed around comma. commaSep :: Parser a -> Parser [a] -commaSep p = p `sepBy1` (try $ newLines *> char ',' <* newLines) +commaSep p = p `sepBy1` try (newLines *> char ',' <* newLines) {- | Haskell comment parser. Supports both single-line comments: @@ -211,4 +214,4 @@ -- | Any combination of spaces and newlines. newLines :: Parser () -newLines = () <$ many (space <|> endOfLine) +newLines = skipMany (space <|> endOfLine) diff --git a/src/Extensions/Package.hs b/src/Extensions/Package.hs --- a/src/Extensions/Package.hs +++ b/src/Extensions/Package.hs @@ -1,5 +1,5 @@ {- | -Copyright: (c) 2020 Kowainik +Copyright: (c) 2020-2022 Kowainik SPDX-License-Identifier: MPL-2.0 Maintainer: Kowainik diff --git a/src/Extensions/Types.hs b/src/Extensions/Types.hs --- a/src/Extensions/Types.hs +++ b/src/Extensions/Types.hs @@ -1,9 +1,10 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} +{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveAnyClass #-} {- | -Copyright: (c) 2020 Kowainik +Copyright: (c) 2020-2022 Kowainik SPDX-License-Identifier: MPL-2.0 Maintainer: Kowainik @@ -172,7 +173,9 @@ showExtension :: Extension -> Text showExtension = \case Cpp -> "CPP" +#if !MIN_VERSION_ghc_boot_th(9,4,1) RecordPuns -> "NamedFieldPuns" +#endif ext -> Text.pack $ show ext {- | Parse 'OnOffExtension' from a string that specifies extension. @@ -192,12 +195,14 @@ readExtension :: String -> Maybe Extension readExtension = \case "GeneralisedNewtypeDeriving" -> Just GeneralizedNewtypeDeriving - "NamedFieldPuns" -> Just RecordPuns - "RecordPuns" -> Nothing - "Rank2Types" -> Just RankNTypes - "CPP" -> Just Cpp - "Cpp" -> Nothing - s -> readMaybe s +#if !MIN_VERSION_ghc_boot_th(9,4,1) + "NamedFieldPuns" -> Just RecordPuns + "RecordPuns" -> Nothing +#endif + "Rank2Types" -> Just RankNTypes + "CPP" -> Just Cpp + "Cpp" -> Nothing + s -> readMaybe s {- | Take accumulated 'OnOffExtension's, and merge them into one 'Set', excluding enabling of 'default2010Extensions'. @@ -264,7 +269,12 @@ , PatternGuards , DoAndIfThenElse , RelaxedPolyRec +#if __GLASGOW_HASKELL__ >= 810 + , CUSKs +#endif ] deriving stock instance Read Extension -deriving stock instance Ord Extension +#if __GLASGOW_HASKELL__ < 900 +deriving stock instance Ord Extension +#endif diff --git a/test/Test/Extensions.hs b/test/Test/Extensions.hs --- a/test/Test/Extensions.hs +++ b/test/Test/Extensions.hs @@ -53,15 +53,15 @@ resultMap :: Map FilePath ExtensionsResult resultMap = Map.fromList [ "app/Cli.hs" `to` Right - (extsPlus $ Set.singleton (On ApplicativeDo)) + (extsPlus $ Set.singleton $ On ApplicativeDo) , "app/Main.hs" `to` Right exts , "src/Extensions.hs" `to` Right exts , "src/Extensions/Cabal.hs" `to` Right - (extsPlus $ Set.singleton $ On Cpp ) + (extsPlus $ Set.singleton $ On Cpp) , "src/Extensions/Module.hs" `to` Right exts , "src/Extensions/Package.hs" `to` Right exts , "src/Extensions/Types.hs" `to` Right - (extsPlus $ Set.singleton $ On DeriveAnyClass ) + (extsPlus $ Set.fromList [On Cpp, On DeriveAnyClass]) , "test/Test/Extensions.hs" `to` Right exts , "test/Test/Extensions/Cabal.hs" `to` Right exts , "test/Test/Extensions/Module.hs" `to` Right exts diff --git a/test/Test/Extensions/Module.hs b/test/Test/Extensions/Module.hs --- a/test/Test/Extensions/Module.hs +++ b/test/Test/Extensions/Module.hs @@ -177,6 +177,22 @@ "{- Haskelll -} {-# {- extension -} LANGUAGE {- called -} LambdaCase {- and nothing else -} #-} {- matters -}" [LambdaCase] itShouldParse (unlines + [ "" + , "{- |" + , "Hello" + , "-}" + , "{-# LANGUAGE CPP #-}" + ]) + [Cpp] + itShouldParse (unlines + [ "" + , "-- | Hey" + , "-- Hello" + , "--" + , "module Abc" + ]) + [] + itShouldParse (unlines [ "{-# LANGUAGE TypeApplications , LambdaCase #-}" , "{- hello -}" ])