Fontify types in generic instantiation.

If there are more than one type params (e.g. "foo[one, two]") we can
be certain it is a generic instantiation and not another kind of index
expression.

Author: muirdm

go-mode.el

@@ -453,6 +453,12 @@ statements."
       (1 font-lock-type-face nil t)
       (2 font-lock-type-face nil t))
 
+     ;; Match multi type param instantiation such as "foo[int, string]".
+     ;; Does not match on "foo[int]" since that is ambiguous.
+     (go--match-type-instantiation
+      (1 font-lock-type-face nil t)
+      (2 font-lock-type-face nil t))
+
      ;; An anchored matcher for type switch case clauses.
      (go--match-type-switch-case
       (go--fontify-type-switch-case
@@ -1633,6 +1639,35 @@ succeeds."
                             (go--in-type-params-p))))))
     found-match))
 
+(defconst go--type-instantiation-re (concat go-type-name-regexp "\\s-*,\\|,\\s-*" go-type-name-regexp))
+
+(defun go--match-type-instantiation (end)
+  "Search for type params in type instantiations.
+
+We look for comma separated names within square brackets. That
+means this only matches for instantiations with more than one
+param."
+  (let (found-match)
+    (while (and
+            (not found-match)
+            ;; Look for "foo ," or ", foo" (i.e. a type name before or
+            ;; after a comma).
+            (re-search-forward go--type-instantiation-re end t))
+
+      (let ((match (match-string 1)))
+        ;; If we matched "foo ,", move back one char so we can see the
+        ;; comma again on the next iteration.
+        (if match
+            (backward-char)
+          (setq match (match-string 2)))
+
+        (setq found-match (and
+                           (not (member match go-mode-keywords))
+                           (save-excursion
+                             (go-goto-opening-parenthesis)
+                             (eq (char-after) ?\[))))))
+    found-match))
+
 (defconst go--single-func-result-re (concat ")[[:space:]]+" go-type-name-regexp "\\(?:$\\|[[:space:]),]\\)"))
 
 (defun go--match-single-func-result (end)

test/go-font-lock-test.el

@@ -53,6 +53,11 @@ QKfuncK (VfV TintT) {}
   (go--should-fontify "KfuncK FfooF[a TintT | TstringT | KstructK{} | *Tfoo.ZebraT](TintT) { }")
   (go--should-fontify "KinterfaceK { TintT | Tfloat64T }"))
 
+(ert-deftest go--fontify-type-instantiation ()
+  ;; ambiguous - leave it unfontified
+  (go--should-fontify "foo[int]")
+  (go--should-fontify "foo[TintT, KstructK{}, *Tfoo.ZebraT]"))
+
 (ert-deftest go--fontify-struct ()
   (go--should-fontify "KstructK { i TintT }")
   (go--should-fontify "KstructK { a, b TintT }")