Merge pull request #83051 from tshortli/diagnose-more-invalid-os-versions

Sema: Diagnose invalid platform versions in more places

Author: tshortli

include/swift/AST/Attr.h

@@ -2399,6 +2399,11 @@ class ProjectedValuePropertyAttr : public DeclAttribute {
 /// The variable \p foo was originally defined in another module called
 /// \p Original prior to OSX 10.15
 class OriginallyDefinedInAttr: public DeclAttribute {
+  const StringRef ManglingModuleName;
+  const StringRef LinkerModuleName;
+  const PlatformKind Platform;
+  const llvm::VersionTuple MovedVersion;
+
 public:
   OriginallyDefinedInAttr(SourceLoc AtLoc, SourceRange Range,
                           StringRef OriginalModuleName,
@@ -2420,16 +2425,22 @@ class OriginallyDefinedInAttr: public DeclAttribute {
   OriginallyDefinedInAttr *clone(ASTContext &C, bool implicit) const;
 
   // The original module name for mangling.
-  const StringRef ManglingModuleName;
+  StringRef getManglingModuleName() const { return ManglingModuleName; }
 
   // The original module name for linker directives.
-  const StringRef LinkerModuleName;
+  StringRef getLinkerModuleName() const { return LinkerModuleName; }
 
   /// The platform of the symbol.
-  const PlatformKind Platform;
+  PlatformKind getPlatform() const { return Platform; }
 
-  /// Indicates when the symbol was moved here.
-  const llvm::VersionTuple MovedVersion;
+  /// The version of the platform that the symbol was moved in, as it was
+  /// written in source.
+  llvm::VersionTuple getParsedMovedVersion() const { return MovedVersion; }
+
+  /// The version of the platform that the symbol was moved in. This may be
+  /// different than the version that was written in source due to
+  /// canonicalization.
+  llvm::VersionTuple getMovedVersion() const;
 
   struct ActiveVersion {
     StringRef ManglingModuleName;
@@ -2928,17 +2939,25 @@ class UnavailableFromAsyncAttr : public DeclAttribute {
 /// available for back deployment to older OSes via emission into the client
 /// binary.
 class BackDeployedAttr : public DeclAttribute {
+  const PlatformKind Platform;
+  const llvm::VersionTuple Version;
+
 public:
   BackDeployedAttr(SourceLoc AtLoc, SourceRange Range, PlatformKind Platform,
                    const llvm::VersionTuple &Version, bool Implicit)
       : DeclAttribute(DeclAttrKind::BackDeployed, AtLoc, Range, Implicit),
         Platform(Platform), Version(Version) {}
 
   /// The platform the decl is available for back deployment in.
-  const PlatformKind Platform;
+  PlatformKind getPlatform() const { return Platform; }
 
-  /// The earliest platform version that may use the back deployed implementation.
-  const llvm::VersionTuple Version;
+  /// The `before:` version tuple that was written in source.
+  llvm::VersionTuple getParsedVersion() const { return Version; }
+
+  /// The `before:` version, which is the earliest platform version that may use
+  /// the back deployed implementation. This may be different from the version
+  /// that was written in source due to canonicalization.
+  llvm::VersionTuple getVersion() const;
 
   /// Returns true if this attribute is active given the current platform.
   bool isActivePlatform(const ASTContext &ctx, bool forTargetVariant) const;

lib/AST/ASTDumper.cpp

@@ -5121,9 +5121,10 @@ class PrintAttribute : public AttributeVisitor<PrintAttribute, void, Label>,
   }
   void visitBackDeployedAttr(BackDeployedAttr *Attr, Label label) {
     printCommon(Attr, "back_deployed_attr", label);
-    printField(Attr->Platform, Label::always("platform"));
-    printFieldRaw([&](auto &out) { out << Attr->Version.getAsString(); },
-                  Label::always("version"));
+    printField(Attr->getPlatform(), Label::always("platform"));
+    printFieldRaw(
+        [&](auto &out) { out << Attr->getParsedVersion().getAsString(); },
+        Label::always("version"));
     printFoot();
   }
   void visitCDeclAttr(CDeclAttr *Attr, Label label) {
@@ -5347,11 +5348,12 @@ class PrintAttribute : public AttributeVisitor<PrintAttribute, void, Label>,
   void visitOriginallyDefinedInAttr(OriginallyDefinedInAttr *Attr,
                                     Label label) {
     printCommon(Attr, "originally_defined_in_attr", label);
-    printField(Attr->ManglingModuleName, Label::always("mangling_module"));
-    printField(Attr->LinkerModuleName, Label::always("linker_module"));
-    printField(Attr->Platform, Label::always("platform"));
-    printFieldRaw([&](auto &out) { out << Attr->MovedVersion.getAsString(); },
-                  Label::always("moved_version"));
+    printField(Attr->getManglingModuleName(), Label::always("mangling_module"));
+    printField(Attr->getLinkerModuleName(), Label::always("linker_module"));
+    printField(Attr->getPlatform(), Label::always("platform"));
+    printFieldRaw(
+        [&](auto &out) { out << Attr->getParsedMovedVersion().getAsString(); },
+        Label::always("moved_version"));
     printFoot();
   }
   void visitPrivateImportAttr(PrivateImportAttr *Attr, Label label) {

lib/AST/ASTPrinter.cpp

@@ -6058,9 +6058,9 @@ class TypePrinter : public TypeVisitor<TypePrinter, void, NonRecursivePrintOptio
     if (Options.UseOriginallyDefinedInModuleNames) {
       Decl *D = Ty->getDecl();
       for (auto attr: D->getAttrs().getAttributes<OriginallyDefinedInAttr>()) {
-        Name = Mod->getASTContext()
-          .getIdentifier(const_cast<OriginallyDefinedInAttr*>(attr)
-                         ->ManglingModuleName);
+        Name = Mod->getASTContext().getIdentifier(
+            const_cast<OriginallyDefinedInAttr *>(attr)
+                ->getManglingModuleName());
         break;
       }
     }

lib/AST/Attr.cpp

@@ -421,8 +421,9 @@ DeclAttributes::getBackDeployed(const ASTContext &ctx,
 
     // We have an attribute that is active for the platform, but
     // is it more specific than our current best?
-    if (!bestAttr || inheritsAvailabilityFromPlatform(
-                         backDeployedAttr->Platform, bestAttr->Platform)) {
+    if (!bestAttr ||
+        inheritsAvailabilityFromPlatform(backDeployedAttr->getPlatform(),
+                                         bestAttr->getPlatform())) {
       bestAttr = backDeployedAttr;
     }
   }
@@ -557,8 +558,8 @@ static void printShortFormBackDeployed(ArrayRef<const DeclAttribute *> Attrs,
     if (!isFirst)
       Printer << ", ";
     auto *attr = cast<BackDeployedAttr>(DA);
-    Printer << platformString(attr->Platform) << " "
-            << attr->Version.getAsString();
+    Printer << platformString(attr->getPlatform()) << " "
+            << attr->getVersion().getAsString();
     isFirst = false;
   }
   Printer << ")";
@@ -771,9 +772,9 @@ static std::optional<PlatformKind> referencedPlatform(const DeclAttribute *attr,
     }
     return std::nullopt;
   case DeclAttrKind::BackDeployed:
-    return static_cast<const BackDeployedAttr *>(attr)->Platform;
+    return static_cast<const BackDeployedAttr *>(attr)->getPlatform();
   case DeclAttrKind::OriginallyDefinedIn:
-    return static_cast<const OriginallyDefinedInAttr *>(attr)->Platform;
+    return static_cast<const OriginallyDefinedInAttr *>(attr)->getPlatform();
   default:
     return std::nullopt;
   }
@@ -1094,7 +1095,7 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
   case DeclAttrKind::OriginallyDefinedIn: {
     auto Attr = cast<OriginallyDefinedInAttr>(this);
     auto Name = D->getDeclContext()->getParentModule()->getName().str();
-    if (Options.IsForSwiftInterface && Attr->ManglingModuleName == Name)
+    if (Options.IsForSwiftInterface && Attr->getManglingModuleName() == Name)
       return false;
     break;
   }
@@ -1195,13 +1196,15 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     Printer.printAttrName("@_originallyDefinedIn");
     Printer << "(module: ";
     auto Attr = cast<OriginallyDefinedInAttr>(this);
-    Printer << "\"" << Attr->ManglingModuleName;
-    ASSERT(!Attr->ManglingModuleName.empty());
-    ASSERT(!Attr->LinkerModuleName.empty());
-    if (Attr->LinkerModuleName != Attr->ManglingModuleName)
-      Printer << ";" << Attr->LinkerModuleName;
-    Printer << "\", " << platformString(Attr->Platform) << " " <<
-      Attr->MovedVersion.getAsString();
+    auto ManglingModuleName = Attr->getManglingModuleName();
+    auto LinkerModuleName = Attr->getLinkerModuleName();
+    Printer << "\"" << ManglingModuleName;
+    ASSERT(!ManglingModuleName.empty());
+    ASSERT(!LinkerModuleName.empty());
+    if (LinkerModuleName != ManglingModuleName)
+      Printer << ";" << LinkerModuleName;
+    Printer << "\", " << platformString(Attr->getPlatform()) << " "
+            << Attr->getMovedVersion().getAsString();
     Printer << ")";
     break;
   }
@@ -1517,8 +1520,8 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     Printer.printAttrName("@backDeployed");
     Printer << "(before: ";
     auto Attr = cast<BackDeployedAttr>(this);
-    Printer << platformString(Attr->Platform) << " " <<
-      Attr->Version.getAsString();
+    Printer << platformString(Attr->getPlatform()) << " "
+            << Attr->getVersion().getAsString();
     Printer << ")";
     break;
   }
@@ -2348,6 +2351,10 @@ AvailableAttr *AvailableAttr::createUnavailableInEmbedded(ASTContext &C,
       /*Implicit=*/false, /*IsSPI=*/false);
 }
 
+llvm::VersionTuple BackDeployedAttr::getVersion() const {
+  return canonicalizePlatformVersion(getPlatform(), getParsedVersion());
+}
+
 bool BackDeployedAttr::isActivePlatform(const ASTContext &ctx,
                                         bool forTargetVariant) const {
   return isPlatformActive(Platform, ctx.LangOpts, forTargetVariant);
@@ -2375,14 +2382,14 @@ bool AvailableAttr::isEquivalent(const AvailableAttr *other,
                 ==  attachedTo->getSemanticAvailableAttr(other)->getDomain();
 }
 
-static StringRef getManglingModuleName(StringRef OriginalModuleName) {
+static StringRef parseManglingModuleName(StringRef OriginalModuleName) {
   auto index = OriginalModuleName.find(";");
   return index == StringRef::npos
       ? OriginalModuleName
       : OriginalModuleName.slice(0, index);
 }
 
-static StringRef getLinkerModuleName(StringRef OriginalModuleName) {
+static StringRef parseLinkerModuleName(StringRef OriginalModuleName) {
   auto index = OriginalModuleName.find(";");
   return index == StringRef::npos
       ? OriginalModuleName
@@ -2393,16 +2400,19 @@ OriginallyDefinedInAttr::OriginallyDefinedInAttr(
     SourceLoc AtLoc, SourceRange Range, StringRef OriginalModuleName,
     PlatformKind Platform, const llvm::VersionTuple MovedVersion, bool Implicit)
     : DeclAttribute(DeclAttrKind::OriginallyDefinedIn, AtLoc, Range, Implicit),
-      ManglingModuleName(getManglingModuleName(OriginalModuleName)),
-      LinkerModuleName(getLinkerModuleName(OriginalModuleName)),
-      Platform(Platform),
-      MovedVersion(canonicalizePlatformVersion(Platform, MovedVersion)) {}
+      ManglingModuleName(parseManglingModuleName(OriginalModuleName)),
+      LinkerModuleName(parseLinkerModuleName(OriginalModuleName)),
+      Platform(Platform), MovedVersion(MovedVersion) {}
+
+llvm::VersionTuple OriginallyDefinedInAttr::getMovedVersion() const {
+  return canonicalizePlatformVersion(getPlatform(), getParsedMovedVersion());
+}
 
 std::optional<OriginallyDefinedInAttr::ActiveVersion>
 OriginallyDefinedInAttr::isActivePlatform(const ASTContext &ctx) const {
   OriginallyDefinedInAttr::ActiveVersion Result;
   Result.Platform = Platform;
-  Result.Version = MovedVersion;
+  Result.Version = getMovedVersion();
   Result.ManglingModuleName = ManglingModuleName;
   Result.LinkerModuleName = LinkerModuleName;
   if (isPlatformActive(Platform, ctx.LangOpts, /*TargetVariant*/false)) {

lib/AST/Availability.cpp

@@ -370,7 +370,7 @@ bool AvailabilityInference::updateBeforeAvailabilityDomainForFallback(
   if (!hasRemap)
     return false;
 
-  auto beforeVersion = attr->Version;
+  auto beforeVersion = attr->getVersion();
   auto potentiallyRemappedIntroducedVersion =
       getRemappedIntroducedVersionForFallbackPlatform(ctx, beforeVersion);
   if (potentiallyRemappedIntroducedVersion.has_value()) {

lib/AST/Decl.cpp

@@ -611,7 +611,7 @@ std::optional<std::pair<const BackDeployedAttr *, AvailabilityRange>>
 Decl::getBackDeployedAttrAndRange(ASTContext &Ctx,
                                   bool forTargetVariant) const {
   if (auto *attr = getAttrs().getBackDeployed(Ctx, forTargetVariant)) {
-    auto version = attr->Version;
+    auto version = attr->getVersion();
     AvailabilityDomain ignoredDomain;
     AvailabilityInference::updateBeforeAvailabilityDomainForFallback(
         attr, getASTContext(), ignoredDomain, version);
@@ -1142,7 +1142,7 @@ StringRef Decl::getAlternateModuleName() const {
   for (auto *Att: Attrs) {
     if (auto *OD = dyn_cast<OriginallyDefinedInAttr>(Att)) {
       if (!OD->isInvalid() && OD->isActivePlatform(getASTContext())) {
-        return OD->ManglingModuleName;
+        return OD->getManglingModuleName();
       }
     }
   }

lib/IRGen/IRGenDebugInfo.cpp

@@ -2540,10 +2540,10 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
       if (auto Attribute =
               ND->getAttrs().getAttribute<OriginallyDefinedInAttr>()) {
         auto Identifier = IGM.getSILModule().getASTContext().getIdentifier(
-            Attribute->ManglingModuleName);
+            Attribute->getManglingModuleName());
         void *Key = (void *)Identifier.get();
-        Scope = getOrCreateModule(Key, TheCU, Attribute->ManglingModuleName, {},
-                                  {});
+        Scope = getOrCreateModule(Key, TheCU,
+                                  Attribute->getManglingModuleName(), {}, {});
       } else {
         Context = ND->getParent();
       }

lib/Sema/MiscDiagnostics.cpp

@@ -5195,8 +5195,8 @@ static bool diagnoseAvailabilityCondition(PoundAvailableInfo *info,
       return true;
     }
 
+    auto rawVersion = parsedSpec->getRawVersion();
     if (hasVersion) {
-      auto rawVersion = parsedSpec->getRawVersion();
       if (!VersionRange::isValidVersion(rawVersion)) {
         diags
             .diagnose(loc, diag::availability_unsupported_version_number,
@@ -5211,6 +5211,12 @@ static bool diagnoseAvailabilityCondition(PoundAvailableInfo *info,
         diags.diagnose(loc, diag::avail_query_expected_version_number);
         return true;
       }
+
+      if (!domain.isVersionValid(rawVersion)) {
+        diags.diagnose(loc,
+                       diag::availability_invalid_version_number_for_domain,
+                       rawVersion, domain);
+      }
     } else if (hasVersion) {
       diags.diagnose(loc, diag::availability_unexpected_version, domain)
           .highlight(parsedSpec->getVersionSrcRange());

lib/Sema/TypeCheckAttr.cpp

@@ -4916,14 +4916,21 @@ void AttributeChecker::checkOriginalDefinedInAttrs(
   // Attrs are in the reverse order of the source order. We need to visit them
   // in source order to diagnose the later attribute.
   for (auto *Attr: Attrs) {
+    auto AtLoc = Attr->AtLoc;
+    auto Platform = Attr->getPlatform();
+    auto Domain = AvailabilityDomain::forPlatform(Platform);
+    auto ParsedVersion = Attr->getParsedMovedVersion();
+    if (!Domain.isVersionValid(ParsedVersion)) {
+      diagnose(AtLoc, diag::availability_invalid_version_number_for_domain,
+               ParsedVersion, Domain);
+    }
+
     if (!Attr->isActivePlatform(Ctx))
       continue;
 
     if (diagnoseAndRemoveAttrIfDeclIsNonPublic(Attr, /*isError=*/false))
       continue;
 
-    auto AtLoc = Attr->AtLoc;
-    auto Platform = Attr->Platform;
     if (!seenPlatforms.insert({Platform, AtLoc}).second) {
       // We've seen the platform before, emit error to the previous one which
       // comes later in the source order.
@@ -4941,7 +4948,7 @@ void AttributeChecker::checkOriginalDefinedInAttrs(
       return;
 
     auto IntroVer = D->getIntroducedOSVersion(Platform);
-    if (IntroVer.value() > Attr->MovedVersion) {
+    if (IntroVer.value() > Attr->getMovedVersion()) {
       diagnose(AtLoc,
                diag::originally_definedin_must_not_before_available_version);
       return;
@@ -5115,6 +5122,13 @@ void AttributeChecker::checkBackDeployedAttrs(
     ActiveAttr = AttrAndRange->first;
 
   for (auto *Attr : Attrs) {
+    auto Domain = Attr->getAvailabilityDomain();
+    if (!Domain.isVersionValid(Attr->getParsedVersion())) {
+      diagnose(Attr->getLocation(),
+               diag::availability_invalid_version_number_for_domain,
+               Attr->getParsedVersion(), Domain);
+    }
+
     // Back deployment only makes sense for public declarations.
     if (diagnoseAndRemoveAttrIfDeclIsNonPublic(Attr, /*isError=*/true))
       continue;
@@ -5162,7 +5176,7 @@ void AttributeChecker::checkBackDeployedAttrs(
     }
 
     auto AtLoc = Attr->AtLoc;
-    auto Platform = Attr->Platform;
+    auto Platform = Attr->getPlatform();
 
     if (!seenPlatforms.insert({Platform, AtLoc}).second) {
       // We've seen the platform before, emit error to the previous one which
@@ -5203,9 +5217,8 @@ void AttributeChecker::checkBackDeployedAttrs(
         D->getLoc(), D->getInnermostDeclContext());
 
     // Unavailable decls cannot be back deployed.
-    auto backDeployedDomain = Attr->getAvailabilityDomain();
-    if (availability.containsUnavailableDomain(backDeployedDomain)) {
-      auto domainForDiagnostics = backDeployedDomain;
+    if (availability.containsUnavailableDomain(Domain)) {
+      auto domainForDiagnostics = Domain;
       llvm::VersionTuple ignoredVersion;
 
       AvailabilityInference::updateBeforeAvailabilityDomainForFallback(
@@ -5237,7 +5250,7 @@ void AttributeChecker::checkBackDeployedAttrs(
     if (auto availableRangeAttrPair =
             getSemanticAvailableRangeDeclAndAttr(VD)) {
       auto beforeDomain = Attr->getAvailabilityDomain();
-      auto beforeVersion = Attr->Version;
+      auto beforeVersion = Attr->getVersion();
       auto availableAttr = availableRangeAttrPair.value().first;
       auto introVersion = availableAttr.getIntroduced().value();
       AvailabilityDomain introDomain = availableAttr.getDomain();
@@ -5247,7 +5260,7 @@ void AttributeChecker::checkBackDeployedAttrs(
       AvailabilityInference::updateIntroducedAvailabilityDomainForFallback(
           availableAttr, Ctx, introDomain, introVersion);
 
-      if (Attr->Version <= introVersion) {
+      if (beforeVersion <= introVersion) {
         diagnose(AtLoc, diag::attr_has_no_effect_decl_not_available_before,
                  Attr, VD, beforeDomain, AvailabilityRange(beforeVersion));
         diagnose(availableAttr.getParsedAttr()->AtLoc,