[move-keyword] Remove old implementation.

By using the keyword instead of the function, we actually get a much simpler
implementation since we avoid all of the machinery of SILGenApply. Given that we
are going down that path, I am removing the old builtin implementation since it
is dead code.

The reason why I am removing this now is that in a subsequent commit, I want to
move all of the ownership checking passes to run /before/ mandatory inlining. I
originally placed the passes after mandatory inlining since the function version
of the move keyword was transparent and needing to be inlined before we could
process it. Since we use the keyword now, that is no longer an issue.

Author: gottesmm

include/swift/AST/Builtins.def

@@ -774,19 +774,6 @@ BUILTIN_MISC_OPERATION(CreateTaskGroup,
 BUILTIN_MISC_OPERATION(DestroyTaskGroup,
                        "destroyTaskGroup", "", Special)
 
-
-/// A builtin that can only be called from a transparent generic function. Takes
-/// two operands, the first operand the result address, the second operand the
-/// input address. Transforms into load [take] + move_value + store [init] when
-/// transparently inlined into a caller that has the generic of the callee
-/// specialized into a loadable type. If the transparent inlining does not
-/// specialize the type (due to being inlined into a non-generic context, the
-/// SILVerifier will abort).
-///
-/// Illegal to call except for in Swift._move in the stdlib. This is enforced by
-/// the SILVerifier.
-BUILTIN_MISC_OPERATION(Move, "move", "", Special)
-
 /// A builtin that can only be called from a transparent generic function. Takes
 /// two operands, the first operand the result address, the second operand the
 /// input address. Transforms into

include/swift/Basic/Features.def

@@ -79,7 +79,6 @@ LANGUAGE_FEATURE(ImplicitSelfCapture, 0, "@_implicitSelfCapture attribute", true
 LANGUAGE_FEATURE(BuiltinBuildExecutor, 0, "Executor-building builtins", true)
 LANGUAGE_FEATURE(BuiltinBuildMainExecutor, 0, "MainActor executor building builtin", true)
 LANGUAGE_FEATURE(BuiltinCreateAsyncTaskInGroup, 0, "MainActor executor building builtin", true)
-LANGUAGE_FEATURE(BuiltinMove, 0, "Builtin.move()", true)
 LANGUAGE_FEATURE(BuiltinCopy, 0, "Builtin.copy()", true)
 LANGUAGE_FEATURE(BuiltinStackAlloc, 0, "Builtin.stackAlloc", true)
 LANGUAGE_FEATURE(BuiltinTaskRunInline, 0, "Builtin.taskRunInline", true)

include/swift/SILOptimizer/PassManager/Passes.def

@@ -462,9 +462,6 @@ PASS(LexicalLifetimeEliminator, "sil-lexical-lifetime-eliminator",
 PASS(MoveKillsCopyableAddressesChecker, "sil-move-kills-copyable-addresses-checker",
      "Pass that checks that any copyable (non-move only) address that is passed "
      "to _move do not have any uses later than the _move")
-PASS(MoveFunctionCanonicalization, "sil-move-function-canon",
-     "Pass that canonicalizes certain parts of the IR before we perform move "
-     "function checking.")
 PASS(DebugInfoCanonicalizer, "sil-onone-debuginfo-canonicalizer",
      "Canonicalize debug info at -Onone by propagating debug info into coroutine funclets")
 PASS(PartialApplySimplification, "partial-apply-simplification",

lib/AST/ASTPrinter.cpp

@@ -2917,10 +2917,6 @@ static bool usesFeatureBuiltinCreateAsyncTaskInGroup(Decl *decl) {
   return false;
 }
 
-static bool usesFeatureBuiltinMove(Decl *decl) {
-  return false;
-}
-
 static bool usesFeatureBuiltinCopy(Decl *decl) { return false; }
 
 static bool usesFeatureBuiltinTaskRunInline(Decl *) { return false; }

lib/AST/Builtins.cpp

@@ -851,11 +851,6 @@ static ValueDecl *getDestroyArrayOperation(ASTContext &ctx, Identifier id) {
                             _void);
 }
 
-static ValueDecl *getMoveOperation(ASTContext &ctx, Identifier id) {
-  return getBuiltinFunction(ctx, id, _thin, _generics(_unrestricted),
-                            _parameters(_owned(_typeparam(0))), _typeparam(0));
-}
-
 static ValueDecl *getCopyOperation(ASTContext &ctx, Identifier id) {
   return getBuiltinFunction(ctx, id, _thin, _generics(_unrestricted),
                             _parameters(_typeparam(0)), _typeparam(0));
@@ -2537,11 +2532,6 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
     if (!Types.empty()) return nullptr;
     return getEndUnpairedAccessOperation(Context, Id);
 
-  case BuiltinValueKind::Move:
-    if (!Types.empty())
-      return nullptr;
-    return getMoveOperation(Context, Id);
-
   case BuiltinValueKind::Copy:
     if (!Types.empty())
       return nullptr;

lib/IRGen/GenBuiltin.cpp

@@ -1307,17 +1307,6 @@ if (Builtin.ID == BuiltinValueKind::id) { \
     return;
   }
 
-  if (Builtin.ID == BuiltinValueKind::Move) {
-    auto input = args.claimNext();
-    auto result = args.claimNext();
-    SILType addrTy = argTypes[0];
-    const TypeInfo &addrTI = IGF.getTypeInfo(addrTy);
-    Address inputAttr = addrTI.getAddressForPointer(input);
-    Address resultAttr = addrTI.getAddressForPointer(result);
-    addrTI.initializeWithTake(IGF, resultAttr, inputAttr, addrTy, false);
-    return;
-  }
-
   if (Builtin.ID == BuiltinValueKind::Copy) {
     auto input = args.claimNext();
     auto result = args.claimNext();

lib/SIL/IR/OperandOwnership.cpp

@@ -795,7 +795,6 @@ BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, GlobalStringTablePointer)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, TypePtrAuthDiscriminator)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, TargetOSVersionAtLeast)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, IntInstrprofIncrement)
-BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, Move)
 BUILTIN_OPERAND_OWNERSHIP(UnownedInstantaneousUse, Copy)
 BUILTIN_OPERAND_OWNERSHIP(DestroyingConsume, StartAsyncLet)
 BUILTIN_OPERAND_OWNERSHIP(DestroyingConsume, EndAsyncLet)

lib/SIL/IR/ValueOwnership.cpp

@@ -560,7 +560,6 @@ CONSTANT_OWNERSHIP_BUILTIN(None, EndAsyncLetLifetime)
 CONSTANT_OWNERSHIP_BUILTIN(None, CreateTaskGroup)
 CONSTANT_OWNERSHIP_BUILTIN(None, DestroyTaskGroup)
 CONSTANT_OWNERSHIP_BUILTIN(None, TaskRunInline)
-CONSTANT_OWNERSHIP_BUILTIN(None, Move)
 CONSTANT_OWNERSHIP_BUILTIN(None, Copy)
 
 #undef CONSTANT_OWNERSHIP_BUILTIN

lib/SIL/Utils/MemAccessUtils.cpp

@@ -2460,7 +2460,6 @@ static void visitBuiltinAddress(BuiltinInst *builtin,
       return;
 
     // These effect both operands.
-    case BuiltinValueKind::Move:
     case BuiltinValueKind::Copy:
       visitor(&builtin->getAllOperands()[1]);
       return;

lib/SIL/Verifier/SILVerifier.cpp

@@ -2017,22 +2017,6 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       return;
     }
 
-    if (builtinKind == BuiltinValueKind::Move) {
-      // We expect that this builtin will be specialized during transparent
-      // inlining into move_value if we inline into a non-generic context. If
-      // the builtin still remains and is not in the specific move semantic
-      // function (which is the only function marked with
-      // semantics::LIFETIMEMANAGEMENT_MOVE), then we know that we did
-      // transparent inlining into a function that did not result in the Builtin
-      // being specialized out which is user error.
-      //
-      // NOTE: Once we have opaque values, this restriction will go away. This
-      // is just so we can call Builtin.move outside of the stdlib.
-      auto semanticName = semantics::LIFETIMEMANAGEMENT_MOVE;
-      require(BI->getFunction()->hasSemanticsAttr(semanticName),
-              "_move used within a generic context");
-    }
-
     if (builtinKind == BuiltinValueKind::Copy) {
       // We expect that this builtin will be specialized during transparent
       // inlining into explicit_copy_value if we inline into a non-generic

lib/SILOptimizer/Mandatory/CMakeLists.txt

@@ -22,7 +22,6 @@ target_sources(swiftSILOptimizer PRIVATE
   LowerHopToActor.cpp
   MandatoryInlining.cpp
   MovedAsyncVarDebugInfoPropagator.cpp
-  MoveFunctionCanonicalization.cpp
   MoveKillsCopyableAddressesChecker.cpp
   MoveKillsCopyableValuesChecker.cpp
   MoveOnlyObjectChecker.cpp