[nongnu] elpa/swift-mode ca6437a 116/496: Merge pull request #29 from ap4y/master

[ELPA Syncer]

branch: elpa/swift-mode
commit ca6437a079036f8a101b492374d1884b8c50e1c6
Merge: 699e896 0fcf3ab
Author: Bozhidar Batsov <bozhidar@batsov.com>
Commit: Bozhidar Batsov <bozhidar@batsov.com>

    Merge pull request #29 from ap4y/master
    
    Set of improvements and fixes #1
---
 swift-mode.el             |  82 ++++++++++++++++++++++++++++----
 test/font-lock-tests.el   |   7 +++
 test/indentation-tests.el | 116 +++++++++++++++++++++++++++++++++++++++++++---
 3 files changed, 190 insertions(+), 15 deletions(-)

diff --git a/swift-mode.el b/swift-mode.el
index 1e289cb..4447b58 100644
--- a/swift-mode.el
+++ b/swift-mode.el
@@ -66,7 +66,7 @@
    (smie-merge-prec2s
     (smie-bnf->prec2
      '((id)
-       (type)
+       (type (type) (type "<T" types "T>"))
        (types (type) (type "," type))
 
        (class-decl-exp (id) (id ":" types))
@@ -95,7 +95,7 @@
        (class-level-sts (class-level-st) (class-level-st ";" class-level-st))
        (class-level-st
         (decl)
-        ("override" "func" func-header "{" insts "}"))
+        ("DECSPEC" "func" func-header "{" insts "}"))
 
        (func-header (id "(" func-params ")"))
        (func-param (decl-exp) ("..."))
@@ -108,7 +108,7 @@
              (dot-exp "{" insts "}")
              (method-call)
              (method-call "{" insts "}")
-             ("enum" decl-exp "{" enum-cases "}")
+             ("enum" decl-exp "{" enum-body "}")
              ("switch" exp "{" switch-body "}")
              (if-clause)
              ("for" for-head "{" insts "}")
@@ -127,7 +127,8 @@
        (op-exp (exp "OP" exp))
 
        (enum-cases (assign-exp)
-                   (enum-cases "case" enum-cases))
+                   (enum-cases ";" "ecase" enum-cases))
+       (enum-body (enum-cases) (insts))
 
        (case-exps (guard-exp))
        (cases (case-exps ":" insts)
@@ -144,6 +145,7 @@
      '((nonassoc "{") (assoc ",") (assoc ";") (assoc ":"))
      '((assoc "in") (assoc "where") (assoc "OP"))
      '((assoc "else"))
+     '((assoc ";") (assoc "ecase"))
      '((assoc "case")))
 
     (smie-precs->prec2
@@ -178,6 +180,9 @@
                 "*" "/" "%" "&*" "&/" "&%" "&"
                 "<<" ">>")))
 
+(defvar swift-smie--decl-specifier-regexp
+  (regexp-opt '("class" "mutating" "override" "static" "unowned" "weak")))
+
 (defun swift-smie--implicit-semi-p ()
   (save-excursion
     (not (or (memq (char-before) '(?\{ ?\[ ?\,))
@@ -189,11 +194,31 @@
    ((and (looking-at "\n") (swift-smie--implicit-semi-p))
     (if (eolp) (forward-char 1) (forward-comment 1))
     ";")
+
    ((looking-at "{") (forward-char 1) "{")
    ((looking-at "}") (forward-char 1) "}")
+
+   ((looking-at ",") (forward-char 1) ",")
+
+   ((looking-at "<") (forward-char 1)
+    (if (looking-at "[[:upper:]]") "<T" "OP"))
+   ((looking-at ">") (forward-char 1)
+    (if (looking-back "[[:space:]]>" 2 t) "OP" "T>"))
+
    ((looking-at swift-smie--operators-regexp)
     (goto-char (match-end 0)) "OP")
-   (t (smie-default-forward-token))))
+
+   ((looking-at swift-smie--decl-specifier-regexp)
+    (goto-char (match-end 0)) "DECSPEC")
+
+   (t (let ((tok (smie-default-forward-token)))
+        (cond
+         ((equal tok "case")
+          (if (looking-at ".+\\(,\\|:\\)")
+              "case"
+            "ecase"))
+         (t tok))))
+   ))
 
 (defun swift-smie--backward-token ()
   (let ((pos (point)))
@@ -202,11 +227,31 @@
      ((and (> pos (line-end-position))
            (swift-smie--implicit-semi-p))
       ";")
+
      ((eq (char-before) ?\{) (backward-char 1) "{")
      ((eq (char-before) ?\}) (backward-char 1) "}")
+
+     ((eq (char-before) ?,) (backward-char 1) ",")
+
+     ((eq (char-before) ?<) (backward-char 1)
+      (if (looking-at "<[[:upper:]]") "<T" "OP"))
+     ((eq (char-before) ?>) (backward-char 1)
+      (if (looking-back "[[:space:]]" 1 t) "OP" "T>"))
+
      ((looking-back swift-smie--operators-regexp (- (point) 3) t)
       (goto-char (match-beginning 0)) "OP")
-     (t (smie-default-backward-token)))))
+
+     ((looking-back swift-smie--decl-specifier-regexp (- (point) 8) t)
+      (goto-char (match-beginning 0)) "DECSPEC")
+
+     (t (let ((tok (smie-default-backward-token)))
+          (cond
+           ((equal tok "case")
+            (if (looking-at ".+\\(,\\|:\\)")
+                "case"
+              "ecase"))
+           (t tok))))
+     )))
 
 (defun swift-smie-rules (kind token)
   (pcase (cons kind token)
@@ -224,6 +269,10 @@
          (if (smie-rule-parent-p "{")
              swift-indent-offset
            (smie-rule-parent))))
+
+    (`(:before . "(")
+     (if (smie-rule-next-p "[") (smie-rule-parent)))
+    (`(:before . "[") (smie-rule-parent))
     ))
 
 ;;; Font lock
@@ -234,6 +283,9 @@
 (defvar swift-mode--val-decl-keywords
   '("let" "var"))
 
+(defvar swift-mode--context-variables-keywords
+  '("self" "super"))
+
 (defvar swift-mode--fn-decl-keywords
   '("deinit" "func" "init"))
 
@@ -249,9 +301,15 @@
     "nonmutating" "operator" "override" "postfix" "precedence" "prefix" "right"
     "set" "unowned" "unowned(safe)" "unowned(unsafe)" "weak" "willSet" 
"convenience"))
 
+(defvar swift-mode--attribute-keywords
+  '("assignment" "class_protocol" "exported" "final" "lazy" "noreturn"
+    "NSCopying" "NSManaged" "objc" "optional" "required" "auto_closure"
+    "IBAction" "IBDesignable" "IBInspectable" "IBOutlet"))
+
 (defvar swift-mode--keywords
   (append swift-mode--type-decl-keywords
           swift-mode--val-decl-keywords
+          swift-mode--context-variables-keywords
           swift-mode--fn-decl-keywords
           swift-mode--misc-keywords
           swift-mode--statement-keywords
@@ -275,6 +333,14 @@
        t)
      1 font-lock-keyword-face)
 
+    ;; Attributes
+    ;;
+    ;; Highlight attributes with keyword face
+    (,(rx-to-string
+       `(and "@" bow (or ,@swift-mode--attribute-keywords) eow)
+       t)
+     0 font-lock-keyword-face)
+
     ;; Types
     ;;
     ;; Any token beginning with an uppercase character is highlighted as a
@@ -338,9 +404,7 @@
     (remove-text-properties start end '(swift-interpolation-match-data))
     (funcall
      (syntax-propertize-rules
-      ((rx (or line-start (not (any "\\")))
-           (zero-or-more "\\\\")
-           (group "\\(" (zero-or-more any) ")"))
+      ((rx (group "\\(" (*? any) ")"))
        (0 (ignore (swift-syntax-propertize-interpolation)))))
      start end)))
 
diff --git a/test/font-lock-tests.el b/test/font-lock-tests.el
index acd14b0..d1ddafc 100644
--- a/test/font-lock-tests.el
+++ b/test/font-lock-tests.el
@@ -187,6 +187,13 @@ test will fail."
 (check-face class/base-type-colon-has-default-face/1 nil "class T {{:}} Base")
 
 (check-face string-interpolation/has-variable-face/1 
font-lock-variable-name-face "\"foo {{\\\(bar)}}\"")
+(check-face string-interpolation/has-variable-face/2 
font-lock-variable-name-face "\"{{\\\(bar)}}\"")
+(check-face string-interpolation/after-has-string-face/2 font-lock-string-face 
"\"(foo \\\(bar){{baz}}\")")
+
+(check-face self/has-keyword-face/1 font-lock-keyword-face "{{self}}.foo")
+(check-face super/has-keyword-face/1 font-lock-keyword-face "{{super}}.foo")
+
+(check-face attributes/has-keyword-face/1 font-lock-keyword-face 
"{{@IBAction}} func")
 
 (provide 'font-lock-tests)
 
diff --git a/test/indentation-tests.el b/test/indentation-tests.el
index 502e961..5f4d394 100644
--- a/test/indentation-tests.el
+++ b/test/indentation-tests.el
@@ -505,6 +505,21 @@ enum Foo: Bar {
 }
 ")
 
+(check-indentation indents-declaration-statements-in-enum/1
+                   "
+enum Foo: Bar {
+    case foo
+    case bar
+         |var foo
+}
+" "
+enum Foo: Bar {
+    case foo
+    case bar
+    |var foo
+}
+")
+
 (check-indentation indents-for-statements/1
   "
 for index in 1..5 {
@@ -652,6 +667,17 @@ class Foo {
 }
 ")
 
+(check-indentation indents-func-declaration/2
+                   "
+class func Foo() {
+|foo
+}
+" "
+class func Foo() {
+    |foo
+}
+")
+
 (check-indentation indents-declaration/1
   "
 var foo = bar + baz
@@ -683,11 +709,11 @@ let foo = [foo: bar, bar: baz]
   "
 let foo = [
 |bar: baz
-    ]
+]
 " "
 let foo = [
-        |bar: baz
-    ]
+    |bar: baz
+]
 ")
 
 (check-indentation indents-declaration/5
@@ -703,11 +729,89 @@ let foo = [foo, bar]
   "
 let foo = [
 |bar
-    ]
+]
 " "
 let foo = [
-        |bar
-    ]
+    |bar
+]
+")
+
+(check-indentation indents-declaration/7
+                   "
+var result = Dictionary<String, V>()
+    |foo
+" "
+var result = Dictionary<String, V>()
+|foo
+")
+
+(check-indentation indents-multiline-expressions/1
+"
+Foo.bar([foo: bar,
+|bar: baz
+])
+" "
+Foo.bar([foo: bar,
+         |bar: baz
+])
+")
+
+(check-indentation indents-multiline-expressions/2
+                   "
+Foo.bar(bar!,
+|baz)
+" "
+Foo.bar(bar!,
+        |baz)
+")
+
+(check-indentation indents-multiline-expressions/3
+                   "
+Foo.bar(bar?,
+|baz)
+" "
+Foo.bar(bar?,
+        |baz)
+")
+
+(check-indentation indents-type-annotations/1
+                   "
+typealias Foo = Bar<Foo.Baz, Foo>
+    |foo
+" "
+typealias Foo = Bar<Foo.Baz, Foo>
+|foo
+")
+
+(check-indentation indents-type-annotations/2
+                   "
+typealias Foo = Bar<Foo.Baz,
+|Foo>
+" "
+typealias Foo = Bar<Foo.Baz,
+                    |Foo>
+")
+
+(check-indentation indents-type-works-with-less-operator/1
+                   "
+typealias Foo = Bar<Foo.Baz, Foo>
+let foo = bar <
+|baz
+" "
+typealias Foo = Bar<Foo.Baz, Foo>
+let foo = bar <
+          |baz
+")
+
+(check-indentation indents-type-works-with-less-operator/2
+                   "
+typealias Foo = Bar<Foo.Baz, Foo>
+let foo = bar >
+|baz
+" "
+typealias Foo = Bar<Foo.Baz, Foo>
+let foo = bar >
+          |baz
 ")
 
 (provide 'indentation-tests)