Merge pull request #2942 from jckarter/optional-codegen-improvements

Optional codegen improvements

Author: jckarter

include/swift/AST/ASTContext.h

@@ -454,15 +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,
-                                     OptionalTypeKind kind) const;
-
   /// Check whether the standard library provides all the correct
   /// intrinsic support for Optional<T>.
   ///

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,12 +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] = {};
-
   /// The declaration of Swift.ImplicitlyUnwrappedOptional<T>.
   EnumDecl *ImplicitlyUnwrappedOptionalDecl = nullptr;
 
@@ -1058,29 +1052,6 @@ FuncDecl *ASTContext::getIsOSVersionAtLeastDecl(LazyResolver *resolver) const {
   return decl;
 }
 
-/// Check whether the given function is generic over a single,
-/// unconstrained archetype.
-static bool isGenericIntrinsic(FuncDecl *fn, CanType &input, CanType &output,
-                               CanType &param) {
-  auto fnType =
-    dyn_cast<GenericFunctionType>(fn->getInterfaceType()->getCanonicalType());
-  if (!fnType || fnType->getGenericParams().size() != 1)
-    return false;
-
-  bool hasRequirements = std::any_of(fnType->getRequirements().begin(),
-                                     fnType->getRequirements().end(),
-                                     [](const Requirement &req) -> bool {
-    return req.getKind() != RequirementKind::WitnessMarker;
-  });
-  if (hasRequirements)
-    return false;
-
-  param = CanGenericTypeParamType(fnType->getGenericParams().front());
-  input = stripImmediateLabels(fnType.getInput());
-  output = stripImmediateLabels(fnType.getResult());
-  return true;
-}
-
 // Find library intrinsic function.
 static FuncDecl *findLibraryFunction(const ASTContext &ctx, FuncDecl *&cache, 
                                      StringRef name, LazyResolver *resolver) {
@@ -1097,97 +1068,11 @@ FuncDecl *ASTContext::get##Name(LazyResolver *resolver) const {     \
 }
 #include "swift/AST/KnownDecls.def"
 
-/// Check whether the given type is Optional applied to the given
-/// type argument.
-static bool isOptionalType(const ASTContext &ctx,
-                           OptionalTypeKind optionalKind,
-                           CanType type, CanType arg) {
-  if (auto boundType = dyn_cast<BoundGenericType>(type)) {
-    return (boundType->getDecl()->classifyAsOptionalType() == optionalKind &&
-            boundType.getGenericArgs().size() == 1 &&
-            boundType.getGenericArgs()[0] == arg);
-  }
-  return false;
-}
-
-/// Turn an OptionalTypeKind into an index into one of the caches.
-static unsigned asIndex(OptionalTypeKind optionalKind) {
-  assert(optionalKind && "passed a non-optional type kind?");
-  return unsigned(optionalKind) - 1;
-}
-
-#define getOptionalIntrinsicName(PREFIX, KIND, SUFFIX) \
-  ((KIND) == OTK_Optional                              \
-    ? (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)];
-  if (cache) return cache;
-
-  auto name = getOptionalIntrinsicName(
-      "_stdlib_", optionalKind, "_unwrapped");
-
-  // Look for the 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 T.
-  if (output != param)
-    return nullptr;
-
-  cache = decl;
-  return decl;
-}
-
-static bool hasOptionalIntrinsics(const ASTContext &ctx, LazyResolver *resolver,
-                                  OptionalTypeKind optionalKind) {
-  return ctx.getOptionalIsSomeDecl(resolver, optionalKind) &&
-    ctx.getOptionalUnwrappedDecl(resolver, optionalKind);
-}
-
 bool ASTContext::hasOptionalIntrinsics(LazyResolver *resolver) const {
   return getOptionalDecl() &&
          getOptionalSomeDecl() &&
          getOptionalNoneDecl() &&
-         ::hasOptionalIntrinsics(*this, resolver, OTK_Optional) &&
-         ::hasOptionalIntrinsics(*this, resolver, OTK_ImplicitlyUnwrappedOptional);
+         getDiagnoseUnexpectedNilOptional(resolver);
 }
 
 bool ASTContext::hasPointerArgumentIntrinsics(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/SILGenConvert.cpp

@@ -149,20 +149,6 @@ getOptionalSomeValue(SILLocation loc, ManagedValue value,
   return emitManagedRValueWithCleanup(result, optTL);
 }
 
-static Substitution getSimpleSubstitution(GenericSignature *genericSig,
-                                          CanType typeArg) {
-  assert(genericSig->getGenericParams().size() == 1);
-  return Substitution{typeArg, {}};
-}
-
-/// Create the correct substitution for calling the given function at
-/// the given type.
-static Substitution getSimpleSubstitution(FuncDecl *fn, CanType typeArg) {
-  auto genericFnType =
-    cast<GenericFunctionType>(fn->getInterfaceType()->getCanonicalType());
-  return getSimpleSubstitution(genericFnType->getGenericSignature(), typeArg);
-}
-
 static CanType getOptionalValueType(SILType optType,
                                     OptionalTypeKind &optionalKind) {
   auto generic = cast<BoundGenericType>(optType.getSwiftRValueType());
@@ -172,19 +158,24 @@ static CanType getOptionalValueType(SILType optType,
 }
 
 void SILGenFunction::emitPreconditionOptionalHasValue(SILLocation loc,
-                                                      SILValue addr) {
+                                                      SILValue optional) {
   OptionalTypeKind OTK;
-  getOptionalValueType(addr->getType().getObjectType(), OTK);
+  getOptionalValueType(optional->getType().getObjectType(), OTK);
 
-  // Generate code to the optional is present, and if not abort with a message
+  // Generate code to the optional is present, and if not, abort with a message
   // (provided by the stdlib).
   SILBasicBlock *contBB = createBasicBlock();
   SILBasicBlock *failBB = createBasicBlock();
 
   auto NoneEnumElementDecl = getASTContext().getOptionalNoneDecl(OTK);
-  B.createSwitchEnumAddr(loc, addr, /*defaultDest*/contBB,
-                         { { NoneEnumElementDecl, failBB }});
-
+  if (optional->getType().isAddress()) {
+    B.createSwitchEnumAddr(loc, optional, /*defaultDest*/contBB,
+                           { { NoneEnumElementDecl, failBB }});
+  } else {
+    B.createSwitchEnum(loc, optional, /*defaultDest*/contBB,
+                       { { NoneEnumElementDecl, failBB }});
+    
+  }
   B.emitBlock(failBB);
 
   // Call the standard library implementation of _diagnoseUnexpectedNilOptional.
@@ -221,27 +212,8 @@ ManagedValue SILGenFunction::emitCheckedGetOptionalValueFrom(SILLocation loc,
                                                       ManagedValue src,
                                                       const TypeLowering &optTL,
                                                       SGFContext C) {
-  SILType optType = src.getType().getObjectType();
-  OptionalTypeKind optionalKind;
-  CanType valueType = getOptionalValueType(optType, optionalKind);
-
-  FuncDecl *fn = getASTContext().getOptionalUnwrappedDecl(
-      nullptr, optionalKind);
-  Substitution sub = getSimpleSubstitution(fn, valueType);
-
-  // The intrinsic takes its parameter indirectly.
-  if (src.getType().isObject()) {
-    auto buf = emitTemporaryAllocation(loc, src.getType());
-    B.createStore(loc, src.forward(*this), buf);
-    src = emitManagedBufferWithCleanup(buf);
-  }
-
-  RValue result = emitApplyOfLibraryIntrinsic(loc, fn, sub, src, C);
-  if (result) {
-    return std::move(result).getAsSingleValue(*this, loc);
-  } else {
-    return ManagedValue::forInContext();
-  }
+  emitPreconditionOptionalHasValue(loc, src.getValue());
+  return emitUncheckedGetOptionalValueFrom(loc, src, optTL, C);
 }
 
 ManagedValue SILGenFunction::emitUncheckedGetOptionalValueFrom(SILLocation loc,