[AST] Update equality for ExtInfo to take Clang types into account.

varungandhi-apple · varungandhi-apple · commit 29188e3fe762 · 2020-07-31T13:55:55.000-07:00
In the future, we will remove the UseClangFunctionTypes language option, but we
temporarily need the scaffolding for equality checks to be consistent in all
places.
diff --git a/include/swift/AST/ExtInfo.h b/include/swift/AST/ExtInfo.h
@@ -66,6 +66,7 @@ class ClangTypeInfo {
   constexpr ClangTypeInfo() : type(nullptr) {}
   constexpr ClangTypeInfo(const clang::Type *type) : type(type) {}
 
+  friend bool operator==(ClangTypeInfo lhs, ClangTypeInfo rhs);
   ClangTypeInfo getCanonical() const;
 
 public:
@@ -345,7 +346,12 @@ class ASTExtInfoBuilder {
                              clangTypeInfo);
   }
 
-  std::pair<unsigned, const void *> getFuncAttrKey() const {
+  bool isEqualTo(ASTExtInfoBuilder other, bool useClangTypes) const {
+    return bits == other.bits &&
+      (useClangTypes ? (clangTypeInfo == other.clangTypeInfo) : true);
+  }
+
+  constexpr std::pair<unsigned, const void *> getFuncAttrKey() const {
     return std::make_pair(bits, clangTypeInfo.getType());
   }
 }; // end ASTExtInfoBuilder
@@ -430,11 +436,8 @@ class ASTExtInfo {
     return builder.withThrows(throws).build();
   }
 
-  bool operator==(ASTExtInfo other) const {
-    return builder.bits == other.builder.bits;
-  }
-  bool operator!=(ASTExtInfo other) const {
-    return builder.bits != other.builder.bits;
+  bool isEqualTo(ASTExtInfo other, bool useClangTypes) const {
+    return builder.isEqualTo(other.builder, useClangTypes);
   }
 
   constexpr std::pair<unsigned, const void *> getFuncAttrKey() const {
@@ -613,7 +616,12 @@ class SILExtInfoBuilder {
         clangTypeInfo);
   }
 
-  std::pair<unsigned, const void *> getFuncAttrKey() const {
+  bool isEqualTo(SILExtInfoBuilder other, bool useClangTypes) const {
+    return bits == other.bits &&
+           (useClangTypes ? (clangTypeInfo == other.clangTypeInfo) : true);
+  }
+
+  constexpr std::pair<unsigned, const void *> getFuncAttrKey() const {
     return std::make_pair(bits, clangTypeInfo.getType());
   }
 }; // end SILExtInfoBuilder
@@ -693,19 +701,24 @@ class SILExtInfo {
     return builder.withNoEscape(noEscape).build();
   }
 
-  bool operator==(SILExtInfo other) const {
-    return builder.bits == other.builder.bits;
-  }
-  bool operator!=(SILExtInfo other) const {
-    return builder.bits != other.builder.bits;
+  bool isEqualTo(SILExtInfo other, bool useClangTypes) const {
+    return builder.isEqualTo(other.builder, useClangTypes);
   }
 
-
   constexpr std::pair<unsigned, const void *> getFuncAttrKey() const {
     return builder.getFuncAttrKey();
   }
 };
 
+/// Helper function to obtain the useClangTypes parameter for checking equality
+/// of ExtInfos.
+///
+/// Typically, the argument will be a function type which was used to obtain one
+/// of the ExtInfos.
+template <typename HasContext> bool useClangTypes(HasContext hasContext) {
+  return hasContext->getASTContext().LangOpts.UseClangFunctionTypes;
+}
+
 } // end namespace swift
 
 #endif // SWIFT_EXTINFO_H
diff --git a/include/swift/AST/TypeDifferenceVisitor.h b/include/swift/AST/TypeDifferenceVisitor.h
@@ -214,7 +214,7 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {
 
   bool visitAnyFunctionType(CanAnyFunctionType type1,
                             CanAnyFunctionType type2) {
-    if (type1->getExtInfo() != type2->getExtInfo())
+    if (!type1->hasSameExtInfoAs(type2))
       return asImpl().visitDifferentTypeStructure(type1, type2);
 
     if (asImpl().visit(type1.getResult(), type2.getResult()))
@@ -242,10 +242,10 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {
 
   bool visitSILFunctionTypeStructure(CanSILFunctionType type1,
                                      CanSILFunctionType type2) {
-    if (type1->getExtInfo() != type2->getExtInfo() ||
+    if (!type1->hasSameExtInfoAs(type2) ||
         type1->getCoroutineKind() != type2->getCoroutineKind() ||
-        type1->getInvocationGenericSignature()
-          != type2->getInvocationGenericSignature())
+        type1->getInvocationGenericSignature() !=
+            type2->getInvocationGenericSignature())
       return asImpl().visitDifferentTypeStructure(type1, type2);
     return false;
   }
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -2932,6 +2932,8 @@ class AnyFunctionType : public TypeBase {
                                         : ClangTypeInfo());
   }
 
+  bool hasSameExtInfoAs(const AnyFunctionType *otherFn);
+
   /// Get the representation of the function type.
   Representation getRepresentation() const {
     return getExtInfo().getRepresentation();
@@ -4295,6 +4297,8 @@ class SILFunctionType final
 
   ClangTypeInfo getClangTypeInfo() const;
 
+  bool hasSameExtInfoAs(const SILFunctionType *otherFn);
+
   /// Given that `this` is a `@differentiable` or `@differentiable(linear)`
   /// function type, returns an `IndexSubset` corresponding to the
   /// differentiability/linearity parameters (e.g. all parameters except the
diff --git a/lib/AST/ExtInfo.cpp b/lib/AST/ExtInfo.cpp
@@ -23,6 +23,15 @@ namespace swift {
 
 // MARK: - ClangTypeInfo
 
+bool operator==(ClangTypeInfo lhs, ClangTypeInfo rhs) {
+  if (lhs.type == rhs.type)
+    return true;
+  if (lhs.type && rhs.type)
+    return lhs.type->getCanonicalTypeInternal() ==
+           rhs.type->getCanonicalTypeInternal();
+  return false;
+}
+
 ClangTypeInfo ClangTypeInfo::getCanonical() const {
   if (!type)
     return ClangTypeInfo();
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -1243,9 +1243,7 @@ CanType TypeBase::computeCanonicalType() {
     getCanonicalParams(funcTy, genericSig, canParams);
     auto resultTy = funcTy->getResult()->getCanonicalType(genericSig);
 
-    bool useClangFunctionType =
-      resultTy->getASTContext().LangOpts.UseClangFunctionTypes;
-    auto extInfo = funcTy->getCanonicalExtInfo(useClangFunctionType);
+    auto extInfo = funcTy->getCanonicalExtInfo(useClangTypes(resultTy));
     if (genericSig) {
       Result = GenericFunctionType::get(genericSig, canParams, resultTy,
                                         extInfo);
@@ -1783,7 +1781,7 @@ class IsBindableVisitor
   CanType visitFunctionType(FunctionType *func, CanType subst,
                             ArchetypeType*, ArrayRef<ProtocolConformanceRef>) {
     if (auto substFunc = dyn_cast<FunctionType>(subst)) {
-      if (func->getExtInfo() != substFunc->getExtInfo())
+      if (!func->hasSameExtInfoAs(substFunc))
         return CanType();
       
       if (func->getParams().size() != substFunc->getParams().size())
@@ -1822,7 +1820,7 @@ class IsBindableVisitor
   CanType visitSILFunctionType(SILFunctionType *func, CanType subst,
                              ArchetypeType*, ArrayRef<ProtocolConformanceRef>) {
     if (auto substFunc = dyn_cast<SILFunctionType>(subst)) {
-      if (func->getExtInfo() != substFunc->getExtInfo())
+      if (!func->hasSameExtInfoAs(substFunc))
         return CanType();
 
       if (func->getInvocationGenericSignature()
@@ -2618,7 +2616,7 @@ static bool matchesFunctionType(CanAnyFunctionType fn1, CanAnyFunctionType fn2,
     if (!ext2.isNoEscape())
       ext1 = ext1.withNoEscape(false);
   }
-  if (ext1 != ext2)
+  if (!ext1.isEqualTo(ext2, useClangTypes(fn1)))
     return false;
 
   return paramsAndResultMatch();
@@ -3427,11 +3425,19 @@ ClangTypeInfo AnyFunctionType::getCanonicalClangTypeInfo() const {
   return getClangTypeInfo().getCanonical();
 }
 
+bool AnyFunctionType::hasSameExtInfoAs(const AnyFunctionType *otherFn) {
+  return getExtInfo().isEqualTo(otherFn->getExtInfo(), useClangTypes(this));
+}
+
 // [TODO: Store-SIL-Clang-type]
 ClangTypeInfo SILFunctionType::getClangTypeInfo() const {
   return ClangTypeInfo();
 }
 
+bool SILFunctionType::hasSameExtInfoAs(const SILFunctionType *otherFn) {
+  return getExtInfo().isEqualTo(otherFn->getExtInfo(), useClangTypes(this));
+}
+
 FunctionType *
 GenericFunctionType::substGenericArgs(SubstitutionMap subs) {
   return substGenericArgs(
diff --git a/lib/AST/TypeJoinMeet.cpp b/lib/AST/TypeJoinMeet.cpp
@@ -314,7 +314,7 @@ CanType TypeJoin::visitFunctionType(CanType second) {
   auto secondExtInfo = secondFnTy->getExtInfo();
 
   // FIXME: Properly handle these attributes.
-  if (firstExtInfo != secondExtInfo)
+  if (!firstExtInfo.isEqualTo(secondExtInfo, useClangTypes(First)))
     return Unimplemented;
 
   if (!AnyFunctionType::equalParams(firstFnTy->getParams(),
diff --git a/lib/SIL/IR/SILFunctionType.cpp b/lib/SIL/IR/SILFunctionType.cpp
@@ -932,7 +932,7 @@ static CanType getKnownType(Optional<CanType> &cacheSlot, ASTContext &C,
 CanAnyFunctionType
 Lowering::adjustFunctionType(CanAnyFunctionType t,
                              AnyFunctionType::ExtInfo extInfo) {
-  if (t->getExtInfo() == extInfo)
+  if (t->getExtInfo().isEqualTo(extInfo, useClangTypes(t)))
     return t;
   return CanAnyFunctionType(t->withExtInfo(extInfo));
 }
@@ -943,7 +943,8 @@ Lowering::adjustFunctionType(CanSILFunctionType type,
                              SILFunctionType::ExtInfo extInfo,
                              ParameterConvention callee,
                              ProtocolConformanceRef witnessMethodConformance) {
-  if (type->getExtInfo() == extInfo && type->getCalleeConvention() == callee &&
+  if (type->getExtInfo().isEqualTo(extInfo, useClangTypes(type)) &&
+      type->getCalleeConvention() == callee &&
       type->getWitnessMethodConformanceOrInvalid() == witnessMethodConformance)
     return type;
 
@@ -965,7 +966,7 @@ SILFunctionType::getWithRepresentation(Representation repr) {
 
 CanSILFunctionType SILFunctionType::getWithExtInfo(ExtInfo newExt) {
   auto oldExt = getExtInfo();
-  if (newExt == oldExt)
+  if (newExt.isEqualTo(oldExt, useClangTypes(this)))
     return CanSILFunctionType(this);
 
   auto calleeConvention =
@@ -3968,7 +3969,7 @@ TypeConverter::getBridgedFunctionType(AbstractionPattern pattern,
   case SILFunctionTypeRepresentation::Closure:
   case SILFunctionTypeRepresentation::WitnessMethod: {
     // No bridging needed for native functions.
-    if (t->getExtInfo() == extInfo)
+    if (t->getExtInfo().isEqualTo(extInfo, useClangTypes(t)))
       return t;
     return CanAnyFunctionType::get(genericSig, t.getParams(), t.getResult(),
                                    extInfo);
diff --git a/lib/SIL/Verifier/SILVerifier.cpp b/lib/SIL/Verifier/SILVerifier.cpp
@@ -3718,8 +3718,10 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             .withRepresentation(SILFunctionType::Representation::Thick)
             .withNoEscape(resFTy->isNoEscape())
             .build();
-    require(adjustedOperandExtInfo == resFTy->getExtInfo(),
-            "operand and result of thin_to_think_function must agree in particulars");
+    require(adjustedOperandExtInfo.isEqualTo(resFTy->getExtInfo(),
+                                             useClangTypes(opFTy)),
+            "operand and result of thin_to_think_function must agree in "
+            "particulars");
   }
 
   void checkThickToObjCMetatypeInst(ThickToObjCMetatypeInst *TTOCI) {
diff --git a/lib/SILGen/SILGenPoly.cpp b/lib/SILGen/SILGenPoly.cpp
@@ -3476,8 +3476,9 @@ static CanSILFunctionType buildWithoutActuallyEscapingThunkType(
     CanSILFunctionType &escapingType, GenericEnvironment *&genericEnv,
     SubstitutionMap &interfaceSubs, CanType &dynamicSelfType) {
 
-  assert(escapingType->getExtInfo() ==
-         noEscapingType->getExtInfo().withNoEscape(false));
+  assert(escapingType->getExtInfo().isEqualTo(
+      noEscapingType->getExtInfo().withNoEscape(false),
+      useClangTypes(escapingType)));
 
   CanType inputSubstType, outputSubstType;
   auto type = SGF.buildThunkType(noEscapingType, escapingType,
@@ -3539,8 +3540,9 @@ SILGenFunction::createWithoutActuallyEscapingClosure(
   auto noEscapingFnSubstTy = noEscapingFunctionValue.getType()
     .castTo<SILFunctionType>();
   // TODO: maybe this should use a more explicit instruction.
-  assert(escapingFnSubstTy->getExtInfo() == noEscapingFnSubstTy->getExtInfo()
-                                                         .withNoEscape(false));
+  assert(escapingFnSubstTy->getExtInfo().isEqualTo(
+      noEscapingFnSubstTy->getExtInfo().withNoEscape(false),
+      useClangTypes(escapingFnSubstTy)));
 
   // Apply function type substitutions, since the code sequence for a thunk
   // doesn't vary with function representation.
diff --git a/lib/Sema/TypeCheckDeclOverride.cpp b/lib/Sema/TypeCheckDeclOverride.cpp
@@ -35,7 +35,7 @@ static void adjustFunctionTypeForOverride(Type &type) {
   auto fnType = type->castTo<AnyFunctionType>();
   auto extInfo = fnType->getExtInfo();
   extInfo = extInfo.withThrows(false);
-  if (fnType->getExtInfo() != extInfo)
+  if (!fnType->getExtInfo().isEqualTo(extInfo, useClangTypes(fnType)))
     type = fnType->withExtInfo(extInfo);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ static void adjustFunctionTypeForOverride(Type &type) {`
`35`	`35`	`auto fnType = type->castTo<AnyFunctionType>();`
`36`	`36`	`auto extInfo = fnType->getExtInfo();`
`37`	`37`	`extInfo = extInfo.withThrows(false);`
`38`		`- if (fnType->getExtInfo() != extInfo)`
	`38`	`+ if (!fnType->getExtInfo().isEqualTo(extInfo, useClangTypes(fnType)))`
`39`	`39`	`type = fnType->withExtInfo(extInfo);`
`40`	`40`	`}`
`41`	`41`