Merge pull request #8386 from slavapestov/non-overlapping-availability-for-properties

Allow overloading properties with non-overlapping availability

Author: slavapestov

lib/Sema/TypeCheckDecl.cpp

@@ -953,10 +953,10 @@ static void checkRedeclaration(TypeChecker &tc, ValueDecl *current) {
           continue;
       }
 
-      // If the conflicting declarations have non-overlapping availability and
-      // - one throws and the other does not,
-      // - or they are initializers with different failability
-      // let them go.
+      // If the conflicting declarations have non-overlapping availability and,
+      // we allow the redeclaration to proceed if...
+      //
+      // - they are initializers with different failability,
       bool isAcceptableVersionBasedChange = false;
       {
         const auto *currentInit = dyn_cast<ConstructorDecl>(current);
@@ -967,6 +967,7 @@ static void checkRedeclaration(TypeChecker &tc, ValueDecl *current) {
           isAcceptableVersionBasedChange = true;
         }
       }
+      // - one throws and the other does not,
       {
         const auto *currentAFD = dyn_cast<AbstractFunctionDecl>(current);
         const auto *otherAFD = dyn_cast<AbstractFunctionDecl>(other);
@@ -975,6 +976,19 @@ static void checkRedeclaration(TypeChecker &tc, ValueDecl *current) {
           isAcceptableVersionBasedChange = true;
         }
       }
+      // - or they are computed properties of different types,
+      {
+        const auto *currentVD = dyn_cast<VarDecl>(current);
+        const auto *otherVD = dyn_cast<VarDecl>(other);
+        if (currentVD && otherVD &&
+            !currentVD->hasStorage() &&
+            !otherVD->hasStorage() &&
+            !currentVD->getInterfaceType()->isEqual(
+              otherVD->getInterfaceType())) {
+          isAcceptableVersionBasedChange = true;
+        }
+      }
+
       if (isAcceptableVersionBasedChange) {
         class AvailabilityRange {
           Optional<clang::VersionTuple> introduced;

test/SILGen/Inputs/availability_overloads_other.swift

@@ -0,0 +1,31 @@
+public class BeforeAndAfterOther {
+  @available(swift, obsoleted: 4.0)
+  public init(foo: ()) {}
+
+  @available(swift 4.0)
+  public init?(foo: ()) {}
+
+  @available(swift, obsoleted: 4.0)
+  public init() {}
+
+  @available(swift 4.0)
+  public init() throws {}
+
+  @available(swift, obsoleted: 4.0)
+  public static func foo() {}
+
+  @available(swift 4.0)
+  public static func foo() throws {}
+
+  @available(swift 4.0)
+  public var computed: Int16 { get { return 0 } set { } }
+
+  @available(swift, obsoleted: 4.0)
+  public var computed: Int8 { get { return 0 } set { } }
+
+  @available(swift 4.0)
+  public static var computed: Int16 { get { return 0 } set { } }
+
+  @available(swift, obsoleted: 4.0)
+  public static var computed: Int8 { get { return 0 } set { } }
+}

test/SILGen/availability_overloads.swift

@@ -1,10 +1,25 @@
-// RUN: %target-swift-frontend -emit-silgen %s
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: %target-swift-frontend -emit-module-path %t/availability_overloads_other.swiftmodule -emit-module -primary-file %S/Inputs/availability_overloads_other.swift
+
+// RUN: %target-swift-frontend -swift-version 3 -I %t -emit-silgen -primary-file %s
+// RUN: %target-swift-frontend -swift-version 3 -I %t -emit-silgen -emit-ir %s
+
+// RUN: %target-swift-frontend -swift-version 4 -I %t -emit-silgen -primary-file %s
+// RUN: %target-swift-frontend -swift-version 4 -I %t -emit-silgen -emit-ir %s
+
+// RUN: %target-swift-frontend -swift-version 3 -I %t -emit-module -emit-module-path /dev/null -primary-file %s
+// RUN: %target-swift-frontend -swift-version 4 -I %t -emit-module -emit-module-path /dev/null -primary-file %s
 
 // This is a "don't crash with duplicate definition errors" test.
 // We care about being able to express each of these "redeclarations" when the
 // availability doesn't overlap.
 
-class BeforeAndAfter {
+import availability_overloads_other
+
+// FIXME: What about method overrides and protocol witnesses?
+
+public class BeforeAndAfter {
   @available(swift, obsoleted: 4.0)
   public init(foo: ()) {}
 
@@ -22,4 +37,35 @@ class BeforeAndAfter {
 
   @available(swift 4.0)
   public static func foo() throws {}
+
+  @available(swift 4.0)
+  public var computed: Int16 { get { return 0 } set { } }
+
+  @available(swift, obsoleted: 4.0)
+  public var computed: Int8 { get { return 0 } set { } }
+
+  @available(swift 4.0)
+  public static var computed: Int16 { get { return 0 } set { } }
+
+  @available(swift, obsoleted: 4.0)
+  public static var computed: Int8 { get { return 0 } set { } }
 }
+
+
+// Make sure we can generate calls to these overloads, too
+_ = BeforeAndAfter(foo: ())
+_ = try BeforeAndAfter()
+_ = try BeforeAndAfter.foo()
+_ = BeforeAndAfter.computed
+BeforeAndAfter.computed = 10
+_ = try BeforeAndAfter().computed
+try BeforeAndAfter().computed = 10
+
+// Same thing but in a different module
+_ = BeforeAndAfterOther(foo: ())
+_ = try BeforeAndAfterOther()
+_ = try BeforeAndAfterOther.foo()
+_ = BeforeAndAfterOther.computed
+BeforeAndAfterOther.computed = 10
+_ = try BeforeAndAfterOther().computed
+try BeforeAndAfterOther().computed = 10

test/decl/init/swift-version-overload.swift renamed to test/Sema/availability_nonoverlapping.swift

@@ -335,3 +335,30 @@ _ = ThrowingToNonThrowingReversed()
 _ = ThrowingToNonThrowingReversed.foo()
 // CHECK-3: :[[@LINE-1]]:{{.+}} not 4.0
 // CHECK-4: :[[@LINE-2]]:{{.+}} yes 4.0
+
+class ChangePropertyType {
+
+  // We don't allow this for stored properties.
+
+  @available(swift 4.0)
+  @available(*, deprecated, message: "yes 4.0")
+  public var stored: Int16 = 0
+
+  @available(swift, obsoleted: 4.0)
+  @available(*, deprecated, message: "not 4.0")
+  public var stored: Int8 = 0 // CHECK: :[[@LINE]]:{{.+}} error: invalid redeclaration of 'stored'
+
+  // OK for computed properties.
+
+  @available(swift 4.0)
+  @available(*, deprecated, message: "yes 4.0")
+  public var computed: Int16 { get { } set { } }
+
+  @available(swift, obsoleted: 4.0)
+  @available(*, deprecated, message: "not 4.0")
+  public var computed: Int8 { get { } set { } } // NEGATIVE-NOT: :[[@LINE]]:{{.+}}error
+}
+
+_ = ChangePropertyType().computed
+// CHECK-3: :[[@LINE-1]]:{{.+}} not 4.0
+// CHECK-4: :[[@LINE-2]]:{{.+}} yes 4.0