diff --git a/ChangeLog b/ChangeLog --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,6 @@ +0.8.9 +- Add `toExtension` and `fromExtension` to convert between HSE and TH language extensions (by Konstantin Ivanov) + 0.8.8 - Implement toDec for AnnPragma (by Matt Torrence) - Add support for OverloadedLabels (by funketh) diff --git a/haskell-src-meta.cabal b/haskell-src-meta.cabal --- a/haskell-src-meta.cabal +++ b/haskell-src-meta.cabal @@ -1,5 +1,5 @@ name: haskell-src-meta -version: 0.8.8 +version: 0.8.9 cabal-version: >= 1.10 build-type: Simple license: BSD3 @@ -19,7 +19,7 @@ library default-language: Haskell2010 build-depends: base >= 4.10 && < 5, - haskell-src-exts >= 1.18 && < 1.24, + haskell-src-exts >= 1.21 && < 1.24, pretty >= 1.0 && < 1.2, syb >= 0.1 && < 0.8, template-haskell >= 2.12 && < 2.19, @@ -27,6 +27,7 @@ hs-source-dirs: src exposed-modules: Language.Haskell.Meta + Language.Haskell.Meta.Extensions Language.Haskell.Meta.Parse Language.Haskell.Meta.Syntax.Translate Language.Haskell.Meta.Utils @@ -41,7 +42,7 @@ build-depends: HUnit >= 1.2, base >= 4.10, - haskell-src-exts >= 1.17, + haskell-src-exts >= 1.21, haskell-src-meta, pretty >= 1.0, template-haskell >= 2.12, diff --git a/src/Language/Haskell/Meta.hs b/src/Language/Haskell/Meta.hs --- a/src/Language/Haskell/Meta.hs +++ b/src/Language/Haskell/Meta.hs @@ -8,10 +8,12 @@ -} module Language.Haskell.Meta ( + module Language.Haskell.Meta.Extensions, module Language.Haskell.Meta.Parse, module Language.Haskell.Meta.Syntax.Translate ) where +import Language.Haskell.Meta.Extensions import Language.Haskell.Meta.Parse import Language.Haskell.Meta.Syntax.Translate import Language.Haskell.TH.Instances () diff --git a/src/Language/Haskell/Meta/Extensions.hs b/src/Language/Haskell/Meta/Extensions.hs new file mode 100644 --- /dev/null +++ b/src/Language/Haskell/Meta/Extensions.hs @@ -0,0 +1,339 @@ +{-# LANGUAGE CPP #-} +{- | + Module : Language.Haskell.Meta.Parse + Copyright : (c) Serokell 2022, Adam Bergmark 2022 + License : BSD3 + Maintainer : Adam Bergmark + Stability : experimental + Portability : portable (template-haskell) +-} + +module Language.Haskell.Meta.Extensions ( + toExtension, + fromExtension + ) where + +import qualified Language.Haskell.Exts.Extension as Exts +import qualified Language.Haskell.TH.Syntax as TH + + +----------------------------------------------------------------------------- + +-- * To template-haskell + +-- | Returns @Nothing@ when the extension is not supported by template-haskell. +toExtension :: Exts.KnownExtension -> Maybe TH.Extension +toExtension e = case e of + Exts.OverlappingInstances -> Just TH.OverlappingInstances + Exts.UndecidableInstances -> Just TH.UndecidableInstances + Exts.IncoherentInstances -> Just TH.IncoherentInstances + Exts.InstanceSigs -> Just TH.InstanceSigs + Exts.DoRec -> Nothing + Exts.RecursiveDo -> Just TH.RecursiveDo + Exts.ParallelListComp -> Just TH.ParallelListComp + Exts.MultiParamTypeClasses -> Just TH.MultiParamTypeClasses + Exts.MonomorphismRestriction -> Just TH.MonomorphismRestriction + Exts.FunctionalDependencies -> Just TH.FunctionalDependencies + Exts.Rank2Types -> Nothing + Exts.RankNTypes -> Just TH.RankNTypes + Exts.PolymorphicComponents -> Nothing + Exts.ExistentialQuantification -> Just TH.ExistentialQuantification + Exts.ScopedTypeVariables -> Just TH.ScopedTypeVariables + Exts.PatternSignatures -> Nothing + Exts.ImplicitParams -> Just TH.ImplicitParams + Exts.FlexibleContexts -> Just TH.FlexibleContexts + Exts.FlexibleInstances -> Just TH.FlexibleInstances + Exts.EmptyDataDecls -> Just TH.EmptyDataDecls + Exts.CPP -> Just TH.Cpp + Exts.KindSignatures -> Just TH.KindSignatures + Exts.BangPatterns -> Just TH.BangPatterns + Exts.TypeSynonymInstances -> Just TH.TypeSynonymInstances + Exts.TemplateHaskell -> Just TH.TemplateHaskell + Exts.ForeignFunctionInterface -> Just TH.ForeignFunctionInterface + Exts.Arrows -> Just TH.Arrows + Exts.Generics -> Nothing + Exts.ImplicitPrelude -> Just TH.ImplicitPrelude + Exts.NamedFieldPuns -> Nothing + Exts.PatternGuards -> Just TH.PatternGuards + Exts.GeneralizedNewtypeDeriving -> Just TH.GeneralizedNewtypeDeriving + Exts.DeriveAnyClass -> Just TH.DeriveAnyClass + Exts.ExtensibleRecords -> Nothing + Exts.RestrictedTypeSynonyms -> Nothing + Exts.HereDocuments -> Nothing + Exts.MagicHash -> Just TH.MagicHash + Exts.BinaryLiterals -> Just TH.BinaryLiterals + Exts.TypeFamilies -> Just TH.TypeFamilies + Exts.StandaloneDeriving -> Just TH.StandaloneDeriving + Exts.UnicodeSyntax -> Just TH.UnicodeSyntax + Exts.UnliftedFFITypes -> Just TH.UnliftedFFITypes + Exts.LiberalTypeSynonyms -> Just TH.LiberalTypeSynonyms + Exts.TypeOperators -> Just TH.TypeOperators + Exts.ParallelArrays -> Just TH.ParallelArrays + Exts.RecordWildCards -> Just TH.RecordWildCards + Exts.RecordPuns -> Just TH.RecordPuns + Exts.DisambiguateRecordFields -> Just TH.DisambiguateRecordFields + Exts.OverloadedStrings -> Just TH.OverloadedStrings + Exts.GADTs -> Just TH.GADTs + Exts.MonoPatBinds -> +#if !MIN_VERSION_template_haskell(2,18,0) + Just TH.MonoPatBinds +#else + Nothing +#endif + Exts.RelaxedPolyRec -> Just TH.RelaxedPolyRec + Exts.ExtendedDefaultRules -> Just TH.ExtendedDefaultRules + Exts.UnboxedTuples -> Just TH.UnboxedTuples + Exts.DeriveDataTypeable -> Just TH.DeriveDataTypeable + Exts.ConstrainedClassMethods -> Just TH.ConstrainedClassMethods + Exts.PackageImports -> Just TH.PackageImports + Exts.LambdaCase -> Just TH.LambdaCase + Exts.EmptyCase -> Just TH.EmptyCase + Exts.ImpredicativeTypes -> Just TH.ImpredicativeTypes + Exts.NewQualifiedOperators -> Nothing + Exts.PostfixOperators -> Just TH.PostfixOperators + Exts.QuasiQuotes -> Just TH.QuasiQuotes + Exts.TransformListComp -> Just TH.TransformListComp + Exts.ViewPatterns -> Just TH.ViewPatterns + Exts.XmlSyntax -> Nothing + Exts.RegularPatterns -> Nothing + Exts.TupleSections -> Just TH.TupleSections + Exts.GHCForeignImportPrim -> Just TH.GHCForeignImportPrim + Exts.NPlusKPatterns -> Just TH.NPlusKPatterns + Exts.DoAndIfThenElse -> Just TH.DoAndIfThenElse + Exts.RebindableSyntax -> Just TH.RebindableSyntax + Exts.ExplicitForAll -> Just TH.ExplicitForAll + Exts.DatatypeContexts -> Just TH.DatatypeContexts + Exts.MonoLocalBinds -> Just TH.MonoLocalBinds + Exts.DeriveFunctor -> Just TH.DeriveFunctor + Exts.DeriveGeneric -> Just TH.DeriveGeneric + Exts.DeriveTraversable -> Just TH.DeriveTraversable + Exts.DeriveFoldable -> Just TH.DeriveFoldable + Exts.NondecreasingIndentation -> Just TH.NondecreasingIndentation + Exts.InterruptibleFFI -> Just TH.InterruptibleFFI + Exts.CApiFFI -> Just TH.CApiFFI + Exts.JavaScriptFFI -> Just TH.JavaScriptFFI + Exts.ExplicitNamespaces -> Just TH.ExplicitNamespaces + Exts.DataKinds -> Just TH.DataKinds + Exts.PolyKinds -> Just TH.PolyKinds + Exts.MultiWayIf -> Just TH.MultiWayIf + Exts.SafeImports -> Nothing + Exts.Safe -> Nothing + Exts.Trustworthy -> Nothing + Exts.DefaultSignatures -> Just TH.DefaultSignatures + Exts.ConstraintKinds -> Just TH.ConstraintKinds + Exts.RoleAnnotations -> Just TH.RoleAnnotations + Exts.PatternSynonyms -> Just TH.PatternSynonyms + Exts.PartialTypeSignatures -> Just TH.PartialTypeSignatures + Exts.NamedWildCards -> Just TH.NamedWildCards + Exts.TypeApplications -> Just TH.TypeApplications + Exts.TypeFamilyDependencies -> Just TH.TypeFamilyDependencies + Exts.OverloadedLabels -> Just TH.OverloadedLabels + Exts.DerivingStrategies -> Just TH.DerivingStrategies + Exts.UnboxedSums -> Just TH.UnboxedSums +#if MIN_VERSION_haskell_src_exts(1,21,0) + Exts.TypeInType -> Just TH.TypeInType +#endif + Exts.Strict -> Just TH.Strict + Exts.StrictData -> Just TH.StrictData + +#if MIN_VERSION_haskell_src_exts(1,21,0) + Exts.DerivingVia -> +#if MIN_VERSION_template_haskell(2,14,0) + Just TH.DerivingVia +#else + Nothing +#endif +#endif + +#if MIN_VERSION_haskell_src_exts(1,22,0) + Exts.QuantifiedConstraints -> +#if MIN_VERSION_template_haskell(2,14,0) + Just TH.QuantifiedConstraints +#else + Nothing +#endif +#endif + +#if MIN_VERSION_haskell_src_exts(1,23,0) + Exts.BlockArguments -> +#if MIN_VERSION_template_haskell(2,14,0) + Just TH.BlockArguments +#else + Nothing +#endif +#endif + + -- NB: when adding a case here, you may also need to update `fromExtension` + + +----------------------------------------------------------------------------- + +-- * From template-haskell + +-- | Returns @Nothing@ when the extension is not supported by haskell-src-exts. +fromExtension :: TH.Extension -> Maybe Exts.KnownExtension +fromExtension e = case e of + TH.Cpp -> Just Exts.CPP + TH.OverlappingInstances -> Just Exts.OverlappingInstances + TH.UndecidableInstances -> Just Exts.UndecidableInstances + TH.IncoherentInstances -> Just Exts.IncoherentInstances + TH.UndecidableSuperClasses -> Nothing + TH.MonomorphismRestriction -> Just Exts.MonomorphismRestriction +#if !MIN_VERSION_template_haskell(2,18,0) + TH.MonoPatBinds -> Just Exts.MonoPatBinds +#endif + TH.MonoLocalBinds -> Just Exts.MonoLocalBinds + TH.RelaxedPolyRec -> Just Exts.RelaxedPolyRec + TH.ExtendedDefaultRules -> Just Exts.ExtendedDefaultRules + TH.ForeignFunctionInterface -> Just Exts.ForeignFunctionInterface + TH.UnliftedFFITypes -> Just Exts.UnliftedFFITypes + TH.InterruptibleFFI -> Just Exts.InterruptibleFFI + TH.CApiFFI -> Just Exts.CApiFFI + TH.GHCForeignImportPrim -> Just Exts.GHCForeignImportPrim + TH.JavaScriptFFI -> Just Exts.JavaScriptFFI + TH.ParallelArrays -> Just Exts.ParallelArrays + TH.Arrows -> Just Exts.Arrows + TH.TemplateHaskell -> Just Exts.TemplateHaskell + TH.TemplateHaskellQuotes -> Nothing + TH.QuasiQuotes -> Just Exts.QuasiQuotes + TH.ImplicitParams -> Just Exts.ImplicitParams + TH.ImplicitPrelude -> Just Exts.ImplicitPrelude + TH.ScopedTypeVariables -> Just Exts.ScopedTypeVariables + TH.AllowAmbiguousTypes -> Nothing + TH.UnboxedTuples -> Just Exts.UnboxedTuples + TH.UnboxedSums -> Just Exts.UnboxedSums + TH.BangPatterns -> Just Exts.BangPatterns + TH.TypeFamilies -> Just Exts.TypeFamilies + TH.TypeFamilyDependencies -> Just Exts.TypeFamilyDependencies + TH.TypeInType -> +#if MIN_VERSION_haskell_src_exts(1,21,0) + Just Exts.TypeInType +#else + Nothing +#endif + TH.OverloadedStrings -> Just Exts.OverloadedStrings + TH.OverloadedLists -> Nothing + TH.NumDecimals -> Nothing + TH.DisambiguateRecordFields -> Just Exts.DisambiguateRecordFields + TH.RecordWildCards -> Just Exts.RecordWildCards + TH.RecordPuns -> Just Exts.RecordPuns + TH.ViewPatterns -> Just Exts.ViewPatterns + TH.GADTs -> Just Exts.GADTs + TH.GADTSyntax -> Nothing + TH.NPlusKPatterns -> Just Exts.NPlusKPatterns + TH.DoAndIfThenElse -> Just Exts.DoAndIfThenElse + TH.RebindableSyntax -> Just Exts.RebindableSyntax + TH.ConstraintKinds -> Just Exts.ConstraintKinds + TH.PolyKinds -> Just Exts.PolyKinds + TH.DataKinds -> Just Exts.DataKinds + TH.InstanceSigs -> Just Exts.InstanceSigs + TH.ApplicativeDo -> Nothing + TH.StandaloneDeriving -> Just Exts.StandaloneDeriving + TH.DeriveDataTypeable -> Just Exts.DeriveDataTypeable + TH.AutoDeriveTypeable -> Nothing + TH.DeriveFunctor -> Just Exts.DeriveFunctor + TH.DeriveTraversable -> Just Exts.DeriveTraversable + TH.DeriveFoldable -> Just Exts.DeriveFoldable + TH.DeriveGeneric -> Just Exts.DeriveGeneric + TH.DefaultSignatures -> Just Exts.DefaultSignatures + TH.DeriveAnyClass -> Just Exts.DeriveAnyClass + TH.DeriveLift -> Nothing + TH.DerivingStrategies -> Just Exts.DerivingStrategies + TH.TypeSynonymInstances -> Just Exts.TypeSynonymInstances + TH.FlexibleContexts -> Just Exts.FlexibleContexts + TH.FlexibleInstances -> Just Exts.FlexibleInstances + TH.ConstrainedClassMethods -> Just Exts.ConstrainedClassMethods + TH.MultiParamTypeClasses -> Just Exts.MultiParamTypeClasses + TH.NullaryTypeClasses -> Nothing + TH.FunctionalDependencies -> Just Exts.FunctionalDependencies + TH.UnicodeSyntax -> Just Exts.UnicodeSyntax + TH.ExistentialQuantification -> Just Exts.ExistentialQuantification + TH.MagicHash -> Just Exts.MagicHash + TH.EmptyDataDecls -> Just Exts.EmptyDataDecls + TH.KindSignatures -> Just Exts.KindSignatures + TH.RoleAnnotations -> Just Exts.RoleAnnotations + TH.ParallelListComp -> Just Exts.ParallelListComp + TH.TransformListComp -> Just Exts.TransformListComp + TH.MonadComprehensions -> Nothing + TH.GeneralizedNewtypeDeriving -> Just Exts.GeneralizedNewtypeDeriving + TH.RecursiveDo -> Just Exts.RecursiveDo + TH.PostfixOperators -> Just Exts.PostfixOperators + TH.TupleSections -> Just Exts.TupleSections + TH.PatternGuards -> Just Exts.PatternGuards + TH.LiberalTypeSynonyms -> Just Exts.LiberalTypeSynonyms + TH.RankNTypes -> Just Exts.RankNTypes + TH.ImpredicativeTypes -> Just Exts.ImpredicativeTypes + TH.TypeOperators -> Just Exts.TypeOperators + TH.ExplicitNamespaces -> Just Exts.ExplicitNamespaces + TH.PackageImports -> Just Exts.PackageImports + TH.ExplicitForAll -> Just Exts.ExplicitForAll + TH.AlternativeLayoutRule -> Nothing + TH.AlternativeLayoutRuleTransitional -> Nothing + TH.DatatypeContexts -> Just Exts.DatatypeContexts + TH.NondecreasingIndentation -> Just Exts.NondecreasingIndentation + TH.RelaxedLayout -> Nothing + TH.TraditionalRecordSyntax -> Nothing + TH.LambdaCase -> Just Exts.LambdaCase + TH.MultiWayIf -> Just Exts.MultiWayIf + TH.BinaryLiterals -> Just Exts.BinaryLiterals + TH.NegativeLiterals -> Nothing + TH.DuplicateRecordFields -> Nothing + TH.OverloadedLabels -> Just Exts.OverloadedLabels + TH.EmptyCase -> Just Exts.EmptyCase + TH.PatternSynonyms -> Just Exts.PatternSynonyms + TH.PartialTypeSignatures -> Just Exts.PartialTypeSignatures + TH.NamedWildCards -> Just Exts.NamedWildCards + TH.StaticPointers -> Nothing + TH.TypeApplications -> Just Exts.TypeApplications + TH.Strict -> Just Exts.Strict + TH.StrictData -> Just Exts.StrictData +#if !MIN_VERSION_template_haskell(2,18,0) + TH.MonadFailDesugaring -> Nothing +#endif + +-- 2.13.0 ---------------------------------------- +#if MIN_VERSION_template_haskell(2,13,0) + TH.HexFloatLiterals -> Nothing + TH.EmptyDataDeriving -> Nothing +#endif + +-- 2.14.0 ---------------------------------------- +#if MIN_VERSION_template_haskell(2,14,0) + + TH.DerivingVia -> +#if MIN_VERSION_haskell_src_exts(1,21,0) + Just Exts.DerivingVia +#else + Nothing +#endif + + TH.QuantifiedConstraints -> +#if MIN_VERSION_haskell_src_exts(1,22,0) + Just Exts.QuantifiedConstraints +#else + Nothing +#endif + + TH.BlockArguments -> +#if MIN_VERSION_haskell_src_exts(1,23,0) + Just Exts.BlockArguments +#else + Nothing +#endif + + TH.NumericUnderscores -> Nothing + TH.StarIsType -> Nothing +#endif + +-- 2.16.0 ---------------------------------------- +#if MIN_VERSION_template_haskell(2,16,0) + TH.UnliftedNewtypes -> Nothing + TH.ImportQualifiedPost -> Nothing + TH.CUSKs -> Nothing + TH.StandaloneKindSignatures -> Nothing +#endif + + + -- NB: when adding a case here, you may also need to update `toExtension` + +----------------------------------------------------------------------------- diff --git a/src/Language/Haskell/Meta/Syntax/Translate.hs b/src/Language/Haskell/Meta/Syntax/Translate.hs --- a/src/Language/Haskell/Meta/Syntax/Translate.hs +++ b/src/Language/Haskell/Meta/Syntax/Translate.hs @@ -810,5 +810,3 @@ instance ToDecs a => ToDecs [a] where toDecs a = concatMap toDecs a - ------------------------------------------------------------------------------