@@ -1,7 +1,798 @@
1−# DO NOT HAND-EDIT THIS FILE
2−import ((import <nixpkgs> {}).fetchFromGitHub (
3− let json = builtins.fromJSON (builtins.readFile ./github.json);
4− in { inherit (json) owner repo rev sha256;
5− private = json.private or false;
6− }
7−))
1+{ nixpkgsFunc ? import ./nixpkgs
2+, system ? builtins.currentSystem
3+, config ? {}
4+, enableLibraryProfiling ? false
5+, enableExposeAllUnfoldings ? true
6+, enableTraceReflexEvents ? false
7+, useFastWeak ? true
8+, useReflexOptimizer ? false
9+, useTextJSString ? true
10+, __useLegacyCompilers ? false # Interface unstable
11+, iosSdkVersion ? "10.2"
12+, nixpkgsOverlays ? []
13+, haskellOverlays ? []
14+}:
15+let iosSupport = system == "x86_64-darwin";
16+ androidSupport = lib.elem system [ "x86_64-linux" ];
17+
18+ # Overlay for GHC with -load-splices & -save-splices option
19+ splicesEval = self: super: {
20+ haskell = super.haskell // {
21+ compiler = super.haskell.compiler // {
22+ ghcSplices-8_4 = super.haskell.compiler.ghc843.overrideAttrs (drv: {
23+ enableParallelBuilding = false;
24+ patches = (drv.patches or [])
25+ ++ [ ./splices-load-save.patch ./haddock.patch ];
26+ });
27+ };
28+ packages = super.haskell.packages // {
29+ ghcSplices-8_4 = super.haskell.packages.ghc843.override {
30+ buildHaskellPackages = self.buildPackages.haskell.packages.ghcSplices-8_4;
31+ ghc = self.buildPackages.haskell.compiler.ghcSplices-8_4;
32+ };
33+ };
34+ };
35+ };
36+
37+ bindHaskellOverlays = self: super: {
38+ haskell = super.haskell // {
39+ overlays = super.overlays or {} // import ./haskell-overlays {
40+ nixpkgs = self;
41+ inherit
42+ haskellLib
43+ fetchFromGitHub hackGet
44+ ghcjsBaseSrc ghcjsBaseTextJSStringSrc
45+ useFastWeak useReflexOptimizer enableLibraryProfiling enableTraceReflexEvents
46+ useTextJSString enableExposeAllUnfoldings
47+ stage2Script
48+ optionalExtension
49+ haskellOverlays;
50+ inherit ghcSavedSplices;
51+ inherit (self) lib;
52+ androidActivity = hackGet ./android-activity;
53+ };
54+ };
55+ };
56+
57+ forceStaticLibs = self: super: {
58+ darwin = super.darwin // {
59+ libiconv = super.darwin.libiconv.overrideAttrs (_:
60+ lib.optionalAttrs (self.stdenv.hostPlatform != self.stdenv.buildPlatform) {
61+ postInstall = "rm $out/include/libcharset.h $out/include/localcharset.h";
62+ configureFlags = ["--disable-shared" "--enable-static"];
63+ });
64+ };
65+ zlib = super.zlib.override (lib.optionalAttrs
66+ (self.stdenv.hostPlatform != self.stdenv.buildPlatform)
67+ { static = true; });
68+ };
69+
70+ mobileGhcOverlay = import ./nixpkgs-overlays/mobile-ghc { inherit lib; };
71+
72+ nixpkgsArgs = {
73+ inherit system;
74+ overlays = [
75+ bindHaskellOverlays
76+ forceStaticLibs
77+ mobileGhcOverlay
78+ splicesEval
79+ ] ++ nixpkgsOverlays;
80+ config = {
81+ permittedInsecurePackages = [
82+ "webkitgtk-2.4.11"
83+ ];
84+ packageOverrides = pkgs: {
85+ webkitgtk = pkgs.webkitgtk220x;
86+ };
87+
88+ # XCode needed for native macOS app
89+ # Obelisk needs it to for some reason
90+ allowUnfree = true;
91+ } // config;
92+ };
93+
94+ nixpkgs = nixpkgsFunc nixpkgsArgs;
95+
96+ inherit (nixpkgs) lib fetchurl fetchgit fetchgitPrivate fetchFromGitHub;
97+
98+ nixpkgsCross = {
99+ android = lib.mapAttrs (_: args: nixpkgsFunc (nixpkgsArgs // args)) rec {
100+ aarch64 = {
101+ crossSystem = lib.systems.examples.aarch64-android-prebuilt;
102+ };
103+ aarch32 = {
104+ crossSystem = lib.systems.examples.armv7a-android-prebuilt // {
105+ # Hard to find newer 32-bit phone to test with that's newer than
106+ # this. Concretely, doing so resulted in:
107+ # https://android.googlesource.com/platform/bionic/+/master/libc/arch-common/bionic/pthread_atfork.h#19
108+ sdkVer = "22";
109+ };
110+ };
111+ # Back compat
112+ arm64 = lib.warn "nixpkgsCross.android.arm64 has been deprecated, using nixpkgsCross.android.aarch64 instead." aarch64;
113+ armv7a = lib.warn "nixpkgsCross.android.armv7a has been deprecated, using nixpkgsCross.android.aarch32 instead." aarch32;
114+ arm64Impure = lib.warn "nixpkgsCross.android.arm64Impure has been deprecated, using nixpkgsCross.android.aarch64 instead." aarch64;
115+ armv7aImpure = lib.warn "nixpkgsCross.android.armv7aImpure has been deprecated, using nixpkgsCross.android.aarch32 instead." aarch32;
116+ };
117+ ios = lib.mapAttrs (_: args: nixpkgsFunc (nixpkgsArgs // args)) rec {
118+ simulator64 = {
119+ crossSystem = lib.systems.examples.iphone64-simulator // {
120+ sdkVer = iosSdkVersion;
121+ };
122+ };
123+ aarch64 = {
124+ crossSystem = lib.systems.examples.iphone64 // {
125+ sdkVer = iosSdkVersion;
126+ };
127+ };
128+ aarch32 = {
129+ crossSystem = lib.systems.examples.iphone32 // {
130+ sdkVer = iosSdkVersion;
131+ };
132+ };
133+ # Back compat
134+ arm64 = lib.warn "nixpkgsCross.ios.arm64 has been deprecated, using nixpkgsCross.ios.aarch64 instead." aarch64;
135+ };
136+ };
137+
138+ haskellLib = nixpkgs.haskell.lib;
139+
140+ filterGit = builtins.filterSource (path: type: !(builtins.any (x: x == baseNameOf path) [".git" "tags" "TAGS" "dist"]));
141+
142+ # Retrieve source that is controlled by the hack-* scripts; it may be either a stub or a checked-out git repo
143+ hackGet = p:
144+ let filterArgs = x: removeAttrs x [ "branch" ];
145+ in if builtins.pathExists (p + "/git.json") then (
146+ let gitArgs = filterArgs (builtins.fromJSON (builtins.readFile (p + "/git.json")));
147+ in if builtins.elem "@" (lib.stringToCharacters gitArgs.url)
148+ then fetchgitPrivate gitArgs
149+ else fetchgit gitArgs)
150+ else if builtins.pathExists (p + "/github.json") then fetchFromGitHub (filterArgs (builtins.fromJSON (builtins.readFile (p + "/github.json"))))
151+ else {
152+ name = baseNameOf p;
153+ outPath = filterGit p;
154+ };
155+
156+ # All imports of sources need to go here, so that they can be explicitly cached
157+ sources = {
158+ ghcjs8_0 = {
159+ boot = hackGet ./ghcjs-8.0/boot;
160+ shims = hackGet ./ghcjs-8.0/shims;
161+ ghcjs = hackGet ./ghcjs-8.0/ghcjs;
162+ };
163+ };
164+
165+ optionalExtension = cond: overlay: if cond then overlay else _: _: {};
166+
167+ applyPatch = patch: src: nixpkgs.runCommand "applyPatch" {
168+ inherit src patch;
169+ } ''
170+ cp -r "$src" "$out"
171+
172+ cd "$out"
173+ chmod -R +w .
174+ patch -p1 <"$patch"
175+ '';
176+
177+ overrideCabal = pkg: f: if pkg == null then null else haskellLib.overrideCabal pkg f;
178+
179+ replaceSrc = pkg: src: version: overrideCabal pkg (drv: {
180+ inherit src version;
181+ sha256 = null;
182+ revision = null;
183+ editedCabalFile = null;
184+ });
185+
186+ combineOverrides = old: new: old // new // lib.optionalAttrs (old ? overrides && new ? overrides) {
187+ overrides = lib.composeExtensions old.overrides new.overrides;
188+ };
189+
190+ # Makes sure that old `overrides` from a previous call to `override` are not
191+ # forgotten, but composed. Do this by overriding `override` and passing a
192+ # function which takes the old argument set and combining it. What a tongue
193+ # twister!
194+ makeRecursivelyOverridable = x: x // {
195+ override = new: makeRecursivelyOverridable (x.override (old: (combineOverrides old new)));
196+ };
197+
198+ foreignLibSmuggleHeaders = pkg: overrideCabal pkg (drv: {
199+ postInstall = ''
200+ cd dist/build/${pkg.pname}/${pkg.pname}-tmp
201+ for header in $(find . | grep '\.h'$); do
202+ local dest_dir=$out/include/$(dirname "$header")
203+ mkdir -p "$dest_dir"
204+ cp "$header" "$dest_dir"
205+ done
206+ '';
207+ });
208+
209+ cabal2nixResult = src: builtins.trace "cabal2nixResult is deprecated; use ghc.haskellSrc2nix or ghc.callCabal2nix instead" (ghc.haskellSrc2nix {
210+ name = "for-unknown-package";
211+ src = "file://${src}";
212+ sha256 = null;
213+ });
214+
215+ stage2Script = nixpkgs.runCommand "stage2.nix" {
216+ GEN_STAGE2 = builtins.readFile (nixpkgs.path + "/pkgs/development/compilers/ghcjs/gen-stage2.rb");
217+ buildCommand = ''
218+ echo "$GEN_STAGE2" > gen-stage2.rb && chmod +x gen-stage2.rb
219+ patchShebangs .
220+ ./gen-stage2.rb "${sources.ghcjs8_0.boot}" >"$out"
221+ '';
222+ nativeBuildInputs = with nixpkgs; [
223+ ruby cabal2nix
224+ ];
225+ } "";
226+
227+ ghcjsApplyFastWeak = ghcjs: ghcjs.overrideAttrs (drv: {
228+ patches = (drv.patches or [])
229+ ++ lib.optional useFastWeak ./fast-weak.patch;
230+ phases = [ "unpackPhase" "patchPhase" "buildPhase" ];
231+ });
232+ useTextJSStringAsBootPkg = ghcjs: if !useTextJSString then ghcjs else ghcjs.overrideAttrs (_: {
233+ postUnpack = ''
234+ set -x
235+ (
236+ echo $sourceRoot
237+ cd $sourceRoot
238+ rm -r lib/boot/pkg/text
239+ cp --no-preserve=mode -r "${textSrc}" lib/boot/pkg/text
240+ cp --no-preserve=mode -r "${ghcjsBaseTextJSStringSrc}" lib/boot/pkg/ghcjs-base
241+ cp --no-preserve=mode -r "${dlistSrc}" lib/boot/pkg/dlist
242+ rm -r lib/boot/pkg/vector
243+ cp --no-preserve=mode -r "${vectorSrc}" lib/boot/pkg/vector
244+ sed -i 's/.\/pkg\/mtl/.\/pkg\/mtl\n - .\/pkg\/ghcjs-base\n - .\/pkg\/dlist\n - .\/pkg\/primitive\n - .\/pkg\/vector/' lib/boot/boot.yaml
245+ cat lib/boot/boot.yaml
246+ )
247+ '';
248+ });
249+ ghcjsBaseSrc = fetchgit {
250+ url = "https://github.com/ghcjs/ghcjs-base.git";
251+ rev = "01014ade3f8f5ae677df192d7c2a208bd795b96c";
252+ sha256 = "173h98m7namxj0kfy8fj29qcxmcz6ilg04x8mwkc3ydjqrvk77hh";
253+ postFetch = ''
254+ ( cd $out
255+ patch -p1 < ${nixpkgs.fetchpatch {
256+ url = "https://github.com/ghcjs/ghcjs-base/commit/2d0d674e54c273ed5fcb9a13f588819c3303a865.patch"; #ghcjs-base/114
257+ sha256 = "15vbxnxa1fpdcmmx5zx1z92bzsxyb0cbs3hs3g7fb1rkds5qbvgp";
258+ }}
259+ patch -p1 < ${nixpkgs.fetchpatch {
260+ url = "https://github.com/ghcjs/ghcjs-base/commit/8eccb8d937041ba323d62dea6fe8eb1b04b3cc47.patch"; #ghcjs-base/116
261+ sha256 = "1lqjpg46ydpm856wcq1g7c97d69qcnnqs5jxp2b788z9cfd5n64c";
262+ }}
263+ patch -p1 < ${nixpkgs.fetchpatch {
264+ url = "https://github.com/ghcjs/ghcjs-base/commit/ce91c525b5d4377ba4aefd0d8072dc1659f75ef1.patch"; #ghcjs-base/118
265+ sha256 = "0f6qca1i60cjzpbq4bc74baa7xrf417cja8nmhfims1fflvsx3wy";
266+ }}
267+ patch -p1 < ${nixpkgs.fetchpatch {
268+ url = "https://github.com/ghcjs/ghcjs-base/commit/213bfc74a051242668edf0533e11a3fafbbb1bfe.patch"; #ghcjs-base/120
269+ sha256 = "0d5dwy22hxa79l8b4y6nn53nbcs74686s0rmfr5l63sdvqxhdy3x";
270+ }}
271+ patch -p1 < ${nixpkgs.fetchpatch {
272+ url = "https://github.com/ghcjs/ghcjs-base/commit/82d76814ab40dc9116990f69f16df330462f27d4.patch"; #ghcjs-base/121
273+ sha256 = "0qa74h6w8770csad0bky4hhss1b1s86i6ccpd3ky4ljx00272gqh";
274+ }}
275+ patch -p1 < ${nixpkgs.fetchpatch {
276+ url = "https://github.com/ghcjs/ghcjs-base/commit/5eb34b3dfc6fc9196931178a7a6e2c8a331a8e53.patch"; #ghcjs-base/122
277+ sha256 = "1wrfi0rscy8qa9pi4siv54pq5alplmy56ym1fbs8n93xwlqhddii";
278+ }}
279+ patch -p1 < ${nixpkgs.fetchpatch {
280+ url = "https://github.com/ghcjs/ghcjs-base/commit/0cf64df77cdd6275d86ec6276fcf947fa58e548b.patch"; #ghcjs-base/122
281+ sha256 = "16wdghfsrzrb1y7lscbf9aawgxi3kvbgdjwvl1ga2zzm4mq139dr";
282+ }}
283+ cat ghcjs-base.cabal
284+ )
285+ '';
286+ };
287+ ghcjsBaseTextJSStringSrc = ghcjsBaseSrc.overrideAttrs (drv: {
288+ outputHash = "1ggfklrmawqh54ins98rpr7qy3zbcqaqp1w7qmh90mq5jf711x9r";
289+ postFetch = (drv.postFetch or "") + ''
290+ ( cd $out
291+ patch -p1 < ${./haskell-overlays/text-jsstring/ghcjs-base-text-jsstring.patch}
292+ )
293+ '';
294+ });
295+
296+ textSrc = fetchgit {
297+ url = "https://github.com/obsidiansystems/text.git";
298+ rev = "50076be0262203f0d2afdd0b190a341878a08e21";
299+ sha256 = "1vy7a81b1vcbfhv7l3m7p4hx365ss13mzbzkjn9751bn4n7x2ydd";
300+ };
301+ dlistSrc = fetchgit {
302+ url = "https://github.com/spl/dlist.git";
303+ rev = "03d91a3000cba49bd2c8588cf1b0d71e229ad3b0"; #v0.8.0.4
304+ sha256 = "0asvz1a2rp174r3vvgs1qaidxbdxly4mnlra33dipd0gxrrk15sq";
305+ };
306+ vectorSrc = fetchgit {
307+ url = "https://github.com/haskell/vector.git";
308+ rev = "1d208ee9e3a252941ebd112e14e8cd5a982ac2bb"; #v0.12.0.1
309+ sha256 = "18qm1c2zqr8h150917djfc0xk62hv99b1clxfs9a79aavrsqi5hs";
310+ postFetch = ''
311+ substituteInPlace $out/vector.cabal --replace 'base >= 4.5 && < 4.10' 'base >= 4.5 && < 5'
312+ '';
313+ };
314+
315+ ghcSavedSplices = ghcSavedSplices-8_4;
316+ ghcSavedSplices-8_4 = (makeRecursivelyOverridable nixpkgs.haskell.packages.integer-simple.ghcSplices-8_4).override {
317+ overrides = lib.foldr lib.composeExtensions (_: _: {}) (let
318+ haskellOverlays = nixpkgs.haskell.overlays;
319+ in [
320+ haskellOverlays.combined
321+ haskellOverlays.saveSplices
322+ (self: super: with haskellLib; {
323+ cryptonite = disableCabalFlag super.cryptonite "integer-gmp";
324+ integer-logarithms = disableCabalFlag super.integer-logarithms "integer-gmp";
325+ scientific = enableCabalFlag super.scientific "integer-simple";
326+ dependent-sum-template = dontCheck super.dependent-sum-template;
327+ generic-deriving = dontCheck super.generic-deriving;
328+ })
329+ ]);
330+ };
331+ ghcjs = if __useLegacyCompilers then ghcjs8_0 else ghcjs8_4;
332+ ghcjs8_4 = (makeRecursivelyOverridable (nixpkgs.haskell.packages.ghcjs84.override (old: {
333+ ghc = useTextJSStringAsBootPkg (ghcjsApplyFastWeak (old.ghc.override {
334+ ghcjsSrc = fetchgit {
335+ url = "https://github.com/obsidiansystems/ghcjs.git";
336+ rev = "584eaa138c32c5debb3aae571c4153d537ff58f1";
337+ sha256 = "1ib0vsv2wrwf5iivnq6jw2l9g5izs0fjpp80jrd71qyywx4xcm66";
338+ fetchSubmodules = true;
339+ };
340+ }));
341+ }))).override {
342+ overrides = nixpkgs.haskell.overlays.combined;
343+ };
344+ ghcjs8_2 = (makeRecursivelyOverridable (nixpkgs.haskell.packages.ghcjs82.override (old: {
345+ ghc = ghcjsApplyFastWeak (old.ghc.override {
346+ ghcjsDepOverrides = self: super: {
347+ haddock-library-ghcjs = haskellLib.doJailbreak super.haddock-library-ghcjs;
348+ };
349+ });
350+ }))).override {
351+ overrides = nixpkgs.haskell.overlays.combined;
352+ };
353+ ghcjs8_0 = (makeRecursivelyOverridable (nixpkgs.haskell.packages.ghcjs80.override (old: {
354+ ghc = (import "${nixpkgs.path}/pkgs/development/compilers/ghcjs/8.0" {
355+ bootPkgs = nixpkgs.haskell.packages.ghc802.override {
356+ overrides = self: super: {
357+ # Newer versions no longer export `(<>)`, because that is now
358+ # understand to be monoid/semigroup append.
359+ wl-pprint-text = haskellLib.doJailbreak (self.callHackage "wl-pprint-text" "1.1.1.0" {});
360+ # Old `wl-pprint-text` in turn doesn't expect `base-compat` to provide
361+ # a `(<>)`, since it is defining its own.
362+ base-compat = self.callHackage "base-compat" "0.9.3" {};
363+ # relax bounds for newer process
364+ concurrent-output = haskellLib.doJailbreak super.concurrent-output;
365+ # missing semigroups pkg
366+ ListLike = haskellLib.addBuildDepend super.ListLike self.semigroups;
367+ };
368+ };
369+ inherit (nixpkgs) cabal-install;
370+ inherit (nixpkgs.buildPackages) fetchgit fetchFromGitHub;
371+ }).override {
372+ ghcjsSrc = sources.ghcjs8_0.ghcjs;
373+ ghcjsBootSrc = sources.ghcjs8_0.boot;
374+ shims = sources.ghcjs8_0.shims;
375+ stage2 = import stage2Script;
376+ };
377+ }))).override {
378+ overrides = nixpkgs.haskell.overlays.combined;
379+ };
380+
381+ ghc = if __useLegacyCompilers then ghc8_0 else ghc8_4;
382+ ghcHEAD = (makeRecursivelyOverridable nixpkgs.haskell.packages.ghcHEAD).override {
383+ overrides = nixpkgs.haskell.overlays.combined;
384+ };
385+ ghc8_4 = (makeRecursivelyOverridable nixpkgs.haskell.packages.ghc843).override {
386+ overrides = nixpkgs.haskell.overlays.combined;
387+ };
388+ ghc8_2 = (makeRecursivelyOverridable nixpkgs.haskell.packages.ghc822).override {
389+ overrides = nixpkgs.haskell.overlays.combined;
390+ };
391+ ghc8_0 = (makeRecursivelyOverridable nixpkgs.haskell.packages.ghc802).override {
392+ overrides = nixpkgs.haskell.overlays.combined;
393+ };
394+ ghc7 = (makeRecursivelyOverridable nixpkgs.haskell.packages.ghc7103).override {
395+ overrides = nixpkgs.haskell.overlays.combined;
396+ };
397+
398+ # Takes a package set with `makeRecursivelyOverridable` and ensures that any
399+ # future overrides will be applied to both the package set itself and it's
400+ # build-time package set (`buildHaskellPackages`).
401+ makeRecursivelyOverridableBHPToo = x: x // {
402+ override = new: makeRecursivelyOverridableBHPToo (x.override
403+ (combineOverrides
404+ {
405+ overrides = self: super: {
406+ buildHaskellPackages = super.buildHaskellPackages.override new;
407+ };
408+ }
409+ new));
410+ };
411+
412+ ghcAndroidAarch64 = if __useLegacyCompilers then ghcAndroidAarch64-8_2 else ghcAndroidAarch64-8_4;
413+ ghcAndroidAarch64-8_4 = makeRecursivelyOverridableBHPToo ((makeRecursivelyOverridable nixpkgsCross.android.aarch64.haskell.packages.integer-simple.ghcSplices-8_4).override {
414+ overrides = nixpkgsCross.android.aarch64.haskell.overlays.combined;
415+ });
416+ ghcAndroidAarch64-8_2 = (makeRecursivelyOverridable nixpkgsCross.android.aarch64.haskell.packages.integer-simple.ghc822).override {
417+ overrides = nixpkgsCross.android.aarch64.haskell.overlays.combined;
418+ };
419+ ghcAndroidAarch32 = if __useLegacyCompilers then ghcAndroidAarch32-8_2 else ghcAndroidAarch32-8_4;
420+ ghcAndroidAarch32-8_4 = makeRecursivelyOverridableBHPToo ((makeRecursivelyOverridable nixpkgsCross.android.aarch32.haskell.packages.integer-simple.ghcSplices-8_4).override {
421+ overrides = nixpkgsCross.android.aarch32.haskell.overlays.combined;
422+ });
423+ ghcAndroidAarch32-8_2 = (makeRecursivelyOverridable nixpkgsCross.android.aarch32.haskell.packages.integer-simple.ghc822).override {
424+ overrides = nixpkgsCross.android.aarch32.haskell.overlays.combined;
425+ };
426+
427+ ghcIosSimulator64 = if __useLegacyCompilers then ghcIosSimulator64-8_2 else ghcIosSimulator64-8_4;
428+ ghcIosSimulator64-8_4 = makeRecursivelyOverridableBHPToo ((makeRecursivelyOverridable nixpkgsCross.ios.simulator64.haskell.packages.integer-simple.ghcSplices-8_4).override {
429+ overrides = nixpkgsCross.ios.simulator64.haskell.overlays.combined;
430+ });
431+ ghcIosSimulator64-8_2 = (makeRecursivelyOverridable nixpkgsCross.ios.simulator64.haskell.packages.integer-simple.ghc822).override {
432+ overrides = nixpkgsCross.ios.simulator64.haskell.overlays.combined;
433+ };
434+ ghcIosAarch64 = if __useLegacyCompilers then ghcIosAarch64-8_2 else ghcIosAarch64-8_4;
435+ ghcIosAarch64-8_4 = makeRecursivelyOverridableBHPToo ((makeRecursivelyOverridable nixpkgsCross.ios.aarch64.haskell.packages.integer-simple.ghcSplices-8_4).override {
436+ overrides = nixpkgsCross.ios.aarch64.haskell.overlays.combined;
437+ });
438+ ghcIosAarch64-8_2 = (makeRecursivelyOverridable nixpkgsCross.ios.aarch64.haskell.packages.integer-simple.ghc822).override {
439+ overrides = nixpkgsCross.ios.aarch64.haskell.overlays.combined;
440+ };
441+ ghcIosAarch32 = if __useLegacyCompilers then ghcIosAarch32-8_2 else ghcIosAarch32-8_4;
442+ ghcIosAarch32-8_4 = makeRecursivelyOverridableBHPToo ((makeRecursivelyOverridable nixpkgsCross.ios.aarch32.haskell.packages.integer-simple.ghcSplices-8_4).override {
443+ overrides = nixpkgsCross.ios.aarch32.haskell.overlays.combined;
444+ });
445+ ghcIosAarch32-8_2 = (makeRecursivelyOverridable nixpkgsCross.ios.aarch32.haskell.packages.integer-simple.ghc822).override {
446+ overrides = nixpkgsCross.ios.aarch32.haskell.overlays.combined;
447+ };
448+
449+ #TODO: Separate debug and release APKs
450+ #TODO: Warn the user that the android app name can't include dashes
451+ android = androidWithHaskellPackages {
452+ inherit ghcAndroidAarch64 ghcAndroidAarch32;
453+ };
454+ android-8_4 = androidWithHaskellPackages {
455+ ghcAndroidAarch64 = ghcAndroidAarch64-8_4;
456+ ghcAndroidAarch32 = ghcAndroidAarch32-8_4;
457+ };
458+ android-8_2 = androidWithHaskellPackages {
459+ ghcAndroidAarch64 = ghcAndroidAarch64-8_2;
460+ ghcAndroidAarch32 = ghcAndroidAarch32-8_2;
461+ };
462+ androidWithHaskellPackages = { ghcAndroidAarch64, ghcAndroidAarch32 }: import ./android {
463+ inherit nixpkgs nixpkgsCross ghcAndroidAarch64 ghcAndroidAarch32 overrideCabal;
464+ };
465+ iosAarch64 = iosWithHaskellPackages ghcIosAarch64;
466+ iosAarch64-8_4 = iosWithHaskellPackages ghcIosAarch64-8_4;
467+ iosAarch64-8_2 = iosWithHaskellPackages ghcIosAarch64-8_2;
468+ iosAarch32 = iosWithHaskellPackages ghcIosAarch32;
469+ iosAarch32-8_4 = iosWithHaskellPackages ghcIosAarch32-8_4;
470+ iosAarch32-8_2 = iosWithHaskellPackages ghcIosAarch32-8_2;
471+ iosWithHaskellPackages = ghc: {
472+ buildApp = import ./ios { inherit nixpkgs ghc; };
473+ };
474+
475+in let this = rec {
476+ inherit nixpkgs
477+ nixpkgsCross
478+ overrideCabal
479+ hackGet
480+ foreignLibSmuggleHeaders
481+ stage2Script
482+ ghc
483+ ghcHEAD
484+ ghc8_4
485+ ghc8_2
486+ ghc8_0
487+ ghc7
488+ ghcIosSimulator64
489+ ghcIosAarch64
490+ ghcIosAarch64-8_4
491+ ghcIosAarch64-8_2
492+ ghcIosAarch32
493+ ghcIosAarch32-8_4
494+ ghcIosAarch32-8_2
495+ ghcAndroidAarch64
496+ ghcAndroidAarch64-8_4
497+ ghcAndroidAarch64-8_2
498+ ghcAndroidAarch32
499+ ghcAndroidAarch32-8_4
500+ ghcAndroidAarch32-8_2
501+ ghcjs
502+ ghcjs8_0
503+ ghcjs8_2
504+ ghcjs8_4
505+ ghcSavedSplices
506+ android
507+ androidWithHaskellPackages
508+ iosAarch32
509+ iosAarch64
510+ iosWithHaskellPackages
511+ filterGit;
512+
513+ # Back compat
514+ ios = iosAarch64;
515+ ghcAndroidArm64 = lib.warn "ghcAndroidArm64 has been deprecated, using ghcAndroidAarch64 instead." ghcAndroidAarch64;
516+ ghcAndroidArmv7a = lib.warn "ghcAndroidArmv7a has been deprecated, using ghcAndroidAarch32 instead." ghcAndroidAarch32;
517+ ghcIosArm64 = lib.warn "ghcIosArm64 has been deprecated, using ghcIosAarch64 instead." ghcIosAarch64;
518+
519+ androidReflexTodomvc = android.buildApp {
520+ package = p: p.reflex-todomvc;
521+ executableName = "reflex-todomvc";
522+ applicationId = "org.reflexfrp.todomvc";
523+ displayName = "Reflex TodoMVC";
524+ };
525+ androidReflexTodomvc-8_4 = android-8_4.buildApp {
526+ package = p: p.reflex-todomvc;
527+ executableName = "reflex-todomvc";
528+ applicationId = "org.reflexfrp.todomvc.via_8_4";
529+ displayName = "Reflex TodoMVC via GHC 8.4";
530+ };
531+ androidReflexTodomvc-8_2 = android-8_2.buildApp {
532+ package = p: p.reflex-todomvc;
533+ executableName = "reflex-todomvc";
534+ applicationId = "org.reflexfrp.todomvc.via_8_2";
535+ displayName = "Reflex TodoMVC via GHC 8.2";
536+ };
537+ iosReflexTodomvc = ios.buildApp {
538+ package = p: p.reflex-todomvc;
539+ executableName = "reflex-todomvc";
540+ bundleIdentifier = "org.reflexfrp.todomvc";
541+ bundleName = "Reflex TodoMVC";
542+ };
543+ iosReflexTodomvc-8_4 = iosAarch64-8_4.buildApp {
544+ package = p: p.reflex-todomvc;
545+ executableName = "reflex-todomvc";
546+ bundleIdentifier = "org.reflexfrp.todomvc.via_8_4";
547+ bundleName = "Reflex TodoMVC via GHC 8.4";
548+ };
549+ iosReflexTodomvc-8_2 = iosAarch64-8_2.buildApp {
550+ package = p: p.reflex-todomvc;
551+ executableName = "reflex-todomvc";
552+ bundleIdentifier = "org.reflexfrp.todomvc.via_8_2";
553+ bundleName = "Reflex TodoMVC via GHC 8.2";
554+ };
555+ setGhcLibdir = ghcLibdir: inputGhcjs:
556+ let libDir = "$out/lib/ghcjs-${inputGhcjs.version}";
557+ ghcLibdirLink = nixpkgs.stdenv.mkDerivation {
558+ name = "ghc_libdir";
559+ inherit ghcLibdir;
560+ buildCommand = ''
561+ mkdir -p ${libDir}
562+ echo "$ghcLibdir" > ${libDir}/ghc_libdir_override
563+ '';
564+ };
565+ in inputGhcjs // {
566+ outPath = nixpkgs.buildEnv {
567+ inherit (inputGhcjs) name;
568+ paths = [ inputGhcjs ghcLibdirLink ];
569+ postBuild = ''
570+ mv ${libDir}/ghc_libdir_override ${libDir}/ghc_libdir
571+ '';
572+ };
573+ };
574+
575+ platforms = [
576+ "ghcjs"
577+ "ghc"
578+ ];
579+
580+ attrsToList = s: map (name: { inherit name; value = builtins.getAttr name s; }) (builtins.attrNames s);
581+ mapSet = f: s: builtins.listToAttrs (map ({name, value}: {
582+ inherit name;
583+ value = f value;
584+ }) (attrsToList s));
585+ mkSdist = pkg: pkg.override (oldArgs: {
586+ mkDerivation = drv: oldArgs.mkDerivation (drv // {
587+ postConfigure = ''
588+ ./Setup sdist
589+ mkdir "$out"
590+ mv dist/*.tar.gz "$out/${drv.pname}-${drv.version}.tar.gz"
591+ exit 0
592+ '';
593+ doHaddock = false;
594+ });
595+ });
596+ sdists = mapSet mkSdist ghc;
597+ mkHackageDocs = pkg: pkg.override (oldArgs: {
598+ mkDerivation = drv: oldArgs.mkDerivation (drv // {
599+ postConfigure = ''
600+ ./Setup haddock --hoogle --hyperlink-source --html --for-hackage --haddock-option=--built-in-themes
601+ cd dist/doc/html
602+ mkdir "$out"
603+ tar cz --format=ustar -f "$out/${drv.pname}-${drv.version}-docs.tar.gz" "${drv.pname}-${drv.version}-docs"
604+ exit 0
605+ '';
606+ doHaddock = false;
607+ });
608+ });
609+ hackageDocs = mapSet mkHackageDocs ghc;
610+ mkReleaseCandidate = pkg: nixpkgs.stdenv.mkDerivation (rec {
611+ name = pkg.name + "-rc";
612+ sdist = mkSdist pkg + "/${pkg.pname}-${pkg.version}.tar.gz";
613+ docs = mkHackageDocs pkg + "/${pkg.pname}-${pkg.version}-docs.tar.gz";
614+
615+ builder = builtins.toFile "builder.sh" ''
616+ source $stdenv/setup
617+
618+ mkdir "$out"
619+ echo -n "${pkg.pname}-${pkg.version}" >"$out/pkgname"
620+ ln -s "$sdist" "$docs" "$out"
621+ '';
622+
623+ # 'checked' isn't used, but it is here so that the build will fail
624+ # if tests fail
625+ checked = overrideCabal pkg (drv: {
626+ doCheck = true;
627+ src = sdist;
628+ });
629+ });
630+ releaseCandidates = mapSet mkReleaseCandidate ghc;
631+
632+ androidDevTools = [
633+ ghc.haven
634+ nixpkgs.maven
635+ nixpkgs.androidsdk
636+ ];
637+
638+ # Tools that are useful for development under both ghc and ghcjs
639+ generalDevToolsAttrs = haskellPackages:
640+ let nativeHaskellPackages = ghc;
641+ in {
642+ inherit (nativeHaskellPackages)
643+ Cabal
644+ cabal-install
645+ ghcid
646+ hasktags
647+ hlint;
648+ inherit (nixpkgs)
649+ cabal2nix
650+ curl
651+ nix-prefetch-scripts
652+ nodejs
653+ pkgconfig
654+ closurecompiler;
655+ } // (lib.optionalAttrs (!(haskellPackages.ghc.isGhcjs or false) && builtins.compareVersions haskellPackages.ghc.version "8.2" < 0) {
656+ # ghc-mod doesn't currently work on ghc 8.2.2; revisit when https://github.com/DanielG/ghc-mod/pull/911 is closed
657+ # When ghc-mod is included in the environment without being wrapped in justStaticExecutables, it prevents ghc-pkg from seeing the libraries we install
658+ ghc-mod = (nixpkgs.haskell.lib.justStaticExecutables haskellPackages.ghc-mod);
659+ inherit (haskellPackages) hdevtools;
660+ }) // (lib.optionalAttrs (builtins.compareVersions haskellPackages.ghc.version "7.10" >= 0) {
661+ inherit (nativeHaskellPackages) stylish-haskell; # Recent stylish-haskell only builds with AMP in place
662+ });
663+
664+ generalDevTools = haskellPackages: builtins.attrValues (generalDevToolsAttrs haskellPackages);
665+
666+ nativeHaskellPackages = haskellPackages:
667+ if haskellPackages.isGhcjs or false
668+ then haskellPackages.ghc
669+ else haskellPackages;
670+
671+ workOn = haskellPackages: package: (overrideCabal package (drv: {
672+ buildDepends = (drv.buildDepends or []) ++ generalDevTools (nativeHaskellPackages haskellPackages);
673+ })).env;
674+
675+ workOnMulti' = { env, packageNames, tools ? _: [], shellToolOverrides ? _: _: {} }:
676+ let inherit (builtins) listToAttrs filter attrValues all concatLists;
677+ combinableAttrs = [
678+ "benchmarkDepends"
679+ "benchmarkFrameworkDepends"
680+ "benchmarkHaskellDepends"
681+ "benchmarkPkgconfigDepends"
682+ "benchmarkSystemDepends"
683+ "benchmarkToolDepends"
684+ "buildDepends"
685+ "buildTools"
686+ "executableFrameworkDepends"
687+ "executableHaskellDepends"
688+ "executablePkgconfigDepends"
689+ "executableSystemDepends"
690+ "executableToolDepends"
691+ "extraLibraries"
692+ "libraryFrameworkDepends"
693+ "libraryHaskellDepends"
694+ "libraryPkgconfigDepends"
695+ "librarySystemDepends"
696+ "libraryToolDepends"
697+ "pkgconfigDepends"
698+ "setupHaskellDepends"
699+ "testDepends"
700+ "testFrameworkDepends"
701+ "testHaskellDepends"
702+ "testPkgconfigDepends"
703+ "testSystemDepends"
704+ "testToolDepends"
705+ ];
706+ concatCombinableAttrs = haskellConfigs: lib.filterAttrs (n: v: v != []) (lib.listToAttrs (map (name: { inherit name; value = concatLists (map (haskellConfig: haskellConfig.${name} or []) haskellConfigs); }) combinableAttrs));
707+ getHaskellConfig = p: (overrideCabal p (args: {
708+ passthru = (args.passthru or {}) // {
709+ out = args;
710+ };
711+ })).out;
712+ notInTargetPackageSet = p: all (pname: (p.pname or "") != pname) packageNames;
713+ baseTools = generalDevToolsAttrs env;
714+ overriddenTools = attrValues (baseTools // shellToolOverrides env baseTools);
715+ depAttrs = lib.mapAttrs (_: v: filter notInTargetPackageSet v) (concatCombinableAttrs (concatLists [
716+ (map getHaskellConfig (lib.attrVals packageNames env))
717+ [{
718+ buildTools = overriddenTools ++ tools env;
719+ }]
720+ ]));
721+
722+ in (env.mkDerivation (depAttrs // {
723+ pname = "work-on-multi--combined-pkg";
724+ version = "0";
725+ license = null;
726+ })).env;
727+
728+ workOnMulti = env: packageNames: workOnMulti' { inherit env packageNames; };
729+
730+ # A simple derivation that just creates a file with the names of all
731+ # of its inputs. If built, it will have a runtime dependency on all
732+ # of the given build inputs.
733+ pinBuildInputs = name: buildInputs: otherDeps: (nixpkgs.releaseTools.aggregate {
734+ inherit name;
735+ constituents = buildInputs ++ otherDeps;
736+ }).overrideAttrs (old: {
737+ buildCommand = old.buildCommand + ''
738+ echo "$propagatedBuildInputs $buildInputs $nativeBuildInputs $propagatedNativeBuildInputs $otherDeps" > "$out/deps"
739+ '';
740+ inherit buildInputs otherDeps;
741+ });
742+
743+ # The systems that we want to build for on the current system
744+ cacheTargetSystems = lib.warn "cacheTargetSystems has been deprecated, use cacheBuildSystems" cacheBuildSystems;
745+ cacheBuildSystems = [
746+ "x86_64-linux"
747+ # "i686-linux"
748+ "x86_64-darwin"
749+ ];
750+
751+ isSuffixOf = suffix: s:
752+ let suffixLen = builtins.stringLength suffix;
753+ in builtins.substring (builtins.stringLength s - suffixLen) suffixLen s == suffix;
754+
755+ reflexEnv = platform:
756+ let haskellPackages = builtins.getAttr platform this;
757+ ghcWithStuff = if platform == "ghc" || platform == "ghcjs"
758+ then haskellPackages.ghcWithHoogle
759+ else haskellPackages.ghcWithPackages;
760+ in ghcWithStuff (p: import ./packages.nix {
761+ haskellPackages = p;
762+ inherit platform;
763+ });
764+
765+ tryReflexPackages = generalDevTools ghc
766+ ++ builtins.map reflexEnv platforms;
767+
768+ cachePackages =
769+ let otherPlatforms = lib.optionals androidSupport [
770+ "ghcAndroidAarch64"
771+ "ghcAndroidAarch32"
772+ ] ++ lib.optional iosSupport "ghcIosAarch64";
773+ in tryReflexPackages
774+ ++ builtins.map reflexEnv otherPlatforms
775+ ++ lib.optionals androidSupport [
776+ androidDevTools
777+ androidReflexTodomvc
778+ ] ++ lib.optionals iosSupport [
779+ iosReflexTodomvc
780+ ];
781+
782+ demoVM = (import "${nixpkgs.path}/nixos" {
783+ configuration = {
784+ imports = [
785+ "${nixpkgs.path}/nixos/modules/virtualisation/virtualbox-image.nix"
786+ "${nixpkgs.path}/nixos/modules/profiles/demo.nix"
787+ ];
788+ environment.systemPackages = tryReflexPackages;
789+ nixpkgs = { localSystem.system = "x86_64-linux"; };
790+ };
791+ }).config.system.build.virtualBoxOVA;
792+
793+ inherit cabal2nixResult sources system androidSupport iosSupport;
794+ project = args: import ./project this (args ({ pkgs = nixpkgs; } // this));
795+ tryReflexShell = pinBuildInputs ("shell-" + system) tryReflexPackages [];
796+ js-framework-benchmark-src = hackGet ./js-framework-benchmark;
797+ ghcjsExternsJs = ./ghcjs.externs.js;
798+}; in this