Merge pull request #4760 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/AST/DiagnosticsSema.def

@@ -4788,6 +4788,9 @@ ERROR(nonisolated_local_var,none,
 ERROR(nonisolated_actor_sync_init,none,
       "'nonisolated' on an actor's synchronous initializer is invalid",
       ())
+ERROR(nonisolated_wrapped_property,none,
+      "'nonisolated' is not supported on properties with property wrappers",
+      ())
 
 ERROR(actor_instance_property_wrapper,none,
       "%0 property in property wrapper type %1 cannot be isolated to "

include/swift/Basic/LLVM.h

@@ -25,6 +25,14 @@
 // None.h includes an enumerator that is desired & cannot be forward declared
 // without a definition of NoneType.
 #include "llvm/ADT/None.h"
+#if defined(__clang_major__) && __clang_major__ < 6
+// Add this header as a workaround to prevent `too few template arguments for
+// class template 'SmallVector'` on the buggy Clang 5 compiler (it doesn't
+// merge template arguments correctly). Remove once the CentOS 7 job is
+// replaced.
+// rdar://98218902
+#include "llvm/ADT/SmallVector.h"
+#endif
 
 // Don't pre-declare certain LLVM types in the runtime, which must
 // not put things in namespace llvm for ODR reasons.

include/swift/Sema/ConstraintLocatorPathElts.def

@@ -72,8 +72,11 @@ CUSTOM_LOCATOR_PATH_ELT(ContextualType)
 /// A result of an expression involving dynamic lookup.
 SIMPLE_LOCATOR_PATH_ELT(DynamicLookupResult)
 
-/// The superclass of a protocol existential type.
-SIMPLE_LOCATOR_PATH_ELT(ExistentialSuperclassType)
+/// The superclass of a protocol composition type.
+SIMPLE_LOCATOR_PATH_ELT(ProtocolCompositionSuperclassType)
+
+/// The constraint of an existential type.
+SIMPLE_LOCATOR_PATH_ELT(ExistentialConstraintType)
 
 /// The argument type of a function.
 SIMPLE_LOCATOR_PATH_ELT(FunctionArgument)

include/swift/Sema/ConstraintSystem.h

@@ -946,6 +946,10 @@ struct AppliedBuilderTransform {
   Expr *returnExpr = nullptr;
 };
 
+struct Score;
+/// Display a score.
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const Score &score);
+
 /// Describes the fixed score of a solution to the constraint system.
 struct Score {
   unsigned Data[NumScoreKinds] = {};
@@ -1016,11 +1020,94 @@ struct Score {
   friend bool operator>=(const Score &x, const Score &y) {
     return !(x < y);
   }
+  
+  /// Return ScoreKind descriptions for printing alongside non-zero ScoreKinds
+  /// in debug output.
+  static std::string getNameFor(ScoreKind kind) {
+    switch (kind) {
+    case SK_Hole:
+      return "hole";
 
-};
+    case SK_Unavailable:
+      return "use of an unavailable declaration";
 
-/// Display a score.
-llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const Score &score);
+    case SK_AsyncInSyncMismatch:
+      return "async-in-synchronous mismatch";
+
+    case SK_SyncInAsync:
+      return "sync-in-asynchronous";
+
+    case SK_ForwardTrailingClosure:
+      return "forward scan when matching a trailing closure";
+
+    case SK_Fix:
+      return "applied fix";
+
+    case SK_DisfavoredOverload:
+      return "disfavored overload";
+
+    case SK_UnresolvedMemberViaOptional:
+      return "unwrapping optional at unresolved member base";
+
+    case SK_ForceUnchecked:
+      return "force of an implicitly unwrapped optional";
+
+    case SK_UserConversion:
+      return "user conversion";
+
+    case SK_FunctionConversion:
+      return "function conversion";
+
+    case SK_NonDefaultLiteral:
+      return "non-default literal";
+
+    case SK_CollectionUpcastConversion:
+      return "collection upcast conversion";
+
+    case SK_ValueToOptional:
+      return "value to optional promotion";
+
+    case SK_EmptyExistentialConversion:
+      return "empty-existential conversion";
+
+    case SK_KeyPathSubscript:
+      return "key path subscript";
+
+    case SK_ValueToPointerConversion:
+      return "value-to-pointer conversion";
+
+    case SK_FunctionToAutoClosureConversion:
+      return "function to autoclosure parameter conversion";
+
+    case SK_ImplicitValueConversion:
+      return "value-to-value conversion";
+
+    case SK_UnappliedFunction:
+      return "use of overloaded unapplied function";
+    }
+  }
+
+  /// Print Score list a with brief description of any non-zero ScoreKinds.
+  void print(llvm::raw_ostream &out) const {
+    bool hasNonDefault = false;
+    for (unsigned int i = 0; i < NumScoreKinds; ++i) {
+      if (Data[i] != 0) {
+        out << " [";
+        out << getNameFor(ScoreKind(i));
+        out << "(s) = ";
+        out << std::to_string(Data[i]);
+        out << "]";
+        hasNonDefault = true;
+      }
+    }
+
+    if (!hasNonDefault) {
+      out << " <default ";
+      out << *this;
+      out << ">";
+    }
+  }
+};
 
 /// Describes a dependent type that has been opened to a particular type
 /// variable.

include/swift/Sema/OverloadChoice.h

@@ -310,6 +310,9 @@ class OverloadChoice {
     assert(isDecl() && "only makes sense for declaration choices");
     return TheFunctionRefKind;
   }
+
+  /// Print selected overload choice kind found for Solution in debug output.
+  void dump(Type adjustedOpenedType, SourceManager *sm, raw_ostream &out) const;
 };
 
 } // end namespace constraints

lib/AST/RequirementMachine/ConcreteContraction.cpp

@@ -301,7 +301,7 @@ Optional<Type> ConcreteContraction::substTypeParameterRec(
 
     // An unresolved DependentMemberType stores an identifier. Handle this
     // by performing a name lookup into the base type.
-    SmallVector<TypeDecl *, 2> concreteDecls;
+    SmallVector<TypeDecl *> concreteDecls;
     lookupConcreteNestedType(*substBaseType, memberType->getName(), concreteDecls);
 
     auto *typeDecl = findBestConcreteNestedType(concreteDecls);

lib/AST/Type.cpp

@@ -882,7 +882,7 @@ Type TypeBase::lookThroughAllOptionalTypes(SmallVectorImpl<Type> &optionals){
 }
 
 unsigned int TypeBase::getOptionalityDepth() {
-  SmallVector<Type, 4> types;
+  SmallVector<Type> types;
   lookThroughAllOptionalTypes(types);
   return types.size();
 }

lib/ClangImporter/ClangDerivedConformances.cpp

@@ -88,7 +88,7 @@ static ValueDecl *getEqualEqualOperator(NominalTypeDecl *decl) {
   // If no member `func ==` was found, look for out-of-class definitions in the
   // same module.
   auto module = decl->getModuleContext();
-  llvm::SmallVector<ValueDecl *> nonMemberResults;
+  SmallVector<ValueDecl *> nonMemberResults;
   module->lookupValue(id, NLKind::UnqualifiedLookup, nonMemberResults);
   for (const auto &nonMember : nonMemberResults) {
     if (isValid(nonMember))

lib/Demangling/Demangler.cpp

@@ -561,9 +561,8 @@ Demangler::DemangleInitRAII::~DemangleInitRAII() {
 }
 
 NodePointer Demangler::demangleSymbol(StringRef MangledName,
-        std::function<SymbolicReferenceResolver_t> SymbolicReferenceResolver) {
-  DemangleInitRAII state(*this, MangledName,
-                         std::move(SymbolicReferenceResolver));
+        std::function<SymbolicReferenceResolver_t> Resolver) {
+  DemangleInitRAII state(*this, MangledName, std::move(Resolver));
 
 #if SWIFT_SUPPORT_OLD_MANGLING
   // Demangle old-style class and protocol names, which are still used in the
@@ -610,9 +609,8 @@ NodePointer Demangler::demangleSymbol(StringRef MangledName,
 }
 
 NodePointer Demangler::demangleType(StringRef MangledName,
-        std::function<SymbolicReferenceResolver_t> SymbolicReferenceResolver) {
-  DemangleInitRAII state(*this, MangledName,
-                         std::move(SymbolicReferenceResolver));
+        std::function<SymbolicReferenceResolver_t> Resolver) {
+  DemangleInitRAII state(*this, MangledName, std::move(Resolver));
 
   parseAndPushNodes();
 

lib/DriverTool/swift_symbolgraph_extract_main.cpp

@@ -241,7 +241,7 @@ int swift_symbolgraph_extract_main(ArrayRef<const char *> Args,
   // don't need to print these errors.
   CI.removeDiagnosticConsumer(&DiagPrinter);
 
-  SmallVector<ModuleDecl *, 8> Overlays;
+  SmallVector<ModuleDecl *> Overlays;
   M->findDeclaredCrossImportOverlaysTransitive(Overlays);
   for (const auto *OM : Overlays) {
     auto CIM = CI.getASTContext().getModuleByName(OM->getNameStr());