SILLocation: replace CleanupLocation::get(loc) with CleanupLocation(loc)

No need to have a static get function - the constructor can be used directly.
NFC

Author: eeckstein

include/swift/SIL/SILLocation.h

@@ -570,10 +570,6 @@ class CleanupLocation : public SILLocation {
   /// Returns a null location.
   static CleanupLocation invalid() { return CleanupLocation(); }
 
-  static CleanupLocation get(SILLocation L) {
-    return CleanupLocation(L);
-  }
-
   /// Returns a location representing a cleanup on the module level.
   /// This is just a null location.
   static CleanupLocation getModuleCleanupLocation() {

lib/SILGen/ArgumentScope.h

@@ -33,7 +33,7 @@ class ArgumentScope {
 
 public:
   ArgumentScope(SILGenFunction &SGF, SILLocation loc)
-      : normalScope(SGF.Cleanups, CleanupLocation::get(loc)),
+      : normalScope(SGF.Cleanups, CleanupLocation(loc)),
         formalEvalScope(SGF), loc(loc) {}
 
   ~ArgumentScope() {

lib/SILGen/Condition.cpp

@@ -77,7 +77,7 @@ SGFContext ConditionalValue::enterBranch(SILBasicBlock *bb) {
 
   assert(!scope.hasValue() && "already have a scope");
   // Start a scope for the current branch.
-  scope.emplace(SGF.Cleanups, CleanupLocation::get(loc));
+  scope.emplace(SGF.Cleanups, CleanupLocation(loc));
 
   // Code emitted in the branch can emit into our buffer for address-only
   // conditionals.

lib/SILGen/FormalEvaluation.cpp

@@ -48,15 +48,15 @@ void FormalAccess::verify(SILGenFunction &SGF) const {
 //===----------------------------------------------------------------------===//
 
 void SharedBorrowFormalAccess::finishImpl(SILGenFunction &SGF) {
-  SGF.B.createEndBorrow(CleanupLocation::get(loc), borrowedValue);
+  SGF.B.createEndBorrow(CleanupLocation(loc), borrowedValue);
 }
 
 //===----------------------------------------------------------------------===//
 //                             OwnedFormalAccess
 //===----------------------------------------------------------------------===//
 
 void OwnedFormalAccess::finishImpl(SILGenFunction &SGF) {
-  auto cleanupLoc = CleanupLocation::get(loc);
+  auto cleanupLoc = CleanupLocation(loc);
   if (value->getType().isAddress())
     SGF.B.createDestroyAddr(cleanupLoc, value);
   else

lib/SILGen/JumpDest.h

@@ -54,7 +54,7 @@ class LLVM_LIBRARY_VISIBILITY JumpDest {
     Block = nullptr;
     Depth = CleanupsDepth::invalid();
     // Null location.
-    CleanupLoc = CleanupLocation::get(ArtificialUnreachableLocation());
+    CleanupLoc = CleanupLocation(ArtificialUnreachableLocation());
     return NewValue;
   }
 

lib/SILGen/LValue.h

@@ -547,7 +547,7 @@ struct LLVM_LIBRARY_VISIBILITY ExclusiveBorrowFormalAccess : FormalAccess {
                         SILGenFunction &SGF) const;
 
   void performWriteback(SILGenFunction &SGF, bool isFinal) {
-    Scope S(SGF.Cleanups, CleanupLocation::get(loc));
+    Scope S(SGF.Cleanups, CleanupLocation(loc));
     component->writeback(SGF, loc, base, materialized, isFinal);
   }
 

lib/SILGen/SILGen.cpp

@@ -1919,7 +1919,7 @@ class SourceFileScope {
         SGF.B.createEndLifetime(moduleLoc, error);
 
         // Signal an abnormal exit by returning 1.
-        SGF.Cleanups.emitCleanupsForReturn(CleanupLocation::get(moduleLoc),
+        SGF.Cleanups.emitCleanupsForReturn(CleanupLocation(moduleLoc),
                                            IsForUnwind);
         SGF.B.createBranch(returnLoc, returnBB, emitTopLevelReturnValue(1));
       }

lib/SILGen/SILGenApply.cpp

@@ -4569,7 +4569,7 @@ SILValue SILGenFunction::emitApplyWithRethrow(SILLocation loc, SILValue fn,
         fnConv.getSILErrorType(getTypeExpansionContext()),
         OwnershipKind::Owned);
 
-    Cleanups.emitCleanupsForReturn(CleanupLocation::get(loc), IsForUnwind);
+    Cleanups.emitCleanupsForReturn(CleanupLocation(loc), IsForUnwind);
     B.createThrow(loc, error);
   }
 

lib/SILGen/SILGenBridging.cpp

@@ -370,7 +370,7 @@ static void buildFuncToBlockInvokeBody(SILGenFunction &SGF,
                                        CanSILFunctionType blockTy,
                                        CanSILBlockStorageType blockStorageTy,
                                        bool isUnretainedClosureSafe) {
-  Scope scope(SGF.Cleanups, CleanupLocation::get(loc));
+  Scope scope(SGF.Cleanups, CleanupLocation(loc));
   SILBasicBlock *entry = &*SGF.F.begin();
   SILFunctionConventions blockConv(blockTy, SGF.SGM.M);
   SILFunctionConventions funcConv(funcTy, SGF.SGM.M);
@@ -835,7 +835,7 @@ static void buildBlockToFuncThunkBody(SILGenFunction &SGF,
                                       CanSILFunctionType blockTy,
                                       CanSILFunctionType funcTy) {
   // Collect the native arguments, which should all be +1.
-  Scope scope(SGF.Cleanups, CleanupLocation::get(loc));
+  Scope scope(SGF.Cleanups, CleanupLocation(loc));
 
   // Make sure we lower the component types of the formal block type.
   formalBlockTy =
@@ -1260,7 +1260,7 @@ static SILValue emitBridgeReturnValue(SILGenFunction &SGF,
                                       CanType formalNativeTy,
                                       CanType formalBridgedTy,
                                       SILType loweredBridgedTy) {
-  Scope scope(SGF.Cleanups, CleanupLocation::get(loc));
+  Scope scope(SGF.Cleanups, CleanupLocation(loc));
 
   ManagedValue native = SGF.emitManagedRValueWithCleanup(result);
   ManagedValue bridged =
@@ -1545,7 +1545,7 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
 
   auto loc = thunk.getAsRegularLocation();
   loc.markAutoGenerated();
-  Scope scope(Cleanups, CleanupLocation::get(loc));
+  Scope scope(Cleanups, CleanupLocation(loc));
 
   // If we are bridging a Swift method with an Any return value, create a
   // stack allocation to hold the result, since Any is address-only.
@@ -1597,7 +1597,7 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
   // Now, enter a cleanup used for bridging the arguments. Note that if we
   // have an indirect result, it must be outside of this scope, otherwise
   // we will deallocate it too early.
-  Scope argScope(Cleanups, CleanupLocation::get(loc));
+  Scope argScope(Cleanups, CleanupLocation(loc));
 
   // Bridge the arguments.
   Optional<ForeignErrorConvention> foreignError;

lib/SILGen/SILGenConstructor.cpp

@@ -156,7 +156,7 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
   Loc.markAutoGenerated();
 
   AssertingManualScope functionLevelScope(SGF.Cleanups,
-                                          CleanupLocation::get(Loc));
+                                          CleanupLocation(Loc));
 
   // FIXME: Handle 'self' along with the other arguments.
   auto *paramList = ctor->getParameters();
@@ -424,7 +424,7 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
     SILGenSavedInsertionPoint savedIP(*this, ReturnDest.getBlock());
     assert(B.getInsertionBB()->empty() && "Epilog already set up?");
 
-    auto cleanupLoc = CleanupLocation::get(ctor);
+    auto cleanupLoc = CleanupLocation(ctor);
 
     if (!F.getConventions().hasIndirectSILResults()) {
       // Otherwise, load and return the final 'self' value.
@@ -657,7 +657,7 @@ static void emitDefaultActorInitialization(SILGenFunction &SGF,
     getBuiltinName(BuiltinValueKind::InitializeDefaultActor));
   auto resultTy = SGF.SGM.Types.getEmptyTupleType();
 
-  FullExpr scope(SGF.Cleanups, CleanupLocation::get(loc));
+  FullExpr scope(SGF.Cleanups, CleanupLocation(loc));
   SGF.B.createBuiltin(loc, builtinName, resultTy, /*subs*/{},
                       { self.borrow(SGF, loc).getValue() });
 }
@@ -760,7 +760,7 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
   // Create a basic block to jump to for the implicit 'self' return.
   // We won't emit the block until after we've emitted the body.
   prepareEpilog(false, ctor->hasThrows(),
-                CleanupLocation::get(endOfInitLoc));
+                CleanupLocation(endOfInitLoc));
 
   auto resultType = ctor->mapTypeIntoContext(ctor->getResultInterfaceType());
 
@@ -1136,7 +1136,7 @@ void SILGenFunction::emitIVarInitializer(SILDeclRef ivarInitializer) {
   assert(selfTy.hasReferenceSemantics() && "can't emit a value type ctor here");
   VarLocs[selfDecl] = VarLoc::get(selfArg);
 
-  auto cleanupLoc = CleanupLocation::get(loc);
+  auto cleanupLoc = CleanupLocation(loc);
   prepareEpilog(false, false, cleanupLoc);
 
   // Emit the initializers.