fix company-capf error when point is on (

Author: arne

el/sclang-language.el

@@ -60,7 +60,7 @@ The expressions are joined as alternatives with the \\| operator."
 (defconst sclang-method-name-special-regexp
   (concat
    "[" (regexp-quote sclang-method-name-special-chars) "]+")
-   "Regular expression matching method names composed of special characters.")
+  "Regular expression matching method names composed of special characters.")
 
 (defconst sclang-method-name-regexp
   (sclang-regexp-concat
@@ -102,10 +102,10 @@ A block is enclosed by parentheses where the opening parenthesis must
 be at the beginning of a line to avoid ambiguities.")
 
 (defconst sclang-beginning-of-defun-regexp
-    (sclang-regexp-concat
-     sclang-class-definition-regexp
-     sclang-block-regexp)
-    "Regular expression matching the beginning of defuns.
+  (sclang-regexp-concat
+   sclang-class-definition-regexp
+   sclang-block-regexp)
+  "Regular expression matching the beginning of defuns.
 
 The match is either the start of a class definition
 \(`sclang-class-definition-regexp') or the beginning of a code block
@@ -251,12 +251,12 @@ low-resource systems."
 (defun sclang-read-symbol (prompt &optional default predicate require-match inherit-input-method)
   (if sclang-use-symbol-table
       (cl-flet ((make-minibuffer-local-map
-	      (parent-keymap)
-	      (let ((map (make-sparse-keymap)))
-		(set-keymap-parent map parent-keymap)
-		;; override keys bound to valid symbols
-		(define-key map [??] 'self-insert-command)
-		map)))
+	          (parent-keymap)
+	          (let ((map (make-sparse-keymap)))
+		    (set-keymap-parent map parent-keymap)
+		    ;; override keys bound to valid symbols
+		    (define-key map [??] 'self-insert-command)
+		    map)))
 	(let ((symbol (sclang-get-symbol default))
 	      (minibuffer-local-completion-map (make-minibuffer-local-map
 						minibuffer-local-completion-map))
@@ -457,9 +457,10 @@ are considered."
   "Function used for `completion-at-point-functions' in `sclang-mode'."
   (let* ((end (point))
 	 (beg (save-excursion
-		(backward-sexp 1)
-		(skip-syntax-forward "'")
-		(point)))
+		(or (ignore-errors (backward-sexp 1)
+		                   (skip-syntax-forward "'")
+		                   (point))
+                    (point))))
 	 (pattern (buffer-substring-no-properties beg end))
 	 (case-fold-search nil)
 	 (predicate (if (sclang-class-name-p pattern)
@@ -770,45 +771,45 @@ Looks for all repetitive patterns in ITEMS recursively.  Therefore, it is
 computationally expensive, especially when ITEMS is a long list.  If you don't
 want smart pattern guessing, use `sclang-format' directly to format your Pseq."
   (cl-labels ((find-reps (items)
-	       (let (r)
-		 (while items
-		   (let ((ret (car items))
-			 (skip 1)
-			 (rep (length items)))
-		     (catch 'match-found
-		       (while (>= rep 2)
-			 (let ((i (/ (length items) rep)))
-			   (while (> i 0)
-			     (let ((sublst (cl-subseq items 0 i)))
-			       (when (catch 'equal
-				       (let ((a items))
-					 (cl-loop repeat rep do
-						  (let ((b sublst))
-						    (while b
-						      (unless (eql (car b) (car a))
-							(throw 'equal nil))
-						      (setq a (cdr a)
-							    b (cdr b)))))
-					 t))
-				 (setq ret (cons rep (if (> i 5)
-							 (find-reps sublst)
-						       sublst))
-				       skip (* i rep))
-				 (throw 'match-found t))
-			       (cl-decf i))))
-			 (cl-decf rep)))
-		     (accept-process-output nil 0 100)
-		     (message "Processed...%S" ret) ;; invent better progress info
-		     (setq r (append r (list ret))
-			   items (nthcdr skip items))))
-		 r))
+	        (let (r)
+		  (while items
+		    (let ((ret (car items))
+			  (skip 1)
+			  (rep (length items)))
+		      (catch 'match-found
+		        (while (>= rep 2)
+			  (let ((i (/ (length items) rep)))
+			    (while (> i 0)
+			      (let ((sublst (cl-subseq items 0 i)))
+			        (when (catch 'equal
+				        (let ((a items))
+					  (cl-loop repeat rep do
+						   (let ((b sublst))
+						     (while b
+						       (unless (eql (car b) (car a))
+							 (throw 'equal nil))
+						       (setq a (cdr a)
+							     b (cdr b)))))
+					  t))
+				  (setq ret (cons rep (if (> i 5)
+							  (find-reps sublst)
+						        sublst))
+				        skip (* i rep))
+				  (throw 'match-found t))
+			        (cl-decf i))))
+			  (cl-decf rep)))
+		      (accept-process-output nil 0 100)
+		      (message "Processed...%S" ret) ;; invent better progress info
+		      (setq r (append r (list ret))
+			    items (nthcdr skip items))))
+		  r))
 	      (elem-to-string (elem)
-	       (cond
-		((consp elem)
-		 (concat "Pseq([ "
-			 (mapconcat #'elem-to-string (cdr elem) ", ")
-			 (format " ], %d)" (car elem))))
-		(t (sclang-object-to-string elem)))))
+	        (cond
+		 ((consp elem)
+		  (concat "Pseq([ "
+			  (mapconcat #'elem-to-string (cdr elem) ", ")
+			  (format " ], %d)" (car elem))))
+		 (t (sclang-object-to-string elem)))))
     (let ((compressed (find-reps items)))
       (if (and (= (length compressed) 1) (consp (car compressed)))
 	  (elem-to-string (car compressed))