[Serialization] Drop functions whose types can't be imported.

This doesn't handle generic functions with problems in their
requirements, but it's a step.

Author: jrose-apple

lib/Serialization/Deserialization.cpp

@@ -2756,6 +2756,10 @@ ModuleFile::getDeclChecked(DeclID DID, Optional<DeclContext *> ForcedContext) {
       return llvm::make_error<OverrideError>(name);
     }
 
+    auto canonicalType = getTypeChecked(canonicalTypeID);
+    if (!canonicalType)
+      return llvm::make_error<TypeError>(name, takeErrorInfo(canonicalType.takeError()));
+
     auto DC = getDeclContext(contextID);
     if (declOrOffset.isComplete())
       return declOrOffset;
@@ -4021,9 +4025,15 @@ Expected<Type> ModuleFile::getTypeChecked(TypeID TID) {
     auto info = GenericFunctionType::ExtInfo(*rep, throws);
 
     auto sig = GenericSignature::get(genericParams, requirements);
-    typeOrOffset = GenericFunctionType::get(sig,
-                                            getType(inputID),
-                                            getType(resultID),
+
+    auto inputTy = getTypeChecked(inputID);
+    if (!inputTy)
+      return inputTy.takeError();
+    auto resultTy = getTypeChecked(resultID);
+    if (!resultTy)
+      return resultTy.takeError();
+
+    typeOrOffset = GenericFunctionType::get(sig, inputTy.get(), resultTy.get(),
                                             info);
     break;
   }

test/Serialization/Recovery/typedefs.swift

@@ -36,6 +36,9 @@ let _: Int32? = useAssoc(AnotherType.self)
 let _ = wrapped // expected-error {{use of unresolved identifier 'wrapped'}}
 let _ = unwrapped // okay
 
+_ = usesWrapped(nil) // expected-error {{use of unresolved identifier 'usesWrapped'}}
+_ = usesUnwrapped(nil) // expected-error {{nil is not compatible with expected argument type 'Int32'}}
+
 #endif // VERIFY
 
 #else // TEST
@@ -124,4 +127,19 @@ public var normalFirst: Int?, wrappedSecond: WrappedInt?
 // CHECK-RECOVERY-NEGATIVE-NOT: var wrappedFourth:
 public var wrappedThird, wrappedFourth: WrappedInt?
 
+// CHECK-DAG: func usesWrapped(_ wrapped: WrappedInt)
+// CHECK-RECOVERY-NEGATIVE-NOT: func usesWrapped(
+public func usesWrapped(_ wrapped: WrappedInt) {}
+// CHECK-DAG: func usesUnwrapped(_ unwrapped: UnwrappedInt)
+// CHECK-RECOVERY-DAG: func usesUnwrapped(_ unwrapped: Int32)
+public func usesUnwrapped(_ unwrapped: UnwrappedInt) {}
+
+// CHECK-DAG: func returnsWrapped() -> WrappedInt
+// CHECK-RECOVERY-NEGATIVE-NOT: func returnsWrapped(
+public func returnsWrapped() -> WrappedInt { fatalError() }
+
+// CHECK-DAG: func returnsWrappedGeneric<T>(_: T.Type) -> WrappedInt
+// CHECK-RECOVERY-NEGATIVE-NOT: func returnsWrappedGeneric
+public func returnsWrappedGeneric<T>(_: T.Type) -> WrappedInt { fatalError() }
+
 #endif // TEST