Rename lookThroughAllAnyOptionalTypes to lookThroughAllOptionalTypes.

Author: rudkx

include/swift/AST/Types.h

@@ -1002,13 +1002,13 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   // otherwise, return the null type.
   Type getSwiftNewtypeUnderlyingType();
 
-  /// Return the type T after looking through all of the optional or
-  /// implicitly-unwrapped optional types.
-  Type lookThroughAllAnyOptionalTypes();
+  /// Return the type T after looking through all of the optional
+  /// types.
+  Type lookThroughAllOptionalTypes();
 
-  /// Return the type T after looking through all of the optional or
-  /// implicitly-unwrapped optional types.
-  Type lookThroughAllAnyOptionalTypes(SmallVectorImpl<Type> &optionals);
+  /// Return the type T after looking through all of the optional
+  /// types.
+  Type lookThroughAllOptionalTypes(SmallVectorImpl<Type> &optionals);
 
   /// Whether this is the AnyObject type.
   bool isAnyObject();

lib/AST/Type.cpp

@@ -554,15 +554,15 @@ Type TypeBase::getAnyPointerElementType(PointerTypeKind &PTK) {
   return Type();
 }
 
-Type TypeBase::lookThroughAllAnyOptionalTypes() {
+Type TypeBase::lookThroughAllOptionalTypes() {
   Type type(this);
   while (auto objType = type->getOptionalObjectType())
     type = objType;
 
   return type;
 }
 
-Type TypeBase::lookThroughAllAnyOptionalTypes(SmallVectorImpl<Type> &optionals){
+Type TypeBase::lookThroughAllOptionalTypes(SmallVectorImpl<Type> &optionals){
   Type type(this);
   while (auto objType = type->getOptionalObjectType()) {
     optionals.push_back(type);

lib/IDE/CodeCompletion.cpp

@@ -1670,7 +1670,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     bool isImplicitlyCurriedIM = isImplicitlyCurriedInstanceMethod(D);
     for (auto expectedType : ExpectedTypes) {
       if (expectedType &&
-          expectedType->lookThroughAllAnyOptionalTypes()
+          expectedType->lookThroughAllOptionalTypes()
               ->is<AnyFunctionType>() &&
           calculateTypeRelationForDecl(D, expectedType, isImplicitlyCurriedIM,
                                        /*UseFuncResultType=*/false) >=
@@ -3746,7 +3746,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
       bool addedSelector = false;
       bool addedKeyPath = false;
       for (auto T : ExpectedTypes) {
-        T = T->lookThroughAllAnyOptionalTypes();
+        T = T->lookThroughAllOptionalTypes();
         if (auto structDecl = T->getStructOrBoundGenericStruct()) {
           if (!addedSelector &&
               structDecl->getName() == Ctx.Id_Selector &&

lib/IDE/CodeCompletionResultBuilder.h

@@ -384,7 +384,7 @@ class CodeCompletionResultBuilder {
 
     // Look through optional types and type aliases to find out if we have
     // function/closure parameter type that is not an autoclosure.
-    Ty = Ty->lookThroughAllAnyOptionalTypes();
+    Ty = Ty->lookThroughAllOptionalTypes();
     if (auto AFT = Ty->getAs<AnyFunctionType>()) {
       if (!AFT->isAutoClosure()) {
         // If this is a closure type, add ChunkKind::CallParameterClosureType.

lib/PrintAsObjC/PrintAsObjC.cpp

@@ -1911,7 +1911,7 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
     PrettyStackTraceType trace(M.getASTContext(), "printing", ty);
 
     if (isFuncParam)
-      if (auto fnTy = ty->lookThroughAllAnyOptionalTypes()
+      if (auto fnTy = ty->lookThroughAllOptionalTypes()
                         ->getAs<AnyFunctionType>())
         if (fnTy->isNoEscape())
           os << "SWIFT_NOESCAPE ";

lib/SILGen/SILGenConvert.cpp

@@ -1280,7 +1280,7 @@ static bool isMatchedAnyToAnyObjectConversion(CanType from, CanType to) {
   }
 
   if (from->isAny()) {
-    assert(to->lookThroughAllAnyOptionalTypes()->isAnyObject());
+    assert(to->lookThroughAllOptionalTypes()->isAnyObject());
     return true;
   }
   return false;

lib/Sema/CSApply.cpp

@@ -3176,9 +3176,9 @@ namespace {
 
       // Dig through the optionals in the from/to types.
       SmallVector<Type, 2> fromOptionals;
-      fromType->lookThroughAllAnyOptionalTypes(fromOptionals);
+      fromType->lookThroughAllOptionalTypes(fromOptionals);
       SmallVector<Type, 2> toOptionals;
-      toType->lookThroughAllAnyOptionalTypes(toOptionals);
+      toType->lookThroughAllOptionalTypes(toOptionals);
 
       // If we have an imbalance of optionals or a collection
       // downcast, handle this as a checked cast followed by a
@@ -3293,11 +3293,11 @@ namespace {
       Type srcType = cs.getType(subExpr);
 
       SmallVector<Type, 4> srcOptionals;
-      srcType = srcType->lookThroughAllAnyOptionalTypes(srcOptionals);
+      srcType = srcType->lookThroughAllOptionalTypes(srcOptionals);
 
       SmallVector<Type, 4> destOptionals;
       auto destValueType
-        = finalResultType->lookThroughAllAnyOptionalTypes(destOptionals);
+        = finalResultType->lookThroughAllOptionalTypes(destOptionals);
 
       // When performing a bridging operation, if the destination value type
       // is 'AnyObject', leave any extra optionals on the source in place.
@@ -5359,10 +5359,10 @@ Expr *ExprRewriter::coerceOptionalToOptional(Expr *expr, Type toType,
   tc.requireOptionalIntrinsics(expr->getLoc());
 
   SmallVector<Type, 4> fromOptionals;
-  (void)fromType->lookThroughAllAnyOptionalTypes(fromOptionals);
+  (void)fromType->lookThroughAllOptionalTypes(fromOptionals);
 
   SmallVector<Type, 4> toOptionals;
-  (void)toType->lookThroughAllAnyOptionalTypes(toOptionals);
+  (void)toType->lookThroughAllOptionalTypes(toOptionals);
 
   assert(!toOptionals.empty());
   assert(!fromOptionals.empty());

lib/Sema/CSDiag.cpp

@@ -2496,7 +2496,7 @@ static bool tryRawRepresentableFixIts(InFlightDiagnostic &diag,
                                       const Expr *expr) {
   // The following fixes apply for optional destination types as well.
   bool toTypeIsOptional = !toType->getOptionalObjectType().isNull();
-  toType = toType->lookThroughAllAnyOptionalTypes();
+  toType = toType->lookThroughAllOptionalTypes();
 
   Type fromTypeUnwrapped = fromType->getOptionalObjectType();
   bool fromTypeIsOptional = !fromTypeUnwrapped.isNull();
@@ -2697,7 +2697,7 @@ static bool addTypeCoerceFixit(InFlightDiagnostic &diag, ConstraintSystem &CS,
                                Type fromType, Type toType, Expr *expr) {
   // Look through optional types; casts can add them, but can't remove extra
   // ones.
-  toType = toType->lookThroughAllAnyOptionalTypes();
+  toType = toType->lookThroughAllOptionalTypes();
 
   CheckedCastKind Kind = CS.getTypeChecker().typeCheckCheckedCast(
       fromType, toType, CheckedCastContextKind::None, CS.DC, SourceLoc(),
@@ -2736,7 +2736,7 @@ static bool tryDiagnoseNonEscapingParameterToEscaping(
   // the event of an implicit promotion.
   auto srcFT = srcType->getAs<AnyFunctionType>();
   auto dstFT =
-      dstType->lookThroughAllAnyOptionalTypes()->getAs<AnyFunctionType>();
+      dstType->lookThroughAllOptionalTypes()->getAs<AnyFunctionType>();
 
   if (!srcFT || !dstFT || !srcFT->isNoEscape() || dstFT->isNoEscape())
     return false;
@@ -4294,7 +4294,7 @@ diagnoseSingleCandidateFailures(CalleeCandidateInfo &CCI, Expr *fnExpr,
       isa<ConstructorDecl>(candidate.getDecl()) && candidate.level == 1) {
     AnyFunctionType::Param &arg = args[0];
     auto resTy =
-        candidate.getResultType()->lookThroughAllAnyOptionalTypes();
+        candidate.getResultType()->lookThroughAllOptionalTypes();
     auto rawTy = isRawRepresentable(resTy, CCI.CS);
     if (rawTy && arg.getType() && resTy->isEqual(arg.getType())) {
       auto getInnerExpr = [](Expr *E) -> Expr * {
@@ -4338,8 +4338,8 @@ diagnoseSingleCandidateFailures(CalleeCandidateInfo &CCI, Expr *fnExpr,
 static bool isRawRepresentableMismatch(Type fromType, Type toType,
                                        KnownProtocolKind kind,
                                        const ConstraintSystem &CS) {
-  toType = toType->lookThroughAllAnyOptionalTypes();
-  fromType = fromType->lookThroughAllAnyOptionalTypes();
+  toType = toType->lookThroughAllOptionalTypes();
+  fromType = fromType->lookThroughAllOptionalTypes();
 
   // First check if this is an attempt to convert from something to
   // raw representable.
@@ -6636,7 +6636,7 @@ static bool diagnoseKeyPathComponents(ConstraintSystem &CS, KeyPathExpr *KPE,
   Type currentType = rootType;
   auto updateState = [&](bool isProperty, Type newType) {
     // Strip off optionals.
-    newType = newType->lookThroughAllAnyOptionalTypes();
+    newType = newType->lookThroughAllOptionalTypes();
 
     // If updating to a type, just set the new type; there's nothing
     // more to do.
@@ -7027,7 +7027,7 @@ bool FailureDiagnosis::visitArrayExpr(ArrayExpr *E) {
 
   // If our contextual type is an optional, look through them, because we're
   // surely initializing whatever is inside.
-  contextualType = contextualType->lookThroughAllAnyOptionalTypes();
+  contextualType = contextualType->lookThroughAllOptionalTypes();
 
   // Validate that the contextual type conforms to ExpressibleByArrayLiteral and
   // figure out what the contextual element type is in place.
@@ -7115,7 +7115,7 @@ bool FailureDiagnosis::visitDictionaryExpr(DictionaryExpr *E) {
   if (auto contextualType = CS.getContextualType()) {
     // If our contextual type is an optional, look through them, because we're
     // surely initializing whatever is inside.
-    contextualType = contextualType->lookThroughAllAnyOptionalTypes();
+    contextualType = contextualType->lookThroughAllOptionalTypes();
 
     auto DLC = CS.TC.getProtocol(
         E->getLoc(), KnownProtocolKind::ExpressibleByDictionaryLiteral);

lib/Sema/CSSimplify.cpp

@@ -1370,10 +1370,10 @@ static void enumerateOptionalConversionRestrictions(
                     ConstraintKind kind, ConstraintLocatorBuilder locator,
                     llvm::function_ref<void(ConversionRestrictionKind)> fn) {
   SmallVector<Type, 2> optionals1;
-  Type objType1 = type1->lookThroughAllAnyOptionalTypes(optionals1);
+  Type objType1 = type1->lookThroughAllOptionalTypes(optionals1);
 
   SmallVector<Type, 2> optionals2;
-  Type objType2 = type2->lookThroughAllAnyOptionalTypes(optionals2);
+  Type objType2 = type2->lookThroughAllOptionalTypes(optionals2);
 
   if (optionals1.empty() && optionals2.empty())
     return;
@@ -2653,8 +2653,8 @@ ConstraintSystem::simplifyCheckedCastConstraint(
 
     // Peel off optionals metatypes from the types, because we might cast through
     // them.
-    toType = toType->lookThroughAllAnyOptionalTypes();
-    fromType = fromType->lookThroughAllAnyOptionalTypes();
+    toType = toType->lookThroughAllOptionalTypes();
+    fromType = fromType->lookThroughAllOptionalTypes();
 
     // Peel off metatypes, since if we can cast two types, we can cast their
     // metatypes.
@@ -4511,7 +4511,7 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
   case ConversionRestrictionKind::HashableToAnyHashable: {
     // We never want to do this if the LHS is already AnyHashable.
     if (isAnyHashableType(
-            type1->getRValueType()->lookThroughAllAnyOptionalTypes())) {
+            type1->getRValueType()->lookThroughAllOptionalTypes())) {
       return SolutionKind::Error;
     }
 

lib/Sema/ConstraintSystem.cpp

@@ -199,7 +199,7 @@ void ConstraintSystem::setMustBeMaterializableRecursive(Type type)
          "argument to setMustBeMaterializableRecursive may not be inherently "
          "non-materializable");
   type = getFixedTypeRecursive(type, /*wantRValue=*/false);
-  type = type->lookThroughAllAnyOptionalTypes();
+  type = type->lookThroughAllOptionalTypes();
 
   if (auto typeVar = type->getAs<TypeVariableType>()) {
     typeVar->getImpl().setMustBeMaterializable(getSavedBindings());

lib/Sema/MiscDiagnostics.cpp

@@ -3477,13 +3477,13 @@ static void diagnoseUnintendedOptionalBehavior(TypeChecker &TC, const Expr *E,
                                  size_t &difference) {
       SmallVector<Type, 4> destOptionals;
       auto destValueType =
-        destType->lookThroughAllAnyOptionalTypes(destOptionals);
+        destType->lookThroughAllOptionalTypes(destOptionals);
 
       if (!destValueType->isAny())
         return false;
 
       SmallVector<Type, 4> srcOptionals;
-      srcType->lookThroughAllAnyOptionalTypes(srcOptionals);
+      srcType->lookThroughAllOptionalTypes(srcOptionals);
 
       if (srcOptionals.size() > destOptionals.size()) {
         difference = srcOptionals.size() - destOptionals.size();

lib/Sema/TypeCheckAttr.cpp

@@ -1397,7 +1397,7 @@ void AttributeChecker::visitRethrowsAttr(RethrowsAttr *attr) {
   for (auto paramList : fn->getParameterLists()) {
     for (auto param : *paramList)
       if (hasThrowingFunctionParameter(param->getType()
-              ->lookThroughAllAnyOptionalTypes()
+              ->lookThroughAllOptionalTypes()
               ->getCanonicalType()))
         return;
   }

lib/Sema/TypeCheckError.cpp

@@ -520,7 +520,7 @@ class ApplyClassifier {
 
   Classification classifyThrowingParameterBody(ParamDecl *param,
                                                PotentialReason reason) {
-    assert(param->getType()->lookThroughAllAnyOptionalTypes()->castTo<AnyFunctionType>()->throws());
+    assert(param->getType()->lookThroughAllOptionalTypes()->castTo<AnyFunctionType>()->throws());
 
     // If we're currently doing rethrows-checking on the body of the
     // function which declares the parameter, it's rethrowing-only.
@@ -706,7 +706,7 @@ class ApplyClassifier {
 
     // Otherwise, if the original parameter type was not a throwing
     // function type, it does not contribute to 'rethrows'.
-    auto paramFnType = paramType->lookThroughAllAnyOptionalTypes()->getAs<AnyFunctionType>();
+    auto paramFnType = paramType->lookThroughAllOptionalTypes()->getAs<AnyFunctionType>();
     if (!paramFnType || !paramFnType->throws())
       return Classification();
 

lib/Sema/TypeCheckExprObjC.cpp

@@ -78,7 +78,7 @@ Optional<Type> TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
   Type currentType;
   auto updateState = [&](bool isProperty, Type newType) {
     // Strip off optionals.
-    newType = newType->lookThroughAllAnyOptionalTypes();
+    newType = newType->lookThroughAllOptionalTypes();
 
     // If updating to a type, just set the new type; there's nothing
     // more to do.

lib/Sema/TypeCheckPattern.cpp

@@ -1221,9 +1221,9 @@ bool TypeChecker::coercePatternToType(Pattern *&P, DeclContext *dc, Type type,
 
     // Determine whether we have an imbalance in the number of optionals.
     SmallVector<Type, 2> inputTypeOptionals;
-    type->lookThroughAllAnyOptionalTypes(inputTypeOptionals);
+    type->lookThroughAllOptionalTypes(inputTypeOptionals);
     SmallVector<Type, 2> castTypeOptionals;
-    castType->lookThroughAllAnyOptionalTypes(castTypeOptionals);
+    castType->lookThroughAllOptionalTypes(castTypeOptionals);
 
     // If we have extra optionals on the input type. Create ".Some" patterns
     // wrapping the isa pattern to balance out the optionals.

lib/Sema/TypeCheckStmt.cpp

@@ -1030,7 +1030,7 @@ bool TypeChecker::typeCheckCatchPattern(CatchStmt *S, DeclContext *DC) {
 static bool isDiscardableType(Type type) {
   return (type->hasError() ||
           type->isUninhabited() ||
-          type->lookThroughAllAnyOptionalTypes()->isVoid());
+          type->lookThroughAllOptionalTypes()->isVoid());
 }
 
 static void diagnoseIgnoredLiteral(TypeChecker &TC, LiteralExpr *LE) {