[nongnu] elpa/smartparens c2b2e603f9 3/3: Merge pull request #1125 from woolsweater/swift-mode

[ELPA Syncer]

branch: elpa/smartparens
commit c2b2e603f904baff69e6606d11d5961ca298d332
Merge: 3ee3baf41f 7e5f169879
Author: Matus Goljer <matus.goljer@gmail.com>
Commit: GitHub <noreply@github.com>

    Merge pull request #1125 from woolsweater/swift-mode
    
    Add basic 'swift-mode' support
---
 Cask                           |   1 +
 smartparens-config.el          |   1 +
 smartparens-swift.el           | 117 ++++++++++++++++++++++++++++++++++++++
 test/smartparens-swift-test.el | 126 +++++++++++++++++++++++++++++++++++++++++
 4 files changed, 245 insertions(+)

diff --git a/Cask b/Cask
index 04bbff4b9d..bc87d58c78 100644
--- a/Cask
+++ b/Cask
@@ -16,6 +16,7 @@
   (depends-on "racket-mode")
   (depends-on "scala-mode")
   (depends-on "rust-mode")
+  (depends-on "swift-mode")
   (depends-on "auctex")
   (depends-on "clojure-mode")
   (depends-on "lua-mode")
diff --git a/smartparens-config.el b/smartparens-config.el
index 6e17e4b4b6..4ae1293ef7 100644
--- a/smartparens-config.el
+++ b/smartparens-config.el
@@ -123,6 +123,7 @@ ID, ACTION, CONTEXT."
 (eval-after-load 'rust-mode                '(require 'smartparens-rust))
 (eval-after-load 'rustic                   '(require 'smartparens-rust))
 (eval-after-load 'scala-mode               '(require 'smartparens-scala))
+(eval-after-load 'swift-mode               '(require 'smartparens-swift))
 (eval-after-load 'tex-mode                 '(require 'smartparens-latex))
 (eval-after-load 'text-mode                '(require 'smartparens-text))
 (eval-after-load 'tuareg                   '(require 'smartparens-ml))
diff --git a/smartparens-swift.el b/smartparens-swift.el
new file mode 100644
index 0000000000..a1efab109d
--- /dev/null
+++ b/smartparens-swift.el
@@ -0,0 +1,117 @@
+;;; smartparens-swift.el --- Additional configuration for Swift language 
buffers.  -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2015 Wilfred Hughes,
+;;               2022 Josh Caswell
+
+;; Created: 4 April 2022
+;; Keywords: abbrev convenience editing
+;; URL: https://github.com/Fuco1/smartparens
+
+;; This file is not part of GNU Emacs.
+
+;;; License:
+
+;; This file is part of Smartparens.
+
+;; Smartparens is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; Smartparens is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with Smartparens.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This file provides some additional configuration for Swift.  To use
+;; it, simply add:
+;;
+;; (require 'smartparens-config)
+;;
+;; alternatively, you can explicitly load these preferences:
+;;
+;; (require 'smartparens-swift)
+;;
+;; in your configuration.
+
+;; For more info, see github readme at
+;; https://github.com/Fuco1/smartparens
+
+;;; Code:
+(require 'smartparens)
+
+(declare-function swift-mode "swift-mode")
+
+(defun sp-swift-skip-match-angle-bracket (_ms _mb me)
+  "Non-nil if we should ignore the bracket as valid delimiter."
+  (save-excursion
+    (goto-char me)
+    (let ((on-fn-return-type
+           (sp--looking-back-p (rx "->") nil))
+          (on-range-operator
+           (sp--looking-back-p (rx "..<") nil))
+          (on-comparison
+           (sp--looking-back-p (rx (or
+                                    (seq space "<")
+                                    (seq space ">")
+                                    (seq space "<<")
+                                    (seq space ">>")))
+                               nil)))
+      (or on-comparison on-fn-return-type on-range-operator))))
+
+(defun sp-swift-filter-angle-brackets (_id action context)
+  "Non-nil if we should allow ID's ACTION in CONTEXT for angle brackets."
+  ;; See the docstring for `sp-pair' for the possible values of ID,
+  ;; ACTION and CONTEXT.
+  (cond
+   ;; Inside strings, don't do anything with < or >.
+   ((eq context 'string)
+    nil)
+   ((or (eq context 'comment)
+        (eq context 'code))
+    (let ((on-fn-return-type
+           (looking-back (rx "->") nil))
+          (on-range-operator
+           (looking-back (rx "..<") nil))
+          (on-comparison
+           (looking-back (rx (or
+                              (seq space "<")
+                              (seq space ">")
+                              (seq space "<<")
+                              (seq space ">>")))
+                         nil)))
+      (cond
+       ;; Only insert a matching > if we're not looking at one of the 
operators.
+       ((eq action 'insert)
+        (and (not on-comparison) (not on-fn-return-type) (not 
on-range-operator)))
+       ;; Allow wrapping in a pair if the region is active and we're not on a
+       ;; range operator.
+       ((eq action 'wrap)
+        (not on-range-operator))
+       ;; When pressing >, autoskip if we're not looking at one of the
+       ;; operators.
+       ((eq action 'autoskip)
+        (and (not on-comparison) (not on-fn-return-type) (not 
on-range-operator)))
+       ;; Allow navigation, highlighting and strictness checks if it's
+       ;; not one of the operators.
+       ((eq action 'navigate)
+        (and (not on-comparison) (not on-fn-return-type) (not 
on-range-operator))))))))
+
+(sp-with-modes '(swift-mode)
+  (sp-local-pair "<" ">"
+                 :when '(sp-swift-filter-angle-brackets)
+                 :skip-match 'sp-swift-skip-match-angle-bracket)
+  (sp-local-pair "\"\"\"" "\"\"\""))
+
+;; Swift has no sexp suffices.  This fixes slurping
+;; (|foo).bar -> (foo.bar)
+(add-to-list 'sp-sexp-suffix (list #'swift-mode 'regexp ""))
+
+(provide 'smartparens-swift)
+
+;;; smartparens-swift.el ends here
diff --git a/test/smartparens-swift-test.el b/test/smartparens-swift-test.el
new file mode 100644
index 0000000000..a9eefd8252
--- /dev/null
+++ b/test/smartparens-swift-test.el
@@ -0,0 +1,126 @@
+(require 'swift-mode)
+(require 'smartparens)
+
+(ert-deftest sp-test-swift-kill-first-line ()
+  "Ensure we can kill words on the first line.
+Regression test."
+  (sp-test-with-temp-buffer "extern|"
+      (swift-mode)
+    (sp-backward-kill-word 1)
+    (should (equal (buffer-string) ""))))
+
+(ert-deftest sp-test-swift-pair-angle-bracket ()
+  "When typing < we should insert the matching pair
+\(when appropriate\)."
+  (sp-test-with-temp-buffer "Result|"
+      (swift-mode)
+    (execute-kbd-macro "<")
+    ;; We should have inserted a pair.
+    (should (equal (buffer-string) "Result<>"))))
+
+(ert-deftest sp-test-swift-forward-angle-bracket ()
+  "< and > are usually brackets in Swift."
+  (sp-test-with-temp-buffer "struct Foo {
+    baz: Baz|<T>
+}"
+      (swift-mode)
+    (sp-forward-sexp)
+    ;; We should have moved over the closing >.
+    (should (looking-at "\n"))))
+
+(ert-deftest sp-test-swift-less-than ()
+  "When using < to compare, don't insert >."
+  (sp-test-with-temp-buffer "if x |"
+      (swift-mode)
+    (execute-kbd-macro "<")
+    (should (equal (buffer-string) "if x <"))))
+
+(ert-deftest sp-test-swift-left-shift ()
+  "When using << for a left shift, don't insert >."
+  (sp-test-with-temp-buffer "if x <|"
+      (swift-mode)
+    (execute-kbd-macro "<")
+    (should (equal (buffer-string) "if x <<"))))
+
+(ert-deftest sp-test-swift-left-shift-then-function ()
+  "We should still be able to insert -> after a left shift."
+  (sp-test-with-temp-buffer "let y: UInt64 = 1 << 2;
+
+func foo(x: UInt64) -|
+
+func bar(x: UInt64) -> Bool {
+    true
+}
+"
+      (swift-mode)
+    (smartparens-strict-mode)
+    (execute-kbd-macro ">")
+    (should (equal (buffer-substring (line-beginning-position) 
(line-end-position))
+                   "func foo(x: UInt64) ->"))))
+
+(ert-deftest sp-test-swift-delete-comparison ()
+  "We should be able to delete comparisons, even in strict mode."
+  (sp-test-with-temp-buffer "a < b; b >|"
+      (swift-mode)
+    (smartparens-strict-mode)
+    (execute-kbd-macro (kbd "<backspace>"))
+    (should (equal (buffer-string) "a < b; b "))))
+
+(ert-deftest sp-test-swift-pair-angle-bracket-in-constructor-call ()
+  "Pair < when parameterizing constructor calls."
+  (sp-test-with-temp-buffer "Array|"
+      (swift-mode)
+    (execute-kbd-macro "<")
+    ;; We should have inserted a pair.
+    (should (equal (buffer-string) "Array<>"))))
+
+(ert-deftest sp-test-swift-pair-autoskip-closing-bracket ()
+  "Autoskip a matching >."
+  (sp-test-with-temp-buffer "Array<T|>"
+      (swift-mode)
+    (execute-kbd-macro ">")
+    ;; We should have skipped the closing bracket.
+    (should (equal (buffer-string) "Array<T>"))))
+
+(ert-deftest sp-test-swift-pair-insert-and-autoskip-closing-bracket ()
+  "Inserting multiple > and closing them."
+  (sp-test-with-temp-buffer "Optional|"
+      (swift-mode)
+    (execute-kbd-macro "<Foo<Bar<T>>>")
+    ;; We should have inserted a pair without an extra chevron.
+    (should (equal (buffer-string) "Optional<Foo<Bar<T>>>"))))
+
+(ert-deftest sp-test-swift-insert-range-operator ()
+  "Inserting a range operator."
+  (sp-test-with-temp-buffer "foo..|"
+                            (swift-mode)
+                            (execute-kbd-macro "<bar")
+                            (should (equal (buffer-string) "foo..<bar"))))
+
+;; #793
+(ert-deftest sp-test-swift-skip-forward-over-return-type ()
+  "Moving forward over a function's return type."
+  (sp-test-with-temp-buffer "func foo() |-> UInt32"
+      (swift-mode)
+    (sp-forward-sexp)
+    (execute-kbd-macro "{")
+    (sp-buffer-equals "func foo() -> UInt32{|}")))
+
+;; #793
+(ert-deftest sp-test-swift-skip-backward-over-return-type ()
+  "Moving backward over a function's return type."
+  (sp-test-with-temp-buffer "foo() -> |UInt32 {}"
+      (swift-mode)
+    (smartparens-strict-mode 1)
+    (sp-backward-sexp)
+    (execute-kbd-macro "func ")
+    (sp-buffer-equals "func |foo() -> UInt32 {}")))
+
+;; #793
+(ert-deftest sp-test-swift-kill-defun ()
+  "Deleting a region containing a Swift function definition."
+  (sp-test-with-temp-buffer "|func foo() ->UInt32 {}"
+      (swift-mode)
+    (mark-whole-buffer)
+    (call-interactively 'sp-kill-region)
+    (should (equal (buffer-string) ""))))