Merge pull request #34472 from bnbarham/benb/allow-errors-69815975

[Serialization] Add an option to output modules regardless of errors

Author: bnbarham

include/swift/Basic/LangOptions.h

@@ -367,6 +367,10 @@ namespace swift {
     /// TODO: remove this when @_implementationOnly modules are robust enough.
     bool AllowDeserializingImplementationOnly = false;
 
+    // Allow errors during module generation. See corresponding option in
+    // FrontendOptions.
+    bool AllowModuleWithCompilerErrors = false;
+
     /// Sets the target we are building for and updates platform conditions
     /// to match.
     ///

include/swift/Frontend/FrontendOptions.h

@@ -290,6 +290,12 @@ class FrontendOptions {
   /// any merge-modules jobs.
   bool EnableExperimentalCrossModuleIncrementalBuild = false;
 
+  /// Best effort to output a .swiftmodule regardless of any compilation
+  /// errors. SIL generation and serialization is skipped entirely when there
+  /// are errors. The resulting serialized AST may include errors types and
+  /// skip nodes entirely, depending on the errors involved.
+  bool AllowModuleWithCompilerErrors = false;
+
   /// The different modes for validating TBD against the LLVM IR.
   enum class TBDValidationMode {
     Default,        ///< Do the default validation for the current platform.

include/swift/Option/FrontendOptions.td

@@ -779,4 +779,9 @@ def experimental_skip_all_function_bodies:
   Flag<["-"], "experimental-skip-all-function-bodies">,
   HelpText<"Skip type-checking function bodies and all SIL generation">;
 
+def experimental_allow_module_with_compiler_errors:
+  Flag<["-"], "experimental-allow-module-with-compiler-errors">,
+  Flags<[HelpHidden]>,
+  HelpText<"Attempt to output .swiftmodule, regardless of compilation errors">;
+
 } // end let Flags = [FrontendOption, NoDriverOption, HelpHidden]

include/swift/Serialization/Validation.h

@@ -98,7 +98,8 @@ class ExtendedValidationInfo {
     unsigned IsSIB : 1;
     unsigned IsTestable : 1;
     unsigned ResilienceStrategy : 2;
-    unsigned IsImplicitDynamicEnabled: 1;
+    unsigned IsImplicitDynamicEnabled : 1;
+    unsigned IsAllowModuleWithCompilerErrorsEnabled : 1;
   } Bits;
 public:
   ExtendedValidationInfo() : Bits() {}
@@ -138,6 +139,12 @@ class ExtendedValidationInfo {
   void setResilienceStrategy(ResilienceStrategy resilience) {
     Bits.ResilienceStrategy = unsigned(resilience);
   }
+  bool isAllowModuleWithCompilerErrorsEnabled() {
+    return Bits.IsAllowModuleWithCompilerErrorsEnabled;
+  }
+  void setAllowModuleWithCompilerErrorsEnabled(bool val) {
+    Bits.IsAllowModuleWithCompilerErrorsEnabled = val;
+  }
 };
 
 /// Returns info about the serialized AST in the given data.

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -214,6 +214,7 @@ bool ArgsToFrontendOptionsConverter::convert(
   Opts.EnableIncrementalDependencyVerifier |= Args.hasArg(OPT_verify_incremental_dependencies);
   Opts.UseSharedResourceFolder = !Args.hasArg(OPT_use_static_resource_dir);
   Opts.DisableBuildingInterface = Args.hasArg(OPT_disable_building_interface);
+  Opts.AllowModuleWithCompilerErrors = Args.hasArg(OPT_experimental_allow_module_with_compiler_errors);
 
   computeImportObjCHeaderOptions();
   computeImplicitImportModuleNames(OPT_import_module, /*isTestable=*/false);

lib/Frontend/CompilerInvocation.cpp

@@ -683,6 +683,10 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     Opts.DisableAvailabilityChecking = true;
   }
 
+  if (FrontendOpts.AllowModuleWithCompilerErrors) {
+    Opts.AllowModuleWithCompilerErrors = true;
+  }
+
   return HadError || UnsupportedOS || UnsupportedArch;
 }
 

lib/Frontend/Frontend.cpp

@@ -1153,7 +1153,8 @@ static void countStatsPostSILOpt(UnifiedStatsReporter &Stats,
 }
 
 bool CompilerInstance::performSILProcessing(SILModule *silModule) {
-  if (performMandatorySILPasses(Invocation, silModule))
+  if (performMandatorySILPasses(Invocation, silModule) &&
+      !Invocation.getFrontendOptions().AllowModuleWithCompilerErrors)
     return true;
 
   {

lib/FrontendTool/FrontendTool.cpp

@@ -1787,11 +1787,13 @@ static void performEndOfPipelineActions(CompilerInstance &Instance) {
     assert(ctx.getLoadedModules().begin()->second == Instance.getMainModule());
   }
 
-  // Verify the AST for all the modules we've loaded.
-  ctx.verifyAllLoadedModules();
+  if (!opts.AllowModuleWithCompilerErrors) {
+    // Verify the AST for all the modules we've loaded.
+    ctx.verifyAllLoadedModules();
 
-  // Verify generic signatures if we've been asked to.
-  verifyGenericSignaturesIfNeeded(Invocation, ctx);
+    // Verify generic signatures if we've been asked to.
+    verifyGenericSignaturesIfNeeded(Invocation, ctx);
+  }
 
   // Emit any additional outputs that we only need for a successful compilation.
   // We don't want to unnecessarily delay getting any errors back to the user.
@@ -1913,7 +1915,8 @@ withSemanticAnalysis(CompilerInstance &Instance, FrontendObserver *observer,
 
   (void)migrator::updateCodeAndEmitRemapIfNeeded(&Instance);
 
-  if (Instance.getASTContext().hadError())
+  if (Instance.getASTContext().hadError() &&
+      !opts.AllowModuleWithCompilerErrors)
     return true;
 
   return cont(Instance);
@@ -2096,7 +2099,8 @@ static bool performCompile(CompilerInstance &Instance,
   if (Instance.hasASTContext() &&
       FrontendOptions::doesActionPerformEndOfPipelineActions(Action)) {
     performEndOfPipelineActions(Instance);
-    hadError |= Instance.getASTContext().hadError();
+    if (!opts.AllowModuleWithCompilerErrors)
+      hadError |= Instance.getASTContext().hadError();
   }
   return hadError;
 }
@@ -2382,7 +2386,7 @@ static bool performCompileStepsPostSILGen(CompilerInstance &Instance,
   if (PSPs.haveModuleOrModuleDocOutputPaths()) {
     if (Action == FrontendOptions::ActionType::MergeModules ||
         Action == FrontendOptions::ActionType::EmitModuleOnly) {
-      return Context.hadError();
+      return Context.hadError() && !opts.AllowModuleWithCompilerErrors;
     }
   }
 
@@ -2400,7 +2404,7 @@ static bool performCompileStepsPostSILGen(CompilerInstance &Instance,
 
   // Check if we had any errors; if we did, don't proceed to IRGen.
   if (Context.hadError())
-    return true;
+    return !opts.AllowModuleWithCompilerErrors;
 
   runSILLoweringPasses(*SM);
 

lib/SILGen/SILGen.cpp

@@ -1952,6 +1952,11 @@ ASTLoweringRequest::evaluate(Evaluator &evaluator,
   if (desc.opts.SkipFunctionBodies == FunctionBodySkipping::All)
     return silMod;
 
+  // Skip emitting SIL if there's been any compilation errors
+  if (silMod->getASTContext().hadError() &&
+      silMod->getASTContext().LangOpts.AllowModuleWithCompilerErrors)
+    return silMod;
+
   SILGenModuleRAII scope(*silMod);
 
   // Emit a specific set of SILDeclRefs if needed.

lib/Sema/TypeCheckStorage.cpp

@@ -2308,6 +2308,8 @@ IsAccessorTransparentRequest::evaluate(Evaluator &evaluator,
       // Anything else should not have a synthesized setter.
       LLVM_FALLTHROUGH;
     case WriteImplKind::Immutable:
+      if (accessor->getASTContext().LangOpts.AllowModuleWithCompilerErrors)
+        return false;
       llvm_unreachable("should not be synthesizing accessor in this case");
 
     case WriteImplKind::StoredWithObservers:

lib/Serialization/DeclTypeRecordNodes.def

@@ -109,6 +109,8 @@ TYPE(SIL_BLOCK_STORAGE)
 TYPE(SIL_BOX)
 TYPE(NAME_ALIAS)
 
+TYPE(ERROR)
+
 FIRST_DECL(TYPE_ALIAS, 60)
 DECL(GENERIC_TYPE_PARAM)
 DECL(ASSOCIATED_TYPE)

lib/Serialization/Deserialization.cpp

@@ -2955,7 +2955,7 @@ class DeclDeserializer {
     declOrOffset = param;
 
     auto paramTy = MF.getType(interfaceTypeID);
-    if (paramTy->hasError()) {
+    if (paramTy->hasError() && !MF.isAllowModuleWithCompilerErrorsEnabled()) {
       // FIXME: This should never happen, because we don't serialize
       // error types.
       DC->printContext(llvm::errs());
@@ -5670,6 +5670,23 @@ class TypeDeserializer {
 
     return UnboundGenericType::get(genericDecl, parentTy, ctx);
   }
+
+  Expected<Type> deserializeErrorType(ArrayRef<uint64_t> scratch,
+                                      StringRef blobData) {
+    if (!MF.isAllowModuleWithCompilerErrorsEnabled())
+      MF.fatal();
+
+    TypeID origID;
+    decls_block::ErrorTypeLayout::readRecord(scratch, origID);
+
+    auto origTy = MF.getTypeChecked(origID);
+    if (!origTy)
+      return origTy.takeError();
+
+    if (!origTy.get())
+      return ErrorType::get(ctx);
+    return ErrorType::get(origTy.get());
+  }
 };
 }
 
@@ -5693,7 +5710,8 @@ Expected<Type> ModuleFile::getTypeChecked(TypeID TID) {
 
 #ifndef NDEBUG
   PrettyStackTraceType trace(getContext(), "deserializing", typeOrOffset.get());
-  if (typeOrOffset.get()->hasError()) {
+  if (typeOrOffset.get()->hasError() &&
+      !isAllowModuleWithCompilerErrorsEnabled()) {
     typeOrOffset.get()->dump(llvm::errs());
     llvm_unreachable("deserialization produced an invalid type "
                      "(rdar://problem/30382791)");
@@ -5753,6 +5771,7 @@ Expected<Type> TypeDeserializer::getTypeCheckedImpl() {
   CASE(Dictionary)
   CASE(Optional)
   CASE(UnboundGeneric)
+  CASE(Error)
 
 #undef CASE
 

lib/Serialization/ModuleFile.h

@@ -465,6 +465,12 @@ class ModuleFile
     return Core->Bits.IsImplicitDynamicEnabled;
   }
 
+  /// Whether this module is compiled while allowing errors
+  /// ('-experimental-allow-module-with-compiler-errors').
+  bool isAllowModuleWithCompilerErrorsEnabled() const {
+    return Core->Bits.IsAllowModuleWithCompilerErrorsEnabled;
+  }
+
   /// \c true if this module has incremental dependency information.
   bool hasIncrementalInfo() const { return Core->hasIncrementalInfo(); }
 

lib/Serialization/ModuleFileSharedCore.cpp

@@ -145,6 +145,9 @@ static bool readOptionsBlock(llvm::BitstreamCursor &cursor,
       options_block::ResilienceStrategyLayout::readRecord(scratch, Strategy);
       extendedInfo.setResilienceStrategy(ResilienceStrategy(Strategy));
       break;
+    case options_block::IS_ALLOW_MODULE_WITH_COMPILER_ERRORS_ENABLED:
+      extendedInfo.setAllowModuleWithCompilerErrorsEnabled(true);
+      break;
     default:
       // Unknown options record, possibly for use by a future version of the
       // module format.
@@ -1150,6 +1153,8 @@ ModuleFileSharedCore::ModuleFileSharedCore(
       Bits.IsTestable = extInfo.isTestable();
       Bits.ResilienceStrategy = unsigned(extInfo.getResilienceStrategy());
       Bits.IsImplicitDynamicEnabled = extInfo.isImplicitDynamicEnabled();
+      Bits.IsAllowModuleWithCompilerErrorsEnabled =
+          extInfo.isAllowModuleWithCompilerErrorsEnabled();
       MiscVersion = info.miscVersion;
 
       hasValidControlBlock = true;

lib/Serialization/ModuleFileSharedCore.h

@@ -320,8 +320,11 @@ class ModuleFileSharedCore {
     /// Whether this module is compiled with implicit dynamic.
     unsigned IsImplicitDynamicEnabled: 1;
 
+    /// Whether this module is compiled while allowing errors.
+    unsigned IsAllowModuleWithCompilerErrorsEnabled: 1;
+
     // Explicitly pad out to the next word boundary.
-    unsigned : 0;
+    unsigned : 3;
   } Bits = {};
   static_assert(sizeof(ModuleBits) <= 8, "The bit set should be small");
 

lib/Serialization/ModuleFormat.h

@@ -56,7 +56,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 585; // hop_to_executor instruction
+const uint16_t SWIFTMODULE_VERSION_MINOR = 586; // allow errors in modules
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -787,7 +787,8 @@ namespace options_block {
     IS_TESTABLE,
     RESILIENCE_STRATEGY,
     ARE_PRIVATE_IMPORTS_ENABLED,
-    IS_IMPLICIT_DYNAMIC_ENABLED
+    IS_IMPLICIT_DYNAMIC_ENABLED,
+    IS_ALLOW_MODULE_WITH_COMPILER_ERRORS_ENABLED
   };
 
   using SDKPathLayout = BCRecordLayout<
@@ -821,6 +822,10 @@ namespace options_block {
     RESILIENCE_STRATEGY,
     BCFixed<2>
   >;
+
+  using IsAllowModuleWithCompilerErrorsEnabledLayout = BCRecordLayout<
+    IS_ALLOW_MODULE_WITH_COMPILER_ERRORS_ENABLED
+  >;
 }
 
 /// The record types within the input block.
@@ -919,6 +924,12 @@ namespace decls_block {
     BCArray<BCVBR<6>>
   >;
 
+  /// A placeholder for invalid types
+  using ErrorTypeLayout = BCRecordLayout<
+    ERROR_TYPE,
+    TypeIDField // original type (if any)
+  >;
+
   using BuiltinAliasTypeLayout = BCRecordLayout<
     BUILTIN_ALIAS_TYPE,
     DeclIDField, // typealias decl