Merge pull request #2703 from swiftwasm/release/5.4

[pull] swiftwasm-release/5.4 from release/5.4

Author: pull[bot]

CHANGELOG.md

@@ -28,6 +28,101 @@ CHANGELOG
 Swift 5.4
 ---------
 
+* Protocol conformance checking now considers `where` clauses when evaluating if a `typealias` is a suitable witness for an associated type requirement. The following code is now rejected:
+
+  ```swift
+  protocol Holder {
+    associatedtype Contents
+  }
+
+  struct Box<T> : Holder {}
+  // error: type 'Box<T>' does not conform to protocol 'Holder'
+
+  extension Box where T : Hashable {
+    typealias Contents = T
+  }
+  ```
+
+  In most cases, the compiler would either crash or produce surprising results when making use of a `typealias` with an unsatisfied `where` clause, but it is possible that some previously-working code is now rejected. In the above example, the conformance can be fixed in one of various ways:
+
+  1) making it conditional (moving the `: Holder` from the definition of `Box` to the extension)
+  2) moving the `typealias` from the extension to the type itself
+  3) relaxing the `where` clause on the extension
+
+* Availability checking now rejects protocols that refine less available protocols. Previously, this was accepted by the compiler but could result in linker errors or runtime crashes:
+
+  ```swift
+  @available(macOS 11, *)
+  protocol Base {}
+
+  protocol Bad : Base {}
+  // error: 'Base' is only available in macOS 11 or newer
+
+  @available(macOS 11, *)
+  protocol Good : Base {} // OK
+  ```
+
+* The `@available` attribute is no longer permitted on generic parameters, where it had no effect:
+
+  ```swift
+  struct Bad<@available(macOS 11, *) T> {}
+  // error: '@available' attribute cannot be applied to this declaration
+
+  struct Good<T> {} // equivalent
+  ```
+
+* If a type is made to conform to a protocol via an extension, the availability of the extension is now taken into account when forming generic types that use this protocol conformance. For example, consider a `Box` type whose conformance to `Hashable` uses features only available on macOS 11:
+
+  ```swift
+  public struct Box {}
+
+  @available(macOS 11, *)
+  extension Box : Hashable {
+    func hash(into: inout Hasher) {
+      // call some new API to hash the value...
+    }
+  }
+
+  public func findBad(_: Set<Box>) -> Box {}
+  // warning: conformance of 'Box' to 'Hashable' is only available in macOS 11 or newer
+
+  @available(macOS 11, *)
+  public func findGood(_: Set<Box>) -> Box {} // OK
+  ```
+
+  In the above code, it is not valid for `findBad()` to take a `Set<Box>`, since `Set` requires that its element type conform to `Hashable`; however the conformance of `Box` to `Hashable` is not available prior to macOS 11.
+
+  Note that using an unavailable protocol conformance is a warning, not an error, to avoid potential source compatibility issues. This is because it was technically possible to write code in the past that made use of unavailable protocol conformances but worked anyway, if the optimizer had serendipitously eliminated all runtime dispatch through this conformance, or the code in question was entirely unreachable at runtime.
+
+  Protocol conformances can also be marked as completely unavailable or deprecated, by placing an appropriate `@available` attribute on the extension:
+
+  ```swift
+  @available(*, unavailable, message: "Not supported anymore")
+  extension Box : Hashable {}
+
+  @available(*, deprecated, message: "Suggest using something else")
+  extension Box : Hashable {}
+  ```
+
+  If a protocol conformance is defined on the type itself, it inherits availability from the type. You can move the protocol conformance to an extension if you need it to have narrower availability than the type.
+
+* When `swift` is run with no arguments, it starts a REPL (read eval print loop) that uses LLDB. The compiler also had a second REPL implementation, known as the "integrated REPL", formerly accessible by running `swift -frontend -repl`. The "integrated REPL" was only intended for use by compiler developers, and has now been removed.
+
+  Note that this does not take away the ability to put Swift code in a script and run it with `swift myScript.swift`. This so-called "script mode" is distinct from the integrated REPL, and continues to be supported.
+
+* Property wrappers now work in local contexts, making the following valid:
+
+  ```swift
+  @propertyWrapper
+  struct Wrapper<T> {
+    var wrappedValue: T
+  }
+
+  func test() {
+    @Wrapper var value = 10
+  }
+  ```
+
 * [SR-10069][]:
 
   Function overloading now works in local contexts, making the following valid:

include/swift/AST/Decl.h

@@ -2319,10 +2319,8 @@ class ValueDecl : public Decl {
   /// dynamic methods on generic classes (see above).
   bool isNativeMethodReplacement() const;
 
-  bool isEffectiveLinkageMoreVisibleThan(ValueDecl *other) const {
-    return (std::min(getEffectiveAccess(), AccessLevel::Public) >
-            std::min(other->getEffectiveAccess(), AccessLevel::Public));
-  }
+  /// Returns if this declaration has more visible formal access than 'other'.
+  bool isMoreVisibleThan(ValueDecl *other) const;
 
   /// Set whether this type is 'dynamic' or not.
   void setIsDynamic(bool value);

lib/AST/Decl.cpp

@@ -3416,6 +3416,23 @@ static bool checkAccess(const DeclContext *useDC, const ValueDecl *VD,
   llvm_unreachable("bad access level");
 }
 
+bool ValueDecl::isMoreVisibleThan(ValueDecl *other) const {
+  auto scope = getFormalAccessScope();
+
+  // 'other' may have come from a @testable import, so we need to upgrade it's
+  // visibility to public here. That is not the same as whether 'other' is
+  // being built with -enable-testing though -- we don't want to treat it
+  // differently in that case.
+  auto otherScope = other->getFormalAccessScope(getDeclContext());
+
+  if (scope.isPublic())
+    return !otherScope.isPublic();
+  else if (scope.isInternal())
+    return !otherScope.isPublic() && !otherScope.isInternal();
+  else
+    return false;
+}
+
 bool ValueDecl::isAccessibleFrom(const DeclContext *useDC,
                                  bool forConformance,
                                  bool allowUsableFromInline) const {

lib/SIL/IR/SILFunctionType.cpp

@@ -2485,7 +2485,22 @@ static CanSILFunctionType getNativeSILFunctionType(
   case SILFunctionType::Representation::Method:
   case SILFunctionType::Representation::Closure:
   case SILFunctionType::Representation::WitnessMethod: {
-    switch (constant ? constant->kind : SILDeclRef::Kind::Func) {
+    // FIXME: We should use origConstant unconditionally here, since in the
+    // case of protocol witness thunk type lowering, we want to lower the
+    // witness's calling convention according to the convention of the protocol
+    // requirement, even if the witness has a different kind. Previously we
+    // would base this on the witness `constant`, and this worked because
+    // witnesses had always been the same decl kind as the requirement, but
+    // enum cases as static witnesses broke this invariant.
+    //
+    // To minimize the change in behavior for Swift 5.4, we only consider
+    // origConstant when constant is an EnumElement, to avoid affecting other
+    // potential corner cases I'm not thinking of in the moment.
+    auto constantToTest = constant;
+    if (constant && constant->kind == SILDeclRef::Kind::EnumElement) {
+      constantToTest = origConstant;
+    }
+    switch (constantToTest ? constantToTest->kind : SILDeclRef::Kind::Func) {
     case SILDeclRef::Kind::Initializer:
     case SILDeclRef::Kind::EnumElement:
       return getSILFunctionTypeForConventions(DefaultInitializerConventions());

lib/SILGen/SILGenApply.cpp

@@ -4265,11 +4265,12 @@ bool SILGenModule::shouldEmitSelfAsRValue(FuncDecl *fn, CanType selfType) {
 
 bool SILGenModule::isNonMutatingSelfIndirect(SILDeclRef methodRef) {
   auto method = methodRef.getFuncDecl();
-  assert(method->getDeclContext()->isTypeContext());
-  assert(method->isNonMutating());
   if (method->isStatic())
     return false;
 
+  assert(method->getDeclContext()->isTypeContext());
+  assert(method->isNonMutating() || method->isConsuming());
+
   auto fnType = M.Types.getConstantFunctionType(TypeExpansionContext::minimal(),
                                                 methodRef);
   auto importAsMember = method->getImportAsMemberStatus();

lib/SILGen/SILGenType.cpp

@@ -111,7 +111,7 @@ SILGenModule::emitVTableMethod(ClassDecl *theClass,
   bool baseLessVisibleThanDerived =
     (!usesObjCDynamicDispatch &&
      !derivedDecl->isFinal() &&
-     derivedDecl->isEffectiveLinkageMoreVisibleThan(baseDecl));
+     derivedDecl->isMoreVisibleThan(baseDecl));
 
   // Determine the derived thunk type by lowering the derived type against the
   // abstraction pattern of the base.

lib/Sema/TypeCheckDecl.cpp

@@ -1022,7 +1022,7 @@ NeedsNewVTableEntryRequest::evaluate(Evaluator &evaluator,
   // If the base is less visible than the override, we might need a vtable
   // entry since callers of the override might not be able to see the base
   // at all.
-  if (decl->isEffectiveLinkageMoreVisibleThan(base))
+  if (decl->isMoreVisibleThan(base))
     return true;
 
   using Direction = ASTContext::OverrideGenericSignatureReqCheck;

test/Driver/static-executable.swift

@@ -1,4 +1,9 @@
 // Create a self contained binary
+
+// REQUIRES: rdar74148842
+// libc.a and libm.a have duplicate definitions of '__isnanl', so this test
+// fails to build.
+
 // REQUIRES: OS=linux-gnu
 // REQUIRES: static_stdlib
 print("hello world!")

test/Interpreter/Inputs/vtables_multifile_testable_helper.swift

@@ -0,0 +1,21 @@
+open class Base {
+  public init() {}
+
+  internal func method() -> Int {
+    return 1
+  }
+}
+
+open class Middle : Base {
+  open override func method() -> Int {
+    return super.method() + 1
+  }
+}
+
+public func callBaseMethod(_ b: Base) -> Int {
+  return b.method()
+}
+
+public func callMiddleMethod(_ m: Middle) -> Int {
+  return m.method()
+}

test/Interpreter/vtables_multifile_testable.swift

@@ -0,0 +1,115 @@
+// We test various combinations to make sure that -enable-testing does not
+// break ABI with or without -enable-library-evolution.
+
+////
+
+// RUN: %empty-directory(%t)
+
+// 1) -enable-testing OFF / -enable-library-evolution OFF
+
+// RUN: %target-build-swift-dylib(%t/%target-library-name(vtables_multifile_testable_helper)) %S/Inputs/vtables_multifile_testable_helper.swift -emit-module -emit-module-path %t/vtables_multifile_testable_helper.swiftmodule
+// RUN: %target-codesign %t/%target-library-name(vtables_multifile_testable_helper)
+
+// RUN: %target-build-swift %s -L %t -I %t -lvtables_multifile_testable_helper -o %t/main %target-rpath(%t)
+// RUN: %target-codesign %t/main
+
+// RUN: %target-run %t/main %t/%target-library-name(vtables_multifile_testable_helper)
+
+// 2) -enable-testing ON / -enable-library-evolution OFF
+
+// ... first without rebuilding the client:
+
+// RUN: %target-build-swift-dylib(%t/%target-library-name(vtables_multifile_testable_helper)) %S/Inputs/vtables_multifile_testable_helper.swift -enable-testing -emit-module -emit-module-path %t/vtables_multifile_testable_helper.swiftmodule
+// RUN: %target-codesign %t/%target-library-name(vtables_multifile_testable_helper)
+
+// RUN: %target-run %t/main %t/%target-library-name(vtables_multifile_testable_helper)
+
+// ... now try to rebuild the client:
+
+// RUN: %target-build-swift %s -L %t -I %t -lvtables_multifile_testable_helper -o %t/main %target-rpath(%t)
+// RUN: %target-codesign %t/main
+
+// RUN: %target-run %t/main %t/%target-library-name(vtables_multifile_testable_helper)
+
+////
+
+// Delete build artifacts
+// RUN: %empty-directory(%t)
+
+// 3) -enable-testing OFF / -enable-library-evolution ON
+
+// RUN: %target-build-swift-dylib(%t/%target-library-name(vtables_multifile_testable_helper)) %S/Inputs/vtables_multifile_testable_helper.swift -enable-library-evolution -emit-module -emit-module-path %t/vtables_multifile_testable_helper.swiftmodule
+// RUN: %target-codesign %t/%target-library-name(vtables_multifile_testable_helper)
+
+// RUN: %target-build-swift %s -L %t -I %t -lvtables_multifile_testable_helper -o %t/main %target-rpath(%t)
+// RUN: %target-codesign %t/main
+
+// RUN: %target-run %t/main %t/%target-library-name(vtables_multifile_testable_helper)
+
+// 4) -enable-testing ON / -enable-library-evolution ON
+
+// ... first without rebuilding the client:
+
+// RUN: %target-build-swift-dylib(%t/%target-library-name(vtables_multifile_testable_helper)) %S/Inputs/vtables_multifile_testable_helper.swift -enable-testing -enable-library-evolution -emit-module -emit-module-path %t/vtables_multifile_testable_helper.swiftmodule
+// RUN: %target-codesign %t/%target-library-name(vtables_multifile_testable_helper)
+
+// RUN: %target-run %t/main %t/%target-library-name(vtables_multifile_testable_helper)
+
+// ... now try to rebuild the client:
+
+// RUN: %target-build-swift %s -L %t -I %t -lvtables_multifile_testable_helper -o %t/main %target-rpath(%t)
+// RUN: %target-codesign %t/main
+
+// RUN: %target-run %t/main %t/%target-library-name(vtables_multifile_testable_helper)
+
+////
+
+// Delete build artifacts
+// RUN: %empty-directory(%t)
+
+// 5) -enable-testing OFF / -enable-library-evolution ON / textual interfaces
+
+// RUN: %target-build-swift-dylib(%t/%target-library-name(vtables_multifile_testable_helper)) %S/Inputs/vtables_multifile_testable_helper.swift -enable-library-evolution -emit-module-interface -emit-module-interface-path %t/vtables_multifile_testable_helper.swiftinterface
+// RUN: %target-codesign %t/%target-library-name(vtables_multifile_testable_helper)
+
+// RUN: %target-build-swift %s -L %t -I %t -lvtables_multifile_testable_helper -o %t/main %target-rpath(%t)
+// RUN: %target-codesign %t/main
+
+// RUN: %target-run %t/main %t/%target-library-name(vtables_multifile_testable_helper)
+
+// 6) -enable-testing ON / -enable-library-evolution ON / textual interfaces
+
+// ... first without rebuilding the client:
+
+// RUN: %target-build-swift-dylib(%t/%target-library-name(vtables_multifile_testable_helper)) %S/Inputs/vtables_multifile_testable_helper.swift -enable-testing -enable-library-evolution -emit-module-interface -emit-module-interface-path %t/vtables_multifile_testable_helper.swiftinterface
+// RUN: %target-codesign %t/%target-library-name(vtables_multifile_testable_helper)
+
+// RUN: %target-run %t/main %t/%target-library-name(vtables_multifile_testable_helper)
+
+// ... now try to rebuild the client:
+
+// RUN: %target-build-swift %s -L %t -I %t -lvtables_multifile_testable_helper -o %t/main %target-rpath(%t)
+// RUN: %target-codesign %t/main
+
+// RUN: %target-run %t/main %t/%target-library-name(vtables_multifile_testable_helper)
+
+
+// REQUIRES: executable_test
+
+import StdlibUnittest
+import vtables_multifile_testable_helper
+
+var VTableTestSuite = TestSuite("VTable")
+
+public class Derived : Middle {
+  public override func method() -> Int {
+    return super.method() + 1
+  }
+}
+
+VTableTestSuite.test("Derived") {
+  expectEqual(3, callBaseMethod(Derived()))
+  expectEqual(3, callMiddleMethod(Derived()))
+}
+
+runAllTests()