[nongnu] elpa/swift-mode 195d040 227/496: Merge pull request #76 from ap4y/batch_smie_fixes

[ELPA Syncer]

branch: elpa/swift-mode
commit 195d040921791722f4effb9690c721158421f6d7
Merge: 3026464 95e753b
Author: Bozhidar Batsov <bozhidar.batsov@gmail.com>
Commit: Bozhidar Batsov <bozhidar.batsov@gmail.com>

    Merge pull request #76 from ap4y/batch_smie_fixes
    
    Batch smie fixes
---
 .travis.yml               |    1 -
 swift-mode.el             |  204 ++++++---
 test/indentation-tests.el | 1113 ++++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 1247 insertions(+), 71 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index a066c7c..257daab 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,6 @@
 language: emacs-lisp
 
 env:
-  - EVM_EMACS=emacs-24.3-bin
   - EVM_EMACS=emacs-24.4-bin
 
 before_install:
diff --git a/swift-mode.el b/swift-mode.el
index 7646ecd..bceab2a 100644
--- a/swift-mode.el
+++ b/swift-mode.el
@@ -6,7 +6,7 @@
 ;;       Bozhidar Batsov <bozhidar@batsov.com>
 ;;       Arthur Evstifeev <lod@pisem.net>
 ;; Version: 0.4.0-cvs
-;; Package-Requires: ((emacs "24.1"))
+;; Package-Requires: ((emacs "24.4"))
 ;; Keywords: languages swift
 
 ;; This file is not part of GNU Emacs.
@@ -56,7 +56,7 @@
   :type 'integer)
 
 (defcustom swift-indent-multiline-statement-offset 2
-  "Defines the indentation offset for for multiline statements."
+  "Defines the indentation offset for multiline statements."
   :group 'swift
   :type 'integer
   :package-version '(swift-mode "0.3.0"))
@@ -75,7 +75,7 @@
    (smie-merge-prec2s
     (smie-bnf->prec2
      '((id)
-       (type (type) (type "<T" types "T>"))
+       (type (type) (type "<T" types "T>") ("[" type "]"))
        (types (type) (type "," type))
 
        (class-decl-exp (id) (id ":" types))
@@ -99,24 +99,36 @@
        (top-level-st
         ("import" type)
         (decl)
-        ("class" class-decl-exp "{" class-level-sts "}"))
+        ("ACCESSMOD" "class" class-decl-exp "{" class-level-sts "}")
+        ("ACCESSMOD" "protocol" class-decl-exp "{" protocol-level-sts "}"))
 
        (class-level-sts (class-level-st) (class-level-st ";" class-level-st))
        (class-level-st
         (decl)
-        ("DECSPEC" "func" func-header "{" insts "}"))
+        (func))
 
+       (protocol-level-sts (protocol-level-st) (protocol-level-st ";" 
protocol-level-st))
+       (protocol-level-st
+        (decl)
+        (func-decl))
+
+       (func-body (insts) ("return" exp))
+       (func (func-decl "{" func-body "}"))
+       (func-decl ("DECSPEC" "func" func-header)
+                  (func-decl "->" type))
        (func-header (id "(" func-params ")"))
-       (func-param (decl-exp) ("..."))
+       (func-param (decl-exp) (decl-exp "=" id) ("..."))
        (func-params (func-param "," func-param))
 
        (insts (inst) (insts ";" insts))
        (inst (decl)
+             (exp "=" exp)
+             (tern-exp)
              (in-exp)
              (dot-exp)
-             (dot-exp "{" insts "}")
+             (dot-exp "{" closure "}")
              (method-call)
-             (method-call "{" insts "}")
+             (method-call "{" closure "}")
              ("enum" decl-exp "{" enum-body "}")
              ("switch" exp "{" switch-body "}")
              (if-clause)
@@ -127,33 +139,36 @@
 
        (method-call (dot-exp "(" method-args ")"))
        (method-args (method-arg) (method-arg "," method-arg))
-       (method-arg (exp "," "{" insts "}") (exp))
+       (method-arg (exp "," "{" closure "}") (exp))
 
        (exp (op-exp)
             ("[" decl-exps "]"))
        (in-exp (id "in" exp))
        (guard-exp (exp "where" exp))
        (op-exp (exp "OP" exp))
+       (tern-exp (op-exp "?" exp ":" exp))
 
-       (enum-cases (assign-exp)
-                   (enum-cases ";" "ecase" enum-cases))
+       (enum-case ("ecase" assign-exp)
+                  ("ecase" "(" type ")"))
+       (enum-cases (enum-case) (enum-case ";" enum-case))
        (enum-body (enum-cases) (insts))
 
-       (case-exps (guard-exp))
-       (cases (case-exps ":" insts)
-              (cases "case" cases))
-       (switch-body (cases) (cases "default:" insts))
+       (case-exps (exp) (guard-exp))
+       (case (case-exps ":" insts))
+       (switch-body (case) (case "case" case))
 
        (for-head (in-exp) (op-exp) (for-head ";" for-head))
 
-       (conditional (exp) (let-decl))
-       (if-body ("if" conditional "{" insts "}"))
-       (if-else-if (if-body) (if-else-if "else" if-else-if))
-       (if-clause (if-else-if)))
+       (if-conditional (exp) (let-decl))
+       (if-body ("if" if-conditional "{" insts "}"))
+       (if-clause (if-body)
+                  (if-body "elseif" if-conditional "{" insts "}")
+                  (if-body "else" "{" insts "}"))
+
+       (closure (insts) (exp "in" insts) (exp "->" id "in" insts)))
      ;; Conflicts
-     '((nonassoc "{") (assoc ",") (assoc ";") (assoc ":"))
+     '((nonassoc "{") (assoc "in") (assoc ",") (assoc ";") (assoc ":") (right 
"="))
      '((assoc "in") (assoc "where") (assoc "OP"))
-     '((assoc "else"))
      '((assoc ";") (assoc "ecase"))
      '((assoc "case")))
 
@@ -187,22 +202,39 @@
                 "is" "as" "as?" ".." "..."
                 "+" "-" "&+" "&-" "|" "^"
                 "*" "/" "%" "&*" "&/" "&%" "&"
-                "<<" ">>")))
+                "<<" ">>" "??")))
 
 (defvar swift-smie--decl-specifier-regexp
-  (rx (? (or "class" "mutating" "override" "static" "unowned" "weak"))
-      (* space) "func"))
+  
"\\(?1:class\\|mutating\\|override\\|static\\|unowned\\|weak\\)\\(?:[[:space:]]*func\\)")
+
+(defvar swift-smie--access-modifier-regexp
+  (regexp-opt '("private" "public" "internal")))
 
 (defun swift-smie--implicit-semi-p ()
   (save-excursion
-    (not (or (memq (char-before) '(?\{ ?\[ ?, ?.))
-             (looking-at "[ \n\t]+[.]")
-             (looking-back swift-smie--operators-regexp (- (point) 3) t)
+    (not (or (memq (char-before) '(?\{ ?\[ ?, ?. ?: ?= ?\())
+             ;; Checking for operators form for "?" and "!",
+             ;; they can be a part of the type.
+             ;; Special case: is? and as? are operators.
+             (looking-back "[[:space:]][?!]" (- (point) 2) t)
+             ;; ??, is? and as? are operators
+             (looking-back "[?][?]\\|as[?]\\|is[?]" (- (point) 3) t)
+             ;; "in" operator in closure
+             (looking-back "in" (- (point) 2) t)
+             ;; Characters placed on the second line in multi-line expression
+             (looking-at "[ \n\t]+[.?:]")
+             ;; Operators placed on the second line in multi-line expression
+             ;; Should respect here possible comments strict before the 
linebreak
+             (looking-at (concat "\\(\/\/.*\\)?\n[[:space:]]*" 
swift-smie--operators-regexp))
+             (and (looking-back swift-smie--operators-regexp (- (point) 3) t)
+                  ;; Not a generic type
+                  (not (looking-back "[[:upper:]]>" (- (point) 2) t)))
              ))))
 
 (defun swift-smie--forward-token ()
+  (skip-chars-forward " \t")
   (cond
-   ((and (looking-at "\n") (swift-smie--implicit-semi-p))
+   ((and (looking-at "\n\\|\/\/") (swift-smie--implicit-semi-p))
     (if (eolp) (forward-char 1) (forward-comment 1))
     ";")
 
@@ -210,6 +242,9 @@
    ((looking-at "}") (forward-char 1) "}")
 
    ((looking-at ",") (forward-char 1) ",")
+   ((looking-at ":") (forward-char 1) ":")
+
+   ((looking-at "->") (forward-char 2) "->")
 
    ((looking-at "<") (forward-char 1)
     (if (looking-at "[[:upper:]]") "<T" "OP"))
@@ -220,12 +255,21 @@
     (goto-char (match-end 0)) "OP")
 
    ((looking-at swift-smie--decl-specifier-regexp)
-    (goto-char (match-end 0)) "DECSPEC")
+    (goto-char (match-end 1)) "DECSPEC")
+
+   ((looking-at swift-smie--access-modifier-regexp)
+    (goto-char (match-end 0)) "ACCESSMOD")
+
+   ((looking-at "\\<default\\>")
+    (goto-char (match-end 0)) "case")
+
+   ((looking-at "else if")
+    (goto-char (match-end 0)) "elseif")
 
    (t (let ((tok (smie-default-forward-token)))
         (cond
          ((equal tok "case")
-          (if (looking-at ".+\\(,\\|:\\)")
+          (if (looking-at "\\([\n\t ]\\|.\\)+?\\(where.*[,]\\|:\\)")
               "case"
             "ecase"))
          (t tok))))
@@ -243,22 +287,36 @@
      ((eq (char-before) ?\}) (backward-char 1) "}")
 
      ((eq (char-before) ?,) (backward-char 1) ",")
+     ((eq (char-before) ?:) (backward-char 1) ":")
+
+     ((looking-back "->" (- (point) 2) t)
+      (goto-char (match-beginning 0)) "->")
 
      ((eq (char-before) ?<) (backward-char 1)
       (if (looking-at "<[[:upper:]]") "<T" "OP"))
-     ((eq (char-before) ?>) (backward-char 1)
+     ((looking-back ">[?!]?" (- (point) 2) t)
+      (goto-char (match-beginning 0))
       (if (looking-back "[[:space:]]" 1 t) "OP" "T>"))
 
      ((looking-back swift-smie--operators-regexp (- (point) 3) t)
       (goto-char (match-beginning 0)) "OP")
 
      ((looking-back swift-smie--decl-specifier-regexp (- (point) 8) t)
-      (goto-char (match-beginning 0)) "DECSPEC")
+      (goto-char (match-beginning 1)) "DECSPEC")
+
+     ((looking-back swift-smie--access-modifier-regexp (- (point) 8) t)
+      (goto-char (match-beginning 0)) "ACCESSMOD")
+
+     ((looking-back "\\<default\\>" (- (point) 9) t)
+      (goto-char (match-beginning 0)) "case")
+
+     ((looking-back "else if" (- (point) 7) t)
+      (goto-char (match-beginning 0)) "elseif")
 
      (t (let ((tok (smie-default-backward-token)))
           (cond
            ((equal tok "case")
-            (if (looking-at ".+\\(,\\|:\\)")
+            (if (looking-at "\\([\n\t ]\\|.\\)+?\\(where.*[,]\\|:\\)")
                 "case"
               "ecase"))
            (t tok))))
@@ -268,43 +326,73 @@
   (pcase (cons kind token)
     (`(:elem . basic) swift-indent-offset)
 
+    (`(:after . ":") 0)
+    (`(:before . ":")
+     (cond
+      ;; Rule for ternary operator in
+      ;; assignment expression.
+      ;; Static indentation relatively to =
+      ((smie-rule-parent-p "=") 2)
+      ;; Rule for the case statement.
+      ((smie-rule-parent-p "case") swift-indent-offset)
+      ;; Rule for the class definition.
+      ((smie-rule-parent-p "class") (smie-rule-parent swift-indent-offset))))
+
     (`(:after . "{")
      (if (smie-rule-parent-p "switch")
          (smie-rule-parent swift-indent-switch-case-offset)))
     (`(:before . ";")
-     (if (smie-rule-parent-p "case" "default:")
+     (if (smie-rule-parent-p "case")
          (smie-rule-parent swift-indent-offset)))
 
     ;; Apply swift-indent-multiline-statement-offset only if
-    ;; - dot is followed by newline, or
-    ;; - if dot is a first token on the line
+    ;; - if is a first token on the line
     (`(:before . ".")
-     (if (or (looking-at "[.][\n]")
-             (smie-rule-bolp))
-         swift-indent-multiline-statement-offset))
+     (when (smie-rule-bolp)
+       (if (smie-rule-parent-p "{")
+           (+ swift-indent-offset swift-indent-multiline-statement-offset)
+         swift-indent-multiline-statement-offset)))
 
     ;; Apply swift-indent-multiline-statement-offset if
     ;; operator is the last symbol on the line
     (`(:before . "OP")
-     (if (and (looking-at ".[\n]")
-              (not (smie-rule-sibling-p)))
-         swift-indent-multiline-statement-offset))
+     (when (and (smie-rule-hanging-p)
+                (not (smie-rule-parent-p "OP")))
+       (if (smie-rule-parent-p "{")
+           (+ swift-indent-offset swift-indent-multiline-statement-offset)
+         swift-indent-multiline-statement-offset)))
 
     ;; Indent second line of the multi-line class
     ;; definitions with swift-indent-offset
     (`(:before . ",")
      (if (smie-rule-parent-p "class")
-       swift-indent-offset))
+       (smie-rule-parent swift-indent-offset)))
 
-    (`(:before . "if")
-     (if (smie-rule-prev-p "else")
-         (if (smie-rule-parent-p "{")
-             swift-indent-offset
-           (smie-rule-parent))))
+    ;; Disable unnecessary default indentation for
+    ;; "func" and "class" keywords
+    (`(:after . ,(or `"func" `"class")) (smie-rule-parent))
 
+    ;; "in" token in closure
+    (`(:after . "in")
+     (if (smie-rule-parent-p "{")
+         (smie-rule-parent swift-indent-offset)))
+
+    (`(:after . "(")
+     (if (smie-rule-parent-p "(") 0
+       (smie-rule-parent swift-indent-offset)))
     (`(:before . "(")
-     (if (smie-rule-next-p "[") (smie-rule-parent)))
-    (`(:before . "[") (smie-rule-parent))
+     (cond
+      ((smie-rule-next-p "[") (smie-rule-parent))
+      ;; Custom indentation for method arguments
+      ((smie-rule-parent-p "." "func") (smie-rule-parent))))
+
+    (`(:before . "[")
+     (cond
+      ((smie-rule-prev-p "->") swift-indent-offset)
+      ((smie-rule-parent-p "[") (smie-rule-parent swift-indent-offset))
+      ((smie-rule-parent-p "{") nil)
+      (t (smie-rule-parent))))
+    (`(:after . "->") (smie-rule-parent swift-indent-offset))
     ))
 
 ;;; Font lock
@@ -602,11 +690,23 @@ You can send text to the REPL process from other buffers 
containing source.
     ;; Parenthesis, braces and brackets
     (modify-syntax-entry ?\( "()" table)
     (modify-syntax-entry ?\) ")(" table)
-    (modify-syntax-entry ?\{ "(}" table)
-    (modify-syntax-entry ?\} "){" table)
     (modify-syntax-entry ?\[ "(]" table)
     (modify-syntax-entry ?\] ")[" table)
 
+    ;; HACK: This is not a correct syntax table definition
+    ;; for the braces, but it allows us disable smie indentation
+    ;; based on  syntax-table. Default behaviour doesn't work with
+    ;; closures in method arguments. For example:
+    ;;
+    ;; foo.bar(10,
+    ;;         closure: {
+    ;;         })
+    ;;
+    ;; With enabled syntax table, smie doesn't respect closing brace, so
+    ;; it's impossible to provide custom indentation rules
+    (modify-syntax-entry ?\{ "w" table)
+    (modify-syntax-entry ?\} "w" table)
+
     table))
 
 (defvar swift-mode-map
diff --git a/test/indentation-tests.el b/test/indentation-tests.el
index cb810b1..8be3235 100644
--- a/test/indentation-tests.el
+++ b/test/indentation-tests.el
@@ -264,6 +264,35 @@ switch true {
 }
 ")
 
+(check-indentation indents-case-statements-to-same-level-as-enclosing-switch/5
+                   "
+switch {
+    |case foo,
+     bar, buz:
+    foo
+}
+" "
+switch {
+|case foo,
+     bar, buz:
+    foo
+}
+")
+
+(check-indentation indents-case-statements-to-same-level-as-enclosing-switch/6
+                   "
+switch {
+    |case
+    foo, bar, buz:
+    foo
+}
+" "
+switch {
+|case
+    foo, bar, buz:
+    foo
+}
+")
 
 (check-indentation indents-case-statement-bodies/1
 "
@@ -388,15 +417,36 @@ case y:
 }
 ")
 
+(check-indentation indents-statements-under-default-case/1
+  "
+{
+    switch true {
+    case y:
+        x
+    default:
+    |z
+    }
+}
+" "
+{
+    switch true {
+    case y:
+        x
+    default:
+        |z
+    }
+}
+")
+
 (check-indentation indents-case-statements-with-destucturing/1
   "
 switch true {
-case let(x, y):
+case let(x, y) where x < y:
 |foo
 }
 " "
 switch true {
-case let(x, y):
+case let(x, y) where x < y:
     |foo
 }
 ")
@@ -404,12 +454,12 @@ case let(x, y):
 (check-indentation indents-case-statements-with-destucturing/2
   "
 switch true {
-case let .Foo(x):
+case let .Foo(x) where x > 0:
 |foo
 }
 " "
 switch true {
-case let .Foo(x):
+case let .Foo(x) where x > 0:
     |foo
 }
 ")
@@ -639,6 +689,57 @@ class Foo: Foo, Bar,
 }
 ")
 
+(check-indentation indents-class-declaration/6
+                   "
+class Foo:
+|Foo, Bar, Baz {
+}
+" "
+class Foo:
+    |Foo, Bar, Baz {
+}
+")
+
+(check-indentation indents-class-declaration/7
+                   "
+class Foo: Bar<A, B,
+|C>
+" "
+class Foo: Bar<A, B,
+               |C>
+")
+
+(check-indentation indents-class-declaration/9
+                   "
+class Foo<A: B<C>>:
+                   |Bar
+" "
+class Foo<A: B<C>>:
+    |Bar
+")
+
+(check-indentation indents-public-class-declaration/1
+                   "
+public class Foo: Foo, Bar,
+|Baz {
+}
+" "
+public class Foo: Foo, Bar,
+    |Baz {
+}
+")
+
+(check-indentation indents-public-class-declaration/2
+  "
+public class Foo {
+          |foo
+}
+" "
+public class Foo {
+    |foo
+}
+")
+
 (check-indentation indents-func-declaration/1
   "
 func Foo(a: String) {
@@ -687,7 +788,7 @@ class Foo {
 }
 ")
 
-(check-indentation indents-func-declaration/2
+(check-indentation indents-func-declaration/5
                    "
 class func Foo() {
 |foo
@@ -698,6 +799,135 @@ class func Foo() {
 }
 ")
 
+(check-indentation indents-func-declaration/6
+                   "
+func Foo(aaaaaaaaa:
+         |AAAAAAAAA) {
+}
+" "
+func Foo(aaaaaaaaa:
+         |AAAAAAAAA) {
+}
+")
+
+(check-indentation indents-func-declaration/7
+  "
+func foo() ->
+|Foo
+" "
+func foo() ->
+    |Foo
+")
+
+(check-indentation indents-func-declaration/8
+  "
+func foo() ->
+|(A, B) {}
+" "
+func foo() ->
+    |(A, B) {}
+")
+
+(check-indentation indents-func-declaration/9
+  "
+func foo() ->
+|[A] {}
+" "
+func foo() ->
+    |[A] {}
+")
+
+(check-indentation indents-func-declaration/10
+                   "
+func a(a: NSString = 1,
+                     |b: NSString = 2) {}
+" "
+func a(a: NSString = 1,
+       |b: NSString = 2) {}
+")
+
+(check-indentation indents-func-declaration/11
+                   "
+class Foo: Bar {
+    func Foo() {
+|foo
+    }
+}
+" "
+class Foo: Bar {
+    func Foo() {
+        |foo
+    }
+}
+")
+
+(check-indentation indents-func-declaration/12
+                   "
+class Foo: Bar {
+    override func Foo() {
+|foo
+    }
+}
+" "
+class Foo: Bar {
+    override func Foo() {
+        |foo
+    }
+}
+")
+
+(check-indentation indents-protocol-declaration/1
+                   "
+protocol Foo {
+    func foo()
+|func bar()
+}
+" "
+protocol Foo {
+    func foo()
+    |func bar()
+}
+")
+
+(check-indentation indents-protocol-declaration/2
+                   "
+protocol Foo {
+    func foo() -> Foo
+|func bar() -> Bar
+}
+" "
+protocol Foo {
+    func foo() -> Foo
+    |func bar() -> Bar
+}
+")
+
+(check-indentation indents-protocol-declaration/3
+                   "
+protocol Foo {
+    func foo() -> Foo<A>
+|func bar() -> Bar<A>
+}
+" "
+protocol Foo {
+    func foo() -> Foo<A>
+    |func bar() -> Bar<A>
+}
+")
+
+(check-indentation indents-protocol-declaration/4
+                   "
+protocol Foo {
+    func foo() -> [A]
+|func bar() -> [A]
+}
+" "
+protocol Foo {
+    func foo() -> [A]
+    |func bar() -> [A]
+}
+")
+
 (check-indentation indents-declaration/1
   "
 var foo = bar + baz
@@ -764,6 +994,131 @@ var result = Dictionary<String, V>()
 var result = Dictionary<String, V>()
 |foo
 ")
+(check-indentation indents-declaration/8
+  "
+let foo =
+|bar
+" "
+let foo =
+    |bar
+")
+
+(check-indentation indents-declaration/9
+  "
+let foo: Foo? =
+|bar
+" "
+let foo: Foo? =
+    |bar
+")
+
+(check-indentation indents-declaration/10
+  "
+let foo: Foo<A> =
+|bar
+" "
+let foo: Foo<A> =
+    |bar
+")
+
+(check-indentation indents-declaration/11
+  "
+let foo = [
+    foo:
+|bar
+]
+" "
+let foo = [
+    foo:
+    |bar
+]
+")
+
+(check-indentation indents-declaration/12
+  "
+let foo = [
+|[
+" "
+let foo = [
+    |[
+")
+
+(check-indentation indents-declaration/13
+                   "
+let foo = [
+|[
+        bar: baz
+    ]
+]
+" "
+let foo = [
+    |[
+        bar: baz
+    ]
+]
+")
+
+(check-indentation indents-declaration/14
+                   "
+let foo = [
+    [
+    |bar: baz
+    ]
+]
+" "
+let foo = [
+    [
+        |bar: baz
+    ]
+]
+")
+
+(check-indentation indents-declaration/15
+                   "
+let foo = [
+    [
+        bar: baz
+|]
+]
+" "
+let foo = [
+    [
+        bar: baz
+    |]
+]
+")
+
+(check-indentation indents-expressions/1
+                   "
+class Foo {
+    func a() {
+    |[a]
+    }
+}
+" "
+class Foo {
+    func a() {
+        |[a]
+    }
+}
+")
+
+(check-indentation indents-expressions/2
+                   "
+class Foo {
+    func a() {
+        a
+    |[a]
+    }
+}
+" "
+class Foo {
+    func a() {
+        a
+        |[a]
+    }
+}
+")
 
 (check-indentation indents-multiline-expressions/1
 "
@@ -839,17 +1194,245 @@ let options = 
NSRegularExpressionOptions.CaseInsensitive &
               |NSRegularExpressionOptions.DotMatchesLineSeparators
 ")
 
-(check-indentation indents-multiline-expressions-to-user-defined-offset/1
+(check-indentation indents-multiline-expressions/9
                    "
-NSNotificationCenter.defaultCenter().
-|postNotificationName(foo, object: nil)
+foo?[bar] +
+     |a
 " "
-NSNotificationCenter.defaultCenter().
-    |postNotificationName(foo, object: nil)
-"
-((swift-indent-multiline-statement-offset 4)))
+foo?[bar] +
+     |a
+")
 
-(check-indentation indents-multiline-expressions-to-user-defined-offset/2
+(check-indentation indents-multiline-expressions/10
+                   "
+foo?(bar) +
+     |a
+" "
+foo?(bar) +
+     |a
+")
+
+(check-indentation indents-multiline-expressions/11
+                   "
+func a () {
+    a +
+|a
+" "
+func a () {
+    a +
+      |a
+")
+
+(check-indentation indents-multiline-expressions/12
+                   "
+func a () {
+    a
+|.a()
+" "
+func a () {
+    a
+      |.a()
+")
+
+(check-indentation indents-multiline-expressions/13
+                   "
+if (a
+|.b)
+" "
+if (a
+     |.b)
+")
+
+(check-indentation indents-multiline-expressions/14
+                   "
+a ??
+|b
+" "
+a ??
+  |b
+")
+
+(check-indentation indents-multiline-expressions/15
+                   "
+a as
+|b
+" "
+a as
+  |b
+")
+
+(check-indentation indents-multiline-expressions/16
+                   "
+a as?
+|b
+" "
+a as?
+  |b
+")
+
+(check-indentation indents-multiline-expressions/17
+                   "
+a is
+|b
+" "
+a is
+  |b
+")
+
+(check-indentation indents-multiline-expressions/18
+                   "
+CGPoint(x: aaaaaaaaaaaaaaa.x +
+|bbbbbbbbbbbbbbbb,
+        y: aaaaaaaaaaaaaaa.y +
+           bbbbbbbbbbbbbbbb)
+" "
+CGPoint(x: aaaaaaaaaaaaaaa.x +
+           |bbbbbbbbbbbbbbbb,
+        y: aaaaaaaaaaaaaaa.y +
+           bbbbbbbbbbbbbbbb)
+")
+
+(check-indentation indents-multiline-expressions/19
+                   "
+let x = 1
+|+ 1
+" "
+let x = 1
+        |+ 1
+")
+
+(check-indentation indents-multiline-expressions/20
+                   "
+let x = foo ??
+            |bar
+" "
+let x = foo ??
+        |bar
+")
+
+(check-indentation indents-multiline-expressions/21
+                   "
+let foo = a +
+          b +
+            |c +
+          d
+" "
+let foo = a +
+          b +
+          |c +
+          d
+")
+
+(check-indentation indents-multiline-expressions/22
+                   "
+let foo = a +
+          b +
+          c +
+              |d
+" "
+let foo = a +
+          b +
+          c +
+          |d
+")
+
+(check-indentation indents-multiline-expressions/23
+                   "
+let x = bar
+        .buz() ??
+|defaultValue
+" "
+let x = bar
+        .buz() ??
+        |defaultValue
+")
+
+(check-indentation indents-long-parameters/1
+                   "
+func foo() {
+    timer = NSTimer.scheduledTimerWithTimeInterval(
+            |1.0,
+                target: self,
+                selector: Selector(\"onTimer\"),
+                userInfo: nil,
+                repeats: true)
+}
+" "
+func foo() {
+    timer = NSTimer.scheduledTimerWithTimeInterval(
+                |1.0,
+                target: self,
+                selector: Selector(\"onTimer\"),
+                userInfo: nil,
+                repeats: true)
+}
+")
+
+(check-indentation indents-long-parameters/2
+                   "
+aaaaaa.aaaaaaaaaaaaaaaaaaaaa(
+  |aaaaaaaaaaaaaaaaaaaaa
+)
+" "
+aaaaaa.aaaaaaaaaaaaaaaaaaaaa(
+    |aaaaaaaaaaaaaaaaaaaaa
+)
+")
+
+(check-indentation indents-long-parameters/3
+                   "
+public func tableView(
+|tableView: UITableView,
+    commitEditingStyle editingStyle: UITableViewCellEditingStyle,
+    forRowAtIndexPath indexPath: NSIndexPath) {
+}
+" "
+public func tableView(
+    |tableView: UITableView,
+    commitEditingStyle editingStyle: UITableViewCellEditingStyle,
+    forRowAtIndexPath indexPath: NSIndexPath) {
+}
+")
+
+(check-indentation indents-long-parameters/4
+                   "
+func a(
+        |a: a,
+    a: a,
+    a: a) {
+}
+" "
+func a(
+    |a: a,
+    a: a,
+    a: a) {
+}
+")
+
+(check-indentation indents-long-parameters/5
+                   "
+func foo() {
+    timer = NSTimer.scheduledTimerWithTimeInterval(
+                1.0,
+                target: self,
+                selector: Selector(\"onTimer\"),
+                userInfo: nil,
+                repeats: true
+|)
+}
+" "
+func foo() {
+    timer = NSTimer.scheduledTimerWithTimeInterval(
+                1.0,
+                target: self,
+                selector: Selector(\"onTimer\"),
+                userInfo: nil,
+                repeats: true
+            |)
+}
+")
+
+(check-indentation indents-multiline-expressions-to-user-defined-offset/1
                    "
 NSNotificationCenter.defaultCenter()
 |.postNotificationName(foo, object: nil)
@@ -859,7 +1442,7 @@ NSNotificationCenter.defaultCenter()
 "
 ((swift-indent-multiline-statement-offset 4)))
 
-(check-indentation indents-multiline-expressions-to-user-defined-offset/3
+(check-indentation indents-multiline-expressions-to-user-defined-offset/2
                    "
 let json_ary = NSJSONSerialization
                |.JSONObjectWithData(data, options: nil, error: &json_err) as 
NSArray
@@ -869,7 +1452,7 @@ let json_ary = NSJSONSerialization
 "
 ((swift-indent-multiline-statement-offset 4)))
 
-(check-indentation indents-multiline-expressions-to-user-defined-offset/4
+(check-indentation indents-multiline-expressions-to-user-defined-offset/3
                    "
 let options = NSRegularExpressionOptions.CaseInsensitive &
 |NSRegularExpressionOptions.DotMatchesLineSeparators
@@ -922,15 +1505,509 @@ let foo = bar >
 (check-indentation indents-multiline-operators-only-once
                    "
 1 +
-    2 + 5 *
+  2 + 5 *
 |3
 " "
 1 +
-    2 + 5 *
-    |3
+  2 + 5 *
+  |3
 "
 )
 
+(check-indentation conditional-operator/1
+                   "
+let a = a
+        |? a +
+          1
+        : a +
+          1
+" "
+let a = a
+        |? a +
+          1
+        : a +
+          1
+")
+
+(check-indentation conditional-operator/2
+                   "
+let a = a
+        ? a +
+          |1
+        : a +
+          1
+" "
+let a = a
+        ? a +
+          |1
+        : a +
+          1
+")
+
+(check-indentation conditional-operator/3
+                   "
+let a = a
+        ? a +
+          1
+        |: a +
+          1
+" "
+let a = a
+        ? a +
+          1
+        |: a +
+          1
+")
+
+(check-indentation conditional-operator/4
+                   "
+let a = a
+        ? a +
+          1
+        : a +
+          |1
+" "
+let a = a
+        ? a +
+          1
+        : a +
+          |1
+")
+
+(check-indentation conditional-operator/5
+                   "
+let a = a ?
+|a : a
+" "
+let a = a ?
+        |a : a
+")
+
+(check-indentation conditional-operator/6
+                   "
+let a = a ?
+      |b :
+        c
+" "
+let a = a ?
+        |b :
+        c
+")
+
+(check-indentation conditional-operator/7
+                   "
+let a = a ?
+        b :
+      |c
+" "
+let a = a ?
+        b :
+        |c
+")
+
+(check-indentation conditional-operator/8
+                   "
+func foo() {
+    return order!.deliver ?
+         |OrderViewTableDeliveryCells.lastCellIndex.rawValue :
+           OrderViewTableTakeAwayCells.lastCellIndex.rawValue
+}
+" "
+func foo() {
+    return order!.deliver ?
+           |OrderViewTableDeliveryCells.lastCellIndex.rawValue :
+           OrderViewTableTakeAwayCells.lastCellIndex.rawValue
+}
+")
+
+(check-indentation conditional-operator/9
+                   "
+func foo() {
+    return order!.deliver ?
+           OrderViewTableDeliveryCells.lastCellIndex.rawValue :
+         |OrderViewTableTakeAwayCells.lastCellIndex.rawValue
+}
+" "
+func foo() {
+    return order!.deliver ?
+           OrderViewTableDeliveryCells.lastCellIndex.rawValue :
+           |OrderViewTableTakeAwayCells.lastCellIndex.rawValue
+}
+")
+
+(check-indentation blank-line/1
+                   "
+func foo() {
+    let a = 1
+
+|let b = 1
+}
+" "
+func foo() {
+    let a = 1
+
+    |let b = 1
+}
+")
+
+(check-indentation block-inside-parenthesis/3
+  "
+\({
+|a
+})
+" "
+\({
+     |a
+})
+")
+
+(check-indentation indent-long-if-else-if/1
+  "
+if a {
+    a
+} else if a {
+    a
+} else if a {
+    |a
+} else {
+    a
+}
+" "
+if a {
+    a
+} else if a {
+    a
+} else if a {
+    |a
+} else {
+    a
+}
+")
+
+(check-indentation indent-long-if-else-if/2
+  "
+if a {
+    a
+} else if a {
+    a
+} else if a {
+    a
+|} else {
+    a
+}
+" "
+if a {
+    a
+} else if a {
+    a
+} else if a {
+    a
+|} else {
+    a
+}
+")
+
+(check-indentation indent-long-if-else-if/3
+  "
+class Foo {
+    func a() {
+        if a {
+            a
+        } else if b {
+        |a
+        } else if a {
+            a
+        } else {
+            a
+        }
+    }
+}
+" "
+class Foo {
+    func a() {
+        if a {
+            a
+        } else if b {
+            |a
+        } else if a {
+            a
+        } else {
+            a
+        }
+    }
+}
+")
+
+(check-indentation indent-long-if-else-if/4
+  "
+class Foo {
+    func a() {
+        if a {
+            a
+        } else if b {
+            a
+    |} else if a {
+            a
+        } else {
+            a
+        }
+    }
+}
+" "
+class Foo {
+    func a() {
+        if a {
+            a
+        } else if b {
+            a
+        |} else if a {
+            a
+        } else {
+            a
+        }
+    }
+}
+")
+
+(check-indentation anonymous-function-as-a-argument/1
+                   "
+UIView.animateWithDuration(1.0,
+                           animations: {
+|})
+" "
+UIView.animateWithDuration(1.0,
+                           animations: {
+                           |})
+")
+
+(check-indentation anonymous-function-as-a-argument/2
+                   "
+UIView.animateWithDuration(
+    1.0,
+    animations: {
+|})
+" "
+UIView.animateWithDuration(
+    1.0,
+    animations: {
+    |})
+")
+
+(check-indentation anonymous-function-as-a-argument/3
+                   "
+func foo() {
+    UIView.animateWithDuration(1.0,
+                               animations: {
+                                   |}
+    ) {
+        completed in
+    }
+}
+" "
+func foo() {
+    UIView.animateWithDuration(1.0,
+                               animations: {
+                               |}
+    ) {
+        completed in
+    }
+}
+")
+
+(check-indentation anonymous-function-as-a-argument/4
+                   "
+func foo() {
+    UIView.animateWithDuration(1.0,
+                               animations: {
+                               }
+|) {
+        completed in
+    }
+}
+" "
+func foo() {
+    UIView.animateWithDuration(1.0,
+                               animations: {
+                               }
+    |) {
+        completed in
+    }
+}
+")
+
+(check-indentation anonymous-function-as-a-argument/5
+                   "
+foo.bar(10,
+        completionHandler: { complete in
+        |foo
+        }
+)
+" "
+foo.bar(10,
+        completionHandler: { complete in
+            |foo
+        }
+)
+")
+
+(check-indentation anonymous-function-as-a-argument/6
+                   "
+foo.bar(10,
+        completionHandler: {
+            complete in
+        |foo
+        }
+)
+" "
+foo.bar(10,
+        completionHandler: {
+            complete in
+            |foo
+        }
+)
+")
+
+(check-indentation anonymous-function-as-a-argument/7
+                   "
+foo.bar(10,
+        completionHandler: { (
+        |bar, baz) in
+            foo
+        }
+)
+" "
+foo.bar(10,
+        completionHandler: { (
+            |bar, baz) in
+            foo
+        }
+)
+")
+
+(check-indentation anonymous-function-as-a-argument/8
+                   "
+foo.bar(10,
+        completionHandler: { (bar, baz) -> Void in
+        |foo
+        }
+" "
+foo.bar(10,
+        completionHandler: { (bar, baz) -> Void in
+            |foo
+        }
+")
+
+(check-indentation anonymous-function-as-a-argument/9
+                   "
+foo.bar(10,
+        completionHandler: { complete in
+
+            if foo {
+                bar
+            } else {
+            |bar
+            }
+        }
+)
+" "
+foo.bar(10,
+        completionHandler: { complete in
+
+            if foo {
+                bar
+            } else {
+                |bar
+            }
+        }
+)
+")
+
+(check-indentation anonymous-function-as-a-argument/10
+                   "
+foo.bar(10,
+        completionHandler: { complete in
+
+            if foo {
+                bar
+            } else {
+                bar
+        |}
+        }
+)
+" "
+foo.bar(10,
+        completionHandler: { complete in
+
+            if foo {
+                bar
+            } else {
+                bar
+            |}
+        }
+)
+")
+
+(check-indentation indents-expression-with-optional-type/1
+                   "
+var object: JsonObject?
+    |var object: JsonObject
+" "
+var object: JsonObject?
+|var object: JsonObject
+")
+
+(check-indentation indents-expression-with-optional-type/2
+                   "
+var object: JsonObject<Foo>?
+    |var object: JsonObject
+" "
+var object: JsonObject<Foo>?
+|var object: JsonObject
+")
+
+(check-indentation indents-expression-with-implicit-unwrapped-type/1
+                   "
+var object: JsonObject!
+    |var object: JsonObject
+" "
+var object: JsonObject!
+|var object: JsonObject
+")
+
+(check-indentation indents-expression-with-implicit-unwrapped-type/2
+                   "
+var object: JsonObject<Foo>!
+    |var object: JsonObject
+" "
+var object: JsonObject<Foo>!
+|var object: JsonObject
+")
+
+(check-indentation indents-expression-with-comment/1
+                   "
+func foo() {
+    foo() // foo
+       |foo()
+}
+" "
+func foo() {
+    foo() // foo
+    |foo()
+}
+")
+
+(check-indentation indents-expression-with-comment/2
+                   "
+func foo() {
+    let x = 1 // foo
+    |/ 1
+}
+" "
+func foo() {
+    let x = 1 // foo
+            |/ 1
+}
+")
 
 (provide 'indentation-tests)