Merge branch 'main' of github.com:apple/swift into main

Author: ktoso

include/swift/ABI/Actor.h

@@ -41,4 +41,4 @@ class alignas(Alignment_DefaultActor) DefaultActor : public HeapObject {
 
 } // end namespace swift
 
-#endif
+#endif

include/swift/AST/ASTSynthesis.h

@@ -353,4 +353,4 @@ Type synthesizeType(SynthesisContext &SC, const OptionalSynthesizer<S> &s) {
 
 } // end namespace swift
 
-#endif
+#endif

include/swift/AST/Decl.h

@@ -871,7 +871,7 @@ class alignas(1 << DeclAlignInBits) Decl {
   }
 
   /// \returns the unparsed comment attached to this declaration.
-  RawComment getRawComment(bool SerializedOK = false) const;
+  RawComment getRawComment(bool SerializedOK = true) const;
 
   Optional<StringRef> getGroupName() const;
 

include/swift/AST/DiagnosticsFrontend.def

@@ -123,6 +123,8 @@ ERROR(error_mode_cannot_emit_interface,none,
       "this mode does not support emitting module interface files", ())
 ERROR(error_mode_cannot_emit_module_summary,none,
       "this mode does not support emitting module summary files", ())
+ERROR(error_mode_cannot_emit_symbol_graph,none,
+      "this mode does not support emitting symbol graph files", ())
 ERROR(cannot_emit_ir_skipping_function_bodies,none,
       "the -experimental-skip-*-function-bodies* flags do not support "
       "emitting IR", ())

include/swift/AST/Effects.h

@@ -74,4 +74,4 @@ void simple_display(llvm::raw_ostream &out, FunctionRethrowingKind value);
 
 } // end namespace swift
 
-#endif
+#endif

include/swift/AST/ForeignAsyncConvention.h

@@ -30,24 +30,35 @@ class ForeignAsyncConvention {
     /// The index of the completion handler parameters.
     unsigned CompletionHandlerParamIndex;
 
-    /// When non-zero, indicates which parameter to the completion handler is
-    /// the Error? parameter (minus one) that makes this async function also
+    /// When non-zero, subtracting one indicates which parameter to the completion handler is
+    /// the Error? parameter that makes this async function also
     /// throwing.
     unsigned CompletionHandlerErrorParamIndexPlusOneOrZero;
 
+    /// When non-zero, indicates that the presence of an error is determined by
+    /// an integral argument to the completion handler being zero or nonzero.
+    unsigned CompletionHandlerFlagParamIndexPlusOneWithPolarityOrZero;
+    
   public:
     Info()
       : CompletionHandlerParamIndex(0),
         CompletionHandlerErrorParamIndexPlusOneOrZero(0) { }
 
     Info(
         unsigned completionHandlerParamIndex,
-        Optional<unsigned> completionHandlerErrorParamIndex)
+        Optional<unsigned> completionHandlerErrorParamIndex,
+        Optional<unsigned> completionHandlerFlagParamIndex,
+        bool completionHandlerFlagIsErrorOnZero)
       : CompletionHandlerParamIndex(completionHandlerParamIndex),
         CompletionHandlerErrorParamIndexPlusOneOrZero(
             completionHandlerErrorParamIndex
               ? *completionHandlerErrorParamIndex + 1
-              : 0) {}
+              : 0),
+        CompletionHandlerFlagParamIndexPlusOneWithPolarityOrZero(
+            completionHandlerFlagParamIndex
+              ? (*completionHandlerFlagParamIndex | ((unsigned)completionHandlerFlagIsErrorOnZero << 31)) + 1
+              : 0)
+        {}
 
     /// Retrieve the index of the completion handler argument in the method's
     /// parameter list.
@@ -56,15 +67,46 @@ class ForeignAsyncConvention {
     }
 
     /// Retrieve the index of the \c Error? parameter in the completion handler's
-    /// parameter list. When argument passed to this parameter is non-null, the
-    /// provided error will be thrown by the async function.
+    /// parameter list.
+    ///
+    /// Typically, when argument passed to this parameter is non-null, the
+    /// provided error will be thrown by the async function. If a
+    /// \c completionHandlerFlagParamIndex is also specified, the
+    /// value of that flag instead indicates whether an error should be raised.
     Optional<unsigned> completionHandlerErrorParamIndex() const {
       if (CompletionHandlerErrorParamIndexPlusOneOrZero == 0)
         return None;
 
       return CompletionHandlerErrorParamIndexPlusOneOrZero - 1;
     }
 
+    /// Retrieve the index of the error flag parameter in the completion handler's
+    /// parameter list, if any.
+    ///
+    /// If present, the boolean value of this argument will indicate whether the
+    /// operation completed with an error. The \c completionHandlerFlagIsErrorOnZero
+    /// value indicates whether this argument being zero indicates an error, or
+    /// whether being nonzero indicates an error.
+    Optional<unsigned> completionHandlerFlagParamIndex() const {
+      if (CompletionHandlerFlagParamIndexPlusOneWithPolarityOrZero == 0)
+        return None;
+
+      return (CompletionHandlerFlagParamIndexPlusOneWithPolarityOrZero - 1)
+        & 0x7FFFFFFFu;
+    }
+    
+    /// Indicates the polarity of the error flag parameter to the completion handler.
+    ///
+    /// It is only valid to call this if \c completionHandlerFlagParamIndex returns
+    /// a non-\c None value; if there is no flag parameter to the completion handler, the value
+    /// of this property is meaningless. Otherwise, if true is returned, then a zero flag value
+    /// indicates an error, and nonzero indicates success. If false, then a zero flag value
+    /// indicates success, and nonzero indicates an error.
+    bool completionHandlerFlagIsErrorOnZero() const {
+      return (CompletionHandlerFlagParamIndexPlusOneWithPolarityOrZero - 1)
+        & 0x80000000u;
+    }
+
     /// Whether the async function is throwing due to the completion handler
     /// having an \c Error? parameter.
     ///
@@ -86,9 +128,13 @@ class ForeignAsyncConvention {
 
   ForeignAsyncConvention(CanType completionHandlerType,
                          unsigned completionHandlerParamIndex,
-                         Optional<unsigned> completionHandlerErrorParamIndex)
+                         Optional<unsigned> completionHandlerErrorParamIndex,
+                         Optional<unsigned> completionHandlerFlagParamIndex,
+                         bool completionHandlerFlagIsErrorOnZero)
       : CompletionHandlerType(completionHandlerType),
-        TheInfo(completionHandlerParamIndex, completionHandlerErrorParamIndex)
+        TheInfo(completionHandlerParamIndex, completionHandlerErrorParamIndex,
+                completionHandlerFlagParamIndex,
+                completionHandlerFlagIsErrorOnZero)
   { }
 
   /// Retrieve the type of the completion handler parameter.
@@ -101,11 +147,36 @@ class ForeignAsyncConvention {
   }
 
   /// Retrieve the index of the \c Error? parameter in the completion handler's
-  /// parameter list. When argument passed to this parameter is non-null, the
-  /// provided error will be thrown by the async function.
+  /// parameter list.
+  ///
+  /// Typically, when argument passed to this parameter is non-null, the
+  /// provided error will be thrown by the async function. If a
+  /// \c completionHandlerFlagParamIndex is also specified, the
+  /// value of that flag instead indicates whether an error should be raised.
   Optional<unsigned> completionHandlerErrorParamIndex() const {
     return TheInfo.completionHandlerErrorParamIndex();
   }
+  
+  /// Retrieve the index of the error flag parameter in the completion handler's
+  /// parameter list, if any.
+  ///
+  /// If present, the boolean value of this argument will indicate whether the
+  /// operation completed with an error. The \c completionHandlerFlagIsErrorOnZero
+  /// value indicates whether this argument being zero indicates an error, or
+  /// whether being nonzero indicates an error.
+  Optional<unsigned> completionHandlerFlagParamIndex() const {
+    return TheInfo.completionHandlerFlagParamIndex();
+  }
+  
+  /// Indicates the polarity of the error flag parameter to the completion handler.
+  ///
+  /// It is only valid to call this if \c completionHandlerFlagParamIndex returns
+  /// a non-\c None value. If true is returned, then a zero flag value indicates an error,
+  /// and nonzero indicates success. If false, then a zero flag value indicates success,
+  /// and nonzero indicates an error.
+  bool completionHandlerFlagIsErrorOnZero() const {
+    return TheInfo.completionHandlerFlagIsErrorOnZero();
+  }
 
   /// Whether the async function is throwing due to the completion handler
   /// having an \c Error? parameter.

include/swift/AST/GenericParamList.h

@@ -393,4 +393,4 @@ class alignas(RequirementRepr) TrailingWhereClause final :
 
 }  // namespace swift
 
-#endif // SWIFT_GENERIC_PARAM_LIST_H
+#endif // SWIFT_GENERIC_PARAM_LIST_H

include/swift/AST/KnownSDKTypes.def

@@ -37,7 +37,6 @@ KNOWN_SDK_TYPE_DECL(ObjectiveC, ObjCBool, StructDecl, 0)
 
 // TODO(async): These might move to the stdlib module when concurrency is
 // standardized
-KNOWN_SDK_TYPE_DECL(Concurrency, UnsafeContinuation, NominalTypeDecl, 1)
-KNOWN_SDK_TYPE_DECL(Concurrency, UnsafeThrowingContinuation, NominalTypeDecl, 1)
+KNOWN_SDK_TYPE_DECL(Concurrency, UnsafeContinuation, NominalTypeDecl, 2)
 
 #undef KNOWN_SDK_TYPE_DECL

include/swift/AST/RequestCache.h

@@ -432,4 +432,4 @@ struct DenseMapInfo<swift::evaluator::RequestKey<Request, Info>> {
 
 } // end namespace llvm
 
-#endif // SWIFT_AST_REQUEST_CACHE_H
+#endif // SWIFT_AST_REQUEST_CACHE_H

include/swift/AST/TypeDifferenceVisitor.h

@@ -382,4 +382,4 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {
 
 }
 
-#endif
+#endif