ASTPrinter: Turn on explicit any printing for everything and remove the option to disable it

Author: AnthonyLatsis

include/swift/AST/PrintOptions.h

@@ -293,10 +293,6 @@ struct PrintOptions {
 
   bool PrintImplicitAttrs = true;
 
-  /// Whether to print the \c any keyword for existential
-  /// types.
-  bool PrintExplicitAny = false;
-
   /// Whether to desugar the constraint for an existential type.
   bool DesugarExistentialConstraint = false;
 
@@ -607,7 +603,6 @@ struct PrintOptions {
   /// The print options used for formatting diagnostic arguments.
   static PrintOptions forDiagnosticArguments() {
     PrintOptions result;
-    result.PrintExplicitAny = true;
     return result;
   }
 
@@ -725,7 +720,6 @@ struct PrintOptions {
   static PrintOptions printQualifiedSILType() {
     PrintOptions result = PrintOptions::printSIL();
     result.FullyQualifiedTypesIfAmbiguous = true;
-    result.PrintExplicitAny = true;
     return result;
   }
 

lib/AST/ASTPrinter.cpp

@@ -178,7 +178,6 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
       PrintOptions::FunctionRepresentationMode::Full;
   result.AlwaysTryPrintParameterLabels = true;
   result.PrintSPIs = printSPIs;
-  result.PrintExplicitAny = true;
   result.DesugarExistentialConstraint = true;
 
   // We should print __consuming, __owned, etc for the module interface file.
@@ -5695,16 +5694,15 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
           return opaque->getDecl()->hasExplicitGenericParams();
         case PrintOptions::OpaqueReturnTypePrintingMode::WithoutOpaqueKeyword:
           return opaque->getDecl()->hasExplicitGenericParams() ||
-              isSimpleUnderPrintOptions(opaque->getExistentialType());
+                 isSimpleUnderPrintOptions(opaque->getExistentialType()
+                                               ->castTo<ExistentialType>()
+                                               ->getConstraintType());
         }
         llvm_unreachable("bad opaque-return-type printing mode");
       }
     } else if (auto existential = dyn_cast<ExistentialType>(T.getPointer())) {
-      if (!Options.PrintExplicitAny || !existential->shouldPrintWithAny())
+      if (!existential->shouldPrintWithAny())
         return isSimpleUnderPrintOptions(existential->getConstraintType());
-    } else if (auto existential = dyn_cast<ExistentialMetatypeType>(T.getPointer())) {
-      if (!Options.PrintExplicitAny)
-        return isSimpleUnderPrintOptions(existential->getInstanceType());
     } else if (auto param = dyn_cast<GenericTypeParamType>(T.getPointer())) {
       if (param->isParameterPack())
         return false;
@@ -6176,7 +6174,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
 
     Type instanceType = T->getInstanceType();
-    if (Options.PrintExplicitAny && T->is<ExistentialMetatypeType>()) {
+    if (T->is<ExistentialMetatypeType>()) {
       Printer << "any ";
 
       // FIXME: We need to replace nested existential metatypes so that
@@ -6188,27 +6186,23 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
 
         return type;
       }));
-    } else if (T->is<MetatypeType>() && instanceType->is<ExistentialType>()) {
-      // The 'any' keyword is needed to distinguish between existential
-      // metatypes and singleton metatypes. However, 'any' usually isn't
-      // printed for Any and AnyObject, because it's unnecessary to write
-      // 'any' with these specific constraints. Force printing with 'any'
-      // for the existential instance type in this case.
-      instanceType->getAs<ExistentialType>()->forcePrintWithAny([&](Type ty) {
-        printWithParensIfNotSimple(ty);
-      });
     } else {
-      printWithParensIfNotSimple(instanceType);
+      assert(T->is<MetatypeType>());
+      if (instanceType->is<ExistentialType>()) {
+        // The 'any' keyword is needed to distinguish between existential
+        // metatypes and singleton metatypes. However, 'any' usually isn't
+        // printed for Any and AnyObject, because it's unnecessary to write
+        // 'any' with these specific constraints. Force printing with 'any'
+        // for the existential instance type in this case.
+        instanceType->getAs<ExistentialType>()->forcePrintWithAny([&](Type ty) {
+          printWithParensIfNotSimple(ty);
+        });
+      } else {
+        printWithParensIfNotSimple(instanceType);
+      }
     }
 
-    // We spell normal metatypes of existential types as .Protocol.
-    if (isa<MetatypeType>(T) &&
-        T->getInstanceType()->isAnyExistentialType() &&
-        !Options.PrintExplicitAny) {
-      Printer << ".Protocol";
-    } else {
-      Printer << ".Type";
-    }
+    Printer << ".Type";
   }
 
   void visitModuleType(ModuleType *T) {
@@ -6835,7 +6829,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   }
 
   void visitExistentialType(ExistentialType *T) {
-    if (Options.PrintExplicitAny && T->shouldPrintWithAny())
+    if (T->shouldPrintWithAny())
       Printer << "any ";
 
     // FIXME: The desugared type is used here only to support

lib/SIL/IR/SILPrinter.cpp

@@ -4287,7 +4287,6 @@ PrintOptions PrintOptions::printSIL(const SILPrintContext *ctx) {
   result.PrintInSILBody = true;
   result.PreferTypeRepr = false;
   result.PrintIfConfig = false;
-  result.PrintExplicitAny = true;
   result.OpaqueReturnTypePrinting =
      OpaqueReturnTypePrintingMode::StableReference;
   if (ctx && ctx->printFullConvention())

lib/Sema/TypeCheckDecl.cpp

@@ -2406,6 +2406,7 @@ InterfaceTypeRequest::evaluate(Evaluator &eval, ValueDecl *D) const {
   case DeclKind::Protocol: {
     auto nominal = cast<NominalTypeDecl>(D);
     Type declaredInterfaceTy = nominal->getDeclaredInterfaceType();
+    // FIXME: For a protocol, this returns a MetatypeType wrapping a ProtocolType, but should be a MetatypeType wrapping an ExistentialType ('(any P).Type', not 'P.Type').
     return MetatypeType::get(declaredInterfaceTy, Context);
   }
 

test/ClangImporter/nested_protocol_name.swift

@@ -11,9 +11,9 @@
 
 // HEADER: class Trunk {
 // HEADER:   init!()
-// HEADER:   class func addLimb(_ limb: Trunk.Branch!)
-// HEADER:   func addLimb(_ limb: Trunk.Branch!)
-// HEADER:   func addLimbs(_ limbs: [Trunk.Branch]!)
+// HEADER:   class func addLimb(_ limb: (any Trunk.Branch)!)
+// HEADER:   func addLimb(_ limb: (any Trunk.Branch)!)
+// HEADER:   func addLimbs(_ limbs: [any Trunk.Branch]!)
 // HEADER: }
 // HEADER: // NS_SWIFT_NAME(Trunk.Branch)
 // HEADER: protocol Branch {

test/ConstExtraction/ExtractGroups.swift

@@ -67,7 +67,7 @@ extension String: Foo {}
 // CHECK-NEXT:      },
 // CHECK-NEXT:      {
 // CHECK-NEXT:        "label": "array2",
-// CHECK-NEXT:        "type": "Swift.Array<ExtractGroups.Foo>",
+// CHECK-NEXT:        "type": "Swift.Array<any ExtractGroups.Foo>",
 // CHECK-NEXT:        "isStatic": "false",
 // CHECK-NEXT:        "isComputed": "false",
 // CHECK-NEXT:        "file": "{{.*}}test{{/|\\\\}}ConstExtraction{{/|\\\\}}ExtractGroups.swift",
@@ -209,7 +209,7 @@ extension String: Foo {}
 // CHECK-NEXT:      },
 // CHECK-NEXT:      {
 // CHECK-NEXT:        "label": "dict3",
-// CHECK-NEXT:        "type": "Swift.Dictionary<Swift.String, ExtractGroups.Foo>",
+// CHECK-NEXT:        "type": "Swift.Dictionary<Swift.String, any ExtractGroups.Foo>",
 // CHECK-NEXT:        "isStatic": "false",
 // CHECK-NEXT:        "isComputed": "false",
 // CHECK-NEXT:        "file": "{{.*}}test{{/|\\\\}}ConstExtraction{{/|\\\\}}ExtractGroups.swift",

test/ConstExtraction/ExtractTypeValue.swift

@@ -16,7 +16,7 @@ struct TypeValuePropertyStruct : MyProto {
 }
 
 // CHECK:             "label": "birdTypes",
-// CHECK-NEXT:        "type": "Swift.Array<ExtractTypeValue.Bird.Type>",
+// CHECK-NEXT:        "type": "Swift.Array<any ExtractTypeValue.Bird.Type>",
 // CHECK-NEXT:        "isStatic": "false",
 // CHECK-NEXT:        "isComputed": "false",
 // CHECK-NEXT:        "file": "{{.*}}ExtractTypeValue.swift",

test/ConstExtraction/ExtractTypes.swift

@@ -20,7 +20,7 @@ public struct Types : MyProto {
 }
 
 // CHECK:       "label": "types1",
-// CHECK-NEXT:  "type": "Swift.Array<ExtractTypes.ContainerType.Type>",
+// CHECK-NEXT:  "type": "Swift.Array<any ExtractTypes.ContainerType.Type>",
 // CHECK:       "valueKind": "Array",
 // CHECK-NEXT:  "value": [
 // CHECK-NEXT:    {

test/Constraints/issue-58019.swift

@@ -4,7 +4,7 @@
 
 func fetch() {
   // CHECK: open_existential_expr implicit type='Void'
-  // CHECK: opaque_value_expr implicit type='MyError'
+  // CHECK: opaque_value_expr implicit type='any MyError'
   // CHECK-NOT: type='SryMap<$T{{.*}}>.Failure'
   sryMap { return "" }
   .napError{ $0.abc() }

test/Constraints/issue-60806.swift

@@ -18,7 +18,7 @@ enum NonBarBaz {
 
 let _: Foo<Bar> = Foo<Bar> { (a: Bar) -> Void in
   switch a {
-  // CHECK: (pattern_is type='Bar' value_cast Baz
+  // CHECK: (pattern_is type='any Bar' value_cast Baz
   // CHECK-NEXT: (pattern_enum_element type='Baz' Baz.someCase
   case let .someCase(value) as Baz:
     print(value)