Fix fontification of generic func names.

Now we fontify func names in generic invocations when there are more
than one type params (so we can be sure it is a func instantiation).

I also tweaked things to avoid fontifying "bar"
in (foo)(bar)(baz) (fixes #385).

We also support fontifying method names with type params even though
that isn't allowed yet.

Author: muirdm

go-mode.el

@@ -486,9 +486,9 @@ statements."
 
    (if go-fontify-function-calls
        ;; Function call/method name
-       `((,(concat "\\(" go-identifier-regexp "\\)[[:space:]]*(") 1 font-lock-function-name-face)
-         ;; Bracketed function call
-         (,(concat "[^[:word:][:multibyte:]](\\(" go-identifier-regexp "\\))[[:space:]]*(") 1 font-lock-function-name-face))
+       `((go--match-func-name
+          (1 font-lock-function-name-face nil t)
+          (2 font-lock-function-name-face nil t)))
      ;; Method name
      `((,go-func-meth-regexp 2 font-lock-function-name-face)))
 
@@ -1730,6 +1730,35 @@ We are looking for the right-hand-side of the type alias"
     found-match))
 
 
+(defconst go--match-func-name-re
+  (concat "\\(?:^\\|[^)]\\)(\\(" go-identifier-regexp "\\))(\\|\\(" go-identifier-regexp "\\)[[(]"))
+
+(defun go--match-func-name (end)
+  "Search for func names in decls and invocations."
+  (let (found-match)
+    (while (and
+            (not found-match)
+            ;; Match "(foo)(" or "foo[" or "foo(".
+            (re-search-forward go--match-func-name-re end t))
+      (if (eq (char-before) ?\()
+          ;; Followed directly by "(" is a match.
+          (setq found-match t)
+        ;; Followed by "[". We are a match if there is at least one
+        ;; comma between the "[" and "]", and if "]" is followed by
+        ;; "(".
+        (let ((commas 0))
+          (while (go--search-next-comma end ?\])
+            (cl-incf commas))
+          (forward-char)
+          (setq found-match (and
+                             ;; We found a comma (so we are sure these are type
+                             ;; params), or we are at file level (so we are sure
+                             ;; it is a func decl).
+                             (or (> commas 0) (= 0 (go-paren-level)))
+                             (eq (char-after) ?\())))))
+    found-match))
+
+
 (defconst go--map-value-re
   (concat "\\_<map\\_>\\[\\(?:\\[[^]]*\\]\\)*[^]]*\\]" go-type-name-regexp))
 

test/go-font-lock-test.el

@@ -61,6 +61,16 @@ QKfuncK (VfV TintT) {}
   (go--should-fontify "KvarK VvV TfooT[TbarT[TintT]]")
   (go--should-fontify "foo[TintT, KstructK{}, *Tfoo.ZebraT]"))
 
+(ert-deftest go--fontify-func ()
+  (go--should-fontify "KfuncK FfooF()")
+  (go--should-fontify "KfuncK FfooF[A TanyT]()")
+  (go--should-fontify "KfuncK (VfV TfooT) FfooF[A TanyT]()")
+  (go--should-fontify "FfooF(bar)")
+  (go--should-fontify "foo.FfooF(bar)")
+  (go--should-fontify "(FfooF)(foo)(foo)")
+  (go--should-fontify "{ foo[int](123) }")
+  (go--should-fontify "FfooF[TintT, TstringT](123)"))
+
 (ert-deftest go--fontify-struct ()
   (go--should-fontify "KstructK { i TintT }")
   (go--should-fontify "KstructK { a, b TintT }")