Merge pull request #71612 from eeckstein/function-type-mismatch-error

Deserializer: better error message if types of referenced functions don't match

Author: eeckstein

include/swift/AST/DiagnosticsSIL.def

@@ -126,6 +126,10 @@ ERROR(function_type_mismatch,none,
 NOTE(function_declared_here,none,
      "function declared here", ())
 
+ERROR(deserialize_function_type_mismatch,Fatal,
+      "type mismatch of function '%0', declared as %1 but used in a swift module as %2",
+      (StringRef, Type, Type))
+
 // Capture before declaration diagnostics.
 ERROR(capture_before_declaration,none,
       "closure captures %0 before it is declared", (Identifier))

lib/Serialization/DeserializeSIL.cpp

@@ -20,6 +20,7 @@
 #include "SILFormat.h"
 #include "SILSerializationFunctionBuilder.h"
 
+#include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/ProtocolConformance.h"
@@ -392,7 +393,8 @@ SILDeserializer::getSILDifferentiabilityWitnessForReference(
 
 /// Helper function to find a SILFunction, given its name and type.
 SILFunction *SILDeserializer::getFuncForReference(StringRef name,
-                                                  SILType type) {
+                                                  SILType type,
+                                                  TypeExpansionContext context) {
   // Check to see if we have a function by this name already.
   SILFunction *fn = SILMod.lookUpFunction(name);
   if (!fn) {
@@ -410,11 +412,27 @@ SILFunction *SILDeserializer::getFuncForReference(StringRef name,
     }
   }
 
-  // FIXME: check for matching types.
-
   // At this point, if fn is set, we know that we have a good function to use.
-  if (fn)
+  if (fn) {
+    SILType fnType = fn->getLoweredTypeInContext(context);
+    if (fnType != type &&
+        // It can happen that opaque return types cause a mismatch when merging
+        // modules, without causing any further assertion failures.
+        // TODO: fix the underlying problem
+        fnType.hasOpaqueArchetype() == type.hasOpaqueArchetype()) {
+      StringRef fnName = fn->getName();
+      if (auto *dc = fn->getDeclContext()) {
+        if (auto *decl = dyn_cast_or_null<AbstractFunctionDecl>(dc->getAsDecl()))
+          fnName = decl->getNameStr();
+      }
+      fn->getModule().getASTContext().Diags.diagnose(
+        fn->getLocation().getSourceLoc(),
+        diag::deserialize_function_type_mismatch,
+        fnName, fnType.getASTType(), type.getASTType());
+      exit(1);
+    }
     return fn;
+  }
 
   // Otherwise, create a function declaration with the right type and a bogus
   // source location. This ensures that we can at least parse the rest of the
@@ -1969,7 +1987,8 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     ResultInst = Builder.createFunctionRef(
         Loc,
         getFuncForReference(
-            FuncName, getSILType(Ty, (SILValueCategory)TyCategory, nullptr)));
+            FuncName, getSILType(Ty, (SILValueCategory)TyCategory, nullptr),
+            Builder.getTypeExpansionContext()));
     break;
   }
   case SILInstructionKind::DynamicFunctionRefInst: {
@@ -1978,7 +1997,8 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     ResultInst = Builder.createDynamicFunctionRef(
         Loc,
         getFuncForReference(
-            FuncName, getSILType(Ty, (SILValueCategory)TyCategory, nullptr)));
+            FuncName, getSILType(Ty, (SILValueCategory)TyCategory, nullptr),
+            Builder.getTypeExpansionContext()));
     break;
   }
   case SILInstructionKind::PreviousDynamicFunctionRefInst: {
@@ -1987,7 +2007,8 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
     ResultInst = Builder.createPreviousDynamicFunctionRef(
         Loc,
         getFuncForReference(
-            FuncName, getSILType(Ty, (SILValueCategory)TyCategory, nullptr)));
+            FuncName, getSILType(Ty, (SILValueCategory)TyCategory, nullptr),
+            Builder.getTypeExpansionContext()));
     break;
   }
   case SILInstructionKind::MarkDependenceInst: {

lib/Serialization/DeserializeSIL.h

@@ -142,7 +142,7 @@ namespace swift {
     SILDifferentiabilityWitness *
     getSILDifferentiabilityWitnessForReference(StringRef mangledKey);
 
-    SILFunction *getFuncForReference(StringRef Name, SILType Ty);
+    SILFunction *getFuncForReference(StringRef Name, SILType Ty, TypeExpansionContext context);
     SILFunction *getFuncForReference(StringRef Name);
     SILVTable *readVTable(serialization::DeclID);
     SILMoveOnlyDeinit *readMoveOnlyDeinit(serialization::DeclID);