Allow for hoogle to be materialized in `shellFor` by using `tools.hoogle` when passed in.
Co-authored-by: Hamish Mackenzie <Hamish.K.Mackenzie@googlemail.com>
- Added the ability to generate coverage reports for packages and
projects.
- Outputs mix and tix information, as well as a HTML report.
- Added the "doCoverage" module option that allows users to choose
packages to enable coverage for.
- Added a "doCoverage" flag to the component builder that outputs HPC
information when coverage is enabled.
- Added the "overrideModules" library function to make it more
ergonomic fo users to enable coverage on existing projects.
- Modified the "check" builder to also output ".tix" files (if they
exist). This information is required to generate the coverage
report.
- Added a test for coverage.
* Changes to allow opencv to be built
The opencv library needs:
1. pkgconfig for opencv should return OpenCV 3, not OpenCV 2 (which is
what pkgs.opencv is)
2. hardeningDisable = [ "bindnow" ] (as per
https://github.com/LumiGuide/haskell-opencv/commit/5ea490af7662fe74b3740619963d37f1fd91e3d4#)
This commit fixes (1) by adding an entry to lib/pkgconf-nixpkgs-map.nix,
and partially fixes (2) by adding a new `hardeningDisable` option to the
set of package options. The user will still need to specify:
packages.opencv.hardeningDisable = [ "bindnow" ];
I'm not sure if there's a place to specify this as default in haskell.nix.
* Update comp-builder.nix
I had to refactor this a bit to understand what was going on, but the
kicker is two changes:
- `removeSelectedInput` was only removing *library* components. This was
fine when we were only looking at the `all` components, since they
always dependend on libraries. But now we're looking at all kinds of
components, and these can, for example, depend on internal libraries.
So we need to filter out dependencies on *any* component, not just a
library component. This fixes https://github.com/input-output-hk/haskell.nix/issues/818
- The filtering on `nativeBuildInputs` was wrong, since it was using the
filtering function that filters *packages*, not the one that filters
*derivations*. I didn't observe this causing a bug but it seems wrong.
Currently if the `ghc-pkg` fails during the last stage of building a library component
(perhaps because of https://github.com/NixOS/nix/issues/719) the failure is ignored.
This seems to be the most likely cause of the bad `config` derivation.
This change should cause the derivation build to fail instead of making invalid
files when this happens.
These can't be null. They could perhaps be absent, but I can't figure
out how to set an attribute only if something else isn't null in a nice
way, and having it be the empty string seems fine.
Fixes#804.
It causes a lot of issues. To make this work:
* `shellFor` is updated to use `getAllComponents` instead of `.all`.
* `getAllComponents` is updated to work on the package rather than
the package config.
* Tests updated to not use `.library` or `.exes.X` where appropriate.
* Documentation updated.
* Out of date examples removed.
As a bonus `shellFor` now takes a `components` argument that might be
useful for limiting the dependencies of the shell to just the ones
needed for the components you intend to work on.
Changes to the interface of haskell.nix (from the changelog.md file):
* Removed `sources.nixpkgs-default`, use `sources.nixpkgs` instead.
* Removed `./nixpkgs` directory, use `(import ./. {}).sources`
or `./nix/sources.nix` instead.
* Removes V1 interface for details on how to fix old code see:
https://github.com/input-output-hk/haskell.nix/issues/709
* Removed defaultCompilerNixName.
* cabalProject, cabalProject', hackage-project and hackage-package
now require a `compiler-nix-name` argument.
* `haskell-nix.tool` and `.tools` now require a `compiler-nix-name` argument.
New functions `p.tool` and `p.tools` (where p is a project) do not.
Like `shellFor { tools = ... }` they will use the compiler nix name
from the project (including stack projects where it is derived from
the resolver).
* `haskell-nix.alex` and `haskell-nix.happy` have been removed. Use
`p.tool "alex" "3.2.5"` or `shellFor { tools = { alex = "3.2.5"; } }`.
* `haskell-nix.nix-tools` -> `haskell-nix.nix-tools.ghc883` (it includes
the hpack exe now).
* `haskell-nix.cabal-install` ->
`p.tool "cabal" "3.2.0.0"` or `shellFor { tools = { cabal = "3.2.0.0"; } }`
* `haskell-nix.haskellNixRoots` -> `haskell-nix.roots ghc883` or `p.roots`
Other changes:
Adds hpack executable to the nix-tools derivations.
Adds a `cabal-hpack` test to make sure `hpack` works with
`cabalProject`.
Reduces the number of calls to `cabalProject` (particularly when
checking materialization), by giving internal tools a per-compiler
attribute.
Uses happy 1.19.12 when building newer ghc versions.
Updates cabal-install 3.2.0.0 to use the source from github that
is compatible with ghc 8.10.1.
Updates the docs for callCabalProjectToNix.
Adds a license mapping to fix a common warning.
Packages like haskell-gi need pkgconfig at configue time to generate
source files we want to run haddock on.
This change also brings back a `mkdir` for the $docs that is needed
for haddock of bytesting-builder (it was removed when haddock the
haddock derivation was split out).
Generation the Haddock documentation for a component in a dedicated
derivation (instead of as part of the derivation to build the component).
This means that the haddock documents will not be built until they are
required for instance in a shellFor shell.
Co-authored-by: Richard Wallace <richard.wallace@simspace.com>
Without this pin the plan choosen with the latest hackage is currently
broken and the build fails with:
```
src/General/Web.hs:21:1: error:
Could not find module ‘Data.Aeson.Encoding’
Perhaps you meant
Data.Aeson.Encode (from aeson-0.11.3.0)
Data.ASN1.Encoding (needs flag -package-key asn1-encoding-0.9.6)
Data.Text.Encoding (from text-1.2.3.1)
Use -v to see a list of the files searched for.
|
21 | import Data.Aeson.Encoding
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
```
pkgconfig-depends that make use of propagatedBuildInputs and frameworks
are not propagated to the exe component that links them. This seems
to be because our libraries do not not include their dependencies
as `buildInputs`. To make this work it also seems to be necessary
for pkgconfig depends themselves to be `propagaedBuildInputs`.
In de3f82a419 a isNativeMusl function was
added, but we did not use it in `builder/ghc-for-component-wrapper.nix`
for selecting a ghc with a suitable `haddock` executable (it was only
used in builder/default.nix).
Although the default ghc used by haskell.nix is ghc 8.6.5 many of
the tools used in haskell.nix are still built with the boot compiler
ghc 8.4.4. These include
* haskell-nix.cabal-install
* haskell-nix.alex
* haskell-nix.happy
This change updates those to ghc 8.6.5 and includes materializations
for the new versions.
When cabal-install is built it is careful to disable materialization
checks on the version of itself used during the build to avoid
infinite recursion.
There was a version of nix-tools built with the boot ghc which was
only used when `checkMaterialization = true`. It was used for
the boot versions of alex, happy and hscolour. These have been update
to use the default (ghc 8.6.5) version of nix-tools and
checkMaterialization is forced off when they are being used to build
ghc. This means the materialization will only be checked for these
when they are built independently (they are included in the test set
via haskellNixRoots).
Three new arguments are added to `default.nix`:
* `defaultCompilerNixName` if not specified "ghc865" is used
* `checkMaterialization` makes it easier to switch on materialization checks
* `system` defaults to `builtins.currentSystem`
This change also moves the work needed for hydra eval to the eval
system using a new `evalPackages` feature. This includes:
* Fetching from git with `fetchgit`
* Building scripts with `runCommand` and `writeTextFile`
* `git ls-files` in `cleanGit`
* running `cabal v2-configure`
* copying materialized files (we are not sure why this is necessary but
if we do not `cp -r` the files nix will not load them on hydra)
Reduce size of `make-config-files.nix` strings by around 80%.
These are unlikely to be the cause of hydra eval time memory
issues in the GB range, but were still quite large (around 10MB for the
`cabal-simple` test case).
There was issue causing excessive builds of the `git` package when
cross compiling. Gory details are a comment in `lib/defaults.nix`
but in short if you use `git` you need an extra `.buildPackages`
one is not enough because it depends on `gdb` and that will
be different in `buildPackages` compared to
`buildPackages.buildPackages`.
Adds missing materialization files for ghc 8.4.4 (only needed
when `checkMaterialization` is on because of other
materialiazations, but good to have).
Currently we do not give components a version and this is inconvenient
as it means nix code that checks for a version does not work
with haskell.nix components.
* Add native musl support
- adds haskellLibl.isNaviveMusl and related fixes (previously it was
assumed that for musl we always use cross-compilation)
- fixed some issues for musl intoduced in nixpkgs 20.03 (ssh/fetchcvs
infinite recursion, busybox pkgsMusl.pkgsStatic chain, etc.)
- cross-compilation fixes for ghc (absolute path for ar, always pass
target to configure, libffi and gmp packages for target platform) -
this needs more testing
* Better explanation for targetPlatform.{libffi, gmp}
* Ghc configure script now respect AR env variable
Co-authored-by: Moritz Angermann <moritz.angermann@gmail.com>
When building profiling executables we want the libraries also with
profiling. This change also adds a flag to link against the debug RTS.
This does not require everything to be built against the debug RTS and
only requires the final linking step, hence no threading is necessary.
Not being able to override components values once they have been setup
and exclusively relying on the module system to do its thing, can be
quite constraining. This change allows us to override components.
Changing from absolute links to relative links increases the length of
the parameters passed during linking by half. For things that have many
dependencies, this results in linking failing with an "argument list too
long" error.
Fixes#562
This change also updates the CI configuration files to help make
it easier for CI to cope with this sort of change.
Co-authored-by: Richard Wallace <richard.wallace@simspace.com>
This overlay helps accessing common executable components.
Typically we want to make these available in a nix-shell
created with shellFor. In most cases the package name
will be the same as the executable, but we have a
`toolPackageName` mapping to help when it is not.
```
# To get a single tool:
haskell-nix.tool "cabal" "3.2.0.0"
# This does the same thing as:
(haskell-nix.hackage-package {
name = "cabal-install"
version = "3.2.0.0"
}).components.exes.cabal
# To get an attr set containing multiple tools:
haskell-nix.tools { cabal = "3.2.0.0"; hlint = "2.2.11"; }
# To add tools to a shell:
shellFor { tools = { cabal = "3.2.0.0"; hlint = "2.2.11"; }; }
```
When used in shellFor the tools will be compiled with the same version
of ghc used in the shell (the build ghc in the case of cross
compilation).
Instead of a version string we can use an attr set containing
arguments that will be passed to `cabalProject`.
For instance to specify the ghc used to compile. Use:
```
haskell-nix.tool "cabal" {
version = "3.2.0.0";
ghc = haskell-nix.compiler.ghc883;
}
```
* Update nixpkgs pins to include 20.03, wobble
- Add 20.03
- Remove 19.03 (and old 18.09 file)
- Update 19.09 to latest
- Update github pin to 20.03
- Remove workarounds for 19.03
* Mark openssl as allowedInsecure
* Force python3 for mkdocs
* fix: don't use fast-llvm for aarch32
fast-llvm bypasses the GHC LLVM mangler and the GNU assembler. The latter is currently required when using the gold linker for valid relocation sections.
* feat: remove usage of the fast-llvm flag
The fast-llvm flag was intented to avoid potential incompatibilities between LLVM and the assembler/linker toolchain by making LLVM responsible for machine-code generation.
It bypasses necessary code transformation and prevents valid program generation in some cases (e.g. cross-compilation to armv6l). It is planned for removal from GHC.
References:
https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3120
Co-authored-by: Michivi <webmaster@michvi.com>
It seems that using ld.gold for cross-compilation to aarch32 results in Haskell programs segfaulting when launched.
Co-authored-by: Michivi <webmaster@michvi.com>
* Allow .so dynamic libraries on Darwin
This code is a hack that applied only to Darwin, it collects all
required dynamic libraries into a single directory. It does this by
listing all library dirs and then linkin all dynamic libraries in them.
Before this change, it would link only `*.dylib` files. This was a
problem, because (weirdly) a lot of libraries in Nixpkgs actually
produce .so even on Darwin (and, weirdly, this somehow works).
So we now link `.so` files as well.
* Fix linking of dynamic libs with static on Darwin
This piece of code `ln`s all libraries we might want to link with into a
single directory and then hides all previous directories from Cabal.
The problem is that this code only `ln`s dynamic libraries, however we
might want to link with some library that only comes in a static
version.
So, `ln` static `.a` libraries too so that they are found when linking.
* Remove unused (and broken) test files
* Make default.nix expose pinned nixpkgs
Also make `nixpkgs/default.nix` just an attribute set of sources.
This is simpler, and consistent with what e.g. `niv` does.
* Add backwards compatibility shim, and version argument to allow evolution in future
* Fix some missed things
* Fix and improve quickstart
This PR adds a patch for GHC 8.6.5 to properly remove the atomic primops fallbacks on ARM architectures. Those primops called some GCC legacy synchronization functions that were not loaded during TH, ending in failure within `remote-iserv`. It turns out that the condition `!defined(arm_HOST_ARCH)` was never `true`, as `arm_HOST_ARCH` was actually defined (on ARM architectures) in a dependency of the `Rts.h` file.
This patch works for my use case (GHC 8.6.5 for armv6l). I haven't done any test on the other GHC versions.
This PR also includes a patch to actually use the native `pkgconfig` during cross-compilation.
Fixes#441
Authored-by: Michivi <webmaster@michvi.com>
* Enables tests for Musl and AArch64 (also rasbery pi, but leaves them disabled for now) and includes many fixes for the tests that were broken.
* Makes Musl cross compiler more like native (including making `ghci` and `runghc` work)
* Updates selection of enableShared
* Works around missing configFiles attribute issue
* Use ghc-extra-packages and compiler.nix-name to pick the right extra packages
* Leaves out --cross-compile on hsc2hs for musl
* Fixes haddock and hoogle for musl and disables them for other cross compilers
* Adds ghc 8.8.3
* Static link components (except libraries and `all`) on musl
* Use qemu for the arm cross compile `testWrapper`
* Add isCrossHost and isCrossTarget functions
* Fixes profiling on AArch64
* Disable split sections when compiling for windows (fixes GHC 8.8 cross compile to windows)
* Disable hoogle in cross compiler shells for now
Moritz AngermannandHamish Mackenzie
Eric WolfandHamish Mackenzie
andremarianiello
Samuel Evans-Powell
Ollie Charles
John A. Lotoski
Michael Peyton Jones
Travis Whitaker
Guillaume Desforges
Alexander KudryashovandMoritz Angermann
Le TuanandMichivi
Kirill Elagin
Yorick