Merge pull request #60317 from tshortli/diagnose-typealias-desugars-to-non-publicly-imported-type

Sema: Diagnose when typealiases used in public declarations would desugar to types from non-public imports

Author: tshortli

include/swift/AST/DiagnosticsSema.def

@@ -2916,6 +2916,17 @@ WARNING(decl_from_hidden_module_warn,none,
       "<<ERROR>>|<<ERROR>>|"
       "%3 was not imported by this file}4",
       (DescriptiveDeclKind, DeclName, unsigned, Identifier, unsigned))
+ERROR(typealias_desugars_to_type_from_hidden_module,none,
+      "%0 aliases '%1.%2' and cannot be used %select{here|"
+      "as property wrapper here|"
+      "as result builder here|"
+      "in an extension with public or '@usableFromInline' members|"
+      "in an extension with conditional conformances}3 "
+      "because %select{%4 has been imported as implementation-only|"
+      "it is an SPI imported from %4|"
+      "<<ERROR>>|"
+      "%4 was not imported by this file}5",
+      (DeclName, StringRef, StringRef, unsigned, Identifier, unsigned))
 ERROR(conformance_from_implementation_only_module,none,
       "cannot use conformance of %0 to %1 %select{here|as property wrapper here|"
       "as result builder here|"
@@ -5805,6 +5816,14 @@ WARNING(inlinable_decl_ref_from_hidden_module_warn,
       "; this is an error in Swift 6",
       (DescriptiveDeclKind, DeclName, unsigned, Identifier, unsigned))
 
+ERROR(inlinable_typealias_desugars_to_type_from_hidden_module,
+      none, "%0 aliases '%1.%2' and cannot be used in " FRAGILE_FUNC_KIND "3 "
+      "because %select{%4 has been imported as implementation-only|"
+      "it is an SPI imported from %4|"
+      "<<ERROR>>|"
+      "%4 was not imported by this file}5",
+      (DeclName, StringRef, StringRef, unsigned, Identifier, unsigned))
+
 ERROR(availability_macro_in_inlinable, none,
       "availability macro cannot be used in " FRAGILE_FUNC_KIND "0",
       (unsigned))

lib/Sema/ResilienceDiagnostics.cpp

@@ -106,20 +106,52 @@ bool TypeChecker::diagnoseInlinableDeclRefAccess(SourceLoc loc,
   return (downgradeToWarning == DowngradeToWarning::No);
 }
 
-bool
-TypeChecker::diagnoseDeclRefExportability(SourceLoc loc,
-                                          const ValueDecl *D,
-                                          const ExportContext &where) {
-  // Accessors cannot have exportability that's different than the storage,
-  // so skip them for now.
-  if (isa<AccessorDecl>(D))
+static bool diagnoseTypeAliasDeclRefExportability(SourceLoc loc,
+                                                  const TypeAliasDecl *TAD,
+                                                  const ExportContext &where) {
+  assert(where.mustOnlyReferenceExportedDecls());
+
+  auto *D = TAD->getUnderlyingType()->getAnyNominal();
+  if (!D)
     return false;
 
-  if (!where.mustOnlyReferenceExportedDecls())
+  auto ignoredDowngradeToWarning = DowngradeToWarning::No;
+  auto originKind =
+      getDisallowedOriginKind(D, where, ignoredDowngradeToWarning);
+  if (originKind == DisallowedOriginKind::None)
     return false;
 
   auto definingModule = D->getModuleContext();
+  ASTContext &ctx = definingModule->getASTContext();
+  auto fragileKind = where.getFragileFunctionKind();
+
+  if (fragileKind.kind == FragileFunctionKind::None) {
+    auto reason = where.getExportabilityReason();
+    ctx.Diags
+        .diagnose(loc, diag::typealias_desugars_to_type_from_hidden_module,
+                  TAD->getName(), definingModule->getNameStr(), D->getNameStr(),
+                  static_cast<unsigned>(*reason), definingModule->getName(),
+                  static_cast<unsigned>(originKind))
+        .warnUntilSwiftVersion(6);
+  } else {
+    ctx.Diags
+        .diagnose(loc,
+                  diag::inlinable_typealias_desugars_to_type_from_hidden_module,
+                  TAD->getName(), definingModule->getNameStr(), D->getNameStr(),
+                  fragileKind.getSelector(), definingModule->getName(),
+                  static_cast<unsigned>(originKind))
+        .warnUntilSwiftVersion(6);
+  }
+  D->diagnose(diag::kind_declared_here, DescriptiveDeclKind::Type);
+
+  return true;
+}
+
+static bool diagnoseValueDeclRefExportability(SourceLoc loc, const ValueDecl *D,
+                                              const ExportContext &where) {
+  assert(where.mustOnlyReferenceExportedDecls());
 
+  auto definingModule = D->getModuleContext();
   auto downgradeToWarning = DowngradeToWarning::No;
 
   auto originKind = getDisallowedOriginKind(
@@ -162,6 +194,27 @@ TypeChecker::diagnoseDeclRefExportability(SourceLoc loc,
   return true;
 }
 
+bool TypeChecker::diagnoseDeclRefExportability(SourceLoc loc,
+                                               const ValueDecl *D,
+                                               const ExportContext &where) {
+  // Accessors cannot have exportability that's different than the storage,
+  // so skip them for now.
+  if (isa<AccessorDecl>(D))
+    return false;
+
+  if (!where.mustOnlyReferenceExportedDecls())
+    return false;
+
+  if (diagnoseValueDeclRefExportability(loc, D, where))
+    return true;
+
+  if (auto *TAD = dyn_cast<TypeAliasDecl>(D))
+    if (diagnoseTypeAliasDeclRefExportability(loc, TAD, where))
+      return true;
+
+  return false;
+}
+
 bool
 TypeChecker::diagnoseConformanceExportability(SourceLoc loc,
                                               const RootProtocolConformance *rootConf,

lib/Sema/TypeCheckAccess.h

@@ -32,12 +32,14 @@ class SourceFile;
 /// itself. Related checks may also be performed.
 void checkAccessControl(Decl *D);
 
-// Problematic origin of an exported type.
-//
-// This enum must be kept in sync with
-// diag::inlinable_decl_ref_from_hidden_module,
-// diag::decl_from_hidden_module and
-// diag::conformance_from_implementation_only_module.
+/// Problematic origin of an exported type.
+///
+/// This enum must be kept in sync with a number of diagnostics:
+///   diag::inlinable_decl_ref_from_hidden_module
+///   diag::decl_from_hidden_module
+///   diag::conformance_from_implementation_only_module
+///   diag::typealias_desugars_to_type_from_hidden_module
+///   daig::inlinable_typealias_desugars_to_type_from_hidden_module
 enum class DisallowedOriginKind : uint8_t {
   ImplementationOnly,
   SPIImported,

test/ModuleInterface/cross-module-typealias.swift

@@ -0,0 +1,35 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// RUN: %target-swift-emit-module-interface(%t/Original.swiftinterface) %t/Original.swift
+// RUN: %target-swift-typecheck-module-from-interface(%t/Original.swiftinterface)
+
+// RUN: %target-swift-emit-module-interface(%t/Aliases.swiftinterface) %t/Aliases.swift -I %t
+// RUN: %target-swift-typecheck-module-from-interface(%t/Aliases.swiftinterface) -I %t
+
+// RUN: %target-swift-frontend -typecheck -verify %t/UsesAliasesNoImport.swift -I %t -swift-version 6
+
+// REQUIRES: asserts
+
+// This test is a simplified version of implicit-import-typealias.swift that
+// verifies errors are emitted instead of warnings in Swift 6.
+
+//--- Original.swift
+
+open class Clazz {}
+
+
+//--- Aliases.swift
+
+import Original
+
+public typealias ClazzAlias = Clazz
+
+
+//--- UsesAliasesNoImport.swift
+
+import Aliases
+
+// expected-error@+1 {{'ClazzAlias' aliases 'Original.Clazz' and cannot be used here because 'Original' was not imported by this file}}
+public class InheritsFromClazzAlias: ClazzAlias {}
+