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

@@ -482,9 +482,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)))
 
@@ -1458,19 +1458,19 @@ the next comma or to the closing paren."
           (setq found-match t)))
 
       ;; Advance to next comma. We are done if there are no more commas.
-      (setq done (not (go--search-next-comma end))))
+      (setq done (not (go--search-next-comma end ?\)))))
     found-match))
 
-(defun go--search-next-comma (end)
+(defun go--search-next-comma (end closer)
   "Search forward from point for a comma whose nesting level is
 the same as point. If it reaches a closing parenthesis before a
 comma, it stops at it. Return non-nil if comma was found."
   (let ((orig-level (go-paren-level)))
     (while (and (< (point) end)
-                (or (looking-at-p "[^,)]")
+                (or (not (member (char-after) `(?, ,closer)))
                     (> (go-paren-level) orig-level)))
       (forward-char))
-    (when (and (looking-at-p ",")
+    (when (and (eq (char-after) ?,)
                (< (point) (1- end)))
       (forward-char)
       t)))
@@ -1502,7 +1502,7 @@ comma, it stops at it. Return non-nil if comma was found."
         (goto-char (match-end 1))
         (unless (member (match-string 1) go-constants)
           (setq found-match t)))
-      (setq done (not (go--search-next-comma end))))
+      (setq done (not (go--search-next-comma end ?\)))))
     found-match))
 
 (defun go--containing-decl ()
@@ -1705,6 +1705,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

@@ -58,6 +58,16 @@ QKfuncK (VfV TintT) {}
   (go--should-fontify "foo[int]")
   (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 }")