Command failed due to signal: Segmentation fault: 11

None of these answers worked for me but I found my issue. It had to do with [Error Handling](

[To see links please register here]

) (in the Disabling Error Propagation section). I had this method:

func getSlider() throws -> UISlider {
... // code that could throw an error
return UISlider()
}

Referencing it like this:

func anotherMethod() -> Float {
return try! getSlider().value
}

gave the error. But, when switching to this, it went away:

func anotherMethod() -> Float {
return (try! getSlider()).value
}

Read the debug message carefully.

in my case, I encountered this error because I used a single '=' instead of double '=' by mistake in if-statement.


if aString.characters.count = 2 {...}

Easy fix if using git.

**1)** In terminal:

git stash

**2)** Seg fault disappears.

**3)** Run the app.

**4)** In terminal:

git stash pop

**5)** Xcode now tells you the real problem.

For me it's because I have two bundles with the same name.

In my case Product Clean and then restarting Xcode did resolve this problem...

I got this error when I was overriding a property in a subclass and I didn't repeat the property's declaration exactly.

Base class:

`var foo: String! {return nil}`

Subclass:

`override var foo: String {return "bar"} // missing the implicit unwrap operator`

For me this popped up when I accidentally called "super.init()" inside a completionHandler of a method that was called from the class init method.

init() {
someFunction(argument, completionHandler: { (data) -> () in
super.init()
...
}

instead of

init() {
super.init()
someFunction(argument, completionHandler: { (data) -> () in
...
}

In my case, I had several instances of methods taking a closure with a signature like this (_notice the **optional** array of dictionaries_):

// 'results' being nil means "failure".
func queryItems(
completion:( (results:[[String:AnyObject]]?)->(Void) )
)
{
// (async operation...)



...which I started to refactor into:

// 'results' is NEVER nil (at most, empty). Pass any errors to the
// failure: closure instead.
func queryItems(
success:( (results:[[String:AnyObject]])->(Void) ),
failure:( (error:NSError) -> (Void) )
)
{
// (async operation...)

...but did not finish, so some methods expected a closure with an optional argument and where being passed a non-optional one (or viceversa?), and I guess the compiler lost track.

I encountered this bug when attempting to define a new `OptionSetType` struct in Swift 2. When I corrected the type on the `init()` parameter from `Self.RawValue` to `Int` the crash stopped occurring:

// bad:
// public init(rawValue: Self.RawValue) {
// self.rawValue = rawValue
// }

// good:
public init(rawValue: Int) {
self.rawValue = rawValue
}

I just had this issue and found that it was because I had accidentally left an `override` on a function that I'd moved from the class to a protocol (therefore the subclass was no longer overriding a function of the parent).