Fold ExtInfo::isThin and ::isBlock into a "Representation" enum.

These bits are orthogonal to each other, so combine them into one, and diagnose attempts to produce a type that's both. Spot-fix a bunch of places this revealed by inspection that we would have crashed in SILGen or IRGen if blocks were be handled.

Swift SVN r16088

Author: jckarter

include/swift/AST/DiagnosticsSema.def

@@ -981,6 +981,8 @@ ERROR(first_class_generic_function,type_parsing,PointsToFirstBadToken,
       "generic types cannot be used as first-class types", ())
 ERROR(autoclosure_function_input_nonunit,attribute_parsing,none,
       "auto_closure argument type must be '()'", ())
+ERROR(objc_block_cannot_be_thin,attribute_parsing,none,
+      "@objc_block function type cannot be @thin", ())
 
 // SIL
 ERROR(sil_local_storage_nested, decl_parsing,none,

include/swift/AST/Types.h

@@ -1702,21 +1702,33 @@ class AnyFunctionType : public TypeBase {
   const Type Output;
 
 public:
+  /// \brief The representation form of a function.
+  enum class Representation {
+    // A "thick" function that carries a context pointer to reference captured
+    // state. The default.
+    Thick = 0,
+    
+    // A thick function that is represented as an Objective-C block.
+    Block,
+    
+    // A "thin" function that needs no context.
+    Thin,
+  };
+  
   /// \brief A class which abstracts out some details necessary for
   /// making a call.
   class ExtInfo {
     // Feel free to rearrange or add bits, but if you go over 7,
     // you'll need to adjust both the Bits field below and
     // BaseType::AnyFunctionTypeBits.
 
-    //   |  CC  |isThin|isAutoClosure|isBlock|noReturn|
-    //   |0 .. 3|   4  |      5      |   6   |   7    |
+    //   |  CC  |representation|isAutoClosure|noReturn|
+    //   |0 .. 3|    4 .. 5    |      6      |   7    |
     //
-    enum { CallConvMask = 0xF };
-    enum { ThinMask = 0x10 };
-    enum { AutoClosureMask = 0x20 };
-    enum { BlockMask = 0x40 };
-    enum { NoReturnMask = 0x80 };
+    enum : uint16_t { CallConvMask = 0xF };
+    enum : uint16_t { RepresentationMask = 0x30, RepresentationShift = 4 };
+    enum : uint16_t { AutoClosureMask = 0x40 };
+    enum : uint16_t { NoReturnMask = 0x80 };
 
     uint16_t Bits;
 
@@ -1732,40 +1744,49 @@ class AnyFunctionType : public TypeBase {
     }
 
     // Constructor for polymorphic type.
-    ExtInfo(AbstractCC CC, bool IsThin, bool IsNoReturn) {
+    ExtInfo(AbstractCC CC, Representation Rep, bool IsNoReturn) {
       Bits = ((unsigned) CC) |
-             (IsThin ? ThinMask : 0) |
+             ((unsigned) Rep << RepresentationShift) |
              (IsNoReturn ? NoReturnMask : 0);
     }
 
     // Constructor with no defaults.
-    ExtInfo(AbstractCC CC, bool IsThin, bool IsNoReturn,
-            bool IsAutoClosure, bool IsBlock) : ExtInfo(CC, IsThin, IsNoReturn){
+    ExtInfo(AbstractCC CC, Representation Rep, bool IsNoReturn,
+            bool IsAutoClosure) : ExtInfo(CC, Rep, IsNoReturn){
       Bits = Bits |
-             (IsAutoClosure ? AutoClosureMask : 0) |
-             (IsBlock ? BlockMask : 0);
+             (IsAutoClosure ? AutoClosureMask : 0);
     }
 
     explicit ExtInfo(AbstractCC CC) : Bits(0) {
       Bits = (Bits & ~CallConvMask) | (unsigned) CC;
     }
 
     AbstractCC getCC() const { return AbstractCC(Bits & CallConvMask); }
-    bool isThin() const { return Bits & ThinMask; }
     bool isNoReturn() const { return Bits & NoReturnMask; }
     bool isAutoClosure() const { return Bits & AutoClosureMask; }
-    bool isBlock() const { return Bits & BlockMask; }
-
+    Representation getRepresentation() const {
+      return Representation((Bits & RepresentationMask) >> RepresentationShift);
+    }
+    
+    /// True if the function representation carries context.
+    bool hasContext() const {
+      switch (getRepresentation()) {
+      case Representation::Thick:
+      case Representation::Block:
+        return true;
+      case Representation::Thin:
+        return false;
+      }
+    }
+    
     // Note that we don't have setters. That is by design, use
     // the following with methods instead of mutating these objects.
     ExtInfo withCallingConv(AbstractCC CC) const {
       return ExtInfo((Bits & ~CallConvMask) | (unsigned) CC);
     }
-    ExtInfo withIsThin(bool IsThin) const {
-      if (IsThin)
-        return ExtInfo(Bits | ThinMask);
-      else
-        return ExtInfo(Bits & ~ThinMask);
+    ExtInfo withRepresentation(Representation Rep) const {
+      return ExtInfo((Bits & ~RepresentationMask)
+                     | (unsigned)Rep << RepresentationShift);
     }
     ExtInfo withIsNoReturn(bool IsNoReturn) const {
       if (IsNoReturn)
@@ -1779,13 +1800,7 @@ class AnyFunctionType : public TypeBase {
       else
         return ExtInfo(Bits & ~AutoClosureMask);
     }
-    ExtInfo withIsBlock(bool IsBlock) const {
-      if (IsBlock)
-        return ExtInfo(Bits | BlockMask);
-      else
-        return ExtInfo(Bits & ~BlockMask);
-    }
-
+    
     char getFuncAttrKey() const {
       return Bits;
     }
@@ -1820,12 +1835,11 @@ class AnyFunctionType : public TypeBase {
     return getExtInfo().getCC();
   }
 
-  /// \brief True if the function type is "thin", meaning values of the type can
-  /// be represented as simple function pointers without context.
-  bool isThin() const {
-    return getExtInfo().isThin();
+  /// \brief Get the representation of the function type.
+  Representation getRepresentation() const {
+    return getExtInfo().getRepresentation();
   }
-
+  
   bool isNoReturn() const {
     return getExtInfo().isNoReturn();
   }
@@ -1836,11 +1850,6 @@ class AnyFunctionType : public TypeBase {
     return getExtInfo().isAutoClosure();
   }
 
-  /// \brief True if this type is an Objective-C-compatible block type.
-  bool isBlock() const {
-    return getExtInfo().isBlock();
-  }
-
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {
     return T->getKind() >= TypeKind::First_AnyFunctionType &&
@@ -2263,7 +2272,8 @@ typedef CanTypeWrapper<SILFunctionType> CanSILFunctionType;
 class SILFunctionType : public TypeBase, public llvm::FoldingSetNode {
 public:
   typedef AnyFunctionType::ExtInfo ExtInfo;
-
+  typedef AnyFunctionType::Representation Representation;
+  
 private:
   CanGenericSignature GenericSig;
 
@@ -2360,17 +2370,11 @@ class SILFunctionType : public TypeBase, public llvm::FoldingSetNode {
     return getExtInfo().getCC();
   }
 
-  /// \brief True if this type is an Objective-C-compatible block type.
-  bool isBlock() const {
-    return getExtInfo().isBlock();
+  /// \brief Get the representation of the function type.
+  Representation getRepresentation() const {
+    return getExtInfo().getRepresentation();
   }
 
-  /// \brief True if the function type is "thin", meaning values of the type can
-  /// be represented as simple function pointers without context.
-  bool isThin() const {
-    return getExtInfo().isThin();
-  }
-
   bool isNoReturn() const {
     return getExtInfo().isNoReturn();
   }

include/swift/SIL/SILBuilder.h

@@ -710,10 +710,9 @@ class SILBuilder {
     ASTContext &AST = F.getModule().getASTContext();
     // builtin_function_ref "int_trap" : $@thin @noreturn () -> ()
     auto bfrInfo = SILFunctionType::ExtInfo(AbstractCC::Freestanding,
-                                            /*thin*/ true,
-                                            /*noreturn*/ true,
-                                            /*autoclosure*/ false,
-                                            /*block*/ false);
+                                          SILFunctionType::Representation::Thin,
+                                          /*noreturn*/ true,
+                                          /*autoclosure*/ false);
     SILResultInfo Result(TupleType::getEmpty(AST), ResultConvention::Unowned);
     auto bfrFnType = SILFunctionType::get(nullptr, bfrInfo,
                                           ParameterConvention::Direct_Owned,

include/swift/SIL/TypeLowering.h

@@ -41,30 +41,20 @@ const ParameterConvention DefaultThickCalleeConvention =
 CanAnyFunctionType adjustFunctionType(CanAnyFunctionType type,
                                       AnyFunctionType::ExtInfo extInfo);
 
-/// Make the given function type @thin and change its CC.
-inline CanAnyFunctionType getThinFunctionType(CanAnyFunctionType t,
-                                              AbstractCC cc) {
-  auto extInfo = t->getExtInfo().withIsThin(true).withCallingConv(cc);
+/// Change the given function type's representation and CC.
+inline CanAnyFunctionType adjustFunctionType(CanAnyFunctionType t,
+                                          AbstractCC cc,
+                                          AnyFunctionType::Representation rep) {
+  auto extInfo = t->getExtInfo().withRepresentation(rep).withCallingConv(cc);
   return adjustFunctionType(t, extInfo);
 }
-/// Make the given function type @thin.
-inline CanAnyFunctionType getThinFunctionType(CanAnyFunctionType t) {
-  auto extInfo = t->getExtInfo().withIsThin(true);
+/// Change the given function type's representation.
+inline CanAnyFunctionType adjustFunctionType(CanAnyFunctionType t,
+                                          AnyFunctionType::Representation rep) {
+  auto extInfo = t->getExtInfo().withRepresentation(rep);
   return adjustFunctionType(t, extInfo);  
 }
-
-/// Make the given function type no longer @thin and change its CC.
-inline CanAnyFunctionType getThickFunctionType(CanAnyFunctionType t,
-                                               AbstractCC cc) {
-  auto extInfo = t->getExtInfo().withIsThin(false).withCallingConv(cc);
-  return adjustFunctionType(t, extInfo);
-}
-/// Make the given function type no longer @thin.
-inline CanAnyFunctionType getThickFunctionType(CanAnyFunctionType t) {
-  auto extInfo = t->getExtInfo().withIsThin(false);
-  return adjustFunctionType(t, extInfo);
-}
-
+  
 /// Given a SIL function type, return a type that is identical except
 /// for using the given ExtInfo.
 CanSILFunctionType adjustFunctionType(CanSILFunctionType type,
@@ -74,17 +64,16 @@ inline CanSILFunctionType adjustFunctionType(CanSILFunctionType type,
                                       SILFunctionType::ExtInfo extInfo) {
   return adjustFunctionType(type, extInfo, type->getCalleeConvention());
 }
-inline CanSILFunctionType getThinFunctionType(CanSILFunctionType t) {
-  if (t->isThin()) return t;
-  return adjustFunctionType(t, t->getExtInfo().withIsThin(true),
-                            ParameterConvention::Direct_Unowned);
-}
-inline CanSILFunctionType getThickFunctionType(CanSILFunctionType t) {
-  if (!t->isThin()) return t;
-  return adjustFunctionType(t, t->getExtInfo().withIsThin(false),
-                            DefaultThickCalleeConvention);
+inline CanSILFunctionType adjustFunctionType(CanSILFunctionType t,
+                                         SILFunctionType::Representation rep) {
+  if (t->getRepresentation() == rep) return t;
+  auto extInfo = t->getExtInfo().withRepresentation(rep);
+  
+  return adjustFunctionType(t, extInfo,
+                    extInfo.hasContext() ? DefaultThickCalleeConvention
+                                         : ParameterConvention::Direct_Unowned);
 }
-
+  
 /// Different ways in which a function can capture context.
 enum class CaptureKind {
   /// No context arguments are necessary.
@@ -618,7 +607,7 @@ class TypeConverter {
   CanSILFunctionType getConstantFunctionType(SILDeclRef constant,
                                    CanAnyFunctionType substFormalType,
                                    CanAnyFunctionType substFormalInterfaceType,
-                                   bool thin);
+                                   AnyFunctionType::Representation rep);
 
   /// Substitute the given function type so that it implements the
   /// given substituted type.

include/swift/Serialization/ModuleFormat.h

@@ -40,7 +40,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// Serialized module format minor version number.
 ///
 /// When the format changes IN ANY WAY, this number should be incremented.
-const uint16_t VERSION_MINOR = 46;
+const uint16_t VERSION_MINOR = 49;
 
 using DeclID = Fixnum<31>;
 using DeclIDField = BCFixed<31>;
@@ -531,6 +531,7 @@ namespace decls_block {
     ParameterConventionField, // callee convention
     AbstractCCField,       // calling convention
     BCFixed<1>,            // thin?
+    BCFixed<1>,            // block?
     BCFixed<1>,            // noreturn?
     BCFixed<30>,           // number of generic parameters
     BCArray<TypeIDField>   // parameter types and conventions, alternating

lib/AST/ASTPrinter.cpp

@@ -1695,11 +1695,18 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       Printer << "@cc(witness_method) ";
       break;
     }
-
-    if (info.isBlock())
-      Printer << "@objc_block ";
-    if (info.isThin())
+    
+    switch (info.getRepresentation()) {
+    case AnyFunctionType::Representation::Thick:
+      break;
+    case AnyFunctionType::Representation::Thin:
       Printer << "@thin ";
+      break;
+    case AnyFunctionType::Representation::Block:
+      Printer << "@objc_block ";
+      break;
+    }
+
     if (info.isNoReturn())
       Printer << "@noreturn ";
   }

lib/AST/Decl.cpp

@@ -1779,7 +1779,7 @@ bool AbstractStorageDecl::usesObjCGetterAndSetter() const {
   // blocks.
   if (isa<VarDecl>(this)) {
     if (auto ft = getType()->getAs<AnyFunctionType>())
-      return ft->isBlock();
+      return ft->getRepresentation() == AnyFunctionType::Representation::Block;
   }
 
   return true;

lib/AST/Mangle.cpp

@@ -823,14 +823,14 @@ void Mangler::mangleType(CanType type, ResilienceExpansion explosion,
     };
 
     // <impl-callee-convention>
-    if (fn->isThin()) {
+    if (fn->getRepresentation() == AnyFunctionType::Representation::Thin) {
       Buffer << 't';
     } else {
       Buffer << mangleParameterConvention(fn->getCalleeConvention());
     }
 
     // <impl-function-attribute>*
-    if (fn->isBlock()) {
+    if (fn->getRepresentation() == AnyFunctionType::Representation::Block) {
       Buffer << "Cb";
     } else {
       switch (fn->getAbstractCC()) {
@@ -1149,7 +1149,7 @@ void Mangler::mangleFunctionType(CanAnyFunctionType fn,
   // type ::= 'f' type type (uncurried)
   // type ::= 'b' type type (objc block)
   // type ::= 'K' type type (auto closure)
-  if (fn->isBlock())
+  if (fn->getRepresentation() == AnyFunctionType::Representation::Block)
     Buffer << 'b';
   else if (fn->isAutoClosure())
     Buffer << 'K';

lib/AST/Type.cpp

@@ -1121,9 +1121,7 @@ bool TypeBase::isSpelledLike(Type other) {
     auto fThem = cast<FunctionType>(them);
     if (fMe->isAutoClosure() != fThem->isAutoClosure())
       return false;
-    if (fMe->isBlock() != fThem->isBlock())
-      return false;
-    if (fMe->isThin() != fThem->isThin())
+    if (fMe->getRepresentation() != fThem->getRepresentation())
       return false;
     if (fMe->isNoReturn() != fThem->isNoReturn())
       return false;
@@ -1285,9 +1283,11 @@ static bool hasRetainablePointerRepresentation(CanType type) {
 
   // Blocks.
   if (auto fnType = dyn_cast<AnyFunctionType>(type)) {
-    return fnType->isBlock();
+    return fnType->getRepresentation()
+      == AnyFunctionType::Representation::Block;
   } else if (auto fnType = dyn_cast<SILFunctionType>(type)) {
-    return fnType->isBlock();
+    return fnType->getRepresentation()
+      == AnyFunctionType::Representation::Block;
   }
 
   // Class metatypes.

lib/ClangImporter/ImportType.cpp

@@ -231,7 +231,8 @@ namespace {
         return Type();
       FunctionType *fTy = pointeeType->castTo<FunctionType>();
       return FunctionType::get(fTy->getInput(), fTy->getResult(),
-                               fTy->getExtInfo().withIsBlock(true));
+                 fTy->getExtInfo()
+                   .withRepresentation(AnyFunctionType::Representation::Block));
     }
 
     Type VisitReferenceType(const clang::ReferenceType *type) {