From 11ae6c5d0d40c79483079d3cdfa1e7e85786ff20 Mon Sep 17 00:00:00 2001
From: Stefan Monnier <monnier@iro.umontreal.ca>
Date: Fri, 29 Sep 2000 03:30:04 +0000
Subject: [PATCH] (lisp-complete-symbol): Distinguish the let-binding case from
 the funcall case. (forward-sexp-function): New variable. (forward-sexp): Use
 it.

---
 lisp/emacs-lisp/lisp.el | 43 +++++++++++++++++++++++++++++------------
 1 file changed, 31 insertions(+), 12 deletions(-)

diff --git a/lisp/emacs-lisp/lisp.el b/lisp/emacs-lisp/lisp.el
index 90e02ee2bae..52912146be9 100644
--- a/lisp/emacs-lisp/lisp.el
+++ b/lisp/emacs-lisp/lisp.el
@@ -44,14 +44,20 @@ See function `beginning-of-defun'."
   :type 'boolean
   :group 'lisp)
 
+(defvar forward-sexp-function nil
+  "If non-nil, `forward-sexp' delegates to this function.
+Should take the same arguments and behave similarly to `forward-sexp'.")
+
 (defun forward-sexp (&optional arg)
   "Move forward across one balanced expression (sexp).
 With ARG, do it that many times.  Negative arg -N means
 move backward across N balanced expressions."
   (interactive "p")
   (or arg (setq arg 1))
-  (goto-char (or (scan-sexps (point) arg) (buffer-end arg)))
-  (if (< arg 0) (backward-prefix-chars)))
+  (if forward-sexp-function
+      (funcall forward-sexp-function arg)
+    (goto-char (or (scan-sexps (point) arg) (buffer-end arg)))
+    (if (< arg 0) (backward-prefix-chars))))
 
 (defun backward-sexp (&optional arg)
   "Move backward across one balanced expression (sexp).
@@ -354,19 +360,32 @@ considered."
   (interactive)
   (let* ((end (point))
 	 (beg (with-syntax-table emacs-lisp-mode-syntax-table
-		  (save-excursion
-		    (backward-sexp 1)
-		    (while (= (char-syntax (following-char)) ?\')
-		      (forward-char 1))
-		    (point))))
+		(save-excursion
+		  (backward-sexp 1)
+		  (while (= (char-syntax (following-char)) ?\')
+		    (forward-char 1))
+		  (point))))
 	 (pattern (buffer-substring-no-properties beg end))
 	 (predicate
 	  (or predicate
-	      (if (eq (char-after (1- beg)) ?\()
-		  'fboundp
-		(function (lambda (sym)
-			    (or (boundp sym) (fboundp sym)
-				(symbol-plist sym)))))))
+	      (save-excursion
+		(goto-char beg)
+		(if (not (eq (char-before) ?\())
+		    (lambda (sym)	;why not just nil ?   -sm
+		      (or (boundp sym) (fboundp sym)
+			  (symbol-plist sym)))
+		  ;; Looks like a funcall position.  Let's double check.
+		  (backward-char 1)	;skip paren
+		  (if (condition-case nil
+			  (progn (up-list -2) (forward-char 1)
+				 (eq (char-after) ?\())
+			(error nil))
+		      ;; If the first element of the parent list is an open
+		      ;; parenthesis we are probably not in a funcall position.
+		      ;; Maybe a `let' varlist or something.
+		      nil
+		    ;; Else, we assume that a function name is expected.
+		    'fboundp)))))
 	 (completion (try-completion pattern obarray predicate)))
     (cond ((eq completion t))
 	  ((null completion)
-- 
2.39.2