Revert "Merge branch 'improved-make-overridable' of git://github.com/ElvishJerricco/nixpkgs"

This reverts commit c3af1210b4, reversing
changes made to 49f175cd0c.

pkgs/development/beam-modules/default.nix

@@ -5,9 +5,14 @@ let
 
   lib = pkgs.callPackage ./lib.nix {};
 
+  # FIXME: add support for overrideScope
+  callPackageWithScope = scope: drv: args: stdenv.lib.callPackageWith scope drv args;
+  mkScope = scope: pkgs // scope;
+
   packages = self:
     let
-      callPackage = stdenv.lib.callPackageWith (pkgs // self);
+      defaultScope = mkScope self;
+      callPackage = drv: args: callPackageWithScope defaultScope drv args;
     in
       import ./hex-packages.nix {
         inherit pkgs stdenv callPackage;

pkgs/development/haskell-modules/default.nix

@@ -7,8 +7,6 @@
 , configurationNix ? import ./configuration-nix.nix
 }:
 
-self: # Provided by `callPackageWithOutput`
-
 let
 
   inherit (lib) extends makeExtensible;
@@ -16,15 +14,19 @@ let
 
   haskellPackages = pkgs.callPackage makePackageSet {
     package-set = initialPackages;
-    extensible-self = self;
-    inherit stdenv haskellLib ghc;
+    inherit stdenv haskellLib ghc extensible-self;
   };
 
   commonConfiguration = configurationCommon { inherit pkgs haskellLib; };
   nixConfiguration = configurationNix { inherit pkgs haskellLib; };
 
-in (extends overrides
-     (extends packageSetConfig
-       (extends compilerConfig
-         (extends commonConfiguration
-           (extends nixConfiguration haskellPackages))))) self
+  extensible-self = makeExtensible
+    (extends overrides
+      (extends packageSetConfig
+        (extends compilerConfig
+          (extends commonConfiguration
+            (extends nixConfiguration haskellPackages)))));
+
+in
+
+  extensible-self

pkgs/development/haskell-modules/make-package-set.nix

@@ -29,7 +29,7 @@ self:
 
 let
 
-  inherit (stdenv.lib) fix' extends makeOverridable callPackageWith;
+  inherit (stdenv.lib) fix' extends makeOverridable;
   inherit (haskellLib) overrideCabal;
 
   mkDerivationImpl = pkgs.callPackage ./generic-builder.nix {
@@ -61,9 +61,39 @@ let
 
   mkDerivation = makeOverridable mkDerivationImpl;
 
+  # manualArgs are the arguments that were explictly passed to `callPackage`, like:
+  #
+  # callPackage foo { bar = null; };
+  #
+  # here `bar` is a manual argument.
+  callPackageWithScope = scope: fn: manualArgs:
+    let
+      # this code is copied from callPackage in lib/customisation.nix
+      #
+      # we cannot use `callPackage` here because we want to call `makeOverridable`
+      # on `drvScope` (we cannot add `overrideScope` after calling `callPackage` because then it is
+      # lost on `.override`) but determine the auto-args based on `drv` (the problem here
+      # is that nix has no way to "passthrough" args while preserving the reflection
+      # info that callPackage uses to determine the arguments).
+      drv = if builtins.isFunction fn then fn else import fn;
+      auto = builtins.intersectAttrs (builtins.functionArgs drv) scope;
+
+      # this wraps the `drv` function to add a `overrideScope` function to the result.
+      drvScope = allArgs: drv allArgs // {
+        overrideScope = f:
+          let newScope = mkScope (fix' (extends f scope.__unfix__));
+          # note that we have to be careful here: `allArgs` includes the auto-arguments that
+          # weren't manually specified. If we would just pass `allArgs` to the recursive call here,
+          # then we wouldn't look up any packages in the scope in the next interation, because it
+          # appears as if all arguments were already manually passed, so the scope change would do
+          # nothing.
+          in callPackageWithScope newScope drv manualArgs;
+      };
+    in stdenv.lib.makeOverridable drvScope (auto // manualArgs);
+
   mkScope = scope: pkgs // pkgs.xorg // pkgs.gnome2 // { inherit stdenv; } // scope;
   defaultScope = mkScope self;
-  callPackage = drv: args: callPackageWith defaultScope drv args;
+  callPackage = drv: args: callPackageWithScope defaultScope drv args;
 
   withPackages = packages: callPackage ./with-packages-wrapper.nix {
     inherit (self) llvmPackages;

pkgs/development/idris-modules/default.nix

@@ -1,8 +1,17 @@
 { pkgs, idris, overrides ? (self: super: {}) }: let
   inherit (pkgs.lib) callPackageWith fix' extends;
 
+  /* Taken from haskell-modules/default.nix, should probably abstract this away */
+  callPackageWithScope = scope: drv: args: (callPackageWith scope drv args) // {
+    overrideScope = f: callPackageWithScope (mkScope (fix' (extends f scope.__unfix__))) drv args;
+  };
+
+  mkScope = scope : pkgs // pkgs.xorg // pkgs.gnome2 // scope;
+
   idrisPackages = self: let
-    callPackage = callPackageWith (pkgs // pkgs.xorg // pkgs.gnome2 // self);
+    defaultScope = mkScope self;
+
+    callPackage = callPackageWithScope defaultScope;
 
     builtins_ = pkgs.lib.mapAttrs self.build-builtin-package {
       prelude = [];