Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -138,9 +138,8 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ modu
       case let initExRef as InitExistentialRefInst:
         if context.options.enableEmbeddedSwift {
           for c in initExRef.conformances where c.isConcrete {
-            specializeWitnessTable(for: c, moduleContext) {
-              worklist.addWitnessMethods(of: $0)
-            }
+            specializeWitnessTable(for: c, moduleContext)
+            worklist.addWitnessMethods(of: c, moduleContext)
           }
         }
 
@@ -149,9 +148,9 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ modu
         case .BuildOrdinaryTaskExecutorRef,
              .BuildOrdinarySerialExecutorRef,
              .BuildComplexEqualitySerialExecutorRef:
-          specializeWitnessTable(for: bi.substitutionMap.conformances[0], moduleContext) {
-            worklist.addWitnessMethods(of: $0)
-          }
+          let conformance = bi.substitutionMap.conformances[0]
+          specializeWitnessTable(for: conformance, moduleContext)
+          worklist.addWitnessMethods(of: conformance, moduleContext)
 
         default:
           break
@@ -515,15 +514,44 @@ extension FunctionWorklist {
     }
   }
 
-  mutating func addWitnessMethods(of witnessTable: WitnessTable) {
+  mutating func addWitnessMethods(of conformance: Conformance, _ context: ModulePassContext) {
+    var visited = Set<Conformance>()
+    addWitnessMethodsRecursively(of: conformance, visited: &visited, context)
+  }
+
+  private mutating func addWitnessMethodsRecursively(of conformance: Conformance,
+                                                     visited: inout Set<Conformance>,
+                                                     _ context: ModulePassContext)
+  {
+    guard conformance.isConcrete,
+          visited.insert(conformance).inserted
+    else {
+      return
+    }
+    let witnessTable: WitnessTable
+    if let wt = context.lookupWitnessTable(for: conformance) {
+      witnessTable = wt
+    } else if let wt = context.lookupWitnessTable(for: conformance.rootConformance) {
+      witnessTable = wt
+    } else {
+      return
+    }
     for entry in witnessTable.entries {
-      if case .method(_, let witness) = entry,
-         let method = witness,
-         // A new witness table can still contain a generic function if the method couldn't be specialized for
-         // some reason and an error has been printed. Exclude generic functions to not run into an assert later.
-         !method.isGeneric
-      {
-        pushIfNotVisited(method)
+      switch entry {
+      case .invalid, .associatedType:
+        break
+      case .method(_, let witness):
+        if let method = witness,
+           // A new witness table can still contain a generic function if the method couldn't be specialized for
+           // some reason and an error has been printed. Exclude generic functions to not run into an assert later.
+           !method.isGeneric
+        {
+          pushIfNotVisited(method)
+        }
+      case .baseProtocol(_, let baseConf):
+        addWitnessMethodsRecursively(of: baseConf, visited: &visited, context)
+      case .associatedConformance(_, let assocConf):
+        addWitnessMethodsRecursively(of: assocConf, visited: &visited, context)
       }
     }
   }

SwiftCompilerSources/Sources/Optimizer/Utilities/GenericSpecialization.swift

@@ -106,10 +106,7 @@ private struct VTableSpecializer {
 }
 
 /// Specializes a witness table of `conformance` for the concrete type of the conformance.
-func specializeWitnessTable(for conformance: Conformance,
-                            _ context: ModulePassContext,
-                            _ notifyNewWitnessTable: (WitnessTable) -> ())
-{
+func specializeWitnessTable(for conformance: Conformance, _ context: ModulePassContext) {
   if let existingSpecialization = context.lookupWitnessTable(for: conformance),
          existingSpecialization.isSpecialized
   {
@@ -125,7 +122,7 @@ func specializeWitnessTable(for conformance: Conformance,
   let baseConf = conformance.isInherited ? conformance.inheritedConformance: conformance
   if !baseConf.isSpecialized {
     var visited = Set<Conformance>()
-    specializeDefaultMethods(for: conformance, visited: &visited, context, notifyNewWitnessTable)
+    specializeDefaultMethods(for: conformance, visited: &visited, context)
     return
   }
 
@@ -158,7 +155,7 @@ func specializeWitnessTable(for conformance: Conformance,
       let baseConf = context.getSpecializedConformance(of: witness,
                                                        for: conformance.type,
                                                        substitutions: conformance.specializedSubstitutions)
-      specializeWitnessTable(for: baseConf, context, notifyNewWitnessTable)
+      specializeWitnessTable(for: baseConf, context)
       return .baseProtocol(requirement: requirement, witness: baseConf)
     case .associatedType(let requirement, let witness):
       let substType = witness.subst(with: conformance.specializedSubstitutions)
@@ -169,15 +166,14 @@ func specializeWitnessTable(for conformance: Conformance,
       let concreteAssociateConf = conformance.getAssociatedConformance(ofAssociatedType: requirement.rawType,
                                                                        to: assocConf.protocol)
       if concreteAssociateConf.isSpecialized {
-        specializeWitnessTable(for: concreteAssociateConf, context, notifyNewWitnessTable)
+        specializeWitnessTable(for: concreteAssociateConf, context)
       }
       return .associatedConformance(requirement: requirement,
                                     witness: concreteAssociateConf)
     }
   }
-  let newWT = context.createSpecializedWitnessTable(entries: newEntries,conformance: conformance,
-                                                    linkage: .shared, serialized: false)
-  notifyNewWitnessTable(newWT)
+  context.createSpecializedWitnessTable(entries: newEntries,conformance: conformance,
+                                        linkage: .shared, serialized: false)
 }
 
 /// Specializes the default methods of a non-generic witness table.
@@ -186,8 +182,7 @@ func specializeWitnessTable(for conformance: Conformance,
 /// specialize inherited conformances so that the concrete self type is correct, even for derived classes.
 private func specializeDefaultMethods(for conformance: Conformance,
                                       visited: inout Set<Conformance>,
-                                      _ context: ModulePassContext,
-                                      _ notifyNewWitnessTable: (WitnessTable) -> ())
+                                      _ context: ModulePassContext)
 {
   // Avoid infinite recursion, which may happen if an associated conformance is the conformance itself.
   guard visited.insert(conformance).inserted,
@@ -224,21 +219,20 @@ private func specializeDefaultMethods(for conformance: Conformance,
       specialized = true
       return .method(requirement: requirement, witness: specializedMethod)
     case .baseProtocol(_, let witness):
-      specializeDefaultMethods(for: witness, visited: &visited, context, notifyNewWitnessTable)
+      specializeDefaultMethods(for: witness, visited: &visited, context)
       return origEntry
     case .associatedType:
       return origEntry
     case .associatedConformance(_, let assocConf):
-      specializeDefaultMethods(for: assocConf, visited: &visited, context, notifyNewWitnessTable)
+      specializeDefaultMethods(for: assocConf, visited: &visited, context)
       return origEntry
     }
   }
   // If the witness table does not contain any default methods, there is no need to create a
   // specialized witness table.
   if specialized {
-    let newWT = context.createSpecializedWitnessTable(entries: newEntries,conformance: conformance,
-                                                      linkage: .shared, serialized: false)
-    notifyNewWitnessTable(newWT)
+    context.createSpecializedWitnessTable(entries: newEntries,conformance: conformance,
+                                          linkage: .shared, serialized: false)
   }
 }
 

lib/Sema/MiscDiagnostics.cpp

@@ -6471,7 +6471,7 @@ void swift::performStmtDiagnostics(const Stmt *S, DeclContext *DC) {
 
 void swift::fixItAccess(InFlightDiagnostic &diag, ValueDecl *VD,
                         AccessLevel desiredAccess, bool isForSetter,
-                        bool shouldUseDefaultAccess) {
+                        bool shouldUseDefaultAccess, bool updateAttr) {
   StringRef fixItString;
   switch (desiredAccess) {
   case AccessLevel::Private:      fixItString = "private ";      break;
@@ -6486,27 +6486,35 @@ void swift::fixItAccess(InFlightDiagnostic &diag, ValueDecl *VD,
   AbstractAccessControlAttr *attr;
   if (isForSetter) {
     attr = attrs.getAttribute<SetterAccessAttr>();
-    cast<AbstractStorageDecl>(VD)->overwriteSetterAccess(desiredAccess);
+    if (updateAttr)
+      cast<AbstractStorageDecl>(VD)->overwriteSetterAccess(desiredAccess);
   } else {
     attr = attrs.getAttribute<AccessControlAttr>();
-    VD->overwriteAccess(desiredAccess);
+    if (updateAttr)
+      VD->overwriteAccess(desiredAccess);
 
     if (auto *ASD = dyn_cast<AbstractStorageDecl>(VD)) {
-      if (auto *getter = ASD->getAccessor(AccessorKind::Get))
-        getter->overwriteAccess(desiredAccess);
+      if (auto *getter = ASD->getAccessor(AccessorKind::Get)) {
+        if (updateAttr)
+          getter->overwriteAccess(desiredAccess);
+      }
 
       if (auto *setterAttr = attrs.getAttribute<SetterAccessAttr>()) {
         if (setterAttr->getAccess() > desiredAccess)
-          fixItAccess(diag, VD, desiredAccess, true);
+          fixItAccess(diag, VD, desiredAccess, /*isForSetter=*/true,
+                      /*shouldUseDefaultAccess=*/false, updateAttr);
       } else {
-        ASD->overwriteSetterAccess(desiredAccess);
+        if (updateAttr)
+          ASD->overwriteSetterAccess(desiredAccess);
       }
     }
   }
 
   if (isForSetter && VD->getFormalAccess() == desiredAccess) {
     assert(attr);
-    attr->setInvalid();
+    if (updateAttr)
+      attr->setInvalid();
+
     // Remove the setter attribute.
     diag.fixItRemove(attr->Range);
 
@@ -6526,7 +6534,8 @@ void swift::fixItAccess(InFlightDiagnostic &diag, ValueDecl *VD,
         // replace the "(set)" part of a setter attribute.
         diag.fixItReplace(attr->getLocation(), fixItString.drop_back());
       }
-      attr->setInvalid();
+      if (updateAttr)
+        attr->setInvalid();
     }
 
   } else if (auto *override = VD->getAttrs().getAttribute<OverrideAttr>()) {

lib/Sema/MiscDiagnostics.h

@@ -53,10 +53,10 @@ namespace swift {
 
   /// Emit a fix-it to set the access of \p VD to \p desiredAccess.
   ///
-  /// This actually updates \p VD as well.
+  /// This actually updates \p VD as well if \p updateAttr is true.
   void fixItAccess(InFlightDiagnostic &diag, ValueDecl *VD,
                    AccessLevel desiredAccess, bool isForSetter = false,
-                   bool shouldUseDefaultAccess = false);
+                   bool shouldUseDefaultAccess = false, bool updateAttr = true);
 
   /// Compute the location of the 'var' keyword for a 'var'-to-'let' Fix-It.
   SourceLoc getFixItLocForVarToLet(VarDecl *var);

lib/Sema/TypeCheckAttr.cpp

@@ -2171,7 +2171,9 @@ visitDynamicMemberLookupAttr(DynamicMemberLookupAttr *attr) {
                             diag::dynamic_member_lookup_candidate_inaccessible,
                             inaccessibleCandidate);
       fixItAccess(diag, inaccessibleCandidate,
-                  requiredAccessScope.requiredAccessForDiagnostics());
+                  requiredAccessScope.requiredAccessForDiagnostics(),
+                  /*isForSetter=*/false, /*useDefaultAccess=*/false,
+                  /*updateAttr=*/false);
       diag.warnUntilSwiftVersionIf(!shouldError, futureVersion);
 
       if (shouldError) {

lib/Sema/TypeCheckDeclOverride.cpp

@@ -2191,17 +2191,23 @@ static bool checkSingleOverride(ValueDecl *override, ValueDecl *base) {
     auto domain = unavailableAttr.getDomain();
     auto parsedAttr = unavailableAttr.getParsedAttr();
 
-    if (domain.isPlatform() || domain.isUniversal()) {
+    switch (domain.getKind()) {
+    case AvailabilityDomain::Kind::Universal:
+    case AvailabilityDomain::Kind::SwiftLanguage:
+    case AvailabilityDomain::Kind::PackageDescription:
+    case AvailabilityDomain::Kind::Platform:
       // FIXME: [availability] Diagnose as an error in a future Swift version.
       break;
+    case AvailabilityDomain::Kind::Embedded:
+    case AvailabilityDomain::Kind::Custom:
+      if (parsedAttr->getLocation().isValid())
+        ctx.Diags.diagnose(override, diag::override_unavailable, override)
+            .fixItRemove(parsedAttr->getRangeWithAt());
+      else
+        ctx.Diags.diagnose(override, diag::override_unavailable, override);
+      ctx.Diags.diagnose(base, diag::overridden_here);
+      break;
     }
-
-    if (parsedAttr->getLocation().isValid())
-      ctx.Diags.diagnose(override, diag::override_unavailable, override)
-          .fixItRemove(parsedAttr->getRangeWithAt());
-    else
-      ctx.Diags.diagnose(override, diag::override_unavailable, override);
-    ctx.Diags.diagnose(base, diag::overridden_here);
     break;
   }
   case OverrideAvailability::OverrideLessAvailable: {

stdlib/CMakeLists.txt

@@ -11,8 +11,13 @@ project(swift-stdlib LANGUAGES C CXX)
 # being built on Windows.  Since we know that we only support `clang-cl` as the
 # compiler for the runtime due to the use of the Swift calling convention, we
 # simply override the CMake behaviour unconditionally.
-set(CMAKE_INCLUDE_SYSTEM_FLAG_C "-Isystem")
-set(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-Isystem")
+if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+  set(CMAKE_INCLUDE_SYSTEM_FLAG_C "-imsvc ")
+  set(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-imsvc ")
+else()
+  set(CMAKE_INCLUDE_SYSTEM_FLAG_C "-Isystem")
+  set(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-Isystem")
+endif()
 
 # Add path for custom CMake modules.
 list(APPEND CMAKE_MODULE_PATH

test/Availability/availability_unavailable_overrides.swift

@@ -239,7 +239,6 @@ func testOverrideOfUnavailableDeclFromUnavailableDerivedType() {
   }
 }
 
-
 func testImplicitSuperInit() {
   // FIXME: The diagnostics for the implicit call to super.init() could be
   // relaxed since both initializers are unreachable and the developer cannot
@@ -256,3 +255,19 @@ func testImplicitSuperInit() {
     // expected-note@-2 {{call to unavailable initializer 'init()' from superclass 'Base' occurs implicitly at the end of this initializer}}
   }
 }
+
+func testUnavailableInSwiftOverrides() {
+  class Base {
+    func availableMethod() {}
+  }
+
+  class Derived1: Base {
+    @available(swift, introduced: 99)
+    override func availableMethod() {}
+  }
+
+  class Derived2: Base {
+    @available(swift, obsoleted: 1)
+    override func availableMethod() {}
+  }
+}

test/ClangImporter/objc_override.swift

@@ -83,6 +83,20 @@ class SomeCellSub5 : SomeCell {
   func otherIsEnabled() { } // should not conflict
 }
 
+class SomeCellSub6 : SomeCell {
+  @available(*, unavailable)
+  @objc override init(string: String) {
+    super.init(string: string)
+  }
+}
+
+class SomeCellSub7 : SomeCell {
+  @available(swift, obsoleted: 4)
+  @objc override init(string: String) {
+    super.init(string: string)
+  }
+}
+
 class FailSub : FailBase {
   override init(value: Int) { try! super.init(value: value) } // expected-error {{overriding a throwing '@objc' initializer with a non-throwing initializer is not supported}}
   override class func processValue() {} // expected-error {{overriding a throwing '@objc' method with a non-throwing method is not supported}}

test/attr/attr_dynamic_member_lookup.swift

@@ -253,9 +253,8 @@ public struct Inaccessible1 {
 
 @dynamicMemberLookup
 public struct Inaccessible2 {
-  // expected-non-resilient-warning @+3 {{'@dynamicMemberLookup' requires 'subscript(dynamicMember:)' to be as accessible as its enclosing type; this will be an error in a future Swift language mode}}{{21-29=public}}
-  // expected-resilient-error @+2 {{'@dynamicMemberLookup' requires 'subscript(dynamicMember:)' to be as accessible as its enclosing type}}{{21-29=public}}
-  // expected-error @+1 {{'@usableFromInline' attribute can only be applied to internal or package declarations, but subscript 'subscript(dynamicMember:)' is public}}
+  // expected-non-resilient-warning @+2 {{'@dynamicMemberLookup' requires 'subscript(dynamicMember:)' to be as accessible as its enclosing type; this will be an error in a future Swift language mode}}{{21-29=public}}
+  // expected-resilient-error @+1 {{'@dynamicMemberLookup' requires 'subscript(dynamicMember:)' to be as accessible as its enclosing type}}{{21-29=public}}
   @usableFromInline internal subscript(dynamicMember member: String) -> Int {
     return 42
   }
@@ -279,6 +278,18 @@ private struct Inaccessible4 {
   }
 }
 
+@dynamicMemberLookup
+public struct Inaccessible5 {
+  internal struct Nested { }
+  var nested: Nested
+
+  // expected-non-resilient-warning @+2 {{'@dynamicMemberLookup' requires 'subscript(dynamicMember:)' to be as accessible as its enclosing type; this will be an error in a future Swift language mode}}{{3-11=public}}
+  // expected-resilient-error @+1 {{'@dynamicMemberLookup' requires 'subscript(dynamicMember:)' to be as accessible as its enclosing type}}{{3-11=public}}
+  internal subscript<Value>(dynamicMember keyPath: KeyPath<Nested, Value>) -> Value {
+    nested[keyPath: keyPath]
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // Existentials
 //===----------------------------------------------------------------------===//