ghc-compat-plugin 0.0.2.0 → 0.1.0.0

raw patch · 35 files changed

+3279/−118 lines, 35 filesdep +ghc-compat-pluginPVP ok

version bump matches the API change (PVP)

Dependencies added: ghc-compat-plugin

API changes (from Hackage documentation)

Files

• CHANGELOG.md +13/−0
• README.md +4/−4
• ghc-compat-plugin.cabal +267/−2
• supported/GhcCompat.hs +166/−18
• supported/GhcCompat/GhcRelease.hs +295/−84
• supported/GhcCompat/Opts.hs +27/−10
• tests/README.md +21/−0
• tests/Test/Min_6_0_1.hs +7/−0
• tests/Test/Min_6_10_1.hs +51/−0
• tests/Test/Min_6_12_1.hs +56/−0
• tests/Test/Min_6_8_1.hs +46/−0
• tests/Test/Min_7_0_1.hs +59/−0
• tests/Test/Min_7_10_1.hs +92/−0
• tests/Test/Min_7_2_1.hs +65/−0
• tests/Test/Min_7_4_1.hs +69/−0
• tests/Test/Min_7_6_1.hs +74/−0
• tests/Test/Min_7_8_1.hs +82/−0
• tests/Test/Min_8_0_1.hs +103/−0
• tests/Test/Min_8_10_1.hs +119/−0
• tests/Test/Min_8_2_1.hs +105/−0
• tests/Test/Min_8_4_1.hs +107/−0
• tests/Test/Min_8_6_1.hs +113/−0
• tests/Test/Min_8_8_1.hs +114/−0
• tests/Test/Min_9_0_1.hs +122/−0
• tests/Test/Min_9_10_1.hs +136/−0
• tests/Test/Min_9_12_1.hs +139/−0
• tests/Test/Min_9_14_1.hs +142/−0
• tests/Test/Min_9_2_1.hs +128/−0
• tests/Test/Min_9_2_4.hs +129/−0
• tests/Test/Min_9_6_1.hs +130/−0
• tests/Test/Min_9_8_1.hs +134/−0
• tests/Test/SupportGHC2021.hs +35/−0
• tests/Test/SupportGHC2024.hs +23/−0
• tests/compilation-haskell.hs +97/−0
• tests/skip.hs +9/−0

@@ -5,6 +5,18 @@ The format is based on [Keep a Changelog 1.1](https://keepachangelog.com/en/1.1.0/), and this project adheres to the [Haskell Package Versioning Policy](https://pvp.haskell.org/). +## [0.1.0.0] – 2026-02-09++### Added++- tests (#6)+- support for reporting language editions that aren’t supported by `minVersion` (#7)++### Fixed++- don’t report extensions implied by language (#6)+- if `minVersion` is provided multiple times, the last one will be used, rather than the first (#6)+ ## [0.0.2.0] – 2026-02-03  ### Fixed@@ -20,5 +32,6 @@  <!-- NB: The version on the left is the Haskell package version (PVP), the version on the right is the repo (tag) version (SemVer). Their only relationship is that a change of any severity on the left implies a change of at least that severity on the right. --> +[0.1.0.0]: https://github.com/sellout/ghc-compat-plugin/compare/v0.2.0...v1.0.0 [0.0.2.0]: https://github.com/sellout/ghc-compat-plugin/compare/v0.1.0...v0.2.0 [0.0.1.0]: https://github.com/sellout/ghc-compat-plugin/releases/tag/v0.1.0

@@ -12,8 +12,8 @@  This plugin does three things: -1. reports if you use any [language extensions]() that aren’t supported by your minimum GHC version,-2. automatically disables any [warnings]() where addressing them requires features that aren’t part of your minimum GHC version, and+1. reports if you use a [language edition](https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/control.html) or [language extensions](https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/table.html) that aren’t supported by your minimum GHC version,+2. automatically disables any [warnings](https://ghc.gitlab.haskell.org/ghc/doc/users_guide/using-warnings.html) where addressing them requires features that aren’t part of your minimum GHC version, and 3. reports any warnings from no. 2 that were introduced before GHC 8.10.1[^1].  [^1]: This is because before GHC 8.10.1, plugins couldn’t modify warning flags, so we report them to allow them to be manually disabled.@@ -40,7 +40,7 @@ [^2]: I like to put it in a `common` section (provided you’re using at least Cabal 2.2) that’s imported by all my stanzas.  ```cabal-  build-depends: ghc-compat-plugin >=0.0.2 && <0.1+  build-depends: ghc-compat-plugin >=0.1.0 && <0.2   ghc-options:     -fplugin=GhcCompat     -fplugin-opt=GhcCompat:minVersion=8.8.1@@ -60,7 +60,7 @@  ```cabal   if impl(ghc >= 7.2.1)-    build-depends: ghc-compat-plugin >=0.0.2 && <0.1+    build-depends: ghc-compat-plugin >=0.1.0 && <0.2     ghc-options:       -fplugin=GhcCompat       -fplugin-opt=GhcCompat:minVersion=6.8.1

@@ -5,7 +5,7 @@ -- https://cabal.readthedocs.io/en/stable/file-format-changelog.html  name: ghc-compat-plugin-version: 0.0.2.0+version: 0.1.0.0 synopsis: Eases support for multiple GHC versions description: Controls various GHC options and extensions to make compilation              across multiple versions easier, and to alert you to@@ -24,6 +24,7 @@   CHANGELOG.md   README.md   docs/*.md+  tests/README.md tested-with:   GHC ==7.10.3   || ==8.0.2@@ -54,7 +55,7 @@   location: https://github.com/sellout/ghc-compat-plugin.git   subdir: core   -- NB: This is the repo version, which is distinct from the package version.-  tag: v0.2.0+  tag: v1.0.0  flag noisy-deprecations   description:@@ -75,6 +76,7 @@   default-extensions:     -- 6.8.1     NoImplicitPrelude+    NoMonomorphismRestriction     -- 6.10.1     NamedFieldPuns     PackageImports@@ -113,6 +115,10 @@   else     ghc-options:       -Wall+  if impl(ghc >= 8.4.1) && impl(ghc < 9.4.1)+    ghc-options:+      -- This breaks `MIN_VERSION_GLASGOW_HASKELL` on some GHCs.`+      -Wno-cpp-undef   if flag(noisy-deprecations)     cpp-options:       -DSELLOUT_NOISY_DEPRECATIONS@@ -150,3 +156,262 @@     ghc-options:       -- remove if the oldest supported version is GHC 9.14.1+       -Wno-pattern-namespace-specifier++-- NB: Currently these compilation tests can only verify that we don’t error+--     when we shouldn’t, not that we do error when we should. So,+--  1. we should make better tests that check error messages, but+--  2. we’re catching the more important case (where someone has to stop using+--     the plugin because it’s complaining about non-issues).++test-suite compilation-haskell98+  hs-source-dirs:+    tests+  type: exitcode-stdio-1.0+  default-language: Haskell98+  main-is: compilation-haskell.hs+  other-modules:+    Test.Min_6_0_1+    Test.Min_6_8_1+    Test.Min_6_10_1+    Test.Min_6_12_1+    Test.Min_7_0_1+  if impl(ghc >= 7.2.1)+    other-modules:+      Test.Min_7_2_1+  if impl(ghc >= 7.4.1)+    other-modules:+      Test.Min_7_4_1+  if impl(ghc >= 7.4.1)+    other-modules:+      Test.Min_7_4_1+  if impl(ghc >= 7.6.1)+    other-modules:+      Test.Min_7_6_1+  if impl(ghc >= 7.8.1)+    other-modules:+      Test.Min_7_8_1+  if impl(ghc >= 7.10.1)+    other-modules:+      Test.Min_7_10_1+  if impl(ghc >= 8.0.1)+    other-modules:+      Test.Min_8_0_1+  if impl(ghc >= 8.2.1)+    other-modules:+      Test.Min_8_2_1+  if impl(ghc >= 8.4.1)+    other-modules:+      Test.Min_8_4_1+  if impl(ghc >= 8.6.1)+    other-modules:+      Test.Min_8_6_1+  if impl(ghc >= 8.8.1)+    other-modules:+      Test.Min_8_8_1+  if impl(ghc >= 8.10.1)+    other-modules:+      Test.Min_8_10_1+  if impl(ghc >= 9.0.1)+    other-modules:+      Test.Min_9_0_1+  if impl(ghc >= 9.2.1)+    other-modules:+      Test.Min_9_2_1+      Test.SupportGHC2021+  if impl(ghc >= 9.2.4)+    other-modules:+      Test.Min_9_2_4+  if impl(ghc >= 9.6.1)+    other-modules:+      Test.Min_9_6_1+  if impl(ghc >= 9.8.1)+    other-modules:+      Test.Min_9_8_1+  if impl(ghc >= 9.10.1)+    other-modules:+      Test.Min_9_10_1+      Test.SupportGHC2024+  if impl(ghc >= 9.12.1)+    other-modules:+      Test.Min_9_12_1+  if impl(ghc >= 9.14.1)+    other-modules:+      Test.Min_9_14_1+  build-depends:+    base >=4.8.0 && <4.23,+    ghc-compat-plugin+  ghc-options:+    -fno-warn-deprecated-flags+    -fplugin GhcCompat+    -- NB: Each test module sets `GhcCompat:minVersion` internally.+    -fplugin-opt GhcCompat:minVersion=6.8.1+    -fplugin-opt GhcCompat:reportIncompatibleExtensions=error+  if impl(ghc >= 8.6.1)+    ghc-options:+      -Wno-star-is-type++test-suite compilation-haskell2010+  hs-source-dirs:+    tests+  type: exitcode-stdio-1.0+  default-language: Haskell2010+  main-is: compilation-haskell.hs+  other-modules:+    Test.Min_6_0_1+    Test.Min_6_8_1+    Test.Min_6_10_1+    Test.Min_6_12_1+    Test.Min_7_0_1+  if impl(ghc >= 7.2.1)+    other-modules:+      Test.Min_7_2_1+  if impl(ghc >= 7.4.1)+    other-modules:+      Test.Min_7_4_1+  if impl(ghc >= 7.4.1)+    other-modules:+      Test.Min_7_4_1+  if impl(ghc >= 7.6.1)+    other-modules:+      Test.Min_7_6_1+  if impl(ghc >= 7.8.1)+    other-modules:+      Test.Min_7_8_1+  if impl(ghc >= 7.10.1)+    other-modules:+      Test.Min_7_10_1+  if impl(ghc >= 8.0.1)+    other-modules:+      Test.Min_8_0_1+  if impl(ghc >= 8.2.1)+    other-modules:+      Test.Min_8_2_1+  if impl(ghc >= 8.4.1)+    other-modules:+      Test.Min_8_4_1+  if impl(ghc >= 8.6.1)+    other-modules:+      Test.Min_8_6_1+  if impl(ghc >= 8.8.1)+    other-modules:+      Test.Min_8_8_1+  if impl(ghc >= 8.10.1)+    other-modules:+      Test.Min_8_10_1+  if impl(ghc >= 9.0.1)+    other-modules:+      Test.Min_9_0_1+  if impl(ghc >= 9.2.1)+    other-modules:+      Test.Min_9_2_1+      Test.SupportGHC2021+  if impl(ghc >= 9.2.4)+    other-modules:+      Test.Min_9_2_4+  if impl(ghc >= 9.6.1)+    other-modules:+      Test.Min_9_6_1+  if impl(ghc >= 9.8.1)+    other-modules:+      Test.Min_9_8_1+  if impl(ghc >= 9.10.1)+    other-modules:+      Test.Min_9_10_1+      Test.SupportGHC2024+  if impl(ghc >= 9.12.1)+    other-modules:+      Test.Min_9_12_1+  if impl(ghc >= 9.14.1)+    other-modules:+      Test.Min_9_14_1+  build-depends:+    base >=4.8.0 && <4.23,+    ghc-compat-plugin+  ghc-options:+    -fno-warn-deprecated-flags+    -fplugin GhcCompat+    -- NB: Each test module sets `GhcCompat:minVersion` internally.+    -fplugin-opt GhcCompat:minVersion=6.8.1+    -fplugin-opt GhcCompat:reportIncompatibleExtensions=error+  if impl(ghc >= 8.6.1)+    ghc-options:+      -Wno-star-is-type++test-suite compilation-ghc2021+  hs-source-dirs:+    tests+  if impl(ghc >= 9.2.1)+    type: exitcode-stdio-1.0+    default-language: GHC2021+    main-is: compilation-ghc2021.hs+    other-modules:+      Test.Min_9_2_1+      Test.SupportGHC2021+    if impl(ghc >= 9.2.4)+      other-modules:+        Test.Min_9_2_4+    if impl(ghc >= 9.6.1)+      other-modules:+        Test.Min_9_6_1+    if impl(ghc >= 9.8.1)+      other-modules:+        Test.Min_9_8_1+    if impl(ghc >= 9.10.1)+      other-modules:+        Test.Min_9_10_1+        Test.SupportGHC2024+    if impl(ghc >= 9.12.1)+      other-modules:+        Test.Min_9_12_1+    if impl(ghc >= 9.14.1)+      other-modules:+        Test.Min_9_14_1+  else+    type: exitcode-stdio-1.0+    default-language: Haskell98+    main-is: skip.hs+  build-depends:+    base >=4.8.0 && <4.23,+    ghc-compat-plugin+  ghc-options:+    -fno-warn-deprecated-flags+    -fplugin GhcCompat+    -- NB: Each test module sets `GhcCompat:minVersion` internally.+    -fplugin-opt GhcCompat:minVersion=9.2.1+    -fplugin-opt GhcCompat:reportIncompatibleExtensions=error+  if impl(ghc >= 8.6.1)+    ghc-options:+      -Wno-star-is-type++test-suite compilation-ghc2024+  hs-source-dirs:+    tests+  if impl(ghc >= 9.10.1)+    type: exitcode-stdio-1.0+    default-language: GHC2024+    main-is: compilation-ghc2024.hs+    other-modules:+      Test.Min_9_10_1+      Test.SupportGHC2024+    if impl(ghc >= 9.12.1)+      other-modules:+        Test.Min_9_12_1+    if impl(ghc >= 9.14.1)+      other-modules:+        Test.Min_9_14_1+  else+    type: exitcode-stdio-1.0+    default-language: Haskell98+    main-is: skip.hs+  build-depends:+    base >=4.8.0 && <4.23,+    ghc-compat-plugin+  ghc-options:+    -fno-warn-deprecated-flags+    -fplugin GhcCompat+    -- NB: Each test module sets `GhcCompat:minVersion` internally.+    -fplugin-opt GhcCompat:minVersion=9.10.1+    -fplugin-opt GhcCompat:reportIncompatibleExtensions=error+  if impl(ghc >= 8.6.1)+    ghc-options:+      -Wno-star-is-type

@@ -21,28 +21,38 @@  import safe "base" Control.Applicative (pure) import safe "base" Control.Category ((.))-import safe "base" Control.Monad ((=<<))+import safe "base" Control.Monad ((<=<), (=<<)) import safe "base" Data.Bifunctor (first)+import safe "base" Data.Bool (Bool, not, (&&))+import safe qualified "base" Data.Bool as Bool import safe "base" Data.Char (isUpper, toLower) import safe "base" Data.Either (either) import safe qualified "base" Data.Foldable as Foldable import safe "base" Data.Function (flip, ($)) import safe "base" Data.Functor (fmap, (<$>)) import safe qualified "base" Data.List as List-import safe "base" Data.Maybe (maybe)+import safe "base" Data.Maybe (Maybe (Nothing))+import safe qualified "base" Data.Maybe as Maybe import safe "base" Data.Monoid (mconcat, (<>)) import safe "base" Data.Ord ((<)) import safe "base" Data.String (String)-import safe "base" Data.Tuple (uncurry)+import safe "base" Data.Tuple (fst, snd, uncurry) import safe "base" Data.Version (Version, showVersion) import safe "base" System.Exit (die) import safe "base" System.IO (IO, putStr) import safe "base" Text.Show (show) import safe "this" GhcCompat.GhcRelease (GhcRelease) import safe qualified "this" GhcCompat.GhcRelease as GhcRelease-import safe "this" GhcCompat.Opts (Opts (Opts), ReportLevel (Error, Warn))+import safe "this" GhcCompat.Opts+  ( Opts (Opts),+    ReportLevel (Error, Warn),+    correctOptionOrder,+  ) import safe qualified "this" GhcCompat.Opts as Opts-#if MIN_VERSION_ghc(9, 0, 0)+#if MIN_VERSION_ghc(8, 2, 1)+import safe "base" Data.Eq ((==))+#endif+#if MIN_VERSION_ghc(9, 0, 1) import "ghc" GHC.Plugins (Plugin, defaultPlugin) import qualified "ghc" GHC.Plugins as Plugins #else@@ -59,20 +69,20 @@ #if MIN_VERSION_ghc(9, 2, 1)     { Plugins.driverPlugin = \optStrs env ->         fmap (\dflags -> env {Plugins.hsc_dflags = dflags})-          . dflagsPlugin optStrs+          . dflagsPlugin (correctOptionOrder optStrs)           $ Plugins.hsc_dflags env,       Plugins.pluginRecompile = Plugins.flagRecompile     } #elif MIN_VERSION_ghc(8, 10, 1)-    { Plugins.dynflagsPlugin = dflagsPlugin,+    { Plugins.dynflagsPlugin = dflagsPlugin . correctOptionOrder,       Plugins.pluginRecompile = Plugins.flagRecompile     } #elif MIN_VERSION_ghc(8, 6, 1)-    { Plugins.installCoreToDos = install,+    { Plugins.installCoreToDos = install . correctOptionOrder,       Plugins.pluginRecompile = Plugins.purePlugin     } #else-    { Plugins.installCoreToDos = install+    { Plugins.installCoreToDos = install . correctOptionOrder     } #endif @@ -82,6 +92,7 @@ dflagsPlugin optStrs dflags = do   opts <-     either (die . (errorPrelude optStrs "error" <>)) pure $ Opts.parse optStrs+  warnLanguage optStrs opts dflags   warnFlags optStrs opts dflags   warnExts optStrs opts dflags   pure $ updateFlags (Opts.minVersion opts) dflags@@ -100,6 +111,7 @@     Plugins.liftIO . either (die . (errorPrelude optStrs "error" <>)) pure $       Opts.parse optStrs   dflags <- Plugins.getDynFlags+  Plugins.liftIO $ warnLanguage optStrs opts dflags   Plugins.liftIO $ warnFlags optStrs opts dflags   Plugins.liftIO $ warnExts optStrs opts dflags   pure todos@@ -116,6 +128,33 @@       ((< GhcRelease.version GhcRelease.ghc_8_10_1) . GhcRelease.version)       GhcRelease.all +identifyProblematicLanguage ::+  Version -> Plugins.DynFlags -> Maybe (Maybe Plugins.Language)+identifyProblematicLanguage minVersion dflags =+  Maybe.maybe+    ( if minVersion < GhcRelease.version GhcRelease.ghc_9_2_1+        then pure Nothing+        else Nothing+    )+    (fmap pure . check)+    $ Plugins.language dflags+  where+    check lang = case lang of+      Plugins.Haskell98 -> Nothing+      Plugins.Haskell2010 -> Nothing+#if MIN_VERSION_ghc(9, 2, 1)+      Plugins.GHC2021 ->+        if minVersion < GhcRelease.version GhcRelease.ghc_9_2_1+        then pure lang+        else Nothing+#endif+#if MIN_VERSION_ghc(9, 10, 1)+      Plugins.GHC2024 ->+        if minVersion < GhcRelease.version GhcRelease.ghc_9_10_1+        then pure lang+        else Nothing+#endif+ -- | Try to print a flag the way it looks to a user. -- --  __FIXME__: `show` on flags doesn’t display them nicely, but I don’t see@@ -130,7 +169,7 @@   where     splitWords :: [String] -> String -> [String]     splitWords acc =-      maybe+      Maybe.maybe         acc         ( \(h, t) ->             uncurry splitWords . first ((acc <>) . pure . (toLower h :)) $@@ -138,13 +177,39 @@         )         . List.uncons +warnLanguage :: [Plugins.CommandLineOption] -> Opts -> Plugins.DynFlags -> IO ()+warnLanguage optStrs opts dflags =+  let minVer = Opts.minVersion opts+   in Maybe.maybe+        (pure ())+        ( \level ->+            Maybe.maybe+              (pure ())+              ( ( case level of+                    Opts.Warn -> putStr . (errorPrelude optStrs "warning" <>)+                    Opts.Error -> die . (errorPrelude optStrs "error" <>)+                )+                  . Maybe.maybe+                    "You are using an implicit language edition, which will be GHC2021 from GHC\n    9.2.1, but empty before that. You should explicitly set it to Haskell2010."+                    ( \lang ->+                        "You are using the "+                          <> showLanguage lang+                          <> " language edition, which is not available in ‘minVersion’ ("+                          <> showVersion minVer+                          <> ").\n"+                    )+              )+              $ identifyProblematicLanguage minVer dflags+        )+        $ Opts.reportIncompatibleExtensions opts+ warnFlags :: [Plugins.CommandLineOption] -> Opts -> Plugins.DynFlags -> IO () warnFlags optStrs opts dflags =   let minVer = Opts.minVersion opts-   in maybe+   in Maybe.maybe         (pure ())         ( \level ->-            maybe+            Maybe.maybe               (pure ())               ( ( case level of                     Opts.Warn -> putStr . (errorPrelude optStrs "warning" <>)@@ -168,10 +233,10 @@ warnExts :: [Plugins.CommandLineOption] -> Opts -> Plugins.DynFlags -> IO () warnExts optStrs opts dflags =   let minVer = Opts.minVersion opts-   in maybe+   in Maybe.maybe         (pure ())         ( \level ->-            maybe+            Maybe.maybe               (pure ())               ( ( case level of                     Opts.Warn -> putStr . (errorPrelude optStrs "warning" <>)@@ -226,19 +291,54 @@ usedIncompatibleExtensions ::   Version -> Plugins.DynFlags -> [GhcRelease.Extension] #if MIN_VERSION_ghc(9, 6, 1)-usedIncompatibleExtensions minVersion =-  List.intersect (incompatibleExtensions minVersion)+usedIncompatibleExtensions minVersion dflags =+  List.intersect+    ( List.filter+        ( \e ->+            not (allowedImpliedByExtension dflags e)+              && not (allowedLanguageEditionExtension dflags e)+        )+        $ incompatibleExtensions minVersion+    )     . fmap removeSwitch-    . Plugins.extensions+    $ Plugins.extensions dflags   where     removeSwitch onOff = case onOff of       Plugins.Off a -> a       Plugins.On a -> a #else usedIncompatibleExtensions minVersion dflags =-  List.filter (`Plugins.xopt` dflags) $ incompatibleExtensions minVersion+  List.filter+    ( \e ->+        e `Plugins.xopt` dflags+          && not (allowedImpliedByExtension dflags e)+          && not (allowedLanguageEditionExtension dflags e)+    )+    $ incompatibleExtensions minVersion #endif +languageEdition :: Plugins.DynFlags -> Maybe Plugins.Language+languageEdition = Maybe.maybe def pure . Plugins.language+#if MIN_VERSION_ghc(9, 2, 1)+  where def = pure Plugins.GHC2021+#else+  where def = Maybe.Nothing+#endif++allowedLanguageEditionExtension ::+  Plugins.DynFlags -> GhcRelease.Extension -> Bool+allowedLanguageEditionExtension dflags ext =+  Maybe.maybe+    Bool.False+    (\lang -> ext `List.elem` languageEditionExtensions lang)+    $ languageEdition dflags++allowedImpliedByExtension :: Plugins.DynFlags -> GhcRelease.Extension -> Bool+allowedImpliedByExtension dflags ext =+  -- NB: In this case we /always/ want `Plugins.xopt`, because the implication+  --     only occurs when the extension is enabled.+  Foldable.any (`Plugins.xopt` dflags) $ impliedByExtensions ext+ -- | A list of /all/ extensions that are incompatible with the provided version. incompatibleExtensions :: Version -> [GhcRelease.Extension] incompatibleExtensions minVersion =@@ -265,3 +365,51 @@ disableIfOlder ::   [(Version, [Plugins.WarningFlag])] -> Version -> [Plugins.WarningFlag] disableIfOlder = flip $ Foldable.concatMap . uncurry . whenOlder++-- | GHC before 8.2 doesn’t define `Eq` for `Plugins.Language`, so this does it.+eqLanguage :: Plugins.Language -> Plugins.Language -> Bool+#if MIN_VERSION_ghc(8, 2, 1)+eqLanguage = (==)+#else+eqLanguage x y = case (x, y) of+  (Plugins.Haskell98, Plugins.Haskell98) -> Bool.True+  (Plugins.Haskell2010, Plugins.Haskell2010) -> Bool.True+  (_, _) -> Bool.False+#endif++-- | GHC before 8.2 doesn’t define `Show` for `Plugins.Language`, so this does+--   it.+showLanguage :: Plugins.Language -> String+#if MIN_VERSION_ghc(8, 2, 1)+showLanguage = show+#else+showLanguage x = case x of+  Plugins.Haskell98 -> "Haskell98"+  Plugins.Haskell2010 -> "Haskell2010"+#endif++-- | A language edition may fool us by setting an extension (even negatively) on+--   a newer GHC that it wouldn’t (need to) set on an older one. This whitelists+--   those extensions.+--+--  __TODO__: It would still be good to give an info message in this case,+--            because we can’t know if the extension was implicit from the+--            language edition or explicit.+--          - Actually, we /can/ know if the `OnOff` is the opposite of the one+--            the edition sets.+languageEditionExtensions :: Plugins.Language -> [GhcRelease.Extension]+languageEditionExtensions language =+  snd <=< List.filter (eqLanguage language . fst) $+    Foldable.foldMap GhcRelease.newEditions GhcRelease.all++-- | Sometimes an extension from a later release may be implied by an extension+--   from an earlier relase. This can fool use, because the implied extension+--   will be included in the enabled extensions, so we need to whitelist those+--   /when/ an extension that implies it is enabled.+--+--  __TODO__: Like with `languageEditionExtensions`, we should be smart enough+--            to recognize that we should still warn about @NoFoo@, even if+--            @Foo@ was implied by a supported extension (ad reverse if @NoFoo@+--            is the implied form).+impliedByExtensions :: GhcRelease.Extension -> [GhcRelease.Extension]+impliedByExtensions = Foldable.foldMap GhcRelease.newImplications GhcRelease.all

@@ -14,7 +14,9 @@   ( Extension,     GhcRelease,     all,+    newEditions,     newExtensions,+    newImplications,     newWarnings,     version, @@ -46,20 +48,21 @@   ) where +import safe "base" Control.Applicative (pure) import safe "base" Data.Int (Int) import safe "base" Data.Version (Version, makeVersion)-#if MIN_VERSION_ghc(8, 0, 0)+#if MIN_VERSION_ghc(8, 0, 1) import safe qualified "ghc-boot-th" GHC.LanguageExtensions.Type as Extension #else import qualified "ghc" GhcPlugins as Extension #endif-#if MIN_VERSION_ghc(9, 0, 0)+#if MIN_VERSION_ghc(9, 0, 1) import qualified "ghc" GHC.Plugins as Plugins #else import qualified "ghc" GhcPlugins as Plugins #endif -#if MIN_VERSION_ghc(8, 0, 0)+#if MIN_VERSION_ghc(8, 0, 1) type Extension = Extension.Extension #else type Extension = Plugins.ExtensionFlag@@ -71,7 +74,12 @@  data GhcRelease = GhcRelease   { version :: Version,+    -- | The same `Plugins.Language` can have an entry in multiple+    --   `GhcRelease`s, it just includes the new `Extension`s that were added in+    --   that release.+    newEditions :: [(Plugins.Language, [Extension])],     newExtensions :: [Extension],+    newImplications :: Extension -> [Extension],     newWarnings :: [(GhcRelease, [Plugins.WarningFlag])]   } @@ -79,7 +87,9 @@ ghcRelease versionComponents =   GhcRelease     { version = makeVersion versionComponents,+      newEditions = [],       newExtensions = [],+      newImplications = pure [],       newWarnings = []     } @@ -87,14 +97,10 @@ ghc_6_0_1 =   (ghcRelease [6, 0, 1]) #if MIN_VERSION_GLASGOW_HASKELL(8, 0, 1, 0)-    { newExtensions =-        [Extension.TemplateHaskell],-      newWarnings = []+    { newExtensions = [Extension.TemplateHaskell]     } #else-    { newExtensions =-        [Extension.Opt_TemplateHaskell],-      newWarnings = []+    { newExtensions = [Extension.Opt_TemplateHaskell]     } #endif @@ -102,7 +108,23 @@ ghc_6_8_1 =   (ghcRelease [6, 8, 1]) #if MIN_VERSION_GLASGOW_HASKELL(8, 0, 1, 0)-    { newExtensions =+    { newEditions =+        [ ( Plugins.Haskell98,+            [ Extension.ImplicitPrelude,+              Extension.MonomorphismRestriction+            ]+          ),+          ( Plugins.Haskell2010,+            [ Extension.EmptyDataDecls,+              Extension.ForeignFunctionInterface,+              Extension.ImplicitPrelude,+              Extension.MonomorphismRestriction,+              Extension.PatternGuards+              -- Extension.RelaxedPolyRec – when does this one show up?+            ]+          )+        ],+      newExtensions =         [ Extension.Arrows,           Extension.BangPatterns,           Extension.ConstrainedClassMethods,@@ -144,11 +166,25 @@           Extension.UndecidableInstances,           Extension.UnicodeSyntax,           Extension.UnliftedFFITypes-        ],-      newWarnings = []+        ]     } #else-    { newExtensions =+    { newEditions =+        [ ( Plugins.Haskell98,+            [ Extension.Opt_ImplicitPrelude,+              Extension.Opt_MonomorphismRestriction+            ]+          ),+          ( Plugins.Haskell2010,+            [ Extension.Opt_ImplicitPrelude,+              Extension.Opt_MonomorphismRestriction,+              Extension.Opt_EmptyDataDecls,+              Extension.Opt_ForeignFunctionInterface,+              Extension.Opt_PatternGuards+            ]+          )+        ],+      newExtensions =         [ Extension.Opt_Arrows,           Extension.Opt_BangPatterns,           Extension.Opt_ConstrainedClassMethods,@@ -190,8 +226,7 @@           Extension.Opt_UndecidableInstances,           Extension.Opt_UnicodeSyntax,           Extension.Opt_UnliftedFFITypes-        ],-      newWarnings = []+        ]     } #endif @@ -211,8 +246,7 @@ #else           Extension.RecordPuns #endif-        ],-      newWarnings = []+        ]     } #else     { newExtensions =@@ -221,8 +255,7 @@           Extension.Opt_RecordPuns,           Extension.Opt_TransformListComp,           Extension.Opt_ViewPatterns-        ],-      newWarnings = []+        ]     } #endif @@ -230,24 +263,48 @@ ghc_6_12_1 =   (ghcRelease [6, 12, 1]) #if MIN_VERSION_GLASGOW_HASKELL(8, 0, 1, 0)-    { newExtensions =+    { newEditions = [(Plugins.Haskell98, [Extension.NPlusKPatterns])],+      newExtensions =         [ Extension.ExplicitForAll,           Extension.GHCForeignImportPrim,           Extension.MonoLocalBinds,           Extension.NPlusKPatterns,           Extension.TupleSections         ],-      newWarnings = []+      newImplications = \ext -> case ext of+        Extension.ExplicitForAll ->+          [ Extension.ScopedTypeVariables,+            Extension.LiberalTypeSynonyms,+            Extension.RankNTypes,+            Extension.ExistentialQuantification+          ]+        Extension.MonoLocalBinds ->+          [ Extension.TypeFamilies,+            Extension.GADTs+          ]+        _ -> []     } #else-    { newExtensions =+    { newEditions = [(Plugins.Haskell98, [Extension.Opt_NPlusKPatterns])],+      newExtensions =         [ Extension.Opt_ExplicitForAll,           Extension.Opt_GHCForeignImportPrim,           Extension.Opt_MonoLocalBinds,           Extension.Opt_NPlusKPatterns,           Extension.Opt_TupleSections         ],-      newWarnings = []+      newImplications = \ext -> case ext of+        Extension.Opt_ExplicitForAll ->+          [ Extension.Opt_ScopedTypeVariables,+            Extension.Opt_LiberalTypeSynonyms,+            Extension.Opt_RankNTypes,+            Extension.Opt_ExistentialQuantification+          ]+        Extension.Opt_MonoLocalBinds ->+          [ Extension.Opt_TypeFamilies,+            Extension.Opt_GADTs+          ]+        _ -> []     } #endif @@ -255,20 +312,34 @@ ghc_7_0_1 =   (ghcRelease [7, 0, 1]) #if MIN_VERSION_GLASGOW_HASKELL(8, 0, 1, 0)-    { newExtensions =+    { newEditions =+        [ (Plugins.Haskell98, [Extension.DatatypeContexts]),+          ( Plugins.Haskell2010,+            [ Extension.DatatypeContexts,+              Extension.DoAndIfThenElse+            ]+          )+        ],+      newExtensions =         [ Extension.DatatypeContexts,           Extension.DoAndIfThenElse,           Extension.RebindableSyntax-        ],-      newWarnings = []+        ]     } #else-    { newExtensions =+    { newEditions =+        [ (Plugins.Haskell98, [Extension.Opt_DatatypeContexts]),+          ( Plugins.Haskell2010,+            [ Extension.Opt_DatatypeContexts,+              Extension.Opt_DoAndIfThenElse+            ]+          )+        ],+      newExtensions =         [ Extension.Opt_DatatypeContexts,           Extension.Opt_DoAndIfThenElse,           Extension.Opt_RebindableSyntax-        ],-      newWarnings = []+        ]     } #endif @@ -276,7 +347,8 @@ ghc_7_2_1 =   (ghcRelease [7, 2, 1]) #if MIN_VERSION_GLASGOW_HASKELL(8, 0, 1, 0)-    { newExtensions =+    { newEditions = [(Plugins.Haskell98, [Extension.NondecreasingIndentation])],+      newExtensions =         [ Extension.DefaultSignatures,           Extension.DeriveGeneric,           Extension.GADTSyntax,@@ -284,10 +356,14 @@           Extension.MonadComprehensions,           Extension.NondecreasingIndentation         ],-      newWarnings = []+      newImplications = \ext -> case ext of+        Extension.GADTSyntax -> [Extension.GADTs]+        _ -> []     } #else-    { newExtensions =+    { newEditions =+        [(Plugins.Haskell98, [Extension.Opt_NondecreasingIndentation])],+      newExtensions =         [ Extension.Opt_DefaultSignatures,           Extension.Opt_DeriveGeneric,           Extension.Opt_GADTSyntax,@@ -295,7 +371,9 @@           Extension.Opt_MonadComprehensions,           Extension.Opt_NondecreasingIndentation         ],-      newWarnings = []+      newImplications = \ext -> case ext of+        Extension.Opt_GADTSyntax -> [Extension.Opt_GADTs]+        _ -> []     } #endif @@ -303,22 +381,28 @@ ghc_7_4_1 =   (ghcRelease [7, 4, 1]) #if MIN_VERSION_GLASGOW_HASKELL(8, 0, 1, 0)-    { newExtensions =+    { newEditions =+        [ (Plugins.Haskell98, [Extension.TraditionalRecordSyntax]),+          (Plugins.Haskell2010, [Extension.TraditionalRecordSyntax])+        ],+      newExtensions =         [ Extension.ConstraintKinds,           Extension.DataKinds,           Extension.PolyKinds,           Extension.TraditionalRecordSyntax-        ],-      newWarnings = []+        ]     } #else-    { newExtensions =+    { newEditions =+        [ (Plugins.Haskell98, [Extension.Opt_TraditionalRecordSyntax]),+          (Plugins.Haskell2010, [Extension.Opt_TraditionalRecordSyntax])+        ],+      newExtensions =         [ Extension.Opt_ConstraintKinds,           Extension.Opt_DataKinds,           Extension.Opt_PolyKinds,           Extension.Opt_TraditionalRecordSyntax-        ],-      newWarnings = []+        ]     } #endif @@ -333,7 +417,12 @@           Extension.LambdaCase,           Extension.MultiWayIf         ],-      newWarnings = []+      newImplications = \ext -> case ext of+        Extension.ExplicitNamespaces ->+          [ Extension.TypeOperators,+            Extension.TypeFamilies+          ]+        _ -> []     } #else     { newExtensions =@@ -343,7 +432,12 @@           Extension.Opt_LambdaCase,           Extension.Opt_MultiWayIf         ],-      newWarnings = []+      newImplications = \ext -> case ext of+        Extension.Opt_ExplicitNamespaces ->+          [ Extension.Opt_TypeOperators,+            Extension.Opt_TypeFamilies+          ]+        _ -> []     } #endif @@ -361,8 +455,7 @@           Extension.OverloadedLists,           Extension.PatternSynonyms,           Extension.RoleAnnotations-        ],-      newWarnings = []+        ]     } #else     { newExtensions =@@ -375,8 +468,7 @@           Extension.Opt_OverloadedLists,           Extension.Opt_PatternSynonyms,           Extension.Opt_RoleAnnotations-        ],-      newWarnings = []+        ]     } #endif @@ -439,7 +531,9 @@           Extension.TypeInType,           Extension.UndecidableSuperClasses         ],-      newWarnings = []+      newImplications = \ext -> case ext of+        Extension.TemplateHaskellQuotes -> [Extension.TemplateHaskell]+        _ -> []     } #endif @@ -451,31 +545,32 @@         [ Extension.DerivingStrategies,           Extension.UnboxedSums         ],-      newWarnings = []+      newImplications = \ext -> case ext of+        Extension.UnboxedSums -> [Extension.UnboxedTuples]+        _ -> []     } #endif  ghc_8_4_1 :: GhcRelease ghc_8_4_1 =   (ghcRelease [8, 4, 1])---- Some versions of GHC error if the third field isn’t 0.-#if MIN_VERSION_GLASGOW_HASKELL(8, 4, 0, 0)+#if MIN_VERSION_GLASGOW_HASKELL(8, 4, 1, 0)     { newExtensions =         [ Extension.EmptyDataDeriving,           Extension.HexFloatLiterals-        ],-      newWarnings = []+        ]     } #endif  ghc_8_6_1 :: GhcRelease ghc_8_6_1 =   (ghcRelease [8, 6, 1])---- Some versions of GHC error if the third field isn’t 0.-#if MIN_VERSION_GLASGOW_HASKELL(8, 6, 0, 0)-    { newExtensions =+#if MIN_VERSION_GLASGOW_HASKELL(8, 6, 1, 0)+    { newEditions =+        [ (Plugins.Haskell98, [Extension.StarIsType]),+          (Plugins.Haskell2010, [Extension.StarIsType])+        ],+      newExtensions =         [ Extension.BlockArguments,           Extension.DerivingVia,           Extension.NumericUnderscores,@@ -489,21 +584,20 @@ ghc_8_8_1 :: GhcRelease ghc_8_8_1 =   (ghcRelease [8, 8, 1])---- Some versions of GHC error if the third field isn’t 0.-#if MIN_VERSION_GLASGOW_HASKELL(8, 8, 0, 0)-    { newExtensions = [],-      newWarnings = [(ghc_8_2_1, [Plugins.Opt_WarnMissingDerivingStrategies])]+#if MIN_VERSION_GLASGOW_HASKELL(8, 8, 1, 0)+    { newWarnings = [(ghc_8_2_1, [Plugins.Opt_WarnMissingDerivingStrategies])]     } #endif  ghc_8_10_1 :: GhcRelease ghc_8_10_1 =   (ghcRelease [8, 10, 1])---- Some versions of GHC error if the third field isn’t 0.-#if MIN_VERSION_GLASGOW_HASKELL(8, 10, 0, 0)-    { newExtensions =+#if MIN_VERSION_GLASGOW_HASKELL(8, 10, 1, 0)+    { newEditions =+        [ (Plugins.Haskell98, [Extension.CUSKs]),+          (Plugins.Haskell2010, [Extension.CUSKs])+        ],+      newExtensions =         [ Extension.CUSKs,           Extension.ImportQualifiedPost,           Extension.StandaloneKindSignatures,@@ -516,25 +610,78 @@ ghc_9_0_1 :: GhcRelease ghc_9_0_1 =   (ghcRelease [9, 0, 1])---- Some versions of GHC error if the third field isn’t 0.-#if MIN_VERSION_GLASGOW_HASKELL(9, 0, 0, 0)+#if MIN_VERSION_GLASGOW_HASKELL(9, 0, 1, 0)     { newExtensions =         [ Extension.LexicalNegation,           Extension.LinearTypes,           Extension.QualifiedDo-        ],-      newWarnings = []+        ]     } #endif  ghc_9_2_1 :: GhcRelease ghc_9_2_1 =   (ghcRelease [9, 2, 1])---- Some versions of GHC error if the third field isn’t 0.-#if MIN_VERSION_GLASGOW_HASKELL(9, 2, 0, 0)-    { newExtensions =+#if MIN_VERSION_GLASGOW_HASKELL(9, 2, 1, 0)+    { newEditions =+        [ (Plugins.Haskell98, [Extension.FieldSelectors]),+          (Plugins.Haskell2010, [Extension.FieldSelectors]),+          ( Plugins.GHC2021,+            [ Extension.BangPatterns,+              Extension.BinaryLiterals,+              Extension.ConstrainedClassMethods,+              Extension.ConstraintKinds,+              Extension.DeriveDataTypeable,+              Extension.DeriveFoldable,+              Extension.DeriveFunctor,+              Extension.DeriveGeneric,+              Extension.DeriveLift,+              Extension.DeriveTraversable,+              Extension.DoAndIfThenElse,+              Extension.EmptyCase,+              Extension.EmptyDataDecls,+              Extension.EmptyDataDeriving,+              Extension.ExistentialQuantification,+              Extension.ExplicitForAll,+              Extension.ExplicitNamespaces, -- negative+              Extension.FieldSelectors,+              Extension.FlexibleContexts,+              Extension.FlexibleInstances,+              Extension.ForeignFunctionInterface,+              Extension.GADTSyntax,+              Extension.GeneralizedNewtypeDeriving,+              Extension.HexFloatLiterals,+              Extension.ImplicitPrelude,+              Extension.ImportQualifiedPost,+              Extension.InstanceSigs,+              Extension.KindSignatures,+              Extension.MonomorphismRestriction,+              Extension.MultiParamTypeClasses,+#if MIN_VERSION_GLASGOW_HASKELL(9, 4, 1, 0)+              Extension.NamedFieldPuns,+#else+              Extension.RecordPuns,+#endif+              Extension.NamedWildCards,+              Extension.NumericUnderscores,+              Extension.PatternGuards,+              Extension.PolyKinds,+              Extension.PostfixOperators,+              Extension.RankNTypes,+              Extension.RelaxedPolyRec,+              Extension.ScopedTypeVariables,+              Extension.StandaloneDeriving,+              Extension.StandaloneKindSignatures,+              Extension.StarIsType,+              Extension.TraditionalRecordSyntax,+              Extension.TupleSections,+              Extension.TypeApplications,+              Extension.TypeOperators,+              Extension.TypeSynonymInstances+            ]+          )+        ],+      newExtensions =         [ Extension.FieldSelectors,           -- added in GHC 6.10, but unreliable before 9.2           Extension.ImpredicativeTypes,@@ -550,8 +697,11 @@ ghc_9_2_4 =   (ghcRelease [9, 2, 4]) #if MIN_VERSION_GLASGOW_HASKELL(9, 2, 4, 0)-    { newExtensions = [Extension.DeepSubsumption],-      newWarnings = []+    { newEditions =+        [ (Plugins.Haskell98, [Extension.DeepSubsumption]),+          (Plugins.Haskell2010, [Extension.DeepSubsumption])+        ],+      newExtensions = [Extension.DeepSubsumption]     } #endif @@ -559,8 +709,7 @@ ghc_9_6_1 =   (ghcRelease [9, 6, 1]) #if MIN_VERSION_GLASGOW_HASKELL(9, 6, 1, 0)-    { newExtensions = [Extension.TypeData],-      newWarnings = []+    { newExtensions = [Extension.TypeData]     } #endif @@ -583,12 +732,69 @@ ghc_9_10_1 =   (ghcRelease [9, 10, 1]) #if MIN_VERSION_GLASGOW_HASKELL(9, 10, 1, 0)-    {+    { newEditions =+        [ ( Plugins.GHC2024,+            [ Extension.BangPatterns,+              Extension.BinaryLiterals,+              Extension.ConstrainedClassMethods,+              Extension.ConstraintKinds,+              Extension.DataKinds,+              Extension.DeriveDataTypeable,+              Extension.DeriveFoldable,+              Extension.DeriveFunctor,+              Extension.DeriveGeneric,+              Extension.DeriveLift,+              Extension.DeriveTraversable,+              Extension.DerivingStrategies,+              Extension.DisambiguateRecordFields,+              Extension.DoAndIfThenElse,+              Extension.EmptyCase,+              Extension.EmptyDataDecls,+              Extension.EmptyDataDeriving,+              Extension.ExistentialQuantification,+              Extension.ExplicitForAll,+              Extension.ExplicitNamespaces, -- positive+              Extension.FieldSelectors,+              Extension.FlexibleContexts,+              Extension.FlexibleInstances,+              Extension.ForeignFunctionInterface,+              Extension.GADTSyntax,+              Extension.GADTs,+              Extension.GeneralizedNewtypeDeriving,+              Extension.HexFloatLiterals,+              Extension.ImplicitPrelude,+              Extension.ImportQualifiedPost,+              Extension.InstanceSigs,+              Extension.KindSignatures,+              Extension.LambdaCase,+              Extension.MonoLocalBinds,+              Extension.MonomorphismRestriction,+              Extension.MultiParamTypeClasses,+              Extension.NamedFieldPuns,+              Extension.NamedWildCards,+              Extension.NumericUnderscores,+              Extension.PatternGuards,+              Extension.PolyKinds,+              Extension.PostfixOperators,+              Extension.RankNTypes,+              Extension.RelaxedPolyRec,+              Extension.RoleAnnotations,+              Extension.ScopedTypeVariables,+              Extension.StandaloneDeriving,+              Extension.StandaloneKindSignatures,+              Extension.StarIsType,+              Extension.TraditionalRecordSyntax,+              Extension.TupleSections,+              Extension.TypeApplications,+              Extension.TypeOperators,+              Extension.TypeSynonymInstances+            ]+          )+        ],       newExtensions =         [ Extension.ListTuplePuns,           Extension.RequiredTypeArguments-        ],-      newWarnings = []+        ]     } #endif @@ -600,8 +806,7 @@         [ Extension.MultilineStrings,           Extension.NamedDefaults,           Extension.OrPatterns-        ],-      newWarnings = []+        ]     } #endif @@ -609,7 +814,13 @@ ghc_9_14_1 =   (ghcRelease [9, 14, 1]) #if MIN_VERSION_GLASGOW_HASKELL(9, 14, 1, 0)-    { newExtensions =+    { newEditions =+        [ (Plugins.Haskell98, [Extension.ImplicitStagePersistence]),+          (Plugins.Haskell2010, [Extension.ImplicitStagePersistence]),+          (Plugins.GHC2021, [Extension.ImplicitStagePersistence]),+          (Plugins.GHC2024, [Extension.ImplicitStagePersistence])+        ],+      newExtensions =         [ Extension.ExplicitLevelImports,           Extension.ImplicitStagePersistence         ],

@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-} {-# LANGUAGE Safe #-}  -- |@@ -8,6 +9,7 @@ module GhcCompat.Opts   ( Opts (Opts),     ReportLevel (Error, Warn),+    correctOptionOrder,     minVersion,     parse,     reportIncompatibleExtensions,@@ -16,6 +18,7 @@  import "base" Control.Applicative (pure) import "base" Control.Category ((.))+import "base" Control.Monad ((<=<)) import "base" Data.Bifunctor (second) import "base" Data.Either (Either (Left)) import "base" Data.Eq ((==))@@ -30,6 +33,16 @@ import "base" Data.Version (Version, parseVersion) import "base" Text.ParserCombinators.ReadP (readP_to_S) +-- | `-fplugin-opt`s are provided to the plugin in reverse order before GHC 8.6.+--   This ensures the plugin always receives then in the order they were+--   provided on the command line.+correctOptionOrder :: [String] -> [String]+#if MIN_VERSION_GLASGOW_HASKELL(8, 6, 1, 0)+correctOptionOrder x = x+#else+correctOptionOrder = reverse+#endif+ -- | This mirrors the levels provided by GHC’s warning flags. Correspondingly, --   we use the lowercase forms for the plugin opts instead of the capitalized --   ones.@@ -55,9 +68,17 @@     reportIncompatibleExtensions :: Maybe ReportLevel   } +parseVersion' :: String -> Either String Version+parseVersion' versionStr =+  maybe+    (Left $ "Couldn’t parse ‘minVersion’ value ‘" <> versionStr <> "’.")+    pure+    $ readVersion versionStr+ parseOpt :: Opts -> String -> String -> Either String Opts parseOpt opts name value = case (name, value) of-  ("minVersion", _) -> pure opts+  ("minVersion", version) ->+    (\v -> opts {minVersion = v}) <$> parseVersion' version   ("reportIncompatibleExtensions", level) ->     (\v -> opts {reportIncompatibleExtensions = v}) <$> case level of       "no" -> pure Nothing@@ -77,14 +98,10 @@   let kv = second (drop 1) . break (== '=') <$> optStrs    in maybe         (Left "Missing required ‘minVersion’ plugin-opt.")-        ( \versionStr ->-            maybe-              ( Left $-                  "Couldn’t parse ‘minVersion’ value ‘" <> versionStr <> "’."-              )-              ( \version ->-                  foldrM (flip $ uncurry . parseOpt) (defaultOpts version) kv-              )-              $ readVersion versionStr+        ( ( \version ->+              foldrM (flip $ uncurry . parseOpt) (defaultOpts version) $+                reverse kv+          )+            <=< parseVersion'         )         $ lookup "minVersion" kv

@@ -0,0 +1,21 @@+# compilation tests++These tests have an odd structure.++First, they only need to be built – they do nothing at runtime.++Then there are a number of components:++- a separate `Test.Min_<x>_<y>_<z>` for each GHC version+- a `Test.Supported<language>` for some language editions+- a `test-suite` for each `default-language`++Each `Test.Min_<x>_<y>_<z>` enables all of the language extensions and warning flags[^1] that are supported by that compiler version, as well as a `-fplugin-opt GhcCompat:minVersion=x.y.z` option.++[^1]: Well, the warning flags that this plugin currently cares about.++When the tests are built with a particular GHC, each suite will build every `Test.Min__<x>_<y>_<z>` up to and including the one tagged with the current GHC version. This ensures we check every `minVersion` value against every GHC version.++The suite-per-`default-language` adds another dimension to the matrix, since the language edition implicitly changes the set of extensions, and we need to make sure that is handled correctly.++The `Test.Supported<language>` modules are just a convenient shorthand to avoid duplicating a number of conditionals in multiple places.

@@ -0,0 +1,7 @@+{-# LANGUAGE NoTemplateHaskell #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=6.0.1 #-}++module Test.Min_6_0_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,51 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE DisambiguateRecordFields #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=6.10.1 #-}++module Test.Min_6_10_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,56 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE DisambiguateRecordFields #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=6.12.1 #-}++module Test.Min_6_12_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,46 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE DisambiguateRecordFields #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=6.8.1 #-}++module Test.Min_6_8_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,59 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DisambiguateRecordFields #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=7.0.1 #-}++module Test.Min_7_0_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,92 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DisambiguateRecordFields #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PolyKinds #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=7.10.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_7_10_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,65 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DisambiguateRecordFields #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=7.2.1 #-}++module Test.Min_7_2_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,69 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DisambiguateRecordFields #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE PolyKinds #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=7.4.1 #-}++module Test.Min_7_4_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,74 @@+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DisambiguateRecordFields #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE PolyKinds #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=7.6.1 #-}++module Test.Min_7_6_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,82 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DisambiguateRecordFields #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE PolyKinds #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=7.8.1 #-}++module Test.Min_7_8_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,103 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=8.0.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_8_0_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,119 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE BlockArguments #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE DerivingVia #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE EmptyDataDeriving #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE HexFloatLiterals #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE QuantifiedConstraints #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StarIsType #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE UnliftedNewtypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoImportQualifiedPost #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoNumericUnderscores #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStandaloneKindSignatures #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE CUSKs #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -Wmissing-deriving-strategies #-}+{-# OPTIONS_GHC -Wprepositive-qualified-module #-}+{-# OPTIONS_GHC -Wstar-is-type #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=8.10.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_8_10_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,105 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=8.2.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_8_2_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,107 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE EmptyDataDeriving #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE HexFloatLiterals #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=8.4.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_8_4_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,113 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE BlockArguments #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE DerivingVia #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE EmptyDataDeriving #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE HexFloatLiterals #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE QuantifiedConstraints #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StarIsType #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoNumericUnderscores #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -Wstar-is-type #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=8.6.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_8_6_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,114 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE BlockArguments #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE DerivingVia #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE EmptyDataDeriving #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE HexFloatLiterals #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE QuantifiedConstraints #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StarIsType #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoNumericUnderscores #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -Wmissing-deriving-strategies #-}+{-# OPTIONS_GHC -Wstar-is-type #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=8.8.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_8_8_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,122 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE BlockArguments #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE DerivingVia #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE EmptyDataDeriving #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE HexFloatLiterals #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LexicalNegation #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE LinearTypes #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE QualifiedDo #-}+{-# LANGUAGE QuantifiedConstraints #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StarIsType #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE UnliftedNewtypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoImportQualifiedPost #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoNumericUnderscores #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStandaloneKindSignatures #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE CUSKs #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -Wmissing-deriving-strategies #-}+{-# OPTIONS_GHC -Wprepositive-qualified-module #-}+{-# OPTIONS_GHC -Wstar-is-type #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=9.0.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_9_0_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,136 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE BlockArguments #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DeepSubsumption #-}+{-# LANGUAGE DerivingVia #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE EmptyDataDeriving #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE ExtendedLiterals #-}+{-# LANGUAGE FieldSelectors #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE HexFloatLiterals #-}+{-# LANGUAGE ImpredicativeTypes #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LexicalNegation #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE LinearTypes #-}+{-# LANGUAGE ListTuplePuns #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE OverloadedRecordUpdate #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE QualifiedDo #-}+{-# LANGUAGE QuantifiedConstraints #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RequiredTypeArguments #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StarIsType #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeAbstractions #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedDatatypes #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE UnliftedNewtypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDerivingStrategies #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoImportQualifiedPost #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoNumericUnderscores #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedRecordDot #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRankNTypes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStandaloneKindSignatures #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeData #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE CUSKs #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -Wmissing-deriving-strategies #-}+{-# OPTIONS_GHC -Wmissing-kind-signatures #-}+{-# OPTIONS_GHC -Wmissing-poly-kind-signatures #-}+{-# OPTIONS_GHC -Wmissing-role-annotations #-}+{-# OPTIONS_GHC -Wprepositive-qualified-module #-}+{-# OPTIONS_GHC -Wstar-is-type #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=9.10.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_9_10_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,139 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE BlockArguments #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DeepSubsumption #-}+{-# LANGUAGE DerivingVia #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE EmptyDataDeriving #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE ExtendedLiterals #-}+{-# LANGUAGE FieldSelectors #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE HexFloatLiterals #-}+{-# LANGUAGE ImpredicativeTypes #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LexicalNegation #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE LinearTypes #-}+{-# LANGUAGE ListTuplePuns #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE MultilineStrings #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedDefaults #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OrPatterns #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE OverloadedRecordUpdate #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE QualifiedDo #-}+{-# LANGUAGE QuantifiedConstraints #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RequiredTypeArguments #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StarIsType #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeAbstractions #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedDatatypes #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE UnliftedNewtypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDerivingStrategies #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoImportQualifiedPost #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoNumericUnderscores #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedRecordDot #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRankNTypes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStandaloneKindSignatures #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeData #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE CUSKs #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -Wmissing-deriving-strategies #-}+{-# OPTIONS_GHC -Wmissing-kind-signatures #-}+{-# OPTIONS_GHC -Wmissing-poly-kind-signatures #-}+{-# OPTIONS_GHC -Wmissing-role-annotations #-}+{-# OPTIONS_GHC -Wprepositive-qualified-module #-}+{-# OPTIONS_GHC -Wstar-is-type #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=9.12.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_9_12_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,142 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE BlockArguments #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DeepSubsumption #-}+{-# LANGUAGE DerivingVia #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE EmptyDataDeriving #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExplicitLevelImports #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE ExtendedLiterals #-}+{-# LANGUAGE FieldSelectors #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE HexFloatLiterals #-}+{-# LANGUAGE ImplicitStagePersistence #-}+{-# LANGUAGE ImpredicativeTypes #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LexicalNegation #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE LinearTypes #-}+{-# LANGUAGE ListTuplePuns #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE MultilineStrings #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedDefaults #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OrPatterns #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE OverloadedRecordUpdate #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE QualifiedDo #-}+{-# LANGUAGE QuantifiedConstraints #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RequiredTypeArguments #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StarIsType #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeAbstractions #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedDatatypes #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE UnliftedNewtypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDerivingStrategies #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoImportQualifiedPost #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoNumericUnderscores #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedRecordDot #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRankNTypes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStandaloneKindSignatures #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeData #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE CUSKs #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -Wmissing-deriving-strategies #-}+{-# OPTIONS_GHC -Wmissing-kind-signatures #-}+{-# OPTIONS_GHC -Wmissing-poly-kind-signatures #-}+{-# OPTIONS_GHC -Wmissing-role-annotations #-}+{-# OPTIONS_GHC -Wprepositive-qualified-module #-}+{-# OPTIONS_GHC -Wstar-is-type #-}+{-# OPTIONS_GHC -Wpattern-namespace-specifier #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=9.14.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_9_14_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,128 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE BlockArguments #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DerivingVia #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE EmptyDataDeriving #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FieldSelectors #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE HexFloatLiterals #-}+{-# LANGUAGE ImpredicativeTypes #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LexicalNegation #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE LinearTypes #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE OverloadedRecordUpdate #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE QualifiedDo #-}+{-# LANGUAGE QuantifiedConstraints #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StarIsType #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedDatatypes #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE UnliftedNewtypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDerivingStrategies #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoImportQualifiedPost #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoNumericUnderscores #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedRecordDot #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRankNTypes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStandaloneKindSignatures #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE CUSKs #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -Wmissing-deriving-strategies #-}+{-# OPTIONS_GHC -Wmissing-kind-signatures #-}+{-# OPTIONS_GHC -Wprepositive-qualified-module #-}+{-# OPTIONS_GHC -Wstar-is-type #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=9.2.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_9_2_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,129 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE BlockArguments #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DeepSubsumption #-}+{-# LANGUAGE DerivingVia #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE EmptyDataDeriving #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FieldSelectors #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE HexFloatLiterals #-}+{-# LANGUAGE ImpredicativeTypes #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LexicalNegation #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE LinearTypes #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE OverloadedRecordUpdate #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE QualifiedDo #-}+{-# LANGUAGE QuantifiedConstraints #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StarIsType #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedDatatypes #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE UnliftedNewtypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDerivingStrategies #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoImportQualifiedPost #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoNumericUnderscores #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedRecordDot #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRankNTypes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStandaloneKindSignatures #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE CUSKs #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -Wmissing-deriving-strategies #-}+{-# OPTIONS_GHC -Wmissing-kind-signatures #-}+{-# OPTIONS_GHC -Wprepositive-qualified-module #-}+{-# OPTIONS_GHC -Wstar-is-type #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=9.2.4 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_9_2_4 (force) where++force :: ()+force = ()

@@ -0,0 +1,130 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE BlockArguments #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DeepSubsumption #-}+{-# LANGUAGE DerivingVia #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE EmptyDataDeriving #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE FieldSelectors #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE HexFloatLiterals #-}+{-# LANGUAGE ImpredicativeTypes #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LexicalNegation #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE LinearTypes #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE OverloadedRecordUpdate #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE QualifiedDo #-}+{-# LANGUAGE QuantifiedConstraints #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StarIsType #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedDatatypes #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE UnliftedNewtypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDerivingStrategies #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoImportQualifiedPost #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoNumericUnderscores #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedRecordDot #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRankNTypes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStandaloneKindSignatures #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeData #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE CUSKs #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -Wmissing-deriving-strategies #-}+{-# OPTIONS_GHC -Wmissing-kind-signatures #-}+{-# OPTIONS_GHC -Wprepositive-qualified-module #-}+{-# OPTIONS_GHC -Wstar-is-type #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=9.6.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_9_6_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,134 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE ApplicativeDo #-}+{-# LANGUAGE BinaryLiterals #-}+{-# LANGUAGE BlockArguments #-}+{-# LANGUAGE CApiFFI #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DatatypeContexts #-}+{-# LANGUAGE DeepSubsumption #-}+{-# LANGUAGE DerivingVia #-}+{-# LANGUAGE DoAndIfThenElse #-}+{-# LANGUAGE DuplicateRecordFields #-}+{-# LANGUAGE EmptyDataDeriving #-}+{-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE ExtendedLiterals #-}+{-# LANGUAGE FieldSelectors #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE GHCForeignImportPrim #-}+{-# LANGUAGE HexFloatLiterals #-}+{-# LANGUAGE ImpredicativeTypes #-}+{-# LANGUAGE IncoherentInstances #-}+{-# LANGUAGE InterruptibleFFI #-}+{-# LANGUAGE LexicalNegation #-}+{-# LANGUAGE LiberalTypeSynonyms #-}+{-# LANGUAGE LinearTypes #-}+{-# LANGUAGE MonadComprehensions #-}+{-# LANGUAGE MonomorphismRestriction #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NPlusKPatterns #-}+{-# LANGUAGE NamedWildCards #-}+{-# LANGUAGE NegativeLiterals #-}+{-# LANGUAGE NondecreasingIndentation #-}+{-# LANGUAGE NullaryTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE OverloadedRecordUpdate #-}+{-# LANGUAGE PartialTypeSignatures #-}+{-# LANGUAGE PostfixOperators #-}+{-# LANGUAGE QualifiedDo #-}+{-# LANGUAGE QuantifiedConstraints #-}+{-# LANGUAGE RebindableSyntax #-}+{-# LANGUAGE RoleAnnotations #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE StarIsType #-}+{-# LANGUAGE StaticPointers #-}+{-# LANGUAGE Strict #-}+{-# LANGUAGE TraditionalRecordSyntax #-}+{-# LANGUAGE TypeAbstractions #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE TypeInType #-}+{-# LANGUAGE UnboxedSums #-}+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}+{-# LANGUAGE UnicodeSyntax #-}+{-# LANGUAGE UnliftedDatatypes #-}+{-# LANGUAGE UnliftedFFITypes #-}+{-# LANGUAGE UnliftedNewtypes #-}+{-# LANGUAGE NoArrows #-}+{-# LANGUAGE NoBangPatterns #-}+{-# LANGUAGE NoConstrainedClassMethods #-}+{-# LANGUAGE NoDataKinds #-}+{-# LANGUAGE NoDefaultSignatures #-}+{-# LANGUAGE NoDeriveAnyClass #-}+{-# LANGUAGE NoDeriveDataTypeable #-}+{-# LANGUAGE NoDeriveFoldable #-}+{-# LANGUAGE NoDeriveFunctor #-}+{-# LANGUAGE NoDeriveGeneric #-}+{-# LANGUAGE NoDeriveLift #-}+{-# LANGUAGE NoDeriveTraversable #-}+{-# LANGUAGE NoDerivingStrategies #-}+{-# LANGUAGE NoDisambiguateRecordFields #-}+{-# LANGUAGE NoEmptyCase #-}+{-# LANGUAGE NoEmptyDataDecls #-}+{-# LANGUAGE NoExplicitForAll #-}+{-# LANGUAGE NoExplicitNamespaces #-}+{-# LANGUAGE NoForeignFunctionInterface #-}+{-# LANGUAGE NoFunctionalDependencies #-}+{-# LANGUAGE NoGADTSyntax #-}+{-# LANGUAGE NoGeneralizedNewtypeDeriving #-}+{-# LANGUAGE NoImplicitParams #-}+{-# LANGUAGE NoImportQualifiedPost #-}+{-# LANGUAGE NoInstanceSigs #-}+{-# LANGUAGE NoKindSignatures #-}+{-# LANGUAGE NoLambdaCase #-}+{-# LANGUAGE NoMagicHash #-}+{-# LANGUAGE NoMonoLocalBinds #-}+{-# LANGUAGE NoMultiWayIf #-}+{-# LANGUAGE NoNumDecimals #-}+{-# LANGUAGE NoNumericUnderscores #-}+{-# LANGUAGE NoOverloadedLabels #-}+{-# LANGUAGE NoOverloadedLists #-}+{-# LANGUAGE NoOverloadedRecordDot #-}+{-# LANGUAGE NoOverloadedStrings #-}+{-# LANGUAGE NoPackageImports #-}+{-# LANGUAGE NoParallelListComp #-}+{-# LANGUAGE NoPatternGuards #-}+{-# LANGUAGE NoPatternSynonyms #-}+{-# LANGUAGE NoPolyKinds #-}+{-# LANGUAGE NoQuasiQuotes #-}+{-# LANGUAGE NoRankNTypes #-}+{-# LANGUAGE NoRecordPuns #-}+{-# LANGUAGE NoRecordWildCards #-}+{-# LANGUAGE NoRecursiveDo #-}+{-# LANGUAGE NoStandaloneDeriving #-}+{-# LANGUAGE NoStandaloneKindSignatures #-}+{-# LANGUAGE NoStrictData #-}+{-# LANGUAGE NoTemplateHaskell #-}+{-# LANGUAGE NoTemplateHaskellQuotes #-}+{-# LANGUAGE NoTransformListComp #-}+{-# LANGUAGE NoTupleSections #-}+{-# LANGUAGE NoTypeApplications #-}+{-# LANGUAGE NoTypeData #-}+{-# LANGUAGE NoTypeFamilies #-}+{-# LANGUAGE NoTypeOperators #-}+{-# LANGUAGE NoTypeSynonymInstances #-}+{-# LANGUAGE NoUnboxedTuples #-}+{-# LANGUAGE NoViewPatterns #-}+{-# LANGUAGE CUSKs #-}+{-# LANGUAGE ImplicitPrelude #-}+{-# OPTIONS_GHC -Wmissing-deriving-strategies #-}+{-# OPTIONS_GHC -Wmissing-kind-signatures #-}+{-# OPTIONS_GHC -Wmissing-poly-kind-signatures #-}+{-# OPTIONS_GHC -Wmissing-role-annotations #-}+{-# OPTIONS_GHC -Wprepositive-qualified-module #-}+{-# OPTIONS_GHC -Wstar-is-type #-}+{-# OPTIONS_GHC -fplugin-opt GhcCompat:minVersion=9.8.1 #-}+{-# OPTIONS_GHC -fwarn-deriving-typeable #-}++module Test.Min_9_8_1 (force) where++force :: ()+force = ()

@@ -0,0 +1,35 @@+{-# LANGUAGE CPP #-}++module Test.SupportGHC2021 (force) where++import Data.Monoid ((<>))+import qualified Test.Min_9_2_1+import Prelude ()+#if MIN_VERSION_GLASGOW_HASKELL(9, 2, 4, 0)+import qualified Test.Min_9_2_4+#endif+#if MIN_VERSION_GLASGOW_HASKELL(9, 6, 1, 0)+import qualified Test.Min_9_6_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(9, 8, 1, 0)+import qualified Test.Min_9_8_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(9, 10, 1, 0)+import qualified Test.SupportGHC2024+#endif++force :: ()+force =+  Test.Min_9_2_1.force+#if MIN_VERSION_GLASGOW_HASKELL(9, 2, 4, 0)+    <> Test.Min_9_2_4.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(9, 6, 1, 0)+    <> Test.Min_9_6_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(9, 8, 1, 0)+    <> Test.Min_9_8_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(9, 10, 1, 0)+    <> Test.SupportGHC2024.force+#endif

@@ -0,0 +1,23 @@+{-# LANGUAGE CPP #-}++module Test.SupportGHC2024 (force) where++import Data.Monoid ((<>))+import qualified Test.Min_9_10_1+import Prelude ()+#if MIN_VERSION_GLASGOW_HASKELL(9, 12, 1, 0)+import qualified Test.Min_9_12_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(9, 14, 1, 0)+import qualified Test.Min_9_14_1+#endif++force :: ()+force =+  Test.Min_9_10_1.force+#if MIN_VERSION_GLASGOW_HASKELL(9, 12, 1, 0)+    <> Test.Min_9_12_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(9, 14, 1, 0)+    <> Test.Min_9_14_1.force+#endif

@@ -0,0 +1,97 @@+{-# LANGUAGE CPP #-}++module Main (main) where++import Control.Applicative (pure)+import Data.Function (($))+import Data.Monoid ((<>))+import System.IO (IO)+import qualified Test.Min_6_0_1+import qualified Test.Min_6_10_1+import qualified Test.Min_6_12_1+import qualified Test.Min_6_8_1+import qualified Test.Min_7_0_1+import qualified Test.Min_7_2_1+import Prelude ()+#if MIN_VERSION_GLASGOW_HASKELL(7, 4, 1, 0)+import qualified Test.Min_7_4_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(7, 6, 1, 0)+import qualified Test.Min_7_6_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(7, 8, 1, 0)+import qualified Test.Min_7_8_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(7, 10, 1, 0)+import qualified Test.Min_7_10_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(8, 0, 1, 0)+import qualified Test.Min_8_0_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(8, 2, 1, 0)+import qualified Test.Min_8_2_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(8, 4, 1, 0)+import qualified Test.Min_8_4_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(8, 6, 1, 0)+import qualified Test.Min_8_6_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(8, 8, 1, 0)+import qualified Test.Min_8_8_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(8, 10, 1, 0)+import qualified Test.Min_8_10_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(9, 0, 1, 0)+import qualified Test.Min_9_0_1+#endif+#if MIN_VERSION_GLASGOW_HASKELL(9, 2, 1, 0)+import qualified Test.SupportGHC2021+#endif++main :: IO ()+main =+  pure $+    Test.Min_6_0_1.force+      <> Test.Min_6_8_1.force+      <> Test.Min_6_10_1.force+      <> Test.Min_6_12_1.force+      <> Test.Min_7_0_1.force+      <> Test.Min_7_2_1.force+#if MIN_VERSION_GLASGOW_HASKELL(7, 4, 1, 0)+      <> Test.Min_7_4_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(7, 6, 1, 0)+      <> Test.Min_7_6_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(7, 8, 1, 0)+      <> Test.Min_7_8_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(7, 10, 1, 0)+      <> Test.Min_7_10_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(8, 0, 1, 0)+      <> Test.Min_8_0_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(8, 2, 1, 0)+      <> Test.Min_8_2_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(8, 4, 1, 0)+      <> Test.Min_8_4_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(8, 6, 1, 0)+      <> Test.Min_8_6_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(8, 8, 1, 0)+      <> Test.Min_8_8_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(8, 10, 1, 0)+      <> Test.Min_8_10_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(9, 0, 1, 0)+      <> Test.Min_9_0_1.force+#endif+#if MIN_VERSION_GLASGOW_HASKELL(9, 2, 1, 0)+      <> Test.SupportGHC2021.force+#endif

@@ -0,0 +1,9 @@+-- | NOP test, to skip on compilers that don’t support the particular test+module Main (main) where++import Control.Applicative (pure)+import System.IO (IO)+import Prelude ()++main :: IO ()+main = pure ()