Is this a bug in Xcode or a practice should be avoid by programmer?

Question

In the first place, I looked for a way to simplify coding by providing default argument values for protocol functions. I took the solution here and then found some fatal subsequence it may bring:

protocol Foo {
    func foo(_ a: Int)
}

extension Foo {
    func foo(_ a: Int = 4) {
        foo(a)
    }
}

struct FooImpl: Foo {
    // empty implementation
}

FooImpl().foo() // will go recursively forever and finally reach the stack limit

I also found that this code would fail to compile in IBM Swift Sandbox thus supposing xcode compiler might be to blame.

Is the comment the compiler error you get? – shallowThought May 13 '17 at 08:35 — shallowThought, May 13 '17 at 08:35

Scott Thompson · Accepted Answer · 2017-05-13T08:35:54.007

4

This looks to be valid Swift code that the compiler should accept and execute. That it contains a fatal infinite recursion is a logic error on the part of the programmer.

I don't see anything in the IBM Swift Sandbox to indicate that it handles the code any better, or differently, than Xcode.

edited May 13 '17 at 08:35

answered May 13 '17 at 08:17

Scott Thompson

22,629
4
32
34

IBM Sandbox says "The Swift compiler reported a segmentation fault or similar error." and if I add an implementation to the `FooImpl` or make the extension non-recursive, the sandbox would accept the code. – Nandin Borjigin May 13 '17 at 08:29
The sandbox only says that when you ask it to run the code. At which time you try to perform an infinite recursion which causes a crash and leads to the error. If you add an implementation to `FooImpl` then you are no longer executing the default implementation that makes the infinitely recursive call that is causing the crash. – Scott Thompson May 13 '17 at 08:31

score 0 · Answer 2 · answered May 13 '17 at 08:37

You omitted a very important part of the implementation. If you do this you have to implement foo in FooImpl. If you do not implement it your code is basically equivalent to

protocol Foo {
}

extension Foo {
    func foo(_ a: Int = 4) {
        foo(a)
    }
}

struct FooImpl: Foo {
}

FooImpl().foo()

which obviously creates an infinite loop. If you correctly implement foo you will see the expected behaviour:

protocol Foo {
    func foo(_ a: Int)
}

extension Foo {
    func foo(_ a: Int = 4) {
        foo(a)
    }
}

struct FooImpl: Foo {
    func foo(_ a: Int) {
        print(a)
    }
}

FooImpl().foo()

Both are perfectly valid swift snippets, the only difference is that one actually works, the other will crash. But that is nothing the compiler is supposed to worry about.

Is this a bug in Xcode or a practice should be avoid by programmer?

2 Answers2