pyrox.dev / nixpkgs
lol
fork atom

lib: Use Nix's static scope checking, fix error message, optimize

Nix can perform static scope checking, but whenever code is inside
a `with` expression, the analysis breaks down, because it can't
know statically what's in the attribute set whose attributes were
brought into scope. In those cases, Nix has to assume that
everything works out.

Except it doesnt. Removing `with` from lib/ revealed an undefined
variable in an error message.

If that doesn't convince you that we're better off without `with`,
I can tell you that this PR results in a 3% evaluation performance
improvement because Nix can look up local variables by index.
This adds up with applications like the module system.

Furthermore, removing `with` makes the binding site of each
variable obvious, which helps with comprehension.

Robert Hensing afa6c51f 5aa2a98d

options
unified split
Changed files
+238 -82
lib
debug.nix
default.nix
lists.nix
modules.nix
options.nix
sources.nix
strings-with-deps.nix
strings.nix
types.nix
+24 -8
lib/debug.nix 
···

       
14

       
 

       
*/


     

       
15

       
 

       
{ lib }:


     

       
16

       
 

       
let


     

       
17

       
-

       
  inherit (builtins) trace isAttrs isList isInt


     

       
18

       
-

       
          head substring attrNames;


     

       
19

       
-

       
  inherit (lib) id elem isFunction;


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
20

       
 

       
in


     

       
21

       
 

       



     

       
22

       
 

       
rec {


     
···

       
94

       
 

       
       trace: { a = { b = {…}; }; }


     

       
95

       
 

       
       => null


     

       
96

       
 

       
   */


     

       
97

       
-

       
  traceSeqN = depth: x: y: with lib;


     

       
98

       
 

       
    let snip = v: if      isList  v then noQuotes "[…]" v


     

       
99

       
 

       
                  else if isAttrs v then noQuotes "{…}" v


     

       
100

       
 

       
                  else v;


     
···

       
149

       
 

       
  */


     

       
150

       
 

       
  runTests =


     

       
151

       
 

       
    # Tests to run


     

       
152

       
-

       
    tests: lib.concatLists (lib.attrValues (lib.mapAttrs (name: test:


     

       
153

       
 

       
    let testsToRun = if tests ? tests then tests.tests else [];


     

       
154

       
 

       
    in if (substring 0 4 name == "test" ||  elem name testsToRun)


     

       
155

       
 

       
       && ((testsToRun == []) || elem name tests.tests)


     
···

       
176

       
 

       
          + "and will be removed in the next release. "


     

       
177

       
 

       
          + "Please use more specific concatenation "


     

       
178

       
 

       
          + "for your uses (`lib.concat(Map)StringsSep`)." )


     

       
179

       
-

       
    (lib.concatStringsSep "; " (map (x: "${x}=") (attrNames a)));


     

       
180

       
 

       



     

       
181

       
-

       
  showVal = with lib;


     

       
182

       
 

       
    trace ( "Warning: `showVal` is deprecated "


     

       
183

       
 

       
          + "and will be removed in the next release, "


     

       
184

       
 

       
          + "please use `traceSeqN`" )


     
···

       
226

       
 

       
    trace ( "Warning: `addErrorContextToAttrs` is deprecated "


     

       
227

       
 

       
          + "and will be removed in the next release. "


     

       
228

       
 

       
          + "Please use `builtins.addErrorContext` directly." )


     

       
229

       
-

       
    (lib.mapAttrs (a: v: lib.addErrorContext "while evaluating ${a}" v) attrs);


     

       
230

       
 

       



     

       
231

       
 

       
  # example: (traceCallXml "myfun" id 3) will output something like


     

       
232

       
 

       
  # calling myfun arg 1: 3 result: 3


     
···

       
14

       
 

       
*/


     

       
15

       
 

       
{ lib }:


     

       
16

       
 

       
let


     

       
17

       
+

       
  inherit (lib)


     

       
18

       
+

       
    isInt


     

       
19

       
+

       
    attrNames


     

       
20

       
+

       
    isList


     

       
21

       
+

       
    isAttrs


     

       
22

       
+

       
    substring


     

       
23

       
+

       
    addErrorContext


     

       
24

       
+

       
    attrValues


     

       
25

       
+

       
    concatLists


     

       
26

       
+

       
    concatStringsSep


     

       
27

       
+

       
    const


     

       
28

       
+

       
    elem


     

       
29

       
+

       
    generators


     

       
30

       
+

       
    head


     

       
31

       
+

       
    id


     

       
32

       
+

       
    isDerivation


     

       
33

       
+

       
    isFunction


     

       
34

       
+

       
    mapAttrs


     

       
35

       
+

       
    trace;


     

       
36

       
 

       
in


     

       
37

       
 

       



     

       
38

       
 

       
rec {


     
···

       
110

       
 

       
       trace: { a = { b = {…}; }; }


     

       
111

       
 

       
       => null


     

       
112

       
 

       
   */


     

       
113

       
+

       
  traceSeqN = depth: x: y:


     

       
114

       
 

       
    let snip = v: if      isList  v then noQuotes "[…]" v


     

       
115

       
 

       
                  else if isAttrs v then noQuotes "{…}" v


     

       
116

       
 

       
                  else v;


     
···

       
165

       
 

       
  */


     

       
166

       
 

       
  runTests =


     

       
167

       
 

       
    # Tests to run


     

       
168

       
+

       
    tests: concatLists (attrValues (mapAttrs (name: test:


     

       
169

       
 

       
    let testsToRun = if tests ? tests then tests.tests else [];


     

       
170

       
 

       
    in if (substring 0 4 name == "test" ||  elem name testsToRun)


     

       
171

       
 

       
       && ((testsToRun == []) || elem name tests.tests)


     
···

       
192

       
 

       
          + "and will be removed in the next release. "


     

       
193

       
 

       
          + "Please use more specific concatenation "


     

       
194

       
 

       
          + "for your uses (`lib.concat(Map)StringsSep`)." )


     

       
195

       
+

       
    (concatStringsSep "; " (map (x: "${x}=") (attrNames a)));


     

       
196

       
 

       



     

       
197

       
+

       
  showVal =


     

       
198

       
 

       
    trace ( "Warning: `showVal` is deprecated "


     

       
199

       
 

       
          + "and will be removed in the next release, "


     

       
200

       
 

       
          + "please use `traceSeqN`" )


     
···

       
242

       
 

       
    trace ( "Warning: `addErrorContextToAttrs` is deprecated "


     

       
243

       
 

       
          + "and will be removed in the next release. "


     

       
244

       
 

       
          + "Please use `builtins.addErrorContext` directly." )


     

       
245

       
+

       
    (mapAttrs (a: v: addErrorContext "while evaluating ${a}" v) attrs);


     

       
246

       
 

       



     

       
247

       
 

       
  # example: (traceCallXml "myfun" id 3) will output something like


     

       
248

       
 

       
  # calling myfun arg 1: 3 result: 3
+18 -18
lib/default.nix 
···

       
9

       
 

       



     

       
10

       
 

       
  lib = makeExtensible (self: let


     

       
11

       
 

       
    callLibs = file: import file { lib = self; };


     

       
12

       
-

       
  in with self; {


     

       
13

       
 

       



     

       
14

       
 

       
    # often used, or depending on very little


     

       
15

       
 

       
    trivial = callLibs ./trivial.nix;


     
···

       
54

       
 

       
    filesystem = callLibs ./filesystem.nix;


     

       
55

       
 

       



     

       
56

       
 

       
    # back-compat aliases


     

       
57

       
-

       
    platforms = systems.doubles;


     

       
58

       
 

       



     

       
59

       
 

       
    # linux kernel configuration


     

       
60

       
 

       
    kernel = callLibs ./kernel.nix;


     
···

       
64

       
 

       
      hasAttr head isAttrs isBool isInt isList isString length


     

       
65

       
 

       
      lessThan listToAttrs pathExists readFile replaceStrings seq


     

       
66

       
 

       
      stringLength sub substring tail;


     

       
67

       
-

       
    inherit (trivial) id const pipe concat or and bitAnd bitOr bitXor


     

       
68

       
 

       
      bitNot boolToString mergeAttrs flip mapNullable inNixShell min max


     

       
69

       
 

       
      importJSON importTOML warn info showWarnings nixpkgsVersion version mod compare


     

       
70

       
 

       
      splitByAndCompare functionArgs setFunctionArgs isFunction toHexString toBaseDigits;


     

       
71

       
-

       
    inherit (fixedPoints) fix fix' converge extends composeExtensions


     

       
72

       
 

       
      makeExtensible makeExtensibleWithCustomName;


     

       
73

       
-

       
    inherit (attrsets) attrByPath hasAttrByPath setAttrByPath


     

       
74

       
 

       
      getAttrFromPath attrVals attrValues getAttrs catAttrs filterAttrs


     

       
75

       
 

       
      filterAttrsRecursive foldAttrs collect nameValuePair mapAttrs


     

       
76

       
 

       
      mapAttrs' mapAttrsToList mapAttrsRecursive mapAttrsRecursiveCond


     
···

       
79

       
 

       
      recursiveUpdate matchAttrs overrideExisting getOutput getBin


     

       
80

       
 

       
      getLib getDev getMan chooseDevOutputs zipWithNames zip


     

       
81

       
 

       
      recurseIntoAttrs dontRecurseIntoAttrs;


     

       
82

       
-

       
    inherit (lists) singleton forEach foldr fold foldl foldl' imap0 imap1


     

       
83

       
 

       
      concatMap flatten remove findSingle findFirst any all count


     

       
84

       
 

       
      optional optionals toList range partition zipListsWith zipLists


     

       
85

       
 

       
      reverseList listDfs toposort sort naturalSort compareLists take


     

       
86

       
 

       
      drop sublist last init crossLists unique intersectLists


     

       
87

       
 

       
      subtractLists mutuallyExclusive groupBy groupBy';


     

       
88

       
-

       
    inherit (strings) concatStrings concatMapStrings concatImapStrings


     

       
89

       
 

       
      intersperse concatStringsSep concatMapStringsSep


     

       
90

       
 

       
      concatImapStringsSep makeSearchPath makeSearchPathOutput


     

       
91

       
 

       
      makeLibraryPath makeBinPath optionalString


     
···

       
97

       
 

       
      nameFromURL enableFeature enableFeatureAs withFeature


     

       
98

       
 

       
      withFeatureAs fixedWidthString fixedWidthNumber isStorePath


     

       
99

       
 

       
      toInt readPathsFromFile fileContents;


     

       
100

       
-

       
    inherit (stringsWithDeps) textClosureList textClosureMap


     

       
101

       
 

       
      noDepEntry fullDepEntry packEntry stringAfter;


     

       
102

       
-

       
    inherit (customisation) overrideDerivation makeOverridable


     

       
103

       
 

       
      callPackageWith callPackagesWith extendDerivation hydraJob


     

       
104

       
 

       
      makeScope;


     

       
105

       
-

       
    inherit (meta) addMetaAttrs dontDistribute setName updateName


     

       
106

       
 

       
      appendToName mapDerivationAttrset setPrio lowPrio lowPrioSet hiPrio


     

       
107

       
 

       
      hiPrioSet;


     

       
108

       
-

       
    inherit (sources) pathType pathIsDirectory cleanSourceFilter


     

       
109

       
 

       
      cleanSource sourceByRegex sourceFilesBySuffices


     

       
110

       
 

       
      commitIdFromGitRepo cleanSourceWith pathHasContext


     

       
111

       
 

       
      canCleanSource pathIsRegularFile pathIsGitRepo;


     

       
112

       
-

       
    inherit (modules) evalModules unifyModuleSyntax


     

       
113

       
 

       
      applyIfFunction mergeModules


     

       
114

       
 

       
      mergeModules' mergeOptionDecls evalOptionValue mergeDefinitions


     

       
115

       
 

       
      pushDownProperties dischargeProperties filterOverrides


     
···

       
119

       
 

       
      mkAliasAndWrapDefinitions fixMergeModules mkRemovedOptionModule


     

       
120

       
 

       
      mkRenamedOptionModule mkMergedOptionModule mkChangedOptionModule


     

       
121

       
 

       
      mkAliasOptionModule doRename;


     

       
122

       
-

       
    inherit (options) isOption mkEnableOption mkSinkUndeclaredOptions


     

       
123

       
 

       
      mergeDefaultOption mergeOneOption mergeEqualOption getValues


     

       
124

       
 

       
      getFiles optionAttrSetToDocList optionAttrSetToDocList'


     

       
125

       
 

       
      scrubOptionValue literalExample showOption showFiles


     

       
126

       
 

       
      unknownModule mkOption;


     

       
127

       
-

       
    inherit (types) isType setType defaultTypeMerge defaultFunctor


     

       
128

       
 

       
      isOptionType mkOptionType;


     

       
129

       
-

       
    inherit (asserts)


     

       
130

       
 

       
      assertMsg assertOneOf;


     

       
131

       
-

       
    inherit (debug) addErrorContextToAttrs traceIf traceVal traceValFn


     

       
132

       
 

       
      traceXMLVal traceXMLValMarked traceSeq traceSeqN traceValSeq


     

       
133

       
 

       
      traceValSeqFn traceValSeqN traceValSeqNFn traceShowVal


     

       
134

       
 

       
      traceShowValMarked showVal traceCall traceCall2 traceCall3


     

       
135

       
 

       
      traceValIfNot runTests testAllTrue traceCallXml attrNamesToStr;


     

       
136

       
-

       
    inherit (misc) maybeEnv defaultMergeArg defaultMerge foldArgs


     

       
137

       
 

       
      maybeAttrNullable maybeAttr ifEnable checkFlag getValue


     

       
138

       
 

       
      checkReqs uniqList uniqListExt condConcat lazyGenericClosure


     

       
139

       
 

       
      innerModifySumArgs modifySumArgs innerClosePropagation


     
···

       
143

       
 

       
      mergeAttrsByFuncDefaultsClean mergeAttrBy


     

       
144

       
 

       
      fakeHash fakeSha256 fakeSha512


     

       
145

       
 

       
      nixType imap;


     

       
146

       
-

       
    inherit (versions)


     

       
147

       
 

       
      splitVersion;


     

       
148

       
 

       
  });


     

       
149

       
 

       
in lib


     
···

       
9

       
 

       



     

       
10

       
 

       
  lib = makeExtensible (self: let


     

       
11

       
 

       
    callLibs = file: import file { lib = self; };


     

       
12

       
+

       
  in {


     

       
13

       
 

       



     

       
14

       
 

       
    # often used, or depending on very little


     

       
15

       
 

       
    trivial = callLibs ./trivial.nix;


     
···

       
54

       
 

       
    filesystem = callLibs ./filesystem.nix;


     

       
55

       
 

       



     

       
56

       
 

       
    # back-compat aliases


     

       
57

       
+

       
    platforms = self.systems.doubles;


     

       
58

       
 

       



     

       
59

       
 

       
    # linux kernel configuration


     

       
60

       
 

       
    kernel = callLibs ./kernel.nix;


     
···

       
64

       
 

       
      hasAttr head isAttrs isBool isInt isList isString length


     

       
65

       
 

       
      lessThan listToAttrs pathExists readFile replaceStrings seq


     

       
66

       
 

       
      stringLength sub substring tail;


     

       
67

       
+

       
    inherit (self.trivial) id const pipe concat or and bitAnd bitOr bitXor


     

       
68

       
 

       
      bitNot boolToString mergeAttrs flip mapNullable inNixShell min max


     

       
69

       
 

       
      importJSON importTOML warn info showWarnings nixpkgsVersion version mod compare


     

       
70

       
 

       
      splitByAndCompare functionArgs setFunctionArgs isFunction toHexString toBaseDigits;


     

       
71

       
+

       
    inherit (self.fixedPoints) fix fix' converge extends composeExtensions


     

       
72

       
 

       
      makeExtensible makeExtensibleWithCustomName;


     

       
73

       
+

       
    inherit (self.attrsets) attrByPath hasAttrByPath setAttrByPath


     

       
74

       
 

       
      getAttrFromPath attrVals attrValues getAttrs catAttrs filterAttrs


     

       
75

       
 

       
      filterAttrsRecursive foldAttrs collect nameValuePair mapAttrs


     

       
76

       
 

       
      mapAttrs' mapAttrsToList mapAttrsRecursive mapAttrsRecursiveCond


     
···

       
79

       
 

       
      recursiveUpdate matchAttrs overrideExisting getOutput getBin


     

       
80

       
 

       
      getLib getDev getMan chooseDevOutputs zipWithNames zip


     

       
81

       
 

       
      recurseIntoAttrs dontRecurseIntoAttrs;


     

       
82

       
+

       
    inherit (self.lists) singleton forEach foldr fold foldl foldl' imap0 imap1


     

       
83

       
 

       
      concatMap flatten remove findSingle findFirst any all count


     

       
84

       
 

       
      optional optionals toList range partition zipListsWith zipLists


     

       
85

       
 

       
      reverseList listDfs toposort sort naturalSort compareLists take


     

       
86

       
 

       
      drop sublist last init crossLists unique intersectLists


     

       
87

       
 

       
      subtractLists mutuallyExclusive groupBy groupBy';


     

       
88

       
+

       
    inherit (self.strings) concatStrings concatMapStrings concatImapStrings


     

       
89

       
 

       
      intersperse concatStringsSep concatMapStringsSep


     

       
90

       
 

       
      concatImapStringsSep makeSearchPath makeSearchPathOutput


     

       
91

       
 

       
      makeLibraryPath makeBinPath optionalString


     
···

       
97

       
 

       
      nameFromURL enableFeature enableFeatureAs withFeature


     

       
98

       
 

       
      withFeatureAs fixedWidthString fixedWidthNumber isStorePath


     

       
99

       
 

       
      toInt readPathsFromFile fileContents;


     

       
100

       
+

       
    inherit (self.stringsWithDeps) textClosureList textClosureMap


     

       
101

       
 

       
      noDepEntry fullDepEntry packEntry stringAfter;


     

       
102

       
+

       
    inherit (self.customisation) overrideDerivation makeOverridable


     

       
103

       
 

       
      callPackageWith callPackagesWith extendDerivation hydraJob


     

       
104

       
 

       
      makeScope;


     

       
105

       
+

       
    inherit (self.meta) addMetaAttrs dontDistribute setName updateName


     

       
106

       
 

       
      appendToName mapDerivationAttrset setPrio lowPrio lowPrioSet hiPrio


     

       
107

       
 

       
      hiPrioSet;


     

       
108

       
+

       
    inherit (self.sources) pathType pathIsDirectory cleanSourceFilter


     

       
109

       
 

       
      cleanSource sourceByRegex sourceFilesBySuffices


     

       
110

       
 

       
      commitIdFromGitRepo cleanSourceWith pathHasContext


     

       
111

       
 

       
      canCleanSource pathIsRegularFile pathIsGitRepo;


     

       
112

       
+

       
    inherit (self.modules) evalModules unifyModuleSyntax


     

       
113

       
 

       
      applyIfFunction mergeModules


     

       
114

       
 

       
      mergeModules' mergeOptionDecls evalOptionValue mergeDefinitions


     

       
115

       
 

       
      pushDownProperties dischargeProperties filterOverrides


     
···

       
119

       
 

       
      mkAliasAndWrapDefinitions fixMergeModules mkRemovedOptionModule


     

       
120

       
 

       
      mkRenamedOptionModule mkMergedOptionModule mkChangedOptionModule


     

       
121

       
 

       
      mkAliasOptionModule doRename;


     

       
122

       
+

       
    inherit (self.options) isOption mkEnableOption mkSinkUndeclaredOptions


     

       
123

       
 

       
      mergeDefaultOption mergeOneOption mergeEqualOption getValues


     

       
124

       
 

       
      getFiles optionAttrSetToDocList optionAttrSetToDocList'


     

       
125

       
 

       
      scrubOptionValue literalExample showOption showFiles


     

       
126

       
 

       
      unknownModule mkOption;


     

       
127

       
+

       
    inherit (self.types) isType setType defaultTypeMerge defaultFunctor


     

       
128

       
 

       
      isOptionType mkOptionType;


     

       
129

       
+

       
    inherit (self.asserts)


     

       
130

       
 

       
      assertMsg assertOneOf;


     

       
131

       
+

       
    inherit (self.debug) addErrorContextToAttrs traceIf traceVal traceValFn


     

       
132

       
 

       
      traceXMLVal traceXMLValMarked traceSeq traceSeqN traceValSeq


     

       
133

       
 

       
      traceValSeqFn traceValSeqN traceValSeqNFn traceShowVal


     

       
134

       
 

       
      traceShowValMarked showVal traceCall traceCall2 traceCall3


     

       
135

       
 

       
      traceValIfNot runTests testAllTrue traceCallXml attrNamesToStr;


     

       
136

       
+

       
    inherit (self.misc) maybeEnv defaultMergeArg defaultMerge foldArgs


     

       
137

       
 

       
      maybeAttrNullable maybeAttr ifEnable checkFlag getValue


     

       
138

       
 

       
      checkReqs uniqList uniqListExt condConcat lazyGenericClosure


     

       
139

       
 

       
      innerModifySumArgs modifySumArgs innerClosePropagation


     
···

       
143

       
 

       
      mergeAttrsByFuncDefaultsClean mergeAttrBy


     

       
144

       
 

       
      fakeHash fakeSha256 fakeSha512


     

       
145

       
 

       
      nixType imap;


     

       
146

       
+

       
    inherit (self.versions)


     

       
147

       
 

       
      splitVersion;


     

       
148

       
 

       
  });


     

       
149

       
 

       
in lib
+1 -1
lib/lists.nix 
···

       
1

       
 

       
# General list operations.


     

       
2

       
 

       



     

       
3

       
 

       
{ lib }:


     

       
4

       
-

       
with lib.trivial;


     

       
5

       
 

       
let


     

       
6

       
 

       
  inherit (lib.strings) toInt;


     

       

       

       
     

       
7

       
 

       
in


     

       
8

       
 

       
rec {


     

       
9

       
 

       



     
···

       
1

       
 

       
# General list operations.


     

       
2

       
 

       



     

       
3

       
 

       
{ lib }:


     

       

       

       
     

       
4

       
 

       
let


     

       
5

       
 

       
  inherit (lib.strings) toInt;


     

       
6

       
+

       
  inherit (lib.trivial) compare min;


     

       
7

       
 

       
in


     

       
8

       
 

       
rec {


     

       
9
+51 -8
lib/modules.nix 
···

       
1

       
 

       
{ lib }:


     

       
2

       
 

       



     

       
3

       
-

       
with lib.lists;


     

       
4

       
-

       
with lib.strings;


     

       
5

       
-

       
with lib.trivial;


     

       
6

       
-

       
with lib.attrsets;


     

       
7

       
-

       
with lib.options;


     

       
8

       
-

       
with lib.debug;


     

       
9

       
-

       
with lib.types;


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
10

       
 

       



     

       
11

       
 

       
rec {


     

       
12

       
 

       



     
···

       
616

       
 

       
  fixupOptionType = loc: opt:


     

       
617

       
 

       
    let


     

       
618

       
 

       
      options = opt.options or


     

       
619

       
-

       
        (throw "Option `${showOption loc'}' has type optionSet but has no option attribute, in ${showFiles opt.declarations}.");


     

       
620

       
 

       
      f = tp:


     

       
621

       
 

       
        let optionSetIn = type: (tp.name == type) && (tp.functor.wrapped.name == "optionSet");


     

       
622

       
 

       
        in


     
···

       
1

       
 

       
{ lib }:


     

       
2

       
 

       



     

       
3

       
+

       
let


     

       
4

       
+

       
  inherit (lib.attrsets)


     

       
5

       
+

       
    mapAttrsRecursiveCond


     

       
6

       
+

       
    ;


     

       
7

       
+

       
  inherit (lib.lists)


     

       
8

       
+

       
    any all concatLists concatMap


     

       
9

       
+

       
    count filter findFirst foldl foldl'


     

       
10

       
+

       
    head imap1 length optional


     

       
11

       
+

       
    reverseList sort


     

       
12

       
+

       
    ;


     

       
13

       
+

       
  inherit (lib.options)


     

       
14

       
+

       
    isOption


     

       
15

       
+

       
    mkOption


     

       
16

       
+

       
    showDefs


     

       
17

       
+

       
    showFiles


     

       
18

       
+

       
    showOption


     

       
19

       
+

       
    unknownModule


     

       
20

       
+

       
    ;


     

       
21

       
+

       
  inherit (lib.attrsets)


     

       
22

       
+

       
    attrByPath


     

       
23

       
+

       
    attrNames


     

       
24

       
+

       
    catAttrs


     

       
25

       
+

       
    getAttrFromPath


     

       
26

       
+

       
    mapAttrs


     

       
27

       
+

       
    mapAttrsToList


     

       
28

       
+

       
    optionalAttrs


     

       
29

       
+

       
    recursiveUpdate


     

       
30

       
+

       
    setAttrByPath


     

       
31

       
+

       
    toList


     

       
32

       
+

       
    ;


     

       
33

       
+

       
  inherit (lib.types)


     

       
34

       
+

       
    types


     

       
35

       
+

       
    ;


     

       
36

       
+

       
  inherit (lib.trivial)


     

       
37

       
+

       
    flip


     

       
38

       
+

       
    id


     

       
39

       
+

       
    isBool


     

       
40

       
+

       
    isFunction


     

       
41

       
+

       
    isString


     

       
42

       
+

       
    min


     

       
43

       
+

       
    warn


     

       
44

       
+

       
    ;


     

       
45

       
+

       
  inherit (lib.strings)


     

       
46

       
+

       
    optionalString


     

       
47

       
+

       
    ;


     

       
48

       
+

       
  inherit (lib)


     

       
49

       
+

       
    elem


     

       
50

       
+

       
    isAttrs


     

       
51

       
+

       
    ;


     

       
52

       
+

       
in


     

       
53

       
 

       



     

       
54

       
 

       
rec {


     

       
55

       
 

       



     
···

       
659

       
 

       
  fixupOptionType = loc: opt:


     

       
660

       
 

       
    let


     

       
661

       
 

       
      options = opt.options or


     

       
662

       
+

       
        (throw "Option `${showOption loc}' has type optionSet but has no option attribute, in ${showFiles opt.declarations}.");


     

       
663

       
 

       
      f = tp:


     

       
664

       
 

       
        let optionSetIn = type: (tp.name == type) && (tp.functor.wrapped.name == "optionSet");


     

       
665

       
 

       
        in
+9 -5
lib/options.nix 
···

       
1

       
 

       
# Nixpkgs/NixOS option handling.


     

       
2

       
 

       
{ lib }:


     

       
3

       
 

       



     

       
4

       
-

       
with lib.trivial;


     

       
5

       
-

       
with lib.lists;


     

       
6

       
-

       
with lib.attrsets;


     

       
7

       
-

       
with lib.strings;


     

       
8

       
-

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
9

       
 

       
rec {


     

       
10

       
 

       



     

       
11

       
 

       
  /* Returns true when the given argument is an option


     
···

       
1

       
 

       
# Nixpkgs/NixOS option handling.


     

       
2

       
 

       
{ lib }:


     

       
3

       
 

       



     

       
4

       
+

       
let


     

       
5

       
+

       
  inherit (lib)


     

       
6

       
+

       
    isAttrs isBool isDerivation isFunction isInt isList isString


     

       
7

       
+

       
    all collect concatMap concatLists elemAt filter foldl' head length mapAttrs optionals optional take


     

       
8

       
+

       
    ;


     

       
9

       
+

       
  inherit (lib.attrsets) optionalAttrs;


     

       
10

       
+

       
  inherit (lib.strings) concatMapStrings concatStringsSep;


     

       
11

       
+

       
  inherit (lib.types) mkOptionType;


     

       
12

       
+

       
in


     

       
13

       
 

       
rec {


     

       
14

       
 

       



     

       
15

       
 

       
  /* Returns true when the given argument is an option
+28 -12
lib/sources.nix 
···

       
1

       
 

       
# Functions for copying sources to the Nix store.


     

       
2

       
 

       
{ lib }:


     

       
3

       
 

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
4

       
 

       
rec {


     

       
5

       
 

       



     

       
6

       
 

       
  # Returns the type of a path: regular (for file), symlink, or directory


     

       
7

       
-

       
  pathType = p: with builtins; getAttr (baseNameOf p) (readDir (dirOf p));


     

       
8

       
 

       



     

       
9

       
 

       
  # Returns true if the path exists and is a directory, false otherwise


     

       
10

       
-

       
  pathIsDirectory = p: if builtins.pathExists p then (pathType p) == "directory" else false;


     

       
11

       
 

       



     

       
12

       
 

       
  # Returns true if the path exists and is a regular file, false otherwise


     

       
13

       
-

       
  pathIsRegularFile = p: if builtins.pathExists p then (pathType p) == "regular" else false;


     

       
14

       
 

       



     

       
15

       
 

       
  # Bring in a path as a source, filtering out all Subversion and CVS


     

       
16

       
 

       
  # directories, as well as backup files (*~).


     
···

       
19

       
 

       
    (baseName == ".git" || type == "directory" && (baseName == ".svn" || baseName == "CVS" || baseName == ".hg")) ||


     

       
20

       
 

       
    # Filter out editor backup / swap files.


     

       
21

       
 

       
    lib.hasSuffix "~" baseName ||


     

       
22

       
-

       
    builtins.match "^\\.sw[a-z]$" baseName != null ||


     

       
23

       
-

       
    builtins.match "^\\..*\\.sw[a-z]$" baseName != null ||


     

       
24

       
 

       



     

       
25

       
 

       
    # Filter out generates files.


     

       
26

       
 

       
    lib.hasSuffix ".o" baseName ||


     
···

       
89

       
 

       
    in lib.cleanSourceWith {


     

       
90

       
 

       
      filter = (path: type:


     

       
91

       
 

       
        let relPath = lib.removePrefix (toString origSrc + "/") (toString path);


     

       
92

       
-

       
        in lib.any (re: builtins.match re relPath != null) regexes);


     

       
93

       
 

       
      inherit src;


     

       
94

       
 

       
    };


     

       
95

       
 

       



     
···

       
102

       
 

       
      in type == "directory" || lib.any (ext: lib.hasSuffix ext base) exts;


     

       
103

       
 

       
    in cleanSourceWith { inherit filter; src = path; };


     

       
104

       
 

       



     

       
105

       
-

       
  pathIsGitRepo = path: (builtins.tryEval (commitIdFromGitRepo path)).success;


     

       
106

       
 

       



     

       
107

       
 

       
  # Get the commit id of a git repo


     

       
108

       
 

       
  # Example: commitIdFromGitRepo <nixpkgs/.git>


     

       
109

       
 

       
  commitIdFromGitRepo =


     

       
110

       
 

       
    let readCommitFromFile = file: path:


     

       
111

       
-

       
      with builtins;


     

       
112

       
 

       
        let fileName       = toString path + "/" + file;


     

       
113

       
 

       
            packedRefsName = toString path + "/packed-refs";


     

       
114

       
 

       
            absolutePath   = base: path:


     
···

       
145

       
 

       
           # packed-refs file, so we have to grep through it:


     

       
146

       
 

       
           then


     

       
147

       
 

       
             let fileContent = readFile packedRefsName;


     

       
148

       
-

       
                 matchRef = builtins.match "([a-z0-9]+) ${file}";


     

       
149

       
-

       
                 isRef = s: builtins.isString s && (matchRef s) != null;


     

       
150

       
 

       
                 # there is a bug in libstdc++ leading to stackoverflow for long strings:


     

       
151

       
 

       
                 # https://github.com/NixOS/nix/issues/2147#issuecomment-659868795


     

       
152

       
-

       
                 refs = builtins.filter isRef (builtins.split "\n" fileContent);


     

       
153

       
 

       
             in if refs == []


     

       
154

       
 

       
                then throw ("Could not find " + file + " in " + packedRefsName)


     

       
155

       
 

       
                else lib.head (matchRef (lib.head refs))


     
···

       
157

       
 

       
           else throw ("Not a .git directory: " + path);


     

       
158

       
 

       
    in readCommitFromFile "HEAD";


     

       
159

       
 

       



     

       
160

       
-

       
  pathHasContext = builtins.hasContext or (lib.hasPrefix builtins.storeDir);


     

       
161

       
 

       



     

       
162

       
 

       
  canCleanSource = src: src ? _isLibCleanSourceWith || !(pathHasContext (toString src));


     

       
163

       
 

       
}


     
···

       
1

       
 

       
# Functions for copying sources to the Nix store.


     

       
2

       
 

       
{ lib }:


     

       
3

       
 

       



     

       
4

       
+

       
let


     

       
5

       
+

       
  inherit (builtins)


     

       
6

       
+

       
    hasContext


     

       
7

       
+

       
    match


     

       
8

       
+

       
    readDir


     

       
9

       
+

       
    readFile


     

       
10

       
+

       
    storeDir


     

       
11

       
+

       
    tryEval


     

       
12

       
+

       
    ;


     

       
13

       
+

       
  inherit (lib)


     

       
14

       
+

       
    filter


     

       
15

       
+

       
    getAttr


     

       
16

       
+

       
    isString


     

       
17

       
+

       
    pathExists


     

       
18

       
+

       
    split


     

       
19

       
+

       
    ;


     

       
20

       
+

       
in


     

       
21

       
 

       
rec {


     

       
22

       
 

       



     

       
23

       
 

       
  # Returns the type of a path: regular (for file), symlink, or directory


     

       
24

       
+

       
  pathType = p: getAttr (baseNameOf p) (readDir (dirOf p));


     

       
25

       
 

       



     

       
26

       
 

       
  # Returns true if the path exists and is a directory, false otherwise


     

       
27

       
+

       
  pathIsDirectory = p: if pathExists p then (pathType p) == "directory" else false;


     

       
28

       
 

       



     

       
29

       
 

       
  # Returns true if the path exists and is a regular file, false otherwise


     

       
30

       
+

       
  pathIsRegularFile = p: if pathExists p then (pathType p) == "regular" else false;


     

       
31

       
 

       



     

       
32

       
 

       
  # Bring in a path as a source, filtering out all Subversion and CVS


     

       
33

       
 

       
  # directories, as well as backup files (*~).


     
···

       
36

       
 

       
    (baseName == ".git" || type == "directory" && (baseName == ".svn" || baseName == "CVS" || baseName == ".hg")) ||


     

       
37

       
 

       
    # Filter out editor backup / swap files.


     

       
38

       
 

       
    lib.hasSuffix "~" baseName ||


     

       
39

       
+

       
    match "^\\.sw[a-z]$" baseName != null ||


     

       
40

       
+

       
    match "^\\..*\\.sw[a-z]$" baseName != null ||


     

       
41

       
 

       



     

       
42

       
 

       
    # Filter out generates files.


     

       
43

       
 

       
    lib.hasSuffix ".o" baseName ||


     
···

       
106

       
 

       
    in lib.cleanSourceWith {


     

       
107

       
 

       
      filter = (path: type:


     

       
108

       
 

       
        let relPath = lib.removePrefix (toString origSrc + "/") (toString path);


     

       
109

       
+

       
        in lib.any (re: match re relPath != null) regexes);


     

       
110

       
 

       
      inherit src;


     

       
111

       
 

       
    };


     

       
112

       
 

       



     
···

       
119

       
 

       
      in type == "directory" || lib.any (ext: lib.hasSuffix ext base) exts;


     

       
120

       
 

       
    in cleanSourceWith { inherit filter; src = path; };


     

       
121

       
 

       



     

       
122

       
+

       
  pathIsGitRepo = path: (tryEval (commitIdFromGitRepo path)).success;


     

       
123

       
 

       



     

       
124

       
 

       
  # Get the commit id of a git repo


     

       
125

       
 

       
  # Example: commitIdFromGitRepo <nixpkgs/.git>


     

       
126

       
 

       
  commitIdFromGitRepo =


     

       
127

       
 

       
    let readCommitFromFile = file: path:


     

       

       

       
     

       
128

       
 

       
        let fileName       = toString path + "/" + file;


     

       
129

       
 

       
            packedRefsName = toString path + "/packed-refs";


     

       
130

       
 

       
            absolutePath   = base: path:


     
···

       
161

       
 

       
           # packed-refs file, so we have to grep through it:


     

       
162

       
 

       
           then


     

       
163

       
 

       
             let fileContent = readFile packedRefsName;


     

       
164

       
+

       
                 matchRef = match "([a-z0-9]+) ${file}";


     

       
165

       
+

       
                 isRef = s: isString s && (matchRef s) != null;


     

       
166

       
 

       
                 # there is a bug in libstdc++ leading to stackoverflow for long strings:


     

       
167

       
 

       
                 # https://github.com/NixOS/nix/issues/2147#issuecomment-659868795


     

       
168

       
+

       
                 refs = filter isRef (split "\n" fileContent);


     

       
169

       
 

       
             in if refs == []


     

       
170

       
 

       
                then throw ("Could not find " + file + " in " + packedRefsName)


     

       
171

       
 

       
                else lib.head (matchRef (lib.head refs))


     
···

       
173

       
 

       
           else throw ("Not a .git directory: " + path);


     

       
174

       
 

       
    in readCommitFromFile "HEAD";


     

       
175

       
 

       



     

       
176

       
+

       
  pathHasContext = builtins.hasContext or (lib.hasPrefix storeDir);


     

       
177

       
 

       



     

       
178

       
 

       
  canCleanSource = src: src ? _isLibCleanSourceWith || !(pathHasContext (toString src));


     

       
179

       
 

       
}
+9 -4
lib/strings-with-deps.nix 
···

       
41

       
 

       
  [1] maybe this behaviour should be removed to keep things simple (?)


     

       
42

       
 

       
*/


     

       
43

       
 

       



     

       
44

       
-

       
with lib.lists;


     

       
45

       
-

       
with lib.attrsets;


     

       
46

       
-

       
with lib.strings;


     

       
47

       
-

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
48

       
 

       
rec {


     

       
49

       
 

       



     

       
50

       
 

       
  /* !!! The interface of this function is kind of messed up, since


     
···

       
41

       
 

       
  [1] maybe this behaviour should be removed to keep things simple (?)


     

       
42

       
 

       
*/


     

       
43

       
 

       



     

       
44

       
+

       
let


     

       
45

       
+

       
  inherit (lib)


     

       
46

       
+

       
    concatStringsSep


     

       
47

       
+

       
    head


     

       
48

       
+

       
    isAttrs


     

       
49

       
+

       
    listToAttrs


     

       
50

       
+

       
    tail


     

       
51

       
+

       
    ;


     

       
52

       
+

       
in


     

       
53

       
 

       
rec {


     

       
54

       
 

       



     

       
55

       
 

       
  /* !!! The interface of this function is kind of messed up, since
+43 -21
lib/strings.nix 
···

       
8

       
 

       



     

       
9

       
 

       
rec {


     

       
10

       
 

       



     

       
11

       
-

       
  inherit (builtins) stringLength substring head tail isString replaceStrings;


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
12

       
 

       



     

       
13

       
 

       
  /* Concatenate a list of strings.


     

       
14

       
 

       



     
···

       
120

       
 

       
    subDir:


     

       
121

       
 

       
    # List of base paths


     

       
122

       
 

       
    paths:


     

       
123

       
-

       
    concatStringsSep ":" (map (path: path + "/" + subDir) (builtins.filter (x: x != null) paths));


     

       
124

       
 

       



     

       
125

       
 

       
  /* Construct a Unix-style search path by appending the given


     

       
126

       
 

       
     `subDir` to the specified `output` of each of the packages. If no


     
···

       
313

       
 

       
       escapeNixString "hello\${}\n"


     

       
314

       
 

       
       => "\"hello\\\${}\\n\""


     

       
315

       
 

       
  */


     

       
316

       
-

       
  escapeNixString = s: escape ["$"] (builtins.toJSON s);


     

       
317

       
 

       



     

       
318

       
 

       
  /* Turn a string into an exact regular expression


     

       
319

       
 

       



     
···

       
337

       
 

       
  */


     

       
338

       
 

       
  escapeNixIdentifier = s:


     

       
339

       
 

       
    # Regex from https://github.com/NixOS/nix/blob/d048577909e383439c2549e849c5c2f2016c997e/src/libexpr/lexer.l#L91


     

       
340

       
-

       
    if builtins.match "[a-zA-Z_][a-zA-Z0-9_'-]*" s != null


     

       
341

       
 

       
    then s else escapeNixString s;


     

       
342

       
 

       



     

       
343

       
 

       
  # Obsolete - use replaceStrings instead.


     
···

       
466

       
 

       
       versionOlder "1.1" "1.1"


     

       
467

       
 

       
       => false


     

       
468

       
 

       
  */


     

       
469

       
-

       
  versionOlder = v1: v2: builtins.compareVersions v2 v1 == 1;


     

       
470

       
 

       



     

       
471

       
 

       
  /* Return true if string v1 denotes a version equal to or newer than v2.


     

       
472

       
 

       



     
···

       
492

       
 

       
  */


     

       
493

       
 

       
  getName = x:


     

       
494

       
 

       
   let


     

       
495

       
-

       
     parse = drv: (builtins.parseDrvName drv).name;


     

       
496

       
 

       
   in if isString x


     

       
497

       
 

       
      then parse x


     

       
498

       
 

       
      else x.pname or (parse x.name);


     
···

       
509

       
 

       
  */


     

       
510

       
 

       
  getVersion = x:


     

       
511

       
 

       
   let


     

       
512

       
-

       
     parse = drv: (builtins.parseDrvName drv).version;


     

       
513

       
 

       
   in if isString x


     

       
514

       
 

       
      then parse x


     

       
515

       
 

       
      else x.version or (parse x.name);


     
···

       
527

       
 

       
    let


     

       
528

       
 

       
      components = splitString "/" url;


     

       
529

       
 

       
      filename = lib.last components;


     

       
530

       
-

       
      name = builtins.head (splitString sep filename);


     

       
531

       
 

       
    in assert name != filename; name;


     

       
532

       
 

       



     

       
533

       
 

       
  /* Create an --{enable,disable}-<feat> string that can be passed to


     
···

       
617

       
 

       
  */


     

       
618

       
 

       
  floatToString = float: let


     

       
619

       
 

       
    result = toString float;


     

       
620

       
-

       
    precise = float == builtins.fromJSON result;


     

       
621

       
 

       
  in if precise then result


     

       
622

       
 

       
    else lib.warn "Imprecise conversion from float to string ${result}" result;


     

       
623

       
 

       



     

       
624

       
 

       
  /* Check whether a value can be coerced to a string */


     

       
625

       
 

       
  isCoercibleToString = x:


     

       
626

       
-

       
    builtins.elem (builtins.typeOf x) [ "path" "string" "null" "int" "float" "bool" ] ||


     

       
627

       
-

       
    (builtins.isList x && lib.all isCoercibleToString x) ||


     

       
628

       
 

       
    x ? outPath ||


     

       
629

       
 

       
    x ? __toString;


     

       
630

       
 

       



     
···

       
643

       
 

       
  isStorePath = x:


     

       
644

       
 

       
    if isCoercibleToString x then


     

       
645

       
 

       
      let str = toString x; in


     

       
646

       
-

       
      builtins.substring 0 1 str == "/"


     

       
647

       
-

       
      && dirOf str == builtins.storeDir


     

       
648

       
 

       
    else


     

       
649

       
 

       
      false;


     

       
650

       
 

       



     
···

       
662

       
 

       
  */


     

       
663

       
 

       
  # Obviously, it is a bit hacky to use fromJSON this way.


     

       
664

       
 

       
  toInt = str:


     

       
665

       
-

       
    let may_be_int = builtins.fromJSON str; in


     

       
666

       
-

       
    if builtins.isInt may_be_int


     

       
667

       
 

       
    then may_be_int


     

       
668

       
 

       
    else throw "Could not convert ${str} to int.";


     

       
669

       
 

       



     
···

       
685

       
 

       
  readPathsFromFile = lib.warn "lib.readPathsFromFile is deprecated, use a list instead"


     

       
686

       
 

       
    (rootPath: file:


     

       
687

       
 

       
      let


     

       
688

       
-

       
        lines = lib.splitString "\n" (builtins.readFile file);


     

       
689

       
 

       
        removeComments = lib.filter (line: line != "" && !(lib.hasPrefix "#" line));


     

       
690

       
 

       
        relativePaths = removeComments lines;


     

       
691

       
-

       
        absolutePaths = builtins.map (path: rootPath + "/${path}") relativePaths;


     

       
692

       
 

       
      in


     

       
693

       
 

       
        absolutePaths);


     

       
694

       
 

       



     
···

       
702

       
 

       
       fileContents ./version


     

       
703

       
 

       
       => "1.0"


     

       
704

       
 

       
  */


     

       
705

       
-

       
  fileContents = file: removeSuffix "\n" (builtins.readFile file);


     

       
706

       
 

       



     

       
707

       
 

       



     

       
708

       
 

       
  /* Creates a valid derivation name from a potentially invalid one.


     
···

       
720

       
 

       
  sanitizeDerivationName = string: lib.pipe string [


     

       
721

       
 

       
    # Get rid of string context. This is safe under the assumption that the


     

       
722

       
 

       
    # resulting string is only used as a derivation name


     

       
723

       
-

       
    builtins.unsafeDiscardStringContext


     

       
724

       
 

       
    # Strip all leading "."


     

       
725

       
-

       
    (x: builtins.elemAt (builtins.match "\\.*(.*)" x) 0)


     

       
726

       
 

       
    # Split out all invalid characters


     

       
727

       
 

       
    # https://github.com/NixOS/nix/blob/2.3.2/src/libstore/store-api.cc#L85-L112


     

       
728

       
 

       
    # https://github.com/NixOS/nix/blob/2242be83c61788b9c0736a92bb0b5c7bbfc40803/nix-rust/src/store/path.rs#L100-L125


     

       
729

       
-

       
    (builtins.split "[^[:alnum:]+._?=-]+")


     

       
730

       
 

       
    # Replace invalid character ranges with a "-"


     

       
731

       
 

       
    (concatMapStrings (s: if lib.isList s then "-" else s))


     

       
732

       
 

       
    # Limit to 211 characters (minus 4 chars for ".drv")


     
···

       
8

       
 

       



     

       
9

       
 

       
rec {


     

       
10

       
 

       



     

       
11

       
+

       
  inherit (builtins)


     

       
12

       
+

       
    compareVersions


     

       
13

       
+

       
    elem


     

       
14

       
+

       
    elemAt


     

       
15

       
+

       
    filter


     

       
16

       
+

       
    fromJSON


     

       
17

       
+

       
    head


     

       
18

       
+

       
    isInt


     

       
19

       
+

       
    isList


     

       
20

       
+

       
    isString


     

       
21

       
+

       
    match


     

       
22

       
+

       
    parseDrvName


     

       
23

       
+

       
    readFile


     

       
24

       
+

       
    replaceStrings


     

       
25

       
+

       
    split


     

       
26

       
+

       
    storeDir


     

       
27

       
+

       
    stringLength


     

       
28

       
+

       
    substring


     

       
29

       
+

       
    tail


     

       
30

       
+

       
    toJSON


     

       
31

       
+

       
    typeOf


     

       
32

       
+

       
    unsafeDiscardStringContext


     

       
33

       
+

       
    ;


     

       
34

       
 

       



     

       
35

       
 

       
  /* Concatenate a list of strings.


     

       
36

       
 

       



     
···

       
142

       
 

       
    subDir:


     

       
143

       
 

       
    # List of base paths


     

       
144

       
 

       
    paths:


     

       
145

       
+

       
    concatStringsSep ":" (map (path: path + "/" + subDir) (filter (x: x != null) paths));


     

       
146

       
 

       



     

       
147

       
 

       
  /* Construct a Unix-style search path by appending the given


     

       
148

       
 

       
     `subDir` to the specified `output` of each of the packages. If no


     
···

       
335

       
 

       
       escapeNixString "hello\${}\n"


     

       
336

       
 

       
       => "\"hello\\\${}\\n\""


     

       
337

       
 

       
  */


     

       
338

       
+

       
  escapeNixString = s: escape ["$"] (toJSON s);


     

       
339

       
 

       



     

       
340

       
 

       
  /* Turn a string into an exact regular expression


     

       
341

       
 

       



     
···

       
359

       
 

       
  */


     

       
360

       
 

       
  escapeNixIdentifier = s:


     

       
361

       
 

       
    # Regex from https://github.com/NixOS/nix/blob/d048577909e383439c2549e849c5c2f2016c997e/src/libexpr/lexer.l#L91


     

       
362

       
+

       
    if match "[a-zA-Z_][a-zA-Z0-9_'-]*" s != null


     

       
363

       
 

       
    then s else escapeNixString s;


     

       
364

       
 

       



     

       
365

       
 

       
  # Obsolete - use replaceStrings instead.


     
···

       
488

       
 

       
       versionOlder "1.1" "1.1"


     

       
489

       
 

       
       => false


     

       
490

       
 

       
  */


     

       
491

       
+

       
  versionOlder = v1: v2: compareVersions v2 v1 == 1;


     

       
492

       
 

       



     

       
493

       
 

       
  /* Return true if string v1 denotes a version equal to or newer than v2.


     

       
494

       
 

       



     
···

       
514

       
 

       
  */


     

       
515

       
 

       
  getName = x:


     

       
516

       
 

       
   let


     

       
517

       
+

       
     parse = drv: (parseDrvName drv).name;


     

       
518

       
 

       
   in if isString x


     

       
519

       
 

       
      then parse x


     

       
520

       
 

       
      else x.pname or (parse x.name);


     
···

       
531

       
 

       
  */


     

       
532

       
 

       
  getVersion = x:


     

       
533

       
 

       
   let


     

       
534

       
+

       
     parse = drv: (parseDrvName drv).version;


     

       
535

       
 

       
   in if isString x


     

       
536

       
 

       
      then parse x


     

       
537

       
 

       
      else x.version or (parse x.name);


     
···

       
549

       
 

       
    let


     

       
550

       
 

       
      components = splitString "/" url;


     

       
551

       
 

       
      filename = lib.last components;


     

       
552

       
+

       
      name = head (splitString sep filename);


     

       
553

       
 

       
    in assert name != filename; name;


     

       
554

       
 

       



     

       
555

       
 

       
  /* Create an --{enable,disable}-<feat> string that can be passed to


     
···

       
639

       
 

       
  */


     

       
640

       
 

       
  floatToString = float: let


     

       
641

       
 

       
    result = toString float;


     

       
642

       
+

       
    precise = float == fromJSON result;


     

       
643

       
 

       
  in if precise then result


     

       
644

       
 

       
    else lib.warn "Imprecise conversion from float to string ${result}" result;


     

       
645

       
 

       



     

       
646

       
 

       
  /* Check whether a value can be coerced to a string */


     

       
647

       
 

       
  isCoercibleToString = x:


     

       
648

       
+

       
    elem (typeOf x) [ "path" "string" "null" "int" "float" "bool" ] ||


     

       
649

       
+

       
    (isList x && lib.all isCoercibleToString x) ||


     

       
650

       
 

       
    x ? outPath ||


     

       
651

       
 

       
    x ? __toString;


     

       
652

       
 

       



     
···

       
665

       
 

       
  isStorePath = x:


     

       
666

       
 

       
    if isCoercibleToString x then


     

       
667

       
 

       
      let str = toString x; in


     

       
668

       
+

       
      substring 0 1 str == "/"


     

       
669

       
+

       
      && dirOf str == storeDir


     

       
670

       
 

       
    else


     

       
671

       
 

       
      false;


     

       
672

       
 

       



     
···

       
684

       
 

       
  */


     

       
685

       
 

       
  # Obviously, it is a bit hacky to use fromJSON this way.


     

       
686

       
 

       
  toInt = str:


     

       
687

       
+

       
    let may_be_int = fromJSON str; in


     

       
688

       
+

       
    if isInt may_be_int


     

       
689

       
 

       
    then may_be_int


     

       
690

       
 

       
    else throw "Could not convert ${str} to int.";


     

       
691

       
 

       



     
···

       
707

       
 

       
  readPathsFromFile = lib.warn "lib.readPathsFromFile is deprecated, use a list instead"


     

       
708

       
 

       
    (rootPath: file:


     

       
709

       
 

       
      let


     

       
710

       
+

       
        lines = lib.splitString "\n" (readFile file);


     

       
711

       
 

       
        removeComments = lib.filter (line: line != "" && !(lib.hasPrefix "#" line));


     

       
712

       
 

       
        relativePaths = removeComments lines;


     

       
713

       
+

       
        absolutePaths = map (path: rootPath + "/${path}") relativePaths;


     

       
714

       
 

       
      in


     

       
715

       
 

       
        absolutePaths);


     

       
716

       
 

       



     
···

       
724

       
 

       
       fileContents ./version


     

       
725

       
 

       
       => "1.0"


     

       
726

       
 

       
  */


     

       
727

       
+

       
  fileContents = file: removeSuffix "\n" (readFile file);


     

       
728

       
 

       



     

       
729

       
 

       



     

       
730

       
 

       
  /* Creates a valid derivation name from a potentially invalid one.


     
···

       
742

       
 

       
  sanitizeDerivationName = string: lib.pipe string [


     

       
743

       
 

       
    # Get rid of string context. This is safe under the assumption that the


     

       
744

       
 

       
    # resulting string is only used as a derivation name


     

       
745

       
+

       
    unsafeDiscardStringContext


     

       
746

       
 

       
    # Strip all leading "."


     

       
747

       
+

       
    (x: elemAt (match "\\.*(.*)" x) 0)


     

       
748

       
 

       
    # Split out all invalid characters


     

       
749

       
 

       
    # https://github.com/NixOS/nix/blob/2.3.2/src/libstore/store-api.cc#L85-L112


     

       
750

       
 

       
    # https://github.com/NixOS/nix/blob/2242be83c61788b9c0736a92bb0b5c7bbfc40803/nix-rust/src/store/path.rs#L100-L125


     

       
751

       
+

       
    (split "[^[:alnum:]+._?=-]+")


     

       
752

       
 

       
    # Replace invalid character ranges with a "-"


     

       
753

       
 

       
    (concatMapStrings (s: if lib.isList s then "-" else s))


     

       
754

       
 

       
    # Limit to 211 characters (minus 4 chars for ".drv")
+55 -5
lib/types.nix 
···

       
1

       
 

       
# Definitions related to run-time type checking.  Used in particular


     

       
2

       
 

       
# to type-check NixOS configurations.


     

       
3

       
 

       
{ lib }:


     

       
4

       
-

       
with lib.lists;


     

       
5

       
-

       
with lib.attrsets;


     

       
6

       
-

       
with lib.options;


     

       
7

       
-

       
with lib.trivial;


     

       
8

       
-

       
with lib.strings;


     

       
9

       
 

       
let


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
10

       
 

       



     

       
11

       
 

       
  inherit (lib.modules) mergeDefinitions;


     

       
12

       
 

       
  outer_types =


     
···

       
1

       
 

       
# Definitions related to run-time type checking.  Used in particular


     

       
2

       
 

       
# to type-check NixOS configurations.


     

       
3

       
 

       
{ lib }:


     

       
4

       
+

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
5

       
 

       
let


     

       
6

       
+

       
  inherit (lib)


     

       
7

       
+

       
    elem


     

       
8

       
+

       
    flip


     

       
9

       
+

       
    functionArgs


     

       
10

       
+

       
    isAttrs


     

       
11

       
+

       
    isBool


     

       
12

       
+

       
    isDerivation


     

       
13

       
+

       
    isFloat


     

       
14

       
+

       
    isFunction


     

       
15

       
+

       
    isInt


     

       
16

       
+

       
    isList


     

       
17

       
+

       
    isString


     

       
18

       
+

       
    isStorePath


     

       
19

       
+

       
    setFunctionArgs


     

       
20

       
+

       
    toDerivation


     

       
21

       
+

       
    toList


     

       
22

       
+

       
    ;


     

       
23

       
+

       
  inherit (lib.lists)


     

       
24

       
+

       
    all


     

       
25

       
+

       
    concatLists


     

       
26

       
+

       
    count


     

       
27

       
+

       
    elemAt


     

       
28

       
+

       
    filter


     

       
29

       
+

       
    foldl'


     

       
30

       
+

       
    head


     

       
31

       
+

       
    imap1


     

       
32

       
+

       
    last


     

       
33

       
+

       
    length


     

       
34

       
+

       
    tail


     

       
35

       
+

       
    unique


     

       
36

       
+

       
    ;


     

       
37

       
+

       
  inherit (lib.attrsets)


     

       
38

       
+

       
    attrNames


     

       
39

       
+

       
    filterAttrs


     

       
40

       
+

       
    hasAttr


     

       
41

       
+

       
    mapAttrs


     

       
42

       
+

       
    optionalAttrs


     

       
43

       
+

       
    zipAttrsWith


     

       
44

       
+

       
    ;


     

       
45

       
+

       
  inherit (lib.options)


     

       
46

       
+

       
    getFiles


     

       
47

       
+

       
    getValues


     

       
48

       
+

       
    mergeDefaultOption


     

       
49

       
+

       
    mergeEqualOption


     

       
50

       
+

       
    mergeOneOption


     

       
51

       
+

       
    showFiles


     

       
52

       
+

       
    showOption


     

       
53

       
+

       
    ;


     

       
54

       
+

       
  inherit (lib.strings)


     

       
55

       
+

       
    concatMapStringsSep


     

       
56

       
+

       
    concatStringsSep


     

       
57

       
+

       
    escapeNixString


     

       
58

       
+

       
    isCoercibleToString


     

       
59

       
+

       
    ;


     

       
60

       
 

       



     

       
61

       
 

       
  inherit (lib.modules) mergeDefinitions;


     

       
62

       
 

       
  outer_types =