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

Adds a new frontend option
"-experimental-allow-module-with-compiler-errors". If any compilation
errors occur while generating the .swiftmodule, this mode will skip SIL
entirely and only serialize the (likey invalid) AST.

This existence of this option during generation is serialized into the
resulting .swiftmodule. Errors found in deserialization are only allowed
if it is set.

Primarily intended for IDE requests (eg. indexing and code completion)
to ensure robust cross-module results, despite possible errors.

Resolves rdar://69815975

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

@@ -289,6 +289,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

@@ -1142,7 +1142,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

@@ -1786,11 +1786,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.
@@ -1867,7 +1869,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);
@@ -2048,7 +2051,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;
 }
@@ -2334,7 +2338,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;
     }
   }
 
@@ -2352,7 +2356,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