This project is mirrored from https://github.com/haskell/Cabal. Pull mirroring updated .
  1. 05 Nov, 2016 1 commit
    • Edward Z. Yang's avatar
      Add fingerprint of Generic representation when serializing. · ebcae71d
      Edward Z. Yang authored
      
      
      The idea is we can use Rep to get a full, structural representation
      of a type, and the fingerprint it using Typeable.  This gives
      us a very concise way of fingerprinting our Binary representation.
      
      This patch is not completely correct; the fingerprint needs
      to be overridable when someone writes a custom Binary instance.
      But this should be "good enough" in practice; we're not using
      these fingerprints to check anything security critical.
      
      TODO: Not sure if I have tagged all the call-sites which could
      profit from this.
      
      Fixes #4059.
      Signed-off-by: default avatarEdward Z. Yang <ezyang@cs.stanford.edu>
      ebcae71d
  2. 01 Nov, 2016 1 commit
  3. 31 Oct, 2016 1 commit
  4. 29 Oct, 2016 1 commit
  5. 28 Oct, 2016 1 commit
    • Edsko de Vries's avatar
      Add support for foreign libraries. · 382143aa
      Edsko de Vries authored
      A stanza for a platform library looks something like
      
          platform-library test-package
            type:                native-shared
      
            if os(Windows)
              options: standalone
              mod-def-file: TestPackage.def
      
            other-modules:       MyPlatformLib.Hello
                                 MyPlatformLib.SomeBindings
            build-depends:       base >=4.7 && <4.9
            hs-source-dirs:      src
            c-sources:           csrc/MyPlatformLibWrapper.c
            default-language:    Haskell2010
      
      where native-shared means that we want to build a native shared library
      (.so on Linux, .dylib on OSX, .dll on Windows). The parser also
      recognizes native-static but this is not currently supported anywhere.
      The standalone option means that the we merge all library dependencies
      into the dynamic library (i.e., ghc options -shared -static), rather
      than make the created dynamic library just record its dependencies (ghc
      options -shared -dynamic); it is currently compulsory on Windows and
      unsupported anywhere else. The mod-def-file can be used to specify a
      module definition file, and is also Windows specific.
      
      There is a bit of refactoring in Build: gbuild is the old buildOrReplExe
      and now deals with both executables and platform libraries.
      382143aa
  6. 27 Oct, 2016 2 commits
  7. 26 Oct, 2016 8 commits
    • Oleg Grenrus's avatar
      Use SnocList to accumulate CondTrees · dc449c73
      Oleg Grenrus authored
      dc449c73
    • Oleg Grenrus's avatar
      Add more parsec warning tests · 211d9a56
      Oleg Grenrus authored
      211d9a56
    • Oleg Grenrus's avatar
      Add nbsp warning test · 9771c366
      Oleg Grenrus authored
      Note: we notify only about nbsp at the beginning of the line
      nbsp inside fields get just parsed atm
      9771c366
    • Oleg Grenrus's avatar
      Add parser BOM warning test · 4a4cea68
      Oleg Grenrus authored
      4a4cea68
    • Oleg Grenrus's avatar
      Lens additions · ee5e64fb
      Oleg Grenrus authored
      ee5e64fb
    • Oleg Grenrus's avatar
      PVP alex bound · 0ee50bc6
      Oleg Grenrus authored
      0ee50bc6
    • Oleg Grenrus's avatar
      Hide StructDiff behind the flag · 722e030f
      Oleg Grenrus authored
      722e030f
    • Oleg Grenrus's avatar
      Parsec parser · 512db606
      Oleg Grenrus authored
      - Initial import of stuff
      - Add hackage index parsing test for parsec
      - We can parse name and version
      - Add generics-sop dep
      - Use D.C.Prelude
      - Add StructDiff
      - Fix integral
      - Add Parsec -class
      - Add licence parsing
      - Free text fields (parsed as ascii atm)
      - Better StructDiff
      - Parsec BuildType
      - Implement VersionRange parser
      - Section parsing first steps
      - Sketch parseCondTree
      - more sec parsing
      - Module name
      - hs-source-dirs
          ::: composition/0.1/composition.cabal
          ::: composition/0.2/composition.cabal
          ::: composition/0.2.1/composition.cabal
          ::: composition/1.0.0.0/composition.cabal
      - PError (Position 20 1) "Unknown section: \"source-repository\""
      - Parses condition
      - Add some notes, address few comments
      - Install alex on linux travis
      - Make ParseResult strict state monad
      - Use withinVersion
      - No warnings
      - Move to Distribution.PackageDescription.Parsec.FieldDescr
      - extensions
      - SourceRepo (sans kind) parsing
      - RepoKind
      - Few more stuff
      - Add Distribution.Compat.Parsec
      - We can parse all 'composition*' packages cabal files \o/
      - fromUtf8BS
      - Clean up abit
      - More stuff
      - And more stuff
      - Traling whitespace :(
      - Executables
      - Benchmarks
      - spaceListField
      - Parse flag sections
      - a ~ Char,
      - tested with
      - package description x-fields
      - Conditions
      - reformat
      - Handle old syntax
      - More fields
      - More stuff
      - ^co ok,
      - more stuff
      - ^c ok
      - some of hackage ok
      - A-Z ok
      - Works [A-al)
      - to the h
      - rest of Hackage
      - Introduce parsec -flag
      - Count warnings
      - Verify we get not less warnings from parsec parser
      - fixup! Introduce parsec -flag
      - Warn about old/new syntax and cabal-version
      - Invalid UTF warning
      - Deprecated fields
      - Fix meta
      - Move transformers dep under parsec flag
      - Add parsec travis job
      512db606
  8. 25 Oct, 2016 1 commit
    • Edward Z. Yang's avatar
      Don't use installedPkgs for internal library library dirs. · a1107e21
      Edward Z. Yang authored
      In 1.24, installedPkgs contained only references to the external package
      database, not any internal libraries. In particular, when we built a
      dynamically linked executable, installedPkgs did NOT have a reference to
      the internal library; instead, depLibraryPaths has a special case
      (hasInternalDeps) to add the final libdir to the RPATH.
      
      In HEAD, after 0d15edef
      
      , we started adding internal libraries (with the
      INPLACE registrations) to installedPkgs to fix #2971.  But depLibraryPaths
      was not updated, which means that the inplace registrations got picked
      up and added to the RPATH, resulting in bad temporary directories
      showing up in RPATHs.
      
      In this commit, we just filter out internal entries from installedPkgs
      and compute the library dirs for them from scratch (this code already
      existed, so no loss!)
      
      Fixes #4025.
      Signed-off-by: default avatarEdward Z. Yang <ezyang@cs.stanford.edu>
      a1107e21
  9. 20 Oct, 2016 1 commit
  10. 19 Oct, 2016 1 commit
  11. 18 Oct, 2016 4 commits
  12. 14 Oct, 2016 1 commit
  13. 08 Oct, 2016 1 commit
  14. 06 Oct, 2016 6 commits
    • Edward Z. Yang's avatar
      45d75e1f
    • Edward Z. Yang's avatar
    • Edward Z. Yang's avatar
      Add the bulk of the new Backpack code · f2840cca
      Edward Z. Yang authored
      This will shortly be used in the package configuration step.
      
      Distribution/Utils/Progress.hs
          A copy of the Progress monad from cabal-install solver, which we use
          to report failure and logging from otherwise pure code.
      
      Distribution/Backpack/ModSubst.hs
          Defines a type class ModSubst for semantic objects that can have
          module substitutions defined over them.  Helps us define ModSubst
          functorially.
      
      Distribution/Backpack/ModuleScope.hs
          A module scope represents the set of required and provided modules
          which are "in scope", i.e., available for import and mix-in linking.
          This is not a simple mapping from module name to module, as we're
          permitted to have conflicting definitions for a module name as long
          as we don't actually use it.  There's a comment which explains this
          more clearly in the file.  These are based off of 'IndefModule'
          because not all modules in scope are necessarily fully instantiated.
      
      Distribution/Backpack/ModuleShape.hs
          A module shape describes the provisions and requirements of a
          library.  It's similar to a module scope, except that every
          export must be unambiguous; it too is based off of 'IndefModule'.
      
      Distribution/Backpack/FullUnitId.hs
          An 'IndefUnitId' is not guaranteed to record a module substitution
          (it could be opaquely represented as a hash); a 'FullUnitId',
          however, IS guaranteed to do so.  Given, for example, an installed
          package database, we can map opaque 'UnitId' into their expanded
          representation.  This can be important to handle obscure unification
          problems when mix-in linking.
      
      Distribution/Backpack/UnifyM.hs
          The unification monad, unifiable variants of Module/UnitId (with
          conversions to and from), and low-level unification operations on
          them.  Uses 'UnionFind' heavily.
      
          There is some commented out support for handling recursive
          unification.  At present there is no surface syntax for representing
          such situations.  (We would also need DFA minimization to
          canonicalize these regular trees.)
      
      Distribution/Backpack/MixLink.hs
          The actual implementation of mix-in linking, on top of the
          unification monad 'UnifyM'.  The key function is 'mixLink',
          which takes two module scopes and links them together.
      
      Distribution/Utils/LogProgress.hs
          The progress monad, specialized with LogMsg traces and Doc
          errors.  We provide a function to run such computations,
          outputting traces according to their 'Verbosity' and 'die'ing
          if there is an error.
      
      Distribution/Backpack/ComponentsGraph.hs
          A small helper function for handling the source-level graph
          of components (so, just the relationship between stanzas
          in a Cabal file.)  This components graph will eventually get
          elaborated into a more complex graph with instantiations, etc.
      
      Distribution/Backpack/Id.hs
          A helper module which now contains the functions for computing
          component identifiers and compatibility package keys.  This
          functionality used to live in Distribution.Simple.Configure
          but I split it out.  There are also adjustments to handle
          the new Backpack functionality.
      
      Distribution/Backpack/ConfiguredComponent.hs
          A configured component is one for which we've resolved all
          source level dependencies (e.g., every entry in build-depends,
          we know the specific transitive versions of each thing
          we're going to use.)  That means we have a 'ComponentId' for
          this component.  This module also contains functions for
          creating a 'ConfiguredComponent' from a source 'Component'.
      
      Distribution/Backpack/LinkedComponent.hs
          A linked component is one which we have done mix-in linking
          for, so we know its 'IndefUnitId' and its 'IndefUnitId'
      dependencies.
          This module calls out to mix-in linking to actually do linking.
          The workhorse, in a sense!
      
      Distribution/Backpack/ReadyComponent.hs
          This module implements the instantiation process, where we
          zip through all of the fully instantiated components, and
          recursively instantiate their dependencies, so that we
          get a separate linked component per thing we need to
          compile, and also finishes off any top-level indefinite
          components.  This gives us the final 'UnitId' for our
          units.
      
          This functionality is reimplemented in a different way in
          cabal-install; the assumptions are slightly different (in
          particular, in the library we can't assume we have access to all
          packages to build them; but in cabal-install we can assume it) so I
          didn't try to abstract over both implementations.
      
      Distribution/Backpack/PreExistingComponent.hs
          This is a "interoperability" data type which identifies
          precisely the information from a 'LinkedComponent' that
          can be derived from an 'InstalledPackageInfo'.
      f2840cca
    • Edward Z. Yang's avatar
      Replace the module renaming/thinning system · 1017f710
      Edward Z. Yang authored
      We had an old implementation of 'ModuleRenaming', with the
      assumption that it would be used directly in build-depends; since
      we have dropped this assumption, we can refactor 'ModuleRenaming'
      and we do so.  The main idea is to make the data type more directly
      reflect the syntax you can specify in a Cabal file; so the default
      renaming and an explicit thinning renaming are now different
      constructors.  It's no longer possible to use the "with" syntax, but
      it's not necessary either, since we have a special backpack-includes
      field to specify renamings, so we don't need them to be Monoidal.
      
      There is also a new syntax for 'hiding', which just lets you hide
      some modules when including a package. Handy!
      
      Previously, we recorded 'ModuleRenaming' in @build-depends@, but
      separated it out when we stored in 'BuildInfo'.  We now go even
      further, by changing it from a 'Map' (the only thing @build-depends@
      could support) to a list (so that a package name can be specified
      multiple times.)  This is good because now a user can instantiate
      something several times, which is useful in Backpack.
      
      Also add the new field @backpack-includes@ which can be used to exert
      fine-grained control over what modules a package brings into scope,
      include it multiple times, etc.
      
      In the .cabal checks, replace 'depsUsingThinningRenamingSyntax' with a
      more direct check to see if @backpack-includes@ was used.
      
      Dropped the legacy 'lookupRenaming' export from ModuleRenaming and
      PackageDescription; we will shortly not use it anymore. As an
      intermediate hack we have a local definition in Configure, but this
      will go away shortly.
      1017f710
    • Edward Z. Yang's avatar
      Add D.Backpack module with IndefUnitId and IndefModule types · fdf30f80
      Edward Z. Yang authored
      This module defines the key data types 'IndefUnitId' and
      'IndefModule', which represent components which are partially
      instantiated with holes in them.  The intent is that they
      can be substituted over (Distribution.Backpack.ModSubst),
      and once all the holes are filled they can be improved into
      proper 'UnitId's, which can then be installed.
      
      Also add Distribution.Util.Base62 module containing an
      implementation of base-62 encoding, which we use when
      computing hashes for fully instantiated unit ids.
      fdf30f80
    • Edward Z. Yang's avatar
      Add more reexported module tests · 6059c6b3
      Edward Z. Yang authored
      
      Signed-off-by: default avatarEdward Z. Yang <ezyang@cs.stanford.edu>
      6059c6b3
  15. 29 Sep, 2016 1 commit
  16. 26 Sep, 2016 2 commits
    • Herbert Valerio Riedel's avatar
      Introduce `Distribution.Compat.Prelude.Internal` + WARNING · 4c730f58
      Herbert Valerio Riedel authored
      This unexposes `Distribution.Compat.Prelude` again, and adds
      an exposed `.Internal` module which reexports the `.Prelude` module with
      an attached module-level `WARNING` pragma.
      
      This way users are discouraged to use this in `Setup.hs` files as they'd
      see compile warning like:
      
          Foo.hs:19:1-55: warning: [-Wdeprecations]
            Module ‘Distribution.Compat.Prelude.Internal’:
              This modules' API is not stable. Use at your own risk, or better yet, use @base-compat@!
      
      In `cabal-install` we import the `.Internal` module exactly once, and
      use -Wno-deprecations to suppress that the warning of that single
      import.
      4c730f58
    • Herbert Valerio Riedel's avatar
      Introduce `Distribution.Client.Compat.Prelude` · 82a22706
      Herbert Valerio Riedel authored
      This is supposed to become more or less a superset of Cabal's
      `Distribution.Compat.Prelude`.
      
      As a side-effect,t his exposes `Distribution.Compat.Prelude` from the
      Cabal library (which may be actually a good thing, as it may be useful
      module to Setup.hs writers).
      82a22706
  17. 22 Sep, 2016 1 commit
    • Herbert Valerio Riedel's avatar
      Update default-language & avoid default-extensions (#3880) · f87738df
      Herbert Valerio Riedel authored
      This upgrades the `default-language: Haskell98` to `Haskell2010`
      and removes `default-extensions: RankNTypes, FlexibleContexts`
      in favor of adding `LANGUAGE` pragmas where needed.
      
      Moroever, this also drops `LANGUAGE` pragmas which have become redundant
      due to `Haskell2010` (specifically, `EmptyDataDecls`,
      `ForeignFunctionInterface` and `PatternGuards`)
      
      Finally, an `other-extensions` specification is put in place for the
      `Cabal` library component.
      
      This helps loading up files directly in GHCi, such as e.g. `ghci Setup.hs`
      without having to specify `-X...` flags.
      f87738df
  18. 18 Sep, 2016 2 commits
    • Edward Z. Yang's avatar
      Use enabledBuildInfos rather than allBuildInfo. · b17a45e9
      Edward Z. Yang authored
      
      
      In many places, we incorrectly used allBuildInfo, which
      returns all BuildInfos that are buildable, and not
      necessarily the ones we are actually going to *build*.
      This used to "mostly do the right thing" because we
      literally edited the PackageDescription to nub out things,
      so you wouldn't see non-enabled components anyway.  However
      when I added support for per-component configure, I stopped
      editing the PackageDescription, which meant all of these
      uses were wrong.
      
      So, I updated them to do the right thing. Note that there
      are still uses of allBuildInfo in Check, but that probably
      requires a closer look.
      
      Fixes #3847.
      Signed-off-by: default avatarEdward Z. Yang <ezyang@cs.stanford.edu>
      b17a45e9
    • Edward Z. Yang's avatar
      Refactor ComponentEnabledSpec into ComponentRequestedSpec. · d03fe594
      Edward Z. Yang authored
      
      
      In the previous documentation for 'ComponentEnabledSpec', I claimed
      that enabled components were buildable, as well as requested
      by the user.  In the course of working on #3847, however,
      I realized that I hadn't actually *checked* that the component
      was buildable anywhere.  In particular, the 'ComponentDisabled'
      reason was *never used*.  This mostly didn't cause problems,
      however, because when we 'flattenPD' all non-buildable components
      get deleted, so you basically never actually have a non-buildable
      'Component'.
      
      But it still seemed a bit silly, so I fixed it by doing this:
      
      1) I introduce a new concept of a component being requested,
      which captures the use of --enable-tests and friends.  This
      does NOT imply buildability.  Renamed ComponentEnabledSpec
      to ComponentRequestedSpec
      
      2) A component is enabled if it is requested and buildable.
      If you give me a Component and a ComponentRequestedSpec I
      can tell you if it's enabled.  However, if you give me a
      ComponentName I can't, because I have no idea if it's buildable.
      
      3) Stopped reexporting ComponentRequestedSpec from
      Distribution.Simple.LocalBuildInfo
      
      4) Added a test for attempting to specify a non-buildable
      component as a target.  The test is accepting suboptimal
      output at the moment, see #3858.
      Signed-off-by: default avatarEdward Z. Yang <ezyang@cs.stanford.edu>
      d03fe594
  19. 10 Sep, 2016 1 commit
  20. 08 Sep, 2016 2 commits
    • Edward Z. Yang's avatar
      Provide useful call-stacks over all IO code. · 48a0d6ce
      Edward Z. Yang authored
      
      
      The key idea is that we define:
      
          type IO a = HasCallStack => Prelude.IO a
      
      and voila, call stacks are maintained across all IO!  You can
      look at the stacks using -v"debug +callstack".
      
      There are a number of IO functions for which the call stack is
      never used.  They are explicitly annotated using NoCallStackIO.
      Maybe some day they will use call stacks and we can change their
      types.  Similarly, there are a number of functions which do
      have type IO, but then suppress the redundant constraint error
      using "_ = callStack". Maybe some day we will attach call
      stacks to the exceptions we throw.
      Signed-off-by: default avatarEdward Z. Yang <ezyang@cs.stanford.edu>
      48a0d6ce
    • Edward Z. Yang's avatar
      Add support for extended verbosity specification -v"debug +callsite" · 83c93c10
      Edward Z. Yang authored
      This patch uses CallStack support in GHC 7.10 and GHC 8.0 to make
      it possible to get stack traces when we log output.
      
      This is the bare minimum to make this patch useful: there is
      plenty of tuning that can be done.  For example:
      
      * Insertions of withFrozenCallStack can help make the "callsite" output
        more useful, though be careful, we lose all stack information at that point!
      
      * Insertions of 'WithVerbosity', which will let us get deeper stacks
        (at the moment, they are basically always 1-deep.)
      
      Fixes #3768.
      
      CC @23Skidoo
      
      Signed-off-by: default avatarEdward Z. Yang <ezyang@cs.stanford.edu>
      83c93c10
  21. 05 Sep, 2016 1 commit