Merge branch 'main' into es-check-exp

Author: elsh

CHANGELOG.md

@@ -1,9 +1,25 @@
 # CHANGELOG
 
-> **Note**\
+> [!NOTE]
 > This is in reverse chronological order, so newer entries are added to the top.
 
 ## Swift 6.0
+* [SE-0352][]:
+  The Swift 6 language mode will open existential values with
+  "self-conforming" types (such as `any Error` or `@objc` protocols)
+  passed to generic functions. For example:
+
+  ```swift
+  func takeError<E: Error>(_ error: E) { }
+
+  func passError(error: any Error) {
+    takeError(error)  // Swift 5 does not open `any Error`, Swift 6 does
+  }
+  ```
+
+  This behavior can be enabled prior to the Swift 6 language mode
+  using the upcoming language feature `ImplicitOpenExistentials`.
+
 * [SE-0422][]:
   Non-built-in expression macros can now be used as default arguments that
   expand at each call site. For example, a custom `#CurrentFile` macro used as
@@ -285,6 +301,8 @@ concurrency checking.
 
 ## Swift 5.9.2
 
+### 2023-12-11 (Xcode 15.1)
+
 * [SE-0407][]:
 
   Member macros can specify a list of protocols via the `conformances` argument to the macro role. The macro implementation will be provided with those protocols that are listed but have not already been implemented by the type to which the member macro is attached, in the same manner as extension macros.
@@ -10133,6 +10151,7 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
 [SE-0417]: https://github.com/apple/swift-evolution/blob/main/proposals/0417-task-executor-preference.md
 [SE-0412]: https://github.com/apple/swift-evolution/blob/main/proposals/0412-strict-concurrency-for-global-variables.md
 [SE-0413]: https://github.com/apple/swift-evolution/blob/main/proposals/0413-typed-throws.md
+[SE-0422]: https://github.com/apple/swift-evolution/blob/main/proposals/0422-caller-side-default-argument-macro-expression.md
 [#64927]: <https://github.com/apple/swift/issues/64927>
 [#42697]: <https://github.com/apple/swift/issues/42697>
 [#42728]: <https://github.com/apple/swift/issues/42728>

docs/LSANFailureSymbolication.md

@@ -4,9 +4,9 @@
 
 1. Clone (or pull) swift-docker: https://github.com/apple/swift-docker
 2. Build the Ubuntu 18.04 container: `cd swift-ci/master/ubuntu/18.04; docker build .`
-3. `docker run -it —cpus <CPUs> —memory <Memory> -v ~/<path to your local sources>:/src-on-host:cached —name lsan-reproducer —cap-add=SYS_PTRACE —security-opt seccomp=unconfined <hash that docker build outputs> bash`
+3. `docker run -it --cpus <CPUs> --memory <Memory> -v ~/<path to your local sources>:/src-on-host:cached --name lsan-reproducer --cap-add=SYS_PTRACE --security-opt seccomp=unconfined <hash that docker build outputs> bash`
     - The `-cap-add` and `-security-opt` arguments are needed to run LLDB inside the Docker container
-4. Copy the sources to inside the Docker container: `cp /src-on-host/* ~`
+4. Copy the sources to inside the Docker container: `cp -r /src-on-host/* ~`
     - We need to to this because the build needs a case-sensitive file system and your host machine probably has a case-insensitive file system
 
 Build inside the Container
@@ -36,36 +36,25 @@ Direct leak of 120 byte(s) in 3 object(s) allocated from:
 SUMMARY: LeakSanitizer: 120 byte(s) leaked in 3 allocation(s).
 ```
 2. `lldb -- <your swiftc invocation above>`
-3. Set a breakpoint somewhere in swiftc, eg. at the start of main: `br s -f driver.cpp -l 19`. This should output something like
-
-```
-Breakpoint 1: where = swiftc`main + 4 at driver.cpp:20:10, address = 0x00000000014d25d4
-```
-
-4. Run swiftc to the breakpoint
-5. This should stop you with something like
-
+3. Start running swiftc inside lldb by executing `r`
+4. Find the loaded offset of swift-frontend by running `image list`
+For example, this might output
 ```
-* thread #1, name = 'swiftc', stop reason = breakpoint 1.1
- frame #0: 0x0000555556a265d4 swiftc`main(argc_=168, argv_=0x00007fffffffced8) at driver.cpp:20:10
-  17  #include "swift/DriverTool/DriverTool.h"
-  18   
-  19  int main(int argc_, const char **argv_) {
-→ 20   return swift::mainEntry(argc_, argv_);
-21  }
+[  0] 0AEA10C1 0x0000555555554000 /home/build-user/build/buildbot_incremental_lsan/swift-linux-x86_64/bin/swift-frontend 
+[  1] D52BB67A-BBBB-E429-6E87-FC16144CA7CE-55276DD6 0x00007ffff7ffb000 [vdso] (0x00007ffff7ffb000)
+[  2] 9EA8014C-F020-21A2-9E57-AA3E0512E9BB-6E30541D 0x00007ffff7dd3000 /lib/x86_64-linux-gnu/ld-2.27.so
 ```
-
-6. Find the loaded offset of swift-frontend by subtracting the breakpoint address from the frame address. With the example above, that’s `0x0000555556a265d4 - 0x00000000014d25d4 = 0x555555554000`.
-7. For the frame that you want to symbolicate,, add the offset you computed above to the stack frame in the LSAN report, eg. to symbolicate frame 1 `0x555555554000 + 0x292d81c = 0x555557E8181C`
-8. Look up the address using `image lookup -a <address you computed>`. This should output something like
+The loaded offset is `0x0000555555554000`
+5. For the frame that you want to symbolicate,, add the offset you computed above to the stack frame in the LSAN report, eg. to symbolicate frame 1 `0x555555554000 + 0x292d81c = 0x555557E8181C`
+6. Look up the address using `image lookup -a <address you computed>`. This should output something like
 
 ```
 (lldb) image lookup -a 0x555557E8181C
       Address: swiftc[0x000000000292d81c] (swiftc.PT_LOAD[0]..text + 22056284)
       Summary: swiftc`registerFunctionTest(BridgedStringRef, void*) + 28 at SILBridging.cpp:148:3
 ```
 
-9. Hoorray, you know which function is leaking.
+7. Hoorray, you know which function is leaking.
 
 ### Making Local Changes Inside the Container
 

include/swift/AST/ASTBridging.h

@@ -481,6 +481,14 @@ BridgedAlignmentAttr_createParsed(BridgedASTContext cContext,
                                   BridgedSourceLoc cAtLoc,
                                   BridgedSourceRange cRange, size_t cValue);
 
+SWIFT_NAME("BridgedAllowFeatureSuppressionAttr.createParsed(_:atLoc:range:features:)")
+BridgedAllowFeatureSuppressionAttr
+BridgedAllowFeatureSuppressionAttr_createParsed(
+                                  BridgedASTContext cContext,
+                                  BridgedSourceLoc cAtLoc,
+                                  BridgedSourceRange cRange,
+                                  BridgedArrayRef cFeatures);
+
 SWIFT_NAME("BridgedCDeclAttr.createParsed(_:atLoc:range:name:)")
 BridgedCDeclAttr BridgedCDeclAttr_createParsed(BridgedASTContext cContext,
                                                BridgedSourceLoc cAtLoc,

include/swift/AST/Attr.h

@@ -191,6 +191,11 @@ class DeclAttribute : public AttributeBase {
     SWIFT_INLINE_BITFIELD(NonisolatedAttr, DeclAttribute, 1,
       isUnsafe : 1
     );
+
+    SWIFT_INLINE_BITFIELD_FULL(AllowFeatureSuppressionAttr, DeclAttribute, 32,
+      : NumPadBits,
+      NumFeatures : 32
+    );
   } Bits;
   // clang-format on
 
@@ -2636,6 +2641,32 @@ template <typename ATTR, bool AllowInvalid> struct ToAttributeKind {
   }
 };
 
+/// The @_allowFeatureSuppression(Foo, Bar) attribute.  The feature
+/// names are intentionally not validated, and the attribute itself is
+/// not printed when rendering a module interface.
+class AllowFeatureSuppressionAttr final
+    : public DeclAttribute,
+      private llvm::TrailingObjects<AllowFeatureSuppressionAttr, Identifier> {
+  friend TrailingObjects;
+
+  /// Create an implicit @objc attribute with the given (optional) name.
+  AllowFeatureSuppressionAttr(SourceLoc atLoc, SourceRange range,
+                              bool implicit, ArrayRef<Identifier> features);
+public:
+  static AllowFeatureSuppressionAttr *create(ASTContext &ctx, SourceLoc atLoc,
+                                             SourceRange range, bool implicit,
+                                             ArrayRef<Identifier> features);
+
+  ArrayRef<Identifier> getSuppressedFeatures() const {
+    return {getTrailingObjects<Identifier>(),
+            Bits.AllowFeatureSuppressionAttr.NumFeatures};
+  }
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DeclAttrKind::AllowFeatureSuppression;
+  }
+};
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.

include/swift/AST/DeclAttr.def

@@ -488,7 +488,10 @@ SIMPLE_DECL_ATTR(_noObjCBridging, NoObjCBridging,
 DECL_ATTR(_distributedThunkTarget, DistributedThunkTarget,
   OnAbstractFunction | UserInaccessible | ABIStableToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,
   156)
-LAST_DECL_ATTR(DistributedThunkTarget)
+DECL_ATTR(_allowFeatureSuppression, AllowFeatureSuppression,
+  OnAnyDecl | UserInaccessible | NotSerialized | ABIStableToAdd | APIStableToAdd | ABIStableToRemove | APIStableToRemove,
+  157)
+LAST_DECL_ATTR(AllowFeatureSuppression)
 
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/DiagnosticEngine.h

@@ -88,6 +88,10 @@ namespace swift {
     };
   }
 
+  template <class... ArgTypes>
+  using DiagArgTuple =
+    std::tuple<typename detail::PassArgument<ArgTypes>::type...>;
+
   /// A family of wrapper types for compiler data types that forces its
   /// underlying data to be formatted with full qualification.
   ///
@@ -476,20 +480,28 @@ namespace swift {
     friend DiagnosticEngine;
     friend class InFlightDiagnostic;
 
+    Diagnostic(DiagID ID) : ID(ID) {}
+
   public:
     // All constructors are intentionally implicit.
     template<typename ...ArgTypes>
     Diagnostic(Diag<ArgTypes...> ID,
                typename detail::PassArgument<ArgTypes>::type... VArgs)
-      : ID(ID.ID) {
-      DiagnosticArgument DiagArgs[] = {
-        DiagnosticArgument(0), std::move(VArgs)... 
-      };
-      Args.append(DiagArgs + 1, DiagArgs + 1 + sizeof...(VArgs));
+        : Diagnostic(ID.ID) {
+      Args.reserve(sizeof...(ArgTypes));
+      gatherArgs(VArgs...);
     }
 
     /*implicit*/Diagnostic(DiagID ID, ArrayRef<DiagnosticArgument> Args)
       : ID(ID), Args(Args.begin(), Args.end()) {}
+
+    template <class... ArgTypes>
+    static Diagnostic fromTuple(Diag<ArgTypes...> id,
+                                const DiagArgTuple<ArgTypes...> &tuple) {
+      Diagnostic result(id.ID);
+      result.gatherArgsFromTuple<DiagArgTuple<ArgTypes...>, 0, ArgTypes...>(tuple);
+      return result;
+    }
 
     // Accessors.
     DiagID getID() const { return ID; }
@@ -528,6 +540,37 @@ namespace swift {
 
     void addChildNote(Diagnostic &&D);
     void insertChildNote(unsigned beforeIndex, Diagnostic &&D);
+
+  private:
+    // gatherArgs could just be `Args.emplace_back(args)...;` if C++
+    // allowed pack expansions in statement context.
+
+    // Base case.
+    void gatherArgs() {}
+
+    // Pull one off the pack.
+    template <class ArgType, class... RemainingArgTypes>
+    void gatherArgs(ArgType arg, RemainingArgTypes... remainingArgs) {
+      Args.emplace_back(arg);
+      gatherArgs(remainingArgs...);
+    }
+
+    // gatherArgsFromTuple could just be
+    // `Args.emplace_back(std::get<packIndexOf<ArgTypes>>(tuple))...;`
+    // in a better world.
+
+    // Base case.
+    template <class Tuple, size_t Index>
+    void gatherArgsFromTuple(const Tuple &tuple) {}
+
+    // Pull one off the pack.
+    template <class Tuple, size_t Index,
+              class ArgType, class... RemainingArgTypes>
+    void gatherArgsFromTuple(const Tuple &tuple) {
+      Args.emplace_back(std::move(std::get<Index>(tuple)));
+      gatherArgsFromTuple<Tuple, Index + 1, RemainingArgTypes...>(
+        std::move(tuple));
+    }
   };
 
   /// A diagnostic that has no input arguments, so it is trivially-destructable.
@@ -866,6 +909,73 @@ namespace swift {
     DiagnosticState &operator=(DiagnosticState &&) = default;
   };
 
+  /// A lightweight reference to a diagnostic that's been fully applied to
+  /// its arguments.  This allows a general routine (in the parser, say) to
+  /// be customized to emit an arbitrary diagnostic without needing to
+  /// eagerly construct a full Diagnostic.  Like ArrayRef and function_ref,
+  /// this stores a reference to what's likely to be a temporary, so it
+  /// should only be used as a function parameter.  If you need to persist
+  /// the diagnostic, you'll have to call createDiagnostic().
+  ///
+  /// You can initialize a DiagRef parameter in one of two ways:
+  /// - passing a Diag<> as the argument, e.g.
+  ///      diag::circular_reference
+  ///   or
+  /// - constructing it with a Diag and its arguments, e.g.
+  ///      {diag::circular_protocol_def, {proto->getName()}}
+  ///
+  /// It'd be nice to let people write `{diag::my_error, arg0, arg1}`
+  /// instead of `{diag::my_error, {arg0, arg1}}`, but we can't: the
+  /// temporary needs to be created in the calling context.
+  class DiagRef {
+    DiagID id;
+
+    /// If this is null, then id is a Diag<> and there are no arguments.
+    Diagnostic (*createFn)(DiagID id, const void *opaqueStorage);
+    const void *opaqueStorage;
+
+  public:
+    /// Construct a diagnostic from a diagnostic ID that's known to not take
+    /// arguments.
+    DiagRef(Diag<> id)
+      : id(id.ID), createFn(nullptr), opaqueStorage(nullptr) {}
+
+    /// Construct a diagnostic from a diagnostic ID and its arguments.
+    template <class... ArgTypes>
+    DiagRef(Diag<ArgTypes...> id, const DiagArgTuple<ArgTypes...> &tuple)
+      : id(id.ID),
+        createFn(&createFromTuple<ArgTypes...>),
+        opaqueStorage(&tuple) {}
+
+    // A specialization of the general constructor above for diagnostics
+    // with no arguments; this is a useful optimization when a DiagRef
+    // is constructed generically.
+    DiagRef(Diag<> id, const DiagArgTuple<> &tuple)
+      : DiagRef(id) {}
+
+    /// Return the diagnostic ID that this will emit.
+    DiagID getID() const {
+      return id;
+    }
+
+    /// Create a full Diagnostic.  It's safe to do this multiple times on
+    /// a single DiagRef.
+    Diagnostic createDiagnostic() {
+      if (!createFn) {
+        return Diagnostic(Diag<> {id});
+      } else {
+        return createFn(id, opaqueStorage);
+      }
+    }
+
+  private:
+    template <class... ArgTypes>
+    static Diagnostic createFromTuple(DiagID id, const void *opaqueStorage) {
+      auto tuple = static_cast<const DiagArgTuple<ArgTypes...> *>(opaqueStorage);
+      return Diagnostic::fromTuple(Diag<ArgTypes...> {id}, *tuple);
+    }
+  };
+
   /// Class responsible for formatting diagnostics and presenting them
   /// to the user.
   class DiagnosticEngine {
@@ -1113,6 +1223,12 @@ namespace swift {
       return diagnose(Loc, Diagnostic(ID, std::move(Args)...));
     }
 
+    /// Emit the given lazily-applied diagnostic at the specified
+    /// source location.
+    InFlightDiagnostic diagnose(SourceLoc loc, DiagRef diag) {
+      return diagnose(loc, diag.createDiagnostic());
+    }
+
     /// Delete an API that may lead clients to avoid specifying source location.
     template<typename ...ArgTypes>
     InFlightDiagnostic

include/swift/AST/DiagnosticsCommon.def

@@ -45,7 +45,7 @@ NOTE(brace_stmt_suggest_do,none,
      "did you mean to use a 'do' statement?", ())
 
 WARNING(error_in_future_swift_version,none,
-        "%0; this is an error in Swift %1",
+        "%0; this is an error in the Swift %1 language mode",
         (DiagnosticInfo *, unsigned))
 
 // Generic disambiguation

include/swift/AST/DiagnosticsParse.def

@@ -1889,6 +1889,10 @@ ERROR(attr_rawlayout_expected_params,none,
 
 ERROR(attr_extern_expected_label,none,
       "expected %0 argument to @_extern attribute", (StringRef))
+
+ERROR(attr_expected_feature_name,none,
+      "expected feature name in @%0 attribute", (StringRef))
+
 //------------------------------------------------------------------------------
 // MARK: Generics parsing diagnostics
 //------------------------------------------------------------------------------

include/swift/AST/DiagnosticsSema.def

@@ -6812,7 +6812,7 @@ WARNING(inlinable_decl_ref_from_hidden_module_warn,
       none, "%kind0 cannot be used in " FRAGILE_FUNC_KIND "1 "
       "because %select{<<ERROR>>|<<ERROR>>|<<ERROR>>|<<ERROR>>|"
       "%2 was not imported by this file}3"
-      "; this is an error in Swift 6",
+      "; this is an error in the Swift 6 language mode",
       (const ValueDecl *, unsigned, Identifier, unsigned))
 
 ERROR(inlinable_typealias_desugars_to_type_from_hidden_module,

include/swift/AST/EducationalNotes.def

@@ -86,5 +86,8 @@ EDUCATIONAL_NOTES(result_builder_missing_build_array,
 
 EDUCATIONAL_NOTES(multiple_inheritance,
                   "multiple-inheritance.md")
-                  
+
+EDUCATIONAL_NOTES(error_in_future_swift_version,
+                  "error-in-future-swift-version.md")
+
 #undef EDUCATIONAL_NOTES