@swift-ci create

This is correct behavior, unfortunately. Previous versions of Swift mistakenly allowed you to override using a stored property as long as that stored property was lazy. The rule is supposed to be that stored properties cannot be used to override at all, because it makes observing accessors ambiguous. (Are they wrapping the new storage, or the superclass's implementation?)

The intended workaround is to make a new property and forward to that one from the override.

We're not inherently against allowing stored properties to be overrides, lazy or otherwise. But it's something that would have to go through the Swift Evolution Process.

Comment by Jeff Johnson (JIRA)

For the record, I'm trying to do something like this:

protocol MyProtocol {
    var foo:String { get }
    func doSomething()
}

class BaseClass:MyProtocol {
    var foo:String { fatalError() }
    func doSomething() {
        print("Do Something")
    }
}

class SubClass:BaseClass {
    override lazy var foo:String = "Something lazy"
}

There's a dummy property in the base class for protocol conformance that must be overridden by subclasses.

From my recollection of history, our prohibition against overriding with stored properties predated our adding the required override keyword. Now that overriding is explicit it's less likely someone would do this by accident, so it's worth reconsidering the rule.

That's true, but again, we haven't solved the observing accessor problem:

class Sub: Base {
  override var foo: String {
    didSet { print(oldValue) }
  }
}

Does this allocate new storage, or wrap the parent's storage?

Comment by Jeff Johnson (JIRA)

This is interesting because in my project base class I'm actually doing something more like

lazy var foo:String = { fatalError() }()

According to the documentation, "You can add property observers to any stored properties you define, except for lazy stored properties."

I'm confused about overriding though. Are you supposed to be able to add a property observer to a lazy stored property in an override, and if so, why can't the observer be added otherwise? It appears I can add an observer in the subclass for the lazy var with

override var foo:String

Hm, I don't remember why lazy properties have a restriction on observers. The issue is more that there's a general rule about stored properties as overrides, and lazy properties are still supposed to act like stored properties and not get special privileges.

I don't think we ever intentionally prevented or enabled it. Since lazy properties are largely implemented by just expanding to a computed property under the hood, the prohibition on observers is likely to just be an accident of that.

Comment by Jeff Johnson (JIRA)

If the reason you can't override a stored property is ambiguous property observers, and lazy stored properties are not allowed to have property observers, then my argument is that you should be allowed to override a lazy stored property.

Currently there is a strange situation where you are not allowed to add property observers to a lazy stored property directly, but you are able to add property observers to a lazy stored property in an override. That may be another bug?

Whichever way you go with property observers, the current situation seems very inconsistent.

I filed a couple of follow-up bugs for the issues you raised:

https://bugs.swift.org/browse/SR-7082
https://bugs.swift.org/browse/SR-7083