Merge pull request #2891 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

include/swift/AST/ActorIsolation.h

@@ -40,7 +40,7 @@ class ActorIsolation {
     /// The actor isolation has not been specified. It is assumed to be
     /// unsafe to interact with this declaration from any actor.
     Unspecified = 0,
-    /// The declaration is isolated to the instance of an actor class.
+    /// The declaration is isolated to the instance of an actor.
     /// For example, a mutable stored property or synchronous function within
     /// the actor is isolated to the instance of that actor.
     ActorInstance,

include/swift/AST/DiagnosticEngine.h

@@ -814,15 +814,15 @@ namespace swift {
       if (llvm::sys::fs::exists(filePath)) {
         if (auto file = llvm::MemoryBuffer::getFile(filePath)) {
           localization = std::make_unique<diag::SerializedLocalizationProducer>(
-              std::move(file.get()));
+              std::move(file.get()), getPrintDiagnosticNames());
         }
       } else {
         llvm::sys::path::replace_extension(filePath, ".yaml");
         // In case of missing localization files, we should fallback to messages
         // from `.def` files.
         if (llvm::sys::fs::exists(filePath)) {
-          localization =
-              std::make_unique<diag::YAMLLocalizationProducer>(filePath.str());
+          localization = std::make_unique<diag::YAMLLocalizationProducer>(
+              filePath.str(), getPrintDiagnosticNames());
         }
       }
     }
@@ -1049,7 +1049,7 @@ namespace swift {
 
   public:
     llvm::StringRef diagnosticStringFor(const DiagID id,
-                                        bool printDiagnosticName);
+                                        bool printDiagnosticNames);
 
     /// If there is no clear .dia file for a diagnostic, put it in the one
     /// corresponding to the SourceLoc given here.

include/swift/AST/DiagnosticsSema.def

@@ -4323,7 +4323,7 @@ ERROR(async_objc_dynamic_self,none,
       "asynchronous method returning 'Self' cannot be '@objc'", ())
 
 ERROR(actor_with_nonactor_superclass,none,
-      "actor class cannot inherit from non-actor class %0", (DeclName))
+      "actor cannot inherit from non-actor class %0", (DeclName))
 
 ERROR(actor_isolated_non_self_reference,none,
         "actor-isolated %0 %1 can only be %select{referenced|mutated|used 'inout'}3 "
@@ -4500,7 +4500,7 @@ ERROR(multiple_global_actors,none,
 ERROR(global_actor_disallowed,none,
       "%0 cannot have a global actor", (DescriptiveDeclKind))
 ERROR(global_actor_on_actor_class,none,
-      "actor class %0 cannot have a global actor", (Identifier))
+      "actor %0 cannot have a global actor", (Identifier))
 ERROR(global_actor_on_local_variable,none,
       "local variable %0 cannot have a global actor", (DeclName))
 ERROR(global_actor_non_unsafe_init,none,
@@ -5581,16 +5581,16 @@ ERROR(property_wrapper_param_not_supported,none,
       (DescriptiveDeclKind))
 NOTE(property_wrapper_declared_here,none,
      "property wrapper type %0 declared here", (Identifier))
-ERROR(property_wrapper_param_no_projection,none,
-      "cannot use property wrapper projection parameter; "
-      "wrapper %0 does not have a 'projectedValue'", (Type))
-ERROR(property_wrapper_param_no_wrapper,none,
-      "cannot use property wrapper projection argument; "
-      "parameter does not have an attached property wrapper",
-      ())
-ERROR(property_wrapper_param_projection_invalid,none,
-      "cannot use property wrapper projection argument; "
-      "pass wrapped value type %0 instead", (Type))
+ERROR(invalid_projection_argument,none,
+      "cannot use property wrapper projection %select{argument|parameter}0",
+      (bool))
+NOTE(property_wrapper_param_no_wrapper,none,
+     "parameter %0 does not have an attached property wrapper", (Identifier))
+NOTE(property_wrapper_param_attr_arg,none,
+     "property wrapper has arguments in the wrapper attribute", ())
+NOTE(property_wrapper_no_init_projected_value,none,
+     "property wrapper type %0 does not support initialization from a "
+     "projected value", (Type))
 ERROR(property_wrapper_param_mutating,none,
       "property wrapper applied to parameter must have a nonmutating "
       "'wrappedValue' getter", ())

include/swift/AST/Types.h

@@ -3329,7 +3329,7 @@ END_CAN_TYPE_WRAPPER(FunctionType, AnyFunctionType)
 struct ParameterListInfo {
   SmallBitVector defaultArguments;
   SmallBitVector acceptsUnlabeledTrailingClosures;
-  SmallVector<const ParamDecl *, 4> propertyWrappers;
+  SmallBitVector propertyWrappers;
 
 public:
   ParameterListInfo() { }
@@ -3346,7 +3346,7 @@ struct ParameterListInfo {
 
   /// The ParamDecl at the given index if the parameter has an applied
   /// property wrapper.
-  const ParamDecl *getPropertyWrapperParam(unsigned paramIdx) const;
+  bool hasExternalPropertyWrapper(unsigned paramIdx) const;
 
   /// Retrieve the number of non-defaulted parameters.
   unsigned numNonDefaultedParameters() const {

include/swift/IDE/Utils.h

@@ -164,6 +164,11 @@ struct ResolvedCursorInfo {
   Type ContainerType;
   Stmt *TrailingStmt = nullptr;
   Expr *TrailingExpr = nullptr;
+  /// If this is a call, whether it is "dynamic", see ide::isDynamicCall.
+  bool IsDynamic = false;
+  /// If this is a call, the types of the base (multiple in the case of
+  /// protocol composition).
+  SmallVector<NominalTypeDecl *, 1> ReceiverTypes;
 
   ResolvedCursorInfo() = default;
   ResolvedCursorInfo(SourceFile *SF) : SF(SF) {}
@@ -174,12 +179,9 @@ struct ResolvedCursorInfo {
       lhs.Loc.getOpaquePointerValue() == rhs.Loc.getOpaquePointerValue();
   }
 
-  void setValueRef(ValueDecl *ValueD,
-                   TypeDecl *CtorTyRef,
-                   ExtensionDecl *ExtTyRef,
-                   bool IsRef,
-                   Type Ty,
-                   Type ContainerType) {
+  void setValueRef(ValueDecl *ValueD, TypeDecl *CtorTyRef,
+                   ExtensionDecl *ExtTyRef, bool IsRef,
+                   Type Ty, Type ContainerType) {
     Kind = CursorInfoKind::ValueRef;
     this->ValueD = ValueD;
     this->CtorTyRef = CtorTyRef;
@@ -621,6 +623,23 @@ ClangNode extensionGetClangNode(const ExtensionDecl *ext);
 /// or a curry thunk, etc.
 std::pair<Type, ConcreteDeclRef> getReferencedDecl(Expr *expr);
 
+/// Whether the last expression in \p ExprStack is being called.
+bool isBeingCalled(ArrayRef<Expr*> ExprStack);
+
+/// The base of the last expression in \p ExprStack (which may look up the
+/// stack in eg. the case of a `DotSyntaxCallExpr`).
+Expr *getBase(ArrayRef<Expr *> ExprStack);
+
+/// Assuming that we have a call, returns whether or not it is "dynamic" based
+/// on its base expression and decl of the callee. Note that this is not
+/// Swift's "dynamic" modifier (`ValueDecl::isDynamic`), but rathar "can call a
+/// function in a conformance/subclass".
+bool isDynamicCall(Expr *Base, ValueDecl *D);
+
+/// Adds the resolved nominal types of \p Base to \p Types.
+void getReceiverType(Expr *Base,
+                     SmallVectorImpl<NominalTypeDecl *> &Types);
+
 } // namespace ide
 } // namespace swift
 

include/swift/Localization/LocalizationFormat.h

@@ -26,6 +26,7 @@
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/OnDiskHashTable.h"
+#include "llvm/Support/StringSaver.h"
 #include "llvm/Support/YAMLParser.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
@@ -154,14 +155,23 @@ class SerializedLocalizationWriter {
 };
 
 class LocalizationProducer {
+  /// This allocator will retain localized diagnostic strings containing the
+  /// diagnostic's message and identifier as `message [id]` for the duration of
+  /// compiler invocation. This will be used when the frontend flag
+  /// `-debug-diagnostic-names` is used.
+  llvm::BumpPtrAllocator localizationAllocator;
+  llvm::StringSaver localizationSaver;
+  bool printDiagnosticNames;
+
 public:
+  LocalizationProducer(bool printDiagnosticNames = false)
+      : localizationSaver(localizationAllocator),
+        printDiagnosticNames(printDiagnosticNames) {}
+
   /// If the  message isn't available/localized in current context
   /// return the fallback default message.
   virtual llvm::StringRef getMessageOr(swift::DiagID id,
-                                       llvm::StringRef defaultMessage) const {
-    auto message = getMessage(id);
-    return message.empty() ? defaultMessage : message;
-  }
+                                       llvm::StringRef defaultMessage);
 
   virtual ~LocalizationProducer() {}
 
@@ -177,7 +187,8 @@ class YAMLLocalizationProducer final : public LocalizationProducer {
 public:
   /// The diagnostics IDs that are no longer available in `.def`
   std::vector<std::string> unknownIDs;
-  explicit YAMLLocalizationProducer(llvm::StringRef filePath);
+  explicit YAMLLocalizationProducer(llvm::StringRef filePath,
+                                    bool printDiagnosticNames = false);
 
   /// Iterate over all of the available (non-empty) translations
   /// maintained by this producer, callback gets each translation
@@ -198,7 +209,8 @@ class SerializedLocalizationProducer final : public LocalizationProducer {
 
 public:
   explicit SerializedLocalizationProducer(
-      std::unique_ptr<llvm::MemoryBuffer> buffer);
+      std::unique_ptr<llvm::MemoryBuffer> buffer,
+      bool printDiagnosticNames = false);
 
 protected:
   llvm::StringRef getMessage(swift::DiagID id) const override;

include/swift/Runtime/Concurrency.h

@@ -479,14 +479,25 @@ SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_MainActor_register(HeapObject *actor);
 
 /// A hook to take over global enqueuing.
-/// TODO: figure out a better abstraction plan than this.
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-void (*swift_task_enqueueGlobal_hook)(Job *job);
+typedef SWIFT_CC(swift) void (*swift_task_enqueueGlobal_original)(Job *job);
+SWIFT_EXPORT_FROM(swift_Concurrency)
+SWIFT_CC(swift) void (*swift_task_enqueueGlobal_hook)(
+    Job *job, swift_task_enqueueGlobal_original original);
 
 /// A hook to take over global enqueuing with delay.
-/// TODO: figure out a better abstraction plan than this.
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-void (*swift_task_enqueueGlobalWithDelay_hook)(unsigned long long delay, Job *job);
+typedef SWIFT_CC(swift) void (*swift_task_enqueueGlobalWithDelay_original)(
+    unsigned long long delay, Job *job);
+SWIFT_EXPORT_FROM(swift_Concurrency)
+SWIFT_CC(swift) void (*swift_task_enqueueGlobalWithDelay_hook)(
+    unsigned long long delay, Job *job,
+    swift_task_enqueueGlobalWithDelay_original original);
+
+/// A hook to take over main executor enqueueing.
+typedef SWIFT_CC(swift) void (*swift_task_enqueueMainExecutor_original)(
+    Job *job);
+SWIFT_EXPORT_FROM(swift_Concurrency)
+SWIFT_CC(swift) void (*swift_task_enqueueMainExecutor_hook)(
+    Job *job, swift_task_enqueueMainExecutor_original original);
 
 /// Initialize the runtime storage for a default actor.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
@@ -537,7 +548,7 @@ void swift_continuation_logFailedCheck(const char *message);
 /// If the binary links CoreFoundation, uses CFRunLoopRun
 /// Otherwise it uses dispatchMain.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-void swift_task_asyncMainDrainQueue();
+void swift_task_asyncMainDrainQueue [[noreturn]]();
 
 /// Establish that the current thread is running as the given
 /// executor, then run a job.

include/swift/Sema/CSFix.h

@@ -122,12 +122,12 @@ enum class FixKind : uint8_t {
   /// the storage or property wrapper.
   UseWrappedValue,
 
-  /// Add 'var projectedValue' to the property wrapper type to allow passing
-  /// a projection argument.
-  AddProjectedValue,
+  /// Allow a type that is not a property wrapper to be used as a property
+  /// wrapper.
+  AllowInvalidPropertyWrapperType,
 
-  /// Add '@propertyWrapper' to a nominal type declaration.
-  AddPropertyWrapperAttribute,
+  /// Remove the '$' prefix from an argument label or parameter name.
+  RemoveProjectedValueArgument,
 
   /// Instead of spelling out `subscript` directly, use subscript operator.
   UseSubscriptOperator,
@@ -984,37 +984,40 @@ class UseWrappedValue final : public ConstraintFix {
                                  ConstraintLocator *locator);
 };
 
-class AddProjectedValue final : public ConstraintFix {
+class AllowInvalidPropertyWrapperType final : public ConstraintFix {
   Type wrapperType;
 
-  AddProjectedValue(ConstraintSystem &cs, Type wrapper,
-                    ConstraintLocator *locator)
-      : ConstraintFix(cs, FixKind::AddProjectedValue, locator), wrapperType(wrapper) {}
+  AllowInvalidPropertyWrapperType(ConstraintSystem &cs, Type wrapperType,
+                                  ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::AllowInvalidPropertyWrapperType, locator),
+        wrapperType(wrapperType) {}
 
 public:
-  static AddProjectedValue *create(ConstraintSystem &cs, Type wrapper,
-                                   ConstraintLocator *locator);
+  static AllowInvalidPropertyWrapperType *create(ConstraintSystem &cs, Type wrapperType,
+                                                 ConstraintLocator *locator);
 
   std::string getName() const override {
-    return "add 'var projectedValue' to pass a projection argument";
+    return "allow invalid property wrapper type";
   }
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
 };
 
-class AddPropertyWrapperAttribute final : public ConstraintFix {
+class RemoveProjectedValueArgument final : public ConstraintFix {
   Type wrapperType;
+  ParamDecl *param;
 
-  AddPropertyWrapperAttribute(ConstraintSystem &cs, Type wrapper,
-                              ConstraintLocator *locator)
-      : ConstraintFix(cs, FixKind::AddPropertyWrapperAttribute, locator), wrapperType(wrapper) {}
+  RemoveProjectedValueArgument(ConstraintSystem &cs, Type wrapper,
+                               ParamDecl *param, ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::RemoveProjectedValueArgument, locator),
+        wrapperType(wrapper), param(param) {}
 
 public:
-  static AddPropertyWrapperAttribute *create(ConstraintSystem &cs, Type wrapper,
-                                             ConstraintLocator *locator);
+  static RemoveProjectedValueArgument *create(ConstraintSystem &cs, Type wrapper,
+                                              ParamDecl *param, ConstraintLocator *locator);
 
   std::string getName() const override {
-    return "add '@propertyWrapper'";
+    return "remove '$' from argument label";
   }
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;

include/swift/Sema/Constraint.h

@@ -187,6 +187,9 @@ enum class ConstraintKind : char {
   /// - If base is a protocol metatype, this constraint becomes a conformance
   ///   check instead of an equality.
   UnresolvedMemberChainBase,
+  /// The first type is a property wrapper with a wrapped-value type
+  /// equal to the second type.
+  PropertyWrapper,
 };
 
 /// Classification of the different kinds of constraints.
@@ -586,6 +589,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::ValueMember:
     case ConstraintKind::UnresolvedValueMember:
     case ConstraintKind::ValueWitness:
+    case ConstraintKind::PropertyWrapper:
       return ConstraintClassification::Member;
 
     case ConstraintKind::DynamicTypeOf:

include/swift/Sema/ConstraintSystem.h

@@ -4595,6 +4595,11 @@ class ConstraintSystem {
       ArrayRef<TypeVariableType *> referencedOuterParameters,
       TypeMatchOptions flags, ConstraintLocatorBuilder locator);
 
+  /// Attempt to simplify a property wrapper constraint.
+  SolutionKind simplifyPropertyWrapperConstraint(Type wrapperType, Type wrappedValueType,
+                                                 TypeMatchOptions flags,
+                                                 ConstraintLocatorBuilder locator);
+
   /// Attempt to simplify a one-way constraint.
   SolutionKind simplifyOneWayConstraint(ConstraintKind kind,
                                         Type first, Type second,