Add Builtin.isOptional.

There was previously no way to detect a type that is nominally
Optional at runtime. The standard library, namely OutputStream, needs
to handle Optionals specially in order to cirumvent conversion to the
Optional's wrapped type. This should be done with conditional
conformance, but until that feature is available, Builtin.isOptional
will serve as a useful crutch.

Author: atrick

include/swift/AST/Builtins.def

@@ -353,6 +353,11 @@ BUILTIN_RUNTIME_CALL(UnexpectedError, "unexpectedError", "")
 /// errorInMain: ErrorType -> ()
 BUILTIN_RUNTIME_CALL(ErrorInMain, "errorInMain", "")
 
+/// IsOptionalType : T.Type -> Bool
+/// This builtin takes a metatype and returns true if the metatype's
+/// nominal type is Optional.
+BUILTIN_RUNTIME_CALL(IsOptionalType, "isOptional", "")
+
 #undef BUILTIN_RUNTIME_CALL
 
 // BUILTIN_MISC_OPERATION - Miscellaneous operations without a unifying class.

lib/AST/Builtins.cpp

@@ -683,6 +683,13 @@ static ValueDecl *getIsPODOperation(ASTContext &Context, Identifier Id) {
   return builder.build(Id);
 }
 
+static ValueDecl *getIsOptionalOperation(ASTContext &Context, Identifier Id) {
+  GenericSignatureBuilder builder(Context);
+  builder.addParameter(makeMetatype(makeGenericParam()));
+  builder.setResult(makeConcrete(BuiltinIntegerType::get(1,Context)));
+  return builder.build(Id);
+}
+
 static ValueDecl *getAllocOperation(ASTContext &Context, Identifier Id) {
   Type PtrSizeTy = BuiltinIntegerType::getWordType(Context);
   TupleTypeElt ArgElts[] = { PtrSizeTy, PtrSizeTy };
@@ -1582,6 +1589,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::IsPOD:
     return getIsPODOperation(Context, Id);
 
+  case BuiltinValueKind::IsOptionalType:
+    return getIsOptionalOperation(Context, Id);
+
   case BuiltinValueKind::AllocRaw:
     return getAllocOperation(Context, Id);
 

lib/IRGen/RuntimeFunctions.def

@@ -853,6 +853,13 @@ FUNCTION(IsClassType,
          ARGS(TypeMetadataPtrTy),
          ATTRS(NoUnwind, ReadNone))
 
+// bool swift_isOptionalType(type*);
+FUNCTION(IsOptionalType,
+         swift_isOptionalType, RuntimeCC,
+         RETURNS(Int1Ty),
+         ARGS(TypeMetadataPtrTy),
+         ATTRS(NoUnwind, ReadNone))
+
 // void swift_once(swift_once_t *predicate,
 //                 void (*function_code)(RefCounted*));
 FUNCTION(Once, swift_once, RuntimeCC,

stdlib/public/core/Builtin.swift

@@ -568,3 +568,11 @@ public // @testable
 func _isPOD<T>(type: T.Type) -> Bool {
   return Bool(Builtin.ispod(type))
 }
+
+/// Return true if type is nominally an Optional type.
+@_transparent
+@warn_unused_result
+public // @testable
+func _isOptional<T>(type: T.Type) -> Bool {
+  return Bool(Builtin.isOptional(type))
+}

stdlib/public/runtime/Casting.cpp

@@ -3172,3 +3172,7 @@ extern "C" const Metadata *_swift_getSuperclass_nonNull(
 extern "C" bool swift_isClassType(const Metadata *type) {
   return Metadata::isAnyKindOfClass(type->getKind());
 }
+
+extern "C" bool swift_isOptionalType(const Metadata *type) {
+  return type->getKind() == MetadataKind::Optional;
+}

test/1_stdlib/Builtins.swift

@@ -277,4 +277,14 @@ tests.test("_isPOD") {
   expectFalse(_isPOD(P.self))
 }
 
+tests.test("_isOptional") {
+  expectTrue(_isOptional(Optional<Int>.self))
+  expectTrue(_isOptional(Optional<X>.self))
+  expectTrue(_isOptional(Optional<P>.self))
+  expectTrue(_isOptional(ImplicitlyUnwrappedOptional<P>.self))
+  expectFalse(_isOptional(Int.self))
+  expectFalse(_isOptional(X.self))
+  expectFalse(_isOptional(P.self))
+}
+
 runAllTests()