I'm sorry for this large patch. But it is hard to fix some defects with current grammar. So, I modified the grammar and related lexer. And this PR fixes #85 #59 #72 #35. How about this?

This patch updates most of indentation logic.

The current implementation defines a complex syntax for SIME and depends on the indentation logic of SMIE. Unfortunately, SMIE is a black magic and controlling SMIE is very hard, so that results in a fragile and inconsistent logic:

func foo() {
    foo
  .bar() // :(
    foo
      .bar()
}

CGPoint(x: aaaaaaaaaaaaaaa.x +
         bbbbbbbbbbbbbbbb, // 1 space
        y: aaaaaaaaaaaaaaa.y +
          bbbbbbbbbbbbbbbb) // 2 spaces

class Foo: Bar,
    Baz { // 4 spaces from "class"
}

class Foo:
      Bar, Baz { // aligns with "Foo"
}

a
  .b // 2 spaces

if (a
     .b) { // 1 spaces
}

protocol Foo {
    func foo()
func bar() // :(
}

public class Foo {
           func foo() { // :(
} // :(
       } // :(

let a = [
[ // :(
    a
]
]

UIView.animateWithDuration(1.0,
                           animations: {
                               foo.center =
                               CGPoint(x: x, y: y) // :(
                              } // :(
                          )

protocol Foo {
    func foo() -> Foo<(A,
                       B),
[C]>  // :(
}

This patch defines a simple syntax enough for indentation and use a simple manual logic for most cases.

The new logic also supports different wrapping styles:

let x =
  1 +
  1 +
  1

let x
  = 1
    + 1
    + 1

timer = NSTimer.scheduledTimerWithTimeInterval(1.0,
                                               target: self,
                                               selector: Selector("onTimer"),
                                               userInfo: nil,
                                               repeats: true)

timer = NSTimer.scheduledTimerWithTimeInterval(
  1.0,
  target: self,
  selector: Selector("onTimer"),
  userInfo: nil,
  repeats: true
)

let x = [
    foo:
      bar,
    foo
      : bar
]

func a() ->
  [a] {
    a
}

func a()
  -> [a] {
    a
}

The new logic passes all existing tests and new tests (on Emacs 24.4.1).

Sorry for a huge monolithic patch.

I keep getting this error only when using swift mode. I opened up a fresh install of emacs and only installed swift-mode and I get the same problem. This happens after the class declaration. Basically, I can create a class without issues but as soon as I finish typing func I get the warning and indentation, etc. stops working correctly.

Introduced new custom indentation offset value for multi-line dot expression: swift-indent-multiline-dot-offset. It defaults to nil to match default smiebehaviour.

Fixes #41

I fixed indent after comment.

• expected result:

func foo() {
    foo()
    //
    |foo()
}

• actual:

func foo() {
    foo()
    //
        |foo()
}

When chaining method calls and inserting a line break, the indention breaks. With the following code:

let json_ary = NSJSONSerialization
.JSONObjectWithData(data, options: nil,
                    error: &json_err) as NSArray

I expect it to get indented like this:

let json_ary = NSJSONSerialization
  .JSONObjectWithData(data, options: nil,
                      error: &json_err) as NSArray

• [ ] guard
• [ ] do blocks
• [ ] Error handling
  • [ ] throws in function declaration
  • [ ] do catch syntax
  • [ ] try keyword
• [ ] defer
• [ ] Pattern matching
  • [ ] if
  • [ ] for
• [ ] @testable
• [ ] repeat
• [ ] new Extensions with predicates
• [ ] indirect cases in enums

With the latest changes I get the following error whenever I open a Swift file:

Error: (wrong-type-argument stringp ("/var/folders/x2/rr8_tk0169n9w8_lmjv6rg300000gn/T/flycheck63731PnK/AppDelegate.swift"))

The exact folder differs, but the message is always the same.

Whenever I open a Swift file I get this error:

File mode specification error: (void-variable flycheck-swift-sdk-path)

I have to comment the eval-after-load block to avoid this error message and make Emacs usable again.

SMIE pretty much aims to end the practice of every package rolling out custom indentation logic. You can see ruby-mode in Emacs's trunk for a good example of SMIE usage.

• Add an email address to Maintainer header for elpa.nongnu.org.
• Fix linter script to check dependency errors.
• Fix dependency errors and other warnings.
• Rename test/swift-files/imenu/imenu-expected.el to test/swift-files/imenu/imenu-expected.eld since it only contains data rather than code.

Co-authored-by: @monnier

I was the primary developer of this file when I was on the Swift project, and there are some nice bits in there that might benefit your mode. In particular, the -skip- functions approximately parse swift pretty reliably and efficiently (I see you have your own code for that and I haven't tried to compare it, but the hangs with which-function mode make me suspect you might want to try a different approach), and there are useful functions for folding away the details of files when you want to easily understand an API.

I sucked those into my personal configuration so I could still use that functionality with your mode.

If there's any interest, I'm happy to help. OTOH, if you've already evaluated what's in there and decided none of it is useful, then, sorry for the noise!

After some investigation of my own swift-stuff for emacs I noticed that "uname -a" is different in iTerm compared to emacs shell. iTerm (rosetta) returns x86_64 while Emacs returns arm64.

The only way I could get xcodebuild to run correctly on M1 is if its prepended with "env /usr/bin/arch - x86_64 \\". Just to be clear, the command runs oki but the -destination with iOS Simulator doesnt work without it.

When trying to call functionjit-lock-fontify-now, this errror will occur.

Debugger entered--Lisp error: (error "Lisp nesting exceeds ‘max-lisp-eval-depth’")
  #f(compiled-function (matched names) #)(nil #)
  #f(compiled-function (elt) #)(#)
  mapc(#f(compiled-function (elt) #) (# #))
  seq-do(#f(compiled-function (elt) #) (# #))
  seq-reduce(#f(compiled-function (matched names) #) (# #) nil)
  #f(compiled-function (pos limit) #)(7758 18354)
  swift-mode:font-lock-match-expr(18354 #f(compiled-function (pos limit) #))
  swift-mode:font-lock-match-expr(18354 #f(compiled-function (pos limit) #))
  swift-mode:font-lock-match-expr(18354 #f(compiled-function (pos limit) #))
  swift-mode:font-lock-match-expr(18354 #f(compiled-function (pos limit) #))
  ...
  ....[lots of same lines]...
  ....
  swift-mode:font-lock-match-expr(18354 #f(compiled-function (pos limit) #))
  swift-mode:font-lock-match-expr(18354 #f(compiled-function (pos limit) #))
  swift-mode:font-lock-match-expr(18354 #f(compiled-function (pos limit) #))
  swift-mode:font-lock-match-builtin-enum-case-names(18354)
  font-lock-fontify-keywords-region(1519 18354 nil)
  font-lock-default-fontify-region(1519 18354 nil)
  font-lock-fontify-region(1519 18354)
  #f(compiled-function (fun) #)(font-lock-fontify-region)
  run-hook-wrapped(#f(compiled-function (fun) #) font-lock-fontify-region)
  jit-lock--run-functions(1519 18354)
  jit-lock-fontify-now()

Restart emacs, and when it tries to restore the previously opened swift file, it will freeze. By executing the C-g key serveral times, it will return to normal, and there will be the following output in *Messages* buffer:

Error during redisplay: (internal--syntax-propertize 1442) signaled (quit)
Error during redisplay: (internal--syntax-propertize 4000) signaled (quit)
Error during redisplay: (internal--syntax-propertize 6042) signaled (quit)
Error during redisplay: (internal--syntax-propertize 8248) signaled (quit)
Error during redisplay: (internal--syntax-propertize 10546) signaled (quit)
Error during redisplay: (internal--syntax-propertize 12685) signaled (quit)
Error during redisplay: (internal--syntax-propertize 14710) signaled (quit)
Error during redisplay: (internal--syntax-propertize 16795) signaled (quit)

Example code with cursor as []:

  // []Start my application.  
  public func application(

Hit C-M-SPC, C-M-@ or mark-sexp, marked region in between []

  // [Start my application.  
  public] func application(

Expected (eg from objc-mode)

  // [Start] my application.  
  public func application(

I've been trying to start a refactoring mode for Swift that would work something like js2r-refactor by Magnar. I keep thinking that Swift-mode would need to be updated to find nodes, etc. Just wanted to know what any of you thought about this mode and if anybody would like to help.

Thanks!