commit liquidhaskell for openSUSE:Factory

30 Sep 2020

Hello community,

here is the log from the commit of package liquidhaskell for openSUSE:Factory checked in at 2020-09-30 19:53:51
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/liquidhaskell (Old)
 and      /work/SRC/openSUSE:Factory/.liquidhaskell.new.4249 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "liquidhaskell"

Wed Sep 30 19:53:51 2020 rev:3 rq:838501 version:0.8.10.2

Changes:
--------

--- /work/SRC/openSUSE:Factory/liquidhaskell/liquidhaskell.changes	2020-09-27 11:49:14.032008371 +0200
+++ /work/SRC/openSUSE:Factory/.liquidhaskell.new.4249/liquidhaskell.changes	2020-09-30 19:53:56.076760209 +0200
@@ -1,0 +2,6 @@
+Sat Sep 19 02:00:44 UTC 2020 - psimons@suse.com
+
+- Update liquidhaskell to version 0.8.10.2 revision 1.
+  Upstream has revised the Cabal build instructions on Hackage.
+
+-------------------------------------------------------------------

New:
----
  liquidhaskell.cabal

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ liquidhaskell.spec ++++++
--- /var/tmp/diff_new_pack.cjAgxB/_old	2020-09-30 19:53:57.628761595 +0200
+++ /var/tmp/diff_new_pack.cjAgxB/_new	2020-09-30 19:53:57.628761595 +0200
@@ -25,6 +25,7 @@
 License:        BSD-3-Clause
 URL:            https://hackage.haskell.org/package/%{name}
 Source0:        https://hackage.haskell.org/package/%{name}-%{version}/%{name}-%{version}.tar.gz
+Source1:        https://hackage.haskell.org/package/%{name}-%{version}/revision/1.cabal#/%{name}.cabal
 Patch1:         fix-build-with-diff-0.4.x-part-1.patch
 Patch2:         fix-build-with-diff-0.4.x-part-2.patch
 BuildRequires:  chrpath

++++++ liquidhaskell.cabal ++++++
cabal-version:      2.4
name:               liquidhaskell
version:            0.8.10.2
x-revision: 1
synopsis:           Liquid Types for Haskell
description:        Liquid Types for Haskell.
license:            BSD-3-Clause
license-file:       LICENSE
copyright:          2010-19 Ranjit Jhala & Niki Vazou & Eric L. Seidel, University of California, San Diego.
author:             Ranjit Jhala, Niki Vazou, Eric Seidel
maintainer:         Ranjit Jhala <jhala@cs.ucsd.edu>
category:           Language
homepage:           https://github.com/ucsd-progsys/liquidhaskell
build-type:         Simple
tested-with:        GHC == 8.6.5, GHC == 8.10.1
extra-source-files: CHANGES.md
                    README.md
                    devel/Paths_liquidhaskell.hs
                    tests/pos/*.hs
                    tests/neg/*.hs
                    tests/import/lib/*.hs
                    tests/import/client/*.hs
                    tests/errors/*.hs
                    tests/pos/*.hquals
                    tests/ffi-include/foo.c
                    tests/ffi-include/foo.h
data-files:         include/*.hquals
                    include/*.hs
                    include/*.spec
                    include/CoreToLogic.lg
                    include/Control/*.spec
                    include/Control/Parallel/*.spec
                    include/Data/*.hquals
                    include/Data/*.spec
                    include/Data/Text/*.spec
                    include/Data/Text/Fusion/*.spec
                    include/Data/Text/Lazy/*.spec
                    include/Data/ByteString/*.spec
                    include/Foreign/*.spec
                    include/Foreign/C/*.spec
                    include/Foreign/Marshal/*.spec
                    include/GHC/*.hquals
                    include/GHC/*.spec
                    include/GHC/IO/*.spec
                    include/Language/Haskell/Liquid/*.hs
                    include/Language/Haskell/Liquid/Synthesize/*.hs
                    include/Language/Haskell/Liquid/*.pred
                    include/System/*.spec
                    include/710/Data/*.spec
                    syntax/liquid.css
                    -- Remove the lines above once we switch to the source plugin.
                    include/*.hs
                    include/Language/Haskell/Liquid/*.hs
                    include/Language/Haskell/Liquid/*.pred

                    -- Needed for the mirror-modules helper
                    mirror-modules/templates/MirrorModule.mustache

source-repository head
  type:     git
  location: https://github.com/ucsd-progsys/liquidhaskell/

flag include
  default:     False
  description: use in-tree include directory

flag deterministic-profiling
  default:     False
  description: Support building against GHC with <https://phabricator.haskell.org/D4388>
               backported

flag no-plugin
  default:     False
  manual:      True
  description: Use the legacy executable for testing.

flag mirror-modules-helper
  default:     False
  manual:      True
  description: Build the "mirror-modules" helper executable.

library
  autogen-modules:    Paths_liquidhaskell
  exposed-modules:    Gradual.Concretize
                      Gradual.GUI
                      Gradual.GUI.Annotate
                      Gradual.GUI.Misc
                      Gradual.GUI.Types
                      Gradual.Misc
                      Gradual.PrettyPrinting
                      Gradual.Refinements
                      Gradual.Trivial
                      Gradual.Types
                      Gradual.Uniquify
                      Language.Haskell.Liquid.Cabal
                      Language.Haskell.Liquid.Bare
                      Language.Haskell.Liquid.Bare.Axiom
                      Language.Haskell.Liquid.Bare.Check
                      Language.Haskell.Liquid.Bare.Class
                      Language.Haskell.Liquid.Bare.DataType
                      Language.Haskell.Liquid.Bare.Expand
                      Language.Haskell.Liquid.Bare.Laws
                      Language.Haskell.Liquid.Bare.Measure
                      Language.Haskell.Liquid.Bare.Misc
                      Language.Haskell.Liquid.Bare.Plugged
                      Language.Haskell.Liquid.Bare.Resolve
                      Language.Haskell.Liquid.Bare.ToBare
                      Language.Haskell.Liquid.Bare.Types
                      Language.Haskell.Liquid.Constraint.Constraint
                      Language.Haskell.Liquid.Constraint.Env
                      Language.Haskell.Liquid.Constraint.Fresh
                      Language.Haskell.Liquid.Constraint.Generate
                      Language.Haskell.Liquid.Constraint.Init
                      Language.Haskell.Liquid.Constraint.Monad
                      Language.Haskell.Liquid.Constraint.Qualifier
                      Language.Haskell.Liquid.Constraint.Split
                      Language.Haskell.Liquid.Constraint.ToFixpoint
                      Language.Haskell.Liquid.Constraint.Types
                      Language.Haskell.Liquid.GHC.API
                      Language.Haskell.Liquid.GHC.GhcMonadLike
                      Language.Haskell.Liquid.GHC.Interface
                      Language.Haskell.Liquid.GHC.Logging
                      Language.Haskell.Liquid.GHC.Misc
                      Language.Haskell.Liquid.GHC.Play
                      Language.Haskell.Liquid.GHC.Resugar
                      Language.Haskell.Liquid.GHC.SpanStack
                      Language.Haskell.Liquid.GHC.Types
                      Language.Haskell.Liquid.GHC.TypeRep
                      Language.Haskell.Liquid.Interactive.Handler
                      Language.Haskell.Liquid.Interactive.Types
                      Language.Haskell.Liquid.LawInstances
                      Language.Haskell.Liquid.Liquid
                      Language.Haskell.Liquid.Measure
                      Language.Haskell.Liquid.Misc
                      Language.Haskell.Liquid.Parse
                      Language.Haskell.Liquid.Synthesize.GHC
                      Language.Haskell.Liquid.Synthesize.Termination
                      Language.Haskell.Liquid.Synthesize.Monad
                      Language.Haskell.Liquid.Synthesize.Misc
                      Language.Haskell.Liquid.Synthesize.Generate
                      Language.Haskell.Liquid.Synthesize.Check
                      Language.Haskell.Liquid.Synthesize.Env
                      Language.Haskell.Liquid.Termination.Structural
                      Language.Haskell.Liquid.Transforms.ANF
                      Language.Haskell.Liquid.Transforms.CoreToLogic
                      Language.Haskell.Liquid.Transforms.Rec
                      Language.Haskell.Liquid.Transforms.RefSplit
                      Language.Haskell.Liquid.Transforms.Rewrite
                      Language.Haskell.Liquid.Transforms.Simplify
                      Language.Haskell.Liquid.Types
                      Language.Haskell.Liquid.Types.Bounds
                      Language.Haskell.Liquid.Types.Dictionaries
                      Language.Haskell.Liquid.Types.Equality
                      Language.Haskell.Liquid.Types.Errors
                      Language.Haskell.Liquid.Types.Fresh
                      Language.Haskell.Liquid.Types.Generics
                      Language.Haskell.Liquid.Types.Literals
                      Language.Haskell.Liquid.Types.Meet
                      Language.Haskell.Liquid.Types.Names
                      Language.Haskell.Liquid.Types.PredType
                      Language.Haskell.Liquid.Types.PrettyPrint
                      Language.Haskell.Liquid.Types.RefType
                      Language.Haskell.Liquid.Types.Specs
                      Language.Haskell.Liquid.Types.Types
                      Language.Haskell.Liquid.Types.Variance
                      Language.Haskell.Liquid.Types.Visitors
                      Language.Haskell.Liquid.Synthesize
                      Language.Haskell.Liquid.UX.ACSS
                      Language.Haskell.Liquid.UX.Annotate
                      Language.Haskell.Liquid.UX.CTags
                      Language.Haskell.Liquid.UX.CmdLine
                      Language.Haskell.Liquid.UX.Config
                      Language.Haskell.Liquid.UX.DiffCheck
                      Language.Haskell.Liquid.UX.Errors
                      Language.Haskell.Liquid.UX.QuasiQuoter
                      Language.Haskell.Liquid.UX.Tidy
                      Language.Haskell.Liquid.WiredIn
                      LiquidHaskell
                      Paths_liquidhaskell

  -- FIXME: Temporary measure to ensure that if the source plugin is available, then:
  --   1. we compile it;
  --   2. We don't rely on the \"liquid-prelude\" Haskell files previously shipped as part of LH itself.
  -- Once the source plugin is out, we should also removed the duplicate \"liquid-prelude\" files from
  -- the \"include\" directory.

  if impl(ghc >= 8.10)
      exposed-modules:    Language.Haskell.Liquid.GHC.Plugin
                          Language.Haskell.Liquid.GHC.Plugin.Tutorial
      other-modules:      Language.Haskell.Liquid.GHC.Plugin.SpecFinder
                          Language.Haskell.Liquid.GHC.Plugin.Types
                          Language.Haskell.Liquid.GHC.Plugin.Util
      hs-source-dirs:     src
  else
      hs-source-dirs:     src include
      exposed-modules:    Language.Haskell.Liquid.RTick
                          Language.Haskell.Liquid.Prelude
                          Language.Haskell.Liquid.Foreign
                          Language.Haskell.Liquid.RTick.Combinators
                          Language.Haskell.Liquid.String
                          Language.Haskell.Liquid.List
                          Language.Haskell.Liquid.Equational
                          Language.Haskell.Liquid.Bag
                          Language.Haskell.Liquid.ProofCombinators
                          KMeansHelper

  build-depends:      base                 >= 4.11.1.0 && < 5
                    , Diff                 >= 0.3 && < 0.4
                    , aeson
                    , binary
                    , bytestring           >= 0.10
                    , Cabal                < 3.3
                    , cereal
                    , cmdargs              >= 0.10
                    , containers           >= 0.5
                    , data-default         >= 0.5
                    , deepseq              >= 1.3
                    , directory            >= 1.2
                    , filepath             >= 1.3
                    , fingertree           >= 0.1
                    , ghc
                    , ghc-boot
                    , ghc-paths            >= 0.1
                    , ghc-prim
                    , gitrev
                    , hashable             >= 1.3
                    , hscolour             >= 1.22
                    , liquid-fixpoint      >= 0.8.10.1 && < 0.8.10.2.1
                    , mtl                  >= 2.1
                    , optics               >= 0.2
                    , optparse-applicative < 0.16.0.0
                    , optparse-simple
                    , githash
                    , parsec               >= 3.1
                    , pretty               >= 1.1
                    , split
                    , syb                  >= 0.4.4
                    , template-haskell     >= 2.9
                    , temporary            >= 1.2
                    , text                 >= 1.2
                    , time                 >= 1.4
                    , time
                    , transformers         >= 0.3
                    , unordered-containers >= 0.2
                    , vector               >= 0.10
                    , extra
  default-language:   Haskell98
  default-extensions: PatternGuards, RecordWildCards, DoAndIfThenElse
  ghc-options:        -W -fwarn-missing-signatures

  if flag(include)
    hs-source-dirs: devel

  if flag(deterministic-profiling)
    cpp-options: -DDETERMINISTIC_PROFILING

  if impl(ghc < 8.10) || flag(no-plugin)
    cpp-options: -DLIQUID_NO_PLUGIN

-- This is the (legacy) 'liquid' executable which uses the old GHC Interface.
executable liquid
  main-is:            exe/Liquid.hs
  build-depends:      base >= 4.9.1.0 && < 5, liquidhaskell
  default-language:   Haskell98
  default-extensions: PatternGuards
  ghc-options:        -W -threaded -fdefer-typed-holes


test-suite test
  type:             exitcode-stdio-1.0
  main-is:          test.hs
  other-modules:    Paths_liquidhaskell
  hs-source-dirs:   tests
  build-depends:    base                 >= 4.8.1.0 && < 5
                  , containers           >= 0.5
                  , directory            >= 1.2
                  , filepath             >= 1.3
                  , mtl                  >= 2.1
                  , optparse-applicative >= 0.11
                  , process              >= 1.2
                  , stm                  >= 2.4
                  , string-conv          >= 0.1
                  , tagged               >= 0.7.3
                  , tasty                >= 0.10 && < 1.3
                  , tasty-ant-xml
                  , tasty-golden         >= 2.0.0
                  , tasty-hunit          >= 0.9
                  , tasty-rerun          >= 1.1
                  , text
                  , transformers         >= 0.3
  default-language: Haskell98
  ghc-options:      -W -threaded
  if !flag(no-plugin)
    cpp-options: -DUSE_NEW_EXECUTABLE

test-suite liquidhaskell-parser
  type:             exitcode-stdio-1.0
  main-is:          Parser.hs
  other-modules:    Paths_liquidhaskell
  hs-source-dirs:   tests
  build-depends:    base            >= 4.8.1.0 && < 5
                  , liquid-fixpoint >= 0.8.10.1 && < 0.8.10.2.1
                  , liquidhaskell
                  , parsec
                  , syb
                  , tasty           >= 0.10
                  , tasty-ant-xml
                  , tasty-hunit     >= 0.9
  default-language: Haskell2010
  ghc-options:      -W

test-suite synthesis
  type:             exitcode-stdio-1.0
  main-is:          Synthesis.hs
  other-modules:    Paths_liquidhaskell
  hs-source-dirs:   tests
  build-depends:    base            >= 4.8.1.0 && < 5
                  , liquid-fixpoint >= 0.8.10.1 && < 0.8.10.2.1
                  , liquidhaskell
                  , tasty           >= 0.7
                  , tasty-hunit
                  , process
                  , filepath
                  , text
                  , directory
                  , ghc
                  , extra
  default-language: Haskell2010
  ghc-options:      -W


-- This executable can be used to generate modules for mirror-packages.
executable mirror-modules
  main-is:        Main.hs
  hs-source-dirs: mirror-modules

  other-modules: CLI
                 Paths_liquidhaskell

  if flag(mirror-modules-helper)
    build-depends: base >= 4.9.1.0 && < 5
                 , shelly < 1.10
                 , text < 1.3
                 , filepath < 1.5
                 , containers < 0.7
                 , mustache < 2.4
                 , optparse-applicative < 0.16.1.0
    buildable: True
  else
    buildable: False

  default-language:   Haskell2010
  default-extensions:
    OverloadedStrings
    RecordWildCards
    MultiWayIf
    LambdaCase
  ghc-options:        -W -threaded

    

commit liquidhaskell for openSUSE:Factory

root