Merge pull request #27145 from slavapestov/refactor-type-check-checked-cast

slavapestov · web-flow · commit cd8fddd2df6a · 2019-09-12T21:07:07.000-04:00
Refactor typeCheckCheckedCast() and a few other things
diff --git a/include/swift/Sema/IDETypeChecking.h b/include/swift/Sema/IDETypeChecking.h
@@ -47,10 +47,6 @@ namespace swift {
   /// \returns true on convertible, false on not.
   bool isConvertibleTo(Type T1, Type T2, bool openArchetypes, DeclContext &DC);
 
-  bool isEqual(Type T1, Type T2, DeclContext &DC);
-
-  bool canPossiblyEqual(Type T1, Type T2, DeclContext &DC);
-
   void collectDefaultImplementationForProtocolMembers(ProtocolDecl *PD,
                         llvm::SmallDenseMap<ValueDecl*, ValueDecl*> &DefaultMap);
 
diff --git a/include/swift/Sema/IDETypeCheckingRequests.h b/include/swift/Sema/IDETypeCheckingRequests.h
@@ -87,8 +87,6 @@ class IsDeclApplicableRequest:
 // Type relation checking
 //----------------------------------------------------------------------------//
 enum class TypeRelation: uint8_t {
-  EqualTo,
-  PossiblyEqualTo,
   ConvertTo,
 };
 
@@ -158,8 +156,6 @@ struct TypeRelationCheckInput {
     out << " is ";
     switch(owner.Relation) {
 #define CASE(NAME) case TypeRelation::NAME: out << #NAME << " "; break;
-    CASE(EqualTo)
-    CASE(PossiblyEqualTo)
     CASE(ConvertTo)
 #undef CASE
     }
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -1479,7 +1479,11 @@ bool TypeBase::isExactSuperclassOf(Type ty) {
          ty->getSuperclass()->getAnyNominal()->hasClangNode())))
     return false;
 
+  SmallPtrSet<ClassDecl *, 8> seen;
   do {
+    if (auto *classDecl = ty->getClassOrBoundGenericClass())
+      if (!seen.insert(classDecl).second)
+        return false;
     if (ty->isEqual(this))
       return true;
   } while ((ty = ty->getSuperclass()));
@@ -1510,6 +1514,10 @@ bool TypeBase::isBindableTo(Type b) {
       if (orig->requiresClass() && !subst->satisfiesClassConstraint())
         return false;
 
+      if (auto superclass = orig->getSuperclass())
+        if (!superclass->isBindableToSuperclassOf(subst))
+          return false;
+
       // TODO: If the archetype has a superclass constraint, check that the
       // substitution is a subclass.
       
@@ -1528,7 +1536,7 @@ bool TypeBase::isBindableTo(Type b) {
       if (CanType(orig) == subst)
         return true;
       
-      llvm_unreachable("not a valid canonical type substitution");
+      return false;
     }
     
     bool visitNominalType(NominalType *nom, CanType subst) {
@@ -1580,17 +1588,20 @@ bool TypeBase::isBindableTo(Type b) {
     }
     
     bool visitDependentMemberType(DependentMemberType *dt, CanType subst) {
-      llvm_unreachable("can't visit dependent types");
+      return true;
     }
     bool visitGenericTypeParamType(GenericTypeParamType *dt, CanType subst) {
-      llvm_unreachable("can't visit dependent types");
+      return true;
     }
     
     bool visitFunctionType(FunctionType *func, CanType subst) {
       if (auto substFunc = dyn_cast<FunctionType>(subst)) {
         if (func->getExtInfo() != substFunc->getExtInfo())
           return false;
         
+        if (func->getParams().size() != substFunc->getParams().size())
+          return false;
+
         for (unsigned i : indices(func->getParams())) {
           if (!visit(func->getParams()[i].getOldType(),
                      substFunc.getParams()[i].getOldType()))
@@ -1708,20 +1719,13 @@ bool TypeBase::isBindableToSuperclassOf(Type ty) {
   if (!ty->mayHaveSuperclass())
     return false;
 
-  // If the type is itself an archetype, we could always potentially bind it
-  // to the superclass (via external retroactive conformance, even if the
-  // type isn't statically known to conform).
-  //
-  // We could theoretically reject cases where the set of conformances is known
-  // (say the protocol or classes are private or internal).
-  if (is<ArchetypeType>())
-    return true;
-  
+  SmallPtrSet<ClassDecl *, 8> seen;
   do {
+    if (auto *classDecl = ty->getClassOrBoundGenericClass())
+      if (!seen.insert(classDecl).second)
+        return false;
     if (isBindableTo(ty))
       return true;
-    if (ty->getAnyNominal() && ty->getAnyNominal()->isInvalid())
-      return false;
   } while ((ty = ty->getSuperclass()));
   return false;
 }
diff --git a/lib/IDE/IDETypeChecking.cpp b/lib/IDE/IDETypeChecking.cpp
@@ -88,25 +88,6 @@ PrintOptions PrintOptions::printDocInterface() {
   return result;
 }
 
-/// Erase any associated types within dependent member types, so we'll resolve
-/// them again.
-static Type eraseAssociatedTypes(Type type) {
-  if (!type->hasTypeParameter()) return type;
-
-  return type.transformRec([](TypeBase *type) -> Optional<Type> {
-    if (auto depMemType = dyn_cast<DependentMemberType>(type)) {
-      auto newBase = eraseAssociatedTypes(depMemType->getBase());
-      if (newBase.getPointer() == depMemType->getBase().getPointer() &&
-          !depMemType->getAssocType())
-        return None;
-
-      return Type(DependentMemberType::get(newBase, depMemType->getName()));
-    }
-
-    return None;
-  });
-}
-
 struct SynthesizedExtensionAnalyzer::Implementation {
   static bool isMemberFavored(const NominalTypeDecl* Target, const Decl* D) {
     DeclContext* DC = Target->getInnermostDeclContext();
@@ -186,11 +167,9 @@ struct SynthesizedExtensionAnalyzer::Implementation {
     std::set<Requirement> Requirements;
     void addRequirement(GenericSignature *GenericSig,
                         Type First, Type Second, RequirementKind Kind) {
-      CanType CanFirst =
-        GenericSig->getCanonicalTypeInContext(eraseAssociatedTypes(First));
+      CanType CanFirst = GenericSig->getCanonicalTypeInContext(First);
       CanType CanSecond;
-      if (Second) CanSecond =
-        GenericSig->getCanonicalTypeInContext(eraseAssociatedTypes(Second));
+      if (Second) CanSecond = GenericSig->getCanonicalTypeInContext(Second);
 
       Requirements.insert({First, Second, Kind, CanFirst, CanSecond});
     }
@@ -325,7 +304,6 @@ struct SynthesizedExtensionAnalyzer::Implementation {
 
         switch (Kind) {
         case RequirementKind::Conformance:
-        case RequirementKind::Superclass:
           // FIXME: This could be more accurate; check
           // conformance instead of subtyping
           if (!isConvertibleTo(First, Second, /*openArchetypes=*/true, *DC))
@@ -335,8 +313,17 @@ struct SynthesizedExtensionAnalyzer::Implementation {
             MergeInfo.addRequirement(GenericSig, First, Second, Kind);
           break;
 
+        case RequirementKind::Superclass:
+          if (!Second->isBindableToSuperclassOf(First)) {
+            return true;
+          } else if (!Second->isExactSuperclassOf(Second)) {
+            MergeInfo.addRequirement(GenericSig, First, Second, Kind);
+          }
+          break;
+
         case RequirementKind::SameType:
-          if (!canPossiblyEqual(First, Second, *DC)) {
+          if (!First->isBindableTo(Second) &&
+              !Second->isBindableTo(First)) {
             return true;
           } else if (!First->isEqual(Second)) {
             MergeInfo.addRequirement(GenericSig, First, Second, Kind);
@@ -753,19 +740,6 @@ bool swift::isMemberDeclApplied(const DeclContext *DC, Type BaseTy,
     IsDeclApplicableRequest(DeclApplicabilityOwner(DC, BaseTy, VD)), false);
 }
 
-bool swift::canPossiblyEqual(Type T1, Type T2, DeclContext &DC) {
-   return evaluateOrDefault(DC.getASTContext().evaluator,
-     TypeRelationCheckRequest(TypeRelationCheckInput(&DC, T1, T2,
-       TypeRelation::PossiblyEqualTo, true)), false);
-}
-
-
-bool swift::isEqual(Type T1, Type T2, DeclContext &DC) {
-  return evaluateOrDefault(DC.getASTContext().evaluator,
-    TypeRelationCheckRequest(TypeRelationCheckInput(&DC, T1, T2,
-      TypeRelation::EqualTo, true)), false);
-}
-
 bool swift::isConvertibleTo(Type T1, Type T2, bool openArchetypes,
                             DeclContext &DC) {
   return evaluateOrDefault(DC.getASTContext().evaluator,
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -7163,6 +7163,7 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
   // T1 <c T2 && T2 : Hashable ===> T1 <c AnyHashable
   case ConversionRestrictionKind::HashableToAnyHashable: {
     // We never want to do this if the LHS is already AnyHashable.
+    type1 = simplifyType(type1);
     if (isAnyHashableType(
             type1->getRValueType()->lookThroughAllOptionalTypes())) {
       return SolutionKind::Error;
diff --git a/lib/Sema/ConstraintSystem.cpp b/lib/Sema/ConstraintSystem.cpp
@@ -728,8 +728,8 @@ Optional<Type> ConstraintSystem::isSetType(Type type) {
 }
 
 bool ConstraintSystem::isCollectionType(Type type) {
-  auto &ctx = type->getASTContext();
   if (auto *structType = type->getAs<BoundGenericStructType>()) {
+    auto &ctx = type->getASTContext();
     auto *decl = structType->getDecl();
     if (decl == ctx.getArrayDecl() || decl == ctx.getDictionaryDecl() ||
         decl == ctx.getSetDecl())
@@ -740,13 +740,9 @@ bool ConstraintSystem::isCollectionType(Type type) {
 }
 
 bool ConstraintSystem::isAnyHashableType(Type type) {
-  if (auto tv = type->getAs<TypeVariableType>()) {
-    auto fixedType = getFixedType(tv);
-    return fixedType && isAnyHashableType(fixedType);
-  }
-
   if (auto st = type->getAs<StructType>()) {
-    return st->getDecl() == TC.Context.getAnyHashableDecl();
+    auto &ctx = type->getASTContext();
+    return st->getDecl() == ctx.getAnyHashableDecl();
   }
 
   return false;
diff --git a/lib/Sema/ConstraintSystem.h b/lib/Sema/ConstraintSystem.h
@@ -2491,7 +2491,7 @@ class ConstraintSystem {
   static bool isCollectionType(Type t);
 
   /// Determine if the type in question is AnyHashable.
-  bool isAnyHashableType(Type t);
+  static bool isAnyHashableType(Type t);
 
   /// Call Expr::isTypeReference on the given expression, using a
   /// custom accessor for the type on the expression that reads the
diff --git a/lib/Sema/IDETypeCheckingRequests.cpp b/lib/Sema/IDETypeCheckingRequests.cpp
@@ -104,11 +104,6 @@ TypeRelationCheckRequest::evaluate(Evaluator &evaluator,
                                    TypeRelationCheckInput Owner) const {
   Optional<constraints::ConstraintKind> CKind;
   switch (Owner.Relation) {
-  case TypeRelation::EqualTo:
-    return Owner.Pair.FirstTy->isEqual(Owner.Pair.SecondTy);
-  case TypeRelation::PossiblyEqualTo:
-    CKind = constraints::ConstraintKind::Bind;
-    break;
   case TypeRelation::ConvertTo:
     CKind = constraints::ConstraintKind::Conversion;
     break;
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
diff --git a/test/expr/cast/metatype_casts.swift b/test/expr/cast/metatype_casts.swift
