AvailabilityDomain.cpp

//===--- AvailabilityDomain.cpp - Swift Availability Domains --------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

#include"swift/AST/AvailabilityDomain.h"
#include"swift/AST/ASTContext.h"
#include"swift/AST/Decl.h"
#include"swift/AST/DiagnosticsSema.h"
#include"swift/AST/Module.h"
#include"swift/AST/TypeCheckRequests.h"
#include"swift/Basic/Assertions.h"
#include"clang/AST/ASTContext.h"
#include"clang/AST/Decl.h"
#include"llvm/ADT/StringSwitch.h"

usingnamespaceswift;

CustomAvailabilityDomain::Kind
getCustomDomainKind(clang::FeatureAvailKind featureAvailKind) {
switch (featureAvailKind) {
case clang::FeatureAvailKind::None:
llvm_unreachable("unexpected kind");
case clang::FeatureAvailKind::Available:
return CustomAvailabilityDomain::Kind::Enabled;
case clang::FeatureAvailKind::Unavailable:
return CustomAvailabilityDomain::Kind::Disabled;
case clang::FeatureAvailKind::Dynamic:
return CustomAvailabilityDomain::Kind::Dynamic;
 }
}

staticconst CustomAvailabilityDomain *
customDomainForClangDecl(Decl *decl, const ASTContext &ctx) {
auto *clangDecl = decl->getClangDecl();
ASSERT(clangDecl);

auto featureInfo = clangDecl->getASTContext().getFeatureAvailInfo(
const_cast<clang::Decl *>(clangDecl));

// Ensure the decl actually represents an availability domain.
if (featureInfo.first.empty())
returnnullptr;

if (featureInfo.second.Kind == clang::FeatureAvailKind::None)
returnnullptr;

returnCustomAvailabilityDomain::get(
 featureInfo.first, getCustomDomainKind(featureInfo.second.Kind),
 decl->getModuleContext(), decl, ctx);
}

std::optional<AvailabilityDomain>
AvailabilityDomain::forCustom(Decl *decl, const ASTContext &ctx) {
if (!decl)
return std::nullopt;

if (decl->hasClangNode()) {
if (auto *customDomain = customDomainForClangDecl(decl, ctx))
returnAvailabilityDomain::forCustom(customDomain);
 } else {
// FIXME: [availability] Handle Swift availability domains decls.
 }

return std::nullopt;
}

std::optional<AvailabilityDomain>
AvailabilityDomain::builtinDomainForString(StringRef string,
const DeclContext *declContext) {
// This parameter is used in downstream forks, do not remove.
 (void)declContext;

auto domain = llvm::StringSwitch<std::optional<AvailabilityDomain>>(string)
 .Case("*", AvailabilityDomain::forUniversal())
 .Case("swift", AvailabilityDomain::forSwiftLanguage())
 .Case("_PackageDescription",
AvailabilityDomain::forPackageDescription())
 .Default(std::nullopt);

if (domain)
return domain;

if (auto platformKind = platformFromString(string))
returnAvailabilityDomain::forPlatform(*platformKind);

return std::nullopt;
}

boolAvailabilityDomain::isVersioned() const {
switch (getKind()) {
case Kind::Universal:
case Kind::Embedded:
returnfalse;
case Kind::SwiftLanguage:
case Kind::PackageDescription:
case Kind::Platform:
returntrue;
case Kind::Custom:
// FIXME: [availability] Support versioned custom availability domains
returnfalse;
 }
}

boolAvailabilityDomain::supportsContextRefinement() const {
switch (getKind()) {
case Kind::Universal:
case Kind::Embedded:
case Kind::SwiftLanguage:
case Kind::PackageDescription:
returnfalse;
case Kind::Platform:
case Kind::Custom:
returntrue;
 }
}

boolAvailabilityDomain::supportsQueries() const {
switch (getKind()) {
case Kind::Universal:
case Kind::Embedded:
case Kind::SwiftLanguage:
case Kind::PackageDescription:
returnfalse;
case Kind::Platform:
case Kind::Custom:
returntrue;
 }
}

boolAvailabilityDomain::isActive(const ASTContext &ctx) const {
switch (getKind()) {
case Kind::Universal:
case Kind::SwiftLanguage:
case Kind::PackageDescription:
case Kind::Embedded:
returntrue;
case Kind::Platform:
returnisPlatformActive(getPlatformKind(), ctx.LangOpts);
case Kind::Custom:
// For now, custom domains are always active but it's conceivable that in
// the future someone might want to define a domain but leave it inactive.
returntrue;
 }
}

boolAvailabilityDomain::isActivePlatform(const ASTContext &ctx) const {
if (!isPlatform())
returnfalse;

returnisActive(ctx);
}

static std::optional<llvm::VersionTuple>
getDeploymentVersion(const AvailabilityDomain &domain, const ASTContext &ctx) {
switch (domain.getKind()) {
case AvailabilityDomain::Kind::Universal:
case AvailabilityDomain::Kind::Embedded:
case AvailabilityDomain::Kind::Custom:
return std::nullopt;
case AvailabilityDomain::Kind::SwiftLanguage:
return ctx.LangOpts.EffectiveLanguageVersion;
case AvailabilityDomain::Kind::PackageDescription:
return ctx.LangOpts.PackageDescriptionVersion;
case AvailabilityDomain::Kind::Platform:
if (domain.isActive(ctx))
return ctx.LangOpts.getMinPlatformVersion();
return std::nullopt;
 }
}

std::optional<AvailabilityRange>
AvailabilityDomain::getDeploymentRange(const ASTContext &ctx) const {
if (auto version = getDeploymentVersion(*this, ctx))
return AvailabilityRange{*version};
return std::nullopt;
}

llvm::StringRef AvailabilityDomain::getNameForDiagnostics() const {
switch (getKind()) {
case Kind::Universal:
return"*";
case Kind::SwiftLanguage:
return"Swift";
case Kind::PackageDescription:
return"PackageDescription";
case Kind::Embedded:
return"Embedded Swift";
case Kind::Platform:
returnswift::prettyPlatformString(getPlatformKind());
case Kind::Custom:
returngetCustomDomain()->getName().str();
 }
}

llvm::StringRef AvailabilityDomain::getNameForAttributePrinting() const {
switch (getKind()) {
case Kind::Universal:
return"*";
case Kind::SwiftLanguage:
return"swift";
case Kind::PackageDescription:
return"_PackageDescription";
case Kind::Embedded:
return"Embedded";
case Kind::Platform:
returnswift::platformString(getPlatformKind());
case Kind::Custom:
returngetCustomDomain()->getName().str();
 }
}

Decl *AvailabilityDomain::getDecl() const {
if (auto *customDomain = getCustomDomain())
return customDomain->getDecl();

returnnullptr;
}

ModuleDecl *AvailabilityDomain::getModule() const {
if (auto customDomain = getCustomDomain())
return customDomain->getModule();

returnnullptr;
}

boolAvailabilityDomain::contains(const AvailabilityDomain &other) const {
switch (getKind()) {
case Kind::Universal:
returntrue;
case Kind::SwiftLanguage:
case Kind::PackageDescription:
case Kind::Embedded:
case Kind::Custom:
return other == *this;
case Kind::Platform:
if (getPlatformKind() == other.getPlatformKind())
returntrue;
returninheritsAvailabilityFromPlatform(other.getPlatformKind(),
getPlatformKind());
 }
}

boolAvailabilityDomain::isRoot() const {
switch (getKind()) {
case AvailabilityDomain::Kind::Universal:
case AvailabilityDomain::Kind::Embedded:
case AvailabilityDomain::Kind::SwiftLanguage:
case AvailabilityDomain::Kind::PackageDescription:
returntrue;
case AvailabilityDomain::Kind::Platform:
returngetRootDomain() == *this;
case AvailabilityDomain::Kind::Custom:
// For now, all custom domains are their own root.
returntrue;
 }
}

AvailabilityDomain AvailabilityDomain::getRootDomain() const {
if (!isPlatform())
return *this;

// iOS specifically contains a few other platforms.
auto iOSDomain = AvailabilityDomain::forPlatform(PlatformKind::iOS);
if (iOSDomain.contains(*this))
return iOSDomain;

// App Extension domains are contained by their base platform domain.
if (auto basePlatform = basePlatformForExtensionPlatform(getPlatformKind()))
returnAvailabilityDomain::forPlatform(*basePlatform);

return *this;
}

voidAvailabilityDomain::print(llvm::raw_ostream &os) const {
 os << getNameForAttributePrinting();
}

AvailabilityDomain AvailabilityDomain::copy(ASTContext &ctx) const {
switch (getKind()) {
case Kind::Universal:
case Kind::SwiftLanguage:
case Kind::PackageDescription:
case Kind::Embedded:
case Kind::Platform:
// These domain kinds aren't ASTContext dependent.
return *this;
case Kind::Custom:
// To support this, the CustomAvailabilityDomain content would need to
// be copied to the other context, allocating new storage if necessary.
llvm::report_fatal_error("unsupported");
 }
}

boolStableAvailabilityDomainComparator::operator()(
const AvailabilityDomain &lhs, const AvailabilityDomain &rhs) const {
auto lhsKind = lhs.getKind();
auto rhsKind = rhs.getKind();
if (lhsKind != rhsKind)
return lhsKind < rhsKind;

switch (lhsKind) {
case AvailabilityDomain::Kind::Universal:
case AvailabilityDomain::Kind::SwiftLanguage:
case AvailabilityDomain::Kind::PackageDescription:
case AvailabilityDomain::Kind::Embedded:
returnfalse;
case AvailabilityDomain::Kind::Platform:
return lhs.getPlatformKind() < rhs.getPlatformKind();
case AvailabilityDomain::Kind::Custom: {
auto lhsMod = lhs.getModule();
auto rhsMod = rhs.getModule();
if (lhsMod != rhsMod)
return lhsMod->getName() < rhsMod->getName();

return lhs.getNameForAttributePrinting() <
 rhs.getNameForAttributePrinting();
 }
 }
}

CustomAvailabilityDomain::CustomAvailabilityDomain(Identifier name, Kind kind,
 ModuleDecl *mod, Decl *decl)
 : name(name), kind(kind), mod(mod), decl(decl) {
ASSERT(!name.empty());
ASSERT(mod);
}

voidCustomAvailabilityDomain::Profile(llvm::FoldingSetNodeID &ID,
 Identifier name, ModuleDecl *mod) {
 ID.AddPointer(name.getAsOpaquePointer());
 ID.AddPointer(mod);
}

std::optional<AvailabilityDomain>
AvailabilityDomainOrIdentifier::lookUpInDeclContext(
 SourceLoc loc, const DeclContext *declContext) const {
DEBUG_ASSERT(isIdentifier());

auto &ctx = declContext->getASTContext();
auto &diags = ctx.Diags;
 std::optional<AvailabilityDomain> domain;
auto identifier = getAsIdentifier().value();

 llvm::SmallVector<AvailabilityDomain> results;
 declContext->lookupAvailabilityDomains(identifier, results);
if (results.size() > 0) {
// FIXME: [availability] Diagnose ambiguity if necessary.
 domain = results.front();
 }

if (!domain) {
auto domainString = identifier.str();
if (auto suggestion = closestCorrectedPlatformString(domainString)) {
 diags
 .diagnose(loc, diag::availability_suggest_platform_name, identifier,
 *suggestion)
 .fixItReplace(SourceRange(loc), *suggestion);
 } else {
 diags.diagnose(loc, diag::availability_unrecognized_platform_name,
 identifier);
 }
return std::nullopt;
 }

if (domain->isCustom() &&
 !ctx.LangOpts.hasFeature(Feature::CustomAvailability) &&
 !declContext->isInSwiftinterface()) {
 diags.diagnose(loc, diag::attr_availability_requires_custom_availability,
 *domain);
return std::nullopt;
 }

return domain;
}

AvailabilityDomainOrIdentifier
AvailabilityDomainOrIdentifier::copy(ASTContext &ctx) const {
if (auto identifier = getAsIdentifier())
return ctx.getIdentifier(identifier->str());

DEBUG_ASSERT(isDomain());
returngetAsDomain()->copy(ctx);
}

voidAvailabilityDomainOrIdentifier::print(llvm::raw_ostream &os) const {
if (auto identifier = getAsIdentifier())
 os << identifier->str();
else
getAsDomain()->print(os);
}