Remove the unused isSome Optional intrinsics.

We already have detailed knowledge of Optional's layout in SILGen, so these intrinsics were almost unused. They were only used in a few obscure places by some optional-to-bool conversions, used by 'is [A]' collection tests and the codegen for 'lazy' properties. Change these over to generate an EnumIsCaseExpr that we can directly lower to a 'select_enum' instruction in SILGen, leading to better codegen and obviating the need for these intrinsic functions.

Author: jckarter

include/swift/AST/ASTContext.h

@@ -454,10 +454,6 @@ class ASTContext {
   FuncDecl *get##Name(LazyResolver *resolver) const;
 #include "swift/AST/KnownDecls.def"
 
-  /// Swift._stdlib_{,ImplicitlyUnwrapped}Optional_isSome.
-  FuncDecl *getOptionalIsSomeDecl(LazyResolver *resolver,
-                                  OptionalTypeKind kind) const;
-
   /// Retrieve the declaration of
   /// Swift._stdlib_{,ImplicitlyUnwrapped}Optional_unwrapped.
   FuncDecl *getOptionalUnwrappedDecl(LazyResolver *resolver,

include/swift/AST/Expr.h

@@ -51,6 +51,7 @@ namespace swift {
   class TypeDecl;
   class PatternBindingDecl;
   class ParameterList;
+  class EnumElementDecl;
 
 enum class ExprKind : uint8_t {
 #define EXPR(Id, Parent) Id,
@@ -3655,6 +3656,33 @@ class IfExpr : public Expr {
   }
 };
 
+/// EnumIsCaseExpr - A boolean expression that is true if an enum value is of
+/// a particular case.
+class EnumIsCaseExpr : public Expr {
+  Expr *SubExpr;
+  EnumElementDecl *Element;
+  
+public:
+  EnumIsCaseExpr(Expr *SubExpr, EnumElementDecl *Element)
+    : Expr(ExprKind::EnumIsCase, /*implicit*/ true),
+      SubExpr(SubExpr), Element(Element)
+  {}
+  
+  Expr *getSubExpr() const { return SubExpr; }
+  void setSubExpr(Expr *e) { SubExpr = e; }
+  
+  EnumElementDecl *getEnumElement() const { return Element; }
+  void setEnumElement(EnumElementDecl *elt) { Element = elt; }
+  
+  SourceLoc getLoc() const { return SubExpr->getLoc(); }
+  SourceLoc getStartLoc() const { return SubExpr->getStartLoc(); }
+  SourceLoc getEndLoc() const { return SubExpr->getEndLoc(); }
+  
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::EnumIsCase;
+  }
+};
+
 /// AssignExpr - A value assignment, like "x = y".
 class AssignExpr : public Expr {
   Expr *Dest;

include/swift/AST/ExprNodes.def

@@ -152,6 +152,7 @@ ABSTRACT_EXPR(ExplicitCast, Expr)
   EXPR_RANGE(ExplicitCast, ForcedCheckedCast, Coerce)
 UNCHECKED_EXPR(Arrow, Expr)
 EXPR(If, Expr)
+EXPR(EnumIsCase, Expr)
 EXPR(Assign, Expr)
 EXPR(DefaultValue, Expr)
 EXPR(CodeCompletion, Expr)

lib/AST/ASTContext.cpp

@@ -168,9 +168,6 @@ struct ASTContext::Implementation {
 #define FUNC_DECL(Name, Id) FuncDecl *Get##Name = nullptr;
 #include "swift/AST/KnownDecls.def"
 
-  /// func _stdlib_Optional_isSome<T>(v: Optional<T>) -> Bool
-  FuncDecl *OptionalIsSomeSomeDecls[NumOptionalTypeKinds] = {};
-
   /// func _stdlib_Optional_unwrapped<T>(v: Optional<T>) -> T
   FuncDecl *OptionalUnwrappedDecls[NumOptionalTypeKinds] = {};
 
@@ -1121,35 +1118,6 @@ static unsigned asIndex(OptionalTypeKind optionalKind) {
     ? (PREFIX "Optional" SUFFIX)                       \
     : (PREFIX "ImplicitlyUnwrappedOptional" SUFFIX))
 
-FuncDecl *ASTContext::getOptionalIsSomeDecl(
-    LazyResolver *resolver, OptionalTypeKind optionalKind) const {
-  auto &cache = Impl.OptionalIsSomeSomeDecls[asIndex(optionalKind)];
-  if (cache)
-    return cache;
-
-  auto name =
-      getOptionalIntrinsicName("_stdlib_", optionalKind, "_isSome");
-
-  // Look for a generic function.
-  CanType input, output, param;
-  auto decl = findLibraryIntrinsic(*this, name, resolver);
-  if (!decl || !isGenericIntrinsic(decl, input, output, param))
-    return nullptr;
-
-  // Input must be Optional<T>.
-  if (!isOptionalType(*this, optionalKind, input, param))
-    return nullptr;
-
-  // Output must be a global type named Bool.
-  auto nominalType = dyn_cast<NominalType>(output);
-  if (!nominalType || nominalType.getParent() ||
-      nominalType->getDecl()->getName().str() != "Bool")
-    return nullptr;
-
-  cache = decl;
-  return decl;
-}
-
 FuncDecl *ASTContext::getOptionalUnwrappedDecl(LazyResolver *resolver,
                                          OptionalTypeKind optionalKind) const {
   auto &cache = Impl.OptionalUnwrappedDecls[asIndex(optionalKind)];
@@ -1178,8 +1146,7 @@ FuncDecl *ASTContext::getOptionalUnwrappedDecl(LazyResolver *resolver,
 
 static bool hasOptionalIntrinsics(const ASTContext &ctx, LazyResolver *resolver,
                                   OptionalTypeKind optionalKind) {
-  return ctx.getOptionalIsSomeDecl(resolver, optionalKind) &&
-    ctx.getOptionalUnwrappedDecl(resolver, optionalKind);
+  return ctx.getOptionalUnwrappedDecl(resolver, optionalKind);
 }
 
 bool ASTContext::hasOptionalIntrinsics(LazyResolver *resolver) const {

lib/AST/ASTDumper.cpp

@@ -2160,6 +2160,12 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printRec(E->getSrc());
     OS << ')';
   }
+  void visitEnumIsCaseExpr(EnumIsCaseExpr *E) {
+    printCommon(E, "enum_is_case_expr") << ' ' <<
+      E->getEnumElement()->getName() << "\n";
+    printRec(E->getSubExpr());
+    
+  }
   void visitUnresolvedPatternExpr(UnresolvedPatternExpr *E) {
     printCommon(E, "unresolved_pattern_expr") << '\n';
     printRec(E->getSubPattern());

lib/AST/ASTVerifier.cpp

@@ -835,6 +835,26 @@ struct ASTNodeBase {};
       checkSameType(lhsTy, S->getSrc()->getType(), "assignment operands");
       verifyCheckedBase(S);
     }
+    
+    void verifyChecked(EnumIsCaseExpr *E) {
+      auto nom = E->getSubExpr()->getType()->getAnyNominal();
+      if (!nom || !isa<EnumDecl>(nom)) {
+        Out << "enum_is_decl operand is not an enum: ";
+        E->getSubExpr()->getType().print(Out);
+        Out << '\n';
+        abort();
+      }
+      
+      if (nom != E->getEnumElement()->getParentEnum()) {
+        Out << "enum_is_decl case is not member of enum:\n";
+        Out << "  case: ";
+        E->getEnumElement()->print(Out);
+        Out << "\n  type: ";
+        E->getSubExpr()->getType().print(Out);
+        Out << '\n';
+        abort();
+      }
+    }
 
     void verifyChecked(TupleExpr *E) {
       const TupleType *exprTy = E->getType()->castTo<TupleType>();

lib/AST/ASTWalker.cpp

@@ -747,6 +747,16 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
     return AE;
   }
 
+  Expr *visitEnumIsCaseExpr(EnumIsCaseExpr *E) {
+    if (Expr *Sub = E->getSubExpr()) {
+      if (!(Sub = doIt(Sub)))
+        return nullptr;
+      E->setSubExpr(Sub);
+    }
+    
+    return E;
+  }
+  
 
   Expr *visitIfExpr(IfExpr *E) {
     if (Expr *Cond = E->getCondExpr()) {

lib/AST/Expr.cpp

@@ -316,6 +316,7 @@ void Expr::propagateLValueAccessKind(AccessKind accessKind,
     NON_LVALUE_EXPR(CodeCompletion)
     NON_LVALUE_EXPR(ObjCSelector)
     NON_LVALUE_EXPR(ObjCKeyPath)
+    NON_LVALUE_EXPR(EnumIsCase)
 
 #define UNCHECKED_EXPR(KIND, BASE) \
     NON_LVALUE_EXPR(KIND)
@@ -600,6 +601,7 @@ bool Expr::canAppendCallParentheses() const {
   case ExprKind::LValueToPointer:
   case ExprKind::ForeignObjectConversion:
   case ExprKind::UnevaluatedInstance:
+  case ExprKind::EnumIsCase:
     // Implicit conversion nodes have no syntax of their own; defer to the
     // subexpression.
     return cast<ImplicitConversionExpr>(this)->getSubExpr()

lib/SILGen/SILGenExpr.cpp

@@ -216,6 +216,7 @@ namespace {
 
     RValue visitDefaultValueExpr(DefaultValueExpr *E, SGFContext C);
     RValue visitAssignExpr(AssignExpr *E, SGFContext C);
+    RValue visitEnumIsCaseExpr(EnumIsCaseExpr *E, SGFContext C);
 
     RValue visitBindOptionalExpr(BindOptionalExpr *E, SGFContext C);
     RValue visitOptionalEvaluationExpr(OptionalEvaluationExpr *E,
@@ -1425,14 +1426,42 @@ RValue RValueEmitter::visitIsExpr(IsExpr *E, SGFContext C) {
                          E->getCastTypeLoc().getType(), E->getCastKind());
 
   // Call the _getBool library intrinsic.
-  ASTContext &ctx = SGF.SGM.M.getASTContext();
+  ASTContext &ctx = SGF.getASTContext();
   auto result =
     SGF.emitApplyOfLibraryIntrinsic(E, ctx.getGetBoolDecl(nullptr), {},
                                     ManagedValue::forUnmanaged(isa),
                                     C);
   return result;
 }
 
+RValue RValueEmitter::visitEnumIsCaseExpr(EnumIsCaseExpr *E,
+                                          SGFContext C) {
+  ASTContext &ctx = SGF.getASTContext();
+  // Get the enum value.
+  auto subExpr = SGF.emitRValueAsSingleValue(E->getSubExpr(),
+                                SGFContext(SGFContext::AllowImmediatePlusZero));
+  // Test its case.
+  auto i1Ty = SILType::getBuiltinIntegerType(1, SGF.getASTContext());
+  auto t = SGF.B.createIntegerLiteral(E, i1Ty, 1);
+  auto f = SGF.B.createIntegerLiteral(E, i1Ty, 0);
+  
+  SILValue selected;
+  if (subExpr.getType().isAddress()) {
+    selected = SGF.B.createSelectEnumAddr(E, subExpr.getValue(), i1Ty, f,
+                                          {{E->getEnumElement(), t}});
+  } else {
+    selected = SGF.B.createSelectEnum(E, subExpr.getValue(), i1Ty, f,
+                                      {{E->getEnumElement(), t}});
+  }
+  
+  // Call the _getBool library intrinsic.
+  auto result =
+    SGF.emitApplyOfLibraryIntrinsic(E, ctx.getGetBoolDecl(nullptr), {},
+                                    ManagedValue::forUnmanaged(selected),
+                                    C);
+  return result;
+}
+
 RValue RValueEmitter::visitCoerceExpr(CoerceExpr *E, SGFContext C) {
   return visit(E->getSubExpr(), C);
 }

lib/Sema/CSApply.cpp

@@ -3299,6 +3299,13 @@ namespace {
       llvm_unreachable("Already type-checked");
     }
 
+    Expr *visitEnumIsCaseExpr(EnumIsCaseExpr *expr) {
+      // Should already be type-checked.
+      Type valueType = simplifyType(expr->getType());
+      expr->setType(valueType);
+      return expr;
+    }
+    
     Expr *visitEditorPlaceholderExpr(EditorPlaceholderExpr *E) {
       Type valueType = simplifyType(E->getType());
       E->setType(valueType);
@@ -6819,32 +6826,10 @@ Expr *Solution::convertOptionalToBool(Expr *expr,
   auto &tc = cs.getTypeChecker();
   tc.requireOptionalIntrinsics(expr->getLoc());
 
-  // Find the library intrinsic.
+  // Match the optional value against its `Some` case.
   auto &ctx = tc.Context;
-  auto *fn = ctx.getOptionalIsSomeDecl(&tc, OTK_Optional);
-  tc.validateDecl(fn);
-
-  // Form a reference to the function. This library intrinsic is generic, so we
-  // need to form substitutions and compute the resulting type.
-  auto unwrappedOptionalType = expr->getType()->getOptionalObjectType();
-
-  Substitution sub(unwrappedOptionalType, {});
-  ConcreteDeclRef fnSpecRef(ctx, fn, sub);
-  auto *fnRef =
-      new (ctx) DeclRefExpr(fnSpecRef, DeclNameLoc(), /*Implicit=*/true);
-
-  TypeSubstitutionMap subMap;
-  auto genericParam = fn->getGenericSignatureOfContext()->getGenericParams()[0];
-  subMap[genericParam->getCanonicalType()->castTo<SubstitutableType>()] =
-      unwrappedOptionalType;
-  fnRef->setType(fn->getInterfaceType().subst(
-      constraintSystem->DC->getParentModule(), subMap, None));
-
-  Expr *call = new (ctx) CallExpr(fnRef, expr, /*Implicit=*/true);
-
-  bool failed = tc.typeCheckExpressionShallow(call, cs.DC);
-  assert(!failed && "Could not call library intrinsic?");
-  (void)failed;
-  return call;
+  auto isSomeExpr = new (ctx) EnumIsCaseExpr(expr, ctx.getOptionalSomeDecl());
+  isSomeExpr->setType(tc.lookupBoolType(cs.DC));
+  return isSomeExpr;
 }
 

lib/Sema/CSGen.cpp

@@ -2810,6 +2810,11 @@ namespace {
     Type visitOpenExistentialExpr(OpenExistentialExpr *expr) {
       llvm_unreachable("Already type-checked");
     }
+    
+    Type visitEnumIsCaseExpr(EnumIsCaseExpr *expr) {
+      // Should already be type-checked.
+      return expr->getType();
+    }
 
     Type visitEditorPlaceholderExpr(EditorPlaceholderExpr *E) {
       if (E->getTypeLoc().isNull()) {

stdlib/public/core/ImplicitlyUnwrappedOptional.swift

@@ -63,14 +63,6 @@ extension ImplicitlyUnwrappedOptional : CustomDebugStringConvertible {
   }
 }
 
-@_transparent
-public // COMPILER_INTRINSIC
-func _stdlib_ImplicitlyUnwrappedOptional_isSome<Wrapped>
-  (_ `self`: Wrapped!) -> Bool {
-
-  return `self` != nil
-}
-
 @_transparent
 public // COMPILER_INTRINSIC
 func _stdlib_ImplicitlyUnwrappedOptional_unwrapped<Wrapped>

stdlib/public/core/Optional.swift

@@ -284,12 +284,6 @@ extension Optional : CustomReflectable {
   }
 }
 
-@_transparent
-public // COMPILER_INTRINSIC
-func _stdlib_Optional_isSome<Wrapped>(_ `self`: Wrapped?) -> Bool {
-  return `self` != nil
-}
-
 @_transparent
 public // COMPILER_INTRINSIC
 func _stdlib_Optional_unwrapped<Wrapped>(_ `self`: Wrapped?) -> Wrapped {

test/SILGen/optional_to_bool.swift

@@ -0,0 +1,25 @@
+// RUN: %target-swift-frontend -emit-silgen %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-runtime
+
+public protocol P {}
+extension Int: P {}
+
+public class A {}
+public class B: A {
+  // CHECK-LABEL: sil @_TFC16optional_to_bool1Bg1x
+  // CHECK:         select_enum {{%.*}} : $Optional<Int>
+  public lazy var x: Int = 0
+  // CHECK-LABEL: sil @_TFC16optional_to_bool1Bg1y
+  // CHECK:         select_enum_addr {{%.*}} : $*Optional<P>
+  public lazy var y: P = 0
+}
+
+// Collection casting is not implemented in non-ObjC runtime
+#if _runtime(_ObjC)
+
+// CHECK-objc-LABEL: sil @_TF16optional_to_bool3foo
+public func foo(x: inout [A]) -> Bool {
+  // CHECK-objc:       select_enum {{%.*}} : $Optional<Array<B>>
+  return x is [B]
+}
+
+#endif