[moveOnly] Add a new SIL specific AST type called SILMoveOnly.

It can only be used in SIL contexts to express that a wrapped type is
MoveOnly.

Author: gottesmm

include/swift/AST/TypeDifferenceVisitor.h

@@ -333,6 +333,11 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {
     return asImpl().visit(type1->getCaptureType(), type2->getCaptureType());
   }
 
+  bool visitSILMoveOnlyType(CanSILMoveOnlyType type1,
+                            CanSILMoveOnlyType type2) {
+    return asImpl().visit(type1->getInnerType(), type2->getInnerType());
+  }
+
   bool visitProtocolCompositionType(CanProtocolCompositionType type1,
                                     CanProtocolCompositionType type2) {
     return visitComponentArray(type1, type2,

include/swift/AST/TypeMatcher.h

@@ -352,6 +352,7 @@ class TypeMatcher {
     TRIVIAL_CASE(SILFunctionType)
     TRIVIAL_CASE(SILBlockStorageType)
     TRIVIAL_CASE(SILBoxType)
+    TRIVIAL_CASE(SILMoveOnlyType)
 
     bool visitProtocolCompositionType(CanProtocolCompositionType firstProtocolComposition,
                                       Type secondType,

include/swift/AST/TypeNodes.def

@@ -159,6 +159,7 @@ ABSTRACT_TYPE(AnyFunction, Type)
 ARTIFICIAL_TYPE(SILFunction, Type)
 ARTIFICIAL_TYPE(SILBlockStorage, Type)
 ARTIFICIAL_TYPE(SILBox, Type)
+ARTIFICIAL_TYPE(SILMoveOnly, Type)
 ARTIFICIAL_TYPE(SILToken, Type)
 TYPE(ProtocolComposition, Type)
 TYPE(ParameterizedProtocol, Type)

include/swift/AST/Types.h

@@ -4995,6 +4995,33 @@ class SILBoxType final : public TypeBase, public llvm::FoldingSetNode
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(SILBoxType, Type)
 
+class SILMoveOnlyType;
+class SILModule; // From SIL
+typedef CanTypeWrapper<SILMoveOnlyType> CanMoveOnlyType;
+
+/// A wrapper type that marks an inner type as being a move only value. Can not
+/// be written directly at the Swift level, instead it is triggered by adding
+/// the type attribute @_moveOnly to a different type. We transform these in
+/// TypeLowering into a moveOnly SILType on the inner type.
+class SILMoveOnlyType final : public TypeBase, public llvm::FoldingSetNode {
+  CanType innerType;
+
+  SILMoveOnlyType(CanType innerType)
+      : TypeBase(TypeKind::SILMoveOnly, &innerType->getASTContext(),
+                 innerType->getRecursiveProperties()),
+        innerType(innerType) {}
+
+public:
+  CanType getInnerType() const { return innerType; }
+
+  static CanMoveOnlyType get(CanType innerType);
+
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::SILMoveOnly;
+  }
+};
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(SILMoveOnlyType, Type)
+
 class SILBlockStorageType;
 typedef CanTypeWrapper<SILBlockStorageType> CanSILBlockStorageType;
 

lib/AST/ASTContext.cpp

@@ -464,6 +464,7 @@ struct ASTContext::Implementation {
   llvm::FoldingSet<GenericFunctionType> GenericFunctionTypes;
   llvm::FoldingSet<SILFunctionType> SILFunctionTypes;
   llvm::DenseMap<CanType, SILBlockStorageType *> SILBlockStorageTypes;
+  llvm::DenseMap<CanType, SILMoveOnlyType *> SILMoveOnlyTypes;
   llvm::FoldingSet<SILBoxType> SILBoxTypes;
   llvm::DenseMap<BuiltinIntegerWidth, BuiltinIntegerType*> IntegerTypes;
   llvm::FoldingSet<BuiltinVectorType> BuiltinVectorTypes;
@@ -4067,6 +4068,19 @@ SILFunctionType::SILFunctionType(
 #endif
 }
 
+CanSILMoveOnlyType SILMoveOnlyType::get(CanType innerType) {
+  ASTContext &ctx = innerType->getASTContext();
+  auto found = ctx.getImpl().SILMoveOnlyTypes.find(innerType);
+  if (found != ctx.getImpl().SILMoveOnlyTypes.end())
+    return CanSILMoveOnlyType(found->second);
+
+  void *mem = ctx.Allocate(sizeof(SILMoveOnlyType), alignof(SILMoveOnlyType));
+
+  auto *storageTy = new (mem) SILMoveOnlyType(innerType);
+  ctx.getImpl().SILMoveOnlyTypes.insert({innerType, storageTy});
+  return CanSILMoveOnlyType(storageTy);
+}
+
 CanSILBlockStorageType SILBlockStorageType::get(CanType captureType) {
   ASTContext &ctx = captureType->getASTContext();
   auto found = ctx.getImpl().SILBlockStorageTypes.find(captureType);

lib/AST/ASTDumper.cpp

@@ -3935,6 +3935,12 @@ namespace {
       PrintWithColorRAII(OS, ParenthesisColor) << ')';
     }
 
+    void visitSILMoveOnlyType(SILMoveOnlyType *T, StringRef label) {
+      printCommon(label, "sil_move_only_type");
+      printRec(T->getInnerType());
+      PrintWithColorRAII(OS, ParenthesisColor) << ')';
+    }
+
     void visitSILBoxType(SILBoxType *T, StringRef label) {
       printCommon(label, "sil_box_type");
       // FIXME: Print the structure of the type.

lib/AST/ASTMangler.cpp

@@ -1448,7 +1448,9 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
 
       return;
     }
-
+    case TypeKind::SILMoveOnly:
+      // If we hit this, we just mangle the underlying name and move on.
+      llvm_unreachable("should never be mangled?");
     case TypeKind::SILBlockStorage:
       llvm_unreachable("should never be mangled");
   }

lib/AST/ASTPrinter.cpp

@@ -6193,6 +6193,11 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
   }
 
+  void visitSILMoveOnlyType(SILMoveOnlyType *T) {
+    Printer << "@moveOnly ";
+    printWithParensIfNotSimple(T->getInnerType());
+  }
+
   void visitArraySliceType(ArraySliceType *T) {
     Printer << "[";
     visit(T->getBaseType());

lib/AST/ExistentialGeneralization.cpp

@@ -175,6 +175,7 @@ class Generalizer : public CanTypeVisitor<Generalizer, Type> {
   INVALID_TO_GENERALIZE(SILBox)
   INVALID_TO_GENERALIZE(SILFunction)
   INVALID_TO_GENERALIZE(SILToken)
+  INVALID_TO_GENERALIZE(SILMoveOnly)
 #undef INVALID_TO_GENERALIZE
 
   /// Generalize the generic arguments of the given generic type.s

lib/AST/Type.cpp

@@ -189,6 +189,9 @@ bool CanType::isReferenceTypeImpl(CanType type, const GenericSignatureImpl *sig,
   case TypeKind::DynamicSelf:
     return isReferenceTypeImpl(cast<DynamicSelfType>(type).getSelfType(),
                                sig, functionsCount);
+  case TypeKind::SILMoveOnly:
+    return isReferenceTypeImpl(cast<SILMoveOnlyType>(type)->getInnerType(), sig,
+                               functionsCount);
 
   // Archetypes and existentials are only class references if class-bounded.
   case TypeKind::PrimaryArchetype:
@@ -1632,6 +1635,7 @@ CanType TypeBase::computeCanonicalType() {
   case TypeKind::SILBox:
   case TypeKind::SILFunction:
   case TypeKind::SILToken:
+  case TypeKind::SILMoveOnly:
     llvm_unreachable("SIL-only types are always canonical!");
 
   case TypeKind::ProtocolComposition: {
@@ -5086,6 +5090,18 @@ case TypeKind::Id:
     return storageTy;
   }
 
+  case TypeKind::SILMoveOnly: {
+    auto *storageTy = cast<SILMoveOnlyType>(base);
+    Type transCap = storageTy->getInnerType().transformWithPosition(
+        TypePosition::Invariant, fn);
+    if (!transCap)
+      return Type();
+    CanType canTransCap = transCap->getCanonicalType();
+    if (canTransCap != storageTy->getInnerType())
+      return SILMoveOnlyType::get(canTransCap);
+    return storageTy;
+  }
+
   case TypeKind::SILBox: {
     bool changed = false;
     auto boxTy = cast<SILBoxType>(base);
@@ -5996,6 +6012,8 @@ ReferenceCounting TypeBase::getReferenceCounting() {
   case TypeKind::DynamicSelf:
     return cast<DynamicSelfType>(type).getSelfType()
         ->getReferenceCounting();
+  case TypeKind::SILMoveOnly:
+    return cast<SILMoveOnlyType>(type)->getInnerType()->getReferenceCounting();
 
   case TypeKind::PrimaryArchetype:
   case TypeKind::OpenedArchetype:

lib/AST/TypeWalker.cpp

@@ -234,6 +234,10 @@ class Traversal : public TypeVisitor<Traversal, bool>
     return doIt(ty->getCaptureType());
   }
 
+  bool visitSILMoveOnlyType(SILMoveOnlyType *ty) {
+    return doIt(ty->getInnerType());
+  }
+
   bool visitSILBoxType(SILBoxType *ty) {
     for (Type type : ty->getSubstitutions().getReplacementTypes()) {
       if (type && doIt(type))

lib/ClangImporter/ImportType.cpp

@@ -1919,6 +1919,7 @@ class GetSendableType :
   NEVER_VISIT(SILBlockStorageType)
   NEVER_VISIT(SILBoxType)
   NEVER_VISIT(SILTokenType)
+  NEVER_VISIT(SILMoveOnlyType)
 
   VISIT(ProtocolCompositionType, compose)
 

lib/IRGen/GenType.cpp

@@ -2169,6 +2169,8 @@ const TypeInfo *TypeConverter::convertType(CanType ty) {
   case TypeKind::BoundGenericEnum:
   case TypeKind::BoundGenericStruct:
     return convertAnyNominalType(ty, cast<BoundGenericType>(ty)->getDecl());
+  case TypeKind::SILMoveOnly:
+    llvm_unreachable("implement this");
   case TypeKind::InOut:
     return convertInOutType(cast<InOutType>(ty));
   case TypeKind::Tuple:

lib/IRGen/GenType.h

@@ -158,6 +158,9 @@ class TypeConverter {
   const TypeInfo *convertBoxType(SILBoxType *T);
   const TypeInfo *convertArchetypeType(ArchetypeType *T);
   const TypeInfo *convertInOutType(InOutType *T);
+  const TypeInfo *convertSILMoveOnlyType(SILMoveOnlyType *T) {
+    return convertType(T->getInnerType());
+  }
   const TypeInfo *convertExistentialMetatypeType(ExistentialMetatypeType *T);
   const TypeInfo *convertMetatypeType(MetatypeType *T);
   const TypeInfo *convertModuleType(ModuleType *T);

lib/IRGen/IRGenDebugInfo.cpp

@@ -1724,6 +1724,7 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
     case TypeKind::SILToken:
     case TypeKind::BuiltinUnsafeValueBuffer:
     case TypeKind::BuiltinDefaultActorStorage:
+    case TypeKind::SILMoveOnly:
 
       LLVM_DEBUG(llvm::dbgs() << "Unhandled type: ";
                  DbgTy.getType()->dump(llvm::dbgs()); llvm::dbgs() << "\n");

lib/IRGen/MetadataRequest.cpp

@@ -1941,7 +1941,10 @@ namespace {
                                           DynamicMetadataRequest request) {
       llvm_unreachable("should not be asking for metadata of a SILToken type");
     }
-
+    MetadataResponse visitSILMoveOnlyType(CanSILMoveOnlyType type,
+                                          DynamicMetadataRequest request) {
+      llvm_unreachable("should not be asking for metadata of a move only type");
+    }
     MetadataResponse visitArchetypeType(CanArchetypeType type,
                                         DynamicMetadataRequest request) {
       return emitArchetypeTypeMetadataRef(IGF, type, request);

lib/SIL/IR/TypeLowering.cpp

@@ -666,6 +666,14 @@ namespace {
           type, getReferenceRecursiveProperties(isSensitive));
     }
 
+    RetTy visitSILMoveOnlyType(CanSILMoveOnlyType type,
+                               AbstractionPattern origType,
+                               IsTypeExpansionSensitive_t isSensitive) {
+      return asImpl().handleReference(
+          type->getInnerType()->getCanonicalType(),
+          getReferenceRecursiveProperties(isSensitive));
+    }
+
     RetTy handleAggregateByProperties(CanType type, RecursiveProperties props) {
       if (props.isAddressOnly()) {
         return asImpl().handleAddressOnly(type, props);

lib/Sema/TypeCheckType.cpp

@@ -2842,7 +2842,7 @@ TypeResolver::resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
 
   // In SIL *only*, allow @moveOnly to specify a moveOnly type.
   if ((options & TypeResolutionFlags::SILType) && attrs.has(TAK_moveOnly)) {
-    //ty = ty->getCanonicalType()->getMoveOnlyType();
+    ty = SILMoveOnlyType::get(ty->getCanonicalType());
     attrs.clearAttribute(TAK_moveOnly);
   }
 

lib/Serialization/DeclTypeRecordNodes.def

@@ -108,6 +108,7 @@ TYPE(SIL_FUNCTION)
 TYPE(DYNAMIC_SELF)
 TYPE(EXISTENTIAL_METATYPE)
 TYPE(SIL_BLOCK_STORAGE)
+TYPE(SIL_MOVE_ONLY)
 TYPE(SIL_BOX)
 TYPE(NAME_ALIAS)
 

lib/Serialization/Deserialization.cpp

@@ -5939,6 +5939,13 @@ Expected<Type> DESERIALIZE_TYPE(SIL_BLOCK_STORAGE_TYPE)(
   return SILBlockStorageType::get(MF.getType(captureID)->getCanonicalType());
 }
 
+Expected<Type> DESERIALIZE_TYPE(SIL_MOVE_ONLY_TYPE)(
+    ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
+  TypeID innerType;
+  decls_block::SILMoveOnlyTypeLayout::readRecord(scratch, innerType);
+  return SILMoveOnlyType::get(MF.getType(innerType)->getCanonicalType());
+}
+
 Expected<Type> DESERIALIZE_TYPE(SIL_BOX_TYPE)(
     ModuleFile &MF, SmallVectorImpl<uint64_t> &scratch, StringRef blobData) {
   SILLayoutID layoutID;

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 691; // bump to avoid conflict
+const uint16_t SWIFTMODULE_VERSION_MINOR = 692; // move only type wrapper
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1208,6 +1208,11 @@ namespace decls_block {
     TypeIDField // capture type
   );
 
+  TYPE_LAYOUT(SILMoveOnlyTypeLayout,
+    SIL_MOVE_ONLY_TYPE,
+    TypeIDField            // inner type
+  );
+
   using SILLayoutLayout = BCRecordLayout<
     SIL_LAYOUT,
     GenericSignatureIDField,    // generic signature

lib/Serialization/Serialization.cpp

@@ -4720,6 +4720,11 @@ class Serializer::TypeSerializer : public TypeVisitor<TypeSerializer> {
         storageTy->getCaptureType());
   }
 
+  void visitSILMoveOnlyType(const SILMoveOnlyType *moveOnlyTy) {
+    using namespace decls_block;
+    serializeSimpleWrapper<SILMoveOnlyTypeLayout>(moveOnlyTy->getInnerType());
+  }
+
   void visitSILBoxType(const SILBoxType *boxTy) {
     using namespace decls_block;
     unsigned abbrCode = S.DeclTypeAbbrCodes[SILBoxTypeLayout::Code];

test/SIL/Parser/basic2.sil

@@ -97,3 +97,19 @@ bb0(%0 : @owned $Builtin.NativeObject):
   %9999 = tuple()
   return %9999 : $()
 }
+
+// Make sure that we properly can parse/print/round trip move only type annotation.
+// CHECK-LABEL: sil [ossa] @test_moveonlytype_parsing : $@convention(thin) (@owned @moveOnly Builtin.NativeObject) -> () {
+// CHECK: bb0(%0 : @owned $@moveOnly Builtin.NativeObject):
+// CHECK-NEXT:   %1 = copy_value %0 : $@moveOnly Builtin.NativeObject
+// CHECK-NEXT:   destroy_value %0 : $@moveOnly Builtin.NativeObject
+// CHECK-NEXT:   destroy_value %1 : $@moveOnly Builtin.NativeObject
+// CHECK: } // end sil function 'test_moveonlytype_parsing'
+sil [ossa] @test_moveonlytype_parsing : $@convention(thin) (@owned @moveOnly Builtin.NativeObject) -> () {
+bb0(%0 : @owned $@moveOnly Builtin.NativeObject):
+  %1 = copy_value %0 : $@moveOnly Builtin.NativeObject
+  destroy_value %0 : $@moveOnly Builtin.NativeObject
+  destroy_value %1 : $@moveOnly Builtin.NativeObject
+  %9999 = tuple()
+  return %9999 : $()
+}