Serialization: Skip patterns with invalid types.

Prevents a crash during module emission with `-enable-lazy-typechecking` when
the type of a `Pattern` cannot be resolved.

Author: tshortli

include/swift/AST/DiagnosticsSema.def

@@ -814,6 +814,9 @@ REMARK(serialization_skipped_invalid_decl,none,
 REMARK(serialization_skipped_invalid_type,none,
        "serialization skipped for invalid type %0",
        (TypeRepr *))
+REMARK(serialization_skipped_invalid_type_unknown_name,none,
+       "serialization skipped for invalid type",
+       ())
 ERROR(serialization_failed,none,
       "serialization of module %0 failed due to the errors above",
       (const ModuleDecl *))

lib/Serialization/Serialization.cpp

@@ -3659,27 +3659,37 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
     }
     case PatternKind::Named: {
       auto named = cast<NamedPattern>(pattern);
+      auto ty = getPatternType();
+      if (S.skipTypeIfInvalid(ty, named->getLoc()))
+        break;
 
       unsigned abbrCode = S.DeclTypeAbbrCodes[NamedPatternLayout::Code];
       NamedPatternLayout::emitRecord(S.Out, S.ScratchRecord, abbrCode,
                                      S.addDeclRef(named->getDecl()),
-                                     S.addTypeRef(getPatternType()));
+                                     S.addTypeRef(ty));
       break;
     }
     case PatternKind::Any: {
+      auto ty = getPatternType();
+      if (S.skipTypeIfInvalid(ty, pattern->getLoc()))
+        break;
+
       unsigned abbrCode = S.DeclTypeAbbrCodes[AnyPatternLayout::Code];
       auto anyPattern = cast<AnyPattern>(pattern);
       AnyPatternLayout::emitRecord(S.Out, S.ScratchRecord, abbrCode,
-                                   S.addTypeRef(getPatternType()),
+                                   S.addTypeRef(ty),
                                    anyPattern->isAsyncLet());
       break;
     }
     case PatternKind::Typed: {
       auto typed = cast<TypedPattern>(pattern);
+      auto ty = getPatternType();
+      if (S.skipTypeIfInvalid(ty, typed->getTypeRepr()))
+        break;
 
       unsigned abbrCode = S.DeclTypeAbbrCodes[TypedPatternLayout::Code];
       TypedPatternLayout::emitRecord(S.Out, S.ScratchRecord, abbrCode,
-                                     S.addTypeRef(getPatternType()));
+                                     S.addTypeRef(ty));
       writePattern(typed->getSubPattern());
       break;
     }
@@ -6813,7 +6823,7 @@ bool Serializer::skipDeclIfInvalid(const Decl *decl) {
 }
 
 bool Serializer::skipTypeIfInvalid(Type ty, TypeRepr *tyRepr) {
-  if (ty || allowCompilerErrors())
+  if ((ty && !ty->hasError()) || allowCompilerErrors())
     return false;
 
   if (Options.EnableSerializationRemarks) {
@@ -6825,6 +6835,19 @@ bool Serializer::skipTypeIfInvalid(Type ty, TypeRepr *tyRepr) {
   return true;
 }
 
+bool Serializer::skipTypeIfInvalid(Type ty, SourceLoc loc) {
+  if ((ty && !ty->hasError()) || allowCompilerErrors())
+    return false;
+
+  if (Options.EnableSerializationRemarks) {
+    getASTContext().Diags.diagnose(
+        loc, diag::serialization_skipped_invalid_type_unknown_name);
+  }
+
+  hadError = true;
+  return true;
+}
+
 void serialization::writeToStream(
     raw_ostream &os, ModuleOrSourceFile DC, const SILModule *M,
     const SerializationOptions &options,

lib/Serialization/Serialization.h

@@ -583,6 +583,10 @@ class Serializer : public SerializerBase {
   /// If the type is invalid, records that an error occurred and returns
   /// true if the type should be skipped.
   bool skipTypeIfInvalid(Type ty, TypeRepr *tyRepr);
+
+  /// If the type is invalid, records that an error occurred and returns
+  /// true if the type should be skipped.
+  bool skipTypeIfInvalid(Type ty, SourceLoc loc);
 };
 
 } // end namespace serialization

test/Serialization/lazy-typecheck-errors.swift

@@ -20,3 +20,15 @@ public func takesInvalidType(_ x: InvalidType) {}
 @InvalidCustomAttr public struct HasInvalidCustomAttr {}
 // FIXME: An error should be emitted for the invalid attribute
 // expected-serialization-remark@-2 {{serialization skipped for invalid type 'InvalidCustomAttr'}}
+
+public var varWithExplicitInvalidType: InvalidType
+// expected-error@-1 {{cannot find type 'InvalidType' in scope}}
+// expected-serialization-remark@-2 {{serialization skipped invalid var 'varWithExplicitInvalidType'}}
+// expected-serialization-remark@-3 {{serialization skipped for invalid type 'InvalidType'}}
+
+public var varWithImplicitInvalidType = (1 as InvalidType)
+// expected-error@-1 {{cannot find type 'InvalidType' in scope}}
+// expected-serialization-remark@-2 {{serialization skipped invalid var 'varWithImplicitInvalidType'}}
+// expected-serialization-remark@-3 {{serialization skipped for invalid type}}
+
+public var _: InvalidType