SIL: The inner type of a SILMoveOnlyWrappedType is a lowered position

include/swift/SIL/SILType.h

@@ -20,6 +20,7 @@
 
 #include "swift/AST/SILLayout.h"
 #include "swift/AST/Types.h"
+#include "swift/Basic/Assertions.h"
 #include "swift/SIL/AbstractionPattern.h"
 #include "swift/SIL/Lifetime.h"
 #include "llvm/ADT/Hashing.h"
@@ -109,7 +110,7 @@ class SILType {
   SILType(CanType ty, SILValueCategory category)
       : value(ty.getPointer(), unsigned(category)) {
     if (!ty) return;
-    assert(ty->isLegalSILType() &&
+    ASSERT(ty->isLegalSILType() &&
            "constructing SILType with type that should have been "
            "eliminated by SIL lowering");
   }

lib/SIL/IR/SILTypeSubstitution.cpp

@@ -420,6 +420,14 @@ class SILTypeSubstituter :
                                          substObjectType));
   }
 
+  /// MoveOnlyWrappedTypes need to have their inner types substituted
+  /// by these rules.
+  CanType visitSILMoveOnlyWrappedType(CanSILMoveOnlyWrappedType origType) {
+    CanType origInnerType = origType->getInnerType();
+    CanType substInnerType = visit(origInnerType);
+    return CanType(SILMoveOnlyWrappedType::get(substInnerType));
+  }
+
   /// Any other type would be a valid type in the AST. Just apply the
   /// substitution on the AST level and then lower that.
   CanType visitType(CanType origType) {

test/SILOptimizer/specialize_move_only_wrapped_type.swift

@@ -0,0 +1,15 @@
+// RUN: %target-swift-frontend -emit-sil -O %s
+
+public struct Mutex<T> {
+  public init(_: T) {}
+}
+
+public struct Locked<T> {
+  public let mutex: Mutex<T>
+
+  public init(_ rawValue: consuming T) {
+    mutex = Mutex(rawValue)
+  }
+}
+
+_ = Locked { }