JakeHillion/nixpkgs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Add the tool "nixos-typecheck" that can check an option declaration to:"

Browse Source 
This reverts commit cad8957eab. It
breaks NixOps, but more importantly, such major changes to the module
system really need to be reviewed.
This commit is contained in:
Eelco Dolstra 2016-03-01 20:47:08 +01:00
parent bf4cafd1dd
commit f3d94cfc23
24 changed files with 127 additions and 703 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
lib/modules.nix
View File

@ -23,6 +23,8 @@ rec {
specialArgs ? {} specialArgs ? {}
, # This would be remove in the future, Prefer _module.args option instead. , # This would be remove in the future, Prefer _module.args option instead.
args ? {} args ? {}
, # This would be remove in the future, Prefer _module.check option instead.
check ? true
}: }:
let let
# This internal module declare internal options under the `_module' # This internal module declare internal options under the `_module'
@ -43,22 +45,9 @@ rec {
_module.check = mkOption { _module.check = mkOption {
type = types.bool; type = types.bool;
internal = true; internal = true;
default = true; default = check;
description = "Whether to check whether all option definitions have matching declarations."; description = "Whether to check whether all option definitions have matching declarations.";
}; };
_module.typeInference = mkOption {
type = types.nullOr types.str;
internal = true;
default = null; # TODO: Move away from 'null' after enough testing.
description = ''
Mode of type inferencing. Possible values are:
null = Disable type inferencing completely. Use 'types.unspecified' for every option without type definition.
"silent" = Try to infer type of option without type definition, but do not print anything.
"printUnspecified" = Try to infer type of option without type definition and print options for which no full type could be inferred.
"printAll" = Try to infer type of option without type definition and print all options without type definition.
'';
};
}; };
config = { config = {
@ -71,7 +60,7 @@ rec {
# Note: the list of modules is reversed to maintain backward # Note: the list of modules is reversed to maintain backward
# compatibility with the old module system. Not sure if this is # compatibility with the old module system. Not sure if this is
# the most sensible policy. # the most sensible policy.
options = mergeModules (config._module) prefix (reverseList closed); options = mergeModules prefix (reverseList closed);
# Traverse options and extract the option values into the final # Traverse options and extract the option values into the final
# config set. At the same time, check whether all option # config set. At the same time, check whether all option
@ -181,11 +170,11 @@ rec {
At the same time, for each option declaration, it will merge the At the same time, for each option declaration, it will merge the
corresponding option definitions in all machines, returning them corresponding option definitions in all machines, returning them
in the ‘value’ attribute of each option. */ in the ‘value’ attribute of each option. */
mergeModules = _module: prefix: modules: mergeModules = prefix: modules:
mergeModules' _module prefix modules mergeModules' prefix modules
(concatMap (m: map (config: { inherit (m) file; inherit config; }) (pushDownProperties m.config)) modules); (concatMap (m: map (config: { inherit (m) file; inherit config; }) (pushDownProperties m.config)) modules);
mergeModules' = _module: prefix: options: configs: mergeModules' = prefix: options: configs:
listToAttrs (map (name: { listToAttrs (map (name: {
# We're descending into attribute ‘name’. # We're descending into attribute ‘name’.
inherit name; inherit name;
@ -211,8 +200,8 @@ rec {
(filter (m: m.config ? ${name}) configs); (filter (m: m.config ? ${name}) configs);
in in
if nrOptions == length decls then if nrOptions == length decls then
let opt = fixupOptionType _module.typeInference loc (mergeOptionDecls loc decls); let opt = fixupOptionType loc (mergeOptionDecls loc decls);
in evalOptionValue _module loc opt defns' in evalOptionValue loc opt defns'
else if nrOptions != 0 then else if nrOptions != 0 then
let let
firstOption = findFirst (m: isOption m.options) "" decls; firstOption = findFirst (m: isOption m.options) "" decls;
@ -220,7 +209,7 @@ rec {
in in
throw "The option `${showOption loc}' in `${firstOption.file}' is a prefix of options in `${firstNonOption.file}'." throw "The option `${showOption loc}' in `${firstOption.file}' is a prefix of options in `${firstNonOption.file}'."
else else
mergeModules' _module loc decls defns; mergeModules' loc decls defns;
}) (concatMap (m: attrNames m.options) options)) }) (concatMap (m: attrNames m.options) options))
// { _definedNames = map (m: { inherit (m) file; names = attrNames m.config; }) configs; }; // { _definedNames = map (m: { inherit (m) file; names = attrNames m.config; }) configs; };
@ -269,7 +258,7 @@ rec {
/* Merge all the definitions of an option to produce the final /* Merge all the definitions of an option to produce the final
config value. */ config value. */
evalOptionValue = _module: loc: opt: defs: evalOptionValue = loc: opt: defs:
let let
# Add in the default value for this option, if any. # Add in the default value for this option, if any.
defs' = defs' =
@ -281,7 +270,7 @@ rec {
if opt.readOnly or false && length defs' > 1 then if opt.readOnly or false && length defs' > 1 then
throw "The option `${showOption loc}' is read-only, but it's set multiple times." throw "The option `${showOption loc}' is read-only, but it's set multiple times."
else else
mergeDefinitions _module loc opt.type defs'; mergeDefinitions loc opt.type defs';
# Check whether the option is defined, and apply the ‘apply’ # Check whether the option is defined, and apply the ‘apply’
# function to the merged value. This allows options to yield a # function to the merged value. This allows options to yield a
@ -302,7 +291,7 @@ rec {
}; };
# Merge definitions of a value of a given type. # Merge definitions of a value of a given type.
mergeDefinitions = _module: loc: type: defs: rec { mergeDefinitions = loc: type: defs: rec {
defsFinal = defsFinal =
let let
# Process mkMerge and mkIf properties. # Process mkMerge and mkIf properties.
@ -325,7 +314,7 @@ rec {
mergedValue = foldl' (res: def: mergedValue = foldl' (res: def:
if type.check def.value then res if type.check def.value then res
else throw "The option value `${showOption loc}' in `${def.file}' is not a ${type.name}.") else throw "The option value `${showOption loc}' in `${def.file}' is not a ${type.name}.")
(type.merge _module loc defsFinal) defsFinal; (type.merge loc defsFinal) defsFinal;
isDefined = defsFinal != []; isDefined = defsFinal != [];
@ -423,7 +412,7 @@ rec {
/* Hack for backward compatibility: convert options of type /* Hack for backward compatibility: convert options of type
optionSet to options of type submodule. FIXME: remove optionSet to options of type submodule. FIXME: remove
eventually. */ eventually. */
fixupOptionType = typeInference: loc: opt: fixupOptionType = loc: opt:
let let
options = opt.options or options = opt.options or
(throw "Option `${showOption loc'}' has type optionSet but has no option attribute, in ${showFiles opt.declarations}."); (throw "Option `${showOption loc'}' has type optionSet but has no option attribute, in ${showFiles opt.declarations}.");
@ -435,66 +424,12 @@ rec {
else if tp.name == "list of option sets" then types.listOf (types.submodule options) else if tp.name == "list of option sets" then types.listOf (types.submodule options)
else if tp.name == "null or option set" then types.nullOr (types.submodule options) else if tp.name == "null or option set" then types.nullOr (types.submodule options)
else tp; else tp;
in in
if opt.type.getSubModules or null == null if opt.type.getSubModules or null == null
then opt // { type = f (opt.type or (inferType typeInference loc opt)); } then opt // { type = f (opt.type or types.unspecified); }
else opt // { type = opt.type.substSubModules opt.options; options = []; }; else opt // { type = opt.type.substSubModules opt.options; options = []; };
/* Function that tries to infer the type of an option from the default value of the option. */
inferType = mode: loc: opt:
let
doc = x: elemAt x 0;
type = x: elemAt x 1;
containsUnspecified = x: elemAt x 2;
inferType' = def:
if isDerivation def then [ "package" types.package false ]
else if isBool def then [ "bool" types.bool false ]
else if builtins.isString def then [ "str" types.str false ]
else if isInt def then [ "int" types.int false ]
else if isFunction def then [ "functionTo unspecified" (types.functionTo types.unspecified) true ]
else if isList def then
let nestedType = if (length def > 0) && (all (x: (type (inferType' x)) == (type (inferType' (head def)))) def)
then inferType' (head def)
else [ "unspecified" types.unspecified true ];
in [ "listOf ${doc nestedType}" (types.listOf (type nestedType)) (containsUnspecified nestedType) ]
else if isAttrs def then
let list = mapAttrsToList (_: v: v) (removeAttrs def ["_args"]);
nestedType = if (length list > 0) && (all (x: (type (inferType' x)) == (type (inferType' (head list)))) list)
then inferType' (head list)
else [ "unspecified" types.unspecified true ];
in [ "attrsOf ${doc nestedType}" (types.attrsOf (type nestedType)) (containsUnspecified nestedType) ]
else [ "unspecified" types.unspecified true ];
inferDoc = x: ''
Inferring the type of "${showOption loc}" to "${doc x}".
Please verify the inferred type and define the type explicitely in ${showFiles opt.declarations}!
'';
inferredType = printMode:
let inferred = inferType' opt.default;
in if printMode == "silent" then type inferred
else if printMode == "printAll" then builtins.trace (inferDoc inferred) (type inferred)
else if printMode == "printUnspecified" && (containsUnspecified inferred) then builtins.trace (inferDoc inferred) (type inferred)
else type inferred;
noInferDoc = ''
Could not infer a type for "${showOption loc}", using "unspecified" instead.
Please define the type explicitely in ${showFiles opt.declarations}!
'';
hasDefault = (opt ? default) && !(opt ? defaultText);
isExternalVisible = (opt.visible or true) && !(opt.internal or false);
in
if isNull mode || !isExternalVisible
then types.unspecified
else if hasDefault
then inferredType mode /* Set to 'true' to see every type that is being inferred, not just those types that result in 'unspecified'. */
else if mode != "silent" then builtins.trace noInferDoc types.unspecified else types.unspecified;
/* Properties. */ /* Properties. */
mkIf = condition: content: mkIf = condition: content:
@ -562,7 +497,7 @@ rec {
/* Compatibility. */ /* Compatibility. */
fixMergeModules = modules: args: evalModules { inherit args; modules = (modules ++ [{ _module.check = false; }]); }; fixMergeModules = modules: args: evalModules { inherit modules args; check = false; };
/* Return a module that causes a warning to be shown if the /* Return a module that causes a warning to be shown if the

145
lib/options.nix
View File

@ -6,7 +6,6 @@ with import ./trivial.nix;
with import ./lists.nix; with import ./lists.nix;
with import ./attrsets.nix; with import ./attrsets.nix;
with import ./strings.nix; with import ./strings.nix;
with {inherit (import ./types.nix) types; };
rec { rec {
@ -43,17 +42,16 @@ rec {
description = "Sink for option definitions."; description = "Sink for option definitions.";
type = mkOptionType { type = mkOptionType {
name = "sink"; name = "sink";
typerep = "(sink)";
check = x: true; check = x: true;
merge = config: loc: defs: false; merge = loc: defs: false;
}; };
apply = x: throw "Option value is not readable because the option is not declared."; apply = x: throw "Option value is not readable because the option is not declared.";
} // attrs); } // attrs);
mergeDefaultOption = config: loc: defs: mergeDefaultOption = loc: defs:
let list = getValues defs; in let list = getValues defs; in
if length list == 1 then head list if length list == 1 then head list
else if all isFunction list then x: mergeDefaultOption config loc (map (f: f x) list) else if all isFunction list then x: mergeDefaultOption loc (map (f: f x) list)
else if all isList list then concatLists list else if all isList list then concatLists list
else if all isAttrs list then foldl' lib.mergeAttrs {} list else if all isAttrs list then foldl' lib.mergeAttrs {} list
else if all isBool list then foldl' lib.or false list else if all isBool list then foldl' lib.or false list
@ -61,14 +59,14 @@ rec {
else if all isInt list && all (x: x == head list) list then head list else if all isInt list && all (x: x == head list) list then head list
else throw "Cannot merge definitions of `${showOption loc}' given in ${showFiles (getFiles defs)}."; else throw "Cannot merge definitions of `${showOption loc}' given in ${showFiles (getFiles defs)}.";
mergeOneOption = config: loc: defs: mergeOneOption = loc: defs:
if defs == [] then abort "This case should never happen." if defs == [] then abort "This case should never happen."
else if length defs != 1 then else if length defs != 1 then
throw "The unique option `${showOption loc}' is defined multiple times, in ${showFiles (getFiles defs)}." throw "The unique option `${showOption loc}' is defined multiple times, in ${showFiles (getFiles defs)}."
else (head defs).value; else (head defs).value;
/* "Merge" option definitions by checking that they all have the same value. */ /* "Merge" option definitions by checking that they all have the same value. */
mergeEqualOption = config: loc: defs: mergeEqualOption = loc: defs:
if defs == [] then abort "This case should never happen." if defs == [] then abort "This case should never happen."
else foldl' (val: def: else foldl' (val: def:
if def.value != val then if def.value != val then
@ -79,154 +77,53 @@ rec {
getValues = map (x: x.value); getValues = map (x: x.value);
getFiles = map (x: x.file); getFiles = map (x: x.file);
# Generate documentation template from the list of option declaration like # Generate documentation template from the list of option declaration like
# the set generated with filterOptionSets. # the set generated with filterOptionSets.
optionAttrSetToDocList = optionAttrSetToDocList' []; optionAttrSetToDocList = optionAttrSetToDocList' [];
optionAttrSetToDocList' = prefix: internalModuleConfig: options: optionAttrSetToDocList' = prefix: options:
concatMap (opt: concatMap (opt:
let let
decls = filter (x: x != unknownModule) opt.declarations;
docOption = rec { docOption = rec {
name = showOption opt.loc; name = showOption opt.loc;
description = opt.description or (throw "Option `${name}' has no description."); description = opt.description or (throw "Option `${name}' has no description.");
declarations = decls; declarations = filter (x: x != unknownModule) opt.declarations;
internal = opt.internal or false; internal = opt.internal or false;
visible = opt.visible or true; visible = opt.visible or true;
readOnly = opt.readOnly or false; readOnly = opt.readOnly or false;
type = opt.type.name or null; type = opt.type.name or null;
} }
// (if opt ? example then { example = detectDerivation decls opt.example; } else {}) // (if opt ? example then { example = scrubOptionValue opt.example; } else {})
// (if opt ? default then { default = detectDerivation decls opt.default; } else {}) // (if opt ? default then { default = scrubOptionValue opt.default; } else {})
// (if opt ? defaultText then { default = opt.defaultText; } else {}); // (if opt ? defaultText then { default = opt.defaultText; } else {});
subOptions = subOptions =
let ss = opt.type.getSubOptionsPrefixed opt.loc; let ss = opt.type.getSubOptions opt.loc;
in if ss != {} then optionAttrSetToDocList' opt.loc internalModuleConfig (ss internalModuleConfig) else []; in if ss != {} then optionAttrSetToDocList' opt.loc ss else [];
in in
[ docOption ] ++ subOptions) (collect isOption options); [ docOption ] ++ subOptions) (collect isOption options);
# TODO: Use "extractOptionAttrSet" instead of "optionAttrSetToDocList'" to reduce the code size.
# It should be a drop-in-replacement. But first, examine the impact on the evaluation time.
# optionAttrSetToDocList = extractOptionAttrSet true [];
# Generate a machine readable specification of the list of option declarations. /* This function recursively removes all derivation attributes from
optionAttrSetToParseableSpecifications = extractOptionAttrSet false []; `x' except for the `name' attribute. This is to make the
generation of `options.xml' much more efficient: the XML
extractOptionAttrSet = toDoc: prefix: internalModuleConfig: options: representation of derivations is very large (on the order of
concatMap (opt: megabytes) and is not actually used by the manual generator. */
let scrubOptionValue = x:
optionName = showOption opt.loc;
# Check if a type contains derivations, that is check if a type nests
# a 'package', 'packageSet' or 'nixpkgsConfig' type.
hasDerivation = any (t: elem t opt.type.nestedTypes) ((map (x: x.typerep) (with types; [package packageSet])) ++ ["(nixpkgsConfig)"]);
# Check if type is 'path' which can potentially contain a derivation.
maybeHiddenDerivation = any (t: elem t opt.type.nestedTypes) (map (x: x.typerep) (with types; [path]));
isDefaultValue = elem opt.default opt.type.defaultValues;
/* Enforce that the example attribute is wrapped with 'literalExample'
for every type that contains derivations. */
example =
if opt ? example
then (if hasDerivation
then (if isLiteralExample opt.example
then { example = detectDerivation decls opt.example; }
else throw "The attribute ${optionName}.example must be wrapped with 'literalExample' in ${concatStringsSep " and " decls}!")
else { example = detectDerivation decls opt.example; })
else {};
/* Enforce that the 'defaultText' attribute is defined for every option
that has a 'default' attribute that contains derivations. */
default =
if opt ? default
then (if hasDerivation
then (if isDefaultValue
then { default = opt.default; }
else (if opt ? defaultText
then { default = literalExample (detectDerivation decls opt.defaultText); }
else throw "The option ${optionName} requires a 'defaultText' attribute in ${concatStringsSep " and " decls}!"))
else (if opt ? defaultText
then (if maybeHiddenDerivation
then (if (let eval = builtins.tryEval (findDerivation opt.default); in eval.success && !eval.value)
then builtins.trace
"The attribute ${optionName}.defaultText might not be necessary in ${concatStringsSep " and " decls}!"
{ default = literalExample (detectDerivation decls opt.defaultText); }
else { default = literalExample (detectDerivation decls opt.defaultText); })
else builtins.trace
"The attribute ${optionName}.defaultText is not used and can be removed in ${concatStringsSep " and " decls}!"
{ default = detectDerivation decls opt.default; })
else { default = detectDerivation decls opt.default; }))
else {};
decls = filter (x: x != unknownModule) opt.declarations;
docOption = {
name = optionName;
description = opt.description or (throw "Option `${optionName}' has no description.");
declarations = decls;
internal = opt.internal or false;
visible = opt.visible or true;
readOnly = opt.readOnly or false;
} // example // default // subOptions // typeKeys;
typeKeys = if toDoc then { type = opt.type.name or null; } else { type = opt.type.typerep; keys = opt.loc; };
subOptions =
if toDoc
then {}
else let ss = opt.type.getSubOptions;
in if ss != {} then { suboptions = (extractOptionAttrSet false [] internalModuleConfig (ss internalModuleConfig)); } else {};
subOptionsDoc =
if toDoc
then let ss = opt.type.getSubOptionsPrefixed opt.loc;
in if ss != {} then extractOptionAttrSet true opt.loc internalModuleConfig (ss internalModuleConfig) else []
else [];
in
[ docOption ] ++ subOptionsDoc )
(filter (opt: (opt.visible or true) && !(opt.internal or false)) (collect isOption options));
/* This function recursively checks for derivations within an
an expression, and throws an error if a derivation or a
store path is found. The function is used to ensure that no
derivation leaks from the 'default' or 'example' attributes
of an option.
This makes the generation of `options.xml' much more efficient:
the XML representation of derivations is very large (on the
order of megabytes) and is not actually used by the manual
generator. */
detectDerivation = decl: x:
if isDerivation x then if isDerivation x then
throw "Found unexpected derivation in '${x.name}' in '${concatStringsSep " and " decl}'!" { type = "derivation"; drvPath = x.name; outPath = x.name; name = x.name; }
else if isString x && isStorePath x then else if isList x then map scrubOptionValue x
throw "Found unexpected store path in '${x.name}' in '${concatStringsSep " and " decl}'!" else if isAttrs x then mapAttrs (n: v: scrubOptionValue v) (removeAttrs x ["_args"])
else if isList x then map (detectDerivation decl) x
else if isAttrs x then mapAttrs (n: v: (detectDerivation decl) v) (removeAttrs x ["_args"])
else x; else x;
/* Same as detectDerivation, but returns a boolean instead of
throwing an exception. */
findDerivation = x:
if (isString x && isStorePath x) || isDerivation x then true
else if isList x then any findDerivation x
else if isAttrs x then any findDerivation (mapAttrsToList (_: v: v) (removeAttrs x ["_args"]))
else false;
/* For use in the ‘example’ option attribute. It causes the given /* For use in the ‘example’ option attribute. It causes the given
text to be included verbatim in documentation. This is necessary text to be included verbatim in documentation. This is necessary
for example values that are not simple values, e.g., for example values that are not simple values, e.g.,
functions. */ functions. */
# TODO: A more general name would probably be "literalNix".
literalExample = text: { _type = "literalExample"; inherit text; }; literalExample = text: { _type = "literalExample"; inherit text; };
isLiteralExample = x: isAttrs x && hasAttr "_type" x && x._type == "literalExample";
/* Helper functions. */ /* Helper functions. */
showOption = concatStringsSep "."; showOption = concatStringsSep ".";

221
lib/types.nix
View File

@ -1,8 +1,6 @@
# Definitions related to run-time type checking. Used in particular # Definitions related to run-time type checking. Used in particular
# to type-check NixOS configurations. # to type-check NixOS configurations.
let lib = import ./default.nix; in
with import ./lists.nix; with import ./lists.nix;
with import ./attrsets.nix; with import ./attrsets.nix;
with import ./options.nix; with import ./options.nix;
@ -23,8 +21,6 @@ rec {
mkOptionType = mkOptionType =
{ # Human-readable representation of the type. { # Human-readable representation of the type.
name name
, # Parseable representation of the type.
typerep
, # Function applied to each definition that should return true if , # Function applied to each definition that should return true if
# its type-correct, false otherwise. # its type-correct, false otherwise.
check ? (x: true) check ? (x: true)
@ -35,59 +31,40 @@ rec {
# definition values and locations (e.g. [ { file = "/foo.nix"; # definition values and locations (e.g. [ { file = "/foo.nix";
# value = 1; } { file = "/bar.nix"; value = 2 } ]). # value = 1; } { file = "/bar.nix"; value = 2 } ]).
merge ? mergeDefaultOption merge ? mergeDefaultOption
, # Return list of sub-options. , # Return a flat list of sub-options. Used to generate
getSubOptions ? {} # documentation.
, # Same as 'getSubOptions', but with extra information about the getSubOptions ? prefix: {}
# location of the option which is used to generate documentation.
getSubOptionsPrefixed ? null
, # List of modules if any, or null if none. , # List of modules if any, or null if none.
getSubModules ? null getSubModules ? null
, # Function for building the same option type with a different list of , # Function for building the same option type with a different list of
# modules. # modules.
substSubModules ? m: null substSubModules ? m: null
, # List of type representations (typerep) of all the elementary types
# that are nested within the type. For an elementary type the list is
# a singleton of the typerep of itself.
# NOTE: Must be specified for every container type!
nestedTypes ? null
, # List of all default values, and an empty list if no default value exists.
defaultValues ? []
}: }:
{ _type = "option-type"; { _type = "option-type";
inherit name typerep check merge getSubOptions getSubModules substSubModules defaultValues; inherit name check merge getSubOptions getSubModules substSubModules;
nestedTypes = if (isNull nestedTypes) then (singleton typerep) else nestedTypes;
getSubOptionsPrefixed = if (isNull getSubOptionsPrefixed) then (prefix: getSubOptions) else getSubOptionsPrefixed;
}; };
types = rec { types = rec {
#
# Elementary types
#
unspecified = mkOptionType { unspecified = mkOptionType {
name = "unspecified"; name = "unspecified";
typerep = "(unspecified)";
}; };
bool = mkOptionType { bool = mkOptionType {
name = "boolean"; name = "boolean";
typerep = "(boolean)";
check = isBool; check = isBool;
merge = mergeEqualOption; merge = mergeEqualOption;
}; };
int = mkOptionType { int = mkOptionType {
name = "integer"; name = "integer";
typerep = "(integer)";
check = isInt; check = isInt;
merge = mergeOneOption; merge = mergeOneOption;
}; };
str = mkOptionType { str = mkOptionType {
name = "string"; name = "string";
typerep = "(string)";
check = isString; check = isString;
merge = mergeOneOption; merge = mergeOneOption;
}; };
@ -95,111 +72,73 @@ rec {
# Merge multiple definitions by concatenating them (with the given # Merge multiple definitions by concatenating them (with the given
# separator between the values). # separator between the values).
separatedString = sep: mkOptionType { separatedString = sep: mkOptionType {
name = "string" + (optionalString (sep != "") " separated by ${sep}"); name = "string";
typerep = "(separatedString(${escape ["(" ")"] sep}))";
check = isString; check = isString;
merge = _module: loc: defs: concatStringsSep sep (getValues defs); merge = loc: defs: concatStringsSep sep (getValues defs);
}; };
lines = separatedString "\n" // { typerep = "(lines)"; }; lines = separatedString "\n";
commas = separatedString "," // { typerep = "(commas)"; }; commas = separatedString ",";
envVar = separatedString ":" // { typerep = "(envVar)"; }; envVar = separatedString ":";
# Deprecated; should not be used because it quietly concatenates # Deprecated; should not be used because it quietly concatenates
# strings, which is usually not what you want. # strings, which is usually not what you want.
string = separatedString "" // { typerep = "(string)"; }; string = separatedString "";
attrs = mkOptionType { attrs = mkOptionType {
name = "attribute set"; name = "attribute set";
typerep = "(attrs)";
check = isAttrs; check = isAttrs;
merge = _module: loc: foldl' (res: def: mergeAttrs res def.value) {}; merge = loc: foldl' (res: def: mergeAttrs res def.value) {};
}; };
# derivation is a reserved keyword. # derivation is a reserved keyword.
package = mkOptionType { package = mkOptionType {
name = "package"; name = "package";
typerep = "(package)";
check = x: isDerivation x || isStorePath x; check = x: isDerivation x || isStorePath x;
merge = _module: loc: defs: merge = loc: defs:
let res = mergeOneOption _module loc defs; let res = mergeOneOption loc defs;
in if isDerivation res then res else toDerivation res; in if isDerivation res then res else toDerivation res;
}; };
# The correct type of packageSet would be:
# packageSet = attrsOf (either package packageSet)
# (Not sure if nix would allow to define a recursive type.)
# However, currently it is not possible to check that a packageSet actually
# contains packages (that is derivations). The check 'isDerivation' is too
# eager for the current implementation of the assertion mechanism and of the
# licenses control mechanism. That means it is not generally possible to go
# into the attribute set of packages to check that every attribute would
# evaluate to a derivation if the package would actually be evaluated. Maybe
# that restriction can be lifted in the future, but for now the content of
# the packageSet is not checked.
# TODO: The 'merge' function is copied from 'mergeDefaultOption' to keep
# backwards compatibility with the 'unspecified' type that was used for
# package sets previously. Maybe review if the merge function has to change.
packageSet = mkOptionType {
name = "derivation set";
typerep = "(packageSet)";
check = isAttrs;
merge = _module: loc: defs: foldl' mergeAttrs {} (map (x: x.value) defs);
};
path = mkOptionType { path = mkOptionType {
name = "path"; name = "path";
typerep = "(path)";
# Hacky: there is no ‘isPath’ primop. # Hacky: there is no ‘isPath’ primop.
check = x: builtins.substring 0 1 (toString x) == "/"; check = x: builtins.substring 0 1 (toString x) == "/";
merge = mergeOneOption; merge = mergeOneOption;
}; };
#
# Container types
#
# drop this in the future: # drop this in the future:
list = builtins.trace "`types.list' is deprecated; use `types.listOf' instead" types.listOf; list = builtins.trace "`types.list' is deprecated; use `types.listOf' instead" types.listOf;
listOf = elemType: mkOptionType { listOf = elemType: mkOptionType {
name = "list of ${elemType.name}s"; name = "list of ${elemType.name}s";
typerep = "(listOf${elemType.typerep})";
check = isList; check = isList;
merge = _module: loc: defs: merge = loc: defs:
map (x: x.value) (filter (x: x ? value) (concatLists (imap (n: def: imap (m: def': map (x: x.value) (filter (x: x ? value) (concatLists (imap (n: def: imap (m: def':
(mergeDefinitions _module (mergeDefinitions
(loc ++ ["[definition ${toString n}-entry ${toString m}]"]) (loc ++ ["[definition ${toString n}-entry ${toString m}]"])
elemType elemType
[{ inherit (def) file; value = def'; }] [{ inherit (def) file; value = def'; }]
).optionalValue ).optionalValue
) def.value) defs))); ) def.value) defs)));
getSubOptions = elemType.getSubOptions; getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["*"]);
getSubOptionsPrefixed = prefix: elemType.getSubOptionsPrefixed (prefix ++ ["*"]);
getSubModules = elemType.getSubModules; getSubModules = elemType.getSubModules;
substSubModules = m: listOf (elemType.substSubModules m); substSubModules = m: listOf (elemType.substSubModules m);
nestedTypes = elemType.nestedTypes;
defaultValues = [[]];
}; };
attrsOf = elemType: mkOptionType { attrsOf = elemType: mkOptionType {
name = "attribute set of ${elemType.name}s"; name = "attribute set of ${elemType.name}s";
typerep = "(attrsOf${elemType.typerep})";
check = isAttrs; check = isAttrs;
merge = _module: loc: defs: merge = loc: defs:
mapAttrs (n: v: v.value) (filterAttrs (n: v: v ? value) (zipAttrsWith (name: defs: mapAttrs (n: v: v.value) (filterAttrs (n: v: v ? value) (zipAttrsWith (name: defs:
(mergeDefinitions _module (loc ++ [name]) elemType defs).optionalValue (mergeDefinitions (loc ++ [name]) elemType defs).optionalValue
) )
# Push down position info. # Push down position info.
(map (def: listToAttrs (mapAttrsToList (n: def': (map (def: listToAttrs (mapAttrsToList (n: def':
{ name = n; value = { inherit (def) file; value = def'; }; }) def.value)) defs))); { name = n; value = { inherit (def) file; value = def'; }; }) def.value)) defs)));
getSubOptions = elemType.getSubOptions; getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name>"]);
getSubOptionsPrefixed = prefix: elemType.getSubOptionsPrefixed (prefix ++ ["<name>"]);
getSubModules = elemType.getSubModules; getSubModules = elemType.getSubModules;
substSubModules = m: attrsOf (elemType.substSubModules m); substSubModules = m: attrsOf (elemType.substSubModules m);
nestedTypes = elemType.nestedTypes;
defaultValues = [{}];
}; };
# List or attribute set of ... # List or attribute set of ...
@ -220,23 +159,18 @@ rec {
attrOnly = attrsOf elemType; attrOnly = attrsOf elemType;
in mkOptionType { in mkOptionType {
name = "list or attribute set of ${elemType.name}s"; name = "list or attribute set of ${elemType.name}s";
typerep = "(loaOf${elemType.typerep})";
check = x: isList x || isAttrs x; check = x: isList x || isAttrs x;
merge = _module: loc: defs: attrOnly.merge _module loc (imap convertIfList defs); merge = loc: defs: attrOnly.merge loc (imap convertIfList defs);
getSubOptions = elemType.getSubOptions; getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name?>"]);
getSubOptionsPrefixed = prefix: elemType.getSubOptionsPrefixed (prefix ++ ["<name?>"]);
getSubModules = elemType.getSubModules; getSubModules = elemType.getSubModules;
substSubModules = m: loaOf (elemType.substSubModules m); substSubModules = m: loaOf (elemType.substSubModules m);
nestedTypes = elemType.nestedTypes;
defaultValues = [{} []];
}; };
# List or element of ... # List or element of ...
loeOf = elemType: mkOptionType { loeOf = elemType: mkOptionType {
name = "element or list of ${elemType.name}s"; name = "element or list of ${elemType.name}s";
typerep = "(loeOf${elemType.typerep})";
check = x: isList x || elemType.check x; check = x: isList x || elemType.check x;
merge = _module: loc: defs: merge = loc: defs:
let let
defs' = filterOverrides defs; defs' = filterOverrides defs;
res = (head defs').value; res = (head defs').value;
@ -247,39 +181,53 @@ rec {
else if !isString res then else if !isString res then
throw "The option `${showOption loc}' does not have a string value, in ${showFiles (getFiles defs)}." throw "The option `${showOption loc}' does not have a string value, in ${showFiles (getFiles defs)}."
else res; else res;
nestedTypes = elemType.nestedTypes;
defaultValues = [[]] ++ elemType.defaultValues;
}; };
uniq = elemType: mkOptionType { uniq = elemType: mkOptionType {
inherit (elemType) check; inherit (elemType) name check;
name = "unique ${elemType.name}";
typerep = "(uniq${elemType.typerep})";
merge = mergeOneOption; merge = mergeOneOption;
getSubOptions = elemType.getSubOptions; getSubOptions = elemType.getSubOptions;
getSubOptionsPrefixed = prefix: elemType.getSubOptionsPrefixed prefix;
getSubModules = elemType.getSubModules; getSubModules = elemType.getSubModules;
substSubModules = m: uniq (elemType.substSubModules m); substSubModules = m: uniq (elemType.substSubModules m);
nestedTypes = elemType.nestedTypes;
defaultValues = elemType.defaultValues;
}; };
nullOr = elemType: mkOptionType { nullOr = elemType: mkOptionType {
name = "null or ${elemType.name}"; name = "null or ${elemType.name}";
typerep = "(nullOr${elemType.typerep})";
check = x: x == null || elemType.check x; check = x: x == null || elemType.check x;
merge = _module: loc: defs: merge = loc: defs:
let nrNulls = count (def: def.value == null) defs; in let nrNulls = count (def: def.value == null) defs; in
if nrNulls == length defs then null if nrNulls == length defs then null
else if nrNulls != 0 then else if nrNulls != 0 then
throw "The option `${showOption loc}' is defined both null and not null, in ${showFiles (getFiles defs)}." throw "The option `${showOption loc}' is defined both null and not null, in ${showFiles (getFiles defs)}."
else elemType.merge _module loc defs; else elemType.merge loc defs;
getSubOptions = elemType.getSubOptions; getSubOptions = elemType.getSubOptions;
getSubOptionsPrefixed = prefix: elemType.getSubOptionsPrefixed prefix;
getSubModules = elemType.getSubModules; getSubModules = elemType.getSubModules;
substSubModules = m: nullOr (elemType.substSubModules m); substSubModules = m: nullOr (elemType.substSubModules m);
nestedTypes = elemType.nestedTypes; };
defaultValues = [null] ++ elemType.defaultValues;
submodule = opts:
let
opts' = toList opts;
inherit (import ./modules.nix) evalModules;
in
mkOptionType rec {
name = "submodule";
check = x: isAttrs x || isFunction x;
merge = loc: defs:
let
coerce = def: if isFunction def then def else { config = def; };
modules = opts' ++ map (def: { _file = def.file; imports = [(coerce def.value)]; }) defs;
in (evalModules {
inherit modules;
args.name = last loc;
prefix = loc;
}).config;
getSubOptions = prefix: (evalModules
{ modules = opts'; inherit prefix;
# FIXME: hack to get shit to evaluate.
args = { name = ""; }; }).options;
getSubModules = opts';
substSubModules = m: submodule m;
}; };
enum = values: enum = values:
@ -291,92 +239,23 @@ rec {
in in
mkOptionType { mkOptionType {
name = "one of ${concatMapStringsSep ", " show values}"; name = "one of ${concatMapStringsSep ", " show values}";
typerep = "(enum${concatMapStrings (x: "(${escape ["(" ")"] (builtins.toString x)})") values})";
check = flip elem values; check = flip elem values;
merge = mergeOneOption; merge = mergeOneOption;
nestedTypes = [];
}; };
either = t1: t2: mkOptionType { either = t1: t2: mkOptionType {
name = "${t1.name} or ${t2.name}"; name = "${t1.name} or ${t2.name}";
typerep = "(either${t1.typerep}${t2.typerep})";
check = x: t1.check x || t2.check x; check = x: t1.check x || t2.check x;
merge = mergeOneOption; merge = mergeOneOption;
nestedTypes = t1.nestedTypes ++ t2.nestedTypes;
defaultValues = t1.defaultValues ++ t2.defaultValues;
}; };
#
# Complex types
#
submodule = opts:
let
opts' = toList opts;
inherit (import ./modules.nix) evalModules;
filterVisible = filter (opt: (if opt ? visible then opt.visible else true) && (if opt ? internal then !opt.internal else true));
in
mkOptionType rec {
name = "submodule";
typerep = "(submodule)";
check = x: isAttrs x || isFunction x;
merge = _module: loc: defs:
let
internalModule = [ { inherit _module; } { _module.args.name = lib.mkForce (last loc); } ];
coerce = def: if isFunction def then def else { config = def; };
modules = opts' ++ internalModule ++ map (def: { _file = def.file; imports = [(coerce def.value)]; }) defs;
in (evalModules {
inherit modules;
prefix = loc;
}).config;
getSubOptions = getSubOptionsPrefixed [];
getSubOptionsPrefixed = prefix: _module:
let
# FIXME: hack to get shit to evaluate.
internalModule = [ { inherit _module; } { _module.args.name = lib.mkForce ""; } ];
in (evalModules {
modules = opts' ++ internalModule;
inherit prefix;
}).options;
getSubModules = opts';
substSubModules = m: submodule m;
nestedTypes = concatMap (opt: opt.type.nestedTypes) (collect (lib.isType "option") (getSubOptions {}));
defaultValues = [{}];
};
#
# Legacy types
#
# Obsolete alternative to configOf. It takes its option # Obsolete alternative to configOf. It takes its option
# declarations from the ‘options’ attribute of containing option # declarations from the ‘options’ attribute of containing option
# declaration. # declaration.
optionSet = mkOptionType { optionSet = mkOptionType {
name = /* builtins.trace "types.optionSet is deprecated; use types.submodule instead" */ "option set"; name = /* builtins.trace "types.optionSet is deprecated; use types.submodule instead" */ "option set";
typerep = "(optionSet)";
}; };
# Try to remove module options of that type wherever possible.
# A module option taking a function can not be introspected and documented properly.
functionTo = resultType:
mkOptionType {
name = "function to ${resultType.name}";
typerep = "(function${resultType.typerep})";
check = builtins.isFunction;
merge = mergeOneOption;
nestedTypes = resultType.nestedTypes;
defaultValues = map (x: {...}:x) resultType.nestedTypes; # INFO: It seems as nix can't compare functions, yet.
};
#
# misc
#
# Augment the given type with an additional type check function. # Augment the given type with an additional type check function.
addCheck = elemType: check: elemType // { check = x: elemType.check x && check x; }; addCheck = elemType: check: elemType // { check = x: elemType.check x && check x; };

2
nixos/default.nix
View File

@ -34,8 +34,6 @@ in
system = eval.config.system.build.toplevel; system = eval.config.system.build.toplevel;
typechecker = eval.config.system.build.typechecker;
vm = vmConfig.system.build.vm; vm = vmConfig.system.build.vm;
vmWithBootLoader = vmWithBootLoaderConfig.system.build.vm; vmWithBootLoader = vmWithBootLoaderConfig.system.build.vm;

6
nixos/doc/manual/default.nix
View File

@ -1,4 +1,4 @@
{ pkgs, options, internalModule, version, revision, extraSources ? [] }: { pkgs, options, version, revision, extraSources ? [] }:
with pkgs; with pkgs;
with pkgs.lib; with pkgs.lib;
@ -6,10 +6,8 @@ with pkgs.lib;
let let
# Remove invisible and internal options. # Remove invisible and internal options.
optionsList = filter (opt: opt.visible && !opt.internal) (optionAttrSetToDocList internalModule options); optionsList = filter (opt: opt.visible && !opt.internal) (optionAttrSetToDocList options);
# INFO: Please add 'defaultText' or 'literalExample' to the option
# definition to avoid this substitution!
# Replace functions by the string <function> # Replace functions by the string <function>
substFunction = x: substFunction = x:
if builtins.isAttrs x then mapAttrs (name: substFunction) x if builtins.isAttrs x then mapAttrs (name: substFunction) x

106
nixos/doc/manual/development/option-declarations.xml
View File

@ -8,7 +8,7 @@
<para>An option declaration specifies the name, type and description <para>An option declaration specifies the name, type and description
of a NixOS configuration option. It is illegal to define an option of a NixOS configuration option. It is illegal to define an option
that has not been declared in any module. A option declaration that hasn’t been declared in any module. A option declaration
generally looks like this: generally looks like this:
<programlisting> <programlisting>
@ -145,108 +145,6 @@ options = {
You can also create new types using the function You can also create new types using the function
<varname>mkOptionType</varname>. See <varname>mkOptionType</varname>. See
<filename>lib/types.nix</filename> in Nixpkgs for details. <filename>lib/types.nix</filename> in Nixpkgs for details.</para>
An option declaration must follow the following rules:
<itemizedlist mark='bullet'>
<listitem>
<para>A <varname>defaultText</varname> must be defined if and only if the type of the option
derives from <varname>package</varname>, <varname>packageSet</varname> or <varname>nixpkgsConfig
</varname>, and if and only if a <varname>default</varname> attribute is defined and if and only if
the value of the <varname>default</varname> attribute is not the default of the type of the
option declaration.
For example, a <varname>defaultText</varname> must be defined for
<programlisting>
type = types.listOf types.package;
default = [ pkgs.foo; ];
defaultText = "[ pkgs.foo; ]";
</programlisting>.
But no <varname>defaultText</varname> must be defined for
<programlisting>
type = types.listOf types.package;
default = [];
</programlisting>,
as <varname>[]</varname> is the default of <varname>types.listOf types.package</varname>.
</para>
</listitem>
<listitem>
<para>A <varname>defaultText</varname> can be defined if the type of the option derives from
<varname>path</varname> and if a <varname>default</varname> attribute is defined.</para>
</listitem>
<listitem>
<para>The value of the <varname>example</varname> attribute must be wrapped with <varname>
literalExample</varname> if the type of the option derives from <varname>package</varname>,
<varname>packageSet</varname> or <varname>nixpkgsConfig</varname>.</para>
</listitem>
<listitem>
<para>The value of <varname>defaultText</varname> and <varname>literalExample</varname> must
be a string which contains a valid nix expression. The nix expression has to evaluate in
<code>{pkgs}: <replaceable>value</replaceable></code>.
For example:
<itemizedlist>
<listitem>
<para>A <varname>defaultText</varname> could, e.g., be:
<programlisting>
type = types.package;
default = pkgs.foo;
defaultText = "pkgs.foo";
</programlisting>
But not <code>defaultText = "pkgs.foo;";</code>, as that
corresponds to <code>{pkgs}: pkgs.foo;</code>, which is an
invalid nix expression due to the ending with <varname>;</varname>.</para>
</listitem>
<listitem>
<para>A <varname>literalExample</varname> could be used as, e.g.:
<programlisting>
type = types.path;
example = literalExample "\"\${pkgs.bar}/bin/bar\"";
</programlisting>
But not <code>literalExample "\${pkgs.bar}/bin/bar";</code>, as that corresponds
to <code>{pkgs}: ${pkgs.bar}/bin/bar</code>, which is an invalid nix expression
as the <varname>path</varname> is not a <varname>string</varname> anymore.</para>
</listitem>
</itemizedlist></para>
</listitem>
<listitem>
<para>The <varname>type</varname> attribute must be defined for every option declaration.</para>
</listitem>
</itemizedlist>
NixOS ships the tool <varname>nixos-typecheck</varname> that can check an option declaration to:
<itemizedlist mark='bullet'>
<listitem>
<para>Enforce that an option declaration has a <varname>defaultText</varname> if and only if the
type of the option derives from <varname>package</varname>, <varname>packageSet</varname> or
<varname>nixpkgsConfig</varname> and if a <varname>default</varname> attribute is defined.</para>
</listitem>
<listitem>
<para>Enforce that the value of the <varname>example</varname> attribute is wrapped with <varname>
literalExample</varname> if the type of the option derives from <varname>package</varname>,
<varname>packageSet</varname> or <varname>nixpkgsConfig</varname>.</para>
</listitem>
<listitem>
<para>Warn if a <varname>defaultText</varname> is defined in an option declaration if the type of
the option does not derive from <varname>package</varname>, <varname>packageSet</varname> or
<varname>nixpkgsConfig</varname>.</para>
</listitem>
<listitem>
<para>Warn if no <varname>type</varname> is defined in an option declaration.</para>
</listitem>
</itemizedlist></para>
</section> </section>

15
nixos/lib/eval-config.nix
View File

@ -20,13 +20,8 @@
, # !!! See comment about args in lib/modules.nix , # !!! See comment about args in lib/modules.nix
specialArgs ? {} specialArgs ? {}
, modules , modules
, # Pass through a configuration of the internal modules declared
# in lib/modules.nix.
_module ? {}
, # !!! See comment about typeInference in lib/modules.nix
typeInference ? null
, # !!! See comment about check in lib/modules.nix , # !!! See comment about check in lib/modules.nix
check ? null check ? true
, prefix ? [] , prefix ? []
, lib ? import ../../lib , lib ? import ../../lib
}: }:
@ -46,17 +41,13 @@ let
}; };
}; };
internalModule = { _module = (_module
// (if isNull check then {} else { inherit check; })
// (if isNull typeInference then {} else { inherit typeInference; })); };
in rec { in rec {
# Merge the option definitions in all modules, forming the full # Merge the option definitions in all modules, forming the full
# system configuration. # system configuration.
inherit (lib.evalModules { inherit (lib.evalModules {
inherit prefix; inherit prefix check;
modules = modules ++ extraModules ++ baseModules ++ [ pkgsModule ] ++ [ internalModule ]; modules = modules ++ extraModules ++ baseModules ++ [ pkgsModule ];
args = extraArgs; args = extraArgs;
specialArgs = { modulesPath = ../modules; } // specialArgs; specialArgs = { modulesPath = ../modules; } // specialArgs;
}) config options; }) config options;

91
nixos/lib/typechecker.nix
View File

@ -1,91 +0,0 @@
{ config, lib, pkgs, baseModules, ... }:
with pkgs;
with pkgs.lib;
let
optionsSpecs = inferenceMode:
let
versionModule =
{ system.nixosVersionSuffix = config.system.nixosVersionSuffix;
system.nixosRevision = config.system.nixosRevision;
nixpkgs.system = config.nixpkgs.system;
};
internalModule = { _module = config._module; } // (if isNull inferenceMode then {} else { _module.typeInference = mkForce inferenceMode; });
eval = evalModules {
modules = [ versionModule ] ++ baseModules ++ [ internalModule ];
args = (config._module.args) // { modules = [ ]; };
};
# Remove invisible and internal options.
optionsSpecs' = filter (opt: opt.visible && !opt.internal) (optionAttrSetToParseableSpecifications config._module eval.options);
# INFO: Please add 'defaultText' or 'literalExample' to the option
# definition to avoid this exception!
substFunction = key: decls: x:
if builtins.isAttrs x then mapAttrs (name: substFunction key decls) x
else if builtins.isList x then map (substFunction key decls) x
else if builtins.isFunction x then throw "Found an unexpected <function> in ${key} declared in ${concatStringsSep " and " decls}."
else x;
prefix = toString ../..;
stripPrefix = fn:
if substring 0 (stringLength prefix) fn == prefix then
substring (stringLength prefix + 1) 1000 fn
else
fn;
# Clean up declaration sites to not refer to the NixOS source tree.
cleanupOptions = x: flip map x (opt:
let substFunction' = y: substFunction opt.name opt.declarations y;
in opt
// { declarations = map (fn: stripPrefix fn) opt.declarations; }
// optionalAttrs (opt ? example) { example = substFunction' opt.example; }
// optionalAttrs (opt ? default) { default = substFunction' opt.default; }
// optionalAttrs (opt ? type) { type = substFunction' opt.type; });
in
cleanupOptions optionsSpecs';
in
{
system.build.typechecker = {
# The NixOS options as machine readable specifications in JSON format.
specifications = stdenv.mkDerivation {
name = "options-specs-json";
buildCommand = ''
# Export list of options in different format.
dst=$out/share/doc/nixos
mkdir -p $dst
cp ${builtins.toFile "options.json" (builtins.unsafeDiscardStringContext (builtins.toJSON
(listToAttrs (map (o: { name = o.name; value = removeAttrs o ["name" "visible" "internal"]; }) (optionsSpecs null)))))
} $dst/options-specs.json
mkdir -p $out/nix-support
echo "file json $dst/options-specs.json" >> $out/nix-support/hydra-build-products
''; # */
meta.description = "List of NixOS options specifications in JSON format";
};
silent = listToAttrs (map (o: { name = o.name; value = removeAttrs o ["name" "visible" "internal"]; }) (optionsSpecs "silent"));
printAll = listToAttrs (map (o: { name = o.name; value = removeAttrs o ["name" "visible" "internal"]; }) (optionsSpecs "printAll"));
printUnspecified = listToAttrs (map (o: { name = o.name; value = removeAttrs o ["name" "visible" "internal"]; }) (optionsSpecs "printUnspecified"));
};
}

1
nixos/modules/config/i18n.nix
View File

@ -64,7 +64,6 @@ in
consoleKeyMap = mkOption { consoleKeyMap = mkOption {
type = mkOptionType { type = mkOptionType {
name = "string or path"; name = "string or path";
typerep = "(stringOrPath)";
check = t: (isString t || types.path.check t); check = t: (isString t || types.path.check t);
}; };

1
nixos/modules/config/sysctl.nix
View File

@ -6,7 +6,6 @@ let
sysctlOption = mkOptionType { sysctlOption = mkOptionType {
name = "sysctl option value"; name = "sysctl option value";
typerep = "(sysctl)";
check = val: check = val:
let let
checkType = x: isBool x || isString x || isInt x || isNull x; checkType = x: isBool x || isString x || isInt x || isNull x;

4
nixos/modules/installer/tools/nixos-option.sh
View File

@ -115,8 +115,8 @@ let
let name = head attrsNames; rest = tail attrsNames; in let name = head attrsNames; rest = tail attrsNames; in
if isOption result.options then if isOption result.options then
walkOptions rest { walkOptions rest {
options = result.options.type.getSubOptionsPrefix ""; options = result.options.type.getSubOptions "";
opt = ''(\${result.opt}.type.getSubOptionsPrefix "")''; opt = ''(\${result.opt}.type.getSubOptions "")'';
cfg = ''\${result.cfg}."\${name}"''; cfg = ''\${result.cfg}."\${name}"'';
} }
else else

52
nixos/modules/installer/tools/nixos-typecheck.sh
View File

@ -1,52 +0,0 @@
#! /bin/sh
#! @shell@
if [ -x "@shell@" ]; then export SHELL="@shell@"; fi;
set -e
showSyntax() {
cat >&1 << EOF
nixos-typecheck
usage:
nixos-typecheck [action] [args]
where:
action = silent | printAll | printUnspecified | getSpecs
with default action: printUnspecified
args = any argument supported by nix-build
EOF
}
# Parse the command line.
extraArgs=()
action=printUnspecified
while [ "$#" -gt 0 ]; do
i="$1"; shift 1
case "$i" in
--help)
showSyntax
;;
silent|printAll|printUnspecified|getSpecs)
action="$i"
;;
*)
extraArgs="$extraArgs $i"
;;
esac
done
if [ "$action" = silent ]; then
nix-build --no-out-link '<nixpkgs/nixos>' -A typechecker.silent $extraArgs
elif [ "$action" = printAll ]; then
nix-build --no-out-link '<nixpkgs/nixos>' -A typechecker.printAll $extraArgs
elif [ "$action" = printUnspecified ]; then
nix-build --no-out-link '<nixpkgs/nixos>' -A typechecker.printUnspecified $extraArgs
elif [ "$action" = getSpecs ]; then
ln -s $(nix-build --no-out-link '<nixpkgs/nixos>' -A typechecker.specifications $extraArgs)/share/doc/nixos/options-specs.json specifications.json
else
showSyntax
exit 1
fi

8
nixos/modules/installer/tools/tools.nix
View File

@ -54,11 +54,6 @@ let
inherit (config.system) nixosVersion nixosCodeName nixosRevision; inherit (config.system) nixosVersion nixosCodeName nixosRevision;
}; };
nixos-typecheck = makeProg {
name = "nixos-typecheck";
src = ./nixos-typecheck.sh;
};
in in
{ {
@ -72,11 +67,10 @@ in
nixos-generate-config nixos-generate-config
nixos-option nixos-option
nixos-version nixos-version
nixos-typecheck
]; ];
system.build = { system.build = {
inherit nixos-install nixos-generate-config nixos-option nixos-rebuild nixos-typecheck; inherit nixos-install nixos-generate-config nixos-option nixos-rebuild;
}; };
}; };

1
nixos/modules/misc/meta.nix
View File

@ -5,7 +5,6 @@ with lib;
let let
maintainer = mkOptionType { maintainer = mkOptionType {
name = "maintainer"; name = "maintainer";
typerep = "(maintainer)";
check = email: elem email (attrValues lib.maintainers); check = email: elem email (attrValues lib.maintainers);
merge = loc: defs: listToAttrs (singleton (nameValuePair (last defs).file (last defs).value)); merge = loc: defs: listToAttrs (singleton (nameValuePair (last defs).file (last defs).value));
}; };

15
nixos/modules/misc/nixpkgs.nix
View File

@ -2,8 +2,6 @@
with lib; with lib;
let
nixpkgsConfig = pkgs:
let let
isConfig = x: isConfig = x:
builtins.isAttrs x || builtins.isFunction x; builtins.isAttrs x || builtins.isFunction x;
@ -24,14 +22,13 @@ let
optCall lhs.packageOverrides pkgs // optCall lhs.packageOverrides pkgs //
optCall (attrByPath ["packageOverrides"] ({}) rhs) pkgs; optCall (attrByPath ["packageOverrides"] ({}) rhs) pkgs;
}; };
in
mkOptionType { configType = mkOptionType {
name = "nixpkgs config"; name = "nixpkgs config";
typerep = "(nixpkgsConfig)"; check = traceValIfNot isConfig;
check = lib.traceValIfNot isConfig; merge = args: fold (def: mergeConfig def.value) {};
merge = config: args: fold (def: mergeConfig def.value) {};
defaultValues = [{}];
}; };
in in
{ {
@ -49,7 +46,7 @@ in
}; };
} }
''; '';
type = nixpkgsConfig pkgs; type = configType;
description = '' description = ''
The configuration of the Nix Packages collection. (For The configuration of the Nix Packages collection. (For
details, see the Nixpkgs documentation.) It allows you to set details, see the Nixpkgs documentation.) It allows you to set

1
nixos/modules/module-list.nix
View File

@ -1,5 +1,4 @@
[ [
../lib/typechecker.nix
./config/debug-info.nix ./config/debug-info.nix
./config/fonts/corefonts.nix ./config/fonts/corefonts.nix
./config/fonts/fontconfig-ultimate.nix ./config/fonts/fontconfig-ultimate.nix

3
nixos/modules/services/misc/gitlab.nix
View File

@ -155,21 +155,18 @@ in {
packages.gitlab = mkOption { packages.gitlab = mkOption {
type = types.package; type = types.package;
default = pkgs.gitlab; default = pkgs.gitlab;
defaultText = "pkgs.gitlab";
description = "Reference to the gitlab package"; description = "Reference to the gitlab package";
}; };
packages.gitlab-shell = mkOption { packages.gitlab-shell = mkOption {
type = types.package; type = types.package;
default = pkgs.gitlab-shell; default = pkgs.gitlab-shell;
defaultText = "pkgs.gitlab-shell";
description = "Reference to the gitlab-shell package"; description = "Reference to the gitlab-shell package";
}; };
packages.gitlab-workhorse = mkOption { packages.gitlab-workhorse = mkOption {
type = types.package; type = types.package;
default = pkgs.gitlab-workhorse; default = pkgs.gitlab-workhorse;
defaultText = "pkgs.gitlab-workhorse";
description = "Reference to the gitlab-workhorse package"; description = "Reference to the gitlab-workhorse package";
}; };

4
nixos/modules/services/misc/ihaskell.nix
View File

@ -15,14 +15,12 @@ in
options = { options = {
services.ihaskell = { services.ihaskell = {
enable = mkOption { enable = mkOption {
type = lib.types.bool;
default = false; default = false;
example = true; example = true;
description = "Autostart an IHaskell notebook service."; description = "Autostart an IHaskell notebook service.";
}; };
haskellPackages = mkOption { haskellPackages = mkOption {
type = lib.types.packageSet;
default = pkgs.haskellPackages; default = pkgs.haskellPackages;
defaultText = "pkgs.haskellPackages"; defaultText = "pkgs.haskellPackages";
example = literalExample "pkgs.haskell.packages.ghc784"; example = literalExample "pkgs.haskell.packages.ghc784";
@ -35,9 +33,7 @@ in
}; };
extraPackages = mkOption { extraPackages = mkOption {
type = types.functionTo (types.listOf types.package);
default = self: []; default = self: [];
defaultText = "self: []";
example = literalExample '' example = literalExample ''
haskellPackages: [ haskellPackages: [
haskellPackages.wreq haskellPackages.wreq

5
nixos/modules/services/misc/nixos-manual.nix
View File

@ -17,8 +17,6 @@ let
nixpkgs.system = config.nixpkgs.system; nixpkgs.system = config.nixpkgs.system;
}; };
internalModule = { _module = config._module; };
/* For the purpose of generating docs, evaluate options with each derivation /* For the purpose of generating docs, evaluate options with each derivation
in `pkgs` (recursively) replaced by a fake with path "\${pkgs.attribute.path}". in `pkgs` (recursively) replaced by a fake with path "\${pkgs.attribute.path}".
It isn't perfect, but it seems to cover a vast majority of use cases. It isn't perfect, but it seems to cover a vast majority of use cases.
@ -31,7 +29,7 @@ let
options = options =
let let
scrubbedEval = evalModules { scrubbedEval = evalModules {
modules = [ versionModule ] ++ baseModules ++ [ internalModule ]; modules = [ versionModule ] ++ baseModules;
args = (config._module.args) // { modules = [ ]; }; args = (config._module.args) // { modules = [ ]; };
specialArgs = { pkgs = scrubDerivations "pkgs" pkgs; }; specialArgs = { pkgs = scrubDerivations "pkgs" pkgs; };
}; };
@ -45,7 +43,6 @@ let
) )
pkgSet; pkgSet;
in scrubbedEval.options; in scrubbedEval.options;
internalModule = config._module;
}; };
entry = "${manual.manual}/share/doc/nixos/index.html"; entry = "${manual.manual}/share/doc/nixos/index.html";

3
nixos/modules/services/web-servers/apache-httpd/default.nix
View File

@ -48,7 +48,8 @@ let
if svc ? function then svc.function if svc ? function then svc.function
else import (toString "${toString ./.}/${if svc ? serviceType then svc.serviceType else svc.serviceName}.nix"); else import (toString "${toString ./.}/${if svc ? serviceType then svc.serviceType else svc.serviceName}.nix");
config = (evalModules config = (evalModules
{ modules = [ { options = res.options; config = svc.config or svc; } ] ++ [ { _module.check = false; } ]; { modules = [ { options = res.options; config = svc.config or svc; } ];
check = false;
}).config; }).config;
defaults = { defaults = {
extraConfig = ""; extraConfig = "";

3
nixos/modules/services/x11/window-managers/xmonad.nix
View File

@ -16,7 +16,6 @@ in
services.xserver.windowManager.xmonad = { services.xserver.windowManager.xmonad = {
enable = mkEnableOption "xmonad"; enable = mkEnableOption "xmonad";
haskellPackages = mkOption { haskellPackages = mkOption {
type = lib.types.packageSet;
default = pkgs.haskellPackages; default = pkgs.haskellPackages;
defaultText = "pkgs.haskellPackages"; defaultText = "pkgs.haskellPackages";
example = literalExample "pkgs.haskell.packages.ghc784"; example = literalExample "pkgs.haskell.packages.ghc784";
@ -29,9 +28,7 @@ in
}; };
extraPackages = mkOption { extraPackages = mkOption {
type = lib.types.functionTo (lib.types.listOf lib.types.package);
default = self: []; default = self: [];
defaultText = "self: []";
example = literalExample '' example = literalExample ''
haskellPackages: [ haskellPackages: [
haskellPackages.xmonad-contrib haskellPackages.xmonad-contrib

1
nixos/modules/system/boot/kernel.nix
View File

@ -20,7 +20,6 @@ in
options = { options = {
boot.kernelPackages = mkOption { boot.kernelPackages = mkOption {
type = types.packageSet;
default = pkgs.linuxPackages; default = pkgs.linuxPackages;
# We don't want to evaluate all of linuxPackages for the manual # We don't want to evaluate all of linuxPackages for the manual
# - some of it might not even evaluate correctly. # - some of it might not even evaluate correctly.

5
nixos/modules/system/boot/systemd-unit-options.nix
View File

@ -17,15 +17,14 @@ in rec {
unitOption = mkOptionType { unitOption = mkOptionType {
name = "systemd option"; name = "systemd option";
typerep = "(systemdOption)"; merge = loc: defs:
merge = _module: loc: defs:
let let
defs' = filterOverrides defs; defs' = filterOverrides defs;
defs'' = getValues defs'; defs'' = getValues defs';
in in
if isList (head defs'') if isList (head defs'')
then concatLists defs'' then concatLists defs''
else mergeOneOption _module loc defs'; else mergeOneOption loc defs';
}; };
sharedOptions = { sharedOptions = {

2
nixos/release.nix
View File

@ -101,8 +101,6 @@ in rec {
manpages = buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.manpages); manpages = buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.manpages);
options = (buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.optionsJSON)).x86_64-linux; options = (buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.optionsJSON)).x86_64-linux;
optionsSpecs = (buildFromConfig ({ pkgs, ... }: { _module.typeInference = "silent"; }) (config: config.system.build.typechecker.specifications)).x86_64-linux;
# Build the initial ramdisk so Hydra can keep track of its size over time. # Build the initial ramdisk so Hydra can keep track of its size over time.
initialRamdisk = buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.initialRamdisk); initialRamdisk = buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.initialRamdisk);