For 'lazy', make "cannot override with a stored property" a warning (#13304)

Previous versions of Swift accidentally treated lazy properties as
computed properties because of how they were implemented. Now that we
check this correctly, we've broken source compatibility. Downgrade the
error to a warning in this case.

(Arguably we could /allow/ overriding with a stored property. The
original concerns were that you could accidentally end up with extra
storage you didn't need, and that observing accessors would behave
differently based on whether or not the property was overriding. But
there's at least no ambiguity for 'lazy', which can't have observing
accessors today.)

rdar://problem/35870371

include/swift/AST/DiagnosticsSema.def

@@ -1877,6 +1877,8 @@ ERROR(override_property_type_mismatch,none,
       (Identifier, Type, Type))
 ERROR(override_with_stored_property,none,
       "cannot override with a stored property %0", (Identifier))
+WARNING(override_with_stored_property_warn,none,
+      "cannot override with a stored property %0", (Identifier))
 ERROR(observing_readonly_property,none,
       "cannot observe read-only property %0; it can't change", (Identifier))
 ERROR(override_mutable_with_readonly_property,none,

lib/Sema/TypeCheckDecl.cpp

@@ -6623,7 +6623,15 @@ public:
       
       // Make sure that the overriding property doesn't have storage.
       if (overrideASD->hasStorage() && !overrideASD->hasObservers()) {
-        TC.diagnose(overrideASD, diag::override_with_stored_property,
+        auto diagID = diag::override_with_stored_property;
+        if (!TC.Context.isSwiftVersionAtLeast(5) &&
+            overrideASD->getAttrs().hasAttribute<LazyAttr>()) {
+          // Swift 4.0 had a bug where lazy properties were considered
+          // computed by the time of this check. Downgrade this diagnostic to
+          // a warning.
+          diagID = diag::override_with_stored_property_warn;
+        }
+        TC.diagnose(overrideASD, diagID,
                     overrideASD->getBaseName().getIdentifier());
         TC.diagnose(baseASD, diag::property_override_here);
         return true;

test/Compatibility/attr_override.swift

@@ -0,0 +1,441 @@
+// RUN: %target-typecheck-verify-swift -swift-version 4
+
+@override // expected-error {{'override' can only be specified on class members}} {{1-11=}} expected-error {{'override' is a declaration modifier, not an attribute}} {{1-2=}}
+func virtualAttributeCanNotBeUsedInSource() {}
+
+class MixedKeywordsAndAttributes { // expected-note {{in declaration of 'MixedKeywordsAndAttributes'}}
+  // expected-error@+1 {{expected declaration}} expected-error@+1 {{consecutive declarations on a line must be separated by ';'}} {{11-11=;}}
+  override @inline(never) func f1() {}
+}
+
+class DuplicateOverrideBase {
+  func f1() {}
+  class func cf1() {}
+  class func cf2() {}
+  class func cf3() {}
+  class func cf4() {}
+}
+class DuplicateOverrideDerived : DuplicateOverrideBase {
+  override override func f1() {} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
+  override override class func cf1() {} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
+  override class override func cf2() {} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
+  class override override func cf3() {} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
+  override class override func cf4() {} // expected-error {{duplicate modifier}} expected-note {{modifier already specified here}}
+}
+
+class A {
+  func f0() { }
+  func f1() { } // expected-note{{overridden declaration is here}}
+
+  var v1: Int { return 5 }
+  var v2: Int { return 5 } // expected-note{{overridden declaration is here}}
+  var v4: String { return "hello" }// expected-note{{attempt to override property here}}
+  var v5: A { return self }
+  var v6: A { return self }
+  var v7: A { // expected-note{{attempt to override property here}}
+    get { return self }
+    set { }
+  }
+  var v8: Int = 0  // expected-note {{attempt to override property here}}
+  var v9: Int { return 5 } // expected-note{{attempt to override property here}}
+  var v10: Int { return 5 } // expected-note{{attempt to override property here}}
+
+  subscript (i: Int) -> String { // expected-note{{potential overridden subscript 'subscript' here}}
+    get {
+      return "hello"
+    }
+
+    set {
+    }
+  }
+
+  subscript (d: Double) -> String { // expected-note{{overridden declaration is here}} expected-note{{potential overridden subscript 'subscript' here}}
+    get {
+      return "hello"
+    }
+
+    set {
+    }
+  }
+
+  subscript (i: Int8) -> A { // expected-note{{potential overridden subscript 'subscript' here}}
+    get { return self }
+  }
+
+  subscript (i: Int16) -> A { // expected-note{{attempt to override subscript here}} expected-note{{potential overridden subscript 'subscript' here}}
+    get { return self }
+    set { }
+  }
+
+  func overriddenInExtension() {} // expected-note {{overridden declaration is here}}
+}
+
+class B : A {
+  override func f0() { }
+  func f1() { } // expected-error{{overriding declaration requires an 'override' keyword}}{{3-3=override }}
+  override func f2() { } // expected-error{{method does not override any method from its superclass}}
+
+  override var v1: Int { return 5 }
+  var v2: Int { return 5 } // expected-error{{overriding declaration requires an 'override' keyword}}
+  override var v3: Int { return 5 } // expected-error{{property does not override any property from its superclass}}
+  override var v4: Int { return 5 } // expected-error{{property 'v4' with type 'Int' cannot override a property with type 'String'}}
+
+  // Covariance
+  override var v5: B { return self }
+  override var v6: B {
+    get { return self }
+    set { }
+  }
+
+  override var v7: B { // expected-error{{cannot override mutable property 'v7' of type 'A' with covariant type 'B'}}
+    get { return self }
+    set { }
+  }
+
+  // Stored properties
+  override var v8: Int { return 5 } // expected-error {{cannot override mutable property with read-only property 'v8'}}
+  override var v9: Int // expected-error{{cannot override with a stored property 'v9'}}
+  lazy override var v10: Int = 5 // expected-warning{{cannot override with a stored property 'v10'}}
+
+  override subscript (i: Int) -> String {
+    get {
+      return "hello"
+    }
+
+    set {
+    }
+  }
+
+  subscript (d: Double) -> String { // expected-error{{overriding declaration requires an 'override' keyword}} {{3-3=override }}
+    get {
+      return "hello"
+    }
+
+    set {
+    }
+  }
+
+  override subscript (f: Float) -> String { // expected-error{{subscript does not override any subscript from its superclass}}
+    get {
+      return "hello"
+    }
+
+    set {
+    }
+  }
+
+  // Covariant
+  override subscript (i: Int8) -> B {
+    get { return self }
+  }
+
+  override subscript (i: Int16) -> B { // expected-error{{cannot override mutable subscript of type '(Int16) -> B' with covariant type '(Int16) -> A'}}
+    get { return self }
+    set { }
+  }
+
+  override init() { }
+  override deinit { } // expected-error{{'override' modifier cannot be applied to this declaration}} {{3-12=}}
+  override typealias Inner = Int // expected-error{{'override' modifier cannot be applied to this declaration}} {{3-12=}}
+}
+
+extension B {
+  override func overriddenInExtension() {} // expected-error{{overriding declarations in extensions is not supported}}
+}
+
+struct S {
+  override func f() { } // expected-error{{'override' can only be specified on class members}} {{3-12=}}
+}
+extension S {
+  override func ef() {} // expected-error{{method does not override any method from its superclass}}
+}
+
+enum E {
+  override func f() { } // expected-error{{'override' can only be specified on class members}} {{3-12=}}
+}
+
+protocol P {
+  override func f() // expected-error{{'override' can only be specified on class members}} {{3-12=}}
+}
+
+override func f() { } // expected-error{{'override' can only be specified on class members}} {{1-10=}}
+
+// Invalid 'override' on declarations inside closures.
+var rdar16654075a = {
+  override func foo() {}  // expected-error{{'override' can only be specified on class members}} {{3-12=}}
+}
+var rdar16654075b = {
+  class A {
+    override func foo() {}  // expected-error{{method does not override any method from its superclass}}
+  }
+}
+var rdar16654075c = { () -> () in
+  override func foo() {} // expected-error {{'override' can only be specified on class members}} {{3-12=}}
+  ()
+}
+var rdar16654075d = { () -> () in
+  class A {
+    override func foo() {} // expected-error {{method does not override any method from its superclass}}
+  }
+  A().foo()
+}
+var rdar16654075e = { () -> () in
+  class A {
+    func foo() {}
+  }
+  class B : A {
+    override func foo() {}
+  }
+  A().foo()
+}
+
+class C { 
+  init(string: String) { } // expected-note{{overridden declaration is here}}
+  required init(double: Double) { } // expected-note 3{{overridden required initializer is here}}
+
+  convenience init() { self.init(string: "hello") } // expected-note{{attempt to override convenience initializer here}}
+}
+
+class D1 : C {
+  override init(string: String) { super.init(string: string) }
+  required init(double: Double) { }
+  convenience init() { self.init(string: "hello") }
+}
+
+class D2 : C {
+  init(string: String) { super.init(string: string) } // expected-error{{overriding declaration requires an 'override' keyword}}{{3-3=override }}
+
+  // FIXME: Would like to remove the space after 'override' as well.
+  required override init(double: Double) { } // expected-warning{{'override' is implied when overriding a required initializer}} {{12-21=}}
+  override convenience init() { self.init(string: "hello") } // expected-error{{initializer does not override a designated initializer from its superclass}}
+}
+
+class D3 : C {
+  override init(string: String) { super.init(string: string) }
+  override init(double: Double) { } // expected-error{{use the 'required' modifier to override a required initializer}}{{3-11=required}}
+}
+
+class D4 : C {
+  // "required override" only when we're overriding a non-required
+  // designated initializer with a required initializer.
+  required override init(string: String) { super.init(string: string) }
+  required init(double: Double) { }
+}
+
+class D5 : C {
+  // "required override" only when we're overriding a non-required
+  // designated initializer with a required initializer.
+  required convenience override init(string: String) { self.init(double: 5.0) }
+  required init(double: Double) { }
+}
+
+class D6 : C {
+  init(double: Double) { } // expected-error{{'required' modifier must be present on all overrides of a required initializer}} {{3-3=required }}
+}
+
+// rdar://problem/18232867
+class C_empty_tuple {
+  init() { }
+}
+
+class D_empty_tuple : C_empty_tuple {
+  override init(foo:()) { } // expected-error{{initializer does not override a designated initializer from its superclass}}
+}
+
+class C_with_let {
+  let x = 42  // expected-note {{attempt to override property here}}
+}
+
+class D_with_let : C_with_let {
+  override var x : Int { get { return 4 } set {} }  // expected-error {{cannot override immutable 'let' property 'x' with the getter of a 'var'}}
+}
+
+
+// <rdar://problem/21311590> QoI: Inconsistent diagnostics when no constructor is available
+class C21311590 {
+  override init() {}  // expected-error {{initializer does not override a designated initializer from its superclass}}
+}
+class B21311590 : C21311590 {}
+_ = C21311590()
+_ = B21311590()
+
+
+class MismatchOptionalBase {
+  func param(_: Int?) {}
+  func paramIUO(_: Int!) {}
+  func result() -> Int { return 0 }
+
+  func fixSeveralTypes(a: Int?, b: Int!) -> Int { return 0 }
+
+  func functionParam(x: ((Int) -> Int)?) {}
+  func tupleParam(x: (Int, Int)?) {}
+  func compositionParam(x: (P1 & P2)?) {}
+
+  func nameAndTypeMismatch(label: Int?) {}
+
+  func ambiguousOverride(a: Int, b: Int?) {} // expected-note 2 {{overridden declaration is here}} expected-note {{potential overridden instance method 'ambiguousOverride(a:b:)' here}}
+  func ambiguousOverride(a: Int?, b: Int) {} // expected-note 2 {{overridden declaration is here}} expected-note {{potential overridden instance method 'ambiguousOverride(a:b:)' here}}
+
+  var prop: Int = 0 // expected-note {{attempt to override property here}}
+  var optProp: Int? // expected-note {{attempt to override property here}}
+
+  var getProp: Int { return 0 } // expected-note {{attempt to override property here}}
+  var getOptProp: Int? { return nil }
+
+  init(param: Int?) {}
+  init() {} // expected-note {{non-failable initializer 'init()' overridden here}}
+
+  subscript(a: Int?) -> Void { // expected-note {{attempt to override subscript here}}
+    get { return () }
+    set {}
+  }
+  subscript(b: Void) -> Int { // expected-note {{attempt to override subscript here}}
+    get { return 0 }
+    set {}
+  }
+
+  subscript(get a: Int?) -> Void {
+    return ()
+  }
+  subscript(get b: Void) -> Int {
+    return 0
+  }
+
+  subscript(ambiguous a: Int, b: Int?) -> Void { // expected-note {{overridden declaration is here}} expected-note {{potential overridden subscript 'subscript(ambiguous:_:)' here}}
+    return ()
+  }
+  subscript(ambiguous a: Int?, b: Int) -> Void { // expected-note {{overridden declaration is here}} expected-note {{potential overridden subscript 'subscript(ambiguous:_:)' here}}
+    return ()
+  }
+}
+
+protocol P1 {}
+protocol P2 {}
+
+class MismatchOptional : MismatchOptionalBase {
+  override func param(_: Int) {} // expected-error {{cannot override instance method parameter of type 'Int?' with non-optional type 'Int'}} {{29-29=?}}
+  override func paramIUO(_: Int) {} // expected-error {{cannot override instance method parameter of type 'Int!' with non-optional type 'Int'}} {{32-32=?}}
+  override func result() -> Int? { return nil } // expected-error {{cannot override instance method result type 'Int' with optional type 'Int?'}} {{32-33=}}
+
+  override func fixSeveralTypes(a: Int, b: Int) -> Int! { return nil }
+  // expected-error@-1 {{cannot override instance method parameter of type 'Int?' with non-optional type 'Int'}} {{39-39=?}}
+  // expected-error@-2 {{cannot override instance method parameter of type 'Int!' with non-optional type 'Int'}} {{47-47=?}}
+  // expected-error@-3 {{cannot override instance method result type 'Int' with optional type 'Int!'}} {{55-56=}}
+
+  override func functionParam(x: @escaping (Int) -> Int) {} // expected-error {{cannot override instance method parameter of type '((Int) -> Int)?' with non-optional type '(Int) -> Int'}} {{34-34=(}} {{56-56=)?}}
+  override func tupleParam(x: (Int, Int)) {} // expected-error {{cannot override instance method parameter of type '(Int, Int)?' with non-optional type '(Int, Int)'}} {{41-41=?}}
+  override func compositionParam(x: P1 & P2) {} // expected-error {{cannot override instance method parameter of type '(P1 & P2)?' with non-optional type 'P1 & P2'}} {{37-37=(}} {{44-44=)?}}
+
+  override func nameAndTypeMismatch(_: Int) {}
+  // expected-error@-1 {{argument labels for method 'nameAndTypeMismatch' do not match those of overridden method 'nameAndTypeMismatch(label:)'}} {{37-37=label }}
+  // expected-error@-2 {{cannot override instance method parameter of type 'Int?' with non-optional type 'Int'}} {{43-43=?}}
+
+  override func ambiguousOverride(a: Int?, b: Int?) {} // expected-error {{declaration 'ambiguousOverride(a:b:)' cannot override more than one superclass declaration}} {{none}}
+  override func ambiguousOverride(a: Int, b: Int) {} // expected-error {{method does not override any method from its superclass}} {{none}}
+
+  override var prop: Int? { // expected-error {{property 'prop' with type 'Int?' cannot override a property with type 'Int'}} {{none}}
+    get { return nil }
+    set {}
+  }
+  override var optProp: Int { // expected-error {{cannot override mutable property 'optProp' of type 'Int?' with covariant type 'Int'}} {{none}}
+    get { return 0 }
+    set {}
+  }
+  override var getProp: Int? { return nil } // expected-error {{property 'getProp' with type 'Int?' cannot override a property with type 'Int'}} {{none}}
+  override var getOptProp: Int { return 0 } // okay
+
+  override init(param: Int) {} // expected-error {{cannot override initializer parameter of type 'Int?' with non-optional type 'Int'}}
+  override init?() {} // expected-error {{failable initializer 'init()' cannot override a non-failable initializer}} {{none}}
+
+  override subscript(a: Int) -> Void { // expected-error {{cannot override mutable subscript of type '(Int) -> Void' with covariant type '(Int?) -> Void'}}
+    get { return () }
+    set {}
+  }
+  override subscript(b: Void) -> Int? { // expected-error {{cannot override mutable subscript of type '(Void) -> Int?' with covariant type '(Void) -> Int'}}
+    get { return nil }
+    set {}
+  }
+
+  override subscript(get a: Int) -> Void { // expected-error {{cannot override subscript index of type 'Int?' with non-optional type 'Int'}} {{32-32=?}}
+    return ()
+  }
+  override subscript(get b: Void) -> Int? { // expected-error {{cannot override subscript element type 'Int' with optional type 'Int?'}} {{41-42=}}
+    return nil
+  }
+
+  override subscript(ambiguous a: Int?, b: Int?) -> Void { // expected-error {{declaration 'subscript(ambiguous:_:)' cannot override more than one superclass declaration}}
+    return ()
+  }
+  override subscript(ambiguous a: Int, b: Int) -> Void { // expected-error {{subscript does not override any subscript from its superclass}}
+    return ()
+  }
+}
+
+class MismatchOptional2 : MismatchOptionalBase {
+  override func result() -> Int! { return nil } // expected-error {{cannot override instance method result type 'Int' with optional type 'Int!'}} {{32-33=}}
+
+  // None of these are overrides because we didn't say 'override'. Since they're
+  // not exact matches, they shouldn't result in errors.
+  func param(_: Int) {}
+  func ambiguousOverride(a: Int, b: Int) {}
+
+  // This is covariant, so we still assume it's meant to override.
+  func ambiguousOverride(a: Int?, b: Int?) {} // expected-error {{declaration 'ambiguousOverride(a:b:)' cannot override more than one superclass declaration}}
+}
+
+class MismatchOptional3 : MismatchOptionalBase {
+  override func result() -> Optional<Int> { return nil } // expected-error {{cannot override instance method result type 'Int' with optional type 'Optional<Int>'}} {{none}}
+}
+
+// Make sure we remap the method's innermost generic parameters
+// to the correct depth
+class GenericBase<T> {
+  func doStuff<U>(t: T, u: U) {}
+  init<U>(t: T, u: U) {}
+}
+
+class ConcreteSub : GenericBase<Int> {
+  override func doStuff<U>(t: Int, u: U) {}
+  override init<U>(t: Int, u: U) {}
+}
+
+class ConcreteBase {
+  init<U>(t: Int, u: U) {}
+  func doStuff<U>(t: Int, u: U) {}
+
+}
+
+class GenericSub<T> : ConcreteBase {
+  override init<U>(t: Int, u: U) {}
+  override func doStuff<U>(t: Int, u: U) {}
+}
+
+// Issue with generic parameter index
+class MoreGenericSub1<T, TT> : GenericBase<T> {
+  override func doStuff<U>(t: T, u: U) {}
+}
+
+class MoreGenericSub2<TT, T> : GenericBase<T> {
+  override func doStuff<U>(t: T, u: U) {}
+}
+
+// Issue with insufficient canonicalization when
+// comparing types
+protocol SI {}
+protocol CI {}
+
+protocol Sequence {
+  associatedtype I : SI // expected-note{{declared here}}
+}
+
+protocol Collection : Sequence {
+  associatedtype I : CI // expected-warning{{redeclaration of associated type 'I'}}
+}
+
+class Index<F, T> {
+  func map(_ f: F) -> T {}
+}
+
+class CollectionIndex<C : Collection> : Index<C, C.I> {
+  override func map(_ f: C) -> C.I {}
+}

test/attr/attr_override.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -swift-version 5
 
 @override // expected-error {{'override' can only be specified on class members}} {{1-11=}} expected-error {{'override' is a declaration modifier, not an attribute}} {{1-2=}}
 func virtualAttributeCanNotBeUsedInSource() {}
@@ -38,6 +38,7 @@ class A {
   }
   var v8: Int = 0  // expected-note {{attempt to override property here}}
   var v9: Int { return 5 } // expected-note{{attempt to override property here}}
+  var v10: Int { return 5 } // expected-note{{attempt to override property here}}
 
   subscript (i: Int) -> String { // expected-note{{potential overridden subscript 'subscript' here}}
     get {
@@ -94,6 +95,7 @@ class B : A {
   // Stored properties
   override var v8: Int { return 5 } // expected-error {{cannot override mutable property with read-only property 'v8'}}
   override var v9: Int // expected-error{{cannot override with a stored property 'v9'}}
+  lazy override var v10: Int = 5 // expected-error{{cannot override with a stored property 'v10'}}
 
   override subscript (i: Int) -> String {
     get {