Merge pull request #2004 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/AST/Decl.h

@@ -3762,6 +3762,7 @@ struct SelfReferencePosition final {
     case Contravariant:
       return Covariant;
     }
+    llvm_unreachable("unhandled self reference position!");
   }
 
   explicit operator bool() const { return kind > None; }

include/swift/AST/DiagnosticsSema.def

@@ -2455,16 +2455,10 @@ NOTE(suggest_removing_override, none,
 ERROR(override_less_available,none,
       "overriding %0 must be as available as declaration it overrides",
       (DeclBaseName))
-WARNING(override_less_available_warn,none,
-        "overriding %0 must be as available as declaration it overrides",
-        (DeclBaseName))
 
 ERROR(override_accessor_less_available,none,
       "overriding %0 for %1 must be as available as declaration it overrides",
       (DescriptiveDeclKind, DeclBaseName))
-WARNING(override_accessor_less_available_warn,none,
-        "overriding %0 for %1 must be as available as declaration it overrides",
-        (DescriptiveDeclKind, DeclBaseName))
 
 ERROR(override_let_property,none,
       "cannot override immutable 'let' property %0 with the getter of a 'var'",

include/swift/AST/ForeignErrorConvention.h

@@ -198,6 +198,7 @@ class ForeignErrorConvention {
     case NonNilError:
       return false;
     }
+    llvm_unreachable("unhandled foreign error kind!");
   }
 
   bool operator==(ForeignErrorConvention other) const {

include/swift/AST/TypeCheckRequests.h

@@ -2687,9 +2687,13 @@ enum class CustomAttrTypeKind {
   /// any contextual type parameters.
   NonGeneric,
 
-  /// Property delegates have some funky rules, like allowing
+  /// Property wrappers have some funky rules, like allowing
   /// unbound generic types.
-  PropertyDelegate,
+  PropertyWrapper,
+
+  /// Global actors are represented as custom type attributes. They don't
+  /// have any particularly interesting semantics.
+  GlobalActor,
 };
 
 void simple_display(llvm::raw_ostream &out, CustomAttrTypeKind value);

include/swift/AST/TypeRefinementContext.h

@@ -154,23 +154,16 @@ class TypeRefinementContext {
 
   SourceRange SrcRange;
 
-  /// Runtime availability information for the code in this context.
   AvailabilityContext AvailabilityInfo;
 
-  /// Runtime availability information as explicitly declared by attributes
-  /// for the inlinable code in this context. Compared to AvailabilityInfo,
-  /// this is not bounded to the minimum deployment OS version.
-  AvailabilityContext AvailabilityInfoExplicit;
-
   std::vector<TypeRefinementContext *> Children;
 
   TypeRefinementContext(ASTContext &Ctx, IntroNode Node,
                         TypeRefinementContext *Parent, SourceRange SrcRange,
-                        const AvailabilityContext &Info,
-                        const AvailabilityContext &InfoExplicit);
+                        const AvailabilityContext &Info);
 
 public:
-
+  
   /// Create the root refinement context for the given SourceFile.
   static TypeRefinementContext *createRoot(SourceFile *SF,
                                            const AvailabilityContext &Info);
@@ -179,9 +172,8 @@ class TypeRefinementContext {
   static TypeRefinementContext *createForDecl(ASTContext &Ctx, Decl *D,
                                               TypeRefinementContext *Parent,
                                               const AvailabilityContext &Info,
-                                              const AvailabilityContext &InfoExplicit,
                                               SourceRange SrcRange);
-
+  
   /// Create a refinement context for the Then branch of the given IfStmt.
   static TypeRefinementContext *
   createForIfStmtThen(ASTContext &Ctx, IfStmt *S, TypeRefinementContext *Parent,
@@ -248,19 +240,11 @@ class TypeRefinementContext {
   SourceRange getSourceRange() const { return SrcRange; }
 
   /// Returns the information on what can be assumed present at run time when
-  /// running code contained in this context, taking into account the minimum
-  /// deployment target.
+  /// running code contained in this context.
   const AvailabilityContext &getAvailabilityInfo() const {
     return AvailabilityInfo;
   }
 
-  /// Returns the information on what can be assumed present at run time when
-  /// running code contained in this context if it were to be inlined,
-  /// without considering the minimum deployment target.
-  const AvailabilityContext &getAvailabilityInfoExplicit() const {
-    return AvailabilityInfoExplicit;
-  }
-
   /// Adds a child refinement context.
   void addChild(TypeRefinementContext *Child) {
     assert(Child->getSourceRange().isValid());

include/swift/Demangling/TypeLookupError.h

@@ -150,6 +150,7 @@ class TypeLookupError {
         delete castContext;
         return nullptr;
       }
+      llvm_unreachable("unhandled command!");
     };
   }
 

include/swift/Sema/ConstraintSystem.h

@@ -1907,6 +1907,7 @@ class SolutionApplicationTarget {
     case Kind::patternBinding:
       return patternBinding;
     }
+    llvm_unreachable("invalid case label type");
   }
 
   VarDecl *getAsUninitializedWrappedVar() const {
@@ -1921,6 +1922,7 @@ class SolutionApplicationTarget {
     case Kind::uninitializedWrappedVar:
       return uninitializedWrappedVar;
     }
+    llvm_unreachable("invalid case label type");
   }
 
   BraceStmt *getFunctionBody() const {

lib/AST/AutoDiff.cpp

@@ -462,6 +462,7 @@ bool swift::operator==(const TangentPropertyInfo::Error &lhs,
   case TangentPropertyInfo::Error::Kind::TangentPropertyWrongType:
     return lhs.getType()->isEqual(rhs.getType());
   }
+  llvm_unreachable("unhandled tangent property!");
 }
 
 void swift::simple_display(llvm::raw_ostream &os, TangentPropertyInfo info) {

lib/AST/Availability.cpp

@@ -144,13 +144,8 @@ static bool isBetterThan(const AvailableAttr *newAttr,
     return true;
 
   // If they belong to the same platform, the one that introduces later wins.
-  if (prevAttr->Platform == newAttr->Platform) {
-    if (newAttr->isUnconditionallyUnavailable())
-      return true;
-    if (prevAttr->isUnconditionallyUnavailable())
-      return false;
+  if (prevAttr->Platform == newAttr->Platform)
     return prevAttr->Introduced.getValue() < newAttr->Introduced.getValue();
-  }
 
   // If the new attribute's platform inherits from the old one, it wins.
   return inheritsAvailabilityFromPlatform(newAttr->Platform,
@@ -163,12 +158,10 @@ AvailabilityInference::annotatedAvailableRange(const Decl *D, ASTContext &Ctx) {
 
   for (auto Attr : D->getAttrs()) {
     auto *AvailAttr = dyn_cast<AvailableAttr>(Attr);
-    if (AvailAttr == nullptr ||
+    if (AvailAttr == nullptr || !AvailAttr->Introduced.hasValue() ||
         !AvailAttr->isActivePlatform(Ctx) ||
         AvailAttr->isLanguageVersionSpecific() ||
-        AvailAttr->isPackageDescriptionVersionSpecific() ||
-        (!AvailAttr->Introduced.hasValue() &&
-         !AvailAttr->isUnconditionallyUnavailable())) {
+        AvailAttr->isPackageDescriptionVersionSpecific()) {
       continue;
     }
 
@@ -179,9 +172,6 @@ AvailabilityInference::annotatedAvailableRange(const Decl *D, ASTContext &Ctx) {
   if (!bestAvailAttr)
     return None;
 
-  if (bestAvailAttr->isUnconditionallyUnavailable())
-      return AvailabilityContext(VersionRange::empty());
-
   return AvailabilityContext{
     VersionRange::allGTE(bestAvailAttr->Introduced.getValue())};
 }

lib/AST/ClangTypeConverter.cpp

@@ -207,6 +207,7 @@ const clang::Type *ClangTypeConverter::getFunctionType(
   case SILFunctionType::Representation::Closure:
     llvm_unreachable("Expected a C-compatible representation.");
   }
+  llvm_unreachable("unhandled representation!");
 }
 
 clang::QualType ClangTypeConverter::convertMemberType(NominalTypeDecl *DC,