[Sema] Report importing modules built from a swiftinterface without resilience

Generating a swiftinterface for a module without library-evolution is
not currently a recommended configuration, and it leads to a warning at
building the module. We’re now considering generating more
swiftinterface even without library evolution as the swiftinterface can
be useful for documentation tools. However, while we can build against
such a swiftinterface we shouldn’t expect the executable to work
reliably.

This PR adds the infrastructure necessary to detect when we’re importing
a module from a swiftinterface without it having enabled
library-evoluation. It is reported as an error which can be downgraded
to a warning with an env var. Compiler engineers may still want a full
build even if the binary is unusable.

rdar://101637436

Author: xymus

include/swift/AST/DiagnosticsSema.def

@@ -984,6 +984,11 @@ WARNING(module_not_compiled_with_library_evolution,none,
         "using it means binary compatibility for %1 can't be guaranteed",
         (Identifier, Identifier))
 
+ERROR(import_not_compiled_with_library_evolution_but_rebuilt,none,
+      "module %0 was rebuilt from its swiftinterface but not compiled with "
+      "library evolution support; execution will be unreliable",
+      (Identifier))
+
 REMARK(cross_import_added,none,
        "import of %0 and %1 triggered a cross-import of %2",
        (Identifier, Identifier, Identifier))

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1913,24 +1913,26 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
   void visitImportDecl(ImportDecl *ID) {
     TypeChecker::checkDeclAttributes(ID);
+    ModuleDecl *importTarget = ID->getModule();
+    if (!importTarget)
+      return;
 
     // Force the lookup of decls referenced by a scoped import in case it emits
     // diagnostics.
     (void)ID->getDecls();
 
     // Report the public import of a private module.
     if (ID->getASTContext().LangOpts.LibraryLevel == LibraryLevel::API) {
-      auto target = ID->getModule();
       auto importer = ID->getModuleContext();
-      if (target &&
+      if (importTarget &&
           !ID->getAttrs().hasAttribute<ImplementationOnlyAttr>() &&
           !ID->getAttrs().hasAttribute<SPIOnlyAttr>() &&
-          target->getLibraryLevel() == LibraryLevel::SPI) {
+          importTarget->getLibraryLevel() == LibraryLevel::SPI) {
 
         auto &diags = ID->getASTContext().Diags;
         InFlightDiagnostic inFlight =
             diags.diagnose(ID, diag::error_public_import_of_private_module,
-                           target->getName(), importer->getName());
+                           importTarget->getName(), importer->getName());
         if (ID->getAttrs().isEmpty()) {
            inFlight.fixItInsert(ID->getStartLoc(),
                               "@_implementationOnly ");
@@ -1942,7 +1944,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         static bool enableTreatAsError = getenv("ENABLE_PUBLIC_IMPORT_OF_PRIVATE_AS_ERROR");
 #endif
 
-        bool isImportOfUnderlying = importer->getName() == target->getName();
+        bool isImportOfUnderlying = importer->getName() ==
+                                    importTarget->getName();
         auto *SF = ID->getDeclContext()->getParentSourceFile();
         bool treatAsError = enableTreatAsError &&
                             !isImportOfUnderlying &&
@@ -1951,6 +1954,21 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
           inFlight.limitBehavior(DiagnosticBehavior::Warning);
       }
     }
+
+    // Report imports of non-resilient modules built from a module interface.
+    if (importTarget->isBuiltFromInterface() &&
+        importTarget->getResilienceStrategy() != ResilienceStrategy::Resilient) {
+      auto &diags = ID->getASTContext().Diags;
+      auto inFlight =
+        diags.diagnose(ID,
+                       diag::import_not_compiled_with_library_evolution_but_rebuilt,
+                       importTarget->getName());
+
+      static const char* acceptNonResilientInterfaes =
+        ::getenv("SWIFT_ACCEPT_NON_RESILIENT_INTERFACES");
+      if (acceptNonResilientInterfaes)
+        inFlight.limitBehavior(DiagnosticBehavior::Warning);
+    }
   }
 
   void visitOperatorDecl(OperatorDecl *OD) {

test/ModuleInterface/non-resilient-swiftinterface-loading.swift

@@ -0,0 +1,59 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// RUN: %target-swift-frontend -emit-module %t/NonResilientLib.swift \
+// RUN:   -module-name NonResilientLib -swift-version 5 \
+// RUN:   -emit-module-path %t/NonResilientLib.swiftmodule \
+// RUN:   -emit-module-interface-path %t/NonResilientLib.swiftinterface 2>&1 \
+// RUN:   | grep "warning: module interfaces are only supported with -enable-library-evolution"
+
+// RUN: %target-swift-frontend -emit-module %t/ResilientLib.swift \
+// RUN:   -module-name ResilientLib -swift-version 5 \
+// RUN:   -enable-library-evolution \
+// RUN:   -emit-module-path %t/ResilientLib.swiftmodule \
+// RUN:   -emit-module-interface-path %t/ResilientLib.swiftinterface
+
+/// Expecting no diagnostics when importing the swiftmodule.
+// RUN: %target-swift-frontend -typecheck %t/ClientClean.swift \
+// RUN:   -swift-version 5 -I %t -verify
+
+/// Expecting diagnostics when importing the non-resilient swiftinterface.
+// RUN: rm %t/*.swiftmodule
+// RUN: %target-swift-frontend -typecheck %t/ClientError.swift \
+// RUN:   -swift-version 5 -I %t -verify
+
+// RUN: env SWIFT_ACCEPT_NON_RESILIENT_INTERFACES=1 \
+// RUN:   %target-swift-frontend -typecheck %t/ClientWarning.swift \
+// RUN:   -swift-version 5 -I %t -verify
+
+//--- NonResilientLib.swift
+
+public func NonResilientFunc() {}
+
+//--- ResilientLib.swift
+
+public func ResilientFunc() {}
+
+//--- ClientClean.swift
+
+import NonResilientLib
+import ResilientLib
+
+NonResilientFunc()
+ResilientFunc()
+
+//--- ClientError.swift
+
+import NonResilientLib // expected-error {{module 'NonResilientLib' was rebuilt from its swiftinterface but not compiled with library evolution support; execution will be unreliable}}
+import ResilientLib
+
+NonResilientFunc()
+ResilientFunc()
+
+//--- ClientWarning.swift
+
+import NonResilientLib // expected-warning {{module 'NonResilientLib' was rebuilt from its swiftinterface but not compiled with library evolution support; execution will be unreliable}}
+import ResilientLib
+
+NonResilientFunc()
+ResilientFunc()