tests: Run without substitutes.

* tests/builders.scm, tests/derivations.scm, tests/packages.scm: Set
  #:use-substitutes? #f for %STORE.

Add a preliminary `guix-package' command-line tool.

* guix-package.in, tests/guix-package.sh: New files.
* configure.ac: Output `guix-package'.
* Makefile.am (TESTS): Add `tests/guix-package.sh'.
  (bin_SCRIPTS): Add `guix-package'.

store: Add `store-path-package-name'.

* guix/store.scm (store-path-package-name): New procedure.
* tests/utils.scm ("store-path-package-name"): New test.

build: Add unit test for the `guix-build' command.

* tests/guix-build.sh: New file.
* Makefile.am (TESTS): Add it.
  (LOG_COMPILER): Rename to...
  (SCM_LOG_COMPILER): ... this.  Move flags to...
  (AM_SCM_LOG_FLAGS): ... this.
  (TEST_EXTENSIONS, SH_LOG_COMPILER, AM_SH_LOG_FLAGS): New variables.

Add (guix build union).

* guix/build/union.scm, tests/union.scm: New files.
* Makefile.am (MODULES): Add `guix/build/union.scm'.
  (TESTS): Add `tests/union.scm'.

tests: Use our own bootstrap tools.

* tests/builders.scm (%bootstrap-inputs): Use %BOOT0-INPUTS from the distro.
* tests/packages.scm (%bootstrap-inputs): Likewise.
* tests/derivations.scm (%coreutils): Alias for %BOOTSTRAP-COREUTILS&CO.

derivations: Pass the derivation of guile-for-build to `imported-files' & co.

* guix/derivations.scm (%guile-for-build): Initialize to #f.
  (imported-files, imported-modules, compiled-modules): Add `guile'
  keyword parameter.  Pass it down to `build-expression->derivation'.
  (build-expression->derivation)[guile-drv]: New variable.  Pass it as
  the #:guile parameter for `imported-modules' and `compiled-modules'.

* tests/derivations.scm: Set %GUILE-FOR-BUILD to the derivation of
  %BOOTSTRAP-GUILE.

store: Add `query-path-hash'.

* guix/store.scm (write-arg, read-arg): Add `base16' literal and
  corresponding rule.
  (query-path-hash): New operation.

* tests/derivations.scm ("fixed-output derivation"): Check whether
  `query-path-hash' returns a bytevector.

derivations: Compile the #:modules passed to `build-expression->derivation'.

* guix/derivations.scm (imported-files)[parent-dirs]: Move to...
  (parent-directories): ... here.  New procedure.
  (compiled-modules): New procedure.
  (build-expression->derivation): Use it.

* tests/derivations.scm ("build-expression->derivation with modules"):
  New test.

packages: Add support for system-dependent inputs.

* guix/packages.scm (package-derivation)[intern]: New procedure.  Pass
  #t as the `recursive?' argument, instead of #f.
  [expand-input]: New procedure, with code formerly in the body.
  Support inputs where the input is a procedure returning a file name or
  an <origin>.
  Use `expand-input' in the body.

* tests/packages.scm ("trivial with system-dependent input"): New test.

utils: Add `fold-port-matches' and `remove-store-references'.

* guix/build/utils.scm (fold-port-matches, remove-store-references): New
  procedures.

* tests/build-utils.scm ("fold-port-matches", "fold-port-matches,
  trickier", "fold-port-matches, with unmatched chars"): New tests.

tests: Use bootstrap and Nixpkgs inputs to be less costly.

* tests/builders.scm (%bootstrap-inputs, %bootstrap-guile): New
  variables.
  ("gnu-build"): Use them, by setting `#:implicit-inputs? #f' and `#:guile'.

* tests/packages.scm (%bootstrap-inputs, %bootstrap-guile): New
  variables.
  ("trivial"): Pass `#:guile %bootstrap-guile'.
  ("GNU Hello"): Use `package-with-explicit-inputs' to use
  %BOOTSTRAP-GUILE and %BOOTSTRAP-INPUTS.

distro: Rename (distro ...) to (distro packages ...).

* distro/base.scm, distro/ld-wrapper.scm: Move to `distro/packages'.
  Adjust LD-WRAPPER-BOOT3 input file name accordingly.
* Makefile.am (MODULES): Adjust accordingly.
* distro.scm (%distro-module-directory): Change to "/distro/packages".
* guix/build-system/gnu.scm (standard-inputs): Change module name
  to (distro packages base).
* tests/packages.scm (test-packages): Likewise.

Add (guix build-system trivial).

* guix/build-system/trivial.scm: New file.
* Makefile.am (MODULES): Add it.
* tests/packages.scm ("trivial"): New test.

* guix/packages.scm (package-derivation): Allow SOURCE to be #f.

define-record-type*: Add the `inherit' syntactic constructor keyword.

* guix/utils.scm (define-record-type*)[make-syntactic-constructor]: New
  `type' parameter.  Add the `inherit' keyword and corresponding support
  code.

* tests/utils.scm ("define-record-type* & inherit", "define-record-type*
  & inherit & letrec* behavior"): New tests.

build: Pass $(NIX_INSTANTIATE) to the build and test environments.

* Makefile.am (.scm.go): Define $NIX_INSTANTIATE.
  (TESTS_ENVIRONMENT): Likewise, and define $NIX_HASH.
* guix/utils.scm (nixpkgs-derivation): Use $NIX_INSTANTIATE when
  defined.

* tests/utils.scm (%nix-hash): New variable.
  ("sha256 & bytevector->nix-base32-string"): Use it.

Add `package-transitive-inputs'; use it to honor propagated inputs.

* guix/packages.scm (package-transitive-inputs): New procedure.
  (package-derivation): Use it to compute INPUTS.

* tests/packages.scm (dummy-package): New macro.
  ("package-transitive-inputs"): New test.

Add builder-side utilities for phases, stream editing, & co.

* guix/build/utils.scm (with-directory-excursion): New macro.
  (alist-cons-before, alist-cons-after, alist-replace): New procedures.
  (substitute): New procedure.

* tests/build-utils.scm: New file.

* Makefile.am (TESTS): Add `tests/build-utils.scm'.

define-record-type*: Add `letrec*' behavior.

* guix/utils.scm (define-record-type*)[make-syntactic-constructor]: Bind
  all the ((FIELD VALUE) ...) in a `letrec*'.  Adjust `field-value'
  accordingly.

* tests/utils.scm ("define-record-type* with letrec* behavior"): New
  test.

derivation: Coalesce multiple occurrences of the same input.

* guix/derivations.scm (write-derivation)[coalesce-duplicate-inputs]:
  New procedure.
  Use it to process INPUTS.

* tests/derivations.scm ("user of multiple-output derivation"): New
  test.