[nongnu] elpa/swift-mode 7a9cf18 382/496: Fix beginning/end-of-sentence

[ELPA Syncer]

branch: elpa/swift-mode
commit 7a9cf18d4aac87d4bfa4533e06b9af31321343c6
Author: taku0 <mxxouy6x3m_github@tatapa.org>
Commit: taku0 <mxxouy6x3m_github@tatapa.org>

    Fix beginning/end-of-sentence
    
    Add tests for beginning/end-of-sentence
---
 swift-mode-beginning-of-defun.el                   |  43 +++++---
 swift-mode-lexer.el                                |  41 ++++----
 .../beginning-of-defun/beginning-of-defun.swift    | 111 +++++++++++----------
 .../beginning-of-defun/beginning-of-sentence.swift |  59 +++++++++++
 test/swift-mode-test-beginning-of-defun.el         | 104 ++++++++++++++++---
 5 files changed, 262 insertions(+), 96 deletions(-)

diff --git a/swift-mode-beginning-of-defun.el b/swift-mode-beginning-of-defun.el
index 77619c6..baf99f2 100644
--- a/swift-mode-beginning-of-defun.el
+++ b/swift-mode-beginning-of-defun.el
@@ -218,6 +218,9 @@ Intended for internal use."
   (let ((chunk (swift-mode:chunk-after)))
     (when chunk
       (goto-char (swift-mode:chunk:start chunk))))
+  (when (and (eq (char-syntax (or (char-after) ?.)) ?w)
+             (eq (char-syntax (or (char-before) ?.)) ?w))
+    (swift-mode:forward-token))
   (let ((pos (point))
         (previous-token (save-excursion
                           (forward-comment (- (point)))
@@ -289,7 +292,7 @@ Statements include comments on the same line.
 Intended for internal use."
   (let ((pos (point)))
     (swift-mode:beginning-of-statement)
-    (when (eq pos (point))
+    (when (<= pos (point))
       (swift-mode:backward-token-or-list)
       (swift-mode:beginning-of-statement))))
 
@@ -336,6 +339,9 @@ Intended for internal use."
   (let ((chunk (swift-mode:chunk-after)))
     (when chunk
       (goto-char (swift-mode:chunk:start chunk))))
+  (when (and (eq (char-syntax (or (char-after) ?.)) ?w)
+             (eq (char-syntax (or (char-before) ?.)) ?w))
+    (swift-mode:backward-token))
   (forward-comment (point-max))
   (let ((pos (point))
         token)
@@ -808,6 +814,17 @@ In comments or strings, skip a sentence.  Otherwise, skip 
a stateement."
   "Skip forward a sentence in a comment.
 
 IS-SINGLE-LINE should be non-nil when called inside a single-line comment."
+  (when (and (not is-single-line)
+             (eq (char-before) ?/)
+             (eq (char-after) ?*))
+    (forward-char))
+  (when (and is-single-line
+             (< (point) (save-excursion
+                          (forward-line 0)
+                          (if (looking-at "\\s *//+")
+                              (match-end 0)
+                            (point)))))
+    (goto-char (match-end 0)))
   (let ((current-buffer (current-buffer))
         (pos (point))
         (comment-block-end-position
@@ -824,7 +841,8 @@ IS-SINGLE-LINE should be non-nil when called inside a 
single-line comment."
         (if is-single-line
             (while (re-search-forward "^[ \t]*/+[ \t]*" nil t)
               (replace-match ""))
-          (when (looking-at "\\*+")
+          (when (and (not (looking-at "\\*+/"))
+                     (looking-at "\\*+"))
             (replace-match ""))))
       ;; Forwards sentence.
       (let ((old-position (point)))
@@ -848,7 +866,14 @@ IS-SINGLE-LINE should be non-nil when called inside a 
single-line comment."
           (forward-line -1)
           (setq line-count (1+ line-count)))))
     (forward-line line-count)
-    (goto-char (- (line-end-position) offset-from-line-end))
+    (goto-char (- (if (and (not is-single-line)
+                           (eq (line-end-position)
+                               (save-excursion
+                                 (goto-char comment-block-end-position)
+                                 (line-end-position))))
+                      comment-block-end-position
+                    (line-end-position))
+                  offset-from-line-end))
     (or (/= (point) pos)
         (progn
           (goto-char comment-block-end-position)
@@ -901,7 +926,7 @@ IS-SINGLE-LINE should be non-nil when called inside a 
single-line comment."
     (or (< (point) pos)
         (progn
           (goto-char comment-block-beginning-position)
-          (swift-mode:backward-sentence-inside-code nil)))))
+          (swift-mode:backward-sentence-inside-code t)))))
 
 (defmacro swift-mode:with-temp-comment-buffer (&rest body)
   "Eval BODY inside a temporary buffer keeping sentence related variables."
@@ -1098,10 +1123,7 @@ the end of a sentence, keep the position."
         (progn (swift-mode:end-of-statement) t)
       (let ((pos (point)))
         (swift-mode:forward-statement)
-        (or (not (eobp))
-             (progn
-               (forward-comment (- (point)))
-               (< pos (point))))))))
+        (< pos (point))))))
 
 (defun swift-mode:backward-sentence-inside-code
     (&optional keep-position-if-at-beginning-of-sentence)
@@ -1118,10 +1140,7 @@ already at the beginning of a sentence, keep the 
position."
         (progn (swift-mode:beginning-of-statement) t)
       (let ((pos (point)))
         (swift-mode:backward-statement)
-        (or (not (bobp))
-            (progn
-              (forward-comment (point-max))
-              (< (point) pos)))))))
+        (< (point) pos)))))
 
 (defun swift-mode:kill-sentence (&optional arg)
   "Kill from the point to the end of sentences.
diff --git a/swift-mode-lexer.el b/swift-mode-lexer.el
index f17bdd5..97483e6 100644
--- a/swift-mode-lexer.el
+++ b/swift-mode-lexer.el
@@ -1331,23 +1331,30 @@ If this line ends with a single-line comment, goto just 
before the comment."
 If the cursor is outside of strings and comments, return nil.
 
 If PARSER-STATE is given, it is used instead of (syntax-ppss)."
-  (when (or (null parser-state) (number-or-marker-p parser-state))
-    (setq parser-state (save-excursion (syntax-ppss parser-state))))
-  (cond
-   ((eq (nth 3 parser-state) t)
-    (swift-mode:chunk 'multiline-string (nth 8 parser-state)))
-   ((nth 3 parser-state)
-    (swift-mode:chunk 'single-line-string (nth 8 parser-state)))
-   ((eq (nth 4 parser-state) t)
-    (swift-mode:chunk 'single-line-comment (nth 8 parser-state)))
-   ((nth 4 parser-state)
-    (swift-mode:chunk 'multiline-comment (nth 8 parser-state)))
-   ((and (eq (char-before) ?/) (eq (char-after) ?/))
-    (swift-mode:chunk 'single-line-comment (1- (point))))
-   ((and (eq (char-before) ?/) (eq (char-after) ?*))
-    (swift-mode:chunk 'multiline-comment (1- (point))))
-   (t
-    nil)))
+  (save-excursion
+    (when (number-or-marker-p parser-state)
+      (goto-char parser-state))
+    (when (or (null parser-state) (number-or-marker-p parser-state))
+      (setq parser-state (save-excursion (syntax-ppss parser-state))))
+    (cond
+     ((nth 3 parser-state)
+      ;; Syntax category "|" is attached to both single-line and multiline
+      ;; string delimiters.  So (nth 3 parser-state) may be t even for
+      ;; single-line string delimiters.
+      (if (save-excursion (goto-char (nth 8 parser-state))
+                          (looking-at "\"\"\""))
+          (swift-mode:chunk 'multiline-string (nth 8 parser-state))
+        (swift-mode:chunk 'single-line-string (nth 8 parser-state))))
+     ((eq (nth 4 parser-state) t)
+      (swift-mode:chunk 'single-line-comment (nth 8 parser-state)))
+     ((nth 4 parser-state)
+      (swift-mode:chunk 'multiline-comment (nth 8 parser-state)))
+     ((and (eq (char-before) ?/) (eq (char-after) ?/))
+      (swift-mode:chunk 'single-line-comment (1- (point))))
+     ((and (eq (char-before) ?/) (eq (char-after) ?*))
+      (swift-mode:chunk 'multiline-comment (1- (point))))
+     (t
+      nil))))
 
 (provide 'swift-mode-lexer)
 
diff --git a/test/swift-files/beginning-of-defun/beginning-of-defun.swift 
b/test/swift-files/beginning-of-defun/beginning-of-defun.swift
index b8b4d2d..df07581 100644
--- a/test/swift-files/beginning-of-defun/beginning-of-defun.swift
+++ b/test/swift-files/beginning-of-defun/beginning-of-defun.swift
@@ -1,8 +1,8 @@
-// Foo bar baz.
+// /*[*/Foo bar baz./*]*/
 
-// Import declarations
+// /*[*/Import declarations/*]*/
 
-/*{*//* aaa */ /* bbb */@Foo import Foundation/*}*/
+/*{*//* /*[*/aaa/*]*/ */ /* /*[*/bbb/*]*/ */@Foo import Foundation/*}*/
 /*{*/@Foo
 import Foundation/*}*/
 
@@ -12,7 +12,7 @@ import Foundation/*}*/
     import Foundation/*}*/
 }/*}*/
 
-// Constant/variable declarations
+// /*[*/Constant/variable declarations/*]*/
 
 /*{*/let x = foo()/*}*/
 /*{*/@Foo
@@ -31,40 +31,40 @@ let
       bar()/*}*/
 
     /*{*/var a: Int {
-        return 0
+        /*[*/return 0/*]*/
     }/*}*/
 
     /*{*/var a: Int {
         /*{*/@Foo
         get {
-            return 0
+            /*[*/return 0/*]*/
         }/*}*/
 
         /*{*/@Foo
         set {
-            foo()
+            /*[*/foo()/*]*/
         }/*}*/
      }/*}*/
 
     /*{*/var a = 0 {
         /*{*/@Foo
         willSet {
-            foo()
+            /*[*/foo()/*]*/
         }/*}*/
 
         /*{*/@Foo
         didSet {
-            foo()
+            /*[*/foo()/*]*/
         }/*}*/
     }/*}*/
 
     /*{*/class func foo() {
-        let x = foo()
-        let
+        /*[*/let x = foo()/*]*/
+        /*[*/let
           y
           =
-          bar()
-        while
+          bar()/*]*/
+        /*[*/while
           let
             x
             =
@@ -80,13 +80,13 @@ let
             )
             =
             ab {
-            foo()
-            foo()
-        }
+            /*[*/foo()/*]*/
+            /*[*/foo()/*]*/
+        }/*]*/
     }/*}*/
 }/*}*/
 
-// Type alias declarationss
+// /*[*/Type alias declarationss/*]*/
 
 /*{*/@Foo typealias A = B/*}*/
 
@@ -107,7 +107,7 @@ typealias
       B/*}*/
 }/*}*/
 
-// Function declarations
+// /*[*/Function declarations/*]*/
 
 /*{*/func foo() {
 }/*}*/
@@ -134,11 +134,11 @@ foo() {
           (Int -> [Int])
           =
           {
-              x
-              in
-              [
+              /*[*/x
+              in/*]*/
+              /*[*/[
                 x
-              ]
+              ]/*]*/
           }
       )
       throws
@@ -156,10 +156,11 @@ foo() {
           ==
           Int
     {
+        /*[*/foo()/*]*/
     }/*}*/
 }/*}*/
 
-// Enum declarations
+// /*[*/Enum declarations/*]*/
 
 /*{*/enum Foo<A> where A: B {
     /*{*/case Foo(a: Int)/*}*/
@@ -177,26 +178,26 @@ foo() {
         0/*}*/
 
     /*{*/func foo() -> a {
-        switch this {
-        case .Foo:
-            return a
-        case
+        /*[*/switch this {
+        /*[*/case .Foo:
+            /*[*/return a/*]*/
+        /*[*/case
           let .Bar(a):
-            return a
-        case
+            /*[*/return a/*]*/
+        /*[*/case
           .Baz(var a):
-            return a
-        }
+            /*[*/return a/*]*/
+        }/*]*/
     }/*}*/
 }/*}*/
 
 
-// Struct declarations
+// /*[*/Struct declarations/*]*/
 
 /*{*/struct Foo {
 }/*}*/
 
-// Class declarations
+// /*[*/Class declarations/*]*/
 
 /*{*/class Foo {
 }/*}*/
@@ -227,7 +228,7 @@ public
     }/*}*/
 }/*}*/
 
-// Protocol declarations
+// /*[*/Protocol declarations/*]*/
 
 /*{*/protocol Foo {
     /*{*/var x: Int {
@@ -251,11 +252,11 @@ public
           E/*}*/
 }/*}*/
 
-// Extension declarations
+// /*[*/Extension declarations/*]*/
 /*{*/extension Foo: AAA {
 }/*}*/
 
-// Operator declarations
+// /*[*/Operator declarations/*]*/
 /*{*/prefix
   operator
   +++/*}*/
@@ -268,52 +269,52 @@ public
   :
   AAA/*}*/
 
-// Precedence group declarations
+// /*[*/Precedence group declarations/*]*/
 /*{*/precedencegroup Foo {
-    higherThan: AAA, BBB, CCC
-    lowerThan: DDD, EEE, FFF
-    assignment: false
-    associativity: left
+    /*[*/higherThan: AAA, BBB, CCC/*]*/
+    /*[*/lowerThan: DDD, EEE, FFF/*]*/
+    /*[*/assignment: false/*]*/
+    /*[*/associativity: left/*]*/
 }/*}*/
 
 /*{*/class Foo {
-    // Initializer declarations
+    // /*[*/Initializer declarations/*]*/
     /*{*/init() {
-        `init`() {
-        }
+        /*[*/`init`() {
+        }/*]*/
     }/*}*/
 
-    // Deinitializer declarations
+    // /*[*/Deinitializer declarations/*]*/
     /*{*/deinit() {
     }/*}*/
 
-    // Subscript declarations
+    // /*[*/Subscript declarations/*]*/
     /*{*/subscript(x: Int) {
     }/*}*/
 }/*}*/
 
-// Multiple declaratoins in single line
+// /*[*/Multiple declaratoins in single line/*]*/
 
 /*{*/func foo(){};/*}*/ /*{*/func foo(){/*{*/func foo(){}/*}*/};/*}*//*{*/func 
foo(){} ;/*}*/ /*{*/func foo() {} /* */ ;/*}*/ /*{*//* */ func foo() {}/*}*/
 
-// Strings and comments
+// /*[*/Strings and comments/*]*/
 
 /*{*/let x = """
-  class Foo {}
+  /*[*/class Foo {}
   \(
-    { () in
+    { /*[*/() in/*]*/
         /*{*/class Foo {
         }/*}*/
-        return 0
+        /*[*/return 0/*]*/
     }()
   )
   """/*}*/
 
-// class Foo {}
+// /*[*/class Foo {}/*]*/
 
 /*
- class Foo {
- }
+ /*[*/class Foo {
+ }/*]*/
  */
 
-// Foo bar baz.
+// /*[*/Foo bar baz./*]*/
diff --git a/test/swift-files/beginning-of-defun/beginning-of-sentence.swift 
b/test/swift-files/beginning-of-defun/beginning-of-sentence.swift
new file mode 100644
index 0000000..892765a
--- /dev/null
+++ b/test/swift-files/beginning-of-defun/beginning-of-sentence.swift
@@ -0,0 +1,59 @@
+
+
+/*{*/let x = "abc./*]*/  /*[*/def."/*}*/
+
+// /*[*/aaa
+// bbb/*]*/
+//
+// /*[*/ccc
+// ddd/*]*/
+
+//
+// /*[*/eee
+// fff/*]*/
+//
+
+/////
+///// /*[*/eee
+///// fff/*]*/
+/////
+
+/**
+ /*[*/aaa./*]*/  /*[*/bbb
+ ccc/*]*/
+
+ /*[*/eee/*]*/
+ */
+
+/*{*/let x = 1/*}*/ // /*[*/aaa
+// aaa
+// bbb/*]*/
+
+/*{*/func foo() {
+    /// /*[*/aaa./*]*/  /*[*/bbb./*]*/
+    ///
+    /// /*[*/ccc./*]*/
+}/*}*/
+
+/*{*/let x = """
+  /*[*/aaa./*]*/
+  /*[*/bbb./*]*/
+  /*[*/ccc./*]*/
+  """ + """
+       /*[*/ddd./*]*/
+       /*[*/eee./*]*/
+       /*[*/fff./*]*/
+       """/*}*/
+
+
+/*{*/let x = """
+  /*[*/aaa./*]*/
+  /*[*/bbb \(
+    foo("aaa./*]*/  /*[*/bbb") + { /*[*/() in/*]*/
+        /*[*/foo()/*]*/
+        /*[*/return bar()/*]*/
+    }() + bar("aaa./*]*/  /*[*/bbb")
+  ) ccc./*]*/
+  """/*}*/
+
+
diff --git a/test/swift-mode-test-beginning-of-defun.el 
b/test/swift-mode-test-beginning-of-defun.el
index 129170f..1ada5d3 100644
--- a/test/swift-mode-test-beginning-of-defun.el
+++ b/test/swift-mode-test-beginning-of-defun.el
@@ -91,7 +91,19 @@ PROGRESS-REPORTER is the progress-reporter."
                   expected-positions-asc
                   #'>
                   #'swift-mode:end-of-defun
-                  'end-of-defun)))
+                  'end-of-defun)
+                 (list
+                  expected-positions-desc
+                  #'<
+                  (lambda ()
+                    (swift-mode:backward-sentence)
+                    (skip-syntax-forward " "))
+                  '(beginning-of-sentence beginning-of-defun))
+                 (list
+                  expected-positions-asc
+                  #'>
+                  #'swift-mode:forward-sentence
+                  '(end-of-sentence end-of-defun))))
           (setq current-line 0)
           (while (not (eobp))
             (when (not noninteractive)
@@ -117,13 +129,15 @@ PROGRESS-REPORTER is the progress-reporter."
 The result is a list of remarkable tokens in descendant order.  A remarkable
 token is a list with the follwing elements:
 
-1. Type; one of `beginning-of-defun', `end-of-defun', `{', or `}'
+1. Type; one of `beginning-of-defun', `end-of-defun', `beginning-of-sentence',
+`end-of-sentence', `{', or `}'
 2. Start position
 3. End position
 4. Nesting level at the start position
 5. Nesting level at the end position
 
-`beginning-of-defun' and `end-of-defun' are represented as /*{*/ and /*}*/,
+`beginning-of-defun', `end-of-defun', `beginning-of-sentence', and
+`end-of-sentence' are represented as /*{*/, /*}*/, /*[*/, and /*]*/,
 respectively, in the test file, and removed from the buffer.
 
 `{' and `}' includes square brackets and parentheses."
@@ -133,7 +147,13 @@ respectively, in the test file, and removed from the 
buffer.
            (list (list 'beginning-of-defun (point) (point) 0 0)))
           (depth 0)
           (pattern (mapconcat #'regexp-quote
-                              '("/*{*/" "/*}*/" "{" "}" "[" "]" "(" ")")
+                              '("/*{*/" "/*}*/" "/*[*/" "/*]*/"
+                                "{" "}" "[" "]" "(" ")"
+                                "/*" "*/"
+                                "//" "\n"
+                                "\"\"\""
+                                "\""
+                                )
                               "\\|"))
           match-string
           match-beginning
@@ -155,16 +175,74 @@ respectively, in the test file, and removed from the 
buffer.
                              match-beginning match-beginning
                              depth depth))
           (replace-match ""))
-         ((and (member match-string '("{" "[" "("))
+         ((equal match-string "/*[*/")
+          (add-to-list 'expected-positions
+                       (list 'beginning-of-sentence
+                             match-beginning match-beginning
+                             depth depth))
+          (replace-match ""))
+         ((equal match-string "/*]*/")
+          (add-to-list 'expected-positions
+                       (list 'end-of-sentence
+                             match-beginning match-beginning
+                             depth depth))
+          (replace-match ""))
+         ((and (member match-string '("{" "[" "(" "/*"))
                (not (swift-mode:chunk-after match-beginning)))
           (setq depth (1+ depth))
           (add-to-list 'expected-positions
                        (list '{ match-beginning match-end (1- depth) depth)))
-         ((and (member match-string '("}" "]" ")"))
+         ((and (member match-string '("}" "]" ")" "*/"))
                (not (swift-mode:chunk-after match-end)))
           (setq depth (1- depth))
           (add-to-list 'expected-positions
-                       (list '} match-beginning match-end (1+ depth) depth)))))
+                       (list '} match-beginning match-end (1+ depth) depth)))
+
+         ((and (equal match-string "//")
+               (not (swift-mode:chunk-after match-beginning)))
+          (setq depth (1+ depth))
+          (add-to-list 'expected-positions
+                       (list '{ match-beginning match-end (1- depth) depth)))
+         ((and (equal match-string "\n")
+               (eq (swift-mode:chunk:type
+                    (swift-mode:chunk-after match-beginning))
+                   'single-line-comment))
+          (if (looking-at "\\s *//")
+              ;; Fuses with next line.
+              (goto-char (match-end 0))
+            (setq depth (1- depth))
+            (add-to-list 'expected-positions
+                         (list '} match-beginning match-end (1+ depth) 
depth))))
+         ((and (equal match-string "\"\"\"")
+               (not (eq (char-before match-beginning) ?\\))
+               (not (swift-mode:chunk:comment-p
+                     (swift-mode:chunk-after match-beginning))))
+          (if (swift-mode:chunk:multiline-string-p
+               (swift-mode:chunk-after match-end))
+              (progn (setq depth (1+ depth))
+                     (add-to-list
+                      'expected-positions
+                      (list '{ match-beginning match-end (1- depth) depth)))
+            (setq depth (1- depth))
+            (add-to-list
+             'expected-positions
+             (list '} match-beginning match-end (1+ depth) depth))))
+         ((and (equal match-string "\"")
+               (not (eq (char-before match-beginning) ?\\))
+               (not (swift-mode:chunk:comment-p
+                     (swift-mode:chunk-after match-beginning)))
+               (not (swift-mode:chunk:multiline-string-p
+                     (swift-mode:chunk-after match-beginning))))
+          (if (swift-mode:chunk:single-line-string-p
+               (swift-mode:chunk-after match-end))
+              (progn (setq depth (1+ depth))
+                     (add-to-list
+                      'expected-positions
+                      (list '{ match-beginning match-end (1- depth) depth)))
+            (setq depth (1- depth))
+            (add-to-list
+             'expected-positions
+             (list '} match-beginning match-end (1+ depth) depth))))))
       (goto-char (point-max))
       (add-to-list 'expected-positions
                    (list 'end-of-defun (point) (point) depth depth))
@@ -177,7 +255,7 @@ respectively, in the test file, and removed from the buffer.
      expected-positions
      less-than-function
      beginning-of-thing-function
-     boundary-symbol)
+     boundary-symbols)
   "Run `beginning-of-defun' test for `swift-mode' on current line.
 
 SWIFT-FILE is the filename of the current test case.
@@ -189,8 +267,10 @@ LESS-THAN-FUNCTION is a function returns non-nil iff the 
firt argument is
 before (or after for `end-of-defun' test) the second argument.
 BEGINNING-OF-THING-FUNCTION is a function goes to the boundary, that is the
 beginning of a defun or the end of the defun..
-BOUNDARY-SYMBOL is the type of expected remarkable token, like
-`beginning-of-defun' or `end-of-defun`'"
+BOUNDARY-SYMBOLS is the type or the list of types of expected remarkable token,
+like `beginning-of-defun' or `end-of-defun'"
+  (when (symbolp boundary-symbols)
+    (setq boundary-symbols (list boundary-symbols)))
   (forward-line 0)
   (let ((status 'ok)
         depth
@@ -209,7 +289,7 @@ BOUNDARY-SYMBOL is the type of expected remarkable token, 
like
                     (lambda (position)
                       (setq depth (min depth (nth 2 position)))
                       (and
-                       (eq (nth 0 position) boundary-symbol)
+                       (memq (nth 0 position) boundary-symbols)
                        (funcall less-than-function (nth 1 position) (point))
                        (<= (nth 2 position) depth)))
                     expected-positions-before-point
@@ -223,7 +303,7 @@ BOUNDARY-SYMBOL is the type of expected remarkable token, 
like
          error-buffer swift-file current-line
          "error"
          (concat
-          (symbol-name boundary-symbol)
+          (symbol-name (car boundary-symbols))
           ": at "
           (prin1-to-string (point))
           ", expected "