import: go: Append version to symbol name in the pinned version mode.

This allows importing packages with complicated version specific dependency
chains without the package symbol names colliding.

* doc/guix.texi (Invoking guix import): Document the --pin-versions option.
Mention that a specific version can be imported.  Remove the experimental
warning.
* guix/import/go.scm (go-module->guix-package-name)[version]: Add optional
argument.  Rewrite the character translation in terms of string-map.
(go-module->guix-package): Conditionally use dependencies whose symbol include
their version, based no the value of the PIN-VERSIONS? argument.
* guix/import/utils.scm (package->definition): Add a new case where the full
version string is appended to the package symbol.
* guix/scripts/import.scm (guix-import): Correctly print forms starting
with '(define-public [...]'.
* guix/scripts/import/go.scm (guix-import-go): Conditionally include the
version in the package symbols defined.

4 files changed, 46 insertions, 27 deletions

diff --git a/guix/import/go.scm b/guix/import/go.scm
index ca2b9c6fa0..bc53f8f558 100644
--- a/guix/import/go.scm
+++ b/guix/import/go.scm
@@ -428,15 +428,19 @@ hence the need to derive this information."
       (vcs-qualified-module-path->root-repo-url module-path)
       module-path))
 
-(define (go-module->guix-package-name module-path)
-  "Converts a module's path to the canonical Guix format for Go packages."
-  (string-downcase (string-append "go-" (string-replace-substring
-                                         (string-replace-substring
-                                          (string-replace-substring
-                                           module-path
-                                           "." "-")
-                                          "/" "-")
-                                         "_" "-"))))
+(define* (go-module->guix-package-name module-path #:optional version)
+  "Converts a module's path to the canonical Guix format for Go packages.
+Optionally include a VERSION string to append to the name."
+  ;; Map dot, slash and underscore characters to hyphens.
+  (let ((module-path* (string-map (lambda (c)
+                                    (if (member c '(#\. #\/ #\_))
+                                        #\-
+                                        c))
+                                  module-path)))
+    (string-downcase (string-append "go-" module-path*
+                                    (if version
+                                        (string-append "-" version)
+                                        "")))))
 
 (define (strip-.git-suffix/maybe repo-url)
   "Strip a repository URL '.git' suffix from REPO-URL if hosted at GitHub."
@@ -575,6 +579,8 @@ When VERSION is unspecified, the latest version available is used."
   (let* ((available-versions (go-module-available-versions goproxy module-path))
          (version* (or version
                        (go-module-version-string goproxy module-path))) ;latest
+         ;; Elide the "v" prefix Go uses.
+         (strip-v-prefix (cut string-trim <> #\v))
          ;; Pseudo-versions do not appear in the versions list; skip the
          ;; following check.
          (_ (unless (or (go-pseudo-version? version*)
@@ -584,7 +590,9 @@ hint: use one of the following available versions ~a\n"
                              version* available-versions))))
          (content (fetch-go.mod goproxy module-path version*))
          (dependencies+versions (parse-go.mod content))
-         (dependencies (map car dependencies+versions))
+         (dependencies (if pin-versions?
+                           dependencies+versions
+                           (map car dependencies+versions)))
          (guix-name (go-module->guix-package-name module-path))
          (root-module-path (module-path->repository-root module-path))
          ;; The VCS type and URL are not included in goproxy information. For
@@ -598,23 +606,27 @@ hint: use one of the following available versions ~a\n"
     (values
      `(package
         (name ,guix-name)
-        ;; Elide the "v" prefix Go uses
-        (version ,(string-trim version* #\v))
+        (version ,(strip-v-prefix version*))
         (source
          ,(vcs->origin vcs-type vcs-repo-url version*))
         (build-system go-build-system)
         (arguments
          '(#:import-path ,root-module-path))
-        ,@(maybe-propagated-inputs (map go-module->guix-package-name
-                                        dependencies))
+        ,@(maybe-propagated-inputs
+           (map (match-lambda
+                  ((name version)
+                   (go-module->guix-package-name name (strip-v-prefix version)))
+                  (name
+                   (go-module->guix-package-name name)))
+                dependencies))
         (home-page ,(format #f "https://~a" root-module-path))
         (synopsis ,synopsis)
         (description ,(and=> description beautify-description))
         (license ,(match (list->licenses licenses)
-                    (() #f)             ;unknown license
-                    ((license)          ;a single license
+                    (() #f)                        ;unknown license
+                    ((license)                     ;a single license
                      license)
-                    ((license ...)      ;a list of licenses
+                    ((license ...)     ;a list of licenses
                      `(list ,@license)))))
      (if pin-versions?
          dependencies+versions
diff --git a/guix/import/utils.scm b/guix/import/utils.scm
index adf90f84d7..d817318a91 100644
--- a/guix/import/utils.scm
+++ b/guix/import/utils.scm
@@ -274,8 +274,9 @@ snippet generated is for regular inputs."
   (maybe-inputs package-names output #:type 'propagated))
 
 (define* (package->definition guix-package #:optional append-version?/string)
-  "If APPEND-VERSION?/STRING is #t, append the package's major+minor
-version. If APPEND-VERSION?/string is a string, append this string."
+  "If APPEND-VERSION?/STRING is #t, append the package's major+minor version.
+If it is the symbol 'full, append the package's complete version.  If
+APPEND-VERSION?/string is a string, append this string."
   (match guix-package
     ((or
       ('package ('name name) ('version version) . rest)
@@ -287,6 +288,8 @@ version. If APPEND-VERSION?/string is a string, append this string."
                          (string-append name "-" append-version?/string))
                         ((eq? append-version?/string #t)
                          (string-append name "-" (version-major+minor version)))
+                        ((eq? 'full append-version?/string)
+                         (string-append name "-" version))
                         (else name)))
         ,guix-package))))
 
diff --git a/guix/scripts/import.scm b/guix/scripts/import.scm
index 1d2b45d942..98554ef79b 100644
--- a/guix/scripts/import.scm
+++ b/guix/scripts/import.scm
@@ -119,7 +119,8 @@ Run IMPORTER with ARGS.\n"))
                                             (current-output-port))))))
            (match (apply (resolve-importer importer) args)
              ((and expr (or ('package _ ...)
-                            ('let _ ...)))
+                            ('let _ ...)
+                            ('define-public _ ...)))
               (print expr))
              ((? list? expressions)
               (for-each (lambda (expr)
diff --git a/guix/scripts/import/go.scm b/guix/scripts/import/go.scm
index 33d2470ce1..04b07f80cc 100644
--- a/guix/scripts/import/go.scm
+++ b/guix/scripts/import/go.scm
@@ -22,9 +22,11 @@
   #:use-module (guix utils)
   #:use-module (guix scripts)
   #:use-module (guix import go)
+  #:use-module (guix import utils)
   #:use-module (guix scripts import)
   #:use-module (srfi srfi-1)
   #:use-module (srfi srfi-11)
+  #:use-module (srfi srfi-26)
   #:use-module (srfi srfi-37)
   #:use-module (ice-9 match)
   #:use-module (ice-9 format)
@@ -94,7 +96,12 @@ that are not yet in Guix"))
                              (('argument . value)
                               value)
                              (_ #f))
-                           (reverse opts))))
+                           (reverse opts)))
+         ;; Append the full version to the package symbol name when using
+         ;; pinned versions.
+         (package->definition* (if (assoc-ref opts 'pin-versions?)
+                                   (cut package->definition <> 'full)
+                                   package->definition)))
     (match args
       ((spec)                         ;e.g., github.com/golang/protobuf@v1.3.1
        (receive (name version)
@@ -106,18 +113,14 @@ that are not yet in Guix"))
                                 (assoc-ref opts 'pin-versions?))))
            (if (assoc-ref opts 'recursive)
                ;; Recursive import.
-               (map (match-lambda
-                      ((and ('package ('name name) . rest) pkg)
-                       `(define-public ,(string->symbol name)
-                          ,pkg))
-                      (_ #f))
+               (map package->definition*
                     (apply go-module-recursive-import arguments))
                ;; Single import.
                (let ((sexp (apply go-module->guix-package arguments)))
                  (unless sexp
                    (leave (G_ "failed to download meta-data for module '~a'~%")
                           module-name))
-                 sexp)))))
+                 (package->definition* sexp))))))
       (()
        (leave (G_ "too few arguments~%")))
       ((many ...)