[nongnu] elpa/scala-mode e277378 143/217: WIP on end-of-defun and beggining of defun which should make writing imenu functionality much easier.

[ELPA Syncer]

branch: elpa/scala-mode
commit e277378dcf405bdac78dfd7414be3aeda792041b
Author: Ivan Malison <IvanMalison@gmail.com>
Commit: Ivan Malison <IvanMalison@gmail.com>

    WIP on end-of-defun and beggining of defun which should make writing imenu 
functionality much easier.
---
 scala-mode2-syntax.el | 312 +++++++++++++++++++++++++++++++-------------------
 1 file changed, 195 insertions(+), 117 deletions(-)

diff --git a/scala-mode2-syntax.el b/scala-mode2-syntax.el
index 1eeb109..fcf0ee1 100644
--- a/scala-mode2-syntax.el
+++ b/scala-mode2-syntax.el
@@ -18,6 +18,10 @@
 ;;; regular expressions, but can be used in declaring one.
 
 ;; single letter matching groups (Chapter 1)
+
+(defun scala-syntax:regexp-or (regexps)
+  (concat "\\(?:" (mapconcat 'identity regexps "\\|")  "\\)"))
+
 (defconst scala-syntax:hexDigit-group "0-9A-Fa-f")
 (defconst scala-syntax:UnicodeEscape-re (concat "\\\\u[" 
scala-syntax:hexDigit-group "]\\{4\\}"))
 
@@ -27,13 +31,13 @@
 (defconst scala-syntax:letter-group (concat scala-syntax:lower-group 
scala-syntax:upper-group)) ;; TODO: add Lt, Lo, Nl
 (defconst scala-syntax:digit-group "0-9")
 (defconst scala-syntax:letterOrDigit-group (concat
-                                            
scala-syntax:upperAndUnderscore-group
-                                            scala-syntax:lower-group
-                                            scala-syntax:digit-group))
+                                           
scala-syntax:upperAndUnderscore-group
+                                           scala-syntax:lower-group
+                                           scala-syntax:digit-group))
 (defconst scala-syntax:opchar-safe-group "!%&*+/?\\\\^|~-") ;; TODO: Sm, So
 (defconst scala-syntax:opchar-unsafe-group "#:<=>@")
 (defconst scala-syntax:opchar-group (concat scala-syntax:opchar-unsafe-group
-                                            scala-syntax:opchar-safe-group))
+                                           scala-syntax:opchar-safe-group))
 
 ;; Scala delimiters (Chapter 1), but no quotes
 (defconst scala-syntax:delimiter-group ".,;")
@@ -43,14 +47,14 @@
 (defconst scala-syntax:octalDigit-group "0-7")
 (defconst scala-syntax:decimalNumeral-re
   (concat "0"
-          "\\|[" scala-syntax:nonZeroDigit-group "][" scala-syntax:digit-group 
"]*"))
+         "\\|[" scala-syntax:nonZeroDigit-group "][" scala-syntax:digit-group 
"]*"))
 (defconst scala-syntax:hexNumeral-re (concat "0x[" scala-syntax:hexDigit-group 
"]+"))
 (defconst scala-syntax:octalNumeral-re (concat "0[" 
scala-syntax:octalDigit-group "]+"))
 (defconst scala-syntax:integerLiteral-re (concat "-?" ;; added from definition 
of literal
-                                                 "\\(" 
scala-syntax:hexNumeral-re
-                                                 "\\|" 
scala-syntax:octalNumeral-re
-                                                 "\\|" 
scala-syntax:decimalNumeral-re
-                                                 "\\)[Ll]?"))
+                                                "\\(" 
scala-syntax:hexNumeral-re
+                                                "\\|" 
scala-syntax:octalNumeral-re
+                                                "\\|" 
scala-syntax:decimalNumeral-re
+                                                "\\)[Ll]?"))
 
 
 ;; Floating Point Literal (Chapter 1.3.2)
@@ -58,12 +62,12 @@
 (defconst scala-syntax:floatType-re "[fFdD]")
 (defconst scala-syntax:floatingPointLiteral-re
   (concat "-?" ;; added from definition of literal
-          "\\([" scala-syntax:digit-group "]+\\.[" scala-syntax:digit-group 
"]*"
-          scala-syntax:exponentPart-re "?" scala-syntax:floatType-re "?"
-          "\\|" "\\.[" scala-syntax:digit-group "]+"
-          scala-syntax:exponentPart-re "?" scala-syntax:floatType-re "?"
-          "\\|" "[" scala-syntax:digit-group "]+" scala-syntax:exponentPart-re
-          "\\|" "[" scala-syntax:digit-group "]+" scala-syntax:floatType-re 
"\\)"))
+         "\\([" scala-syntax:digit-group "]+\\.[" scala-syntax:digit-group "]*"
+         scala-syntax:exponentPart-re "?" scala-syntax:floatType-re "?"
+         "\\|" "\\.[" scala-syntax:digit-group "]+"
+         scala-syntax:exponentPart-re "?" scala-syntax:floatType-re "?"
+         "\\|" "[" scala-syntax:digit-group "]+" scala-syntax:exponentPart-re
+         "\\|" "[" scala-syntax:digit-group "]+" scala-syntax:floatType-re 
"\\)"))
 
 (defconst scala-syntax:number-safe-start-re
   (concat "[^_" scala-syntax:letter-group "]"))
@@ -80,19 +84,19 @@
 ;; Character Literals (Chapter 1.3.4)
 (defconst scala-syntax:characterLiteral-re
   (concat "\\('\\)\\(" "[^\\\\]" ;; should be just printable char, but this is 
faster
-          "\\|" scala-syntax:escapeSequence-re
-          "\\|" scala-syntax:octalEscape-re
-          "\\|" scala-syntax:UnicodeEscape-re "\\)\\('\\)"))
+         "\\|" scala-syntax:escapeSequence-re
+         "\\|" scala-syntax:octalEscape-re
+         "\\|" scala-syntax:UnicodeEscape-re "\\)\\('\\)"))
 
 (defconst scala-syntax:string-escape-re
   (concat scala-syntax:escapeSequence-re
-          "\\|" scala-syntax:octalEscape-re
-          "\\|" scala-syntax:UnicodeEscape-re))
+         "\\|" scala-syntax:octalEscape-re
+         "\\|" scala-syntax:UnicodeEscape-re))
 
 ;; String Literals (Chapter 1.3.5)
 (defconst scala-syntax:stringElement-re
   (concat "\\(" "[^\n\"\\\\]"
-          "\\|" scala-syntax:string-escape-re  "\\)"))
+         "\\|" scala-syntax:string-escape-re  "\\)"))
 (defconst scala-syntax:oneLineStringLiteral-re (concat "\\(\"\\)" 
scala-syntax:stringElement-re "*\\(\"\\)"))
 (defconst scala-syntax:multiLineStringLiteral-start-re
   "\\(\"\\)\"\"\\(\"?\"?[^\"]\\)*")
@@ -100,10 +104,10 @@
   "\"\"+\\(\"\\)")
 (defconst scala-syntax:multiLineStringLiteral-re
   (concat scala-syntax:multiLineStringLiteral-start-re
-          scala-syntax:multiLineStringLiteral-end-re))
+         scala-syntax:multiLineStringLiteral-end-re))
 (defconst scala-syntax:stringLiteral-re
   (concat "\\(" scala-syntax:multiLineStringLiteral-re
-          "\\|" scala-syntax:oneLineStringLiteral-re "\\)" ))
+         "\\|" scala-syntax:oneLineStringLiteral-re "\\)" ))
 
 ;; If you change this or any of the used regex, be sure to
 ;; maintain this or update propertize function acordingly:
@@ -112,9 +116,9 @@
 ;; group 7 = string start, 9 = end
 (defconst scala-syntax:relaxed-char-and-string-literal-re
   (concat scala-syntax:characterLiteral-re
-          "\\|" scala-syntax:multiLineStringLiteral-start-re
-          "\\(?:" scala-syntax:multiLineStringLiteral-end-re "\\)?"
-          "\\|\\(\"\\)" "\\(\\\\.\\|[^\"\n\\]\\)*" "\\(\"\\)"))
+         "\\|" scala-syntax:multiLineStringLiteral-start-re
+         "\\(?:" scala-syntax:multiLineStringLiteral-end-re "\\)?"
+         "\\|\\(\"\\)" "\\(\\\\.\\|[^\"\n\\]\\)*" "\\(\"\\)"))
 
 ;; Identifiers (Chapter 1.1)
 (defconst scala-syntax:op-re
@@ -122,23 +126,23 @@
 (defconst scala-syntax:idrest-re
   ;; Eagerness of regexp causes problems with _. The following is a workaround,
   ;; but the resulting regexp matches only what SLS demands.
-  (concat "\\(" "[_]??" "[" scala-syntax:letter-group scala-syntax:digit-group 
"]+" "\\)*"
-          "\\(" "_+" scala-syntax:op-re "\\|" "_" "\\)?"))
+  (concat "\\(?:" "[_]??" "[" scala-syntax:letter-group 
scala-syntax:digit-group "]+" "\\)*"
+         "\\(?:" "_+" scala-syntax:op-re "\\|" "_" "\\)?"))
 (defconst scala-syntax:varid-re (concat "[" scala-syntax:lower-group "]" 
scala-syntax:idrest-re))
 (defconst scala-syntax:capitalid-re (concat "[" 
scala-syntax:upperAndUnderscore-group "]" scala-syntax:idrest-re))
 ;; alphaid introduce by SIP11
-(defconst scala-syntax:alphaid-re (concat "\\(" "[" scala-syntax:lower-group 
scala-syntax:upperAndUnderscore-group "]" scala-syntax:idrest-re "\\)"))
-(defconst scala-syntax:plainid-re (concat "\\(" scala-syntax:alphaid-re "\\|" 
scala-syntax:op-re "\\)"))
+(defconst scala-syntax:alphaid-re (concat "\\(?:" "[" scala-syntax:lower-group 
scala-syntax:upperAndUnderscore-group "]" scala-syntax:idrest-re "\\)"))
+(defconst scala-syntax:plainid-re (concat "\\(?:" scala-syntax:alphaid-re 
"\\|" scala-syntax:op-re "\\)"))
 ;; stringlit is referred to, but not defined Scala Language Specification 2.9
 ;; we define it as consisting of anything but '`' and newline
 (defconst scala-syntax:stringlit-re "[^`\n\r]")
 (defconst scala-syntax:quotedid-re (concat "`" scala-syntax:stringlit-re "`"))
-(defconst scala-syntax:id-re (concat "\\(" scala-syntax:plainid-re
-                              "\\|" scala-syntax:quotedid-re "\\)"))
+(defconst scala-syntax:id-re (concat "\\(?:" scala-syntax:plainid-re
+                                    "\\|" scala-syntax:quotedid-re "\\)"))
 (defconst scala-syntax:id-first-char-group
   (concat scala-syntax:lower-group
-          scala-syntax:upperAndUnderscore-group
-          scala-syntax:opchar-group))
+         scala-syntax:upperAndUnderscore-group
+         scala-syntax:opchar-group))
 
 ;; Symbol literals (Chapter 1.3.7)
 (defconst scala-syntax:symbolLiteral-re
@@ -148,12 +152,12 @@
 ;; Literals (Chapter 1.3)
 (defconst scala-syntax:literal-re
   (concat "\\(" scala-syntax:integerLiteral-re
-          "\\|" scala-syntax:floatingPointLiteral-re
-          "\\|" scala-syntax:booleanLiteral-re
-          "\\|" scala-syntax:characterLiteral-re
-          "\\|" scala-syntax:stringLiteral-re
-          "\\|" scala-syntax:symbolLiteral-re
-          "\\|" "null" "\\)"))
+         "\\|" scala-syntax:floatingPointLiteral-re
+         "\\|" scala-syntax:booleanLiteral-re
+         "\\|" scala-syntax:characterLiteral-re
+         "\\|" scala-syntax:stringLiteral-re
+         "\\|" scala-syntax:symbolLiteral-re
+         "\\|" "null" "\\)"))
 
 ;; Paths (Chapter 3.1)
 ;; emacs has a problem with these regex, don't use them
@@ -172,46 +176,46 @@
   (save-excursion
     (when (looking-at "\\<super\\>")
       (let ((beg (match-beginning 0)))
-        (when (and (goto-char (match-end 0))
-                   (or (when (= (char-after) ?.)
-                         (forward-char)
-                         t)
-                       (and (when (and (not (eobp)) (= (char-after) ?\[))
-                              (forward-char)
-                              t)
-                            (progn (scala-syntax:skip-forward-ignorable)
-                                   (looking-at scala-syntax:id-re))
-                            (progn (goto-char (match-end 0))
-                                   (scala-syntax:skip-forward-ignorable)
-                                   (when (and (not (eobp)) (= (char-after) 
?\]))
-                                     (forward-char)
-                                     t))
-                            (when (and (not (eobp)) (= (char-after) ?.))
-                              (forward-char)
-                              t)))
-                   (looking-at scala-syntax:id-re))
-          (set-match-data `(,beg ,(match-end 0)))
-          t)))))
+       (when (and (goto-char (match-end 0))
+                  (or (when (= (char-after) ?.)
+                        (forward-char)
+                        t)
+                      (and (when (and (not (eobp)) (= (char-after) ?\[))
+                             (forward-char)
+                             t)
+                           (progn (scala-syntax:skip-forward-ignorable)
+                                  (looking-at scala-syntax:id-re))
+                           (progn (goto-char (match-end 0))
+                                  (scala-syntax:skip-forward-ignorable)
+                                  (when (and (not (eobp)) (= (char-after) ?\]))
+                                    (forward-char)
+                                    t))
+                           (when (and (not (eobp)) (= (char-after) ?.))
+                             (forward-char)
+                             t)))
+                  (looking-at scala-syntax:id-re))
+         (set-match-data `(,beg ,(match-end 0)))
+         t)))))
 
 (defun scala-syntax:looking-at-stableIdOrPath (&optional path-p beg)
   (unless beg (setq beg (point)))
   (save-excursion
     (cond ((looking-at "\\<this\\>")
-           (goto-char (match-end 0))
-           (if (and (not (eobp)) (= (char-after) ?.))
-               (progn (forward-char)
-                      (scala-syntax:looking-at-stableIdOrPath path-p beg))
-             path-p))
-          ((or (scala-syntax:looking-at-super)
-               (and (not (or (looking-at scala-syntax:keywords-unsafe-re)
-                             (scala-syntax:looking-at-reserved-symbol nil)))
-                    (looking-at scala-syntax:id-re)))
-           (goto-char (match-end 0))
-           (if (and (not (eobp)) (= (char-after) ?.))
-               (progn (forward-char)
-                      (scala-syntax:looking-at-stableIdOrPath path-p beg))
-             (set-match-data `(,beg ,(match-end 0)))
-             (point))))))
+          (goto-char (match-end 0))
+          (if (and (not (eobp)) (= (char-after) ?.))
+              (progn (forward-char)
+                     (scala-syntax:looking-at-stableIdOrPath path-p beg))
+            path-p))
+         ((or (scala-syntax:looking-at-super)
+              (and (not (or (looking-at scala-syntax:keywords-unsafe-re)
+                            (scala-syntax:looking-at-reserved-symbol nil)))
+                   (looking-at scala-syntax:id-re)))
+          (goto-char (match-end 0))
+          (if (and (not (eobp)) (= (char-after) ?.))
+              (progn (forward-char)
+                     (scala-syntax:looking-at-stableIdOrPath path-p beg))
+            (set-match-data `(,beg ,(match-end 0)))
+            (point))))))
 
 (defun scala-syntax:looking-at-simplePattern-beginning ()
   (or (looking-at "[_(]")
@@ -221,11 +225,11 @@
 
 (defun scala-syntax:regexp-for-id (id)
   (let ((prefix-regex
-         (if (string-match scala-syntax:alphaid-re id)
-             "\\b" (concat "\\(^\\|[^" scala-syntax:opchar-group "]\\)")))
-        (suffix-regex
-         (if (string-match scala-syntax:op-re (substring id -1 nil))
-             (concat "\\([^" scala-syntax:opchar-group "]\\|$\\)") "\\b")))
+        (if (string-match scala-syntax:alphaid-re id)
+            "\\b" (concat "\\(^\\|[^" scala-syntax:opchar-group "]\\)")))
+       (suffix-regex
+        (if (string-match scala-syntax:op-re (substring id -1 nil))
+            (concat "\\([^" scala-syntax:opchar-group "]\\|$\\)") "\\b")))
     (concat prefix-regex id suffix-regex)))
 
 ;;;
@@ -261,8 +265,8 @@
 
 (defconst scala-syntax:other-keywords-unsafe-re
   (regexp-opt '("abstract" "case" "catch" "class" "def" "do" "else" "extends"
-                "final" "finally" "for" "forSome" "if" "implicit" "import"
-                "lazy" "match" "new" "object" "override" "package" "private"
+               "final" "finally" "for" "forSome" "if" "implicit" "import"
+               "lazy" "match" "new" "object" "override" "package" "private"
                 "protected" "return" "sealed" "throw" "trait" "try" "type"
                 "val" "var" "while" "with" "yield") 'words))
 
@@ -315,7 +319,6 @@
           "\\(:\\)"
           "\\(" scala-syntax:after-reserved-symbol-re "\\)"))
 
-
 (defconst scala-syntax:override-unsafe-re
   (regexp-opt '("override") 'words))
 
@@ -371,6 +374,9 @@
 (defconst scala-syntax:modifiers-re
   (concat "\\(^\\|[^`'_]\\)\\(" scala-syntax:modifiers-unsafe-re "\\)"))
 
+(defconst scala-syntax:whitespace-delimeted-modifiers-re
+  (concat " *\\(?:" scala-syntax:modifiers-unsafe-re "\\(?: *\\)" "\\)*"))
+
 (defconst scala-syntax:body-start-re
   (concat "=" scala-syntax:end-of-code-line-re)
   "A regexp for detecting if a line ends with '='")
@@ -391,6 +397,31 @@
 (defconst scala-syntax:class-or-object-re
   (regexp-opt '("class" "object") 'words))
 
+(defconst scala-syntax:top-level-definition-words-re
+  (regexp-opt '("class" "object" "trait") 'words))
+
+(defconst scala-syntax:member-definition-words-re
+  (regexp-opt '("val" "var" "def" "type") 'words))
+
+(defconst scala-syntax:definition-words-re
+  (regexp-opt '("class" "object" "trait" "val" "var" "def" "type") 'words))
+
+(defun scala-syntax:build-definition-re (words-re)
+  (concat scala-syntax:whitespace-delimeted-modifiers-re
+         words-re
+         "\\(?: *\\)"
+         "\\(?2:"
+         scala-syntax:id-re
+         "\\)"))
+
+(defconst scala-syntax:top-level-definition-re
+  (scala-syntax:build-definition-re 
scala-syntax:top-level-definition-words-re))
+
+(defconst scala-syntax:member-definition-re
+  (scala-syntax:build-definition-re scala-syntax:member-definition-words-re))
+
+(defconst scala-syntax:all-definition-re
+  (scala-syntax:build-definition-re scala-syntax:definition-words-re))
 
 ;;;;
 ;;;; Character syntax table and related syntax-propertize functions
@@ -799,6 +830,53 @@ end of the skipped expression."
   (when (= (skip-syntax-forward ".") 0)
     (goto-char (or (scan-sexps (point) 1) (buffer-end 1)))))
 
+(defun backward-sexp-forcing ()
+  (condition-case ex (backward-sexp) ('error (backward-char))))
+
+(defun scala-syntax:beginning-of-definition ()
+  "This function is not totally correct. Scala syntax is hard."
+  (interactive)
+  (let ((found-position
+        (save-excursion
+          (funcall 'backward-sexp-forcing)
+          (scala-syntax:search-re-movement-function 
scala-syntax:all-definition-re
+                                                    'backward-sexp-forcing))))
+    (when found-position (goto-char found-position))))
+
+(defun scala-syntax:end-of-definition ()
+  "This function is not totally correct. Scala syntax is hard."
+  (interactive)
+  (re-search-forward scala-syntax:all-definition-re)
+  (let ((found-position
+        (scala-syntax:search-re-movement-function 
scala-syntax:top-level-definition-re
+                                                  #'backward-sexp)))
+    (when found-position (goto-char found-position))))
+
+(defun find-brace-equals-or-next ()
+  (interactive)
+  (let ((found-position
+        (scala-syntax:search-re-movement-function
+         (scala-syntax:regexp-or
+          `(,scala-syntax:all-definition-re "=" "{"))
+         #'forward-sexp)))
+    (when found-position (goto-char found-position))))
+    
+
+(setq beginning-of-defun-function 'scala-syntax:beginning-of-defun)
+(setq end-of-defun-function 'scala-syntax:end-of-defun)
+
+(defun scala-syntax:search-re-movement-function (re movement-function)
+    "Applies movement-function until something matching re is matched by
+looking-at-p or the end/beginning of the buffer is reached.
+
+The position is returned if something is found, nil is returned if not.
+"
+    (save-excursion
+      (progn
+       (while (not (or (bobp) (eobp) (looking-at re)))
+              (funcall movement-function))
+            (if (looking-at re) (point) nil))))
+
 (defun scala-syntax:forward-token ()
   "Move forward one scala token, comment word or string word. It
 can be: start or end of list (value or type), id, reserved
@@ -833,46 +911,46 @@ is placed at the end of the skipped token."
      ;; otherwise forward-sexp
      (t (forward-sexp)))))
 
-(defun scala-syntax:backward-sexp ()
-  "Move backward one scala expression. It can be: parameter
+  (defun scala-syntax:backward-sexp ()
+    "Move backward one scala expression. It can be: parameter
   list (value or type), id, reserved symbol, keyword, block, or
   literal. Delimiters (.,;) and comments are skipped
   silently. Position is placed at the beginning of the skipped
   expression."
-  (interactive)
-  (syntax-propertize (point))
-  ;; for implementation comments, see scala-syntax:forward-sexp
-  (forward-comment (- (buffer-size)))
-  (while (> 0 (+ (skip-syntax-backward " ")
-                 (skip-chars-backward scala-syntax:delimiter-group))))
-
-  (when (= (skip-syntax-backward ".") 0)
-    (goto-char (or (scan-sexps (point) -1) (buffer-end -1)))
-    (backward-prefix-chars)))
-
-(defun scala-syntax:has-char-before (char end)
-  (save-excursion
-    (while (and (< (point) end)
-                (or (bobp)
-                    (/= (char-before) char)))
-      (scala-syntax:forward-sexp))
-    (when (= (char-before) char)
-      (scala-syntax:skip-forward-ignorable)
-      (> end (point)))))
-
-(defun scala-syntax:search-backward-sexp (re)
-  "Searches backward sexps until it reaches re, empty line or ;.
+    (interactive)
+    (syntax-propertize (point))
+    ;; for implementation comments, see scala-syntax:forward-sexp
+    (forward-comment (- (buffer-size)))
+    (while (> 0 (+ (skip-syntax-backward " ")
+                  (skip-chars-backward scala-syntax:delimiter-group))))
+
+    (when (= (skip-syntax-backward ".") 0)
+      (goto-char (or (scan-sexps (point) -1) (buffer-end -1)))
+      (backward-prefix-chars)))
+
+  (defun scala-syntax:has-char-before (char end)
+    (save-excursion
+      (while (and (< (point) end)
+                 (or (bobp)
+                     (/= (char-before) char)))
+       (scala-syntax:forward-sexp))
+      (when (= (char-before) char)
+       (scala-syntax:skip-forward-ignorable)
+       (> end (point)))))
+
+  (defun scala-syntax:search-backward-sexp (re)
+    "Searches backward sexps until it reaches re, empty line or ;.
 If re is found, point is set to beginning of re and the position
 is returned, otherwise nil is returned"
-  (let ((found (save-excursion
-                 (while (not (or (bobp)
-                                 (scala-syntax:looking-back-empty-line-p)
-                                 (scala-syntax:looking-back-token "[;,]")
-                                 (looking-at re)))
-                   (scala-syntax:backward-sexp))
-                 (if (looking-at re)
-                     (point)
-                   nil))))
+    (let ((found (save-excursion
+                  (while (not (or (bobp)
+                                  (scala-syntax:looking-back-empty-line-p)
+                                  (scala-syntax:looking-back-token "[;,]")
+                                  (looking-at re)))
+                    (scala-syntax:backward-sexp))
+                  (if (looking-at re)
+                      (point)
+                    nil))))
     (when found (goto-char found))))
 
 (defun scala-syntax:list-p (&optional point)