Merge pull request #15128 from rudkx/handle-relational-constraints-in-bindings
Begin refactoring type variable binding code.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ab911cf..390d338 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,6 +23,19 @@
Swift 4.2
---------
+* [SE-0196][]
+
+ Custom compile-time warnings or error messages can be emitted using the
+ `#warning(_:)` and `#error(_:)` directives.
+
+ ```swift
+ #warning("this is incomplete")
+
+ #if MY_BUILD_CONFIG && MY_OTHER_BUILD_CONFIG
+ #error("MY_BUILD_CONFIG and MY_OTHER_BUILD_CONFIG cannot both be set")
+ #endif
+ ```
+
* Public classes may now have internal `required` initializers. The rule for
`required` initializers is that they must be available everywhere the class
can be subclassed, but previously we said that `required` initializers on
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0050546..bc10278 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -822,20 +822,23 @@
endif()
message(STATUS "Building host Swift tools for ${SWIFT_HOST_VARIANT_SDK} ${SWIFT_HOST_VARIANT_ARCH}")
-message(STATUS " Build type: ${CMAKE_BUILD_TYPE}")
-message(STATUS " Assertions: ${LLVM_ENABLE_ASSERTIONS}")
-message(STATUS " LTO: ${SWIFT_TOOLS_ENABLE_LTO}")
+message(STATUS " Build type: ${CMAKE_BUILD_TYPE}")
+message(STATUS " Assertions: ${LLVM_ENABLE_ASSERTIONS}")
+message(STATUS " LTO: ${SWIFT_TOOLS_ENABLE_LTO}")
+message(STATUS " +0 Normal Args: ${SWIFT_ENABLE_GUARANTEED_NORMAL_ARGUMENTS}")
message(STATUS "")
-if (SWIFT_BULID_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
+if (SWIFT_BUILD_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
message(STATUS "Building Swift standard library and overlays for SDKs: ${SWIFT_SDKS}")
- message(STATUS " Build type: ${SWIFT_STDLIB_BUILD_TYPE}")
- message(STATUS " Assertions: ${SWIFT_STDLIB_ASSERTIONS}")
+ message(STATUS " Build type: ${SWIFT_STDLIB_BUILD_TYPE}")
+ message(STATUS " Assertions: ${SWIFT_STDLIB_ASSERTIONS}")
+ message(STATUS " +0 Normal Args: ${SWIFT_ENABLE_GUARANTEED_NORMAL_ARGUMENTS}")
message(STATUS "")
message(STATUS "Building Swift runtime with:")
message(STATUS " Leak Detection Checker Entrypoints: ${SWIFT_RUNTIME_ENABLE_LEAK_CHECKER}")
+ message(STATUS " +0 Normal Args: ${SWIFT_ENABLE_GUARANTEED_NORMAL_ARGUMENTS}")
message(STATUS "")
else()
diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake
index e837cf6..a251222 100644
--- a/cmake/modules/AddSwift.cmake
+++ b/cmake/modules/AddSwift.cmake
@@ -100,26 +100,8 @@
set(result ${${CFLAGS_RESULT_VAR_NAME}})
- # MSVC and clang-cl don't understand -target.
- if (NOT SWIFT_COMPILER_IS_MSVC_LIKE)
- list(APPEND result "-target" "${SWIFT_SDK_${CFLAGS_SDK}_ARCH_${CFLAGS_ARCH}_TRIPLE}")
- endif()
-
is_darwin_based_sdk("${CFLAGS_SDK}" IS_DARWIN)
if(IS_DARWIN)
- list(APPEND result "-isysroot" "${SWIFT_SDK_${CFLAGS_SDK}_PATH}")
- elseif(NOT SWIFT_COMPILER_IS_MSVC_LIKE AND NOT "${SWIFT_SDK_${CFLAGS_SDK}_PATH}" STREQUAL "/")
- list(APPEND result "--sysroot=${SWIFT_SDK_${CFLAGS_SDK}_PATH}")
- endif()
-
- if("${CFLAGS_SDK}" STREQUAL "ANDROID")
- list(APPEND result
- "--sysroot=${SWIFT_ANDROID_SDK_PATH}"
- # Use the linker included in the Android NDK.
- "-B" "${SWIFT_ANDROID_PREBUILT_PATH}/arm-linux-androideabi/bin/")
- endif()
-
- if(IS_DARWIN)
# Check if there's a specific OS deployment version needed for this invocation
if("${CFLAGS_SDK}" STREQUAL "OSX")
set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_OSX})
@@ -134,7 +116,27 @@
if("${DEPLOYMENT_VERSION}" STREQUAL "")
set(DEPLOYMENT_VERSION "${SWIFT_SDK_${CFLAGS_SDK}_DEPLOYMENT_VERSION}")
endif()
+ endif()
+ # MSVC and clang-cl don't understand -target.
+ if (NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+ list(APPEND result "-target" "${SWIFT_SDK_${CFLAGS_SDK}_ARCH_${CFLAGS_ARCH}_TRIPLE}${DEPLOYMENT_VERSION}")
+ endif()
+
+ if(IS_DARWIN)
+ list(APPEND result "-isysroot" "${SWIFT_SDK_${CFLAGS_SDK}_PATH}")
+ elseif(NOT SWIFT_COMPILER_IS_MSVC_LIKE AND NOT "${SWIFT_SDK_${CFLAGS_SDK}_PATH}" STREQUAL "/")
+ list(APPEND result "--sysroot=${SWIFT_SDK_${CFLAGS_SDK}_PATH}")
+ endif()
+
+ if("${CFLAGS_SDK}" STREQUAL "ANDROID")
+ list(APPEND result
+ "--sysroot=${SWIFT_ANDROID_SDK_PATH}"
+ # Use the linker included in the Android NDK.
+ "-B" "${SWIFT_ANDROID_PREBUILT_PATH}/arm-linux-androideabi/bin/")
+ endif()
+
+ if(IS_DARWIN)
list(APPEND result
"-arch" "${CFLAGS_ARCH}"
"-F" "${SWIFT_SDK_${CFLAGS_SDK}_PATH}/../../../Developer/Library/Frameworks"
@@ -297,16 +299,19 @@
list(APPEND result "-sdk" "${SWIFT_SDK_${sdk}_PATH}")
endif()
- if(BUILD_STANDALONE)
+ is_darwin_based_sdk("${sdk}" IS_DARWIN)
+ if(IS_DARWIN)
list(APPEND result
- "-target" "${SWIFT_SDK_${sdk}_ARCH_${arch}_TRIPLE}")
+ "-target" "${SWIFT_SDK_${sdk}_ARCH_${arch}_TRIPLE}${SWIFT_SDK_${sdk}_DEPLOYMENT_VERSION}")
else()
list(APPEND result
- "-target" "${SWIFT_SDK_${sdk}_ARCH_${arch}_TRIPLE}"
- "-resource-dir" "${SWIFTLIB_DIR}")
+ "-target" "${SWIFT_SDK_${sdk}_ARCH_${arch}_TRIPLE}")
endif()
- is_darwin_based_sdk("${sdk}" IS_DARWIN)
+ if(NOT BUILD_STANDALONE)
+ list(APPEND result "-resource-dir" "${SWIFTLIB_DIR}")
+ endif()
+
if(IS_DARWIN)
list(APPEND result
"-F" "${SWIFT_SDK_${sdk}_PATH}/../../../Developer/Library/Frameworks")
@@ -2002,7 +2007,7 @@
BINARY_DIR ${SWIFT_RUNTIME_OUTPUT_INTDIR}
LIBRARY_DIR ${SWIFT_LIBRARY_OUTPUT_INTDIR})
- target_link_libraries("${name}" ${SWIFTEXE_SINGLE_LINK_LIBRARIES} ${SWIFTEXE_SINGLE_LINK_FAT_LIBRARIES})
+ target_link_libraries("${name}" PRIVATE ${SWIFTEXE_SINGLE_LINK_LIBRARIES} ${SWIFTEXE_SINGLE_LINK_FAT_LIBRARIES})
swift_common_llvm_config("${name}" ${SWIFTEXE_SINGLE_LLVM_COMPONENT_DEPENDS})
set_target_properties(${name}
diff --git a/cmake/modules/SwiftConfigureSDK.cmake b/cmake/modules/SwiftConfigureSDK.cmake
index 75682c1..ab3c7fb 100644
--- a/cmake/modules/SwiftConfigureSDK.cmake
+++ b/cmake/modules/SwiftConfigureSDK.cmake
@@ -123,7 +123,7 @@
foreach(arch ${architectures})
set(SWIFT_SDK_${prefix}_ARCH_${arch}_TRIPLE
- "${arch}-apple-${SWIFT_SDK_${prefix}_TRIPLE_NAME}${SWIFT_SDK_${prefix}_DEPLOYMENT_VERSION}")
+ "${arch}-apple-${SWIFT_SDK_${prefix}_TRIPLE_NAME}")
endforeach()
# Add this to the list of known SDKs.
@@ -141,7 +141,7 @@
set(SWIFT_SDK_${prefix}_PATH "${sdkpath}")
set(SWIFT_SDK_${prefix}_VERSION "don't use")
set(SWIFT_SDK_${prefix}_BUILD_NUMBER "don't use")
- set(SWIFT_SDK_${prefix}_DEPLOYMENT_VERSION "don't use")
+ set(SWIFT_SDK_${prefix}_DEPLOYMENT_VERSION "")
set(SWIFT_SDK_${prefix}_LIB_SUBDIR "${lib_subdir}")
set(SWIFT_SDK_${prefix}_VERSION_MIN_NAME "")
set(SWIFT_SDK_${prefix}_TRIPLE_NAME "${triple_name}")
@@ -171,7 +171,7 @@
set(SWIFT_SDK_${prefix}_PATH "/")
set(SWIFT_SDK_${prefix}_VERSION "NOTFOUND")
set(SWIFT_SDK_${prefix}_BUILD_NUMBER "NOTFOUND")
- set(SWIFT_SDK_${prefix}_DEPLOYMENT_VERSION "NOTFOUND")
+ set(SWIFT_SDK_${prefix}_DEPLOYMENT_VERSION "")
set(SWIFT_SDK_${prefix}_LIB_SUBDIR "windows")
set(SWIFT_SDK_${prefix}_VERSION_MIN_NAME "NOTFOUND")
set(SWIFT_SDK_${prefix}_TRIPLE_NAME "Win32")
diff --git a/cmake/modules/SwiftSharedCMakeConfig.cmake b/cmake/modules/SwiftSharedCMakeConfig.cmake
index a832224..8edeed4 100644
--- a/cmake/modules/SwiftSharedCMakeConfig.cmake
+++ b/cmake/modules/SwiftSharedCMakeConfig.cmake
@@ -309,7 +309,7 @@
else()
# HACK: Otherwise (for example, for executables), use a plain signature,
# because LLVM CMake does that already.
- target_link_libraries("${target}" ${libnames})
+ target_link_libraries("${target}" PRIVATE ${libnames})
endif()
else()
# If Swift was not built standalone, dispatch to 'llvm_config()'.
diff --git a/docs/OptimizationTips.rst b/docs/OptimizationTips.rst
index f428915..8661d07 100644
--- a/docs/OptimizationTips.rst
+++ b/docs/OptimizationTips.rst
@@ -21,7 +21,7 @@
======================
The first thing one should always do is to enable optimization. Swift provides
-three different optimization levels:
+four different optimization levels:
- ``-Onone``: This is meant for normal development. It performs minimal
optimizations and preserves all debug info.
@@ -35,6 +35,8 @@
result in undetected memory safety issues and integer overflows. Only use this
if you have carefully reviewed that your code is safe with respect to integer
overflow and type casts.
+- ``-Osize``: This is a special optimization mode where the compiler prioritizes
+ code size over performance.
In the Xcode UI, one can modify the current optimization level as follows:
diff --git a/docs/WindowsBuild.md b/docs/WindowsBuild.md
index 734729b..7bf7324 100644
--- a/docs/WindowsBuild.md
+++ b/docs/WindowsBuild.md
@@ -121,8 +121,6 @@
two hours depending on your system.
- You may need to adjust the `SWIFT_WINDOWS_LIB_DIRECTORY` parameter depending on
your target platform or Windows SDK version.
-- While the commands here use MSVC to build, using `clang-cl` is recommended (see
- the **Clang-cl** section below).
```cmd
mkdir "%swift_source_dir%/build/Ninja-DebugAssert/swift-windows-amd64/ninja"
pushd "%swift_source_dir%/build/Ninja-DebugAssert/swift-windows-amd64/ninja"
diff --git a/include/swift/AST/ConcreteDeclRef.h b/include/swift/AST/ConcreteDeclRef.h
index 6dc3159..d9c378e 100644
--- a/include/swift/AST/ConcreteDeclRef.h
+++ b/include/swift/AST/ConcreteDeclRef.h
@@ -71,7 +71,7 @@
llvm::PointerUnion<ValueDecl *, SpecializedDeclRef *> Data;
- friend class llvm::PointerLikeTypeTraits<ConcreteDeclRef>;
+ friend struct llvm::PointerLikeTypeTraits<ConcreteDeclRef>;
public:
/// Create an empty declaration reference.
@@ -140,7 +140,7 @@
} // end namespace swift
namespace llvm {
- template<> class PointerLikeTypeTraits<swift::ConcreteDeclRef> {
+ template<> struct PointerLikeTypeTraits<swift::ConcreteDeclRef> {
typedef llvm::PointerUnion<swift::ValueDecl *,
swift::ConcreteDeclRef::SpecializedDeclRef *>
DataPointer;
diff --git a/include/swift/AST/GenericSignatureBuilder.h b/include/swift/AST/GenericSignatureBuilder.h
index ba7931f..ca901bf 100644
--- a/include/swift/AST/GenericSignatureBuilder.h
+++ b/include/swift/AST/GenericSignatureBuilder.h
@@ -447,7 +447,9 @@
/// Add a rewrite rule that makes \c otherPA a part of the given equivalence
/// class.
- void addSameTypeRewriteRule(EquivalenceClass *equivClass,
+ ///
+ /// \returns true if a new rewrite rule was added, and false otherwise.
+ bool addSameTypeRewriteRule(EquivalenceClass *equivClass,
PotentialArchetype *otherPA);
/// \brief Add a new conformance requirement specifying that the given
diff --git a/include/swift/AST/Identifier.h b/include/swift/AST/Identifier.h
index 784ed2a..957632e 100644
--- a/include/swift/AST/Identifier.h
+++ b/include/swift/AST/Identifier.h
@@ -191,9 +191,9 @@
};
// An Identifier is "pointer like".
- template<typename T> class PointerLikeTypeTraits;
+ template<typename T> struct PointerLikeTypeTraits;
template<>
- class PointerLikeTypeTraits<swift::Identifier> {
+ struct PointerLikeTypeTraits<swift::Identifier> {
public:
static inline void *getAsVoidPointer(swift::Identifier I) {
return const_cast<void *>(I.getAsOpaquePointer());
@@ -333,8 +333,8 @@
};
// A DeclBaseName is "pointer like".
-template <typename T> class PointerLikeTypeTraits;
-template <> class PointerLikeTypeTraits<swift::DeclBaseName> {
+template <typename T> struct PointerLikeTypeTraits;
+template <> struct PointerLikeTypeTraits<swift::DeclBaseName> {
public:
static inline void *getAsVoidPointer(swift::DeclBaseName D) {
return const_cast<void *>(D.getAsOpaquePointer());
@@ -687,9 +687,9 @@
namespace llvm {
// A DeclName is "pointer like".
- template<typename T> class PointerLikeTypeTraits;
+ template<typename T> struct PointerLikeTypeTraits;
template<>
- class PointerLikeTypeTraits<swift::DeclName> {
+ struct PointerLikeTypeTraits<swift::DeclName> {
public:
static inline void *getAsVoidPointer(swift::DeclName name) {
return name.getOpaqueValue();
@@ -717,9 +717,9 @@
};
// An ObjCSelector is "pointer like".
- template<typename T> class PointerLikeTypeTraits;
+ template<typename T> struct PointerLikeTypeTraits;
template<>
- class PointerLikeTypeTraits<swift::ObjCSelector> {
+ struct PointerLikeTypeTraits<swift::ObjCSelector> {
public:
static inline void *getAsVoidPointer(swift::ObjCSelector name) {
return name.getOpaqueValue();
diff --git a/include/swift/AST/LayoutConstraint.h b/include/swift/AST/LayoutConstraint.h
index ef0561c..961fa8a 100644
--- a/include/swift/AST/LayoutConstraint.h
+++ b/include/swift/AST/LayoutConstraint.h
@@ -395,7 +395,7 @@
};
// A LayoutConstraint is "pointer like".
-template <> class PointerLikeTypeTraits<swift::LayoutConstraint> {
+template <> struct PointerLikeTypeTraits<swift::LayoutConstraint> {
public:
static inline void *getAsVoidPointer(swift::LayoutConstraint I) {
return (void *)I.getPointer();
diff --git a/include/swift/AST/Type.h b/include/swift/AST/Type.h
index 2619c78..fd1e1ca 100644
--- a/include/swift/AST/Type.h
+++ b/include/swift/AST/Type.h
@@ -674,7 +674,7 @@
// A Type is "pointer like".
template<>
- class PointerLikeTypeTraits<swift::Type> {
+ struct PointerLikeTypeTraits<swift::Type> {
public:
static inline void *getAsVoidPointer(swift::Type I) {
return (void*)I.getPointer();
@@ -686,7 +686,7 @@
};
template<>
- class PointerLikeTypeTraits<swift::CanType> :
+ struct PointerLikeTypeTraits<swift::CanType> :
public PointerLikeTypeTraits<swift::Type> {
public:
static inline swift::CanType getFromVoidPointer(void *P) {
@@ -695,7 +695,7 @@
};
template<>
- class PointerLikeTypeTraits<swift::CanGenericSignature> {
+ struct PointerLikeTypeTraits<swift::CanGenericSignature> {
public:
static inline swift::CanGenericSignature getFromVoidPointer(void *P) {
return swift::CanGenericSignature((swift::GenericSignature*)P);
diff --git a/include/swift/AST/TypeAlignments.h b/include/swift/AST/TypeAlignments.h
index 3c68c5a..f4c4b78 100644
--- a/include/swift/AST/TypeAlignments.h
+++ b/include/swift/AST/TypeAlignments.h
@@ -72,14 +72,14 @@
}
};
- template <class T> class PointerLikeTypeTraits;
+ template <class T> struct PointerLikeTypeTraits;
}
/// Declare the expected alignment of pointers to the given type.
/// This macro should be invoked from a top-level file context.
#define LLVM_DECLARE_TYPE_ALIGNMENT(CLASS, ALIGNMENT) \
namespace llvm { \
-template <> class PointerLikeTypeTraits<CLASS*> \
+template <> struct PointerLikeTypeTraits<CLASS*> \
: public MoreAlignedPointerTraits<CLASS, ALIGNMENT> {}; \
}
diff --git a/include/swift/Basic/DiverseStack.h b/include/swift/Basic/DiverseStack.h
index 9403912..7445512 100644
--- a/include/swift/Basic/DiverseStack.h
+++ b/include/swift/Basic/DiverseStack.h
@@ -378,7 +378,7 @@
/// Allow stable_iterators to be put in things like TinyPtrVectors.
namespace llvm {
template <>
- class PointerLikeTypeTraits<
+ struct PointerLikeTypeTraits<
swift::DiverseStackBase::stable_iterator::AsPointer> {
using AsPointer = swift::DiverseStackBase::stable_iterator::AsPointer;
public:
diff --git a/include/swift/Basic/FlaggedPointer.h b/include/swift/Basic/FlaggedPointer.h
index b409f47..5b5743d 100644
--- a/include/swift/Basic/FlaggedPointer.h
+++ b/include/swift/Basic/FlaggedPointer.h
@@ -152,7 +152,7 @@
// Teach SmallPtrSet that FlaggedPointer is "basically a pointer".
template <typename PointerTy, unsigned BitPosition, typename PtrTraits>
-class llvm::PointerLikeTypeTraits<
+struct llvm::PointerLikeTypeTraits<
swift::FlaggedPointer<PointerTy, BitPosition, PtrTraits>> {
public:
static inline void *
diff --git a/include/swift/Basic/SupplementaryOutputPaths.h b/include/swift/Basic/SupplementaryOutputPaths.h
index 95098da..6653c7e 100644
--- a/include/swift/Basic/SupplementaryOutputPaths.h
+++ b/include/swift/Basic/SupplementaryOutputPaths.h
@@ -49,6 +49,9 @@
/// frontend invocation.
std::string SerializedDiagnosticsPath;
+ /// The path to which we should output fix-its as source edits.
+ std::string FixItsOutputPath;
+
/// The path to which we should output a loaded module trace file.
/// It is currently only used with WMO, but could be generalized.
std::string LoadedModuleTracePath;
diff --git a/include/swift/Frontend/FrontendOptions.h b/include/swift/Frontend/FrontendOptions.h
index 0e8146d..62e4829 100644
--- a/include/swift/Frontend/FrontendOptions.h
+++ b/include/swift/Frontend/FrontendOptions.h
@@ -55,9 +55,6 @@
/// The name of the library to link against when using this module.
std::string ModuleLinkName;
- /// The path to which we should output fixits as source edits.
- std::string FixitsOutputPath;
-
/// Arguments which should be passed in immediate mode.
std::vector<std::string> ImmediateArgv;
diff --git a/include/swift/Frontend/InputFile.h b/include/swift/Frontend/InputFile.h
index caed06f..6965501 100644
--- a/include/swift/Frontend/InputFile.h
+++ b/include/swift/Frontend/InputFile.h
@@ -95,6 +95,9 @@
return getPrimarySpecificPaths().SupplementaryOutputs
.SerializedDiagnosticsPath;
}
+ std::string fixItsOutputPath() const {
+ return getPrimarySpecificPaths().SupplementaryOutputs.FixItsOutputPath;
+ }
};
} // namespace swift
diff --git a/include/swift/Parse/Lexer.h b/include/swift/Parse/Lexer.h
index 90b544c..9440aa6 100644
--- a/include/swift/Parse/Lexer.h
+++ b/include/swift/Parse/Lexer.h
@@ -195,8 +195,10 @@
void lex(Token &Result, syntax::Trivia &LeadingTriviaResult,
syntax::Trivia &TrailingTriviaResult) {
Result = NextToken;
- LeadingTriviaResult = {LeadingTrivia};
- TrailingTriviaResult = {TrailingTrivia};
+ if (TriviaRetention == TriviaRetentionMode::WithTrivia) {
+ LeadingTriviaResult = {LeadingTrivia};
+ TrailingTriviaResult = {TrailingTrivia};
+ }
if (Result.isNot(tok::eof))
lexImpl();
}
diff --git a/include/swift/Runtime/Debug.h b/include/swift/Runtime/Debug.h
index f2fa9a2..c495998 100644
--- a/include/swift/Runtime/Debug.h
+++ b/include/swift/Runtime/Debug.h
@@ -224,6 +224,10 @@
SWIFT_RUNTIME_STDLIB_SPI
bool _swift_reportFatalErrorsToDebugger;
+SWIFT_RUNTIME_STDLIB_SPI
+bool _swift_shouldReportFatalErrorsToDebugger();
+
+
LLVM_ATTRIBUTE_ALWAYS_INLINE
inline static int swift_asprintf(char **strp, const char *fmt, ...) {
va_list args;
diff --git a/include/swift/SIL/Dominance.h b/include/swift/SIL/Dominance.h
index 539c580..091a9a6 100644
--- a/include/swift/SIL/Dominance.h
+++ b/include/swift/SIL/Dominance.h
@@ -30,10 +30,8 @@
using SILDomTree = llvm::DomTreeBase<swift::SILBasicBlock>;
using SILPostDomTree = llvm::PostDomTreeBase<swift::SILBasicBlock>;
-extern template void Calculate<SILDomTree, swift::SILFunction>(
- SILDomTree &DT, swift::SILFunction &F);
-extern template void Calculate<SILPostDomTree, swift::SILFunction>(
- SILPostDomTree &DT, swift::SILFunction &F);
+extern template void Calculate<SILDomTree>(SILDomTree &DT);
+extern template void Calculate<SILPostDomTree>(SILPostDomTree &DT);
} // namespace DomTreeBuilder
} // namespace llvm
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
index d3ac08b..29b5d64 100644
--- a/include/swift/SIL/SILInstruction.h
+++ b/include/swift/SIL/SILInstruction.h
@@ -166,7 +166,7 @@
reverse_range getReversedValues() const;
using type_range = llvm::iterator_range<
- llvm::mapped_iterator<iterator, std::function<SILType(SILValue)>>>;
+ llvm::mapped_iterator<iterator, std::function<SILType(SILValue)>, SILType>>;
type_range getTypes() const;
bool operator==(const SILInstructionResultArray &rhs);
diff --git a/include/swift/SIL/SILNode.h b/include/swift/SIL/SILNode.h
index b6e0b84..106365a 100644
--- a/include/swift/SIL/SILNode.h
+++ b/include/swift/SIL/SILNode.h
@@ -544,7 +544,7 @@
/// ValueBase * is always at least eight-byte aligned; make the three tag bits
/// available through PointerLikeTypeTraits.
template<>
-class PointerLikeTypeTraits<swift::SILNode *> {
+struct PointerLikeTypeTraits<swift::SILNode *> {
public:
static inline void *getAsVoidPointer(swift::SILNode *I) {
return (void*)I;
diff --git a/include/swift/SIL/SILType.h b/include/swift/SIL/SILType.h
index 9a65ee9..05883c7 100644
--- a/include/swift/SIL/SILType.h
+++ b/include/swift/SIL/SILType.h
@@ -615,7 +615,7 @@
// Allow the low bit of SILType to be used for nefarious purposes, e.g. putting
// a SILType into a PointerUnion.
template<>
-class PointerLikeTypeTraits<swift::SILType> {
+struct PointerLikeTypeTraits<swift::SILType> {
public:
static inline void *getAsVoidPointer(swift::SILType T) {
return T.getOpaqueValue();
diff --git a/include/swift/SIL/SILValue.h b/include/swift/SIL/SILValue.h
index bfc202c..dedf753 100644
--- a/include/swift/SIL/SILValue.h
+++ b/include/swift/SIL/SILValue.h
@@ -272,7 +272,7 @@
/// ValueBase * is always at least eight-byte aligned; make the three tag bits
/// available through PointerLikeTypeTraits.
template<>
-class PointerLikeTypeTraits<swift::ValueBase *> {
+struct PointerLikeTypeTraits<swift::ValueBase *> {
public:
static inline void *getAsVoidPointer(swift::ValueBase *I) {
return (void*)I;
@@ -627,7 +627,7 @@
};
/// SILValue is a PointerLikeType.
- template<> class PointerLikeTypeTraits<::swift::SILValue> {
+ template<> struct PointerLikeTypeTraits<::swift::SILValue> {
using SILValue = ::swift::SILValue;
public:
static void *getAsVoidPointer(SILValue v) {
diff --git a/lib/AST/ASTVerifier.cpp b/lib/AST/ASTVerifier.cpp
index cd0c9a1..e8e86f8 100644
--- a/lib/AST/ASTVerifier.cpp
+++ b/lib/AST/ASTVerifier.cpp
@@ -2143,7 +2143,7 @@
if (ASD->getSetter() &&
ASD->getSetter()->getFormalAccess() != setterAccess) {
Out << "AbstractStorageDecl's setter access is out of sync"
- " with the access actually on the setter";
+ " with the access actually on the setter\n";
abort();
}
}
@@ -2151,21 +2151,22 @@
if (auto getter = ASD->getGetter()) {
if (getter->isMutating() != ASD->isGetterMutating()) {
Out << "AbstractStorageDecl::isGetterMutating is out of sync"
- " with whether the getter is actually mutating";
+ " with whether the getter is actually mutating\n";
abort();
}
}
if (auto setter = ASD->getSetter()) {
if (setter->isMutating() != ASD->isSetterMutating()) {
Out << "AbstractStorageDecl::isSetterMutating is out of sync"
- " with whether the setter is actually mutating";
+ " with whether the setter is actually mutating\n";
abort();
}
}
if (auto materializeForSet = ASD->getMaterializeForSetFunc()) {
- if (materializeForSet->isMutating() != ASD->isSetterMutating()) {
- Out << "AbstractStorageDecl::isSetterMutating is out of sync"
- " with whether materializeForSet is mutating";
+ if (materializeForSet->isMutating() !=
+ (ASD->isSetterMutating() || ASD->isGetterMutating())) {
+ Out << "AbstractStorageDecl::is{Getter,Setter}Mutating is out of sync"
+ " with whether materializeForSet is mutating\n";
abort();
}
}
diff --git a/lib/AST/GenericSignatureBuilder.cpp b/lib/AST/GenericSignatureBuilder.cpp
index a63cf56..0d96054 100644
--- a/lib/AST/GenericSignatureBuilder.cpp
+++ b/lib/AST/GenericSignatureBuilder.cpp
@@ -107,6 +107,14 @@
"Delayed requirements left unresolved");
STATISTIC(NumConditionalRequirementsAdded,
"# of conditional requirements added");
+STATISTIC(NumRewriteMinimizations,
+ "# of rewrite system minimizations performed");
+STATISTIC(NumRewriteRhsSimplified,
+ "# of rewrite rule right-hand sides simplified");
+STATISTIC(NumRewriteRhsSimplifiedToLhs,
+ "# of rewrite rule right-hand sides simplified to lhs (and removed)");
+STATISTIC(NumRewriteRulesRedundant,
+ "# of rewrite rules that are redundant (and removed)");
namespace {
@@ -114,6 +122,8 @@
/// sequence of associated type references.
using RelativeRewritePath = ArrayRef<AssociatedTypeDecl *>;
+class AnchorPathCache;
+
/// Describes a rewrite path, which contains an optional base (generic
/// parameter) followed by a sequence of associated type references.
class RewritePath {
@@ -158,13 +168,25 @@
/// types.
Optional<RewritePath> static createPath(Type type);
+ /// Decompose a type into a path.
+ ///
+ /// \param path Will be filled in with the components of the path, in
+ /// reverse order.
+ ///
+ /// \returns the generic parameter at the start of the path, or \c None if
+ ///
+ Optional<GenericParamKey>
+ static createPath(Type type, SmallVectorImpl<AssociatedTypeDecl *> &path);
+
/// Compute the longer common prefix between this path and \c other.
RewritePath commonPath(const RewritePath &other) const;
/// Form a canonical, dependent type.
///
- /// This requires that the rewrite path have a base.
- CanType formDependentType(ASTContext &ctx) const;
+ /// This requires that either the rewrite path have a base, or the
+ /// \c baseEquivClass to be non-null (which substitutes in a base).
+ CanType formDependentType(ASTContext &ctx,
+ AnchorPathCache *anchorPathCache = nullptr) const;
/// Compare the given rewrite paths.
int compare(const RewritePath &other) const;
@@ -182,6 +204,26 @@
}
};
+/// A cache that lazily computes the anchor path for the given equivalence
+/// class.
+class AnchorPathCache {
+ GenericSignatureBuilder &builder;
+ EquivalenceClass &equivClass;
+ Optional<RewritePath> anchorPath;
+
+public:
+ AnchorPathCache(GenericSignatureBuilder &builder,
+ EquivalenceClass &equivClass)
+ : builder(builder), equivClass(equivClass) { }
+
+ Optional<RewritePath> getAnchorPath() {
+ if (anchorPath) return anchorPath;
+
+ anchorPath = RewritePath::createPath(equivClass.getAnchor(builder, { }));
+ return anchorPath;
+ }
+};
+
/// A node within the prefix tree that is used to match associated type
/// references.
class RewriteTreeNode {
@@ -239,12 +281,24 @@
rewrite = replacementPath;
}
+ /// Remove the rewrite rule.
+ void removeRewriteRule() {
+ assert(hasRewriteRule());
+ assocTypeAndHasRewrite.setInt(false);
+ }
+
/// Retrieve the path to which this node will be rewritten.
- const RewritePath &getRewriteRule() const {
+ const RewritePath &getRewriteRule() const & {
assert(hasRewriteRule());
return rewrite;
}
+ /// Retrieve the path to which this node will be rewritten.
+ RewritePath &&getRewriteRule() && {
+ assert(hasRewriteRule());
+ return std::move(rewrite);
+ }
+
/// Add a new rewrite rule to this tree node.
///
/// \param matchPath The path of associated type declarations that must
@@ -252,7 +306,10 @@
///
/// \param replacementPath The sequence of associated type declarations
/// with which a match will be replaced.
- void addRewriteRule(RelativeRewritePath matchPath,
+ ///
+ /// \returns true if a rewrite rule was added, and false if it already
+ /// existed.
+ bool addRewriteRule(RelativeRewritePath matchPath,
RewritePath replacementPath);
/// Enumerate all of the paths to which the given matched path can be
@@ -283,11 +340,62 @@
/// \param path The path to match.
/// \param prefixLength The length of the prefix leading up to \c path.
Optional<std::pair<unsigned, RewritePath>>
- bestMatch(GenericParamKey base, RelativeRewritePath path,
+ bestRewritePath(GenericParamKey base, RelativeRewritePath path,
unsigned prefixLength);
/// Merge the given rewrite tree into \c other.
- void mergeInto(RewriteTreeNode *other);
+ ///
+ /// \returns true if any rules were created by this merge.
+ bool mergeInto(RewriteTreeNode *other);
+
+ /// An action to perform for the given rule
+ class RuleAction {
+ enum Kind {
+ /// No action; continue traversal.
+ None,
+
+ /// Stop traversal.
+ Stop,
+
+ /// Remove the given rule completely.
+ Remove,
+
+ /// Replace the right-hand side of the rule with the given new path.
+ Replace,
+ } kind;
+
+ RewritePath path;
+
+ RuleAction(Kind kind, RewritePath path = {})
+ : kind(kind), path(path) { }
+
+ friend class RewriteTreeNode;
+
+ public:
+ static RuleAction none() { return RuleAction(None); }
+ static RuleAction stop() { return RuleAction(Stop); }
+ static RuleAction remove() { return RuleAction(Remove); }
+
+ static RuleAction replace(RewritePath path) {
+ return RuleAction(Replace, std::move(path));
+ }
+
+ operator Kind() const { return kind; }
+ };
+
+ /// Callback function for enumerating rules in a tree.
+ using EnumerateCallback =
+ RuleAction(RelativeRewritePath lhs, const RewritePath &rhs);
+
+ /// Enumerate all of the rewrite rules, calling \c fn with the left and
+ /// right-hand sides of each rule.
+ ///
+ /// \returns true if the action function returned \c Stop at any point.
+ bool enumerateRules(llvm::function_ref<EnumerateCallback> fn,
+ bool temporarilyDisableVisitedRule = false) {
+ SmallVector<AssociatedTypeDecl *, 4> lhs;
+ return enumerateRulesRec(fn, temporarilyDisableVisitedRule, lhs);
+ }
LLVM_ATTRIBUTE_DEPRECATED(void dump() const LLVM_ATTRIBUTE_USED,
"only for use within the debugger");
@@ -296,9 +404,13 @@
void dump(llvm::raw_ostream &out, bool lastChild = true) const;
private:
- /// Merge the given rewrite tree into \c other.
- void mergeIntoRec(RewriteTreeNode *other,
- llvm::SmallVectorImpl<AssociatedTypeDecl *> &matchPath);
+ /// Enumerate all of the rewrite rules, calling \c fn with the left and
+ /// right-hand sides of each rule.
+ ///
+ /// \returns true if the action function returned \c Stop at any point.
+ bool enumerateRulesRec(llvm::function_ref<EnumerateCallback> &fn,
+ bool temporarilyDisableVisitedRule,
+ llvm::SmallVectorImpl<AssociatedTypeDecl *> &lhs);
};
}
@@ -329,6 +441,13 @@
DenseMap<const EquivalenceClass *, std::unique_ptr<RewriteTreeNode>>
RewriteTreeRoots;
+ /// The generation number for the term-rewriting system, which is
+ /// increased every time a new rule gets added.
+ unsigned RewriteGeneration = 0;
+
+ /// The generation at which the term-rewriting system was last minimized.
+ unsigned LastRewriteMinimizedGeneration = 0;
+
/// The generation number, which is incremented whenever we successfully
/// introduce a new constraint.
unsigned Generation = 0;
@@ -339,6 +458,9 @@
/// Whether we are currently processing delayed requirements.
bool ProcessingDelayedRequirements = false;
+ /// Whether we are currently minimizing the term-rewriting system.
+ bool MinimizingRewriteSystem = false;
+
/// Whether there were any errors.
bool HadAnyError = false;
@@ -369,6 +491,21 @@
/// creating it if needed.
RewriteTreeNode *getOrCreateRewriteTreeRoot(
const EquivalenceClass *equivClass);
+
+ /// Minimize the rewrite tree by minimizing the right-hand sides and
+ /// removing redundant rules.
+ void minimizeRewriteTree(GenericSignatureBuilder &builder);
+
+private:
+ /// Minimize the right-hand sides of the rewrite tree, simplifying them
+ /// as far as possible and removing any changes that result in trivial
+ /// rules.
+ void minimizeRewriteTreeRhs(GenericSignatureBuilder &builder);
+
+ /// Minimize the right-hand sides of the rewrite tree, simplifying them
+ /// as far as possible and removing any changes that result in trivial
+ /// rules.
+ void removeRewriteTreeRedundancies(GenericSignatureBuilder &builder);
};
#pragma mark Memory management
@@ -3038,6 +3175,16 @@
Optional<RewritePath> RewritePath::createPath(Type type) {
SmallVector<AssociatedTypeDecl *, 4> path;
+ if (auto genericParam = createPath(type, path)) {
+ return RewritePath(*genericParam, path, Reverse);
+ }
+
+ return None;
+}
+
+Optional<GenericParamKey>
+RewritePath::createPath(Type type,
+ SmallVectorImpl<AssociatedTypeDecl *> &path) {
while (auto depMemTy = type->getAs<DependentMemberType>()) {
auto assocType = depMemTy->getAssocType();
if (!assocType) return None;
@@ -3049,7 +3196,7 @@
auto genericParam = type->getAs<GenericTypeParamType>();
if (!genericParam) return None;
- return RewritePath(GenericParamKey(genericParam), path, Reverse);
+ return GenericParamKey(genericParam);
}
RewritePath RewritePath::commonPath(const RewritePath &other) const {
@@ -3090,9 +3237,24 @@
path);
}
-CanType RewritePath::formDependentType(ASTContext &ctx) const {
- assert(getBase());
- return CanType(::formDependentType(ctx, *getBase(), getPath()));
+CanType RewritePath::formDependentType(
+ ASTContext &ctx,
+ AnchorPathCache *anchorPathCache) const {
+ if (auto base = getBase())
+ return CanType(::formDependentType(ctx, *base, getPath()));
+
+ assert(anchorPathCache && "Need an anchor path cache");
+ Optional<RewritePath> anchorPath = anchorPathCache->getAnchorPath();
+ if (!anchorPath) return CanType();
+
+ // Add the relative path to the anchor path.
+ SmallVector<AssociatedTypeDecl *, 4> absolutePath;
+ absolutePath.append(anchorPath->getPath().begin(),
+ anchorPath->getPath().end());
+ absolutePath.append(getPath().begin(), getPath().end());
+ return CanType(::formDependentType(ctx, *anchorPath->getBase(),
+ absolutePath));
+
}
int RewritePath::compare(const RewritePath &other) const {
@@ -3162,25 +3324,25 @@
};
}
-void RewriteTreeNode::addRewriteRule(RelativeRewritePath matchPath,
+bool RewriteTreeNode::addRewriteRule(RelativeRewritePath matchPath,
RewritePath replacementPath) {
// If the match path is empty, we're adding the rewrite rule to this node.
if (matchPath.empty()) {
// If we don't already have a rewrite rule, add it.
if (!hasRewriteRule()) {
setRewriteRule(replacementPath);
- return;
+ return true;
}
// If we already have this rewrite rule, we're done.
- if (getRewriteRule() == replacementPath) return;
+ if (getRewriteRule() == replacementPath) return false;
// Check whether any of the continuation children matches.
auto insertPos = children.begin();
while (insertPos != children.end() && !(*insertPos)->getMatch()) {
if ((*insertPos)->hasRewriteRule() &&
(*insertPos)->getRewriteRule() == replacementPath)
- return;
+ return false;
++insertPos;
}
@@ -3190,7 +3352,7 @@
auto newChild = new RewriteTreeNode(nullptr);
newChild->setRewriteRule(replacementPath);
children.insert(insertPos, newChild);
- return;
+ return true;
}
// Find (or create) a child node describing the next step in the match.
@@ -3203,7 +3365,7 @@
}
// Add the rewrite rule to the child.
- (*childPos)->addRewriteRule(matchPath.slice(1), replacementPath);
+ return (*childPos)->addRewriteRule(matchPath.slice(1), replacementPath);
}
void RewriteTreeNode::enumerateRewritePathsImpl(
@@ -3236,7 +3398,7 @@
}
Optional<std::pair<unsigned, RewritePath>>
-RewriteTreeNode::bestMatch(GenericParamKey base, RelativeRewritePath path,
+RewriteTreeNode::bestRewritePath(GenericParamKey base, RelativeRewritePath path,
unsigned prefixLength) {
Optional<std::pair<unsigned, RewritePath>> best;
unsigned bestAdjustedLength = 0;
@@ -3267,29 +3429,82 @@
return best;
}
-void RewriteTreeNode::mergeInto(RewriteTreeNode *other) {
- SmallVector<AssociatedTypeDecl *, 4> matchPath;
- mergeIntoRec(other, matchPath);
-}
-
-void RewriteTreeNode::mergeIntoRec(
- RewriteTreeNode *other,
- llvm::SmallVectorImpl<AssociatedTypeDecl *> &matchPath) {
+bool RewriteTreeNode::mergeInto(RewriteTreeNode *other) {
// FIXME: A destructive version of this operation would be more efficient,
// since we generally don't care about \c other after doing this.
- if (auto assocType = getMatch())
- matchPath.push_back(assocType);
+ bool anyAdded = false;
+ (void)enumerateRules([other, &anyAdded](RelativeRewritePath lhs,
+ const RewritePath &rhs) {
+ if (other->addRewriteRule(lhs, rhs))
+ anyAdded = true;
+ return RuleAction::none();
+ });
- // Add this rewrite rule, if there is one.
- if (hasRewriteRule())
- other->addRewriteRule(matchPath, rewrite);
+ return anyAdded;
+}
+
+bool RewriteTreeNode::enumerateRulesRec(
+ llvm::function_ref<EnumerateCallback> &fn,
+ bool temporarilyDisableVisitedRule,
+ llvm::SmallVectorImpl<AssociatedTypeDecl *> &lhs) {
+ if (auto assocType = getMatch())
+ lhs.push_back(assocType);
+
+ SWIFT_DEFER {
+ if (auto assocType = getMatch())
+ lhs.pop_back();
+ };
+
+ // If there is a rewrite rule, invoke the callback.
+ if (hasRewriteRule()) {
+ // If we're supposed to temporarily disabled the visited rule, do so
+ // now.
+ Optional<RewritePath> rewriteRule;
+ if (temporarilyDisableVisitedRule) {
+ rewriteRule = std::move(*this).getRewriteRule();
+ removeRewriteRule();
+ }
+
+ // Make sure that we put the rewrite rule back in place if we moved it
+ // aside.
+ SWIFT_DEFER {
+ if (temporarilyDisableVisitedRule && rewriteRule)
+ setRewriteRule(*std::move(rewriteRule));
+ };
+
+ switch (auto action =
+ fn(lhs, rewriteRule ? *rewriteRule : getRewriteRule())) {
+ case RuleAction::None:
+ break;
+
+ case RuleAction::Stop:
+ return true;
+
+ case RuleAction::Remove:
+ if (temporarilyDisableVisitedRule)
+ rewriteRule = None;
+ else
+ removeRewriteRule();
+ break;
+
+ case RuleAction::Replace:
+ if (temporarilyDisableVisitedRule) {
+ rewriteRule = std::move(action.path);
+ } else {
+ removeRewriteRule();
+ setRewriteRule(action.path);
+ }
+ break;
+ }
+ }
// Recurse into the child nodes.
- for (auto child : children)
- child->mergeIntoRec(other, matchPath);
+ for (auto child : children) {
+ if (child->enumerateRulesRec(fn, temporarilyDisableVisitedRule, lhs))
+ return true;
+ }
- if (getMatch())
- matchPath.pop_back();
+ return false;
}
void RewriteTreeNode::dump() const {
@@ -3354,22 +3569,133 @@
return root.get();
}
-void GenericSignatureBuilder::addSameTypeRewriteRule(
+void GenericSignatureBuilder::Implementation::minimizeRewriteTree(
+ GenericSignatureBuilder &builder) {
+ // Only perform minimization if the term-rewriting tree has changed.
+ if (LastRewriteMinimizedGeneration == RewriteGeneration
+ || MinimizingRewriteSystem)
+ return;
+
+ ++NumRewriteMinimizations;
+ llvm::SaveAndRestore<bool> minimizingRewriteSystem(MinimizingRewriteSystem,
+ true);
+ SWIFT_DEFER {
+ LastRewriteMinimizedGeneration = RewriteGeneration;
+ };
+
+ minimizeRewriteTreeRhs(builder);
+ removeRewriteTreeRedundancies(builder);
+}
+
+void GenericSignatureBuilder::Implementation::minimizeRewriteTreeRhs(
+ GenericSignatureBuilder &builder) {
+ assert(MinimizingRewriteSystem);
+
+ // Minimize the right-hand sides of each rule in the tree.
+ for (auto &equivClass : EquivalenceClasses) {
+ auto root = RewriteTreeRoots.find(&equivClass);
+ if (root == RewriteTreeRoots.end()) continue;
+
+ AnchorPathCache anchorPathCache(builder, equivClass);
+
+ ASTContext &ctx = builder.getASTContext();
+ root->second->enumerateRules([&](RelativeRewritePath lhs,
+ const RewritePath &rhs) {
+ // Compute the type of the right-hand side.
+ Type rhsType = rhs.formDependentType(ctx, &anchorPathCache);
+ if (!rhsType) return RewriteTreeNode::RuleAction::none();
+
+ // Compute the canonical type for the right-hand side.
+ Type canonicalRhsType = builder.getCanonicalTypeParameter(rhsType);
+
+ // If the canonicalized result is equivalent to the right-hand side we
+ // had, there's nothing to do.
+ if (rhsType->isEqual(canonicalRhsType))
+ return RewriteTreeNode::RuleAction::none();
+
+ // We have a canonical replacement path. Determine its encoding and
+ // perform the replacement.
+ ++NumRewriteRhsSimplified;
+
+ // Determine replacement path, which might be relative to the anchor.
+ auto canonicalRhsPath = *RewritePath::createPath(canonicalRhsType);
+ auto anchorPath = anchorPathCache.getAnchorPath();
+ if (auto prefix = anchorPath->commonPath(canonicalRhsPath)) {
+ unsigned prefixLength = prefix.getPath().size();
+ RelativeRewritePath replacementRhsPath =
+ canonicalRhsPath.getPath().slice(prefixLength);
+
+ // If the left and right-hand sides are equivalent, just remove the
+ // rule.
+ if (lhs == replacementRhsPath) {
+ ++NumRewriteRhsSimplifiedToLhs;
+ return RewriteTreeNode::RuleAction::remove();
+ }
+
+ RewritePath replacementRhs(None, replacementRhsPath,
+ RewritePath::Forward);
+ return RewriteTreeNode::RuleAction::replace(std::move(replacementRhs));
+ }
+
+ return RewriteTreeNode::RuleAction::replace(canonicalRhsPath);
+ });
+ }
+}
+
+void GenericSignatureBuilder::Implementation::removeRewriteTreeRedundancies(
+ GenericSignatureBuilder &builder) {
+ assert(MinimizingRewriteSystem);
+
+ // Minimize the right-hand sides of each rule in the tree.
+ for (auto &equivClass : EquivalenceClasses) {
+ auto root = RewriteTreeRoots.find(&equivClass);
+ if (root == RewriteTreeRoots.end()) continue;
+
+ AnchorPathCache anchorPathCache(builder, equivClass);
+
+ ASTContext &ctx = builder.getASTContext();
+ root->second->enumerateRules([&](RelativeRewritePath lhs,
+ const RewritePath &rhs) {
+ /// Left-hand side type.
+ Type lhsType = RewritePath(None, lhs, RewritePath::Forward)
+ .formDependentType(ctx, &anchorPathCache);
+ if (!lhsType) return RewriteTreeNode::RuleAction::none();
+
+ // Simplify the left-hand type.
+ Type simplifiedLhsType = builder.getCanonicalTypeParameter(lhsType);
+ if (!simplifiedLhsType) return RewriteTreeNode::RuleAction::none();
+
+ // Compute the type of the right-hand side.
+ Type rhsType = rhs.formDependentType(ctx, &anchorPathCache);
+ if (!rhsType) return RewriteTreeNode::RuleAction::none();
+
+ if (simplifiedLhsType->isEqual(rhsType)) {
+ ++NumRewriteRulesRedundant;
+ return RewriteTreeNode::RuleAction::remove();
+ }
+
+ return RewriteTreeNode::RuleAction::none();
+ },
+ /*temporarilyDisableVisitedRule=*/true);
+ }
+}
+
+bool GenericSignatureBuilder::addSameTypeRewriteRule(
EquivalenceClass *equivClass,
PotentialArchetype *otherPA){
// Simplify both sides in the hope of uncovering a common path.
Type simplifiedType1 = equivClass->getAnchor(*this, { });
- if (!simplifiedType1) return;
+ if (!simplifiedType1) return false;
Type simplifiedType2;
if (auto otherEquivClass = otherPA->getEquivalenceClassIfPresent())
simplifiedType2 = otherEquivClass->getAnchor(*this, { });
else
simplifiedType2 = getCanonicalTypeParameter(otherPA->getDependentType({ }));
- if (!simplifiedType2) return;
+ if (!simplifiedType2) return false;
// We already effectively have this rewrite rule.
- if (simplifiedType1->isEqual(simplifiedType2)) return;
+ if (simplifiedType1->isEqual(simplifiedType2)) return false;
auto path1 = *RewritePath::createPath(simplifiedType1);
auto path2 = *RewritePath::createPath(simplifiedType2);
@@ -3394,10 +3720,9 @@
// Add the rewrite rule.
auto root = Impl->getOrCreateRewriteTreeRoot(equivClass);
- root->addRewriteRule(relPath1,
- RewritePath(None, relPath2, RewritePath::Forward));
-
- return;
+ return root->addRewriteRule(
+ relPath1,
+ RewritePath(None, relPath2, RewritePath::Forward));
}
// Otherwise, form a rewrite rule with absolute paths.
@@ -3417,7 +3742,7 @@
assert(baseEquivClass && "Base cannot be resolved?");
auto root = Impl->getOrCreateRewriteTreeRoot(baseEquivClass);
- root->addRewriteRule(path1.getPath(), path2);
+ return root->addRewriteRule(path1.getPath(), path2);
}
Type GenericSignatureBuilder::getCanonicalTypeParameter(Type type) {
@@ -3443,7 +3768,7 @@
if (auto rootNode = Impl->getRewriteTreeRootIfPresent(equivClass)) {
// Find the best rewrite rule for the path starting at startIndex.
auto match =
- rootNode->bestMatch(genericParamType,
+ rootNode->bestRewritePath(genericParamType,
llvm::makeArrayRef(path).slice(startIndex),
startIndex);
@@ -4143,7 +4468,9 @@
// ... from the same module as the protocol.
if (type->getModuleContext() != proto->getModuleContext()) continue;
- // Or is constrained.
+ // Ignore types defined in constrained extensions; their equivalence
+ // to the associated type would have to be conditional, which we cannot
+ // model.
if (auto ext = dyn_cast<ExtensionDecl>(type->getDeclContext())) {
if (ext->isConstrainedExtension()) continue;
}
@@ -4564,7 +4891,8 @@
// Add a rewrite rule to map T2 down to the anchor.
auto equivClass = T1->getOrCreateEquivalenceClass(*this);
- addSameTypeRewriteRule(equivClass, T2);
+ if (addSameTypeRewriteRule(equivClass, T2))
+ ++Impl->RewriteGeneration;
// Merge the equivalence classes.
equivClass->modified(*this);
@@ -4595,7 +4923,8 @@
if (auto rewriteRoot2 = Impl->getOrCreateRewriteTreeRoot(equivClass2)) {
if (auto rewriteRoot1 = Impl->getOrCreateRewriteTreeRoot(equivClass)) {
// Merge the second rewrite tree into the first.
- rewriteRoot2->mergeInto(rewriteRoot1);
+ if (rewriteRoot2->mergeInto(rewriteRoot1))
+ ++Impl->RewriteGeneration;
Impl->RewriteTreeRoots.erase(equivClass2);
} else {
// Take the second rewrite tree and make it the first.
diff --git a/lib/Basic/CMakeLists.txt b/lib/Basic/CMakeLists.txt
index 5510318..debe5ce 100644
--- a/lib/Basic/CMakeLists.txt
+++ b/lib/Basic/CMakeLists.txt
@@ -5,7 +5,7 @@
set(UUID_LIBRARIES "")
elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
set(UUID_INCLUDE "")
- set(UUID_LIBRARIES "ole32.lib")
+ set(UUID_LIBRARIES "rpcrt4.lib")
else()
find_package(UUID REQUIRED)
set(UUID_INCLUDE "-I${UUID_INCLUDE_DIRS}")
diff --git a/lib/Basic/Platform.cpp b/lib/Basic/Platform.cpp
index 206aaca..2c90231 100644
--- a/lib/Basic/Platform.cpp
+++ b/lib/Basic/Platform.cpp
@@ -113,7 +113,6 @@
case llvm::Triple::RTEMS:
case llvm::Triple::NaCl:
case llvm::Triple::CNK:
- case llvm::Triple::Bitrig:
case llvm::Triple::AIX:
case llvm::Triple::CUDA:
case llvm::Triple::NVCL:
@@ -121,6 +120,7 @@
case llvm::Triple::ELFIAMCU:
case llvm::Triple::Mesa3D:
case llvm::Triple::Contiki:
+ case llvm::Triple::AMDPAL:
return "";
case llvm::Triple::Darwin:
case llvm::Triple::MacOSX:
diff --git a/lib/Basic/UUID.cpp b/lib/Basic/UUID.cpp
index a8099ba..f17aab4 100644
--- a/lib/Basic/UUID.cpp
+++ b/lib/Basic/UUID.cpp
@@ -42,7 +42,7 @@
swift::UUID::UUID(FromTime_t) {
#if defined(_WIN32)
- ::GUID uuid;
+ ::UUID uuid;
::CoCreateGuid(&uuid);
memcpy(Value, &uuid, Size);
@@ -53,7 +53,8 @@
swift::UUID::UUID() {
#if defined(_WIN32)
- ::GUID uuid = GUID();
+ ::UUID uuid = *((::UUID *)&Value);
+ UuidCreateNil(&uuid);
memcpy(Value, &uuid, Size);
#else
@@ -63,18 +64,11 @@
Optional<swift::UUID> swift::UUID::fromString(const char *s) {
#if defined(_WIN32)
- int length = strlen(s) + 1;
- wchar_t *unicodeString = new wchar_t[length];
+ RPC_CSTR t = const_cast<RPC_CSTR>(reinterpret_cast<const unsigned char*>(s));
- size_t convertedChars = 0;
- errno_t conversionResult =
- mbstowcs_s(&convertedChars, unicodeString, length, s, length);
- assert(conversionResult == 0 &&
- "expected successful conversion of char* to wchar_t*");
-
- ::GUID uuid;
- HRESULT parseResult = CLSIDFromString(unicodeString, &uuid);
- if (parseResult != 0) {
+ ::UUID uuid;
+ RPC_STATUS status = UuidFromStringA(t, &uuid);
+ if (status == RPC_S_INVALID_STRING_UUID) {
return None;
}
@@ -92,19 +86,14 @@
void swift::UUID::toString(llvm::SmallVectorImpl<char> &out) const {
out.resize(UUID::StringBufferSize);
#if defined(_WIN32)
- ::GUID uuid;
+ ::UUID uuid;
memcpy(&uuid, Value, Size);
- LPOLESTR unicodeStr;
- StringFromCLSID(uuid, &unicodeStr);
+ RPC_CSTR str;
+ UuidToStringA(&uuid, &str);
- char str[StringBufferSize];
- int strLen = wcstombs(str, unicodeStr, sizeof(str));
-
- assert(strLen == 37 && "expected ascii convertible output from StringFromCLSID.");
- (void)strLen;
-
- memcpy(out.data(), str, StringBufferSize);
+ char* signedStr = reinterpret_cast<char*>(str);
+ memcpy(out.data(), signedStr, StringBufferSize);
#else
uuid_unparse_upper(Value, out.data());
#endif
@@ -115,13 +104,14 @@
int swift::UUID::compare(UUID y) const {
#if defined(_WIN32)
- ::GUID uuid1;
+ RPC_STATUS s;
+ ::UUID uuid1;
memcpy(&uuid1, Value, Size);
- ::GUID uuid2;
+ ::UUID uuid2;
memcpy(&uuid2, y.Value, Size);
- return memcmp(Value, y.Value, Size);
+ return UuidCompare(&uuid1, &uuid2, &s);
#else
return uuid_compare(Value, y.Value);
#endif
diff --git a/lib/ClangImporter/ClangAdapter.cpp b/lib/ClangImporter/ClangAdapter.cpp
index 04daaf81..6ed0bf4 100644
--- a/lib/ClangImporter/ClangAdapter.cpp
+++ b/lib/ClangImporter/ClangAdapter.cpp
@@ -337,6 +337,7 @@
// FIXME: Types that can be mapped, but aren't yet.
case clang::BuiltinType::Half:
case clang::BuiltinType::LongDouble:
+ case clang::BuiltinType::Float16:
case clang::BuiltinType::Float128:
case clang::BuiltinType::NullPtr:
return OmissionTypeName();
diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
index b43cc42..d8cc57d 100644
--- a/lib/ClangImporter/ClangImporter.cpp
+++ b/lib/ClangImporter/ClangImporter.cpp
@@ -406,27 +406,6 @@
#define SHIMS_INCLUDE_FLAG "-isystem"
-static StringRef
-getMinVersionOptNameForDarwinTriple(const llvm::Triple &triple) {
- switch(getDarwinPlatformKind(triple)) {
- case DarwinPlatformKind::MacOS:
- return "-mmacosx-version-min=";
- case DarwinPlatformKind::IPhoneOS:
- return "-mios-version-min=";
- case DarwinPlatformKind::IPhoneOSSimulator:
- return "-mios-simulator-version-min=";
- case DarwinPlatformKind::TvOS:
- return "-mtvos-version-min=";
- case DarwinPlatformKind::TvOSSimulator:
- return "-mtvos-simulator-version-min=";
- case DarwinPlatformKind::WatchOS:
- return "-mwatchos-version-min=";
- case DarwinPlatformKind::WatchOSSimulator:
- return "-mwatchos-simulator-version-min=";
- }
- llvm_unreachable("Unsupported Darwin platform");
-}
-
static void
getNormalInvocationArguments(std::vector<std::string> &invocationArgStrs,
ASTContext &ctx,
@@ -659,24 +638,6 @@
invocationArgStrs.push_back("-target");
invocationArgStrs.push_back(triple.str());
- if (triple.isOSDarwin()) {
- std::string minVersionBuf;
- llvm::raw_string_ostream minVersionOpt{minVersionBuf};
- minVersionOpt << getMinVersionOptNameForDarwinTriple(triple);
-
- unsigned major, minor, micro;
- if (triple.isiOS()) {
- triple.getiOSVersion(major, minor, micro);
- } else if (triple.isWatchOS()) {
- triple.getWatchOSVersion(major, minor, micro);
- } else {
- assert(triple.isMacOSX());
- triple.getMacOSXVersion(major, minor, micro);
- }
- minVersionOpt << clang::VersionTuple(major, minor, micro);
- invocationArgStrs.push_back(std::move(minVersionOpt.str()));
- }
-
invocationArgStrs.push_back(ImporterImpl::moduleImportBufferName);
if (ctx.LangOpts.EnableAppExtensionRestrictions) {
diff --git a/lib/ClangImporter/ImportType.cpp b/lib/ClangImporter/ImportType.cpp
index c1b09ad..d2c6249 100644
--- a/lib/ClangImporter/ImportType.cpp
+++ b/lib/ClangImporter/ImportType.cpp
@@ -224,6 +224,7 @@
// FIXME: Types that can be mapped, but aren't yet.
case clang::BuiltinType::Half:
+ case clang::BuiltinType::Float16:
case clang::BuiltinType::Float128:
case clang::BuiltinType::NullPtr:
return Type();
diff --git a/lib/Frontend/ArgsToFrontendOptionsConverter.cpp b/lib/Frontend/ArgsToFrontendOptionsConverter.cpp
index 68c583a..697f015 100644
--- a/lib/Frontend/ArgsToFrontendOptionsConverter.cpp
+++ b/lib/Frontend/ArgsToFrontendOptionsConverter.cpp
@@ -117,9 +117,6 @@
if (checkUnusedSupplementaryOutputPaths())
return true;
- if (const Arg *A = Args.getLastArg(OPT_emit_fixits_path))
- Opts.FixitsOutputPath = A->getValue();
-
if (const Arg *A = Args.getLastArg(OPT_module_link_name))
Opts.ModuleLinkName = A->getValue();
diff --git a/lib/Frontend/ArgsToFrontendOutputsConverter.cpp b/lib/Frontend/ArgsToFrontendOutputsConverter.cpp
index 5698a56..f9616c2 100644
--- a/lib/Frontend/ArgsToFrontendOutputsConverter.cpp
+++ b/lib/Frontend/ArgsToFrontendOutputsConverter.cpp
@@ -283,13 +283,15 @@
options::OPT_emit_reference_dependencies_path);
auto serializedDiagnostics = getSupplementaryFilenamesFromArguments(
options::OPT_serialize_diagnostics_path);
+ auto fixItsOutput = getSupplementaryFilenamesFromArguments(
+ options::OPT_emit_fixits_path);
auto loadedModuleTrace = getSupplementaryFilenamesFromArguments(
options::OPT_emit_loaded_module_trace_path);
auto TBD = getSupplementaryFilenamesFromArguments(options::OPT_emit_tbd_path);
if (!objCHeaderOutput || !moduleOutput || !moduleDocOutput ||
!dependenciesFile || !referenceDependenciesFile ||
- !serializedDiagnostics || !loadedModuleTrace || !TBD) {
+ !serializedDiagnostics || !fixItsOutput || !loadedModuleTrace || !TBD) {
return None;
}
std::vector<SupplementaryOutputPaths> result;
@@ -304,6 +306,7 @@
sop.DependenciesFilePath = (*dependenciesFile)[i];
sop.ReferenceDependenciesFilePath = (*referenceDependenciesFile)[i];
sop.SerializedDiagnosticsPath = (*serializedDiagnostics)[i];
+ sop.FixItsOutputPath = (*fixItsOutput)[i];
sop.LoadedModuleTracePath = (*loadedModuleTrace)[i];
sop.TBDPath = (*TBD)[i];
@@ -356,6 +359,9 @@
OPT_serialize_diagnostics, pathsFromArguments.SerializedDiagnosticsPath,
"dia", "", defaultSupplementaryOutputPathExcludingExtension);
+ // There is no non-path form of -emit-fixits-path
+ auto fixItsOutputPath = pathsFromArguments.FixItsOutputPath;
+
auto objcHeaderOutputPath = determineSupplementaryOutputFilename(
OPT_emit_objc_header, pathsFromArguments.ObjCHeaderOutputPath, "h", "",
defaultSupplementaryOutputPathExcludingExtension);
@@ -391,6 +397,7 @@
sop.DependenciesFilePath = dependenciesFilePath;
sop.ReferenceDependenciesFilePath = referenceDependenciesFilePath;
sop.SerializedDiagnosticsPath = serializedDiagnosticsPath;
+ sop.FixItsOutputPath = fixItsOutputPath;
sop.LoadedModuleTracePath = loadedModuleTracePath;
sop.TBDPath = tbdPath;
return sop;
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
index 6eb05c3..b522760 100644
--- a/lib/Frontend/CompilerInvocation.cpp
+++ b/lib/Frontend/CompilerInvocation.cpp
@@ -908,8 +908,10 @@
return false;
}
-bool ParseMigratorArgs(MigratorOptions &Opts, llvm::Triple &Triple,
- StringRef ResourcePath, ArgList &Args,
+bool ParseMigratorArgs(MigratorOptions &Opts,
+ const FrontendOptions &FrontendOpts,
+ const llvm::Triple &Triple,
+ StringRef ResourcePath, const ArgList &Args,
DiagnosticEngine &Diags) {
using namespace options;
@@ -958,6 +960,21 @@
}
}
+ if (Opts.shouldRunMigrator()) {
+ assert(!FrontendOpts.InputsAndOutputs.isWholeModule());
+ // FIXME: In order to support batch mode properly, the migrator would have
+ // to support having one remap file path and one migrated file path per
+ // primary input. The easiest way to do this would be to move processing of
+ // these paths into FrontendOptions, like other supplementary outputs, and
+ // to call migrator::updateCodeAndEmitRemapIfNeeded once for each primary
+ // file.
+ //
+ // Supporting WMO would be similar, but WMO is set up to only produce one
+ // supplementary output for the whole compilation instead of one per input,
+ // so it's probably not worth it.
+ FrontendOpts.InputsAndOutputs.assertMustNotBeMoreThanOnePrimaryInput();
+ }
+
return false;
}
@@ -1022,7 +1039,7 @@
return true;
}
- if (ParseMigratorArgs(MigratorOpts, LangOpts.Target,
+ if (ParseMigratorArgs(MigratorOpts, FrontendOpts, LangOpts.Target,
SearchPathOpts.RuntimeResourcePath, ParsedArgs, Diags)) {
return true;
}
diff --git a/lib/Frontend/DiagnosticVerifier.cpp b/lib/Frontend/DiagnosticVerifier.cpp
index 604bb78..e43fc97 100644
--- a/lib/Frontend/DiagnosticVerifier.cpp
+++ b/lib/Frontend/DiagnosticVerifier.cpp
@@ -17,9 +17,10 @@
#include "swift/Frontend/DiagnosticVerifier.h"
#include "swift/Basic/SourceManager.h"
#include "swift/Parse/Lexer.h"
+#include "llvm/Support/FileSystem.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"
-#include <fstream>
+
using namespace swift;
namespace {
@@ -688,9 +689,12 @@
// Retain the end of the file.
Result.append(LastPos, bufferRange.end());
-
- std::ofstream outs(memBuffer->getBufferIdentifier());
- outs << Result;
+
+ std::error_code error;
+ llvm::raw_fd_ostream outs(memBuffer->getBufferIdentifier(), error,
+ llvm::sys::fs::OpenFlags::F_None);
+ if (!error)
+ outs << Result;
}
//===----------------------------------------------------------------------===//
diff --git a/lib/FrontendTool/FrontendTool.cpp b/lib/FrontendTool/FrontendTool.cpp
index 041886c..743c1d7 100644
--- a/lib/FrontendTool/FrontendTool.cpp
+++ b/lib/FrontendTool/FrontendTool.cpp
@@ -1509,6 +1509,41 @@
ProfileEvents, ProfileEntities);
}
+/// Creates a diagnostic consumer that handles dispatching diagnostics to
+/// multiple output files, based on the supplementary output paths specified by
+/// \p inputsAndOutputs.
+///
+/// If no output files are needed, returns null.
+static std::unique_ptr<DiagnosticConsumer>
+createDispatchingDiagnosticConsumerIfNeeded(
+ const FrontendInputsAndOutputs &inputsAndOutputs,
+ llvm::function_ref<std::unique_ptr<DiagnosticConsumer>(const InputFile &)>
+ maybeCreateSingleConsumer) {
+
+ // The "4" here is somewhat arbitrary. In practice we're going to have one
+ // sub-consumer for each diagnostic file we're trying to output, which (again
+ // in practice) is going to be 1 in WMO mode and equal to the number of
+ // primary inputs in batch mode. That in turn is going to be "the number of
+ // files we need to recompile in this build, divided by the number of jobs".
+ // So a value of "4" here means that there would be no heap allocation on a
+ // clean build of a module with up to 32 files on an 8-core machine, if the
+ // user doesn't customize anything.
+ SmallVector<FileSpecificDiagnosticConsumer::ConsumerPair, 4> subConsumers;
+
+ inputsAndOutputs.forEachInputProducingSupplementaryOutput(
+ [&](const InputFile &input) -> bool {
+ if (auto subConsumer = maybeCreateSingleConsumer(input))
+ subConsumers.emplace_back(input.file(), std::move(subConsumer));
+ return false;
+ });
+
+ if (subConsumers.empty())
+ return nullptr;
+ if (subConsumers.size() == 1)
+ return std::move(subConsumers.front()).second;
+ return llvm::make_unique<FileSpecificDiagnosticConsumer>(subConsumers);
+}
+
/// Creates a diagnostic consumer that handles serializing diagnostics, based on
/// the supplementary output paths specified by \p inputsAndOutputs.
///
@@ -1520,39 +1555,39 @@
static std::unique_ptr<DiagnosticConsumer>
createSerializedDiagnosticConsumerIfNeeded(
const FrontendInputsAndOutputs &inputsAndOutputs) {
-
- // The "4" here is somewhat arbitrary. In practice we're going to have one
- // sub-consumer for each .dia file we're trying to output, which (again in
- // practice) is going to be 1 in WMO mode and equal to the number of primary
- // inputs in batch mode. That in turn is going to be "the number of files we
- // need to recompile in this build, divided by the number of jobs". So a
- // value of "4" here means that there would be no heap allocation on a clean
- // build of a module with up to 32 files on an 8-core machine, if the user
- // doesn't customize anything.
- SmallVector<FileSpecificDiagnosticConsumer::ConsumerPair, 4>
- serializedConsumers;
-
- inputsAndOutputs.forEachInputProducingSupplementaryOutput(
- [&](const InputFile &Input) -> bool {
- std::string serializedDiagnosticsPath = Input.serializedDiagnosticsPath();
+ return createDispatchingDiagnosticConsumerIfNeeded(
+ inputsAndOutputs,
+ [](const InputFile &input) -> std::unique_ptr<DiagnosticConsumer> {
+ std::string serializedDiagnosticsPath = input.serializedDiagnosticsPath();
if (serializedDiagnosticsPath.empty())
- return false;
-
- serializedConsumers.emplace_back(
- Input.file(),
- serialized_diagnostics::createConsumer(serializedDiagnosticsPath));
-
- // Continue for other inputs.
- return false;
+ return nullptr;
+ return serialized_diagnostics::createConsumer(serializedDiagnosticsPath);
});
-
- if (serializedConsumers.empty())
- return nullptr;
- if (serializedConsumers.size() == 1)
- return std::move(serializedConsumers.front()).second;
- return llvm::make_unique<FileSpecificDiagnosticConsumer>(serializedConsumers);
}
+/// Creates a diagnostic consumer that handles serializing diagnostics, based on
+/// the supplementary output paths specified in \p options.
+///
+/// The returned consumer will handle producing multiple serialized diagnostics
+/// files if necessary, by using sub-consumers for each file and dispatching to
+/// the right one.
+///
+/// If no serialized diagnostics are being produced, returns null.
+static std::unique_ptr<DiagnosticConsumer>
+createJSONFixItDiagnosticConsumerIfNeeded(
+ const CompilerInvocation &invocation) {
+ return createDispatchingDiagnosticConsumerIfNeeded(
+ invocation.getFrontendOptions().InputsAndOutputs,
+ [&](const InputFile &input) -> std::unique_ptr<DiagnosticConsumer> {
+ std::string fixItsOutputPath = input.fixItsOutputPath();
+ if (fixItsOutputPath.empty())
+ return nullptr;
+ return llvm::make_unique<JSONFixitWriter>(
+ fixItsOutputPath, invocation.getDiagnosticOptions());
+ });
+}
+
+
int swift::performFrontend(ArrayRef<const char *> Args,
const char *Argv0, void *MainAddr,
FrontendObserver *observer) {
@@ -1671,17 +1706,10 @@
if (SerializedConsumerDispatcher)
Instance->addDiagnosticConsumer(SerializedConsumerDispatcher.get());
- // FIXME: The fix-its need to be multiplexed like the serialized diagnostics.
- std::unique_ptr<DiagnosticConsumer> FixitsConsumer;
- {
- const std::string &FixitsOutputPath =
- Invocation.getFrontendOptions().FixitsOutputPath;
- if (!FixitsOutputPath.empty()) {
- FixitsConsumer.reset(new JSONFixitWriter(FixitsOutputPath,
- Invocation.getDiagnosticOptions()));
- Instance->addDiagnosticConsumer(FixitsConsumer.get());
- }
- }
+ std::unique_ptr<DiagnosticConsumer> FixItsConsumer =
+ createJSONFixItDiagnosticConsumerIfNeeded(Invocation);
+ if (FixItsConsumer)
+ Instance->addDiagnosticConsumer(FixItsConsumer.get());
if (Invocation.getDiagnosticOptions().UseColor)
PDC.forceColors();
diff --git a/lib/IDE/APIDigesterData.cpp b/lib/IDE/APIDigesterData.cpp
index 8e7450d..cc6d032 100644
--- a/lib/IDE/APIDigesterData.cpp
+++ b/lib/IDE/APIDigesterData.cpp
@@ -309,7 +309,7 @@
#define DIFF_ITEM_KEY_KIND_STRING(NAME) StringRef NAME;
#define DIFF_ITEM_KEY_KIND_INT(NAME) Optional<int> NAME;
#include "swift/IDE/DigesterEnums.def"
- for (auto Pair : *Node) {
+ for (auto &Pair : *Node) {
switch(parseKeyKind(getScalarString(Pair.getKey()))) {
#define DIFF_ITEM_KEY_KIND_STRING(NAME) \
case DiffItemKeyKind::KK_##NAME: \
diff --git a/lib/IRGen/GenCall.cpp b/lib/IRGen/GenCall.cpp
index a90895f..b2157ce 100644
--- a/lib/IRGen/GenCall.cpp
+++ b/lib/IRGen/GenCall.cpp
@@ -870,6 +870,9 @@
return convertFloatingType(Ctx.getTargetInfo().getDoubleFormat());
case clang::BuiltinType::LongDouble:
return convertFloatingType(Ctx.getTargetInfo().getLongDoubleFormat());
+ case clang::BuiltinType::Float16:
+ llvm_unreachable("When upstream support is added for Float16 in "
+ "clang::TargetInfo, use the implementation here");
case clang::BuiltinType::Float128:
return convertFloatingType(Ctx.getTargetInfo().getFloat128Format());
diff --git a/lib/IRGen/IRBuilder.h b/lib/IRGen/IRBuilder.h
index ac59edc..8c2d1d2 100644
--- a/lib/IRGen/IRBuilder.h
+++ b/lib/IRGen/IRBuilder.h
@@ -376,7 +376,7 @@
} // end namespace swift
namespace llvm {
- template <> class PointerLikeTypeTraits<swift::irgen::IRBuilder::StableIP> {
+ template <> struct PointerLikeTypeTraits<swift::irgen::IRBuilder::StableIP> {
typedef swift::irgen::IRBuilder::StableIP type;
public:
static void *getAsVoidPointer(type IP) {
diff --git a/lib/IRGen/IRGen.cpp b/lib/IRGen/IRGen.cpp
index 353faeb..40d3a5f 100644
--- a/lib/IRGen/IRGen.cpp
+++ b/lib/IRGen/IRGen.cpp
@@ -41,6 +41,7 @@
#include "llvm/Bitcode/BitcodeWriter.h"
#include "llvm/Bitcode/BitcodeWriterPass.h"
#include "llvm/CodeGen/BasicTTIImpl.h"
+#include "llvm/CodeGen/TargetSubtargetInfo.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/IRPrintingPasses.h"
@@ -62,7 +63,6 @@
#include "llvm/Support/Path.h"
#include "llvm/Support/TargetRegistry.h"
#include "llvm/Target/TargetMachine.h"
-#include "llvm/Target/TargetSubtargetInfo.h"
#include "llvm/Transforms/Coroutines.h"
#include "llvm/Transforms/IPO.h"
#include "llvm/Transforms/IPO/AlwaysInliner.h"
@@ -556,7 +556,7 @@
// Create a target machine.
llvm::TargetMachine *TargetMachine = Target->createTargetMachine(
EffectiveTriple.str(), CPU, targetFeatures, TargetOpts, Reloc::PIC_,
- CodeModel::Default, OptLevel);
+ None, OptLevel);
if (!TargetMachine) {
Ctx.Diags.diagnose(SourceLoc(), diag::no_llvm_target,
EffectiveTriple.str(), "no LLVM target machine");
diff --git a/lib/IRGen/SwiftTargetInfo.cpp b/lib/IRGen/SwiftTargetInfo.cpp
index 3a5b504..c8a5a1c 100644
--- a/lib/IRGen/SwiftTargetInfo.cpp
+++ b/lib/IRGen/SwiftTargetInfo.cpp
@@ -51,7 +51,7 @@
// arm64 requires marker assembly for objc_retainAutoreleasedReturnValue.
target.ObjCRetainAutoreleasedReturnValueMarker =
- "mov\tfp, fp\t\t# marker for objc_retainAutoreleaseReturnValue";
+ "mov\tfp, fp\t\t// marker for objc_retainAutoreleaseReturnValue";
// arm64 requires ISA-masking.
target.ObjCUseISAMask = true;
@@ -100,7 +100,7 @@
SwiftTargetInfo &target) {
// ARM requires marker assembly for objc_retainAutoreleasedReturnValue.
target.ObjCRetainAutoreleasedReturnValueMarker =
- "mov\tr7, r7\t\t@ marker for objc_retainAutoreleaseReturnValue";
+ "mov\tr7, r7\t\t// marker for objc_retainAutoreleaseReturnValue";
// armv7k has opaque ISAs which must go through the ObjC runtime.
if (triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v7k)
diff --git a/lib/Index/Index.cpp b/lib/Index/Index.cpp
index 06b2c47..44b2391 100644
--- a/lib/Index/Index.cpp
+++ b/lib/Index/Index.cpp
@@ -1209,7 +1209,7 @@
IndexSymbol Info;
Info.decl = nullptr;
Info.symInfo = SymbolInfo{ SymbolKind::CommentTag, SymbolSubKind::None,
- SymbolPropertySet(), SymbolLanguage::Swift };
+ SymbolLanguage::Swift, SymbolPropertySet() };
Info.roles |= (unsigned)SymbolRole::Definition;
Info.name = StringRef();
SmallString<128> storage;
diff --git a/lib/Index/IndexSymbol.cpp b/lib/Index/IndexSymbol.cpp
index acfd1f1..afcc92d 100644
--- a/lib/Index/IndexSymbol.cpp
+++ b/lib/Index/IndexSymbol.cpp
@@ -138,7 +138,7 @@
SymbolInfo index::getSymbolInfoForDecl(const Decl *D) {
SymbolInfo info{ SymbolKind::Unknown, SymbolSubKind::None,
- SymbolPropertySet(), SymbolLanguage::Swift };
+ SymbolLanguage::Swift, SymbolPropertySet() };
switch (D->getKind()) {
case DeclKind::Enum: info.Kind = SymbolKind::Enum; break;
case DeclKind::Struct: info.Kind = SymbolKind::Struct; break;
diff --git a/lib/LLVMPasses/LLVMSwiftAA.cpp b/lib/LLVMPasses/LLVMSwiftAA.cpp
index 4b349b4..97e3350 100644
--- a/lib/LLVMPasses/LLVMSwiftAA.cpp
+++ b/lib/LLVMPasses/LLVMSwiftAA.cpp
@@ -25,7 +25,7 @@
static ModRefInfo getConservativeModRefForKind(const llvm::Instruction &I) {
switch (classifyInstruction(I)) {
-#define KIND(Name, MemBehavior) case RT_ ## Name: return MRI_ ## MemBehavior;
+#define KIND(Name, MemBehavior) case RT_ ## Name: return ModRefInfo:: MemBehavior;
#include "LLVMSwift.def"
}
@@ -37,8 +37,9 @@
// We know at compile time that certain entry points do not modify any
// compiler-visible state ever. Quickly check if we have one of those
// instructions and return if so.
- if (MRI_NoModRef == getConservativeModRefForKind(*CS.getInstruction()))
- return MRI_NoModRef;
+ if (ModRefInfo::NoModRef ==
+ getConservativeModRefForKind(*CS.getInstruction()))
+ return ModRefInfo::NoModRef;
// Otherwise, delegate to the rest of the AA ModRefInfo machinery.
return AAResultBase::getModRefInfo(CS, Loc);
diff --git a/lib/Parse/Lexer.cpp b/lib/Parse/Lexer.cpp
index 66829cd..047e880 100644
--- a/lib/Parse/Lexer.cpp
+++ b/lib/Parse/Lexer.cpp
@@ -283,7 +283,9 @@
StringRef TokenText { TokStart, static_cast<size_t>(CurPtr - TokStart) };
- lexTrivia(TrailingTrivia, /* IsForTrailingTrivia */ true);
+ if (TriviaRetention == TriviaRetentionMode::WithTrivia) {
+ lexTrivia(TrailingTrivia, /* IsForTrailingTrivia */ true);
+ }
NextToken.setToken(Kind, TokenText, CommentLength, MultilineString);
}
@@ -292,11 +294,11 @@
assert(CurPtr - TokStart >= 3 && "escaped identifier must be longer than or equal 3 bytes");
assert(TokStart[0] == '`' && "escaped identifier starts with backtick");
assert(CurPtr[-1] == '`' && "escaped identifier ends with backtick");
- if (TriviaRetention == TriviaRetentionMode::WithTrivia) {
- LeadingTrivia.push_back(TriviaPiece::backtick());
- assert(TrailingTrivia.empty() && "TrailingTrivia is empty here");
- TrailingTrivia.push_back(TriviaPiece::backtick());
- }
+
+ LeadingTrivia.push_back(TriviaPiece::backtick());
+ assert(TrailingTrivia.empty() && "TrailingTrivia is empty here");
+ TrailingTrivia.push_back(TriviaPiece::backtick());
+
formToken(tok::identifier, TokStart);
// If this token is at ArtificialEOF, it's forced to be tok::eof. Don't mark
// this as escaped-identifier in this case.
@@ -2159,18 +2161,15 @@
assert(CurPtr >= BufferStart &&
CurPtr <= BufferEnd && "Current pointer out of range!");
- if (TriviaRetention == TriviaRetentionMode::WithTrivia) {
- LeadingTrivia.clear();
- TrailingTrivia.clear();
- }
+ LeadingTrivia.clear();
+ TrailingTrivia.clear();
+
if (CurPtr == BufferStart) {
if (BufferStart < ContentStart) {
size_t BOMLen = ContentStart - BufferStart;
assert(BOMLen == 3 && "UTF-8 BOM is 3 bytes");
- if (TriviaRetention == TriviaRetentionMode::WithTrivia) {
- // Add UTF-8 BOM to LeadingTrivia.
- LeadingTrivia.push_back(TriviaPiece::garbageText({CurPtr, BOMLen}));
- }
+ // Add UTF-8 BOM to LeadingTrivia.
+ LeadingTrivia.push_back(TriviaPiece::garbageText({CurPtr, BOMLen}));
CurPtr += BOMLen;
}
NextToken.setAtStartOfLine(true);
@@ -2182,7 +2181,6 @@
LastCommentBlockStart = CurPtr;
SeenComment = false;
-Restart:
lexTrivia(LeadingTrivia, /* IsForTrailingTrivia */ false);
// Remember the start of the token so we can form the text range.
@@ -2198,24 +2196,23 @@
return lexOperatorIdentifier();
bool ShouldTokenize = lexUnknown(/*EmitDiagnosticsIfToken=*/true);
- if (ShouldTokenize) {
- return formToken(tok::unknown, TokStart);
- }
- goto Restart; // Skip presumed whitespace.
+ assert(
+ ShouldTokenize &&
+ "Invalid UTF-8 sequence should be eaten by lexTrivia as LeadingTrivia");
+ (void)ShouldTokenize;
+ return formToken(tok::unknown, TokStart);
}
case '\n':
case '\r':
- assert(TriviaRetention != TriviaRetentionMode::WithTrivia &&
- "newlines should be eaten by lexTrivia as LeadingTrivia");
- NextToken.setAtStartOfLine(true);
- goto Restart; // Skip whitespace.
+ llvm_unreachable("Newlines should be eaten by lexTrivia as LeadingTrivia");
case ' ':
case '\t':
case '\f':
case '\v':
- goto Restart; // Skip whitespace.
+ llvm_unreachable(
+ "Whitespaces should be eaten by lexTrivia as LeadingTrivia");
case -1:
case -2:
@@ -2228,17 +2225,16 @@
case NulCharacterKind::CodeCompletion:
return formToken(tok::code_complete, TokStart);
- case NulCharacterKind::Embedded:
- // If this is a random nul character in the middle of a buffer, skip it as
- // whitespace.
- diagnoseEmbeddedNul(Diags, CurPtr-1);
- goto Restart;
case NulCharacterKind::BufferEnd:
- // Otherwise, this is the real end of the buffer. Put CurPtr back into
- // buffer bounds.
+ // This is the real end of the buffer.
+ // Put CurPtr back into buffer bounds.
--CurPtr;
// Return EOF.
return formToken(tok::eof, TokStart);
+
+ case NulCharacterKind::Embedded:
+ llvm_unreachable(
+ "Embedded nul should be eaten by lexTrivia as LeadingTrivia");
}
case '@': return formToken(tok::at_sign, TokStart);
@@ -2275,16 +2271,16 @@
if (CurPtr[0] == '/') { // "//"
skipSlashSlashComment(/*EatNewline=*/true);
SeenComment = true;
- if (isKeepingComments())
- return formToken(tok::comment, TokStart);
- goto Restart;
+ assert(isKeepingComments() &&
+ "Non token comment should be eaten by lexTrivia as LeadingTrivia");
+ return formToken(tok::comment, TokStart);
}
if (CurPtr[0] == '*') { // "/*"
skipSlashStarComment();
SeenComment = true;
- if (isKeepingComments())
- return formToken(tok::comment, TokStart);
- goto Restart;
+ assert(isKeepingComments() &&
+ "Non token comment should be eaten by lexTrivia as LeadingTrivia");
+ return formToken(tok::comment, TokStart);
}
return lexOperatorIdentifier();
case '%':
@@ -2313,13 +2309,9 @@
case '<':
if (CurPtr[0] == '#')
return tryLexEditorPlaceholder();
- else if (CurPtr[0] == '<' && tryLexConflictMarker(/*EatNewline=*/true))
- goto Restart;
- return lexOperatorIdentifier();
+ return lexOperatorIdentifier();
case '>':
- if (CurPtr[0] == '>' && tryLexConflictMarker(/*EatNewline=*/true))
- goto Restart;
return lexOperatorIdentifier();
case '=': case '-': case '+': case '*':
@@ -2378,9 +2370,6 @@
}
void Lexer::lexTrivia(syntax::Trivia &Pieces, bool IsForTrailingTrivia) {
- if (TriviaRetention == TriviaRetentionMode::WithoutTrivia)
- return;
-
Restart:
const char *TriviaStart = CurPtr;
diff --git a/lib/SIL/Dominance.cpp b/lib/SIL/Dominance.cpp
index eb27420..88e034c 100644
--- a/lib/SIL/Dominance.cpp
+++ b/lib/SIL/Dominance.cpp
@@ -24,10 +24,8 @@
namespace llvm {
namespace DomTreeBuilder {
-template void Calculate<SILDomTree, swift::SILFunction>(
- SILDomTree &DT, swift::SILFunction &F);
-template void Calculate<SILPostDomTree, swift::SILFunction>(
- SILPostDomTree &DT, swift::SILFunction &F);
+template void Calculate<SILDomTree>(SILDomTree &DT);
+template void Calculate<SILPostDomTree>(SILPostDomTree &DT);
} // namespace DomTreeBuilder
} // namespace llvm
diff --git a/lib/SIL/SILOwnershipVerifier.cpp b/lib/SIL/SILOwnershipVerifier.cpp
index 67c1107..70d3889 100644
--- a/lib/SIL/SILOwnershipVerifier.cpp
+++ b/lib/SIL/SILOwnershipVerifier.cpp
@@ -150,7 +150,7 @@
namespace llvm {
-template <> class PointerLikeTypeTraits<GeneralizedUser> {
+template <> struct PointerLikeTypeTraits<GeneralizedUser> {
public:
static void *getAsVoidPointer(GeneralizedUser v) {
diff --git a/lib/SIL/SILVerifier.cpp b/lib/SIL/SILVerifier.cpp
index cf92a42..2ac2bff 100644
--- a/lib/SIL/SILVerifier.cpp
+++ b/lib/SIL/SILVerifier.cpp
@@ -2342,14 +2342,6 @@
case SILInstructionKind::ApplyInst:
case SILInstructionKind::TryApplyInst:
case SILInstructionKind::PartialApplyInst:
- // Non-Mutating set pattern that allows a inout (that can't really
- // write back. Only SILGen generates PointerToThinkFunction
- // instructions in the writeback code.
- if (auto *AI = dyn_cast<ApplyInst>(inst)) {
- if (isa<PointerToThinFunctionInst>(AI->getCallee())) {
- break;
- }
- }
if (isConsumingOrMutatingApplyUse(use))
return true;
else
@@ -3849,7 +3841,13 @@
case KeyPathPatternComponent::Kind::SettableProperty: {
bool hasIndices = !component.getSubscriptIndices().empty();
- // Getter should be <Sig...> @convention(thin) (@in Base) -> @out Result
+ ParameterConvention normalArgConvention;
+ if (F.getModule().getOptions().EnableGuaranteedNormalArguments)
+ normalArgConvention = ParameterConvention::Indirect_In_Guaranteed;
+ else
+ normalArgConvention = ParameterConvention::Indirect_In;
+
+ // Getter should be <Sig...> @convention(thin) (@in_guaranteed Base) -> @out Result
{
auto getter = component.getComputedPropertyGetter();
auto substGetterType = getter->getLoweredFunctionType()
@@ -3861,9 +3859,8 @@
require(substGetterType->getNumParameters() == 1 + hasIndices,
"getter should have one parameter");
auto baseParam = substGetterType->getParameters()[0];
- require(baseParam.getConvention() ==
- ParameterConvention::Indirect_In,
- "getter base parameter should be @in");
+ require(baseParam.getConvention() == normalArgConvention,
+ "getter base parameter should have normal arg convention");
require(baseParam.getType() == loweredBaseTy.getSwiftRValueType(),
"getter base parameter should match base of component");
@@ -3889,7 +3886,7 @@
if (kind == KeyPathPatternComponent::Kind::SettableProperty) {
// Setter should be
- // <Sig...> @convention(thin) (@in Result, @in Base) -> ()
+ // <Sig...> @convention(thin) (@in_guaranteed Result, @in Base) -> ()
auto setter = component.getComputedPropertySetter();
auto substSetterType = setter->getLoweredFunctionType()
@@ -3903,16 +3900,17 @@
"setter should have two parameters");
auto newValueParam = substSetterType->getParameters()[0];
- require(newValueParam.getConvention() ==
- ParameterConvention::Indirect_In,
- "setter value parameter should be @in");
+ // TODO: This should probably be unconditionally +1 when we
+ // can represent that.
+ require(newValueParam.getConvention() == normalArgConvention,
+ "setter value parameter should havee normal arg convention");
auto baseParam = substSetterType->getParameters()[1];
- require(baseParam.getConvention() ==
- ParameterConvention::Indirect_In
+ require(baseParam.getConvention() == normalArgConvention
|| baseParam.getConvention() ==
ParameterConvention::Indirect_Inout,
- "setter base parameter should be @in or @inout");
+ "setter base parameter should be normal arg convention "
+ "or @inout");
if (hasIndices) {
auto indicesParam = substSetterType->getParameters()[2];
diff --git a/lib/SIL/TypeLowering.cpp b/lib/SIL/TypeLowering.cpp
index 37a0957..c54f546 100644
--- a/lib/SIL/TypeLowering.cpp
+++ b/lib/SIL/TypeLowering.cpp
@@ -2071,25 +2071,28 @@
auto selfMetatypeType = MetatypeType::get(selfType,
MetatypeRepresentation::Thick);
+ auto canSelfType = selfType->getCanonicalType(genericSig);
+ auto canSelfMetatypeType = selfMetatypeType->getCanonicalType(genericSig);
+ auto selfConvention = (storage->isSetterMutating()
+ ? ParameterConvention::Indirect_Inout
+ : ParameterConvention::Indirect_In_Guaranteed);
+
{
GenericContextScope scope(*this, genericSig);
// If 'self' is a metatype, make it @thin or @thick as needed, but not inside
// selfMetatypeType.
- if (auto metatype = selfType->getAs<MetatypeType>()) {
+ if (auto metatype = canSelfType->getAs<MetatypeType>()) {
if (!metatype->hasRepresentation())
- selfType = getLoweredType(metatype).getSwiftRValueType();
+ canSelfType = getLoweredType(metatype).getSwiftRValueType();
}
}
- auto canSelfType = selfType->getCanonicalType(genericSig);
- auto canSelfMetatypeType = selfMetatypeType->getCanonicalType(genericSig);
-
// Create the SILFunctionType for the callback.
SILParameterInfo params[] = {
{ ctx.TheRawPointerType, ParameterConvention::Direct_Unowned },
{ ctx.TheUnsafeValueBufferType, ParameterConvention::Indirect_Inout },
- { canSelfType, ParameterConvention::Indirect_Inout },
+ { canSelfType, selfConvention },
{ canSelfMetatypeType, ParameterConvention::Direct_Unowned },
};
ArrayRef<SILResultInfo> results = {};
diff --git a/lib/SILGen/ArgumentSource.cpp b/lib/SILGen/ArgumentSource.cpp
index 9f5ce5e..765a145 100644
--- a/lib/SILGen/ArgumentSource.cpp
+++ b/lib/SILGen/ArgumentSource.cpp
@@ -174,7 +174,9 @@
case Kind::RValue: {
auto loc = getKnownRValueLocation();
if (auto init = C.getEmitInto()) {
- std::move(*this).asKnownRValue(SGF).forwardInto(SGF, loc, init);
+ std::move(*this).asKnownRValue(SGF)
+ .ensurePlusOne(SGF, loc)
+ .forwardInto(SGF, loc, init);
return ManagedValue::forInContext();
} else {
return std::move(*this).asKnownRValue(SGF).getAsSingleValue(SGF, loc);
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
index 53ead97..3149b26 100644
--- a/lib/SILGen/SILGenExpr.cpp
+++ b/lib/SILGen/SILGenExpr.cpp
@@ -3008,7 +3008,14 @@
if (!storage->getDeclContext()->isTypeContext())
return ManagedValue();
- auto paramOrigValue = subSGF.emitManagedRValueWithCleanup(paramArg);
+ ManagedValue paramOrigValue;
+
+ if (subSGF.SGM.M.getOptions().EnableGuaranteedNormalArguments) {
+ paramOrigValue =
+ ManagedValue::forBorrowedRValue(paramArg).copy(subSGF, loc);
+ } else {
+ paramOrigValue = subSGF.emitManagedRValueWithCleanup(paramArg);
+ }
auto paramSubstValue = subSGF.emitOrigToSubstValue(loc, paramOrigValue,
AbstractionPattern::getOpaque(),
baseType);
@@ -3107,9 +3114,15 @@
propertyType);
}
+ ParameterConvention paramConvention;
+ if (SGM.M.getOptions().EnableGuaranteedNormalArguments)
+ paramConvention = ParameterConvention::Indirect_In_Guaranteed;
+ else
+ paramConvention = ParameterConvention::Indirect_In;
+
SmallVector<SILParameterInfo, 2> params;
params.push_back({loweredBaseTy.getSwiftRValueType(),
- ParameterConvention::Indirect_In});
+ paramConvention});
auto &C = SGM.getASTContext();
if (!indexes.empty())
params.push_back({C.getUnsafeRawPointerDecl()->getDeclaredType()
@@ -3224,15 +3237,21 @@
auto &C = SGM.getASTContext();
+ ParameterConvention paramConvention;
+ if (SGM.M.getOptions().EnableGuaranteedNormalArguments)
+ paramConvention = ParameterConvention::Indirect_In_Guaranteed;
+ else
+ paramConvention = ParameterConvention::Indirect_In;
+
SmallVector<SILParameterInfo, 3> params;
// property value
params.push_back({loweredPropTy.getSwiftRValueType(),
- ParameterConvention::Indirect_In});
+ paramConvention});
// base
params.push_back({loweredBaseTy.getSwiftRValueType(),
property->isSetterMutating()
? ParameterConvention::Indirect_Inout
- : ParameterConvention::Indirect_In});
+ : paramConvention});
// indexes
if (!indexes.empty())
params.push_back({C.getUnsafeRawPointerDecl()->getDeclaredType()
@@ -3298,7 +3317,12 @@
indexes,
indexPtrArg);
- auto valueOrig = subSGF.emitManagedRValueWithCleanup(valueArg);
+ ManagedValue valueOrig;
+ if (SGM.M.getOptions().EnableGuaranteedNormalArguments)
+ valueOrig = ManagedValue::forBorrowedRValue(valueArg)
+ .copy(subSGF, loc);
+ else
+ valueOrig = subSGF.emitManagedRValueWithCleanup(valueArg);
auto valueSubst = subSGF.emitOrigToSubstValue(loc, valueOrig,
AbstractionPattern::getOpaque(),
propertyType);
@@ -3613,8 +3637,7 @@
SILValue hashCode;
- // TODO: Combine hashes of the indexes. There isn't a great hash combining
- // interface in the standard library to do this yet.
+ // TODO: Combine hashes of the indexes using an inout _Hasher
{
auto &index = indexes[0];
diff --git a/lib/SILGen/SILGenMaterializeForSet.cpp b/lib/SILGen/SILGenMaterializeForSet.cpp
index 046948d..b3c4cb5 100644
--- a/lib/SILGen/SILGenMaterializeForSet.cpp
+++ b/lib/SILGen/SILGenMaterializeForSet.cpp
@@ -964,7 +964,7 @@
}
// The callback gets the address of 'self' at +0.
- ManagedValue mSelf = ManagedValue::forLValue(self);
+ ManagedValue mSelf = ManagedValue::forUnmanaged(self);
// That's enough to build the l-value.
LValue lvalue = buildLValue(SGF, loc, mSelf, std::move(indices),
diff --git a/lib/SILOptimizer/Transforms/ObjectOutliner.cpp b/lib/SILOptimizer/Transforms/ObjectOutliner.cpp
index 7b846a8..ee77a47 100644
--- a/lib/SILOptimizer/Transforms/ObjectOutliner.cpp
+++ b/lib/SILOptimizer/Transforms/ObjectOutliner.cpp
@@ -286,20 +286,25 @@
ArrayRef<Operand> TailCounts = ARI->getTailAllocatedCounts();
SILType TailType;
unsigned NumTailElems = 0;
- if (!TailCounts.empty()) {
- // We only support a single tail allocated array.
- if (TailCounts.size() > 1)
+
+ // We only support a single tail allocated arrays.
+ // Stdlib's tail allocated arrays don't have any side-effects in the
+ // constructor if the element type is trivial.
+ // TODO: also exclude custom tail allocated arrays which might have
+ // side-effects in the destructor.
+ if (TailCounts.size() != 1)
return false;
- // The number of tail allocated elements must be constant.
- if (auto *ILI = dyn_cast<IntegerLiteralInst>(TailCounts[0].get())) {
- if (ILI->getValue().getActiveBits() > 20)
- return false;
- NumTailElems = ILI->getValue().getZExtValue();
- TailType = ARI->getTailAllocatedTypes()[0];
- } else {
+
+ // The number of tail allocated elements must be constant.
+ if (auto *ILI = dyn_cast<IntegerLiteralInst>(TailCounts[0].get())) {
+ if (ILI->getValue().getActiveBits() > 20)
return false;
- }
+ NumTailElems = ILI->getValue().getZExtValue();
+ TailType = ARI->getTailAllocatedTypes()[0];
+ } else {
+ return false;
}
+
SILType Ty = ARI->getType();
ClassDecl *Cl = Ty.getClassOrBoundGenericClass();
if (!Cl)
diff --git a/lib/Sema/CodeSynthesis.cpp b/lib/Sema/CodeSynthesis.cpp
index 2dcc3fb..1e93ffc 100644
--- a/lib/Sema/CodeSynthesis.cpp
+++ b/lib/Sema/CodeSynthesis.cpp
@@ -296,7 +296,9 @@
static AccessorDecl *
createMaterializeForSetPrototype(AbstractStorageDecl *storage,
- FuncDecl *setter, TypeChecker &TC) {
+ FuncDecl *getter,
+ FuncDecl *setter,
+ TypeChecker &TC) {
auto &ctx = storage->getASTContext();
SourceLoc loc = storage->getLoc();
@@ -319,7 +321,7 @@
params.push_back(buildIndexForwardingParamList(storage, bufferElements));
// The accessor returns (temporary: Builtin.RawPointer,
- // callback: Builtin.RawPointer),
+ // callback: Optional<Builtin.RawPointer>),
// where the first pointer is the materialized address and the
// second is the address of an optional callback.
TupleTypeElt retElts[] = {
@@ -349,10 +351,15 @@
// Open-code the setMutating() calculation since we might run before
// the setter has been type checked.
Type contextTy = DC->getDeclaredInterfaceType();
- if (contextTy && !contextTy->hasReferenceSemantics() &&
+ if (contextTy && !contextTy->hasReferenceSemantics()) {
+ bool hasMutatingSetter =
!setter->getAttrs().hasAttribute<NonMutatingAttr>() &&
- storage->isSetterMutating())
- materializeForSet->setSelfAccessKind(SelfAccessKind::Mutating);
+ storage->isSetterMutating();
+ bool hasMutatingGetter =
+ getter->getAttrs().hasAttribute<MutatingAttr>();
+ if (hasMutatingSetter || hasMutatingGetter)
+ materializeForSet->setSelfAccessKind(SelfAccessKind::Mutating);
+ }
materializeForSet->setStatic(storage->isStatic());
@@ -847,7 +854,7 @@
}
auto materializeForSet = createMaterializeForSetPrototype(
- storage, storage->getSetter(), TC);
+ storage, storage->getGetter(), storage->getSetter(), TC);
addMemberToContextIfNeeded(materializeForSet, storage->getDeclContext(),
storage->getSetter());
storage->setMaterializeForSetFunc(materializeForSet);
@@ -1815,7 +1822,9 @@
AccessorDecl *materializeForSet = nullptr;
if (dc->getAsNominalTypeOrNominalTypeExtensionContext())
- materializeForSet = createMaterializeForSetPrototype(var, setter, TC);
+ materializeForSet = createMaterializeForSetPrototype(var,
+ getter, setter,
+ TC);
var->makeComputed(SourceLoc(), getter, setter, materializeForSet, SourceLoc());
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
index 7833007..e6b40b8 100644
--- a/lib/Serialization/Serialization.cpp
+++ b/lib/Serialization/Serialization.cpp
@@ -4347,7 +4347,7 @@
if (!MapNode) {
return true;
}
- for (auto Pair : *MapNode) {
+ for (auto &Pair : *MapNode) {
auto *Key = dyn_cast_or_null<llvm::yaml::ScalarNode>(Pair.getKey());
auto *Value = dyn_cast_or_null<llvm::yaml::SequenceNode>(Pair.getValue());
diff --git a/stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb b/stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb
index 6be54c0..9f626c4 100644
--- a/stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb
+++ b/stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb
@@ -1089,6 +1089,15 @@
static var runNoTestsWasCalled: Bool = false
static var ranSomething: Bool = false
static var complaintInstalled = false
+ static var hashingKeyOverridden = false
+
+ static func overrideHashingKey() {
+ if !hashingKeyOverridden {
+ // FIXME(hasher): This has to run before creating the first Set/Dictionary
+ _Hasher._secretKey = (0, 0)
+ hashingKeyOverridden = true
+ }
+ }
static func complainIfNothingRuns() {
if !complaintInstalled {
@@ -1200,6 +1209,7 @@
public final class TestSuite {
public init(_ name: String) {
+ PersistentState.overrideHashingKey()
self.name = name
_precondition(
_testNameToIndex[name] == nil,
diff --git a/stdlib/public/core/AnyHashable.swift b/stdlib/public/core/AnyHashable.swift
index ef3087b..3e8b243 100644
--- a/stdlib/public/core/AnyHashable.swift
+++ b/stdlib/public/core/AnyHashable.swift
@@ -48,6 +48,7 @@
/// no comparison is possible. Otherwise, contains the result of `==`.
func _isEqual(to: _AnyHashableBox) -> Bool?
var _hashValue: Int { get }
+ func _hash(_into hasher: inout _Hasher)
var _base: Any { get }
func _downCastConditional<T>(into result: UnsafeMutablePointer<T>) -> Bool
@@ -95,6 +96,12 @@
@_inlineable // FIXME(sil-serialize-all)
@_versioned // FIXME(sil-serialize-all)
+ func _hash(_into hasher: inout _Hasher) {
+ _baseHashable._hash(into: &hasher)
+ }
+
+ @_inlineable // FIXME(sil-serialize-all)
+ @_versioned // FIXME(sil-serialize-all)
internal var _base: Any {
return _baseHashable
}
@@ -295,6 +302,11 @@
public var hashValue: Int {
return _box._hashValue
}
+
+ @_inlineable // FIXME(sil-serialize-all)
+ public func _hash(into hasher: inout _Hasher) {
+ _box._hash(_into: &hasher)
+ }
}
extension AnyHashable : CustomStringConvertible {
diff --git a/stdlib/public/core/Bool.swift b/stdlib/public/core/Bool.swift
index 6ab1c17..c4b22c6 100644
--- a/stdlib/public/core/Bool.swift
+++ b/stdlib/public/core/Bool.swift
@@ -154,9 +154,13 @@
/// invocations of the same program. Do not persist the hash value across
/// program runs.
@_inlineable // FIXME(sil-serialize-all)
- @_transparent
public var hashValue: Int {
- return self ? 1 : 0
+ return _hashValue(for: self)
+ }
+
+ @_inlineable // FIXME(sil-serialize-all)
+ public func _hash(into hasher: inout _Hasher) {
+ hasher.append((self ? 1 : 0) as UInt8)
}
@_inlineable // FIXME(sil-serialize-all)
diff --git a/stdlib/public/core/CTypes.swift b/stdlib/public/core/CTypes.swift
index e35d1d7..628903b 100644
--- a/stdlib/public/core/CTypes.swift
+++ b/stdlib/public/core/CTypes.swift
@@ -182,7 +182,12 @@
/// program runs.
@_inlineable // FIXME(sil-serialize-all)
public var hashValue: Int {
- return Int(Builtin.ptrtoint_Word(_rawValue))
+ return _hashValue(for: self)
+ }
+
+ @_inlineable // FIXME(sil-serialize-all)
+ public func _hash(into hasher: inout _Hasher) {
+ hasher.append(Int(Builtin.ptrtoint_Word(_rawValue)))
}
}
diff --git a/stdlib/public/core/DoubleWidth.swift.gyb b/stdlib/public/core/DoubleWidth.swift.gyb
index b7474bb..fe6f93c 100644
--- a/stdlib/public/core/DoubleWidth.swift.gyb
+++ b/stdlib/public/core/DoubleWidth.swift.gyb
@@ -151,10 +151,13 @@
extension DoubleWidth : Hashable {
@_inlineable // FIXME(sil-serialize-all)
public var hashValue: Int {
- var result = 0
- result = _combineHashValues(result, _storage.high.hashValue)
- result = _combineHashValues(result, _storage.low.hashValue)
- return result
+ return _hashValue(for: self)
+ }
+
+ @_inlineable // FIXME(sil-serialize-all)
+ public func _hash(into hasher: inout _Hasher) {
+ hasher.append(low)
+ hasher.append(high)
}
}
diff --git a/stdlib/public/core/DropWhile.swift b/stdlib/public/core/DropWhile.swift
index 741808d..08e8ed8 100644
--- a/stdlib/public/core/DropWhile.swift
+++ b/stdlib/public/core/DropWhile.swift
@@ -190,6 +190,10 @@
public var hashValue: Int {
return base.hashValue
}
+
+ public func _hash(into hasher: inout _Hasher) {
+ hasher.append(base)
+ }
}
extension LazyDropWhileCollection: Collection {
diff --git a/stdlib/public/core/Flatten.swift b/stdlib/public/core/Flatten.swift
index ea8bade..f94f0af 100644
--- a/stdlib/public/core/Flatten.swift
+++ b/stdlib/public/core/Flatten.swift
@@ -233,7 +233,14 @@
extension FlattenCollection.Index : Hashable
where Base.Index : Hashable, Base.Element.Index : Hashable {
public var hashValue: Int {
- return _combineHashValues(_inner?.hashValue ?? 0, _outer.hashValue)
+ return _hashValue(for: self)
+ }
+
+ public func _hash(into hasher: inout _Hasher) {
+ hasher.append(_outer)
+ if let inner = _inner {
+ hasher.append(inner)
+ }
}
}
diff --git a/stdlib/public/core/FloatingPointTypes.swift.gyb b/stdlib/public/core/FloatingPointTypes.swift.gyb
index 39cdc31..ff9a700 100644
--- a/stdlib/public/core/FloatingPointTypes.swift.gyb
+++ b/stdlib/public/core/FloatingPointTypes.swift.gyb
@@ -1524,26 +1524,25 @@
/// your program. Do not save hash values to use during a future execution.
@_inlineable // FIXME(sil-serialize-all)
public var hashValue: Int {
+ return _hashValue(for: self)
+ }
+
+ @_inlineable // FIXME(sil-serialize-all)
+ public func _hash(into hasher: inout _Hasher) {
+ var v = self
if isZero {
// To satisfy the axiom that equality implies hash equality, we need to
// finesse the hash value of -0.0 to match +0.0.
- return 0
- } else {
- %if bits <= word_bits:
- return Int(bitPattern: UInt(bitPattern))
- %elif bits == 64: # Double -> 32-bit Int
- return Int(truncatingIfNeeded: bitPattern &>> 32) ^
- Int(truncatingIfNeeded: bitPattern)
- %elif word_bits == 32: # Float80 -> 32-bit Int
- return Int(truncatingIfNeeded: significandBitPattern &>> 32) ^
- Int(truncatingIfNeeded: significandBitPattern) ^
- Int(_representation.signAndExponent)
- %else: # Float80 -> 64-bit Int
- return Int(bitPattern: UInt(significandBitPattern)) ^
- Int(_representation.signAndExponent)
- %end
+ v = 0
}
+ %if bits == 80:
+ hasher.append(v._representation.signAndExponent)
+ hasher.append(v.significandBitPattern)
+ %else:
+ hasher.append(v.bitPattern)
+ %end
}
+
}
extension ${Self} {
diff --git a/stdlib/public/core/Hashable.swift b/stdlib/public/core/Hashable.swift
index 98fd5ff..d92cad5 100644
--- a/stdlib/public/core/Hashable.swift
+++ b/stdlib/public/core/Hashable.swift
@@ -108,6 +108,24 @@
/// Hash values are not guaranteed to be equal across different executions of
/// your program. Do not save hash values to use during a future execution.
var hashValue: Int { get }
+
+ /// Feed bits to be hashed into the hash function represented by `hasher`.
+ func _hash(into hasher: inout _Hasher)
+}
+
+extension Hashable {
+ @inline(__always)
+ public func _hash(into hasher: inout _Hasher) {
+ hasher.append(self.hashValue)
+ }
+}
+
+// Called by synthesized `hashValue` implementations.
+@inline(__always)
+public func _hashValue<H: Hashable>(for value: H) -> Int {
+ var hasher = _Hasher()
+ hasher.append(value)
+ return hasher.finalize()
}
// Called by the SwiftValue implementation.
@@ -126,4 +144,3 @@
) -> Int {
return value.pointee.hashValue
}
-
diff --git a/stdlib/public/core/HashedCollections.swift.gyb b/stdlib/public/core/HashedCollections.swift.gyb
index b91923f..e755ee2 100644
--- a/stdlib/public/core/HashedCollections.swift.gyb
+++ b/stdlib/public/core/HashedCollections.swift.gyb
@@ -792,11 +792,16 @@
@_inlineable // FIXME(sil-serialize-all)
public var hashValue: Int {
// FIXME(ABI)#177: <rdar://problem/18915294> Cache Set<T> hashValue
- var result: Int = _mixInt(0)
+ return _hashValue(for: self)
+ }
+
+ @_inlineable // FIXME(sil-serialize-all)
+ public func _hash(into hasher: inout _Hasher) {
+ var hash = 0
for member in self {
- result ^= _mixInt(member.hashValue)
+ hash ^= _hashValue(for: member)
}
- return result
+ hasher.append(hash)
}
}
@@ -3985,7 +3990,7 @@
@_versioned
@inline(__always) // For performance reasons.
internal func _bucket(_ k: Key) -> Int {
- return _squeezeHashValue(k.hashValue, bucketCount)
+ return _hashValue(for: k) & _bucketMask
}
@_inlineable // FIXME(sil-serialize-all)
diff --git a/stdlib/public/core/Hashing.swift b/stdlib/public/core/Hashing.swift
index f6fef16..97ff40b 100644
--- a/stdlib/public/core/Hashing.swift
+++ b/stdlib/public/core/Hashing.swift
@@ -25,31 +25,9 @@
@_fixed_layout // FIXME(sil-serialize-all)
public // @testable
-enum _Hashing {
- // FIXME(ABI)#41 : make this an actual public API.
- @_inlineable // FIXME(sil-serialize-all)
- public // SPI
- static var secretKey: (UInt64, UInt64) {
- get {
- // The variable itself is defined in C++ code so that it is initialized
- // during static construction. Almost every Swift program uses hash
- // tables, so initializing the secret key during the startup seems to be
- // the right trade-off.
- return (
- _swift_stdlib_Hashing_secretKey.key0,
- _swift_stdlib_Hashing_secretKey.key1)
- }
- set {
- (_swift_stdlib_Hashing_secretKey.key0,
- _swift_stdlib_Hashing_secretKey.key1) = newValue
- }
- }
-}
-
-@_fixed_layout // FIXME(sil-serialize-all)
-public // @testable
enum _HashingDetail {
+ // FIXME(hasher): Remove
@_inlineable // FIXME(sil-serialize-all)
public // @testable
static var fixedSeedOverride: UInt64 {
@@ -64,6 +42,7 @@
}
}
+ // FIXME(hasher): Remove
@_inlineable // FIXME(sil-serialize-all)
@_versioned
@_transparent
@@ -74,6 +53,7 @@
return _HashingDetail.fixedSeedOverride == 0 ? seed : fixedSeedOverride
}
+ // FIXME(hasher): Remove
@_inlineable // FIXME(sil-serialize-all)
@_versioned
@_transparent
@@ -98,6 +78,7 @@
// their inputs and just exhibit avalanche effect.
//
+// FIXME(hasher): Remove
@_inlineable // FIXME(sil-serialize-all)
@_transparent
public // @testable
@@ -112,6 +93,7 @@
return UInt32((extendedResult >> 3) & 0xffff_ffff)
}
+// FIXME(hasher): Remove
@_inlineable // FIXME(sil-serialize-all)
@_transparent
public // @testable
@@ -119,6 +101,7 @@
return Int32(bitPattern: _mixUInt32(UInt32(bitPattern: value)))
}
+// FIXME(hasher): Remove
@_inlineable // FIXME(sil-serialize-all)
@_transparent
public // @testable
@@ -130,6 +113,7 @@
return _HashingDetail.hash16Bytes(seed &+ (low << 3), high)
}
+// FIXME(hasher): Remove
@_inlineable // FIXME(sil-serialize-all)
@_transparent
public // @testable
@@ -137,6 +121,7 @@
return Int64(bitPattern: _mixUInt64(UInt64(bitPattern: value)))
}
+// FIXME(hasher): Remove
@_inlineable // FIXME(sil-serialize-all)
@_transparent
public // @testable
@@ -148,6 +133,7 @@
#endif
}
+// FIXME(hasher): Remove
@_inlineable // FIXME(sil-serialize-all)
@_transparent
public // @testable
@@ -159,35 +145,6 @@
#endif
}
-/// Given a hash value, returns an integer value in the range of
-/// 0..<`upperBound` that corresponds to a hash value.
-///
-/// The `upperBound` must be positive and a power of 2.
-///
-/// This function is superior to computing the remainder of `hashValue` by
-/// the range length. Some types have bad hash functions; sometimes simple
-/// patterns in data sets create patterns in hash values and applying the
-/// remainder operation just throws away even more information and invites
-/// even more hash collisions. This effect is especially bad because the
-/// range is a power of two, which means to throws away high bits of the hash
-/// (which would not be a problem if the hash was known to be good). This
-/// function mixes the bits in the hash value to compensate for such cases.
-///
-/// Of course, this function is a compressing function, and applying it to a
-/// hash value does not change anything fundamentally: collisions are still
-/// possible, and it does not prevent malicious users from constructing data
-/// sets that will exhibit pathological collisions.
-@_inlineable // FIXME(sil-serialize-all)
-public // @testable
-func _squeezeHashValue(_ hashValue: Int, _ upperBound: Int) -> Int {
- _sanityCheck(_isPowerOf2(upperBound))
- let mixedHashValue = _mixInt(hashValue)
-
- // As `upperBound` is a power of two we can do a bitwise-and to calculate
- // mixedHashValue % upperBound.
- return mixedHashValue & (upperBound &- 1)
-}
-
/// Returns a new value that combines the two given hash values.
///
/// Combining is performed using [a hash function][ref] described by T.C. Hoad
@@ -214,3 +171,130 @@
x ^= UInt(bitPattern: secondValue) &+ magic &+ (x &<< 6) &+ (x &>> 2)
return Int(bitPattern: x)
}
+
+// FIXME(hasher): This hasher emulates Swift 4.1 hashValues. It is purely for
+// benchmarking; to be removed.
+internal struct _LegacyHasher {
+ internal var _hash: Int
+
+ @inline(__always)
+ internal init(key: (UInt64, UInt64) = (0, 0)) { // key is ignored
+ _hash = 0
+ }
+
+ @inline(__always)
+ internal mutating func append(_ value: Int) {
+ _hash = (_hash == 0 ? value : _combineHashValues(_hash, value))
+ }
+
+ @inline(__always)
+ internal mutating func append(_ value: UInt) {
+ append(Int(bitPattern: value))
+ }
+
+ @inline(__always)
+ internal mutating func append(_ value: UInt32) {
+ append(Int(truncatingIfNeeded: value))
+ }
+
+ @inline(__always)
+ internal mutating func append(_ value: UInt64) {
+ if UInt64.bitWidth > Int.bitWidth {
+ append(Int(truncatingIfNeeded: value ^ (value &>> 32)))
+ } else {
+ append(Int(truncatingIfNeeded: value))
+ }
+ }
+
+ @inline(__always)
+ internal mutating func finalize() -> UInt64 {
+ return UInt64(
+ _truncatingBits: UInt(bitPattern: _mixInt(_hash))._lowWord)
+ }
+}
+
+
+// NOT @_fixed_layout
+public struct _Hasher {
+ internal typealias Core = _SipHash13
+
+ // NOT @_versioned
+ internal var _core: Core
+
+ // NOT @_inlineable
+ @effects(releasenone)
+ public init() {
+ self._core = Core(key: _Hasher._secretKey)
+ }
+
+ // NOT @_inlineable
+ @effects(releasenone)
+ public init(key: (UInt64, UInt64)) {
+ self._core = Core(key: key)
+ }
+
+ // FIXME(ABI)#41 : make this an actual public API.
+ @_inlineable // FIXME(sil-serialize-all)
+ public // SPI
+ static var _secretKey: (UInt64, UInt64) {
+ get {
+ // The variable itself is defined in C++ code so that it is initialized
+ // during static construction. Almost every Swift program uses hash
+ // tables, so initializing the secret key during the startup seems to be
+ // the right trade-off.
+ return (
+ _swift_stdlib_Hashing_secretKey.key0,
+ _swift_stdlib_Hashing_secretKey.key1)
+ }
+ set {
+ // FIXME(hasher) Replace setter with some override mechanism inside
+ // the runtime
+ (_swift_stdlib_Hashing_secretKey.key0,
+ _swift_stdlib_Hashing_secretKey.key1) = newValue
+ }
+ }
+
+ @_inlineable
+ @inline(__always)
+ public mutating func append<H: Hashable>(_ value: H) {
+ value._hash(into: &self)
+ }
+
+ // NOT @_inlineable
+ @effects(releasenone)
+ public mutating func append(bits: UInt) {
+ _core.append(bits)
+ }
+ // NOT @_inlineable
+ @effects(releasenone)
+ public mutating func append(bits: UInt32) {
+ _core.append(bits)
+ }
+ // NOT @_inlineable
+ @effects(releasenone)
+ public mutating func append(bits: UInt64) {
+ _core.append(bits)
+ }
+
+ // NOT @_inlineable
+ @effects(releasenone)
+ public mutating func append(bits: Int) {
+ _core.append(UInt(bitPattern: bits))
+ }
+ // NOT @_inlineable
+ @effects(releasenone)
+ public mutating func append(bits: Int32) {
+ _core.append(UInt32(bitPattern: bits))
+ }
+ // NOT @_inlineable
+ @effects(releasenone)
+ public mutating func append(bits: Int64) {
+ _core.append(UInt64(bitPattern: bits))
+ }
+
+ // NOT @_inlineable
+ @effects(releasenone)
+ public mutating func finalize() -> Int {
+ return Int(truncatingIfNeeded: _core.finalize())
+ }
+}
diff --git a/stdlib/public/core/Integers.swift.gyb b/stdlib/public/core/Integers.swift.gyb
index 76bc9ca..a2a02b8 100644
--- a/stdlib/public/core/Integers.swift.gyb
+++ b/stdlib/public/core/Integers.swift.gyb
@@ -3610,22 +3610,29 @@
public var hashValue: Int {
@inline(__always)
get {
-% if bits <= word_bits and signed:
- // Sign extend the value.
- return Int(self)
-% elif bits <= word_bits and not signed:
- // Sign extend the value.
- return Int(${OtherSelf}(bitPattern: self))
-% elif bits == word_bits * 2:
- // We have twice as many bits as we need to return.
- return
- Int(truncatingIfNeeded: self) ^
- Int(truncatingIfNeeded: self &>> 32)
-% else:
- _Unimplemented()
-% end
+ return _hashValue(for: self)
}
}
+
+ @_inlineable // FIXME(sil-serialize-all)
+ public func _hash(into hasher: inout _Hasher) {
+ // FIXME(hasher): To correctly bridge `Set`s/`Dictionary`s containing
+ // `AnyHashable`-boxed integers, all integer values are currently required
+ // to hash exactly the same way as the corresponding (U)Int64 value. To fix
+ // this, we should introduce a custom AnyHashable box for integer values
+ // that sign-extends values to 64 bits.
+ % if bits <= word_bits:
+ hasher.append(bits: _lowWord)
+ % elif bits == 2 * word_bits:
+ if let word = ${"" if signed else "U"}Int(exactly: self) {
+ hasher.append(bits: word._lowWord)
+ } else {
+ hasher.append(bits: UInt64(_value))
+ }
+ % else:
+ fatalError("Unsupported integer width")
+ % end
+ }
}
diff --git a/stdlib/public/core/KeyPath.swift b/stdlib/public/core/KeyPath.swift
index 70dace6..28e9cb7 100644
--- a/stdlib/public/core/KeyPath.swift
+++ b/stdlib/public/core/KeyPath.swift
@@ -49,21 +49,25 @@
@_inlineable // FIXME(sil-serialize-all)
final public var hashValue: Int {
- var hash = 0
- withBuffer {
+ return _hashValue(for: self)
+ }
+
+ @_inlineable // FIXME(sil-serialize-all)
+ public func _hash(into hasher: inout _Hasher) {
+ return withBuffer {
var buffer = $0
while true {
let (component, type) = buffer.next()
- hash ^= _mixInt(component.value.hashValue)
+ hasher.append(component.value)
if let type = type {
- hash ^= _mixInt(unsafeBitCast(type, to: Int.self))
+ hasher.append(unsafeBitCast(type, to: Int.self))
} else {
break
}
}
}
- return hash
}
+
@_inlineable // FIXME(sil-serialize-all)
public static func ==(a: AnyKeyPath, b: AnyKeyPath) -> Bool {
// Fast-path identical objects
@@ -452,11 +456,14 @@
@_inlineable // FIXME(sil-serialize-all)
@_versioned // FIXME(sil-serialize-all)
internal var hashValue: Int {
- var hash = 0
- hash ^= _mixInt(value)
- hash ^= _mixInt(isStoredProperty ? 13 : 17)
- hash ^= _mixInt(isTableOffset ? 19 : 23)
- return hash
+ return _hashValue(for: self)
+ }
+
+ @_inlineable // FIXME(sil-serialize-all)
+ public func _hash(into hasher: inout _Hasher) {
+ hasher.append(value)
+ hasher.append(isStoredProperty)
+ hasher.append(isTableOffset)
}
}
@@ -473,6 +480,7 @@
(_ xInstanceArguments: UnsafeRawPointer,
_ yInstanceArguments: UnsafeRawPointer,
_ size: Int) -> Bool
+ // FIXME(hasher) Append to an inout _Hasher instead
internal typealias Hash = @convention(thin)
(_ instanceArguments: UnsafeRawPointer,
_ size: Int) -> Int
@@ -584,46 +592,54 @@
@_inlineable // FIXME(sil-serialize-all)
@_versioned // FIXME(sil-serialize-all)
internal var hashValue: Int {
- var hash: Int = 0
- func mixHashFromArgument(_ argument: KeyPathComponent.ArgumentRef?) {
+ return _hashValue(for: self)
+ }
+
+ @_inlineable // FIXME(sil-serialize-all)
+ @_versioned // FIXME(sil-serialize-all)
+ internal func _hash(into hasher: inout _Hasher) {
+ var hasher = hasher
+ func appendHashFromArgument(
+ _ argument: KeyPathComponent.ArgumentRef?
+ ) {
if let argument = argument {
- let addedHash = argument.witnesses.pointee.hash(
+ let hash = argument.witnesses.pointee.hash(
argument.data.baseAddress.unsafelyUnwrapped,
argument.data.count)
// Returning 0 indicates that the arguments should not impact the
// hash value of the overall key path.
- if addedHash != 0 {
- hash ^= _mixInt(addedHash)
+ // FIXME(hasher): hash witness should just mutate hasher directly
+ if hash != 0 {
+ hasher.append(hash)
}
}
}
switch self {
case .struct(offset: let a):
- hash ^= _mixInt(0)
- hash ^= _mixInt(a)
+ hasher.append(0)
+ hasher.append(a)
case .class(offset: let b):
- hash ^= _mixInt(1)
- hash ^= _mixInt(b)
+ hasher.append(1)
+ hasher.append(b)
case .optionalChain:
- hash ^= _mixInt(2)
+ hasher.append(2)
case .optionalForce:
- hash ^= _mixInt(3)
+ hasher.append(3)
case .optionalWrap:
- hash ^= _mixInt(4)
+ hasher.append(4)
case .get(id: let id, get: _, argument: let argument):
- hash ^= _mixInt(5)
- hash ^= _mixInt(id.hashValue)
- mixHashFromArgument(argument)
+ hasher.append(5)
+ hasher.append(id)
+ appendHashFromArgument(argument)
case .mutatingGetSet(id: let id, get: _, set: _, argument: let argument):
- hash ^= _mixInt(6)
- hash ^= _mixInt(id.hashValue)
- mixHashFromArgument(argument)
+ hasher.append(6)
+ hasher.append(id)
+ appendHashFromArgument(argument)
case .nonmutatingGetSet(id: let id, get: _, set: _, argument: let argument):
- hash ^= _mixInt(7)
- hash ^= _mixInt(id.hashValue)
- mixHashFromArgument(argument)
+ hasher.append(7)
+ hasher.append(id)
+ appendHashFromArgument(argument)
}
- return hash
}
}
diff --git a/stdlib/public/core/PrefixWhile.swift b/stdlib/public/core/PrefixWhile.swift
index 92a627d..b5e7b1e 100644
--- a/stdlib/public/core/PrefixWhile.swift
+++ b/stdlib/public/core/PrefixWhile.swift
@@ -208,11 +208,15 @@
extension LazyPrefixWhileCollection.Index: Hashable where Base.Index: Hashable {
public var hashValue: Int {
+ return _hashValue(for: self)
+ }
+
+ public func _hash(into hasher: inout _Hasher) {
switch _value {
case .index(let value):
- return value.hashValue
+ hasher.append(value)
case .pastEnd:
- return .max
+ hasher.append(Int.max)
}
}
}
diff --git a/stdlib/public/core/Reverse.swift b/stdlib/public/core/Reverse.swift
index ad08943..01585dd 100644
--- a/stdlib/public/core/Reverse.swift
+++ b/stdlib/public/core/Reverse.swift
@@ -197,6 +197,10 @@
public var hashValue: Int {
return base.hashValue
}
+
+ public func _hash(into hasher: inout _Hasher) {
+ hasher.append(base)
+ }
}
extension ReversedCollection: BidirectionalCollection {
diff --git a/stdlib/public/core/SipHash.swift.gyb b/stdlib/public/core/SipHash.swift.gyb
index 558cca3..54f4d0d 100644
--- a/stdlib/public/core/SipHash.swift.gyb
+++ b/stdlib/public/core/SipHash.swift.gyb
@@ -19,63 +19,20 @@
/// * Daniel J. Bernstein <djb@cr.yp.to>
//===----------------------------------------------------------------------===//
+%{
+# Number of bits in the Builtin.Word type
+word_bits = int(CMAKE_SIZEOF_VOID_P) * 8
+}%
+
@_fixed_layout // FIXME(sil-serialize-all)
@_versioned
internal enum _SipHashDetail {
- @_inlineable // FIXME(sil-serialize-all)
@_versioned
@inline(__always)
- internal static func _rotate(_ x: UInt64, leftBy amount: Int) -> UInt64 {
- return (x &<< UInt64(amount)) | (x &>> UInt64(64 - amount))
+ internal static func _rotate(_ x: UInt64, leftBy amount: UInt64) -> UInt64 {
+ return (x &<< amount) | (x &>> (64 - amount))
}
- @_inlineable // FIXME(sil-serialize-all)
- @_versioned
- @inline(__always)
- internal static func _loadUnalignedUInt64LE(
- from p: UnsafeRawPointer
- ) -> UInt64 {
- // FIXME(integers): split into multiple expressions to speed up the
- // typechecking
- var result =
- UInt64(p.load(fromByteOffset: 0, as: UInt8.self))
- result |=
- (UInt64(p.load(fromByteOffset: 1, as: UInt8.self)) &<< (8 as UInt64))
- result |=
- (UInt64(p.load(fromByteOffset: 2, as: UInt8.self)) &<< (16 as UInt64))
- result |=
- (UInt64(p.load(fromByteOffset: 3, as: UInt8.self)) &<< (24 as UInt64))
- result |=
- (UInt64(p.load(fromByteOffset: 4, as: UInt8.self)) &<< (32 as UInt64))
- result |=
- (UInt64(p.load(fromByteOffset: 5, as: UInt8.self)) &<< (40 as UInt64))
- result |=
- (UInt64(p.load(fromByteOffset: 6, as: UInt8.self)) &<< (48 as UInt64))
- result |=
- (UInt64(p.load(fromByteOffset: 7, as: UInt8.self)) &<< (56 as UInt64))
- return result
- }
-
- @_inlineable // FIXME(sil-serialize-all)
- @_versioned
- @inline(__always)
- internal static func _loadPartialUnalignedUInt64LE(
- from p: UnsafeRawPointer,
- byteCount: Int
- ) -> UInt64 {
- _sanityCheck((0..<8).contains(byteCount))
- var result: UInt64 = 0
- if byteCount >= 1 { result |= UInt64(p.load(fromByteOffset: 0, as: UInt8.self)) }
- if byteCount >= 2 { result |= UInt64(p.load(fromByteOffset: 1, as: UInt8.self)) &<< (8 as UInt64) }
- if byteCount >= 3 { result |= UInt64(p.load(fromByteOffset: 2, as: UInt8.self)) &<< (16 as UInt64) }
- if byteCount >= 4 { result |= UInt64(p.load(fromByteOffset: 3, as: UInt8.self)) &<< (24 as UInt64) }
- if byteCount >= 5 { result |= UInt64(p.load(fromByteOffset: 4, as: UInt8.self)) &<< (32 as UInt64) }
- if byteCount >= 6 { result |= UInt64(p.load(fromByteOffset: 5, as: UInt8.self)) &<< (40 as UInt64) }
- if byteCount >= 7 { result |= UInt64(p.load(fromByteOffset: 6, as: UInt8.self)) &<< (48 as UInt64) }
- return result
- }
-
- @_inlineable // FIXME(sil-serialize-all)
@_versioned
@inline(__always)
internal static func _sipRound(
@@ -102,7 +59,7 @@
}
% for (c_rounds, d_rounds) in [(2, 4), (1, 3)]:
-% Self = '_SipHash{}{}Context'.format(c_rounds, d_rounds)
+% Self = '_SipHash{}{}'.format(c_rounds, d_rounds)
@_fixed_layout // FIXME(sil-serialize-all)
public // @testable
@@ -120,19 +77,14 @@
@_versioned
internal var v3: UInt64 = 0x7465646279746573
+ /// This value holds the byte count and the pending bytes that haven't been
+ /// compressed yet, in the format that the finalization step needs. (The least
+ /// significant 56 bits hold the trailing bytes, while the most significant 8
+ /// bits hold the count of bytes appended so far, mod 256.)
@_versioned
- internal var hashedByteCount: UInt64 = 0
+ internal var tailAndByteCount: UInt64 = 0
- @_versioned
- internal var dataTail: UInt64 = 0
-
- @_versioned
- internal var dataTailByteCount: Int = 0
-
- @_versioned
- internal var finalizedHash: UInt64?
-
- @_inlineable // FIXME(sil-serialize-all)
+ @inline(__always)
public init(key: (UInt64, UInt64)) {
v3 ^= key.1
v2 ^= key.0
@@ -140,113 +92,102 @@
v0 ^= key.0
}
- // FIXME(ABI)#62 (UnsafeRawBufferPointer): Use UnsafeRawBufferPointer.
- @_inlineable // FIXME(sil-serialize-all)
- public // @testable
- mutating func append(_ data: UnsafeRawPointer, byteCount: Int) {
- _append_alwaysInline(data, byteCount: byteCount)
- }
-
- // FIXME(ABI)#63 (UnsafeRawBufferPointer): Use UnsafeRawBufferPointer.
- @_inlineable // FIXME(sil-serialize-all)
@_versioned
- @inline(__always)
- internal mutating func _append_alwaysInline(
- _ data: UnsafeRawPointer,
- byteCount: Int
- ) {
- precondition(finalizedHash == nil)
- _sanityCheck((0..<8).contains(dataTailByteCount))
-
- let dataEnd = data + byteCount
-
- var data = data
- var byteCount = byteCount
- if dataTailByteCount != 0 {
- let restByteCount = min(
- MemoryLayout<UInt64>.size - dataTailByteCount,
- byteCount)
- let rest = _SipHashDetail._loadPartialUnalignedUInt64LE(
- from: data,
- byteCount: restByteCount)
- dataTail |= rest &<< UInt64(dataTailByteCount * 8)
- dataTailByteCount += restByteCount
- data += restByteCount
- byteCount -= restByteCount
- }
-
- if dataTailByteCount == MemoryLayout<UInt64>.size {
- _appendDirectly(dataTail)
- dataTail = 0
- dataTailByteCount = 0
- } else if dataTailByteCount != 0 {
- _sanityCheck(data == dataEnd)
- return
- }
-
- let endOfWords =
- data + byteCount - (byteCount % MemoryLayout<UInt64>.size)
- while data != endOfWords {
- _appendDirectly(_SipHashDetail._loadUnalignedUInt64LE(from: data))
- data += 8
- // No need to update `byteCount`, it is not used beyond this point.
- }
-
- if data != dataEnd {
- dataTailByteCount = dataEnd - data
- dataTail = _SipHashDetail._loadPartialUnalignedUInt64LE(
- from: data,
- byteCount: dataTailByteCount)
+ internal var byteCount: UInt64 {
+ @inline(__always)
+ get {
+ return tailAndByteCount &>> 56
}
}
- /// This function mixes in the given word directly into the state,
- /// ignoring `dataTail`.
- @_inlineable // FIXME(sil-serialize-all)
@_versioned
+ internal var tail: UInt64 {
+ @inline(__always)
+ get {
+ return tailAndByteCount & ~(0xFF &<< 56)
+ }
+ }
+
@inline(__always)
- internal mutating func _appendDirectly(_ m: UInt64) {
+ @_versioned
+ internal mutating func _compress(_ m: UInt64) {
v3 ^= m
for _ in 0..<${c_rounds} {
_SipHashDetail._sipRound(v0: &v0, v1: &v1, v2: &v2, v3: &v3)
}
v0 ^= m
- hashedByteCount += 8
}
-% for data_type in ['UInt', 'Int', 'UInt64', 'Int64', 'UInt32', 'Int32']:
- @_inlineable // FIXME(sil-serialize-all)
- public // @testable
- mutating func append(_ data: ${data_type}) {
- var data = data
- _append_alwaysInline(&data, byteCount: MemoryLayout.size(ofValue: data))
- }
-% end
-
- @_inlineable // FIXME(sil-serialize-all)
- public // @testable
- mutating func finalizeAndReturnHash() -> UInt64 {
- return _finalizeAndReturnHash_alwaysInline()
- }
-
- @_inlineable // FIXME(sil-serialize-all)
- @_versioned
@inline(__always)
- internal mutating func _finalizeAndReturnHash_alwaysInline() -> UInt64 {
- if let finalizedHash = finalizedHash {
- return finalizedHash
+ public mutating func append(_ value: Int) {
+ append(UInt(bitPattern: value))
+ }
+
+ @inline(__always)
+ public mutating func append(_ value: UInt) {
+ % if word_bits == 64:
+ append(UInt64(_truncatingBits: value._lowWord))
+ % elif word_bits == 32:
+ append(UInt32(_truncatingBits: value._lowWord))
+ % else:
+ fatalError("Unsupported word width")
+ % end
+ }
+
+ @inline(__always)
+ public mutating func append(_ value: Int32) {
+ append(UInt32(bitPattern: value))
+ }
+
+ @inline(__always)
+ public mutating func append(_ value: UInt32) {
+ let m = UInt64(_truncatingBits: value._lowWord)
+ if byteCount & 4 == 0 {
+ _sanityCheck(byteCount & 7 == 0 && tail == 0)
+ tailAndByteCount = (tailAndByteCount | m) &+ (4 &<< 56)
+ } else {
+ _sanityCheck(byteCount & 3 == 0)
+ _compress((m &<< 32) | tail)
+ tailAndByteCount = (byteCount &+ 4) &<< 56
}
+ }
- _sanityCheck((0..<8).contains(dataTailByteCount))
+ @inline(__always)
+ public mutating func append(_ value: Int64) {
+ append(UInt64(bitPattern: value))
+ }
- hashedByteCount += UInt64(dataTailByteCount)
- let b: UInt64 = (hashedByteCount << 56) | dataTail
-
- v3 ^= b
- for _ in 0..<${c_rounds} {
- _SipHashDetail._sipRound(v0: &v0, v1: &v1, v2: &v2, v3: &v3)
+ @inline(__always)
+ public mutating func append(_ m: UInt64) {
+ if byteCount & 4 == 0 {
+ _sanityCheck(byteCount & 7 == 0 && tail == 0)
+ _compress(m)
+ tailAndByteCount = tailAndByteCount &+ (8 &<< 56)
+ } else {
+ _sanityCheck(byteCount & 3 == 0)
+ _compress((m &<< 32) | tail)
+ tailAndByteCount = ((byteCount &+ 8) &<< 56) | (m &>> 32)
}
- v0 ^= b
+ }
+
+ @inline(__always)
+ public mutating func finalize(
+ tailBytes: UInt64,
+ tailByteCount: Int
+ ) -> UInt64 {
+ _sanityCheck(tailByteCount >= 0)
+ _sanityCheck(tailByteCount < 8 - (byteCount & 7))
+ _sanityCheck(tailBytes >> (tailByteCount << 3) == 0)
+ let count = UInt64(_truncatingBits: tailByteCount._lowWord)
+ let currentByteCount = byteCount & 7
+ tailAndByteCount |= (tailBytes &<< (currentByteCount &<< 3))
+ tailAndByteCount = tailAndByteCount &+ (count &<< 56)
+ return finalize()
+ }
+
+ @inline(__always)
+ public mutating func finalize() -> UInt64 {
+ _compress(tailAndByteCount)
v2 ^= 0xff
@@ -254,47 +195,7 @@
_SipHashDetail._sipRound(v0: &v0, v1: &v1, v2: &v2, v3: &v3)
}
- finalizedHash = v0 ^ v1 ^ v2 ^ v3
- return finalizedHash!
- }
-
- @_inlineable // FIXME(sil-serialize-all)
- @_versioned // FIXME(sil-serialize-all)
- internal mutating func _finalizeAndReturnIntHash() -> Int {
- let hash: UInt64 = finalizeAndReturnHash()
-#if arch(i386) || arch(arm)
- return Int(truncatingIfNeeded: hash)
-#elseif arch(x86_64) || arch(arm64) || arch(powerpc64) || arch(powerpc64le) || arch(s390x)
- return Int(Int64(bitPattern: hash))
-#endif
- }
-
- // FIXME(ABI)#64 (UnsafeRawBufferPointer): Use UnsafeRawBufferPointer.
- @_inlineable // FIXME(sil-serialize-all)
- public // @testable
- static func hash(
- data: UnsafeRawPointer,
- dataByteCount: Int,
- key: (UInt64, UInt64)
- ) -> UInt64 {
- return ${Self}._hash_alwaysInline(
- data: data,
- dataByteCount: dataByteCount,
- key: key)
- }
-
- // FIXME(ABI)#65 (UnsafeRawBufferPointer): Use UnsafeRawBufferPointer.
- @_inlineable // FIXME(sil-serialize-all)
- @inline(__always)
- public // @testable
- static func _hash_alwaysInline(
- data: UnsafeRawPointer,
- dataByteCount: Int,
- key: (UInt64, UInt64)
- ) -> UInt64 {
- var context = ${Self}(key: key)
- context._append_alwaysInline(data, byteCount: dataByteCount)
- return context._finalizeAndReturnHash_alwaysInline()
+ return (v0 ^ v1 ^ v2 ^ v3)
}
}
% end
diff --git a/stdlib/public/core/StringHashable.swift b/stdlib/public/core/StringHashable.swift
index 7607c9b..c87ff59 100644
--- a/stdlib/public/core/StringHashable.swift
+++ b/stdlib/public/core/StringHashable.swift
@@ -37,34 +37,33 @@
// @_inlineable // FIXME(sil-serialize-all)
// @_versioned // FIXME(sil-serialize-all)
internal static func hashASCII(
- _ string: UnsafeBufferPointer<UInt8>
- ) -> Int {
+ _ string: UnsafeBufferPointer<UInt8>,
+ into hasher: inout _Hasher
+ ) {
let collationTable = _swift_stdlib_unicode_getASCIICollationTable()
- var hasher = _SipHash13Context(key: _Hashing.secretKey)
for c in string {
_precondition(c <= 127)
let element = collationTable[Int(c)]
// Ignore zero valued collation elements. They don't participate in the
// ordering relation.
if element != 0 {
- hasher.append(element)
+ hasher.append(Int(truncatingIfNeeded: element))
}
}
- return hasher._finalizeAndReturnIntHash()
}
// FIXME: cannot be marked @_versioned. See <rdar://problem/34438258>
// @_inlineable // FIXME(sil-serialize-all)
// @_versioned // FIXME(sil-serialize-all)
internal static func hashUTF16(
- _ string: UnsafeBufferPointer<UInt16>
- ) -> Int {
+ _ string: UnsafeBufferPointer<UInt16>,
+ into hasher: inout _Hasher
+ ) {
let collationIterator = _swift_stdlib_unicodeCollationIterator_create(
string.baseAddress!,
UInt32(string.count))
defer { _swift_stdlib_unicodeCollationIterator_delete(collationIterator) }
- var hasher = _SipHash13Context(key: _Hashing.secretKey)
while true {
var hitEnd = false
let element =
@@ -75,10 +74,9 @@
// Ignore zero valued collation elements. They don't participate in the
// ordering relation.
if element != 0 {
- hasher.append(element)
+ hasher.append(Int(truncatingIfNeeded: element))
}
}
- return hasher._finalizeAndReturnIntHash()
}
}
@@ -100,7 +98,9 @@
// Swift.String.hashValue and NSString.hash being the same.
return stringHashOffset ^ hash
#else
- return Unicode.hashASCII(self.buffer)
+ var hasher = _Hasher()
+ Unicode.hashASCII(self.buffer, into: &hasher)
+ return Int(truncatingIfNeeded: hasher.finalize())
#endif // _runtime(_ObjC)
}
}
@@ -118,7 +118,9 @@
// Swift.String.hashValue and NSString.hash being the same.
return stringHashOffset ^ hash
#else
- return Unicode.hashUTF16(self.buffer)
+ var hasher = _Hasher()
+ Unicode.hashUTF16(self.buffer, into: &hasher)
+ return Int(truncatingIfNeeded: hasher.finalize())
#endif // _runtime(_ObjC)
}
}
@@ -139,7 +141,11 @@
defer { p.deallocate(capacity: count) }
let buffer = UnsafeMutableBufferPointer(start: p, count: count)
_copy(into: buffer)
- return Unicode.hashUTF16(UnsafeBufferPointer(buffer))
+ var hasher = _Hasher()
+ Unicode.hashUTF16(
+ UnsafeBufferPointer(start: p, count: count),
+ into: &hasher)
+ return Int(truncatingIfNeeded: hasher.finalize())
#endif
}
}
@@ -195,6 +201,11 @@
let gutsBits = _guts.rawBits
return _StringGuts._computeHashValue(_unsafeBitPattern: gutsBits)
}
+
+ @_inlineable
+ public func _hash(into hasher: inout _Hasher) {
+ hasher.append(self.hashValue)
+ }
}
extension StringProtocol {
@@ -202,4 +213,9 @@
public var hashValue : Int {
return _wholeString._guts._computeHashValue(_encodedOffsetRange)
}
+
+ @_inlineable
+ public func _hash(into hasher: inout _Hasher) {
+ hasher.append(self.hashValue)
+ }
}
diff --git a/stdlib/public/core/UnsafePointer.swift.gyb b/stdlib/public/core/UnsafePointer.swift.gyb
index 288b484..4e314bd 100644
--- a/stdlib/public/core/UnsafePointer.swift.gyb
+++ b/stdlib/public/core/UnsafePointer.swift.gyb
@@ -904,10 +904,15 @@
/// program runs.
@_inlineable
public var hashValue: Int {
- return Int(bitPattern: self)
+ return _hashValue(for: self)
+ }
+
+ @_inlineable // FIXME(sil-serialize-all)
+ public func _hash(into hasher: inout _Hasher) {
+ hasher.append(Int(bitPattern: self))
}
}
-
+
extension ${Self}: Strideable {
/// Returns a pointer to the next consecutive instance.
///
diff --git a/stdlib/public/runtime/Casting.cpp b/stdlib/public/runtime/Casting.cpp
index 5a70cf3..d1c2c77 100644
--- a/stdlib/public/runtime/Casting.cpp
+++ b/stdlib/public/runtime/Casting.cpp
@@ -2823,8 +2823,7 @@
return _fail(src, srcType, targetType, flags);
}
- // Unless we're always supposed to consume the input, retain the
- // object because the witness takes it at +1.
+ // TODO: Avoid the retain here in +0 mode if the input is never consumed.
bool alwaysConsumeSrc = (flags & DynamicCastFlags::TakeOnSuccess) &&
(flags & DynamicCastFlags::DestroyOnFailure);
if (!alwaysConsumeSrc) {
@@ -2880,6 +2879,7 @@
(HeapObject *)srcObject, (OpaqueValue *)optDestBuffer,
targetType, targetType, targetBridgeWitness);
}
+ SWIFT_CC_PLUSZERO_GUARD(swift_unknownRelease(srcObject));
// If we succeeded, take from the optional buffer into the
// destination buffer.
@@ -2887,8 +2887,6 @@
targetType->vw_initializeWithTake(dest, (OpaqueValue *)optDestBuffer);
}
- // Unless we're always supposed to consume the input, release the
- // input if we need to now.
if (!alwaysConsumeSrc && shouldDeallocateSource(success, flags)) {
swift_unknownRelease(srcObject);
}
diff --git a/stdlib/public/runtime/ErrorObject.mm b/stdlib/public/runtime/ErrorObject.mm
index d5303b3..fadba49 100644
--- a/stdlib/public/runtime/ErrorObject.mm
+++ b/stdlib/public/runtime/ErrorObject.mm
@@ -409,8 +409,10 @@
// initialization of the object happens-before the domain initialization so
// that the domain can be used alone as a flag for the initialization of the
// object.
- if (errorObject->domain.load(std::memory_order_acquire))
+ if (errorObject->domain.load(std::memory_order_acquire)) {
+ SWIFT_CC_PLUSZERO_GUARD([ns retain]);
return ns;
+ }
// Otherwise, calculate the domain, code, and user info, and
// initialize the NSError.
@@ -451,6 +453,7 @@
std::memory_order_acq_rel))
objc_release(domain);
+ SWIFT_CC_PLUSZERO_GUARD([ns retain]);
return ns;
}
diff --git a/stdlib/public/runtime/Errors.cpp b/stdlib/public/runtime/Errors.cpp
index a603936..d91e8cd 100644
--- a/stdlib/public/runtime/Errors.cpp
+++ b/stdlib/public/runtime/Errors.cpp
@@ -292,6 +292,12 @@
_swift_runtime_on_report(flags, message, details);
}
+bool swift::_swift_reportFatalErrorsToDebugger = true;
+
+bool swift::_swift_shouldReportFatalErrorsToDebugger() {
+ return _swift_reportFatalErrorsToDebugger;
+}
+
/// Report a fatal error to system console, stderr, and crash logs.
/// Does not crash by itself.
void swift::swift_reportError(uint32_t flags,
diff --git a/stdlib/public/runtime/ReflectionMirror.mm b/stdlib/public/runtime/ReflectionMirror.mm
index 7280fdf..637a217 100644
--- a/stdlib/public/runtime/ReflectionMirror.mm
+++ b/stdlib/public/runtime/ReflectionMirror.mm
@@ -635,19 +635,20 @@
/// TODO: Implement specialized mirror witnesses for all kinds.
case MetadataKind::Function:
- case MetadataKind::Existential: {
- OpaqueImpl impl;
- return call(&impl);
- }
+ case MetadataKind::Existential:
+ break;
// Types can't have these kinds.
case MetadataKind::HeapLocalVariable:
case MetadataKind::HeapGenericLocalVariable:
case MetadataKind::ErrorObject:
swift::crash("Swift mirror lookup failure");
- }
+ }
- swift_runtime_unreachable("Unhandled MetadataKind in switch.");
+ // If we have an unknown kind of type, or a type without special handling,
+ // treat it as opaque.
+ OpaqueImpl impl;
+ return call(&impl);
}
} // end anonymous namespace
@@ -738,7 +739,7 @@
return "(ErrorType Object)";
}
- swift_runtime_unreachable("Unhandled MetadataKind in switch.");
+ return "(Unknown)";
}
#if SWIFT_OBJC_INTEROP
diff --git a/stdlib/public/runtime/SwiftObject.mm b/stdlib/public/runtime/SwiftObject.mm
index 03e4816..02da955 100644
--- a/stdlib/public/runtime/SwiftObject.mm
+++ b/stdlib/public/runtime/SwiftObject.mm
@@ -1398,7 +1398,7 @@
"withoutActuallyEscaping block";
auto messageLength = strlen(message);
- if (_swift_reportFatalErrorsToDebugger)
+ if (_swift_shouldReportFatalErrorsToDebugger())
_swift_reportToDebugger(RuntimeErrorFlagFatal, message);
char *log;
diff --git a/stdlib/public/stubs/Assert.cpp b/stdlib/public/stubs/Assert.cpp
index a4b29ab..ceb369e 100644
--- a/stdlib/public/stubs/Assert.cpp
+++ b/stdlib/public/stubs/Assert.cpp
@@ -21,13 +21,11 @@
using namespace swift;
-bool swift::_swift_reportFatalErrorsToDebugger = true;
-
static void logPrefixAndMessageToDebugger(
const unsigned char *prefix, int prefixLength,
const unsigned char *message, int messageLength
) {
- if (!_swift_reportFatalErrorsToDebugger)
+ if (!_swift_shouldReportFatalErrorsToDebugger())
return;
char *debuggerMessage;
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 64800a1..bc3ec41 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -158,7 +158,7 @@
foreach(ARCH ${SWIFT_SDK_${SDK}_ARCHITECTURES})
# Configure variables for this subdirectory.
set(VARIANT_SUFFIX "-${SWIFT_SDK_${SDK}_LIB_SUBDIR}-${ARCH}")
- set(VARIANT_TRIPLE "${SWIFT_SDK_${SDK}_ARCH_${ARCH}_TRIPLE}")
+ set(VARIANT_TRIPLE "${SWIFT_SDK_${SDK}_ARCH_${ARCH}_TRIPLE}${SWIFT_SDK_${SDK}_DEPLOYMENT_VERSION}")
set(VARIANT_SDK "${SWIFT_SDK_${SDK}_PATH}")
# A directory where to put the xUnit-style XML test results.
diff --git a/test/ClangImporter/availability_returns_twice.swift b/test/ClangImporter/availability_returns_twice.swift
index f0cee90..537c184 100644
--- a/test/ClangImporter/availability_returns_twice.swift
+++ b/test/ClangImporter/availability_returns_twice.swift
@@ -1,6 +1,6 @@
// RUN: %target-swift-frontend -typecheck -verify %s
-#if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
import Darwin
typealias JumpBuffer = Int32
#else
diff --git a/test/ClangImporter/clang_builtins.swift b/test/ClangImporter/clang_builtins.swift
index 73ef91e..b9a72eb 100644
--- a/test/ClangImporter/clang_builtins.swift
+++ b/test/ClangImporter/clang_builtins.swift
@@ -3,7 +3,7 @@
// RUN: not %target-swift-frontend -swift-version 4 -typecheck %s 2> %t.4.txt
// RUN: %FileCheck -check-prefix=CHECK-4 -check-prefix=CHECK-%target-runtime-4 %s < %t.4.txt
-#if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
import Darwin
#else
import Glibc
@@ -27,7 +27,7 @@
// CHECK-4: [[@LINE-2]]:16: error: cannot convert value of type '({{.+}}) -> Int'{{( [(]aka .+[)])?}} to specified type 'Int'
}
-#if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
// These functions aren't consistently available across platforms, so only
// test for them on Apple platforms.
func testApple() {
diff --git a/test/ClangImporter/objc_ir.swift b/test/ClangImporter/objc_ir.swift
index d95743d..7f9b8c2 100644
--- a/test/ClangImporter/objc_ir.swift
+++ b/test/ClangImporter/objc_ir.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %build-clang-importer-objc-overlays
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -I %S/Inputs/custom-modules -emit-ir -g -o - -primary-file %s | %FileCheck %s
diff --git a/test/ClangImporter/optional.swift b/test/ClangImporter/optional.swift
index 9feb50b..c510215 100644
--- a/test/ClangImporter/optional.swift
+++ b/test/ClangImporter/optional.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -I %S/Inputs/custom-modules -emit-silgen -o - %s | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/ClangImporter/plus_zero_objc_ir.swift b/test/ClangImporter/plus_zero_objc_ir.swift
new file mode 100644
index 0000000..4ea8181
--- /dev/null
+++ b/test/ClangImporter/plus_zero_objc_ir.swift
@@ -0,0 +1,349 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %build-clang-importer-objc-overlays
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -I %S/Inputs/custom-modules -emit-ir -g -o - -primary-file %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+// REQUIRES: OS=macosx
+
+// CHECK: %TSo1BC = type
+
+import ObjectiveC
+import Foundation
+import objc_ext
+import TestProtocols
+import ObjCIRExtras
+
+// CHECK: @"\01L_selector_data(method:withFloat:)" = private global [18 x i8] c"method:withFloat:\00"
+// CHECK: @"\01L_selector_data(method:withDouble:)" = private global [19 x i8] c"method:withDouble:\00"
+// CHECK: @"\01L_selector_data(method:separateExtMethod:)" = private global [26 x i8] c"method:separateExtMethod:\00", section "__TEXT,__objc_methname,cstring_literals"
+
+// Instance method invocation
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir15instanceMethodsyySo1BCF"(%TSo1BC*
+func instanceMethods(_ b: B) {
+ // CHECK: load i8*, i8** @"\01L_selector(method:withFloat:)"
+ // CHECK: call i32 bitcast (void ()* @objc_msgSend to i32
+ var i = b.method(1, with: 2.5 as Float)
+ // CHECK: load i8*, i8** @"\01L_selector(method:withDouble:)"
+ // CHECK: call i32 bitcast (void ()* @objc_msgSend to i32
+ i = i + b.method(1, with: 2.5 as Double)
+}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir16extensionMethods1bySo1BC_tF"
+func extensionMethods(b b: B) {
+ // CHECK: load i8*, i8** @"\01L_selector(method:separateExtMethod:)", align 8
+ // CHECK: [[T0:%.*]] = call i8* bitcast (void ()* @objc_msgSend to i8*
+ // CHECK-NEXT: [[T1:%.*]] = {{.*}}call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
+ // CHECK-NOT: [[T0]]
+ // CHECK: [[T1]]
+ b.method(1, separateExtMethod:1.5)
+}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir19initCallToAllocInit1iys5Int32V_tF"
+func initCallToAllocInit(i i: CInt) {
+ // CHECK: call {{.*}} @"$SSo1BC3intABSgs5Int32V_tcfC"
+
+ B(int: i)
+}
+
+// CHECK-LABEL: linkonce_odr hidden {{.*}} @"$SSo1BC3intABSgs5Int32V_tcfC"
+// CHECK: call [[OPAQUE:%.*]]* @objc_allocWithZone
+
+// Indexed subscripting
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir19indexedSubscripting1b3idx1aySo1BC_SiSo1ACtF"
+func indexedSubscripting(b b: B, idx: Int, a: A) {
+ // CHECK: load i8*, i8** @"\01L_selector(setObject:atIndexedSubscript:)", align 8
+ b[idx] = a
+
+ // CHECK: load i8*, i8** @"\01L_selector(objectAtIndexedSubscript:)"
+ var a2 = b[idx] as! A
+}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir17keyedSubscripting1b3idx1aySo1BC_So1ACAItF"
+func keyedSubscripting(b b: B, idx: A, a: A) {
+ // CHECK: load i8*, i8** @"\01L_selector(setObject:forKeyedSubscript:)"
+ b[a] = a
+ // CHECK: load i8*, i8** @"\01L_selector(objectForKeyedSubscript:)"
+ var a2 = b[a] as! A
+}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir14propertyAccess1bySo1BC_tF"
+func propertyAccess(b b: B) {
+ // CHECK: load i8*, i8** @"\01L_selector(counter)"
+ // CHECK: load i8*, i8** @"\01L_selector(setCounter:)"
+ b.counter = b.counter + 1
+
+ // CHECK: load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_B"
+ // CHECK: load i8*, i8** @"\01L_selector(sharedCounter)"
+ // CHECK: load i8*, i8** @"\01L_selector(setSharedCounter:)"
+ B.sharedCounter = B.sharedCounter + 1
+}
+
+// CHECK-LABEL: define hidden swiftcc %TSo1BC* @"$S7objc_ir8downcast1aSo1BCSo1AC_tF"(
+func downcast(a a: A) -> B {
+ // CHECK: [[CLASS:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_B"
+ // CHECK: [[T0:%.*]] = call %objc_class* @swift_getInitializedObjCClass(%objc_class* [[CLASS]])
+ // CHECK: [[T1:%.*]] = bitcast %objc_class* [[T0]] to i8*
+ // CHECK: call i8* @swift_dynamicCastObjCClassUnconditional(i8* [[A:%.*]], i8* [[T1]]) [[NOUNWIND:#[0-9]+]]
+ return a as! B
+}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir19almostSubscriptable3as11aySo06AlmostD0C_So1ACtF"
+func almostSubscriptable(as1 as1: AlmostSubscriptable, a: A) {
+ as1.objectForKeyedSubscript(a)
+}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir13protocolTypes1a1bySo7NSMinceC_So9NSRuncing_ptF"(%TSo7NSMinceC*, %objc_object*) {{.*}} {
+func protocolTypes(a a: NSMince, b: NSRuncing) {
+ // - (void)eatWith:(id <NSRuncing>)runcer;
+ a.eat(with: b)
+ // CHECK: [[SEL:%.*]] = load i8*, i8** @"\01L_selector(eatWith:)", align 8
+ // CHECK: call void bitcast (void ()* @objc_msgSend to void ([[OPAQUE:%.*]]*, i8*, i8*)*)([[OPAQUE:%.*]]* {{%.*}}, i8* [[SEL]], i8* {{%.*}})
+}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir6getset1pySo8FooProto_p_tF"(%objc_object*) {{.*}} {
+func getset(p p: FooProto) {
+ // CHECK: load i8*, i8** @"\01L_selector(bar)"
+ // CHECK: load i8*, i8** @"\01L_selector(setBar:)"
+ let prop = p.bar
+ p.bar = prop
+}
+
+// CHECK-LABEL: define hidden swiftcc %swift.type* @"$S7objc_ir16protocolMetatype1pSo8FooProto_pXpSoAD_p_tF"(%objc_object*) {{.*}} {
+func protocolMetatype(p: FooProto) -> FooProto.Type {
+ // CHECK: = call %swift.type* @swift_getObjectType(%objc_object* %0)
+ // CHECK-NOT: {{retain|release}}
+ // CHECK: [[RAW_RESULT:%.+]] = call i8* @processFooType(i8* {{%.+}})
+ // CHECK: [[CASTED_RESULT:%.+]] = bitcast i8* [[RAW_RESULT]] to %objc_class*
+ // CHECK: [[SWIFT_RESULT:%.+]] = call %swift.type* @swift_getObjCClassMetadata(%objc_class* [[CASTED_RESULT]])
+ // CHECK-NOT: call void @swift_unknownRelease(%objc_object* %0)
+ // CHECK: ret %swift.type* [[SWIFT_RESULT]]
+ let type = processFooType(type(of: p))
+ return type
+} // CHECK: }
+
+class Impl: FooProto, AnotherProto {
+ @objc var bar: Int32 = 0
+}
+
+// CHECK-LABEL: define hidden swiftcc %swift.type* @"$S7objc_ir27protocolCompositionMetatype1pSo12AnotherProto_So03FooG0pXpAA4ImplC_tF"(%T7objc_ir4ImplC*) {{.*}} {
+func protocolCompositionMetatype(p: Impl) -> (FooProto & AnotherProto).Type {
+ // CHECK: = getelementptr inbounds %T7objc_ir4ImplC, %T7objc_ir4ImplC* %0, i32 0, i32 0, i32 0
+ // CHECK-NOT: {{retain|release}}
+ // CHECK: [[RAW_RESULT:%.+]] = call i8* @processComboType(i8* {{%.+}})
+ // CHECK: [[CASTED_RESULT:%.+]] = bitcast i8* [[RAW_RESULT]] to %objc_class*
+ // CHECK: [[SWIFT_RESULT:%.+]] = call %swift.type* @swift_getObjCClassMetadata(%objc_class* [[CASTED_RESULT]])
+ // CHECK-NOT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T7objc_ir4ImplC*)*)(%T7objc_ir4ImplC* %0)
+ // CHECK: ret %swift.type* [[SWIFT_RESULT]]
+ let type = processComboType(type(of: p))
+ return type
+} // CHECK: }
+
+// CHECK-LABEL: define hidden swiftcc %swift.type* @"$S7objc_ir28protocolCompositionMetatype21pSo12AnotherProto_So03FooG0pXpAA4ImplC_tF"(%T7objc_ir4ImplC*) {{.*}} {
+func protocolCompositionMetatype2(p: Impl) -> (FooProto & AnotherProto).Type {
+ // CHECK: = getelementptr inbounds %T7objc_ir4ImplC, %T7objc_ir4ImplC* %0, i32 0, i32 0, i32 0
+ // CHECK-NOT: {{retain|release}}
+ // CHECK: [[RAW_RESULT:%.+]] = call i8* @processComboType2(i8* {{%.+}})
+ // CHECK: [[CASTED_RESULT:%.+]] = bitcast i8* [[RAW_RESULT]] to %objc_class*
+ // CHECK: [[SWIFT_RESULT:%.+]] = call %swift.type* @swift_getObjCClassMetadata(%objc_class* [[CASTED_RESULT]])
+ // CHECK-NOT: @swift_release
+ // CHECK: ret %swift.type* [[SWIFT_RESULT]]
+ let type = processComboType2(type(of: p))
+ return type
+} // CHECK: }
+
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir17pointerPropertiesyySo14PointerWrapperCF"(%TSo14PointerWrapperC*) {{.*}} {
+func pointerProperties(_ obj: PointerWrapper) {
+ // CHECK: load i8*, i8** @"\01L_selector(setVoidPtr:)"
+ // CHECK: load i8*, i8** @"\01L_selector(setIntPtr:)"
+ // CHECK: load i8*, i8** @"\01L_selector(setIdPtr:)"
+ obj.voidPtr = nil as UnsafeMutableRawPointer?
+ obj.intPtr = nil as UnsafeMutablePointer?
+ obj.idPtr = nil as AutoreleasingUnsafeMutablePointer?
+}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir16strangeSelectorsyySo13SwiftNameTestCF"(%TSo13SwiftNameTestC*) {{.*}} {
+func strangeSelectors(_ obj: SwiftNameTest) {
+ // CHECK: load i8*, i8** @"\01L_selector(:b:)"
+ obj.empty(a: 0, b: 0)
+}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir20customFactoryMethodsyyF"() {{.*}} {
+func customFactoryMethods() {
+ // CHECK: call swiftcc %TSo13SwiftNameTestC* @"$SSo13SwiftNameTestC10dummyParamAByt_tcfCTO"
+ // CHECK: call swiftcc %TSo13SwiftNameTestC* @"$SSo13SwiftNameTestC2ccABypSg_tcfCTO"
+ // CHECK: call swiftcc %TSo13SwiftNameTestC* @"$SSo13SwiftNameTestC5emptyABs5Int32V_tcfCTO"
+ _ = SwiftNameTest(dummyParam: ())
+ _ = SwiftNameTest(cc: nil)
+ _ = SwiftNameTest(empty: 0)
+
+ // CHECK: load i8*, i8** @"\01L_selector(testZ)"
+ // CHECK: load i8*, i8** @"\01L_selector(testY:)"
+ // CHECK: load i8*, i8** @"\01L_selector(testX:xx:)"
+ // CHECK: load i8*, i8** @"\01L_selector(::)"
+ _ = SwiftNameTest.zz()
+ _ = SwiftNameTest.yy(aa: nil)
+ _ = SwiftNameTest.xx(nil, bb: nil)
+ _ = SwiftNameTest.empty(1, 2)
+
+ do {
+ // CHECK: call swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC5errorAByt_tKcfCTO"
+ // CHECK: call swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC2aa5errorABypSg_yttKcfCTO"
+ // CHECK: call swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC2aa5error5blockABypSg_ytyyctKcfCTO"
+ // CHECK: call swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC5error5blockAByt_yyctKcfCTO"
+ // CHECK: call swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC2aaABypSg_tKcfCTO"
+ // CHECK: call swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC2aa5blockABypSg_yyctKcfCTO"
+ // CHECK: call swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC5blockAByyc_tKcfCTO"
+ _ = try SwiftNameTestError(error: ())
+ _ = try SwiftNameTestError(aa: nil, error: ())
+ _ = try SwiftNameTestError(aa: nil, error: (), block: {})
+ _ = try SwiftNameTestError(error: (), block: {})
+
+ _ = try SwiftNameTestError(aa: nil)
+ _ = try SwiftNameTestError(aa: nil, block: {})
+ _ = try SwiftNameTestError(block: {})
+
+ // CHECK: load i8*, i8** @"\01L_selector(testW:error:)"
+ // CHECK: load i8*, i8** @"\01L_selector(testW2:error:)"
+ // CHECK: load i8*, i8** @"\01L_selector(testV:)"
+ // CHECK: load i8*, i8** @"\01L_selector(testV2:)"
+ _ = try SwiftNameTestError.ww(nil)
+ _ = try SwiftNameTestError.w2(nil, error: ())
+ _ = try SwiftNameTestError.vv()
+ _ = try SwiftNameTestError.v2(error: ())
+ } catch _ {
+ }
+}
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo13SwiftNameTestC* @"$SSo13SwiftNameTestC10dummyParamAByt_tcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(b)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo13SwiftNameTestC* @"$SSo13SwiftNameTestC2ccABypSg_tcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(c:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC5errorAByt_tKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err1:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC2aa5errorABypSg_yttKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err2:error:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC2aa5error5blockABypSg_ytyyctKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err3:error:callback:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC5error5blockAByt_yyctKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err4:callback:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC2aaABypSg_tKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err5:error:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC2aa5blockABypSg_yyctKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err6:error:callback:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo18SwiftNameTestErrorC* @"$SSo18SwiftNameTestErrorC5blockAByyc_tKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err7:callback:)"
+// CHECK: }
+
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir29customFactoryMethodsInheritedyyF"() {{.*}} {
+func customFactoryMethodsInherited() {
+ // CHECK: call swiftcc %TSo16SwiftNameTestSubC* @"$SSo16SwiftNameTestSubC10dummyParamAByt_tcfCTO"
+ // CHECK: call swiftcc %TSo16SwiftNameTestSubC* @"$SSo16SwiftNameTestSubC2ccABypSg_tcfCTO"
+ _ = SwiftNameTestSub(dummyParam: ())
+ _ = SwiftNameTestSub(cc: nil)
+
+ // CHECK: load i8*, i8** @"\01L_selector(testZ)"
+ // CHECK: load i8*, i8** @"\01L_selector(testY:)"
+ // CHECK: load i8*, i8** @"\01L_selector(testX:xx:)"
+ _ = SwiftNameTestSub.zz()
+ _ = SwiftNameTestSub.yy(aa: nil)
+ _ = SwiftNameTestSub.xx(nil, bb: nil)
+
+ do {
+ // CHECK: call swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC5errorAByt_tKcfCTO"
+ // CHECK: call swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC2aa5errorABypSg_yttKcfCTO"
+ // CHECK: call swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC2aa5error5blockABypSg_ytyyctKcfCTO"
+ // CHECK: call swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC5error5blockAByt_yyctKcfCTO"
+ // CHECK: call swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC2aaABypSg_tKcfCTO"
+ // CHECK: call swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC2aa5blockABypSg_yyctKcfCTO"
+ // CHECK: call swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC5blockAByyc_tKcfCTO"
+ _ = try SwiftNameTestErrorSub(error: ())
+ _ = try SwiftNameTestErrorSub(aa: nil, error: ())
+ _ = try SwiftNameTestErrorSub(aa: nil, error: (), block: {})
+ _ = try SwiftNameTestErrorSub(error: (), block: {})
+
+ _ = try SwiftNameTestErrorSub(aa: nil)
+ _ = try SwiftNameTestErrorSub(aa: nil, block: {})
+ _ = try SwiftNameTestErrorSub(block: {})
+
+ // CHECK: load i8*, i8** @"\01L_selector(testW:error:)"
+ // CHECK: load i8*, i8** @"\01L_selector(testW2:error:)"
+ // CHECK: load i8*, i8** @"\01L_selector(testV:)"
+ // CHECK: load i8*, i8** @"\01L_selector(testV2:)"
+ _ = try SwiftNameTestErrorSub.ww(nil)
+ _ = try SwiftNameTestErrorSub.w2(nil, error: ())
+ _ = try SwiftNameTestErrorSub.vv()
+ _ = try SwiftNameTestErrorSub.v2(error: ())
+ } catch _ {
+ }
+}
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo16SwiftNameTestSubC* @"$SSo16SwiftNameTestSubC10dummyParamAByt_tcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(b)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo16SwiftNameTestSubC* @"$SSo16SwiftNameTestSubC2ccABypSg_tcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(c:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC5errorAByt_tKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err1:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC2aa5errorABypSg_yttKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err2:error:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC2aa5error5blockABypSg_ytyyctKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err3:error:callback:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC5error5blockAByt_yyctKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err4:callback:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC2aaABypSg_tKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err5:error:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC2aa5blockABypSg_yyctKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err6:error:callback:)"
+// CHECK: }
+
+// CHECK-LABEL: define linkonce_odr hidden swiftcc %TSo21SwiftNameTestErrorSubC* @"$SSo21SwiftNameTestErrorSubC5blockAByyc_tKcfCTO"
+// CHECK: load i8*, i8** @"\01L_selector(err7:callback:)"
+// CHECK: }
+
+
+// CHECK-LABEL: define hidden swiftcc void @"$S7objc_ir30testCompatibilityAliasMangling3objySo13SwiftNameTestC_tF"
+func testCompatibilityAliasMangling(obj: SwiftNameAlias) {
+ // CHECK: call void @llvm.dbg.declare(metadata %TSo13SwiftNameTestC** {{%.+}}, metadata ![[SWIFT_NAME_ALIAS_VAR:[0-9]+]], metadata !DIExpression())
+}
+
+
+// CHECK: linkonce_odr hidden {{.*}} @"$SSo1BC3intABSgs5Int32V_tcfcTO"
+// CHECK: load i8*, i8** @"\01L_selector(initWithInt:)"
+// CHECK: call [[OPAQUE:%.*]]* bitcast (void ()* @objc_msgSend
+
+
+// CHECK: attributes [[NOUNWIND]] = { nounwind }
+
+// CHECK: ![[SWIFT_NAME_ALIAS_VAR]] = !DILocalVariable(name: "obj", arg: 1, scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: ![[SWIFT_NAME_ALIAS_TYPE:[0-9]+]])
+// CHECK: ![[SWIFT_NAME_ALIAS_TYPE]] = !DIDerivedType(tag: DW_TAG_typedef, name: "$SSo14SwiftNameAliasaD", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, baseType: !{{[0-9]+}})
+
diff --git a/test/ClangImporter/plus_zero_optional.swift b/test/ClangImporter/plus_zero_optional.swift
new file mode 100644
index 0000000..f36c2af
--- /dev/null
+++ b/test/ClangImporter/plus_zero_optional.swift
@@ -0,0 +1,83 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -I %S/Inputs/custom-modules -enable-sil-ownership -emit-silgen -o - %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import ObjectiveC
+import Foundation
+import objc_ext
+import TestProtocols
+
+class A {
+ @objc func foo() -> String? {
+ return ""
+ }
+// CHECK-LABEL: sil hidden [thunk] @$S8optional1AC3fooSSSgyFTo : $@convention(objc_method) (A) -> @autoreleased Optional<NSString>
+// CHECK: bb0([[SELF:%.*]] : @unowned $A):
+// CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+// CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+// CHECK: [[T0:%.*]] = function_ref @$S8optional1AC3fooSSSgyF
+// CHECK-NEXT: [[T1:%.*]] = apply [[T0]]([[BORROWED_SELF_COPY]])
+// CHECK-NEXT: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+// CHECK-NEXT: destroy_value [[SELF_COPY]]
+// CHECK-NEXT: switch_enum [[T1]] : $Optional<String>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+// Something branch: project value, translate, inject into result.
+// CHECK: [[SOME_BB]]([[STR:%.*]] : @owned $String):
+// CHECK: [[T0:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+// CHECK-NEXT: [[BORROWED_STR:%.*]] = begin_borrow [[STR]]
+// CHECK-NEXT: [[T1:%.*]] = apply [[T0]]([[BORROWED_STR]])
+// CHECK-NEXT: enum $Optional<NSString>, #Optional.some!enumelt.1, [[T1]]
+// CHECK-NEXT: end_borrow [[BORROWED_STR:%.*]] from [[STR]]
+// CHECK-NEXT: destroy_value [[STR]]
+// CHECK-NEXT: br
+// Nothing branch: inject nothing into result.
+//
+// CHECK: [[NONE_BB]]:
+// CHECK-NEXT: enum $Optional<NSString>, #Optional.none!enumelt
+// CHECK-NEXT: br
+// Continuation.
+// CHECK: bb3([[T0:%.*]] : @owned $Optional<NSString>):
+// CHECK-NEXT: return [[T0]]
+
+ @objc func bar(x x : String?) {}
+// CHECK-LABEL: sil hidden [thunk] @$S8optional1AC3bar1xySSSg_tFTo : $@convention(objc_method) (Optional<NSString>, A) -> ()
+// CHECK: bb0([[ARG:%.*]] : @unowned $Optional<NSString>, [[SELF:%.*]] : @unowned $A):
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+// CHECK: switch_enum [[ARG_COPY]] : $Optional<NSString>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+// Something branch: project value, translate, inject into result.
+// CHECK: [[SOME_BB]]([[NSSTR:%.*]] : @owned $NSString):
+// CHECK: [[T0:%.*]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+// Make a temporary initialized string that we're going to clobber as part of the conversion process (?).
+// CHECK-NEXT: [[NSSTR_BOX:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[NSSTR]] : $NSString
+// CHECK-NEXT: [[STRING_META:%.*]] = metatype $@thin String.Type
+// CHECK-NEXT: [[T1:%.*]] = apply [[T0]]([[NSSTR_BOX]], [[STRING_META]])
+// CHECK-NEXT: enum $Optional<String>, #Optional.some!enumelt.1, [[T1]]
+// CHECK-NEXT: destroy_value [[NSSTR_BOX]]
+// CHECK-NEXT: br
+//
+// Nothing branch: inject nothing into result.
+// CHECK: [[NONE_BB]]:
+// CHECK: enum $Optional<String>, #Optional.none!enumelt
+// CHECK-NEXT: br
+// Continuation.
+// CHECK: bb3([[T0:%.*]] : @owned $Optional<String>):
+// CHECK: [[BORROWED_T0:%.*]] = begin_borrow [[T0]]
+// CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+// CHECK: [[T1:%.*]] = function_ref @$S8optional1AC3bar1xySSSg_tF
+// CHECK-NEXT: [[T2:%.*]] = apply [[T1]]([[BORROWED_T0]], [[BORROWED_SELF_COPY]])
+// CHECK-NEXT: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+// CHECK-NEXT: end_borrow [[BORROWED_T0]] from [[T0]]
+// CHECK-NEXT: destroy_value [[T0]]
+// CHECK-NEXT: destroy_value [[SELF_COPY]]
+// CHECK-NEXT: return [[T2]] : $()
+}
+
+
+// rdar://15144951
+class TestWeak : NSObject {
+ weak var b : WeakObject? = nil
+}
+class WeakObject : NSObject {}
diff --git a/test/ClangImporter/plus_zero_serialization-sil.swift b/test/ClangImporter/plus_zero_serialization-sil.swift
new file mode 100644
index 0000000..2c063a6
--- /dev/null
+++ b/test/ClangImporter/plus_zero_serialization-sil.swift
@@ -0,0 +1,44 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module-path %t/Test.swiftmodule -emit-sil -o /dev/null -module-name Test %s -sdk "" -import-objc-header %S/Inputs/serialization-sil.h -enable-sil-ownership
+// RUN: %target-sil-func-extractor %t/Test.swiftmodule -sil-print-debuginfo -func='$S4Test16testPartialApplyyySoAA_pF' -o - | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+// @_transparent to force serialization.
+@_transparent
+public func testPartialApply(_ obj: Test) {
+ // CHECK-LABEL: @$S4Test16testPartialApplyyySoAA_pF : $@convention(thin) (@guaranteed Test) -> () {
+ if let curried1 = obj.normalObject {
+ // CHECK: dynamic_method_br [[CURRIED1_OBJ:%.+]] : $@opened([[CURRIED1_EXISTENTIAL:.+]]) Test, #Test.normalObject!1.foreign, [[CURRIED1_TRUE:[^,]+]], [[CURRIED1_FALSE:[^,]+]]
+ // CHECK: [[CURRIED1_FALSE]]:
+ // CHECK: [[CURRIED1_TRUE]]([[CURRIED1_METHOD:%.+]] : $@convention(objc_method) (@opened([[CURRIED1_EXISTENTIAL]]) Test) -> @autoreleased AnyObject):
+ // CHECK: [[CURRIED1_PARTIAL:%.+]] = partial_apply [callee_guaranteed] [[CURRIED1_METHOD]]([[CURRIED1_OBJ]]) : $@convention(objc_method) (@opened([[CURRIED1_EXISTENTIAL]]) Test) -> @autoreleased AnyObject
+ // CHECK: [[CURRIED1_THUNK:%.+]] = function_ref @$SyXlIego_ypIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> @owned AnyObject) -> @out Any
+ // CHECK: = partial_apply [callee_guaranteed] [[CURRIED1_THUNK]]([[CURRIED1_PARTIAL]])
+ curried1()
+ }
+ if let curried2 = obj.innerPointer {
+ // CHECK: dynamic_method_br [[CURRIED2_OBJ:%.+]] : $@opened([[CURRIED2_EXISTENTIAL:.+]]) Test, #Test.innerPointer!1.foreign, [[CURRIED2_TRUE:[^,]+]], [[CURRIED2_FALSE:[^,]+]]
+ // CHECK: [[CURRIED2_FALSE]]:
+ // CHECK: [[CURRIED2_TRUE]]([[CURRIED2_METHOD:%.+]] : $@convention(objc_method) (@opened([[CURRIED2_EXISTENTIAL]]) Test) -> @unowned_inner_pointer UnsafeMutableRawPointer):
+ // CHECK: [[CURRIED2_PARTIAL:%.+]] = partial_apply [callee_guaranteed] [[CURRIED2_METHOD]]([[CURRIED2_OBJ]]) : $@convention(objc_method) (@opened([[CURRIED2_EXISTENTIAL]]) Test) -> @unowned_inner_pointer UnsafeMutableRawPointer
+ curried2()
+ }
+ if let prop1 = obj.normalObjectProp {
+ // CHECK: dynamic_method_br [[PROP1_OBJ:%.+]] : $@opened([[PROP1_EXISTENTIAL:.+]]) Test, #Test.normalObjectProp!getter.1.foreign, [[PROP1_TRUE:[^,]+]], [[PROP1_FALSE:[^,]+]]
+ // CHECK: [[PROP1_FALSE]]:
+ // CHECK: [[PROP1_TRUE]]([[PROP1_METHOD:%.+]] : $@convention(objc_method) (@opened([[PROP1_EXISTENTIAL]]) Test) -> @autoreleased AnyObject):
+ // CHECK: [[PROP1_PARTIAL:%.+]] = partial_apply [callee_guaranteed] [[PROP1_METHOD]]([[PROP1_OBJ]]) : $@convention(objc_method) (@opened([[PROP1_EXISTENTIAL]]) Test) -> @autoreleased AnyObject
+ // CHECK: = apply [[PROP1_PARTIAL]]() : $@callee_guaranteed () -> @owned AnyObject
+ _ = prop1
+ }
+ if let prop2 = obj.innerPointerProp {
+ // CHECK: dynamic_method_br [[PROP2_OBJ:%.+]] : $@opened([[PROP2_EXISTENTIAL:.+]]) Test, #Test.innerPointerProp!getter.1.foreign, [[PROP2_TRUE:[^,]+]], [[PROP2_FALSE:[^,]+]]
+ // CHECK: [[PROP2_FALSE]]:
+ // CHECK: [[PROP2_TRUE]]([[PROP2_METHOD:%.+]] : $@convention(objc_method) (@opened([[PROP2_EXISTENTIAL]]) Test) -> @unowned_inner_pointer UnsafeMutableRawPointer):
+ // CHECK: [[PROP2_PARTIAL:%.+]] = partial_apply [callee_guaranteed] [[PROP2_METHOD]]([[PROP2_OBJ]]) : $@convention(objc_method) (@opened([[PROP2_EXISTENTIAL]]) Test) -> @unowned_inner_pointer UnsafeMutableRawPointer
+ // CHECK: = apply [[PROP2_PARTIAL]]() : $@callee_guaranteed () -> UnsafeMutableRawPointer
+ _ = prop2
+ }
+} // CHECK: // end sil function '$S4Test16testPartialApplyyySoAA_pF'
diff --git a/test/ClangImporter/serialization-sil.swift b/test/ClangImporter/serialization-sil.swift
index dc43fdd..eeb1d66 100644
--- a/test/ClangImporter/serialization-sil.swift
+++ b/test/ClangImporter/serialization-sil.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module-path %t/Test.swiftmodule -emit-sil -o /dev/null -module-name Test %s -sdk "" -import-objc-header %S/Inputs/serialization-sil.h
// RUN: %target-sil-func-extractor %t/Test.swiftmodule -sil-print-debuginfo -func='$S4Test16testPartialApplyyySoAA_pF' -o - | %FileCheck %s
diff --git a/test/DebugInfo/apple-names-accel.swift b/test/DebugInfo/apple-names-accel.swift
new file mode 100644
index 0000000..ff28e6e
--- /dev/null
+++ b/test/DebugInfo/apple-names-accel.swift
@@ -0,0 +1,10 @@
+// Check that the apple-names section is emitted on Darwin.
+// Adapted from llvm/test/DebugInfo/X86/debugger-tune.ll
+// RUN: %target-swiftc_driver -emit-object -g %s -o %t
+// RUN: llvm-readobj -sections %t | %FileCheck --check-prefix=CHECK-LLDB %s
+
+// CHECK-LLDB-NOT: debug_pubnames
+// CHECK-LLDB: apple_names
+// CHECK-LLDB-NOT: debug_pubnames
+
+// REQUIRES: OS=macosx
diff --git a/test/DebugInfo/apple-types-accel.swift b/test/DebugInfo/apple-types-accel.swift
index 94e1fe1..7279181 100644
--- a/test/DebugInfo/apple-types-accel.swift
+++ b/test/DebugInfo/apple-types-accel.swift
@@ -4,12 +4,12 @@
// RUN: | %FileCheck --check-prefix=CHECK-ACCEL %s
// RUN: %llvm-dwarfdump --debug-info %t.o \
// RUN: | %FileCheck --check-prefix=CHECK-DWARF %s
-// DISABLED <rdar://problem/28232630>: dwarfdump --verify %t.o
+// RUN: %llvm-dwarfdump --verify %t.o
// REQUIRES: OS=macosx
// Verify that the unmangles basenames end up in the accelerator table.
-// CHECK-ACCEL-DAG: Name: {{.*}}"Int64"
-// CHECK-ACCEL-DAG: Name: {{.*}}"foo"
+// CHECK-ACCEL-DAG: String: {{.*}}"Int64"
+// CHECK-ACCEL-DAG: String: {{.*}}"foo"
// Verify that the mangled names end up in the debug info.
// CHECK-DWARF: TAG_module
diff --git a/test/DebugInfo/closure-multivalue.swift b/test/DebugInfo/closure-multivalue.swift
index bd541ab..c724ad1 100644
--- a/test/DebugInfo/closure-multivalue.swift
+++ b/test/DebugInfo/closure-multivalue.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// rdar://problem/23727705:
// RUN-DISABLED: %target-swift-frontend -O %s -disable-llvm-optzns -emit-ir -g -o - | %FileCheck %s
import StdlibUnittest
@@ -35,8 +36,8 @@
// Verify that a reabstraction thunk does not have a line number.
// CHECK-O0-NOT: DW_OP_bit_piece
// CHECK-O0-NOT: DW_OP_bit_piece
-// CHECK-O0: !DILocalVariable(name: "a", arg: 1{{.*}} line: 17,
+// CHECK-O0: !DILocalVariable(name: "a", arg: 1{{.*}} line: 18,
// CHECK-O0-NOT: DW_OP_bit_piece
-// CHECK-O0: !DILocalVariable(name: "b", arg: 2{{.*}} line: 17,
+// CHECK-O0: !DILocalVariable(name: "b", arg: 2{{.*}} line: 18,
// CHECK-O0-NOT: DW_OP_bit_piece
// CHECK-O0: !DISubprogram(linkageName: "$SS2SSbs5Error_pIgxxdzo_S2SSbsAA_pIegiidzo_TR",
diff --git a/test/DebugInfo/compiler-flags.swift b/test/DebugInfo/compiler-flags.swift
index a68fd68..f13b430 100644
--- a/test/DebugInfo/compiler-flags.swift
+++ b/test/DebugInfo/compiler-flags.swift
@@ -12,16 +12,6 @@
// CHECK-EXPLICIT-NOT: "
// CHECK-EXPLICIT-SAME: -resource-dir
-
-// Check that we tune the debug output for LLDB.
-// Adapted from llvm/test/DebugInfo/X86/debugger-tune.ll
-// RUN: %target-swiftc_driver -emit-object -g %s -o %t
-// RUN: llvm-readobj -sections %t | %FileCheck --check-prefix=CHECK-LLDB %s
-
-// CHECK-LLDB-NOT: debug_pubnames
-// CHECK-LLDB: apple_names
-// CHECK-LLDB-NOT: debug_pubnames
-
// Check that we don't write temporary file names in the debug info
// RUN: TMPDIR=abc/def %target-swift-frontend %s -I abc/def/xyz -g -emit-ir -o - | %FileCheck --check-prefix CHECK-TEMP %s
// CHECK-TEMP: !DICompileUnit({{.*}} flags: "{{.*}} -I <temporary-file>
diff --git a/test/DebugInfo/generic_args.swift b/test/DebugInfo/generic_args.swift
index 3f57123..a0974eb 100644
--- a/test/DebugInfo/generic_args.swift
+++ b/test/DebugInfo/generic_args.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -primary-file %s -emit-ir -verify -g -o - | %FileCheck %s
func markUsed<T>(_ t: T) {}
diff --git a/test/DebugInfo/local-vars.swift.gyb b/test/DebugInfo/local-vars.swift.gyb
index b8e5320..ab9a294 100644
--- a/test/DebugInfo/local-vars.swift.gyb
+++ b/test/DebugInfo/local-vars.swift.gyb
@@ -7,6 +7,7 @@
// RUN: %target-swift-frontend %t.swift -g -c -o %t.o
// RUN: %llvm-dwarfdump %t.o \
// RUN: | %FileCheck %t.swift --check-prefix=DWARF
+// RUN: %llvm-dwarfdump --verify %t.o
// RUN: %target-swift-frontend %t.swift -O -g -emit-ir -o - \
// RUN: | %FileCheck %t.swift --check-prefix=OPTZNS
diff --git a/test/DebugInfo/plus_zero_closure-multivalue.swift b/test/DebugInfo/plus_zero_closure-multivalue.swift
new file mode 100644
index 0000000..f77552f
--- /dev/null
+++ b/test/DebugInfo/plus_zero_closure-multivalue.swift
@@ -0,0 +1,43 @@
+// REQUIRES: plus_zero_runtime
+// rdar://problem/23727705:
+// RUN-DISABLED: %target-swift-frontend -O %s -disable-llvm-optzns -emit-ir -g -o - | %FileCheck %s
+import StdlibUnittest
+
+// CHECK: define {{.*}}i1 {{.*}}4main4sort
+// CHECK: call void @llvm.dbg.value(metadata i8*{{.*}}, metadata ![[A:.*]], metadata ![[P1:.*]])
+// CHECK: call void @llvm.dbg.value(metadata i{{[0-9]+}} {{.*}}, metadata ![[A]], metadata ![[P2:.*]])
+// CHECK: call void @llvm.dbg.value(metadata i{{[0-9]+}} {{.*}}, metadata ![[A]], metadata ![[P3:.*]])
+// CHECK: call void @llvm.dbg.value(metadata i8*{{.*}}, metadata ![[B:.*]], metadata ![[P1]])
+// CHECK: call void @llvm.dbg.value(metadata i{{[0-9]+}} {{.*}}, metadata ![[B]], metadata ![[P2]])
+// CHECK: call void @llvm.dbg.value(metadata i{{[0-9]+}} {{.*}}, metadata ![[B]], metadata ![[P3]])
+// CHECK-DAG: ![[A]] = !DILocalVariable(name: "a",{{.*}} line: 17
+// CHECK-DAG: ![[B]] = !DILocalVariable(name: "b",{{.*}} line: 17
+// CHECK-DAG: ![[P1]] = !DIExpression(DW_OP_bit_piece, 0, {{(32|64)}})
+// CHECK-DAG: ![[P2]] = !DIExpression(DW_OP_bit_piece, {{(32, 32|64, 64)}})
+// CHECK-DAG: ![[P3]] = !DIExpression(DW_OP_bit_piece, {{(64, 32|128, 64)}})
+public func sort(_ a: String, b: String) -> Bool {
+ _blackHole("Sorting..\(a) & \(b)")
+ return (a < b)
+}
+
+public func demo() {
+ let names = ["Sean", "Barry", "Kate"]
+ let sortedNames = names.sorted(by: sort)
+ var sortedNamesAsString : String = String()
+ for name in sortedNames {
+ sortedNamesAsString += ("\(name), ")
+ }
+ _blackHole(sortedNamesAsString)
+}
+demo()
+
+// At -O0, we should have a single aggregate argument.
+// RUN: %target-swift-frontend %s -emit-ir -g -o - | %FileCheck %s --check-prefix=CHECK-O0
+// Verify that a reabstraction thunk does not have a line number.
+// CHECK-O0-NOT: DW_OP_bit_piece
+// CHECK-O0-NOT: DW_OP_bit_piece
+// CHECK-O0: !DILocalVariable(name: "a", arg: 1{{.*}} line: 17,
+// CHECK-O0-NOT: DW_OP_bit_piece
+// CHECK-O0: !DILocalVariable(name: "b", arg: 2{{.*}} line: 17,
+// CHECK-O0-NOT: DW_OP_bit_piece
+// CHECK-O0: !DISubprogram(linkageName: "$SS2SSbs5Error_pIgggdzo_S2SSbsAA_pIegnndzo_TR",
diff --git a/test/DebugInfo/plus_zero_generic_args.swift b/test/DebugInfo/plus_zero_generic_args.swift
new file mode 100644
index 0000000..e4de262
--- /dev/null
+++ b/test/DebugInfo/plus_zero_generic_args.swift
@@ -0,0 +1,54 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -primary-file %s -emit-ir -verify -g -o - | %FileCheck %s
+
+func markUsed<T>(_ t: T) {}
+
+protocol AProtocol {
+ func f() -> String
+}
+class AClass : AProtocol {
+ func f() -> String { return "A" }
+}
+class AnotherClass : AProtocol {
+ func f() -> String { return "B" }
+}
+
+// CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "$S12generic_args9aFunction{{.*}}D",{{.*}} elements: ![[PROTOS:[0-9]+]]
+// CHECK-DAG: ![[PROTOS]] = !{![[INHERIT:.*]]}
+// CHECK-DAG: ![[INHERIT]] = !DIDerivedType(tag: DW_TAG_inheritance,{{.*}} baseType: ![[PROTOCOL:[0-9]+]]
+// CHECK-DAG: ![[PROTOCOL]] = !DICompositeType(tag: DW_TAG_structure_type, name: "$S12generic_args9AProtocol_pmD",
+// CHECK-DAG: !DILocalVariable(name: "x", arg: 1,{{.*}} type: ![[T:.*]])
+// CHECK-DAG: ![[T]] = !DICompositeType(tag: DW_TAG_structure_type, name: "$S12generic_args9aFunction
+// CHECK-DAG: !DILocalVariable(name: "y", arg: 2,{{.*}} type: ![[Q:.*]])
+// CHECK-DAG: ![[Q]] = !DICompositeType(tag: DW_TAG_structure_type, name: "$S12generic_args9aFunction
+func aFunction<T : AProtocol, Q : AProtocol>(_ x: T, _ y: Q, _ z: String) {
+ markUsed("I am in \(z): \(x.f()) \(y.f())")
+}
+
+aFunction(AClass(),AnotherClass(),"aFunction")
+
+struct Wrapper<T: AProtocol> {
+
+ init<U>(from : Wrapper<U>) {
+ // CHECK-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "Wrapper",{{.*}} identifier: "$S12generic_args7WrapperVyAC4fromACyxGACyqd__G_tcAA9AProtocolRd__lufcQq_GD")
+ var wrapped = from
+ wrapped = from
+ _ = wrapped
+ }
+
+ func passthrough(_ t: T) -> T {
+ // The type of local should have the context Wrapper<T>.
+ // CHECK-DAG: ![[WRAPPER:.*]] = !DICompositeType({{.*}}identifier: "$S12generic_args7WrapperVQq_D")
+ // CHECK-DAG: !DILocalVariable(name: "local",{{.*}} line: [[@LINE+1]],{{.*}} type: ![[WRAPPER]]
+ var local = t
+ local = t
+ return local
+ }
+}
+
+// CHECK-DAG: ![[FNTY:.*]] = !DICompositeType({{.*}}identifier: "$S12generic_args5apply_1fq_x_q_xXEtr0_lFQq_AaB_ACq_x_q_xXEtr0_lFQq0_Ignr_D"
+// CHECK-DAG: !DILocalVariable(name: "f", {{.*}}, line: [[@LINE+1]], type: ![[FNTY]])
+func apply<T, U> (_ x: T, f: (T) -> (U)) -> U {
+ return f(x)
+}
+
diff --git a/test/DebugInfo/plus_zero_resilience.swift b/test/DebugInfo/plus_zero_resilience.swift
new file mode 100644
index 0000000..0e50528
--- /dev/null
+++ b/test/DebugInfo/plus_zero_resilience.swift
@@ -0,0 +1,39 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+//
+// Compile the external swift module.
+// RUN: %target-swift-frontend -g -emit-module -enable-resilience \
+// RUN: -emit-module-path=%t/resilient_struct.swiftmodule \
+// RUN: -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
+//
+// RUN: %target-swift-frontend -g -I %t -emit-ir -enable-resilience %s -o - \
+// RUN: | %FileCheck %s
+//
+// RUN: %target-swift-frontend -g -I %t -emit-sil -enable-resilience %s -o - \
+// RUN: | %FileCheck %s --check-prefix=CHECK-SIL
+// RUN: %target-swift-frontend -g -I %t -emit-sil -enable-resilience %s -o - \
+// RUN: -debugger-support | %FileCheck %s --check-prefix=CHECK-LLDB
+import resilient_struct
+
+func use<T>(_ t: T) {}
+
+public func f() {
+ let s1 = Size(w: 1, h: 2)
+ use(s1)
+ // CHECK: %[[ADDR:.*]] = alloca i8*
+ // CHECK: call void @llvm.dbg.declare(metadata i8** %[[ADDR]],
+ // CHECK-SAME: metadata ![[V1:[0-9]+]],
+ // CHECK-SAME: metadata !DIExpression(DW_OP_deref))
+ // CHECK: %[[S1:.*]] = alloca i8,
+ // CHECK: store i8* %[[S1]], i8** %[[ADDR]]
+ // CHECK: ![[V1]] = !DILocalVariable(name: "s1", {{.*}}type: ![[TY:[0-9]+]])
+ // CHECK: ![[TY]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Size",
+ // FIXME-NOT: size:
+ // CHECK: =
+}
+
+// CHECK-SIL: // f()
+// CHECK-LLDB: // f()
+// CHECK-SIL: %0 = alloc_stack $Size, let, name "s1"
+// CHECK-LLDB: %0 = metatype $@thin Size.Type
+// CHECK-LLDB: debug_value %{{.*}} : $Size, let, name "s1"
diff --git a/test/DebugInfo/resilience.swift b/test/DebugInfo/resilience.swift
index 34651fe..5f78283 100644
--- a/test/DebugInfo/resilience.swift
+++ b/test/DebugInfo/resilience.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
//
// Compile the external swift module.
diff --git a/test/FixCode/Inputs/batch-mode-helper.swift b/test/FixCode/Inputs/batch-mode-helper.swift
new file mode 100644
index 0000000..8b3bcbd
--- /dev/null
+++ b/test/FixCode/Inputs/batch-mode-helper.swift
@@ -0,0 +1,10 @@
+enum E2 {
+ case x
+ case y
+ case z
+}
+
+func fooHelper(_ e: E2) {
+ switch e {
+ }
+}
diff --git a/test/FixCode/batch-mode.swift b/test/FixCode/batch-mode.swift
new file mode 100644
index 0000000..a2504ed
--- /dev/null
+++ b/test/FixCode/batch-mode.swift
@@ -0,0 +1,24 @@
+// RUN: not %swift -typecheck -target %target-triple -primary-file %s -emit-fixits-path %t.main.remap -primary-file %S/Inputs/batch-mode-helper.swift -emit-fixits-path %t.helper.remap -diagnostics-editor-mode
+// RUN: %FileCheck -check-prefix=CHECK-MAIN %s < %t.main.remap
+// RUN: %FileCheck -check-prefix=NEGATIVE-MAIN %s < %t.main.remap
+// RUN: %FileCheck -check-prefix=CHECK-HELPER %s < %t.helper.remap
+// RUN: %FileCheck -check-prefix=NEGATIVE-HELPER %s < %t.helper.remap
+
+// CHECK-MAIN: "file": "{{.+}}batch-mode.swift"
+// CHECK-MAIN: "text": "case .a:\n<#code#>\ncase .b:\n<#code#>\ncase .c:\n<#code#>\n"
+// NEGATIVE-MAIN-NOT: batch-mode-helper.swift
+
+// CHECK-HELPER: "file": "{{.+}}batch-mode-helper.swift"
+// CHECK-HELPER: "text": "case .x:\n<#code#>\ncase .y:\n<#code#>\ncase .z:\n<#code#>\n"
+// NEGATIVE-HELPER-NOT: batch-mode.swift
+
+enum E1 {
+ case a
+ case b
+ case c
+}
+
+func fooMain(_ e: E1) {
+ switch e {
+ }
+}
diff --git a/test/Frontend/embed-bitcode-tvos.ll b/test/Frontend/embed-bitcode-tvos.ll
index ccac443..d1b874d 100644
--- a/test/Frontend/embed-bitcode-tvos.ll
+++ b/test/Frontend/embed-bitcode-tvos.ll
@@ -12,7 +12,7 @@
; CHECK-IMPORTER: clang
; CHECK-IMPORTER: -fembed-bitcode
; CHECK-IMPORTER: -target
-; CHECK-IMPORTER: -mtvos-version-min=9
+; CHECK-IMPORTER: arm64-apple-tvos9
; CHECK-IMPORTER-NOT: argument unused
define i32 @f0() nounwind ssp {
diff --git a/test/Fuzzing/fuzzer_test.swift b/test/Fuzzing/fuzzer_test.swift
index 054bf41..3795c4c 100644
--- a/test/Fuzzing/fuzzer_test.swift
+++ b/test/Fuzzing/fuzzer_test.swift
@@ -8,7 +8,7 @@
// XFAIL: OS=watchos
// CHECK: Crash!
-#if os(OSX) || os(iOS)
+#if os(macOS) || os(iOS)
import Darwin
#elseif os(Linux) || os(FreeBSD) || os(PS4) || os(Android) || os(Cygwin)
import Glibc
diff --git a/test/Fuzzing/fuzzer_test_simpler.swift b/test/Fuzzing/fuzzer_test_simpler.swift
index 94e9b6c..beade8e 100644
--- a/test/Fuzzing/fuzzer_test_simpler.swift
+++ b/test/Fuzzing/fuzzer_test_simpler.swift
@@ -8,7 +8,7 @@
// XFAIL: OS=tvos
// XFAIL: OS=watchos
-#if os(OSX) || os(iOS)
+#if os(macOS) || os(iOS)
import Darwin
#elseif os(Linux) || os(FreeBSD) || os(PS4) || os(Android) || os(Cygwin)
import Glibc
diff --git a/test/IDE/coloring_configs.swift b/test/IDE/coloring_configs.swift
index 6bd6393..69445d0 100644
--- a/test/IDE/coloring_configs.swift
+++ b/test/IDE/coloring_configs.swift
@@ -280,8 +280,8 @@
// CHECK: <kw>class</kw> NestedPoundIf {
func foo1() {
// CHECK: <kw>func</kw> foo1() {
- #if os(OSX)
-// CHECK: <#kw>#if</#kw> <#id>os</#id>(<#id>OSX</#id>)
+ #if os(macOS)
+// CHECK: <#kw>#if</#kw> <#id>os</#id>(<#id>macOS</#id>)
var a = 1
// CHECK: <kw>var</kw> a = <int>1</int>
#if USE_METAL
diff --git a/test/IDE/structure.swift b/test/IDE/structure.swift
index edee06d..87bbdfd 100644
--- a/test/IDE/structure.swift
+++ b/test/IDE/structure.swift
@@ -154,7 +154,7 @@
class NestedPoundIf{
func foo1() {
- #if os(OSX)
+ #if os(macOS)
var a = 1
#if USE_METAL
var b = 2
diff --git a/test/IRGen/Inputs/ObjectiveC.swift b/test/IRGen/Inputs/ObjectiveC.swift
index 7457f48..0e155bb 100644
--- a/test/IRGen/Inputs/ObjectiveC.swift
+++ b/test/IRGen/Inputs/ObjectiveC.swift
@@ -2,8 +2,8 @@
@_exported import ObjectiveC
public struct ObjCBool : CustomStringConvertible {
-#if os(OSX) || (os(iOS) && (arch(i386) || arch(arm)))
- // On OS X and 32-bit iOS, Objective-C's BOOL type is a "signed char".
+#if os(macOS) || (os(iOS) && (arch(i386) || arch(arm)))
+ // On macOS and 32-bit iOS, Objective-C's BOOL type is a "signed char".
private var value: Int8
public init(_ value: Bool) {
diff --git a/test/IRGen/big_types_corner_cases.swift b/test/IRGen/big_types_corner_cases.swift
index 7dfb3eb..7d3886d 100644
--- a/test/IRGen/big_types_corner_cases.swift
+++ b/test/IRGen/big_types_corner_cases.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -enable-large-loadable-types %s -emit-ir | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize
// REQUIRES: optimized_stdlib
// UNSUPPORTED: resilient_stdlib
diff --git a/test/IRGen/builtin_math.swift b/test/IRGen/builtin_math.swift
index 43a84b5..04a3a39 100644
--- a/test/IRGen/builtin_math.swift
+++ b/test/IRGen/builtin_math.swift
@@ -20,21 +20,22 @@
return _exp(f)
}
-// LLVM's sqrt intrinsic does not have the same semantics as libm's sqrt.
-// In particular, llvm.sqrt(negative) is documented as being undef, but
-// we want sqrt(negative) to be defined to be NaN for IEEE 754 conformance.
-
// CHECK-LABEL: define {{.*}}test3
// CHECK: call double @sqrt
public func test3(d : Double) -> Double {
+ // This call uses the sqrt function imported from C.
return sqrt(d)
}
// CHECK-LABEL: define {{.*}}test4
-// CHECK: call float @sqrtf
+// CHECK: call float @llvm.sqrt.f32
public func test4(f : Float) -> Float {
+ // This call does not match the signature for the C sqrt function
+ // (as opposed to sqrtf) so instead it gets compiled using the generic
+ // sqrt function from the stdlib's tgmath.swift. That translates to
+ // _stdlib_squareRootf and then to __builtin_sqrtf via SwiftShims.
return sqrt(f)
}
diff --git a/test/IRGen/builtins.swift b/test/IRGen/builtins.swift
index 92d1f49..7046e14 100644
--- a/test/IRGen/builtins.swift
+++ b/test/IRGen/builtins.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -parse-stdlib -primary-file %s -emit-ir -o - -disable-objc-attr-requires-foundation-module | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-runtime
// REQUIRES: CPU=x86_64
diff --git a/test/IRGen/class_bounded_generics.swift b/test/IRGen/class_bounded_generics.swift
index d66fc4a..f1db660 100644
--- a/test/IRGen/class_bounded_generics.swift
+++ b/test/IRGen/class_bounded_generics.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-ir -primary-file %s -disable-objc-attr-requires-foundation-module | %FileCheck %s
// REQUIRES: CPU=x86_64
diff --git a/test/IRGen/enum_resilience.swift b/test/IRGen/enum_resilience.swift
index 8370768..7c3393a 100644
--- a/test/IRGen/enum_resilience.swift
+++ b/test/IRGen/enum_resilience.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_struct.swiftmodule -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_enum.swiftmodule -module-name=resilient_enum -I %t %S/../Inputs/resilient_enum.swift
diff --git a/test/IRGen/generic_metatypes.swift b/test/IRGen/generic_metatypes.swift
index ff14d93..fef162f 100644
--- a/test/IRGen/generic_metatypes.swift
+++ b/test/IRGen/generic_metatypes.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %swift -target x86_64-apple-macosx10.9 -emit-ir -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 %s
// RUN: %swift -target i386-apple-ios7.0 -emit-ir -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 %s
// RUN: %swift -target x86_64-apple-ios7.0 -emit-ir -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 %s
diff --git a/test/IRGen/generic_metatypes_arm.swift b/test/IRGen/generic_metatypes_arm.swift
index e5f28b0..58bfd76 100644
--- a/test/IRGen/generic_metatypes_arm.swift
+++ b/test/IRGen/generic_metatypes_arm.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %swift -target armv7-apple-ios7.0 -module-name generic_metatypes -emit-ir -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 %s
// RUN: %swift -target arm64-apple-ios7.0 -emit-ir -module-name generic_metatypes -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 %s
// RUN: %swift -target armv7-apple-tvos9.0 -emit-ir -module-name generic_metatypes -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 %s
diff --git a/test/IRGen/generic_tuples.swift b/test/IRGen/generic_tuples.swift
index 99fd2ff..9f2968d 100644
--- a/test/IRGen/generic_tuples.swift
+++ b/test/IRGen/generic_tuples.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-ir -primary-file %s | %FileCheck %s
// Make sure that optimization passes don't choke on storage types for generic tuples
diff --git a/test/IRGen/keypaths.sil b/test/IRGen/keypaths.sil
index 9c8636b..3c736a8 100644
--- a/test/IRGen/keypaths.sil
+++ b/test/IRGen/keypaths.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// -- Convert <i32 0x...> constants to decimal constants that LLVM will print
// RUN: %utils/chex.py < %s > %t/keypaths.sil
diff --git a/test/IRGen/keypaths_objc.sil b/test/IRGen/keypaths_objc.sil
index 589fe23..bd94794 100644
--- a/test/IRGen/keypaths_objc.sil
+++ b/test/IRGen/keypaths_objc.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %utils/chex.py < %s > %t/keypaths_objc.sil
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-ir %t/keypaths_objc.sil | %FileCheck %t/keypaths_objc.sil --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize
diff --git a/test/IRGen/lowered_optional_self_metadata.sil b/test/IRGen/lowered_optional_self_metadata.sil
index 11edc8f..8f14c95 100644
--- a/test/IRGen/lowered_optional_self_metadata.sil
+++ b/test/IRGen/lowered_optional_self_metadata.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-ir %s
sil_stage canonical
diff --git a/test/IRGen/objc.swift b/test/IRGen/objc.swift
index ec4d58a..0a15e37 100644
--- a/test/IRGen/objc.swift
+++ b/test/IRGen/objc.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %build-irgen-test-overlays
// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -primary-file %s -emit-ir -disable-objc-attr-requires-foundation-module | %FileCheck %s
diff --git a/test/IRGen/objc_retainAutoreleasedReturnValue.swift b/test/IRGen/objc_retainAutoreleasedReturnValue.swift
index a8d1a27..65c781c 100644
--- a/test/IRGen/objc_retainAutoreleasedReturnValue.swift
+++ b/test/IRGen/objc_retainAutoreleasedReturnValue.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -target x86_64-apple-macosx10.12 -assume-parsing-unqualified-ownership-sil -import-objc-header %S/Inputs/StaticInline.h %s -emit-ir | %FileCheck %s
// RUN: %target-swift-frontend -O -target x86_64-apple-macosx10.12 -assume-parsing-unqualified-ownership-sil -import-objc-header %S/Inputs/StaticInline.h %s -emit-ir | %FileCheck %s --check-prefix=OPT
diff --git a/test/IRGen/plus_zero_big_types_corner_cases.swift b/test/IRGen/plus_zero_big_types_corner_cases.swift
new file mode 100644
index 0000000..05b8339
--- /dev/null
+++ b/test/IRGen/plus_zero_big_types_corner_cases.swift
@@ -0,0 +1,236 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -enable-large-loadable-types %s -emit-ir | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize
+// REQUIRES: optimized_stdlib
+// UNSUPPORTED: resilient_stdlib
+
+public struct BigStruct {
+ var i0 : Int32 = 0
+ var i1 : Int32 = 1
+ var i2 : Int32 = 2
+ var i3 : Int32 = 3
+ var i4 : Int32 = 4
+ var i5 : Int32 = 5
+ var i6 : Int32 = 6
+ var i7 : Int32 = 7
+ var i8 : Int32 = 8
+}
+
+func takeClosure(execute block: () -> Void) {
+}
+
+class OptionalInoutFuncType {
+ private var lp : BigStruct?
+ private var _handler : ((BigStruct?, Error?) -> ())?
+
+ func execute(_ error: Error?) {
+ var p : BigStruct?
+ var handler: ((BigStruct?, Error?) -> ())?
+
+ takeClosure {
+ p = self.lp
+ handler = self._handler
+ self._handler = nil
+ }
+
+ handler?(p, error)
+ }
+}
+
+// CHECK-LABEL: define{{( protected)?}} i32 @main(i32, i8**)
+// CHECK: call void @llvm.lifetime.start
+// CHECK: call void @llvm.memcpy
+// CHECK: call void @llvm.lifetime.end
+// CHECK: ret i32 0
+let bigStructGlobalArray : [BigStruct] = [
+ BigStruct()
+]
+
+// CHECK-LABEL: define{{( protected)?}} internal swiftcc void @"$S22big_types_corner_cases21OptionalInoutFuncTypeC7executeyys5Error_pSgFyyXEfU_"(%T22big_types_corner_cases9BigStructVSg* nocapture dereferenceable({{.*}}), %T22big_types_corner_cases21OptionalInoutFuncTypeC*, %T22big_types_corner_cases9BigStructVSgs5Error_pSgIegcg_Sg* nocapture dereferenceable({{.*}})
+// CHECK: call void @"$SSqWy
+// CHECK: call void @"$SSqWe
+// CHECK: ret void
+
+public func f1_returns_BigType(_ x: BigStruct) -> BigStruct {
+ return x
+}
+
+public func f2_returns_f1() -> (_ x: BigStruct) -> BigStruct {
+ return f1_returns_BigType
+}
+
+public func f3_uses_f2() {
+ let x = BigStruct()
+ let useOfF2 = f2_returns_f1()
+ let _ = useOfF2(x)
+}
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S22big_types_corner_cases10f3_uses_f2yyF"()
+// CHECK: call swiftcc void @"$S22big_types_corner_cases9BigStructVACycfC"(%T22big_types_corner_cases9BigStructV* noalias nocapture sret
+// CHECK: call swiftcc { i8*, %swift.refcounted* } @"$S22big_types_corner_cases13f2_returns_f1AA9BigStructVADcyF"()
+// CHECK: call swiftcc void {{.*}}(%T22big_types_corner_cases9BigStructV* noalias nocapture sret {{.*}}, %T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}}) {{.*}}, %swift.refcounted* swiftself {{.*}})
+// CHECK: ret void
+
+public func f4_tuple_use_of_f2() {
+ let x = BigStruct()
+ let tupleWithFunc = (f2_returns_f1(), x)
+ let useOfF2 = tupleWithFunc.0
+ let _ = useOfF2(x)
+}
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S22big_types_corner_cases18f4_tuple_use_of_f2yyF"()
+// CHECK: [[TUPLE:%.*]] = call swiftcc { i8*, %swift.refcounted* } @"$S22big_types_corner_cases13f2_returns_f1AA9BigStructVADcyF"()
+// CHECK: [[TUPLE_EXTRACT:%.*]] = extractvalue { i8*, %swift.refcounted* } [[TUPLE]], 0
+// CHECK: [[CAST_EXTRACT:%.*]] = bitcast i8* [[TUPLE_EXTRACT]] to void (%T22big_types_corner_cases9BigStructV*, %T22big_types_corner_cases9BigStructV*, %swift.refcounted*)*
+// CHECK: call swiftcc void [[CAST_EXTRACT]](%T22big_types_corner_cases9BigStructV* noalias nocapture sret {{.*}}, %T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}}) {{.*}}, %swift.refcounted* swiftself %{{.*}})
+// CHECK: ret void
+
+public class BigClass {
+ public init() {
+ }
+
+ public var optVar: ((BigStruct)-> Void)? = nil
+
+ func useBigStruct(bigStruct: BigStruct) {
+ optVar!(bigStruct)
+ }
+}
+
+// CHECK-LABEL: define{{( protected)?}} hidden swiftcc void @"$S22big_types_corner_cases8BigClassC03useE6Struct0aH0yAA0eH0V_tF"(%T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}}), %T22big_types_corner_cases8BigClassC* swiftself)
+// CHECK: [[BITCAST:%.*]] = bitcast i8* {{.*}} to void (%T22big_types_corner_cases9BigStructV*, %swift.refcounted*)*
+// CHECK: call swiftcc void [[BITCAST]](%T22big_types_corner_cases9BigStructV* noalias nocapture dereferenceable({{.*}}) %0, %swift.refcounted* swiftself
+// CHECK: ret void
+
+public struct MyStruct {
+ public let a: Int
+ public let b: String?
+ }
+
+typealias UploadFunction = ((MyStruct, Int?) -> Void) -> Void
+func takesUploader(_ u: UploadFunction) { }
+
+class Foo {
+ func blam() {
+ takesUploader(self.myMethod) // crash compiling this
+ }
+
+ func myMethod(_ callback: (MyStruct, Int) -> Void) -> Void { }
+}
+
+// CHECK-LABEL: define{{( protected)?}} linkonce_odr hidden swiftcc { i8*, %swift.refcounted* } @"$S22big_types_corner_cases3FooC8myMethodyyyAA8MyStructV_SitXEFTc"(%T22big_types_corner_cases3FooC*)
+// CHECK: getelementptr inbounds %T22big_types_corner_cases3FooC, %T22big_types_corner_cases3FooC*
+// CHECK: getelementptr inbounds void (i8*, %swift.opaque*, %T22big_types_corner_cases3FooC*)*, void (i8*, %swift.opaque*, %T22big_types_corner_cases3FooC*)**
+// CHECK: call noalias %swift.refcounted* @swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata*
+// CHECK: ret { i8*, %swift.refcounted* }
+
+public enum LargeEnum {
+ public enum InnerEnum {
+ case simple(Int64)
+ case hard(Int64, String?, Int64)
+ }
+ case Empty1
+ case Empty2
+ case Full(InnerEnum)
+}
+
+public func enumCallee(_ x: LargeEnum) {
+ switch x {
+ case .Full(let inner): print(inner)
+ case .Empty1: break
+ case .Empty2: break
+ }
+}
+// CHECK-LABEL-64: define{{( protected)?}} swiftcc void @"$S22big_types_corner_cases10enumCalleeyAA9LargeEnumOF"(%T22big_types_corner_cases9LargeEnumO* noalias nocapture dereferenceable({{.*}})) #0 {
+// CHECK-64: alloca %T22big_types_corner_cases9LargeEnumO05InnerF0O
+// CHECK-64: alloca %T22big_types_corner_cases9LargeEnumO
+// CHECK-64: call void @llvm.memcpy.p0i8.p0i8.i64
+// CHECK-64: call void @llvm.memcpy.p0i8.p0i8.i64
+// CHECK-64: $Ss5print_9separator10terminatoryypd_S2StF
+// CHECK-64: ret void
+
+// CHECK-LABEL: define{{( protected)?}} internal swiftcc void @"$S22big_types_corner_cases8SuperSubC1fyyFAA9BigStructVycfU_"(%T22big_types_corner_cases9BigStructV* noalias nocapture sret, %T22big_types_corner_cases8SuperSubC*)
+// CHECK-64: [[ALLOC1:%.*]] = alloca %T22big_types_corner_cases9BigStructV
+// CHECK-64: [[ALLOC2:%.*]] = alloca %T22big_types_corner_cases9BigStructV
+// CHECK-64: [[ALLOC3:%.*]] = alloca %T22big_types_corner_cases9BigStructVSg
+// CHECK-64: [[ALLOC4:%.*]] = alloca %T22big_types_corner_cases9BigStructVSg
+// CHECK-64: call swiftcc void @"$S22big_types_corner_cases9SuperBaseC4boomAA9BigStructVyF"(%T22big_types_corner_cases9BigStructV* noalias nocapture sret [[ALLOC1]], %T22big_types_corner_cases9SuperBaseC* swiftself {{.*}})
+// CHECK: ret void
+class SuperBase {
+ func boom() -> BigStruct {
+ return BigStruct()
+ }
+}
+
+class SuperSub : SuperBase {
+ override func boom() -> BigStruct {
+ return BigStruct()
+ }
+ func f() {
+ let _ = {
+ nil ?? super.boom()
+ }
+ }
+}
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S22big_types_corner_cases10MUseStructV16superclassMirrorAA03BigF0VSgvg"(%T22big_types_corner_cases9BigStructVSg* noalias nocapture sret, %T22big_types_corner_cases10MUseStructV* noalias nocapture swiftself dereferenceable({{.*}}))
+// CHECK: [[ALLOC:%.*]] = alloca %T22big_types_corner_cases9BigStructVSg
+// CHECK: [[LOAD:%.*]] = load %swift.refcounted*, %swift.refcounted** %.callInternalLet.data
+// CHECK: call swiftcc void %7(%T22big_types_corner_cases9BigStructVSg* noalias nocapture sret [[ALLOC]], %swift.refcounted* swiftself [[LOAD]])
+// CHECK: ret void
+public struct MUseStruct {
+ var x = BigStruct()
+ public var superclassMirror: BigStruct? {
+ return callInternalLet()
+ }
+
+ internal let callInternalLet: () -> BigStruct?
+}
+
+// CHECK-LABEL-64: define{{( protected)?}} swiftcc void @"$S22big_types_corner_cases18stringAndSubstringSS_s0G0VtyF"(<{ %TSS, %Ts9SubstringV }>* noalias nocapture sret) #0 {
+// CHECK-LABEL-32: define{{( protected)?}} swiftcc void @"$S22big_types_corner_cases18stringAndSubstringSS_s0G0VtyF"(<{ %TSS, [4 x i8], %Ts9SubstringV }>* noalias nocapture sret) #0 {
+// CHECK: alloca %Ts9SubstringV
+// CHECK: alloca %Ts9SubstringV
+// CHECK: ret void
+public func stringAndSubstring() -> (String, Substring) {
+ let s = "Hello, World"
+ let a = Substring(s).dropFirst()
+ return (s, a)
+}
+
+func bigStructGet() -> BigStruct {
+ return BigStruct()
+}
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S22big_types_corner_cases11testGetFuncyyF"()
+// CHECK: ret void
+public func testGetFunc() {
+ let testGetPtr: @convention(thin) () -> BigStruct = bigStructGet
+}
+
+// CHECK-LABEL: define{{( protected)?}} hidden swiftcc void @"$S22big_types_corner_cases7TestBigC4testyyF"(%T22big_types_corner_cases7TestBigC* swiftself)
+// CHECK: [[CALL1:%.*]] = call %swift.type* @"$SSayy22big_types_corner_cases9BigStructVcSgGMa"
+// CHECK: [[CALL2:%.*]] = call i8** @"$SSayy22big_types_corner_cases9BigStructVcSgGSayxGs10CollectionsWl
+// CHECK: call swiftcc void @"$Ss10CollectionPsE5index5where5IndexQzSgSb7ElementQzKXE_tKF"(%TSq.{{.*}}* noalias nocapture sret {{.*}}, i8* bitcast (i1 (%T22big_types_corner_cases9BigStructVytIegnr_Sg*, %swift.refcounted*, %swift.error**)* @"$S22big_types_corner_cases9BigStructVIegy_SgSbs5Error_pIggdzo_ACytIegnr_SgSbsAE_pIegndzo_TRTA" to i8*), %swift.opaque* {{.*}}, %swift.type* [[CALL1]], i8** [[CALL2]], %swift.opaque* noalias nocapture swiftself
+// CHECK: ret void
+
+// CHECK-LABEL: define{{( protected)?}} hidden swiftcc void @"$S22big_types_corner_cases7TestBigC5test2yyF"(%T22big_types_corner_cases7TestBigC* swiftself)
+// CHECK: [[CALL1:%.*]] = call %swift.type* @"$SSaySS2ID_y22big_types_corner_cases9BigStructVcSg7handlertGMa"
+// CHECK: [[CALL2:%.*]] = call i8** @"$SSaySS2ID_y22big_types_corner_cases9BigStructVcSg7handlertGSayxGs10CollectionsWl"
+// CHECK: call swiftcc void @"$Ss10CollectionPss16IndexingIteratorVyxG0C0RtzrlE04makeC0AEyF"(%Ts16IndexingIteratorV* noalias nocapture sret {{.*}}, %swift.type* [[CALL1]], i8** [[CALL2]], %swift.opaque* noalias nocapture swiftself {{.*}})
+// CHECK: ret void
+class TestBig {
+ typealias Handler = (BigStruct) -> Void
+
+ func test() {
+ let arr = [Handler?]()
+ let d = arr.index(where: { _ in true })
+ }
+
+ func test2() {
+ let arr: [(ID: String, handler: Handler?)] = []
+ for (_, handler) in arr {
+ takeClosure {
+ handler?(BigStruct())
+ }
+ }
+ }
+}
diff --git a/test/IRGen/plus_zero_builtins.swift b/test/IRGen/plus_zero_builtins.swift
new file mode 100644
index 0000000..b4479ad
--- /dev/null
+++ b/test/IRGen/plus_zero_builtins.swift
@@ -0,0 +1,872 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -parse-stdlib -primary-file %s -emit-ir -o - -disable-objc-attr-requires-foundation-module | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-runtime
+
+// REQUIRES: CPU=x86_64
+
+import Swift
+
+// CHECK-DAG: [[REFCOUNT:%swift.refcounted.*]] = type
+// CHECK-DAG: [[X:%T8builtins1XC]] = type
+// CHECK-DAG: [[Y:%T8builtins1YC]] = type
+
+typealias Int = Builtin.Int32
+typealias Bool = Builtin.Int1
+
+// CHECK: call swiftcc void @swift_errorInMain(
+
+infix operator * {
+ associativity left
+ precedence 200
+}
+infix operator / {
+ associativity left
+ precedence 200
+}
+infix operator % {
+ associativity left
+ precedence 200
+}
+
+infix operator + {
+ associativity left
+ precedence 190
+}
+infix operator - {
+ associativity left
+ precedence 190
+}
+
+infix operator << {
+ associativity none
+ precedence 180
+}
+infix operator >> {
+ associativity none
+ precedence 180
+}
+
+infix operator ... {
+ associativity none
+ precedence 175
+}
+
+infix operator < {
+ associativity none
+ precedence 170
+}
+infix operator <= {
+ associativity none
+ precedence 170
+}
+infix operator > {
+ associativity none
+ precedence 170
+}
+infix operator >= {
+ associativity none
+ precedence 170
+}
+
+infix operator == {
+ associativity none
+ precedence 160
+}
+infix operator != {
+ associativity none
+ precedence 160
+}
+
+func * (lhs: Int, rhs: Int) -> Int {
+ return Builtin.mul_Int32(lhs, rhs)
+ // CHECK: mul i32
+}
+func / (lhs: Int, rhs: Int) -> Int {
+ return Builtin.sdiv_Int32(lhs, rhs)
+ // CHECK: sdiv i32
+}
+func % (lhs: Int, rhs: Int) -> Int {
+ return Builtin.srem_Int32(lhs, rhs)
+ // CHECK: srem i32
+}
+func + (lhs: Int, rhs: Int) -> Int {
+ return Builtin.add_Int32(lhs, rhs)
+ // CHECK: add i32
+}
+func - (lhs: Int, rhs: Int) -> Int {
+ return Builtin.sub_Int32(lhs, rhs)
+ // CHECK: sub i32
+}
+// In C, 180 is <<, >>
+func < (lhs: Int, rhs: Int) -> Bool {
+ return Builtin.cmp_slt_Int32(lhs, rhs)
+ // CHECK: icmp slt i32
+}
+func > (lhs: Int, rhs: Int) -> Bool {
+ return Builtin.cmp_sgt_Int32(lhs, rhs)
+ // CHECK: icmp sgt i32
+}
+func <=(lhs: Int, rhs: Int) -> Bool {
+ return Builtin.cmp_sle_Int32(lhs, rhs)
+ // CHECK: icmp sle i32
+}
+func >=(lhs: Int, rhs: Int) -> Bool {
+ return Builtin.cmp_sge_Int32(lhs, rhs)
+ // CHECK: icmp sge i32
+}
+func ==(lhs: Int, rhs: Int) -> Bool {
+ return Builtin.cmp_eq_Int32(lhs, rhs)
+ // CHECK: icmp eq i32
+}
+func !=(lhs: Int, rhs: Int) -> Bool {
+ return Builtin.cmp_ne_Int32(lhs, rhs)
+ // CHECK: icmp ne i32
+}
+
+func gepRaw_test(_ ptr: Builtin.RawPointer, offset: Builtin.Int64)
+ -> Builtin.RawPointer {
+ return Builtin.gepRaw_Int64(ptr, offset)
+ // CHECK: getelementptr inbounds i8, i8*
+}
+
+// CHECK: define hidden {{.*}}i64 @"$S8builtins9load_test{{[_0-9a-zA-Z]*}}F"
+func load_test(_ ptr: Builtin.RawPointer) -> Builtin.Int64 {
+ // CHECK: [[CASTPTR:%.*]] = bitcast i8* [[PTR:%.*]] to i64*
+ // CHECK-NEXT: load i64, i64* [[CASTPTR]]
+ // CHECK: ret
+ return Builtin.load(ptr)
+}
+
+// CHECK: define hidden {{.*}}i64 @"$S8builtins13load_raw_test{{[_0-9a-zA-Z]*}}F"
+func load_raw_test(_ ptr: Builtin.RawPointer) -> Builtin.Int64 {
+ // CHECK: [[CASTPTR:%.*]] = bitcast i8* [[PTR:%.*]] to i64*
+ // CHECK-NEXT: load i64, i64* [[CASTPTR]]
+ // CHECK: ret
+ return Builtin.loadRaw(ptr)
+}
+
+// CHECK: define hidden {{.*}}void @"$S8builtins11assign_test{{[_0-9a-zA-Z]*}}F"
+func assign_test(_ value: Builtin.Int64, ptr: Builtin.RawPointer) {
+ Builtin.assign(value, ptr)
+ // CHECK: ret
+}
+
+// CHECK: define hidden {{.*}}%swift.refcounted* @"$S8builtins16load_object_test{{[_0-9a-zA-Z]*}}F"
+func load_object_test(_ ptr: Builtin.RawPointer) -> Builtin.NativeObject {
+ // CHECK: [[T0:%.*]] = load [[REFCOUNT]]*, [[REFCOUNT]]**
+ // CHECK: call [[REFCOUNT]]* @swift_retain([[REFCOUNT]]* returned [[T0]])
+ // CHECK: ret [[REFCOUNT]]* [[T0]]
+ return Builtin.load(ptr)
+}
+
+// CHECK: define hidden {{.*}}%swift.refcounted* @"$S8builtins20load_raw_object_test{{[_0-9a-zA-Z]*}}F"
+func load_raw_object_test(_ ptr: Builtin.RawPointer) -> Builtin.NativeObject {
+ // CHECK: [[T0:%.*]] = load [[REFCOUNT]]*, [[REFCOUNT]]**
+ // CHECK: call [[REFCOUNT]]* @swift_retain([[REFCOUNT]]* returned [[T0]])
+ // CHECK: ret [[REFCOUNT]]* [[T0]]
+ return Builtin.loadRaw(ptr)
+}
+
+// CHECK: define hidden {{.*}}void @"$S8builtins18assign_object_test{{[_0-9a-zA-Z]*}}F"
+func assign_object_test(_ value: Builtin.NativeObject, ptr: Builtin.RawPointer) {
+ Builtin.assign(value, ptr)
+}
+
+// CHECK: define hidden {{.*}}void @"$S8builtins16init_object_test{{[_0-9a-zA-Z]*}}F"
+func init_object_test(_ value: Builtin.NativeObject, ptr: Builtin.RawPointer) {
+ // CHECK: [[DEST:%.*]] = bitcast i8* {{%.*}} to [[REFCOUNT]]**
+ // CHECK-NEXT: call [[REFCOUNT]]* @swift_retain([[REFCOUNT]]* returned [[SRC:%.*]])
+ // CHECK-NEXT: store [[REFCOUNT]]* [[SRC]], [[REFCOUNT]]** [[DEST]]
+ Builtin.initialize(value, ptr)
+}
+
+func cast_test(_ ptr: inout Builtin.RawPointer, i8: inout Builtin.Int8,
+ i64: inout Builtin.Int64, f: inout Builtin.FPIEEE32,
+ d: inout Builtin.FPIEEE64
+) {
+ // CHECK: cast_test
+
+ i8 = Builtin.trunc_Int64_Int8(i64) // CHECK: trunc
+ i64 = Builtin.zext_Int8_Int64(i8) // CHECK: zext
+ i64 = Builtin.sext_Int8_Int64(i8) // CHECK: sext
+ i64 = Builtin.ptrtoint_Int64(ptr) // CHECK: ptrtoint
+ ptr = Builtin.inttoptr_Int64(i64) // CHECK: inttoptr
+ i64 = Builtin.fptoui_FPIEEE64_Int64(d) // CHECK: fptoui
+ i64 = Builtin.fptosi_FPIEEE64_Int64(d) // CHECK: fptosi
+ d = Builtin.uitofp_Int64_FPIEEE64(i64) // CHECK: uitofp
+ d = Builtin.sitofp_Int64_FPIEEE64(i64) // CHECK: sitofp
+ d = Builtin.fpext_FPIEEE32_FPIEEE64(f) // CHECK: fpext
+ f = Builtin.fptrunc_FPIEEE64_FPIEEE32(d) // CHECK: fptrunc
+ i64 = Builtin.bitcast_FPIEEE64_Int64(d) // CHECK: bitcast
+ d = Builtin.bitcast_Int64_FPIEEE64(i64) // CHECK: bitcast
+}
+
+func intrinsic_test(_ i32: inout Builtin.Int32, i16: inout Builtin.Int16) {
+ i32 = Builtin.int_bswap_Int32(i32) // CHECK: llvm.bswap.i32(
+
+ i16 = Builtin.int_bswap_Int16(i16) // CHECK: llvm.bswap.i16(
+
+ var x = Builtin.int_sadd_with_overflow_Int16(i16, i16) // CHECK: call { i16, i1 } @llvm.sadd.with.overflow.i16(
+
+ Builtin.int_trap() // CHECK: llvm.trap()
+}
+
+// CHECK: define hidden {{.*}}void @"$S8builtins19sizeof_alignof_testyyF"()
+func sizeof_alignof_test() {
+ // CHECK: store i64 4, i64*
+ var xs = Builtin.sizeof(Int.self)
+ // CHECK: store i64 4, i64*
+ var xa = Builtin.alignof(Int.self)
+ // CHECK: store i64 1, i64*
+ var ys = Builtin.sizeof(Bool.self)
+ // CHECK: store i64 1, i64*
+ var ya = Builtin.alignof(Bool.self)
+
+}
+
+// CHECK: define hidden {{.*}}void @"$S8builtins27generic_sizeof_alignof_testyyxlF"
+func generic_sizeof_alignof_test<T>(_: T) {
+ // CHECK: [[T0:%.*]] = getelementptr inbounds i8*, i8** [[T:%.*]], i32 9
+ // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[T0]]
+ // CHECK-NEXT: [[SIZE:%.*]] = ptrtoint i8* [[T1]] to i64
+ // CHECK-NEXT: store i64 [[SIZE]], i64* [[S:%.*]]
+ var s = Builtin.sizeof(T.self)
+ // CHECK: [[T0:%.*]] = getelementptr inbounds i8*, i8** [[T:%.*]], i32 10
+ // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[T0]]
+ // CHECK-NEXT: [[T2:%.*]] = ptrtoint i8* [[T1]] to i64
+ // CHECK-NEXT: [[T3:%.*]] = and i64 [[T2]], 65535
+ // CHECK-NEXT: [[ALIGN:%.*]] = add i64 [[T3]], 1
+ // CHECK-NEXT: store i64 [[ALIGN]], i64* [[A:%.*]]
+ var a = Builtin.alignof(T.self)
+}
+
+// CHECK: define hidden {{.*}}void @"$S8builtins21generic_strideof_testyyxlF"
+func generic_strideof_test<T>(_: T) {
+ // CHECK: [[T0:%.*]] = getelementptr inbounds i8*, i8** [[T:%.*]], i32 11
+ // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[T0]]
+ // CHECK-NEXT: [[STRIDE:%.*]] = ptrtoint i8* [[T1]] to i64
+ // CHECK-NEXT: store i64 [[STRIDE]], i64* [[S:%.*]]
+ var s = Builtin.strideof(T.self)
+}
+
+class X {}
+
+class Y {}
+func move(_ ptr: Builtin.RawPointer) {
+ var temp : Y = Builtin.take(ptr)
+ // CHECK: define hidden {{.*}}void @"$S8builtins4move{{[_0-9a-zA-Z]*}}F"
+ // CHECK: [[SRC:%.*]] = bitcast i8* {{%.*}} to [[Y]]**
+ // CHECK-NEXT: [[VAL:%.*]] = load [[Y]]*, [[Y]]** [[SRC]]
+ // CHECK-NEXT: store [[Y]]* [[VAL]], [[Y]]** {{%.*}}
+}
+
+func allocDealloc(_ size: Builtin.Word, align: Builtin.Word) {
+ var ptr = Builtin.allocRaw(size, align)
+ Builtin.deallocRaw(ptr, size, align)
+}
+
+func fence_test() {
+ // CHECK: fence acquire
+ Builtin.fence_acquire()
+
+ // CHECK: fence syncscope("singlethread") acq_rel
+ Builtin.fence_acqrel_singlethread()
+}
+
+func cmpxchg_test(_ ptr: Builtin.RawPointer, a: Builtin.Int32, b: Builtin.Int32) {
+ // rdar://12939803 - ER: support atomic cmpxchg/xchg with pointers
+
+ // CHECK: [[Z_RES:%.*]] = cmpxchg i32* {{.*}}, i32 {{.*}}, i32 {{.*}} acquire acquire
+ // CHECK: [[Z_VAL:%.*]] = extractvalue { i32, i1 } [[Z_RES]], 0
+ // CHECK: [[Z_SUCCESS:%.*]] = extractvalue { i32, i1 } [[Z_RES]], 1
+ // CHECK: store i32 [[Z_VAL]], i32* {{.*}}, align 4
+ // CHECK: store i1 [[Z_SUCCESS]], i1* {{.*}}, align 1
+ var (z, zSuccess) = Builtin.cmpxchg_acquire_acquire_Int32(ptr, a, b)
+
+ // CHECK: [[Y_RES:%.*]] = cmpxchg volatile i32* {{.*}}, i32 {{.*}}, i32 {{.*}} monotonic monotonic
+ // CHECK: [[Y_VAL:%.*]] = extractvalue { i32, i1 } [[Y_RES]], 0
+ // CHECK: [[Y_SUCCESS:%.*]] = extractvalue { i32, i1 } [[Y_RES]], 1
+ // CHECK: store i32 [[Y_VAL]], i32* {{.*}}, align 4
+ // CHECK: store i1 [[Y_SUCCESS]], i1* {{.*}}, align 1
+ var (y, ySuccess) = Builtin.cmpxchg_monotonic_monotonic_volatile_Int32(ptr, a, b)
+
+ // CHECK: [[X_RES:%.*]] = cmpxchg volatile i32* {{.*}}, i32 {{.*}}, i32 {{.*}} syncscope("singlethread") acquire monotonic
+ // CHECK: [[X_VAL:%.*]] = extractvalue { i32, i1 } [[X_RES]], 0
+ // CHECK: [[X_SUCCESS:%.*]] = extractvalue { i32, i1 } [[X_RES]], 1
+ // CHECK: store i32 [[X_VAL]], i32* {{.*}}, align 4
+ // CHECK: store i1 [[X_SUCCESS]], i1* {{.*}}, align 1
+ var (x, xSuccess) = Builtin.cmpxchg_acquire_monotonic_volatile_singlethread_Int32(ptr, a, b)
+
+ // CHECK: [[W_RES:%.*]] = cmpxchg volatile i64* {{.*}}, i64 {{.*}}, i64 {{.*}} seq_cst seq_cst
+ // CHECK: [[W_VAL:%.*]] = extractvalue { i64, i1 } [[W_RES]], 0
+ // CHECK: [[W_SUCCESS:%.*]] = extractvalue { i64, i1 } [[W_RES]], 1
+ // CHECK: [[W_VAL_PTR:%.*]] = inttoptr i64 [[W_VAL]] to i8*
+ // CHECK: store i8* [[W_VAL_PTR]], i8** {{.*}}, align 8
+ // CHECK: store i1 [[W_SUCCESS]], i1* {{.*}}, align 1
+ var (w, wSuccess) = Builtin.cmpxchg_seqcst_seqcst_volatile_singlethread_RawPointer(ptr, ptr, ptr)
+
+ // CHECK: [[V_RES:%.*]] = cmpxchg weak volatile i64* {{.*}}, i64 {{.*}}, i64 {{.*}} seq_cst seq_cst
+ // CHECK: [[V_VAL:%.*]] = extractvalue { i64, i1 } [[V_RES]], 0
+ // CHECK: [[V_SUCCESS:%.*]] = extractvalue { i64, i1 } [[V_RES]], 1
+ // CHECK: [[V_VAL_PTR:%.*]] = inttoptr i64 [[V_VAL]] to i8*
+ // CHECK: store i8* [[V_VAL_PTR]], i8** {{.*}}, align 8
+ // CHECK: store i1 [[V_SUCCESS]], i1* {{.*}}, align 1
+ var (v, vSuccess) = Builtin.cmpxchg_seqcst_seqcst_weak_volatile_singlethread_RawPointer(ptr, ptr, ptr)
+}
+
+func atomicrmw_test(_ ptr: Builtin.RawPointer, a: Builtin.Int32,
+ ptr2: Builtin.RawPointer) {
+ // CHECK: atomicrmw add i32* {{.*}}, i32 {{.*}} acquire
+ var z = Builtin.atomicrmw_add_acquire_Int32(ptr, a)
+
+ // CHECK: atomicrmw volatile max i32* {{.*}}, i32 {{.*}} monotonic
+ var y = Builtin.atomicrmw_max_monotonic_volatile_Int32(ptr, a)
+
+ // CHECK: atomicrmw volatile xchg i32* {{.*}}, i32 {{.*}} syncscope("singlethread") acquire
+ var x = Builtin.atomicrmw_xchg_acquire_volatile_singlethread_Int32(ptr, a)
+
+ // rdar://12939803 - ER: support atomic cmpxchg/xchg with pointers
+ // CHECK: atomicrmw volatile xchg i64* {{.*}}, i64 {{.*}} syncscope("singlethread") acquire
+ var w = Builtin.atomicrmw_xchg_acquire_volatile_singlethread_RawPointer(ptr, ptr2)
+
+}
+
+func addressof_test(_ a: inout Int, b: inout Bool) {
+ // CHECK: bitcast i32* {{.*}} to i8*
+ var ap : Builtin.RawPointer = Builtin.addressof(&a)
+ // CHECK: bitcast i1* {{.*}} to i8*
+ var bp : Builtin.RawPointer = Builtin.addressof(&b)
+}
+
+func fneg_test(_ half: Builtin.FPIEEE16,
+ single: Builtin.FPIEEE32,
+ double: Builtin.FPIEEE64)
+ -> (Builtin.FPIEEE16, Builtin.FPIEEE32, Builtin.FPIEEE64)
+{
+ // CHECK: fsub half 0xH8000, {{%.*}}
+ // CHECK: fsub float -0.000000e+00, {{%.*}}
+ // CHECK: fsub double -0.000000e+00, {{%.*}}
+ return (Builtin.fneg_FPIEEE16(half),
+ Builtin.fneg_FPIEEE32(single),
+ Builtin.fneg_FPIEEE64(double))
+}
+
+// The call to the builtins should get removed before we reach IRGen.
+func testStaticReport(_ b: Bool, ptr: Builtin.RawPointer) -> () {
+ Builtin.staticReport(b, b, ptr);
+ return Builtin.staticReport(b, b, ptr);
+}
+
+// CHECK-LABEL: define hidden {{.*}}void @"$S8builtins12testCondFail{{[_0-9a-zA-Z]*}}F"(i1, i1)
+func testCondFail(_ b: Bool, c: Bool) {
+ // CHECK: br i1 %0, label %[[FAIL:.*]], label %[[CONT:.*]]
+ Builtin.condfail(b)
+ // CHECK: <label>:[[CONT]]
+ // CHECK: br i1 %1, label %[[FAIL2:.*]], label %[[CONT:.*]]
+ Builtin.condfail(c)
+ // CHECK: <label>:[[CONT]]
+ // CHECK: ret void
+
+ // CHECK: <label>:[[FAIL]]
+ // CHECK: call void @llvm.trap()
+ // CHECK: unreachable
+
+ // CHECK: <label>:[[FAIL2]]
+ // CHECK: call void @llvm.trap()
+ // CHECK: unreachable
+}
+
+// CHECK-LABEL: define hidden {{.*}}void @"$S8builtins8testOnce{{[_0-9a-zA-Z]*}}F"(i8*, i8*) {{.*}} {
+// CHECK: [[PRED_PTR:%.*]] = bitcast i8* %0 to [[WORD:i64|i32]]*
+// CHECK-objc: [[PRED:%.*]] = load {{.*}} [[WORD]]* [[PRED_PTR]]
+// CHECK-objc: [[IS_DONE:%.*]] = icmp eq [[WORD]] [[PRED]], -1
+// CHECK-objc: br i1 [[IS_DONE]], label %[[DONE:.*]], label %[[NOT_DONE:.*]]
+// CHECK-objc: [[NOT_DONE]]:
+// CHECK: call void @swift_once([[WORD]]* [[PRED_PTR]], i8* %1, i8* undef)
+// CHECK-objc: br label %[[DONE]]
+// CHECK-objc: [[DONE]]:
+// CHECK-objc: [[PRED:%.*]] = load {{.*}} [[WORD]]* [[PRED_PTR]]
+// CHECK-objc: [[IS_DONE:%.*]] = icmp eq [[WORD]] [[PRED]], -1
+// CHECK-objc: call void @llvm.assume(i1 [[IS_DONE]])
+
+func testOnce(_ p: Builtin.RawPointer, f: @escaping @convention(c) () -> ()) {
+ Builtin.once(p, f)
+}
+
+// CHECK-LABEL: define hidden {{.*}}void @"$S8builtins19testOnceWithContext{{[_0-9a-zA-Z]*}}F"(i8*, i8*, i8*) {{.*}} {
+// CHECK: [[PRED_PTR:%.*]] = bitcast i8* %0 to [[WORD:i64|i32]]*
+// CHECK-objc: [[PRED:%.*]] = load {{.*}} [[WORD]]* [[PRED_PTR]]
+// CHECK-objc: [[IS_DONE:%.*]] = icmp eq [[WORD]] [[PRED]], -1
+// CHECK-objc: br i1 [[IS_DONE]], label %[[DONE:.*]], label %[[NOT_DONE:.*]]
+// CHECK-objc: [[NOT_DONE]]:
+// CHECK: call void @swift_once([[WORD]]* [[PRED_PTR]], i8* %1, i8* %2)
+// CHECK-objc: br label %[[DONE]]
+// CHECK-objc: [[DONE]]:
+// CHECK-objc: [[PRED:%.*]] = load {{.*}} [[WORD]]* [[PRED_PTR]]
+// CHECK-objc: [[IS_DONE:%.*]] = icmp eq [[WORD]] [[PRED]], -1
+// CHECK-objc: call void @llvm.assume(i1 [[IS_DONE]])
+func testOnceWithContext(_ p: Builtin.RawPointer, f: @escaping @convention(c) (Builtin.RawPointer) -> (), k: Builtin.RawPointer) {
+ Builtin.onceWithContext(p, f, k)
+}
+
+class C {}
+struct S {}
+@objc class O {}
+@objc protocol OP1 {}
+@objc protocol OP2 {}
+protocol P {}
+
+// CHECK-LABEL: define hidden {{.*}}void @"$S8builtins10canBeClass{{[_0-9a-zA-Z]*}}F"
+func canBeClass<T>(_ f: @escaping (Builtin.Int8) -> (), _: T) {
+ // CHECK: call {{.*}}void {{%.*}}(i8 1
+ f(Builtin.canBeClass(O.self))
+ // CHECK: call {{.*}}void {{%.*}}(i8 1
+ f(Builtin.canBeClass(OP1.self))
+ typealias ObjCCompo = OP1 & OP2
+ // CHECK: call {{.*}}void {{%.*}}(i8 1
+ f(Builtin.canBeClass(ObjCCompo.self))
+
+ // CHECK: call {{.*}}void {{%.*}}(i8 0
+ f(Builtin.canBeClass(S.self))
+ // CHECK: call {{.*}}void {{%.*}}(i8 1
+ f(Builtin.canBeClass(C.self))
+ // CHECK: call {{.*}}void {{%.*}}(i8 0
+ f(Builtin.canBeClass(P.self))
+ typealias MixedCompo = OP1 & P
+ // CHECK: call {{.*}}void {{%.*}}(i8 0
+ f(Builtin.canBeClass(MixedCompo.self))
+
+ // CHECK: call {{.*}}void {{%.*}}(i8 2
+ f(Builtin.canBeClass(T.self))
+}
+
+// CHECK-LABEL: define hidden {{.*}}void @"$S8builtins15destroyPODArray{{[_0-9a-zA-Z]*}}F"(i8*, i64)
+// CHECK-NOT: loop:
+// CHECK: ret void
+func destroyPODArray(_ array: Builtin.RawPointer, count: Builtin.Word) {
+ Builtin.destroyArray(Int.self, array, count)
+}
+
+// CHECK-LABEL: define hidden {{.*}}void @"$S8builtins18destroyNonPODArray{{[_0-9a-zA-Z]*}}F"(i8*, i64) {{.*}} {
+// CHECK-NOT: loop:
+// CHECK: call void @swift_arrayDestroy(
+func destroyNonPODArray(_ array: Builtin.RawPointer, count: Builtin.Word) {
+ Builtin.destroyArray(C.self, array, count)
+}
+
+// CHECK-LABEL: define hidden {{.*}}void @"$S8builtins15destroyGenArray_5count_yBp_BwxtlF"(i8*, i64, %swift.opaque* noalias nocapture, %swift.type* %T)
+// CHECK-NOT: loop:
+// CHECK: call void @swift_arrayDestroy
+func destroyGenArray<T>(_ array: Builtin.RawPointer, count: Builtin.Word, _: T) {
+ Builtin.destroyArray(T.self, array, count)
+}
+
+
+// CHECK-LABEL: define hidden {{.*}}void @"$S8builtins12copyPODArray{{[_0-9a-zA-Z]*}}F"(i8*, i8*, i64)
+// check: mul nuw i64 4, %2
+// check: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 {{.*}}, i32 4, i1 false)
+// check: mul nuw i64 4, %2
+// check: call void @llvm.memmove.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 {{.*}}, i32 4, i1 false)
+// check: mul nuw i64 4, %2
+// check: call void @llvm.memmove.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 {{.*}}, i32 4, i1 false)
+// check: mul nuw i64 4, %2
+// check: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 {{.*}}, i32 4, i1 false)
+// check: mul nuw i64 4, %2
+// check: call void @llvm.memmove.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 {{.*}}, i32 4, i1 false)
+// check: mul nuw i64 4, %2
+// check: call void @llvm.memmove.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 {{.*}}, i32 4, i1 false)
+// check: mul nuw i64 4, %2
+// check: call void @llvm.memcpy.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 {{.*}}, i32 4, i1 false)
+func copyPODArray(_ dest: Builtin.RawPointer, src: Builtin.RawPointer, count: Builtin.Word) {
+ Builtin.copyArray(Int.self, dest, src, count)
+ Builtin.takeArrayFrontToBack(Int.self, dest, src, count)
+ Builtin.takeArrayBackToFront(Int.self, dest, src, count)
+ Builtin.assignCopyArrayNoAlias(Int.self, dest, src, count)
+ Builtin.assignCopyArrayFrontToBack(Int.self, dest, src, count)
+ Builtin.assignCopyArrayBackToFront(Int.self, dest, src, count)
+ Builtin.assignTakeArray(Int.self, dest, src, count)
+}
+
+
+// CHECK-LABEL: define hidden {{.*}}void @"$S8builtins11copyBTArray{{[_0-9a-zA-Z]*}}F"(i8*, i8*, i64) {{.*}} {
+// CHECK-NOT: loop:
+// CHECK: call void @swift_arrayInitWithCopy
+// CHECK: mul nuw i64 8, %2
+// CHECK: call void @llvm.memmove.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 {{.*}}, i32 8, i1 false)
+// CHECK: mul nuw i64 8, %2
+// CHECK: call void @llvm.memmove.p0i8.p0i8.i64(i8* {{.*}}, i8* {{.*}}, i64 {{.*}}, i32 8, i1 false)
+// CHECK: call void @swift_arrayAssignWithCopyNoAlias(
+// CHECK: call void @swift_arrayAssignWithCopyFrontToBack(
+// CHECK: call void @swift_arrayAssignWithCopyBackToFront(
+// CHECK: call void @swift_arrayAssignWithTake(
+func copyBTArray(_ dest: Builtin.RawPointer, src: Builtin.RawPointer, count: Builtin.Word) {
+ Builtin.copyArray(C.self, dest, src, count)
+ Builtin.takeArrayFrontToBack(C.self, dest, src, count)
+ Builtin.takeArrayBackToFront(C.self, dest, src, count)
+ Builtin.assignCopyArrayNoAlias(C.self, dest, src, count)
+ Builtin.assignCopyArrayFrontToBack(C.self, dest, src, count)
+ Builtin.assignCopyArrayBackToFront(C.self, dest, src, count)
+ Builtin.assignTakeArray(C.self, dest, src, count)
+}
+
+struct W { weak var c: C? }
+
+// CHECK-LABEL: define hidden {{.*}}void @"$S8builtins15copyNonPODArray{{[_0-9a-zA-Z]*}}F"(i8*, i8*, i64) {{.*}} {
+// CHECK-NOT: loop:
+// CHECK: call void @swift_arrayInitWithCopy(
+// CHECK-NOT: loop{{.*}}:
+// CHECK: call void @swift_arrayInitWithTakeFrontToBack(
+// CHECK-NOT: loop{{.*}}:
+// CHECK: call void @swift_arrayInitWithTakeBackToFront(
+// CHECK: call void @swift_arrayAssignWithCopyNoAlias(
+// CHECK: call void @swift_arrayAssignWithCopyFrontToBack(
+// CHECK: call void @swift_arrayAssignWithCopyBackToFront(
+// CHECK: call void @swift_arrayAssignWithTake(
+func copyNonPODArray(_ dest: Builtin.RawPointer, src: Builtin.RawPointer, count: Builtin.Word) {
+ Builtin.copyArray(W.self, dest, src, count)
+ Builtin.takeArrayFrontToBack(W.self, dest, src, count)
+ Builtin.takeArrayBackToFront(W.self, dest, src, count)
+ Builtin.assignCopyArrayNoAlias(W.self, dest, src, count)
+ Builtin.assignCopyArrayFrontToBack(W.self, dest, src, count)
+ Builtin.assignCopyArrayBackToFront(W.self, dest, src, count)
+ Builtin.assignTakeArray(W.self, dest, src, count)
+}
+
+// CHECK-LABEL: define hidden {{.*}}void @"$S8builtins12copyGenArray{{[_0-9a-zA-Z]*}}F"(i8*, i8*, i64, %swift.opaque* noalias nocapture, %swift.type* %T)
+// CHECK-NOT: loop:
+// CHECK: call void @swift_arrayInitWithCopy
+// CHECK-NOT: loop:
+// CHECK: call void @swift_arrayInitWithTakeFrontToBack(
+// CHECK-NOT: loop:
+// CHECK: call void @swift_arrayInitWithTakeBackToFront(
+// CHECK: call void @swift_arrayAssignWithCopyNoAlias(
+// CHECK: call void @swift_arrayAssignWithCopyFrontToBack(
+// CHECK: call void @swift_arrayAssignWithCopyBackToFront(
+// CHECK: call void @swift_arrayAssignWithTake(
+func copyGenArray<T>(_ dest: Builtin.RawPointer, src: Builtin.RawPointer, count: Builtin.Word, _: T) {
+ Builtin.copyArray(T.self, dest, src, count)
+ Builtin.takeArrayFrontToBack(T.self, dest, src, count)
+ Builtin.takeArrayBackToFront(T.self, dest, src, count)
+ Builtin.assignCopyArrayNoAlias(T.self, dest, src, count)
+ Builtin.assignCopyArrayFrontToBack(T.self, dest, src, count)
+ Builtin.assignCopyArrayBackToFront(T.self, dest, src, count)
+ Builtin.assignTakeArray(T.self, dest, src, count)
+}
+
+// CHECK-LABEL: define hidden {{.*}}void @"$S8builtins24conditionallyUnreachableyyF"
+// CHECK-NEXT: entry
+// CHECK-NEXT: unreachable
+func conditionallyUnreachable() {
+ Builtin.conditionallyUnreachable()
+}
+
+struct Abc {
+ var value : Builtin.Word
+}
+
+// CHECK-LABEL: define hidden {{.*}}@"$S8builtins22assumeNonNegative_testyBwAA3AbcVzF"
+func assumeNonNegative_test(_ x: inout Abc) -> Builtin.Word {
+ // CHECK: load {{.*}}, !range ![[R:[0-9]+]]
+ return Builtin.assumeNonNegative_Word(x.value)
+}
+
+@inline(never)
+func return_word(_ x: Builtin.Word) -> Builtin.Word {
+ return x
+}
+
+// CHECK-LABEL: define hidden {{.*}}@"$S8builtins23assumeNonNegative_test2yBwBwF"
+func assumeNonNegative_test2(_ x: Builtin.Word) -> Builtin.Word {
+ // CHECK: call {{.*}}, !range ![[R]]
+ return Builtin.assumeNonNegative_Word(return_word(x))
+}
+
+struct Empty {}
+struct Pair { var i: Int, b: Bool }
+
+// CHECK-LABEL: define hidden {{.*}}i64 @"$S8builtins15zeroInitializerAA5EmptyV_AA4PairVtyF"() {{.*}} {
+// CHECK: [[ALLOCA:%.*]] = alloca { i64 }
+// CHECK: bitcast
+// CHECK: lifetime.start
+// CHECK: [[EMPTYPAIR:%.*]] = bitcast { i64 }* [[ALLOCA]]
+// CHECK: [[PAIR:%.*]] = getelementptr inbounds {{.*}} [[EMPTYPAIR]], i32 0, i32 0
+// CHECK: [[FLDI:%.*]] = getelementptr inbounds {{.*}} [[PAIR]], i32 0, i32 0
+// CHECK: store i32 0, i32* [[FLDI]]
+// CHECK: [[FLDB:%.*]] = getelementptr inbounds {{.*}} [[PAIR]], i32 0, i32 1
+// CHECK: store i1 false, i1* [[FLDB]]
+// CHECK: [[RET:%.*]] = getelementptr inbounds {{.*}} [[ALLOCA]], i32 0, i32 0
+// CHECK: [[RES:%.*]] = load i64, i64* [[RET]]
+// CHECK: ret i64 [[RES]]
+func zeroInitializer() -> (Empty, Pair) {
+ return (Builtin.zeroInitializer(), Builtin.zeroInitializer())
+}
+
+// CHECK-LABEL: define hidden {{.*}}i64 @"$S8builtins20zeroInitializerTupleAA5EmptyV_AA4PairVtyF"() {{.*}} {
+// CHECK: [[ALLOCA:%.*]] = alloca { i64 }
+// CHECK: bitcast
+// CHECK: lifetime.start
+// CHECK: [[EMPTYPAIR:%.*]] = bitcast { i64 }* [[ALLOCA]]
+// CHECK: [[PAIR:%.*]] = getelementptr inbounds {{.*}} [[EMPTYPAIR]], i32 0, i32 0
+// CHECK: [[FLDI:%.*]] = getelementptr inbounds {{.*}} [[PAIR]], i32 0, i32 0
+// CHECK: store i32 0, i32* [[FLDI]]
+// CHECK: [[FLDB:%.*]] = getelementptr inbounds {{.*}} [[PAIR]], i32 0, i32 1
+// CHECK: store i1 false, i1* [[FLDB]]
+// CHECK: [[RET:%.*]] = getelementptr inbounds {{.*}} [[ALLOCA]], i32 0, i32 0
+// CHECK: [[RES:%.*]] = load i64, i64* [[RET]]
+// CHECK: ret i64 [[RES]]
+func zeroInitializerTuple() -> (Empty, Pair) {
+ return Builtin.zeroInitializer()
+}
+
+// CHECK-LABEL: define hidden {{.*}}void @"$S8builtins20zeroInitializerEmptyyyF"() {{.*}} {
+// CHECK: ret void
+func zeroInitializerEmpty() {
+ return Builtin.zeroInitializer()
+}
+
+// ----------------------------------------------------------------------------
+// isUnique variants
+// ----------------------------------------------------------------------------
+
+// CHECK: define hidden {{.*}}void @"$S8builtins26acceptsBuiltinNativeObjectyyBoSgzF"([[BUILTIN_NATIVE_OBJECT_TY:%.*]]* nocapture dereferenceable({{.*}})) {{.*}} {
+func acceptsBuiltinNativeObject(_ ref: inout Builtin.NativeObject?) {}
+
+// native
+// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins8isUniqueyBi1_BoSgzF"({{%.*}}* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-NEXT: entry:
+// CHECK-NEXT: bitcast [[BUILTIN_NATIVE_OBJECT_TY]]* %0 to %swift.refcounted**
+// CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %1
+// CHECK-NEXT: call i1 @swift_isUniquelyReferenced_native(%swift.refcounted* %2)
+// CHECK-NEXT: ret i1 %3
+func isUnique(_ ref: inout Builtin.NativeObject?) -> Bool {
+ return Builtin.isUnique(&ref)
+}
+
+// native nonNull
+// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins8isUniqueyBi1_BozF"(%swift.refcounted** nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-NEXT: entry:
+// CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %0
+// CHECK-NEXT: call i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %1)
+// CHECK-NEXT: ret i1 %2
+func isUnique(_ ref: inout Builtin.NativeObject) -> Bool {
+ return Builtin.isUnique(&ref)
+}
+
+// native pinned
+// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins16isUniqueOrPinnedyBi1_BoSgzF"({{%.*}}* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-NEXT: entry:
+// CHECK-NEXT: bitcast [[BUILTIN_NATIVE_OBJECT_TY]]* %0 to %swift.refcounted**
+// CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %1
+// CHECK-NEXT: call i1 @swift_isUniquelyReferencedOrPinned_native(%swift.refcounted* %2)
+// CHECK-NEXT: ret i1 %3
+func isUniqueOrPinned(_ ref: inout Builtin.NativeObject?) -> Bool {
+ return Builtin.isUniqueOrPinned(&ref)
+}
+
+// native pinned nonNull
+// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins16isUniqueOrPinnedyBi1_BozF"(%swift.refcounted** nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-NEXT: entry:
+// CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %0
+// CHECK-NEXT: call i1 @swift_isUniquelyReferencedOrPinned_nonNull_native(%swift.refcounted* %1)
+// CHECK-NEXT: ret i1 %2
+func isUniqueOrPinned(_ ref: inout Builtin.NativeObject) -> Bool {
+ return Builtin.isUniqueOrPinned(&ref)
+}
+
+// CHECK: define hidden {{.*}}void @"$S8builtins27acceptsBuiltinUnknownObjectyyBOSgzF"([[BUILTIN_UNKNOWN_OBJECT_TY:%.*]]* nocapture dereferenceable({{.*}})) {{.*}} {
+func acceptsBuiltinUnknownObject(_ ref: inout Builtin.UnknownObject?) {}
+
+// ObjC
+// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins8isUniqueyBi1_BOSgzF"({{%.*}}* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-NEXT: entry:
+// CHECK-NEXT: bitcast [[BUILTIN_UNKNOWN_OBJECT_TY]]* %0 to [[UNKNOWN_OBJECT:%objc_object|%swift\.refcounted]]**
+// CHECK-NEXT: load [[UNKNOWN_OBJECT]]*, [[UNKNOWN_OBJECT]]** %1
+// CHECK-objc-NEXT: call i1 @swift_isUniquelyReferencedNonObjC([[UNKNOWN_OBJECT]]* %2)
+// CHECK-native-NEXT: call i1 @swift_isUniquelyReferenced_native([[UNKNOWN_OBJECT]]* %2)
+// CHECK-NEXT: ret i1 %3
+func isUnique(_ ref: inout Builtin.UnknownObject?) -> Bool {
+ return Builtin.isUnique(&ref)
+}
+
+// ObjC nonNull
+// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins8isUniqueyBi1_BOzF"
+// CHECK-SAME: ([[UNKNOWN_OBJECT]]** nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-NEXT: entry:
+// CHECK-NEXT: load [[UNKNOWN_OBJECT]]*, [[UNKNOWN_OBJECT]]** %0
+// CHECK-objc-NEXT: call i1 @swift_isUniquelyReferencedNonObjC_nonNull([[UNKNOWN_OBJECT]]* %1)
+// CHECK-native-NEXT: call i1 @swift_isUniquelyReferenced_nonNull_native([[UNKNOWN_OBJECT]]* %1)
+// CHECK-NEXT: ret i1 %2
+func isUnique(_ ref: inout Builtin.UnknownObject) -> Bool {
+ return Builtin.isUnique(&ref)
+}
+
+// ObjC pinned nonNull
+// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins16isUniqueOrPinnedyBi1_BOzF"
+// CHECK-SAME: ([[UNKNOWN_OBJECT]]** nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-NEXT: entry:
+// CHECK-NEXT: load [[UNKNOWN_OBJECT]]*, [[UNKNOWN_OBJECT]]** %0
+// CHECK-native-NEXT: call i1 @swift_isUniquelyReferencedOrPinned_nonNull_native([[UNKNOWN_OBJECT]]* %1)
+// CHECK-objc-NEXT: call i1 @swift_isUniquelyReferencedOrPinnedNonObjC_nonNull([[UNKNOWN_OBJECT]]* %1)
+// CHECK-NEXT: ret i1 %2
+func isUniqueOrPinned(_ ref: inout Builtin.UnknownObject) -> Bool {
+ return Builtin.isUniqueOrPinned(&ref)
+}
+
+// BridgeObject nonNull
+// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins8isUniqueyBi1_BbzF"(%swift.bridge** nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-NEXT: entry:
+// CHECK-NEXT: load %swift.bridge*, %swift.bridge** %0
+// CHECK-NEXT: call i1 @swift_isUniquelyReferencedNonObjC_nonNull_bridgeObject(%swift.bridge* %1)
+// CHECK-NEXT: ret i1 %2
+func isUnique(_ ref: inout Builtin.BridgeObject) -> Bool {
+ return Builtin.isUnique(&ref)
+}
+
+// Bridge pinned nonNull
+// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins16isUniqueOrPinnedyBi1_BbzF"(%swift.bridge** nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-NEXT: entry:
+// CHECK-NEXT: load %swift.bridge*, %swift.bridge** %0
+// CHECK-NEXT: call i1 @swift_isUniquelyReferencedOrPinnedNonObjC_nonNull_bridgeObject(%swift.bridge* %1)
+// CHECK-NEXT: ret i1 %2
+func isUniqueOrPinned(_ ref: inout Builtin.BridgeObject) -> Bool {
+ return Builtin.isUniqueOrPinned(&ref)
+}
+
+// BridgeObject nonNull
+// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins15isUnique_nativeyBi1_BbzF"(%swift.bridge** nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-NEXT: entry:
+// CHECK-NEXT: bitcast %swift.bridge** %0 to %swift.refcounted**
+// CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %1
+// CHECK-NEXT: call i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %2)
+// CHECK-NEXT: ret i1 %3
+func isUnique_native(_ ref: inout Builtin.BridgeObject) -> Bool {
+ return Builtin.isUnique_native(&ref)
+}
+
+// Bridge pinned nonNull
+// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins23isUniqueOrPinned_nativeyBi1_BbzF"(%swift.bridge** nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-NEXT: entry:
+// CHECK-NEXT: bitcast %swift.bridge** %0 to %swift.refcounted**
+// CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %1
+// CHECK-NEXT: call i1 @swift_isUniquelyReferencedOrPinned_nonNull_native(%swift.refcounted* %2)
+// CHECK-NEXT: ret i1 %3
+func isUniqueOrPinned_native(_ ref: inout Builtin.BridgeObject) -> Bool {
+ return Builtin.isUniqueOrPinned_native(&ref)
+}
+
+// ImplicitlyUnwrappedOptional argument to isUnique.
+// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins11isUniqueIUOyBi1_BoSgzF"(%{{.*}}* nocapture dereferenceable({{.*}})) {{.*}} {
+// CHECK-NEXT: entry:
+// CHECK: call i1 @swift_isUniquelyReferenced_native(%swift.refcounted*
+// CHECK: ret i1
+func isUniqueIUO(_ ref: inout Builtin.NativeObject?) -> Bool {
+ var iuo : Builtin.NativeObject! = ref
+ return Builtin.isUnique(&iuo)
+}
+
+// CHECK-LABEL: define {{.*}} @{{.*}}generic_ispod_test
+func generic_ispod_test<T>(_: T) {
+ // CHECK: [[T0:%.*]] = getelementptr inbounds i8*, i8** [[T:%.*]], i32 10
+ // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[T0]]
+ // CHECK-NEXT: [[FLAGS:%.*]] = ptrtoint i8* [[T1]] to i64
+ // CHECK-NEXT: [[ISNOTPOD:%.*]] = and i64 [[FLAGS]], 65536
+ // CHECK-NEXT: [[ISPOD:%.*]] = icmp eq i64 [[ISNOTPOD]], 0
+ // CHECK-NEXT: store i1 [[ISPOD]], i1* [[S:%.*]]
+ var s = Builtin.ispod(T.self)
+}
+
+// CHECK-LABEL: define {{.*}} @{{.*}}ispod_test
+func ispod_test() {
+ // CHECK: store i1 true, i1*
+ // CHECK: store i1 false, i1*
+ var t = Builtin.ispod(Int.self)
+ var f = Builtin.ispod(Builtin.NativeObject)
+}
+
+// CHECK-LABEL: define {{.*}} @{{.*}}is_same_metatype
+func is_same_metatype_test(_ t1: Any.Type, _ t2: Any.Type) {
+ // CHECK: [[MT1_AS_PTR:%.*]] = bitcast %swift.type* %0 to i8*
+ // CHECK: [[MT2_AS_PTR:%.*]] = bitcast %swift.type* %1 to i8*
+ // CHECK: icmp eq i8* [[MT1_AS_PTR]], [[MT2_AS_PTR]]
+ var t = Builtin.is_same_metatype(t1, t2)
+}
+
+// CHECK-LABEL: define {{.*}} @{{.*}}generic_unsafeGuaranteed_test
+// CHECK: call {{.*}}* @{{.*}}swift_{{.*}}etain({{.*}}* returned %0)
+// CHECK: call void @{{.*}}swift_{{.*}}elease({{.*}}* %0)
+// CHECK: ret {{.*}}* %0
+func generic_unsafeGuaranteed_test<T: AnyObject>(_ t : T) -> T {
+ let (g, _) = Builtin.unsafeGuaranteed(t)
+ return g
+}
+
+// CHECK-LABEL: define {{.*}} @{{.*}}unsafeGuaranteed_test
+// CHECK: [[LOCAL:%.*]] = alloca %swift.refcounted*
+// CHECK: call %swift.refcounted* @swift_retain(%swift.refcounted* returned %0)
+// CHECK: store %swift.refcounted* %0, %swift.refcounted** [[LOCAL]]
+// CHECK: call void @swift_release(%swift.refcounted* %0)
+// CHECK: ret %swift.refcounted* %0
+func unsafeGuaranteed_test(_ x: Builtin.NativeObject) -> Builtin.NativeObject {
+ var (g,t) = Builtin.unsafeGuaranteed(x)
+ Builtin.unsafeGuaranteedEnd(t)
+ return g
+}
+
+// CHECK-LABEL: define {{.*}} @{{.*}}unsafeGuaranteedEnd_test
+// CHECK-NEXT: {{.*}}:
+// CHECK-NEXT: ret void
+func unsafeGuaranteedEnd_test(_ x: Builtin.Int8) {
+ Builtin.unsafeGuaranteedEnd(x)
+}
+
+// CHECK-LABEL: define {{.*}} @{{.*}}atomicload
+func atomicload(_ p: Builtin.RawPointer) {
+ // CHECK: [[A:%.*]] = load atomic i8*, i8** {{%.*}} unordered, align 8
+ let a: Builtin.RawPointer = Builtin.atomicload_unordered_RawPointer(p)
+ // CHECK: [[B:%.*]] = load atomic i32, i32* {{%.*}} syncscope("singlethread") monotonic, align 4
+ let b: Builtin.Int32 = Builtin.atomicload_monotonic_singlethread_Int32(p)
+ // CHECK: [[C:%.*]] = load atomic volatile i64, i64* {{%.*}} syncscope("singlethread") acquire, align 8
+ let c: Builtin.Int64 =
+ Builtin.atomicload_acquire_volatile_singlethread_Int64(p)
+ // CHECK: [[D0:%.*]] = load atomic volatile i32, i32* {{%.*}} seq_cst, align 4
+ // CHECK: [[D:%.*]] = bitcast i32 [[D0]] to float
+ let d: Builtin.FPIEEE32 = Builtin.atomicload_seqcst_volatile_FPIEEE32(p)
+
+ // CHECK: store atomic i8* [[A]], i8** {{%.*}} unordered, align 8
+ Builtin.atomicstore_unordered_RawPointer(p, a)
+ // CHECK: store atomic i32 [[B]], i32* {{%.*}} syncscope("singlethread") monotonic, align 4
+ Builtin.atomicstore_monotonic_singlethread_Int32(p, b)
+ // CHECK: store atomic volatile i64 [[C]], i64* {{%.*}} syncscope("singlethread") release, align 8
+ Builtin.atomicstore_release_volatile_singlethread_Int64(p, c)
+ // CHECK: [[D1:%.*]] = bitcast float [[D]] to i32
+ // CHECK: store atomic volatile i32 [[D1]], i32* {{.*}} seq_cst, align 4
+ Builtin.atomicstore_seqcst_volatile_FPIEEE32(p, d)
+}
+
+// CHECK-LABEL: define {{.*}} @"$S8builtins14stringObjectOryS2u_SutF"(i64, i64)
+// CHECK-NEXT: {{.*}}:
+// CHECK-NEXT: %2 = or i64 %0, %1
+// CHECK-NEXT: ret i64 %2
+func stringObjectOr(_ x: UInt, _ y: UInt) -> UInt {
+ return UInt(Builtin.stringObjectOr_Int64(
+ x._value, y._value))
+}
+
+func createInt(_ fn: () -> ()) throws {}
+// CHECK-LABEL: define {{.*}}testForceTry
+// CHECK: call swiftcc void @swift_unexpectedError(%swift.error*
+func testForceTry(_ fn: () -> ()) {
+ try! createInt(fn)
+}
+
+// CHECK-LABEL: declare swiftcc void @swift_unexpectedError(%swift.error*
+
+enum MyError : Error {
+ case A, B
+}
+
+throw MyError.A
+
+
+
+// CHECK: ![[R]] = !{i64 0, i64 9223372036854775807}
+
diff --git a/test/IRGen/plus_zero_class_bounded_generics.swift b/test/IRGen/plus_zero_class_bounded_generics.swift
new file mode 100644
index 0000000..304f545
--- /dev/null
+++ b/test/IRGen/plus_zero_class_bounded_generics.swift
@@ -0,0 +1,312 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-ir -primary-file %s -disable-objc-attr-requires-foundation-module | %FileCheck %s
+
+// REQUIRES: CPU=x86_64
+// XFAIL: linux
+
+protocol ClassBound : class {
+ func classBoundMethod()
+}
+protocol ClassBound2 : class {
+ func classBoundMethod2()
+}
+protocol ClassBoundBinary : ClassBound {
+ func classBoundBinaryMethod(_ x: Self)
+}
+@objc protocol ObjCClassBound {
+ func objCClassBoundMethod()
+}
+@objc protocol ObjCClassBound2 {
+ func objCClassBoundMethod2()
+}
+protocol NotClassBound {
+ func notClassBoundMethod()
+ func notClassBoundBinaryMethod(_ x: Self)
+}
+
+struct ClassGenericFieldStruct<T:ClassBound> {
+ var x : Int
+ var y : T
+ var z : Int
+}
+
+struct ClassProtocolFieldStruct {
+ var x : Int
+ var y : ClassBound
+ var z : Int
+}
+
+class ClassGenericFieldClass<T:ClassBound> {
+ final var x : Int = 0
+ final var y : T
+ final var z : Int = 0
+
+ init(t: T) {
+ y = t
+ }
+}
+
+class ClassProtocolFieldClass {
+ var x : Int = 0
+ var y : ClassBound
+ var z : Int = 0
+
+ init(classBound cb: ClassBound) {
+ y = cb
+ }
+}
+
+// CHECK-DAG: %T22class_bounded_generics017ClassGenericFieldD0C = type <{ %swift.refcounted, %TSi, %objc_object*, %TSi }>
+// CHECK-DAG: %T22class_bounded_generics23ClassGenericFieldStructV = type <{ %TSi, %objc_object*, %TSi }>
+// CHECK-DAG: %T22class_bounded_generics24ClassProtocolFieldStructV = type <{ %TSi, %T22class_bounded_generics10ClassBoundP, %TSi }>
+
+// CHECK-LABEL: define hidden swiftcc %objc_object* @"$S22class_bounded_generics0a1_B10_archetype{{[_0-9a-zA-Z]*}}F"(%objc_object*, %swift.type* %T, i8** %T.ClassBound)
+func class_bounded_archetype<T : ClassBound>(_ x: T) -> T {
+ return x
+}
+
+class SomeClass {}
+class SomeSubclass : SomeClass {}
+
+// CHECK-LABEL: define hidden swiftcc %T22class_bounded_generics9SomeClassC* @"$S22class_bounded_generics011superclass_B10_archetype{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics9SomeClassC*, %swift.type* %T)
+func superclass_bounded_archetype<T : SomeClass>(_ x: T) -> T {
+ return x
+}
+
+// CHECK-LABEL: define hidden swiftcc { %T22class_bounded_generics9SomeClassC*, %T22class_bounded_generics12SomeSubclassC* } @"$S22class_bounded_generics011superclass_B15_archetype_call{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics9SomeClassC*, %T22class_bounded_generics12SomeSubclassC*)
+func superclass_bounded_archetype_call(_ x: SomeClass, y: SomeSubclass) -> (SomeClass, SomeSubclass) {
+ return (superclass_bounded_archetype(x),
+ superclass_bounded_archetype(y));
+ // CHECK: [[SOMECLASS_RESULT:%.*]] = call swiftcc %T22class_bounded_generics9SomeClassC* @"$S22class_bounded_generics011superclass_B10_archetype{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics9SomeClassC* {{%.*}}, {{.*}})
+ // CHECK: [[SOMESUPERCLASS_IN:%.*]] = bitcast %T22class_bounded_generics12SomeSubclassC* {{%.*}} to %T22class_bounded_generics9SomeClassC*
+ // CHECK: [[SOMESUPERCLASS_RESULT:%.*]] = call swiftcc %T22class_bounded_generics9SomeClassC* @"$S22class_bounded_generics011superclass_B10_archetype{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics9SomeClassC* [[SOMESUPERCLASS_IN]], {{.*}})
+ // CHECK: bitcast %T22class_bounded_generics9SomeClassC* [[SOMESUPERCLASS_RESULT]] to %T22class_bounded_generics12SomeSubclassC*
+}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S22class_bounded_generics0a1_B17_archetype_method{{[_0-9a-zA-Z]*}}F"(%objc_object*, %objc_object*, %swift.type* %T, i8** %T.ClassBoundBinary)
+func class_bounded_archetype_method<T : ClassBoundBinary>(_ x: T, y: T) {
+ x.classBoundMethod()
+ // CHECK: [[INHERITED_GEP:%.*]] = getelementptr inbounds i8*, i8** %T.ClassBoundBinary, i32 1
+ // CHECK: [[INHERITED:%.*]] = load i8*, i8** [[INHERITED_GEP]]
+ // CHECK: [[INHERITED_WTBL:%.*]] = bitcast i8* [[INHERITED]] to i8**
+ // CHECK: [[WITNESS_GEP:%.*]] = getelementptr inbounds i8*, i8** [[INHERITED_WTBL]], i32 1
+ // CHECK: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_GEP]], align 8
+ // CHECK: [[WITNESS_FUNC:%.*]] = bitcast i8* [[WITNESS]] to void (%objc_object*, %swift.type*, i8**)
+ // CHECK: call swiftcc void [[WITNESS_FUNC]](%objc_object* swiftself %0, %swift.type* {{.*}}, i8** [[INHERITED_WTBL]])
+ x.classBoundBinaryMethod(y)
+ // CHECK-NOT: call %objc_object* @swift_unknownRetain(%objc_object* returned [[Y:%.*]])
+ // CHECK: [[WITNESS_ENTRY:%.*]] = getelementptr inbounds i8*, i8** %T.ClassBoundBinary, i32 2
+ // CHECK: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ENTRY]], align 8
+ // CHECK: [[WITNESS_FUNC:%.*]] = bitcast i8* [[WITNESS]] to void (%objc_object*, %objc_object*, %swift.type*, i8**)
+ // CHECK: call swiftcc void [[WITNESS_FUNC]](%objc_object* %1, %objc_object* swiftself %0, %swift.type* %T, i8** %T.ClassBoundBinary)
+}
+
+// CHECK-LABEL: define hidden swiftcc { %objc_object*, %objc_object* } @"$S22class_bounded_generics0a1_B16_archetype_tuple{{[_0-9a-zA-Z]*}}F"(%objc_object*, %swift.type* %T, i8** %T.ClassBound)
+func class_bounded_archetype_tuple<T : ClassBound>(_ x: T) -> (T, T) {
+ return (x, x)
+}
+
+class ConcreteClass : ClassBoundBinary, NotClassBound {
+ func classBoundMethod() {}
+ func classBoundBinaryMethod(_ x: ConcreteClass) {}
+ func notClassBoundMethod() {}
+ func notClassBoundBinaryMethod(_ x: ConcreteClass) {}
+}
+
+// CHECK-LABEL: define hidden swiftcc %T22class_bounded_generics13ConcreteClassC* @"$S22class_bounded_generics05call_a1_B10_archetype{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics13ConcreteClassC*) {{.*}} {
+func call_class_bounded_archetype(_ x: ConcreteClass) -> ConcreteClass {
+ return class_bounded_archetype(x)
+ // CHECK: [[IN:%.*]] = bitcast %T22class_bounded_generics13ConcreteClassC* {{%.*}} to %objc_object*
+ // CHECK: [[OUT_ORIG:%.*]] = call swiftcc %objc_object* @"$S22class_bounded_generics0a1_B10_archetype{{[_0-9a-zA-Z]*}}F"(%objc_object* [[IN]], {{.*}})
+ // CHECK: [[OUT:%.*]] = bitcast %objc_object* [[OUT_ORIG]] to %T22class_bounded_generics13ConcreteClassC*
+ // CHECK: ret %T22class_bounded_generics13ConcreteClassC* [[OUT]]
+}
+
+// CHECK: define hidden swiftcc void @"$S22class_bounded_generics04not_a1_B10_archetype{{[_0-9a-zA-Z]*}}F"(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.NotClassBound)
+func not_class_bounded_archetype<T : NotClassBound>(_ x: T) -> T {
+ return x
+}
+
+// CHECK-LABEL: define hidden swiftcc %objc_object* @"$S22class_bounded_generics0a1_b18_archetype_to_not_a1_B0{{[_0-9a-zA-Z]*}}F"(%objc_object*, %swift.type* %T, i8** %T.ClassBound, i8** %T.NotClassBound) {{.*}} {
+func class_bounded_archetype_to_not_class_bounded
+<T: ClassBound & NotClassBound>(_ x:T) -> T {
+ // CHECK: alloca %objc_object*, align 8
+ return not_class_bounded_archetype(x)
+}
+
+/* TODO Abstraction remapping to non-class-bounded witnesses
+func class_and_not_class_bounded_archetype_methods
+<T: ClassBound & NotClassBound>(_ x:T, y:T) {
+ x.classBoundMethod()
+ x.classBoundBinaryMethod(y)
+ x.notClassBoundMethod()
+ x.notClassBoundBinaryMethod(y)
+}
+*/
+
+// CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @"$S22class_bounded_generics0a1_B8_erasure{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics13ConcreteClassC*) {{.*}} {
+func class_bounded_erasure(_ x: ConcreteClass) -> ClassBound {
+ return x
+ // CHECK: [[INSTANCE_OPAQUE:%.*]] = bitcast %T22class_bounded_generics13ConcreteClassC* [[INSTANCE:%.*]] to %objc_object*
+ // CHECK: [[T0:%.*]] = insertvalue { %objc_object*, i8** } undef, %objc_object* [[INSTANCE_OPAQUE]], 0
+ // CHECK: [[T1:%.*]] = insertvalue { %objc_object*, i8** } [[T0]], i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* @"$S22class_bounded_generics13ConcreteClassCAA0E5BoundAAWP", i32 0, i32 0), 1
+ // CHECK: ret { %objc_object*, i8** } [[T1]]
+}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S22class_bounded_generics0a1_B16_protocol_method{{[_0-9a-zA-Z]*}}F"(%objc_object*, i8**) {{.*}} {
+func class_bounded_protocol_method(_ x: ClassBound) {
+ x.classBoundMethod()
+ // CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getObjectType(%objc_object* %0)
+ // CHECK: [[WITNESS_GEP:%.*]] = getelementptr inbounds i8*, i8** [[WITNESS_TABLE:%.*]], i32 1
+ // CHECK: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_GEP]], align 8
+ // CHECK: [[WITNESS_FN:%.*]] = bitcast i8* [[WITNESS]] to void (%objc_object*, %swift.type*, i8**)
+ // CHECK: call swiftcc void [[WITNESS_FN]](%objc_object* swiftself %0, %swift.type* [[METADATA]], i8** [[WITNESS_TABLE]])
+}
+
+// CHECK-LABEL: define hidden swiftcc %T22class_bounded_generics13ConcreteClassC* @"$S22class_bounded_generics0a1_B15_archetype_cast{{[_0-9a-zA-Z]*}}F"(%objc_object*, %swift.type* %T, i8** %T.ClassBound)
+func class_bounded_archetype_cast<T : ClassBound>(_ x: T) -> ConcreteClass {
+ return x as! ConcreteClass
+ // CHECK: [[IN_PTR:%.*]] = bitcast %objc_object* {{%.*}} to i8*
+ // CHECK: [[T0:%.*]] = call %swift.type* @"$S22class_bounded_generics13ConcreteClassCMa"()
+ // CHECK: [[T1:%.*]] = bitcast %swift.type* [[T0]] to i8*
+ // CHECK: [[OUT_PTR:%.*]] = call i8* @swift_dynamicCastClassUnconditional(i8* [[IN_PTR]], i8* [[T1]])
+ // CHECK: [[OUT:%.*]] = bitcast i8* [[OUT_PTR]] to %T22class_bounded_generics13ConcreteClassC*
+ // CHECK: ret %T22class_bounded_generics13ConcreteClassC* [[OUT]]
+}
+
+// CHECK-LABEL: define hidden swiftcc %T22class_bounded_generics13ConcreteClassC* @"$S22class_bounded_generics0a1_B14_protocol_cast{{[_0-9a-zA-Z]*}}F"(%objc_object*, i8**)
+func class_bounded_protocol_cast(_ x: ClassBound) -> ConcreteClass {
+ return x as! ConcreteClass
+ // CHECK: [[IN_PTR:%.*]] = bitcast %objc_object* {{%.*}} to i8*
+ // CHECK: [[T0:%.*]] = call %swift.type* @"$S22class_bounded_generics13ConcreteClassCMa"()
+ // CHECK: [[T1:%.*]] = bitcast %swift.type* [[T0]] to i8*
+ // CHECK: [[OUT_PTR:%.*]] = call i8* @swift_dynamicCastClassUnconditional(i8* [[IN_PTR]], i8* [[T1]])
+ // CHECK: [[OUT:%.*]] = bitcast i8* [[OUT_PTR]] to %T22class_bounded_generics13ConcreteClassC*
+ // CHECK: ret %T22class_bounded_generics13ConcreteClassC* [[OUT]]
+}
+
+// CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @"$S22class_bounded_generics0a1_B22_protocol_conversion_{{.*}}"(%objc_object*, i8**, i8**) {{.*}} {
+func class_bounded_protocol_conversion_1(_ x: ClassBound & ClassBound2)
+-> ClassBound {
+ return x
+}
+// CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @"$S22class_bounded_generics0a1_B22_protocol_conversion_{{.*}}"(%objc_object*, i8**, i8**) {{.*}} {
+func class_bounded_protocol_conversion_2(_ x: ClassBound & ClassBound2)
+-> ClassBound2 {
+ return x
+}
+
+// CHECK-LABEL: define hidden swiftcc { %objc_object*, i8** } @"$S22class_bounded_generics05objc_a1_B22_protocol_conversion_{{.*}}"(%objc_object*, i8**) {{.*}} {
+func objc_class_bounded_protocol_conversion_1
+(_ x: ClassBound & ObjCClassBound) -> ClassBound {
+ return x
+}
+// CHECK-LABEL: define hidden swiftcc %objc_object* @"$S22class_bounded_generics05objc_a1_B22_protocol_conversion_{{.*}}"(%objc_object*, i8**) {{.*}} {
+func objc_class_bounded_protocol_conversion_2
+(_ x: ClassBound & ObjCClassBound) -> ObjCClassBound {
+ return x
+}
+// CHECK-LABEL: define hidden swiftcc %objc_object* @"$S22class_bounded_generics05objc_a1_B22_protocol_conversion_{{.*}}"(%objc_object*)
+func objc_class_bounded_protocol_conversion_3
+(_ x: ObjCClassBound & ObjCClassBound2) -> ObjCClassBound {
+ return x
+}
+// CHECK-LABEL: define hidden swiftcc %objc_object* @"$S22class_bounded_generics05objc_a1_B22_protocol_conversion_{{.*}}"(%objc_object*)
+func objc_class_bounded_protocol_conversion_4
+(_ x: ObjCClassBound & ObjCClassBound2) -> ObjCClassBound2 {
+ return x
+}
+
+// CHECK-LABEL: define hidden swiftcc { i64, %objc_object*, i64 } @"$S22class_bounded_generics0A28_generic_field_struct_fields{{[_0-9a-zA-Z]*}}F"(i64, %objc_object*, i64, %swift.type* %T, i8** %T.ClassBound)
+func class_generic_field_struct_fields<T>
+(_ x:ClassGenericFieldStruct<T>) -> (Int, T, Int) {
+ return (x.x, x.y, x.z)
+}
+
+// CHECK-LABEL: define hidden swiftcc { i64, %objc_object*, i8**, i64 } @"$S22class_bounded_generics0A29_protocol_field_struct_fields{{[_0-9a-zA-Z]*}}F"(i64, %objc_object*, i8**, i64)
+func class_protocol_field_struct_fields
+(_ x:ClassProtocolFieldStruct) -> (Int, ClassBound, Int) {
+ return (x.x, x.y, x.z)
+}
+
+// CHECK-LABEL: define hidden swiftcc { i64, %objc_object*, i64 } @"$S22class_bounded_generics0a15_generic_field_A7_fields{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics017ClassGenericFieldD0C*)
+func class_generic_field_class_fields<T>
+(_ x:ClassGenericFieldClass<T>) -> (Int, T, Int) {
+ return (x.x, x.y, x.z)
+ // CHECK: getelementptr inbounds %T22class_bounded_generics017ClassGenericFieldD0C, %T22class_bounded_generics017ClassGenericFieldD0C* %0, i32 0, i32 1
+ // CHECK: getelementptr inbounds %T22class_bounded_generics017ClassGenericFieldD0C, %T22class_bounded_generics017ClassGenericFieldD0C* %0, i32 0, i32 2
+ // CHECK: getelementptr inbounds %T22class_bounded_generics017ClassGenericFieldD0C, %T22class_bounded_generics017ClassGenericFieldD0C* %0, i32 0, i32 3
+}
+
+// CHECK-LABEL: define hidden swiftcc { i64, %objc_object*, i8**, i64 } @"$S22class_bounded_generics0a16_protocol_field_A7_fields{{[_0-9a-zA-Z]*}}F"(%T22class_bounded_generics018ClassProtocolFieldD0C*)
+func class_protocol_field_class_fields(_ x: ClassProtocolFieldClass)
+-> (Int, ClassBound, Int) {
+ return (x.x, x.y, x.z)
+ // CHECK: = call swiftcc i64 %{{[0-9]+}}
+ // CHECK: = call swiftcc { %objc_object*, i8** } %{{[0-9]+}}
+ // CHECK: = call swiftcc i64 %{{[0-9]+}}
+}
+
+class SomeSwiftClass {
+ class func foo() {}
+}
+
+// T must have a Swift layout, so we can load this metatype with a direct access.
+// CHECK-LABEL: define hidden swiftcc void @"$S22class_bounded_generics0a1_B9_metatype{{[_0-9a-zA-Z]*}}F"
+// CHECK: [[T0:%.*]] = getelementptr inbounds %T22class_bounded_generics14SomeSwiftClassC, %T22class_bounded_generics14SomeSwiftClassC* {{%.*}}, i32 0, i32 0, i32 0
+// CHECK-NEXT: [[T1:%.*]] = load %swift.type*, %swift.type** [[T0]], align 8
+// CHECK-NEXT: [[T2:%.*]] = bitcast %swift.type* [[T1]] to void (%swift.type*)**
+// CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds void (%swift.type*)*, void (%swift.type*)** [[T2]], i64 10
+// CHECK-NEXT: load void (%swift.type*)*, void (%swift.type*)** [[T3]], align 8
+func class_bounded_metatype<T: SomeSwiftClass>(_ t : T) {
+ type(of: t).foo()
+}
+
+class WeakRef<T: AnyObject> {
+ weak var value: T?
+}
+
+class A<T> {
+ required init() {}
+}
+
+class M<T, S: A<T>> {
+ private var s: S
+ init() {
+ // Don't crash generating the reference to 's'.
+ s = S.init()
+ }
+}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S22class_bounded_generics14takes_metatypeyyxmlF"(%swift.type*, %swift.type* %T)
+func takes_metatype<T>(_: T.Type) {}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S22class_bounded_generics023archetype_with_generic_A11_constraint1tyx_tAA1ACyq_GRbzr0_lF"(%T22class_bounded_generics1AC.2*, %swift.type* %T)
+// CHECK: [[ISA_ADDR:%.*]] = bitcast %T22class_bounded_generics1AC.2* %0 to %swift.type**
+// CHECK-NEXT: [[ISA:%.*]] = load %swift.type*, %swift.type** [[ISA_ADDR]]
+// CHECK-NEXT: call swiftcc void @"$S22class_bounded_generics14takes_metatypeyyxmlF"(%swift.type* %T, %swift.type* %T)
+// CHECK-NEXT: [[ISA_PTR:%.*]] = bitcast %swift.type* [[ISA]] to %swift.type**
+// CHECK-NEXT: [[U_ADDR:%.*]] = getelementptr inbounds %swift.type*, %swift.type** [[ISA_PTR]], i64 10
+// CHECK-NEXT: [[U:%.*]] = load %swift.type*, %swift.type** [[U_ADDR]]
+// CHECK-NEXT: call swiftcc void @"$S22class_bounded_generics14takes_metatypeyyxmlF"(%swift.type* %U, %swift.type* %U)
+// CHECK: ret void
+
+func archetype_with_generic_class_constraint<T, U>(t: T) where T : A<U> {
+ takes_metatype(T.self)
+ takes_metatype(U.self)
+}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S22class_bounded_generics029calls_archetype_with_generic_A11_constraint1ayAA1ACyxG_tlF"(%T22class_bounded_generics1AC*) #0 {
+// CHECK: [[ISA_ADDR:%.*]] = getelementptr inbounds %T22class_bounded_generics1AC, %T22class_bounded_generics1AC* %0, i32 0, i32 0, i32 0
+// CHECK-NEXT: [[ISA:%.*]] = load %swift.type*, %swift.type** [[ISA_ADDR]]
+// CHECK: [[SELF:%.*]] = bitcast %T22class_bounded_generics1AC* %0 to %T22class_bounded_generics1AC.2*
+// CHECK-NEXT: [[ISA_PTR:%.*]] = bitcast %swift.type* [[ISA]] to %swift.type**
+// CHECK-NEXT: [[T_ADDR:%.*]] = getelementptr inbounds %swift.type*, %swift.type** [[ISA_PTR]], i64 10
+// CHECK-NEXT: [[T:%.*]] = load %swift.type*, %swift.type** [[T_ADDR]]
+// CHECK-NEXT: [[A_OF_T:%.*]] = call %swift.type* @"$S22class_bounded_generics1ACMa"(%swift.type* [[T]])
+// CHECK-NEXT: call swiftcc void @"$S22class_bounded_generics023archetype_with_generic_A11_constraint1tyx_tAA1ACyq_GRbzr0_lF"(%T22class_bounded_generics1AC.2* [[SELF]], %swift.type* [[A_OF_T]])
+// CHECK: ret void
+
+func calls_archetype_with_generic_class_constraint<T>(a: A<T>) {
+ archetype_with_generic_class_constraint(t: a)
+}
diff --git a/test/IRGen/plus_zero_enum_resilience.swift b/test/IRGen/plus_zero_enum_resilience.swift
new file mode 100644
index 0000000..8332486
--- /dev/null
+++ b/test/IRGen/plus_zero_enum_resilience.swift
@@ -0,0 +1,275 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_struct.swiftmodule -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
+// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_enum.swiftmodule -module-name=resilient_enum -I %t %S/../Inputs/resilient_enum.swift
+// RUN: %target-swift-frontend -I %t -emit-ir -enable-resilience %s | %FileCheck %s
+// RUN: %target-swift-frontend -I %t -emit-ir -enable-resilience -O %s
+
+import resilient_enum
+import resilient_struct
+
+// CHECK: %swift.type = type { [[INT:i32|i64]] }
+
+// CHECK: %T15enum_resilience5ClassC = type <{ %swift.refcounted }>
+// CHECK: %T15enum_resilience9ReferenceV = type <{ %T15enum_resilience5ClassC* }>
+
+// Public fixed layout struct contains a public resilient struct,
+// cannot use spare bits
+
+// CHECK: %T15enum_resilience6EitherO = type <{ [[REFERENCE_TYPE:\[(4|8) x i8\]]], [1 x i8] }>
+
+// Public resilient struct contains a public resilient struct,
+// can use spare bits
+
+// CHECK: %T15enum_resilience15ResilientEitherO = type <{ [[REFERENCE_TYPE]] }>
+
+// Internal fixed layout struct contains a public resilient struct,
+// can use spare bits
+
+// CHECK: %T15enum_resilience14InternalEitherO = type <{ [[REFERENCE_TYPE]] }>
+
+// Public fixed layout struct contains a fixed layout struct,
+// can use spare bits
+
+// CHECK: %T15enum_resilience10EitherFastO = type <{ [[REFERENCE_TYPE]] }>
+
+public class Class {}
+
+public struct Reference {
+ public var n: Class
+}
+
+@_fixed_layout public enum Either {
+ case Left(Reference)
+ case Right(Reference)
+}
+
+public enum ResilientEither {
+ case Left(Reference)
+ case Right(Reference)
+}
+
+enum InternalEither {
+ case Left(Reference)
+ case Right(Reference)
+}
+
+@_fixed_layout public struct ReferenceFast {
+ public var n: Class
+}
+
+@_fixed_layout public enum EitherFast {
+ case Left(ReferenceFast)
+ case Right(ReferenceFast)
+}
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S15enum_resilience25functionWithResilientEnumy010resilient_A06MediumOAEF"(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture)
+public func functionWithResilientEnum(_ m: Medium) -> Medium {
+
+// CHECK: [[METADATA:%.*]] = call %swift.type* @"$S14resilient_enum6MediumOMa"()
+// CHECK-NEXT: [[METADATA_ADDR:%.*]] = bitcast %swift.type* [[METADATA]] to i8***
+// CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[METADATA_ADDR]], [[INT:i32|i64]] -1
+// CHECK-NEXT: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
+// This is copying the +0 argument to be used as a return value.
+// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 2
+// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
+// CHECK-NEXT: [[WITNESS_FN:%initializeWithCopy]] = bitcast i8* [[WITNESS]]
+// CHECK-NEXT: call %swift.opaque* [[WITNESS_FN]](%swift.opaque* noalias %0, %swift.opaque* noalias %1, %swift.type* [[METADATA]])
+// CHECK-NEXT: ret void
+
+ return m
+}
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S15enum_resilience33functionWithIndirectResilientEnumy010resilient_A00E8ApproachOAEF"(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture)
+public func functionWithIndirectResilientEnum(_ ia: IndirectApproach) -> IndirectApproach {
+
+// CHECK: [[METADATA:%.*]] = call %swift.type* @"$S14resilient_enum16IndirectApproachOMa"()
+// CHECK-NEXT: [[METADATA_ADDR:%.*]] = bitcast %swift.type* [[METADATA]] to i8***
+// CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[METADATA_ADDR]], [[INT:i32|i64]] -1
+// CHECK-NEXT: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
+// This is copying the +0 argument into the return slot.
+// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 2
+// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
+// CHECK-NEXT: [[WITNESS_FN:%initializeWithCopy]] = bitcast i8* [[WITNESS]]
+// CHECK-NEXT: call %swift.opaque* [[WITNESS_FN]](%swift.opaque* noalias %0, %swift.opaque* noalias %1, %swift.type* [[METADATA]])
+// CHECK-NEXT: ret void
+
+ return ia
+}
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S15enum_resilience31constructResilientEnumNoPayload010resilient_A06MediumOyF"
+public func constructResilientEnumNoPayload() -> Medium {
+// CHECK: [[METADATA:%.*]] = call %swift.type* @"$S14resilient_enum6MediumOMa"()
+// CHECK-NEXT: [[METADATA_ADDR:%.*]] = bitcast %swift.type* [[METADATA]] to i8***
+// CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[METADATA_ADDR]], [[INT:i32|i64]] -1
+// CHECK-NEXT: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
+
+// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 17
+// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
+// CHECK-NEXT: [[WITNESS_FN:%.*]] = bitcast i8* [[WITNESS]]
+// CHECK-NEXT: call void [[WITNESS_FN]](%swift.opaque* noalias %0, i32 0, %swift.type* [[METADATA]])
+
+// CHECK-NEXT: ret void
+ return Medium.Paper
+}
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S15enum_resilience29constructResilientEnumPayloady010resilient_A06MediumO0G7_struct4SizeVF"
+public func constructResilientEnumPayload(_ s: Size) -> Medium {
+// CHECK: [[METADATA:%.*]] = call %swift.type* @"$S16resilient_struct4SizeVMa"()
+// CHECK-NEXT: [[METADATA_ADDR:%.*]] = bitcast %swift.type* [[METADATA]] to i8***
+// CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[METADATA_ADDR]], [[INT:i32|i64]] -1
+// CHECK-NEXT: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
+
+// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 2
+// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
+// CHECK-NEXT: [[WITNESS_FN:%initializeWithCopy]] = bitcast i8* [[WITNESS]]
+// CHECK-NEXT: [[COPY:%.*]] = call %swift.opaque* [[WITNESS_FN]](%swift.opaque* noalias %0, %swift.opaque* noalias %1, %swift.type* [[METADATA]])
+
+// CHECK-NEXT: [[METADATA2:%.*]] = call %swift.type* @"$S14resilient_enum6MediumOMa"()
+// CHECK-NEXT: [[METADATA_ADDR2:%.*]] = bitcast %swift.type* [[METADATA2]] to i8***
+// CHECK-NEXT: [[VWT_ADDR2:%.*]] = getelementptr inbounds i8**, i8*** [[METADATA_ADDR2]], [[INT:i32|i64]] -1
+// CHECK-NEXT: [[VWT2:%.*]] = load i8**, i8*** [[VWT_ADDR2]]
+
+// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT2]], i32 17
+// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
+// CHECK-NEXT: [[WITNESS_FN:%destructiveInjectEnumTag]] = bitcast i8* [[WITNESS]]
+// CHECK-NEXT: call void [[WITNESS_FN]](%swift.opaque* noalias %0, i32 -2, %swift.type* [[METADATA2]])
+// CHECK-NEXT: ret void
+
+ return Medium.Postcard(s)
+}
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc {{i32|i64}} @"$S15enum_resilience19resilientSwitchTestySi0c1_A06MediumOF"(%swift.opaque* noalias nocapture)
+// CHECK: [[METADATA:%.*]] = call %swift.type* @"$S14resilient_enum6MediumOMa"()
+// CHECK: [[METADATA_ADDR:%.*]] = bitcast %swift.type* [[METADATA]] to i8***
+// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[METADATA_ADDR]], [[INT]] -1
+// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
+
+// CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 9
+// CHECK: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
+// CHECK: [[WITNESS_FOR_SIZE:%size]] = ptrtoint i8* [[WITNESS]]
+// CHECK: [[ALLOCA:%.*]] = alloca i8, {{.*}} [[WITNESS_FOR_SIZE]], align 16
+// CHECK: [[ALLOCA:%.*]] = alloca i8, {{.*}} [[WITNESS_FOR_SIZE]], align 16
+// CHECK: [[ENUM_STORAGE:%.*]] = bitcast i8* [[ALLOCA]] to %swift.opaque*
+
+// CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 2
+// CHECK: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
+// CHECK: [[WITNESS_FN:%initializeWithCopy]] = bitcast i8* [[WITNESS]]
+// CHECK: [[ENUM_COPY:%.*]] = call %swift.opaque* [[WITNESS_FN]](%swift.opaque* noalias [[ENUM_STORAGE]], %swift.opaque* noalias %0, %swift.type* [[METADATA]])
+
+// CHECK: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 15
+// CHECK: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]]
+// CHECK: [[WITNESS_FN:%getEnumTag]] = bitcast i8* [[WITNESS]]
+// CHECK: [[TAG:%.*]] = call i32 [[WITNESS_FN]](%swift.opaque* noalias [[ENUM_STORAGE]], %swift.type* [[METADATA]])
+
+// CHECK: switch i32 [[TAG]], label %[[DEFAULT_CASE:.*]] [
+// CHECK: i32 -1, label %[[PAMPHLET_CASE:.*]]
+// CHECK: i32 0, label %[[PAPER_CASE:.*]]
+// CHECK: i32 1, label %[[CANVAS_CASE:.*]]
+// CHECK: ]
+
+// CHECK: ; <label>:[[PAPER_CASE]]
+// CHECK: br label %[[END:.*]]
+
+// CHECK: ; <label>:[[CANVAS_CASE]]
+// CHECK: br label %[[END]]
+
+// CHECK: ; <label>:[[PAMPHLET_CASE]]
+// CHECK: br label %[[END]]
+
+// CHECK: ; <label>:[[DEFAULT_CASE]]
+// CHECK: br label %[[END]]
+
+// CHECK: ; <label>:[[END]]
+// CHECK: ret
+
+public func resilientSwitchTest(_ m: Medium) -> Int {
+ switch m {
+ case .Paper:
+ return 1
+ case .Canvas:
+ return 2
+ case .Pamphlet(let m):
+ return resilientSwitchTest(m)
+ default:
+ return 3
+ }
+}
+
+public func reabstraction<T>(_ f: (Medium) -> T) {}
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S15enum_resilience25resilientEnumPartialApplyyySi0c1_A06MediumOXEF"(i8*, %swift.opaque*)
+public func resilientEnumPartialApply(_ f: (Medium) -> Int) {
+
+// CHECK: [[CONTEXT:%.*]] = call noalias %swift.refcounted* @swift_allocObject
+// CHECK: call swiftcc void @"$S15enum_resilience13reabstractionyyx010resilient_A06MediumOXElF"(i8* bitcast (void (%TSi*, %swift.opaque*, %swift.refcounted*)* @"$S14resilient_enum6MediumOSiIgnd_ACSiIegnr_TRTA" to i8*), %swift.opaque* [[CONTEXT:%.*]], %swift.type* @"$SSiN")
+ reabstraction(f)
+
+// CHECK: ret void
+}
+
+// CHECK-LABEL: define internal swiftcc void @"$S14resilient_enum6MediumOSiIgnd_ACSiIegnr_TRTA"(%TSi* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.refcounted* swiftself)
+
+
+// Enums with resilient payloads from a different resilience domain
+// require runtime metadata instantiation, just like generics.
+
+public enum EnumWithResilientPayload {
+ case OneSize(Size)
+ case TwoSizes(Size, Size)
+}
+
+// Make sure we call a function to access metadata of enums with
+// resilient layout.
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc %swift.type* @"$S15enum_resilience20getResilientEnumTypeypXpyF"()
+// CHECK: [[METADATA:%.*]] = call %swift.type* @"$S15enum_resilience24EnumWithResilientPayloadOMa"()
+// CHECK-NEXT: ret %swift.type* [[METADATA]]
+
+public func getResilientEnumType() -> Any.Type {
+ return EnumWithResilientPayload.self
+}
+
+// Public metadata accessor for our resilient enum
+// CHECK-LABEL: define{{( protected)?}} %swift.type* @"$S15enum_resilience24EnumWithResilientPayloadOMa"()
+// CHECK: [[METADATA:%.*]] = load %swift.type*, %swift.type** @"$S15enum_resilience24EnumWithResilientPayloadOML"
+// CHECK-NEXT: [[COND:%.*]] = icmp eq %swift.type* [[METADATA]], null
+// CHECK-NEXT: br i1 [[COND]], label %cacheIsNull, label %cont
+
+// CHECK: cacheIsNull:
+// CHECK-NEXT: call void @swift_once([[INT]]* @"$S15enum_resilience24EnumWithResilientPayloadOMa.once_token", i8* bitcast (void (i8*)* @initialize_metadata_EnumWithResilientPayload to i8*), i8* undef)
+// CHECK-NEXT: [[METADATA2:%.*]] = load %swift.type*, %swift.type** @"$S15enum_resilience24EnumWithResilientPayloadOML"
+// CHECK-NEXT: br label %cont
+
+// CHECK: cont:
+// CHECK-NEXT: [[RESULT:%.*]] = phi %swift.type* [ [[METADATA]], %entry ], [ [[METADATA2]], %cacheIsNull ]
+// CHECK-NEXT: ret %swift.type* [[RESULT]]
+
+// Methods inside extensions of resilient enums fish out type parameters
+// from metadata -- make sure we can do that
+extension ResilientMultiPayloadGenericEnum {
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc %swift.type* @"$S14resilient_enum32ResilientMultiPayloadGenericEnumO0B11_resilienceE16getTypeParameterxmyF"(%swift.type* %"ResilientMultiPayloadGenericEnum<T>", %swift.opaque* noalias nocapture swiftself)
+// CHECK: [[METADATA:%.*]] = bitcast %swift.type* %"ResilientMultiPayloadGenericEnum<T>" to %swift.type**
+// CHECK-NEXT: [[T_ADDR:%.*]] = getelementptr inbounds %swift.type*, %swift.type** [[METADATA]], [[INT]] 2
+// CHECK-NEXT: [[T:%.*]] = load %swift.type*, %swift.type** [[T_ADDR]]
+ public func getTypeParameter() -> T.Type {
+ return T.self
+ }
+}
+
+// CHECK-LABEL: define{{( protected)?}} private void @initialize_metadata_EnumWithResilientPayload(i8*)
+// CHECK: call void @swift_initEnumMetadataMultiPayload(%swift.type* {{.*}}, [[INT]] 256, [[INT]] 2, i8*** {{.*}})
+
+
+
+public protocol Prot {
+}
+
+private enum ProtGenEnumWithSize<T: Prot> {
+ case c1(s1: Size)
+ case c2(s2: Size)
+}
+
+// CHECK-LABEL: define{{( protected)?}} internal %T15enum_resilience19ProtGenEnumWithSize33_59077B69D65A4A3BEE0C93708067D5F0LLO* @"$S15enum_resilienceytWh2_"(%T15enum_resilience19ProtGenEnumWithSize
+// CHECK: ret %T15enum_resilience19ProtGenEnumWithSize33_59077B69D65A4A3BEE0C93708067D5F0LLO* %0
diff --git a/test/IRGen/plus_zero_generic_metatypes.swift b/test/IRGen/plus_zero_generic_metatypes.swift
new file mode 100644
index 0000000..0249939
--- /dev/null
+++ b/test/IRGen/plus_zero_generic_metatypes.swift
@@ -0,0 +1,181 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %swift -target x86_64-apple-macosx10.9 -emit-ir -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 %s
+// RUN: %swift -target i386-apple-ios7.0 -emit-ir -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 %s
+// RUN: %swift -target x86_64-apple-ios7.0 -emit-ir -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 %s
+// RUN: %swift -target i386-apple-tvos9.0 -emit-ir -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 %s
+// RUN: %swift -target x86_64-apple-tvos9.0 -emit-ir -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 %s
+// RUN: %swift -target i386-apple-watchos2.0 -emit-ir -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 %s
+// RUN: %swift -target x86_64-unknown-linux-gnu -disable-objc-interop -emit-ir -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 %s
+
+// REQUIRES: CODEGENERATOR=X86
+
+// CHECK: define hidden swiftcc %swift.type* [[GENERIC_TYPEOF:@"\$S17generic_metatypes0A6TypeofyxmxlF"]](%swift.opaque* noalias nocapture, %swift.type* [[TYPE:%.*]])
+func genericTypeof<T>(_ x: T) -> T.Type {
+ // CHECK: [[METATYPE:%.*]] = call %swift.type* @swift_getDynamicType(%swift.opaque* {{.*}}, %swift.type* [[TYPE]], i1 false)
+ // CHECK: ret %swift.type* [[METATYPE]]
+ return type(of: x)
+}
+
+struct Foo {}
+class Bar {}
+
+// CHECK-LABEL: define hidden swiftcc %swift.type* @"$S17generic_metatypes27remapToSubstitutedMetatypes{{.*}}"(%T17generic_metatypes3BarC*) {{.*}} {
+func remapToSubstitutedMetatypes(_ x: Foo, y: Bar)
+ -> (Foo.Type, Bar.Type)
+{
+ // CHECK: call swiftcc %swift.type* [[GENERIC_TYPEOF]](%swift.opaque* noalias nocapture undef, %swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}})
+ // CHECK: [[T0:%.*]] = call %swift.type* @"$S17generic_metatypes3BarCMa"()
+ // CHECK: [[BAR_META:%.*]] = call swiftcc %swift.type* [[GENERIC_TYPEOF]](%swift.opaque* noalias nocapture {{%.*}}, %swift.type* [[T0]])
+ // CHECK: ret %swift.type* [[BAR_META]]
+ return (genericTypeof(x), genericTypeof(y))
+}
+
+
+// CHECK-LABEL: define hidden swiftcc void @"$S17generic_metatypes23remapToGenericMetatypesyyF"()
+func remapToGenericMetatypes() {
+ // CHECK: [[T0:%.*]] = call %swift.type* @"$S17generic_metatypes3BarCMa"()
+ // CHECK: call swiftcc void @"$S17generic_metatypes0A9Metatypes{{.*}}"(%swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}} %swift.type* [[T0]], %swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}} %swift.type* [[T0]])
+ genericMetatypes(Foo.self, Bar.self)
+}
+
+func genericMetatypes<T, U>(_ t: T.Type, _ u: U.Type) {}
+
+protocol Bas {}
+
+// CHECK: define hidden swiftcc { %swift.type*, i8** } @"$S17generic_metatypes14protocolTypeof{{.*}}"(%T17generic_metatypes3BasP* noalias nocapture dereferenceable({{.*}}))
+func protocolTypeof(_ x: Bas) -> Bas.Type {
+ // CHECK: [[METADATA_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, %T17generic_metatypes3BasP* [[X:%.*]], i32 0, i32 1
+ // CHECK: [[METADATA:%.*]] = load %swift.type*, %swift.type** [[METADATA_ADDR]]
+ // CHECK: [[BUFFER:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, %T17generic_metatypes3BasP* [[X]], i32 0, i32 0
+ // CHECK: [[VALUE_ADDR:%.*]] = call %swift.opaque* @__swift_project_boxed_opaque_existential_1({{.*}} [[BUFFER]], %swift.type* [[METADATA]])
+ // CHECK: [[METATYPE:%.*]] = call %swift.type* @swift_getDynamicType(%swift.opaque* [[VALUE_ADDR]], %swift.type* [[METADATA]], i1 true)
+ // CHECK: [[WTABLE_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, %T17generic_metatypes3BasP* %0, i32 0, i32 2
+ // CHECK: [[WTABLE:%.*]] = load i8**, i8*** [[WTABLE_ADDR]]
+ // CHECK-NOT: call void @__swift_destroy_boxed_opaque_existential_1(%T17generic_metatypes3BasP* %0)
+ // CHECK: [[T0:%.*]] = insertvalue { %swift.type*, i8** } undef, %swift.type* [[METATYPE]], 0
+ // CHECK: [[T1:%.*]] = insertvalue { %swift.type*, i8** } [[T0]], i8** [[WTABLE]], 1
+ // CHECK: ret { %swift.type*, i8** } [[T1]]
+ return type(of: x)
+}
+
+struct Zim : Bas {}
+class Zang : Bas {}
+
+// CHECK-LABEL: define hidden swiftcc { %swift.type*, i8** } @"$S17generic_metatypes15metatypeErasureyAA3Bas_pXpAA3ZimVmF"() #0
+func metatypeErasure(_ z: Zim.Type) -> Bas.Type {
+ // CHECK: ret { %swift.type*, i8** } {{.*}} @"$S17generic_metatypes3ZimVMf", {{.*}} @"$S17generic_metatypes3ZimVAA3BasAAWP"
+ return z
+}
+
+// CHECK-LABEL: define hidden swiftcc { %swift.type*, i8** } @"$S17generic_metatypes15metatypeErasureyAA3Bas_pXpAA4ZangCmF"(%swift.type*) #0
+func metatypeErasure(_ z: Zang.Type) -> Bas.Type {
+ // CHECK: [[RET:%.*]] = insertvalue { %swift.type*, i8** } undef, %swift.type* %0, 0
+ // CHECK: [[RET2:%.*]] = insertvalue { %swift.type*, i8** } [[RET]], i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"$S17generic_metatypes4ZangCAA3BasAAWP", i32 0, i32 0), 1
+ // CHECK: ret { %swift.type*, i8** } [[RET2]]
+ return z
+}
+
+struct OneArg<T> {}
+struct TwoArgs<T, U> {}
+struct ThreeArgs<T, U, V> {}
+struct FourArgs<T, U, V, W> {}
+struct FiveArgs<T, U, V, W, X> {}
+
+func genericMetatype<A>(_ x: A.Type) {}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S17generic_metatypes20makeGenericMetatypesyyF"() {{.*}} {
+func makeGenericMetatypes() {
+ // CHECK: call %swift.type* @"$S17generic_metatypes6OneArgVyAA3FooVGMa"() [[NOUNWIND_READNONE:#[0-9]+]]
+ genericMetatype(OneArg<Foo>.self)
+
+ // CHECK: call %swift.type* @"$S17generic_metatypes7TwoArgsVyAA3FooVAA3BarCGMa"() [[NOUNWIND_READNONE]]
+ genericMetatype(TwoArgs<Foo, Bar>.self)
+
+ // CHECK: call %swift.type* @"$S17generic_metatypes9ThreeArgsVyAA3FooVAA3BarCAEGMa"() [[NOUNWIND_READNONE]]
+ genericMetatype(ThreeArgs<Foo, Bar, Foo>.self)
+
+ // CHECK: call %swift.type* @"$S17generic_metatypes8FourArgsVyAA3FooVAA3BarCAeGGMa"() [[NOUNWIND_READNONE]]
+ genericMetatype(FourArgs<Foo, Bar, Foo, Bar>.self)
+
+ // CHECK: call %swift.type* @"$S17generic_metatypes8FiveArgsVyAA3FooVAA3BarCAegEGMa"() [[NOUNWIND_READNONE]]
+ genericMetatype(FiveArgs<Foo, Bar, Foo, Bar, Foo>.self)
+}
+
+// CHECK: define linkonce_odr hidden %swift.type* @"$S17generic_metatypes6OneArgVyAA3FooVGMa"() [[NOUNWIND_READNONE_OPT:#[0-9]+]]
+// CHECK: call %swift.type* @"$S17generic_metatypes6OneArgVMa"(%swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}) [[NOUNWIND_READNONE:#[0-9]+]]
+
+// CHECK-LABEL: define hidden %swift.type* @"$S17generic_metatypes6OneArgVMa"(%swift.type*)
+// CHECK: [[BUFFER:%.*]] = alloca { %swift.type* }
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type* }* [[BUFFER]] to i8*
+// CHECK: call void @llvm.lifetime.start
+// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type* }, { %swift.type* }* [[BUFFER]], i32 0, i32 0
+// CHECK: store %swift.type* %0, %swift.type** [[BUFFER_ELT]]
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type* }* [[BUFFER]] to i8*
+// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getGenericMetadata(%swift.type_descriptor* {{.*}} @"$S17generic_metatypes6OneArgVMn" {{.*}}, i8* [[BUFFER_PTR]])
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type* }* [[BUFFER]] to i8*
+// CHECK: call void @llvm.lifetime.end
+// CHECK: ret %swift.type* [[METADATA]]
+
+// CHECK: define linkonce_odr hidden %swift.type* @"$S17generic_metatypes7TwoArgsVyAA3FooVAA3BarCGMa"() [[NOUNWIND_READNONE_OPT]]
+// CHECK: [[T0:%.*]] = call %swift.type* @"$S17generic_metatypes3BarCMa"()
+// CHECK: call %swift.type* @"$S17generic_metatypes7TwoArgsVMa"(%swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}, %swift.type* [[T0]])
+
+// CHECK-LABEL: define hidden %swift.type* @"$S17generic_metatypes7TwoArgsVMa"(%swift.type*, %swift.type*)
+// CHECK: [[BUFFER:%.*]] = alloca { %swift.type*, %swift.type* }
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type* }* [[BUFFER]] to i8*
+// CHECK: call void @llvm.lifetime.start
+// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type* }, { %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 0
+// CHECK: store %swift.type* %0, %swift.type** [[BUFFER_ELT]]
+// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type* }, { %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 1
+// CHECK: store %swift.type* %1, %swift.type** [[BUFFER_ELT]]
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type* }* [[BUFFER]] to i8*
+// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getGenericMetadata(%swift.type_descriptor* {{.*}} @"$S17generic_metatypes7TwoArgsVMn" {{.*}}, i8* [[BUFFER_PTR]])
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type* }* [[BUFFER]] to i8*
+// CHECK: call void @llvm.lifetime.end
+// CHECK: ret %swift.type* [[METADATA]]
+
+// CHECK: define linkonce_odr hidden %swift.type* @"$S17generic_metatypes9ThreeArgsVyAA3FooVAA3BarCAEGMa"() [[NOUNWIND_READNONE_OPT]]
+// CHECK: [[T0:%.*]] = call %swift.type* @"$S17generic_metatypes3BarCMa"()
+// CHECK: call %swift.type* @"$S17generic_metatypes9ThreeArgsVMa"(%swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}, %swift.type* [[T0]], %swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}) [[NOUNWIND_READNONE]]
+
+// CHECK-LABEL: define hidden %swift.type* @"$S17generic_metatypes9ThreeArgsVMa"(%swift.type*, %swift.type*, %swift.type*)
+// CHECK: [[BUFFER:%.*]] = alloca { %swift.type*, %swift.type*, %swift.type* }
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]] to i8*
+// CHECK: call void @llvm.lifetime.start
+// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type*, %swift.type* }, { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 0
+// CHECK: store %swift.type* %0, %swift.type** [[BUFFER_ELT]]
+// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type*, %swift.type* }, { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 1
+// CHECK: store %swift.type* %1, %swift.type** [[BUFFER_ELT]]
+// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type*, %swift.type* }, { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 2
+// CHECK: store %swift.type* %2, %swift.type** [[BUFFER_ELT]]
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]] to i8*
+// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getGenericMetadata(%swift.type_descriptor* {{.*}} @"$S17generic_metatypes9ThreeArgsVMn" {{.*}}, i8* [[BUFFER_PTR]])
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]] to i8*
+// CHECK: call void @llvm.lifetime.end
+// CHECK: ret %swift.type* [[METADATA]]
+
+// CHECK: define linkonce_odr hidden %swift.type* @"$S17generic_metatypes8FourArgsVyAA3FooVAA3BarCAeGGMa"() [[NOUNWIND_READNONE_OPT]]
+// CHECK: [[BUFFER:%.*]] = alloca [4 x i8*]
+// CHECK: [[T0:%.*]] = call %swift.type* @"$S17generic_metatypes3BarCMa"()
+// CHECK: call void @llvm.lifetime.start
+// CHECK-NEXT: [[SLOT_3:%.*]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[BUFFER]], i32 0, i32 3
+// CHECK-NEXT: [[T0_AS_VOIDPTR:%.*]] = bitcast %swift.type* [[T0]] to i8*
+// CHECK-NEXT: store i8* [[T0_AS_VOIDPTR]], i8** [[SLOT_3]]
+// CHECK-NEXT: [[BUFFER_PTR:%.*]] = bitcast [4 x i8*]* [[BUFFER]] to i8**
+// CHECK-NEXT: call %swift.type* @"$S17generic_metatypes8FourArgsVMa"(%swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}, %swift.type* [[T0]], %swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}, i8** [[BUFFER_PTR]]) [[NOUNWIND_ARGMEM:#[0-9]+]]
+// CHECK: call void @llvm.lifetime.end.p0i8
+
+// CHECK: define linkonce_odr hidden %swift.type* @"$S17generic_metatypes8FiveArgsVyAA3FooVAA3BarCAegEGMa"() [[NOUNWIND_READNONE_OPT]]
+// CHECK: [[T0:%.*]] = call %swift.type* @"$S17generic_metatypes3BarCMa"()
+// CHECK: call %swift.type* @"$S17generic_metatypes8FiveArgsVMa"(%swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}, %swift.type* [[T0]], %swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}, i8**
+
+// CHECK: define hidden %swift.type* @"$S17generic_metatypes8FiveArgsVMa"(%swift.type*, %swift.type*, %swift.type*, i8**) [[NOUNWIND_OPT:#[0-9]+]]
+// CHECK-NOT: alloc
+// CHECK: call %swift.type* @swift_getGenericMetadata(%swift.type_descriptor* {{.*}} @"$S17generic_metatypes8FiveArgsVMn" {{.*}}, i8*
+// CHECK-NOT: call void @llvm.lifetime.end
+// CHECK: ret %swift.type*
+
+// CHECK: attributes [[NOUNWIND_READNONE_OPT]] = { nounwind readnone "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "target-cpu"
+// CHECK: attributes [[NOUNWIND_OPT]] = { nounwind "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "target-cpu"
+// CHECK: attributes [[NOUNWIND_READNONE]] = { nounwind readnone }
+// CHECK: attributes [[NOUNWIND_ARGMEM]] = { inaccessiblemem_or_argmemonly nounwind }
diff --git a/test/IRGen/plus_zero_generic_metatypes_arm.swift b/test/IRGen/plus_zero_generic_metatypes_arm.swift
new file mode 100644
index 0000000..ad87734
--- /dev/null
+++ b/test/IRGen/plus_zero_generic_metatypes_arm.swift
@@ -0,0 +1,176 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %swift -target armv7-apple-ios7.0 -module-name generic_metatypes -emit-ir -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 %s
+// RUN: %swift -target arm64-apple-ios7.0 -emit-ir -module-name generic_metatypes -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 %s
+// RUN: %swift -target armv7-apple-tvos9.0 -emit-ir -module-name generic_metatypes -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 %s
+// RUN: %swift -target arm64-apple-tvos9.0 -emit-ir -module-name generic_metatypes -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-64 %s
+// RUN: %swift -target armv7k-apple-watchos2.0 -emit-ir -module-name generic_metatypes -parse-stdlib -primary-file %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-32 %s
+
+// REQUIRES: CODEGENERATOR=ARM
+
+// CHECK: define hidden swiftcc %swift.type* [[GENERIC_TYPEOF:@"\$S17generic_metatypes0A6TypeofyxmxlF"]](%swift.opaque* noalias nocapture, %swift.type* [[TYPE:%.*]])
+func genericTypeof<T>(_ x: T) -> T.Type {
+ // CHECK: [[METATYPE:%.*]] = call %swift.type* @swift_getDynamicType(%swift.opaque* {{.*}}, %swift.type* [[TYPE]], i1 false)
+ // CHECK: ret %swift.type* [[METATYPE]]
+ return type(of: x)
+}
+
+struct Foo {}
+class Bar {}
+
+// CHECK-LABEL: define hidden swiftcc %swift.type* @"$S17generic_metatypes27remapToSubstitutedMetatypes{{.*}}"(%T17generic_metatypes3BarC*) {{.*}} {
+func remapToSubstitutedMetatypes(_ x: Foo, y: Bar)
+ -> (Foo.Type, Bar.Type)
+{
+ // CHECK: call swiftcc %swift.type* [[GENERIC_TYPEOF]](%swift.opaque* noalias nocapture undef, %swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}})
+ // CHECK: [[T0:%.*]] = call %swift.type* @"$S17generic_metatypes3BarCMa"()
+ // CHECK: [[BAR_META:%.*]] = call swiftcc %swift.type* [[GENERIC_TYPEOF]](%swift.opaque* noalias nocapture {{%.*}}, %swift.type* [[T0]])
+ // CHECK: ret %swift.type* [[BAR_META]]
+ return (genericTypeof(x), genericTypeof(y))
+}
+
+
+// CHECK-LABEL: define hidden swiftcc void @"$S17generic_metatypes23remapToGenericMetatypesyyF"()
+func remapToGenericMetatypes() {
+ // CHECK: [[T0:%.*]] = call %swift.type* @"$S17generic_metatypes3BarCMa"()
+ // CHECK: call swiftcc void @"$S17generic_metatypes0A9Metatypes{{.*}}"(%swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}} %swift.type* [[T0]], %swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}} %swift.type* [[T0]])
+ genericMetatypes(Foo.self, Bar.self)
+}
+
+func genericMetatypes<T, U>(_ t: T.Type, _ u: U.Type) {}
+
+protocol Bas {}
+
+// CHECK: define hidden swiftcc { %swift.type*, i8** } @"$S17generic_metatypes14protocolTypeof{{.*}}"(%T17generic_metatypes3BasP* noalias nocapture dereferenceable({{.*}}))
+func protocolTypeof(_ x: Bas) -> Bas.Type {
+ // CHECK: [[METADATA_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, %T17generic_metatypes3BasP* [[X:%.*]], i32 0, i32 1
+ // CHECK: [[METADATA:%.*]] = load %swift.type*, %swift.type** [[METADATA_ADDR]]
+ // CHECK: [[BUFFER:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, %T17generic_metatypes3BasP* [[X]], i32 0, i32 0
+ // CHECK: [[VALUE_ADDR:%.*]] = call %swift.opaque* @__swift_project_boxed_opaque_existential_1({{.*}} [[BUFFER]], %swift.type* [[METADATA]])
+ // CHECK: [[METATYPE:%.*]] = call %swift.type* @swift_getDynamicType(%swift.opaque* [[VALUE_ADDR]], %swift.type* [[METADATA]], i1 true)
+ // CHECK: [[WTABLE_ADDR:%.*]] = getelementptr inbounds %T17generic_metatypes3BasP, %T17generic_metatypes3BasP* %0, i32 0, i32 2
+ // CHECK: [[WTABLE:%.*]] = load i8**, i8*** [[WTABLE_ADDR]]
+ // CHECK-NOT: call void @__swift_destroy_boxed_opaque_existential_1(%T17generic_metatypes3BasP* %0)
+ // CHECK: [[T0:%.*]] = insertvalue { %swift.type*, i8** } undef, %swift.type* [[METATYPE]], 0
+ // CHECK: [[T1:%.*]] = insertvalue { %swift.type*, i8** } [[T0]], i8** [[WTABLE]], 1
+ // CHECK: ret { %swift.type*, i8** } [[T1]]
+ return type(of: x)
+}
+
+struct Zim : Bas {}
+class Zang : Bas {}
+
+// CHECK-LABEL: define hidden swiftcc { %swift.type*, i8** } @"$S17generic_metatypes15metatypeErasureyAA3Bas_pXpAA3ZimVmF"() #0
+func metatypeErasure(_ z: Zim.Type) -> Bas.Type {
+ // CHECK: ret { %swift.type*, i8** } {{.*}} @"$S17generic_metatypes3ZimVMf", {{.*}} @"$S17generic_metatypes3ZimVAA3BasAAWP"
+ return z
+}
+
+// CHECK-LABEL: define hidden swiftcc { %swift.type*, i8** } @"$S17generic_metatypes15metatypeErasureyAA3Bas_pXpAA4ZangCmF"(%swift.type*) #0
+func metatypeErasure(_ z: Zang.Type) -> Bas.Type {
+ // CHECK: [[RET:%.*]] = insertvalue { %swift.type*, i8** } undef, %swift.type* %0, 0
+ // CHECK: [[RET2:%.*]] = insertvalue { %swift.type*, i8** } [[RET]], i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"$S17generic_metatypes4ZangCAA3BasAAWP", i32 0, i32 0), 1
+ // CHECK: ret { %swift.type*, i8** } [[RET2]]
+ return z
+}
+
+struct OneArg<T> {}
+struct TwoArgs<T, U> {}
+struct ThreeArgs<T, U, V> {}
+struct FourArgs<T, U, V, W> {}
+struct FiveArgs<T, U, V, W, X> {}
+
+func genericMetatype<A>(_ x: A.Type) {}
+
+// CHECK-LABEL: define hidden swiftcc void @"$S17generic_metatypes20makeGenericMetatypesyyF"() {{.*}} {
+func makeGenericMetatypes() {
+ // CHECK: call %swift.type* @"$S17generic_metatypes6OneArgVyAA3FooVGMa"() [[NOUNWIND_READNONE:#[0-9]+]]
+ genericMetatype(OneArg<Foo>.self)
+
+ // CHECK: call %swift.type* @"$S17generic_metatypes7TwoArgsVyAA3FooVAA3BarCGMa"() [[NOUNWIND_READNONE]]
+ genericMetatype(TwoArgs<Foo, Bar>.self)
+
+ // CHECK: call %swift.type* @"$S17generic_metatypes9ThreeArgsVyAA3FooVAA3BarCAEGMa"() [[NOUNWIND_READNONE]]
+ genericMetatype(ThreeArgs<Foo, Bar, Foo>.self)
+
+ // CHECK: call %swift.type* @"$S17generic_metatypes8FourArgsVyAA3FooVAA3BarCAeGGMa"() [[NOUNWIND_READNONE]]
+ genericMetatype(FourArgs<Foo, Bar, Foo, Bar>.self)
+
+ // CHECK: call %swift.type* @"$S17generic_metatypes8FiveArgsVyAA3FooVAA3BarCAegEGMa"() [[NOUNWIND_READNONE]]
+ genericMetatype(FiveArgs<Foo, Bar, Foo, Bar, Foo>.self)
+}
+
+// CHECK: define linkonce_odr hidden %swift.type* @"$S17generic_metatypes6OneArgVyAA3FooVGMa"() [[NOUNWIND_READNONE_OPT:#[0-9]+]]
+// CHECK: call %swift.type* @"$S17generic_metatypes6OneArgVMa"(%swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}) [[NOUNWIND_READNONE:#[0-9]+]]
+
+// CHECK-LABEL: define hidden %swift.type* @"$S17generic_metatypes6OneArgVMa"(%swift.type*)
+// CHECK: [[BUFFER:%.*]] = alloca { %swift.type* }
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type* }* [[BUFFER]] to i8*
+// CHECK: call void @llvm.lifetime.start
+// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type* }, { %swift.type* }* [[BUFFER]], i32 0, i32 0
+// CHECK: store %swift.type* %0, %swift.type** [[BUFFER_ELT]]
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type* }* [[BUFFER]] to i8*
+// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getGenericMetadata(%swift.type_descriptor* {{.*}} @"$S17generic_metatypes6OneArgVMn" {{.*}}, i8* [[BUFFER_PTR]])
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type* }* [[BUFFER]] to i8*
+// CHECK: call void @llvm.lifetime.end
+// CHECK: ret %swift.type* [[METADATA]]
+
+// CHECK: define linkonce_odr hidden %swift.type* @"$S17generic_metatypes7TwoArgsVyAA3FooVAA3BarCGMa"() [[NOUNWIND_READNONE_OPT]]
+// CHECK: [[T0:%.*]] = call %swift.type* @"$S17generic_metatypes3BarCMa"()
+// CHECK: call %swift.type* @"$S17generic_metatypes7TwoArgsVMa"(%swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}, %swift.type* [[T0]])
+
+// CHECK-LABEL: define hidden %swift.type* @"$S17generic_metatypes7TwoArgsVMa"(%swift.type*, %swift.type*)
+// CHECK: [[BUFFER:%.*]] = alloca { %swift.type*, %swift.type* }
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type* }* [[BUFFER]] to i8*
+// CHECK: call void @llvm.lifetime.start
+// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type* }, { %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 0
+// CHECK: store %swift.type* %0, %swift.type** [[BUFFER_ELT]]
+// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type* }, { %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 1
+// CHECK: store %swift.type* %1, %swift.type** [[BUFFER_ELT]]
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type* }* [[BUFFER]] to i8*
+// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getGenericMetadata(%swift.type_descriptor* {{.*}} @"$S17generic_metatypes7TwoArgsVMn" {{.*}}, i8* [[BUFFER_PTR]])
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type* }* [[BUFFER]] to i8*
+// CHECK: call void @llvm.lifetime.end
+// CHECK: ret %swift.type* [[METADATA]]
+
+// CHECK: define linkonce_odr hidden %swift.type* @"$S17generic_metatypes9ThreeArgsVyAA3FooVAA3BarCAEGMa"() [[NOUNWIND_READNONE_OPT]]
+// CHECK: [[T0:%.*]] = call %swift.type* @"$S17generic_metatypes3BarCMa"()
+// CHECK: call %swift.type* @"$S17generic_metatypes9ThreeArgsVMa"(%swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}, %swift.type* [[T0]], %swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}) [[NOUNWIND_READNONE]]
+
+// CHECK-LABEL: define hidden %swift.type* @"$S17generic_metatypes9ThreeArgsVMa"(%swift.type*, %swift.type*, %swift.type*)
+// CHECK: [[BUFFER:%.*]] = alloca { %swift.type*, %swift.type*, %swift.type* }
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]] to i8*
+// CHECK: call void @llvm.lifetime.start
+// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type*, %swift.type* }, { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 0
+// CHECK: store %swift.type* %0, %swift.type** [[BUFFER_ELT]]
+// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type*, %swift.type* }, { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 1
+// CHECK: store %swift.type* %1, %swift.type** [[BUFFER_ELT]]
+// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type*, %swift.type* }, { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 2
+// CHECK: store %swift.type* %2, %swift.type** [[BUFFER_ELT]]
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]] to i8*
+// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getGenericMetadata(%swift.type_descriptor* {{.*}} @"$S17generic_metatypes9ThreeArgsVMn" {{.*}}, i8* [[BUFFER_PTR]])
+// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]] to i8*
+// CHECK: call void @llvm.lifetime.end
+// CHECK: ret %swift.type* [[METADATA]]
+
+// CHECK: define linkonce_odr hidden %swift.type* @"$S17generic_metatypes8FourArgsVyAA3FooVAA3BarCAeGGMa"() [[NOUNWIND_READNONE_OPT]]
+// CHECK: [[T0:%.*]] = call %swift.type* @"$S17generic_metatypes3BarCMa"()
+// CHECK: call %swift.type* @"$S17generic_metatypes8FourArgsVMa"(%swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}, %swift.type* [[T0]], %swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}, i8**
+
+// CHECK-LABEL: define hidden %swift.type* @"$S17generic_metatypes8FourArgsVMa"(%swift.type*, %swift.type*, %swift.type*, i8**)
+// CHECK-NOT: alloc
+// CHECK: call %swift.type* @swift_getGenericMetadata(
+// CHECK-NOT: call void @llvm.lifetime.end
+// CHECK: ret %swift.type*
+
+// CHECK: define linkonce_odr hidden %swift.type* @"$S17generic_metatypes8FiveArgsVyAA3FooVAA3BarCAegEGMa"() [[NOUNWIND_READNONE_OPT]]
+// CHECK: [[T0:%.*]] = call %swift.type* @"$S17generic_metatypes3BarCMa"()
+// CHECK: call %swift.type* @"$S17generic_metatypes8FiveArgsVMa"(%swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}, %swift.type* [[T0]], %swift.type* {{.*}} @"$S17generic_metatypes3FooVMf", {{.*}}, i8**
+
+// CHECK-LABEL: define hidden %swift.type* @"$S17generic_metatypes8FiveArgsVMa"(%swift.type*, %swift.type*, %swift.type*, i8**)
+// CHECK-NOT: alloca
+// CHECK: call %swift.type* @swift_getGenericMetadata(%swift.type_descriptor* {{.*}} @"$S17generic_metatypes8FiveArgsVMn" {{.*}}, i8*
+// CHECK-NOT: call void @llvm.lifetime.end
+// CHECK: ret %swift.type*
+
+// CHECK: attributes [[NOUNWIND_READNONE_OPT]] = { nounwind readnone "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "target-cpu"
+// CHECK: attributes [[NOUNWIND_READNONE]] = { nounwind readnone }
diff --git a/test/IRGen/plus_zero_generic_tuples.swift b/test/IRGen/plus_zero_generic_tuples.swift
new file mode 100644
index 0000000..c45781d
--- /dev/null
+++ b/test/IRGen/plus_zero_generic_tuples.swift
@@ -0,0 +1,120 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-ir -primary-file %s | %FileCheck %s
+
+// Make sure that optimization passes don't choke on storage types for generic tuples
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-ir -O %s
+
+// REQUIRES: CPU=x86_64
+
+// CHECK: [[TYPE:%swift.type]] = type {
+// CHECK: [[OPAQUE:%swift.opaque]] = type opaque
+// CHECK: [[TUPLE_TYPE:%swift.tuple_type]] = type { [[TYPE]], i64, i8*, [0 x %swift.tuple_element_type] }
+// CHECK: %swift.tuple_element_type = type { [[TYPE]]*, i64 }
+
+func dup<T>(_ x: T) -> (T, T) { var x = x; return (x,x) }
+// CHECK: define hidden swiftcc void @"$S14generic_tuples3dupyx_xtxlF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T)
+// CHECK: entry:
+// Allocate a local variable for 'x'.
+// CHECK: [[TYPE_ADDR:%.*]] = bitcast %swift.type* %T to i8***
+// CHECK: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[TYPE_ADDR]], i64 -1
+// CHECK: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
+// CHECK: [[SIZE_WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 9
+// CHECK: [[SIZE_WITNESS:%.*]] = load i8*, i8** [[SIZE_WITNESS_ADDR]]
+// CHECK: [[SIZE:%.*]] = ptrtoint i8* [[SIZE_WITNESS]]
+// CHECK: [[X_ALLOCA:%.*]] = alloca i8, {{.*}} [[SIZE]], align 16
+// CHECK: [[X_TMP:%.*]] = bitcast i8* [[X_ALLOCA]] to %swift.opaque*
+// Debug info shadow copy.
+// CHECK-NEXT: store i8* [[X_ALLOCA]]
+// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 2
+// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]], align 8
+// CHECK-NEXT: [[INITIALIZE_WITH_COPY:%.*]] = bitcast i8* [[WITNESS]] to [[OPAQUE]]* ([[OPAQUE]]*, [[OPAQUE]]*, [[TYPE]]*)*
+// CHECK-NEXT: [[X:%.*]] = call [[OPAQUE]]* [[INITIALIZE_WITH_COPY]]([[OPAQUE]]* noalias [[X_TMP]], [[OPAQUE]]* noalias {{.*}}, [[TYPE]]* %T)
+// Copy 'x' into the first result.
+// CHECK-NEXT: call [[OPAQUE]]* [[INITIALIZE_WITH_COPY]]([[OPAQUE]]* noalias %0, [[OPAQUE]]* noalias [[X_TMP]], [[TYPE]]* %T)
+// Copy 'x' into the second element.
+// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 4
+// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]], align 8
+// CHECK-NEXT: [[TAKE_FN:%.*]] = bitcast i8* [[WITNESS]] to [[OPAQUE]]* ([[OPAQUE]]*, [[OPAQUE]]*, [[TYPE]]*)*
+// CHECK-NEXT: call [[OPAQUE]]* [[TAKE_FN]]([[OPAQUE]]* noalias %1, [[OPAQUE]]* noalias [[X_TMP]], [[TYPE]]* %T)
+
+struct S {}
+
+
+func callDup(_ s: S) { _ = dup(s) }
+// CHECK-LABEL: define hidden swiftcc void @"$S14generic_tuples7callDupyyAA1SVF"()
+// CHECK-NEXT: entry:
+// CHECK-NEXT: call swiftcc void @"$S14generic_tuples3dupyx_xtxlF"({{.*}} undef, {{.*}} undef, %swift.type* {{.*}} @"$S14generic_tuples1SVMf", {{.*}})
+// CHECK-NEXT: ret void
+
+class C {}
+
+func dupC<T : C>(_ x: T) -> (T, T) { return (x, x) }
+// CHECK-LABEL: define hidden swiftcc { %T14generic_tuples1CC*, %T14generic_tuples1CC* } @"$S14generic_tuples4dupCyx_xtxAA1CCRbzlF"(%T14generic_tuples1CC*, %swift.type* %T)
+// CHECK-NEXT: entry:
+// CHECK: [[REF:%.*]] = bitcast %T14generic_tuples1CC* %0 to %swift.refcounted*
+// CHECK-NEXT: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[REF]])
+// CHECK-NEXT: [[REF:%.*]] = bitcast %T14generic_tuples1CC* %0 to %swift.refcounted*
+// CHECK-NEXT: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[REF]])
+// CHECK-NEXT: [[TUP1:%.*]] = insertvalue { %T14generic_tuples1CC*, %T14generic_tuples1CC* } undef, %T14generic_tuples1CC* %0, 0
+// CHECK-NEXT: [[TUP2:%.*]] = insertvalue { %T14generic_tuples1CC*, %T14generic_tuples1CC* } [[TUP1:%.*]], %T14generic_tuples1CC* %0, 1
+// CHECK-NEXT: ret { %T14generic_tuples1CC*, %T14generic_tuples1CC* } [[TUP2]]
+
+func callDupC(_ c: C) { _ = dupC(c) }
+// CHECK-LABEL: define hidden swiftcc void @"$S14generic_tuples8callDupCyyAA1CCF"(%T14generic_tuples1CC*)
+// CHECK-NEXT: entry:
+// CHECK-NEXT: [[METATYPE:%.*]] = call %swift.type* @"$S14generic_tuples1CCMa"()
+// CHECK-NEXT: [[TUPLE:%.*]] = call swiftcc { %T14generic_tuples1CC*, %T14generic_tuples1CC* } @"$S14generic_tuples4dupCyx_xtxAA1CCRbzlF"(%T14generic_tuples1CC* %0, %swift.type* [[METATYPE]])
+// CHECK-NEXT: [[LEFT:%.*]] = extractvalue { %T14generic_tuples1CC*, %T14generic_tuples1CC* } [[TUPLE]], 0
+// CHECK-NEXT: [[RIGHT:%.*]] = extractvalue { %T14generic_tuples1CC*, %T14generic_tuples1CC* } [[TUPLE]], 1
+// CHECK-NEXT: [[LEFT_CAST:%.*]] = bitcast %T14generic_tuples1CC* [[LEFT]] to %swift.refcounted*
+// CHECK-NEXT: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[LEFT_CAST]]
+// CHECK-NEXT: [[RIGHT_CAST:%.*]] = bitcast %T14generic_tuples1CC* [[RIGHT]] to %swift.refcounted*
+// CHECK-NEXT: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[RIGHT_CAST]]
+// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* [[LEFT]])
+// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* [[RIGHT]])
+// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* [[RIGHT]])
+// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* [[LEFT]])
+// CHECK-NEXT: ret void
+
+// CHECK: define hidden swiftcc i64 @"$S14generic_tuples4lumpySi_xxtxlF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T)
+func lump<T>(_ x: T) -> (Int, T, T) { return (0,x,x) }
+// CHECK: define hidden swiftcc { i64, i64 } @"$S14generic_tuples5lump2ySi_SixtxlF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T)
+func lump2<T>(_ x: T) -> (Int, Int, T) { return (0,0,x) }
+// CHECK: define hidden swiftcc void @"$S14generic_tuples5lump3yx_xxtxlF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T)
+func lump3<T>(_ x: T) -> (T, T, T) { return (x,x,x) }
+// CHECK: define hidden swiftcc i64 @"$S14generic_tuples5lump4yx_SixtxlF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T)
+func lump4<T>(_ x: T) -> (T, Int, T) { return (x,0,x) }
+
+// CHECK: define hidden swiftcc i64 @"$S14generic_tuples6unlumpyS2i_xxt_tlF"(i64, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T)
+func unlump<T>(_ x: (Int, T, T)) -> Int { return x.0 }
+// CHECK: define hidden swiftcc void @"$S14generic_tuples7unlump1yxSi_xxt_tlF"(%swift.opaque* noalias nocapture sret, i64, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T)
+func unlump1<T>(_ x: (Int, T, T)) -> T { return x.1 }
+// CHECK: define hidden swiftcc void @"$S14generic_tuples7unlump2yxx_Sixt_tlF"(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture, i64, %swift.opaque* noalias nocapture, %swift.type* %T)
+func unlump2<T>(_ x: (T, Int, T)) -> T { return x.0 }
+// CHECK: define hidden swiftcc i64 @"$S14generic_tuples7unlump3ySix_Sixt_tlF"(%swift.opaque* noalias nocapture, i64, %swift.opaque* noalias nocapture, %swift.type* %T)
+func unlump3<T>(_ x: (T, Int, T)) -> Int { return x.1 }
+
+
+// CHECK: tuple_existentials
+func tuple_existentials() {
+ // Empty tuple:
+ var a : Any = ()
+ // CHECK: store %swift.type* getelementptr inbounds (%swift.full_type, %swift.full_type* @"$SytN", i32 0, i32 1),
+
+ // 2 element tuple
+ var t2 = (1,2.0)
+ a = t2
+ // CHECK: call %swift.type* @swift_getTupleTypeMetadata2({{.*}}@"$SSiN{{.*}}",{{.*}}@"$SSdN{{.*}}", i8* null, i8** null)
+
+
+ // 3 element tuple
+ var t3 = ((),(),())
+ a = t3
+ // CHECK: call %swift.type* @swift_getTupleTypeMetadata3({{.*}}@"$SytN{{.*}},{{.*}}@"$SytN{{.*}},{{.*}}@"$SytN{{.*}}, i8* null, i8** null)
+
+ // 4 element tuple
+ var t4 = (1,2,3,4)
+ a = t4
+ // CHECK: call %swift.type* @swift_getTupleTypeMetadata(i64 4, {{.*}}, i8* null, i8** null)
+}
+
diff --git a/test/IRGen/plus_zero_keypaths.sil b/test/IRGen/plus_zero_keypaths.sil
new file mode 100644
index 0000000..7cafbd0
--- /dev/null
+++ b/test/IRGen/plus_zero_keypaths.sil
@@ -0,0 +1,438 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// -- Convert <i32 0x...> constants to decimal constants that LLVM will print
+// RUN: %utils/chex.py < %s > %t/keypaths.sil
+// RUN: %target-swift-frontend -emit-ir %s | %FileCheck %t/keypaths.sil --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize --check-prefix=CHECK-%target-os
+
+sil_stage canonical
+import Swift
+
+struct S: Hashable {
+ var x: Int
+ let y: String
+ var z: C
+ var reabstracted: () -> ()
+
+ var hashValue: Int { get }
+ static func ==(_: S, _: S) -> Bool
+}
+class C: Hashable {
+ final var x: Int
+ final let y: String
+ final var z: S
+ var w: Int { get set }
+
+ init()
+
+ var hashValue: Int { get }
+ static func ==(_: C, _: C) -> Bool
+}
+
+struct G<T> {
+ var x: T
+ subscript<U: Hashable>(x: U) -> T { get set }
+}
+
+sil_vtable C {}
+
+// CHECK: %TSi = type <{ [[WORD:i.*]] }>
+
+// -- %a: S.x
+// CHECK: [[KP_A:@keypath.*]] = private global <{ {{.*}} }> <{
+// CHECK-SAME: [[WORD]] 0,
+// CHECK-SAME: %swift.type* (i8*)*
+// CHECK-SAME: %swift.type* (i8*)*
+// -- instantiable in-line, size 4
+// CHECK-SAME: <i32 0x8000_0004>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// -- offset of S.x
+// CHECK-SAME: i32 0 }>
+
+// -- %b: S.y
+// CHECK: [[KP_B:@keypath.*]] = private global <{ {{.*}} }> <{
+// CHECK-SAME: [[WORD]] 0,
+// CHECK-SAME: %swift.type* (i8*)*
+// CHECK-SAME: %swift.type* (i8*)*
+// -- instantiable in-line, size 4
+// CHECK-SAME: <i32 0x8000_0004>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// -- offset of S.y
+// CHECK-32-SAME: i32 4 }>
+// CHECK-64-SAME: i32 8 }>
+
+// -- %c: S.z
+// CHECK: [[KP_C:@keypath.*]] = private global <{ {{.*}} }> <{
+// CHECK-SAME: [[WORD]] 0,
+// CHECK-SAME: %swift.type* (i8*)*
+// CHECK-SAME: %swift.type* (i8*)*
+// -- instantiable in-line, size 4
+// CHECK-SAME: <i32 0x8000_0004>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// -- offset of S.z
+// CHECK-32-SAME: i32 16 }>
+// CHECK-64-SAME: i32 24 }>
+
+// -- %d: C.x
+// CHECK: [[KP_D:@keypath.*]] = private global <{ {{.*}} }> <{
+// CHECK-SAME: [[WORD]] 0,
+// CHECK-SAME: %swift.type* (i8*)*
+// CHECK-SAME: %swift.type* (i8*)*
+// -- instantiable in-line, size 4
+// CHECK-SAME: <i32 0x8000_0004>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// -- 0x0200_0000 (class) + offset of C.x
+// CHECK-32-SAME: <i32 0x0200_0008> }>
+// CHECK-64-SAME: <i32 0x0200_0010> }>
+
+// -- %e: C.y
+// CHECK: [[KP_E:@keypath.*]] = private global <{ {{.*}} }> <{
+// CHECK-SAME: [[WORD]] 0,
+// CHECK-SAME: %swift.type* (i8*)*
+// CHECK-SAME: %swift.type* (i8*)*
+// -- instantiable in-line, size 4
+// CHECK-SAME: <i32 0x8000_0004>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// -- 0x0200_0000 (class) + offset of C.y
+// CHECK-32-SAME: <i32 0x0200_000c> }>
+// CHECK-64-SAME: <i32 0x0200_0018> }>
+
+// -- %f: C.z
+// CHECK: [[KP_F:@keypath.*]] = private global <{ {{.*}} }> <{
+// CHECK-SAME: [[WORD]] 0,
+// CHECK-SAME: %swift.type* (i8*)*
+// CHECK-SAME: %swift.type* (i8*)*
+// -- instantiable in-line, size 4
+// CHECK-SAME: <i32 0x8000_0004>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// -- 0x0200_0000 (class) + offset of C.z
+// CHECK-32-SAME: <i32 0x0200_0018> }>
+// CHECK-64-SAME: <i32 0x0200_0028> }>
+
+// -- %g: S.z.x
+// CHECK: [[KP_G:@keypath.*]] = private global <{ {{.*}} }> <{
+// CHECK-SAME: [[WORD]] 0,
+// CHECK-SAME: %swift.type* (i8*)*
+// CHECK-SAME: %swift.type* (i8*)*
+// -- instantiable in-line, size 12
+// CHECK-32-SAME: <i32 0x8000_000c>,
+// -- instantiable in-line, size 20
+// CHECK-64-SAME: <i32 0x8000_0014>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// -- offset of S.z
+// CHECK-32-SAME: i32 16,
+// CHECK-64-SAME: i32 24,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// CHECK: %swift.type* (i8*)*
+// -- 0x0200_0000 (class) + offset of C.x
+// CHECK-32-SAME: <i32 0x0200_0008> }>
+// CHECK-64-SAME: <i32 0x0200_0010> }>
+
+// -- %h: C.z.x
+// CHECK: [[KP_H:@keypath.*]] = private global <{ {{.*}} }> <{
+// CHECK-SAME: [[WORD]] 0,
+// CHECK-SAME: %swift.type* (i8*)*
+// CHECK-SAME: %swift.type* (i8*)*
+// -- instantiable in-line, size 12
+// CHECK-32-SAME: <i32 0x8000_000c>,
+// -- instantiable in-line, size 20
+// CHECK-64-SAME: <i32 0x8000_0014>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// -- 0x0200_0000 (class) + offset of C.z
+// CHECK-32-SAME: <i32 0x0200_0018>,
+// CHECK-64-SAME: <i32 0x0200_0028>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// CHECK: %swift.type* (i8*)*
+// -- offset of S.x
+// CHECK-SAME: i32 0 }>
+
+// -- %k: computed
+// CHECK: [[KP_K:@keypath.*]] = private global <{ {{.*}} }> <{
+// CHECK-SAME: [[WORD]] 0,
+// CHECK-SAME: %swift.type* (i8*)*
+// CHECK-SAME: %swift.type* (i8*)*
+// -- instantiable in-line, size 24
+// CHECK-64-SAME: <i32 0x8000_0018>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// -- instantiable in-line, size 12
+// CHECK-32-SAME: <i32 0x8000_000c>,
+// -- computed, get-only, identified by function pointer, no args
+// CHECK-SAME: <i32 0x0100_0000>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// CHECK-SAME: void ()* @k_id,
+// CHECK-SAME: void (%TSi*, %T8keypaths1SV*)* @k_get }>
+
+// -- %l: computed
+// CHECK: [[KP_L:@keypath.*]] = private global <{ {{.*}} }> <{
+// CHECK-SAME: [[WORD]] 0,
+// CHECK-SAME: %swift.type* (i8*)*
+// CHECK-SAME: %swift.type* (i8*)*
+// -- instantiable in-line, size 32
+// CHECK-64-SAME: <i32 0x8000_0020>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// -- instantiable in-line, size 16
+// CHECK-32-SAME: <i32 0x8000_0010>,
+// -- computed, settable, nonmutating, identified by vtable, no args
+// CHECK-SAME: <i32 0x0150_0000>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// CHECK-SAME: [[WORD]]
+// CHECK-SAME: void (%TSi*, %T8keypaths1CC**)* @l_get,
+// CHECK-SAME: void (%TSi*, %T8keypaths1CC**)* @l_set }>
+
+// -- %m: computed
+// CHECK: [[KP_M:@keypath.*]] = private global <{ {{.*}} }> <{
+// CHECK-SAME: [[WORD]] 0,
+// CHECK-SAME: %swift.type* (i8*)*
+// CHECK-SAME: %swift.type* (i8*)*
+// -- instantiable in-line, size 32
+// CHECK-64-SAME: <i32 0x8000_0020>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// -- instantiable in-line, size 16
+// CHECK-32-SAME: <i32 0x8000_0010>,
+// -- computed, settable, nonmutating, identified by property offset, no args
+// CHECK-SAME: <i32 0x01e0_0000>,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// CHECK-SAME: [[WORD]]
+// CHECK-SAME: void (%swift.function*, %T8keypaths1SV*)* @m_get,
+// CHECK-SAME: void (%swift.function*, %T8keypaths1SV*)* @m_set }>
+
+
+// -- %i: Gen<A>.x
+// CHECK: [[KP_I:@keypath.*]] = private global <{ {{.*}} }> <{
+// CHECK-SAME: [[WORD]] 0,
+// CHECK-SAME: %swift.type* (i8*)* [[I_GET_GEN_A_A:@[a-z_.0-9]+]],
+// CHECK-SAME: %swift.type* (i8*)* [[I_GET_A:@[a-z_.0-9]+]],
+// -- size 8
+// CHECK-SAME: i32 8,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// -- struct with runtime-resolved offset
+// CHECK-SAME: <i32 0x00fffffe>,
+// CHECK-32-SAME: i32 16 }>
+// CHECK-64-SAME: i32 32 }>
+
+// -- %j: Gen<A>.y
+// CHECK: [[KP_J:@keypath.*]] = private global <{ {{.*}} }> <{
+// CHECK-SAME: [[WORD]] 0,
+// CHECK-SAME: %swift.type* (i8*)* [[J_GET_GEN_A_A:@[a-z_.0-9]+]],
+// CHECK-SAME: %swift.type* (i8*)* [[J_GET_A:@[a-z_.0-9]+]],
+// -- size 8
+// CHECK-SAME: i32 8,
+// CHECK-64-SAME: [4 x i8] zeroinitializer,
+// -- struct with runtime-resolved offset
+// CHECK-SAME: <i32 0x00fffffe>,
+// CHECK-32-SAME: i32 20 }>
+// CHECK-64-SAME: i32 40 }>
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @stored_property_fixed_offsets()
+sil @stored_property_fixed_offsets : $@convention(thin) () -> () {
+entry:
+ // CHECK: call %swift.refcounted* @swift_getKeyPath(i8* bitcast ({{.*}} [[KP_A]] to i8*), i8* undef)
+ %a = keypath $KeyPath<S, Int>, (root $S; stored_property #S.x : $Int)
+ // CHECK: call %swift.refcounted* @swift_getKeyPath(i8* bitcast ({{.*}} [[KP_B]] to i8*), i8* undef)
+ %b = keypath $KeyPath<S, String>, (root $S; stored_property #S.y : $String)
+ // CHECK: call %swift.refcounted* @swift_getKeyPath(i8* bitcast ({{.*}} [[KP_C]] to i8*), i8* undef)
+ %c = keypath $KeyPath<S, C>, (root $S; stored_property #S.z : $C)
+
+ // CHECK: call %swift.refcounted* @swift_getKeyPath(i8* bitcast ({{.*}} [[KP_D]] to i8*), i8* undef)
+ %d = keypath $KeyPath<C, Int>, (root $C; stored_property #C.x : $Int)
+ // CHECK: call %swift.refcounted* @swift_getKeyPath(i8* bitcast ({{.*}} [[KP_E]] to i8*), i8* undef)
+ %e = keypath $KeyPath<C, String>, (root $C; stored_property #C.y : $String)
+ // CHECK: call %swift.refcounted* @swift_getKeyPath(i8* bitcast ({{.*}} [[KP_F]] to i8*), i8* undef)
+ %f = keypath $KeyPath<C, S>, (root $C; stored_property #C.z : $S)
+
+ // CHECK: call %swift.refcounted* @swift_getKeyPath(i8* bitcast ({{.*}} [[KP_G]] to i8*), i8* undef)
+ %g = keypath $KeyPath<S, Int>, (root $S; stored_property #S.z : $C; stored_property #C.x : $Int)
+ // CHECK: call %swift.refcounted* @swift_getKeyPath(i8* bitcast ({{.*}} [[KP_H]] to i8*), i8* undef)
+ %h = keypath $KeyPath<C, Int>, (root $C; stored_property #C.z : $S; stored_property #S.x : $Int)
+
+ %k = keypath $KeyPath<S, Int>, (root $S; gettable_property $Int, id @k_id : $@convention(thin) () -> (), getter @k_get : $@convention(thin) (@in_guaranteed S) -> @out Int)
+ %l = keypath $KeyPath<C, Int>, (root $C; settable_property $Int, id #C.w!getter.1, getter @l_get : $@convention(thin) (@in_guaranteed C) -> @out Int, setter @l_set : $@convention(thin) (@in_guaranteed Int, @in_guaranteed C) -> ())
+ %m = keypath $KeyPath<S, () -> ()>, (root $S; settable_property $() -> (), id ##S.reabstracted, getter @m_get : $@convention(thin) (@in_guaranteed S) -> @out @callee_guaranteed (@in_guaranteed ()) -> @out (), setter @m_set : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed ()) -> @out (), @inout S) -> ())
+
+ return undef : $()
+}
+
+sil @k_id : $@convention(thin) () -> ()
+sil @k_get : $@convention(thin) (@in_guaranteed S) -> @out Int
+
+sil @l_get : $@convention(thin) (@in_guaranteed C) -> @out Int
+sil @l_set : $@convention(thin) (@in_guaranteed Int, @in_guaranteed C) -> ()
+
+sil @m_get : $@convention(thin) (@in_guaranteed S) -> @out @callee_guaranteed (@in_guaranteed ()) -> @out ()
+sil @m_set : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed ()) -> @out (), @inout S) -> ()
+
+struct Gen<T, U> {
+ var x: T
+ var y: U
+}
+
+struct Foo<T> {
+ var foo: T
+}
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @stored_property_generics(%swift.type* %T, %swift.type* %U)
+sil @stored_property_generics : $@convention(thin) <T, U> () -> () {
+entry:
+ // CHECK: [[PTR:%.*]] = bitcast i8* [[ARGS:%.*]] to
+ // CHECK: store %swift.type* %T, %swift.type** [[PTR]]
+ // CHECK: call %swift.refcounted* @swift_getKeyPath(i8* bitcast ({{.*}} [[KP_I]] to i8*), i8* [[ARGS]])
+ %i = keypath $KeyPath<Gen<T,T>, T>, <A> (root $Gen<A, A>; stored_property #Gen.x : $A) <T>
+
+ // CHECK: [[PTR:%.*]] = bitcast i8* [[ARGS:%.*]] to
+ // CHECK: store %swift.type* %U, %swift.type** [[PTR]]
+ // CHECK: call %swift.refcounted* @swift_getKeyPath(i8* bitcast ({{.*}} [[KP_J]] to i8*), i8* [[ARGS]])
+ %j = keypath $KeyPath<Gen<U,U>, U>, <A> (root $Gen<A, A>; stored_property #Gen.y : $A) <U>
+
+ // CHECK: [[PTR:%.*]] = bitcast i8* [[ARGS:%.*]] to
+ // CHECK: [[FOO_T:%.*]] = call %swift.type* @"$S8keypaths3FooVMa"(%swift.type* %T)
+ // CHECK: store %swift.type* [[FOO_T]], %swift.type** [[PTR]]
+ // CHECK: call %swift.refcounted* @swift_getKeyPath(i8* bitcast ({{.*}} [[KP_I]] to i8*), i8* [[ARGS]])
+ %i2 = keypath $KeyPath<Gen<Foo<T>,Foo<T>>, Foo<T>>, <A> (root $Gen<A, A>; stored_property #Gen.x : $A) <Foo<T>>
+
+ return undef : $()
+}
+
+// CHECK: define private %swift.type* [[I_GET_GEN_A_A]](i8*)
+// CHECK: [[BUF:%.*]] = bitcast i8* %0
+// CHECK: [[A:%.*]] = load %swift.type*, %swift.type** [[BUF]]
+// CHECK: [[GEN:%.*]] = call %swift.type* @"$S8keypaths3GenVMa"(%swift.type* [[A]], %swift.type* [[A]])
+// CHECK: ret %swift.type* [[GEN]]
+
+
+// CHECK: define private %swift.type* [[I_GET_A]](i8*)
+// CHECK: [[BUF:%.*]] = bitcast i8* %0
+// CHECK: [[A:%.*]] = load %swift.type*, %swift.type** [[BUF]]
+// CHECK: ret %swift.type* [[A]]
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @computed_property_generics
+sil @computed_property_generics : $@convention(thin) <T, U> () -> () {
+entry:
+ %n = keypath $WritableKeyPath<T, U>, <UUU, TTT> (root $TTT; settable_property $UUU, id @n_get : $@convention(thin) <UU, TT> (@in_guaranteed TT) -> @out UU, getter @n_get : $@convention(thin) <UU, TT> (@in_guaranteed TT) -> @out UU, setter @n_set : $@convention(thin) <UU, TT> (@in_guaranteed UU, @in_guaranteed TT) -> ()) <U, T>
+
+ return undef : $()
+}
+
+sil @n_get : $@convention(thin) <UU, TT> (@in_guaranteed TT) -> @out UU
+sil @n_set : $@convention(thin) <UU, TT> (@in_guaranteed UU, @in_guaranteed TT) -> ()
+
+sil @computed_property_indices : $@convention(thin) (C, S, C, S, C, S) -> () {
+entry(%0 : $C, %1 : $S, %2 : $C, %3 : $S, %4 : $C, %5 : $S):
+ %o = keypath $WritableKeyPath<S, C>, (
+ root $S;
+ settable_property $C,
+ id @o_get : $@convention(thin) (@in_guaranteed S, UnsafeRawPointer) -> @out C,
+ getter @o_get : $@convention(thin) (@in_guaranteed S, UnsafeRawPointer) -> @out C,
+ setter @o_set : $@convention(thin) (@in_guaranteed C, @in_guaranteed S, UnsafeRawPointer) -> (),
+ indices [%$0 : $C : $C],
+ indices_equals @o_equals : $@convention(thin) (UnsafeRawPointer, UnsafeRawPointer) -> Bool,
+ indices_hash @o_hash : $@convention(thin) (UnsafeRawPointer) -> Int
+ ) (%0)
+ %p = keypath $WritableKeyPath<S, C>, (
+ root $S;
+ settable_property $C,
+ id @o_get : $@convention(thin) (@in_guaranteed S, UnsafeRawPointer) -> @out C,
+ getter @o_get : $@convention(thin) (@in_guaranteed S, UnsafeRawPointer) -> @out C,
+ setter @o_set : $@convention(thin) (@in_guaranteed C, @in_guaranteed S, UnsafeRawPointer) -> (),
+ indices [%$0 : $S : $S, %$1 : $C : $C],
+ indices_equals @o_equals : $@convention(thin) (UnsafeRawPointer, UnsafeRawPointer) -> Bool,
+ indices_hash @o_hash : $@convention(thin) (UnsafeRawPointer) -> Int
+ ) (%1, %2)
+ %r = keypath $WritableKeyPath<S, S>, (
+ root $S;
+ settable_property $C,
+ id @o_get : $@convention(thin) (@in_guaranteed S, UnsafeRawPointer) -> @out C,
+ getter @o_get : $@convention(thin) (@in_guaranteed S, UnsafeRawPointer) -> @out C,
+ setter @o_set : $@convention(thin) (@in_guaranteed C, @in_guaranteed S, UnsafeRawPointer) -> (),
+ indices [%$0 : $S : $S, %$1 : $C : $C],
+ indices_equals @o_equals : $@convention(thin) (UnsafeRawPointer, UnsafeRawPointer) -> Bool,
+ indices_hash @o_hash : $@convention(thin) (UnsafeRawPointer) -> Int;
+ settable_property $S,
+ id @r_get : $@convention(thin) (@in_guaranteed C, UnsafeRawPointer) -> @out S,
+ getter @r_get : $@convention(thin) (@in_guaranteed C, UnsafeRawPointer) -> @out S,
+ setter @r_set : $@convention(thin) (@in_guaranteed S, @in_guaranteed C, UnsafeRawPointer) -> (),
+ indices [%$2 : $S : $S],
+ indices_equals @o_equals : $@convention(thin) (UnsafeRawPointer, UnsafeRawPointer) -> Bool,
+ indices_hash @o_hash : $@convention(thin) (UnsafeRawPointer) -> Int
+ ) (%3, %4, %5)
+
+ return undef : $()
+}
+
+sil @o_get : $@convention(thin) (@in_guaranteed S, UnsafeRawPointer) -> @out C
+sil @o_set : $@convention(thin) (@in_guaranteed C, @in_guaranteed S, UnsafeRawPointer) -> ()
+sil @o_equals : $@convention(thin) (UnsafeRawPointer, UnsafeRawPointer) -> Bool
+sil @o_hash : $@convention(thin) (UnsafeRawPointer) -> Int
+
+sil @r_get : $@convention(thin) (@in_guaranteed C, UnsafeRawPointer) -> @out S
+sil @r_set : $@convention(thin) (@in_guaranteed S, @in_guaranteed C, UnsafeRawPointer) -> ()
+
+sil @generic_computed_property_indices : $@convention(thin) <A: Hashable, B: Hashable> (@in_guaranteed A, @in_guaranteed B, @in_guaranteed A, @in_guaranteed B, @in_guaranteed A, @in_guaranteed B) -> () {
+entry(%0 : $*A, %1 : $*B, %2 : $*A, %3 : $*B, %4 : $*A, %5 : $*B):
+ %s = keypath $WritableKeyPath<A, B>, <X: Hashable, Y: Hashable> (
+ root $X;
+ settable_property $Y,
+ id @s_get : $@convention(thin) <T: Hashable, U: Hashable> (@in_guaranteed T, UnsafeRawPointer) -> @out U,
+ getter @s_get : $@convention(thin) <T: Hashable, U: Hashable> (@in_guaranteed T, UnsafeRawPointer) -> @out U,
+ setter @s_set : $@convention(thin) <T: Hashable, U: Hashable> (@in_guaranteed U, @in_guaranteed T, UnsafeRawPointer) -> (),
+ indices [%$0 : $X : $*X],
+ indices_equals @s_equals : $@convention(thin) <T: Hashable, U: Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool,
+ indices_hash @s_hash : $@convention(thin) <T: Hashable, U: Hashable> (UnsafeRawPointer) -> Int
+ ) <A, B> (%0)
+ %t = keypath $WritableKeyPath<A, B>, <X: Hashable, Y: Hashable> (
+ root $X;
+ settable_property $Y,
+ id @s_get : $@convention(thin) <T: Hashable, U: Hashable> (@in_guaranteed T, UnsafeRawPointer) -> @out U,
+ getter @s_get : $@convention(thin) <T: Hashable, U: Hashable> (@in_guaranteed T, UnsafeRawPointer) -> @out U,
+ setter @s_set : $@convention(thin) <T: Hashable, U: Hashable> (@in_guaranteed U, @in_guaranteed T, UnsafeRawPointer) -> (),
+ indices [%$0 : $Y : $*Y, %$1 : $X : $*X],
+ indices_equals @s_equals : $@convention(thin) <T: Hashable, U: Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool,
+ indices_hash @s_hash : $@convention(thin) <T: Hashable, U: Hashable> (UnsafeRawPointer) -> Int
+ ) <A, B> (%1, %2)
+ %v = keypath $WritableKeyPath<A, A>, <X: Hashable, Y: Hashable> (
+ root $X;
+ settable_property $Y,
+ id @s_get : $@convention(thin) <T: Hashable, U: Hashable> (@in_guaranteed T, UnsafeRawPointer) -> @out U,
+ getter @s_get : $@convention(thin) <T: Hashable, U: Hashable> (@in_guaranteed T, UnsafeRawPointer) -> @out U,
+ setter @s_set : $@convention(thin) <T: Hashable, U: Hashable> (@in_guaranteed U, @in_guaranteed T, UnsafeRawPointer) -> (),
+ indices [%$0 : $Y : $*Y, %$1 : $X : $*X],
+ indices_equals @s_equals : $@convention(thin) <T: Hashable, U: Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool,
+ indices_hash @s_hash : $@convention(thin) <T: Hashable, U: Hashable> (UnsafeRawPointer) -> Int;
+ settable_property $X,
+ id @v_get : $@convention(thin) <T: Hashable, U: Hashable> (@in_guaranteed U, UnsafeRawPointer) -> @out T,
+ getter @v_get : $@convention(thin) <T: Hashable, U: Hashable> (@in_guaranteed U, UnsafeRawPointer) -> @out T,
+ setter @v_set : $@convention(thin) <T: Hashable, U: Hashable> (@in_guaranteed T, @in_guaranteed U, UnsafeRawPointer) -> (),
+ indices [%$2 : $Y : $*Y],
+ indices_equals @s_equals : $@convention(thin) <T: Hashable, U: Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool,
+ indices_hash @s_hash : $@convention(thin) <T: Hashable, U: Hashable> (UnsafeRawPointer) -> Int
+ ) <A, B> (%3, %4, %5)
+
+ return undef : $()
+}
+
+sil @generic_external : $@convention(thin) <A: Hashable, B: Hashable> (@in_guaranteed A, @in_guaranteed B, @in_guaranteed A, @in_guaranteed B, @in_guaranteed A, @in_guaranteed B) -> () {
+entry(%0 : $*A, %1 : $*B, %2 : $*A, %3 : $*B, %4 : $*A, %5 : $*B):
+ %t = keypath $KeyPath<G<B>, B>, <Z> (
+ root $G<Z>;
+ external #G.x<Z> : $Z
+ ) <B>
+
+ %u = keypath $KeyPath<G<A>, A>, <X: Hashable, Y: Hashable> (
+ root $G<Y>;
+ external #G.subscript<Y, X> [%$0 : $X : $*X] : $Y
+ ) <B, A> (%1)
+
+ %v = keypath $KeyPath<G<G<B>>, B>, <X: Hashable, Y: Hashable> (
+ root $G<G<X>>;
+ external #G.subscript<G<X>, Y> [%$1 : $Y : $*Y] : $G<X>;
+ external #G.subscript<X, X> [%$0 : $X : $*X] : $X
+ ) <B, A> (%3, %4)
+
+ return undef : $()
+}
+
+sil @s_get : $@convention(thin) <A: Hashable, B: Hashable> (@in_guaranteed A, UnsafeRawPointer) -> @out B
+sil @s_set : $@convention(thin) <A: Hashable, B: Hashable> (@in_guaranteed B, @in_guaranteed A, UnsafeRawPointer) -> ()
+sil @s_equals : $@convention(thin) <A: Hashable, B: Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool
+sil @s_hash : $@convention(thin) <A: Hashable, B: Hashable> (UnsafeRawPointer) -> Int
+
+sil @v_get : $@convention(thin) <A: Hashable, B: Hashable> (@in_guaranteed B, UnsafeRawPointer) -> @out A
+sil @v_set : $@convention(thin) <A: Hashable, B: Hashable> (@in_guaranteed A, @in_guaranteed B, UnsafeRawPointer) -> ()
diff --git a/test/IRGen/plus_zero_keypaths_objc.sil b/test/IRGen/plus_zero_keypaths_objc.sil
new file mode 100644
index 0000000..1504309
--- /dev/null
+++ b/test/IRGen/plus_zero_keypaths_objc.sil
@@ -0,0 +1,53 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %utils/chex.py < %s > %t/keypaths_objc.sil
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-ir %t/keypaths_objc.sil | %FileCheck %t/keypaths_objc.sil --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize
+// REQUIRES: objc_interop
+
+import Swift
+import Foundation
+
+class C: NSObject {
+ dynamic var x: NSString { get }
+ @sil_stored final var stored: Int
+ override init()
+}
+
+sil_vtable C {}
+
+sil @x_get : $@convention(thin) (@in_guaranteed C) -> @out NSString
+
+// CHECK: [[KEYPATH_A:@keypath.*]] = private global
+// -- 0x0100_0002: computed, get-only, indirect identifier
+// CHECK-SAME: <i32 0x0100_0002>,
+// CHECK-SAME: i8** @"\01L_selector(x)"
+
+// CHECK: [[KEYPATH_B:@keypath.*]] = private global
+// -- 0x02fffffd: class stored property with indirect offset
+// CHECK-SAME: <i32 0x02fffffd>,
+// CHECK-SAME: @"$S13keypaths_objc1CC6storedSivpWvd"
+
+// CHECK-LABEL: define swiftcc void @objc_only_property()
+sil @objc_only_property : $@convention(thin) () -> () {
+entry:
+ // CHECK: call %swift.refcounted* @swift_getKeyPath({{.*}} [[KEYPATH_A]]
+ %a = keypath $KeyPath<C, NSString>, (objc "x"; root $C; gettable_property $NSString, id #C.x!getter.1.foreign, getter @x_get : $@convention(thin) (@in_guaranteed C) -> @out NSString)
+ unreachable
+}
+
+sil hidden @$S13keypaths_objc1CC1xSo8NSStringCvgTo : $@convention(objc_method) (@guaranteed C) -> NSString {
+entry(%0 : $C):
+ unreachable
+}
+
+sil hidden @$S13keypaths_objc1CCACycfcTo : $@convention(objc_method) (@objc_metatype C.Type) -> @owned C {
+entry(%0 : $@objc_metatype C.Type):
+ unreachable
+}
+
+sil @objc_stored_property : $@convention(thin) () -> () {
+entry:
+ // CHECK: call %swift.refcounted* @swift_getKeyPath({{.*}} [[KEYPATH_B]]
+ %b = keypath $KeyPath<C, Int>, (objc "stored"; root $C; stored_property #C.stored : $Int)
+ unreachable
+}
diff --git a/test/IRGen/plus_zero_lowered_optional_self_metadata.sil b/test/IRGen/plus_zero_lowered_optional_self_metadata.sil
new file mode 100644
index 0000000..005e8bb
--- /dev/null
+++ b/test/IRGen/plus_zero_lowered_optional_self_metadata.sil
@@ -0,0 +1,33 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-ir %s
+sil_stage canonical
+
+import Swift
+
+public protocol Protocol {
+ static func foo(_: Self?)
+}
+
+// SR-3021: Ensure we pass the Self type metadata for Optional methods using the
+// formal Optional type and not a lowered SIL type.
+
+// CHECK-LABEL: @_TMaGSqFT_T__
+
+sil @optional_method : $@convention(method) <T> (@in_guaranteed Optional<T>) -> ()
+
+sil @call_optional_method_with_lowered_function : $@convention(thin) (@in_guaranteed Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()>) -> () {
+entry(%x : $*Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()>):
+ %f = function_ref @optional_method : $@convention(method) <T> (@in_guaranteed Optional<T>) -> ()
+ apply %f<() -> ()>(%x) : $@convention(method) <T> (@in_guaranteed Optional<T>) -> ()
+ %p = partial_apply [callee_guaranteed] %f<() -> ()>() : $@convention(method) <T> (@in_guaranteed Optional<T>) -> ()
+ return undef : $()
+}
+
+// SR-3548: Ensure we correctly emit "metadata for layout" for lowered Optional types.
+
+sil @alloc_stack_optional_with_generic : $@convention(thin) <T> () -> () {
+ %a = alloc_stack $*Optional<(T, @convention(thin) () -> ())>
+ dealloc_stack %a : $*Optional<(T, @convention(thin) () -> ())>
+ %t = tuple ()
+ return %t : $()
+}
diff --git a/test/IRGen/plus_zero_objc.swift b/test/IRGen/plus_zero_objc.swift
new file mode 100644
index 0000000..634a5a6
--- /dev/null
+++ b/test/IRGen/plus_zero_objc.swift
@@ -0,0 +1,148 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %build-irgen-test-overlays
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -primary-file %s -emit-ir -disable-objc-attr-requires-foundation-module | %FileCheck %s
+
+// REQUIRES: CPU=x86_64
+// REQUIRES: objc_interop
+
+import Foundation
+import gizmo
+
+// CHECK: [[TYPE:%swift.type]] = type
+// CHECK: [[BLAMMO:%T4objc6BlammoC]] = type
+// CHECK: [[MYBLAMMO:%T4objc8MyBlammoC]] = type
+// CHECK: [[TEST2:%T4objc5Test2C]] = type
+// CHECK: [[OBJC:%objc_object]] = type
+// CHECK: [[ID:%T4objc2idV]] = type <{ %AnyObject }>
+// CHECK: [[GIZMO:%TSo5GizmoC]] = type
+// CHECK: [[RECT:%TSo4RectV]] = type
+// CHECK: [[FLOAT:%TSf]] = type
+
+// CHECK: @"\01L_selector_data(bar)" = private global [4 x i8] c"bar\00", section "__TEXT,__objc_methname,cstring_literals", align 1
+// CHECK: @"\01L_selector(bar)" = private externally_initialized global i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"\01L_selector_data(bar)", i64 0, i64 0), section "__DATA,__objc_selrefs,literal_pointers,no_dead_strip", align 8
+
+// CHECK: @"$SSo4RectVMn" = linkonce_odr hidden constant
+// CHECK: @"$SSo4RectVN" = linkonce_odr hidden global
+
+// CHECK: @"\01L_selector_data(acquiesce)"
+// CHECK-NOT: @"\01L_selector_data(disharmonize)"
+// CHECK: @"\01L_selector_data(eviscerate)"
+
+struct id {
+ var data : AnyObject
+}
+
+// Exporting something as [objc] doesn't make it an ObjC class.
+@objc class Blammo {
+}
+// Class and methods are [objc] by inheritance.
+class MyBlammo : Blammo {
+ func foo() {}
+// CHECK: define hidden swiftcc void @"$S4objc8MyBlammoC3fooyyF"([[MYBLAMMO]]* swiftself) {{.*}} {
+// CHECK: call {{.*}} @swift_release
+// CHECK: ret void
+}
+
+// Class and methods are [objc] by inheritance.
+class Test2 : Gizmo {
+ func foo() {}
+// CHECK: define hidden swiftcc void @"$S4objc5Test2C3fooyyF"([[TEST2]]* swiftself) {{.*}} {
+// CHECK: call {{.*}} @objc_release
+// CHECK: ret void
+
+ dynamic func bar() {}
+}
+
+// Test @nonobjc.
+class Contrarian : Blammo {
+ func acquiesce() {}
+ @nonobjc func disharmonize() {}
+ @nonobjc func eviscerate() {}
+}
+
+class Octogenarian : Contrarian {
+ // Override of @nonobjc is @objc again unless made @nonobjc.
+ @nonobjc override func disharmonize() {}
+
+ // Override of @nonobjc can be @objc.
+ @objc override func eviscerate() {}
+}
+
+@_silgen_name("unknown")
+func unknown(_ x: id) -> id
+
+// CHECK: define hidden swiftcc %objc_object* @"$S4objc5test0{{[_0-9a-zA-Z]*}}F"(%objc_object*)
+// CHECK-NOT: call {{.*}} @swift_unknownRetain
+// CHECK: call {{.*}} @swift_unknownRetain
+// CHECK-NOT: call {{.*}} @swift_unknownRelease
+// CHECK: call {{.*}} @swift_unknownRelease
+// CHECK: ret %objc_object*
+func test0(_ arg: id) -> id {
+ var x : id
+ x = arg
+ unknown(x)
+ var y = x
+ return y
+}
+
+func test1(_ cell: Blammo) {}
+// CHECK: define hidden swiftcc void @"$S4objc5test1{{[_0-9a-zA-Z]*}}F"([[BLAMMO]]*) {{.*}} {
+// CHECK-NEXT: entry
+// CHECK-NEXT: ret void
+
+
+// FIXME: These ownership convention tests should become SILGen tests.
+func test2(_ v: Test2) { v.bar() }
+func test3() -> NSObject {
+ return Gizmo()
+}
+// Normal message send with argument, no transfers.
+func test5(_ g: Gizmo) {
+ Gizmo.inspect(g)
+}
+// The argument to consume: is __attribute__((ns_consumed)).
+func test6(_ g: Gizmo) {
+ Gizmo.consume(g)
+}
+// fork is __attribute__((ns_consumes_self)).
+func test7(_ g: Gizmo) {
+ g.fork()
+}
+// clone is __attribute__((ns_returns_retained)).
+func test8(_ g: Gizmo) {
+ g.clone()
+}
+// duplicate has an object returned at +0.
+func test9(_ g: Gizmo) {
+ g.duplicate()
+}
+
+func test10(_ g: Gizmo, r: Rect) {
+ Gizmo.run(with: r, andGizmo:g);
+}
+
+// Force the emission of the Rect metadata.
+func test11_helper<T>(_ t: T) {}
+// NSRect's metadata needs to be uniqued at runtime using getForeignTypeMetadata.
+// CHECK-LABEL: define hidden swiftcc void @"$S4objc6test11yySo4RectVF"
+// CHECK: call %swift.type* @swift_getForeignTypeMetadata({{.*}} @"$SSo4RectVN"
+func test11(_ r: Rect) { test11_helper(r) }
+
+class WeakObjC {
+ weak var obj: NSObject?
+ weak var id: AnyObject?
+
+ init() {
+ var foo = obj
+ var bar: AnyObject? = id
+ }
+}
+
+// rdar://17528908
+// CHECK: i32 1, !"Objective-C Version", i32 2}
+// CHECK: i32 1, !"Objective-C Image Info Version", i32 0}
+// CHECK: i32 1, !"Objective-C Image Info Section", !"__DATA,__objc_imageinfo,regular,no_dead_strip"}
+// 1536 == (6 << 8). 6 is the Swift ABI version.
+// CHECK: i32 4, !"Objective-C Garbage Collection", i32 1536}
+// CHECK: i32 1, !"Swift Version", i32 6}
diff --git a/test/IRGen/plus_zero_objc_retainAutoreleasedReturnValue.swift b/test/IRGen/plus_zero_objc_retainAutoreleasedReturnValue.swift
new file mode 100644
index 0000000..67bf5d9
--- /dev/null
+++ b/test/IRGen/plus_zero_objc_retainAutoreleasedReturnValue.swift
@@ -0,0 +1,40 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -target x86_64-apple-macosx10.12 -assume-parsing-unqualified-ownership-sil -import-objc-header %S/Inputs/StaticInline.h %s -emit-ir | %FileCheck %s
+// RUN: %target-swift-frontend -O -target x86_64-apple-macosx10.12 -assume-parsing-unqualified-ownership-sil -import-objc-header %S/Inputs/StaticInline.h %s -emit-ir | %FileCheck %s --check-prefix=OPT
+
+// REQUIRES: objc_interop
+// REQUIRES: CPU=x86_64
+// REQUIRES: OS=macosx
+import Foundation
+
+@inline(never)
+public func useClosure(_ dict: NSDictionary, _ action : (NSDictionary) -> ()) {
+ action(dict)
+}
+
+@inline(never)
+public func test(_ dict: NSDictionary) {
+ useClosure(dict, { $0.objectEnumerator()} )
+}
+
+// Don't tail call objc_retainAutoreleasedReturnValue as this would block the
+// autorelease return value optimization.
+
+// callq 0x01ec08 ; symbol stub for: objc_msgSend
+// movq %rax, %rdi
+// popq %rbp ;<== Blocks the handshake from objc_autoreleaseReturnValue
+// jmp 0x01ec20 ; symbol stub for: objc_retainAutoreleasedReturnValue
+
+// CHECK-LABEL: define {{.*}}swiftcc void @"$S34objc_retainAutoreleasedReturnValue4testyySo12NSDictionaryCFyADXEfU_"(%TSo12NSDictionaryC*)
+// CHECK: entry:
+// CHECK: call {{.*}}@objc_msgSend
+// CHECK: notail call i8* @objc_retainAutoreleasedReturnValue
+// CHECK: ret void
+
+// CHECK-LABEL: define {{.*}}swiftcc void @"$SSo12NSDictionaryCSo12NSEnumeratorCIggo_ABIegg_TR"(%TSo12NSDictionaryC*, i8*, %swift.opaque*)
+
+// OPT-LABEL: define {{.*}}swiftcc void @"$S34objc_retainAutoreleasedReturnValue10useClosureyySo12NSDictionaryC_yADXEtF06$SSo12h44CSo12NSEnumeratorCIggo_ABIegg_TR049$S34objc_bcD42Value4testyySo12a6CFSo12B8CADXEfU_Tf3npf_nTf1nc_n"(%TSo12NSDictionaryC*)
+// OPT: entry:
+// OPT: call {{.*}}@objc_msgSend
+// OPT: notail call i8* @objc_retainAutoreleasedReturnValue
+// OPT: ret void
diff --git a/test/IRGen/plus_zero_runtime_calling_conventions.swift b/test/IRGen/plus_zero_runtime_calling_conventions.swift
new file mode 100644
index 0000000..8322258
--- /dev/null
+++ b/test/IRGen/plus_zero_runtime_calling_conventions.swift
@@ -0,0 +1,19 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -parse-as-library -emit-ir %s | %FileCheck %s
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -parse-as-library -O -emit-ir %s | %FileCheck --check-prefix=OPT-CHECK %s
+
+// Test that runtime functions are invoked using the new calling convention.
+
+public class C {
+}
+
+// CHECK-LABEL: define {{(protected )?}}swiftcc void @"$S27runtime_calling_conventions3fooyyAA1CCF"(%T27runtime_calling_conventions1CC*)
+// Check that runtime functions use a proper calling convention.
+// CHECK-NOT: call void {{.*}} @swift_release
+
+// OPT-CHECK-LABEL: define {{(protected )?}}swiftcc void @"$S27runtime_calling_conventions3fooyyAA1CCF"(%T27runtime_calling_conventions1CC* nocapture)
+// Check that runtime functions use a proper calling convention.
+// OPT-CHECK-NOT: tail call void @swift_release
+
+public func foo(_ c: C) {
+}
diff --git a/test/IRGen/plus_zero_struct_resilience.swift b/test/IRGen/plus_zero_struct_resilience.swift
new file mode 100644
index 0000000..6f0bdf7
--- /dev/null
+++ b/test/IRGen/plus_zero_struct_resilience.swift
@@ -0,0 +1,173 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_struct.swiftmodule -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
+// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_enum.swiftmodule -module-name=resilient_enum -I %t %S/../Inputs/resilient_enum.swift
+// RUN: %target-swift-frontend -I %t -emit-ir -enable-resilience %s | %FileCheck %s
+// RUN: %target-swift-frontend -I %t -emit-ir -enable-resilience -O %s
+
+import resilient_struct
+import resilient_enum
+
+// CHECK: %TSi = type <{ [[INT:i32|i64]] }>
+
+// CHECK-LABEL: @"$S17struct_resilience26StructWithResilientStorageVMf" = internal global
+
+// Resilient structs from outside our resilience domain are manipulated via
+// value witnesses
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S17struct_resilience26functionWithResilientTypes_1f010resilient_A04SizeVAF_A2FXEtF"(%swift.opaque* noalias nocapture sret, %swift.opaque* noalias nocapture, i8*, %swift.opaque*)
+
+public func functionWithResilientTypes(_ s: Size, f: (Size) -> Size) -> Size {
+// CHECK: entry:
+// CHECK-NEXT: [[FN:%.*]] = bitcast i8* %2 to void (%swift.opaque*, %swift.opaque*, %swift.refcounted*)*
+// CHECK-NEXT: [[SELF:%.*]] = bitcast %swift.opaque* %3 to %swift.refcounted*
+// CHECK-NEXT: call swiftcc void [[FN]](%swift.opaque* noalias nocapture sret %0, %swift.opaque* noalias nocapture %1, %swift.refcounted* swiftself [[SELF]])
+// CHECK-NEXT: ret void
+
+ return f(s)
+}
+
+// Rectangle has fixed layout inside its resilience domain, and dynamic
+// layout on the outside.
+//
+// Make sure we use a type metadata accessor function, and load indirect
+// field offsets from it.
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S17struct_resilience26functionWithResilientTypesyy010resilient_A09RectangleVF"(%T16resilient_struct9RectangleV* noalias nocapture)
+public func functionWithResilientTypes(_ r: Rectangle) {
+
+// CHECK: [[METADATA:%.*]] = call %swift.type* @"$S16resilient_struct9RectangleVMa"()
+// CHECK-NEXT: [[METADATA_ADDR:%.*]] = bitcast %swift.type* [[METADATA]] to [[INT]]*
+// CHECK-NEXT: [[FIELD_OFFSET_VECTOR:%.*]] = getelementptr inbounds [[INT]], [[INT]]* [[METADATA_ADDR]], [[INT]] 2
+// CHECK-NEXT: [[FIELD_OFFSET_PTR:%.*]] = getelementptr inbounds [[INT]], [[INT]]* [[FIELD_OFFSET_VECTOR]], i32 2
+// CHECK-NEXT: [[FIELD_OFFSET:%.*]] = load [[INT]], [[INT]]* [[FIELD_OFFSET_PTR]]
+// CHECK-NEXT: [[STRUCT_ADDR:%.*]] = bitcast %T16resilient_struct9RectangleV* %0 to i8*
+// CHECK-NEXT: [[FIELD_ADDR:%.*]] = getelementptr inbounds i8, i8* [[STRUCT_ADDR]], [[INT]] [[FIELD_OFFSET]]
+// CHECK-NEXT: [[FIELD_PTR:%.*]] = bitcast i8* [[FIELD_ADDR]] to %TSi*
+// CHECK-NEXT: [[FIELD_PAYLOAD_PTR:%.*]] = getelementptr inbounds %TSi, %TSi* [[FIELD_PTR]], i32 0, i32 0
+// CHECK-NEXT: [[FIELD_PAYLOAD:%.*]] = load [[INT]], [[INT]]* [[FIELD_PAYLOAD_PTR]]
+
+ _ = r.color
+
+// CHECK-NEXT: ret void
+
+}
+
+// Resilient structs from inside our resilience domain are manipulated
+// directly.
+
+public struct MySize {
+ public let w: Int
+ public let h: Int
+}
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S17struct_resilience28functionWithMyResilientTypes_1fAA0E4SizeVAE_A2EXEtF"(%T17struct_resilience6MySizeV* {{.*}}, %T17struct_resilience6MySizeV* {{.*}}, i8*, %swift.opaque*)
+public func functionWithMyResilientTypes(_ s: MySize, f: (MySize) -> MySize) -> MySize {
+// CHECK: entry:
+// CHECK-NEXT: [[FN:%.*]] = bitcast i8* %2
+// CHECK-NEXT: [[SELF:%.*]] = bitcast %swift.opaque* %3
+// CHECK-NEXT: call swiftcc void [[FN]](%T17struct_resilience6MySizeV* {{.*}} %0, {{.*}} %1, %swift.refcounted* swiftself [[SELF]])
+// CHECK-NEXT: ret void
+ return f(s)
+}
+
+// CHECK-LABEL: declare %swift.type* @"$S16resilient_struct4SizeVMa"()
+
+// Structs with resilient storage from a different resilience domain require
+// runtime metadata instantiation, just like generics.
+
+public struct StructWithResilientStorage {
+ public let s: Size
+ public let ss: (Size, Size)
+ public let n: Int
+ public let i: ResilientInt
+}
+
+// Make sure we call a function to access metadata of structs with
+// resilient layout, and go through the field offset vector in the
+// metadata when accessing stored properties.
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc {{i32|i64}} @"$S17struct_resilience26StructWithResilientStorageV1nSivg"(%T17struct_resilience26StructWithResilientStorageV* {{.*}})
+// CHECK: [[METADATA:%.*]] = call %swift.type* @"$S17struct_resilience26StructWithResilientStorageVMa"()
+// CHECK-NEXT: [[METADATA_ADDR:%.*]] = bitcast %swift.type* [[METADATA]] to [[INT]]*
+// CHECK-NEXT: [[FIELD_OFFSET_VECTOR:%.*]] = getelementptr inbounds [[INT]], [[INT]]* [[METADATA_ADDR]], [[INT]] 2
+// CHECK-NEXT: [[FIELD_OFFSET_PTR:%.*]] = getelementptr inbounds [[INT]], [[INT]]* [[FIELD_OFFSET_VECTOR]], i32 2
+// CHECK-NEXT: [[FIELD_OFFSET:%.*]] = load [[INT]], [[INT]]* [[FIELD_OFFSET_PTR]]
+// CHECK-NEXT: [[STRUCT_ADDR:%.*]] = bitcast %T17struct_resilience26StructWithResilientStorageV* %0 to i8*
+// CHECK-NEXT: [[FIELD_ADDR:%.*]] = getelementptr inbounds i8, i8* [[STRUCT_ADDR]], [[INT]] [[FIELD_OFFSET]]
+// CHECK-NEXT: [[FIELD_PTR:%.*]] = bitcast i8* [[FIELD_ADDR]] to %TSi*
+// CHECK-NEXT: [[FIELD_PAYLOAD_PTR:%.*]] = getelementptr inbounds %TSi, %TSi* [[FIELD_PTR]], i32 0, i32 0
+// CHECK-NEXT: [[FIELD_PAYLOAD:%.*]] = load [[INT]], [[INT]]* [[FIELD_PAYLOAD_PTR]]
+// CHECK-NEXT: ret [[INT]] [[FIELD_PAYLOAD]]
+
+
+// Indirect enums with resilient payloads are still fixed-size.
+
+public struct StructWithIndirectResilientEnum {
+ public let s: FunnyShape
+ public let n: Int
+}
+
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc {{i32|i64}} @"$S17struct_resilience31StructWithIndirectResilientEnumV1nSivg"(%T17struct_resilience31StructWithIndirectResilientEnumV* {{.*}})
+// CHECK: [[FIELD_PTR:%.*]] = getelementptr inbounds %T17struct_resilience31StructWithIndirectResilientEnumV, %T17struct_resilience31StructWithIndirectResilientEnumV* %0, i32 0, i32 1
+// CHECK-NEXT: [[FIELD_PAYLOAD_PTR:%.*]] = getelementptr inbounds %TSi, %TSi* [[FIELD_PTR]], i32 0, i32 0
+// CHECK-NEXT: [[FIELD_PAYLOAD:%.*]] = load [[INT]], [[INT]]* [[FIELD_PAYLOAD_PTR]]
+// CHECK-NEXT: ret [[INT]] [[FIELD_PAYLOAD]]
+
+
+// Partial application of methods on resilient value types
+
+public struct ResilientStructWithMethod {
+ public func method() {}
+}
+
+// Corner case -- type is address-only in SIL, but empty in IRGen
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S17struct_resilience29partialApplyOfResilientMethod1ryAA0f10StructWithG0V_tF"(%T17struct_resilience25ResilientStructWithMethodV* noalias nocapture)
+public func partialApplyOfResilientMethod(r: ResilientStructWithMethod) {
+ _ = r.method
+}
+
+// Type is address-only in SIL, and resilient in IRGen
+
+// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S17struct_resilience29partialApplyOfResilientMethod1sy010resilient_A04SizeV_tF"(%swift.opaque* noalias nocapture)
+public func partialApplyOfResilientMethod(s: Size) {
+ _ = s.method
+}
+
+// Public metadata accessor for our resilient struct
+
+// CHECK-LABEL: define{{( protected)?}} %swift.type* @"$S17struct_resilience6MySizeVMa"()
+// CHECK: ret %swift.type* bitcast ([[INT]]* getelementptr inbounds {{.*}} @"$S17struct_resilience6MySizeVMf", i32 0, i32 1) to %swift.type*)
+
+
+// CHECK-LABEL: define{{( protected)?}} private void @initialize_metadata_StructWithResilientStorage(i8*)
+// CHECK: [[FIELDS:%.*]] = alloca [4 x i8**]
+
+// CHECK: [[FIELDS_ADDR:%.*]] = getelementptr inbounds [4 x i8**], [4 x i8**]* [[FIELDS]], i32 0, i32 0
+
+// public let s: Size
+
+// CHECK: [[FIELD_1:%.*]] = getelementptr inbounds i8**, i8*** [[FIELDS_ADDR]], i32 0
+// CHECK: store i8** [[SIZE_AND_ALIGNMENT:%.*]], i8*** [[FIELD_1]]
+
+// public let ss: (Size, Size)
+
+// CHECK: [[FIELD_2:%.*]] = getelementptr inbounds i8**, i8*** [[FIELDS_ADDR]], i32 1
+// CHECK: store i8** [[SIZE_AND_ALIGNMENT:%.*]], i8*** [[FIELD_2]]
+
+// Fixed-layout aggregate -- we can reference a static value witness table
+// public let n: Int
+
+// CHECK: [[FIELD_3:%.*]] = getelementptr inbounds i8**, i8*** [[FIELDS_ADDR]], i32 2
+// CHECK: store i8** getelementptr inbounds (i8*, i8** @"$SBi{{32|64}}_WV", i32 {{.*}}), i8*** [[FIELD_3]]
+
+// Resilient aggregate with one field -- make sure we don't look inside it
+// public let i: ResilientInt
+// CHECK: [[FIELD_4:%.*]] = getelementptr inbounds i8**, i8*** [[FIELDS_ADDR]], i32 3
+// CHECK: store i8** [[SIZE_AND_ALIGNMENT:%.*]], i8*** [[FIELD_4]]
+
+// CHECK: call void @swift_initStructMetadata(%swift.type* {{.*}}, [[INT]] 256, [[INT]] 4, i8*** [[FIELDS_ADDR]], [[INT]]* {{.*}})
+// CHECK: store atomic %swift.type* {{.*}} @"$S17struct_resilience26StructWithResilientStorageVMf{{.*}}, %swift.type** @"$S17struct_resilience26StructWithResilientStorageVML" release,
+// CHECK: ret void
diff --git a/test/IRGen/runtime_calling_conventions.swift b/test/IRGen/runtime_calling_conventions.swift
index e7d0d97..74ca835 100644
--- a/test/IRGen/runtime_calling_conventions.swift
+++ b/test/IRGen/runtime_calling_conventions.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -parse-as-library -emit-ir %s | %FileCheck %s
// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -parse-as-library -O -emit-ir %s | %FileCheck --check-prefix=OPT-CHECK %s
diff --git a/test/IRGen/struct_resilience.swift b/test/IRGen/struct_resilience.swift
index 1151eb1..2118662 100644
--- a/test/IRGen/struct_resilience.swift
+++ b/test/IRGen/struct_resilience.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_struct.swiftmodule -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_enum.swiftmodule -module-name=resilient_enum -I %t %S/../Inputs/resilient_enum.swift
diff --git a/test/Interpreter/SDK/Foundation_test.swift b/test/Interpreter/SDK/Foundation_test.swift
index 50dfc96..f41b2a3 100644
--- a/test/Interpreter/SDK/Foundation_test.swift
+++ b/test/Interpreter/SDK/Foundation_test.swift
@@ -252,7 +252,7 @@
let _: CFArrayEqualCallBack = { DarwinBoolean($0 == $1) }
}
-#if os(OSX)
+#if os(macOS)
FoundationTestSuite.test("NSRectEdge/constants") {
// Check that the following constants have the correct type and value.
//
diff --git a/test/Interpreter/SDK/c_pointers.swift b/test/Interpreter/SDK/c_pointers.swift
index f7f3657..c295c14 100644
--- a/test/Interpreter/SDK/c_pointers.swift
+++ b/test/Interpreter/SDK/c_pointers.swift
@@ -6,7 +6,7 @@
// REQUIRES: objc_interop
import Foundation
-#if os(OSX)
+#if os(macOS)
import AppKit
typealias XXColor = NSColor
#endif
@@ -28,7 +28,7 @@
let nsRed = XXColor(cgColor: cgRed)
var r: CGFloat = 0.5, g: CGFloat = 0.5, b: CGFloat = 0.5, a: CGFloat = 0.5
-#if os(OSX)
+#if os(macOS)
nsRed!.getRed(&r, green: &g, blue: &b, alpha: &a)
#else
nsRed.getRed(&r, green: &g, blue: &b, alpha: &a)
diff --git a/test/Interpreter/SDK/cf_extensions.swift b/test/Interpreter/SDK/cf_extensions.swift
index 57aa920..9dcc3cb 100644
--- a/test/Interpreter/SDK/cf_extensions.swift
+++ b/test/Interpreter/SDK/cf_extensions.swift
@@ -6,7 +6,7 @@
import Foundation
import StdlibUnittest
-#if os(OSX)
+#if os(macOS)
import AppKit
#endif
diff --git a/test/Interpreter/SDK/cf_type_bridging.swift b/test/Interpreter/SDK/cf_type_bridging.swift
index e755645..23dfa86 100644
--- a/test/Interpreter/SDK/cf_type_bridging.swift
+++ b/test/Interpreter/SDK/cf_type_bridging.swift
@@ -3,7 +3,7 @@
// REQUIRES: objc_interop
-#if os(OSX)
+#if os(macOS)
import AppKit
#endif
#if os(iOS) || os(tvOS) || os(watchOS)
diff --git a/test/Interpreter/SDK/libc.swift b/test/Interpreter/SDK/libc.swift
index 13a0e17..0e1dd7d 100644
--- a/test/Interpreter/SDK/libc.swift
+++ b/test/Interpreter/SDK/libc.swift
@@ -9,7 +9,7 @@
// TODO: rdar://problem/33388782
// REQUIRES: CPU=x86_64
-#if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
import Darwin
#elseif os(Linux) || os(FreeBSD) || os(PS4) || os(Android)
import Glibc
diff --git a/test/Interpreter/SDK/objc_ns_enum.swift b/test/Interpreter/SDK/objc_ns_enum.swift
index e125436..b2c5d1d 100644
--- a/test/Interpreter/SDK/objc_ns_enum.swift
+++ b/test/Interpreter/SDK/objc_ns_enum.swift
@@ -8,7 +8,7 @@
// strict checking if we get a guarantee that certain types don't have
// hidden or future enumeration values.)
-#if os(OSX)
+#if os(macOS)
import AppKit
print(NSButtonType(rawValue: 20721)!.rawValue)
diff --git a/test/Migrator/no_duplicate_aarch64_use_tbi.swift b/test/Migrator/no_duplicate_aarch64_use_tbi.swift
index b2c648c..af356a1 100644
--- a/test/Migrator/no_duplicate_aarch64_use_tbi.swift
+++ b/test/Migrator/no_duplicate_aarch64_use_tbi.swift
@@ -2,14 +2,14 @@
// REQUIRES: CPU=arm64
// RUN: %target-swift-frontend -typecheck %s -swift-version 3
// RUN: %empty-directory(%t)
-// RUN: cd %t && %swiftc_driver -c -update-code -target arm64-apple-ios10.3 -output-file-map %S/Inputs/no_duplicate_aarch64_use_tbi_ofm.json -swift-version 3 %s -v
-// RUN: cd %t && %swiftc_driver -c -update-code -target arm64-apple-ios10.3 -output-file-map %S/Inputs/no_duplicate_aarch64_use_tbi_ofm.json -swift-version 3 %s -### > %t/driver_actions.txt
+// RUN: cd %t && %target-swiftc_driver -c -update-code -output-file-map %S/Inputs/no_duplicate_aarch64_use_tbi_ofm.json -swift-version 3 %s -v
+// RUN: cd %t && %target-swiftc_driver -c -update-code -output-file-map %S/Inputs/no_duplicate_aarch64_use_tbi_ofm.json -swift-version 3 %s -### > %t/driver_actions.txt
// RUN: %FileCheck --check-prefix=CHECK-REMAP %s < %t/no_duplicate_aarch64_use_tbi.remap
// RUN: %FileCheck --check-prefix=CHECK-ACTIONS %s < %t/driver_actions.txt
public func foo(_ f: (Void) -> ()) {}
-// CHECK-REMAP: "offset": 673,
+// CHECK-REMAP: "offset": 632,
// CHECK-REMAP: "remove": 5,
// CHECK-REMAP: "text": "("
diff --git a/test/Parse/ConditionalCompilation/basicIdentity.swift b/test/Parse/ConditionalCompilation/basicIdentity.swift
index 14072e7..a067063 100644
--- a/test/Parse/ConditionalCompilation/basicIdentity.swift
+++ b/test/Parse/ConditionalCompilation/basicIdentity.swift
@@ -63,3 +63,9 @@
var w = Foo()
#endif
var x = w
+
+// Test os(macOS) as well
+#if os(macOS)
+var y = Foo()
+#endif
+var z = y
diff --git a/test/PrintAsObjC/accessibility.swift b/test/PrintAsObjC/accessibility.swift
index bbe7d07..e509860 100644
--- a/test/PrintAsObjC/accessibility.swift
+++ b/test/PrintAsObjC/accessibility.swift
@@ -37,7 +37,7 @@
#if MAIN
-#if os(OSX)
+#if os(macOS)
import AppKit
@NSApplicationMain
diff --git a/test/Reflection/capture_descriptors.sil b/test/Reflection/capture_descriptors.sil
index 19580f8..5630624 100644
--- a/test/Reflection/capture_descriptors.sil
+++ b/test/Reflection/capture_descriptors.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// REQUIRES: no_asan
// RUN: %empty-directory(%t)
// RUN: %target-build-swift %s -emit-module -emit-library -module-name capture_descriptors -o %t/capture_descriptors.%target-dylib-extension
diff --git a/test/Reflection/plus_zero_capture_descriptors.sil b/test/Reflection/plus_zero_capture_descriptors.sil
new file mode 100644
index 0000000..dab2c61
--- /dev/null
+++ b/test/Reflection/plus_zero_capture_descriptors.sil
@@ -0,0 +1,290 @@
+// REQUIRES: plus_zero_runtime
+// REQUIRES: no_asan
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift %s -emit-module -emit-library -module-name capture_descriptors -o %t/capture_descriptors.%target-dylib-extension
+// RUN: %target-swift-reflection-dump -binary-filename %t/capture_descriptors.%target-dylib-extension | %FileCheck %s
+
+sil_stage canonical
+
+import Builtin
+import Swift
+import SwiftShims
+
+// CHECK: CAPTURE DESCRIPTORS:
+// CHECK-NEXT: ====================
+
+// Concrete caller and callee -- nothing interesting going on
+
+protocol P {}
+extension Int: P {}
+
+sil @concrete_callee1 : $@convention(thin) (Int, @owned <τ_0_0> { var τ_0_0 } <Int>, @thin Int.Type, @thick P.Type) -> () {
+bb0(%i: $Int, %b: $<τ_0_0> { var τ_0_0 } <Int>, %m: $@thin Int.Type, %p: $@thick P.Type):
+ %12 = tuple ()
+ return %12 : $()
+}
+
+sil @concrete_caller1 : $@convention(thin) (Int, @thick P.Type) -> @owned @callee_guaranteed () -> () {
+bb0(%i: $Int, %p: $@thick P.Type):
+ %f = function_ref @concrete_callee1 : $@convention(thin) (Int, @owned <τ_0_0> { var τ_0_0 } <Int>, @thin Int.Type, @thick P.Type) -> ()
+ %b = alloc_box $<τ_0_0> { var τ_0_0 } <Int>
+ %m = metatype $@thin Int.Type
+ %c = partial_apply [callee_guaranteed] %f(%i, %b, %m, %p) : $@convention(thin) (Int, @owned <τ_0_0> { var τ_0_0 } <Int>, @thin Int.Type, @thick P.Type) -> ()
+ return %c : $@callee_guaranteed () -> ()
+}
+
+// This is the descriptor for '<τ_0_0> { var τ_0_0 } <Int>' above
+
+// CHECK: - Capture types:
+// CHECK-NEXT: (struct Swift.Int)
+// CHECK-NEXT: - Metadata sources:
+
+// CHECK: - Capture types:
+// CHECK-NEXT: (struct Swift.Int)
+// CHECK-NEXT: (sil_box
+// CHECK-NEXT: (struct Swift.Int))
+// CHECK-NEXT: (existential_metatype
+// CHECK-NEXT: (protocol_composition
+// CHECK-NEXT: (protocol capture_descriptors.P)))
+// CHECK-NEXT: - Metadata sources:
+
+
+// Concrete caller and generic callee -- capture types are fully substituted,
+// and there are no metadata bindings
+
+sil @generic_callee2 : $@convention(thin) <T, U> (@in T, @owned <τ_0_0> { var τ_0_0 } <U>) -> () {
+bb0(%i: $*T, %b: $<τ_0_0> { var τ_0_0 } <U>):
+ %12 = tuple ()
+ return %12 : $()
+}
+
+sil @concrete_caller2 : $@convention(thin) () -> @owned @callee_guaranteed () -> () {
+bb0:
+ %f = function_ref @generic_callee2 : $@convention(thin) <T, U> (@in T, @owned <τ_0_0> { var τ_0_0 } <U>) -> ()
+ %i = alloc_stack $Int
+ %b = alloc_box $<τ_0_0> { var τ_0_0 } <String>
+ %c = partial_apply [callee_guaranteed] %f<Int, String>(%i, %b) : $@convention(thin) <T, U> (@in T, @owned <τ_0_0> { var τ_0_0 } <U>) -> ()
+ dealloc_stack %i : $*Int
+ return %c : $@callee_guaranteed () -> ()
+}
+
+// This is the descriptor for '<τ_0_0> { var τ_0_0 } <String>' above
+
+// CHECK: - Capture types:
+// CHECK-NEXT: (struct Swift.String)
+// CHECK-NEXT: - Metadata sources:
+
+// CHECK: - Capture types:
+// CHECK-NEXT: (struct Swift.Int)
+// CHECK-NEXT: (sil_box
+// CHECK-NEXT: (struct Swift.String))
+// CHECK-NEXT: - Metadata sources:
+
+
+// Generic caller and generic callee -- capture types are written in terms of
+// the caller's generic parameters, and metadata bindings are present for
+// structural sub-terms of the callee's substituted generic parameters that
+// contain the caller's generic parameters.
+
+sil @generic_callee3 : $@convention(thin) <T, U> (@in_guaranteed T) -> () {
+bb0(%t: $*T):
+ %12 = tuple ()
+ return %12 : $()
+}
+
+sil @generic_caller3 : $@convention(thin) <A, B, C> () -> @owned @callee_guaranteed () -> () {
+bb0:
+ %f = function_ref @generic_callee3 : $@convention(thin) <T, U> (@in_guaranteed T) -> ()
+ %t = alloc_stack $Optional<@callee_guaranteed (@in_guaranteed A) -> @out B>
+ %c = partial_apply [callee_guaranteed] %f<Optional<(A) -> B>, (B, (C) -> Int)>(%t) : $@convention(thin) <T, U> (@in_guaranteed T) -> ()
+ dealloc_stack %t : $*Optional<@callee_guaranteed (@in_guaranteed A) -> @out B>
+ return %c : $@callee_guaranteed () -> ()
+}
+
+// CHECK: - Capture types:
+// CHECK-NEXT: (bound_generic_enum Swift.Optional
+// CHECK-NEXT: (function
+// CHECK-NEXT: (parameters)
+// CHECK-NEXT: (result
+// CHECK-NEXT: (tuple)))
+// CHECK-NEXT: - Metadata sources:
+// CHECK-NEXT: (bound_generic_enum Swift.Optional
+// CHECK-NEXT: (function
+// CHECK-NEXT: (parameters
+// CHECK-NEXT: (generic_type_parameter depth=0 index=0)
+// CHECK-NEXT: (result
+// CHECK-NEXT: (generic_type_parameter depth=0 index=1)))
+// CHECK-NEXT: (closure_binding index=0)
+// CHECK-NEXT: (generic_type_parameter depth=0 index=1)
+// CHECK-NEXT: (closure_binding index=1)
+// CHECK-NEXT: (generic_type_parameter depth=0 index=2)
+// CHECK-NEXT: (closure_binding index=2)
+
+
+// Generic caller and generic callee -- and one of the type parameters is
+// fulfilled by a thick metatype value.
+
+sil @generic_callee4 : $@convention(thin) <T, U> (@thick Optional<T>.Type) -> () {
+bb0(%t: $@thick Optional<T>.Type):
+ %12 = tuple ()
+ return %12 : $()
+}
+
+sil @generic_caller4 : $@convention(thin) <A, B, C> () -> @owned @callee_guaranteed () -> () {
+bb0:
+ %f = function_ref @generic_callee4 : $@convention(thin) <T, U> (@thick Optional<T>.Type) -> ()
+ %t = metatype $@thick Optional<(B) -> C>.Type
+ %c = partial_apply [callee_guaranteed] %f<(B) -> C, Int>(%t) : $@convention(thin) <T, U> (@thick Optional<T>.Type) -> ()
+ return %c : $@callee_guaranteed () -> ()
+}
+
+// CHECK: - Capture types:
+// CHECK-NEXT: (metatype was_abstract
+// CHECK-NEXT: (bound_generic_enum Swift.Optional
+// CHECK-NEXT: (function
+// CHECK-NEXT: (parameters
+// CHECK-NEXT: (generic_type_parameter depth=0 index=1)
+// CHECK-NEXT: (result
+// CHECK-NEXT: (generic_type_parameter depth=0 index=2))))
+// CHECK-NEXT: - Metadata sources:
+// CHECK-NEXT: (function
+// CHECK-NEXT: (parameters
+// CHECK-NEXT: (generic_type_parameter depth=0 index=1)
+// CHECK-NEXT: (result
+// CHECK-NEXT: (generic_type_parameter depth=0 index=2))
+// CHECK-NEXT: (generic_argument index=0
+// CHECK-NEXT: (metadata_capture index=0))
+
+
+// Generic caller and generic callee -- and one of the type parameters is
+// fulfilled by the isa pointer of a class instance.
+
+class GenericClass<T, U> {}
+
+sil @generic_callee5 : $@convention(thin) <T, U, V> (@owned GenericClass<T, U>) -> () {
+bb0(%t: $GenericClass<T, U>):
+ %12 = tuple ()
+ return %12 : $()
+}
+
+sil @generic_caller5 : $@convention(thin) <A, B, C> (@owned GenericClass<(A, B), (B, C)>) -> @owned @callee_guaranteed () -> () {
+bb0(%g: $GenericClass<(A, B), (B, C)>):
+ %f = function_ref @generic_callee5 : $@convention(thin) <T, U, V> (@owned GenericClass<T, U>) -> ()
+ %c = partial_apply [callee_guaranteed] %f<(A, B), (B, C), (C, A)>(%g) : $@convention(thin) <T, U, V> (@owned GenericClass<T, U>) -> ()
+ return %c : $@callee_guaranteed () -> ()
+}
+
+sil_vtable GenericClass {}
+
+// CHECK: - Capture types:
+// CHECK-NEXT: (bound_generic_class capture_descriptors.GenericClass
+// CHECK-NEXT: (tuple
+// CHECK-NEXT: (generic_type_parameter depth=0 index=0)
+// CHECK-NEXT: (generic_type_parameter depth=0 index=1))
+// CHECK-NEXT: (tuple
+// CHECK-NEXT: (generic_type_parameter depth=0 index=1)
+// CHECK-NEXT: (generic_type_parameter depth=0 index=2)))
+// CHECK-NEXT: - Metadata sources:
+// CHECK-NEXT: (generic_type_parameter depth=0 index=2)
+// CHECK-NEXT: (closure_binding index=0)
+// CHECK-NEXT: (generic_type_parameter depth=0 index=0)
+// CHECK-NEXT: (closure_binding index=1)
+// CHECK-NEXT: (tuple
+// CHECK-NEXT: (generic_type_parameter depth=0 index=0)
+// CHECK-NEXT: (generic_type_parameter depth=0 index=1))
+// CHECK-NEXT: (generic_argument index=0
+// CHECK-NEXT: (reference_capture index=0))
+// CHECK-NEXT: (tuple
+// CHECK-NEXT: (generic_type_parameter depth=0 index=1)
+// CHECK-NEXT: (generic_type_parameter depth=0 index=2))
+// CHECK-NEXT: (generic_argument index=1
+// CHECK-NEXT: (reference_capture index=0))
+
+
+// Pseudogeneric caller and pseudogeneric callee -- type parameters are
+// erased at runtime.
+
+sil @pseudogeneric_callee : $@convention(thin) @pseudogeneric <T : AnyObject, U : AnyObject> (@owned T, @owned U) -> () {
+bb0(%t: $T, %u: $U):
+ %12 = tuple ()
+ return %12 : $()
+}
+
+sil @pseudogeneric_caller : $@convention(thin) @pseudogeneric <A : AnyObject, B : AnyObject, C : AnyObject> (@owned A, @owned B) -> @owned @pseudogeneric @callee_guaranteed () -> () {
+bb0(%a: $A, %b: $B):
+ %f = function_ref @pseudogeneric_callee : $@convention(thin) @pseudogeneric <T : AnyObject, U : AnyObject> (@owned T, @owned U) -> ()
+ %c = partial_apply [callee_guaranteed] %f<A, B>(%a, %b) : $@convention(thin) @pseudogeneric <A : AnyObject, B : AnyObject> (@owned A, @owned B) -> ()
+ return %c : $@pseudogeneric @callee_guaranteed () -> ()
+}
+
+// CHECK: - Capture types:
+// CHECK-NEXT: (protocol_composition any_object)
+// CHECK-NEXT: (protocol_composition any_object)
+// CHECK-NEXT: - Metadata sources:
+
+
+// Capturing lowered function types
+
+sil @function_callee : $@convention(thin) (@convention(thin) () -> (), @convention(c) () -> (), @convention(block) () -> (), @convention(thick) () -> (), @convention(method) () -> (), @convention(witness_method: P) (Int) -> ()) -> () {
+bb0(%thin: $@convention(thin) () -> (), %c: $@convention(c) () -> (), %block: $@convention(block) () -> (), %thick: $@convention(thick) () -> (), %method: $@convention(method) () -> (), %witness_method: $@convention(witness_method: P) (Int) -> ()):
+ %12 = tuple ()
+ return %12 : $()
+}
+
+sil @function_caller : $@convention(thin) (@convention(thin) () -> (), @convention(c) () -> (), @convention(block) () -> (), @convention(thick) () -> (), @convention(method) () -> (), @convention(witness_method: P) (Int) -> ()) -> @owned @callee_guaranteed () -> () {
+bb0(%thin: $@convention(thin) () -> (), %c: $@convention(c) () -> (), %block: $@convention(block) () -> (), %thick: $@convention(thick) () -> (), %method: $@convention(method) () -> (), %witness_method: $@convention(witness_method: P) (Int) -> ()):
+ %f = function_ref @function_callee : $@convention(thin) (@convention(thin) () -> (), @convention(c) () -> (), @convention(block) () -> (), @convention(thick) () -> (), @convention(method) () -> (), @convention(witness_method: P) (Int) -> ()) -> ()
+ %result = partial_apply [callee_guaranteed] %f(%thin, %c, %block, %thick, %method, %witness_method) : $@convention(thin) (@convention(thin) () -> (), @convention(c) () -> (), @convention(block) () -> (), @convention(thick) () -> (), @convention(method) () -> (), @convention(witness_method: P) (Int) -> ()) -> ()
+ return %result : $@callee_guaranteed () -> ()
+}
+
+// CHECK: - Capture types:
+// CHECK-NEXT: (function convention=thin
+// CHECK-NEXT: (parameters)
+// CHECK-NEXT: (result
+// CHECK-NEXT: (tuple))
+// CHECK-NEXT: (function convention=c
+// CHECK-NEXT: (parameters)
+// CHECK-NEXT: (result
+// CHECK-NEXT: (tuple))
+// CHECK-NEXT: (function convention=block
+// CHECK-NEXT: (parameters)
+// CHECK-NEXT: (result
+// CHECK-NEXT: (tuple))
+// CHECK-NEXT: (function
+// CHECK-NEXT: (parameters)
+// CHECK-NEXT: (result
+// CHECK-NEXT: (tuple))
+// CHECK-NEXT: (function convention=thin
+// CHECK-NEXT: (parameters)
+// CHECK-NEXT: (result
+// CHECK-NEXT: (tuple))
+// CHECK-NEXT: (function convention=thin
+// CHECK-NEXT: (parameters)
+// CHECK-NEXT: (result
+// CHECK-NEXT: (tuple))
+// CHECK-NEXT: - Metadata sources:
+
+// Capturing opened existentials
+//
+// Not supported yet -- make sure we bail out instead of crashing.
+//
+// FIXME: Eventually, we should emit a useful capture descriptor
+// for this case.
+
+sil @existential_callee : $@convention(thin) <τ_0_0 where τ_0_0 : P> () -> @out P {
+bb0(%0 : $*P):
+ unreachable
+}
+
+
+sil @existential_caller : $@convention(thin) (@in P) -> () {
+bb0(%0 : $*P):
+ %payload = open_existential_addr immutable_access %0 : $*P to $*@opened("2D7A8F84-2973-11E7-838D-34363BD08DA0") P
+ %f = function_ref @existential_callee : $@convention(thin) <τ_0_0 where τ_0_0 : P> () -> @out P
+ %result = partial_apply [callee_guaranteed] %f<@opened("2D7A8F84-2973-11E7-838D-34363BD08DA0") P>() : $@convention(thin) <τ_0_0 where τ_0_0 : P> () -> @out P
+ destroy_value %result : $@callee_guaranteed () -> @out P
+ destroy_addr %0 : $*P
+ %tuple = tuple ()
+ return %tuple : $()
+}
diff --git a/test/Runtime/linux-fatal-backtrace.swift b/test/Runtime/linux-fatal-backtrace.swift
index 6df5ec3..202983c 100644
--- a/test/Runtime/linux-fatal-backtrace.swift
+++ b/test/Runtime/linux-fatal-backtrace.swift
@@ -4,6 +4,7 @@
// REQUIRES: executable_test
// REQUIRES: OS=linux-gnu
// REQUIRES: lldb
+// REQUIRES: rdar38181372
// Backtraces are not emitted when optimizations are enabled. This test can not
// run when optimizations are enabled.
diff --git a/test/SIL/Parser/apply_with_substitution.sil b/test/SIL/Parser/apply_with_substitution.sil
index 2991489..bce0544 100644
--- a/test/SIL/Parser/apply_with_substitution.sil
+++ b/test/SIL/Parser/apply_with_substitution.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend %s -emit-silgen | %FileCheck %s
// rdar://14443287
diff --git a/test/SIL/Parser/bound_generic.sil b/test/SIL/Parser/bound_generic.sil
index 87c0895..73e681b 100644
--- a/test/SIL/Parser/bound_generic.sil
+++ b/test/SIL/Parser/bound_generic.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend %s -emit-silgen | %FileCheck %s
// rdar://14443287
diff --git a/test/SIL/Parser/generic_signature_with_depth.swift b/test/SIL/Parser/generic_signature_with_depth.swift
index d1ba566..6dc1e51 100644
--- a/test/SIL/Parser/generic_signature_with_depth.swift
+++ b/test/SIL/Parser/generic_signature_with_depth.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend %s -emit-silgen | %target-sil-opt | %FileCheck %s
protocol mmGeneratorType {
diff --git a/test/SIL/Parser/keypath.sil b/test/SIL/Parser/keypath.sil
index aeae6b2..f2dad3d 100644
--- a/test/SIL/Parser/keypath.sil
+++ b/test/SIL/Parser/keypath.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-sil-opt %s | %target-sil-opt | %FileCheck %s
sil_stage canonical
diff --git a/test/SIL/Parser/plus_zero_apply_with_substitution.sil b/test/SIL/Parser/plus_zero_apply_with_substitution.sil
new file mode 100644
index 0000000..a63e3c0
--- /dev/null
+++ b/test/SIL/Parser/plus_zero_apply_with_substitution.sil
@@ -0,0 +1,52 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend %s -emit-silgen | %FileCheck %s
+
+// rdar://14443287
+sil_stage raw
+
+import Builtin
+import Swift
+
+// CHECK-LABEL: sil @_TF4test3fooFT1fGSqFT_T___T_ : $@convention(thin) (@guaranteed Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()>) -> ()
+sil @_TF4test3fooFT1fGSqFT_T___T_ : $@convention(thin) (@guaranteed Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()>) -> () {
+bb0(%0 : $Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()>):
+ %1 = alloc_box $<τ_0_0> { var τ_0_0 } <Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()>> // var f // users: %2, %6, %32
+ %1a = project_box %1 : $<τ_0_0> { var τ_0_0 } <Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()>>, 0
+ store %0 to [init] %1a : $*Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()> // id: %2
+ %3 = alloc_stack $Optional<()> // users: %22, %28, %30, %31
+ %4 = alloc_stack $() // users: %12, %22, %25
+ %5 = alloc_stack $Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()> // users: %6, %8, %10, %11, %16, %24
+ copy_addr %1a to [initialization] %5 : $*Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()> // id: %6
+ %7 = function_ref @_TFs22_doesOptionalHaveValueU__FT1vRGSqQ___Bi1_ : $@convention(thin) <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1 // user: %8
+ %8 = apply %7<() -> ()>(%5) : $@convention(thin) <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1 // user: %9
+ br bb2 // id: %13
+
+bb2: // Preds: bb0
+ %14 = function_ref @_TFs17_getOptionalValueU__FT1vGSqQ___Q_ : $@convention(thin) <τ_0_0> (@in_guaranteed Optional<τ_0_0>) -> @out τ_0_0 // user: %16
+ %15 = alloc_stack $@callee_guaranteed (@in_guaranteed ()) -> @out () // users: %16, %17, %23
+ // CHECK: apply %{{[0-9]+}}<() -> ()>(%{{[0-9]+}}, %{{[0-9]+}}) : $@convention(thin) <τ_0_0> (@in_guaranteed Optional<τ_0_0>) -> @out τ_0_0
+ %16 = apply %14<() -> ()>(%15, %5) : $@convention(thin) <τ_0_0> (@in_guaranteed Optional<τ_0_0>) -> @out τ_0_0
+ %17 = load [take] %15 : $*@callee_guaranteed (@in_guaranteed ()) -> @out () // user: %19
+ %18 = function_ref @_TTRXFo_iT__iT__XFo__dT__ : $@convention(thin) (@guaranteed @callee_guaranteed (@in_guaranteed ()) -> @out ()) -> () // user: %19
+ %19 = partial_apply [callee_guaranteed] %18(%17) : $@convention(thin) (@guaranteed @callee_guaranteed (@in_guaranteed ()) -> @out ()) -> () // user: %20
+ %20 = apply %19() : $@callee_guaranteed () -> ()
+ %21 = function_ref @_TFs24_injectValueIntoOptionalU__FT1vQ__GSqQ__ : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out Optional<τ_0_0> // user: %22
+ // CHECK: apply %{{[0-9]+}}<()>(%{{[0-9]+}}, %{{[0-9]+}}) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out Optional<τ_0_0>
+ %22 = apply %21<()>(%3, %4) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out Optional<τ_0_0>
+ dealloc_stack %15 : $*@callee_guaranteed (@in_guaranteed ()) -> @out () // id: %23
+ dealloc_stack %5 : $*Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()> // id: %24
+ dealloc_stack %4 : $*() // id: %25
+ br bb4 // id: %26
+
+bb4: // Preds: bb2 bb3
+ %30 = load [trivial] %3 : $*Optional<()>
+ dealloc_stack %3 : $*Optional<()> // id: %31
+ destroy_value %1 : $<τ_0_0> { var τ_0_0 } <Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()>>
+ %33 = tuple () // user: %34
+ return %33 : $() // id: %34
+}
+
+sil [transparent] @_TFs22_doesOptionalHaveValueU__FT1vRGSqQ___Bi1_ : $@convention(thin) <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1
+sil [transparent] @_TFs17_getOptionalValueU__FT1vGSqQ___Q_ : $@convention(thin) <τ_0_0> (@in_guaranteed Optional<τ_0_0>) -> @out τ_0_0
+sil [transparent] @_TTRXFo_iT__iT__XFo__dT__ : $@convention(thin) (@guaranteed @callee_guaranteed (@in_guaranteed ()) -> @out ()) -> ()
+sil [transparent] @_TFs24_injectValueIntoOptionalU__FT1vQ__GSqQ__ : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out Optional<τ_0_0>
diff --git a/test/SIL/Parser/plus_zero_bound_generic.sil b/test/SIL/Parser/plus_zero_bound_generic.sil
new file mode 100644
index 0000000..c535ee7
--- /dev/null
+++ b/test/SIL/Parser/plus_zero_bound_generic.sil
@@ -0,0 +1,47 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend %s -emit-silgen | %FileCheck %s
+
+// rdar://14443287
+sil_stage raw
+
+import Builtin
+import Swift
+
+// CHECK-LABEL: sil @_TF9optional3fooFT1fGSqFT_T___T_ : $@convention(thin) (@guaranteed Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()>) -> ()
+sil @_TF9optional3fooFT1fGSqFT_T___T_ : $@convention(thin) (@guaranteed Optional<@callee_guaranteed (@in_guaranteed ()) -> (@out ())>) -> () {
+bb0(%0 : $Optional<@callee_guaranteed (@in_guaranteed ()) -> (@out ())>):
+ %1 = alloc_box $<τ_0_0> { var τ_0_0 } <Optional<@callee_guaranteed (@in_guaranteed ()) -> (@out ())>>
+ %1a = project_box %1 : $<τ_0_0> { var τ_0_0 } <Optional<@callee_guaranteed (@in_guaranteed ()) -> (@out ())>>, 0
+ store %0 to [init] %1a : $*Optional<@callee_guaranteed (@in_guaranteed ()) -> (@out ())>
+ %3 = alloc_stack $Optional<()>
+ %4 = alloc_stack $()
+ %5 = alloc_stack $Optional<@callee_guaranteed (@in_guaranteed ()) -> (@out ())>
+ copy_addr %1a to [initialization] %5 : $*Optional<@callee_guaranteed (@in_guaranteed ()) -> (@out ())>
+ // function_ref Swift._doesOptionalHaveValue <A>(v : @inout Swift.Optional<A>) -> Builtin.Int1
+ %7 = function_ref @_TFs22_doesOptionalHaveValueU__FT1vRGSqQ___Bi1_ : $@convention(thin) <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1
+ // CHECK: apply %{{[0-9]+}}<() -> ()>(%{{[0-9]+}}) : $@convention(thin) <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1
+ %8 = apply %7<() -> ()>(%5) : $@convention(thin) <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1
+ br bb1
+
+bb1:
+ destroy_addr %5 : $*Optional<@callee_guaranteed (@in_guaranteed ()) -> (@out ())>
+ dealloc_stack %5 : $*Optional<@callee_guaranteed (@in_guaranteed ()) -> (@out ())>
+ dealloc_stack %4 : $*()
+ br bb3
+
+bb3:
+ %27 = function_ref @_TFs26_injectNothingIntoOptionalU__FT_GSqQ__ : $@convention(thin) <τ_0_0> () -> @out Optional<τ_0_0>
+ // CHECK: apply %{{[0-9]+}}<()>(%{{[0-9]+}}) : $@convention(thin) <τ_0_0> () -> @out Optional<τ_0_0>
+ %28 = apply %27<()>(%3) : $@convention(thin) <τ_0_0> () -> @out Optional<τ_0_0>
+ br bb4
+
+bb4:
+ %30 = load [trivial] %3 : $*Optional<()>
+ dealloc_stack %3 : $*Optional<()>
+ destroy_value %1 : $<τ_0_0> { var τ_0_0 } <Optional<@callee_guaranteed (@in_guaranteed ()) -> (@out ())>>
+ %33 = tuple ()
+ return %33 : $()
+}
+
+sil [transparent] @_TFs22_doesOptionalHaveValueU__FT1vRGSqQ___Bi1_ : $@convention(thin) <τ_0_0> (@inout Optional<τ_0_0>) -> Builtin.Int1
+sil [transparent] @_TFs26_injectNothingIntoOptionalU__FT_GSqQ__ : $@convention(thin) <τ_0_0> () -> @out Optional<τ_0_0>
diff --git a/test/SIL/Parser/plus_zero_generic_signature_with_depth.swift b/test/SIL/Parser/plus_zero_generic_signature_with_depth.swift
new file mode 100644
index 0000000..f25a2a4
--- /dev/null
+++ b/test/SIL/Parser/plus_zero_generic_signature_with_depth.swift
@@ -0,0 +1,35 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend %s -emit-silgen | %target-sil-opt | %FileCheck %s
+
+protocol mmGeneratorType {
+ associatedtype Element
+}
+
+protocol mmSequenceType {
+ associatedtype Generator : mmGeneratorType
+}
+
+protocol mmCollectionType : mmSequenceType {
+}
+
+protocol mmExt : mmCollectionType {
+ mutating func extend<
+ S : mmSequenceType
+ where S.Generator.Element == Self.Generator.Element
+ > (_ seq: S)
+}
+
+// CHECK-LABEL: @$S28generic_signature_with_depth4testyxx_q_tAA5mmExtRzAaCR_9Generator_7ElementQY_AD_AERTzr0_lF : $@convention(thin) <EC1, EC2 where EC1 : mmExt, EC2 : mmExt, EC1.Generator.Element == EC2.Generator.Element> (@in_guaranteed EC1, @in_guaranteed EC2) -> @out EC1 {
+// CHECK: witness_method $EC1, #mmExt.extend!1 : {{.*}} : $@convention(witness_method: mmExt) <τ_0_0 where τ_0_0 : mmExt><τ_1_0 where τ_1_0 : mmSequenceType, τ_0_0.Generator.Element == τ_1_0.Generator.Element> (@in_guaranteed τ_1_0, @inout τ_0_0) -> ()
+// CHECK: apply {{%[0-9]+}}<EC1, EC2>({{%[0-9]+}}, {{%[0-9]+}}) : $@convention(witness_method: mmExt) <τ_0_0 where τ_0_0 : mmExt><τ_1_0 where τ_1_0 : mmSequenceType, τ_0_0.Generator.Element == τ_1_0.Generator.Element> (@in_guaranteed τ_1_0, @inout τ_0_0) -> ()
+
+func test<
+ EC1 : mmExt,
+ EC2 : mmExt
+ where EC1.Generator.Element == EC2.Generator.Element
+>
+(_ lhs: EC1, _ rhs: EC2) -> EC1 {
+ var lhs = lhs
+ lhs.extend(rhs)
+ return lhs
+}
diff --git a/test/SIL/Parser/plus_zero_keypath.sil b/test/SIL/Parser/plus_zero_keypath.sil
new file mode 100644
index 0000000..7c9b0a0
--- /dev/null
+++ b/test/SIL/Parser/plus_zero_keypath.sil
@@ -0,0 +1,184 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-sil-opt %s | %target-sil-opt | %FileCheck %s
+
+sil_stage canonical
+
+import Swift
+
+struct S: Hashable {
+ var x: Int
+ let y: String
+ var z: C
+
+ var hashValue: Int { get }
+ static func ==(x: S, y: S) -> Bool
+}
+class C: Hashable {
+ final var x: Int
+ final let y: String
+ final var z: S
+
+ init()
+ var overridable: Int {
+ get set
+ }
+
+ var hashValue: Int { get }
+ static func ==(x: C, y: C) -> Bool
+}
+
+protocol P {}
+protocol Q {}
+protocol R {}
+
+struct Gen<A: P, B: Q, C: R> {
+ var x: A
+ let y: B
+ var z: C
+}
+
+public struct External<T> {
+ var ro: T
+
+ subscript<U: Hashable>(ro _: U) -> T { get }
+}
+
+// CHECK-LABEL: sil shared @stored_properties
+sil shared @stored_properties : $@convention(thin) () -> () {
+entry:
+ // CHECK: keypath $WritableKeyPath<S, Int>, (root $S; stored_property #S.x : $Int)
+ %a = keypath $WritableKeyPath<S, Int>, (root $S; stored_property #S.x : $Int)
+ // CHECK: keypath $ReferenceWritableKeyPath<C, Int>, (root $C; stored_property #C.x : $Int)
+ %b = keypath $ReferenceWritableKeyPath<C, Int>, (root $C; stored_property #C.x : $Int)
+ // CHECK: keypath $KeyPath<S, String>, (root $S; stored_property #S.y : $String)
+ %c = keypath $KeyPath<S, String>, (root $S; stored_property #S.y : $String)
+ // CHECK: keypath $ReferenceWritableKeyPath<S, Int>, (root $S; stored_property #S.z : $C; stored_property #C.x : $Int)
+ %d = keypath $ReferenceWritableKeyPath<S, Int>, (root $S; stored_property #S.z : $C; stored_property #C.x : $Int)
+
+ return undef : $()
+}
+
+// CHECK-LABEL: sil shared @stored_properties_generic
+sil shared @stored_properties_generic : $@convention(thin) <D: P, E: Q, F: R> () -> () {
+entry:
+ // CHECK: keypath $WritableKeyPath<Gen<D, E, F>, D>, <τ_0_0, τ_0_1, τ_0_2 where {{.*}}> (root $Gen<τ_0_0, τ_0_1, τ_0_2>; stored_property #Gen.x : $τ_0_0) <D, E, F>
+ %a = keypath $WritableKeyPath<Gen<D,E,F>, D>, <G: P, H: Q, I: R> (root $Gen<G, H, I>; stored_property #Gen.x : $G) <D, E, F>
+ // CHECK: keypath $KeyPath<Gen<D, E, F>, E>, <τ_0_0, τ_0_1, τ_0_2 where {{.*}}> (root $Gen<τ_0_0, τ_0_1, τ_0_2>; stored_property #Gen.y : $τ_0_1) <D, E, F>
+ %b = keypath $KeyPath<Gen<D,E,F>, E>, <G: P, H: Q, I: R> (root $Gen<G, H, I>; stored_property #Gen.y : $H) <D, E, F>
+
+ return undef : $()
+}
+
+sil @id_a : $@convention(thin) () -> ()
+sil @get_s_int : $@convention(thin) (@in_guaranteed S) -> @out Int
+sil @set_s_int : $@convention(thin) (@in_guaranteed Int, @in_guaranteed S) -> ()
+sil @get_c_int : $@convention(thin) (@in_guaranteed C) -> @out Int
+sil @set_c_int : $@convention(thin) (@in_guaranteed Int, @in_guaranteed C) -> ()
+sil @get_fns_fnc : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed S) -> @out S) -> @out @callee_guaranteed (@in_guaranteed C) -> @out C
+sil @set_fns_fnc : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed C) -> @out C, @in_guaranteed @callee_guaranteed (@in_guaranteed S) -> @out S) -> ()
+sil @get_s_int_subs : $@convention(thin) (@in_guaranteed S, UnsafeRawPointer) -> @out Int
+sil @set_s_int_subs : $@convention(thin) (@in_guaranteed Int, @in_guaranteed S, UnsafeRawPointer) -> ()
+sil @subs_eq : $@convention(thin) (UnsafeRawPointer, UnsafeRawPointer) -> Bool
+sil @subs_hash : $@convention(thin) (UnsafeRawPointer) -> Int
+sil @get_gen_int_subs : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (@in_guaranteed A, UnsafeRawPointer) -> @out C
+sil @set_gen_int_subs : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (@in_guaranteed C, @in_guaranteed A, UnsafeRawPointer) -> ()
+sil @gen_subs_eq : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool
+sil @gen_subs_hash : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (UnsafeRawPointer) -> Int
+
+
+// CHECK-LABEL: sil shared @computed_properties
+sil shared @computed_properties : $@convention(thin) () -> () {
+entry:
+ // CHECK: keypath $KeyPath<S, Int>, (root $S; gettable_property $Int, id @id_a : $@convention(thin) () -> (), getter @get_s_int : $@convention(thin) (@in_guaranteed S) -> @out Int)
+ %a = keypath $KeyPath<S, Int>, (root $S; gettable_property $Int, id @id_a : $@convention(thin) () -> (), getter @get_s_int : $@convention(thin) (@in_guaranteed S) -> @out Int)
+ // CHECK: keypath $WritableKeyPath<S, Int>, (root $S; settable_property $Int, id @id_a : $@convention(thin) () -> (), getter @get_s_int : $@convention(thin) (@in_guaranteed S) -> @out Int, setter @set_s_int : $@convention(thin) (@in_guaranteed Int, @in_guaranteed S) -> ())
+ %b = keypath $WritableKeyPath<S, Int>, (root $S; settable_property $Int, id @id_a : $@convention(thin) () -> (), getter @get_s_int : $@convention(thin) (@in_guaranteed S) -> @out Int, setter @set_s_int : $@convention(thin) (@in_guaranteed Int, @in_guaranteed S) -> ())
+ // CHECK: keypath $WritableKeyPath<(S) -> S, (C) -> C>, (root $(S) -> S; settable_property $(C) -> C, id @id_a : $@convention(thin) () -> (), getter @get_fns_fnc : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed S) -> @out S) -> @out @callee_guaranteed (@in_guaranteed C) -> @out C, setter @set_fns_fnc : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed C) -> @out C, @in_guaranteed @callee_guaranteed (@in_guaranteed S) -> @out S) -> ())
+ %c = keypath $WritableKeyPath<(S) -> S, (C) -> C>, (root $(S) -> S; settable_property $(C) -> C, id @id_a : $@convention(thin) () -> (), getter @get_fns_fnc : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed S) -> @out S) -> @out @callee_guaranteed (@in_guaranteed C) -> @out C, setter @set_fns_fnc : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed C) -> @out C, @in_guaranteed @callee_guaranteed (@in_guaranteed S) -> @out S) -> ())
+ // CHECK: keypath $WritableKeyPath<C, Int>, (root $C; settable_property $Int, id #C.overridable!getter.1 : (C) -> () -> Int, getter @get_c_int : $@convention(thin) (@in_guaranteed C) -> @out Int, setter @set_c_int : $@convention(thin) (@in_guaranteed Int, @in_guaranteed C) -> ())
+ %d = keypath $WritableKeyPath<C, Int>, (root $C; settable_property $Int, id #C.overridable!getter.1 : (C) -> () -> Int, getter @get_c_int : $@convention(thin) (@in_guaranteed C) -> @out Int, setter @set_c_int : $@convention(thin) (@in_guaranteed Int, @in_guaranteed C) -> ())
+
+ return undef : $()
+}
+
+sil @get_gen_a : $@convention(thin) <X1: P, Y1: Q, Z1: R> (@in_guaranteed Gen<X1, Y1, Z1>) -> @out X1
+sil @set_gen_a : $@convention(thin) <X2: P, Y2: Q, Z2: R> (@in_guaranteed X2, @in_guaranteed Gen<X2, Y2, Z2>) -> ()
+
+// CHECK-LABEL: sil shared @computed_properties_generic
+sil shared @computed_properties_generic : $@convention(thin) <D: P, E: Q, F: R> () -> () {
+entry:
+ // CHECK: keypath $KeyPath<Gen<D, E, F>, D>, <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : P, τ_0_1 : Q, τ_0_2 : R> (root $Gen<τ_0_0, τ_0_1, τ_0_2>; settable_property $τ_0_0, id @id_a : $@convention(thin) () -> (), getter @get_gen_a : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : P, τ_0_1 : Q, τ_0_2 : R> (@in_guaranteed Gen<τ_0_0, τ_0_1, τ_0_2>) -> @out τ_0_0, setter @set_gen_a : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : P, τ_0_1 : Q, τ_0_2 : R> (@in_guaranteed τ_0_0, @in_guaranteed Gen<τ_0_0, τ_0_1, τ_0_2>) -> ()) <D, E, F>
+ %a = keypath $KeyPath<Gen<D, E, F>, D>, <G: P, H: Q, I: R> (root $Gen<G, H, I>; settable_property $G, id @id_a : $@convention(thin) () -> (), getter @get_gen_a : $@convention(thin) <X3: P, Y3: Q, Z3: R> (@in_guaranteed Gen<X3, Y3, Z3>) -> @out X3, setter @set_gen_a : $@convention(thin) <X4: P, Y4: Q, Z4: R> (@in_guaranteed X4, @in_guaranteed Gen<X4, Y4, Z4>) -> ()) <D, E, F>
+
+ return undef : $()
+}
+
+// CHECK-LABEL: sil @optional
+sil @optional : $@convention(thin) () -> () {
+entry:
+ // CHECK: keypath $KeyPath<Optional<Int>, Optional<Int>>, (root $Optional<Int>; optional_chain : $Int; optional_wrap : $Optional<Int>)
+ %a = keypath $KeyPath<Optional<Int>, Optional<Int>>, (root $Optional<Int>; optional_chain : $Int; optional_wrap : $Optional<Int>)
+ // CHECK: keypath $KeyPath<Optional<Int>, Int>, (root $Optional<Int>; optional_force : $Int)
+ %b = keypath $KeyPath<Optional<Int>, Int>, (root $Optional<Int>; optional_force : $Int)
+
+ return undef : $()
+}
+
+// CHECK-LABEL: sil @indexes
+sil @indexes : $@convention(thin) (S, C) -> () {
+// CHECK: bb0([[S:%.*]] : $S, [[C:%.*]] : $C):
+entry(%s : $S, %c : $C):
+ // CHECK: keypath $KeyPath<S, Int>, (root $S; settable_property $Int, id @id_a : $@convention(thin) () -> (), getter @get_s_int_subs : $@convention(thin) (@in_guaranteed S, UnsafeRawPointer) -> @out Int, setter @set_s_int_subs : $@convention(thin) (@in_guaranteed Int, @in_guaranteed S, UnsafeRawPointer) -> (), indices [%$0 : $S : $S, %$1 : $C : $C], indices_equals @subs_eq : $@convention(thin) (UnsafeRawPointer, UnsafeRawPointer) -> Bool, indices_hash @subs_hash : $@convention(thin) (UnsafeRawPointer) -> Int) ([[S]], [[C]])
+ %a = keypath $KeyPath<S, Int>, (root $S; settable_property $Int, id @id_a : $@convention(thin) () -> (), getter @get_s_int_subs : $@convention(thin) (@in_guaranteed S, UnsafeRawPointer) -> @out Int, setter @set_s_int_subs : $@convention(thin) (@in_guaranteed Int, @in_guaranteed S, UnsafeRawPointer) -> (), indices [%$0 : $S : $S, %$1 : $C : $C], indices_equals @subs_eq : $@convention(thin) (UnsafeRawPointer, UnsafeRawPointer) -> Bool, indices_hash @subs_hash : $@convention(thin) (UnsafeRawPointer) -> Int) (%s, %c)
+ // CHECK: [[T:%.*]] = alloc_stack
+ %t = alloc_stack $S
+ // CHECK: [[D:%.*]] = alloc_stack
+ %d = alloc_stack $C
+ // CHECK: keypath $KeyPath<S, Int>, <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : Hashable, τ_0_1 : Hashable, τ_0_2 : Hashable> (root $τ_0_0; settable_property $τ_0_2, id @id_a : $@convention(thin) () -> (), getter @get_gen_int_subs : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : Hashable, τ_0_1 : Hashable, τ_0_2 : Hashable> (@in_guaranteed τ_0_0, UnsafeRawPointer) -> @out τ_0_2, setter @set_gen_int_subs : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : Hashable, τ_0_1 : Hashable, τ_0_2 : Hashable> (@in_guaranteed τ_0_2, @in_guaranteed τ_0_0, UnsafeRawPointer) -> (), indices [%$0 : $τ_0_0 : $*τ_0_0, %$1 : $τ_0_1 : $*τ_0_1], indices_equals @gen_subs_eq : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : Hashable, τ_0_1 : Hashable, τ_0_2 : Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool, indices_hash @gen_subs_hash : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : Hashable, τ_0_1 : Hashable, τ_0_2 : Hashable> (UnsafeRawPointer) -> Int) <S, C, Int> ([[T]], [[D]])
+ %b = keypath $KeyPath<S, Int>, <τ_0_0: Hashable, Y: Hashable, Z: Hashable> (root $τ_0_0; settable_property $Z, id @id_a : $@convention(thin) () -> (), getter @get_gen_int_subs : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (@in_guaranteed A, UnsafeRawPointer) -> @out C, setter @set_gen_int_subs : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (@in_guaranteed C, @in_guaranteed A, UnsafeRawPointer) -> (), indices [%$0 : $τ_0_0 : $*τ_0_0, %$1 : $Y : $*Y], indices_equals @gen_subs_eq : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool, indices_hash @gen_subs_hash : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (UnsafeRawPointer) -> Int) <S, C, Int> (%t, %d)
+
+ dealloc_stack %d : $*C
+ dealloc_stack %t : $*S
+
+ return undef : $()
+}
+
+// CHECK-LABEL: sil @external
+sil @external : $@convention(thin) <A, B: Hashable> (@in_guaranteed B) -> () {
+entry(%z : $*B):
+ // CHECK: %1 = keypath $KeyPath<External<Int>, Int>, (root $External<Int>; external #External.ro<Int> : $Int)
+ %a = keypath $KeyPath<External<Int>, Int>, (root $External<Int>; external #External.ro<Int> : $Int)
+
+ // CHECK: %2 = keypath $KeyPath<External<A>, A>, <τ_0_0, τ_0_1, τ_0_2> (root $External<τ_0_2>; external #External.ro<τ_0_2> : $τ_0_2) <A, A, A>
+ %b = keypath $KeyPath<External<A>, A>, <C, D, E> (root $External<E>; external #External.ro <E> : $E) <A, A, A>
+
+ // CHECK: %3 = keypath $KeyPath<External<Int>, Int>, <τ_0_0> (root $External<τ_0_0>; external #External.ro<τ_0_0> : $τ_0_0) <Int>
+ %c = keypath $KeyPath<External<Int>, Int>, <F> (root $External<F>; external #External.ro <F> : $F) <Int>
+
+ // CHECK: %4 = keypath $KeyPath<External<A>, A>, <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (root $External<τ_0_1>; external #External.subscript<τ_0_1, τ_0_0>[%$0 : $τ_0_0 : $*τ_0_0] : $τ_0_1) <B, A> (%0)
+ %d = keypath $KeyPath<External<A>, A>, <G: Hashable, H> (root $External<H>; external #External.subscript <H, G> [%$0 : $G : $*G] : $H) <B, A> (%z)
+
+ return undef : $()
+}
+
+sil @get_external_subscript : $@convention(thin) <T, U: Hashable> (@in_guaranteed External<T>, UnsafeRawPointer) -> @out T
+sil @equals_external_subscript : $@convention(thin) <T, U: Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool
+sil @hash_external_subscript : $@convention(thin) <T, U: Hashable> (UnsafeRawPointer) -> Int
+
+// CHECK-LABEL: sil_property #External.ro<τ_0_0> (stored_property #External.ro : $τ_0_0)
+sil_property #External.ro <T> (stored_property #External.ro : $T)
+
+// CHECK-LABEL: sil_property #External.subscript<τ_0_0><τ_1_0 where τ_1_0 : Hashable> (gettable_property $τ_0_0,
+// CHECK-SAME: id @id_a : $@convention(thin) () -> (),
+// CHECK-SAME: getter @get_external_subscript : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_1 : Hashable> (@in_guaranteed External<τ_0_0>, UnsafeRawPointer) -> @out τ_0_0,
+// CHECK-SAME: indices [%$0 : $τ_1_0 : $*τ_1_0],
+// CHECK-SAME: indices_equals @equals_external_subscript : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_1 : Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool,
+// CHECK-SAME: indices_hash @hash_external_subscript : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_1 : Hashable> (UnsafeRawPointer) -> Int)
+sil_property #External.subscript <T><U: Hashable> (gettable_property $T,
+ id @id_a : $@convention(thin) () -> (),
+ getter @get_external_subscript : $@convention(thin) <T, U: Hashable> (@in_guaranteed External<T>, UnsafeRawPointer) -> @out T,
+ indices [%$0 : $U : $*U],
+ indices_equals @equals_external_subscript : $@convention(thin) <T, U: Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool,
+ indices_hash @hash_external_subscript : $@convention(thin) <T, U: Hashable> (UnsafeRawPointer) -> Int)
+
+
diff --git a/test/SIL/Serialization/deserialize_generic.sil b/test/SIL/Serialization/deserialize_generic.sil
index bbd1533..4d22ac5 100644
--- a/test/SIL/Serialization/deserialize_generic.sil
+++ b/test/SIL/Serialization/deserialize_generic.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/def_generic.swift
// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -linker -I %t %s | %FileCheck %s
diff --git a/test/SIL/Serialization/deserialize_generic_marker.sil b/test/SIL/Serialization/deserialize_generic_marker.sil
index eebbde4..b63ef5c 100644
--- a/test/SIL/Serialization/deserialize_generic_marker.sil
+++ b/test/SIL/Serialization/deserialize_generic_marker.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/def_generic_marker.swift
// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -linker -I %t %s | %FileCheck %s
diff --git a/test/SIL/Serialization/keypath.sil b/test/SIL/Serialization/keypath.sil
index 684f57d..73a927d 100644
--- a/test/SIL/Serialization/keypath.sil
+++ b/test/SIL/Serialization/keypath.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// First parse this and then emit a *.sib. Then read in the *.sib, then recreate
// RUN: %empty-directory(%t)
// RUN: %target-sil-opt %s -emit-sib -o %t/tmp.sib -module-name boxes
diff --git a/test/SIL/Serialization/plus_zero_deserialize_generic.sil b/test/SIL/Serialization/plus_zero_deserialize_generic.sil
new file mode 100644
index 0000000..d8aa071
--- /dev/null
+++ b/test/SIL/Serialization/plus_zero_deserialize_generic.sil
@@ -0,0 +1,26 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/def_generic.swift
+// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -linker -I %t %s | %FileCheck %s
+
+// Make sure that SILFunctionType with GenericSignature can match up with
+// SILFunctionType deserialized from module.
+
+sil_stage raw
+
+import def_generic
+import Builtin
+import Swift
+
+// CHECK-LABEL: sil @top_level_code
+// CHECK: function_ref @$S11def_generic1AC23convertFromArrayLiteralyACyxGxd_tF
+sil @top_level_code : $@convention(thin) () -> () {
+bb0:
+ %3 = function_ref @$S11def_generic1AC23convertFromArrayLiteralyACyxGxd_tF : $@convention(method) <T> (@guaranteed Array<T>, @guaranteed A<T>) -> @owned A<T>
+ %0 = tuple () // user: %1
+ return %0 : $() // id: %1
+}
+
+// Make sure the function body is deserialized.
+// CHECK-LABEL: sil public_external [serialized] [canonical] @$S11def_generic1AC23convertFromArrayLiteralyACyxGxd_tF : $@convention(method) <T> (@guaranteed Array<T>, @guaranteed A<T>) -> @owned A<T> {
+sil @$S11def_generic1AC23convertFromArrayLiteralyACyxGxd_tF : $@convention(method) <T> (@guaranteed Array<T>, @guaranteed A<T>) -> @owned A<T>
diff --git a/test/SIL/Serialization/plus_zero_deserialize_generic_marker.sil b/test/SIL/Serialization/plus_zero_deserialize_generic_marker.sil
new file mode 100644
index 0000000..bb3984d
--- /dev/null
+++ b/test/SIL/Serialization/plus_zero_deserialize_generic_marker.sil
@@ -0,0 +1,24 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/def_generic_marker.swift
+// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -linker -I %t %s | %FileCheck %s
+
+// Make sure that SILFunctionType with GenericSignature can match up with
+// SILFunctionType deserialized from module.
+
+import def_generic_marker
+import Builtin
+import Swift
+
+// CHECK-LABEL: sil @top_level_code
+// CHECK: function_ref @$S18def_generic_marker4testyxx_q_tAA16mmCollectionTypeRzAaCR_9Generator_7ElementQY_AD_AERTzr0_lF : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : mmCollectionType, τ_0_1 : mmCollectionType, τ_0_0.Generator.Element == τ_0_1.Generator.Element> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_1) -> @out τ_0_0
+sil @top_level_code : $@convention(thin) () -> () {
+bb0:
+ %43 = function_ref @$S18def_generic_marker4testyxx_q_tAA16mmCollectionTypeRzAaCR_9Generator_7ElementQY_AD_AERTzr0_lF : $@convention(thin) <EC1, EC2 where EC1 : mmCollectionType, EC2 : mmCollectionType, EC1.Generator.Element == EC2.Generator.Element> (@in_guaranteed EC1, @in_guaranteed EC2) -> @out EC1
+ %0 = tuple ()
+ return %0 : $()
+}
+
+// Make sure the function body is deserialized.
+// CHECK-LABEL: @$S18def_generic_marker4testyxx_q_tAA16mmCollectionTypeRzAaCR_9Generator_7ElementQY_AD_AERTzr0_lF : $@convention(thin) <EC1, EC2 where EC1 : mmCollectionType, EC2 : mmCollectionType, EC1.Generator.Element == EC2.Generator.Element> (@in_guaranteed EC1, @in_guaranteed EC2) -> @out EC1 {
+sil @$S18def_generic_marker4testyxx_q_tAA16mmCollectionTypeRzAaCR_9Generator_7ElementQY_AD_AERTzr0_lF : $@convention(thin) <EC1, EC2 where EC1 : mmCollectionType, EC2 : mmCollectionType, EC1.Generator.Element == EC2.Generator.Element> (@in_guaranteed EC1, @in_guaranteed EC2) -> @out EC1
diff --git a/test/SIL/Serialization/plus_zero_keypath.sil b/test/SIL/Serialization/plus_zero_keypath.sil
new file mode 100644
index 0000000..00a9747
--- /dev/null
+++ b/test/SIL/Serialization/plus_zero_keypath.sil
@@ -0,0 +1,200 @@
+// REQUIRES: plus_zero_runtime
+// First parse this and then emit a *.sib. Then read in the *.sib, then recreate
+// RUN: %empty-directory(%t)
+// RUN: %target-sil-opt %s -emit-sib -o %t/tmp.sib -module-name boxes
+// RUN: %target-sil-opt %t/tmp.sib -o %t/tmp.2.sib -module-name boxes
+// RUN: %target-sil-opt %t/tmp.2.sib -module-name boxes | %FileCheck %s
+
+sil_stage canonical
+
+import Swift
+
+struct S: Hashable {
+ var x: Int
+ let y: String
+ var z: C
+
+ var hashValue: Int { get }
+ static func ==(x: S, y: S) -> Bool
+}
+class C: Hashable {
+ final var x: Int
+ final let y: String
+ final var z: S
+
+ init()
+ var overridable: Int {
+ get set
+ }
+
+ var hashValue: Int { get }
+ static func ==(x: C, y: C) -> Bool
+}
+
+protocol P {}
+protocol Q {}
+protocol R {}
+
+struct Gen<A: P, B: Q, C: R> {
+ var x: A
+ let y: B
+ var z: C
+}
+
+public struct External<T> {
+ var ro: T { get }
+
+ subscript<U: Hashable>(ro _: U) -> T { get }
+}
+
+// CHECK-LABEL: sil shared [serialized] @stored_properties
+sil shared [serialized] @stored_properties : $@convention(thin) () -> () {
+entry:
+ // CHECK: keypath $WritableKeyPath<S, Int>, (root $S; stored_property #S.x : $Int)
+ %a = keypath $WritableKeyPath<S, Int>, (root $S; stored_property #S.x : $Int)
+ // CHECK: keypath $ReferenceWritableKeyPath<C, Int>, (root $C; stored_property #C.x : $Int)
+ %b = keypath $ReferenceWritableKeyPath<C, Int>, (root $C; stored_property #C.x : $Int)
+ // CHECK: keypath $KeyPath<S, String>, (root $S; stored_property #S.y : $String)
+ %c = keypath $KeyPath<S, String>, (root $S; stored_property #S.y : $String)
+ // CHECK: keypath $ReferenceWritableKeyPath<S, Int>, (root $S; stored_property #S.z : $C; stored_property #C.x : $Int)
+ %d = keypath $ReferenceWritableKeyPath<S, Int>, (root $S; stored_property #S.z : $C; stored_property #C.x : $Int)
+
+ return undef : $()
+}
+
+// CHECK-LABEL: sil shared [serialized] @stored_properties_generic
+sil shared [serialized] @stored_properties_generic : $@convention(thin) <D: P, E: Q, F: R> () -> () {
+entry:
+ // CHECK: keypath $WritableKeyPath<Gen<D, E, F>, D>, <τ_0_0, τ_0_1, τ_0_2 where {{.*}}> (root $Gen<τ_0_0, τ_0_1, τ_0_2>; stored_property #Gen.x : $τ_0_0) <D, E, F>
+ %a = keypath $WritableKeyPath<Gen<D,E,F>, D>, <G: P, H: Q, I: R> (root $Gen<G, H, I>; stored_property #Gen.x : $G) <D, E, F>
+ // CHECK: keypath $KeyPath<Gen<D, E, F>, E>, <τ_0_0, τ_0_1, τ_0_2 where {{.*}}> (root $Gen<τ_0_0, τ_0_1, τ_0_2>; stored_property #Gen.y : $τ_0_1) <D, E, F>
+ %b = keypath $KeyPath<Gen<D,E,F>, E>, <G: P, H: Q, I: R> (root $Gen<G, H, I>; stored_property #Gen.y : $H) <D, E, F>
+
+ return undef : $()
+}
+
+sil @id_a : $@convention(thin) () -> ()
+sil @get_s_int : $@convention(thin) (@in_guaranteed S) -> @out Int
+sil @set_s_int : $@convention(thin) (@in_guaranteed Int, @in_guaranteed S) -> ()
+sil @get_c_int : $@convention(thin) (@in_guaranteed C) -> @out Int
+sil @set_c_int : $@convention(thin) (@in_guaranteed Int, @in_guaranteed C) -> ()
+sil @get_fns_fnc : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed S) -> @out S) -> @out @callee_guaranteed (@in_guaranteed C) -> @out C
+sil @set_fns_fnc : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed C) -> @out C, @in_guaranteed @callee_guaranteed (@in_guaranteed S) -> @out S) -> ()
+sil @get_s_int_subs : $@convention(thin) (@in_guaranteed S, UnsafeRawPointer) -> @out Int
+sil @set_s_int_subs : $@convention(thin) (@in_guaranteed Int, @in_guaranteed S, UnsafeRawPointer) -> ()
+sil @subs_eq : $@convention(thin) (UnsafeRawPointer, UnsafeRawPointer) -> Bool
+sil @subs_hash : $@convention(thin) (UnsafeRawPointer) -> Int
+sil @get_gen_int_subs : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (@in_guaranteed A, UnsafeRawPointer) -> @out C
+sil @set_gen_int_subs : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (@in_guaranteed C, @in_guaranteed A, UnsafeRawPointer) -> ()
+sil @gen_subs_eq : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool
+sil @gen_subs_hash : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (UnsafeRawPointer) -> Int
+
+// CHECK-LABEL: sil shared [serialized] @computed_properties
+sil shared [serialized] @computed_properties : $@convention(thin) () -> () {
+entry:
+ // CHECK: keypath $KeyPath<S, Int>, (root $S; gettable_property $Int, id @id_a : $@convention(thin) () -> (), getter @get_s_int : $@convention(thin) (@in_guaranteed S) -> @out Int)
+ %a = keypath $KeyPath<S, Int>, (root $S; gettable_property $Int, id @id_a : $@convention(thin) () -> (), getter @get_s_int : $@convention(thin) (@in_guaranteed S) -> @out Int)
+ // CHECK: keypath $WritableKeyPath<S, Int>, (root $S; settable_property $Int, id @id_a : $@convention(thin) () -> (), getter @get_s_int : $@convention(thin) (@in_guaranteed S) -> @out Int, setter @set_s_int : $@convention(thin) (@in_guaranteed Int, @in_guaranteed S) -> ())
+ %b = keypath $WritableKeyPath<S, Int>, (root $S; settable_property $Int, id @id_a : $@convention(thin) () -> (), getter @get_s_int : $@convention(thin) (@in_guaranteed S) -> @out Int, setter @set_s_int : $@convention(thin) (@in_guaranteed Int, @in_guaranteed S) -> ())
+ // CHECK: keypath $WritableKeyPath<(S) -> S, (C) -> C>, (root $(S) -> S; settable_property $(C) -> C, id @id_a : $@convention(thin) () -> (), getter @get_fns_fnc : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed S) -> @out S) -> @out @callee_guaranteed (@in_guaranteed C) -> @out C, setter @set_fns_fnc : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed C) -> @out C, @in_guaranteed @callee_guaranteed (@in_guaranteed S) -> @out S) -> ())
+ %c = keypath $WritableKeyPath<(S) -> S, (C) -> C>, (root $(S) -> S; settable_property $(C) -> C, id @id_a : $@convention(thin) () -> (), getter @get_fns_fnc : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed S) -> @out S) -> @out @callee_guaranteed (@in_guaranteed C) -> @out C, setter @set_fns_fnc : $@convention(thin) (@in_guaranteed @callee_guaranteed (@in_guaranteed C) -> @out C, @in_guaranteed @callee_guaranteed (@in_guaranteed S) -> @out S) -> ())
+ // CHECK: keypath $WritableKeyPath<C, Int>, (root $C; settable_property $Int, id #C.overridable!getter.1 : (C) -> () -> Int, getter @get_c_int : $@convention(thin) (@in_guaranteed C) -> @out Int, setter @set_c_int : $@convention(thin) (@in_guaranteed Int, @in_guaranteed C) -> ())
+ %d = keypath $WritableKeyPath<C, Int>, (root $C; settable_property $Int, id #C.overridable!getter.1 : (C) -> () -> Int, getter @get_c_int : $@convention(thin) (@in_guaranteed C) -> @out Int, setter @set_c_int : $@convention(thin) (@in_guaranteed Int, @in_guaranteed C) -> ())
+
+ return undef : $()
+}
+
+sil @get_gen_a : $@convention(thin) <X1: P, Y1: Q, Z1: R> (@in_guaranteed Gen<X1, Y1, Z1>) -> @out X1
+sil @set_gen_a : $@convention(thin) <X2: P, Y2: Q, Z2: R> (@in_guaranteed X2, @in_guaranteed Gen<X2, Y2, Z2>) -> ()
+
+// CHECK-LABEL: sil shared [serialized] @computed_properties_generic
+sil shared [serialized] @computed_properties_generic : $@convention(thin) <D: P, E: Q, F: R> () -> () {
+entry:
+ // CHECK: keypath $KeyPath<Gen<D, E, F>, D>, <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : P, τ_0_1 : Q, τ_0_2 : R> (root $Gen<τ_0_0, τ_0_1, τ_0_2>; settable_property $τ_0_0, id @id_a : $@convention(thin) () -> (), getter @get_gen_a : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : P, τ_0_1 : Q, τ_0_2 : R> (@in_guaranteed Gen<τ_0_0, τ_0_1, τ_0_2>) -> @out τ_0_0, setter @set_gen_a : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : P, τ_0_1 : Q, τ_0_2 : R> (@in_guaranteed τ_0_0, @in_guaranteed Gen<τ_0_0, τ_0_1, τ_0_2>) -> ()) <D, E, F>
+ %a = keypath $KeyPath<Gen<D, E, F>, D>, <G: P, H: Q, I: R> (root $Gen<G, H, I>; settable_property $G, id @id_a : $@convention(thin) () -> (), getter @get_gen_a : $@convention(thin) <X3: P, Y3: Q, Z3: R> (@in_guaranteed Gen<X3, Y3, Z3>) -> @out X3, setter @set_gen_a : $@convention(thin) <X4: P, Y4: Q, Z4: R> (@in_guaranteed X4, @in_guaranteed Gen<X4, Y4, Z4>) -> ()) <D, E, F>
+
+ return undef : $()
+}
+
+// CHECK-LABEL: sil shared [serialized] @optional
+sil shared [serialized] @optional : $@convention(thin) () -> () {
+entry:
+ // CHECK: keypath $KeyPath<Optional<Int>, Optional<Int>>, (root $Optional<Int>; optional_chain : $Int; optional_wrap : $Optional<Int>)
+ %a = keypath $KeyPath<Optional<Int>, Optional<Int>>, (root $Optional<Int>; optional_chain : $Int; optional_wrap : $Optional<Int>)
+ // CHECK: keypath $KeyPath<Optional<Int>, Int>, (root $Optional<Int>; optional_force : $Int)
+ %b = keypath $KeyPath<Optional<Int>, Int>, (root $Optional<Int>; optional_force : $Int)
+
+ return undef : $()
+}
+
+// CHECK-LABEL: sil shared [serialized] @indexes
+sil shared [serialized] @indexes : $@convention(thin) (S, C) -> () {
+// CHECK: bb0([[S:%.*]] : $S, [[C:%.*]] : $C):
+entry(%s : $S, %c : $C):
+ // CHECK: keypath $KeyPath<S, Int>, (root $S; settable_property $Int, id @id_a : $@convention(thin) () -> (), getter @get_s_int_subs : $@convention(thin) (@in_guaranteed S, UnsafeRawPointer) -> @out Int, setter @set_s_int_subs : $@convention(thin) (@in_guaranteed Int, @in_guaranteed S, UnsafeRawPointer) -> (), indices [%$0 : $S : $S, %$1 : $C : $C], indices_equals @subs_eq : $@convention(thin) (UnsafeRawPointer, UnsafeRawPointer) -> Bool, indices_hash @subs_hash : $@convention(thin) (UnsafeRawPointer) -> Int) ([[S]], [[C]])
+ %a = keypath $KeyPath<S, Int>, (root $S; settable_property $Int, id @id_a : $@convention(thin) () -> (), getter @get_s_int_subs : $@convention(thin) (@in_guaranteed S, UnsafeRawPointer) -> @out Int, setter @set_s_int_subs : $@convention(thin) (@in_guaranteed Int, @in_guaranteed S, UnsafeRawPointer) -> (), indices [%$0 : $S : $S, %$1 : $C : $C], indices_equals @subs_eq : $@convention(thin) (UnsafeRawPointer, UnsafeRawPointer) -> Bool, indices_hash @subs_hash : $@convention(thin) (UnsafeRawPointer) -> Int) (%s, %c)
+ // CHECK: [[T:%.*]] = alloc_stack
+ %t = alloc_stack $S
+ // CHECK: [[D:%.*]] = alloc_stack
+ %d = alloc_stack $C
+ // CHECK: keypath $KeyPath<S, Int>, <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : Hashable, τ_0_1 : Hashable, τ_0_2 : Hashable> (root $τ_0_0; settable_property $τ_0_2, id @id_a : $@convention(thin) () -> (), getter @get_gen_int_subs : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : Hashable, τ_0_1 : Hashable, τ_0_2 : Hashable> (@in_guaranteed τ_0_0, UnsafeRawPointer) -> @out τ_0_2, setter @set_gen_int_subs : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : Hashable, τ_0_1 : Hashable, τ_0_2 : Hashable> (@in_guaranteed τ_0_2, @in_guaranteed τ_0_0, UnsafeRawPointer) -> (), indices [%$0 : $τ_0_0 : $*τ_0_0, %$1 : $τ_0_1 : $*τ_0_1], indices_equals @gen_subs_eq : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : Hashable, τ_0_1 : Hashable, τ_0_2 : Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool, indices_hash @gen_subs_hash : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : Hashable, τ_0_1 : Hashable, τ_0_2 : Hashable> (UnsafeRawPointer) -> Int) <S, C, Int> ([[T]], [[D]])
+ %b = keypath $KeyPath<S, Int>, <τ_0_0: Hashable, Y: Hashable, Z: Hashable> (root $τ_0_0; settable_property $Z, id @id_a : $@convention(thin) () -> (), getter @get_gen_int_subs : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (@in_guaranteed A, UnsafeRawPointer) -> @out C, setter @set_gen_int_subs : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (@in_guaranteed C, @in_guaranteed A, UnsafeRawPointer) -> (), indices [%$0 : $τ_0_0 : $*τ_0_0, %$1 : $Y : $*Y], indices_equals @gen_subs_eq : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool, indices_hash @gen_subs_hash : $@convention(thin) <A: Hashable, B: Hashable, C: Hashable> (UnsafeRawPointer) -> Int) <S, C, Int> (%t, %d)
+
+ dealloc_stack %d : $*C
+ dealloc_stack %t : $*S
+
+ return undef : $()
+}
+
+// CHECK-LABEL: sil shared [serialized] @external
+sil shared [serialized] @external : $@convention(thin) <A, B: Hashable> (@in_guaranteed B) -> () {
+entry(%z : $*B):
+ // CHECK: %1 = keypath $KeyPath<External<Int>, Int>, (root $External<Int>; external #External.ro<Int> : $Int)
+ %a = keypath $KeyPath<External<Int>, Int>, (root $External<Int>; external #External.ro<Int> : $Int)
+
+ // CHECK: %2 = keypath $KeyPath<External<A>, A>, <τ_0_0, τ_0_1, τ_0_2> (root $External<τ_0_2>; external #External.ro<τ_0_2> : $τ_0_2) <A, A, A>
+ %b = keypath $KeyPath<External<A>, A>, <C, D, E> (root $External<E>; external #External.ro <E> : $E) <A, A, A>
+
+ // CHECK: %3 = keypath $KeyPath<External<Int>, Int>, <τ_0_0> (root $External<τ_0_0>; external #External.ro<τ_0_0> : $τ_0_0) <Int>
+ %c = keypath $KeyPath<External<Int>, Int>, <F> (root $External<F>; external #External.ro <F> : $F) <Int>
+
+ // CHECK: %4 = keypath $KeyPath<External<A>, A>, <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (root $External<τ_0_1>; external #External.subscript<τ_0_1, τ_0_0>[%$0 : $τ_0_0 : $*τ_0_0] : $τ_0_1) <B, A> (%0)
+ %d = keypath $KeyPath<External<A>, A>, <G: Hashable, H> (root $External<H>; external #External.subscript <H, G> [%$0 : $G : $*G] : $H) <B, A> (%z)
+
+ return undef : $()
+}
+
+sil [serialized] @serialize_all : $@convention(thin) () -> () {
+entry:
+ %0 = function_ref @stored_properties : $@convention(thin) () -> ()
+ %1 = function_ref @stored_properties_generic : $@convention(thin) <D: P, E: Q, F: R> () -> ()
+ %2 = function_ref @computed_properties : $@convention(thin) () -> ()
+ %3 = function_ref @computed_properties_generic : $@convention(thin) <D: P, E: Q, F: R> () -> ()
+ %4 = function_ref @optional : $@convention(thin) () -> ()
+ %5 = function_ref @indexes : $@convention(thin) (S, C) -> ()
+ %6 = function_ref @external : $@convention(thin) <A, B: Hashable> (@in_guaranteed B) -> ()
+
+ unreachable
+}
+
+sil [serialized] @get_external_subscript : $@convention(thin) <T, U: Hashable> (@in_guaranteed External<T>, UnsafeRawPointer) -> @out T
+sil [serialized] @equals_external_subscript : $@convention(thin) <T, U: Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool
+sil [serialized] @hash_external_subscript : $@convention(thin) <T, U: Hashable> (UnsafeRawPointer) -> Int
+
+// CHECK-LABEL: sil_property [serialized] #External.ro<τ_0_0> (stored_property #External.ro : $τ_0_0)
+sil_property [serialized] #External.ro <T> (stored_property #External.ro : $T)
+
+// CHECK-LABEL: sil_property [serialized] #External.subscript<τ_0_0><τ_1_0 where τ_1_0 : Hashable> (gettable_property $τ_0_0,
+// CHECK-SAME: id @id_a : $@convention(thin) () -> (),
+// CHECK-SAME: getter @get_external_subscript : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_1 : Hashable> (@in_guaranteed External<τ_0_0>, UnsafeRawPointer) -> @out τ_0_0,
+// CHECK-SAME: indices [%$0 : $τ_1_0 : $*τ_1_0],
+// CHECK-SAME: indices_equals @equals_external_subscript : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_1 : Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool,
+// CHECK-SAME: indices_hash @hash_external_subscript : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_1 : Hashable> (UnsafeRawPointer) -> Int)
+sil_property [serialized] #External.subscript <T><U: Hashable> (gettable_property $T,
+ id @id_a : $@convention(thin) () -> (),
+ getter @get_external_subscript : $@convention(thin) <T, U: Hashable> (@in_guaranteed External<T>, UnsafeRawPointer) -> @out T,
+ indices [%$0 : $U : $*U],
+ indices_equals @equals_external_subscript : $@convention(thin) <T, U: Hashable> (UnsafeRawPointer, UnsafeRawPointer) -> Bool,
+ indices_hash @hash_external_subscript : $@convention(thin) <T, U: Hashable> (UnsafeRawPointer) -> Int)
+
+
diff --git a/test/SILGen/access_marker_gen.swift b/test/SILGen/access_marker_gen.swift
index fff4558..974aa66 100644
--- a/test/SILGen/access_marker_gen.swift
+++ b/test/SILGen/access_marker_gen.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -parse-as-library -Xllvm -sil-full-demangle -enforce-exclusivity=checked -emit-silgen -enable-sil-ownership %s | %FileCheck %s
func modify<T>(_ x: inout T) {}
diff --git a/test/SILGen/accessors.swift b/test/SILGen/accessors.swift
index 06982c9..5a85c8d 100644
--- a/test/SILGen/accessors.swift
+++ b/test/SILGen/accessors.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -enable-sil-ownership %s | %FileCheck %s
// Hold a reference to do to magically become non-POD.
@@ -65,9 +66,8 @@
// CHECK-NEXT: switch_enum [[OPT_CALLBACK]] : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: [[WRITEBACK:bb[0-9]+]], case #Optional.none!enumelt: [[CONT:bb[0-9]+]]
// CHECK: [[WRITEBACK]]([[CALLBACK_ADDR:%.*]] : @trivial $Builtin.RawPointer):
-// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout A, @thick A.Type) -> ()
+// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed A, @thick A.Type) -> ()
// CHECK-NEXT: [[TEMP2:%.*]] = alloc_stack $A
-// SEMANTIC SIL TODO: This is an issue caused by the callback for materializeForSet in the class case taking the value as @inout when it should really take it as @guaranteed.
// CHECK-NEXT: store_borrow [[BORROWED_ARG_LHS]] to [[TEMP2]] : $*A
// CHECK-NEXT: [[T0:%.*]] = metatype $@thick A.Type
// CHECK-NEXT: [[T1:%.*]] = address_to_pointer [[ADDR]] : $*OrdinarySub to $Builtin.RawPointer
@@ -128,7 +128,7 @@
// CHECK-NEXT: switch_enum [[OPT_CALLBACK]] : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: [[WRITEBACK:bb[0-9]+]], case #Optional.none!enumelt: [[CONT:bb[0-9]+]]
//
// CHECK: [[WRITEBACK]]([[CALLBACK_ADDR:%.*]] : @trivial $Builtin.RawPointer):
-// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout B, @thick B.Type) -> ()
+// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed B, @thick B.Type) -> ()
// CHECK-NEXT: [[TEMP2:%.*]] = alloc_stack $B
// CHECK-NEXT: store_borrow [[BORROWED_ARG_RHS]] to [[TEMP2]] : $*B
// CHECK-NEXT: [[T0:%.*]] = metatype $@thick B.Type
@@ -154,7 +154,7 @@
// CHECK-NEXT: switch_enum [[OPT_CALLBACK]] : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: [[WRITEBACK:bb[0-9]+]], case #Optional.none!enumelt: [[CONT:bb[0-9]+]]
//
// CHECK: [[WRITEBACK]]([[CALLBACK_ADDR:%.*]] : @trivial $Builtin.RawPointer):
-// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout B, @thick B.Type) -> ()
+// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed B, @thick B.Type) -> ()
// CHECK-NEXT: [[TEMP2:%.*]] = alloc_stack $B
// CHECK-NEXT: store_borrow [[BORROWED_ARG_LHS]] to [[TEMP2]] : $*B
// CHECK-NEXT: [[T0:%.*]] = metatype $@thick B.Type
diff --git a/test/SILGen/address_only_types.swift b/test/SILGen/address_only_types.swift
index 3d771a8..bc02604 100644
--- a/test/SILGen/address_only_types.swift
+++ b/test/SILGen/address_only_types.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -parse-as-library -parse-stdlib -emit-silgen %s | %FileCheck %s
precedencegroup AssignmentPrecedence { assignment: true }
diff --git a/test/SILGen/addressors.swift b/test/SILGen/addressors.swift
index 76fe58a..a1186cd 100644
--- a/test/SILGen/addressors.swift
+++ b/test/SILGen/addressors.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -emit-sil %s | %FileCheck %s
// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -emit-silgen %s | %FileCheck %s -check-prefix=SILGEN
// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -emit-ir %s
@@ -354,7 +355,7 @@
// CHECK: strong_release [[OWNER]] : $Builtin.NativeObject
// materializeForSet callback for G.value
-// CHECK-LABEL: sil private [transparent] @$S10addressors1GC5values5Int32VvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout G, @thick G.Type) -> () {
+// CHECK-LABEL: sil private [transparent] @$S10addressors1GC5values5Int32VvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed G, @thick G.Type) -> () {
// CHECK: bb0([[BUFFER:%0]] : $Builtin.RawPointer, [[STORAGE:%1]] : $*Builtin.UnsafeValueBuffer, [[SELF:%2]] : $*G, [[SELFTYPE:%3]] : $@thick G.Type):
// CHECK: [[T0:%.*]] = project_value_buffer $Builtin.NativeObject in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
// CHECK: [[OWNER:%.*]] = load [[T0]]
@@ -475,7 +476,7 @@
// CHECK: strong_unpin [[OWNER]] : $Optional<Builtin.NativeObject>
// materializeForSet callback for I.value
-// CHECK-LABEL: sil private [transparent] @$S10addressors1IC5values5Int32VvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout I, @thick I.Type) -> () {
+// CHECK-LABEL: sil private [transparent] @$S10addressors1IC5values5Int32VvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed I, @thick I.Type) -> () {
// CHECK: bb0([[BUFFER:%0]] : $Builtin.RawPointer, [[STORAGE:%1]] : $*Builtin.UnsafeValueBuffer, [[SELF:%2]] : $*I, [[SELFTYPE:%3]] : $@thick I.Type):
// CHECK: [[T0:%.*]] = project_value_buffer $Optional<Builtin.NativeObject> in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
// CHECK: [[OWNER:%.*]] = load [[T0]]
diff --git a/test/SILGen/apply_abstraction_nested.swift b/test/SILGen/apply_abstraction_nested.swift
index df737ad..6ea71bd 100644
--- a/test/SILGen/apply_abstraction_nested.swift
+++ b/test/SILGen/apply_abstraction_nested.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -emit-silgen %s | %FileCheck %s
infix operator ~> { precedence 255 associativity left }
diff --git a/test/SILGen/argument_labels.swift b/test/SILGen/argument_labels.swift
index 629cb93..4702392 100644
--- a/test/SILGen/argument_labels.swift
+++ b/test/SILGen/argument_labels.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
public struct X { }
diff --git a/test/SILGen/argument_shuffle_swift3.swift b/test/SILGen/argument_shuffle_swift3.swift
index 9a671c8..d28323c 100644
--- a/test/SILGen/argument_shuffle_swift3.swift
+++ b/test/SILGen/argument_shuffle_swift3.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s -swift-version 3 | %FileCheck %s
func fn(_: Any) {}
diff --git a/test/SILGen/array_literal_abstraction.swift b/test/SILGen/array_literal_abstraction.swift
index 5a72c8f..074cf18 100644
--- a/test/SILGen/array_literal_abstraction.swift
+++ b/test/SILGen/array_literal_abstraction.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
// Verify that reabstraction happens when forming container literals.
diff --git a/test/SILGen/auto_closures.swift b/test/SILGen/auto_closures.swift
index ae73d29..f87040c 100644
--- a/test/SILGen/auto_closures.swift
+++ b/test/SILGen/auto_closures.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -parse-stdlib -emit-silgen %s | %FileCheck %s
struct Bool {}
diff --git a/test/SILGen/borrow.swift b/test/SILGen/borrow.swift
index 12789f0..35c3c73 100644
--- a/test/SILGen/borrow.swift
+++ b/test/SILGen/borrow.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -emit-silgen %s | %FileCheck %s
import Swift
diff --git a/test/SILGen/boxed_existentials.swift b/test/SILGen/boxed_existentials.swift
index ae640f1..92210e8 100644
--- a/test/SILGen/boxed_existentials.swift
+++ b/test/SILGen/boxed_existentials.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-silgen %s | %FileCheck %s
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-silgen %s | %FileCheck %s --check-prefix=GUARANTEED
diff --git a/test/SILGen/call_chain_reabstraction.swift b/test/SILGen/call_chain_reabstraction.swift
index 22b8a82..bca5a66 100644
--- a/test/SILGen/call_chain_reabstraction.swift
+++ b/test/SILGen/call_chain_reabstraction.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
struct A {
diff --git a/test/SILGen/capture_typed_boxes.swift b/test/SILGen/capture_typed_boxes.swift
index b19759f..50a806e 100644
--- a/test/SILGen/capture_typed_boxes.swift
+++ b/test/SILGen/capture_typed_boxes.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
func foo(_ x: Int) -> () -> Int {
diff --git a/test/SILGen/casts.swift b/test/SILGen/casts.swift
index 8a429ea..74e7718 100644
--- a/test/SILGen/casts.swift
+++ b/test/SILGen/casts.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
class B { }
diff --git a/test/SILGen/cf.swift b/test/SILGen/cf.swift
index aa4cb6a..ebc2c23 100644
--- a/test/SILGen/cf.swift
+++ b/test/SILGen/cf.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -import-cf-types -sdk %S/Inputs %s -emit-silgen -o - | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILGen/class_bound_protocols.swift b/test/SILGen/class_bound_protocols.swift
index bf9df67..b190ced 100644
--- a/test/SILGen/class_bound_protocols.swift
+++ b/test/SILGen/class_bound_protocols.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -parse-stdlib -parse-as-library -module-name Swift -emit-silgen %s | %FileCheck %s
enum Optional<T> {
diff --git a/test/SILGen/class_resilience.swift b/test/SILGen/class_resilience.swift
index 8b91e2e..e821bc5 100644
--- a/test/SILGen/class_resilience.swift
+++ b/test/SILGen/class_resilience.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_struct.swiftmodule -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_class.swiftmodule -module-name=resilient_class -I %t %S/../Inputs/resilient_class.swift
diff --git a/test/SILGen/closures.swift b/test/SILGen/closures.swift
index c90d81d..ca0d033 100644
--- a/test/SILGen/closures.swift
+++ b/test/SILGen/closures.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -parse-as-library -emit-silgen %s | %FileCheck %s
// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -parse-as-library -emit-silgen %s | %FileCheck %s --check-prefix=GUARANTEED
diff --git a/test/SILGen/collection_downcast.swift b/test/SILGen/collection_downcast.swift
index a6633f0..b3768d4 100644
--- a/test/SILGen/collection_downcast.swift
+++ b/test/SILGen/collection_downcast.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -sdk %S/Inputs -I %S/Inputs -enable-source-import %s | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILGen/collection_subtype_downcast.swift b/test/SILGen/collection_subtype_downcast.swift
index ce47645..821115f 100644
--- a/test/SILGen/collection_subtype_downcast.swift
+++ b/test/SILGen/collection_subtype_downcast.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -sdk %S/Inputs %s | %FileCheck %s
struct S { var x, y: Int }
diff --git a/test/SILGen/collection_subtype_upcast.swift b/test/SILGen/collection_subtype_upcast.swift
index 6081663..d6d4ad9 100644
--- a/test/SILGen/collection_subtype_upcast.swift
+++ b/test/SILGen/collection_subtype_upcast.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -sdk %S/Inputs %s | %FileCheck %s
struct S { var x, y: Int }
diff --git a/test/SILGen/collection_upcast.swift b/test/SILGen/collection_upcast.swift
index ac73520..faecb5b 100644
--- a/test/SILGen/collection_upcast.swift
+++ b/test/SILGen/collection_upcast.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -sdk %S/Inputs -I %S/Inputs -enable-source-import %s | %FileCheck %s
// FIXME: rdar://problem/19648117 Needs splitting objc parts out
diff --git a/test/SILGen/constrained_extensions.swift b/test/SILGen/constrained_extensions.swift
index 2d1fd81..f6e8418 100644
--- a/test/SILGen/constrained_extensions.swift
+++ b/test/SILGen/constrained_extensions.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -primary-file %s | %FileCheck %s
// RUN: %target-swift-frontend -emit-sil -O -primary-file %s > /dev/null
// RUN: %target-swift-frontend -emit-ir -primary-file %s > /dev/null
@@ -137,7 +138,7 @@
extension GenericClass where Y == () {
// CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlE5valuexvg : $@convention(method) <X, Y where Y == ()> (@guaranteed GenericClass<X, ()>) -> @out X
// CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlE5valuexvs : $@convention(method) <X, Y where Y == ()> (@in X, @guaranteed GenericClass<X, ()>) -> ()
- // CHECK-LABEL: sil shared [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlE5valuexvmytfU_ : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout GenericClass<X, ()>, @thick GenericClass<X, ()>.Type) -> ()
+ // CHECK-LABEL: sil shared [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlE5valuexvmytfU_ : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed GenericClass<X, ()>, @thick GenericClass<X, ()>.Type) -> ()
// CHECK-LABEL: sil [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlE5valuexvm : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed GenericClass<X, ()>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
public var value: X {
get { while true {} }
@@ -146,7 +147,7 @@
// CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlE5emptyytvg : $@convention(method) <X, Y where Y == ()> (@guaranteed GenericClass<X, ()>) -> ()
// CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlE5emptyytvs : $@convention(method) <X, Y where Y == ()> (@guaranteed GenericClass<X, ()>) -> ()
- // CHECK-LABEL: sil shared [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlE5emptyytvmytfU_ : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout GenericClass<X, ()>, @thick GenericClass<X, ()>.Type) -> ()
+ // CHECK-LABEL: sil shared [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlE5emptyytvmytfU_ : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed GenericClass<X, ()>, @thick GenericClass<X, ()>.Type) -> ()
// CHECK-LABEL: sil [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlE5emptyytvm : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed GenericClass<X, ()>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
public var empty: Y {
get { return () }
@@ -155,7 +156,7 @@
// CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlEyxyt_tcig : $@convention(method) <X, Y where Y == ()> (@guaranteed GenericClass<X, ()>) -> @out X
// CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlEyxyt_tcis : $@convention(method) <X, Y where Y == ()> (@in X, @guaranteed GenericClass<X, ()>) -> ()
- // CHECK-LABEL: sil shared [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlEyxyt_tcimytfU_ : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout GenericClass<X, ()>, @thick GenericClass<X, ()>.Type) -> ()
+ // CHECK-LABEL: sil shared [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlEyxyt_tcimytfU_ : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed GenericClass<X, ()>, @thick GenericClass<X, ()>.Type) -> ()
// CHECK-LABEL: sil [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlEyxyt_tcim : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed GenericClass<X, ()>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
public subscript(_: Y) -> X {
get { while true {} }
@@ -164,7 +165,7 @@
// CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlEyyxcig : $@convention(method) <X, Y where Y == ()> (@in X, @guaranteed GenericClass<X, ()>) -> ()
// CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlEyyxcis : $@convention(method) <X, Y where Y == ()> (@in X, @guaranteed GenericClass<X, ()>) -> ()
- // CHECK-LABEL: sil shared [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlEyyxcimytfU_ : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout GenericClass<X, ()>, @thick GenericClass<X, ()>.Type) -> ()
+ // CHECK-LABEL: sil shared [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlEyyxcimytfU_ : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed GenericClass<X, ()>, @thick GenericClass<X, ()>.Type) -> ()
// CHECK-LABEL: sil [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlEyyxcim : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in X, @guaranteed GenericClass<X, ()>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
public subscript(_: X) -> Y {
get { while true {} }
diff --git a/test/SILGen/default_arguments.swift b/test/SILGen/default_arguments.swift
index 0059519..ad11d44 100644
--- a/test/SILGen/default_arguments.swift
+++ b/test/SILGen/default_arguments.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-silgen -swift-version 3 %s | %FileCheck %s
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-silgen -swift-version 3 %s | %FileCheck %s --check-prefix=NEGATIVE
diff --git a/test/SILGen/default_arguments_generic.swift b/test/SILGen/default_arguments_generic.swift
index 61297aa..4755f22 100644
--- a/test/SILGen/default_arguments_generic.swift
+++ b/test/SILGen/default_arguments_generic.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -swift-version 3 %s | %FileCheck %s
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -swift-version 4 %s | %FileCheck %s
diff --git a/test/SILGen/default_arguments_serialized.swift b/test/SILGen/default_arguments_serialized.swift
index 0172a9c..2308dcd 100644
--- a/test/SILGen/default_arguments_serialized.swift
+++ b/test/SILGen/default_arguments_serialized.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module-path %t/default_arguments_other.swiftmodule -emit-module -swift-version 4 -primary-file %S/Inputs/default_arguments_other.swift
diff --git a/test/SILGen/dependent_member_lowering.swift b/test/SILGen/dependent_member_lowering.swift
index 218c589..86aad55 100644
--- a/test/SILGen/dependent_member_lowering.swift
+++ b/test/SILGen/dependent_member_lowering.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
protocol P {
diff --git a/test/SILGen/downcast_reabstraction.swift b/test/SILGen/downcast_reabstraction.swift
index 191a90e..3a07b17 100644
--- a/test/SILGen/downcast_reabstraction.swift
+++ b/test/SILGen/downcast_reabstraction.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
// CHECK-LABEL: sil hidden @$S22downcast_reabstraction19condFunctionFromAnyyyypF
diff --git a/test/SILGen/dynamic.swift b/test/SILGen/dynamic.swift
index 7d85d4e..49806ca 100644
--- a/test/SILGen/dynamic.swift
+++ b/test/SILGen/dynamic.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %build-silgen-test-overlays
diff --git a/test/SILGen/dynamic_lookup.swift b/test/SILGen/dynamic_lookup.swift
index a0d85b3..b55f1f0 100644
--- a/test/SILGen/dynamic_lookup.swift
+++ b/test/SILGen/dynamic_lookup.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -parse-as-library -emit-silgen -disable-objc-attr-requires-foundation-module %s | %FileCheck %s
// RUN: %target-swift-frontend -parse-as-library -emit-silgen -disable-objc-attr-requires-foundation-module %s | %FileCheck %s --check-prefix=GUARANTEED
diff --git a/test/SILGen/dynamic_lookup_throws.swift b/test/SILGen/dynamic_lookup_throws.swift
index 67ac9b4..178909d 100644
--- a/test/SILGen/dynamic_lookup_throws.swift
+++ b/test/SILGen/dynamic_lookup_throws.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %build-clang-importer-objc-overlays
diff --git a/test/SILGen/dynamic_self.swift b/test/SILGen/dynamic_self.swift
index a08e377..fc284ae 100644
--- a/test/SILGen/dynamic_self.swift
+++ b/test/SILGen/dynamic_self.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen %s -disable-objc-attr-requires-foundation-module | %FileCheck %s
// RUN: %target-swift-frontend -emit-sil -O %s -disable-objc-attr-requires-foundation-module
// RUN: %target-swift-frontend -emit-ir %s -disable-objc-attr-requires-foundation-module
diff --git a/test/SILGen/enum.swift b/test/SILGen/enum.swift
index af87a52..f16ea12 100644
--- a/test/SILGen/enum.swift
+++ b/test/SILGen/enum.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -parse-stdlib -parse-as-library -emit-silgen -enable-sil-ownership -module-name Swift %s | %FileCheck %s
precedencegroup AssignmentPrecedence { assignment: true }
diff --git a/test/SILGen/enum_resilience.swift b/test/SILGen/enum_resilience.swift
index dbebe9c..d2f2145 100644
--- a/test/SILGen/enum_resilience.swift
+++ b/test/SILGen/enum_resilience.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_struct.swiftmodule -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_enum.swiftmodule -module-name=resilient_enum -I %t %S/../Inputs/resilient_enum.swift
diff --git a/test/SILGen/erasure_reabstraction.swift b/test/SILGen/erasure_reabstraction.swift
index a63f65b..10c6e39 100644
--- a/test/SILGen/erasure_reabstraction.swift
+++ b/test/SILGen/erasure_reabstraction.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
struct Foo {}
diff --git a/test/SILGen/existential_erasure.swift b/test/SILGen/existential_erasure.swift
index ead4724..15bf015 100644
--- a/test/SILGen/existential_erasure.swift
+++ b/test/SILGen/existential_erasure.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
protocol P {
diff --git a/test/SILGen/expressions.swift b/test/SILGen/expressions.swift
index 5f91200..6de0dea 100644
--- a/test/SILGen/expressions.swift
+++ b/test/SILGen/expressions.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: echo "public var x = Int()" | %target-swift-frontend -module-name FooBar -emit-module -o %t -
// RUN: %target-swift-frontend -parse-stdlib -emit-silgen -enable-sil-ownership %s -I%t -disable-access-control | %FileCheck %s
diff --git a/test/SILGen/extensions_objc.swift b/test/SILGen/extensions_objc.swift
index 36fce74..7015fa7 100644
--- a/test/SILGen/extensions_objc.swift
+++ b/test/SILGen/extensions_objc.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -sdk %S/Inputs %s -I %S/Inputs -enable-source-import -emit-silgen -enable-sil-ownership | %FileCheck %s
//
// REQUIRES: objc_interop
diff --git a/test/SILGen/external_definitions.swift b/test/SILGen/external_definitions.swift
index 6cff400..e7a1090 100644
--- a/test/SILGen/external_definitions.swift
+++ b/test/SILGen/external_definitions.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -sdk %S/Inputs %s -emit-silgen -enable-sil-ownership | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILGen/final.swift b/test/SILGen/final.swift
index 1538d5e..dd24729 100644
--- a/test/SILGen/final.swift
+++ b/test/SILGen/final.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
class TestClass {
diff --git a/test/SILGen/force_cast_chained_optional.swift b/test/SILGen/force_cast_chained_optional.swift
index e84b241..2eae970 100644
--- a/test/SILGen/force_cast_chained_optional.swift
+++ b/test/SILGen/force_cast_chained_optional.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
class Foo {
diff --git a/test/SILGen/foreach.swift b/test/SILGen/foreach.swift
index 745cb95..6dd219b 100644
--- a/test/SILGen/foreach.swift
+++ b/test/SILGen/foreach.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
//////////////////
diff --git a/test/SILGen/foreign_errors.swift b/test/SILGen/foreign_errors.swift
index e3c45fe..65bc729 100644
--- a/test/SILGen/foreign_errors.swift
+++ b/test/SILGen/foreign_errors.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %build-clang-importer-objc-overlays
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -emit-silgen -parse-as-library %s | %FileCheck %s
diff --git a/test/SILGen/function_conversion.swift b/test/SILGen/function_conversion.swift
index 0fac5bc..2266959 100644
--- a/test/SILGen/function_conversion.swift
+++ b/test/SILGen/function_conversion.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -primary-file %s | %FileCheck %s
// RUN: %target-swift-frontend -emit-ir -enable-sil-ownership -primary-file %s
diff --git a/test/SILGen/function_conversion_objc.swift b/test/SILGen/function_conversion_objc.swift
index 0af62ed..fcd20ec 100644
--- a/test/SILGen/function_conversion_objc.swift
+++ b/test/SILGen/function_conversion_objc.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -sdk %S/Inputs %s -I %S/Inputs -enable-sil-ownership -enable-source-import -emit-silgen -verify | %FileCheck %s
import Foundation
diff --git a/test/SILGen/functions.swift b/test/SILGen/functions.swift
index 36e943a..bc02381 100644
--- a/test/SILGen/functions.swift
+++ b/test/SILGen/functions.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -parse-stdlib -parse-as-library -emit-silgen -enable-sil-ownership %s | %FileCheck %s
import Swift // just for Optional
diff --git a/test/SILGen/generic_casts.swift b/test/SILGen/generic_casts.swift
index 6fe1f40..56d6d8d 100644
--- a/test/SILGen/generic_casts.swift
+++ b/test/SILGen/generic_casts.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -enable-sil-ownership %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-%target-runtime %s
protocol ClassBound : class {}
diff --git a/test/SILGen/generic_closures.swift b/test/SILGen/generic_closures.swift
index b3bddf9..7cabd10 100644
--- a/test/SILGen/generic_closures.swift
+++ b/test/SILGen/generic_closures.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -parse-stdlib -emit-silgen -enable-sil-ownership %s | %FileCheck %s
import Swift
diff --git a/test/SILGen/generic_property_base_lifetime.swift b/test/SILGen/generic_property_base_lifetime.swift
index 9ccc903..7338fee 100644
--- a/test/SILGen/generic_property_base_lifetime.swift
+++ b/test/SILGen/generic_property_base_lifetime.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen %s -disable-objc-attr-requires-foundation-module -enable-sil-ownership | %FileCheck %s
protocol ProtocolA: class {
diff --git a/test/SILGen/generic_tuples.swift b/test/SILGen/generic_tuples.swift
index 137bd18..c2330dd 100644
--- a/test/SILGen/generic_tuples.swift
+++ b/test/SILGen/generic_tuples.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -parse-as-library -enable-sil-ownership %s | %FileCheck %s
diff --git a/test/SILGen/generic_witness.swift b/test/SILGen/generic_witness.swift
index 3b4a719..98dfffe 100644
--- a/test/SILGen/generic_witness.swift
+++ b/test/SILGen/generic_witness.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
// RUN: %target-swift-frontend -emit-ir -enable-sil-ownership %s
diff --git a/test/SILGen/guaranteed_normal_args.swift b/test/SILGen/guaranteed_normal_args.swift
index a072527..250a763 100644
--- a/test/SILGen/guaranteed_normal_args.swift
+++ b/test/SILGen/guaranteed_normal_args.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -parse-as-library -module-name Swift -parse-stdlib -emit-silgen -enable-sil-ownership -enable-guaranteed-normal-arguments %s | %FileCheck %s
// This test checks specific codegen related to normal arguments being passed at
diff --git a/test/SILGen/guaranteed_self.swift b/test/SILGen/guaranteed_self.swift
index b285f62..02e4524 100644
--- a/test/SILGen/guaranteed_self.swift
+++ b/test/SILGen/guaranteed_self.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen %s -disable-objc-attr-requires-foundation-module -enable-sil-ownership | %FileCheck %s
protocol Fooable {
diff --git a/test/SILGen/if_while_binding.swift b/test/SILGen/if_while_binding.swift
index c921e3e..9564b01 100644
--- a/test/SILGen/if_while_binding.swift
+++ b/test/SILGen/if_while_binding.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -enable-sil-ownership %s | %FileCheck %s
func foo() -> String? { return "" }
diff --git a/test/SILGen/implicitly_unwrapped_optional.swift b/test/SILGen/implicitly_unwrapped_optional.swift
index 3273c3b..5307d7f 100644
--- a/test/SILGen/implicitly_unwrapped_optional.swift
+++ b/test/SILGen/implicitly_unwrapped_optional.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
func foo(f f: (() -> ())!) {
diff --git a/test/SILGen/indirect_enum.swift b/test/SILGen/indirect_enum.swift
index bae2be1..b384995 100644
--- a/test/SILGen/indirect_enum.swift
+++ b/test/SILGen/indirect_enum.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-print-debuginfo -emit-silgen %s | %FileCheck %s
indirect enum TreeA<T> {
diff --git a/test/SILGen/inlineable_attribute.swift b/test/SILGen/inlineable_attribute.swift
index 564b5b5..747abcc 100644
--- a/test/SILGen/inlineable_attribute.swift
+++ b/test/SILGen/inlineable_attribute.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -emit-verbose-sil %s | %FileCheck %s
// CHECK-LABEL: sil [serialized] @$S20inlineable_attribute15fragileFunctionyyF : $@convention(thin) () -> ()
diff --git a/test/SILGen/inlineable_attribute_objc.swift b/test/SILGen/inlineable_attribute_objc.swift
index 8e36109..a7ff8d5 100644
--- a/test/SILGen/inlineable_attribute_objc.swift
+++ b/test/SILGen/inlineable_attribute_objc.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %build-silgen-test-overlays
diff --git a/test/SILGen/keypath_application.swift b/test/SILGen/keypath_application.swift
index 88cd272..66a8fb7 100644
--- a/test/SILGen/keypath_application.swift
+++ b/test/SILGen/keypath_application.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
class A {}
diff --git a/test/SILGen/keypaths.swift b/test/SILGen/keypaths.swift
index d028842..55fc6ab 100644
--- a/test/SILGen/keypaths.swift
+++ b/test/SILGen/keypaths.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
struct S<T> {
diff --git a/test/SILGen/let_decls.swift b/test/SILGen/let_decls.swift
index 43e68654..493c2db 100644
--- a/test/SILGen/let_decls.swift
+++ b/test/SILGen/let_decls.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -enable-sil-ownership %s | %FileCheck %s
func takeClosure(_ a : () -> Int) {}
diff --git a/test/SILGen/lifetime.swift b/test/SILGen/lifetime.swift
index 751f386..1700a7f 100644
--- a/test/SILGen/lifetime.swift
+++ b/test/SILGen/lifetime.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -parse-as-library -emit-silgen -primary-file %s | %FileCheck %s
struct Buh<T> {
@@ -389,7 +390,7 @@
// CHECK: [[ADDR:%.*]] = pointer_to_address [[PTR]]
// CHECK: [[MARKED_ADDR:%.*]] = mark_dependence [[ADDR]] : $*Aleph on [[R2]]
// CHECK: {{.*}}([[CALLBACK_ADDR:%.*]] :
- // CHECK: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout RefWithProp, @thick RefWithProp.Type) -> ()
+ // CHECK: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed RefWithProp, @thick RefWithProp.Type) -> ()
// CHECK: [[TEMP:%.*]] = alloc_stack $RefWithProp
// CHECK: store [[R2]] to [init] [[TEMP]]
// CHECK: apply [[CALLBACK]]({{.*}}, [[STORAGE]], [[TEMP]], {{%.*}})
diff --git a/test/SILGen/mangling.swift b/test/SILGen/mangling.swift
index 0cb1dd2..6fffed4 100644
--- a/test/SILGen/mangling.swift
+++ b/test/SILGen/mangling.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -sdk %S/Inputs -I %S/Inputs -enable-source-import %s -emit-silgen -enable-sil-ownership | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILGen/materializeForSet.swift b/test/SILGen/materializeForSet.swift
index 97adf6f..be4c1a4 100644
--- a/test/SILGen/materializeForSet.swift
+++ b/test/SILGen/materializeForSet.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
// RUN: %target-swift-frontend -emit-silgen -enforce-exclusivity=unchecked %s | %FileCheck --check-prefix=UNCHECKED %s
@@ -22,7 +23,7 @@
// UNCHECKED: return [[T3]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
// UNCHECKED: }
-// CHECK-LABEL: sil private [transparent] @$S17materializeForSet4BaseC8computedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Base, @thick Base.Type) -> () {
+// CHECK-LABEL: sil private [transparent] @$S17materializeForSet4BaseC8computedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed Base, @thick Base.Type) -> () {
// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $*Base, [[SELFTYPE:%.*]] : $@thick Base.Type):
// CHECK: [[T0:%.*]] = load_borrow [[SELF]]
// CHECK: [[T1:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
@@ -37,7 +38,7 @@
// CHECK: [[T1:%.*]] = apply [[T0]]([[SELF]])
// CHECK: store [[T1]] to [trivial] [[ADDR]] : $*Int
// CHECK: [[BUFFER:%.*]] = address_to_pointer [[ADDR]]
-// CHECK: [[T0:%.*]] = function_ref @$S17materializeForSet4BaseC8computedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Base, @thick Base.Type) -> ()
+// CHECK: [[T0:%.*]] = function_ref @$S17materializeForSet4BaseC8computedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed Base, @thick Base.Type) -> ()
// CHECK: [[T2:%.*]] = thin_function_to_pointer [[T0]]
// CHECK: [[T3:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[T2]] : $Builtin.RawPointer
// CHECK: [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, [[T3]] : $Optional<Builtin.RawPointer>)
@@ -76,7 +77,7 @@
extension Derived : Abstractable {}
-// CHECK-LABEL: sil private [transparent] @$S17materializeForSet7DerivedCAA12AbstractableA2aDP14storedFunction6ResultQzycvmytfU_TW : $@convention(witness_method: Abstractable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Derived, @thick Derived.Type) -> ()
+// CHECK-LABEL: sil private [transparent] @$S17materializeForSet7DerivedCAA12AbstractableA2aDP14storedFunction6ResultQzycvmytfU_TW : $@convention(witness_method: Abstractable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed Derived, @thick Derived.Type) -> ()
// CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*Derived, %3 : $@thick Derived.Type):
// CHECK-NEXT: [[T0:%.*]] = load_borrow %2 : $*Derived
// CHECK-NEXT: [[SELF:%.*]] = upcast [[T0]] : $Derived to $Base
@@ -217,8 +218,8 @@
// CHECK-NEXT: destroy_addr [[OUT]] : $*@callee_guaranteed () -> Int
// CHECK-NEXT: store [[NEWVALUE]] to [init] [[RESULT_ADDR]] : $*@callee_guaranteed () -> @out Int
// CHECK-NEXT: [[ADDR:%.*]] = address_to_pointer [[RESULT_ADDR]] : $*@callee_guaranteed () -> @out Int to $Builtin.RawPointer
-// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S17materializeForSet7DerivedCAA12AbstractableA2aDP14staticFunction6ResultQzycvmZytfU_TW : $@convention(witness_method: Abstractable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout @thick Derived.Type, @thick Derived.Type.Type) -> ()
-// CHECK-NEXT: [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]] : $@convention(witness_method: Abstractable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout @thick Derived.Type, @thick Derived.Type.Type) -> () to $Builtin.RawPointer
+// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S17materializeForSet7DerivedCAA12AbstractableA2aDP14staticFunction6ResultQzycvmZytfU_TW : $@convention(witness_method: Abstractable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed @thick Derived.Type, @thick Derived.Type.Type) -> ()
+// CHECK-NEXT: [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]] : $@convention(witness_method: Abstractable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed @thick Derived.Type, @thick Derived.Type.Type) -> () to $Builtin.RawPointer
// CHECK-NEXT: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]] : $Builtin.RawPointer
// CHECK-NEXT: [[RESULT:%.*]] = tuple ([[ADDR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
// CHECK-NEXT: dealloc_stack [[OUT]] : $*@callee_guaranteed () -> Int
@@ -263,7 +264,7 @@
// CHECK: [[T1:%.*]] = apply [[T0]]([[SELF]])
// CHECK: store [[T1]] to [trivial] [[T2]] : $*Int
// CHECK: [[BUFFER:%.*]] = address_to_pointer [[T2]]
-// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S17materializeForSet06HasDidC0C6storedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasDidSet, @thick HasDidSet.Type) -> ()
+// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S17materializeForSet06HasDidC0C6storedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed HasDidSet, @thick HasDidSet.Type) -> ()
// CHECK: [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]]
// CHECK: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]]
// CHECK: [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
@@ -282,7 +283,7 @@
// CHECK: [[T1:%.*]] = apply [[T0]]([[SELF]])
// CHECK: store [[T1]] to [trivial] [[T2]] : $*Int
// CHECK: [[BUFFER:%.*]] = address_to_pointer [[T2]]
-// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S17materializeForSet06HasDidC0C8computedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasDidSet, @thick HasDidSet.Type) -> ()
+// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S17materializeForSet06HasDidC0C8computedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed HasDidSet, @thick HasDidSet.Type) -> ()
// CHECK: [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]]
// CHECK: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]]
// CHECK: [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
@@ -295,7 +296,7 @@
didSet {}
}
-// CHECK-LABEL: sil private [transparent] @$S17materializeForSet012HasStoredDidC0C6storedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasStoredDidSet, @thick HasStoredDidSet.Type) -> () {
+// CHECK-LABEL: sil private [transparent] @$S17materializeForSet012HasStoredDidC0C6storedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed HasStoredDidSet, @thick HasStoredDidSet.Type) -> () {
// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $*HasStoredDidSet, [[METATYPE:%.*]] : $@thick HasStoredDidSet.Type):
// CHECK: [[SELF_VALUE:%.*]] = load_borrow [[SELF]] : $*HasStoredDidSet
// CHECK: [[BUFFER_ADDR:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
@@ -312,7 +313,7 @@
// CHECK: [[T1:%.*]] = apply [[T0]]([[SELF]])
// CHECK: store [[T1]] to [trivial] [[T2]] : $*Int
// CHECK: [[BUFFER:%.*]] = address_to_pointer [[T2]]
-// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S17materializeForSet012HasStoredDidC0C6storedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasStoredDidSet, @thick HasStoredDidSet.Type) -> ()
+// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S17materializeForSet012HasStoredDidC0C6storedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed HasStoredDidSet, @thick HasStoredDidSet.Type) -> ()
// CHECK: [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]]
// CHECK: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]]
// CHECK: [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
@@ -332,7 +333,7 @@
// CHECK: end_access [[READ]] : $*@sil_weak Optional<HasWeak>
// CHECK: store [[T1]] to [init] [[T2]] : $*Optional<HasWeak>
// CHECK: [[BUFFER:%.*]] = address_to_pointer [[T2]]
-// CHECK: [[T0:%.*]] = function_ref @$S17materializeForSet7HasWeakC7weakvarACSgXwvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasWeak, @thick HasWeak.Type) -> ()
+// CHECK: [[T0:%.*]] = function_ref @$S17materializeForSet7HasWeakC7weakvarACSgXwvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed HasWeak, @thick HasWeak.Type) -> ()
// CHECK: [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, {{.*}} : $Optional<Builtin.RawPointer>)
// CHECK: return [[T4]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
// CHECK: }
@@ -344,7 +345,7 @@
// UNCHECKED: [[T1:%.*]] = load_weak [[T0]] : $*@sil_weak Optional<HasWeak>
// UNCHECKED: store [[T1]] to [init] [[T2]] : $*Optional<HasWeak>
// UNCHECKED: [[BUFFER:%.*]] = address_to_pointer [[T2]]
-// UNCHECKED: [[T0:%.*]] = function_ref @$S17materializeForSet7HasWeakC7weakvarACSgXwvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasWeak, @thick HasWeak.Type) -> ()
+// UNCHECKED: [[T0:%.*]] = function_ref @$S17materializeForSet7HasWeakC7weakvarACSgXwvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed HasWeak, @thick HasWeak.Type) -> ()
// UNCHECKED: [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, {{.*}} : $Optional<Builtin.RawPointer>)
// UNCHECKED: return [[T4]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
// UNCHECKED: }
@@ -660,6 +661,25 @@
f.computed = f.computed
}
+// Odd corner case -- mutating getter, non-mutating setter
+protocol BackwardMutationProtocol {
+ var value: Int {
+ mutating get
+ nonmutating set
+ }
+}
+
+struct BackwardMutation : BackwardMutationProtocol {
+ var value: Int {
+ mutating get { return 0 }
+ nonmutating set { }
+ }
+}
+
+func doBackwardMutation(m: inout BackwardMutationProtocol) {
+ m.value += 1
+}
+
// CHECK-LABEL: sil_vtable DerivedForOverride {
// CHECK: #BaseForOverride.valueStored!getter.1: (BaseForOverride) -> () -> Int : @$S17materializeForSet07DerivedB8OverrideC11valueStoredSivg
// CHECK: #BaseForOverride.valueStored!setter.1: (BaseForOverride) -> (Int) -> () : @$S17materializeForSet07DerivedB8OverrideC11valueStoredSivs
diff --git a/test/SILGen/metatype_abstraction.swift b/test/SILGen/metatype_abstraction.swift
index 7b701ec..1ee4e9d 100644
--- a/test/SILGen/metatype_abstraction.swift
+++ b/test/SILGen/metatype_abstraction.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -module-name Swift -parse-stdlib %s | %FileCheck %s
enum Optional<Wrapped> {
diff --git a/test/SILGen/multi_file.swift b/test/SILGen/multi_file.swift
index 9109af1..9be3c89 100644
--- a/test/SILGen/multi_file.swift
+++ b/test/SILGen/multi_file.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -primary-file %s %S/Inputs/multi_file_helper.swift | %FileCheck %s
func markUsed<T>(_ t: T) {}
diff --git a/test/SILGen/nested_generics.swift b/test/SILGen/nested_generics.swift
index d3f1460..b639d7d 100644
--- a/test/SILGen/nested_generics.swift
+++ b/test/SILGen/nested_generics.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -Xllvm -sil-full-demangle -emit-silgen -parse-as-library %s | %FileCheck %s
// RUN: %target-swift-frontend -enable-sil-ownership -Xllvm -sil-full-demangle -emit-sil -parse-as-library %s > /dev/null
// RUN: %target-swift-frontend -enable-sil-ownership -Xllvm -sil-full-demangle -emit-sil -O -parse-as-library %s > /dev/null
diff --git a/test/SILGen/nested_types_referencing_nested_functions.swift b/test/SILGen/nested_types_referencing_nested_functions.swift
index db22276..d6a8d6d 100644
--- a/test/SILGen/nested_types_referencing_nested_functions.swift
+++ b/test/SILGen/nested_types_referencing_nested_functions.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
do {
diff --git a/test/SILGen/newtype.swift b/test/SILGen/newtype.swift
index 7b80715..1f7b6f2 100644
--- a/test/SILGen/newtype.swift
+++ b/test/SILGen/newtype.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -sdk %S/Inputs -I %S/Inputs -enable-source-import %s | %FileCheck %s -check-prefix=CHECK-RAW
// RUN: %target-swift-frontend -emit-sil -sdk %S/Inputs -I %S/Inputs -enable-source-import %s | %FileCheck %s -check-prefix=CHECK-CANONICAL
diff --git a/test/SILGen/noescape_reabstraction.swift b/test/SILGen/noescape_reabstraction.swift
index 1958efd..4bfeb40 100644
--- a/test/SILGen/noescape_reabstraction.swift
+++ b/test/SILGen/noescape_reabstraction.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
struct S {}
diff --git a/test/SILGen/objc_attr_NSManaged.swift b/test/SILGen/objc_attr_NSManaged.swift
index 8cb5e51..0a60635 100644
--- a/test/SILGen/objc_attr_NSManaged.swift
+++ b/test/SILGen/objc_attr_NSManaged.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -sdk %S/Inputs %s -I %S/Inputs -enable-source-import -emit-silgen -enable-sil-ownership | %FileCheck %s
// REQUIRES: objc_interop
@@ -104,7 +105,7 @@
@NSManaged final var entityID: String
}
-// CHECK-LABEL: sil private @$S19objc_attr_NSManaged11FinalEntityC8entityIDSSvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout FinalEntity, @thick FinalEntity.Type) -> ()
+// CHECK-LABEL: sil private @$S19objc_attr_NSManaged11FinalEntityC8entityIDSSvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed FinalEntity, @thick FinalEntity.Type) -> ()
// CHECK: objc_method {{.*}} : $FinalEntity, #FinalEntity.entityID!setter.1.foreign
// CHECK: return
diff --git a/test/SILGen/objc_attr_NSManaged_multi.swift b/test/SILGen/objc_attr_NSManaged_multi.swift
index 5cce85e..9b4f085 100644
--- a/test/SILGen/objc_attr_NSManaged_multi.swift
+++ b/test/SILGen/objc_attr_NSManaged_multi.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -sdk %S/Inputs -primary-file %s %S/objc_attr_NSManaged.swift -I %S/Inputs -enable-source-import -emit-silgen -enable-sil-ownership | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILGen/objc_blocks_bridging.swift b/test/SILGen/objc_blocks_bridging.swift
index 50cc6e6..8984176 100644
--- a/test/SILGen/objc_blocks_bridging.swift
+++ b/test/SILGen/objc_blocks_bridging.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %build-silgen-test-overlays
// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -verify -emit-silgen -I %S/Inputs -disable-objc-attr-requires-foundation-module -enable-sil-ownership %s | %FileCheck %s
diff --git a/test/SILGen/objc_bridged_results.swift b/test/SILGen/objc_bridged_results.swift
index a0aaa6b..94c6cbb 100644
--- a/test/SILGen/objc_bridged_results.swift
+++ b/test/SILGen/objc_bridged_results.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %build-silgen-test-overlays
diff --git a/test/SILGen/objc_bridging.swift b/test/SILGen/objc_bridging.swift
index 613a091..28b2ed6 100644
--- a/test/SILGen/objc_bridging.swift
+++ b/test/SILGen/objc_bridging.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %build-silgen-test-overlays
// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -emit-module -o %t -I %S/../Inputs/ObjCBridging %S/../Inputs/ObjCBridging/Appliances.swift
diff --git a/test/SILGen/objc_bridging_any.swift b/test/SILGen/objc_bridging_any.swift
index aa23de2..3ca525e 100644
--- a/test/SILGen/objc_bridging_any.swift
+++ b/test/SILGen/objc_bridging_any.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -Xllvm -sil-print-debuginfo -emit-silgen -enable-sil-ownership %s | %FileCheck %s
// REQUIRES: objc_interop
@@ -757,4 +758,5 @@
// CHECK-LABEL: sil_witness_table shared [serialized] GenericOption: Hashable module objc_generics {
// CHECK-NEXT: base_protocol Equatable: GenericOption: Equatable module objc_generics
// CHECK-NEXT: method #Hashable.hashValue!getter.1: {{.*}} : @$SSo13GenericOptionas8HashableSCsACP9hashValueSivgTW
+// CHECK-NEXT: method #Hashable._hash!1: {{.*}} : @$SSo13GenericOptionas8HashableSCsACP5_hash4intoys7_HasherVz_tFTW
// CHECK-NEXT: }
diff --git a/test/SILGen/objc_bridging_peephole.swift b/test/SILGen/objc_bridging_peephole.swift
index 317aba5..09954bb 100644
--- a/test/SILGen/objc_bridging_peephole.swift
+++ b/test/SILGen/objc_bridging_peephole.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-silgen -enable-sil-ownership %s | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILGen/objc_currying.swift b/test/SILGen/objc_currying.swift
index a22f54e..036ca8c 100644
--- a/test/SILGen/objc_currying.swift
+++ b/test/SILGen/objc_currying.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %build-silgen-test-overlays
// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -enable-sil-ownership -emit-silgen %s | %FileCheck %s
diff --git a/test/SILGen/objc_dictionary_bridging.swift b/test/SILGen/objc_dictionary_bridging.swift
index 421fc90..74dd95e 100644
--- a/test/SILGen/objc_dictionary_bridging.swift
+++ b/test/SILGen/objc_dictionary_bridging.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %build-silgen-test-overlays
diff --git a/test/SILGen/objc_error.swift b/test/SILGen/objc_error.swift
index 1a40901..b9ee4d3 100644
--- a/test/SILGen/objc_error.swift
+++ b/test/SILGen/objc_error.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %build-clang-importer-objc-overlays
diff --git a/test/SILGen/objc_extensions.swift b/test/SILGen/objc_extensions.swift
index b3f34bf..639b8aa 100644
--- a/test/SILGen/objc_extensions.swift
+++ b/test/SILGen/objc_extensions.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -emit-silgen -sdk %S/Inputs/ -I %S/Inputs -enable-source-import %s | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILGen/objc_imported_generic.swift b/test/SILGen/objc_imported_generic.swift
index 165e8dd..586aea6 100644
--- a/test/SILGen/objc_imported_generic.swift
+++ b/test/SILGen/objc_imported_generic.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-silgen %s -enable-sil-ownership | %FileCheck %s
// For integration testing, ensure we get through IRGen too.
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-ir -verify -DIRGEN_INTEGRATION_TEST %s
diff --git a/test/SILGen/objc_ownership_conventions.swift b/test/SILGen/objc_ownership_conventions.swift
index adc562a..ec991b6 100644
--- a/test/SILGen/objc_ownership_conventions.swift
+++ b/test/SILGen/objc_ownership_conventions.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -sdk %S/Inputs -I %S/Inputs -enable-source-import %s -emit-silgen -enable-sil-ownership | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILGen/objc_protocol_native_thunk.swift b/test/SILGen/objc_protocol_native_thunk.swift
index f5540bd..bde4e32 100644
--- a/test/SILGen/objc_protocol_native_thunk.swift
+++ b/test/SILGen/objc_protocol_native_thunk.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-silgen -enable-sil-ownership %s | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILGen/objc_protocols.swift b/test/SILGen/objc_protocols.swift
index 2b91662..15a0ed2 100644
--- a/test/SILGen/objc_protocols.swift
+++ b/test/SILGen/objc_protocols.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -sdk %S/Inputs -I %S/Inputs -enable-source-import %s -emit-silgen -disable-objc-attr-requires-foundation-module -enable-sil-ownership | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILGen/objc_set_bridging.swift b/test/SILGen/objc_set_bridging.swift
index 617d9e8..5e79cfd 100644
--- a/test/SILGen/objc_set_bridging.swift
+++ b/test/SILGen/objc_set_bridging.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %build-silgen-test-overlays
diff --git a/test/SILGen/objc_thunks.swift b/test/SILGen/objc_thunks.swift
index c0adf9d..f6f8d3f 100644
--- a/test/SILGen/objc_thunks.swift
+++ b/test/SILGen/objc_thunks.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -Xllvm -sil-print-debuginfo -sdk %S/Inputs -I %S/Inputs -enable-source-import %s -emit-silgen -emit-verbose-sil -enable-sil-ownership | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILGen/objc_witnesses.swift b/test/SILGen/objc_witnesses.swift
index 9d754fc..333edae 100644
--- a/test/SILGen/objc_witnesses.swift
+++ b/test/SILGen/objc_witnesses.swift
@@ -100,7 +100,7 @@
var valence: Int { get { return 1 } set { } }
}
-// CHECK-LABEL: sil private @$SSo8NSObjectC14objc_witnessesE7valenceSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout NSObject, @thick NSObject.Type) -> () {
+// CHECK-LABEL: sil private @$SSo8NSObjectC14objc_witnessesE7valenceSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed NSObject, @thick NSObject.Type) -> () {
// CHECK: objc_method %4 : $NSObject, #NSObject.valence!setter.1.foreign
// CHECK: }
diff --git a/test/SILGen/opaque_ownership.swift b/test/SILGen/opaque_ownership.swift
index d56c998..5fa51ce 100644
--- a/test/SILGen/opaque_ownership.swift
+++ b/test/SILGen/opaque_ownership.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-opaque-values -enable-sil-ownership -emit-sorted-sil -Xllvm -sil-full-demangle -emit-silgen -parse-stdlib -parse-as-library -module-name Swift %s | %FileCheck %s
// RUN: %target-swift-frontend -target x86_64-apple-macosx10.9 -enable-sil-opaque-values -enable-sil-ownership -emit-sorted-sil -Xllvm -sil-full-demangle -emit-silgen -parse-stdlib -parse-as-library -module-name Swift %s | %FileCheck --check-prefix=CHECK-OSX %s
@@ -170,7 +171,7 @@
case minus
}
-#if os(OSX)
+#if os(macOS)
// Test open_existential_value used in a conversion context.
// (the actual bridging call is dropped because we don't import Swift).
// ---
@@ -195,7 +196,7 @@
public protocol Error {}
-#if os(OSX)
+#if os(macOS)
// Test open_existential_box_value in a conversion context.
// ---
// CHECK-OSX-LABEL: sil @$Ss3foo1eys5Error_pSg_tF : $@convention(thin) (@owned Optional<Error>) -> () {
diff --git a/test/SILGen/opaque_values_silgen.swift b/test/SILGen/opaque_values_silgen.swift
index 1154d02..6c9931b 100644
--- a/test/SILGen/opaque_values_silgen.swift
+++ b/test/SILGen/opaque_values_silgen.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-opaque-values -emit-sorted-sil -Xllvm -sil-full-demangle -emit-silgen %s | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-runtime
// UNSUPPORTED: resilient_stdlib
diff --git a/test/SILGen/opaque_values_silgen_lib.swift b/test/SILGen/opaque_values_silgen_lib.swift
index c7064d7..3d69099 100644
--- a/test/SILGen/opaque_values_silgen_lib.swift
+++ b/test/SILGen/opaque_values_silgen_lib.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -enable-sil-opaque-values -emit-sorted-sil -Xllvm -sil-full-demangle -parse-stdlib -parse-as-library -emit-silgen -module-name Swift %s | %FileCheck %s
// UNSUPPORTED: resilient_stdlib
diff --git a/test/SILGen/optional-cast.swift b/test/SILGen/optional-cast.swift
index e5501cb..6a1c2f7 100644
--- a/test/SILGen/optional-cast.swift
+++ b/test/SILGen/optional-cast.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
class A {}
diff --git a/test/SILGen/optional.swift b/test/SILGen/optional.swift
index 68b6c8a..3cc67b5 100644
--- a/test/SILGen/optional.swift
+++ b/test/SILGen/optional.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
func testCall(_ f: (() -> ())?) {
diff --git a/test/SILGen/optional_lvalue.swift b/test/SILGen/optional_lvalue.swift
index a735e2c..153200f 100644
--- a/test/SILGen/optional_lvalue.swift
+++ b/test/SILGen/optional_lvalue.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
// CHECK-LABEL: sil hidden @$S15optional_lvalue07assign_a1_B0yySiSgz_SitF
diff --git a/test/SILGen/partial_apply_generic.swift b/test/SILGen/partial_apply_generic.swift
index 9b1e736..94c032c 100644
--- a/test/SILGen/partial_apply_generic.swift
+++ b/test/SILGen/partial_apply_generic.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
protocol Panda {
diff --git a/test/SILGen/partial_apply_protocol.swift b/test/SILGen/partial_apply_protocol.swift
index 902ce27..60e3e0d 100644
--- a/test/SILGen/partial_apply_protocol.swift
+++ b/test/SILGen/partial_apply_protocol.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -emit-silgen -primary-file %s | %FileCheck %s
// RUN: %target-swift-frontend -enable-sil-ownership -emit-ir -primary-file %s
diff --git a/test/SILGen/partial_apply_protocol_class_refinement_method.swift b/test/SILGen/partial_apply_protocol_class_refinement_method.swift
index f69af05..ca2450c 100644
--- a/test/SILGen/partial_apply_protocol_class_refinement_method.swift
+++ b/test/SILGen/partial_apply_protocol_class_refinement_method.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
protocol P { func foo() }
diff --git a/test/SILGen/partial_apply_super.swift b/test/SILGen/partial_apply_super.swift
index ae315df..685ee8c 100644
--- a/test/SILGen/partial_apply_super.swift
+++ b/test/SILGen/partial_apply_super.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -I %t -emit-module -emit-module-path=%t/resilient_struct.swiftmodule -module-name resilient_struct %S/../Inputs/resilient_struct.swift
// RUN: %target-swift-frontend -I %t -emit-module -emit-module-path=%t/resilient_class.swiftmodule -module-name resilient_class %S/../Inputs/resilient_class.swift
diff --git a/test/SILGen/pgo_checked_cast.swift b/test/SILGen/pgo_checked_cast.swift
index f8ae4f9..41db5fd 100644
--- a/test/SILGen/pgo_checked_cast.swift
+++ b/test/SILGen/pgo_checked_cast.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-build-swift %s -profile-generate -Xfrontend -disable-incremental-llvm-codegen -module-name pgo_checked_cast -o %t/main
// RUN: env LLVM_PROFILE_FILE=%t/default.profraw %target-run %t/main
diff --git a/test/SILGen/pgo_switchenum.swift b/test/SILGen/pgo_switchenum.swift
index 6b9d940..9978fa6 100644
--- a/test/SILGen/pgo_switchenum.swift
+++ b/test/SILGen/pgo_switchenum.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-build-swift %s -profile-generate -Xfrontend -disable-incremental-llvm-codegen -module-name pgo_switchenum -o %t/main
// RUN: env LLVM_PROFILE_FILE=%t/default.profraw %target-run %t/main
diff --git a/test/SILGen/plus_zero_access_marker_gen.swift b/test/SILGen/plus_zero_access_marker_gen.swift
new file mode 100644
index 0000000..6781648
--- /dev/null
+++ b/test/SILGen/plus_zero_access_marker_gen.swift
@@ -0,0 +1,139 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -parse-as-library -Xllvm -sil-full-demangle -enforce-exclusivity=checked -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+func modify<T>(_ x: inout T) {}
+
+public struct S {
+ var i: Int
+ var o: AnyObject?
+}
+
+// CHECK-LABEL: sil hidden [noinline] @$S17access_marker_gen5initSyAA1SVyXlSgF : $@convention(thin) (@guaranteed Optional<AnyObject>) -> @owned S {
+// CHECK: bb0(%0 : @guaranteed $Optional<AnyObject>):
+// CHECK: [[BOX:%.*]] = alloc_box ${ var S }, var, name "s"
+// CHECK: [[MARKED_BOX:%.*]] = mark_uninitialized [var] [[BOX]] : ${ var S }
+// CHECK: [[ADDR:%.*]] = project_box [[MARKED_BOX]] : ${ var S }, 0
+// CHECK: cond_br %{{.*}}, bb1, bb2
+// CHECK: bb1:
+// CHECK: [[ACCESS1:%.*]] = begin_access [modify] [unknown] [[ADDR]] : $*S
+// CHECK: assign %{{.*}} to [[ACCESS1]] : $*S
+// CHECK: end_access [[ACCESS1]] : $*S
+// CHECK: bb2:
+// CHECK: [[ACCESS2:%.*]] = begin_access [modify] [unknown] [[ADDR]] : $*S
+// CHECK: assign %{{.*}} to [[ACCESS2]] : $*S
+// CHECK: end_access [[ACCESS2]] : $*S
+// CHECK: bb3:
+// CHECK: [[ACCESS3:%.*]] = begin_access [read] [unknown] [[ADDR]] : $*S
+// CHECK: [[RET:%.*]] = load [copy] [[ACCESS3]] : $*S
+// CHECK: end_access [[ACCESS3]] : $*S
+// CHECK: return [[RET]] : $S
+// CHECK-LABEL: } // end sil function '$S17access_marker_gen5initSyAA1SVyXlSgF'
+@inline(never)
+func initS(_ o: AnyObject?) -> S {
+ var s: S
+ if o == nil {
+ s = S(i: 0, o: nil)
+ } else {
+ s = S(i: 1, o: o)
+ }
+ return s
+}
+
+@inline(never)
+func takeS(_ s: S) {}
+
+// CHECK-LABEL: sil @$S17access_marker_gen14modifyAndReadSyyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK: %[[BOX:.*]] = alloc_box ${ var S }, var, name "s"
+// CHECK: %[[ADDRS:.*]] = project_box %[[BOX]] : ${ var S }, 0
+// CHECK: %[[ACCESS1:.*]] = begin_access [modify] [unknown] %[[ADDRS]] : $*S
+// CHECK: %[[ADDRI:.*]] = struct_element_addr %[[ACCESS1]] : $*S, #S.i
+// CHECK: assign %{{.*}} to %[[ADDRI]] : $*Int
+// CHECK: end_access %[[ACCESS1]] : $*S
+// CHECK: %[[ACCESS2:.*]] = begin_access [read] [unknown] %[[ADDRS]] : $*S
+// CHECK: %{{.*}} = load [copy] %[[ACCESS2]] : $*S
+// CHECK: end_access %[[ACCESS2]] : $*S
+// CHECK-LABEL: } // end sil function '$S17access_marker_gen14modifyAndReadSyyF'
+public func modifyAndReadS() {
+ var s = initS(nil)
+ s.i = 42
+ takeS(s)
+}
+
+var global = S(i: 0, o: nil)
+
+func readGlobal() -> AnyObject? {
+ return global.o
+}
+
+// CHECK-LABEL: sil hidden @$S17access_marker_gen10readGlobalyXlSgyF
+// CHECK: [[ADDRESSOR:%.*]] = function_ref @$S17access_marker_gen6globalAA1SVvau :
+// CHECK-NEXT: [[T0:%.*]] = apply [[ADDRESSOR]]()
+// CHECK-NEXT: [[T1:%.*]] = pointer_to_address [[T0]] : $Builtin.RawPointer to [strict] $*S
+// CHECK-NEXT: [[T2:%.*]] = begin_access [read] [dynamic] [[T1]]
+// CHECK-NEXT: [[T3:%.*]] = struct_element_addr [[T2]] : $*S, #S.o
+// CHECK-NEXT: [[T4:%.*]] = load [copy] [[T3]]
+// CHECK-NEXT: end_access [[T2]]
+// CHECK-NEXT: return [[T4]]
+
+
+public struct HasTwoStoredProperties {
+ var f: Int = 7
+ var g: Int = 9
+
+// CHECK-LABEL: sil hidden @$S17access_marker_gen22HasTwoStoredPropertiesV027noOverlapOnAssignFromPropToM0yyF : $@convention(method) (@inout HasTwoStoredProperties) -> ()
+// CHECK: [[ACCESS1:%.*]] = begin_access [read] [unknown] [[SELF_ADDR:%.*]] : $*HasTwoStoredProperties
+// CHECK-NEXT: [[G_ADDR:%.*]] = struct_element_addr [[ACCESS1]] : $*HasTwoStoredProperties, #HasTwoStoredProperties.g
+// CHECK-NEXT: [[G_VAL:%.*]] = load [trivial] [[G_ADDR]] : $*Int
+// CHECK-NEXT: end_access [[ACCESS1]] : $*HasTwoStoredProperties
+// CHECK-NEXT: [[ACCESS2:%.*]] = begin_access [modify] [unknown] [[SELF_ADDR]] : $*HasTwoStoredProperties
+// CHECK-NEXT: [[F_ADDR:%.*]] = struct_element_addr [[ACCESS2]] : $*HasTwoStoredProperties, #HasTwoStoredProperties.f
+// CHECK-NEXT: assign [[G_VAL]] to [[F_ADDR]] : $*Int
+// CHECK-NEXT: end_access [[ACCESS2]] : $*HasTwoStoredProperties
+ mutating func noOverlapOnAssignFromPropToProp() {
+ f = g
+ }
+}
+
+class C {
+ final var x: Int = 0
+}
+
+func testClassInstanceProperties(c: C) {
+ let y = c.x
+ c.x = y
+}
+// CHECK-LABEL: sil hidden @$S17access_marker_gen27testClassInstanceProperties1cyAA1CC_tF :
+// CHECK: bb0([[C:%.*]] : @guaranteed $C
+// CHECK-NEXT: debug_value
+// CHECK-NEXT: [[CX:%.*]] = ref_element_addr [[C]] : $C, #C.x
+// CHECK-NEXT: [[ACCESS:%.*]] = begin_access [read] [dynamic] [[CX]] : $*Int
+// CHECK-NEXT: [[Y:%.*]] = load [trivial] [[ACCESS]]
+// CHECK-NEXT: end_access [[ACCESS]]
+// CHECK-NEXT: debug_value
+// CHECK-NEXT: [[CX:%.*]] = ref_element_addr [[C]] : $C, #C.x
+// CHECK-NEXT: [[ACCESS:%.*]] = begin_access [modify] [dynamic] [[CX]] : $*Int
+// CHECK-NEXT: assign [[Y]] to [[ACCESS]]
+// CHECK-NEXT: end_access [[ACCESS]]
+
+class D {
+ var x: Int = 0
+}
+// materializeForSet callback
+// CHECK-LABEL: sil private [transparent] @$S17access_marker_gen1DC1xSivmytfU_
+// CHECK: end_unpaired_access [dynamic] %1 : $*Builtin.UnsafeValueBuffer
+
+// materializeForSet
+// CHECK-LABEL: sil hidden [transparent] @$S17access_marker_gen1DC1xSivm
+// CHECK: [[T0:%.*]] = ref_element_addr %2 : $D, #D.x
+// CHECK-NEXT: begin_unpaired_access [modify] [dynamic] [[T0]] : $*Int
+
+func testDispatchedClassInstanceProperty(d: D) {
+ modify(&d.x)
+}
+// CHECK-LABEL: sil hidden @$S17access_marker_gen35testDispatchedClassInstanceProperty1dyAA1DC_tF
+// CHECK: bb0([[D:%.*]] : @guaranteed $D
+// CHECK: [[METHOD:%.*]] = class_method [[D]] : $D, #D.x!materializeForSet.1
+// CHECK: apply [[METHOD]]({{.*}}, [[D]])
+// CHECK-NOT: begin_access
+
diff --git a/test/SILGen/plus_zero_accessors.swift b/test/SILGen/plus_zero_accessors.swift
new file mode 100644
index 0000000..47ebf94
--- /dev/null
+++ b/test/SILGen/plus_zero_accessors.swift
@@ -0,0 +1,235 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+// Hold a reference to do to magically become non-POD.
+class Reference {}
+
+// A struct with a non-mutating getter and a mutating setter.
+struct OrdinarySub {
+ var ptr = Reference()
+ subscript(value: Int) -> Int {
+ get { return value }
+ set {}
+ }
+}
+
+class A { var array = OrdinarySub() }
+
+func index0() -> Int { return 0 }
+func index1() -> Int { return 1 }
+
+func someValidPointer<T>() -> UnsafePointer<T> { fatalError() }
+func someValidPointer<T>() -> UnsafeMutablePointer<T> { fatalError() }
+
+// Verify that there is no unnecessary extra copy_value of ref.array.
+// rdar://19002913
+func test0(_ ref: A) {
+ ref.array[index0()] = ref.array[index1()]
+}
+// CHECK: sil hidden @$S9accessors5test0yyAA1ACF : $@convention(thin) (@guaranteed A) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $A):
+// CHECK-NEXT: debug_value
+// Formal evaluation of LHS.
+// CHECK-NEXT: // function_ref accessors.index0() -> Swift.Int
+// CHECK-NEXT: [[T0:%.*]] = function_ref @$S9accessors6index0SiyF
+// CHECK-NEXT: [[INDEX0:%.*]] = apply [[T0]]()
+// Formal evaluation of RHS.
+// CHECK-NEXT: // function_ref accessors.index1() -> Swift.Int
+// CHECK-NEXT: [[T0:%.*]] = function_ref @$S9accessors6index1SiyF
+// CHECK-NEXT: [[INDEX1:%.*]] = apply [[T0]]()
+// Formal access to RHS.
+// CHECK-NEXT: [[TEMP:%.*]] = alloc_stack $OrdinarySub
+// CHECK-NEXT: [[T0:%.*]] = class_method [[ARG]] : $A, #A.array!getter.1
+// CHECK-NEXT: [[T1:%.*]] = apply [[T0]]([[ARG]])
+// CHECK-NEXT: store [[T1]] to [init] [[TEMP]]
+// CHECK-NEXT: [[T0:%.*]] = load_borrow [[TEMP]]
+// CHECK-NEXT: // function_ref accessors.OrdinarySub.subscript.getter : (Swift.Int) -> Swift.Int
+// CHECK-NEXT: [[T1:%.*]] = function_ref @$S9accessors11OrdinarySubVyS2icig
+// CHECK-NEXT: [[VALUE:%.*]] = apply [[T1]]([[INDEX1]], [[T0]])
+// CHECK-NEXT: end_borrow [[T0]] from [[TEMP]]
+// CHECK-NEXT: destroy_addr [[TEMP]]
+// Formal access to LHS.
+// CHECK-NEXT: [[STORAGE:%.*]] = alloc_stack $Builtin.UnsafeValueBuffer
+// CHECK-NEXT: [[BUFFER:%.*]] = alloc_stack $OrdinarySub
+// CHECK-NEXT: [[T0:%.*]] = address_to_pointer [[BUFFER]]
+// CHECK-NEXT: [[T1:%.*]] = class_method [[ARG]] : $A, #A.array!materializeForSet.1
+// CHECK-NEXT: [[T2:%.*]] = apply [[T1]]([[T0]], [[STORAGE]], [[ARG]])
+// CHECK-NEXT: [[T3:%.*]] = tuple_extract [[T2]] {{.*}}, 0
+// CHECK-NEXT: [[OPT_CALLBACK:%.*]] = tuple_extract [[T2]] {{.*}}, 1
+// CHECK-NEXT: [[T4:%.*]] = pointer_to_address [[T3]]
+// CHECK-NEXT: [[ADDR:%.*]] = mark_dependence [[T4]] : $*OrdinarySub on [[ARG]] : $A
+// CHECK-NEXT: // function_ref accessors.OrdinarySub.subscript.setter : (Swift.Int) -> Swift.Int
+// CHECK-NEXT: [[SETTER:%.*]] = function_ref @$S9accessors11OrdinarySubVyS2icis
+// CHECK-NEXT: apply [[SETTER]]([[VALUE]], [[INDEX0]], [[ADDR]])
+// CHECK-NEXT: switch_enum [[OPT_CALLBACK]] : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: [[WRITEBACK:bb[0-9]+]], case #Optional.none!enumelt: [[CONT:bb[0-9]+]]
+
+// CHECK: [[WRITEBACK]]([[CALLBACK_ADDR:%.*]] : @trivial $Builtin.RawPointer):
+// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout A, @thick A.Type) -> ()
+// CHECK-NEXT: [[TEMP2:%.*]] = alloc_stack $A
+// SEMANTIC SIL TODO: This is an issue caused by the callback for materializeForSet in the class case taking the value as @inout when it should really take it as @guaranteed.
+// CHECK-NEXT: store_borrow [[ARG]] to [[TEMP2]] : $*A
+// CHECK-NEXT: [[T0:%.*]] = metatype $@thick A.Type
+// CHECK-NEXT: [[T1:%.*]] = address_to_pointer [[ADDR]] : $*OrdinarySub to $Builtin.RawPointer
+// CHECK-NEXT: apply [[CALLBACK]]([[T1]], [[STORAGE]], [[TEMP2]], [[T0]])
+// CHECK-NEXT: dealloc_stack [[TEMP2]]
+// CHECK-NEXT: br [[CONT]]
+
+// CHECK: [[CONT]]:
+// CHECK-NEXT: dealloc_stack [[BUFFER]]
+// CHECK-NEXT: dealloc_stack [[STORAGE]]
+// CHECK-NEXT: dealloc_stack [[TEMP]]
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: return
+
+// A struct with a mutating getter and a mutating setter.
+struct MutatingSub {
+ var ptr = Reference()
+ subscript(value: Int) -> Int {
+ mutating get { return value }
+ set {}
+ }
+}
+class B { var array = MutatingSub() }
+
+func test1(_ ref: B) {
+ ref.array[index0()] = ref.array[index1()]
+}
+// CHECK-LABEL: sil hidden @$S9accessors5test1yyAA1BCF : $@convention(thin) (@guaranteed B) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $B):
+// CHECK-NEXT: debug_value
+// Formal evaluation of LHS.
+// CHECK-NEXT: // function_ref accessors.index0() -> Swift.Int
+// CHECK-NEXT: [[T0:%.*]] = function_ref @$S9accessors6index0SiyF
+// CHECK-NEXT: [[INDEX0:%.*]] = apply [[T0]]()
+// Formal evaluation of RHS.
+// CHECK-NEXT: // function_ref accessors.index1() -> Swift.Int
+// CHECK-NEXT: [[T0:%.*]] = function_ref @$S9accessors6index1SiyF
+// CHECK-NEXT: [[INDEX1:%.*]] = apply [[T0]]()
+// Formal access to RHS.
+// CHECK-NEXT: [[STORAGE:%.*]] = alloc_stack $Builtin.UnsafeValueBuffer
+// CHECK-NEXT: [[BUFFER:%.*]] = alloc_stack $MutatingSub
+// CHECK-NEXT: [[T0:%.*]] = address_to_pointer [[BUFFER]]
+// CHECK-NEXT: [[T1:%.*]] = class_method [[ARG]] : $B, #B.array!materializeForSet.1
+// CHECK-NEXT: [[T2:%.*]] = apply [[T1]]([[T0]], [[STORAGE]], [[ARG]])
+// CHECK-NEXT: [[T3:%.*]] = tuple_extract [[T2]] {{.*}}, 0
+// CHECK-NEXT: [[OPT_CALLBACK:%.*]] = tuple_extract [[T2]] {{.*}}, 1
+// CHECK-NEXT: [[T4:%.*]] = pointer_to_address [[T3]]
+// CHECK-NEXT: [[ADDR:%.*]] = mark_dependence [[T4]] : $*MutatingSub on [[ARG]] : $B
+// CHECK-NEXT: // function_ref accessors.MutatingSub.subscript.getter : (Swift.Int) -> Swift.Int
+// CHECK-NEXT: [[T0:%.*]] = function_ref @$S9accessors11MutatingSubVyS2icig : $@convention(method) (Int, @inout MutatingSub) -> Int
+// CHECK-NEXT: [[VALUE:%.*]] = apply [[T0]]([[INDEX1]], [[ADDR]])
+// CHECK-NEXT: switch_enum [[OPT_CALLBACK]] : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: [[WRITEBACK:bb[0-9]+]], case #Optional.none!enumelt: [[CONT:bb[0-9]+]]
+//
+// CHECK: [[WRITEBACK]]([[CALLBACK_ADDR:%.*]] : @trivial $Builtin.RawPointer):
+// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout B, @thick B.Type) -> ()
+// CHECK-NEXT: [[TEMP2:%.*]] = alloc_stack $B
+// CHECK-NEXT: store_borrow [[ARG]] to [[TEMP2]] : $*B
+// CHECK-NEXT: [[T0:%.*]] = metatype $@thick B.Type
+// CHECK-NEXT: [[T1:%.*]] = address_to_pointer [[ADDR]] : $*MutatingSub to $Builtin.RawPointer
+// CHECK-NEXT: apply [[CALLBACK]]([[T1]], [[STORAGE]], [[TEMP2]], [[T0]])
+// CHECK-NEXT: dealloc_stack [[TEMP2]]
+// CHECK-NEXT: br [[CONT]]
+//
+// CHECK: [[CONT]]:
+// Formal access to LHS.
+// CHECK-NEXT: [[STORAGE2:%.*]] = alloc_stack $Builtin.UnsafeValueBuffer
+// CHECK-NEXT: [[BUFFER2:%.*]] = alloc_stack $MutatingSub
+// CHECK-NEXT: [[T0:%.*]] = address_to_pointer [[BUFFER2]]
+// CHECK-NEXT: [[T1:%.*]] = class_method [[ARG]] : $B, #B.array!materializeForSet.1
+// CHECK-NEXT: [[T2:%.*]] = apply [[T1]]([[T0]], [[STORAGE2]], [[ARG]])
+// CHECK-NEXT: [[T3:%.*]] = tuple_extract [[T2]] {{.*}}, 0
+// CHECK-NEXT: [[OPT_CALLBACK:%.*]] = tuple_extract [[T2]] {{.*}}, 1
+// CHECK-NEXT: [[T4:%.*]] = pointer_to_address [[T3]]
+// CHECK-NEXT: [[ADDR:%.*]] = mark_dependence [[T4]] : $*MutatingSub on [[ARG]] : $B
+// CHECK-NEXT: // function_ref accessors.MutatingSub.subscript.setter : (Swift.Int) -> Swift.Int
+// CHECK-NEXT: [[SETTER:%.*]] = function_ref @$S9accessors11MutatingSubVyS2icis : $@convention(method) (Int, Int, @inout MutatingSub) -> ()
+// CHECK-NEXT: apply [[SETTER]]([[VALUE]], [[INDEX0]], [[ADDR]])
+// CHECK-NEXT: switch_enum [[OPT_CALLBACK]] : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: [[WRITEBACK:bb[0-9]+]], case #Optional.none!enumelt: [[CONT:bb[0-9]+]]
+//
+// CHECK: [[WRITEBACK]]([[CALLBACK_ADDR:%.*]] : @trivial $Builtin.RawPointer):
+// CHECK-NEXT: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout B, @thick B.Type) -> ()
+// CHECK-NEXT: [[TEMP2:%.*]] = alloc_stack $B
+// CHECK-NEXT: store_borrow [[ARG]] to [[TEMP2]] : $*B
+// CHECK-NEXT: [[T0:%.*]] = metatype $@thick B.Type
+// CHECK-NEXT: [[T1:%.*]] = address_to_pointer [[ADDR]] : $*MutatingSub to $Builtin.RawPointer
+// CHECK-NEXT: apply [[CALLBACK]]([[T1]], [[STORAGE2]], [[TEMP2]], [[T0]])
+// CHECK-NEXT: dealloc_stack [[TEMP2]]
+// CHECK-NEXT: br [[CONT]]
+//
+// CHECK: [[CONT]]:
+// CHECK-NEXT: dealloc_stack [[BUFFER2]]
+// CHECK-NEXT: dealloc_stack [[STORAGE2]]
+// CHECK-NEXT: dealloc_stack [[BUFFER]]
+// CHECK-NEXT: dealloc_stack [[STORAGE]]
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: return
+
+struct RecInner {
+ subscript(i: Int) -> Int {
+ get { return i }
+ }
+}
+struct RecOuter {
+ var inner : RecInner {
+ unsafeAddress { return someValidPointer() }
+ unsafeMutableAddress { return someValidPointer() }
+ }
+}
+func test_rec(_ outer: inout RecOuter) -> Int {
+ return outer.inner[0]
+}
+// This uses the immutable addressor.
+// CHECK: sil hidden @$S9accessors8test_recySiAA8RecOuterVzF : $@convention(thin) (@inout RecOuter) -> Int {
+// CHECK: function_ref @$S9accessors8RecOuterV5innerAA0B5InnerVvlu : $@convention(method) (RecOuter) -> UnsafePointer<RecInner>
+
+struct Rec2Inner {
+ subscript(i: Int) -> Int {
+ mutating get { return i }
+ }
+}
+struct Rec2Outer {
+ var inner : Rec2Inner {
+ unsafeAddress { return someValidPointer() }
+ unsafeMutableAddress { return someValidPointer() }
+ }
+}
+func test_rec2(_ outer: inout Rec2Outer) -> Int {
+ return outer.inner[0]
+}
+// This uses the mutable addressor.
+// CHECK: sil hidden @$S9accessors9test_rec2ySiAA9Rec2OuterVzF : $@convention(thin) (@inout Rec2Outer) -> Int {
+// CHECK: function_ref @$S9accessors9Rec2OuterV5innerAA0B5InnerVvau : $@convention(method) (@inout Rec2Outer) -> UnsafeMutablePointer<Rec2Inner>
+
+struct Foo {
+ private subscript(privateSubscript x: Void) -> Void {
+ // CHECK-DAG: sil private @$S9accessors3FooV16privateSubscriptyyt_tc33_D7F31B09EE737C687DC580B2014D759CLlig : $@convention(method) (Foo) -> () {
+ get {}
+ }
+ private(set) subscript(withPrivateSet x: Void) -> Void {
+ // CHECK-DAG: sil hidden @$S9accessors3FooV14withPrivateSetyyt_tcig : $@convention(method) (Foo) -> () {
+ get {}
+ // CHECK-DAG: sil private @$S9accessors3FooV14withPrivateSetyyt_tcis : $@convention(method) (@inout Foo) -> () {
+ set {}
+ }
+ subscript(withNestedClass x: Void) -> Void {
+ // Check for initializer of NestedClass
+ // CHECK-DAG: sil private @$S9accessors3FooV15withNestedClassyyt_tcig0dE0L_CAFycfc : $@convention(method) (@owned NestedClass) -> @owned NestedClass {
+ class NestedClass {}
+ }
+
+ // CHECK-DAG: sil private @$S9accessors3FooV15privateVariable33_D7F31B09EE737C687DC580B2014D759CLLytvg : $@convention(method) (Foo) -> () {
+ private var privateVariable: Void {
+ return
+ }
+ private(set) var variableWithPrivateSet: Void {
+ // CHECK-DAG: sil hidden @$S9accessors3FooV22variableWithPrivateSetytvg : $@convention(method) (Foo) -> () {
+ get {}
+ // CHECK-DAG: sil private @$S9accessors3FooV22variableWithPrivateSetytvs : $@convention(method) (@inout Foo) -> () {
+ set {}
+ }
+ var propertyWithNestedClass: Void {
+ // Check for initializer of NestedClass
+ // CHECK-DAG: sil private @$S9accessors3FooV23propertyWithNestedClassytvg0eF0L_CAFycfc : $@convention(method) (@owned NestedClass) -> @owned NestedClass {
+ class NestedClass {}
+ }
+}
diff --git a/test/SILGen/plus_zero_address_only_types.swift b/test/SILGen/plus_zero_address_only_types.swift
new file mode 100644
index 0000000..e270074
--- /dev/null
+++ b/test/SILGen/plus_zero_address_only_types.swift
@@ -0,0 +1,229 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -parse-as-library -parse-stdlib -emit-silgen %s | %FileCheck %s
+
+precedencegroup AssignmentPrecedence { assignment: true }
+
+typealias Int = Builtin.Int64
+
+enum Bool { case true_, false_ }
+
+protocol Unloadable {
+ func foo() -> Int
+ var address_only_prop : Unloadable { get }
+ var loadable_prop : Int { get }
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B9_argument{{[_0-9a-zA-Z]*}}F
+func address_only_argument(_ x: Unloadable) {
+ // CHECK: bb0([[XARG:%[0-9]+]] : @trivial $*Unloadable):
+ // CHECK: debug_value_addr [[XARG]]
+ // CHECK-NEXT: tuple
+ // CHECK-NEXT: return
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B17_ignored_argument{{[_0-9a-zA-Z]*}}F
+func address_only_ignored_argument(_: Unloadable) {
+ // CHECK: bb0([[XARG:%[0-9]+]] : @trivial $*Unloadable):
+ // CHECK-NOT: dealloc_stack {{.*}} [[XARG]]
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B7_return{{[_0-9a-zA-Z]*}}F
+func address_only_return(_ x: Unloadable, y: Int) -> Unloadable {
+ // CHECK: bb0([[RET:%[0-9]+]] : @trivial $*Unloadable, [[XARG:%[0-9]+]] : @trivial $*Unloadable, [[YARG:%[0-9]+]] : @trivial $Builtin.Int64):
+ // CHECK-NEXT: debug_value_addr [[XARG]] : $*Unloadable, let, name "x"
+ // CHECK-NEXT: debug_value [[YARG]] : $Builtin.Int64, let, name "y"
+ // CHECK-NEXT: copy_addr [[XARG]] to [initialization] [[RET]]
+ // CHECK-NEXT: [[VOID:%[0-9]+]] = tuple ()
+ // CHECK-NEXT: return [[VOID]]
+ return x
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B15_missing_return{{[_0-9a-zA-Z]*}}F
+func address_only_missing_return() -> Unloadable {
+ // CHECK: unreachable
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B27_conditional_missing_return{{[_0-9a-zA-Z]*}}F
+func address_only_conditional_missing_return(_ x: Unloadable) -> Unloadable {
+ // CHECK: bb0({{%.*}} : @trivial $*Unloadable, {{%.*}} : @trivial $*Unloadable):
+ // CHECK: switch_enum {{%.*}}, case #Bool.true_!enumelt: [[TRUE:bb[0-9]+]], case #Bool.false_!enumelt: [[FALSE:bb[0-9]+]]
+ switch Bool.true_ {
+ case .true_:
+ // CHECK: [[TRUE]]:
+ // CHECK: copy_addr %1 to [initialization] %0 : $*Unloadable
+ // CHECK: return
+ return x
+ case .false_:
+ ()
+ }
+ // CHECK: [[FALSE]]:
+ // CHECK: unreachable
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B29_conditional_missing_return_2
+func address_only_conditional_missing_return_2(_ x: Unloadable) -> Unloadable {
+ // CHECK: bb0({{%.*}} : @trivial $*Unloadable, {{%.*}} : @trivial $*Unloadable):
+ // CHECK: switch_enum {{%.*}}, case #Bool.true_!enumelt: [[TRUE1:bb[0-9]+]], case #Bool.false_!enumelt: [[FALSE1:bb[0-9]+]]
+ switch Bool.true_ {
+ case .true_:
+ return x
+ case .false_:
+ ()
+ }
+ // CHECK: [[FALSE1]]:
+ // CHECK: switch_enum {{%.*}}, case #Bool.true_!enumelt: [[TRUE2:bb[0-9]+]], case #Bool.false_!enumelt: [[FALSE2:bb[0-9]+]]
+ switch Bool.true_ {
+ case .true_:
+ return x
+ case .false_:
+ ()
+ }
+ // CHECK: [[FALSE2]]:
+ // CHECK: unreachable
+
+ // CHECK: bb{{.*}}:
+ // CHECK: return
+}
+
+var crap : Unloadable = some_address_only_function_1()
+func some_address_only_function_1() -> Unloadable { return crap }
+func some_address_only_function_2(_ x: Unloadable) -> () {}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B7_call_1
+func address_only_call_1() -> Unloadable {
+ // CHECK: bb0([[RET:%[0-9]+]] : @trivial $*Unloadable):
+ return some_address_only_function_1()
+ // FIXME emit into
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S18address_only_types05some_a1_B11_function_1AA10Unloadable_pyF
+ // CHECK: apply [[FUNC]]([[RET]])
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B21_call_1_ignore_returnyyF
+func address_only_call_1_ignore_return() {
+ // CHECK: bb0:
+ some_address_only_function_1()
+ // CHECK: [[TEMP:%[0-9]+]] = alloc_stack $Unloadable
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S18address_only_types05some_a1_B11_function_1AA10Unloadable_pyF
+ // CHECK: apply [[FUNC]]([[TEMP]])
+ // CHECK: destroy_addr [[TEMP]]
+ // CHECK: dealloc_stack [[TEMP]]
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B7_call_2{{[_0-9a-zA-Z]*}}F
+func address_only_call_2(_ x: Unloadable) {
+ // CHECK: bb0([[XARG:%[0-9]+]] : @trivial $*Unloadable):
+ // CHECK: debug_value_addr [[XARG]] : $*Unloadable
+ some_address_only_function_2(x)
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S18address_only_types05some_a1_B11_function_2{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[FUNC]]([[XARG]])
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B12_call_1_in_2{{[_0-9a-zA-Z]*}}F
+func address_only_call_1_in_2() {
+ // CHECK: bb0:
+ some_address_only_function_2(some_address_only_function_1())
+ // CHECK: [[TEMP:%[0-9]+]] = alloc_stack $Unloadable
+ // CHECK: [[FUNC1:%[0-9]+]] = function_ref @$S18address_only_types05some_a1_B11_function_1{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[FUNC1]]([[TEMP]])
+ // CHECK: [[FUNC2:%[0-9]+]] = function_ref @$S18address_only_types05some_a1_B11_function_2{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[FUNC2]]([[TEMP]])
+ // CHECK: dealloc_stack [[TEMP]]
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B12_materialize{{[_0-9a-zA-Z]*}}F
+func address_only_materialize() -> Int {
+ // CHECK: bb0:
+ return some_address_only_function_1().foo()
+ // CHECK: [[TEMP:%[0-9]+]] = alloc_stack $Unloadable
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S18address_only_types05some_a1_B11_function_1{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[FUNC]]([[TEMP]])
+ // CHECK: [[TEMP_PROJ:%[0-9]+]] = open_existential_addr immutable_access [[TEMP]] : $*Unloadable to $*[[OPENED:@opened(.*) Unloadable]]
+ // CHECK: [[FOO_METHOD:%[0-9]+]] = witness_method $[[OPENED]], #Unloadable.foo!1
+ // CHECK: [[RET:%[0-9]+]] = apply [[FOO_METHOD]]<[[OPENED]]>([[TEMP_PROJ]])
+ // CHECK: destroy_addr [[TEMP]]
+ // CHECK: dealloc_stack [[TEMP]]
+ // CHECK: return [[RET]]
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B21_assignment_from_temp{{[_0-9a-zA-Z]*}}F
+func address_only_assignment_from_temp(_ dest: inout Unloadable) {
+ // CHECK: bb0([[DEST:%[0-9]+]] : @trivial $*Unloadable):
+ dest = some_address_only_function_1()
+ // CHECK: [[TEMP:%[0-9]+]] = alloc_stack $Unloadable
+ // CHECK: %[[ACCESS:.*]] = begin_access [modify] [unknown] %0 :
+ // CHECK: copy_addr [take] [[TEMP]] to %[[ACCESS]] :
+ // CHECK-NOT: destroy_addr [[TEMP]]
+ // CHECK: dealloc_stack [[TEMP]]
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B19_assignment_from_lv{{[_0-9a-zA-Z]*}}F
+func address_only_assignment_from_lv(_ dest: inout Unloadable, v: Unloadable) {
+ var v = v
+ // CHECK: bb0([[DEST:%[0-9]+]] : @trivial $*Unloadable, [[VARG:%[0-9]+]] : @trivial $*Unloadable):
+ // CHECK: [[VBOX:%.*]] = alloc_box ${ var Unloadable }
+ // CHECK: [[PBOX:%[0-9]+]] = project_box [[VBOX]]
+ // CHECK: copy_addr [[VARG]] to [initialization] [[PBOX]] : $*Unloadable
+ dest = v
+ // CHECK: [[READBOX:%.*]] = begin_access [read] [unknown] [[PBOX]] :
+ // CHECK: [[TEMP:%[0-9]+]] = alloc_stack $Unloadable
+ // CHECK: copy_addr [[READBOX]] to [initialization] [[TEMP]] :
+ // CHECK: [[RET:%.*]] = begin_access [modify] [unknown] %0 :
+ // CHECK: copy_addr [take] [[TEMP]] to [[RET]] :
+ // CHECK: destroy_value [[VBOX]]
+}
+
+var global_prop : Unloadable {
+ get {
+ return crap
+ }
+ set {}
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B33_assignment_from_temp_to_property{{[_0-9a-zA-Z]*}}F
+func address_only_assignment_from_temp_to_property() {
+ // CHECK: bb0:
+ global_prop = some_address_only_function_1()
+ // CHECK: [[TEMP:%[0-9]+]] = alloc_stack $Unloadable
+ // CHECK: [[SETTER:%[0-9]+]] = function_ref @$S18address_only_types11global_propAA10Unloadable_pvs
+ // CHECK: apply [[SETTER]]([[TEMP]])
+ // CHECK: dealloc_stack [[TEMP]]
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B31_assignment_from_lv_to_property{{[_0-9a-zA-Z]*}}F
+func address_only_assignment_from_lv_to_property(_ v: Unloadable) {
+ // CHECK: bb0([[VARG:%[0-9]+]] : @trivial $*Unloadable):
+ // CHECK: debug_value_addr [[VARG]] : $*Unloadable
+ // CHECK: [[TEMP:%[0-9]+]] = alloc_stack $Unloadable
+ // CHECK: copy_addr [[VARG]] to [initialization] [[TEMP]]
+ // CHECK: [[SETTER:%[0-9]+]] = function_ref @$S18address_only_types11global_propAA10Unloadable_pvs
+ // CHECK: apply [[SETTER]]([[TEMP]])
+ // CHECK: dealloc_stack [[TEMP]]
+ global_prop = v
+}
+
+// CHECK-LABEL: sil hidden @$S18address_only_types0a1_B4_varAA10Unloadable_pyF
+func address_only_var() -> Unloadable {
+ // CHECK: bb0([[RET:%[0-9]+]] : @trivial $*Unloadable):
+ var x = some_address_only_function_1()
+ // CHECK: [[XBOX:%[0-9]+]] = alloc_box ${ var Unloadable }
+ // CHECK: [[XPB:%.*]] = project_box [[XBOX]]
+ // CHECK: apply {{%.*}}([[XPB]])
+ return x
+ // CHECK: [[ACCESS:%.*]] = begin_access [read] [unknown] [[XPB]] :
+ // CHECK: copy_addr [[ACCESS]] to [initialization] %0
+ // CHECK: destroy_value [[XBOX]]
+ // CHECK: return
+}
+
+func unloadable_to_unloadable(_ x: Unloadable) -> Unloadable { return x }
+var some_address_only_nontuple_arg_function : (Unloadable) -> Unloadable = unloadable_to_unloadable
+
+// CHECK-LABEL: sil hidden @$S18address_only_types05call_a1_B22_nontuple_arg_function{{[_0-9a-zA-Z]*}}F
+func call_address_only_nontuple_arg_function(_ x: Unloadable) {
+ some_address_only_nontuple_arg_function(x)
+}
diff --git a/test/SILGen/plus_zero_addressors.swift b/test/SILGen/plus_zero_addressors.swift
new file mode 100644
index 0000000..0a02140
--- /dev/null
+++ b/test/SILGen/plus_zero_addressors.swift
@@ -0,0 +1,582 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -emit-sil %s | %FileCheck %s
+// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -emit-silgen %s | %FileCheck %s -check-prefix=SILGEN
+// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -emit-ir %s
+
+// This test includes some calls to transparent stdlib functions.
+// We pattern match for the absence of access markers in the inlined code.
+// REQUIRES: optimized_stdlib
+
+import Swift
+
+func someValidPointer<T>() -> UnsafePointer<T> { fatalError() }
+func someValidPointer<T>() -> UnsafeMutablePointer<T> { fatalError() }
+
+struct A {
+ var base: UnsafeMutablePointer<Int32> = someValidPointer()
+
+ subscript(index: Int32) -> Int32 {
+ unsafeAddress {
+ return UnsafePointer(base)
+ }
+ unsafeMutableAddress {
+ return base
+ }
+ }
+
+ static var staticProp: Int32 {
+ unsafeAddress {
+ // Just don't trip up the verifier.
+ fatalError()
+ }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10addressors1AVys5Int32VAEcilu : $@convention(method) (Int32, A) -> UnsafePointer<Int32>
+// CHECK: bb0([[INDEX:%.*]] : $Int32, [[SELF:%.*]] : $A):
+// CHECK: [[BASE:%.*]] = struct_extract [[SELF]] : $A, #A.base
+// CHECK: [[T0:%.*]] = struct_extract [[BASE]] : $UnsafeMutablePointer<Int32>, #UnsafeMutablePointer._rawValue
+// CHECK: [[T1:%.*]] = struct $UnsafePointer<Int32> ([[T0]] : $Builtin.RawPointer)
+// CHECK: return [[T1]] : $UnsafePointer<Int32>
+
+// CHECK-LABEL: sil hidden @$S10addressors1AVys5Int32VAEciau : $@convention(method) (Int32, @inout A) -> UnsafeMutablePointer<Int32>
+// CHECK: bb0([[INDEX:%.*]] : $Int32, [[SELF:%.*]] : $*A):
+// CHECK: [[READ:%.*]] = begin_access [read] [static] [[SELF]] : $*A
+// CHECK: [[T0:%.*]] = struct_element_addr [[READ]] : $*A, #A.base
+// CHECK: [[BASE:%.*]] = load [[T0]] : $*UnsafeMutablePointer<Int32>
+// CHECK: return [[BASE]] : $UnsafeMutablePointer<Int32>
+
+// CHECK-LABEL: sil hidden @$S10addressors5test0yyF : $@convention(thin) () -> () {
+func test0() {
+// CHECK: [[A:%.*]] = alloc_stack $A
+// CHECK: [[T1:%.*]] = metatype $@thin A.Type
+// CHECK: [[T0:%.*]] = function_ref @$S10addressors1AV{{[_0-9a-zA-Z]*}}fC
+// CHECK: [[AVAL:%.*]] = apply [[T0]]([[T1]])
+// CHECK: store [[AVAL]] to [[A]]
+ var a = A()
+
+// CHECK: [[T0:%.*]] = function_ref @$S10addressors1AVys5Int32VAEcilu :
+// CHECK: [[T1:%.*]] = apply [[T0]]({{%.*}}, [[AVAL]])
+// CHECK: [[T2:%.*]] = struct_extract [[T1]] : $UnsafePointer<Int32>, #UnsafePointer._rawValue
+// CHECK: [[T3:%.*]] = pointer_to_address [[T2]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: [[Z:%.*]] = load [[T3]] : $*Int32
+ let z = a[10]
+
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [static] [[A]] : $*A
+// CHECK: [[T0:%.*]] = function_ref @$S10addressors1AVys5Int32VAEciau :
+// CHECK: [[T1:%.*]] = apply [[T0]]({{%.*}}, [[WRITE]])
+// CHECK: [[T2:%.*]] = struct_extract [[T1]] : $UnsafeMutablePointer<Int32>, #UnsafeMutablePointer._rawValue
+// CHECK: [[T3:%.*]] = pointer_to_address [[T2]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: load
+// CHECK: sadd_with_overflow_Int{{32|64}}
+// CHECK: store {{%.*}} to [[T3]]
+ a[5] += z
+
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [static] [[A]] : $*A
+// CHECK: [[T0:%.*]] = function_ref @$S10addressors1AVys5Int32VAEciau :
+// CHECK: [[T1:%.*]] = apply [[T0]]({{%.*}}, [[WRITE]])
+// CHECK: [[T2:%.*]] = struct_extract [[T1]] : $UnsafeMutablePointer<Int32>, #UnsafeMutablePointer._rawValue
+// CHECK: [[T3:%.*]] = pointer_to_address [[T2]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: store {{%.*}} to [[T3]]
+ a[3] = 6
+}
+
+// CHECK-LABEL: sil hidden @$S10addressors5test1s5Int32VyF : $@convention(thin) () -> Int32
+func test1() -> Int32 {
+// CHECK: [[T0:%.*]] = metatype $@thin A.Type
+// CHECK: [[CTOR:%.*]] = function_ref @$S10addressors1AV{{[_0-9a-zA-Z]*}}fC
+// CHECK: [[A:%.*]] = apply [[CTOR]]([[T0]]) : $@convention(method) (@thin A.Type) -> A
+// CHECK: [[ACCESSOR:%.*]] = function_ref @$S10addressors1AVys5Int32VAEcilu : $@convention(method) (Int32, A) -> UnsafePointer<Int32>
+// CHECK: [[PTR:%.*]] = apply [[ACCESSOR]]({{%.*}}, [[A]]) : $@convention(method) (Int32, A) -> UnsafePointer<Int32>
+// CHECK: [[T0:%.*]] = struct_extract [[PTR]] : $UnsafePointer<Int32>, #UnsafePointer._rawValue
+// CHECK: [[T1:%.*]] = pointer_to_address [[T0]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: [[T2:%.*]] = load [[T1]] : $*Int32
+// CHECK: return [[T2]] : $Int32
+ return A()[0]
+}
+
+let uninitAddr = UnsafeMutablePointer<Int32>.allocate(capacity: 1)
+var global: Int32 {
+ unsafeAddress {
+ return UnsafePointer(uninitAddr)
+ }
+// CHECK: sil hidden @$S10addressors6globals5Int32Vvlu : $@convention(thin) () -> UnsafePointer<Int32> {
+// CHECK: [[T0:%.*]] = global_addr @$S10addressors10uninitAddrSpys5Int32VGvp : $*UnsafeMutablePointer<Int32>
+// CHECK: [[T1:%.*]] = load [[T0]] : $*UnsafeMutablePointer<Int32>
+// CHECK: [[T2:%.*]] = struct_extract [[T1]] : $UnsafeMutablePointer<Int32>, #UnsafeMutablePointer._rawValue
+// CHECK: [[T3:%.*]] = struct $UnsafePointer<Int32> ([[T2]] : $Builtin.RawPointer)
+// CHECK: return [[T3]] : $UnsafePointer<Int32>
+}
+
+func test_global() -> Int32 {
+ return global
+}
+// CHECK-LABEL: sil hidden @$S10addressors11test_globals5Int32VyF : $@convention(thin) () -> Int32 {
+// CHECK: [[T0:%.*]] = function_ref @$S10addressors6globals5Int32Vvlu : $@convention(thin) () -> UnsafePointer<Int32>
+// CHECK: [[T1:%.*]] = apply [[T0]]() : $@convention(thin) () -> UnsafePointer<Int32>
+// CHECK: [[T2:%.*]] = struct_extract [[T1]] : $UnsafePointer<Int32>, #UnsafePointer._rawValue
+// CHECK: [[T3:%.*]] = pointer_to_address [[T2]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: [[T4:%.*]] = load [[T3]] : $*Int32
+// CHECK: return [[T4]] : $Int32
+
+// Test that having generated trivial accessors for something because
+// of protocol conformance doesn't force us down inefficient access paths.
+protocol Subscriptable {
+ subscript(i: Int32) -> Int32 { get set }
+}
+
+struct B : Subscriptable {
+ subscript(i: Int32) -> Int32 {
+ unsafeAddress { return someValidPointer() }
+ unsafeMutableAddress { return someValidPointer() }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10addressors6test_ByyAA1BVzF : $@convention(thin) (@inout B) -> () {
+// CHECK: bb0([[B:%.*]] : $*B):
+// CHECK: [[T0:%.*]] = integer_literal $Builtin.Int32, 0
+// CHECK: [[INDEX:%.*]] = struct $Int32 ([[T0]] : $Builtin.Int32)
+// CHECK: [[RHS:%.*]] = integer_literal $Builtin.Int32, 7
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [static] [[B]] : $*B
+// CHECK: [[T0:%.*]] = function_ref @$S10addressors1BVys5Int32VAEciau
+// CHECK: [[PTR:%.*]] = apply [[T0]]([[INDEX]], [[WRITE]])
+// CHECK: [[T0:%.*]] = struct_extract [[PTR]] : $UnsafeMutablePointer<Int32>,
+// CHECK: [[ADDR:%.*]] = pointer_to_address [[T0]] : $Builtin.RawPointer to [strict] $*Int32
+// Accept either of struct_extract+load or load+struct_element_addr.
+// CHECK: load
+// CHECK: [[T1:%.*]] = builtin "or_Int32"
+// CHECK: [[T2:%.*]] = struct $Int32 ([[T1]] : $Builtin.Int32)
+// CHECK: store [[T2]] to [[ADDR]] : $*Int32
+func test_B(_ b: inout B) {
+ b[0] |= 7
+}
+
+// Test that we handle abstraction difference.
+struct CArray<T> {
+ var storage: UnsafeMutablePointer<T>
+ subscript(index: Int) -> T {
+ unsafeAddress { return UnsafePointer(storage) + index }
+ unsafeMutableAddress { return storage + index }
+ }
+}
+
+func id_int(_ i: Int32) -> Int32 { return i }
+
+// CHECK-LABEL: sil hidden @$S10addressors11test_carrayys5Int32VAA6CArrayVyA2DcGzF : $@convention(thin) (@inout CArray<(Int32) -> Int32>) -> Int32 {
+// CHECK: bb0([[ARRAY:%.*]] : $*CArray<(Int32) -> Int32>):
+func test_carray(_ array: inout CArray<(Int32) -> Int32>) -> Int32 {
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [static] [[ARRAY]] : $*CArray<(Int32) -> Int32>
+// CHECK: [[T0:%.*]] = function_ref @$S10addressors6CArrayVyxSiciau :
+// CHECK: [[T1:%.*]] = apply [[T0]]<(Int32) -> Int32>({{%.*}}, [[WRITE]])
+// CHECK: [[T2:%.*]] = struct_extract [[T1]] : $UnsafeMutablePointer<(Int32) -> Int32>, #UnsafeMutablePointer._rawValue
+// CHECK: [[T3:%.*]] = pointer_to_address [[T2]] : $Builtin.RawPointer to [strict] $*@callee_guaranteed (@in_guaranteed Int32) -> @out Int32
+// CHECK: store {{%.*}} to [[T3]] :
+ array[0] = id_int
+
+// CHECK: [[READ:%.*]] = begin_access [read] [static] [[ARRAY]] : $*CArray<(Int32) -> Int32>
+// CHECK: [[T0:%.*]] = load [[READ]]
+// CHECK: [[T1:%.*]] = function_ref @$S10addressors6CArrayVyxSicilu :
+// CHECK: [[T2:%.*]] = apply [[T1]]<(Int32) -> Int32>({{%.*}}, [[T0]])
+// CHECK: [[T3:%.*]] = struct_extract [[T2]] : $UnsafePointer<(Int32) -> Int32>, #UnsafePointer._rawValue
+// CHECK: [[T4:%.*]] = pointer_to_address [[T3]] : $Builtin.RawPointer to [strict] $*@callee_guaranteed (@in_guaranteed Int32) -> @out Int32
+// CHECK: [[T5:%.*]] = load [[T4]]
+ return array[1](5)
+}
+
+// rdar://17270560, redux
+struct D : Subscriptable {
+ subscript(i: Int32) -> Int32 {
+ get { return i }
+ unsafeMutableAddress { return someValidPointer() }
+ }
+}
+// Setter.
+// SILGEN-LABEL: sil hidden [transparent] @$S10addressors1DVys5Int32VAEcis
+// SILGEN: bb0([[VALUE:%.*]] : @trivial $Int32, [[I:%.*]] : @trivial $Int32, [[SELF:%.*]] : @trivial $*D):
+// SILGEN: debug_value [[VALUE]] : $Int32
+// SILGEN: debug_value [[I]] : $Int32
+// SILGEN: debug_value_addr [[SELF]]
+// SILGEN: [[ACCESS:%.*]] = begin_access [modify] [unknown] [[SELF]] : $*D // users: %12, %8
+// SILGEN: [[T0:%.*]] = function_ref @$S10addressors1DVys5Int32VAEciau{{.*}}
+// SILGEN: [[PTR:%.*]] = apply [[T0]]([[I]], [[ACCESS]])
+// SILGEN: [[T0:%.*]] = struct_extract [[PTR]] : $UnsafeMutablePointer<Int32>,
+// SILGEN: [[ADDR:%.*]] = pointer_to_address [[T0]] : $Builtin.RawPointer to [strict] $*Int32
+// SILGEN: assign [[VALUE]] to [[ADDR]] : $*Int32
+
+// materializeForSet.
+// SILGEN-LABEL: sil hidden [transparent] @$S10addressors1DVys5Int32VAEcim
+// SILGEN: bb0([[BUFFER:%.*]] : @trivial $Builtin.RawPointer, [[STORAGE:%.*]] : @trivial $*Builtin.UnsafeValueBuffer, [[I:%.*]] : @trivial $Int32, [[SELF:%.*]] : @trivial $*D):
+// SILGEN: [[T0:%.*]] = function_ref @$S10addressors1DVys5Int32VAEciau
+// SILGEN: [[PTR:%.*]] = apply [[T0]]([[I]], [[SELF]])
+// SILGEN: [[ADDR_TMP:%.*]] = struct_extract [[PTR]] : $UnsafeMutablePointer<Int32>,
+// SILGEN: [[ADDR:%.*]] = pointer_to_address [[ADDR_TMP]]
+// SILGEN: [[PTR:%.*]] = address_to_pointer [[ADDR]]
+// SILGEN: [[OPT:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.none!enumelt
+// SILGEN: [[T2:%.*]] = tuple ([[PTR]] : $Builtin.RawPointer, [[OPT]] : $Optional<Builtin.RawPointer>)
+// SILGEN: return [[T2]] :
+
+func make_int() -> Int32 { return 0 }
+func take_int_inout(_ value: inout Int32) {}
+
+// CHECK-LABEL: sil hidden @$S10addressors6test_dys5Int32VAA1DVzF : $@convention(thin) (@inout D) -> Int32
+// CHECK: bb0([[ARRAY:%.*]] : $*D):
+func test_d(_ array: inout D) -> Int32 {
+// CHECK: [[T0:%.*]] = function_ref @$S10addressors8make_ints5Int32VyF
+// CHECK: [[V:%.*]] = apply [[T0]]()
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [static] [[ARRAY]] : $*D
+// CHECK: [[T0:%.*]] = function_ref @$S10addressors1DVys5Int32VAEciau
+// CHECK: [[T1:%.*]] = apply [[T0]]({{%.*}}, [[WRITE]])
+// CHECK: [[T2:%.*]] = struct_extract [[T1]] : $UnsafeMutablePointer<Int32>,
+// CHECK: [[ADDR:%.*]] = pointer_to_address [[T2]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: store [[V]] to [[ADDR]] : $*Int32
+ array[0] = make_int()
+
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [static] [[ARRAY]] : $*D
+// CHECK: [[T0:%.*]] = function_ref @$S10addressors1DVys5Int32VAEciau
+// CHECK: [[T1:%.*]] = apply [[T0]]({{%.*}}, [[WRITE]])
+// CHECK: [[T2:%.*]] = struct_extract [[T1]] : $UnsafeMutablePointer<Int32>,
+// CHECK: [[ADDR:%.*]] = pointer_to_address [[T2]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: [[FN:%.*]] = function_ref @$S10addressors14take_int_inoutyys5Int32VzF
+// CHECK: apply [[FN]]([[ADDR]])
+ take_int_inout(&array[1])
+
+// CHECK: [[READ:%.*]] = begin_access [read] [static] [[ARRAY]] : $*D
+// CHECK: [[T0:%.*]] = load [[READ]]
+// CHECK: [[T1:%.*]] = function_ref @$S10addressors1DVys5Int32VAEcig
+// CHECK: [[T2:%.*]] = apply [[T1]]({{%.*}}, [[T0]])
+// CHECK: return [[T2]]
+ return array[2]
+}
+
+struct E {
+ var value: Int32 {
+ unsafeAddress { return someValidPointer() }
+ nonmutating unsafeMutableAddress { return someValidPointer() }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10addressors6test_eyyAA1EVF
+// CHECK: bb0([[E:%.*]] : $E):
+// CHECK: [[T0:%.*]] = function_ref @$S10addressors1EV5values5Int32Vvau
+// CHECK: [[T1:%.*]] = apply [[T0]]([[E]])
+// CHECK: [[T2:%.*]] = struct_extract [[T1]]
+// CHECK: [[T3:%.*]] = pointer_to_address [[T2]]
+// CHECK: store {{%.*}} to [[T3]] : $*Int32
+func test_e(_ e: E) {
+ e.value = 0
+}
+
+class F {
+ var data: UnsafeMutablePointer<Int32> = UnsafeMutablePointer.allocate(capacity: 100)
+
+ final var value: Int32 {
+ addressWithNativeOwner {
+ return (UnsafePointer(data), Builtin.castToNativeObject(self))
+ }
+ mutableAddressWithNativeOwner {
+ return (data, Builtin.castToNativeObject(self))
+ }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10addressors1FC5values5Int32Vvlo : $@convention(method) (@guaranteed F) -> (UnsafePointer<Int32>, @owned Builtin.NativeObject) {
+// CHECK-LABEL: sil hidden @$S10addressors1FC5values5Int32Vvao : $@convention(method) (@guaranteed F) -> (UnsafeMutablePointer<Int32>, @owned Builtin.NativeObject) {
+
+func test_f0(_ f: F) -> Int32 {
+ return f.value
+}
+// CHECK-LABEL: sil hidden @$S10addressors7test_f0ys5Int32VAA1FCF : $@convention(thin) (@guaranteed F) -> Int32 {
+// CHECK: bb0([[SELF:%0]] : $F):
+// CHECK: [[ADDRESSOR:%.*]] = function_ref @$S10addressors1FC5values5Int32Vvlo : $@convention(method) (@guaranteed F) -> (UnsafePointer<Int32>, @owned Builtin.NativeObject)
+// CHECK: [[T0:%.*]] = apply [[ADDRESSOR]]([[SELF]])
+// CHECK: [[PTR:%.*]] = tuple_extract [[T0]] : $(UnsafePointer<Int32>, Builtin.NativeObject), 0
+// CHECK: [[OWNER:%.*]] = tuple_extract [[T0]] : $(UnsafePointer<Int32>, Builtin.NativeObject), 1
+// CHECK: [[T0:%.*]] = struct_extract [[PTR]]
+// CHECK: [[T1:%.*]] = pointer_to_address [[T0]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: [[T2:%.*]] = mark_dependence [[T1]] : $*Int32 on [[OWNER]] : $Builtin.NativeObject
+// CHECK: [[VALUE:%.*]] = load [[T2]] : $*Int32
+// CHECK: strong_release [[OWNER]] : $Builtin.NativeObject
+// CHECK-NOT: strong_release [[SELF]] : $F
+// CHECK: return [[VALUE]] : $Int32
+
+func test_f1(_ f: F) {
+ f.value = 14
+}
+// CHECK-LABEL: sil hidden @$S10addressors7test_f1yyAA1FCF : $@convention(thin) (@guaranteed F) -> () {
+// CHECK: bb0([[SELF:%0]] : $F):
+// CHECK: [[T0:%.*]] = integer_literal $Builtin.Int32, 14
+// CHECK: [[VALUE:%.*]] = struct $Int32 ([[T0]] : $Builtin.Int32)
+// CHECK: [[ADDRESSOR:%.*]] = function_ref @$S10addressors1FC5values5Int32Vvao : $@convention(method) (@guaranteed F) -> (UnsafeMutablePointer<Int32>, @owned Builtin.NativeObject)
+// CHECK: [[T0:%.*]] = apply [[ADDRESSOR]]([[SELF]])
+// CHECK: [[PTR:%.*]] = tuple_extract [[T0]] : $(UnsafeMutablePointer<Int32>, Builtin.NativeObject), 0
+// CHECK: [[OWNER:%.*]] = tuple_extract [[T0]] : $(UnsafeMutablePointer<Int32>, Builtin.NativeObject), 1
+// CHECK: [[T0:%.*]] = struct_extract [[PTR]]
+// CHECK: [[T1:%.*]] = pointer_to_address [[T0]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: [[T2:%.*]] = mark_dependence [[T1]] : $*Int32 on [[OWNER]] : $Builtin.NativeObject
+// CHECK: store [[VALUE]] to [[T2]] : $*Int32
+// CHECK: strong_release [[OWNER]] : $Builtin.NativeObject
+// CHECK-NOT: strong_release [[SELF]] : $F
+
+class G {
+ var data: UnsafeMutablePointer<Int32> = UnsafeMutablePointer.allocate(capacity: 100)
+
+ var value: Int32 {
+ addressWithNativeOwner {
+ return (UnsafePointer(data), Builtin.castToNativeObject(self))
+ }
+ mutableAddressWithNativeOwner {
+ return (data, Builtin.castToNativeObject(self))
+ }
+ }
+}
+// CHECK-LABEL: sil hidden [transparent] @$S10addressors1GC5values5Int32Vvg : $@convention(method) (@guaranteed G) -> Int32 {
+// CHECK: bb0([[SELF:%0]] : $G):
+// CHECK: [[ADDRESSOR:%.*]] = function_ref @$S10addressors1GC5values5Int32Vvlo : $@convention(method) (@guaranteed G) -> (UnsafePointer<Int32>, @owned Builtin.NativeObject)
+// CHECK: [[T0:%.*]] = apply [[ADDRESSOR]]([[SELF]])
+// CHECK: [[PTR:%.*]] = tuple_extract [[T0]] : $(UnsafePointer<Int32>, Builtin.NativeObject), 0
+// CHECK: [[OWNER:%.*]] = tuple_extract [[T0]] : $(UnsafePointer<Int32>, Builtin.NativeObject), 1
+// CHECK: [[T0:%.*]] = struct_extract [[PTR]]
+// CHECK: [[T1:%.*]] = pointer_to_address [[T0]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: [[T2:%.*]] = mark_dependence [[T1]] : $*Int32 on [[OWNER]] : $Builtin.NativeObject
+// CHECK: [[VALUE:%.*]] = load [[T2]] : $*Int32
+// CHECK: strong_release [[OWNER]] : $Builtin.NativeObject
+// CHECK: return [[VALUE]] : $Int32
+
+// CHECK-LABEL: sil hidden [transparent] @$S10addressors1GC5values5Int32Vvs : $@convention(method) (Int32, @guaranteed G) -> () {
+// CHECK: bb0([[VALUE:%0]] : $Int32, [[SELF:%1]] : $G):
+// CHECK: [[ADDRESSOR:%.*]] = function_ref @$S10addressors1GC5values5Int32Vvao : $@convention(method) (@guaranteed G) -> (UnsafeMutablePointer<Int32>, @owned Builtin.NativeObject)
+// CHECK: [[T0:%.*]] = apply [[ADDRESSOR]]([[SELF]])
+// CHECK: [[PTR:%.*]] = tuple_extract [[T0]] : $(UnsafeMutablePointer<Int32>, Builtin.NativeObject), 0
+// CHECK: [[OWNER:%.*]] = tuple_extract [[T0]] : $(UnsafeMutablePointer<Int32>, Builtin.NativeObject), 1
+// CHECK: [[T0:%.*]] = struct_extract [[PTR]]
+// CHECK: [[T1:%.*]] = pointer_to_address [[T0]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: [[T2:%.*]] = mark_dependence [[T1]] : $*Int32 on [[OWNER]] : $Builtin.NativeObject
+// CHECK: store [[VALUE]] to [[T2]] : $*Int32
+// CHECK: strong_release [[OWNER]] : $Builtin.NativeObject
+
+// materializeForSet callback for G.value
+// CHECK-LABEL: sil private [transparent] @$S10addressors1GC5values5Int32VvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout G, @thick G.Type) -> () {
+// CHECK: bb0([[BUFFER:%0]] : $Builtin.RawPointer, [[STORAGE:%1]] : $*Builtin.UnsafeValueBuffer, [[SELF:%2]] : $*G, [[SELFTYPE:%3]] : $@thick G.Type):
+// CHECK: [[T0:%.*]] = project_value_buffer $Builtin.NativeObject in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
+// CHECK: [[OWNER:%.*]] = load [[T0]]
+// CHECK: strong_release [[OWNER]] : $Builtin.NativeObject
+// CHECK: dealloc_value_buffer $Builtin.NativeObject in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
+
+// materializeForSet for G.value
+// CHECK-LABEL: sil hidden [transparent] @$S10addressors1GC5values5Int32Vvm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed G) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0([[BUFFER:%0]] : $Builtin.RawPointer, [[STORAGE:%1]] : $*Builtin.UnsafeValueBuffer, [[SELF:%2]] : $G):
+// Call the addressor.
+// CHECK: [[ADDRESSOR:%.*]] = function_ref @$S10addressors1GC5values5Int32Vvao : $@convention(method) (@guaranteed G) -> (UnsafeMutablePointer<Int32>, @owned Builtin.NativeObject)
+// CHECK: [[T0:%.*]] = apply [[ADDRESSOR]]([[SELF]])
+// CHECK: [[T1:%.*]] = tuple_extract [[T0]] : $(UnsafeMutablePointer<Int32>, Builtin.NativeObject), 0
+// CHECK: [[T2:%.*]] = tuple_extract [[T0]] : $(UnsafeMutablePointer<Int32>, Builtin.NativeObject), 1
+// Get the address.
+// CHECK: [[PTR:%.*]] = struct_extract [[T1]] : $UnsafeMutablePointer<Int32>, #UnsafeMutablePointer._rawValue
+// CHECK: [[ADDR_TMP:%.*]] = pointer_to_address [[PTR]]
+// CHECK: [[ADDR:%.*]] = mark_dependence [[ADDR_TMP]] : $*Int32 on [[T2]]
+// Initialize the callback storage with the owner.
+// CHECK: [[T0:%.*]] = alloc_value_buffer $Builtin.NativeObject in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
+// CHECK: store [[T2]] to [[T0]] : $*Builtin.NativeObject
+// CHECK: [[PTR:%.*]] = address_to_pointer [[ADDR]]
+// Set up the callback.
+// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S10addressors1GC5values5Int32VvmytfU_ :
+// CHECK: [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]]
+// CHECK: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]]
+// Epilogue.
+// CHECK: [[RESULT:%.*]] = tuple ([[PTR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
+// CHECK: return [[RESULT]]
+
+class H {
+ var data: UnsafeMutablePointer<Int32> = UnsafeMutablePointer.allocate(capacity: 100)
+
+ final var value: Int32 {
+ addressWithPinnedNativeOwner {
+ return (UnsafePointer(data), Builtin.tryPin(Builtin.castToNativeObject(self)))
+ }
+ mutableAddressWithPinnedNativeOwner {
+ return (data, Builtin.tryPin(Builtin.castToNativeObject(self)))
+ }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10addressors1HC5values5Int32Vvlp : $@convention(method) (@guaranteed H) -> (UnsafePointer<Int32>, @owned Optional<Builtin.NativeObject>) {
+// CHECK-LABEL: sil hidden @$S10addressors1HC5values5Int32VvaP : $@convention(method) (@guaranteed H) -> (UnsafeMutablePointer<Int32>, @owned Optional<Builtin.NativeObject>) {
+
+func test_h0(_ f: H) -> Int32 {
+ return f.value
+}
+// CHECK-LABEL: sil hidden @$S10addressors7test_h0ys5Int32VAA1HCF : $@convention(thin) (@guaranteed H) -> Int32 {
+// CHECK: bb0([[SELF:%0]] : $H):
+// CHECK: [[ADDRESSOR:%.*]] = function_ref @$S10addressors1HC5values5Int32Vvlp : $@convention(method) (@guaranteed H) -> (UnsafePointer<Int32>, @owned Optional<Builtin.NativeObject>)
+
+// CHECK: [[T0:%.*]] = apply [[ADDRESSOR]]([[SELF]])
+// CHECK: [[PTR:%.*]] = tuple_extract [[T0]] : $(UnsafePointer<Int32>, Optional<Builtin.NativeObject>), 0
+// CHECK: [[OWNER:%.*]] = tuple_extract [[T0]] : $(UnsafePointer<Int32>, Optional<Builtin.NativeObject>), 1
+// CHECK: [[T0:%.*]] = struct_extract [[PTR]]
+// CHECK: [[T1:%.*]] = pointer_to_address [[T0]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: [[T2:%.*]] = mark_dependence [[T1]] : $*Int32 on [[OWNER]] : $Optional<Builtin.NativeObject>
+// CHECK: [[VALUE:%.*]] = load [[T2]] : $*Int32
+// CHECK: strong_unpin [[OWNER]] : $Optional<Builtin.NativeObject>
+// CHECK-NOT: strong_release [[SELF]] : $H
+// CHECK: return [[VALUE]] : $Int32
+
+func test_h1(_ f: H) {
+ f.value = 14
+}
+// CHECK-LABEL: sil hidden @$S10addressors7test_h1yyAA1HCF : $@convention(thin) (@guaranteed H) -> () {
+// CHECK: bb0([[SELF:%0]] : $H):
+// CHECK: [[T0:%.*]] = integer_literal $Builtin.Int32, 14
+// CHECK: [[VALUE:%.*]] = struct $Int32 ([[T0]] : $Builtin.Int32)
+// CHECK: [[ADDRESSOR:%.*]] = function_ref @$S10addressors1HC5values5Int32VvaP : $@convention(method) (@guaranteed H) -> (UnsafeMutablePointer<Int32>, @owned Optional<Builtin.NativeObject>)
+// CHECK: [[T0:%.*]] = apply [[ADDRESSOR]]([[SELF]])
+// CHECK: [[PTR:%.*]] = tuple_extract [[T0]] : $(UnsafeMutablePointer<Int32>, Optional<Builtin.NativeObject>), 0
+// CHECK: [[OWNER:%.*]] = tuple_extract [[T0]] : $(UnsafeMutablePointer<Int32>, Optional<Builtin.NativeObject>), 1
+// CHECK: [[T0:%.*]] = struct_extract [[PTR]]
+// CHECK: [[T1:%.*]] = pointer_to_address [[T0]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: [[T2:%.*]] = mark_dependence [[T1]] : $*Int32 on [[OWNER]] : $Optional<Builtin.NativeObject>
+// CHECK: store [[VALUE]] to [[T2]] : $*Int32
+// CHECK: strong_unpin [[OWNER]] : $Optional<Builtin.NativeObject>
+// CHECK-NOT: strong_release [[SELF]] : $H
+
+class I {
+ var data: UnsafeMutablePointer<Int32> = UnsafeMutablePointer.allocate(capacity: 100)
+
+ var value: Int32 {
+ addressWithPinnedNativeOwner {
+ return (UnsafePointer(data), Builtin.tryPin(Builtin.castToNativeObject(self)))
+ }
+ mutableAddressWithPinnedNativeOwner {
+ return (data, Builtin.tryPin(Builtin.castToNativeObject(self)))
+ }
+ }
+}
+// CHECK-LABEL: sil hidden [transparent] @$S10addressors1IC5values5Int32Vvg : $@convention(method) (@guaranteed I) -> Int32 {
+// CHECK: bb0([[SELF:%0]] : $I):
+// CHECK: [[ADDRESSOR:%.*]] = function_ref @$S10addressors1IC5values5Int32Vvlp : $@convention(method) (@guaranteed I) -> (UnsafePointer<Int32>, @owned Optional<Builtin.NativeObject>)
+// CHECK: [[T0:%.*]] = apply [[ADDRESSOR]]([[SELF]])
+// CHECK: [[PTR:%.*]] = tuple_extract [[T0]] : $(UnsafePointer<Int32>, Optional<Builtin.NativeObject>), 0
+// CHECK: [[OWNER:%.*]] = tuple_extract [[T0]] : $(UnsafePointer<Int32>, Optional<Builtin.NativeObject>), 1
+// CHECK: [[T0:%.*]] = struct_extract [[PTR]]
+// CHECK: [[T1:%.*]] = pointer_to_address [[T0]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: [[T2:%.*]] = mark_dependence [[T1]] : $*Int32 on [[OWNER]] : $Optional<Builtin.NativeObject>
+// CHECK: [[VALUE:%.*]] = load [[T2]] : $*Int32
+// CHECK: strong_unpin [[OWNER]] : $Optional<Builtin.NativeObject>
+// CHECK: return [[VALUE]] : $Int32
+
+// CHECK-LABEL: sil hidden [transparent] @$S10addressors1IC5values5Int32Vvs : $@convention(method) (Int32, @guaranteed I) -> () {
+// CHECK: bb0([[VALUE:%0]] : $Int32, [[SELF:%1]] : $I):
+// CHECK: [[ADDRESSOR:%.*]] = function_ref @$S10addressors1IC5values5Int32VvaP : $@convention(method) (@guaranteed I) -> (UnsafeMutablePointer<Int32>, @owned Optional<Builtin.NativeObject>)
+// CHECK: [[T0:%.*]] = apply [[ADDRESSOR]]([[SELF]])
+// CHECK: [[PTR:%.*]] = tuple_extract [[T0]] : $(UnsafeMutablePointer<Int32>, Optional<Builtin.NativeObject>), 0
+// CHECK: [[OWNER:%.*]] = tuple_extract [[T0]] : $(UnsafeMutablePointer<Int32>, Optional<Builtin.NativeObject>), 1
+// CHECK: [[T0:%.*]] = struct_extract [[PTR]]
+// CHECK: [[T1:%.*]] = pointer_to_address [[T0]] : $Builtin.RawPointer to [strict] $*Int32
+// CHECK: [[T2:%.*]] = mark_dependence [[T1]] : $*Int32 on [[OWNER]] : $Optional<Builtin.NativeObject>
+// CHECK: store [[VALUE]] to [[T2]] : $*Int32
+// CHECK: strong_unpin [[OWNER]] : $Optional<Builtin.NativeObject>
+
+// materializeForSet callback for I.value
+// CHECK-LABEL: sil private [transparent] @$S10addressors1IC5values5Int32VvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout I, @thick I.Type) -> () {
+// CHECK: bb0([[BUFFER:%0]] : $Builtin.RawPointer, [[STORAGE:%1]] : $*Builtin.UnsafeValueBuffer, [[SELF:%2]] : $*I, [[SELFTYPE:%3]] : $@thick I.Type):
+// CHECK: [[T0:%.*]] = project_value_buffer $Optional<Builtin.NativeObject> in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
+// CHECK: [[OWNER:%.*]] = load [[T0]]
+// CHECK: strong_unpin [[OWNER]] : $Optional<Builtin.NativeObject>
+// CHECK: dealloc_value_buffer $Optional<Builtin.NativeObject> in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
+
+// CHECK-LABEL: sil hidden [transparent] @$S10addressors1IC5values5Int32Vvm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed I) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0([[BUFFER:%0]] : $Builtin.RawPointer, [[STORAGE:%1]] : $*Builtin.UnsafeValueBuffer, [[SELF:%2]] : $I):
+// Call the addressor.
+// CHECK: [[ADDRESSOR:%.*]] = function_ref @$S10addressors1IC5values5Int32VvaP : $@convention(method) (@guaranteed I) -> (UnsafeMutablePointer<Int32>, @owned Optional<Builtin.NativeObject>)
+// CHECK: [[T0:%.*]] = apply [[ADDRESSOR]]([[SELF]])
+// CHECK: [[T1:%.*]] = tuple_extract [[T0]] : $(UnsafeMutablePointer<Int32>, Optional<Builtin.NativeObject>), 0
+// CHECK: [[T2:%.*]] = tuple_extract [[T0]] : $(UnsafeMutablePointer<Int32>, Optional<Builtin.NativeObject>), 1
+// Pull out the address.
+// CHECK: [[PTR:%.*]] = struct_extract [[T1]] : $UnsafeMutablePointer<Int32>, #UnsafeMutablePointer._rawValue
+// CHECK: [[ADDR_TMP:%.*]] = pointer_to_address [[PTR]]
+// CHECK: [[ADDR:%.*]] = mark_dependence [[ADDR_TMP]] : $*Int32 on [[T2]]
+// Initialize the callback storage with the owner.
+// CHECK: [[T0:%.*]] = alloc_value_buffer $Optional<Builtin.NativeObject> in [[STORAGE]] : $*Builtin.UnsafeValueBuffer
+// CHECK: store [[T2]] to [[T0]] : $*Optional<Builtin.NativeObject>
+// CHECK: [[PTR:%.*]] = address_to_pointer [[ADDR]]
+// Set up the callback.
+// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S10addressors1IC5values5Int32VvmytfU_ :
+// CHECK: [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]]
+// CHECK: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]]
+// Epilogue.
+// CHECK: [[RESULT:%.*]] = tuple ([[PTR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
+// CHECK: return [[RESULT]]
+
+struct RecInner {
+ subscript(i: Int32) -> Int32 {
+ mutating get { return i }
+ }
+}
+struct RecMiddle {
+ var inner: RecInner
+}
+class RecOuter {
+ var data: UnsafeMutablePointer<RecMiddle> = UnsafeMutablePointer.allocate(capacity: 100)
+ final var middle: RecMiddle {
+ addressWithPinnedNativeOwner {
+ return (UnsafePointer(data), Builtin.tryPin(Builtin.castToNativeObject(self)))
+ }
+ mutableAddressWithPinnedNativeOwner {
+ return (data, Builtin.tryPin(Builtin.castToNativeObject(self)))
+ }
+ }
+}
+func test_rec(_ outer: RecOuter) -> Int32 {
+ return outer.middle.inner[0]
+}
+// This uses the mutable addressor.
+// CHECK-LABEL: sil hidden @$S10addressors8test_recys5Int32VAA8RecOuterCF : $@convention(thin) (@guaranteed RecOuter) -> Int32 {
+// CHECK: function_ref @$S10addressors8RecOuterC6middleAA0B6MiddleVvaP
+// CHECK: struct_element_addr {{.*}} : $*RecMiddle, #RecMiddle.inner
+// CHECK: function_ref @$S10addressors8RecInnerVys5Int32VAEcig
+
+class Base {
+ var data: UnsafeMutablePointer<Int32> = UnsafeMutablePointer.allocate(capacity: 100)
+
+ var value: Int32 {
+ addressWithNativeOwner {
+ return (UnsafePointer(data), Builtin.castToNativeObject(self))
+ }
+ mutableAddressWithNativeOwner {
+ return (data, Builtin.castToNativeObject(self))
+ }
+ }
+}
+
+class Sub : Base {
+ override var value: Int32 {
+ addressWithNativeOwner {
+ return (UnsafePointer(data), Builtin.castToNativeObject(self))
+ }
+ mutableAddressWithNativeOwner {
+ return (data, Builtin.castToNativeObject(self))
+ }
+ }
+}
+
+// Make sure addressors don't get vtable entries.
+// CHECK-LABEL: sil_vtable Base {
+// CHECK-NEXT: #Base.data!getter.1: (Base) -> () -> UnsafeMutablePointer<Int32> : @$S10addressors4BaseC4dataSpys5Int32VGvg
+// CHECK-NEXT: #Base.data!setter.1: (Base) -> (UnsafeMutablePointer<Int32>) -> () : @$S10addressors4BaseC4dataSpys5Int32VGvs
+// CHECK-NEXT: #Base.data!materializeForSet.1: (Base) -> (Builtin.RawPointer, inout Builtin.UnsafeValueBuffer) -> (Builtin.RawPointer, Builtin.RawPointer?) : @$S10addressors4BaseC4dataSpys5Int32VGvm
+// CHECK-NEXT: #Base.value!getter.1: (Base) -> () -> Int32 : @$S10addressors4BaseC5values5Int32Vvg
+// CHECK-NEXT: #Base.value!setter.1: (Base) -> (Int32) -> () : @$S10addressors4BaseC5values5Int32Vvs
+// CHECK-NEXT: #Base.value!materializeForSet.1: (Base) -> (Builtin.RawPointer, inout Builtin.UnsafeValueBuffer) -> (Builtin.RawPointer, Builtin.RawPointer?) : @$S10addressors4BaseC5values5Int32Vvm
+// CHECK-NEXT: #Base.init!initializer.1: (Base.Type) -> () -> Base : @$S10addressors4BaseCACycfc
+// CHECK-NEXT: #Base.deinit!deallocator: @$S10addressors4BaseCfD
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil_vtable Sub {
+// CHECK-NEXT: #Base.data!getter.1: (Base) -> () -> UnsafeMutablePointer<Int32> : @$S10addressors4BaseC4dataSpys5Int32VGvg
+// CHECK-NEXT: #Base.data!setter.1: (Base) -> (UnsafeMutablePointer<Int32>) -> () : @$S10addressors4BaseC4dataSpys5Int32VGvs
+// CHECK-NEXT: #Base.data!materializeForSet.1: (Base) -> (Builtin.RawPointer, inout Builtin.UnsafeValueBuffer) -> (Builtin.RawPointer, Builtin.RawPointer?) : @$S10addressors4BaseC4dataSpys5Int32VGvm
+// CHECK-NEXT: #Base.value!getter.1: (Base) -> () -> Int32 : @$S10addressors3SubC5values5Int32Vvg
+// CHECK-NEXT: #Base.value!setter.1: (Base) -> (Int32) -> () : @$S10addressors3SubC5values5Int32Vvs
+// CHECK-NEXT: #Base.value!materializeForSet.1: (Base) -> (Builtin.RawPointer, inout Builtin.UnsafeValueBuffer) -> (Builtin.RawPointer, Builtin.RawPointer?) : @$S10addressors3SubC5values5Int32Vvm
+// CHECK-NEXT: #Base.init!initializer.1: (Base.Type) -> () -> Base : @$S10addressors3SubCACycfc
+// CHECK-NEXT: #Sub.deinit!deallocator: @$S10addressors3SubCfD
+// CHECK-NEXT: }
diff --git a/test/SILGen/plus_zero_apply_abstraction_nested.swift b/test/SILGen/plus_zero_apply_abstraction_nested.swift
new file mode 100644
index 0000000..f1143d9
--- /dev/null
+++ b/test/SILGen/plus_zero_apply_abstraction_nested.swift
@@ -0,0 +1,27 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -emit-silgen %s | %FileCheck %s
+
+infix operator ~> { precedence 255 associativity left }
+
+protocol P { }
+
+func bar<T:P>(_: inout T) -> () -> () { return {_ in ()} }
+func baz<T:P>(_: inout T) -> (Int) -> () { return {_ in ()} }
+
+func ~> <T: P, Args, Result>(
+ x: inout T,
+ m: (_ x: inout T) -> ((Args) -> Result)
+) -> ((Args) -> Result) {
+ return m(&x)
+}
+
+struct X : P {}
+
+var a = X()
+(a~>bar)()
+
+// CHECK: [[CHAINED_FUNC:%.*]] = apply {{%.*}}<X, (), ()>({{%.*}}, {{%.*}}) : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2 where τ_0_0 : P> (@inout τ_0_0, @noescape @callee_guaranteed (@inout τ_0_0) -> @owned @callee_guaranteed (@in_guaranteed τ_0_1) -> @out τ_0_2) -> @owned @callee_guaranteed (@in_guaranteed τ_0_1) -> @out τ_0_2
+// CHECK: [[REABSTRACT:%.*]] = function_ref @$SytytIegnr_Ieg_TR
+// CHECK: [[CHAINED_FUNC_REABSTRACTED:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACT]]([[CHAINED_FUNC]])
+// CHECK: [[BORROW:%.*]] = begin_borrow [[CHAINED_FUNC_REABSTRACTED]]
+// CHECK: apply [[BORROW]]() : $@callee_guaranteed () -> ()
diff --git a/test/SILGen/plus_zero_argument_labels.swift b/test/SILGen/plus_zero_argument_labels.swift
new file mode 100644
index 0000000..95bb1d6
--- /dev/null
+++ b/test/SILGen/plus_zero_argument_labels.swift
@@ -0,0 +1,21 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+public struct X { }
+public struct Y { }
+
+public class Foo {
+ func doSomething(x: X, y: Y) { }
+ func doSomethingElse(x: X) { }
+}
+
+// CHECK-LABEL: sil hidden @$S15argument_labels7testFoo{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[ARG0:%.*]] : @guaranteed $Foo,
+func testFoo(foo: Foo, x: X, y: Y) {
+ // CHECK: class_method [[ARG0]] : $Foo, #Foo.doSomething!1 : (Foo) -> (X, Y) -> ()
+ foo.doSomething(x: x, y: y)
+
+ // CHECK: class_method [[ARG0]] : $Foo, #Foo.doSomethingElse!1 : (Foo) -> (X) -> ()
+ foo.doSomethingElse(x: x)
+}
+
diff --git a/test/SILGen/plus_zero_argument_shuffle_swift3.swift b/test/SILGen/plus_zero_argument_shuffle_swift3.swift
new file mode 100644
index 0000000..d76bb29
--- /dev/null
+++ b/test/SILGen/plus_zero_argument_shuffle_swift3.swift
@@ -0,0 +1,26 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s -swift-version 3 | %FileCheck %s
+
+func fn(_: Any) {}
+
+enum HasAnyCase {
+ case any(_: Any)
+}
+
+// CHECK-LABEL: sil hidden @$S23argument_shuffle_swift31g1xyyp_tF : $@convention(thin) (@in_guaranteed Any) -> () {
+func g(x: Any) {
+ // CHECK: [[FN:%.*]] = function_ref @$S23argument_shuffle_swift32fnyyypF : $@convention(thin) (@in_guaranteed Any) -> ()
+ // CHECK: apply [[FN:%.*]]({{.*}}) : $@convention(thin) (@in_guaranteed Any) -> ()
+ fn(data: 123)
+ // CHECK: [[FN:%.*]] = function_ref @$S23argument_shuffle_swift32fnyyypF : $@convention(thin) (@in_guaranteed Any) -> ()
+ // CHECK: apply [[FN:%.*]]({{.*}}) : $@convention(thin) (@in_guaranteed Any) -> ()
+ fn(data: x)
+
+ // CHECK: inject_enum_addr {{.*}} : $*HasAnyCase, #HasAnyCase.any!enumelt.1
+ _ = HasAnyCase.any(123)
+
+ // CHECK: inject_enum_addr {{.*}} : $*HasAnyCase, #HasAnyCase.any!enumelt.1
+ _ = HasAnyCase.any(data: 123)
+
+ // CHECK: return
+}
diff --git a/test/SILGen/plus_zero_array_literal_abstraction.swift b/test/SILGen/plus_zero_array_literal_abstraction.swift
new file mode 100644
index 0000000..d7f1e36
--- /dev/null
+++ b/test/SILGen/plus_zero_array_literal_abstraction.swift
@@ -0,0 +1,25 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
+
+// Verify that reabstraction happens when forming container literals.
+// <rdar://problem/16039286>
+
+// CHECK-LABEL: sil hidden @$S25array_literal_abstraction0A9_of_funcsSayyycGyF
+// CHECK: pointer_to_address {{.*}} $*@callee_guaranteed (@in_guaranteed ()) -> @out ()
+func array_of_funcs() -> [(() -> ())] {
+ return [{}, {}]
+}
+
+// CHECK-LABEL: sil hidden @$S25array_literal_abstraction13dict_of_funcss10DictionaryVySiyycGyF
+// CHECK: pointer_to_address {{.*}} $*(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ())
+func dict_of_funcs() -> Dictionary<Int, () -> ()> {
+ return [0: {}, 1: {}]
+}
+
+func vararg_funcs(_ fs: (() -> ())...) {}
+
+// CHECK-LABEL: sil hidden @$S25array_literal_abstraction17call_vararg_funcsyyF
+// CHECK: pointer_to_address {{.*}} $*@callee_guaranteed (@in_guaranteed ()) -> @out ()
+func call_vararg_funcs() {
+ vararg_funcs({}, {})
+}
diff --git a/test/SILGen/plus_zero_auto_closures.swift b/test/SILGen/plus_zero_auto_closures.swift
new file mode 100644
index 0000000..0adc57e
--- /dev/null
+++ b/test/SILGen/plus_zero_auto_closures.swift
@@ -0,0 +1,73 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -parse-stdlib -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+struct Bool {}
+var false_ = Bool()
+
+// CHECK-LABEL: sil hidden @$S13auto_closures05call_A8_closureyAA4BoolVADyXKF : $@convention(thin) (@noescape @callee_guaranteed () -> Bool) -> Bool
+func call_auto_closure(_ x: @autoclosure () -> Bool) -> Bool {
+ // CHECK: bb0([[CLOSURE:%.*]] : @trivial $@noescape @callee_guaranteed () -> Bool):
+ // CHECK: [[RET:%.*]] = apply [[CLOSURE]]()
+ // CHECK: return [[RET]]
+ return x()
+}
+
+// CHECK-LABEL: sil hidden @$S13auto_closures05test_A21_closure_with_capture{{[_0-9a-zA-Z]*}}F
+func test_auto_closure_with_capture(_ x: Bool) -> Bool {
+ // CHECK: [[CLOSURE:%.*]] = function_ref @$S13auto_closures05test_A21_closure_with_capture
+ // CHECK: [[WITHCAPTURE:%.*]] = partial_apply [callee_guaranteed] [[CLOSURE]](
+ // CHECK: [[CVT:%.*]] = convert_escape_to_noescape [[WITHCAPTURE]]
+ // CHECK: [[RET:%.*]] = apply {{%.*}}([[CVT]])
+ // CHECK: return [[RET]]
+ return call_auto_closure(x)
+}
+
+// CHECK-LABEL: sil hidden @$S13auto_closures05test_A24_closure_without_capture{{[_0-9a-zA-Z]*}}F
+func test_auto_closure_without_capture() -> Bool {
+ // CHECK: [[CLOSURE:%.*]] = function_ref @$S13auto_closures05test_A24_closure_without_capture
+ // CHECK: [[CVT:%.*]] = convert_function [[CLOSURE]]
+ // CHECK: [[THICK:%.*]] = thin_to_thick_function [[CVT]] : $@convention(thin) @noescape () -> Bool to $@noescape @callee_guaranteed () -> Bool
+ // CHECK: [[RET:%.*]] = apply {{%.*}}([[THICK]])
+ // CHECK: return [[RET]]
+ return call_auto_closure(false_)
+}
+
+public class Base {
+ var x: Bool { return false_ }
+}
+
+public class Sub : Base {
+ // CHECK-LABEL: sil hidden @$S13auto_closures3SubC1xAA4BoolVvg : $@convention(method) (@guaranteed Sub) -> Bool {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $Sub):
+ // CHECK: [[AUTOCLOSURE_FUNC:%.*]] = function_ref @$S13auto_closures3SubC1xAA4BoolVvgAFyXKfu_ : $@convention(thin) (@guaranteed Sub) -> Bool
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[AUTOCLOSURE:%.*]] = partial_apply [callee_guaranteed] [[AUTOCLOSURE_FUNC]]([[SELF_COPY]])
+ // CHECK: [[CVT:%.*]] = convert_escape_to_noescape [[AUTOCLOSURE]]
+ // CHECK: [[AUTOCLOSURE_CONSUMER:%.*]] = function_ref @$S13auto_closures05call_A8_closureyAA4BoolVADyXKF : $@convention(thin)
+ // CHECK: [[RET:%.*]] = apply [[AUTOCLOSURE_CONSUMER]]([[CVT]])
+ // CHECK: return [[RET]] : $Bool
+ // CHECK: }
+
+ // CHECK-LABEL: sil private [transparent] @$S13auto_closures3SubC1xAA4BoolVvgAFyXKfu_ : $@convention(thin) (@guaranteed Sub) -> Bool {
+ // CHECK: [[SUPER:%[0-9]+]] = function_ref @$S13auto_closures4BaseC1xAA4BoolVvg : $@convention(method) (@guaranteed Base) -> Bool
+ // CHECK: [[RET:%.*]] = apply [[SUPER]]({{%.*}})
+ // CHECK: return [[RET]]
+ override var x: Bool { return call_auto_closure(super.x) }
+}
+
+// CHECK-LABEL: sil hidden @$S13auto_closures20closureInAutoclosureyAA4BoolVAD_ADtF : $@convention(thin) (Bool, Bool) -> Bool {
+// CHECK: }
+// CHECK-LABEL: sil private [transparent] @$S13auto_closures20closureInAutoclosureyAA4BoolVAD_ADtFADyXKfu_ : $@convention(thin) (Bool, Bool) -> Bool {
+// CHECK: }
+// CHECK-LABEL: sil private @$S13auto_closures20closureInAutoclosureyAA4BoolVAD_ADtFADyXKfu_A2DXEfU_ : $@convention(thin) (Bool, Bool) -> Bool {
+// CHECK: }
+func compareBool(_ lhs: Bool, _ rhs: Bool) -> Bool { return false_ }
+func testBool(_ x: Bool, _ pred: (Bool) -> Bool) -> Bool {
+ return pred(x)
+}
+func delayBool(_ fn: @autoclosure () -> Bool) -> Bool {
+ return fn()
+}
+func closureInAutoclosure(_ lhs: Bool, _ rhs: Bool) -> Bool {
+ return delayBool(testBool(lhs, { compareBool($0, rhs) }))
+}
diff --git a/test/SILGen/plus_zero_borrow.swift b/test/SILGen/plus_zero_borrow.swift
new file mode 100644
index 0000000..5dcec6f
--- /dev/null
+++ b/test/SILGen/plus_zero_borrow.swift
@@ -0,0 +1,36 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -emit-silgen %s | %FileCheck %s
+
+import Swift
+
+final class D {}
+
+// Make sure that we insert the borrow for a ref_element_addr lvalue in the
+// proper place.
+final class C {
+ var d: D = D()
+}
+
+func useD(_ d: D) {}
+
+// CHECK-LABEL: sil hidden @$S6borrow44lvalueBorrowShouldBeAtEndOfFormalAccessScope{{.*}} : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK: [[BOX:%.*]] = alloc_box ${ var C }, var, name "c"
+// CHECK: [[PB_BOX:%.*]] = project_box [[BOX]]
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [unknown] [[PB_BOX]] : $*C
+// CHECK: [[CLASS:%.*]] = load [copy] [[ACCESS]]
+// CHECK: [[BORROWED_CLASS:%.*]] = begin_borrow [[CLASS]]
+// CHECK: [[OFFSET:%.*]] = ref_element_addr [[BORROWED_CLASS]]
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [dynamic] [[OFFSET]] : $*D
+// CHECK: [[LOADED_VALUE:%.*]] = load [copy] [[ACCESS]]
+// CHECK: end_borrow [[BORROWED_CLASS]] from [[CLASS]]
+// CHECK: destroy_value [[CLASS]]
+// CHECK: [[BORROWED_LOADED_VALUE:%.*]] = begin_borrow [[LOADED_VALUE]]
+// CHECK: [[FUNC:%.*]] = function_ref @$S6borrow4useD{{.*}} : $@convention(thin) (@guaranteed D) -> ()
+// CHECK: apply [[FUNC]]([[BORROWED_LOADED_VALUE]])
+// CHECK: destroy_value [[BOX]]
+// CHECK: } // end sil function '$S6borrow44lvalueBorrowShouldBeAtEndOfFormalAccessScope{{.*}}'
+func lvalueBorrowShouldBeAtEndOfFormalAccessScope() {
+ var c = C()
+ useD(c.d)
+}
diff --git a/test/SILGen/plus_zero_boxed_existentials.swift b/test/SILGen/plus_zero_boxed_existentials.swift
new file mode 100644
index 0000000..70b4197
--- /dev/null
+++ b/test/SILGen/plus_zero_boxed_existentials.swift
@@ -0,0 +1,217 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-silgen %s | %FileCheck %s
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-silgen %s | %FileCheck %s --check-prefix=GUARANTEED
+
+func test_type_lowering(_ x: Error) { }
+// CHECK-LABEL: sil hidden @$S18boxed_existentials18test_type_loweringyys5Error_pF : $@convention(thin) (@guaranteed Error) -> () {
+// CHECK-NOT: destroy_value %0 : $Error
+
+class Document {}
+
+enum ClericalError: Error {
+ case MisplacedDocument(Document)
+
+ var _domain: String { return "" }
+ var _code: Int { return 0 }
+}
+
+func test_concrete_erasure(_ x: ClericalError) -> Error {
+ return x
+}
+// CHECK-LABEL: sil hidden @$S18boxed_existentials21test_concrete_erasureys5Error_pAA08ClericalF0OF
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $ClericalError):
+// CHECK: [[EXISTENTIAL:%.*]] = alloc_existential_box $Error, $ClericalError
+// CHECK: [[ADDR:%.*]] = project_existential_box $ClericalError in [[EXISTENTIAL]] : $Error
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: store [[ARG_COPY]] to [init] [[ADDR]] : $*ClericalError
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return [[EXISTENTIAL]] : $Error
+
+protocol HairType {}
+
+func test_composition_erasure(_ x: HairType & Error) -> Error {
+ return x
+}
+// CHECK-LABEL: sil hidden @$S18boxed_existentials24test_composition_erasureys5Error_psAC_AA8HairTypepF
+// CHECK: [[VALUE_ADDR:%.*]] = open_existential_addr immutable_access [[OLD_EXISTENTIAL:%.*]] : $*Error & HairType to $*[[VALUE_TYPE:@opened\(.*\) Error & HairType]]
+// CHECK: [[NEW_EXISTENTIAL:%.*]] = alloc_existential_box $Error, $[[VALUE_TYPE]]
+// CHECK: [[ADDR:%.*]] = project_existential_box $[[VALUE_TYPE]] in [[NEW_EXISTENTIAL]] : $Error
+// CHECK: copy_addr [[VALUE_ADDR]] to [initialization] [[ADDR]]
+// CHECK-NOT: destroy_addr [[OLD_EXISTENTIAL]]
+// CHECK: return [[NEW_EXISTENTIAL]]
+
+protocol HairClass: class {}
+
+func test_class_composition_erasure(_ x: HairClass & Error) -> Error {
+ return x
+}
+// CHECK-LABEL: sil hidden @$S18boxed_existentials30test_class_composition_erasureys5Error_psAC_AA9HairClasspF
+// CHECK: [[VALUE:%.*]] = open_existential_ref [[OLD_EXISTENTIAL:%.*]] : $Error & HairClass to $[[VALUE_TYPE:@opened\(.*\) Error & HairClass]]
+// CHECK: [[NEW_EXISTENTIAL:%.*]] = alloc_existential_box $Error, $[[VALUE_TYPE]]
+// CHECK: [[ADDR:%.*]] = project_existential_box $[[VALUE_TYPE]] in [[NEW_EXISTENTIAL]] : $Error
+// CHECK: [[COPIED_VALUE:%.*]] = copy_value [[VALUE]]
+// CHECK: store [[COPIED_VALUE]] to [init] [[ADDR]]
+// CHECK: return [[NEW_EXISTENTIAL]]
+
+func test_property(_ x: Error) -> String {
+ return x._domain
+}
+// CHECK-LABEL: sil hidden @$S18boxed_existentials13test_propertyySSs5Error_pF
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Error):
+// CHECK: [[VALUE:%.*]] = open_existential_box [[ARG]] : $Error to $*[[VALUE_TYPE:@opened\(.*\) Error]]
+// FIXME: Extraneous copy here
+// CHECK-NEXT: [[COPY:%[0-9]+]] = alloc_stack $[[VALUE_TYPE]]
+// CHECK-NEXT: copy_addr [[VALUE]] to [initialization] [[COPY]] : $*[[VALUE_TYPE]]
+// CHECK: [[METHOD:%.*]] = witness_method $[[VALUE_TYPE]], #Error._domain!getter.1
+// -- self parameter of witness is @in_guaranteed; no need to copy since
+// value in box is immutable and box is guaranteed
+// CHECK: [[RESULT:%.*]] = apply [[METHOD]]<[[VALUE_TYPE]]>([[COPY]])
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return [[RESULT]]
+
+func test_property_of_lvalue(_ x: Error) -> String {
+ var x = x
+ return x._domain
+}
+
+// CHECK-LABEL: sil hidden @$S18boxed_existentials23test_property_of_lvalueySSs5Error_pF :
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Error):
+// CHECK: [[VAR:%.*]] = alloc_box ${ var Error }
+// CHECK: [[PVAR:%.*]] = project_box [[VAR]]
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]] : $Error
+// CHECK: store [[ARG_COPY]] to [init] [[PVAR]]
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [unknown] [[PVAR]] : $*Error
+// CHECK: [[VALUE_BOX:%.*]] = load [copy] [[ACCESS]]
+// CHECK: [[VALUE:%.*]] = open_existential_box [[VALUE_BOX]] : $Error to $*[[VALUE_TYPE:@opened\(.*\) Error]]
+// CHECK: [[COPY:%.*]] = alloc_stack $[[VALUE_TYPE]]
+// CHECK: copy_addr [[VALUE]] to [initialization] [[COPY]]
+// CHECK: [[METHOD:%.*]] = witness_method $[[VALUE_TYPE]], #Error._domain!getter.1
+// CHECK: [[RESULT:%.*]] = apply [[METHOD]]<[[VALUE_TYPE]]>([[COPY]])
+// CHECK: destroy_addr [[COPY]]
+// CHECK: dealloc_stack [[COPY]]
+// CHECK: destroy_value [[VALUE_BOX]]
+// CHECK: destroy_value [[VAR]]
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return [[RESULT]]
+// CHECK: } // end sil function '$S18boxed_existentials23test_property_of_lvalueySSs5Error_pF'
+extension Error {
+ func extensionMethod() { }
+}
+
+// CHECK-LABEL: sil hidden @$S18boxed_existentials21test_extension_methodyys5Error_pF
+func test_extension_method(_ error: Error) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Error):
+ // CHECK: [[VALUE:%.*]] = open_existential_box [[ARG]]
+ // CHECK: [[METHOD:%.*]] = function_ref
+ // CHECK-NOT: copy_addr
+ // CHECK: apply [[METHOD]]<{{.*}}>([[VALUE]])
+ // CHECK-NOT: destroy_addr [[COPY]]
+ // CHECK-NOT: destroy_addr [[VALUE]]
+ // CHECK-NOT: destroy_addr [[VALUE]]
+ // -- destroy_value the owned argument
+ // CHECK-NOT: destroy_value %0
+ error.extensionMethod()
+}
+
+func plusOneError() -> Error { }
+
+// CHECK-LABEL: sil hidden @$S18boxed_existentials31test_open_existential_semanticsyys5Error_p_sAC_ptF
+// GUARANTEED-LABEL: sil hidden @$S18boxed_existentials31test_open_existential_semanticsyys5Error_p_sAC_ptF
+// CHECK: bb0([[ARG0:%.*]]: @guaranteed $Error,
+// GUARANTEED: bb0([[ARG0:%.*]]: @guaranteed $Error,
+func test_open_existential_semantics(_ guaranteed: Error,
+ _ immediate: Error) {
+ var immediate = immediate
+ // CHECK: [[IMMEDIATE_BOX:%.*]] = alloc_box ${ var Error }
+ // CHECK: [[PB:%.*]] = project_box [[IMMEDIATE_BOX]]
+ // GUARANTEED: [[IMMEDIATE_BOX:%.*]] = alloc_box ${ var Error }
+ // GUARANTEED: [[PB:%.*]] = project_box [[IMMEDIATE_BOX]]
+
+ // CHECK-NOT: copy_value [[ARG0]]
+ // CHECK: [[VALUE:%.*]] = open_existential_box [[ARG0]]
+ // CHECK: [[METHOD:%.*]] = function_ref
+ // CHECK-NOT: copy_addr
+ // CHECK: apply [[METHOD]]<{{.*}}>([[VALUE]])
+ // CHECK-NOT: destroy_value [[ARG0]]
+
+ // GUARANTEED-NOT: copy_value [[ARG0]]
+ // GUARANTEED: [[VALUE:%.*]] = open_existential_box [[ARG0]]
+ // GUARANTEED: [[METHOD:%.*]] = function_ref
+ // GUARANTEED: apply [[METHOD]]<{{.*}}>([[VALUE]])
+ // GUARANTEED-NOT: destroy_addr [[VALUE]]
+ // GUARANTEED-NOT: destroy_value [[ARG0]]
+ guaranteed.extensionMethod()
+
+ // CHECK: [[ACCESS:%.*]] = begin_access [read] [unknown] [[PB]] : $*Error
+ // CHECK: [[IMMEDIATE:%.*]] = load [copy] [[ACCESS]]
+ // -- need a copy_value to guarantee
+ // CHECK: [[VALUE:%.*]] = open_existential_box [[IMMEDIATE]]
+ // CHECK: [[METHOD:%.*]] = function_ref
+ // CHECK-NOT: copy_addr
+ // CHECK: apply [[METHOD]]<{{.*}}>([[VALUE]])
+ // -- end the guarantee
+ // -- TODO: could in theory do this sooner, after the value's been copied
+ // out.
+ // CHECK: destroy_value [[IMMEDIATE]]
+
+ // GUARANTEED: [[ACCESS:%.*]] = begin_access [read] [unknown] [[PB]] : $*Error
+ // GUARANTEED: [[IMMEDIATE:%.*]] = load [copy] [[ACCESS]]
+ // -- need a copy_value to guarantee
+ // GUARANTEED: [[VALUE:%.*]] = open_existential_box [[IMMEDIATE]]
+ // GUARANTEED: [[METHOD:%.*]] = function_ref
+ // GUARANTEED: apply [[METHOD]]<{{.*}}>([[VALUE]])
+ // GUARANTEED-NOT: destroy_addr [[VALUE]]
+ // -- end the guarantee
+ // GUARANTEED: destroy_value [[IMMEDIATE]]
+ immediate.extensionMethod()
+
+ // CHECK: [[F:%.*]] = function_ref {{.*}}plusOneError
+ // CHECK: [[PLUS_ONE:%.*]] = apply [[F]]()
+ // CHECK: [[VALUE:%.*]] = open_existential_box [[PLUS_ONE]]
+ // CHECK: [[METHOD:%.*]] = function_ref
+ // CHECK-NOT: copy_addr
+ // CHECK: apply [[METHOD]]<{{.*}}>([[VALUE]])
+ // CHECK: destroy_value [[PLUS_ONE]]
+
+ // GUARANTEED: [[F:%.*]] = function_ref {{.*}}plusOneError
+ // GUARANTEED: [[PLUS_ONE:%.*]] = apply [[F]]()
+ // GUARANTEED: [[VALUE:%.*]] = open_existential_box [[PLUS_ONE]]
+ // GUARANTEED: [[METHOD:%.*]] = function_ref
+ // GUARANTEED: apply [[METHOD]]<{{.*}}>([[VALUE]])
+ // GUARANTEED-NOT: destroy_addr [[VALUE]]
+ // GUARANTEED: destroy_value [[PLUS_ONE]]
+ plusOneError().extensionMethod()
+}
+
+// CHECK-LABEL: sil hidden @$S18boxed_existentials14erasure_to_anyyyps5Error_p_sAC_ptF
+// CHECK: bb0([[OUT:%.*]] : @trivial $*Any, [[GUAR:%.*]] : @guaranteed $Error,
+func erasure_to_any(_ guaranteed: Error, _ immediate: Error) -> Any {
+ var immediate = immediate
+ // CHECK: [[IMMEDIATE_BOX:%.*]] = alloc_box ${ var Error }
+ // CHECK: [[PB:%.*]] = project_box [[IMMEDIATE_BOX]]
+ if true {
+ // CHECK-NOT: copy_value [[GUAR]]
+ // CHECK: [[FROM_VALUE:%.*]] = open_existential_box [[GUAR:%.*]]
+ // CHECK: [[TO_VALUE:%.*]] = init_existential_addr [[OUT]]
+ // CHECK: copy_addr [[FROM_VALUE]] to [initialization] [[TO_VALUE]]
+ // CHECK-NOT: destroy_value [[GUAR]]
+ return guaranteed
+ } else if true {
+ // CHECK: [[ACCESS:%.*]] = begin_access [read] [unknown] [[PB]]
+ // CHECK: [[IMMEDIATE:%.*]] = load [copy] [[ACCESS]]
+ // CHECK: [[FROM_VALUE:%.*]] = open_existential_box [[IMMEDIATE]]
+ // CHECK: [[TO_VALUE:%.*]] = init_existential_addr [[OUT]]
+ // CHECK: copy_addr [[FROM_VALUE]] to [initialization] [[TO_VALUE]]
+ // CHECK: destroy_value [[IMMEDIATE]]
+ return immediate
+ } else if true {
+ // CHECK: function_ref boxed_existentials.plusOneError
+ // CHECK: [[PLUS_ONE:%.*]] = apply
+ // CHECK: [[FROM_VALUE:%.*]] = open_existential_box [[PLUS_ONE]]
+ // CHECK: [[TO_VALUE:%.*]] = init_existential_addr [[OUT]]
+ // CHECK: copy_addr [[FROM_VALUE]] to [initialization] [[TO_VALUE]]
+ // CHECK: destroy_value [[PLUS_ONE]]
+
+ return plusOneError()
+ }
+}
diff --git a/test/SILGen/plus_zero_call_chain_reabstraction.swift b/test/SILGen/plus_zero_call_chain_reabstraction.swift
new file mode 100644
index 0000000..123c453
--- /dev/null
+++ b/test/SILGen/plus_zero_call_chain_reabstraction.swift
@@ -0,0 +1,20 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+struct A {
+ func g<U>(_ recur: (A, U) -> U) -> (A, U) -> U {
+ return { _, x in return x }
+ }
+ // CHECK-LABEL: sil hidden @$S24call_chain_reabstraction1AV1f{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[G:%.*]] = function_ref @$S24call_chain_reabstraction1AV1g{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[G2:%.*]] = apply [[G]]<A>
+ // CHECK: [[REABSTRACT_THUNK:%.*]] = function_ref @$S24call_chain_reabstraction1AVA2CIegynr_A3CIegyyd_TR
+ // CHECK: [[REABSTRACT:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACT_THUNK]]([[G2]])
+ // CHECK: [[BORROW:%.*]] = begin_borrow [[REABSTRACT]]
+ // CHECK: apply [[BORROW]]([[SELF:%.*]], [[SELF]])
+ // CHECK: destroy_value [[REABSTRACT]]
+ func f() {
+ let recur: (A, A) -> A = { c, x in x }
+ let b = g(recur)(self, self)
+ }
+}
diff --git a/test/SILGen/plus_zero_capture_typed_boxes.swift b/test/SILGen/plus_zero_capture_typed_boxes.swift
new file mode 100644
index 0000000..c33dad1
--- /dev/null
+++ b/test/SILGen/plus_zero_capture_typed_boxes.swift
@@ -0,0 +1,32 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+func foo(_ x: Int) -> () -> Int {
+ var x = x
+ return { x }
+}
+// CHECK-LABEL: sil private @$S19capture_typed_boxes3fooySiycSiFSiycfU_ : $@convention(thin) (@guaranteed { var Int }) -> Int {
+// CHECK: bb0(%0 : @guaranteed ${ var Int }):
+
+func closure(_ f: @escaping (Int) -> Int) -> Int {
+ var f = f
+ func bar(_ x: Int) -> Int {
+ return f(x)
+ }
+
+ return bar(0)
+}
+// CHECK-LABEL: sil private @$S19capture_typed_boxes7closureyS3icF3barL_yS2iF : $@convention(thin) (Int, @guaranteed { var @callee_guaranteed (Int) -> Int }) -> Int {
+// CHECK: bb0(%0 : @trivial $Int, %1 : @guaranteed ${ var @callee_guaranteed (Int) -> Int }):
+
+func closure_generic<T>(_ f: @escaping (T) -> T, x: T) -> T {
+ var f = f
+ func bar(_ x: T) -> T {
+ return f(x)
+ }
+
+ return bar(x)
+}
+// CHECK-LABEL: sil private @$S19capture_typed_boxes15closure_generic{{.*}} : $@convention(thin) <T> (@in_guaranteed T, @guaranteed <τ_0_0> { var @callee_guaranteed (@in_guaranteed τ_0_0) -> @out τ_0_0 } <T>) -> @out T {
+// CHECK-LABEL: bb0(%0 : @trivial $*T, %1 : @trivial $*T, %2 : @guaranteed $<τ_0_0> { var @callee_guaranteed (@in_guaranteed τ_0_0) -> @out τ_0_0 } <T>):
+
diff --git a/test/SILGen/plus_zero_casts.swift b/test/SILGen/plus_zero_casts.swift
new file mode 100644
index 0000000..6944bbd
--- /dev/null
+++ b/test/SILGen/plus_zero_casts.swift
@@ -0,0 +1,103 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+class B { }
+class D : B { }
+
+// CHECK-LABEL: sil hidden @$S5casts6upcast{{[_0-9a-zA-Z]*}}F
+func upcast(d: D) -> B {
+ // CHECK: {{%.*}} = upcast
+ return d
+}
+// CHECK-LABEL: sil hidden @$S5casts8downcast{{[_0-9a-zA-Z]*}}F
+func downcast(b: B) -> D {
+ // CHECK: {{%.*}} = unconditional_checked_cast
+ return b as! D
+}
+
+// CHECK-LABEL: sil hidden @$S5casts3isa{{[_0-9a-zA-Z]*}}F
+func isa(b: B) -> Bool {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $B):
+ // CHECK: [[COPIED_BORROWED_ARG:%.*]] = copy_value [[ARG]]
+ // CHECK: checked_cast_br [[COPIED_BORROWED_ARG]] : $B to $D, [[YES:bb[0-9]+]], [[NO:bb[0-9]+]]
+ //
+ // CHECK: [[YES]]([[CASTED_VALUE:%.*]] : @owned $D):
+ // CHECK: integer_literal {{.*}} -1
+ // CHECK: destroy_value [[CASTED_VALUE]]
+ //
+ // CHECK: [[NO]]([[ORIGINAL_VALUE:%.*]] : @owned $B):
+ // CHECK: destroy_value [[ORIGINAL_VALUE]]
+ // CHECK: integer_literal {{.*}} 0
+ return b is D
+}
+
+// CHECK-LABEL: sil hidden @$S5casts16upcast_archetype{{[_0-9a-zA-Z]*}}F
+func upcast_archetype<T : B>(t: T) -> B {
+ // CHECK: {{%.*}} = upcast
+ return t
+}
+
+// CHECK-LABEL: sil hidden @$S5casts25upcast_archetype_metatype{{[_0-9a-zA-Z]*}}F
+func upcast_archetype_metatype<T : B>(t: T.Type) -> B.Type {
+ // CHECK: {{%.*}} = upcast
+ return t
+}
+
+// CHECK-LABEL: sil hidden @$S5casts18downcast_archetype{{[_0-9a-zA-Z]*}}F
+func downcast_archetype<T : B>(b: B) -> T {
+ // CHECK: {{%.*}} = unconditional_checked_cast
+ return b as! T
+}
+
+// This is making sure that we do not have the default propagating behavior in
+// the address case.
+//
+// CHECK-LABEL: sil hidden @$S5casts12is_archetype{{[_0-9a-zA-Z]*}}F
+func is_archetype<T : B>(b: B, _: T) -> Bool {
+ // CHECK: bb0([[ARG1:%.*]] : @guaranteed $B, [[ARG2:%.*]] : @guaranteed $T):
+ // CHECK: checked_cast_br {{%.*}}, [[YES:bb[0-9]+]], [[NO:bb[0-9]+]]
+ // CHECK: [[YES]]([[CASTED_ARG:%.*]] : @owned $T):
+ // CHECK: integer_literal {{.*}} -1
+ // CHECK: destroy_value [[CASTED_ARG]]
+ // CHECK: [[NO]]([[ORIGINAL_VALUE:%.*]] : @owned $B):
+ // CHCEK: destroy_value [[CASTED_ARG]]
+ // CHECK: integer_literal {{.*}} 0
+ return b is T
+}
+// CHECK: } // end sil function '$S5casts12is_archetype{{[_0-9a-zA-Z]*}}F'
+
+// CHECK: sil hidden @$S5casts20downcast_conditional{{[_0-9a-zA-Z]*}}F
+// CHECK: checked_cast_br {{%.*}} : $B to $D
+// CHECK: bb{{[0-9]+}}({{.*}} : $Optional<D>)
+func downcast_conditional(b: B) -> D? {
+ return b as? D
+}
+
+protocol P {}
+struct S : P {}
+
+// CHECK: sil hidden @$S5casts32downcast_existential_conditional{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[IN:%.*]] : @trivial $*P):
+// CHECK: [[COPY:%.*]] = alloc_stack $P
+// CHECK: copy_addr [[IN]] to [initialization] [[COPY]]
+// CHECK: [[TMP:%.*]] = alloc_stack $S
+// CHECK: checked_cast_addr_br take_always P in [[COPY]] : $*P to S in [[TMP]] : $*S, bb1, bb2
+// Success block.
+// CHECK: bb1:
+// CHECK: [[T0:%.*]] = load [trivial] [[TMP]] : $*S
+// CHECK: [[T1:%.*]] = enum $Optional<S>, #Optional.some!enumelt.1, [[T0]] : $S
+// CHECK: dealloc_stack [[TMP]]
+// CHECK: br bb3([[T1]] : $Optional<S>)
+// Failure block.
+// CHECK: bb2:
+// CHECK: [[T0:%.*]] = enum $Optional<S>, #Optional.none!enumelt
+// CHECK: dealloc_stack [[TMP]]
+// CHECK: br bb3([[T0]] : $Optional<S>)
+// Continuation block.
+// CHECK: bb3([[RESULT:%.*]] : @trivial $Optional<S>):
+// CHECK: dealloc_stack [[COPY]]
+// CHECK: return [[RESULT]]
+func downcast_existential_conditional(p: P) -> S? {
+ return p as? S
+}
+
diff --git a/test/SILGen/plus_zero_cf.swift b/test/SILGen/plus_zero_cf.swift
new file mode 100644
index 0000000..ac4e227
--- /dev/null
+++ b/test/SILGen/plus_zero_cf.swift
@@ -0,0 +1,83 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -import-cf-types -sdk %S/Inputs %s -emit-silgen -o - | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import CoreCooling
+
+// CHECK: sil hidden @$S2cf8useEmAllyySo16CCMagnetismModelCF :
+// CHECK: bb0([[ARG:%.*]] : $CCMagnetismModel):
+func useEmAll(_ model: CCMagnetismModel) {
+// CHECK: function_ref @CCPowerSupplyGetDefault : $@convention(c) () -> @autoreleased Optional<CCPowerSupply>
+ let power = CCPowerSupplyGetDefault()
+
+// CHECK: function_ref @CCRefrigeratorCreate : $@convention(c) (Optional<CCPowerSupply>) -> Optional<Unmanaged<CCRefrigerator>>
+ let unmanagedFridge = CCRefrigeratorCreate(power)
+
+// CHECK: function_ref @CCRefrigeratorSpawn : $@convention(c) (Optional<CCPowerSupply>) -> @owned Optional<CCRefrigerator>
+ let managedFridge = CCRefrigeratorSpawn(power)
+
+// CHECK: function_ref @CCRefrigeratorOpen : $@convention(c) (Optional<CCRefrigerator>) -> ()
+ CCRefrigeratorOpen(managedFridge)
+
+// CHECK: function_ref @CCRefrigeratorCopy : $@convention(c) (Optional<CCRefrigerator>) -> @owned Optional<CCRefrigerator>
+ let copy = CCRefrigeratorCopy(managedFridge)
+
+// CHECK: function_ref @CCRefrigeratorClone : $@convention(c) (Optional<CCRefrigerator>) -> @autoreleased Optional<CCRefrigerator>
+ let clone = CCRefrigeratorClone(managedFridge)
+
+// CHECK: function_ref @CCRefrigeratorDestroy : $@convention(c) (@owned Optional<CCRefrigerator>) -> ()
+ CCRefrigeratorDestroy(clone)
+
+// CHECK: objc_method [[ARG]] : $CCMagnetismModel, #CCMagnetismModel.refrigerator!1.foreign : (CCMagnetismModel) -> () -> Unmanaged<CCRefrigerator>?, $@convention(objc_method) (CCMagnetismModel) -> Optional<Unmanaged<CCRefrigerator>>
+ let f0 = model.refrigerator()
+
+// CHECK: objc_method [[ARG]] : $CCMagnetismModel, #CCMagnetismModel.getRefrigerator!1.foreign : (CCMagnetismModel) -> () -> CCRefrigerator?, $@convention(objc_method) (CCMagnetismModel) -> @autoreleased Optional<CCRefrigerator>
+ let f1 = model.getRefrigerator()
+
+// CHECK: objc_method [[ARG]] : $CCMagnetismModel, #CCMagnetismModel.takeRefrigerator!1.foreign : (CCMagnetismModel) -> () -> CCRefrigerator?, $@convention(objc_method) (CCMagnetismModel) -> @owned Optional<CCRefrigerator>
+ let f2 = model.takeRefrigerator()
+
+// CHECK: objc_method [[ARG]] : $CCMagnetismModel, #CCMagnetismModel.borrowRefrigerator!1.foreign : (CCMagnetismModel) -> () -> CCRefrigerator?, $@convention(objc_method) (CCMagnetismModel) -> @autoreleased Optional<CCRefrigerator>
+ let f3 = model.borrowRefrigerator()
+
+// CHECK: objc_method [[ARG]] : $CCMagnetismModel, #CCMagnetismModel.setRefrigerator!1.foreign : (CCMagnetismModel) -> (CCRefrigerator?) -> (), $@convention(objc_method) (Optional<CCRefrigerator>, CCMagnetismModel) -> ()
+ model.setRefrigerator(copy)
+
+// CHECK: objc_method [[ARG]] : $CCMagnetismModel, #CCMagnetismModel.giveRefrigerator!1.foreign : (CCMagnetismModel) -> (CCRefrigerator?) -> (), $@convention(objc_method) (@owned Optional<CCRefrigerator>, CCMagnetismModel) -> ()
+ model.giveRefrigerator(copy)
+
+ // rdar://16846555
+ let prop: CCRefrigerator = model.fridgeProp
+}
+
+// Ensure that accessors are emitted for fields used as protocol witnesses.
+protocol Impedance {
+ associatedtype Component
+ var real: Component { get }
+ var imag: Component { get }
+}
+
+extension CCImpedance: Impedance {}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$SSo11CCImpedanceV2cf9ImpedanceA2cDP4real9ComponentQzvgTW
+// CHECK-LABEL: sil shared [transparent] [serializable] @$SSo11CCImpedanceV4realSdvg
+// CHECK-LABEL: sil private [transparent] [thunk] @$SSo11CCImpedanceV2cf9ImpedanceA2cDP4imag9ComponentQzvgTW
+// CHECK-LABEL: sil shared [transparent] [serializable] @$SSo11CCImpedanceV4imagSdvg
+
+class MyMagnetism : CCMagnetismModel {
+ // CHECK-LABEL: sil hidden [thunk] @$S2cf11MyMagnetismC15getRefrigerator{{[_0-9a-zA-Z]*}}FTo : $@convention(objc_method) (MyMagnetism) -> @autoreleased CCRefrigerator
+ override func getRefrigerator() -> CCRefrigerator {
+ return super.getRefrigerator()
+ }
+
+ // CHECK-LABEL: sil hidden [thunk] @$S2cf11MyMagnetismC16takeRefrigerator{{[_0-9a-zA-Z]*}}FTo : $@convention(objc_method) (MyMagnetism) -> @owned CCRefrigerator
+ override func takeRefrigerator() -> CCRefrigerator {
+ return super.takeRefrigerator()
+ }
+
+ // CHECK-LABEL: sil hidden [thunk] @$S2cf11MyMagnetismC18borrowRefrigerator{{[_0-9a-zA-Z]*}}FTo : $@convention(objc_method) (MyMagnetism) -> @autoreleased CCRefrigerator
+ override func borrowRefrigerator() -> CCRefrigerator {
+ return super.borrowRefrigerator()
+ }
+}
diff --git a/test/SILGen/plus_zero_class_bound_protocols.swift b/test/SILGen/plus_zero_class_bound_protocols.swift
new file mode 100644
index 0000000..a6b66b8
--- /dev/null
+++ b/test/SILGen/plus_zero_class_bound_protocols.swift
@@ -0,0 +1,219 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -parse-stdlib -parse-as-library -module-name Swift -emit-silgen %s | %FileCheck %s
+
+enum Optional<T> {
+ case some(T)
+ case none
+}
+
+precedencegroup AssignmentPrecedence {}
+
+typealias AnyObject = Builtin.AnyObject
+
+// -- Class-bound archetypes and existentials are *not* address-only and can
+// be manipulated using normal reference type value semantics.
+
+protocol NotClassBound {
+ func notClassBoundMethod()
+}
+protocol ClassBound : class {
+ func classBoundMethod()
+}
+
+protocol ClassBound2 : class {
+ func classBound2Method()
+}
+
+class ConcreteClass : NotClassBound, ClassBound, ClassBound2 {
+ func notClassBoundMethod() {}
+ func classBoundMethod() {}
+ func classBound2Method() {}
+}
+
+class ConcreteSubclass : ConcreteClass { }
+
+// CHECK-LABEL: sil hidden @$Ss19class_bound_generic{{[_0-9a-zA-Z]*}}F
+func class_bound_generic<T : ClassBound>(x: T) -> T {
+ var x = x
+ // CHECK: bb0([[X:%.*]] : $T):
+ // CHECK: [[X_ADDR:%.*]] = alloc_box $<τ_0_0 where τ_0_0 : ClassBound> { var τ_0_0 } <T>
+ // CHECK: [[PB:%.*]] = project_box [[X_ADDR]]
+ // CHECK: [[X_COPY:%.*]] = copy_value [[X]]
+ // CHECK: store [[X_COPY]] to [init] [[PB]]
+ return x
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PB]] : $*T
+ // CHECK: [[X1:%.*]] = load [copy] [[READ]]
+ // CHECK: destroy_value [[X_ADDR]]
+ // CHECK: return [[X1]]
+}
+
+// CHECK-LABEL: sil hidden @$Ss21class_bound_generic_2{{[_0-9a-zA-Z]*}}F
+func class_bound_generic_2<T : ClassBound & NotClassBound>(x: T) -> T {
+ var x = x
+ // CHECK: bb0([[X:%.*]] : $T):
+ // CHECK: [[X_ADDR:%.*]] = alloc_box $<τ_0_0 where τ_0_0 : ClassBound, τ_0_0 : NotClassBound> { var τ_0_0 } <T>
+ // CHECK: [[PB:%.*]] = project_box [[X_ADDR]]
+ // CHECK: [[X_COPY:%.*]] = copy_value [[X]]
+ // CHECK: store [[X_COPY]] to [init] [[PB]]
+ return x
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PB]] : $*T
+ // CHECK: [[X1:%.*]] = load [copy] [[READ]]
+ // CHECK: return [[X1]]
+}
+
+// CHECK-LABEL: sil hidden @$Ss20class_bound_protocol{{[_0-9a-zA-Z]*}}F
+func class_bound_protocol(x: ClassBound) -> ClassBound {
+ var x = x
+ // CHECK: bb0([[X:%.*]] : $ClassBound):
+ // CHECK: [[X_ADDR:%.*]] = alloc_box ${ var ClassBound }
+ // CHECK: [[PB:%.*]] = project_box [[X_ADDR]]
+ // CHECK: [[X_COPY:%.*]] = copy_value [[X]]
+ // CHECK: store [[X_COPY]] to [init] [[PB]]
+ return x
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PB]] : $*ClassBound
+ // CHECK: [[X1:%.*]] = load [copy] [[READ]]
+ // CHECK: return [[X1]]
+}
+
+// CHECK-LABEL: sil hidden @$Ss32class_bound_protocol_composition{{[_0-9a-zA-Z]*}}F
+func class_bound_protocol_composition(x: ClassBound & NotClassBound)
+-> ClassBound & NotClassBound {
+ var x = x
+ // CHECK: bb0([[X:%.*]] : $ClassBound & NotClassBound):
+ // CHECK: [[X_ADDR:%.*]] = alloc_box ${ var ClassBound & NotClassBound }
+ // CHECK: [[PB:%.*]] = project_box [[X_ADDR]]
+ // CHECK: [[X_COPY:%.*]] = copy_value [[X]]
+ // CHECK: store [[X_COPY]] to [init] [[PB]]
+ return x
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PB]] : $*ClassBound & NotClassBound
+ // CHECK: [[X1:%.*]] = load [copy] [[READ]]
+ // CHECK: return [[X1]]
+}
+
+// CHECK-LABEL: sil hidden @$Ss19class_bound_erasure{{[_0-9a-zA-Z]*}}F
+func class_bound_erasure(x: ConcreteClass) -> ClassBound {
+ return x
+ // CHECK: [[PROTO:%.*]] = init_existential_ref {{%.*}} : $ConcreteClass, $ClassBound
+ // CHECK: return [[PROTO]]
+}
+
+// CHECK-LABEL: sil hidden @$Ss30class_bound_existential_upcast1xs10ClassBound_psAC_s0E6Bound2p_tF :
+func class_bound_existential_upcast(x: ClassBound & ClassBound2)
+-> ClassBound {
+ return x
+ // CHECK: bb0([[ARG:%.*]] : $ClassBound & ClassBound2):
+ // CHECK: [[OPENED:%.*]] = open_existential_ref [[ARG]] : $ClassBound & ClassBound2 to [[OPENED_TYPE:\$@opened(.*) ClassBound & ClassBound2]]
+ // CHECK: [[OPENED_COPY:%.*]] = copy_value [[OPENED]]
+ // CHECK: [[PROTO:%.*]] = init_existential_ref [[OPENED_COPY]] : [[OPENED_TYPE]] : [[OPENED_TYPE]], $ClassBound
+ // CHECK: return [[PROTO]]
+}
+// CHECK: } // end sil function '$Ss30class_bound_existential_upcast1xs10ClassBound_psAC_s0E6Bound2p_tF'
+
+// CHECK-LABEL: sil hidden @$Ss41class_bound_to_unbound_existential_upcast1xs13NotClassBound_ps0hI0_sACp_tF :
+// CHECK: bb0([[ARG0:%.*]] : $*NotClassBound, [[ARG1:%.*]] : $ClassBound & NotClassBound):
+// CHECK: [[X_OPENED:%.*]] = open_existential_ref [[ARG1]] : $ClassBound & NotClassBound to [[OPENED_TYPE:\$@opened(.*) ClassBound & NotClassBound]]
+// CHECK: [[PAYLOAD_ADDR:%.*]] = init_existential_addr [[ARG0]] : $*NotClassBound, [[OPENED_TYPE]]
+// CHECK: [[X_OPENED_COPY:%.*]] = copy_value [[X_OPENED]]
+// CHECK: store [[X_OPENED_COPY]] to [init] [[PAYLOAD_ADDR]]
+func class_bound_to_unbound_existential_upcast
+(x: ClassBound & NotClassBound) -> NotClassBound {
+ return x
+}
+
+// CHECK-LABEL: sil hidden @$Ss18class_bound_method1xys10ClassBound_p_tF :
+// CHECK: bb0([[ARG:%.*]] : $ClassBound):
+func class_bound_method(x: ClassBound) {
+ var x = x
+ x.classBoundMethod()
+ // CHECK: [[XBOX:%.*]] = alloc_box ${ var ClassBound }, var, name "x"
+ // CHECK: [[XBOX_PB:%.*]] = project_box [[XBOX]]
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: store [[ARG_COPY]] to [init] [[XBOX_PB]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[XBOX_PB]] : $*ClassBound
+ // CHECK: [[X:%.*]] = load [copy] [[READ]] : $*ClassBound
+ // CHECK: [[PROJ:%.*]] = open_existential_ref [[X]] : $ClassBound to $[[OPENED:@opened(.*) ClassBound]]
+ // CHECK: [[METHOD:%.*]] = witness_method $[[OPENED]], #ClassBound.classBoundMethod!1
+ // CHECK: apply [[METHOD]]<[[OPENED]]>([[PROJ]])
+ // CHECK: destroy_value [[PROJ]]
+ // CHECK: destroy_value [[XBOX]]
+}
+// CHECK: } // end sil function '$Ss18class_bound_method1xys10ClassBound_p_tF'
+
+// rdar://problem/31858378
+struct Value {}
+
+protocol HasMutatingMethod {
+ mutating func mutateMe()
+ var mutatingCounter: Value { get set }
+ var nonMutatingCounter: Value { get nonmutating set }
+}
+
+protocol InheritsMutatingMethod : class, HasMutatingMethod {}
+
+func takesInOut<T>(_: inout T) {}
+
+// CHECK-LABEL: sil hidden @$Ss27takesInheritsMutatingMethod1x1yys0bcD0_pz_s5ValueVtF : $@convention(thin) (@inout InheritsMutatingMethod, Value) -> () {
+func takesInheritsMutatingMethod(x: inout InheritsMutatingMethod,
+ y: Value) {
+ // CHECK: [[X_ADDR:%.*]] = begin_access [modify] [unknown] %0 : $*InheritsMutatingMethod
+ // CHECK-NEXT: [[X_VALUE:%.*]] = load [copy] [[X_ADDR]] : $*InheritsMutatingMethod
+ // CHECK-NEXT: [[X_PAYLOAD:%.*]] = open_existential_ref [[X_VALUE]] : $InheritsMutatingMethod to $@opened("{{.*}}") InheritsMutatingMethod
+ // CHECK-NEXT: [[TEMPORARY:%.*]] = alloc_stack $@opened("{{.*}}") InheritsMutatingMethod
+ // CHECK-NEXT: store [[X_PAYLOAD]] to [init] [[TEMPORARY]] : $*@opened("{{.*}}") InheritsMutatingMethod
+ // CHECK-NEXT: [[METHOD:%.*]] = witness_method $@opened("{{.*}}") InheritsMutatingMethod, #HasMutatingMethod.mutateMe!1 : <Self where Self : HasMutatingMethod> (inout Self) -> () -> (), [[X_PAYLOAD]] : $@opened("{{.*}}") InheritsMutatingMethod : $@convention(witness_method: HasMutatingMethod) <τ_0_0 where τ_0_0 : HasMutatingMethod> (@inout τ_0_0) -> ()
+ // CHECK-NEXT: apply [[METHOD]]<@opened("{{.*}}") InheritsMutatingMethod>([[TEMPORARY]]) : $@convention(witness_method: HasMutatingMethod) <τ_0_0 where τ_0_0 : HasMutatingMethod> (@inout τ_0_0) -> ()
+ // CHECK-NEXT: [[X_PAYLOAD:%.*]] = load [take] [[TEMPORARY]] : $*@opened("{{.*}}") InheritsMutatingMethod
+ // CHECK-NEXT: [[X_VALUE:%.*]] = init_existential_ref [[X_PAYLOAD]] : $@opened("{{.*}}") InheritsMutatingMethod : $@opened("{{.*}}") InheritsMutatingMethod, $InheritsMutatingMethod
+ // CHECK-NEXT: assign [[X_VALUE]] to [[X_ADDR]] : $*InheritsMutatingMethod
+ // CHECK-NEXT: end_access [[X_ADDR]] : $*InheritsMutatingMethod
+ // CHECK-NEXT: dealloc_stack [[TEMPORARY]] : $*@opened("{{.*}}") InheritsMutatingMethod
+ x.mutateMe()
+
+ // CHECK-NEXT: [[RESULT_BOX:%.*]] = alloc_stack $Value
+ // CHECK-NEXT: [[RESULT:%.*]] = mark_uninitialized [var] [[RESULT_BOX]] : $*Value
+ // CHECK-NEXT: [[X_ADDR:%.*]] = begin_access [read] [unknown] %0 : $*InheritsMutatingMethod
+ // CHECK-NEXT: [[X_VALUE:%.*]] = load [copy] [[X_ADDR]] : $*InheritsMutatingMethod
+ // CHECK-NEXT: [[X_PAYLOAD:%.*]] = open_existential_ref [[X_VALUE]] : $InheritsMutatingMethod to $@opened("{{.*}}") InheritsMutatingMethod
+ // CHECK-NEXT: [[TEMPORARY:%.*]] = alloc_stack $@opened("{{.*}}") InheritsMutatingMethod
+ // CHECK-NEXT: store [[X_PAYLOAD]] to [init] [[TEMPORARY]] : $*@opened("{{.*}}") InheritsMutatingMethod
+ // CHECK-NEXT: [[X_PAYLOAD_RELOADED:%.*]] = load_borrow [[TEMPORARY]]
+ //
+ // ** *NOTE* This extra copy is here since RValue invariants enforce that all
+ // ** loadable objects are actually loaded. So we form the RValue and
+ // ** load... only to then need to store the value back in a stack location to
+ // ** pass to an in_guaranteed method. PredictableMemOpts is able to handle this
+ // ** type of temporary codegen successfully.
+ // CHECK-NEXT: [[TEMPORARY_2:%.*]] = alloc_stack $@opened("{{.*}}") InheritsMutatingMethod
+ // CHECK-NEXT: store_borrow [[X_PAYLOAD_RELOADED:%.*]] to [[TEMPORARY_2]]
+ //
+ // CHECK-NEXT: [[METHOD:%.*]] = witness_method $@opened("{{.*}}") InheritsMutatingMethod, #HasMutatingMethod.mutatingCounter!getter.1 : <Self where Self : HasMutatingMethod> (Self) -> () -> Value, [[X_PAYLOAD]] : $@opened("{{.*}}") InheritsMutatingMethod : $@convention(witness_method: HasMutatingMethod) <τ_0_0 where τ_0_0 : HasMutatingMethod> (@in_guaranteed τ_0_0) -> Value
+ // CHECK-NEXT: [[RESULT_VALUE:%.*]] = apply [[METHOD]]<@opened("{{.*}}") InheritsMutatingMethod>([[TEMPORARY_2]]) : $@convention(witness_method: HasMutatingMethod) <τ_0_0 where τ_0_0 : HasMutatingMethod> (@in_guaranteed τ_0_0) -> Value
+ // CHECK-NEXT: dealloc_stack [[TEMPORARY_2]]
+ // CHECK-NEXT: end_borrow [[X_PAYLOAD_RELOADED]]
+ // CHECK-NEXT: assign [[RESULT_VALUE]] to [[RESULT]] : $*Value
+ // CHECK-NEXT: destroy_addr [[TEMPORARY]]
+ // CHECK-NEXT: end_access [[X_ADDR]]
+ // CHECK-NEXT: dealloc_stack [[TEMPORARY]] : $*@opened("{{.*}}") InheritsMutatingMethod
+ // CHECK-NEXT: dealloc_stack [[RESULT_BOX]] : $*Value
+ _ = x.mutatingCounter
+
+ // CHECK-NEXT: [[X_ADDR:%.*]] = begin_access [modify] [unknown] %0 : $*InheritsMutatingMethod
+ // CHECK-NEXT: [[X_VALUE:%.*]] = load [copy] [[X_ADDR]] : $*InheritsMutatingMethod
+ // CHECK-NEXT: [[X_PAYLOAD:%.*]] = open_existential_ref [[X_VALUE]] : $InheritsMutatingMethod to $@opened("{{.*}}") InheritsMutatingMethod
+ // CHECK-NEXT: [[TEMPORARY:%.*]] = alloc_stack $@opened("{{.*}}") InheritsMutatingMethod
+ // CHECK-NEXT: store [[X_PAYLOAD]] to [init] [[TEMPORARY]] : $*@opened("{{.*}}") InheritsMutatingMethod
+ // CHECK-NEXT: [[METHOD:%.*]] = witness_method $@opened("{{.*}}") InheritsMutatingMethod, #HasMutatingMethod.mutatingCounter!setter.1 : <Self where Self : HasMutatingMethod> (inout Self) -> (Value) -> (), [[X_PAYLOAD]] : $@opened("{{.*}}") InheritsMutatingMethod : $@convention(witness_method: HasMutatingMethod) <τ_0_0 where τ_0_0 : HasMutatingMethod> (Value, @inout τ_0_0) -> ()
+ // CHECK-NEXT: apply [[METHOD]]<@opened("{{.*}}") InheritsMutatingMethod>(%1, [[TEMPORARY]]) : $@convention(witness_method: HasMutatingMethod) <τ_0_0 where τ_0_0 : HasMutatingMethod> (Value, @inout τ_0_0) -> ()
+ // CHECK-NEXT: [[X_PAYLOAD:%.*]] = load [take] [[TEMPORARY]] : $*@opened("{{.*}}") InheritsMutatingMethod
+ // CHECK-NEXT: [[X_VALUE:%.*]] = init_existential_ref [[X_PAYLOAD]] : $@opened("{{.*}}") InheritsMutatingMethod : $@opened("{{.*}}") InheritsMutatingMethod, $InheritsMutatingMethod
+ // CHECK-NEXT: assign [[X_VALUE]] to [[X_ADDR]] : $*InheritsMutatingMethod
+ // CHECK-NEXT: end_access [[X_ADDR]] : $*InheritsMutatingMethod
+ // CHECK-NEXT: dealloc_stack [[TEMPORARY]] : $*@opened("{{.*}}") InheritsMutatingMethod
+ x.mutatingCounter = y
+
+ takesInOut(&x.mutatingCounter)
+
+ _ = x.nonMutatingCounter
+ x.nonMutatingCounter = y
+ takesInOut(&x.nonMutatingCounter)
+}
diff --git a/test/SILGen/plus_zero_class_resilience.swift b/test/SILGen/plus_zero_class_resilience.swift
new file mode 100644
index 0000000..5421688
--- /dev/null
+++ b/test/SILGen/plus_zero_class_resilience.swift
@@ -0,0 +1,48 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_struct.swiftmodule -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
+// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_class.swiftmodule -module-name=resilient_class -I %t %S/../Inputs/resilient_class.swift
+// RUN: %target-swift-frontend -I %t -emit-silgen -enable-sil-ownership -enable-resilience %s | %FileCheck %s
+
+import resilient_class
+
+// Accessing final property of resilient class from different resilience domain
+// through accessor
+
+// CHECK-LABEL: sil @$S16class_resilience20finalPropertyOfOtheryy010resilient_A022ResilientOutsideParentCF
+// CHECK: function_ref @$S15resilient_class22ResilientOutsideParentC13finalPropertySSvg
+
+public func finalPropertyOfOther(_ other: ResilientOutsideParent) {
+ _ = other.finalProperty
+}
+
+public class MyResilientClass {
+ public final var finalProperty: String = "MyResilientClass.finalProperty"
+}
+
+// Accessing final property of resilient class from my resilience domain
+// directly
+
+// CHECK-LABEL: sil @$S16class_resilience19finalPropertyOfMineyyAA16MyResilientClassCF
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $MyResilientClass):
+// CHECK: ref_element_addr [[ARG]] : $MyResilientClass, #MyResilientClass.finalProperty
+// CHECK: } // end sil function '$S16class_resilience19finalPropertyOfMineyyAA16MyResilientClassCF'
+
+public func finalPropertyOfMine(_ other: MyResilientClass) {
+ _ = other.finalProperty
+}
+
+class SubclassOfOutsideChild : ResilientOutsideChild {
+ override func method() {}
+
+ func newMethod() {}
+}
+
+// Note: no entries for [inherited] methods
+
+// CHECK-LABEL: sil_vtable SubclassOfOutsideChild {
+// CHECK-NEXT: #ResilientOutsideParent.init!initializer.1: (ResilientOutsideParent.Type) -> () -> ResilientOutsideParent : @$S16class_resilience22SubclassOfOutsideChildCACycfc [override]
+// CHECK-NEXT: #ResilientOutsideParent.method!1: (ResilientOutsideParent) -> () -> () : @$S16class_resilience22SubclassOfOutsideChildC6methodyyF [override]
+// CHECK-NEXT: #SubclassOfOutsideChild.newMethod!1: (SubclassOfOutsideChild) -> () -> () : @$S16class_resilience22SubclassOfOutsideChildC9newMethodyyF
+// CHECK-NEXT: #SubclassOfOutsideChild.deinit!deallocator: @$S16class_resilience22SubclassOfOutsideChildCfD
+// CHECK-NEXT: }
diff --git a/test/SILGen/plus_zero_closures.swift b/test/SILGen/plus_zero_closures.swift
new file mode 100644
index 0000000..2442f4b
--- /dev/null
+++ b/test/SILGen/plus_zero_closures.swift
@@ -0,0 +1,792 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -parse-as-library -emit-silgen %s | %FileCheck %s
+// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -parse-as-library -emit-silgen %s | %FileCheck %s --check-prefix=GUARANTEED
+
+import Swift
+
+var zero = 0
+
+// <rdar://problem/15921334>
+// CHECK-LABEL: sil hidden @$S8closures46return_local_generic_function_without_captures{{[_0-9a-zA-Z]*}}F : $@convention(thin) <A, R> () -> @owned @callee_guaranteed (@in_guaranteed A) -> @out R {
+func return_local_generic_function_without_captures<A, R>() -> (A) -> R {
+ func f(_: A) -> R {
+ Builtin.int_trap()
+ }
+ // CHECK: [[FN:%.*]] = function_ref @$S8closures46return_local_generic_function_without_captures{{[_0-9a-zA-Z]*}} : $@convention(thin) <τ_0_0, τ_0_1> (@in_guaranteed τ_0_0) -> @out τ_0_1
+ // CHECK: [[FN_WITH_GENERIC_PARAMS:%.*]] = partial_apply [callee_guaranteed] [[FN]]<A, R>() : $@convention(thin) <τ_0_0, τ_0_1> (@in_guaranteed τ_0_0) -> @out τ_0_1
+ // CHECK: return [[FN_WITH_GENERIC_PARAMS]] : $@callee_guaranteed (@in_guaranteed A) -> @out R
+ return f
+}
+
+func return_local_generic_function_with_captures<A, R>(_ a: A) -> (A) -> R {
+ func f(_: A) -> R {
+ _ = a
+ }
+
+ return f
+}
+
+// CHECK-LABEL: sil hidden @$S8closures17read_only_captureyS2iF : $@convention(thin) (Int) -> Int {
+func read_only_capture(_ x: Int) -> Int {
+ var x = x
+ // CHECK: bb0([[X:%[0-9]+]] : @trivial $Int):
+ // CHECK: [[XBOX:%[0-9]+]] = alloc_box ${ var Int }
+ // SEMANTIC ARC TODO: This is incorrect. We need to do the project_box on the copy.
+ // CHECK: [[PROJECT:%.*]] = project_box [[XBOX]]
+ // CHECK: store [[X]] to [trivial] [[PROJECT]]
+
+ func cap() -> Int {
+ return x
+ }
+
+ return cap()
+ // CHECK: [[XBOX_BORROW:%.*]] = begin_borrow [[XBOX]]
+ // SEMANTIC ARC TODO: See above. This needs to happen on the copy_valued box.
+ // CHECK: mark_function_escape [[PROJECT]]
+ // CHECK: [[CAP:%[0-9]+]] = function_ref @[[CAP_NAME:\$S8closures17read_only_capture.*]] : $@convention(thin) (@guaranteed { var Int }) -> Int
+ // CHECK: [[RET:%[0-9]+]] = apply [[CAP]]([[XBOX_BORROW]])
+ // CHECK: end_borrow [[XBOX_BORROW]]
+ // CHECK: destroy_value [[XBOX]]
+ // CHECK: return [[RET]]
+}
+// CHECK: } // end sil function '$S8closures17read_only_captureyS2iF'
+
+// CHECK: sil private @[[CAP_NAME]]
+// CHECK: bb0([[XBOX:%[0-9]+]] : @guaranteed ${ var Int }):
+// CHECK: [[XADDR:%[0-9]+]] = project_box [[XBOX]]
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [unknown] [[XADDR]] : $*Int
+// CHECK: [[X:%[0-9]+]] = load [trivial] [[ACCESS]]
+// CHECK: return [[X]]
+// } // end sil function '[[CAP_NAME]]'
+
+// SEMANTIC ARC TODO: This is a place where we have again project_box too early.
+// CHECK-LABEL: sil hidden @$S8closures16write_to_captureyS2iF : $@convention(thin) (Int) -> Int {
+func write_to_capture(_ x: Int) -> Int {
+ var x = x
+ // CHECK: bb0([[X:%[0-9]+]] : @trivial $Int):
+ // CHECK: [[XBOX:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[XBOX_PB:%.*]] = project_box [[XBOX]]
+ // CHECK: store [[X]] to [trivial] [[XBOX_PB]]
+ // CHECK: [[X2BOX:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[X2BOX_PB:%.*]] = project_box [[X2BOX]]
+ // CHECK: [[ACCESS:%.*]] = begin_access [read] [unknown] [[XBOX_PB]] : $*Int
+ // CHECK: copy_addr [[ACCESS]] to [initialization] [[X2BOX_PB]]
+ // CHECK: [[X2BOX_BORROW:%.*]] = begin_borrow [[X2BOX]]
+ // SEMANTIC ARC TODO: This next mark_function_escape should be on a projection from X2BOX_BORROW.
+ // CHECK: mark_function_escape [[X2BOX_PB]]
+ var x2 = x
+
+ func scribble() {
+ x2 = zero
+ }
+
+ scribble()
+ // CHECK: [[SCRIB:%[0-9]+]] = function_ref @[[SCRIB_NAME:\$S8closures16write_to_capture.*]] : $@convention(thin) (@guaranteed { var Int }) -> ()
+ // CHECK: apply [[SCRIB]]([[X2BOX_BORROW]])
+ // SEMANTIC ARC TODO: This should load from X2BOX_BORROW project. There is an
+ // issue here where after a copy_value, we need to reassign a projection in
+ // some way.
+ // CHECK: [[ACCESS:%.*]] = begin_access [read] [unknown] [[X2BOX_PB]] : $*Int
+ // CHECK: [[RET:%[0-9]+]] = load [trivial] [[ACCESS]]
+ // CHECK: destroy_value [[X2BOX]]
+ // CHECK: destroy_value [[XBOX]]
+ // CHECK: return [[RET]]
+ return x2
+}
+// CHECK: } // end sil function '$S8closures16write_to_captureyS2iF'
+
+// CHECK: sil private @[[SCRIB_NAME]]
+// CHECK: bb0([[XBOX:%[0-9]+]] : @guaranteed ${ var Int }):
+// CHECK: [[XADDR:%[0-9]+]] = project_box [[XBOX]]
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [unknown] [[XADDR]] : $*Int
+// CHECK: assign {{%[0-9]+}} to [[ACCESS]]
+// CHECK: return
+// CHECK: } // end sil function '[[SCRIB_NAME]]'
+
+// CHECK-LABEL: sil hidden @$S8closures21multiple_closure_refs{{[_0-9a-zA-Z]*}}F
+func multiple_closure_refs(_ x: Int) -> (() -> Int, () -> Int) {
+ var x = x
+ func cap() -> Int {
+ return x
+ }
+
+ return (cap, cap)
+ // CHECK: [[CAP:%[0-9]+]] = function_ref @[[CAP_NAME:\$S8closures21multiple_closure_refs.*]] : $@convention(thin) (@guaranteed { var Int }) -> Int
+ // CHECK: [[CAP_CLOSURE_1:%[0-9]+]] = partial_apply [callee_guaranteed] [[CAP]]
+ // CHECK: [[CAP:%[0-9]+]] = function_ref @[[CAP_NAME:\$S8closures21multiple_closure_refs.*]] : $@convention(thin) (@guaranteed { var Int }) -> Int
+ // CHECK: [[CAP_CLOSURE_2:%[0-9]+]] = partial_apply [callee_guaranteed] [[CAP]]
+ // CHECK: [[RET:%[0-9]+]] = tuple ([[CAP_CLOSURE_1]] : {{.*}}, [[CAP_CLOSURE_2]] : {{.*}})
+ // CHECK: return [[RET]]
+}
+
+// CHECK-LABEL: sil hidden @$S8closures18capture_local_funcySiycycSiF : $@convention(thin) (Int) -> @owned @callee_guaranteed () -> @owned @callee_guaranteed () -> Int {
+func capture_local_func(_ x: Int) -> () -> () -> Int {
+ // CHECK: bb0([[ARG:%.*]] : @trivial $Int):
+ var x = x
+ // CHECK: [[XBOX:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[XBOX_PB:%.*]] = project_box [[XBOX]]
+ // CHECK: store [[ARG]] to [trivial] [[XBOX_PB]]
+
+ func aleph() -> Int { return x }
+
+ func beth() -> () -> Int { return aleph }
+ // CHECK: [[BETH_REF:%.*]] = function_ref @[[BETH_NAME:\$S8closures18capture_local_funcySiycycSiF4bethL_SiycyF]] : $@convention(thin) (@guaranteed { var Int }) -> @owned @callee_guaranteed () -> Int
+ // CHECK: [[XBOX_COPY:%.*]] = copy_value [[XBOX]]
+ // SEMANTIC ARC TODO: This is incorrect. This should be a project_box from XBOX_COPY.
+ // CHECK: mark_function_escape [[XBOX_PB]]
+ // CHECK: [[BETH_CLOSURE:%[0-9]+]] = partial_apply [callee_guaranteed] [[BETH_REF]]([[XBOX_COPY]])
+
+ return beth
+ // CHECK: destroy_value [[XBOX]]
+ // CHECK: return [[BETH_CLOSURE]]
+}
+// CHECK: } // end sil function '$S8closures18capture_local_funcySiycycSiF'
+
+// CHECK: sil private @[[ALEPH_NAME:\$S8closures18capture_local_funcySiycycSiF5alephL_SiyF]] : $@convention(thin) (@guaranteed { var Int }) -> Int {
+// CHECK: bb0([[XBOX:%[0-9]+]] : @guaranteed ${ var Int }):
+
+// CHECK: sil private @[[BETH_NAME]] : $@convention(thin) (@guaranteed { var Int }) -> @owned @callee_guaranteed () -> Int {
+// CHECK: bb0([[XBOX:%[0-9]+]] : @guaranteed ${ var Int }):
+// CHECK: [[XBOX_PB:%.*]] = project_box [[XBOX]]
+// CHECK: [[ALEPH_REF:%[0-9]+]] = function_ref @[[ALEPH_NAME]] : $@convention(thin) (@guaranteed { var Int }) -> Int
+// CHECK: [[XBOX_COPY:%.*]] = copy_value [[XBOX]]
+// SEMANTIC ARC TODO: This should be on a PB from XBOX_COPY.
+// CHECK: mark_function_escape [[XBOX_PB]]
+// CHECK: [[ALEPH_CLOSURE:%[0-9]+]] = partial_apply [callee_guaranteed] [[ALEPH_REF]]([[XBOX_COPY]])
+// CHECK: return [[ALEPH_CLOSURE]]
+// CHECK: } // end sil function '[[BETH_NAME]]'
+
+// CHECK-LABEL: sil hidden @$S8closures22anon_read_only_capture{{[_0-9a-zA-Z]*}}F
+func anon_read_only_capture(_ x: Int) -> Int {
+ var x = x
+ // CHECK: bb0([[X:%[0-9]+]] : @trivial $Int):
+ // CHECK: [[XBOX:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[PB:%.*]] = project_box [[XBOX]]
+
+ return ({ x })()
+ // -- func expression
+ // CHECK: [[ANON:%[0-9]+]] = function_ref @[[CLOSURE_NAME:\$S8closures22anon_read_only_capture[_0-9a-zA-Z]*]] : $@convention(thin) (@inout_aliasable Int) -> Int
+ // -- apply expression
+ // CHECK: [[RET:%[0-9]+]] = apply [[ANON]]([[PB]])
+ // -- cleanup
+ // CHECK: destroy_value [[XBOX]]
+ // CHECK: return [[RET]]
+}
+// CHECK: sil private @[[CLOSURE_NAME]]
+// CHECK: bb0([[XADDR:%[0-9]+]] : @trivial $*Int):
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [unknown] [[XADDR]] : $*Int
+// CHECK: [[X:%[0-9]+]] = load [trivial] [[ACCESS]]
+// CHECK: return [[X]]
+
+// CHECK-LABEL: sil hidden @$S8closures21small_closure_capture{{[_0-9a-zA-Z]*}}F
+func small_closure_capture(_ x: Int) -> Int {
+ var x = x
+ // CHECK: bb0([[X:%[0-9]+]] : @trivial $Int):
+ // CHECK: [[XBOX:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[PB:%.*]] = project_box [[XBOX]]
+
+ return { x }()
+ // -- func expression
+ // CHECK: [[ANON:%[0-9]+]] = function_ref @[[CLOSURE_NAME:\$S8closures21small_closure_capture[_0-9a-zA-Z]*]] : $@convention(thin) (@inout_aliasable Int) -> Int
+ // -- apply expression
+ // CHECK: [[RET:%[0-9]+]] = apply [[ANON]]([[PB]])
+ // -- cleanup
+ // CHECK: destroy_value [[XBOX]]
+ // CHECK: return [[RET]]
+}
+// CHECK: sil private @[[CLOSURE_NAME]]
+// CHECK: bb0([[XADDR:%[0-9]+]] : @trivial $*Int):
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [unknown] [[XADDR]] : $*Int
+// CHECK: [[X:%[0-9]+]] = load [trivial] [[ACCESS]]
+// CHECK: return [[X]]
+
+
+// CHECK-LABEL: sil hidden @$S8closures35small_closure_capture_with_argument{{[_0-9a-zA-Z]*}}F
+func small_closure_capture_with_argument(_ x: Int) -> (_ y: Int) -> Int {
+ var x = x
+ // CHECK: [[XBOX:%[0-9]+]] = alloc_box ${ var Int }
+
+ return { x + $0 }
+ // -- func expression
+ // CHECK: [[ANON:%[0-9]+]] = function_ref @[[CLOSURE_NAME:\$S8closures35small_closure_capture_with_argument.*]] : $@convention(thin) (Int, @guaranteed { var Int }) -> Int
+ // CHECK: [[XBOX_COPY:%.*]] = copy_value [[XBOX]]
+ // CHECK: [[ANON_CLOSURE_APP:%[0-9]+]] = partial_apply [callee_guaranteed] [[ANON]]([[XBOX_COPY]])
+ // -- return
+ // CHECK: destroy_value [[XBOX]]
+ // CHECK: return [[ANON_CLOSURE_APP]]
+}
+// FIXME(integers): the following checks should be updated for the new way +
+// gets invoked. <rdar://problem/29939484>
+// XCHECK: sil private @[[CLOSURE_NAME]] : $@convention(thin) (Int, @guaranteed { var Int }) -> Int
+// XCHECK: bb0([[DOLLAR0:%[0-9]+]] : $Int, [[XBOX:%[0-9]+]] : ${ var Int }):
+// XCHECK: [[XADDR:%[0-9]+]] = project_box [[XBOX]]
+// XCHECK: [[PLUS:%[0-9]+]] = function_ref @$Ss1poiS2i_SitF{{.*}}
+// XCHECK: [[LHS:%[0-9]+]] = load [trivial] [[XADDR]]
+// XCHECK: [[RET:%[0-9]+]] = apply [[PLUS]]([[LHS]], [[DOLLAR0]])
+// XCHECK: destroy_value [[XBOX]]
+// XCHECK: return [[RET]]
+
+// CHECK-LABEL: sil hidden @$S8closures24small_closure_no_capture{{[_0-9a-zA-Z]*}}F
+func small_closure_no_capture() -> (_ y: Int) -> Int {
+ // CHECK: [[ANON:%[0-9]+]] = function_ref @[[CLOSURE_NAME:\$S8closures24small_closure_no_captureS2icyFS2icfU_]] : $@convention(thin) (Int) -> Int
+ // CHECK: [[ANON_THICK:%[0-9]+]] = thin_to_thick_function [[ANON]] : ${{.*}} to $@callee_guaranteed (Int) -> Int
+ // CHECK: return [[ANON_THICK]]
+ return { $0 }
+}
+// CHECK: sil private @[[CLOSURE_NAME]] : $@convention(thin) (Int) -> Int
+// CHECK: bb0([[YARG:%[0-9]+]] : @trivial $Int):
+
+// CHECK-LABEL: sil hidden @$S8closures17uncaptured_locals{{[_0-9a-zA-Z]*}}F :
+func uncaptured_locals(_ x: Int) -> (Int, Int) {
+ var x = x
+ // -- locals without captures are stack-allocated
+ // CHECK: bb0([[XARG:%[0-9]+]] : @trivial $Int):
+ // CHECK: [[XADDR:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[PB:%.*]] = project_box [[XADDR]]
+ // CHECK: store [[XARG]] to [trivial] [[PB]]
+
+ var y = zero
+ // CHECK: [[YADDR:%[0-9]+]] = alloc_box ${ var Int }
+ return (x, y)
+
+}
+
+class SomeClass {
+ var x : Int = zero
+
+ init() {
+ x = { self.x }() // Closing over self.
+ }
+}
+
+// Closures within destructors <rdar://problem/15883734>
+class SomeGenericClass<T> {
+ deinit {
+ var i: Int = zero
+ // CHECK: [[C1REF:%[0-9]+]] = function_ref @$S8closures16SomeGenericClassCfdSiyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> Int
+ // CHECK: apply [[C1REF]]([[IBOX:%[0-9]+]]) : $@convention(thin) (@inout_aliasable Int) -> Int
+ var x = { i + zero } ()
+
+ // CHECK: [[C2REF:%[0-9]+]] = function_ref @$S8closures16SomeGenericClassCfdSiyXEfU0_ : $@convention(thin) () -> Int
+ // CHECK: apply [[C2REF]]() : $@convention(thin) () -> Int
+ var y = { zero } ()
+
+ // CHECK: [[C3REF:%[0-9]+]] = function_ref @$S8closures16SomeGenericClassCfdyyXEfU1_ : $@convention(thin) <τ_0_0> () -> ()
+ // CHECK: apply [[C3REF]]<T>() : $@convention(thin) <τ_0_0> () -> ()
+ var z = { _ = T.self } ()
+ }
+
+ // CHECK-LABEL: sil private @$S8closures16SomeGenericClassCfdSiyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> Int
+
+ // CHECK-LABEL: sil private @$S8closures16SomeGenericClassCfdSiyXEfU0_ : $@convention(thin) () -> Int
+
+ // CHECK-LABEL: sil private @$S8closures16SomeGenericClassCfdyyXEfU1_ : $@convention(thin) <T> () -> ()
+}
+
+// This is basically testing that the constraint system ranking
+// function conversions as worse than others, and therefore performs
+// the conversion within closures when possible.
+class SomeSpecificClass : SomeClass {}
+func takesSomeClassGenerator(_ fn : () -> SomeClass) {}
+func generateWithConstant(_ x : SomeSpecificClass) {
+ takesSomeClassGenerator({ x })
+}
+
+// CHECK-LABEL: sil private @$S8closures20generateWithConstantyyAA17SomeSpecificClassCFAA0eG0CyXEfU_ : $@convention(thin) (@guaranteed SomeSpecificClass) -> @owned SomeClass {
+// CHECK: bb0([[T0:%.*]] : @guaranteed $SomeSpecificClass):
+// CHECK: debug_value [[T0]] : $SomeSpecificClass, let, name "x", argno 1
+// CHECK: [[T0_COPY:%.*]] = copy_value [[T0]]
+// CHECK: [[T0_COPY_CASTED:%.*]] = upcast [[T0_COPY]] : $SomeSpecificClass to $SomeClass
+// CHECK: return [[T0_COPY_CASTED]]
+// CHECK: } // end sil function '$S8closures20generateWithConstantyyAA17SomeSpecificClassCFAA0eG0CyXEfU_'
+
+
+// Check the annoying case of capturing 'self' in a derived class 'init'
+// method. We allocate a mutable box to deal with 'self' potentially being
+// rebound by super.init, but 'self' is formally immutable and so is captured
+// by value. <rdar://problem/15599464>
+class Base {}
+
+class SelfCapturedInInit : Base {
+ var foo : () -> SelfCapturedInInit
+
+ // CHECK-LABEL: sil hidden @$S8closures18SelfCapturedInInitC{{[_0-9a-zA-Z]*}}fc : $@convention(method) (@owned SelfCapturedInInit) -> @owned SelfCapturedInInit {
+ // CHECK: bb0([[SELF:%.*]] : @owned $SelfCapturedInInit):
+ //
+ // First create our initial value for self.
+ // CHECK: [[SELF_BOX:%.*]] = alloc_box ${ var SelfCapturedInInit }, let, name "self"
+ // CHECK: [[UNINIT_SELF:%.*]] = mark_uninitialized [derivedself] [[SELF_BOX]]
+ // CHECK: [[PB_SELF_BOX:%.*]] = project_box [[UNINIT_SELF]]
+ // CHECK: store [[SELF]] to [init] [[PB_SELF_BOX]]
+ //
+ // Then perform the super init sequence.
+ // CHECK: [[TAKEN_SELF:%.*]] = load [take] [[PB_SELF_BOX]]
+ // CHECK: [[UPCAST_TAKEN_SELF:%.*]] = upcast [[TAKEN_SELF]]
+ // CHECK: [[NEW_SELF:%.*]] = apply {{.*}}([[UPCAST_TAKEN_SELF]]) : $@convention(method) (@owned Base) -> @owned Base
+ // CHECK: [[DOWNCAST_NEW_SELF:%.*]] = unchecked_ref_cast [[NEW_SELF]] : $Base to $SelfCapturedInInit
+ // CHECK: store [[DOWNCAST_NEW_SELF]] to [init] [[PB_SELF_BOX]]
+ //
+ // Finally put self in the closure.
+ // CHECK: [[BORROWED_SELF:%.*]] = load_borrow [[PB_SELF_BOX]]
+ // CHECK: [[COPIED_SELF:%.*]] = load [copy] [[PB_SELF_BOX]]
+ // CHECK: [[FOO_VALUE:%.*]] = partial_apply [callee_guaranteed] {{%.*}}([[COPIED_SELF]]) : $@convention(thin) (@guaranteed SelfCapturedInInit) -> @owned SelfCapturedInInit
+ // CHECK: [[FOO_LOCATION:%.*]] = ref_element_addr [[BORROWED_SELF]]
+ // CHECK: [[ACCESS:%.*]] = begin_access [modify] [dynamic] [[FOO_LOCATION]] : $*@callee_guaranteed () -> @owned SelfCapturedInInit
+ // CHECK: assign [[FOO_VALUE]] to [[ACCESS]]
+ override init() {
+ super.init()
+ foo = { self }
+ }
+}
+
+func takeClosure(_ fn: () -> Int) -> Int { return fn() }
+
+class TestCaptureList {
+ var x = zero
+
+ func testUnowned() {
+ let aLet = self
+ takeClosure { aLet.x }
+ takeClosure { [unowned aLet] in aLet.x }
+ takeClosure { [weak aLet] in aLet!.x }
+
+ var aVar = self
+ takeClosure { aVar.x }
+ takeClosure { [unowned aVar] in aVar.x }
+ takeClosure { [weak aVar] in aVar!.x }
+
+ takeClosure { self.x }
+ takeClosure { [unowned self] in self.x }
+ takeClosure { [weak self] in self!.x }
+
+ takeClosure { [unowned newVal = TestCaptureList()] in newVal.x }
+ takeClosure { [weak newVal = TestCaptureList()] in newVal!.x }
+ }
+}
+
+class ClassWithIntProperty { final var x = 42 }
+
+func closeOverLetLValue() {
+ let a : ClassWithIntProperty
+ a = ClassWithIntProperty()
+
+ takeClosure { a.x }
+}
+
+// The let property needs to be captured into a temporary stack slot so that it
+// is loadable even though we capture the value.
+// CHECK-LABEL: sil private @$S8closures18closeOverLetLValueyyFSiyXEfU_ : $@convention(thin) (@guaranteed ClassWithIntProperty) -> Int {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $ClassWithIntProperty):
+// CHECK: [[TMP_CLASS_ADDR:%.*]] = alloc_stack $ClassWithIntProperty, let, name "a", argno 1
+// CHECK: [[COPY_ARG:%.*]] = copy_value [[ARG]]
+// CHECK: store [[COPY_ARG]] to [init] [[TMP_CLASS_ADDR]] : $*ClassWithIntProperty
+// CHECK: [[LOADED_CLASS:%.*]] = load [copy] [[TMP_CLASS_ADDR]] : $*ClassWithIntProperty
+// CHECK: [[BORROWED_LOADED_CLASS:%.*]] = begin_borrow [[LOADED_CLASS]]
+// CHECK: [[INT_IN_CLASS_ADDR:%.*]] = ref_element_addr [[BORROWED_LOADED_CLASS]] : $ClassWithIntProperty, #ClassWithIntProperty.x
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [dynamic] [[INT_IN_CLASS_ADDR]] : $*Int
+// CHECK: [[INT_IN_CLASS:%.*]] = load [trivial] [[ACCESS]] : $*Int
+// CHECK: end_borrow [[BORROWED_LOADED_CLASS]] from [[LOADED_CLASS]]
+// CHECK: destroy_value [[LOADED_CLASS]]
+// CHECK: destroy_addr [[TMP_CLASS_ADDR]] : $*ClassWithIntProperty
+// CHECK: dealloc_stack %1 : $*ClassWithIntProperty
+// CHECK: return [[INT_IN_CLASS]]
+// CHECK: } // end sil function '$S8closures18closeOverLetLValueyyFSiyXEfU_'
+
+// GUARANTEED-LABEL: sil private @$S8closures18closeOverLetLValueyyFSiyXEfU_ : $@convention(thin) (@guaranteed ClassWithIntProperty) -> Int {
+// GUARANTEED: bb0(%0 : @guaranteed $ClassWithIntProperty):
+// GUARANTEED: [[TMP:%.*]] = alloc_stack $ClassWithIntProperty
+// GUARANTEED: [[COPY:%.*]] = copy_value %0 : $ClassWithIntProperty
+// GUARANTEED: store [[COPY]] to [init] [[TMP]] : $*ClassWithIntProperty
+// GUARANTEED: [[LOADED_COPY:%.*]] = load [copy] [[TMP]]
+// GUARANTEED: [[BORROWED:%.*]] = begin_borrow [[LOADED_COPY]]
+// GUARANTEED: end_borrow [[BORROWED]] from [[LOADED_COPY]]
+// GUARANTEED: destroy_value [[LOADED_COPY]]
+// GUARANTEED: destroy_addr [[TMP]]
+// GUARANTEED: } // end sil function '$S8closures18closeOverLetLValueyyFSiyXEfU_'
+
+
+// Use an external function so inout deshadowing cannot see its body.
+@_silgen_name("takesNoEscapeClosure")
+func takesNoEscapeClosure(fn : () -> Int)
+
+struct StructWithMutatingMethod {
+ var x = 42
+
+ mutating func mutatingMethod() {
+ // This should not capture the refcount of the self shadow.
+ takesNoEscapeClosure { x = 42; return x }
+ }
+}
+
+// Check that the address of self is passed in, but not the refcount pointer.
+
+// CHECK-LABEL: sil hidden @$S8closures24StructWithMutatingMethodV08mutatingE0{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0(%0 : @trivial $*StructWithMutatingMethod):
+// CHECK: [[CLOSURE:%[0-9]+]] = function_ref @$S8closures24StructWithMutatingMethodV08mutatingE0{{.*}} : $@convention(thin) (@inout_aliasable StructWithMutatingMethod) -> Int
+// CHECK: partial_apply [callee_guaranteed] [[CLOSURE]](%0) : $@convention(thin) (@inout_aliasable StructWithMutatingMethod) -> Int
+
+// Check that the closure body only takes the pointer.
+// CHECK-LABEL: sil private @$S8closures24StructWithMutatingMethodV08mutatingE0{{.*}} : $@convention(thin) (@inout_aliasable StructWithMutatingMethod) -> Int {
+// CHECK: bb0(%0 : @trivial $*StructWithMutatingMethod):
+
+class SuperBase {
+ func boom() {}
+}
+class SuperSub : SuperBase {
+ override func boom() {}
+
+ // CHECK-LABEL: sil hidden @$S8closures8SuperSubC1ayyF : $@convention(method) (@guaranteed SuperSub) -> () {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[INNER:%.*]] = function_ref @[[INNER_FUNC_1:\$S8closures8SuperSubC1a[_0-9a-zA-Z]*]] : $@convention(thin) (@guaranteed SuperSub) -> ()
+ // CHECK: apply [[INNER]]([[SELF]])
+ // CHECK: } // end sil function '$S8closures8SuperSubC1ayyF'
+ func a() {
+ // CHECK: sil private @[[INNER_FUNC_1]] : $@convention(thin) (@guaranteed SuperSub) -> () {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[CLASS_METHOD:%.*]] = class_method [[ARG]] : $SuperSub, #SuperSub.boom!1
+ // CHECK: = apply [[CLASS_METHOD]]([[ARG]])
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: [[ARG_COPY_SUPER:%.*]] = upcast [[ARG_COPY]] : $SuperSub to $SuperBase
+ // CHECK: [[BORROWED_ARG_COPY_SUPER:%.*]] = begin_borrow [[ARG_COPY_SUPER]]
+ // CHECK: [[SUPER_METHOD:%[0-9]+]] = function_ref @$S8closures9SuperBaseC4boomyyF : $@convention(method) (@guaranteed SuperBase) -> ()
+ // CHECK: = apply [[SUPER_METHOD]]([[BORROWED_ARG_COPY_SUPER]])
+ // CHECK: destroy_value [[ARG_COPY_SUPER]]
+ // CHECK: } // end sil function '[[INNER_FUNC_1]]'
+ func a1() {
+ self.boom()
+ super.boom()
+ }
+ a1()
+ }
+
+ // CHECK-LABEL: sil hidden @$S8closures8SuperSubC1byyF : $@convention(method) (@guaranteed SuperSub) -> () {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[INNER:%.*]] = function_ref @[[INNER_FUNC_1:\$S8closures8SuperSubC1b[_0-9a-zA-Z]*]] : $@convention(thin) (@guaranteed SuperSub) -> ()
+ // CHECK: = apply [[INNER]]([[SELF]])
+ // CHECK: } // end sil function '$S8closures8SuperSubC1byyF'
+ func b() {
+ // CHECK: sil private @[[INNER_FUNC_1]] : $@convention(thin) (@guaranteed SuperSub) -> () {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[INNER:%.*]] = function_ref @[[INNER_FUNC_2:\$S8closures8SuperSubC1b.*]] : $@convention(thin) (@guaranteed SuperSub) -> ()
+ // CHECK: = apply [[INNER]]([[ARG]])
+ // CHECK: } // end sil function '[[INNER_FUNC_1]]'
+ func b1() {
+ // CHECK: sil private @[[INNER_FUNC_2]] : $@convention(thin) (@guaranteed SuperSub) -> () {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[CLASS_METHOD:%.*]] = class_method [[ARG]] : $SuperSub, #SuperSub.boom!1
+ // CHECK: = apply [[CLASS_METHOD]]([[ARG]]) : $@convention(method) (@guaranteed SuperSub) -> ()
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: [[ARG_COPY_SUPER:%.*]] = upcast [[ARG_COPY]] : $SuperSub to $SuperBase
+ // CHECK: [[BORROWED_ARG_COPY_SUPER:%.*]] = begin_borrow [[ARG_COPY_SUPER]]
+ // CHECK: [[SUPER_METHOD:%.*]] = function_ref @$S8closures9SuperBaseC4boomyyF : $@convention(method) (@guaranteed SuperBase) -> ()
+ // CHECK: = apply [[SUPER_METHOD]]([[BORROWED_ARG_COPY_SUPER]]) : $@convention(method) (@guaranteed SuperBase)
+ // CHECK: destroy_value [[ARG_COPY_SUPER]]
+ // CHECK: } // end sil function '[[INNER_FUNC_2]]'
+ func b2() {
+ self.boom()
+ super.boom()
+ }
+ b2()
+ }
+ b1()
+ }
+
+ // CHECK-LABEL: sil hidden @$S8closures8SuperSubC1cyyF : $@convention(method) (@guaranteed SuperSub) -> () {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[INNER:%.*]] = function_ref @[[INNER_FUNC_1:\$S8closures8SuperSubC1c[_0-9a-zA-Z]*]] : $@convention(thin) (@guaranteed SuperSub) -> ()
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[INNER]]([[SELF_COPY]])
+ // CHECK: [[BORROWED_PA:%.*]] = begin_borrow [[PA]]
+ // CHECK: [[PA_COPY:%.*]] = copy_value [[BORROWED_PA]]
+ // CHECK: [[B:%.*]] = begin_borrow [[PA_COPY]]
+ // CHECK: apply [[B]]()
+ // CHECK: end_borrow [[B]]
+ // CHECK: destroy_value [[PA_COPY]]
+ // CHECK: end_borrow [[BORROWED_PA]] from [[PA]]
+ // CHECK: destroy_value [[PA]]
+ // CHECK: } // end sil function '$S8closures8SuperSubC1cyyF'
+ func c() {
+ // CHECK: sil private @[[INNER_FUNC_1]] : $@convention(thin) (@guaranteed SuperSub) -> ()
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[CLASS_METHOD:%.*]] = class_method [[ARG]] : $SuperSub, #SuperSub.boom!1
+ // CHECK: = apply [[CLASS_METHOD]]([[ARG]]) : $@convention(method) (@guaranteed SuperSub) -> ()
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: [[ARG_COPY_SUPER:%.*]] = upcast [[ARG_COPY]] : $SuperSub to $SuperBase
+ // CHECK: [[BORROWED_ARG_COPY_SUPER:%.*]] = begin_borrow [[ARG_COPY_SUPER]]
+ // CHECK: [[SUPER_METHOD:%[0-9]+]] = function_ref @$S8closures9SuperBaseC4boomyyF : $@convention(method) (@guaranteed SuperBase) -> ()
+ // CHECK: = apply [[SUPER_METHOD]]([[BORROWED_ARG_COPY_SUPER]])
+ // CHECK: destroy_value [[ARG_COPY_SUPER]]
+ // CHECK: } // end sil function '[[INNER_FUNC_1]]'
+ let c1 = { () -> Void in
+ self.boom()
+ super.boom()
+ }
+ c1()
+ }
+
+ // CHECK-LABEL: sil hidden @$S8closures8SuperSubC1dyyF : $@convention(method) (@guaranteed SuperSub) -> () {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[INNER:%.*]] = function_ref @[[INNER_FUNC_1:\$S8closures8SuperSubC1d[_0-9a-zA-Z]*]] : $@convention(thin) (@guaranteed SuperSub) -> ()
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[INNER]]([[SELF_COPY]])
+ // CHECK: [[BORROWED_PA:%.*]] = begin_borrow [[PA]]
+ // CHECK: [[PA_COPY:%.*]] = copy_value [[BORROWED_PA]]
+ // CHECK: [[B:%.*]] = begin_borrow [[PA_COPY]]
+ // CHECK: apply [[B]]()
+ // CHECK: end_borrow [[B]]
+ // CHECK: destroy_value [[PA_COPY]]
+ // CHECK: end_borrow [[BORROWED_PA]] from [[PA]]
+ // CHECK: destroy_value [[PA]]
+ // CHECK: } // end sil function '$S8closures8SuperSubC1dyyF'
+ func d() {
+ // CHECK: sil private @[[INNER_FUNC_1]] : $@convention(thin) (@guaranteed SuperSub) -> () {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[INNER:%.*]] = function_ref @[[INNER_FUNC_2:\$S8closures8SuperSubC1d.*]] : $@convention(thin) (@guaranteed SuperSub) -> ()
+ // CHECK: = apply [[INNER]]([[ARG]])
+ // CHECK: } // end sil function '[[INNER_FUNC_1]]'
+ let d1 = { () -> Void in
+ // CHECK: sil private @[[INNER_FUNC_2]] : $@convention(thin) (@guaranteed SuperSub) -> () {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: [[ARG_COPY_SUPER:%.*]] = upcast [[ARG_COPY]] : $SuperSub to $SuperBase
+ // CHECK: [[BORROWED_ARG_COPY_SUPER:%.*]] = begin_borrow [[ARG_COPY_SUPER]]
+ // CHECK: [[SUPER_METHOD:%.*]] = function_ref @$S8closures9SuperBaseC4boomyyF : $@convention(method) (@guaranteed SuperBase) -> ()
+ // CHECK: = apply [[SUPER_METHOD]]([[BORROWED_ARG_COPY_SUPER]])
+ // CHECK: destroy_value [[ARG_COPY_SUPER]]
+ // CHECK: } // end sil function '[[INNER_FUNC_2]]'
+ func d2() {
+ super.boom()
+ }
+ d2()
+ }
+ d1()
+ }
+
+ // CHECK-LABEL: sil hidden @$S8closures8SuperSubC1eyyF : $@convention(method) (@guaranteed SuperSub) -> () {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[INNER:%.*]] = function_ref @[[INNER_FUNC_NAME1:\$S8closures8SuperSubC1e[_0-9a-zA-Z]*]] : $@convention(thin)
+ // CHECK: = apply [[INNER]]([[SELF]])
+ // CHECK: } // end sil function '$S8closures8SuperSubC1eyyF'
+ func e() {
+ // CHECK: sil private @[[INNER_FUNC_NAME1]] : $@convention(thin)
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[INNER:%.*]] = function_ref @[[INNER_FUNC_NAME2:\$S8closures8SuperSubC1e.*]] : $@convention(thin)
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[INNER]]([[ARG_COPY]])
+ // CHECK: [[BORROWED_PA:%.*]] = begin_borrow [[PA]]
+ // CHECK: [[PA_COPY:%.*]] = copy_value [[BORROWED_PA]]
+ // CHECK: [[B:%.*]] = begin_borrow [[PA_COPY]]
+ // CHECK: apply [[B]]() : $@callee_guaranteed () -> ()
+ // CHECK: end_borrow [[B]]
+ // CHECK: destroy_value [[PA_COPY]]
+ // CHECK: end_borrow [[BORROWED_PA]] from [[PA]]
+ // CHECK: destroy_value [[PA]]
+ // CHECK: } // end sil function '[[INNER_FUNC_NAME1]]'
+ func e1() {
+ // CHECK: sil private @[[INNER_FUNC_NAME2]] : $@convention(thin)
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: [[ARG_COPY_SUPERCAST:%.*]] = upcast [[ARG_COPY]] : $SuperSub to $SuperBase
+ // CHECK: [[BORROWED_ARG_COPY_SUPERCAST:%.*]] = begin_borrow [[ARG_COPY_SUPERCAST]]
+ // CHECK: [[SUPER_METHOD:%.*]] = function_ref @$S8closures9SuperBaseC4boomyyF : $@convention(method) (@guaranteed SuperBase) -> ()
+ // CHECK: = apply [[SUPER_METHOD]]([[BORROWED_ARG_COPY_SUPERCAST]])
+ // CHECK: destroy_value [[ARG_COPY_SUPERCAST]]
+ // CHECK: return
+ // CHECK: } // end sil function '[[INNER_FUNC_NAME2]]'
+ let e2 = {
+ super.boom()
+ }
+ e2()
+ }
+ e1()
+ }
+
+ // CHECK-LABEL: sil hidden @$S8closures8SuperSubC1fyyF : $@convention(method) (@guaranteed SuperSub) -> () {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[INNER:%.*]] = function_ref @[[INNER_FUNC_1:\$S8closures8SuperSubC1fyyFyycfU_]] : $@convention(thin) (@guaranteed SuperSub) -> ()
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[INNER]]([[SELF_COPY]])
+ // CHECK: destroy_value [[PA]]
+ // CHECK: } // end sil function '$S8closures8SuperSubC1fyyF'
+ func f() {
+ // CHECK: sil private @[[INNER_FUNC_1]] : $@convention(thin) (@guaranteed SuperSub) -> () {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[INNER:%.*]] = function_ref @[[INNER_FUNC_2:\$S8closures8SuperSubC1fyyFyycfU_yyKXKfu_]] : $@convention(thin) (@guaranteed SuperSub) -> @error Error
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[INNER]]([[ARG_COPY]])
+ // CHECK: [[CVT:%.*]] = convert_escape_to_noescape [[PA]]
+ // CHECK: [[REABSTRACT_PA:%.*]] = partial_apply [callee_guaranteed] {{.*}}([[CVT]])
+ // CHECK: [[REABSTRACT_CVT:%.*]] = convert_escape_to_noescape [[REABSTRACT_PA]]
+ // CHECK: [[TRY_APPLY_AUTOCLOSURE:%.*]] = function_ref @$Ss2qqoiyxxSg_xyKXKtKlF : $@convention(thin) <τ_0_0> (@in_guaranteed Optional<τ_0_0>, @noescape @callee_guaranteed () -> (@out τ_0_0, @error Error)) -> (@out τ_0_0, @error Error)
+ // CHECK: try_apply [[TRY_APPLY_AUTOCLOSURE]]<()>({{.*}}, {{.*}}, [[REABSTRACT_CVT]]) : $@convention(thin) <τ_0_0> (@in_guaranteed Optional<τ_0_0>, @noescape @callee_guaranteed () -> (@out τ_0_0, @error Error)) -> (@out τ_0_0, @error Error), normal [[NORMAL_BB:bb1]], error [[ERROR_BB:bb2]]
+ // CHECK: [[NORMAL_BB]]{{.*}}
+ // CHECK: } // end sil function '[[INNER_FUNC_1]]'
+ let f1 = {
+ // CHECK: sil private [transparent] @[[INNER_FUNC_2]]
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: [[ARG_COPY_SUPER:%.*]] = upcast [[ARG_COPY]] : $SuperSub to $SuperBase
+ // CHECK: [[BORROWED_ARG_COPY_SUPER:%.*]] = begin_borrow [[ARG_COPY_SUPER]]
+ // CHECK: [[SUPER_METHOD:%.*]] = function_ref @$S8closures9SuperBaseC4boomyyF : $@convention(method) (@guaranteed SuperBase) -> ()
+ // CHECK: = apply [[SUPER_METHOD]]([[BORROWED_ARG_COPY_SUPER]]) : $@convention(method) (@guaranteed SuperBase) -> ()
+ // CHECK: destroy_value [[ARG_COPY_SUPER]]
+ // CHECK: } // end sil function '[[INNER_FUNC_2]]'
+ nil ?? super.boom()
+ }
+ }
+
+ // CHECK-LABEL: sil hidden @$S8closures8SuperSubC1gyyF : $@convention(method) (@guaranteed SuperSub) -> () {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[INNER:%.*]] = function_ref @[[INNER_FUNC_1:\$S8closures8SuperSubC1g[_0-9a-zA-Z]*]] : $@convention(thin) (@guaranteed SuperSub) -> ()
+ // CHECK: = apply [[INNER]]([[SELF]])
+ // CHECK: } // end sil function '$S8closures8SuperSubC1gyyF'
+ func g() {
+ // CHECK: sil private @[[INNER_FUNC_1]] : $@convention(thin) (@guaranteed SuperSub) -> ()
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[INNER:%.*]] = function_ref @[[INNER_FUNC_2:\$S8closures8SuperSubC1g.*]] : $@convention(thin) (@guaranteed SuperSub) -> @error Error
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[INNER]]([[ARG_COPY]])
+ // CHECK: [[CVT:%.*]] = convert_escape_to_noescape [[PA]] : $@callee_guaranteed () -> @error Error to $@noescape @callee_guaranteed () -> @error Error
+ // CHECK: [[REABSTRACT_PA:%.*]] = partial_apply [callee_guaranteed] {{%.*}}([[CVT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> @error Error) -> (@out (), @error Error)
+ // CHECK: [[REABSTRACT_CVT:%.*]] = convert_escape_to_noescape [[REABSTRACT_PA]]
+ // CHECK: [[TRY_APPLY_FUNC:%.*]] = function_ref @$Ss2qqoiyxxSg_xyKXKtKlF : $@convention(thin) <τ_0_0> (@in_guaranteed Optional<τ_0_0>, @noescape @callee_guaranteed () -> (@out τ_0_0, @error Error)) -> (@out τ_0_0, @error Error)
+ // CHECK: try_apply [[TRY_APPLY_FUNC]]<()>({{.*}}, {{.*}}, [[REABSTRACT_CVT]]) : $@convention(thin) <τ_0_0> (@in_guaranteed Optional<τ_0_0>, @noescape @callee_guaranteed () -> (@out τ_0_0, @error Error)) -> (@out τ_0_0, @error Error), normal [[NORMAL_BB:bb1]], error [[ERROR_BB:bb2]]
+ // CHECK: [[NORMAL_BB]]{{.*}}
+ // CHECK: } // end sil function '[[INNER_FUNC_1]]'
+ func g1() {
+ // CHECK: sil private [transparent] @[[INNER_FUNC_2]] : $@convention(thin) (@guaranteed SuperSub) -> @error Error {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $SuperSub):
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: [[ARG_COPY_SUPER:%.*]] = upcast [[ARG_COPY]] : $SuperSub to $SuperBase
+ // CHECK: [[BORROWED_ARG_COPY_SUPER:%.*]] = begin_borrow [[ARG_COPY_SUPER]]
+ // CHECK: [[SUPER_METHOD:%.*]] = function_ref @$S8closures9SuperBaseC4boomyyF : $@convention(method) (@guaranteed SuperBase) -> ()
+ // CHECK: = apply [[SUPER_METHOD]]([[BORROWED_ARG_COPY_SUPER]])
+ // CHECK: destroy_value [[ARG_COPY_SUPER]]
+ // CHECK: } // end sil function '[[INNER_FUNC_2]]'
+ nil ?? super.boom()
+ }
+ g1()
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S8closures24UnownedSelfNestedCaptureC06nestedE0{{[_0-9a-zA-Z]*}}F : $@convention(method) (@guaranteed UnownedSelfNestedCapture) -> ()
+// -- We enter with an assumed strong +1.
+// CHECK: bb0([[SELF:%.*]] : @guaranteed $UnownedSelfNestedCapture):
+// CHECK: [[OUTER_SELF_CAPTURE:%.*]] = alloc_box ${ var @sil_unowned UnownedSelfNestedCapture }
+// CHECK: [[PB:%.*]] = project_box [[OUTER_SELF_CAPTURE]]
+// -- strong +2
+// CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+// CHECK: [[UNOWNED_SELF:%.*]] = ref_to_unowned [[SELF_COPY]] :
+// -- TODO: A lot of fussy r/r traffic and owned/unowned conversions here.
+// -- strong +2, unowned +1
+// CHECK: [[UNOWNED_SELF_COPY:%.*]] = copy_value [[UNOWNED_SELF]]
+// CHECK: store [[UNOWNED_SELF_COPY]] to [init] [[PB]]
+// SEMANTIC ARC TODO: This destroy_value should probably be /after/ the load from PB on the next line.
+// CHECK: destroy_value [[SELF_COPY]]
+// CHECK: [[UNOWNED_SELF:%.*]] = load_borrow [[PB]]
+// -- strong +2, unowned +1
+// CHECK: [[SELF:%.*]] = copy_unowned_value [[UNOWNED_SELF]]
+// CHECK: end_borrow [[UNOWNED_SELF]] from [[PB]]
+// CHECK: [[UNOWNED_SELF2:%.*]] = ref_to_unowned [[SELF]]
+// -- strong +2, unowned +2
+// CHECK: [[UNOWNED_SELF2_COPY:%.*]] = copy_value [[UNOWNED_SELF2]]
+// -- strong +1, unowned +2
+// CHECK: destroy_value [[SELF]]
+// -- closure takes unowned ownership
+// CHECK: [[OUTER_CLOSURE:%.*]] = partial_apply [callee_guaranteed] {{%.*}}([[UNOWNED_SELF2_COPY]])
+// CHECK: [[OUTER_CONVERT:%.*]] = convert_escape_to_noescape [[OUTER_CLOSURE]]
+// -- call consumes closure
+// -- strong +1, unowned +1
+// CHECK: [[INNER_CLOSURE:%.*]] = apply [[OUTER_CONVERT]]
+// CHECK: [[B:%.*]] = begin_borrow [[INNER_CLOSURE]]
+// CHECK: [[CONSUMED_RESULT:%.*]] = apply [[B]]()
+// CHECK: destroy_value [[CONSUMED_RESULT]]
+// CHECK: destroy_value [[INNER_CLOSURE]]
+// -- destroy_values unowned self in box
+// -- strong +1, unowned +0
+// CHECK: destroy_value [[OUTER_SELF_CAPTURE]]
+// -- strong +0, unowned +0
+// CHECK: } // end sil function '$S8closures24UnownedSelfNestedCaptureC06nestedE0{{[_0-9a-zA-Z]*}}F'
+
+// -- outer closure
+// -- strong +0, unowned +1
+// CHECK: sil private @[[OUTER_CLOSURE_FUN:\$S8closures24UnownedSelfNestedCaptureC06nestedE0yyFACycyXEfU_]] : $@convention(thin) (@guaranteed @sil_unowned UnownedSelfNestedCapture) -> @owned @callee_guaranteed () -> @owned UnownedSelfNestedCapture {
+// CHECK: bb0([[CAPTURED_SELF:%.*]] : @guaranteed $@sil_unowned UnownedSelfNestedCapture):
+// -- strong +0, unowned +2
+// CHECK: [[CAPTURED_SELF_COPY:%.*]] = copy_value [[CAPTURED_SELF]] :
+// -- closure takes ownership of unowned ref
+// CHECK: [[INNER_CLOSURE:%.*]] = partial_apply [callee_guaranteed] {{%.*}}([[CAPTURED_SELF_COPY]])
+// -- strong +0, unowned +1 (claimed by closure)
+// CHECK: return [[INNER_CLOSURE]]
+// CHECK: } // end sil function '[[OUTER_CLOSURE_FUN]]'
+
+// -- inner closure
+// -- strong +0, unowned +1
+// CHECK: sil private @[[INNER_CLOSURE_FUN:\$S8closures24UnownedSelfNestedCaptureC06nestedE0yyFACycyXEfU_ACycfU_]] : $@convention(thin) (@guaranteed @sil_unowned UnownedSelfNestedCapture) -> @owned UnownedSelfNestedCapture {
+// CHECK: bb0([[CAPTURED_SELF:%.*]] : @guaranteed $@sil_unowned UnownedSelfNestedCapture):
+// -- strong +1, unowned +1
+// CHECK: [[SELF:%.*]] = copy_unowned_value [[CAPTURED_SELF:%.*]] :
+// -- strong +1, unowned +0 (claimed by return)
+// CHECK: return [[SELF]]
+// CHECK: } // end sil function '[[INNER_CLOSURE_FUN]]'
+class UnownedSelfNestedCapture {
+ func nestedCapture() {
+ {[unowned self] in { self } }()()
+ }
+}
+
+// Check that capturing 'self' via a 'super' call also captures the generic
+// signature if the base class is concrete and the derived class is generic
+
+class ConcreteBase {
+ func swim() {}
+}
+
+// CHECK-LABEL: sil private @$S8closures14GenericDerivedC4swimyyFyyXEfU_ : $@convention(thin) <Ocean> (@guaranteed GenericDerived<Ocean>) -> ()
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $GenericDerived<Ocean>):
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: [[ARG_COPY_SUPER:%.*]] = upcast [[ARG_COPY]] : $GenericDerived<Ocean> to $ConcreteBase
+// CHECK: [[BORROWED_ARG_COPY_SUPER:%.*]] = begin_borrow [[ARG_COPY_SUPER]]
+// CHECK: [[METHOD:%.*]] = function_ref @$S8closures12ConcreteBaseC4swimyyF
+// CHECK: apply [[METHOD]]([[BORROWED_ARG_COPY_SUPER]]) : $@convention(method) (@guaranteed ConcreteBase) -> ()
+// CHECK: destroy_value [[ARG_COPY_SUPER]]
+// CHECK: } // end sil function '$S8closures14GenericDerivedC4swimyyFyyXEfU_'
+
+class GenericDerived<Ocean> : ConcreteBase {
+ override func swim() {
+ withFlotationAid {
+ super.swim()
+ }
+ }
+
+ func withFlotationAid(_ fn: () -> ()) {}
+}
+
+// Don't crash on this
+func r25993258_helper(_ fn: (inout Int, Int) -> ()) {}
+func r25993258() {
+ r25993258_helper { _ in () }
+}
+
+// rdar://29810997
+//
+// Using a let from a closure in an init was causing the type-checker
+// to produce invalid AST: 'self.fn' was an l-value, but 'self' was already
+// loaded to make an r-value. This was ultimately because CSApply was
+// building the member reference correctly in the context of the closure,
+// where 'fn' is not settable, but CSGen / CSSimplify was processing it
+// in the general DC of the constraint system, i.e. the init, where
+// 'fn' *is* settable.
+func r29810997_helper(_ fn: (Int) -> Int) -> Int { return fn(0) }
+struct r29810997 {
+ private let fn: (Int) -> Int
+ private var x: Int
+
+ init(function: @escaping (Int) -> Int) {
+ fn = function
+ x = r29810997_helper { fn($0) }
+ }
+}
+
+// DI will turn this into a direct capture of the specific stored property.
+// CHECK-LABEL: sil hidden @$S8closures16r29810997_helperyS3iXEF : $@convention(thin) (@noescape @callee_guaranteed (Int) -> Int) -> Int
diff --git a/test/SILGen/plus_zero_collection_downcast.swift b/test/SILGen/plus_zero_collection_downcast.swift
new file mode 100644
index 0000000..30f16af
--- /dev/null
+++ b/test/SILGen/plus_zero_collection_downcast.swift
@@ -0,0 +1,241 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -sdk %S/Inputs -I %S/Inputs -enable-source-import %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+
+// FIXME: Should go into the standard library.
+public extension _ObjectiveCBridgeable {
+ static func _unconditionallyBridgeFromObjectiveC(_ source: _ObjectiveCType?)
+ -> Self {
+ var result: Self?
+ _forceBridgeFromObjectiveC(source!, result: &result)
+ return result!
+ }
+}
+
+class BridgedObjC : NSObject { }
+
+func == (x: BridgedObjC, y: BridgedObjC) -> Bool { return true }
+
+struct BridgedSwift : Hashable, _ObjectiveCBridgeable {
+ var hashValue: Int { return 0 }
+
+ func _bridgeToObjectiveC() -> BridgedObjC {
+ return BridgedObjC()
+ }
+
+ static func _forceBridgeFromObjectiveC(
+ _ x: BridgedObjC,
+ result: inout BridgedSwift?
+ ) {
+ }
+ static func _conditionallyBridgeFromObjectiveC(
+ _ x: BridgedObjC,
+ result: inout BridgedSwift?
+ ) -> Bool {
+ return true
+ }
+}
+
+func == (x: BridgedSwift, y: BridgedSwift) -> Bool { return true }
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast17testArrayDowncast{{.*}}F
+// CHECK: bb0([[ARRAY:%[0-9]+]] : $Array<AnyObject>):
+func testArrayDowncast(_ array: [AnyObject]) -> [BridgedObjC] {
+ // CHECK: [[ARRAY_COPY:%.*]] = copy_value [[ARRAY]]
+ // CHECK: [[DOWNCAST_FN:%[0-9]+]] = function_ref @$Ss15_arrayForceCast{{.*}}F
+ // CHECK: apply [[DOWNCAST_FN]]<AnyObject, BridgedObjC>([[ARRAY_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Array<τ_0_1>
+ return array as! [BridgedObjC]
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast27testArrayDowncastFromObject{{.*}}F
+// CHECK: bb0([[OBJ:%[0-9]+]] : $AnyObject):
+func testArrayDowncastFromObject(_ obj: AnyObject) -> [BridgedObjC] {
+ // CHECK: unconditional_checked_cast_addr AnyObject in [[OBJECT_ALLOC:%[0-9]+]] : $*AnyObject to Array<BridgedObjC> in [[VALUE_ALLOC:%[0-9]+]] : $*Array<BridgedObjC>
+ return obj as! [BridgedObjC]
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast28testArrayDowncastFromNSArray{{.*}}F
+// CHECK: bb0([[NSARRAY_OBJ:%[0-9]+]] : $NSArray):
+func testArrayDowncastFromNSArray(_ obj: NSArray) -> [BridgedObjC] {
+ // CHECK: unconditional_checked_cast_addr NSArray in [[OBJECT_ALLOC:%[0-9]+]] : $*NSArray to Array<BridgedObjC> in [[VALUE_ALLOC:%[0-9]+]] : $*Array<BridgedObjC>
+ return obj as! [BridgedObjC]
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast28testArrayDowncastConditional{{.*}}F
+// CHECK: bb0([[ARRAY:%[0-9]+]] : $Array<AnyObject>):
+func testArrayDowncastConditional(_ array: [AnyObject]) -> [BridgedObjC]? {
+ // CHECK: [[ARRAY_COPY:%.*]] = copy_value [[ARRAY]]
+ // CHECK: [[DOWNCAST_FN:%[0-9]+]] = function_ref @$Ss21_arrayConditionalCast{{.*}}F
+ // CHECK: apply [[DOWNCAST_FN]]<AnyObject, BridgedObjC>([[ARRAY_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Optional<Array<τ_0_1>>
+ return array as? [BridgedObjC]
+}
+// CHECK: } // end sil function '$S19collection_downcast28testArrayDowncastConditional{{.*}}F'
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast12testArrayIsa{{.*}}F
+// CHECK: bb0([[ARRAY:%[0-9]+]] : $Array<AnyObject>)
+func testArrayIsa(_ array: [AnyObject]) -> Bool {
+ // CHECK: [[ARRAY_COPY:%.*]] = copy_value [[ARRAY]]
+ // CHECK: [[DOWNCAST_FN:%[0-9]+]] = function_ref @$Ss21_arrayConditionalCast{{.*}}F
+ // CHECK: apply [[DOWNCAST_FN]]<AnyObject, BridgedObjC>([[ARRAY_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Optional<Array<τ_0_1>>
+ // CHECK-NOT: destroy_value [[ARRAY]]
+ return array is [BridgedObjC] ? true : false
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast24testArrayDowncastBridged{{.*}}F
+// CHECK: bb0([[ARRAY:%[0-9]+]] : $Array<AnyObject>):
+func testArrayDowncastBridged(_ array: [AnyObject]) -> [BridgedSwift] {
+ // CHECK: [[ARRAY_COPY:%.*]] = copy_value [[ARRAY]]
+ // CHECK: [[BRIDGE_FN:%[0-9]+]] = function_ref @$Ss15_arrayForceCast{{.*}}F
+ // CHECK: apply [[BRIDGE_FN]]<AnyObject, BridgedSwift>([[ARRAY_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Array<τ_0_1>
+ // CHECK-NOT: destroy_value [[ARRAY]]
+ return array as! [BridgedSwift]
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast35testArrayDowncastBridgedConditional{{.*}}F
+// CHECK: bb0([[ARRAY:%[0-9]+]] : $Array<AnyObject>):
+func testArrayDowncastBridgedConditional(_ array: [AnyObject]) -> [BridgedSwift]?{
+ // CHECK: [[ARRAY_COPY:%.*]] = copy_value [[ARRAY]]
+ // CHECK: [[BRIDGE_FN:%[0-9]+]] = function_ref @$Ss21_arrayConditionalCast{{.*}}F
+ // CHECK: apply [[BRIDGE_FN]]<AnyObject, BridgedSwift>([[ARRAY_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Optional<Array<τ_0_1>>
+ // CHECK-NOT: destroy_value [[ARRAY]]
+ return array as? [BridgedSwift]
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast19testArrayIsaBridged{{.*}}F
+// CHECK: bb0([[ARRAY:%[0-9]+]] : $Array<AnyObject>)
+func testArrayIsaBridged(_ array: [AnyObject]) -> Bool {
+ // CHECK: [[ARRAY_COPY:%.*]] = copy_value [[ARRAY]]
+ // CHECK: [[DOWNCAST_FN:%[0-9]+]] = function_ref @$Ss21_arrayConditionalCast{{.*}}F
+ // CHECK: apply [[DOWNCAST_FN]]<AnyObject, BridgedSwift>([[ARRAY_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Optional<Array<τ_0_1>>
+ // CHECK-NOT: destroy_value [[ARRAY]]
+ return array is [BridgedSwift] ? true : false
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast32testDictionaryDowncastFromObject{{.*}}F
+// CHECK: bb0([[OBJ:%[0-9]+]] : $AnyObject):
+func testDictionaryDowncastFromObject(_ obj: AnyObject)
+ -> Dictionary<BridgedObjC, BridgedObjC> {
+ // CHECK: unconditional_checked_cast_addr AnyObject in [[OBJECT_ALLOC:%[0-9]+]] : $*AnyObject to Dictionary<BridgedObjC, BridgedObjC> in [[VALUE_ALLOC:%[0-9]+]] : $*Dictionary<BridgedObjC, BridgedObjC>
+ return obj as! Dictionary<BridgedObjC, BridgedObjC>
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast22testDictionaryDowncast{{.*}}F
+// CHECK: bb0([[DICT:%[0-9]+]] : $Dictionary<NSObject, AnyObject>)
+func testDictionaryDowncast(_ dict: Dictionary<NSObject, AnyObject>)
+ -> Dictionary<BridgedObjC, BridgedObjC> {
+ // CHECK: [[DICT_COPY:%.*]] = copy_value [[DICT]]
+ // CHECK: [[DOWNCAST_FN:%[0-9]+]] = function_ref @$Ss19_dictionaryDownCast{{.*}}F
+ // CHECK: apply [[DOWNCAST_FN]]<NSObject, AnyObject, BridgedObjC, BridgedObjC>([[DICT_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_0 : Hashable, τ_0_2 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned Dictionary<τ_0_2, τ_0_3>
+ // CHECK-NOT: destroy_value [[DICT]]
+ return dict as! Dictionary<BridgedObjC, BridgedObjC>
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast33testDictionaryDowncastConditional{{.*}}F
+// CHECK: bb0([[DICT:%[0-9]+]] : $Dictionary<NSObject, AnyObject>)
+func testDictionaryDowncastConditional(_ dict: Dictionary<NSObject, AnyObject>)
+-> Dictionary<BridgedObjC, BridgedObjC>? {
+ // CHECK: [[DICT_COPY:%.*]] = copy_value [[DICT]]
+ // CHECK: [[DOWNCAST_FN:%[0-9]+]] = function_ref @$Ss30_dictionaryDownCastConditional{{.*}}F
+ // CHECK: apply [[DOWNCAST_FN]]<NSObject, AnyObject, BridgedObjC, BridgedObjC>([[DICT_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_0 : Hashable, τ_0_2 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned Optional<Dictionary<τ_0_2, τ_0_3>>
+ // CHECK-NOT: destroy_value [[DICT]]
+ return dict as? Dictionary<BridgedObjC, BridgedObjC>
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast41testDictionaryDowncastBridgedVConditional{{.*}}F
+// CHECK: bb0([[DICT:%[0-9]+]] : $Dictionary<NSObject, AnyObject>)
+func testDictionaryDowncastBridgedVConditional(_ dict: Dictionary<NSObject, AnyObject>)
+ -> Dictionary<BridgedObjC, BridgedSwift>? {
+ // CHECK: [[DICT_COPY:%.*]] = copy_value [[DICT]]
+ // CHECK: [[BRIDGE_FN:%[0-9]+]] = function_ref @$Ss30_dictionaryDownCastConditional{{.*}}F
+ // CHECK: apply [[BRIDGE_FN]]<NSObject, AnyObject, BridgedObjC, BridgedSwift>([[DICT_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_0 : Hashable, τ_0_2 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned Optional<Dictionary<τ_0_2, τ_0_3>>{{.*}}
+ // CHECK-NOT: destroy_value [[DICT]]
+ return dict as? Dictionary<BridgedObjC, BridgedSwift>
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast41testDictionaryDowncastBridgedKConditional{{.*}}F
+// CHECK: bb0([[DICT:%[0-9]+]] : $Dictionary<NSObject, AnyObject>)
+func testDictionaryDowncastBridgedKConditional(_ dict: Dictionary<NSObject, AnyObject>)
+-> Dictionary<BridgedSwift, BridgedObjC>? {
+ // CHECK: [[DICT_COPY:%.*]] = copy_value [[DICT]]
+ // CHECK: [[BRIDGE_FN:%[0-9]+]] = function_ref @$Ss30_dictionaryDownCastConditional{{.*}}F
+ // CHECK: apply [[BRIDGE_FN]]<NSObject, AnyObject, BridgedSwift, BridgedObjC>([[DICT_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_0 : Hashable, τ_0_2 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned Optional<Dictionary<τ_0_2, τ_0_3>>
+ // CHECK-NOT: destroy_value [[DICT]]
+ return dict as? Dictionary<BridgedSwift, BridgedObjC>
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast31testDictionaryDowncastBridgedKV{{.*}}F
+// CHECK: bb0([[DICT:%[0-9]+]] : $Dictionary<NSObject, AnyObject>)
+func testDictionaryDowncastBridgedKV(_ dict: Dictionary<NSObject, AnyObject>)
+-> Dictionary<BridgedSwift, BridgedSwift> {
+ // CHECK: [[DICT_COPY:%.*]] = copy_value [[DICT]]
+ // CHECK: [[BRIDGE_FN:%[0-9]+]] = function_ref @$Ss19_dictionaryDownCast{{.*}}F
+ // CHECK: apply [[BRIDGE_FN]]<NSObject, AnyObject, BridgedSwift, BridgedSwift>([[DICT_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_0 : Hashable, τ_0_2 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned Dictionary<τ_0_2, τ_0_3>
+ // CHECK-NOT: destroy_value [[DICT]]
+ return dict as! Dictionary<BridgedSwift, BridgedSwift>
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast42testDictionaryDowncastBridgedKVConditional{{.*}}F
+// CHECK: bb0([[DICT:%[0-9]+]] : $Dictionary<NSObject, AnyObject>)
+func testDictionaryDowncastBridgedKVConditional(_ dict: Dictionary<NSObject, AnyObject>)
+ -> Dictionary<BridgedSwift, BridgedSwift>? {
+ // CHECK: [[DICT_COPY:%.*]] = copy_value [[DICT]]
+ // CHECK: [[BRIDGE_FN:%[0-9]+]] = function_ref @$Ss30_dictionaryDownCastConditional{{.*}}F
+ // CHECK: apply [[BRIDGE_FN]]<NSObject, AnyObject, BridgedSwift, BridgedSwift>([[DICT_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_0 : Hashable, τ_0_2 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned Optional<Dictionary<τ_0_2, τ_0_3>>
+ // CHECK-NOT: destroy_value [[DICT]]
+ return dict as? Dictionary<BridgedSwift, BridgedSwift>
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast25testSetDowncastFromObject{{.*}}F
+// CHECK: bb0([[OBJ:%[0-9]+]] : $AnyObject):
+func testSetDowncastFromObject(_ obj: AnyObject)
+ -> Set<BridgedObjC> {
+ // CHECK: unconditional_checked_cast_addr AnyObject in [[OBJECT_ALLOC:%[0-9]+]] : $*AnyObject to Set<BridgedObjC> in [[VALUE_ALLOC:%[0-9]+]] : $*Set<BridgedObjC>
+ return obj as! Set<BridgedObjC>
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast15testSetDowncast{{.*}}F
+// CHECK: bb0([[SET:%[0-9]+]] : $Set<NSObject>)
+func testSetDowncast(_ dict: Set<NSObject>)
+ -> Set<BridgedObjC> {
+ // CHECK: [[SET_COPY:%.*]] = copy_value [[SET]]
+ // CHECK: [[DOWNCAST_FN:%[0-9]+]] = function_ref @$Ss12_setDownCast{{.*}}F
+ // CHECK: apply [[DOWNCAST_FN]]<NSObject, BridgedObjC>([[SET_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : Hashable, τ_0_1 : Hashable> (@guaranteed Set<τ_0_0>) -> @owned Set<τ_0_1>
+ // CHECK-NOT: destroy_value [[SET]]
+ return dict as! Set<BridgedObjC>
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast26testSetDowncastConditional{{.*}}F
+// CHECK: bb0([[SET:%[0-9]+]] : $Set<NSObject>)
+func testSetDowncastConditional(_ dict: Set<NSObject>)
+ -> Set<BridgedObjC>? {
+ // CHECK: [[SET_COPY:%.*]] = copy_value [[SET]]
+ // CHECK: [[DOWNCAST_FN:%[0-9]+]] = function_ref @$Ss23_setDownCastConditional{{.*}}F
+ // CHECK: apply [[DOWNCAST_FN]]<NSObject, BridgedObjC>([[SET_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : Hashable, τ_0_1 : Hashable> (@guaranteed Set<τ_0_0>) -> @owned Optional<Set<τ_0_1>>
+ // CHECK-NOT: destroy_value [[SET]]
+ return dict as? Set<BridgedObjC>
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast22testSetDowncastBridged{{.*}}F
+// CHECK: bb0([[SET:%[0-9]+]] : $Set<NSObject>)
+func testSetDowncastBridged(_ dict: Set<NSObject>)
+ -> Set<BridgedSwift> {
+ // CHECK: [[SET_COPY:%.*]] = copy_value [[SET]]
+ // CHECK: [[DOWNCAST_FN:%[0-9]+]] = function_ref @$Ss12_setDownCast{{.*}}F
+ // CHECK: apply [[DOWNCAST_FN]]<NSObject, BridgedSwift>([[SET_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : Hashable, τ_0_1 : Hashable> (@guaranteed Set<τ_0_0>) -> @owned Set<τ_0_1>
+ // CHECK-NOT: destroy_value [[SET]]
+ return dict as! Set<BridgedSwift>
+}
+
+// CHECK-LABEL: sil hidden @$S19collection_downcast33testSetDowncastBridgedConditional{{.*}}F
+// CHECK: bb0([[SET:%[0-9]+]] : $Set<NSObject>)
+func testSetDowncastBridgedConditional(_ dict: Set<NSObject>)
+ -> Set<BridgedSwift>? {
+ // CHECK: [[SET_COPY:%.*]] = copy_value [[SET]]
+ // CHECK: [[DOWNCAST_FN:%[0-9]+]] = function_ref @$Ss23_setDownCastConditional{{.*}}F
+ // CHECK: apply [[DOWNCAST_FN]]<NSObject, BridgedSwift>([[SET_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : Hashable, τ_0_1 : Hashable> (@guaranteed Set<τ_0_0>) -> @owned Optional<Set<τ_0_1>>
+ // CHECK-NOT: destroy_value [[SET]]
+ return dict as? Set<BridgedSwift>
+}
diff --git a/test/SILGen/plus_zero_collection_subtype_downcast.swift b/test/SILGen/plus_zero_collection_subtype_downcast.swift
new file mode 100644
index 0000000..251eb9e
--- /dev/null
+++ b/test/SILGen/plus_zero_collection_subtype_downcast.swift
@@ -0,0 +1,47 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -sdk %S/Inputs %s | %FileCheck %s
+
+struct S { var x, y: Int }
+
+// CHECK-LABEL: sil hidden @$S27collection_subtype_downcast06array_C00D0SayAA1SVGSgSayypG_tF :
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Array<Any>):
+// CHECK-NEXT: debug_value [[ARG]]
+// CHECK-NEXT: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK-NEXT: // function_ref
+// CHECK-NEXT: [[FN:%.*]] = function_ref @$Ss21_arrayConditionalCastySayq_GSgSayxGr0_lF
+// CHECK-NEXT: [[BORROWED_ARG_COPY:%.*]] = begin_borrow [[ARG_COPY]]
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[FN]]<Any, S>([[BORROWED_ARG_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Optional<Array<τ_0_1>>
+// CHECK-NEXT: end_borrow
+// CHECK-NEXT: destroy_value [[ARG_COPY]]
+// CHECK-NEXT: return [[RESULT]]
+func array_downcast(array: [Any]) -> [S]? {
+ return array as? [S]
+}
+
+extension S : Hashable {
+ var hashValue : Int {
+ return x + y
+ }
+}
+func ==(lhs: S, rhs: S) -> Bool {
+ return true
+}
+
+// FIXME: This entrypoint name should not be bridging-specific
+// CHECK-LABEL: sil hidden @$S27collection_subtype_downcast05dict_C00D0s10DictionaryVyAA1SVSiGSgAEyAGypG_tF :
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Dictionary<S, Any>):
+// CHECK: debug_value [[ARG]]
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: // function_ref
+// CHECK: [[FN:%.*]] = function_ref @$Ss30_dictionaryDownCastConditionalys10DictionaryVyq0_q1_GSgACyxq_Gs8HashableRzsAGR0_r2_lF
+// CHECK: [[BORROWED_ARG_COPY:%.*]] = begin_borrow [[ARG_COPY]]
+// CHECK: [[RESULT:%.*]] = apply [[FN]]<S, Any, S, Int>([[BORROWED_ARG_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_0 : Hashable, τ_0_2 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned Optional<Dictionary<τ_0_2, τ_0_3>>
+// CHECK: end_borrow [[BORROWED_ARG_COPY]] from [[ARG_COPY]]
+// CHECK: destroy_value [[ARG_COPY]]
+// CHECK: return [[RESULT]]
+func dict_downcast(dict: [S: Any]) -> [S: Int]? {
+ return dict as? [S: Int]
+}
+
+// It's not actually possible to test this for Sets independent of
+// the bridging rules.
diff --git a/test/SILGen/plus_zero_collection_subtype_upcast.swift b/test/SILGen/plus_zero_collection_subtype_upcast.swift
new file mode 100644
index 0000000..a0d1a13
--- /dev/null
+++ b/test/SILGen/plus_zero_collection_subtype_upcast.swift
@@ -0,0 +1,46 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -sdk %S/Inputs %s | %FileCheck %s
+
+struct S { var x, y: Int }
+
+// CHECK-LABEL: sil hidden @$S25collection_subtype_upcast06array_C00D0SayypGSayAA1SVG_tF :
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Array<S>):
+// CHECK: debug_value [[ARG]]
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: // function_ref
+// CHECK: [[FN:%.*]] = function_ref @$Ss15_arrayForceCastySayq_GSayxGr0_lF
+// CHECK: [[BORROWED_ARG_COPY:%.*]] = begin_borrow [[ARG_COPY]]
+// CHECK: [[RESULT:%.*]] = apply [[FN]]<S, Any>([[BORROWED_ARG_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Array<τ_0_1>
+// CHECK: end_borrow [[BORROWED_ARG_COPY]] from [[ARG_COPY]]
+// CHECK: destroy_value [[ARG_COPY]]
+// CHECK: return [[RESULT]]
+func array_upcast(array: [S]) -> [Any] {
+ return array
+}
+
+extension S : Hashable {
+ var hashValue : Int {
+ return x + y
+ }
+}
+func ==(lhs: S, rhs: S) -> Bool {
+ return true
+}
+
+// FIXME: This entrypoint name should not be bridging-specific
+// CHECK-LABEL: sil hidden @$S25collection_subtype_upcast05dict_C00D0s10DictionaryVyAA1SVypGAEyAGSiG_tF :
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Dictionary<S, Int>):
+// CHECK: debug_value [[ARG]]
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: // function_ref
+// CHECK: [[FN:%.*]] = function_ref @$Ss17_dictionaryUpCastys10DictionaryVyq0_q1_GACyxq_Gs8HashableRzsAFR0_r2_lF
+// CHECK: [[BORROWED_ARG_COPY:%.*]] = begin_borrow [[ARG_COPY]]
+// CHECK: [[RESULT:%.*]] = apply [[FN]]<S, Int, S, Any>([[BORROWED_ARG_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_0 : Hashable, τ_0_2 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned Dictionary<τ_0_2, τ_0_3>
+// CHECK: destroy_value [[ARG_COPY]]
+// CHECK: return [[RESULT]]
+func dict_upcast(dict: [S: Int]) -> [S: Any] {
+ return dict
+}
+
+// It's not actually possible to test this for Sets independent of
+// the bridging rules.
diff --git a/test/SILGen/plus_zero_collection_upcast.swift b/test/SILGen/plus_zero_collection_upcast.swift
new file mode 100644
index 0000000..c0bb574
--- /dev/null
+++ b/test/SILGen/plus_zero_collection_upcast.swift
@@ -0,0 +1,111 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -sdk %S/Inputs -I %S/Inputs -enable-source-import %s | %FileCheck %s
+
+// FIXME: rdar://problem/19648117 Needs splitting objc parts out
+// XFAIL: linux
+
+import Foundation
+
+// FIXME: Should go into the standard library.
+public extension _ObjectiveCBridgeable {
+ static func _unconditionallyBridgeFromObjectiveC(_ source: _ObjectiveCType?)
+ -> Self {
+ var result: Self?
+ _forceBridgeFromObjectiveC(source!, result: &result)
+ return result!
+ }
+}
+
+class BridgedObjC : NSObject { }
+
+func == (x: BridgedObjC, y: BridgedObjC) -> Bool { return true }
+
+struct BridgedSwift : Hashable, _ObjectiveCBridgeable {
+ var hashValue: Int { return 0 }
+
+ func _bridgeToObjectiveC() -> BridgedObjC {
+ return BridgedObjC()
+ }
+
+ static func _forceBridgeFromObjectiveC(
+ _ x: BridgedObjC,
+ result: inout BridgedSwift?
+ ) {
+ }
+ static func _conditionallyBridgeFromObjectiveC(
+ _ x: BridgedObjC,
+ result: inout BridgedSwift?
+ ) -> Bool {
+ return true
+ }
+}
+
+func == (x: BridgedSwift, y: BridgedSwift) -> Bool { return true }
+
+// CHECK-LABEL: sil hidden @$S17collection_upcast15testArrayUpcast{{.*}}F :
+// CHECK: bb0([[ARRAY:%[0-9]+]] : $Array<BridgedObjC>):
+func testArrayUpcast(_ array: [BridgedObjC]) {
+ // CHECK: [[ARRAY_COPY:%.*]] = copy_value [[ARRAY]]
+ // CHECK: [[UPCAST_FN:%[0-9]+]] = function_ref @$Ss15_arrayForceCast{{.*}}F : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Array<τ_0_1>
+ // CHECK: [[RESULT:%.*]] = apply [[UPCAST_FN]]<BridgedObjC, AnyObject>([[ARRAY_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Array<τ_0_1>
+ // CHECK: destroy_value [[RESULT]]
+ // CHECK-NOT: destroy_value [[ARRAY]]
+ let anyObjectArr: [AnyObject] = array
+}
+// CHECK: } // end sil function '$S17collection_upcast15testArrayUpcast{{.*}}F'
+
+// CHECK-LABEL: sil hidden @$S17collection_upcast22testArrayUpcastBridged{{.*}}F
+// CHECK: bb0([[ARRAY:%[0-9]+]] : $Array<BridgedSwift>):
+func testArrayUpcastBridged(_ array: [BridgedSwift]) {
+ // CHECK: [[ARRAY_COPY:%.*]] = copy_value [[ARRAY]]
+ // CHECK: [[BRIDGE_FN:%[0-9]+]] = function_ref @$Ss15_arrayForceCast{{.*}}F : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Array<τ_0_1>
+ // CHECK: [[RESULT:%.*]] = apply [[BRIDGE_FN]]<BridgedSwift, AnyObject>([[ARRAY_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Array<τ_0_1>
+ // CHECK: destroy_value [[RESULT]]
+ // CHECK-NOT: destroy_value [[ARRAY]]
+ let anyObjectArr = array as [AnyObject]
+}
+// CHECK: } // end sil function '$S17collection_upcast22testArrayUpcastBridged{{.*}}F'
+
+// CHECK-LABEL: sil hidden @$S17collection_upcast20testDictionaryUpcast{{.*}}F
+// CHECK: bb0([[DICT:%[0-9]+]] : $Dictionary<BridgedObjC, BridgedObjC>):
+func testDictionaryUpcast(_ dict: Dictionary<BridgedObjC, BridgedObjC>) {
+ // CHECK: [[DICT_COPY:%.*]] = copy_value [[DICT]]
+ // CHECK: [[UPCAST_FN:%[0-9]+]] = function_ref @$Ss17_dictionaryUpCast{{.*}}F : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_0 : Hashable, τ_0_2 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned Dictionary<τ_0_2, τ_0_3>
+ // CHECK: [[RESULT:%.*]] = apply [[UPCAST_FN]]<BridgedObjC, BridgedObjC, NSObject, AnyObject>([[DICT_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_0 : Hashable, τ_0_2 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned Dictionary<τ_0_2, τ_0_3>
+ // CHECK: destroy_value [[RESULT]]
+ // CHECK-NOT: destroy_value [[DICT]]
+ let anyObjectDict: Dictionary<NSObject, AnyObject> = dict
+}
+
+// CHECK-LABEL: sil hidden @$S17collection_upcast27testDictionaryUpcastBridged{{.*}}F
+// CHECK: bb0([[DICT:%[0-9]+]] : $Dictionary<BridgedSwift, BridgedSwift>):
+func testDictionaryUpcastBridged(_ dict: Dictionary<BridgedSwift, BridgedSwift>) {
+ // CHECK: [[DICT_COPY:%.*]] = copy_value [[DICT]]
+ // CHECK: [[BRIDGE_FN:%[0-9]+]] = function_ref @$Ss17_dictionaryUpCast{{.*}}F
+ // CHECK: [[RESULT:%.*]] = apply [[BRIDGE_FN]]<BridgedSwift, BridgedSwift, NSObject, AnyObject>([[DICT_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_0 : Hashable, τ_0_2 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned Dictionary<τ_0_2, τ_0_3>
+ // CHECK: destroy_value [[RESULT]]
+ // CHECK-NOT: destroy_value [[DICT]]
+ let anyObjectDict = dict as Dictionary<NSObject, AnyObject>
+}
+
+// CHECK-LABEL: sil hidden @$S17collection_upcast13testSetUpcast{{.*}}F
+// CHECK: bb0([[SET:%[0-9]+]] : $Set<BridgedObjC>):
+func testSetUpcast(_ dict: Set<BridgedObjC>) {
+ // CHECK: [[SET_COPY:%.*]] = copy_value [[SET]]
+ // CHECK: [[BRIDGE_FN:%[0-9]+]] = function_ref @$Ss10_setUpCast{{.*}}F : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : Hashable, τ_0_1 : Hashable> (@guaranteed Set<τ_0_0>) -> @owned Set<τ_0_1>
+ // CHECK: [[RESULT:%.*]] = apply [[BRIDGE_FN]]<BridgedObjC, NSObject>([[SET_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : Hashable, τ_0_1 : Hashable> (@guaranteed Set<τ_0_0>) -> @owned Set<τ_0_1>
+ // CHECK: destroy_value [[RESULT]]
+ // CHECK-NOT: destroy_value [[SET]]
+ let anyObjectSet: Set<NSObject> = dict
+}
+
+// CHECK-LABEL: sil hidden @$S17collection_upcast20testSetUpcastBridged{{.*}}F
+// CHECK: bb0([[SET:%.*]] : $Set<BridgedSwift>):
+func testSetUpcastBridged(_ set: Set<BridgedSwift>) {
+ // CHECK: [[SET_COPY:%.*]] = copy_value [[SET]]
+ // CHECK: [[BRIDGE_FN:%[0-9]+]] = function_ref @$Ss10_setUpCast{{.*}}F
+ // CHECK: [[RESULT:%.*]] = apply [[BRIDGE_FN]]<BridgedSwift, NSObject>([[SET_COPY]]) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : Hashable, τ_0_1 : Hashable> (@guaranteed Set<τ_0_0>) -> @owned Set<τ_0_1>
+ // CHECK: destroy_value [[RESULT]]
+ // CHECK-NOT: destroy_value [[SET]]
+ let anyObjectSet = set as Set<NSObject>
+}
diff --git a/test/SILGen/plus_zero_constrained_extensions.swift b/test/SILGen/plus_zero_constrained_extensions.swift
new file mode 100644
index 0000000..c925a1e
--- /dev/null
+++ b/test/SILGen/plus_zero_constrained_extensions.swift
@@ -0,0 +1,226 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -primary-file %s | %FileCheck %s
+// RUN: %target-swift-frontend -emit-sil -O -primary-file %s > /dev/null
+// RUN: %target-swift-frontend -emit-ir -primary-file %s > /dev/null
+
+extension Array where Element == Int {
+ // CHECK-LABEL: sil @$SSa22constrained_extensionsSiRszlE1xSaySiGyt_tcfC : $@convention(method) (@thin Array<Int>.Type) -> @owned Array<Int>
+ public init(x: ()) {
+ self.init()
+ }
+
+ // CHECK-LABEL: sil @$SSa22constrained_extensionsSiRszlE16instancePropertySivg : $@convention(method) (@guaranteed Array<Int>) -> Int
+ // CHECK-LABEL: sil @$SSa22constrained_extensionsSiRszlE16instancePropertySivs : $@convention(method) (Int, @inout Array<Int>) -> ()
+ // CHECK-LABEL: sil shared [transparent] [serialized] @$SSa22constrained_extensionsSiRszlE16instancePropertySivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Array<Int>, @thick Array<Int>.Type) -> ()
+ // CHECK-LABEL: sil [transparent] [serialized] @$SSa22constrained_extensionsSiRszlE16instancePropertySivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Array<Int>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+
+ public var instanceProperty: Element {
+ get {
+ return self[0]
+ }
+ set {
+ self[0] = newValue
+ }
+ }
+
+ // CHECK-LABEL: sil @$SSa22constrained_extensionsSiRszlE14instanceMethodSiyF : $@convention(method) (@guaranteed Array<Int>) -> Int
+ public func instanceMethod() -> Element {
+ return instanceProperty
+ }
+
+ // CHECK-LABEL: sil @$SSa22constrained_extensionsSiRszlE14instanceMethod1eS2i_tF : $@convention(method) (Int, @guaranteed Array<Int>) -> Int
+ public func instanceMethod(e: Element) -> Element {
+ return e
+ }
+
+ // CHECK-LABEL: sil @$SSa22constrained_extensionsSiRszlE14staticPropertySivgZ : $@convention(method) (@thin Array<Int>.Type) -> Int
+ public static var staticProperty: Element {
+ return Array(x: ()).instanceProperty
+ }
+
+ // CHECK-LABEL: sil @$SSa22constrained_extensionsSiRszlE12staticMethodSiyFZ : $@convention(method) (@thin Array<Int>.Type) -> Int
+ public static func staticMethod() -> Element {
+ return staticProperty
+ }
+
+ // CHECK-LABEL: sil @$SSa22constrained_extensionsSiRszlE12staticMethod1eS2iSg_tFZfA_ : $@convention(thin) () -> Optional<Int>
+ // CHECK-LABEL: sil @$SSa22constrained_extensionsSiRszlE12staticMethod1eS2iSg_tFZ : $@convention(method) (Optional<Int>, @thin Array<Int>.Type) -> Int
+ public static func staticMethod(e: Element? = nil) -> Element {
+ return e!
+ }
+
+ // CHECK-LABEL: sil @$SSa22constrained_extensionsSiRszlEySiyt_tcig : $@convention(method) (@guaranteed Array<Int>) -> Int
+ public subscript(i: ()) -> Element {
+ return self[0]
+ }
+
+ // CHECK-LABEL: sil @$SSa22constrained_extensionsSiRszlE21inoutAccessOfPropertyyyF : $@convention(method) (@inout Array<Int>) -> ()
+ public mutating func inoutAccessOfProperty() {
+ func increment(x: inout Element) {
+ x += 1
+ }
+
+ increment(x: &instanceProperty)
+ }
+}
+
+extension Dictionary where Key == Int {
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlE1xABySiq_Gyt_tcfC : $@convention(method) <Key, Value where Key == Int> (@thin Dictionary<Int, Value>.Type) -> @owned Dictionary<Int, Value> {
+ public init(x: ()) {
+ self.init()
+ }
+
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlE16instancePropertyq_vg : $@convention(method) <Key, Value where Key == Int> (@guaranteed Dictionary<Int, Value>) -> @out Value
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlE16instancePropertyq_vs : $@convention(method) <Key, Value where Key == Int> (@in Value, @inout Dictionary<Int, Value>) -> ()
+ // CHECK-LABEL: sil shared [transparent] [serialized] @$Ss10DictionaryV22constrained_extensionsSiRszrlE16instancePropertyq_vmytfU_ : $@convention(method) <Key, Value where Key == Int> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Dictionary<Int, Value>, @thick Dictionary<Int, Value>.Type) -> ()
+ // CHECK-LABEL: sil [transparent] [serialized] @$Ss10DictionaryV22constrained_extensionsSiRszrlE16instancePropertyq_vm : $@convention(method) <Key, Value where Key == Int> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Dictionary<Int, Value>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ public var instanceProperty: Value {
+ get {
+ return self[0]!
+ }
+ set {
+ self[0] = newValue
+ }
+ }
+
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlE14instanceMethodq_yF : $@convention(method) <Key, Value where Key == Int> (@guaranteed Dictionary<Int, Value>) -> @out Value
+ public func instanceMethod() -> Value {
+ return instanceProperty
+ }
+
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlE14instanceMethod1vq_q__tF : $@convention(method) <Key, Value where Key == Int> (@in_guaranteed Value, @guaranteed Dictionary<Int, Value>) -> @out Value
+ public func instanceMethod(v: Value) -> Value {
+ return v
+ }
+
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlE12staticMethodSiyFZ : $@convention(method) <Key, Value where Key == Int> (@thin Dictionary<Int, Value>.Type) -> Int
+ public static func staticMethod() -> Key {
+ return staticProperty
+ }
+
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlE14staticPropertySivgZ : $@convention(method) <Key, Value where Key == Int> (@thin Dictionary<Int, Value>.Type) -> Int
+ public static var staticProperty: Key {
+ return 0
+ }
+
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlE12staticMethod1k1vq_SiSg_q_SgtFZfA_ : $@convention(thin) <Key, Value where Key == Int> () -> Optional<Int>
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlE12staticMethod1k1vq_SiSg_q_SgtFZfA0_ : $@convention(thin) <Key, Value where Key == Int> () -> @out Optional<Value>
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlE12staticMethod1k1vq_SiSg_q_SgtFZ : $@convention(method) <Key, Value where Key == Int> (Optional<Int>, @in_guaranteed Optional<Value>, @thin Dictionary<Int, Value>.Type) -> @out Value
+ public static func staticMethod(k: Key? = nil, v: Value? = nil) -> Value {
+ return v!
+ }
+
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlE17callsStaticMethodq_yFZ : $@convention(method) <Key, Value where Key == Int> (@thin Dictionary<Int, Value>.Type) -> @out Value
+ public static func callsStaticMethod() -> Value {
+ return staticMethod()
+ }
+
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlE16callsConstructorq_yFZ : $@convention(method) <Key, Value where Key == Int> (@thin Dictionary<Int, Value>.Type) -> @out Value
+ public static func callsConstructor() -> Value {
+ return Dictionary(x: ()).instanceMethod()
+ }
+
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlEyq_yt_tcig : $@convention(method) <Key, Value where Key == Int> (@guaranteed Dictionary<Int, Value>) -> @out Value
+ public subscript(i: ()) -> Value {
+ return self[0]!
+ }
+
+ // CHECK-LABEL: sil @$Ss10DictionaryV22constrained_extensionsSiRszrlE21inoutAccessOfPropertyyyF : $@convention(method) <Key, Value where Key == Int> (@inout Dictionary<Int, Value>) -> ()
+ public mutating func inoutAccessOfProperty() {
+ func increment(x: inout Value) { }
+
+ increment(x: &instanceProperty)
+ }
+}
+
+public class GenericClass<X, Y> {}
+
+extension GenericClass where Y == () {
+ // CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlE5valuexvg : $@convention(method) <X, Y where Y == ()> (@guaranteed GenericClass<X, ()>) -> @out X
+ // CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlE5valuexvs : $@convention(method) <X, Y where Y == ()> (@in X, @guaranteed GenericClass<X, ()>) -> ()
+ // CHECK-LABEL: sil shared [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlE5valuexvmytfU_ : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout GenericClass<X, ()>, @thick GenericClass<X, ()>.Type) -> ()
+ // CHECK-LABEL: sil [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlE5valuexvm : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed GenericClass<X, ()>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ public var value: X {
+ get { while true {} }
+ set {}
+ }
+
+ // CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlE5emptyytvg : $@convention(method) <X, Y where Y == ()> (@guaranteed GenericClass<X, ()>) -> ()
+ // CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlE5emptyytvs : $@convention(method) <X, Y where Y == ()> (@guaranteed GenericClass<X, ()>) -> ()
+ // CHECK-LABEL: sil shared [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlE5emptyytvmytfU_ : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout GenericClass<X, ()>, @thick GenericClass<X, ()>.Type) -> ()
+ // CHECK-LABEL: sil [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlE5emptyytvm : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed GenericClass<X, ()>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ public var empty: Y {
+ get { return () }
+ set {}
+ }
+
+ // CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlEyxyt_tcig : $@convention(method) <X, Y where Y == ()> (@guaranteed GenericClass<X, ()>) -> @out X
+ // CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlEyxyt_tcis : $@convention(method) <X, Y where Y == ()> (@in X, @guaranteed GenericClass<X, ()>) -> ()
+ // CHECK-LABEL: sil shared [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlEyxyt_tcimytfU_ : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout GenericClass<X, ()>, @thick GenericClass<X, ()>.Type) -> ()
+ // CHECK-LABEL: sil [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlEyxyt_tcim : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed GenericClass<X, ()>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ public subscript(_: Y) -> X {
+ get { while true {} }
+ set {}
+ }
+
+ // CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlEyyxcig : $@convention(method) <X, Y where Y == ()> (@in_guaranteed X, @guaranteed GenericClass<X, ()>) -> ()
+ // CHECK-LABEL: sil @$S22constrained_extensions12GenericClassCAAytRs_rlEyyxcis : $@convention(method) <X, Y where Y == ()> (@in X, @guaranteed GenericClass<X, ()>) -> ()
+ // CHECK-LABEL: sil shared [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlEyyxcimytfU_ : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout GenericClass<X, ()>, @thick GenericClass<X, ()>.Type) -> ()
+ // CHECK-LABEL: sil [transparent] [serialized] @$S22constrained_extensions12GenericClassCAAytRs_rlEyyxcim : $@convention(method) <X, Y where Y == ()> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed X, @guaranteed GenericClass<X, ()>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ public subscript(_: X) -> Y {
+ get { while true {} }
+ set {}
+ }
+}
+
+protocol VeryConstrained {}
+
+struct AnythingGoes<T> {
+ // CHECK-LABEL: sil hidden [transparent] @$S22constrained_extensions12AnythingGoesV13meaningOfLifexSgvpfi : $@convention(thin) <T> () -> @out Optional<T>
+ var meaningOfLife: T? = nil
+}
+
+extension AnythingGoes where T : VeryConstrained {
+ // CHECK-LABEL: sil hidden @$S22constrained_extensions12AnythingGoesVA2A15VeryConstrainedRzlE13fromExtensionACyxGyt_tcfC : $@convention(method) <T where T : VeryConstrained> (@thin AnythingGoes<T>.Type) -> @out AnythingGoes<T> {
+
+ // CHECK: [[INIT:%.*]] = function_ref @$S22constrained_extensions12AnythingGoesV13meaningOfLifexSgvpfi : $@convention(thin) <τ_0_0> () -> @out Optional<τ_0_0>
+ // CHECK: [[RESULT:%.*]] = alloc_stack $Optional<T>
+ // CHECK: apply [[INIT]]<T>([[RESULT]]) : $@convention(thin) <τ_0_0> () -> @out Optional<τ_0_0>
+ // CHECK: return
+ init(fromExtension: ()) {}
+}
+
+extension Array where Element == Int {
+ struct Nested {
+ // CHECK-LABEL: sil hidden [transparent] @$SSa22constrained_extensionsSiRszlE6NestedV1eSiSgvpfi : $@convention(thin) () -> Optional<Int>
+ var e: Element? = nil
+
+ // CHECK-LABEL: sil hidden @$SSa22constrained_extensionsSiRszlE6NestedV10hasDefault1eySiSg_tFfA_ : $@convention(thin) () -> Optional<Int>
+ // CHECK-LABEL: sil hidden @$SSa22constrained_extensionsSiRszlE6NestedV10hasDefault1eySiSg_tF : $@convention(method) (Optional<Int>, @inout Array<Int>.Nested) -> ()
+ mutating func hasDefault(e: Element? = nil) {
+ self.e = e
+ }
+ }
+}
+
+extension Array where Element == AnyObject {
+ class NestedClass {
+ // CHECK-LABEL: sil hidden @$SSa22constrained_extensionsyXlRszlE11NestedClassCfd : $@convention(method) (@guaranteed Array<AnyObject>.NestedClass) -> @owned Builtin.NativeObject
+ // CHECK-LABEL: sil hidden @$SSa22constrained_extensionsyXlRszlE11NestedClassCfD : $@convention(method) (@owned Array<AnyObject>.NestedClass) -> ()
+ deinit { }
+
+ // CHECK-LABEL: sil hidden @$SSa22constrained_extensionsyXlRszlE11NestedClassCACyyXl_GycfC : $@convention(method) (@thick Array<AnyObject>.NestedClass.Type) -> @owned Array<AnyObject>.NestedClass
+ // CHECK-LABEL: sil hidden @$SSa22constrained_extensionsyXlRszlE11NestedClassCACyyXl_Gycfc : $@convention(method) (@owned Array<AnyObject>.NestedClass) -> @owned Array<AnyObject>.NestedClass
+ }
+
+ class DerivedClass : NestedClass {
+ // CHECK-LABEL: sil hidden [transparent] @$SSa22constrained_extensionsyXlRszlE12DerivedClassC1eyXlSgvpfi : $@convention(thin) () -> @owned Optional<AnyObject>
+ // CHECK-LABEL: sil hidden @$SSa22constrained_extensionsyXlRszlE12DerivedClassCfE : $@convention(method) (@guaranteed Array<AnyObject>.DerivedClass) -> ()
+ var e: Element? = nil
+ }
+}
+
+func referenceNestedTypes() {
+ _ = Array<AnyObject>.NestedClass()
+ _ = Array<AnyObject>.DerivedClass()
+}
diff --git a/test/SILGen/plus_zero_default_arguments.swift b/test/SILGen/plus_zero_default_arguments.swift
new file mode 100644
index 0000000..ad5ff0e
--- /dev/null
+++ b/test/SILGen/plus_zero_default_arguments.swift
@@ -0,0 +1,378 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-silgen -swift-version 3 %s | %FileCheck %s
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-silgen -swift-version 3 %s | %FileCheck %s --check-prefix=NEGATIVE
+
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-silgen -swift-version 4 %s | %FileCheck %s
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-silgen -swift-version 4 %s | %FileCheck %s --check-prefix=NEGATIVE
+
+// __FUNCTION__ used as top-level parameter produces the module name.
+// CHECK-LABEL: sil @main
+// CHECK: string_literal utf16 "default_arguments"
+
+// Default argument for first parameter.
+// CHECK-LABEL: sil hidden @$S17default_arguments7defarg11i1d1sySi_SdSStFfA_ : $@convention(thin) () -> Int
+// CHECK: [[INT:%[0-9]+]] = metatype $@thin Int.Type
+// CHECK: [[LIT:%[0-9]+]] = integer_literal $Builtin.Int2048, 17
+// CHECK: [[CVT:%[0-9]+]] = function_ref @$SSi22_builtinIntegerLiteralSiBi{{[_0-9]*}}__tcfC
+// CHECK: [[RESULT:%[0-9]+]] = apply [[CVT]]([[LIT]], [[INT]]) : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int
+// CHECK: return [[RESULT]] : $Int
+
+// Default argument for third parameter.
+// CHECK-LABEL: sil hidden @$S17default_arguments7defarg11i1d1sySi_SdSStFfA1_ : $@convention(thin) () -> @owned String
+// CHECK: [[LIT:%[0-9]+]] = string_literal utf8 "Hello"
+// CHECK: [[LEN:%[0-9]+]] = integer_literal $Builtin.Word, 5
+// CHECK: [[STRING:%[0-9]+]] = metatype $@thin String.Type
+// CHECK: [[CVT:%[0-9]+]] = function_ref @$SSS21_builtinStringLiteral17utf8CodeUnitCount7isASCIISSBp_BwBi1_tcfC
+// CHECK: [[RESULT:%[0-9]+]] = apply [[CVT]]([[LIT]], [[LEN]], {{[^,]+}}, [[STRING]]) : $@convention(method)
+// CHECK: return [[RESULT]] : $String
+func defarg1(i: Int = 17, d: Double, s: String = "Hello") { }
+
+// CHECK-LABEL: sil hidden @$S17default_arguments15testDefaultArg1yyF
+func testDefaultArg1() {
+ // CHECK: [[FLOAT64:%[0-9]+]] = metatype $@thin Double.Type
+ // CHECK: [[FLOATLIT:%[0-9]+]] = float_literal $Builtin.FPIEEE{{64|80}}, {{0x4009000000000000|0x4000C800000000000000}}
+ // CHECK: [[LITFN:%[0-9]+]] = function_ref @$SSd20_builtinFloatLiteralSdBf{{[_0-9]*}}__tcfC
+ // CHECK: [[FLOATVAL:%[0-9]+]] = apply [[LITFN]]([[FLOATLIT]], [[FLOAT64]])
+ // CHECK: [[DEF0FN:%[0-9]+]] = function_ref @$S17default_arguments7defarg1{{.*}}A_
+ // CHECK: [[DEF0:%[0-9]+]] = apply [[DEF0FN]]()
+ // CHECK: [[DEF2FN:%[0-9]+]] = function_ref @$S17default_arguments7defarg1{{.*}}A1_
+ // CHECK: [[DEF2:%[0-9]+]] = apply [[DEF2FN]]()
+ // CHECK: [[BORROWED_DEF2:%.*]] = begin_borrow [[DEF2]]
+ // CHECK: [[FNREF:%[0-9]+]] = function_ref @$S17default_arguments7defarg1{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[FNREF]]([[DEF0]], [[FLOATVAL]], [[BORROWED_DEF2]])
+ defarg1(d:3.125)
+}
+
+func defarg2(_ i: Int, d: Double = 3.125, s: String = "Hello") { }
+
+// CHECK-LABEL: sil hidden @$S17default_arguments15testDefaultArg2{{[_0-9a-zA-Z]*}}F
+func testDefaultArg2() {
+// CHECK: [[INT64:%[0-9]+]] = metatype $@thin Int.Type
+// CHECK: [[INTLIT:%[0-9]+]] = integer_literal $Builtin.Int2048, 5
+// CHECK: [[LITFN:%[0-9]+]] = function_ref @$SSi22_builtinIntegerLiteralSiBi{{[_0-9]*}}__tcfC
+// CHECK: [[I:%[0-9]+]] = apply [[LITFN]]([[INTLIT]], [[INT64]]) : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int
+// CHECK: [[DFN:%[0-9]+]] = function_ref @$S17default_arguments7defarg2{{.*}}A0_ : $@convention(thin) () -> Double
+// CHECK: [[D:%[0-9]+]] = apply [[DFN]]() : $@convention(thin) () -> Double
+// CHECK: [[SFN:%[0-9]+]] = function_ref @$S17default_arguments7defarg2{{.*}}A1_ : $@convention(thin) () -> @owned String
+// CHECK: [[S:%[0-9]+]] = apply [[SFN]]() : $@convention(thin) () -> @owned String
+// CHECK: [[BORROWED_S:%.*]] = begin_borrow [[S]]
+// CHECK: [[FNREF:%[0-9]+]] = function_ref @$S17default_arguments7defarg2{{[_0-9a-zA-Z]*}}F : $@convention(thin) (Int, Double, @guaranteed String) -> ()
+// CHECK: apply [[FNREF]]([[I]], [[D]], [[BORROWED_S]]) : $@convention(thin) (Int, Double, @guaranteed String) -> ()
+ defarg2(5)
+}
+
+func autocloseFile(x: @autoclosure () -> String = #file,
+ y: @autoclosure () -> Int = #line) { }
+// CHECK-LABEL: sil hidden @$S17default_arguments17testAutocloseFileyyF
+func testAutocloseFile() {
+ // CHECK-LABEL: sil private [transparent] @$S17default_arguments17testAutocloseFileyyFSSyXKfu_ : $@convention(thin) () -> @owned String
+ // CHECK: string_literal utf16{{.*}}default_arguments.swift
+
+ // CHECK-LABEL: sil private [transparent] @$S17default_arguments17testAutocloseFileyyFSiyXKfu0_ : $@convention(thin) () -> Int
+ // CHECK: integer_literal $Builtin.Int2048, [[@LINE+1]]
+ autocloseFile()
+}
+
+func testMagicLiterals(file: String = #file,
+ function: String = #function,
+ line: Int = #line,
+ column: Int = #column) {}
+
+// Check that default argument generator functions don't leak information about
+// user's source.
+//
+// NEGATIVE-NOT: sil hidden @$S17default_arguments17testMagicLiteralsySS4file_SS8functionSi4lineSi6columntFfA_
+//
+// NEGATIVE-NOT: sil hidden @$S17default_arguments17testMagicLiteralsySS4file_SS8functionSi4lineSi6columntFfA0_
+//
+// NEGATIVE-NOT: sil hidden @$S17default_arguments17testMagicLiteralsySS4file_SS8functionSi4lineSi6columntFfA1_
+//
+// NEGATIVE-NOT: sil hidden @$S17default_arguments17testMagicLiteralsySS4file_SS8functionSi4lineSi6columntFfA2_
+
+func closure(_: () -> ()) {}
+func autoclosure(_: @autoclosure () -> ()) {}
+
+// CHECK-LABEL: sil hidden @$S17default_arguments25testCallWithMagicLiteralsyyF
+// CHECK: string_literal utf16 "testCallWithMagicLiterals()"
+// CHECK: string_literal utf16 "testCallWithMagicLiterals()"
+// CHECK-LABEL: sil private @$S17default_arguments25testCallWithMagicLiteralsyyFyyXEfU_
+// CHECK: string_literal utf16 "testCallWithMagicLiterals()"
+// CHECK-LABEL: sil private [transparent] @$S17default_arguments25testCallWithMagicLiteralsyyFyyXKfu_
+// CHECK: string_literal utf16 "testCallWithMagicLiterals()"
+func testCallWithMagicLiterals() {
+ testMagicLiterals()
+ testMagicLiterals()
+ closure { testMagicLiterals() }
+ autoclosure(testMagicLiterals())
+}
+
+// CHECK-LABEL: sil hidden @$S17default_arguments25testPropWithMagicLiteralsSivg
+// CHECK: string_literal utf16 "testPropWithMagicLiterals"
+var testPropWithMagicLiterals: Int {
+ testMagicLiterals()
+ closure { testMagicLiterals() }
+ autoclosure(testMagicLiterals())
+ return 0
+}
+
+class Foo {
+
+ // CHECK-LABEL: sil hidden @$S17default_arguments3FooC3int6stringACSi_SStcfc : $@convention(method) (Int, @owned String, @owned Foo) -> @owned Foo
+ // CHECK: string_literal utf16 "init(int:string:)"
+ init(int: Int, string: String = #function) {
+ testMagicLiterals()
+ closure { testMagicLiterals() }
+ autoclosure(testMagicLiterals())
+ }
+
+ // CHECK-LABEL: sil hidden @$S17default_arguments3FooCfd
+ // CHECK: string_literal utf16 "deinit"
+ deinit {
+ testMagicLiterals()
+ closure { testMagicLiterals() }
+ autoclosure(testMagicLiterals())
+ }
+
+ // CHECK-LABEL: sil hidden @$S17default_arguments3FooCyS2icig
+ // CHECK: string_literal utf16 "subscript"
+ subscript(x: Int) -> Int {
+ testMagicLiterals()
+ closure { testMagicLiterals() }
+ autoclosure(testMagicLiterals())
+ return x
+ }
+
+ // CHECK-LABEL: sil private @globalinit_33_E52D764B1F2009F2390B2B8DF62DAEB8_func0
+ // CHECK: string_literal utf16 "Foo"
+ static let x = Foo(int:0)
+
+}
+
+// Test at top level.
+testMagicLiterals()
+closure { testMagicLiterals() }
+autoclosure(testMagicLiterals())
+
+// CHECK: string_literal utf16 "default_arguments"
+let y : String = #function
+
+// CHECK-LABEL: sil hidden @$S17default_arguments16testSelectorCall_17withMagicLiteralsySi_SitF
+// CHECK: string_literal utf16 "testSelectorCall(_:withMagicLiterals:)"
+func testSelectorCall(_ x: Int, withMagicLiterals y: Int) {
+ testMagicLiterals()
+}
+
+// CHECK-LABEL: sil hidden @$S17default_arguments32testSelectorCallWithUnnamedPieceyySi_SitF
+// CHECK: string_literal utf16 "testSelectorCallWithUnnamedPiece"
+func testSelectorCallWithUnnamedPiece(_ x: Int, _ y: Int) {
+ testMagicLiterals()
+}
+
+// Test default arguments in an inherited subobject initializer
+class SuperDefArg {
+ init(int i: Int = 10) { }
+}
+
+// CHECK: sil hidden @$S17default_arguments11SuperDefArgC3intACSi_tcfcfA_ : $@convention(thin) () -> Int
+
+// CHECK-NOT: sil hidden @$S17default_arguments9SubDefArgCAC3intSi_tcfcfA_ : $@convention(thin) () -> Int
+
+class SubDefArg : SuperDefArg { }
+
+// CHECK: sil hidden @$S17default_arguments13testSubDefArgAA0deF0CyF : $@convention(thin) () -> @owned SubDefArg
+func testSubDefArg() -> SubDefArg {
+ // CHECK: function_ref @$S17default_arguments11SuperDefArgC3intACSi_tcfcfA_
+ // CHECK: function_ref @$S17default_arguments9SubDefArgC{{[_0-9a-zA-Z]*}}fC
+ // CHECK: return
+ return SubDefArg()
+}
+
+// CHECK-NOT: sil hidden @$S17default_arguments9SubDefArgCACSi3int_tcfcfA_ : $@convention(thin) () -> Int
+
+// <rdar://problem/17379550>
+func takeDefaultArgUnnamed(_ x: Int = 5) { }
+
+// CHECK-LABEL: sil hidden @$S17default_arguments25testTakeDefaultArgUnnamed{{[_0-9a-zA-Z]*}}F
+func testTakeDefaultArgUnnamed(_ i: Int) {
+ // CHECK: bb0([[I:%[0-9]+]] : @trivial $Int):
+ // CHECK: [[FN:%[0-9]+]] = function_ref @$S17default_arguments21takeDefaultArgUnnamedyySiF : $@convention(thin) (Int) -> ()
+ // CHECK: apply [[FN]]([[I]]) : $@convention(thin) (Int) -> ()
+ takeDefaultArgUnnamed(i)
+}
+
+func takeDSOHandle(_ handle: UnsafeRawPointer = #dsohandle) { }
+
+// CHECK-LABEL: sil hidden @$S17default_arguments13testDSOHandleyyF
+func testDSOHandle() {
+ // CHECK: [[DSO_HANDLE:%[0-9]+]] = global_addr @__dso_handle : $*Builtin.RawPointer
+ takeDSOHandle()
+}
+
+// Test __FUNCTION__ in an extension initializer. rdar://problem/19792181
+extension SuperDefArg {
+ static let extensionInitializerWithClosure: Int = { return 22 }()
+}
+
+
+// <rdar://problem/19086357> SILGen crashes reabstracting default argument closure in members
+class ReabstractDefaultArgument<T> {
+ init(a: (T, T) -> Bool = { _, _ in true }) {
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S17default_arguments32testDefaultArgumentReabstractionyyF
+// function_ref default_arguments.ReabstractDefaultArgument.__allocating_init <A>(default_arguments.ReabstractDefaultArgument<A>.Type)(a : (A, A) -> Swift.Bool) -> default_arguments.ReabstractDefaultArgument<A>
+// CHECK: [[FN:%.*]] = function_ref @$S17default_arguments25ReabstractDefaultArgument{{.*}} : $@convention(thin) <τ_0_0> () -> @owned @callee_guaranteed (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0) -> Bool
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[FN]]<Int>() : $@convention(thin) <τ_0_0> () -> @owned @callee_guaranteed (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0) -> Bool
+// CHECK-NEXT: function_ref reabstraction thunk helper from @escaping @callee_guaranteed (@in_guaranteed Swift.Int, @in_guaranteed Swift.Int) -> (@unowned Swift.Bool) to @escaping @callee_guaranteed (@unowned Swift.Int, @unowned Swift.Int) -> (@unowned Swift.Bool)
+// CHECK-NEXT: [[THUNK:%.*]] = function_ref @$SS2iSbIegnnd_S2iSbIegyyd_TR : $@convention(thin) (Int, Int, @guaranteed @callee_guaranteed (@in_guaranteed Int, @in_guaranteed Int) -> Bool) -> Bool
+// CHECK-NEXT: [[FN:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[RESULT]]) : $@convention(thin) (Int, Int, @guaranteed @callee_guaranteed (@in_guaranteed Int, @in_guaranteed Int) -> Bool) -> Bool
+// CHECK-NEXT: [[CONV_FN:%.*]] = convert_escape_to_noescape [[FN]]
+// function_ref reabstraction thunk helper from @callee_guaranteed (@unowned Swift.Int, @unowned Swift.Int) -> (@unowned Swift.Bool) to @callee_guaranteed (@in_guaranteed Swift.Int, @in_guaranteed Swift.Int) -> (@unowned Swift.Bool)
+// CHECK: [[THUNK:%.*]] = function_ref @$SS2iSbIgyyd_S2iSbIegnnd_TR : $@convention(thin) (@in_guaranteed Int, @in_guaranteed Int, @noescape @callee_guaranteed (Int, Int) -> Bool) -> Bool
+// CHECK-NEXT: [[FN:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[CONV_FN]]) : $@convention(thin) (@in_guaranteed Int, @in_guaranteed Int, @noescape @callee_guaranteed (Int, Int) -> Bool) -> Bool
+// CHECK-NEXT: [[CONV_FN:%.*]] = convert_escape_to_noescape [[FN]]
+// CHECK: [[INITFN:%[0-9]+]] = function_ref @$S17default_arguments25ReabstractDefaultArgumentC{{[_0-9a-zA-Z]*}}fC
+// CHECK-NEXT: apply [[INITFN]]<Int>([[CONV_FN]],
+
+func testDefaultArgumentReabstraction() {
+ _ = ReabstractDefaultArgument<Int>()
+}
+
+// <rdar://problem/20494437> SILGen crash handling default arguments
+// CHECK-LABEL: sil hidden @$S17default_arguments18r20494437onSuccessyyAA25r20494437ExecutionContext_pF
+// CHECK: function_ref @$S17default_arguments19r20494437onCompleteyyAA25r20494437ExecutionContext_pF
+// <rdar://problem/20494437> SILGen crash handling default arguments
+protocol r20494437ExecutionContext {}
+let r20494437Default: r20494437ExecutionContext
+func r20494437onComplete(_ executionContext: r20494437ExecutionContext = r20494437Default) {}
+func r20494437onSuccess(_ a: r20494437ExecutionContext) {
+ r20494437onComplete(a)
+}
+
+// <rdar://problem/18400194> Parenthesized function expression crashes the compiler
+func r18400194(_ a: Int, x: Int = 97) {}
+
+// CHECK-LABEL: sil hidden @$S17default_arguments9r18400194_1xySi_SitFfA0_
+// CHECK: integer_literal $Builtin.Int2048, 97
+
+// CHECK-LABEL: sil hidden @$S17default_arguments14test_r18400194yyF
+// CHECK: integer_literal $Builtin.Int2048, 1
+// CHECK: function_ref @$S17default_arguments9r18400194_1xySi_SitFfA0_ : $@convention(thin) () -> Int
+// CHECK: function_ref @$S17default_arguments9r18400194_1xySi_SitF : $@convention(thin) (Int, Int) -> (){{.*}}
+func test_r18400194() {
+ (r18400194)(1)
+}
+
+// rdar://24242783
+// Don't add capture arguments to local default argument generators.
+func localFunctionWithDefaultArg() {
+ var z = 5
+ func bar(_ x: Int? = nil) {
+ z += 1
+ }
+ bar()
+}
+// CHECK-LABEL: sil private @$S17default_arguments27localFunctionWithDefaultArgyyF3barL_yySiSgFfA_
+// CHECK-SAME: $@convention(thin) () -> Optional<Int>
+
+// CHECK-LABEL: sil hidden @$S17default_arguments15throwingDefault7closureySbyKXE_tKFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> (Bool, @error Error)
+func throwingDefault(closure: () throws -> Bool = { return true }) throws {
+ try _ = closure()
+}
+
+// CHECK-LABEL: sil hidden @$S17default_arguments26throwingAutoclosureDefault7closureySbyKXK_tKFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> (Bool, @error Error)
+func throwingAutoclosureDefault(closure: @autoclosure () throws -> Bool = true ) throws {
+ try _ = closure()
+}
+
+// CHECK-LABEL: sil hidden @$S17default_arguments0A3Arg7closureySbyXE_tFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> Bool
+func defaultArg(closure: () -> Bool = { return true }) {
+ _ = closure()
+}
+
+// CHECK-LABEL: sil hidden @$S17default_arguments21autoclosureDefaultArg7closureySbyXK_tFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> Bool
+func autoclosureDefaultArg(closure: @autoclosure () -> Bool = true ) {
+ _ = closure()
+}
+
+// CHECK-LABEL: sil hidden @$S17default_arguments23throwingDefaultEscaping7closureySbyKc_tKFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> (Bool, @error Error)
+func throwingDefaultEscaping(closure: @escaping () throws -> Bool = { return true }) throws {
+ try _ = closure()
+}
+
+// CHECK-LABEL: sil hidden @$S17default_arguments34throwingAutoclosureDefaultEscaping7closureySbyKXA_tKFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> (Bool, @error Error)
+func throwingAutoclosureDefaultEscaping(closure: @escaping @autoclosure () throws -> Bool = true ) throws {
+ try _ = closure()
+}
+
+// CHECK-LABEL: sil hidden @$S17default_arguments0A8Escaping7closureySbyc_tFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> Bool
+func defaultEscaping(closure: @escaping () -> Bool = { return true }) {
+ _ = closure()
+}
+
+// CHECK-LABEL: sil hidden @$S17default_arguments26autoclosureDefaultEscaping7closureySbyXA_tFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> Bool {
+func autoclosureDefaultEscaping(closure: @escaping @autoclosure () -> Bool = true ) {
+ _ = closure()
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}callThem{{.*}} : $@convention(thin) () -> @error Error
+
+// CHECK: [[F:%.*]] = function_ref @$S17default_arguments15throwingDefault7closureySbyKXE_tKFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> (Bool, @error Error)
+// CHECK: [[C:%.*]] = apply [[F]]() : $@convention(thin) () -> @owned @callee_guaranteed () -> (Bool, @error Error)
+// CHECK: [[E:%.*]] = convert_escape_to_noescape [[C]]
+// CHECK: [[R:%.*]] = function_ref @$S17default_arguments15throwingDefault7closureySbyKXE_tKF : $@convention(thin) (@noescape @callee_guaranteed () -> (Bool, @error Error)) -> @error Error
+// CHECK: try_apply [[R]]([[E]])
+
+// CHECK: [[F:%.*]] = function_ref @$S17default_arguments26throwingAutoclosureDefault7closureySbyKXK_tKFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> (Bool, @error Error)
+// CHECK: [[C:%.*]] = apply [[F]]() : $@convention(thin) () -> @owned @callee_guaranteed () -> (Bool, @error Error)
+// CHECK: [[E:%.*]] = convert_escape_to_noescape [[C]]
+// CHECK: [[R:%.*]] = function_ref @$S17default_arguments26throwingAutoclosureDefault7closureySbyKXK_tKF : $@convention(thin) (@noescape @callee_guaranteed () -> (Bool, @error Error)) -> @error Error
+// CHECK: try_apply [[R]]([[E]])
+
+// CHECK: [[F:%.*]] = function_ref @$S17default_arguments0A3Arg7closureySbyXE_tFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> Bool
+// CHECK: [[C:%.*]] = apply [[F]]() : $@convention(thin) () -> @owned @callee_guaranteed () -> Bool
+// CHECK: [[E:%.*]] = convert_escape_to_noescape [[C]]
+// CHECK: [[R:%.*]] = function_ref @$S17default_arguments0A3Arg7closureySbyXE_tF : $@convention(thin) (@noescape @callee_guaranteed () -> Bool) -> ()
+// CHECK: apply [[R]]([[E]])
+
+// CHECK: [[F:%.*]] = function_ref @$S17default_arguments21autoclosureDefaultArg7closureySbyXK_tFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> Boo
+// CHECK: [[C:%.*]] = apply [[F]]() : $@convention(thin) () -> @owned @callee_guaranteed () -> Bool
+// CHECK: [[E:%.*]] = convert_escape_to_noescape [[C]]
+// CHECK: [[R:%.*]] = function_ref @$S17default_arguments21autoclosureDefaultArg7closureySbyXK_tF : $@convention(thin) (@noescape @callee_guaranteed () -> Bool) -> ()
+// CHECK: apply [[R]]([[E]])
+
+// CHECK: [[F:%.*]] = function_ref @$S17default_arguments23throwingDefaultEscaping7closureySbyKc_tKFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> (Bool, @error Error)
+// CHECK: [[E:%.*]] = apply [[F]]() : $@convention(thin) () -> @owned @callee_guaranteed () -> (Bool, @error Error)
+// CHECK: [[BORROWED_E:%.*]] = begin_borrow [[E]]
+// CHECK: [[R:%.*]] = function_ref @$S17default_arguments23throwingDefaultEscaping7closureySbyKc_tKF : $@convention(thin) (@guaranteed @callee_guaranteed () -> (Bool, @error Error)) -> @error Erro
+// CHECK: try_apply [[R]]([[BORROWED_E]])
+
+// CHECK: [[F:%.*]] = function_ref @$S17default_arguments34throwingAutoclosureDefaultEscaping7closureySbyKXA_tKFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> (Bool, @error Error)
+// CHECK: [[E:%.*]] = apply [[F]]() : $@convention(thin) () -> @owned @callee_guaranteed () -> (Bool, @error Error)
+// CHECK: [[BORROWED_E:%.*]] = begin_borrow [[E]]
+// CHECK: [[R:%.*]] = function_ref @$S17default_arguments34throwingAutoclosureDefaultEscaping7closureySbyKXA_tKF : $@convention(thin) (@guaranteed @callee_guaranteed () -> (Bool, @error Error)) -> @error Error
+// CHECK: try_apply [[R]]([[BORROWED_E]])
+
+// CHECK: [[F:%.*]] = function_ref @$S17default_arguments0A8Escaping7closureySbyc_tFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> Bool
+// CHECK: [[E:%.*]] = apply [[F]]() : $@convention(thin) () -> @owned @callee_guaranteed () -> Bool
+// CHECK: [[BORROWED_E:%.*]] = begin_borrow [[E]]
+// CHECK: [[R:%.*]] = function_ref @$S17default_arguments0A8Escaping7closureySbyc_tF : $@convention(thin) (@guaranteed @callee_guaranteed () -> Bool) -> ()
+// CHECK: apply [[R]]([[BORROWED_E]])
+
+// CHECK: [[F:%.*]] = function_ref @$S17default_arguments26autoclosureDefaultEscaping7closureySbyXA_tFfA_ : $@convention(thin) () -> @owned @callee_guaranteed () -> Bool
+// CHECK: [[E:%.*]] = apply [[F]]() : $@convention(thin) () -> @owned @callee_guaranteed () -> Bool
+// CHECK: [[BORROWED_E:%.*]] = begin_borrow [[E]]
+// CHECK: [[R:%.*]] = function_ref @$S17default_arguments26autoclosureDefaultEscaping7closureySbyXA_tF : $@convention(thin) (@guaranteed @callee_guaranteed () -> Bool) -> ()
+// CHECK: apply [[R]]([[BORROWED_E]])
+
+func callThem() throws {
+ try throwingDefault()
+ try throwingAutoclosureDefault()
+ defaultArg()
+ autoclosureDefaultArg()
+ try throwingDefaultEscaping()
+ try throwingAutoclosureDefaultEscaping()
+ defaultEscaping()
+ autoclosureDefaultEscaping()
+}
diff --git a/test/SILGen/plus_zero_default_arguments_generic.swift b/test/SILGen/plus_zero_default_arguments_generic.swift
new file mode 100644
index 0000000..b382f5b
--- /dev/null
+++ b/test/SILGen/plus_zero_default_arguments_generic.swift
@@ -0,0 +1,66 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -swift-version 3 %s | %FileCheck %s
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -swift-version 4 %s | %FileCheck %s
+
+func foo<T: ExpressibleByIntegerLiteral>(_: T.Type, x: T = 0) { }
+
+struct Zim<T: ExpressibleByIntegerLiteral> {
+ init(x: T = 0) { }
+ init<U: ExpressibleByFloatLiteral>(_ x: T = 0, y: U = 0.5) { }
+
+ static func zim(x: T = 0) { }
+ static func zang<U: ExpressibleByFloatLiteral>(_: U.Type, _ x: T = 0, y: U = 0.5) { }
+}
+
+// CHECK-LABEL: sil hidden @$S25default_arguments_generic3baryyF : $@convention(thin) () -> () {
+func bar() {
+ // CHECK: [[FOO_DFLT:%.*]] = function_ref @$S25default_arguments_generic3foo
+ // CHECK: apply [[FOO_DFLT]]<Int>
+ foo(Int.self)
+ // CHECK: [[ZIM_DFLT:%.*]] = function_ref @$S25default_arguments_generic3ZimV3zim
+ // CHECK: apply [[ZIM_DFLT]]<Int>
+ Zim<Int>.zim()
+ // CHECK: [[ZANG_DFLT_0:%.*]] = function_ref @$S25default_arguments_generic3ZimV4zang{{.*}}A0_
+ // CHECK: apply [[ZANG_DFLT_0]]<Int, Double>
+ // CHECK: [[ZANG_DFLT_1:%.*]] = function_ref @$S25default_arguments_generic3ZimV4zang{{.*}}A1_
+ // CHECK: apply [[ZANG_DFLT_1]]<Int, Double>
+ Zim<Int>.zang(Double.self)
+ // CHECK: [[ZANG_DFLT_1:%.*]] = function_ref @$S25default_arguments_generic3ZimV4zang{{.*}}A1_
+ // CHECK: apply [[ZANG_DFLT_1]]<Int, Double>
+ Zim<Int>.zang(Double.self, 22)
+}
+
+protocol Initializable {
+ init()
+}
+struct Generic<T: Initializable> {
+ init(_ value: T = T()) {}
+}
+struct InitializableImpl: Initializable {
+ init() {}
+}
+// CHECK-LABEL: sil hidden @$S25default_arguments_generic17testInitializableyyF
+func testInitializable() {
+ // The ".init" is required to trigger the crash that used to happen.
+ _ = Generic<InitializableImpl>.init()
+ // CHECK: function_ref @$S25default_arguments_generic7GenericVyACyxGxcfcfA_ : $@convention(thin) <τ_0_0 where τ_0_0 : Initializable> () -> @out τ_0_0
+ // CHECK: [[INIT:%.+]] = function_ref @$S25default_arguments_generic7GenericVyACyxGxcfC
+ // CHECK: apply [[INIT]]<InitializableImpl>({{%.+}}, {{%.+}}) : $@convention(method) <τ_0_0 where τ_0_0 : Initializable> (@in τ_0_0, @thin Generic<τ_0_0>.Type) -> Generic<τ_0_0>
+} // CHECK: end sil function '$S25default_arguments_generic17testInitializableyyF'
+
+// Local generic functions with default arguments
+
+// CHECK-LABEL: sil hidden @$S25default_arguments_generic5outer1tyx_tlF : $@convention(thin) <T> (@in_guaranteed T) -> ()
+func outer<T>(t: T) {
+ func inner1(x: Int = 0) {}
+
+ // CHECK: [[ARG_GENERATOR:%.*]] = function_ref @$S25default_arguments_generic5outer1tyx_tlF6inner1L_1xySi_tlFfA_ : $@convention(thin) () -> Int
+ // CHECK: [[ARG:%.*]] = apply [[ARG_GENERATOR]]() : $@convention(thin) () -> Int
+ _ = inner1()
+
+ func inner2(x: Int = 0) { _ = T.self }
+
+ // CHECK: [[ARG_GENERATOR:%.*]] = function_ref @$S25default_arguments_generic5outer1tyx_tlF6inner2L_1xySi_tlFfA_ : $@convention(thin) <τ_0_0> () -> Int
+ // CHECK: [[ARG:%.*]] = apply [[ARG_GENERATOR]]<T>() : $@convention(thin) <τ_0_0> () -> Int
+ _ = inner2()
+}
diff --git a/test/SILGen/plus_zero_default_arguments_serialized.swift b/test/SILGen/plus_zero_default_arguments_serialized.swift
new file mode 100644
index 0000000..1472952
--- /dev/null
+++ b/test/SILGen/plus_zero_default_arguments_serialized.swift
@@ -0,0 +1,62 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module-path %t/default_arguments_other.swiftmodule -emit-module -swift-version 4 -primary-file %S/Inputs/default_arguments_other.swift
+
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-silgen -swift-version 3 -I %t %s | %FileCheck %s --check-prefix=SWIFT3 --check-prefix=CHECK
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-silgen -swift-version 4 -I %t %s | %FileCheck %s --check-prefix=SWIFT4 --check-prefix=CHECK
+
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-sil -O -swift-version 3 -I %t %s | %FileCheck %s --check-prefix=OPT
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -enable-sil-ownership -emit-sil -O -swift-version 4 -I %t %s | %FileCheck %s --check-prefix=OPT
+
+// Check that default arguments are serialized in Swift 4 mode.
+
+import default_arguments_other
+
+// CHECK-LABEL: sil @$S28default_arguments_serialized0A6StringSSyF : $@convention(thin) () -> @owned String
+public func defaultString() -> String { return "hi" }
+
+// SWIFT3-LABEL: sil @$S28default_arguments_serialized19hasDefaultArguments1x1yySi_SStFfA_ : $@convention(thin) () -> Int
+// SWIFT4-LABEL: sil non_abi [serialized] @$S28default_arguments_serialized19hasDefaultArguments1x1yySi_SStFfA_ : $@convention(thin) () -> Int
+
+// SWIFT3-LABEL: sil @$S28default_arguments_serialized19hasDefaultArguments1x1yySi_SStFfA0_ : $@convention(thin) () -> @owned String
+// SWIFT4-LABEL: sil non_abi [serialized] @$S28default_arguments_serialized19hasDefaultArguments1x1yySi_SStFfA0_ : $@convention(thin) () -> @owned String
+
+public func hasDefaultArguments(x: Int = 0, y: String = defaultString()) {}
+
+// CHECK-LABEL: sil @$S28default_arguments_serialized21callsDefaultArgumentsyyF : $@convention(thin) () -> ()
+// CHECK: function_ref @$S28default_arguments_serialized19hasDefaultArguments1x1yySi_SStFfA_ : $@convention(thin) () -> Int
+// CHECK: function_ref @$S28default_arguments_serialized19hasDefaultArguments1x1yySi_SStFfA0_ : $@convention(thin) () -> @owned String
+// CHECK: function_ref @$S28default_arguments_serialized19hasDefaultArguments1x1yySi_SStF : $@convention(thin) (Int, @guaranteed String) -> ()
+// CHECK: apply
+// CHECK: return
+public func callsDefaultArguments() {
+ hasDefaultArguments()
+}
+
+// When calling a default argument generator for a function in another module
+// that was built in Swift 4 mode, we should always treat it as serialized,
+// even if *this* module is built in Swift 3 mode.
+
+// CHECK-LABEL: sil @$S28default_arguments_serialized26callsOtherDefaultArgumentsyyF : $@convention(thin) () -> ()
+// CHECK: function_ref @$S23default_arguments_other0C16DefaultArguments1xySi_tFfA_ : $@convention(thin) () -> Int
+// CHECK: function_ref @$S23default_arguments_other0C16DefaultArguments1xySi_tF : $@convention(thin) (Int) -> ()
+// CHECK: apply
+// CHECK: return
+
+// Make sure the optimizer inlines the default argument generator from the
+// other module.
+
+// OPT-LABEL: sil @$S28default_arguments_serialized26callsOtherDefaultArgumentsyyF : $@convention(thin) () -> ()
+// OPT: [[INT_VAL:%.*]] = integer_literal [[INT_TYPE:\$Builtin.Int(32|64)]], 0
+// OPT: [[INT:%.*]] = struct $Int ([[INT_VAL]] : [[INT_TYPE]]
+// OPT: [[FN:%.*]] = function_ref @$S23default_arguments_other0C16DefaultArguments1xySi_tF : $@convention(thin) (Int) -> ()
+// OPT: apply [[FN]]([[INT]]) : $@convention(thin) (Int) -> ()
+// OPT: return
+public func callsOtherDefaultArguments() {
+ otherDefaultArguments()
+}
+
+// CHECK-LABEL: sil hidden_external [serialized] @$S23default_arguments_other0C16DefaultArguments1xySi_tFfA_ : $@convention(thin) () -> Int
+
+// CHECK-LABEL: sil @$S23default_arguments_other0C16DefaultArguments1xySi_tF : $@convention(thin) (Int) -> ()
+
diff --git a/test/SILGen/plus_zero_dependent_member_lowering.swift b/test/SILGen/plus_zero_dependent_member_lowering.swift
new file mode 100644
index 0000000..be5785f
--- /dev/null
+++ b/test/SILGen/plus_zero_dependent_member_lowering.swift
@@ -0,0 +1,22 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+protocol P {
+ associatedtype A
+
+ func f(_ x: A)
+}
+struct Foo<T>: P {
+ typealias A = T.Type
+
+ func f(_ t: T.Type) {}
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S25dependent_member_lowering3FooVyxGAA1PA2aEP1fyy1AQzFTW : $@convention(witness_method: P) <τ_0_0> (@in_guaranteed @thick τ_0_0.Type, @in_guaranteed Foo<τ_0_0>) -> ()
+ // CHECK: bb0(%0 : @trivial $*@thick τ_0_0.Type, %1 : @trivial $*Foo<τ_0_0>):
+}
+struct Bar<T>: P {
+ typealias A = (Int) -> T
+
+ func f(_ t: @escaping (Int) -> T) {}
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S25dependent_member_lowering3BarVyxGAA1PA2aEP1fyy1AQzFTW : $@convention(witness_method: P) <τ_0_0> (@in_guaranteed @callee_guaranteed (@in_guaranteed Int) -> @out τ_0_0, @in_guaranteed Bar<τ_0_0>) -> ()
+ // CHECK: bb0(%0 : @trivial $*@callee_guaranteed (@in_guaranteed Int) -> @out τ_0_0, %1 : @trivial $*Bar<τ_0_0>):
+}
diff --git a/test/SILGen/plus_zero_downcast_reabstraction.swift b/test/SILGen/plus_zero_downcast_reabstraction.swift
new file mode 100644
index 0000000..52608d2
--- /dev/null
+++ b/test/SILGen/plus_zero_downcast_reabstraction.swift
@@ -0,0 +1,28 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+// CHECK-LABEL: sil hidden @$S22downcast_reabstraction19condFunctionFromAnyyyypF
+// CHECK: checked_cast_addr_br take_always Any in [[IN:%.*]] : $*Any to () -> () in [[OUT:%.*]] : $*@callee_guaranteed (@in_guaranteed ()) -> @out (), [[YES:bb[0-9]+]], [[NO:bb[0-9]+]]
+// CHECK: [[YES]]:
+// CHECK: [[ORIG_VAL:%.*]] = load [take] [[OUT]]
+// CHECK: [[REABSTRACT:%.*]] = function_ref @$SytytIegnr_Ieg_TR
+// CHECK: [[SUBST_VAL:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACT]]([[ORIG_VAL]])
+
+func condFunctionFromAny(_ x: Any) {
+ if let f = x as? () -> () {
+ f()
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S22downcast_reabstraction21uncondFunctionFromAnyyyypF : $@convention(thin) (@in_guaranteed Any) -> () {
+// CHECK: unconditional_checked_cast_addr Any in [[IN:%.*]] : $*Any to () -> () in [[OUT:%.*]] : $*@callee_guaranteed (@in_guaranteed ()) -> @out ()
+// CHECK: [[ORIG_VAL:%.*]] = load [take] [[OUT]]
+// CHECK: [[REABSTRACT:%.*]] = function_ref @$SytytIegnr_Ieg_TR
+// CHECK: [[SUBST_VAL:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACT]]([[ORIG_VAL]])
+// CHECK: [[BORROW:%.*]] = begin_borrow [[SUBST_VAL]]
+// CHECK: apply [[BORROW]]()
+// CHECK: end_borrow [[BORROW]] from [[SUBST_VAL]]
+// CHECK: destroy_value [[SUBST_VAL]]
+func uncondFunctionFromAny(_ x: Any) {
+ (x as! () -> ())()
+}
diff --git a/test/SILGen/plus_zero_dynamic.swift b/test/SILGen/plus_zero_dynamic.swift
new file mode 100644
index 0000000..2376ae7
--- /dev/null
+++ b/test/SILGen/plus_zero_dynamic.swift
@@ -0,0 +1,557 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %build-silgen-test-overlays
+
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -Xllvm -sil-full-demangle -primary-file %s %S/Inputs/dynamic_other.swift -emit-silgen | %FileCheck %s
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -Xllvm -sil-full-demangle -primary-file %s %S/Inputs/dynamic_other.swift -emit-sil -verify
+
+// REQUIRES: objc_interop
+
+import Foundation
+import gizmo
+
+class Foo: Proto {
+ // Not objc or dynamic, so only a vtable entry
+ init(native: Int) {}
+ func nativeMethod() {}
+ var nativeProp: Int = 0
+ subscript(native native: Int) -> Int {
+ get { return native }
+ set {}
+ }
+
+ // @objc, so it has an ObjC entry point but can also be dispatched
+ // by vtable
+ @objc init(objc: Int) {}
+ @objc func objcMethod() {}
+ @objc var objcProp: Int = 0
+ @objc subscript(objc objc: AnyObject) -> Int {
+ get { return 0 }
+ set {}
+ }
+
+ // dynamic, so it has only an ObjC entry point
+ dynamic init(dynamic: Int) {}
+ dynamic func dynamicMethod() {}
+ dynamic var dynamicProp: Int = 0
+ dynamic subscript(dynamic dynamic: Int) -> Int {
+ get { return dynamic }
+ set {}
+ }
+
+ func overriddenByDynamic() {}
+
+ @NSManaged var managedProp: Int
+}
+
+protocol Proto {
+ func nativeMethod()
+ var nativeProp: Int { get set }
+ subscript(native native: Int) -> Int { get set }
+
+ func objcMethod()
+ var objcProp: Int { get set }
+ subscript(objc objc: AnyObject) -> Int { get set }
+
+ func dynamicMethod()
+ var dynamicProp: Int { get set }
+ subscript(dynamic dynamic: Int) -> Int { get set }
+}
+
+// ObjC entry points for @objc and dynamic entry points
+
+// normal and @objc initializing ctors can be statically dispatched
+// CHECK-LABEL: sil hidden @$S7dynamic3FooC{{.*}}tcfC
+// CHECK: function_ref @$S7dynamic3FooC{{.*}}tcfc
+
+// CHECK-LABEL: sil hidden @$S7dynamic3FooC{{.*}}tcfC
+// CHECK: function_ref @$S7dynamic3FooC{{.*}}tcfc
+
+// CHECK-LABEL: sil hidden [thunk] @$S7dynamic3{{[_0-9a-zA-Z]*}}fcTo
+// CHECK-LABEL: sil hidden [thunk] @$S7dynamic3FooC10objcMethod{{[_0-9a-zA-Z]*}}FTo
+// CHECK-LABEL: sil hidden [transparent] [thunk] @$S7dynamic3FooC8objcPropSivgTo
+// CHECK-LABEL: sil hidden [transparent] [thunk] @$S7dynamic3FooC8objcPropSivsTo
+// CHECK-LABEL: sil hidden [thunk] @$S7dynamic3FooC4objcSiyXl_tcigTo
+// CHECK-LABEL: sil hidden [thunk] @$S7dynamic3FooC4objcSiyXl_tcisTo
+
+// TODO: dynamic initializing ctor must be objc dispatched
+// CHECK-LABEL: sil hidden @$S7dynamic3{{[_0-9a-zA-Z]*}}fC
+// CHECK: function_ref @$S7dynamic3{{[_0-9a-zA-Z]*}}fcTD
+// CHECK-LABEL: sil shared [transparent] [serializable] [thunk] @$S7dynamic3{{[_0-9a-zA-Z]*}}fcTD
+// CHECK: objc_method {{%.*}} : $Foo, #Foo.init!initializer.1.foreign :
+
+// CHECK-LABEL: sil hidden [thunk] @$S7dynamic3{{[_0-9a-zA-Z]*}}fcTo
+// CHECK-LABEL: sil hidden [thunk] @$S7dynamic3FooC0A6Method{{[_0-9a-zA-Z]*}}FTo
+// CHECK-LABEL: sil hidden [transparent] [thunk] @$S7dynamic3FooC0A4PropSivgTo
+// CHECK-LABEL: sil hidden [transparent] [thunk] @$S7dynamic3FooC0A4PropSivsTo
+// CHECK-LABEL: sil hidden [thunk] @$S7dynamic3FooCAAS2i_tcigTo
+// CHECK-LABEL: sil hidden [thunk] @$S7dynamic3FooCAAS2i_tcisTo
+
+// Protocol witnesses use best appropriate dispatch
+
+// Native witnesses use vtable dispatch:
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDP12nativeMethod{{[_0-9a-zA-Z]*}}FTW
+// CHECK: class_method {{%.*}} : $Foo, #Foo.nativeMethod!1 :
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDP10nativePropSivgTW
+// CHECK: class_method {{%.*}} : $Foo, #Foo.nativeProp!getter.1 :
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDP10nativePropSivsTW
+// CHECK: class_method {{%.*}} : $Foo, #Foo.nativeProp!setter.1 :
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDP6nativeS2i_tcigTW
+// CHECK: class_method {{%.*}} : $Foo, #Foo.subscript!getter.1 :
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDP6nativeS2i_tcisTW
+// CHECK: class_method {{%.*}} : $Foo, #Foo.subscript!setter.1 :
+
+// @objc witnesses use vtable dispatch:
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDP10objcMethod{{[_0-9a-zA-Z]*}}FTW
+// CHECK: class_method {{%.*}} : $Foo, #Foo.objcMethod!1 :
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDP8objcPropSivgTW
+// CHECK: class_method {{%.*}} : $Foo, #Foo.objcProp!getter.1 :
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDP8objcPropSivsTW
+// CHECK: class_method {{%.*}} : $Foo, #Foo.objcProp!setter.1 :
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDP4objcSiyXl_tcigTW
+// CHECK: class_method {{%.*}} : $Foo, #Foo.subscript!getter.1 :
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDP4objcSiyXl_tcisTW
+// CHECK: class_method {{%.*}} : $Foo, #Foo.subscript!setter.1 :
+
+// Dynamic witnesses use objc dispatch:
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDP0A6Method{{[_0-9a-zA-Z]*}}FTW
+// CHECK: function_ref @$S7dynamic3FooC0A6Method{{[_0-9a-zA-Z]*}}FTD
+// CHECK-LABEL: sil shared [transparent] [serializable] [thunk] @$S7dynamic3FooC0A6Method{{[_0-9a-zA-Z]*}}FTD
+// CHECK: objc_method {{%.*}} : $Foo, #Foo.dynamicMethod!1.foreign :
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDP0A4PropSivgTW
+// CHECK: function_ref @$S7dynamic3FooC0A4PropSivgTD
+// CHECK-LABEL: sil shared [transparent] [serializable] [thunk] @$S7dynamic3FooC0A4PropSivgTD
+// CHECK: objc_method {{%.*}} : $Foo, #Foo.dynamicProp!getter.1.foreign :
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDP0A4PropSivsTW
+// CHECK: function_ref @$S7dynamic3FooC0A4PropSivsTD
+// CHECK-LABEL: sil shared [transparent] [serializable] [thunk] @$S7dynamic3FooC0A4PropSivsTD
+// CHECK: objc_method {{%.*}} : $Foo, #Foo.dynamicProp!setter.1.foreign :
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDPAAS2i_tcigTW
+// CHECK: function_ref @$S7dynamic3FooCAAS2i_tcigTD
+// CHECK-LABEL: sil shared [transparent] [serializable] [thunk] @$S7dynamic3FooCAAS2i_tcigTD
+// CHECK: objc_method {{%.*}} : $Foo, #Foo.subscript!getter.1.foreign :
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S7dynamic3FooCAA5ProtoA2aDPAAS2i_tcisTW
+// CHECK: function_ref @$S7dynamic3FooCAAS2i_tcisTD
+// CHECK-LABEL: sil shared [transparent] [serializable] [thunk] @$S7dynamic3FooCAAS2i_tcisTD
+// CHECK: objc_method {{%.*}} : $Foo, #Foo.subscript!setter.1.foreign :
+
+// Superclass dispatch
+class Subclass: Foo {
+ // Native and objc methods can directly reference super members
+ override init(native: Int) {
+ super.init(native: native)
+ }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC{{[_0-9a-zA-Z]*}}fC
+ // CHECK: function_ref @$S7dynamic8SubclassC{{[_0-9a-zA-Z]*}}fc
+
+ override func nativeMethod() {
+ super.nativeMethod()
+ }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC12nativeMethod{{[_0-9a-zA-Z]*}}F
+ // CHECK: function_ref @$S7dynamic3FooC12nativeMethodyyF : $@convention(method) (@guaranteed Foo) -> ()
+
+ override var nativeProp: Int {
+ get { return super.nativeProp }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC10nativePropSivg
+ // CHECK: function_ref @$S7dynamic3FooC10nativePropSivg : $@convention(method) (@guaranteed Foo) -> Int
+ set { super.nativeProp = newValue }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC10nativePropSivs
+ // CHECK: function_ref @$S7dynamic3FooC10nativePropSivs : $@convention(method) (Int, @guaranteed Foo) -> ()
+ }
+
+ override subscript(native native: Int) -> Int {
+ get { return super[native: native] }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC6nativeS2i_tcig
+ // CHECK: function_ref @$S7dynamic3FooC6nativeS2i_tcig : $@convention(method) (Int, @guaranteed Foo) -> Int
+ set { super[native: native] = newValue }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC6nativeS2i_tcis
+ // CHECK: function_ref @$S7dynamic3FooC6nativeS2i_tcis : $@convention(method) (Int, Int, @guaranteed Foo) -> ()
+ }
+
+ override init(objc: Int) {
+ super.init(objc: objc)
+ }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC4objcACSi_tcfc
+ // CHECK: function_ref @$S7dynamic3FooC4objcACSi_tcfc : $@convention(method) (Int, @owned Foo) -> @owned Foo
+
+ override func objcMethod() {
+ super.objcMethod()
+ }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC10objcMethod{{[_0-9a-zA-Z]*}}F
+ // CHECK: function_ref @$S7dynamic3FooC10objcMethodyyF : $@convention(method) (@guaranteed Foo) -> ()
+
+ override var objcProp: Int {
+ get { return super.objcProp }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC8objcPropSivg
+ // CHECK: function_ref @$S7dynamic3FooC8objcPropSivg : $@convention(method) (@guaranteed Foo) -> Int
+ set { super.objcProp = newValue }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC8objcPropSivs
+ // CHECK: function_ref @$S7dynamic3FooC8objcPropSivs : $@convention(method) (Int, @guaranteed Foo) -> ()
+ }
+
+ override subscript(objc objc: AnyObject) -> Int {
+ get { return super[objc: objc] }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC4objcSiyXl_tcig
+ // CHECK: function_ref @$S7dynamic3FooC4objcSiyXl_tcig : $@convention(method) (@guaranteed AnyObject, @guaranteed Foo) -> Int
+ set { super[objc: objc] = newValue }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC4objcSiyXl_tcis
+ // CHECK: function_ref @$S7dynamic3FooC4objcSiyXl_tcis : $@convention(method) (Int, @owned AnyObject, @guaranteed Foo) -> ()
+ }
+
+ // Dynamic methods are super-dispatched by objc_msgSend
+ override init(dynamic: Int) {
+ super.init(dynamic: dynamic)
+ }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC{{[_0-9a-zA-Z]*}}fc
+ // CHECK: objc_super_method {{%.*}} : $Subclass, #Foo.init!initializer.1.foreign :
+
+ override func dynamicMethod() {
+ super.dynamicMethod()
+ }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC0A6Method{{[_0-9a-zA-Z]*}}F
+ // CHECK: objc_super_method {{%.*}} : $Subclass, #Foo.dynamicMethod!1.foreign :
+
+ override var dynamicProp: Int {
+ get { return super.dynamicProp }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC0A4PropSivg
+ // CHECK: objc_super_method {{%.*}} : $Subclass, #Foo.dynamicProp!getter.1.foreign :
+ set { super.dynamicProp = newValue }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassC0A4PropSivs
+ // CHECK: objc_super_method {{%.*}} : $Subclass, #Foo.dynamicProp!setter.1.foreign :
+ }
+
+ override subscript(dynamic dynamic: Int) -> Int {
+ get { return super[dynamic: dynamic] }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassCAAS2i_tcig
+ // CHECK: objc_super_method {{%.*}} : $Subclass, #Foo.subscript!getter.1.foreign :
+ set { super[dynamic: dynamic] = newValue }
+ // CHECK-LABEL: sil hidden @$S7dynamic8SubclassCAAS2i_tcis
+ // CHECK: objc_super_method {{%.*}} : $Subclass, #Foo.subscript!setter.1.foreign :
+ }
+
+ dynamic override func overriddenByDynamic() {}
+}
+
+class SubclassWithInheritedInits: Foo {
+ // CHECK-LABEL: sil hidden @$S7dynamic26SubclassWithInheritedInitsC{{[_0-9a-zA-Z]*}}fc
+ // CHECK: objc_super_method {{%.*}} : $SubclassWithInheritedInits, #Foo.init!initializer.1.foreign :
+}
+class GrandchildWithInheritedInits: SubclassWithInheritedInits {
+ // CHECK-LABEL: sil hidden @$S7dynamic28GrandchildWithInheritedInitsC{{[_0-9a-zA-Z]*}}fc
+ // CHECK: objc_super_method {{%.*}} : $GrandchildWithInheritedInits, #SubclassWithInheritedInits.init!initializer.1.foreign :
+}
+class GrandchildOfInheritedInits: SubclassWithInheritedInits {
+ // Dynamic methods are super-dispatched by objc_msgSend
+ override init(dynamic: Int) {
+ super.init(dynamic: dynamic)
+ }
+ // CHECK-LABEL: sil hidden @$S7dynamic26GrandchildOfInheritedInitsC{{[_0-9a-zA-Z]*}}fc
+ // CHECK: objc_super_method {{%.*}} : $GrandchildOfInheritedInits, #SubclassWithInheritedInits.init!initializer.1.foreign :
+}
+
+// CHECK-LABEL: sil hidden @$S7dynamic20nativeMethodDispatchyyF : $@convention(thin) () -> ()
+func nativeMethodDispatch() {
+ // CHECK: function_ref @$S7dynamic3{{[_0-9a-zA-Z]*}}fC
+ let c = Foo(native: 0)
+ // CHECK: class_method {{%.*}} : $Foo, #Foo.nativeMethod!1 :
+ c.nativeMethod()
+ // CHECK: class_method {{%.*}} : $Foo, #Foo.nativeProp!getter.1 :
+ let x = c.nativeProp
+ // CHECK: class_method {{%.*}} : $Foo, #Foo.nativeProp!setter.1 :
+ c.nativeProp = x
+ // CHECK: class_method {{%.*}} : $Foo, #Foo.subscript!getter.1 :
+ let y = c[native: 0]
+ // CHECK: class_method {{%.*}} : $Foo, #Foo.subscript!setter.1 :
+ c[native: 0] = y
+}
+
+// CHECK-LABEL: sil hidden @$S7dynamic18objcMethodDispatchyyF : $@convention(thin) () -> ()
+func objcMethodDispatch() {
+ // CHECK: function_ref @$S7dynamic3{{[_0-9a-zA-Z]*}}fC
+ let c = Foo(objc: 0)
+ // CHECK: class_method {{%.*}} : $Foo, #Foo.objcMethod!1 :
+ c.objcMethod()
+ // CHECK: class_method {{%.*}} : $Foo, #Foo.objcProp!getter.1 :
+ let x = c.objcProp
+ // CHECK: class_method {{%.*}} : $Foo, #Foo.objcProp!setter.1 :
+ c.objcProp = x
+ // CHECK: class_method {{%.*}} : $Foo, #Foo.subscript!getter.1 :
+ let y = c[objc: 0 as NSNumber]
+ // CHECK: class_method {{%.*}} : $Foo, #Foo.subscript!setter.1 :
+ c[objc: 0 as NSNumber] = y
+}
+
+// CHECK-LABEL: sil hidden @$S7dynamic0A14MethodDispatchyyF : $@convention(thin) () -> ()
+func dynamicMethodDispatch() {
+ // CHECK: function_ref @$S7dynamic3{{[_0-9a-zA-Z]*}}fC
+ let c = Foo(dynamic: 0)
+ // CHECK: objc_method {{%.*}} : $Foo, #Foo.dynamicMethod!1.foreign
+ c.dynamicMethod()
+ // CHECK: objc_method {{%.*}} : $Foo, #Foo.dynamicProp!getter.1.foreign
+ let x = c.dynamicProp
+ // CHECK: objc_method {{%.*}} : $Foo, #Foo.dynamicProp!setter.1.foreign
+ c.dynamicProp = x
+ // CHECK: objc_method {{%.*}} : $Foo, #Foo.subscript!getter.1.foreign
+ let y = c[dynamic: 0]
+ // CHECK: objc_method {{%.*}} : $Foo, #Foo.subscript!setter.1.foreign
+ c[dynamic: 0] = y
+}
+
+// CHECK-LABEL: sil hidden @$S7dynamic15managedDispatchyyAA3FooCF
+func managedDispatch(_ c: Foo) {
+ // CHECK: objc_method {{%.*}} : $Foo, #Foo.managedProp!getter.1.foreign
+ let x = c.managedProp
+ // CHECK: objc_method {{%.*}} : $Foo, #Foo.managedProp!setter.1.foreign
+ c.managedProp = x
+}
+
+// CHECK-LABEL: sil hidden @$S7dynamic21foreignMethodDispatchyyF
+func foreignMethodDispatch() {
+ // CHECK: function_ref @$SSo9GuisemeauC{{[_0-9a-zA-Z]*}}fC
+ let g = Guisemeau()!
+ // CHECK: objc_method {{%.*}} : $Gizmo, #Gizmo.frob!1.foreign
+ g.frob()
+ // CHECK: objc_method {{%.*}} : $Gizmo, #Gizmo.count!getter.1.foreign
+ let x = g.count
+ // CHECK: objc_method {{%.*}} : $Gizmo, #Gizmo.count!setter.1.foreign
+ g.count = x
+ // CHECK: objc_method {{%.*}} : $Guisemeau, #Guisemeau.subscript!getter.1.foreign
+ let y: Any! = g[0]
+ // CHECK: objc_method {{%.*}} : $Guisemeau, #Guisemeau.subscript!setter.1.foreign
+ g[0] = y
+ // CHECK: objc_method {{%.*}} : $NSObject, #NSObject.description!getter.1.foreign
+ _ = g.description
+}
+
+extension Gizmo {
+ // CHECK-LABEL: sil hidden @$SSo5GizmoC7dynamicE{{[_0-9a-zA-Z]*}}fc
+ // CHECK: objc_method {{%.*}} : $Gizmo, #Gizmo.init!initializer.1.foreign
+ convenience init(convenienceInExtension: Int) {
+ self.init(bellsOn: convenienceInExtension)
+ }
+
+ // CHECK-LABEL: sil hidden @$SSo5GizmoC7dynamicE{{[_0-9a-zA-Z]*}}fC
+ // CHECK: objc_method {{%.*}} : $@objc_metatype Gizmo.Type, #Gizmo.init!allocator.1.foreign
+ convenience init(foreignClassFactory x: Int) {
+ self.init(stuff: x)
+ }
+
+ // CHECK-LABEL: sil hidden @$SSo5GizmoC7dynamicE{{[_0-9a-zA-Z]*}}fC
+ // CHECK: objc_method {{%.*}} : $@objc_metatype Gizmo.Type, #Gizmo.init!allocator.1.foreign
+ convenience init(foreignClassExactFactory x: Int) {
+ self.init(exactlyStuff: x)
+ }
+
+ @objc func foreignObjCExtension() { }
+ dynamic func foreignDynamicExtension() { }
+}
+
+// CHECK-LABEL: sil hidden @$S7dynamic24foreignExtensionDispatchyySo5GizmoCF
+// CHECK: bb0([[ARG:%.*]] : $Gizmo):
+func foreignExtensionDispatch(_ g: Gizmo) {
+ // CHECK: objc_method [[ARG]] : $Gizmo, #Gizmo.foreignObjCExtension!1.foreign : (Gizmo)
+ g.foreignObjCExtension()
+ // CHECK: objc_method [[ARG]] : $Gizmo, #Gizmo.foreignDynamicExtension!1.foreign
+ g.foreignDynamicExtension()
+}
+
+
+// CHECK-LABEL: sil hidden @$S7dynamic33nativeMethodDispatchFromOtherFileyyF : $@convention(thin) () -> ()
+func nativeMethodDispatchFromOtherFile() {
+ // CHECK: function_ref @$S7dynamic13FromOtherFile{{[_0-9a-zA-Z]*}}fC
+ let c = FromOtherFile(native: 0)
+ // CHECK: class_method {{%.*}} : $FromOtherFile, #FromOtherFile.nativeMethod!1 :
+ c.nativeMethod()
+ // CHECK: class_method {{%.*}} : $FromOtherFile, #FromOtherFile.nativeProp!getter.1 :
+ let x = c.nativeProp
+ // CHECK: class_method {{%.*}} : $FromOtherFile, #FromOtherFile.nativeProp!setter.1 :
+ c.nativeProp = x
+ // CHECK: class_method {{%.*}} : $FromOtherFile, #FromOtherFile.subscript!getter.1 :
+ let y = c[native: 0]
+ // CHECK: class_method {{%.*}} : $FromOtherFile, #FromOtherFile.subscript!setter.1 :
+ c[native: 0] = y
+}
+
+// CHECK-LABEL: sil hidden @$S7dynamic31objcMethodDispatchFromOtherFileyyF : $@convention(thin) () -> ()
+func objcMethodDispatchFromOtherFile() {
+ // CHECK: function_ref @$S7dynamic13FromOtherFile{{[_0-9a-zA-Z]*}}fC
+ let c = FromOtherFile(objc: 0)
+ // CHECK: class_method {{%.*}} : $FromOtherFile, #FromOtherFile.objcMethod!1 :
+ c.objcMethod()
+ // CHECK: class_method {{%.*}} : $FromOtherFile, #FromOtherFile.objcProp!getter.1 :
+ let x = c.objcProp
+ // CHECK: class_method {{%.*}} : $FromOtherFile, #FromOtherFile.objcProp!setter.1 :
+ c.objcProp = x
+ // CHECK: class_method {{%.*}} : $FromOtherFile, #FromOtherFile.subscript!getter.1 :
+ let y = c[objc: 0]
+ // CHECK: class_method {{%.*}} : $FromOtherFile, #FromOtherFile.subscript!setter.1 :
+ c[objc: 0] = y
+}
+
+// CHECK-LABEL: sil hidden @$S7dynamic0A27MethodDispatchFromOtherFileyyF : $@convention(thin) () -> ()
+func dynamicMethodDispatchFromOtherFile() {
+ // CHECK: function_ref @$S7dynamic13FromOtherFile{{[_0-9a-zA-Z]*}}fC
+ let c = FromOtherFile(dynamic: 0)
+ // CHECK: objc_method {{%.*}} : $FromOtherFile, #FromOtherFile.dynamicMethod!1.foreign
+ c.dynamicMethod()
+ // CHECK: objc_method {{%.*}} : $FromOtherFile, #FromOtherFile.dynamicProp!getter.1.foreign
+ let x = c.dynamicProp
+ // CHECK: objc_method {{%.*}} : $FromOtherFile, #FromOtherFile.dynamicProp!setter.1.foreign
+ c.dynamicProp = x
+ // CHECK: objc_method {{%.*}} : $FromOtherFile, #FromOtherFile.subscript!getter.1.foreign
+ let y = c[dynamic: 0]
+ // CHECK: objc_method {{%.*}} : $FromOtherFile, #FromOtherFile.subscript!setter.1.foreign
+ c[dynamic: 0] = y
+}
+
+// CHECK-LABEL: sil hidden @$S7dynamic28managedDispatchFromOtherFileyyAA0deF0CF
+func managedDispatchFromOtherFile(_ c: FromOtherFile) {
+ // CHECK: objc_method {{%.*}} : $FromOtherFile, #FromOtherFile.managedProp!getter.1.foreign
+ let x = c.managedProp
+ // CHECK: objc_method {{%.*}} : $FromOtherFile, #FromOtherFile.managedProp!setter.1.foreign
+ c.managedProp = x
+}
+
+// CHECK-LABEL: sil hidden @$S7dynamic0A16ExtensionMethodsyyAA13ObjCOtherFileCF
+func dynamicExtensionMethods(_ obj: ObjCOtherFile) {
+ // CHECK: objc_method {{%.*}} : $ObjCOtherFile, #ObjCOtherFile.extensionMethod!1.foreign
+ obj.extensionMethod()
+ // CHECK: objc_method {{%.*}} : $ObjCOtherFile, #ObjCOtherFile.extensionProp!getter.1.foreign
+ _ = obj.extensionProp
+
+ // CHECK: thick_to_objc_metatype {{%.*}} : $@thick ObjCOtherFile.Type to $@objc_metatype ObjCOtherFile.Type
+ // CHECK-NEXT: objc_method {{%.*}} : $@objc_metatype ObjCOtherFile.Type, #ObjCOtherFile.extensionClassProp!getter.1.foreign
+ _ = type(of: obj).extensionClassProp
+
+ // CHECK: objc_method {{%.*}} : $ObjCOtherFile, #ObjCOtherFile.dynExtensionMethod!1.foreign
+ obj.dynExtensionMethod()
+ // CHECK: objc_method {{%.*}} : $ObjCOtherFile, #ObjCOtherFile.dynExtensionProp!getter.1.foreign
+ _ = obj.dynExtensionProp
+
+ // CHECK: thick_to_objc_metatype {{%.*}} : $@thick ObjCOtherFile.Type to $@objc_metatype ObjCOtherFile.Type
+ // CHECK-NEXT: objc_method {{%.*}} : $@objc_metatype ObjCOtherFile.Type, #ObjCOtherFile.dynExtensionClassProp!getter.1.foreign
+ _ = type(of: obj).dynExtensionClassProp
+}
+
+public class Base {
+ dynamic var x: Bool { return false }
+}
+
+public class Sub : Base {
+ // CHECK-LABEL: sil hidden @$S7dynamic3SubC1xSbvg : $@convention(method) (@guaranteed Sub) -> Bool {
+ // CHECK: bb0([[SELF:%.*]] : $Sub):
+ // CHECK: [[AUTOCLOSURE:%.*]] = function_ref @$S7dynamic3SubC1xSbvgSbyKXKfu_ : $@convention(thin) (@guaranteed Sub) -> (Bool, @error Error)
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: = partial_apply [callee_guaranteed] [[AUTOCLOSURE]]([[SELF_COPY]])
+ // CHECK: return {{%.*}} : $Bool
+ // CHECK: } // end sil function '$S7dynamic3SubC1xSbvg'
+
+ // CHECK-LABEL: sil private [transparent] @$S7dynamic3SubC1xSbvgSbyKXKfu_ : $@convention(thin) (@guaranteed Sub) -> (Bool, @error Error) {
+ // CHECK: bb0([[VALUE:%.*]] : $Sub):
+ // CHECK: [[VALUE_COPY:%.*]] = copy_value [[VALUE]]
+ // CHECK: [[CASTED_VALUE_COPY:%.*]] = upcast [[VALUE_COPY]]
+ // CHECK: [[BORROWED_CASTED_VALUE_COPY:%.*]] = begin_borrow [[CASTED_VALUE_COPY]]
+ // CHECK: [[DOWNCAST_FOR_SUPERMETHOD:%.*]] = unchecked_ref_cast [[BORROWED_CASTED_VALUE_COPY]]
+ // CHECK: [[SUPER:%.*]] = objc_super_method [[DOWNCAST_FOR_SUPERMETHOD]] : $Sub, #Base.x!getter.1.foreign : (Base) -> () -> Bool, $@convention(objc_method) (Base) -> ObjCBool
+ // CHECK: end_borrow [[BORROWED_CASTED_VALUE_COPY]]
+ // CHECK: = apply [[SUPER]]([[CASTED_VALUE_COPY]])
+ // CHECK: destroy_value [[CASTED_VALUE_COPY]]
+ // CHECK: } // end sil function '$S7dynamic3SubC1xSbvgSbyKXKfu_'
+ override var x: Bool { return false || super.x }
+}
+
+public class BaseExt : NSObject {}
+
+extension BaseExt {
+ @objc public var count: Int {
+ return 0
+ }
+}
+
+public class SubExt : BaseExt {
+ public override var count: Int {
+ return 1
+ }
+}
+
+public class GenericBase<T> {
+ public func method(_: T) {}
+}
+
+public class ConcreteDerived : GenericBase<Int> {
+ public override dynamic func method(_: Int) {}
+}
+
+// The dynamic override has a different calling convention than the base,
+// so after re-abstracting the signature we must dispatch to the dynamic
+// thunk.
+
+// CHECK-LABEL: sil private @$S7dynamic15ConcreteDerivedC6methodyySiFAA11GenericBaseCADyyxFTV : $@convention(method) (@in_guaranteed Int, @guaranteed ConcreteDerived) -> ()
+// CHECK: bb0(%0 : $*Int, %1 : $ConcreteDerived):
+// CHECK-NEXT: [[VALUE:%.*]] = load [trivial] %0 : $*Int
+// CHECK: [[DYNAMIC_THUNK:%.*]] = function_ref @$S7dynamic15ConcreteDerivedC6methodyySiFTD : $@convention(method) (Int, @guaranteed ConcreteDerived) -> ()
+// CHECK-NEXT: apply [[DYNAMIC_THUNK]]([[VALUE]], %1) : $@convention(method) (Int, @guaranteed ConcreteDerived) -> ()
+// CHECK: return
+
+// Vtable contains entries for native and @objc methods, but not dynamic ones
+// CHECK-LABEL: sil_vtable Foo {
+// CHECK-NEXT: #Foo.init!initializer.1: {{.*}} : @$S7dynamic3FooC6nativeACSi_tcfc
+// CHECK-NEXT: #Foo.nativeMethod!1: {{.*}} : @$S7dynamic3FooC12nativeMethodyyF
+// CHECK-NEXT: #Foo.nativeProp!getter.1: {{.*}} : @$S7dynamic3FooC10nativePropSivg // dynamic.Foo.nativeProp.getter : Swift.Int
+// CHECK-NEXT: #Foo.nativeProp!setter.1: {{.*}} : @$S7dynamic3FooC10nativePropSivs // dynamic.Foo.nativeProp.setter : Swift.Int
+// CHECK-NEXT: #Foo.nativeProp!materializeForSet.1
+// CHECK-NEXT: #Foo.subscript!getter.1: {{.*}} : @$S7dynamic3FooC6nativeS2i_tcig // dynamic.Foo.subscript.getter : (native: Swift.Int) -> Swift.Int
+// CHECK-NEXT: #Foo.subscript!setter.1: {{.*}} : @$S7dynamic3FooC6nativeS2i_tcis // dynamic.Foo.subscript.setter : (native: Swift.Int) -> Swift.Int
+// CHECK-NEXT: #Foo.subscript!materializeForSet.1
+// CHECK-NEXT: #Foo.init!initializer.1: {{.*}} : @$S7dynamic3FooC4objcACSi_tcfc
+// CHECK-NEXT: #Foo.objcMethod!1: {{.*}} : @$S7dynamic3FooC10objcMethodyyF
+// CHECK-NEXT: #Foo.objcProp!getter.1: {{.*}} : @$S7dynamic3FooC8objcPropSivg // dynamic.Foo.objcProp.getter : Swift.Int
+// CHECK-NEXT: #Foo.objcProp!setter.1: {{.*}} : @$S7dynamic3FooC8objcPropSivs // dynamic.Foo.objcProp.setter : Swift.Int
+// CHECK-NEXT: #Foo.objcProp!materializeForSet.1
+// CHECK-NEXT: #Foo.subscript!getter.1: {{.*}} : @$S7dynamic3FooC4objcSiyXl_tcig // dynamic.Foo.subscript.getter : (objc: Swift.AnyObject) -> Swift.Int
+// CHECK-NEXT: #Foo.subscript!setter.1: {{.*}} : @$S7dynamic3FooC4objcSiyXl_tcis // dynamic.Foo.subscript.setter : (objc: Swift.AnyObject) -> Swift.Int
+// CHECK-NEXT: #Foo.subscript!materializeForSet
+// CHECK-NEXT: #Foo.overriddenByDynamic!1: {{.*}} : @$S7dynamic3FooC19overriddenByDynamic{{[_0-9a-zA-Z]*}}
+// CHECK-NEXT: #Foo.deinit!deallocator: {{.*}}
+// CHECK-NEXT: }
+
+// Vtable uses a dynamic thunk for dynamic overrides
+// CHECK-LABEL: sil_vtable Subclass {
+// CHECK: #Foo.overriddenByDynamic!1: {{.*}} : public @$S7dynamic8SubclassC19overriddenByDynamic{{[_0-9a-zA-Z]*}}FTD
+// CHECK: }
+
+// Check vtables for implicitly-inherited initializers
+// CHECK-LABEL: sil_vtable SubclassWithInheritedInits {
+// CHECK: #Foo.init!initializer.1: (Foo.Type) -> (Int) -> Foo : @$S7dynamic26SubclassWithInheritedInitsC6nativeACSi_tcfc
+// CHECK: #Foo.init!initializer.1: (Foo.Type) -> (Int) -> Foo : @$S7dynamic26SubclassWithInheritedInitsC4objcACSi_tcfc
+// CHECK-NOT: .init!
+// CHECK: }
+
+// CHECK-LABEL: sil_vtable GrandchildWithInheritedInits {
+// CHECK: #Foo.init!initializer.1: (Foo.Type) -> (Int) -> Foo : @$S7dynamic28GrandchildWithInheritedInitsC6nativeACSi_tcfc
+// CHECK: #Foo.init!initializer.1: (Foo.Type) -> (Int) -> Foo : @$S7dynamic28GrandchildWithInheritedInitsC4objcACSi_tcfc
+// CHECK-NOT: .init!
+// CHECK: }
+
+// CHECK-LABEL: sil_vtable GrandchildOfInheritedInits {
+// CHECK: #Foo.init!initializer.1: (Foo.Type) -> (Int) -> Foo : @$S7dynamic26GrandchildOfInheritedInitsC6nativeACSi_tcfc
+// CHECK: #Foo.init!initializer.1: (Foo.Type) -> (Int) -> Foo : @$S7dynamic26GrandchildOfInheritedInitsC4objcACSi_tcfc
+// CHECK-NOT: .init!
+// CHECK: }
+
+// No vtable entry for override of @objc extension property
+// CHECK-LABEL: sil_vtable [serialized] SubExt {
+// CHECK-NEXT: #BaseExt.init!initializer.1: (BaseExt.Type) -> () -> BaseExt : @$S7dynamic6SubExtCACycfc [override] // dynamic.SubExt.init() -> dynamic.SubExt
+// CHECK-NEXT: #SubExt.deinit!deallocator: @$S7dynamic6SubExtCfD // dynamic.SubExt.__deallocating_deinit
+// CHECK-NEXT: }
+
+// Dynamic thunk + vtable re-abstraction
+// CHECK-LABEL: sil_vtable [serialized] ConcreteDerived {
+// CHECK-NEXT: #GenericBase.method!1: <T> (GenericBase<T>) -> (T) -> () : public @$S7dynamic15ConcreteDerivedC6methodyySiFAA11GenericBaseCADyyxFTV [override] // vtable thunk for dynamic.GenericBase.method(A) -> () dispatching to dynamic.ConcreteDerived.method(Swift.Int) -> ()
+// CHECK-NEXT: #GenericBase.init!initializer.1: <T> (GenericBase<T>.Type) -> () -> GenericBase<T> : @$S7dynamic15ConcreteDerivedCACycfc [override] // dynamic.ConcreteDerived.init() -> dynamic.ConcreteDerived
+// CHECK-NEXT: #ConcreteDerived.deinit!deallocator: @$S7dynamic15ConcreteDerivedCfD // dynamic.ConcreteDerived.__deallocating_deinit
+// CHECK-NEXT: }
diff --git a/test/SILGen/plus_zero_dynamic_lookup.swift b/test/SILGen/plus_zero_dynamic_lookup.swift
new file mode 100644
index 0000000..64062f5
--- /dev/null
+++ b/test/SILGen/plus_zero_dynamic_lookup.swift
@@ -0,0 +1,361 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -parse-as-library -emit-silgen -disable-objc-attr-requires-foundation-module %s | %FileCheck %s
+// RUN: %target-swift-frontend -parse-as-library -emit-silgen -disable-objc-attr-requires-foundation-module %s | %FileCheck %s --check-prefix=GUARANTEED
+
+// REQUIRES: objc_interop
+
+class X {
+ @objc func f() { }
+ @objc class func staticF() { }
+ @objc var value: Int {
+ return 17
+ }
+
+ @objc subscript (i: Int) -> Int {
+ get {
+ return i
+ }
+ set {}
+ }
+}
+
+@objc protocol P {
+ func g()
+}
+
+// CHECK-LABEL: sil hidden @$S14dynamic_lookup15direct_to_class{{[_0-9a-zA-Z]*}}F
+func direct_to_class(_ obj: AnyObject) {
+ // CHECK: bb0([[ARG:%.*]] : $AnyObject):
+ // CHECK: [[OPENED_ARG:%[0-9]+]] = open_existential_ref [[ARG]] : $AnyObject to $@opened({{.*}}) AnyObject
+ // CHECK: [[OPENED_ARG_COPY:%.*]] = copy_value [[OPENED_ARG]]
+ // CHECK: [[METHOD:%[0-9]+]] = objc_method [[OPENED_ARG_COPY]] : $@opened({{.*}}) AnyObject, #X.f!1.foreign : (X) -> () -> (), $@convention(objc_method) (@opened({{.*}}) AnyObject) -> ()
+ // CHECK: apply [[METHOD]]([[OPENED_ARG_COPY]]) : $@convention(objc_method) (@opened({{.*}}) AnyObject) -> ()
+ // CHECK: destroy_value [[OPENED_ARG_COPY]]
+ obj.f!()
+}
+// CHECK: } // end sil function '$S14dynamic_lookup15direct_to_class{{[_0-9a-zA-Z]*}}F'
+
+// CHECK-LABEL: sil hidden @$S14dynamic_lookup18direct_to_protocol{{[_0-9a-zA-Z]*}}F
+func direct_to_protocol(_ obj: AnyObject) {
+ // CHECK: bb0([[ARG:%.*]] : $AnyObject):
+ // CHECK: [[OPENED_ARG:%[0-9]+]] = open_existential_ref [[ARG]] : $AnyObject to $@opened({{.*}}) AnyObject
+ // CHECK: [[OPENED_ARG_COPY:%.*]] = copy_value [[OPENED_ARG]]
+ // CHECK: [[METHOD:%[0-9]+]] = objc_method [[OPENED_ARG_COPY]] : $@opened({{.*}}) AnyObject, #P.g!1.foreign : <Self where Self : P> (Self) -> () -> (), $@convention(objc_method) (@opened({{.*}}) AnyObject) -> ()
+ // CHECK: apply [[METHOD]]([[OPENED_ARG_COPY]]) : $@convention(objc_method) (@opened({{.*}}) AnyObject) -> ()
+ // CHECK: destroy_value [[OPENED_ARG_COPY]]
+ obj.g!()
+}
+// CHECK: } // end sil function '$S14dynamic_lookup18direct_to_protocol{{[_0-9a-zA-Z]*}}F'
+
+// CHECK-LABEL: sil hidden @$S14dynamic_lookup23direct_to_static_method{{[_0-9a-zA-Z]*}}F
+func direct_to_static_method(_ obj: AnyObject) {
+ // CHECK: bb0([[ARG:%.*]] : $AnyObject):
+ var obj = obj
+ // CHECK: [[OBJBOX:%[0-9]+]] = alloc_box ${ var AnyObject }
+ // CHECK-NEXT: [[PBOBJ:%[0-9]+]] = project_box [[OBJBOX]]
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: store [[ARG_COPY]] to [init] [[PBOBJ]] : $*AnyObject
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBOBJ]]
+ // CHECK-NEXT: [[OBJCOPY:%[0-9]+]] = load [copy] [[READ]] : $*AnyObject
+ // CHECK: end_access [[READ]]
+ // CHECK-NEXT: [[OBJMETA:%[0-9]+]] = existential_metatype $@thick AnyObject.Type, [[OBJCOPY]] : $AnyObject
+ // CHECK-NEXT: [[OPENMETA:%[0-9]+]] = open_existential_metatype [[OBJMETA]] : $@thick AnyObject.Type to $@thick (@opened([[UUID:".*"]]) AnyObject).Type
+ // CHECK-NEXT: [[METHOD:%[0-9]+]] = objc_method [[OPENMETA]] : $@thick (@opened([[UUID]]) AnyObject).Type, #X.staticF!1.foreign : (X.Type) -> () -> (), $@convention(objc_method) (@thick (@opened([[UUID]]) AnyObject).Type) -> ()
+ // CHECK: apply [[METHOD]]([[OPENMETA]]) : $@convention(objc_method) (@thick (@opened([[UUID]]) AnyObject).Type) -> ()
+ // CHECK: destroy_value [[OBJBOX]]
+ type(of: obj).staticF!()
+}
+// } // end sil function '_TF14dynamic_lookup23direct_to_static_method{{.*}}'
+
+// CHECK-LABEL: sil hidden @$S14dynamic_lookup12opt_to_class{{[_0-9a-zA-Z]*}}F
+func opt_to_class(_ obj: AnyObject) {
+ // CHECK: bb0([[ARG:%.*]] : $AnyObject):
+ var obj = obj
+ // CHECK: [[EXISTBOX:%[0-9]+]] = alloc_box ${ var AnyObject }
+ // CHECK: [[PBOBJ:%[0-9]+]] = project_box [[EXISTBOX]]
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: store [[ARG_COPY]] to [init] [[PBOBJ]]
+ // CHECK: [[OPTBOX:%[0-9]+]] = alloc_box ${ var Optional<@callee_guaranteed () -> ()> }
+ // CHECK: [[PBOPT:%.*]] = project_box [[OPTBOX]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBOBJ]]
+ // CHECK: [[EXISTVAL:%[0-9]+]] = load [copy] [[READ]] : $*AnyObject
+ // CHECK: [[OBJ_SELF:%[0-9]*]] = open_existential_ref [[EXISTVAL]]
+ // CHECK: [[OPT_TMP:%.*]] = alloc_stack $Optional<@callee_guaranteed () -> ()>
+ // CHECK: dynamic_method_br [[OBJ_SELF]] : $@opened({{.*}}) AnyObject, #X.f!1.foreign, [[HASBB:[a-zA-z0-9]+]], [[NOBB:[a-zA-z0-9]+]]
+
+ // Has method BB:
+ // CHECK: [[HASBB]]([[UNCURRIED:%[0-9]+]] : $@convention(objc_method) (@opened({{.*}}) AnyObject) -> ()):
+ // CHECK: [[OBJ_SELF_COPY:%.*]] = copy_value [[OBJ_SELF]]
+ // CHECK: [[PARTIAL:%[0-9]+]] = partial_apply [callee_guaranteed] [[UNCURRIED]]([[OBJ_SELF_COPY]]) : $@convention(objc_method) (@opened({{.*}}) AnyObject) -> ()
+ // CHECK: [[THUNK_PAYLOAD:%.*]] = init_enum_data_addr [[OPT_TMP]]
+ // CHECK: store [[PARTIAL]] to [init] [[THUNK_PAYLOAD]]
+ // CHECK: inject_enum_addr [[OPT_TMP]] : $*Optional<@callee_guaranteed () -> ()>, #Optional.some!enumelt.1
+ // CHECK: br [[CONTBB:[a-zA-Z0-9]+]]
+
+ // No method BB:
+ // CHECK: [[NOBB]]:
+ // CHECK: inject_enum_addr [[OPT_TMP]] : {{.*}}, #Optional.none!enumelt
+ // CHECK: br [[CONTBB]]
+
+ // Continuation block
+ // CHECK: [[CONTBB]]:
+ // CHECK: [[OPT:%.*]] = load [take] [[OPT_TMP]]
+ // CHECK: store [[OPT]] to [init] [[PBOPT]] : $*Optional<@callee_guaranteed () -> ()>
+ // CHECK: dealloc_stack [[OPT_TMP]]
+ var of: (() -> ())! = obj.f
+
+ // Exit
+ // CHECK: destroy_value [[OBJ_SELF]] : $@opened({{".*"}}) AnyObject
+ // CHECK: destroy_value [[OPTBOX]] : ${ var Optional<@callee_guaranteed () -> ()> }
+ // CHECK: destroy_value [[EXISTBOX]] : ${ var AnyObject }
+ // CHECK: [[RESULT:%[0-9]+]] = tuple ()
+ // CHECK: return [[RESULT]] : $()
+}
+
+// CHECK-LABEL: sil hidden @$S14dynamic_lookup20forced_without_outer{{[_0-9a-zA-Z]*}}F
+func forced_without_outer(_ obj: AnyObject) {
+ // CHECK: dynamic_method_br
+ var f = obj.f!
+}
+
+// CHECK-LABEL: sil hidden @$S14dynamic_lookup20opt_to_static_method{{[_0-9a-zA-Z]*}}F
+func opt_to_static_method(_ obj: AnyObject) {
+ var obj = obj
+ // CHECK: bb0([[OBJ:%[0-9]+]] : $AnyObject):
+ // CHECK: [[OBJBOX:%[0-9]+]] = alloc_box ${ var AnyObject }
+ // CHECK: [[PBOBJ:%[0-9]+]] = project_box [[OBJBOX]]
+ // CHECK: [[OBJ_COPY:%.*]] = copy_value [[OBJ]]
+ // CHECK: store [[OBJ_COPY]] to [init] [[PBOBJ]] : $*AnyObject
+ // CHECK: [[OPTBOX:%[0-9]+]] = alloc_box ${ var Optional<@callee_guaranteed () -> ()> }
+ // CHECK: [[PBO:%.*]] = project_box [[OPTBOX]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBOBJ]]
+ // CHECK: [[OBJCOPY:%[0-9]+]] = load [copy] [[READ]] : $*AnyObject
+ // CHECK: [[OBJMETA:%[0-9]+]] = existential_metatype $@thick AnyObject.Type, [[OBJCOPY]] : $AnyObject
+ // CHECK: [[OPENMETA:%[0-9]+]] = open_existential_metatype [[OBJMETA]] : $@thick AnyObject.Type to $@thick (@opened
+ // CHECK: [[OBJCMETA:%[0-9]+]] = thick_to_objc_metatype [[OPENMETA]]
+ // CHECK: [[OPTTEMP:%.*]] = alloc_stack $Optional<@callee_guaranteed () -> ()>
+ // CHECK: dynamic_method_br [[OBJCMETA]] : $@objc_metatype (@opened({{".*"}}) AnyObject).Type, #X.staticF!1.foreign, [[HASMETHOD:[A-Za-z0-9_]+]], [[NOMETHOD:[A-Za-z0-9_]+]]
+ var optF: (() -> ())! = type(of: obj).staticF
+}
+
+// CHECK-LABEL: sil hidden @$S14dynamic_lookup15opt_to_property{{[_0-9a-zA-Z]*}}F
+func opt_to_property(_ obj: AnyObject) {
+ var obj = obj
+ // CHECK: bb0([[OBJ:%[0-9]+]] : $AnyObject):
+ // CHECK: [[OBJ_BOX:%[0-9]+]] = alloc_box ${ var AnyObject }
+ // CHECK: [[PBOBJ:%[0-9]+]] = project_box [[OBJ_BOX]]
+ // CHECK: [[OBJ_COPY:%.*]] = copy_value [[OBJ]]
+ // CHECK: store [[OBJ_COPY]] to [init] [[PBOBJ]] : $*AnyObject
+ // CHECK: [[INT_BOX:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: project_box [[INT_BOX]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBOBJ]]
+ // CHECK: [[OBJ:%[0-9]+]] = load [copy] [[READ]] : $*AnyObject
+ // CHECK: [[RAWOBJ_SELF:%[0-9]+]] = open_existential_ref [[OBJ]] : $AnyObject
+ // CHECK: [[OPTTEMP:%.*]] = alloc_stack $Optional<Int>
+ // CHECK: dynamic_method_br [[RAWOBJ_SELF]] : $@opened({{.*}}) AnyObject, #X.value!getter.1.foreign, bb1, bb2
+
+ // CHECK: bb1([[METHOD:%[0-9]+]] : $@convention(objc_method) (@opened({{.*}}) AnyObject) -> Int):
+ // CHECK: [[RAWOBJ_SELF_COPY:%.*]] = copy_value [[RAWOBJ_SELF]]
+ // CHECK: [[BOUND_METHOD:%[0-9]+]] = partial_apply [callee_guaranteed] [[METHOD]]([[RAWOBJ_SELF_COPY]]) : $@convention(objc_method) (@opened({{.*}}) AnyObject) -> Int
+ // CHECK: [[B:%.*]] = begin_borrow [[BOUND_METHOD]]
+ // CHECK: [[VALUE:%[0-9]+]] = apply [[B]]() : $@callee_guaranteed () -> Int
+ // CHECK: end_borrow [[B]]
+ // CHECK: [[VALUETEMP:%.*]] = init_enum_data_addr [[OPTTEMP]]
+ // CHECK: store [[VALUE]] to [trivial] [[VALUETEMP]]
+ // CHECK: inject_enum_addr [[OPTTEMP]]{{.*}}some
+ // CHECK: destroy_value [[BOUND_METHOD]]
+ // CHECK: br bb3
+ var i: Int = obj.value!
+}
+// CHECK: } // end sil function '$S14dynamic_lookup15opt_to_property{{[_0-9a-zA-Z]*}}F'
+
+// GUARANTEED-LABEL: sil hidden @$S14dynamic_lookup15opt_to_property{{[_0-9a-zA-Z]*}}F
+ // GUARANTEED: bb0([[OBJ:%[0-9]+]] : $AnyObject):
+ // GUARANTEED: [[OBJ_BOX:%[0-9]+]] = alloc_box ${ var AnyObject }
+ // GUARANTEED: [[PBOBJ:%[0-9]+]] = project_box [[OBJ_BOX]]
+ // GUARANTEED: [[OBJ_COPY:%.*]] = copy_value [[OBJ]]
+ // GUARANTEED: store [[OBJ_COPY]] to [init] [[PBOBJ]] : $*AnyObject
+ // GUARANTEED: [[INT_BOX:%[0-9]+]] = alloc_box ${ var Int }
+ // GUARANTEED: project_box [[INT_BOX]]
+ // GUARANTEED: [[READ:%.*]] = begin_access [read] [unknown] [[PBOBJ]]
+ // GUARANTEED: [[OBJ:%[0-9]+]] = load [copy] [[READ]] : $*AnyObject
+ // GUARANTEED: [[RAWOBJ_SELF:%[0-9]+]] = open_existential_ref [[OBJ]] : $AnyObject
+ // GUARANTEED: [[OPTTEMP:%.*]] = alloc_stack $Optional<Int>
+ // GUARANTEED: dynamic_method_br [[RAWOBJ_SELF]] : $@opened({{.*}}) AnyObject, #X.value!getter.1.foreign, bb1, bb2
+
+ // GUARANTEED: bb1([[METHOD:%[0-9]+]] : $@convention(objc_method) (@opened({{.*}}) AnyObject) -> Int):
+ // GUARANTEED: [[RAWOBJ_SELF_COPY:%.*]] = copy_value [[RAWOBJ_SELF]]
+ // GUARANTEED: [[BOUND_METHOD:%[0-9]+]] = partial_apply [callee_guaranteed] [[METHOD]]([[RAWOBJ_SELF_COPY]])
+ // GUARANTEED: [[BEGIN_BORROW:%.*]] = begin_borrow [[BOUND_METHOD]]
+ // GUARANTEED: [[VALUE:%[0-9]+]] = apply [[BEGIN_BORROW]]
+ // GUARANTEED: end_borrow [[BEGIN_BORROW]] from [[BOUND_METHOD]]
+ // GUARANTEED: [[VALUETEMP:%.*]] = init_enum_data_addr [[OPTTEMP]]
+ // GUARANTEED: store [[VALUE]] to [trivial] [[VALUETEMP]]
+ // GUARANTEED: inject_enum_addr [[OPTTEMP]]{{.*}}some
+ // GUARANTEED: destroy_value [[BOUND_METHOD]]
+ // GUARANTEED: br bb3
+
+// CHECK-LABEL: sil hidden @$S14dynamic_lookup19direct_to_subscript{{[_0-9a-zA-Z]*}}F
+func direct_to_subscript(_ obj: AnyObject, i: Int) {
+ var obj = obj
+ var i = i
+ // CHECK: bb0([[OBJ:%[0-9]+]] : $AnyObject, [[I:%[0-9]+]] : $Int):
+ // CHECK: [[OBJ_BOX:%[0-9]+]] = alloc_box ${ var AnyObject }
+ // CHECK: [[PBOBJ:%[0-9]+]] = project_box [[OBJ_BOX]]
+ // CHECK: [[OBJ_COPY:%.*]] = copy_value [[OBJ]]
+ // CHECK: store [[OBJ_COPY]] to [init] [[PBOBJ]] : $*AnyObject
+ // CHECK: [[I_BOX:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[PBI:%.*]] = project_box [[I_BOX]]
+ // CHECK: store [[I]] to [trivial] [[PBI]] : $*Int
+ // CHECK: alloc_box ${ var Int }
+ // CHECK: project_box
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBOBJ]]
+ // CHECK: [[OBJ:%[0-9]+]] = load [copy] [[READ]] : $*AnyObject
+ // CHECK: [[OBJ_REF:%[0-9]+]] = open_existential_ref [[OBJ]] : $AnyObject to $@opened({{.*}}) AnyObject
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBI]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READ]] : $*Int
+ // CHECK: [[OPTTEMP:%.*]] = alloc_stack $Optional<Int>
+ // CHECK: dynamic_method_br [[OBJ_REF]] : $@opened({{.*}}) AnyObject, #X.subscript!getter.1.foreign, bb1, bb2
+
+ // CHECK: bb1([[GETTER:%[0-9]+]] : $@convention(objc_method) (Int, @opened({{.*}}) AnyObject) -> Int):
+ // CHECK: [[OBJ_REF_COPY:%.*]] = copy_value [[OBJ_REF]]
+ // CHECK: [[GETTER_WITH_SELF:%[0-9]+]] = partial_apply [callee_guaranteed] [[GETTER]]([[OBJ_REF_COPY]]) : $@convention(objc_method) (Int, @opened({{.*}}) AnyObject) -> Int
+ // CHECK: [[B:%.*]] = begin_borrow [[GETTER_WITH_SELF]]
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[B]]([[I]]) : $@callee_guaranteed (Int) -> Int
+ // CHECK: end_borrow [[B]]
+ // CHECK: [[RESULTTEMP:%.*]] = init_enum_data_addr [[OPTTEMP]]
+ // CHECK: store [[RESULT]] to [trivial] [[RESULTTEMP]]
+ // CHECK: inject_enum_addr [[OPTTEMP]]{{.*}}some
+ // CHECK: destroy_value [[GETTER_WITH_SELF]]
+ // CHECK: br bb3
+ var x: Int = obj[i]!
+}
+// CHECK: } // end sil function '$S14dynamic_lookup19direct_to_subscript{{[_0-9a-zA-Z]*}}F'
+
+// GUARANTEED-LABEL: sil hidden @$S14dynamic_lookup19direct_to_subscript{{[_0-9a-zA-Z]*}}F
+ // GUARANTEED: bb0([[OBJ:%[0-9]+]] : $AnyObject, [[I:%[0-9]+]] : $Int):
+ // GUARANTEED: [[OBJ_BOX:%[0-9]+]] = alloc_box ${ var AnyObject }
+ // GUARANTEED: [[PBOBJ:%[0-9]+]] = project_box [[OBJ_BOX]]
+ // GUARANTEED: [[OBJ_COPY:%.*]] = copy_value [[OBJ]]
+ // GUARANTEED: store [[OBJ_COPY]] to [init] [[PBOBJ]] : $*AnyObject
+ // GUARANTEED: [[I_BOX:%[0-9]+]] = alloc_box ${ var Int }
+ // GUARANTEED: [[PBI:%.*]] = project_box [[I_BOX]]
+ // GUARANTEED: store [[I]] to [trivial] [[PBI]] : $*Int
+ // GUARANTEED: alloc_box ${ var Int }
+ // GUARANTEED: project_box
+ // GUARANTEED: [[READ:%.*]] = begin_access [read] [unknown] [[PBOBJ]]
+ // GUARANTEED: [[OBJ:%[0-9]+]] = load [copy] [[READ]] : $*AnyObject
+ // GUARANTEED: [[OBJ_REF:%[0-9]+]] = open_existential_ref [[OBJ]] : $AnyObject to $@opened({{.*}}) AnyObject
+ // GUARANTEED: [[READ:%.*]] = begin_access [read] [unknown] [[PBI]]
+ // GUARANTEED: [[I:%[0-9]+]] = load [trivial] [[READ]] : $*Int
+ // GUARANTEED: [[OPTTEMP:%.*]] = alloc_stack $Optional<Int>
+ // GUARANTEED: dynamic_method_br [[OBJ_REF]] : $@opened({{.*}}) AnyObject, #X.subscript!getter.1.foreign, bb1, bb2
+
+ // GUARANTEED: bb1([[GETTER:%[0-9]+]] : $@convention(objc_method) (Int, @opened({{.*}}) AnyObject) -> Int):
+ // GUARANTEED: [[OBJ_REF_COPY:%.*]] = copy_value [[OBJ_REF]]
+ // GUARANTEED: [[GETTER_WITH_SELF:%[0-9]+]] = partial_apply [callee_guaranteed] [[GETTER]]([[OBJ_REF_COPY]])
+ // GUARANTEED: [[BORROW:%.*]] = begin_borrow [[GETTER_WITH_SELF]]
+ // GUARANTEED: [[RESULT:%[0-9]+]] = apply [[BORROW]]([[I]])
+ // GUARANTEED: end_borrow [[BORROW]] from [[GETTER_WITH_SELF]]
+ // GUARANTEED: [[RESULTTEMP:%.*]] = init_enum_data_addr [[OPTTEMP]]
+ // GUARANTEED: store [[RESULT]] to [trivial] [[RESULTTEMP]]
+ // GUARANTEED: inject_enum_addr [[OPTTEMP]]{{.*}}some
+ // GUARANTEED: destroy_value [[GETTER_WITH_SELF]]
+ // GUARANTEED: br bb3
+
+// CHECK-LABEL: sil hidden @$S14dynamic_lookup16opt_to_subscript{{[_0-9a-zA-Z]*}}F
+func opt_to_subscript(_ obj: AnyObject, i: Int) {
+ var obj = obj
+ var i = i
+ // CHECK: bb0([[OBJ:%[0-9]+]] : $AnyObject, [[I:%[0-9]+]] : $Int):
+ // CHECK: [[OBJ_BOX:%[0-9]+]] = alloc_box ${ var AnyObject }
+ // CHECK: [[PBOBJ:%[0-9]+]] = project_box [[OBJ_BOX]]
+ // CHECK: [[OBJ_COPY:%.*]] = copy_value [[OBJ]]
+ // CHECK: store [[OBJ_COPY]] to [init] [[PBOBJ]] : $*AnyObject
+ // CHECK: [[I_BOX:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[PBI:%.*]] = project_box [[I_BOX]]
+ // CHECK: store [[I]] to [trivial] [[PBI]] : $*Int
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBOBJ]]
+ // CHECK: [[OBJ:%[0-9]+]] = load [copy] [[READ]] : $*AnyObject
+ // CHECK: [[OBJ_REF:%[0-9]+]] = open_existential_ref [[OBJ]] : $AnyObject to $@opened({{.*}}) AnyObject
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBI]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READ]] : $*Int
+ // CHECK: [[OPTTEMP:%.*]] = alloc_stack $Optional<Int>
+ // CHECK: dynamic_method_br [[OBJ_REF]] : $@opened({{.*}}) AnyObject, #X.subscript!getter.1.foreign, bb1, bb2
+
+ // CHECK: bb1([[GETTER:%[0-9]+]] : $@convention(objc_method) (Int, @opened({{.*}}) AnyObject) -> Int):
+ // CHECK: [[OBJ_REF_COPY:%.*]] = copy_value [[OBJ_REF]]
+ // CHECK: [[GETTER_WITH_SELF:%[0-9]+]] = partial_apply [callee_guaranteed] [[GETTER]]([[OBJ_REF_COPY]]) : $@convention(objc_method) (Int, @opened({{.*}}) AnyObject) -> Int
+ // CHECK: [[B:%.*]] = begin_borrow [[GETTER_WITH_SELF]]
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[B]]([[I]]) : $@callee_guaranteed (Int) -> Int
+ // CHECK: end_borrow [[B]]
+ // CHECK: [[RESULTTEMP:%.*]] = init_enum_data_addr [[OPTTEMP]]
+ // CHECK: store [[RESULT]] to [trivial] [[RESULTTEMP]]
+ // CHECK: inject_enum_addr [[OPTTEMP]]
+ // CHECK: destroy_value [[GETTER_WITH_SELF]]
+ // CHECK: br bb3
+ obj[i]
+}
+
+// CHECK-LABEL: sil hidden @$S14dynamic_lookup8downcast{{[_0-9a-zA-Z]*}}F
+func downcast(_ obj: AnyObject) -> X {
+ var obj = obj
+ // CHECK: bb0([[OBJ:%[0-9]+]] : $AnyObject):
+ // CHECK: [[OBJ_BOX:%[0-9]+]] = alloc_box ${ var AnyObject }
+ // CHECK: [[PBOBJ:%[0-9]+]] = project_box [[OBJ_BOX]]
+ // CHECK: [[OBJ_COPY:%.*]] = copy_value [[OBJ]]
+ // CHECK: store [[OBJ_COPY]] to [init] [[PBOBJ]] : $*AnyObject
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBOBJ]]
+ // CHECK: [[OBJ:%[0-9]+]] = load [copy] [[READ]] : $*AnyObject
+ // CHECK: [[X:%[0-9]+]] = unconditional_checked_cast [[OBJ]] : $AnyObject to $X
+ // CHECK: destroy_value [[OBJ_BOX]] : ${ var AnyObject }
+ // CHECK: return [[X]] : $X
+ return obj as! X
+}
+
+@objc class Juice { }
+
+@objc protocol Fruit {
+ @objc optional var juice: Juice { get }
+}
+
+// CHECK-LABEL: sil hidden @$S14dynamic_lookup7consumeyyAA5Fruit_pF
+// CHECK: bb0(%0 : $Fruit):
+// CHECK: [[BOX:%.*]] = alloc_stack $Optional<Juice>
+// CHECK: dynamic_method_br [[SELF:%.*]] : $@opened("{{.*}}") Fruit, #Fruit.juice!getter.1.foreign, bb1, bb2
+
+// CHECK: bb1([[FN:%.*]] : $@convention(objc_method) (@opened("{{.*}}") Fruit) -> @autoreleased Juice):
+// CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+// CHECK: [[METHOD:%.*]] = partial_apply [callee_guaranteed] [[FN]]([[SELF_COPY]]) : $@convention(objc_method) (@opened("{{.*}}") Fruit) -> @autoreleased Juice
+// CHECK: [[B:%.*]] = begin_borrow [[METHOD]]
+// CHECK: [[RESULT:%.*]] = apply [[B]]() : $@callee_guaranteed () -> @owned Juice
+// CHECK: end_borrow [[B]]
+// CHECK: [[PAYLOAD:%.*]] = init_enum_data_addr [[BOX]] : $*Optional<Juice>, #Optional.some!enumelt.1
+// CHECK: store [[RESULT]] to [init] [[PAYLOAD]]
+// CHECK: inject_enum_addr [[BOX]] : $*Optional<Juice>, #Optional.some!enumelt.1
+// CHECK: destroy_value [[METHOD]]
+// CHECK: br bb3
+
+// CHECK: bb2:
+// CHECK: inject_enum_addr [[BOX]] : $*Optional<Juice>, #Optional.none!enumelt
+// CHECK: br bb3
+
+// CHECK: bb3:
+// CHECK: return
+
+func consume(_ fruit: Fruit) {
+ _ = fruit.juice
+}
+
+// rdar://problem/29249513 -- looking up an IUO member through AnyObject
+// produces a Foo!? type. The SIL verifier did not correctly consider Optional
+// to be the lowering of IUO (which is now eliminated by SIL lowering).
+
+@objc protocol IUORequirement {
+ var iuoProperty: AnyObject! { get }
+}
+
+func getIUOPropertyDynamically(x: AnyObject) -> Any {
+ return x.iuoProperty
+}
+
diff --git a/test/SILGen/plus_zero_dynamic_lookup_throws.swift b/test/SILGen/plus_zero_dynamic_lookup_throws.swift
new file mode 100644
index 0000000..6b2a455
--- /dev/null
+++ b/test/SILGen/plus_zero_dynamic_lookup_throws.swift
@@ -0,0 +1,30 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %build-clang-importer-objc-overlays
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -emit-silgen -parse-as-library %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+
+class Blub : NSObject {
+ func blub() throws {}
+}
+
+// CHECK-LABEL: sil hidden @$S21dynamic_lookup_throws8testBlub1ayyXl_tKF : $@convention(thin) (@guaranteed AnyObject) -> @error Error
+// CHECK: bb0([[ARG:%.*]] : $AnyObject):
+func testBlub(a: AnyObject) throws {
+ // CHECK: [[ANYOBJECT_REF:%.*]] = open_existential_ref [[ARG]] : $AnyObject to $@opened("[[OPENED:.*]]") AnyObject
+ // CHECK: [[ANYOBJECT_REF_COPY:%.*]] = copy_value [[ANYOBJECT_REF]]
+ // CHECK: objc_method [[ANYOBJECT_REF_COPY]] : $@opened("[[OPENED]]") AnyObject, #Blub.blub!1.foreign : (Blub) -> () throws -> (), $@convention(objc_method) (Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, @opened("[[OPENED]]") AnyObject) -> ObjCBool
+ // CHECK: cond_br {{%.*}}, bb1, bb2
+
+ // CHECK: bb1
+ // CHECK: return
+
+ // CHECK: bb2
+ // CHECK: function_ref @$S10Foundation22_convertNSErrorToErrorys0E0_pSo0C0CSgF
+ // CHECK: throw {{%.*}} : $Error
+ try a.blub()
+}
diff --git a/test/SILGen/plus_zero_dynamic_self.swift b/test/SILGen/plus_zero_dynamic_self.swift
new file mode 100644
index 0000000..d02f276
--- /dev/null
+++ b/test/SILGen/plus_zero_dynamic_self.swift
@@ -0,0 +1,375 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s -disable-objc-attr-requires-foundation-module | %FileCheck %s
+// RUN: %target-swift-frontend -emit-sil -O %s -disable-objc-attr-requires-foundation-module
+// RUN: %target-swift-frontend -emit-ir %s -disable-objc-attr-requires-foundation-module
+
+protocol P {
+ func f() -> Self
+}
+
+protocol CP : class {
+ func f() -> Self
+}
+
+class X : P, CP {
+ required init(int i: Int) { }
+
+ // CHECK-LABEL: sil hidden @$S12dynamic_self1XC1f{{[_0-9a-zA-Z]*}}F : $@convention(method) (@guaranteed X) -> @owned
+ func f() -> Self { return self }
+
+ // CHECK-LABEL: sil hidden @$S12dynamic_self1XC7factory{{[_0-9a-zA-Z]*}}FZ : $@convention(method) (Int, @thick X.Type) -> @owned X
+ // CHECK: bb0([[I:%[0-9]+]] : @trivial $Int, [[SELF:%[0-9]+]] : @trivial $@thick X.Type):
+ // CHECK: [[DYNAMIC_SELF:%[0-9]+]] = unchecked_trivial_bit_cast [[SELF]] : $@thick X.Type to $@thick @dynamic_self X.Type
+ // CHECK: [[STATIC_SELF:%[0-9]+]] = upcast [[DYNAMIC_SELF]] : $@thick @dynamic_self X.Type to $@thick X.Type
+ // CHECK: [[CTOR:%[0-9]+]] = class_method [[STATIC_SELF]] : $@thick X.Type, #X.init!allocator.1 : (X.Type) -> (Int) -> X, $@convention(method) (Int, @thick X.Type) -> @owned X
+ // CHECK: apply [[CTOR]]([[I]], [[STATIC_SELF]]) : $@convention(method) (Int, @thick X.Type) -> @owned X
+ class func factory(i: Int) -> Self { return self.init(int: i) }
+}
+
+class Y : X {
+ required init(int i: Int) {
+ super.init(int: i)
+ }
+}
+
+class GX<T> {
+ func f() -> Self { return self }
+}
+
+class GY<T> : GX<[T]> { }
+
+// CHECK-LABEL: sil hidden @$S12dynamic_self23testDynamicSelfDispatch{{[_0-9a-zA-Z]*}}F : $@convention(thin) (@guaranteed Y) -> ()
+// CHECK: bb0([[Y:%[0-9]+]] : @guaranteed $Y):
+// CHECK: [[Y_AS_X:%[0-9]+]] = upcast [[Y]] : $Y to $X
+// CHECK: [[X_F:%[0-9]+]] = class_method [[Y_AS_X]] : $X, #X.f!1 : (X) -> () -> @dynamic_self X, $@convention(method) (@guaranteed X) -> @owned X
+// CHECK: [[X_RESULT:%[0-9]+]] = apply [[X_F]]([[Y_AS_X]]) : $@convention(method) (@guaranteed X) -> @owned X
+// CHECK: [[Y_RESULT:%[0-9]+]] = unchecked_ref_cast [[X_RESULT]] : $X to $Y
+// CHECK: destroy_value [[Y_RESULT]] : $Y
+func testDynamicSelfDispatch(y: Y) {
+ _ = y.f()
+}
+
+// CHECK-LABEL: sil hidden @$S12dynamic_self30testDynamicSelfDispatchGeneric{{[_0-9a-zA-Z]*}}F : $@convention(thin) (@guaranteed GY<Int>) -> ()
+func testDynamicSelfDispatchGeneric(gy: GY<Int>) {
+ // CHECK: bb0([[GY:%[0-9]+]] : @guaranteed $GY<Int>):
+ // CHECK: [[GY_AS_GX:%[0-9]+]] = upcast [[GY]] : $GY<Int> to $GX<Array<Int>>
+ // CHECK: [[GX_F:%[0-9]+]] = class_method [[GY_AS_GX]] : $GX<Array<Int>>, #GX.f!1 : <T> (GX<T>) -> () -> @dynamic_self GX<T>, $@convention(method) <τ_0_0> (@guaranteed GX<τ_0_0>) -> @owned GX<τ_0_0>
+ // CHECK: [[GX_RESULT:%[0-9]+]] = apply [[GX_F]]<[Int]>([[GY_AS_GX]]) : $@convention(method) <τ_0_0> (@guaranteed GX<τ_0_0>) -> @owned GX<τ_0_0>
+ // CHECK: [[GY_RESULT:%[0-9]+]] = unchecked_ref_cast [[GX_RESULT]] : $GX<Array<Int>> to $GY<Int>
+ // CHECK: destroy_value [[GY_RESULT]] : $GY<Int>
+ _ = gy.f()
+}
+
+// CHECK-LABEL: sil hidden @$S12dynamic_self21testArchetypeDispatch{{[_0-9a-zA-Z]*}}F : $@convention(thin) <T where T : P> (@in_guaranteed T) -> ()
+func testArchetypeDispatch<T: P>(t: T) {
+ // CHECK: bb0([[T:%[0-9]+]] : @trivial $*T):
+ // CHECK: [[T_RESULT:%[0-9]+]] = alloc_stack $T
+ // CHECK: [[ARCHETYPE_F:%[0-9]+]] = witness_method $T, #P.f!1 : {{.*}} : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ // CHECK: [[SELF_RESULT:%[0-9]+]] = apply [[ARCHETYPE_F]]<T>([[T_RESULT]], [[T]]) : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ _ = t.f()
+}
+
+// CHECK-LABEL: sil hidden @$S12dynamic_self23testExistentialDispatch{{[_0-9a-zA-Z]*}}F
+func testExistentialDispatch(p: P) {
+// CHECK: bb0([[P:%[0-9]+]] : @trivial $*P):
+// CHECK: [[PCOPY_ADDR:%[0-9]+]] = open_existential_addr immutable_access [[P]] : $*P to $*@opened([[N:".*"]]) P
+// CHECK: [[P_RESULT:%[0-9]+]] = alloc_stack $P
+// CHECK: [[P_RESULT_ADDR:%[0-9]+]] = init_existential_addr [[P_RESULT]] : $*P, $@opened([[N]]) P
+// CHECK: [[P_F_METHOD:%[0-9]+]] = witness_method $@opened([[N]]) P, #P.f!1 : {{.*}}, [[PCOPY_ADDR]]{{.*}} : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> @out τ_0_0
+// CHECK: apply [[P_F_METHOD]]<@opened([[N]]) P>([[P_RESULT_ADDR]], [[PCOPY_ADDR]]) : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> @out τ_0_0
+// CHECK: destroy_addr [[P_RESULT]] : $*P
+// CHECK: dealloc_stack [[P_RESULT]] : $*P
+ _ = p.f()
+}
+
+// CHECK-LABEL: sil hidden @$S12dynamic_self28testExistentialDispatchClass{{[_0-9a-zA-Z]*}}F : $@convention(thin) (@guaranteed CP) -> ()
+// CHECK: bb0([[CP:%[0-9]+]] : @guaranteed $CP):
+// CHECK: [[CP_ADDR:%[0-9]+]] = open_existential_ref [[CP]] : $CP to $@opened([[N:".*"]]) CP
+// CHECK: [[CP_F:%[0-9]+]] = witness_method $@opened([[N]]) CP, #CP.f!1 : {{.*}}, [[CP_ADDR]]{{.*}} : $@convention(witness_method: CP) <τ_0_0 where τ_0_0 : CP> (@guaranteed τ_0_0) -> @owned τ_0_0
+// CHECK: [[CP_F_RESULT:%[0-9]+]] = apply [[CP_F]]<@opened([[N]]) CP>([[CP_ADDR]]) : $@convention(witness_method: CP) <τ_0_0 where τ_0_0 : CP> (@guaranteed τ_0_0) -> @owned τ_0_0
+// CHECK: [[RESULT_EXISTENTIAL:%[0-9]+]] = init_existential_ref [[CP_F_RESULT]] : $@opened([[N]]) CP : $@opened([[N]]) CP, $CP
+// CHECK: destroy_value [[RESULT_EXISTENTIAL]]
+func testExistentialDispatchClass(cp: CP) {
+ _ = cp.f()
+}
+
+@objc class ObjC {
+ @objc func method() -> Self { return self }
+}
+
+// CHECK-LABEL: sil hidden @$S12dynamic_self21testAnyObjectDispatch1oyyXl_tF : $@convention(thin) (@guaranteed AnyObject) -> () {
+func testAnyObjectDispatch(o: AnyObject) {
+ // CHECK: dynamic_method_br [[O_OBJ:%[0-9]+]] : $@opened({{.*}}) AnyObject, #ObjC.method!1.foreign, bb1, bb2
+
+ // CHECK: bb1([[METHOD:%[0-9]+]] : @trivial $@convention(objc_method) (@opened({{.*}}) AnyObject) -> @autoreleased AnyObject):
+ // CHECK: [[O_OBJ_COPY:%.*]] = copy_value [[O_OBJ]]
+ // CHECK: [[VAR_9:%[0-9]+]] = partial_apply [callee_guaranteed] [[METHOD]]([[O_OBJ_COPY]]) : $@convention(objc_method) (@opened({{.*}}) AnyObject) -> @autoreleased AnyObject
+ var _ = o.method
+}
+// CHECK: } // end sil function '$S12dynamic_self21testAnyObjectDispatch1oyyXl_tF'
+
+
+// <rdar://problem/16270889> Dispatch through ObjC metatypes.
+class ObjCInit {
+ dynamic required init() { }
+}
+
+// CHECK-LABEL: sil hidden @$S12dynamic_self12testObjCInit{{[_0-9a-zA-Z]*}}F : $@convention(thin) (@thick ObjCInit.Type) -> ()
+func testObjCInit(meta: ObjCInit.Type) {
+// CHECK: bb0([[THICK_META:%[0-9]+]] : @trivial $@thick ObjCInit.Type):
+// CHECK: [[OBJC_META:%[0-9]+]] = thick_to_objc_metatype [[THICK_META]] : $@thick ObjCInit.Type to $@objc_metatype ObjCInit.Type
+// CHECK: [[OBJ:%[0-9]+]] = alloc_ref_dynamic [objc] [[OBJC_META]] : $@objc_metatype ObjCInit.Type, $ObjCInit
+// CHECK: [[INIT:%[0-9]+]] = objc_method [[OBJ]] : $ObjCInit, #ObjCInit.init!initializer.1.foreign : (ObjCInit.Type) -> () -> ObjCInit, $@convention(objc_method) (@owned ObjCInit) -> @owned ObjCInit
+// CHECK: [[RESULT_OBJ:%[0-9]+]] = apply [[INIT]]([[OBJ]]) : $@convention(objc_method) (@owned ObjCInit) -> @owned ObjCInit
+// CHECK: [[RESULT:%[0-9]+]] = tuple ()
+// CHECK: return [[RESULT]] : $()
+ _ = meta.init()
+}
+
+class OptionalResult {
+ func foo() -> Self? { return self }
+}
+
+// CHECK-LABEL: sil hidden @$S12dynamic_self14OptionalResultC3fooACXDSgyF : $@convention(method) (@guaranteed OptionalResult) -> @owned Optional<OptionalResult> {
+// CHECK: bb0([[SELF:%.*]] : @guaranteed $OptionalResult):
+// CHECK-NEXT: debug_value [[SELF]] : $OptionalResult
+// CHECK-NEXT: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+// CHECK-NEXT: [[T0:%.*]] = enum $Optional<OptionalResult>, #Optional.some!enumelt.1, [[SELF_COPY]] : $OptionalResult
+// CHECK-NEXT: return [[T0]] : $Optional<OptionalResult>
+// CHECK: } // end sil function '$S12dynamic_self14OptionalResultC3fooACXDSgyF'
+
+class OptionalResultInheritor : OptionalResult {
+ func bar() {}
+}
+
+func testOptionalResult(v : OptionalResultInheritor) {
+ v.foo()?.bar()
+}
+
+// CHECK-LABEL: sil hidden @$S12dynamic_self18testOptionalResult1vyAA0dE9InheritorC_tF : $@convention(thin) (@guaranteed OptionalResultInheritor) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $OptionalResultInheritor):
+// CHECK: [[CAST_ARG:%.*]] = upcast [[ARG]]
+// CHECK: [[T0:%.*]] = class_method [[CAST_ARG]] : $OptionalResult, #OptionalResult.foo!1 : (OptionalResult) -> () -> @dynamic_self OptionalResult?, $@convention(method) (@guaranteed OptionalResult) -> @owned Optional<OptionalResult>
+// CHECK-NEXT: [[RES:%.*]] = apply [[T0]]([[CAST_ARG]])
+// CHECK-NEXT: [[T4:%.*]] = unchecked_ref_cast [[RES]] : $Optional<OptionalResult> to $Optional<OptionalResultInheritor>
+
+func id<T>(_ t: T) -> T { return t }
+
+class Z {
+
+ required init() {}
+
+ // CHECK-LABEL: sil hidden @$S12dynamic_self1ZC23testDynamicSelfCaptures1xACXDSi_tF : $@convention(method) (Int, @guaranteed Z) -> @owned Z {
+ func testDynamicSelfCaptures(x: Int) -> Self {
+ // CHECK: bb0({{.*}}, [[SELF:%.*]] : @guaranteed $Z):
+
+ // Single capture of 'self' type
+
+ // CHECK: [[FN:%.*]] = function_ref @$S12dynamic_self1ZC23testDynamicSelfCaptures1xACXDSi_tFyycfU_ : $@convention(thin) (@guaranteed Z) -> ()
+ // CHECK-NEXT: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $Z
+ // CHECK-NEXT: partial_apply [callee_guaranteed] [[FN]]([[SELF_COPY]])
+ let fn1 = { _ = self }
+ fn1()
+
+ // Capturing 'self', but it's not the last capture. Make sure it ends
+ // up at the end of the list anyway
+
+ // CHECK: [[FN:%.*]] = function_ref @$S12dynamic_self1ZC23testDynamicSelfCaptures1xACXDSi_tFyycfU0_ : $@convention(thin) (Int, @guaranteed Z) -> ()
+ // CHECK-NEXT: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $Z
+ // CHECK-NEXT: partial_apply [callee_guaranteed] [[FN]]({{.*}}, [[SELF_COPY]])
+ let fn2 = {
+ _ = self
+ _ = x
+ }
+ fn2()
+
+ // Capturing 'self' weak, so we have to pass in a metatype explicitly
+ // so that IRGen can recover metadata.
+
+ // CHECK: [[WEAK_SELF:%.*]] = alloc_box ${ var @sil_weak Optional<Z> }
+ // CHECK: [[FN:%.*]] = function_ref @$S12dynamic_self1ZC23testDynamicSelfCaptures1xACXDSi_tFyycfU1_ : $@convention(thin) (@guaranteed { var @sil_weak Optional<Z> }, @thick @dynamic_self Z.Type) -> ()
+ // CHECK: [[WEAK_SELF_COPY:%.*]] = copy_value [[WEAK_SELF]] : ${ var @sil_weak Optional<Z> }
+ // CHECK-NEXT: [[DYNAMIC_SELF:%.*]] = metatype $@thick @dynamic_self Z.Type
+ // CHECK: partial_apply [callee_guaranteed] [[FN]]([[WEAK_SELF_COPY]], [[DYNAMIC_SELF]]) : $@convention(thin) (@guaranteed { var @sil_weak Optional<Z> }, @thick @dynamic_self Z.Type) -> ()
+ let fn3 = {
+ [weak self] in
+ _ = self
+ }
+ fn3()
+
+ // Capturing a value with a complex type involving self
+
+ // CHECK: [[FN:%.*]] = function_ref @$S12dynamic_self1ZC23testDynamicSelfCaptures1xACXDSi_tFyycfU2_ : $@convention(thin) (@guaranteed (Z, Z), @thick @dynamic_self Z.Type) -> ()
+ let xx = (self, self)
+ let fn4 = {
+ _ = xx
+ }
+ fn4()
+
+ return self
+ }
+
+ // Capturing metatype of dynamic self
+ static func testStaticMethodDynamicSelfCaptures() -> Self {
+ let fn0 = { _ = self; _ = { _ = self } }
+ fn0()
+
+ let x = self
+ let fn1 = { _ = x; _ = { _ = x } }
+ fn1()
+
+ let xx = (self, self)
+ let fn2 = { _ = xx; _ = { _ = xx } }
+ fn2()
+
+ return self.init()
+ }
+
+ // Make sure the actual self value has the same lowered type as the
+ // substituted result of a generic function call
+ func testDynamicSelfSubstitution(_ b: Bool) -> Self {
+ return b ? self : id(self)
+ }
+
+ // Same for metatype of self
+ static func testStaticMethodDynamicSelfSubstitution(_ b: Bool) -> Self {
+ _ = (b ? self : id(self))
+ return self.init()
+ }
+}
+
+// Unbound reference to a method returning Self.
+
+class Factory {
+ required init() {}
+
+ func newInstance() -> Self { return self }
+ class func classNewInstance() -> Self { return self.init() }
+ static func staticNewInstance() -> Self { return self.init() }
+}
+
+// CHECK-LABEL: sil hidden @$S12dynamic_self22partialApplySelfReturn1c1tyAA7FactoryC_AFmtF : $@convention(thin) (@guaranteed Factory, @thick Factory.Type) -> ()
+func partialApplySelfReturn(c: Factory, t: Factory.Type) {
+ // CHECK: function_ref @$S12dynamic_self7FactoryC11newInstanceACXDyFTc : $@convention(thin) (@guaranteed Factory) -> @owned @callee_guaranteed () -> @owned Factory
+ _ = c.newInstance
+ // CHECK: function_ref @$S12dynamic_self7FactoryC11newInstanceACXDyFTc : $@convention(thin) (@guaranteed Factory) -> @owned @callee_guaranteed () -> @owned Factory
+ _ = Factory.newInstance
+ // CHECK: function_ref @$S12dynamic_self7FactoryC11newInstanceACXDyFTc : $@convention(thin) (@guaranteed Factory) -> @owned @callee_guaranteed () -> @owned Factory
+ _ = t.newInstance
+ _ = type(of: c).newInstance
+
+ // CHECK: function_ref @$S12dynamic_self7FactoryC16classNewInstanceACXDyFZTc : $@convention(thin) (@thick Factory.Type) -> @owned @callee_guaranteed () -> @owned Factory
+ _ = t.classNewInstance
+ // CHECK: function_ref @$S12dynamic_self7FactoryC16classNewInstanceACXDyFZTc : $@convention(thin) (@thick Factory.Type) -> @owned @callee_guaranteed () -> @owned Factory
+ _ = type(of: c).classNewInstance
+ // CHECK: function_ref @$S12dynamic_self7FactoryC16classNewInstanceACXDyFZTc : $@convention(thin) (@thick Factory.Type) -> @owned @callee_guaranteed () -> @owned Factory
+ _ = Factory.classNewInstance
+
+ // CHECK: function_ref @$S12dynamic_self7FactoryC17staticNewInstanceACXDyFZTc : $@convention(thin) (@thick Factory.Type) -> @owned @callee_guaranteed () -> @owned Factory
+ _ = t.staticNewInstance
+ // CHECK: function_ref @$S12dynamic_self7FactoryC17staticNewInstanceACXDyFZTc : $@convention(thin) (@thick Factory.Type) -> @owned @callee_guaranteed () -> @owned Factory
+ _ = type(of: c).staticNewInstance
+ // CHECK: function_ref @$S12dynamic_self7FactoryC17staticNewInstanceACXDyFZTc : $@convention(thin) (@thick Factory.Type) -> @owned @callee_guaranteed () -> @owned Factory
+ _ = Factory.staticNewInstance
+}
+
+class FactoryFactory {
+
+ // CHECK-LABEL: sil hidden @$S12dynamic_self07FactoryC0C11newInstanceACXDyFZ : $@convention(method) (@thick FactoryFactory.Type) -> @owned FactoryFactory
+ static func newInstance() -> Self {
+ // CHECK: bb0(%0 : @trivial $@thick FactoryFactory.Type):
+
+ // CHECK: [[DYNAMIC_SELF:%.*]] = unchecked_trivial_bit_cast %0 : $@thick FactoryFactory.Type to $@thick @dynamic_self FactoryFactory.Type
+ // CHECK: [[METATYPE:%.*]] = value_metatype $@thick @dynamic_self FactoryFactory.Type.Type, [[DYNAMIC_SELF]] : $@thick @dynamic_self FactoryFactory.Type
+ // CHECK: [[ANY:%.*]] = init_existential_metatype [[METATYPE]] : $@thick @dynamic_self FactoryFactory.Type.Type, $@thick Any.Type
+ let _: Any.Type = type(of: self)
+
+ while true {}
+ }
+}
+
+// Super call to a method returning Self
+class Base {
+ required init() {}
+
+ func returnsSelf() -> Self {
+ return self
+ }
+
+ static func returnsSelfStatic() -> Self {
+ return self.init()
+ }
+}
+
+class Derived : Base {
+ // CHECK-LABEL: sil hidden @$S12dynamic_self7DerivedC9superCallyyF : $@convention(method) (@guaranteed Derived) -> ()
+ // CHECK: [[SELF:%.*]] = copy_value %0
+ // CHECK: [[SUPER:%.*]] = upcast [[SELF]] : $Derived to $Base
+ // CHECK: [[BORROWED_SUPER:%.*]] = begin_borrow [[SUPER]]
+ // CHECK: [[METHOD:%.*]] = function_ref @$S12dynamic_self4BaseC11returnsSelfACXDyF
+ // CHECK: apply [[METHOD]]([[BORROWED_SUPER]])
+ // CHECK: return
+ func superCall() {
+ _ = super.returnsSelf()
+ }
+
+ // CHECK-LABEL: sil hidden @$S12dynamic_self7DerivedC15superCallStaticyyFZ : $@convention(method) (@thick Derived.Type) -> ()
+ // CHECK: [[SUPER:%.*]] = upcast %0 : $@thick Derived.Type to $@thick Base.Type
+ // CHECK: [[METHOD:%.*]] = function_ref @$S12dynamic_self4BaseC17returnsSelfStaticACXDyFZ
+ // CHECK: apply [[METHOD]]([[SUPER]])
+ // CHECK: return
+ static func superCallStatic() {
+ _ = super.returnsSelfStatic()
+ }
+
+ // CHECK-LABEL: sil hidden @$S12dynamic_self7DerivedC32superCallFromMethodReturningSelfACXDyF : $@convention(method) (@guaranteed Derived) -> @owned Derived
+ // CHECK: [[SELF:%.*]] = copy_value %0
+ // CHECK: [[SUPER:%.*]] = upcast [[SELF]] : $Derived to $Base
+ // CHEcK: [[BORROWED_SUPER:%.*]] = begin_borrow [[SUPER]]
+ // CHECK: [[METHOD:%.*]] = function_ref @$S12dynamic_self4BaseC11returnsSelfACXDyF
+ // CHECK: apply [[METHOD]]([[BORROWED_SUPER]])
+ // CHECK: return
+ func superCallFromMethodReturningSelf() -> Self {
+ _ = super.returnsSelf()
+ return self
+ }
+
+ // CHECK-LABEL: sil hidden @$S12dynamic_self7DerivedC38superCallFromMethodReturningSelfStaticACXDyFZ : $@convention(method) (@thick Derived.Type) -> @owned Derived
+ // CHECK; [[DYNAMIC_SELF:%.*]] = unchecked_trivial_bit_cast %0 : $@thick Derived.Type to $@thick @synamic_self Derived.Type
+ // CHECK: [[SUPER:%.*]] = upcast [[DYNAMIC_SELF]] : $@thick @dynamic_self Derived.Type to $@thick Base.Type
+ // CHECK: [[METHOD:%.*]] = function_ref @$S12dynamic_self4BaseC17returnsSelfStaticACXDyFZ
+ // CHECK: apply [[METHOD]]([[SUPER]])
+ // CHECK: return
+ static func superCallFromMethodReturningSelfStatic() -> Self {
+ _ = super.returnsSelfStatic()
+ return self.init()
+ }
+}
+
+class Generic<T> {
+ // Examples where we have to add a special argument to capture Self's metadata
+ func t1() -> Self {
+ // CHECK-LABEL: sil private @$S12dynamic_self7GenericC2t1ACyxGXDyFAEXDSgycfU_ : $@convention(thin) <T> (@guaranteed <τ_0_0> { var @sil_weak Optional<Generic<τ_0_0>> } <T>, @thick @dynamic_self Generic<T>.Type) -> @owned Optional<Generic<T>>
+ _ = {[weak self] in self }
+ return self
+ }
+
+ func t2() -> Self {
+ // CHECK-LABEL: sil private @$S12dynamic_self7GenericC2t2ACyxGXDyFAEXD_AEXDtycfU_ : $@convention(thin) <T> (@guaranteed (Generic<T>, Generic<T>), @thick @dynamic_self Generic<T>.Type) -> (@owned Generic<T>, @owned Generic<T>)
+ let selves = (self, self)
+ _ = { selves }
+ return self
+ }
+
+ func t3() -> Self {
+ // CHECK-LABEL: sil private @$S12dynamic_self7GenericC2t3ACyxGXDyFAEXDycfU_ : $@convention(thin) <T> (@guaranteed @sil_unowned Generic<T>, @thick @dynamic_self Generic<T>.Type) -> @owned Generic<T>
+ _ = {[unowned self] in self }
+ return self
+ }
+}
+
+// CHECK-LABEL: sil_witness_table hidden X: P module dynamic_self {
+// CHECK: method #P.f!1: {{.*}} : @$S12dynamic_self1XCAA1PA2aDP1f{{[_0-9a-zA-Z]*}}FTW
+
+// CHECK-LABEL: sil_witness_table hidden X: CP module dynamic_self {
+// CHECK: method #CP.f!1: {{.*}} : @$S12dynamic_self1XCAA2CPA2aDP1f{{[_0-9a-zA-Z]*}}FTW
diff --git a/test/SILGen/plus_zero_enum.swift b/test/SILGen/plus_zero_enum.swift
new file mode 100644
index 0000000..53a818c
--- /dev/null
+++ b/test/SILGen/plus_zero_enum.swift
@@ -0,0 +1,215 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -parse-stdlib -parse-as-library -emit-silgen -enable-sil-ownership -module-name Swift %s | %FileCheck %s
+
+precedencegroup AssignmentPrecedence { assignment: true }
+
+enum Optional<Wrapped> {
+ case none
+ case some(Wrapped)
+}
+
+enum Boolish {
+ case falsy
+ case truthy
+}
+
+// CHECK-LABEL: sil hidden @$Ss13Boolish_casesyyF
+func Boolish_cases() {
+ // CHECK: [[BOOLISH:%[0-9]+]] = metatype $@thin Boolish.Type
+ // CHECK-NEXT: [[FALSY:%[0-9]+]] = enum $Boolish, #Boolish.falsy!enumelt
+ _ = Boolish.falsy
+
+ // CHECK-NEXT: [[BOOLISH:%[0-9]+]] = metatype $@thin Boolish.Type
+ // CHECK-NEXT: [[TRUTHY:%[0-9]+]] = enum $Boolish, #Boolish.truthy!enumelt
+ _ = Boolish.truthy
+}
+
+struct Int {}
+
+enum Optionable {
+ case nought
+ case mere(Int)
+}
+
+// CHECK-LABEL: sil hidden @$Ss16Optionable_casesyySiF
+func Optionable_cases(_ x: Int) {
+
+ // CHECK: [[METATYPE:%.*]] = metatype $@thin Optionable.Type
+ // CHECK: [[FN:%.*]] = function_ref @$Ss10OptionableO4mereyABSicABmF
+ // CHECK-NEXT: [[CTOR:%.*]] = apply [[FN]]([[METATYPE]])
+ // CHECK-NEXT: destroy_value [[CTOR]]
+ _ = Optionable.mere
+
+ // CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin Optionable.Type
+ // CHECK-NEXT: [[RES:%.*]] = enum $Optionable, #Optionable.mere!enumelt.1, %0 : $Int
+ _ = Optionable.mere(x)
+}
+
+// CHECK-LABEL: sil shared [transparent] [thunk] @$Ss10OptionableO4mereyABSicABmF
+// CHECK: [[FN:%.*]] = function_ref @$Ss10OptionableO4mereyABSicABmF
+// CHECK-NEXT: [[METHOD:%.*]] = partial_apply [callee_guaranteed] [[FN]](%0)
+// CHECK-NEXT: return [[METHOD]]
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil shared [transparent] @$Ss10OptionableO4mereyABSicABmF
+// CHECK: [[RES:%.*]] = enum $Optionable, #Optionable.mere!enumelt.1, %0 : $Int
+// CHECK-NEXT: return [[RES]] : $Optionable
+// CHECK-NEXT: }
+
+protocol P {}
+struct S : P {}
+
+enum AddressOnly {
+ case nought
+ case mere(P)
+ case phantom(S)
+}
+
+// CHECK-LABEL: sil hidden @$Ss17AddressOnly_casesyys1SVF
+func AddressOnly_cases(_ s: S) {
+
+ // CHECK: [[METATYPE:%.*]] = metatype $@thin AddressOnly.Type
+ // CHECK: [[FN:%.*]] = function_ref @$Ss11AddressOnlyO4mereyABs1P_pcABmF
+ // CHECK-NEXT: [[CTOR:%.*]] = apply [[FN]]([[METATYPE]])
+ // CHECK-NEXT: destroy_value [[CTOR]]
+ _ = AddressOnly.mere
+
+ // CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin AddressOnly.Type
+ // CHECK-NEXT: [[NOUGHT:%.*]] = alloc_stack $AddressOnly
+ // CHECK-NEXT: inject_enum_addr [[NOUGHT]]
+ // CHECK-NEXT: destroy_addr [[NOUGHT]]
+ // CHECK-NEXT: dealloc_stack [[NOUGHT]]
+ _ = AddressOnly.nought
+
+ // CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin AddressOnly.Type
+ // CHECK-NEXT: [[MERE:%.*]] = alloc_stack $AddressOnly
+ // CHECK-NEXT: [[PAYLOAD:%.*]] = init_enum_data_addr [[MERE]]
+ // CHECK-NEXT: [[PAYLOAD_ADDR:%.*]] = init_existential_addr [[PAYLOAD]]
+ // CHECK-NEXT: store %0 to [trivial] [[PAYLOAD_ADDR]]
+ // CHECK-NEXT: inject_enum_addr [[MERE]]
+ // CHECK-NEXT: destroy_addr [[MERE]]
+ // CHECK-NEXT: dealloc_stack [[MERE]]
+ _ = AddressOnly.mere(s)
+
+ // Address-only enum vs loadable payload
+
+ // CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin AddressOnly.Type
+ // CHECK-NEXT: [[PHANTOM:%.*]] = alloc_stack $AddressOnly
+ // CHECK-NEXT: [[PAYLOAD:%.*]] = init_enum_data_addr [[PHANTOM]] : $*AddressOnly, #AddressOnly.phantom!enumelt.1
+ // CHECK-NEXT: store %0 to [trivial] [[PAYLOAD]]
+ // CHECK-NEXT: inject_enum_addr [[PHANTOM]] : $*AddressOnly, #AddressOnly.phantom!enumelt.1
+ // CHECK-NEXT: destroy_addr [[PHANTOM]]
+ // CHECK-NEXT: dealloc_stack [[PHANTOM]]
+
+ _ = AddressOnly.phantom(s)
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil shared [transparent] [thunk] @$Ss11AddressOnlyO4mereyABs1P_pcABmF
+// CHECK: [[FN:%.*]] = function_ref @$Ss11AddressOnlyO4mereyABs1P_pcABmF
+// CHECK-NEXT: [[METHOD:%.*]] = partial_apply [callee_guaranteed] [[FN]](%0)
+// CHECK-NEXT: // function_ref
+// CHECK-NEXT: [[CANONICAL_THUNK_FN:%.*]] = function_ref @$Ss1P_ps11AddressOnlyOIegir_sAA_pACIegnr_TR : $@convention(thin) (@in_guaranteed P, @guaranteed @callee_guaranteed (@in P) -> @out AddressOnly) -> @out AddressOnly
+// CHECK-NEXT: [[CANONICAL_THUNK:%.*]] = partial_apply [callee_guaranteed] [[CANONICAL_THUNK_FN]]([[METHOD]])
+// CHECK-NEXT: return [[CANONICAL_THUNK]] : $@callee_guaranteed (@in_guaranteed P) -> @out AddressOnly
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil shared [transparent] @$Ss11AddressOnlyO4mereyABs1P_pcABmF : $@convention
+// CHECK: bb0([[ARG0:%.*]] : @trivial $*AddressOnly, [[ARG1:%.*]] : @trivial $*P, [[ARG2:%.*]] : @trivial $@thin AddressOnly.Type):
+// CHECK: [[RET_DATA:%.*]] = init_enum_data_addr [[ARG0]] : $*AddressOnly, #AddressOnly.mere!enumelt.1
+// CHECK-NEXT: copy_addr [take] [[ARG1]] to [initialization] [[RET_DATA]] : $*P
+// CHECK-NEXT: inject_enum_addr [[ARG0]] : $*AddressOnly, #AddressOnly.mere!enumelt.1
+// CHECK: return
+// CHECK-NEXT: } // end sil function '$Ss11AddressOnlyO4mereyABs1P_pcABmF'
+
+enum PolyOptionable<T> {
+ case nought
+ case mere(T)
+}
+
+// CHECK-LABEL: sil hidden @$Ss20PolyOptionable_casesyyxlF
+func PolyOptionable_cases<T>(_ t: T) {
+
+// CHECK: [[METATYPE:%.*]] = metatype $@thin PolyOptionable<T>.Type
+// CHECK-NEXT: [[NOUGHT:%.*]] = alloc_stack $PolyOptionable<T>
+// CHECK-NEXT: inject_enum_addr [[NOUGHT]]
+// CHECK-NEXT: destroy_addr [[NOUGHT]]
+// CHECK-NEXT: dealloc_stack [[NOUGHT]]
+ _ = PolyOptionable<T>.nought
+
+// CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin PolyOptionable<T>.Type
+// CHECK-NEXT: [[MERE:%.*]] = alloc_stack $PolyOptionable<T>
+// CHECK-NEXT: [[PAYLOAD:%.*]] = init_enum_data_addr [[MERE]]
+// CHECK-NEXT: copy_addr %0 to [initialization] [[PAYLOAD]]
+// CHECK-NEXT: inject_enum_addr [[MERE]]
+// CHECK-NEXT: destroy_addr [[MERE]]
+// CHECK-NEXT: dealloc_stack [[MERE]]
+
+ _ = PolyOptionable<T>.mere(t)
+
+// CHECK-NOT: destroy_addr %0
+// CHECK: return
+
+}
+
+// The substituted type is loadable and trivial here
+
+// CHECK-LABEL: sil hidden @$Ss32PolyOptionable_specialized_casesyySiF
+func PolyOptionable_specialized_cases(_ t: Int) {
+
+// CHECK: [[METATYPE:%.*]] = metatype $@thin PolyOptionable<Int>.Type
+// CHECK-NEXT: [[NOUGHT:%.*]] = enum $PolyOptionable<Int>, #PolyOptionable.nought!enumelt
+ _ = PolyOptionable<Int>.nought
+
+// CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin PolyOptionable<Int>.Type
+// CHECK-NEXT: [[NOUGHT:%.*]] = enum $PolyOptionable<Int>, #PolyOptionable.mere!enumelt.1, %0
+ _ = PolyOptionable<Int>.mere(t)
+
+// CHECK: return
+
+}
+
+
+// Regression test for a bug where temporary allocations created as a result of
+// tuple implosion were not deallocated in enum constructors.
+struct String { var ptr: Builtin.NativeObject }
+
+enum Foo { case A(P, String) }
+
+// Curry Thunk for Foo.A(_:)
+//
+// CHECK-LABEL: sil shared [transparent] [thunk] @$Ss3FooO1AyABs1P_p_SStcABmF
+// CHECK: [[FN:%.*]] = function_ref @$Ss3FooO1AyABs1P_p_SStcABmF
+// CHECK-NEXT: [[METHOD:%.*]] = partial_apply [callee_guaranteed] [[FN]](%0)
+// CHECK-NEXT: // function_ref
+// CHECK-NEXT: [[CANONICAL_THUNK_FN:%.*]] = function_ref @$Ss1P_pSSs3FooOIegixr_sAA_pSSACIegngr_TR : $@convention(thin) (@in_guaranteed P, @guaranteed String, @guaranteed @callee_guaranteed (@in P, @owned String) -> @out Foo) -> @out Foo
+// CHECK-NEXT: [[CANONICAL_THUNK:%.*]] = partial_apply [callee_guaranteed] [[CANONICAL_THUNK_FN]]([[METHOD]])
+// CHECK-NEXT: return [[CANONICAL_THUNK]]
+// CHECK-NEXT: }
+
+// Foo.A(_:)
+// CHECK-LABEL: sil shared [transparent] @$Ss3FooO1AyABs1P_p_SStcABmF
+// CHECK: bb0([[ARG0:%.*]] : @trivial $*Foo, [[ARG1:%.*]] : @trivial $*P, [[ARG2:%.*]] : @owned $String, [[ARG3:%.*]] : @trivial $@thin Foo.Type):
+// CHECK: [[PAYLOAD:%.*]] = init_enum_data_addr [[ARG0]] : $*Foo, #Foo.A!enumelt.1
+// CHECK-NEXT: [[LEFT:%.*]] = tuple_element_addr [[PAYLOAD]] : $*(P, String), 0
+// CHECK-NEXT: [[RIGHT:%.*]] = tuple_element_addr [[PAYLOAD]] : $*(P, String), 1
+// CHECK-NEXT: copy_addr [take] [[ARG1]] to [initialization] [[LEFT]] : $*P
+// CHECK-NEXT: store [[ARG2]] to [init] [[RIGHT]]
+// CHECK-NEXT: inject_enum_addr [[ARG0]] : $*Foo, #Foo.A!enumelt.1
+// CHECK: return
+// CHECK-NEXT: } // end sil function '$Ss3FooO1AyABs1P_p_SStcABmF'
+
+func Foo_cases() {
+ _ = Foo.A
+}
+
+enum Indirect<T> {
+ indirect case payload((T, other: T))
+ case none
+}
+// CHECK-LABEL: sil{{.*}} @{{.*}}makeIndirectEnum{{.*}} : $@convention(thin) <T> (@in_guaranteed T) -> @owned Indirect<T>
+// CHECK: [[BOX:%.*]] = alloc_box $<τ_0_0> { var (τ_0_0, other: τ_0_0) } <T>
+// CHECK: enum $Indirect<T>, #Indirect.payload!enumelt.1, [[BOX]] : $<τ_0_0> { var (τ_0_0, other: τ_0_0) } <T>
+func makeIndirectEnum<T>(_ payload: T) -> Indirect<T> {
+ return Indirect.payload((payload, other: payload))
+}
diff --git a/test/SILGen/plus_zero_enum_resilience.swift b/test/SILGen/plus_zero_enum_resilience.swift
new file mode 100644
index 0000000..7b5ac8a
--- /dev/null
+++ b/test/SILGen/plus_zero_enum_resilience.swift
@@ -0,0 +1,83 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_struct.swiftmodule -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
+// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_enum.swiftmodule -module-name=resilient_enum -I %t %S/../Inputs/resilient_enum.swift
+// RUN: %target-swift-frontend -I %t -enable-sil-ownership -emit-silgen -enable-resilience %s | %FileCheck %s
+
+import resilient_enum
+
+// Resilient enums are always address-only, and switches must include
+// a default case
+
+// CHECK-LABEL: sil hidden @$S15enum_resilience15resilientSwitchyy0c1_A06MediumOF : $@convention(thin) (@in_guaranteed Medium) -> ()
+// CHECK: [[BOX:%.*]] = alloc_stack $Medium
+// CHECK-NEXT: copy_addr %0 to [initialization] [[BOX]]
+// CHECK-NEXT: switch_enum_addr [[BOX]] : $*Medium, case #Medium.Paper!enumelt: bb1, case #Medium.Canvas!enumelt: bb2, case #Medium.Pamphlet!enumelt.1: bb3, case #Medium.Postcard!enumelt.1: bb4, default bb5
+// CHECK: bb1:
+// CHECK-NEXT: dealloc_stack [[BOX]]
+// CHECK-NEXT: br bb6
+// CHECK: bb2:
+// CHECK-NEXT: dealloc_stack [[BOX]]
+// CHECK-NEXT: br bb6
+// CHECK: bb3:
+// CHECK-NEXT: [[INDIRECT_ADDR:%.*]] = unchecked_take_enum_data_addr [[BOX]]
+// CHECK-NEXT: [[INDIRECT:%.*]] = load [take] [[INDIRECT_ADDR]]
+// CHECK-NEXT: [[PAYLOAD:%.*]] = project_box [[INDIRECT]]
+// CHECK-NEXT: destroy_value [[INDIRECT]]
+// CHECK-NEXT: dealloc_stack [[BOX]]
+// CHECK-NEXT: br bb6
+// CHECK: bb4:
+// CHECK-NEXT: [[PAYLOAD_ADDR:%.*]] = unchecked_take_enum_data_addr [[BOX]]
+// CHECK-NEXT: destroy_addr [[PAYLOAD_ADDR]]
+// CHECK-NEXT: dealloc_stack [[BOX]]
+// CHECK-NEXT: br bb6
+// CHECK: bb5:
+// CHECK-NEXT: builtin "int_trap"()
+// CHECK-NEXT: unreachable
+// CHECK: bb6:
+// CHECK-NOT: destroy_addr %0
+// CHECK-NEXT: [[RESULT:%.*]] = tuple ()
+// CHECK-NEXT: return [[RESULT]]
+
+func resilientSwitch(_ m: Medium) {
+ switch m {
+ case .Paper: ()
+ case .Canvas: ()
+ case .Pamphlet: ()
+ case .Postcard: ()
+ }
+}
+
+// Indirect enums are still address-only, because the discriminator is stored
+// as part of the value, so we cannot resiliently make assumptions about the
+// enum's size
+
+// CHECK-LABEL: sil hidden @$S15enum_resilience21indirectResilientEnumyy010resilient_A016IndirectApproachOF : $@convention(thin) (@in_guaranteed IndirectApproach) -> ()
+func indirectResilientEnum(_ ia: IndirectApproach) {}
+
+public enum MyResilientEnum {
+ case kevin
+ case loki
+}
+
+// CHECK-LABEL: sil @$S15enum_resilience15resilientSwitchyyAA15MyResilientEnumOF : $@convention(thin) (@in_guaranteed MyResilientEnum) -> ()
+// CHECK: switch_enum_addr %2 : $*MyResilientEnum, case #MyResilientEnum.kevin!enumelt: bb1, case #MyResilientEnum.loki!enumelt: bb2 //
+// CHECK: return
+public func resilientSwitch(_ e: MyResilientEnum) {
+ switch e {
+ case .kevin: ()
+ case .loki: ()
+ }
+}
+
+// Inlineable functions must lower the switch as if it came from outside the module
+
+// CHECK-LABEL: sil [serialized] @$S15enum_resilience16inlineableSwitchyyAA15MyResilientEnumOF : $@convention(thin) (@in_guaranteed MyResilientEnum) -> ()
+// CHECK: switch_enum_addr %2 : $*MyResilientEnum, case #MyResilientEnum.kevin!enumelt: bb1, case #MyResilientEnum.loki!enumelt: bb2, default bb3
+// CHECK: return
+@_inlineable public func inlineableSwitch(_ e: MyResilientEnum) {
+ switch e {
+ case .kevin: ()
+ case .loki: ()
+ }
+}
diff --git a/test/SILGen/plus_zero_erasure_reabstraction.swift b/test/SILGen/plus_zero_erasure_reabstraction.swift
new file mode 100644
index 0000000..1c2c0eb
--- /dev/null
+++ b/test/SILGen/plus_zero_erasure_reabstraction.swift
@@ -0,0 +1,20 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+struct Foo {}
+class Bar {}
+
+// CHECK: [[CONCRETE:%.*]] = init_existential_addr [[EXISTENTIAL:%.*]] : $*Any, $Foo.Type
+// CHECK: [[METATYPE:%.*]] = metatype $@thick Foo.Type
+// CHECK: store [[METATYPE]] to [trivial] [[CONCRETE]] : $*@thick Foo.Type
+let x: Any = Foo.self
+
+
+// CHECK: [[CONCRETE:%.*]] = init_existential_addr [[EXISTENTIAL:%.*]] : $*Any, $() -> ()
+// CHECK: [[CLOSURE:%.*]] = function_ref
+// CHECK: [[CLOSURE_THICK:%.*]] = thin_to_thick_function [[CLOSURE]]
+// CHECK: [[REABSTRACTION_THUNK:%.*]] = function_ref @$SIeg_ytytIegnr_TR
+// CHECK: [[CLOSURE_REABSTRACTED:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACTION_THUNK]]([[CLOSURE_THICK]])
+// CHECK: store [[CLOSURE_REABSTRACTED]] to [init] [[CONCRETE]]
+let y: Any = {() -> () in ()}
+
diff --git a/test/SILGen/plus_zero_existential_erasure.swift b/test/SILGen/plus_zero_existential_erasure.swift
new file mode 100644
index 0000000..a60024f
--- /dev/null
+++ b/test/SILGen/plus_zero_existential_erasure.swift
@@ -0,0 +1,129 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+protocol P {
+ func downgrade(_ m68k: Bool) -> Self
+ func upgrade() throws -> Self
+}
+protocol Q {}
+
+struct X: P, Q {
+ func downgrade(_ m68k: Bool) -> X {
+ return self
+ }
+
+ func upgrade() throws -> X {
+ return self
+ }
+}
+
+func makePQ() -> P & Q { return X() }
+
+func useP(_ x: P) { }
+
+func throwingFunc() throws -> Bool { return true }
+
+// CHECK-LABEL: sil hidden @$S19existential_erasure5PQtoPyyF : $@convention(thin) () -> () {
+func PQtoP() {
+ // CHECK: [[PQ_PAYLOAD:%.*]] = open_existential_addr immutable_access [[PQ:%.*]] : $*P & Q to $*[[OPENED_TYPE:@opened(.*) P & Q]]
+ // CHECK: [[P_PAYLOAD:%.*]] = init_existential_addr [[P:%.*]] : $*P, $[[OPENED_TYPE]]
+ // CHECK: copy_addr [[PQ_PAYLOAD]] to [initialization] [[P_PAYLOAD]]
+ // CHECK: destroy_addr [[PQ]]
+ // CHECK-NOT: destroy_addr [[P]]
+ // CHECK-NOT: destroy_addr [[P_PAYLOAD]]
+ // CHECK-NOT: deinit_existential_addr [[PQ]]
+ // CHECK-NOT: destroy_addr [[PQ_PAYLOAD]]
+ useP(makePQ())
+}
+
+// Make sure uninitialized existentials are properly deallocated when we
+// have an early return.
+
+// CHECK-LABEL: sil hidden @$S19existential_erasure19openExistentialToP1yyAA1P_pKF
+func openExistentialToP1(_ p: P) throws {
+// CHECK: bb0(%0 : @trivial $*P):
+// CHECK: [[OPEN:%.*]] = open_existential_addr immutable_access %0 : $*P to $*[[OPEN_TYPE:@opened\(.*\) P]]
+// CHECK: [[RESULT:%.*]] = alloc_stack $P
+// CHECK: [[RESULT_ADDR:%.*]] = init_existential_addr [[RESULT]] : $*P, $[[OPEN_TYPE]]
+// CHECK: [[FUNC:%.*]] = function_ref @$S19existential_erasure12throwingFuncSbyKF
+// CHECK: try_apply [[FUNC]]()
+//
+// CHECK: bb1([[SUCCESS:%.*]] : @trivial $Bool):
+// CHECK: [[METHOD:%.*]] = witness_method $[[OPEN_TYPE]], #P.downgrade!1 : {{.*}}, [[OPEN]]
+// CHECK: apply [[METHOD]]<[[OPEN_TYPE]]>([[RESULT_ADDR]], [[SUCCESS]], [[OPEN]])
+// CHECK: dealloc_stack [[RESULT]]
+// CHECK: return
+//
+// CHECK: bb2([[FAILURE:%.*]] : @owned $Error):
+// CHECK: deinit_existential_addr [[RESULT]]
+// CHECK: dealloc_stack [[RESULT]]
+// CHECK: throw [[FAILURE]]
+//
+ try useP(p.downgrade(throwingFunc()))
+}
+
+// CHECK-LABEL: sil hidden @$S19existential_erasure19openExistentialToP2yyAA1P_pKF
+func openExistentialToP2(_ p: P) throws {
+// CHECK: bb0(%0 : @trivial $*P):
+// CHECK: [[OPEN:%.*]] = open_existential_addr immutable_access %0 : $*P to $*[[OPEN_TYPE:@opened\(.*\) P]]
+// CHECK: [[RESULT:%.*]] = alloc_stack $P
+// CHECK: [[RESULT_ADDR:%.*]] = init_existential_addr [[RESULT]] : $*P, $[[OPEN_TYPE]]
+// CHECK: [[METHOD:%.*]] = witness_method $[[OPEN_TYPE]], #P.upgrade!1 : {{.*}}, [[OPEN]]
+// CHECK: try_apply [[METHOD]]<[[OPEN_TYPE]]>([[RESULT_ADDR]], [[OPEN]])
+//
+// CHECK: bb1
+// CHECK: dealloc_stack [[RESULT]]
+// CHECK: return
+//
+// CHECK: bb2([[FAILURE:%.*]]: @owned $Error):
+// CHECK: deinit_existential_addr [[RESULT]]
+// CHECK: dealloc_stack [[RESULT]]
+// CHECK: throw [[FAILURE]]
+//
+ try useP(p.upgrade())
+}
+
+// Same as above but for boxed existentials
+
+extension Error {
+ func returnOrThrowSelf() throws -> Self {
+ throw self
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S19existential_erasure12errorHandlerys5Error_psAC_pKF
+func errorHandler(_ e: Error) throws -> Error {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Error):
+// CHECK: debug_value [[ARG]] : $Error
+// CHECK: [[OPEN:%.*]] = open_existential_box [[ARG]] : $Error to $*[[OPEN_TYPE:@opened\(.*\) Error]]
+// CHECK: [[RESULT:%.*]] = alloc_existential_box $Error, $[[OPEN_TYPE]]
+// CHECK: [[ADDR:%.*]] = project_existential_box $[[OPEN_TYPE]] in [[RESULT]] : $Error
+// CHECK: [[FUNC:%.*]] = function_ref @$Ss5ErrorP19existential_erasureE17returnOrThrowSelf{{[_0-9a-zA-Z]*}}F
+// CHECK: try_apply [[FUNC]]<[[OPEN_TYPE]]>([[ADDR]], [[OPEN]])
+//
+// CHECK: bb1
+// CHECK: return [[RESULT]] : $Error
+//
+// CHECK: bb2([[FAILURE:%.*]] : @owned $Error):
+// CHECK: dealloc_existential_box [[RESULT]]
+// CHECK: throw [[FAILURE]] : $Error
+//
+ return try e.returnOrThrowSelf()
+}
+
+
+// rdar://problem/22003864 -- SIL verifier crash when init_existential_addr
+// references dynamic Self type
+class EraseDynamicSelf {
+ required init() {}
+
+// CHECK-LABEL: sil hidden @$S19existential_erasure16EraseDynamicSelfC7factoryACXDyFZ : $@convention(method) (@thick EraseDynamicSelf.Type) -> @owned EraseDynamicSelf
+// CHECK: [[ANY:%.*]] = alloc_stack $Any
+// CHECK: init_existential_addr [[ANY]] : $*Any, $@dynamic_self EraseDynamicSelf
+//
+ class func factory() -> Self {
+ let instance = self.init()
+ let _: Any = instance
+ return instance
+ }
+}
diff --git a/test/SILGen/plus_zero_expressions.swift b/test/SILGen/plus_zero_expressions.swift
new file mode 100644
index 0000000..293c8fe
--- /dev/null
+++ b/test/SILGen/plus_zero_expressions.swift
@@ -0,0 +1,737 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: echo "public var x = Int()" | %target-swift-frontend -module-name FooBar -emit-module -o %t -
+// RUN: %target-swift-frontend -parse-stdlib -emit-silgen -enable-sil-ownership %s -I%t -disable-access-control | %FileCheck %s
+
+import Swift
+import FooBar
+
+struct SillyString : _ExpressibleByBuiltinStringLiteral, ExpressibleByStringLiteral {
+ init(_builtinUnicodeScalarLiteral value: Builtin.Int32) {}
+
+ init(unicodeScalarLiteral value: SillyString) { }
+
+ init(
+ _builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer,
+ utf8CodeUnitCount: Builtin.Word,
+ isASCII: Builtin.Int1
+ ) {
+ }
+
+ init(extendedGraphemeClusterLiteral value: SillyString) { }
+
+ init(
+ _builtinStringLiteral start: Builtin.RawPointer,
+ utf8CodeUnitCount: Builtin.Word,
+ isASCII: Builtin.Int1) {
+ }
+
+ init(stringLiteral value: SillyString) { }
+}
+
+struct SillyUTF16String : _ExpressibleByBuiltinUTF16StringLiteral, ExpressibleByStringLiteral {
+ init(_builtinUnicodeScalarLiteral value: Builtin.Int32) { }
+
+ init(unicodeScalarLiteral value: SillyString) { }
+
+ init(
+ _builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer,
+ utf8CodeUnitCount: Builtin.Word,
+ isASCII: Builtin.Int1
+ ) {
+ }
+
+ init(extendedGraphemeClusterLiteral value: SillyString) { }
+
+ init(
+ _builtinStringLiteral start: Builtin.RawPointer,
+ utf8CodeUnitCount: Builtin.Word,
+ isASCII: Builtin.Int1
+ ) { }
+
+ init(
+ _builtinUTF16StringLiteral start: Builtin.RawPointer,
+ utf16CodeUnitCount: Builtin.Word
+ ) {
+ }
+
+ init(stringLiteral value: SillyUTF16String) { }
+}
+
+struct SillyConstUTF16String : _ExpressibleByBuiltinConstUTF16StringLiteral, ExpressibleByStringLiteral {
+ init(_builtinUnicodeScalarLiteral value: Builtin.Int32) { }
+
+ init(unicodeScalarLiteral value: SillyString) { }
+
+ init(
+ _builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer,
+ utf8CodeUnitCount: Builtin.Word,
+ isASCII: Builtin.Int1
+ ) {
+ }
+
+ init(extendedGraphemeClusterLiteral value: SillyString) { }
+
+ init( _builtinConstStringLiteral start: Builtin.RawPointer) { }
+
+ init( _builtinConstUTF16StringLiteral start: Builtin.RawPointer) { }
+
+ init(stringLiteral value: SillyUTF16String) { }
+}
+
+func literals() {
+ var a = 1
+ var b = 1.25
+ var d = "foö"
+ var e:SillyString = "foo"
+
+ var f:SillyConstUTF16String = "foobar"
+ var non_ascii:SillyConstUTF16String = "foobarö"
+}
+// CHECK-LABEL: sil hidden @$S11expressions8literalsyyF
+// CHECK: integer_literal $Builtin.Int2048, 1
+// CHECK: float_literal $Builtin.FPIEEE{{64|80}}, {{0x3FF4000000000000|0x3FFFA000000000000000}}
+// CHECK: string_literal utf16 "foö"
+// CHECK: string_literal utf8 "foo"
+// CHECK: [[CONST_STRING_LIT:%.*]] = const_string_literal utf8 "foobar"
+// CHECK: [[METATYPE:%.*]] = metatype $@thin SillyConstUTF16String.Type
+// CHECK: [[FUN:%.*]] = function_ref @$S11expressions21SillyConstUTF16StringV08_builtincE7LiteralACBp_tcfC : $@convention(method) (Builtin.RawPointer, @thin SillyConstUTF16String.Type) -> SillyConstUTF16String
+// CHECK: apply [[FUN]]([[CONST_STRING_LIT]], [[METATYPE]]) : $@convention(method) (Builtin.RawPointer, @thin SillyConstUTF16String.Type) -> SillyConstUTF16String
+// CHECK: [[CONST_UTF16STRING_LIT:%.*]] = const_string_literal utf16 "foobarö"
+// CHECK: [[FUN:%.*]] = function_ref @$S11expressions21SillyConstUTF16StringV08_builtincdE7LiteralACBp_tcfC : $@convention(method) (Builtin.RawPointer, @thin SillyConstUTF16String.Type) -> SillyConstUTF16String
+// CHECK: apply [[FUN]]([[CONST_UTF16STRING_LIT]], {{.*}}) : $@convention(method) (Builtin.RawPointer, @thin SillyConstUTF16String.Type) -> SillyConstUTF16String
+
+func bar(_ x: Int) {}
+func bar(_ x: Int, _ y: Int) {}
+
+func call_one() {
+ bar(42);
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions8call_oneyyF
+// CHECK: [[FORTYTWO:%[0-9]+]] = integer_literal {{.*}} 42
+// CHECK: [[FORTYTWO_CONVERTED:%[0-9]+]] = apply {{.*}}([[FORTYTWO]], {{.*}})
+// CHECK: [[BAR:%[0-9]+]] = function_ref @$S11expressions3bar{{[_0-9a-zA-Z]*}}F : $@convention(thin) (Int) -> ()
+// CHECK: apply [[BAR]]([[FORTYTWO_CONVERTED]])
+
+func call_two() {
+ bar(42, 219)
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions8call_twoyyF
+// CHECK: [[FORTYTWO:%[0-9]+]] = integer_literal {{.*}} 42
+// CHECK: [[FORTYTWO_CONVERTED:%[0-9]+]] = apply {{.*}}([[FORTYTWO]], {{.*}})
+// CHECK: [[TWONINETEEN:%[0-9]+]] = integer_literal {{.*}} 219
+// CHECK: [[TWONINETEEN_CONVERTED:%[0-9]+]] = apply {{.*}}([[TWONINETEEN]], {{.*}})
+// CHECK: [[BAR:%[0-9]+]] = function_ref @$S11expressions3bar{{[_0-9a-zA-Z]*}}F : $@convention(thin) (Int, Int) -> ()
+// CHECK: apply [[BAR]]([[FORTYTWO_CONVERTED]], [[TWONINETEEN_CONVERTED]])
+
+func tuples() {
+ bar((4, 5).1)
+
+ var T1 : (a: Int16, b: Int) = (b : 42, a : 777)
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions6tuplesyyF
+
+
+class C {
+ var chi:Int
+ init() {
+ chi = 219
+ }
+ init(x:Int) {
+ chi = x
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions7classesyyF
+func classes() {
+ // CHECK: function_ref @$S11expressions1CC{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@thick C.Type) -> @owned C
+ var a = C()
+ // CHECK: function_ref @$S11expressions1CC{{[_0-9a-zA-Z]*}}fC : $@convention(method) (Int, @thick C.Type) -> @owned C
+ var b = C(x: 0)
+}
+
+struct S {
+ var x:Int
+ init() {
+ x = 219
+ }
+ init(x: Int) {
+ self.x = x
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions7structsyyF
+func structs() {
+ // CHECK: function_ref @$S11expressions1SV{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@thin S.Type) -> S
+ var a = S()
+ // CHECK: function_ref @$S11expressions1SV{{[_0-9a-zA-Z]*}}fC : $@convention(method) (Int, @thin S.Type) -> S
+ var b = S(x: 0)
+}
+
+
+func inoutcallee(_ x: inout Int) {}
+func address_of_expr() {
+ var x: Int = 4
+ inoutcallee(&x)
+}
+
+
+
+func identity<T>(_ x: T) -> T {}
+
+struct SomeStruct {
+ mutating
+ func a() {}
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions5callsyyF
+// CHECK: [[METHOD:%[0-9]+]] = function_ref @$S11expressions10SomeStructV1a{{[_0-9a-zA-Z]*}}F : $@convention(method) (@inout SomeStruct) -> ()
+// CHECK: apply [[METHOD]]({{.*}})
+func calls() {
+ var a : SomeStruct
+ a.a()
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions11module_path{{[_0-9a-zA-Z]*}}F
+func module_path() -> Int {
+ return FooBar.x
+ // CHECK: [[x_GET:%[0-9]+]] = function_ref @$S6FooBar1xSivau
+ // CHECK-NEXT: apply [[x_GET]]()
+}
+
+func default_args(_ x: Int, y: Int = 219, z: Int = 20721) {}
+
+// CHECK-LABEL: sil hidden @$S11expressions19call_default_args_1{{[_0-9a-zA-Z]*}}F
+func call_default_args_1(_ x: Int) {
+ default_args(x)
+ // CHECK: [[YFUNC:%[0-9]+]] = function_ref @$S11expressions12default_args{{[_0-9a-zA-Z]*}}A0_
+ // CHECK: [[Y:%[0-9]+]] = apply [[YFUNC]]()
+ // CHECK: [[ZFUNC:%[0-9]+]] = function_ref @$S11expressions12default_args{{[_0-9a-zA-Z]*}}A1_
+ // CHECK: [[Z:%[0-9]+]] = apply [[ZFUNC]]()
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S11expressions12default_args{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[FUNC]]({{.*}}, [[Y]], [[Z]])
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions19call_default_args_2{{[_0-9a-zA-Z]*}}F
+func call_default_args_2(_ x: Int, z: Int) {
+ default_args(x, z:z)
+ // CHECK: [[DEFFN:%[0-9]+]] = function_ref @$S11expressions12default_args{{[_0-9a-zA-Z]*}}A0_
+ // CHECK-NEXT: [[C219:%[0-9]+]] = apply [[DEFFN]]()
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S11expressions12default_args{{[_0-9a-zA-Z]*}}F
+ // CHECK-NEXT: apply [[FUNC]]({{.*}}, [[C219]], {{.*}})
+}
+
+struct Generic<T> {
+ var mono_member:Int
+ var typevar_member:T
+
+ // CHECK-LABEL: sil hidden @$S11expressions7GenericV13type_variable{{[_0-9a-zA-Z]*}}F
+ mutating
+ func type_variable() -> T.Type {
+ return T.self
+ // CHECK: [[METATYPE:%[0-9]+]] = metatype $@thick T.Type
+ // CHECK: return [[METATYPE]]
+ }
+
+ // CHECK-LABEL: sil hidden @$S11expressions7GenericV19copy_typevar_member{{[_0-9a-zA-Z]*}}F
+ mutating
+ func copy_typevar_member(_ x: Generic<T>) {
+ typevar_member = x.typevar_member
+ }
+
+ // CHECK-LABEL: sil hidden @$S11expressions7GenericV12class_method{{[_0-9a-zA-Z]*}}FZ
+ static func class_method() {}
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions18generic_member_ref{{[_0-9a-zA-Z]*}}F
+func generic_member_ref<T>(_ x: Generic<T>) -> Int {
+ // CHECK: bb0([[XADDR:%[0-9]+]] : @trivial $*Generic<T>):
+ return x.mono_member
+ // CHECK: [[MEMBER_ADDR:%[0-9]+]] = struct_element_addr {{.*}}, #Generic.mono_member
+ // CHECK: load [trivial] [[MEMBER_ADDR]]
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions24bound_generic_member_ref{{[_0-9a-zA-Z]*}}F
+func bound_generic_member_ref(_ x: Generic<UnicodeScalar>) -> Int {
+ var x = x
+ // CHECK: bb0([[XADDR:%[0-9]+]] : @trivial $Generic<Unicode.Scalar>):
+ return x.mono_member
+ // CHECK: [[MEMBER_ADDR:%[0-9]+]] = struct_element_addr {{.*}}, #Generic.mono_member
+ // CHECK: load [trivial] [[MEMBER_ADDR]]
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions6coerce{{[_0-9a-zA-Z]*}}F
+func coerce(_ x: Int32) -> Int64 {
+ return 0
+}
+
+class B {
+}
+
+class D : B {
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions8downcast{{[_0-9a-zA-Z]*}}F
+func downcast(_ x: B) -> D {
+ return x as! D
+ // CHECK: unconditional_checked_cast %{{[0-9]+}} : {{.*}} to $D
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions6upcast{{[_0-9a-zA-Z]*}}F
+func upcast(_ x: D) -> B {
+ return x
+ // CHECK: upcast %{{[0-9]+}} : ${{.*}} to $B
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions14generic_upcast{{[_0-9a-zA-Z]*}}F
+func generic_upcast<T : B>(_ x: T) -> B {
+ return x
+ // CHECK: upcast %{{.*}} to $B
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions16generic_downcast{{[_0-9a-zA-Z]*}}F
+func generic_downcast<T : B>(_ x: T, y: B) -> T {
+ return y as! T
+ // CHECK: unconditional_checked_cast %{{[0-9]+}} : {{.*}} to $T
+ // CHECK: return
+}
+
+// TODO: generic_downcast
+
+// CHECK-LABEL: sil hidden @$S11expressions15metatype_upcast{{[_0-9a-zA-Z]*}}F
+func metatype_upcast() -> B.Type {
+ return D.self
+ // CHECK: metatype $@thick D
+ // CHECK-NEXT: upcast
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions19interpolated_string{{[_0-9a-zA-Z]*}}F
+func interpolated_string(_ x: Int, y: String) -> String {
+ return "The \(x) Million Dollar \(y)"
+}
+
+protocol Runcible {
+ associatedtype U
+ var free:Int { get }
+ var associated:U { get }
+
+ func free_method() -> Int
+ mutating func associated_method() -> U.Type
+ static func static_method()
+}
+
+protocol Mincible {
+ var free:Int { get }
+ func free_method() -> Int
+ static func static_method()
+}
+
+protocol Bendable { }
+protocol Wibbleable { }
+
+// CHECK-LABEL: sil hidden @$S11expressions20archetype_member_ref{{[_0-9a-zA-Z]*}}F
+func archetype_member_ref<T : Runcible>(_ x: T) {
+ var x = x
+ x.free_method()
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[X:%.*]]
+ // CHECK-NEXT: [[TEMP:%.*]] = alloc_stack $T
+ // CHECK-NEXT: copy_addr [[READ]] to [initialization] [[TEMP]]
+ // CHECK-NEXT: end_access [[READ]]
+ // CHECK-NEXT: witness_method $T, #Runcible.free_method!1
+ // CHECK-NEXT: apply
+ // CHECK-NEXT: destroy_addr [[TEMP]]
+ var u = x.associated_method()
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown]
+ // CHECK-NEXT: witness_method $T, #Runcible.associated_method!1
+ // CHECK-NEXT: apply
+ T.static_method()
+ // CHECK: metatype $@thick T.Type
+ // CHECK-NEXT: witness_method $T, #Runcible.static_method!1
+ // CHECK-NEXT: apply
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions22existential_member_ref{{[_0-9a-zA-Z]*}}F
+func existential_member_ref(_ x: Mincible) {
+ x.free_method()
+ // CHECK: open_existential_addr
+ // CHECK-NEXT: witness_method
+ // CHECK-NEXT: apply
+}
+
+/*TODO archetype and existential properties and subscripts
+func archetype_property_ref<T : Runcible>(_ x: T) -> (Int, T.U) {
+ x.free = x.free_method()
+ x.associated = x.associated_method()
+ return (x.free, x.associated)
+}
+
+func existential_property_ref<T : Runcible>(_ x: T) -> Int {
+ x.free = x.free_method()
+ return x.free
+}
+
+also archetype/existential subscripts
+*/
+
+struct Spoon : Runcible, Mincible {
+ typealias U = Float
+ var free: Int { return 4 }
+ var associated: Float { return 12 }
+
+ func free_method() -> Int {}
+ func associated_method() -> Float.Type {}
+ static func static_method() {}
+}
+
+struct Hat<T> : Runcible {
+ typealias U = [T]
+ var free: Int { return 1 }
+ var associated: U { get {} }
+
+ func free_method() -> Int {}
+
+ // CHECK-LABEL: sil hidden @$S11expressions3HatV17associated_method{{[_0-9a-zA-Z]*}}F
+ mutating
+ func associated_method() -> U.Type {
+ return U.self
+ // CHECK: [[META:%[0-9]+]] = metatype $@thin Array<T>.Type
+ // CHECK: return [[META]]
+ }
+
+ static func static_method() {}
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions7erasure{{[_0-9a-zA-Z]*}}F
+func erasure(_ x: Spoon) -> Mincible {
+ return x
+ // CHECK: init_existential_addr
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions19declref_to_metatypeAA5SpoonVmyF
+func declref_to_metatype() -> Spoon.Type {
+ return Spoon.self
+ // CHECK: metatype $@thin Spoon.Type
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions27declref_to_generic_metatype{{[_0-9a-zA-Z]*}}F
+func declref_to_generic_metatype() -> Generic<UnicodeScalar>.Type {
+ // FIXME parsing of T<U> in expression context
+ typealias GenericChar = Generic<UnicodeScalar>
+ return GenericChar.self
+ // CHECK: metatype $@thin Generic<Unicode.Scalar>.Type
+}
+
+func int(_ x: Int) {}
+func float(_ x: Float) {}
+
+func tuple() -> (Int, Float) { return (1, 1.0) }
+
+// CHECK-LABEL: sil hidden @$S11expressions13tuple_element{{[_0-9a-zA-Z]*}}F
+func tuple_element(_ x: (Int, Float)) {
+ var x = x
+ // CHECK: [[XADDR:%.*]] = alloc_box ${ var (Int, Float) }
+ // CHECK: [[PB:%.*]] = project_box [[XADDR]]
+
+ int(x.0)
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PB]]
+ // CHECK: tuple_element_addr [[READ]] : {{.*}}, 0
+ // CHECK: apply
+
+ float(x.1)
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PB]]
+ // CHECK: tuple_element_addr [[READ]] : {{.*}}, 1
+ // CHECK: apply
+
+ int(tuple().0)
+ // CHECK: [[ZERO:%.*]] = tuple_extract {{%.*}} : {{.*}}, 0
+ // CHECK: apply {{.*}}([[ZERO]])
+
+ float(tuple().1)
+ // CHECK: [[ONE:%.*]] = tuple_extract {{%.*}} : {{.*}}, 1
+ // CHECK: apply {{.*}}([[ONE]])
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions10containers{{[_0-9a-zA-Z]*}}F
+func containers() -> ([Int], Dictionary<String, Int>) {
+ return ([1, 2, 3], ["Ankeny": 1, "Burnside": 2, "Couch": 3])
+}
+
+// CHECK-LABEL: sil hidden @$S11expressions7if_expr{{[_0-9a-zA-Z]*}}F
+func if_expr(_ a: Bool, b: Bool, x: Int, y: Int, z: Int) -> Int {
+ var a = a
+ var b = b
+ var x = x
+ var y = y
+ var z = z
+ // CHECK: bb0({{.*}}):
+ // CHECK: [[AB:%[0-9]+]] = alloc_box ${ var Bool }
+ // CHECK: [[PBA:%.*]] = project_box [[AB]]
+ // CHECK: [[BB:%[0-9]+]] = alloc_box ${ var Bool }
+ // CHECK: [[PBB:%.*]] = project_box [[BB]]
+ // CHECK: [[XB:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[PBX:%.*]] = project_box [[XB]]
+ // CHECK: [[YB:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[PBY:%.*]] = project_box [[YB]]
+ // CHECK: [[ZB:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[PBZ:%.*]] = project_box [[ZB]]
+
+ return a
+ ? x
+ : b
+ ? y
+ : z
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBA]]
+ // CHECK: [[A:%[0-9]+]] = load [trivial] [[READ]]
+ // CHECK: [[ACOND:%[0-9]+]] = apply {{.*}}([[A]])
+ // CHECK: cond_br [[ACOND]], [[IF_A:bb[0-9]+]], [[ELSE_A:bb[0-9]+]]
+ // CHECK: [[IF_A]]:
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBX]]
+ // CHECK: [[XVAL:%[0-9]+]] = load [trivial] [[READ]]
+ // CHECK: br [[CONT_A:bb[0-9]+]]([[XVAL]] : $Int)
+ // CHECK: [[ELSE_A]]:
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBB]]
+ // CHECK: [[B:%[0-9]+]] = load [trivial] [[READ]]
+ // CHECK: [[BCOND:%[0-9]+]] = apply {{.*}}([[B]])
+ // CHECK: cond_br [[BCOND]], [[IF_B:bb[0-9]+]], [[ELSE_B:bb[0-9]+]]
+ // CHECK: [[IF_B]]:
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBY]]
+ // CHECK: [[YVAL:%[0-9]+]] = load [trivial] [[READ]]
+ // CHECK: br [[CONT_B:bb[0-9]+]]([[YVAL]] : $Int)
+ // CHECK: [[ELSE_B]]:
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBZ]]
+ // CHECK: [[ZVAL:%[0-9]+]] = load [trivial] [[READ]]
+ // CHECK: br [[CONT_B:bb[0-9]+]]([[ZVAL]] : $Int)
+ // CHECK: [[CONT_B]]([[B_RES:%[0-9]+]] : @trivial $Int):
+ // CHECK: br [[CONT_A:bb[0-9]+]]([[B_RES]] : $Int)
+ // CHECK: [[CONT_A]]([[A_RES:%[0-9]+]] : @trivial $Int):
+ // CHECK: return [[A_RES]]
+}
+
+
+// Test that magic identifiers expand properly. We test #column here because
+// it isn't affected as this testcase slides up and down the file over time.
+func magic_identifier_expansion(_ a: Int = #column) {
+ // CHECK-LABEL: sil hidden @{{.*}}magic_identifier_expansion
+
+ // This should expand to the column number of the first _.
+ var tmp = #column
+ // CHECK: integer_literal $Builtin.Int2048, 13
+
+ // This should expand to the column number of the (, not to the column number
+ // of #column in the default argument list of this function.
+ // rdar://14315674
+ magic_identifier_expansion()
+ // CHECK: integer_literal $Builtin.Int2048, 29
+}
+
+func print_string() {
+ // CHECK-LABEL: print_string
+ var str = "\u{08}\u{09}\thello\r\n\0wörld\u{1e}\u{7f}"
+ // CHECK: string_literal utf16 "\u{08}\t\thello\r\n\0wörld\u{1E}\u{7F}"
+}
+
+
+
+// Test that we can silgen superclass calls that go farther than the immediate
+// superclass.
+class Super1 {
+ func funge() {}
+}
+class Super2 : Super1 {}
+class Super3 : Super2 {
+ override func funge() {
+ super.funge()
+ }
+}
+
+// <rdar://problem/16880240> SILGen crash assigning to _
+func testDiscardLValue() {
+ var a = 42
+ _ = a
+}
+
+
+func dynamicTypePlusZero(_ a: Super1) -> Super1.Type {
+ return type(of: a)
+}
+// CHECK-LABEL: dynamicTypePlusZero
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Super1):
+// CHECK-NOT: copy_value
+// CHECK: value_metatype $@thick Super1.Type, [[ARG]] : $Super1
+
+struct NonTrivialStruct {
+ var c : Super1
+ var x: NonTrivialStruct? {
+ get { return nil }
+ set {}
+ }
+}
+
+func dontEmitIgnoredLoadExpr(_ a: NonTrivialStruct) -> NonTrivialStruct.Type {
+ return type(of: a)
+}
+// CHECK-LABEL: dontEmitIgnoredLoadExpr
+// CHECK: bb0(%0 : @guaranteed $NonTrivialStruct):
+// CHECK-NEXT: debug_value
+// CHECK-NEXT: [[RESULT:%.*]] = metatype $@thin NonTrivialStruct.Type
+// CHECK-NEXT: return [[RESULT]] : $@thin NonTrivialStruct.Type
+
+// Test that we evaluate the force unwrap to get its side effects (a potential trap),
+// but don't actually need to perform the load of its value.
+func dontLoadIgnoredLValueForceUnwrap(_ a: inout NonTrivialStruct?) -> NonTrivialStruct.Type {
+ return type(of: a!)
+}
+// CHECK-LABEL: dontLoadIgnoredLValueForceUnwrap
+// CHECK: bb0(%0 : @trivial $*Optional<NonTrivialStruct>):
+// CHECK-NEXT: debug_value_addr %0
+// CHECK-NEXT: [[READ:%[0-9]+]] = begin_access [read] [unknown] %0
+// CHECK-NEXT: switch_enum_addr [[READ]] : $*Optional<NonTrivialStruct>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb1
+// CHECK: bb1:
+// CHECK: unreachable
+// CHECK: bb2:
+// CHECK-NEXT: unchecked_take_enum_data_addr [[READ]] : $*Optional<NonTrivialStruct>, #Optional.some!enumelt.1
+// CHECK-NEXT: end_access [[READ]]
+// CHECK-NEXT: [[METATYPE:%[0-9]+]] = metatype $@thin NonTrivialStruct.Type
+// CHECK-NEXT: return [[METATYPE]]
+
+func dontLoadIgnoredLValueDoubleForceUnwrap(_ a: inout NonTrivialStruct??) -> NonTrivialStruct.Type {
+ return type(of: a!!)
+}
+// CHECK-LABEL: dontLoadIgnoredLValueDoubleForceUnwrap
+// CHECK: bb0(%0 : @trivial $*Optional<Optional<NonTrivialStruct>>):
+// CHECK-NEXT: debug_value_addr %0
+// CHECK-NEXT: [[READ:%[0-9]+]] = begin_access [read] [unknown] %0
+// CHECK-NEXT: switch_enum_addr [[READ]] : $*Optional<Optional<NonTrivialStruct>>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb1
+// CHECK: bb1:
+// CHECK: unreachable
+// CHECK: bb2:
+// CHECK-NEXT: [[UNWRAPPED:%[0-9]+]] = unchecked_take_enum_data_addr [[READ]] : $*Optional<Optional<NonTrivialStruct>>, #Optional.some!enumelt.1
+// CHECK-NEXT: switch_enum_addr [[UNWRAPPED]] : $*Optional<NonTrivialStruct>, case #Optional.some!enumelt.1: bb4, case #Optional.none!enumelt: bb3
+// CHECK: bb3:
+// CHECK: unreachable
+// CHECK: bb4:
+// CHECK-NEXT: unchecked_take_enum_data_addr [[UNWRAPPED]] : $*Optional<NonTrivialStruct>, #Optional.some!enumelt.1
+// CHECK-NEXT: end_access [[READ]]
+// CHECK-NEXT: [[METATYPE:%[0-9]+]] = metatype $@thin NonTrivialStruct.Type
+// CHECK-NEXT: return [[METATYPE]]
+
+func loadIgnoredLValueForceUnwrap(_ a: inout NonTrivialStruct) -> NonTrivialStruct.Type {
+ return type(of: a.x!)
+}
+// CHECK-LABEL: loadIgnoredLValueForceUnwrap
+// CHECK: bb0(%0 : @trivial $*NonTrivialStruct):
+// CHECK-NEXT: debug_value_addr %0
+// CHECK-NEXT: [[READ:%[0-9]+]] = begin_access [read] [unknown] %0
+// CHECK-NEXT: [[BORROW:%[0-9]+]] = load_borrow [[READ]]
+// CHECK-NEXT: // function_ref NonTrivialStruct.x.getter
+// CHECK-NEXT: [[GETTER:%[0-9]+]] = function_ref @$S{{[_0-9a-zA-Z]*}}vg : $@convention(method) (@guaranteed NonTrivialStruct) -> @owned Optional<NonTrivialStruct>
+// CHECK-NEXT: [[X:%[0-9]+]] = apply [[GETTER]]([[BORROW]])
+// CHECK-NEXT: end_borrow [[BORROW]] from [[READ]]
+// CHECK-NEXT: end_access [[READ]]
+// CHECK-NEXT: switch_enum [[X]] : $Optional<NonTrivialStruct>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb1
+// CHECK: bb1:
+// CHECK: unreachable
+// CHECK: bb2([[UNWRAPPED_X:%[0-9]+]] : @owned $NonTrivialStruct):
+// CHECK-NEXT: destroy_value [[UNWRAPPED_X]]
+// CHECK-NEXT: [[METATYPE:%[0-9]+]] = metatype $@thin NonTrivialStruct.Type
+// CHECK-NEXT: return [[METATYPE]]
+
+func loadIgnoredLValueThroughForceUnwrap(_ a: inout NonTrivialStruct?) -> NonTrivialStruct.Type {
+ return type(of: a!.x!)
+}
+// CHECK-LABEL: loadIgnoredLValueThroughForceUnwrap
+// CHECK: bb0(%0 : @trivial $*Optional<NonTrivialStruct>):
+// CHECK-NEXT: debug_value_addr %0
+// CHECK-NEXT: [[READ:%[0-9]+]] = begin_access [read] [unknown] %0
+// CHECK-NEXT: switch_enum_addr [[READ]] : $*Optional<NonTrivialStruct>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb1
+// CHECK: bb1:
+// CHECK: unreachable
+// CHECK: bb2:
+// CHECK-NEXT: [[UNWRAPPED:%[0-9]+]] = unchecked_take_enum_data_addr [[READ]] : $*Optional<NonTrivialStruct>, #Optional.some!enumelt.1
+// CHECK-NEXT: [[BORROW:%[0-9]+]] = load_borrow [[UNWRAPPED]]
+// CHECK-NEXT: // function_ref NonTrivialStruct.x.getter
+// CHECK-NEXT: [[GETTER:%[0-9]+]] = function_ref @$S{{[_0-9a-zA-Z]*}}vg : $@convention(method) (@guaranteed NonTrivialStruct) -> @owned Optional<NonTrivialStruct>
+// CHECK-NEXT: [[X:%[0-9]+]] = apply [[GETTER]]([[BORROW]])
+// CHECK-NEXT: end_borrow [[BORROW]] from [[UNWRAPPED]]
+// CHECK-NEXT: end_access [[READ]]
+// CHECK-NEXT: switch_enum [[X]] : $Optional<NonTrivialStruct>, case #Optional.some!enumelt.1: bb4, case #Optional.none!enumelt: bb3
+// CHECK: bb3:
+// CHECK: unreachable
+// CHECK: bb4([[UNWRAPPED_X:%[0-9]+]] : @owned $NonTrivialStruct):
+// CHECK-NEXT: destroy_value [[UNWRAPPED_X]]
+// CHECK-NEXT: [[METATYPE:%[0-9]+]] = metatype $@thin NonTrivialStruct.Type
+// CHECK-NEXT: return [[METATYPE]]
+
+func evaluateIgnoredKeyPathExpr(_ s: inout NonTrivialStruct, _ kp: WritableKeyPath<NonTrivialStruct, Int>) -> Int.Type {
+ return type(of: s[keyPath: kp])
+}
+// CHECK-LABEL: evaluateIgnoredKeyPathExpr
+// CHECK: bb0(%0 : @trivial $*NonTrivialStruct, %1 : @guaranteed $WritableKeyPath<NonTrivialStruct, Int>):
+// CHECK-NEXT: debug_value_addr %0
+// CHECK-NEXT: debug_value %1
+// CHECK-NEXT: [[S_READ:%[0-9]+]] = begin_access [read] [unknown] %0
+// CHECK-NEXT: [[S_TEMP:%[0-9]+]] = alloc_stack $NonTrivialStruct
+// CHECK-NEXT: copy_addr [[S_READ]] to [initialization] [[S_TEMP]]
+// CHECK-NEXT: [[KP_TEMP:%[0-9]+]] = copy_value %1
+// CHECK-NEXT: [[KP:%[0-9]+]] = upcast [[KP_TEMP]]
+// CHECK-NEXT: [[RESULT:%[0-9]+]] = alloc_stack $Int
+// CHECK-NEXT: // function_ref
+// CHECK-NEXT: [[PROJECT_FN:%[0-9]+]] = function_ref @$Ss23_projectKeyPathReadOnly{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: [[KP_BORROW:%.*]] = begin_borrow [[KP]]
+// CHECK-NEXT: apply [[PROJECT_FN]]<NonTrivialStruct, Int>([[RESULT]], [[S_TEMP]], [[KP_BORROW]])
+// CHECK-NEXT: end_access [[S_READ]]
+// CHECK-NEXT: end_borrow [[KP_BORROW]]
+// CHECK-NEXT: dealloc_stack [[RESULT]]
+// CHECK-NEXT: destroy_value [[KP]]
+// CHECK-NEXT: destroy_addr [[S_TEMP]]
+// CHECK-NEXT: dealloc_stack [[S_TEMP]]
+// CHECK-NEXT: [[METATYPE:%[0-9]+]] = metatype $@thin Int.Type
+// CHECK-NOT: destroy_value %1
+// CHECK-NEXT: return [[METATYPE]]
+
+
+
+// <rdar://problem/18851497> Swiftc fails to compile nested destructuring tuple binding
+// CHECK-LABEL: sil hidden @$S11expressions21implodeRecursiveTupleyySi_Sit_SitSgF
+// CHECK: bb0(%0 : @trivial $Optional<((Int, Int), Int)>):
+func implodeRecursiveTuple(_ expr: ((Int, Int), Int)?) {
+
+ // CHECK: bb2([[WHOLE:%.*]] : @trivial $((Int, Int), Int)):
+ // CHECK-NEXT: [[X:%[0-9]+]] = tuple_extract [[WHOLE]] : $((Int, Int), Int), 0
+ // CHECK-NEXT: [[X0:%[0-9]+]] = tuple_extract [[X]] : $(Int, Int), 0
+ // CHECK-NEXT: [[X1:%[0-9]+]] = tuple_extract [[X]] : $(Int, Int), 1
+ // CHECK-NEXT: [[Y:%[0-9]+]] = tuple_extract [[WHOLE]] : $((Int, Int), Int), 1
+ // CHECK-NEXT: [[X:%[0-9]+]] = tuple ([[X0]] : $Int, [[X1]] : $Int)
+ // CHECK-NEXT: debug_value [[X]] : $(Int, Int), let, name "x"
+ // CHECK-NEXT: debug_value [[Y]] : $Int, let, name "y"
+
+ let (x, y) = expr!
+}
+
+func test20087517() {
+ class Color {
+ static func greenColor() -> Color { return Color() }
+ }
+ let x: (Color?, Int) = (.greenColor(), 1)
+}
+
+func test20596042() {
+ enum E {
+ case thing1
+ case thing2
+ }
+
+ func f() -> (E?, Int)? {
+ return (.thing1, 1)
+ }
+}
+
+func test21886435() {
+ () = ()
+}
+
diff --git a/test/SILGen/plus_zero_extensions_objc.swift b/test/SILGen/plus_zero_extensions_objc.swift
new file mode 100644
index 0000000..24a9cb7
--- /dev/null
+++ b/test/SILGen/plus_zero_extensions_objc.swift
@@ -0,0 +1,36 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -sdk %S/Inputs %s -I %S/Inputs -enable-source-import -emit-silgen -enable-sil-ownership | %FileCheck %s
+//
+// REQUIRES: objc_interop
+
+import Foundation
+
+class Foo {}
+
+extension Foo {
+ dynamic func kay() {}
+ dynamic var cox: Int { return 0 }
+}
+
+// CHECK-LABEL: sil hidden @$S15extensions_objc19extensionReferencesyyAA3FooCF
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Foo):
+func extensionReferences(_ x: Foo) {
+ // dynamic extension methods are still dynamically dispatched.
+ // CHECK: objc_method [[ARG]] : $Foo, #Foo.kay!1.foreign
+ x.kay()
+
+ // CHECK: objc_method [[ARG]] : $Foo, #Foo.cox!getter.1.foreign
+ _ = x.cox
+
+}
+
+func extensionMethodCurrying(_ x: Foo) {
+ _ = x.kay
+}
+
+// CHECK-LABEL: sil shared [thunk] @$S15extensions_objc3FooC3kayyyFTc
+// CHECK: function_ref @$S15extensions_objc3FooC3kayyyFTD
+// CHECK-LABEL: sil shared [transparent] [serializable] [thunk] @$S15extensions_objc3FooC3kayyyFTD
+// CHECK: bb0([[SELF:%.*]] : @guaranteed $Foo):
+// CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+// CHECK: objc_method [[SELF_COPY]] : $Foo, #Foo.kay!1.foreign
diff --git a/test/SILGen/plus_zero_external_definitions.swift b/test/SILGen/plus_zero_external_definitions.swift
new file mode 100644
index 0000000..eed168f
--- /dev/null
+++ b/test/SILGen/plus_zero_external_definitions.swift
@@ -0,0 +1,46 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -sdk %S/Inputs %s -emit-silgen -enable-sil-ownership | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import ansible
+
+var a = NSAnse(Ansible(bellsOn: NSObject()))
+
+var anse = NSAnse
+
+hasNoPrototype()
+
+// CHECK-LABEL: sil @main
+// -- Foreign function is referenced with C calling conv and ownership semantics
+// CHECK: [[NSOBJECT_CTOR:%.*]] = function_ref @$SSo8NSObjectC{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@thick NSObject.Type) -> @owned NSObject
+// CHECK: [[ANSIBLE_CTOR:%.*]] = function_ref @$SSo7AnsibleC{{[_0-9a-zA-Z]*}}fC
+// CHECK: [[ANSIBLE:%.*]] = apply [[ANSIBLE_CTOR]]
+// CHECK: [[NSANSE:%.*]] = function_ref @NSAnse : $@convention(c) (Optional<Ansible>) -> @autoreleased Optional<Ansible>
+// CHECK: [[NSANSE_RESULT:%.*]] = apply [[NSANSE]]([[ANSIBLE]])
+// CHECK: destroy_value [[ANSIBLE]] : $Optional<Ansible>
+// -- Referencing unapplied C function goes through a thunk
+// CHECK: [[NSANSE:%.*]] = function_ref @$SSo6NSAnseySo7AnsibleCSgADFTO : $@convention(thin) (@guaranteed Optional<Ansible>) -> @owned Optional<Ansible>
+// -- Referencing unprototyped C function passes no parameters
+// CHECK: [[NOPROTO:%.*]] = function_ref @hasNoPrototype : $@convention(c) () -> ()
+// CHECK: apply [[NOPROTO]]()
+
+// -- Constructors for imported NSObject
+// CHECK-LABEL: sil shared [serializable] @$SSo8NSObjectC{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@thick NSObject.Type) -> @owned NSObject
+
+// -- Constructors for imported Ansible
+// CHECK-LABEL: sil shared [serializable] @$SSo7AnsibleC{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@in Optional<Any>, @thick Ansible.Type) -> @owned Optional<Ansible>
+
+// -- Native Swift thunk for NSAnse
+// CHECK: sil shared [serialized] [thunk] @$SSo6NSAnseySo7AnsibleCSgADFTO : $@convention(thin) (@guaranteed Optional<Ansible>) -> @owned Optional<Ansible> {
+// CHECK: bb0([[ARG0:%.*]] : @guaranteed $Optional<Ansible>):
+// CHECK: [[ARG0_COPY:%.*]] = copy_value [[ARG0]]
+// CHECK: [[FUNC:%.*]] = function_ref @NSAnse : $@convention(c) (Optional<Ansible>) -> @autoreleased Optional<Ansible>
+// CHECK: [[RESULT:%.*]] = apply [[FUNC]]([[ARG0_COPY]]) : $@convention(c) (Optional<Ansible>) -> @autoreleased Optional<Ansible>
+// CHECK: destroy_value [[ARG0_COPY]] : $Optional<Ansible>
+// CHECK: return [[RESULT]] : $Optional<Ansible>
+// CHECK: }
+
+// -- Constructor for imported Ansible was unused, should not be emitted.
+// CHECK-NOT: sil {{.*}} @$SSo7AnsibleC{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@thick Ansible.Type) -> @owned Ansible
+
diff --git a/test/SILGen/plus_zero_final.swift b/test/SILGen/plus_zero_final.swift
new file mode 100644
index 0000000..3e9133b
--- /dev/null
+++ b/test/SILGen/plus_zero_final.swift
@@ -0,0 +1,45 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+class TestClass {
+
+ final
+ var finalProperty : Int { return 42 }
+
+ final
+ func finalMethod() -> Int { return 12 }
+
+
+ func baseMethod() {}
+}
+
+class TestDerived : TestClass {
+ final
+ override func baseMethod() {}
+}
+
+
+// CHECK-LABEL: sil hidden @{{.*}}testDirectDispatch{{.*}} : $@convention(thin) (@guaranteed TestClass) -> Int {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $TestClass):
+// CHECK: [[FINALMETH:%[0-9]+]] = function_ref @$S5final9TestClassC0A6Method{{[_0-9a-zA-Z]*}}F
+// CHECK: apply [[FINALMETH]]([[ARG]])
+// CHECK: [[FINALPROP:%[0-9]+]] = function_ref @$S5final9TestClassC0A8PropertySivg
+// CHECK: apply [[FINALPROP]]([[ARG]])
+func testDirectDispatch(c : TestClass) -> Int {
+ return c.finalMethod()+c.finalProperty
+}
+
+
+// Verify that the non-overriding final methods don't get emitted to the vtable.
+// CHECK-LABEL: sil_vtable TestClass {
+// CHECK-NEXT: #TestClass.baseMethod!1: {{.*}} : @$S5final9TestClassC10baseMethod{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: #TestClass.init!initializer.1: {{.*}} : @$S5final9TestClassC{{[_0-9a-zA-Z]*}}fc
+// CHECK-NEXT: #TestClass.deinit!
+// CHECK-NEXT: }
+
+// Verify that overriding final methods don't get emitted to the vtable.
+// CHECK-LABEL: sil_vtable TestDerived {
+// CHECK-NEXT: #TestClass.baseMethod!1: {{.*}} : @$S5final11TestDerivedC10baseMethod{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: #TestClass.init!initializer.1: {{.*}} : @$S5final11TestDerivedC{{[_0-9a-zA-Z]*}}fc
+// CHECK-NEXT: #TestDerived.deinit!
+// CHECK-NEXT: }
diff --git a/test/SILGen/plus_zero_force_cast_chained_optional.swift b/test/SILGen/plus_zero_force_cast_chained_optional.swift
new file mode 100644
index 0000000..d903e82
--- /dev/null
+++ b/test/SILGen/plus_zero_force_cast_chained_optional.swift
@@ -0,0 +1,37 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+class Foo {
+ var bar: Bar!
+}
+
+class Bar {
+ var bas: C!
+}
+
+class C {}
+class D: C {}
+
+// CHECK-LABEL: sil hidden @$S27force_cast_chained_optional4testyAA1DCAA3FooCF
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Foo):
+// CHECK: class_method [[ARG]] : $Foo, #Foo.bar!getter.1 : (Foo) -> () -> Bar?, $@convention(method) (@guaranteed Foo) ->
+// CHECK: select_enum_addr
+// CHECK: cond_br {{%.*}}, [[SOME_BAR:bb[0-9]+]], [[NO_BAR:bb[0-9]+]]
+//
+// CHECK: [[NO_BAR]]:
+// CHECK: br [[TRAP:bb[0-9]+]]
+//
+// CHECK: [[SOME_BAR]]:
+// CHECK: [[PAYLOAD_ADDR:%.*]] = unchecked_take_enum_data_addr {{%.*}} : $*Optional<Bar>
+// CHECK: [[BAR:%.*]] = load [copy] [[PAYLOAD_ADDR]]
+// CHECK: [[BORROWED_BAR:%.*]] = begin_borrow [[BAR]]
+// CHECK: [[METHOD:%.*]] = class_method [[BORROWED_BAR]] : $Bar, #Bar.bas!getter.1 : (Bar) -> () -> C?, $@convention(method) (@guaranteed Bar) ->
+// CHECK: apply [[METHOD]]([[BORROWED_BAR]])
+// CHECK: end_borrow [[BORROWED_BAR]] from [[BAR]]
+// CHECK: unconditional_checked_cast {{%.*}} : $C to $D
+//
+// CHECK: [[TRAP]]:
+// CHECK: unreachable
+func test(_ x: Foo) -> D {
+ return x.bar?.bas as! D
+}
diff --git a/test/SILGen/plus_zero_foreach.swift b/test/SILGen/plus_zero_foreach.swift
new file mode 100644
index 0000000..7a3589b
--- /dev/null
+++ b/test/SILGen/plus_zero_foreach.swift
@@ -0,0 +1,642 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+//////////////////
+// Declarations //
+//////////////////
+
+class C {}
+
+@_silgen_name("loopBodyEnd")
+func loopBodyEnd() -> ()
+
+@_silgen_name("condition")
+func condition() -> Bool
+
+@_silgen_name("loopContinueEnd")
+func loopContinueEnd() -> ()
+
+@_silgen_name("loopBreakEnd")
+func loopBreakEnd() -> ()
+
+@_silgen_name("funcEnd")
+func funcEnd() -> ()
+
+struct TrivialStruct {
+ var value: Int32
+}
+
+struct NonTrivialStruct {
+ var value: C
+}
+
+struct GenericStruct<T> {
+ var value: T
+ var value2: C
+}
+
+protocol P {}
+protocol ClassP : class {}
+
+protocol GenericCollection : Collection {
+
+}
+
+///////////
+// Tests //
+///////////
+
+//===----------------------------------------------------------------------===//
+// Trivial Struct
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: sil hidden @$S7foreach13trivialStructyySaySiGF : $@convention(thin) (@guaranteed Array<Int>) -> () {
+// CHECK: bb0([[ARRAY:%.*]] : @guaranteed $Array<Int>):
+// CHECK: [[ITERATOR_BOX:%.*]] = alloc_box ${ var IndexingIterator<Array<Int>> }, var, name "$x$generator"
+// CHECK: [[PROJECT_ITERATOR_BOX:%.*]] = project_box [[ITERATOR_BOX]]
+// CHECK: br [[LOOP_DEST:bb[0-9]+]]
+//
+// CHECK: [[LOOP_DEST]]:
+// CHECK: switch_enum [[IND_VAR:%.*]] : $Optional<Int>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+// CHECK: [[NONE_BB]]:
+// CHECK: br [[CONT_BLOCK:bb[0-9]+]]
+//
+// CHECK: [[SOME_BB]]([[VAR:%.*]] : @trivial $Int):
+// CHECK: [[LOOP_END_FUNC:%.*]] = function_ref @loopBodyEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_END_FUNC]]()
+// CHECK: br [[LOOP_DEST]]
+//
+// CHECK: [[CONT_BLOCK]]:
+// CHECK: destroy_value [[ITERATOR_BOX]]
+// CHECK: [[FUNC_END_FUNC:%.*]] = function_ref @funcEnd : $@convention(thin) () -> ()
+// CHECK: apply [[FUNC_END_FUNC]]()
+// CHECK: } // end sil function '$S7foreach13trivialStructyySaySiGF'
+func trivialStruct(_ xx: [Int]) {
+ for x in xx {
+ loopBodyEnd()
+ }
+ funcEnd()
+}
+
+// TODO: Write this test
+func trivialStructContinue(_ xx: [Int]) {
+ for x in xx {
+ if (condition()) {
+ loopContinueEnd()
+ continue
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+// TODO: Write this test
+func trivialStructBreak(_ xx: [Int]) {
+ for x in xx {
+ if (condition()) {
+ loopBreakEnd()
+ break
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+// CHECK-LABEL: sil hidden @$S7foreach26trivialStructContinueBreakyySaySiGF : $@convention(thin) (@guaranteed Array<Int>) -> () {
+// CHECK: bb0([[ARRAY:%.*]] : @guaranteed $Array<Int>):
+// CHECK: [[ITERATOR_BOX:%.*]] = alloc_box ${ var IndexingIterator<Array<Int>> }, var, name "$x$generator"
+// CHECK: [[PROJECT_ITERATOR_BOX:%.*]] = project_box [[ITERATOR_BOX]]
+// CHECK: [[BORROWED_ARRAY_STACK:%.*]] = alloc_stack $Array<Int>
+// CHECK: store_borrow [[ARRAY]] to [[BORROWED_ARRAY_STACK]]
+// CHECK: [[MAKE_ITERATOR_FUNC:%.*]] = function_ref @$Ss10CollectionPss16IndexingIteratorVyxG0C0RtzrlE04makeC0AEyF : $@convention(method) <τ_0_0 where τ_0_0 : Collection, τ_0_0.Iterator == IndexingIterator<τ_0_0>> (@in_guaranteed τ_0_0) -> @out IndexingIterator<τ_0_0>
+// CHECK: apply [[MAKE_ITERATOR_FUNC]]<[Int]>([[PROJECT_ITERATOR_BOX]], [[BORROWED_ARRAY_STACK]])
+// CHECK: br [[LOOP_DEST:bb[0-9]+]]
+//
+// CHECK: [[LOOP_DEST]]:
+// CHECK: [[GET_ELT_STACK:%.*]] = alloc_stack $Optional<Int>
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PROJECT_ITERATOR_BOX]] : $*IndexingIterator<Array<Int>>
+// CHECK: [[FUNC_REF:%.*]] = function_ref @$Ss16IndexingIteratorV4next7ElementQzSgyF : $@convention(method)
+// CHECK: apply [[FUNC_REF]]<[Int]>([[GET_ELT_STACK]], [[WRITE]])
+// CHECK: [[IND_VAR:%.*]] = load [trivial] [[GET_ELT_STACK]]
+// CHECK: switch_enum [[IND_VAR]] : $Optional<Int>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+// CHECK: [[NONE_BB]]:
+// CHECK: br [[CONT_BLOCK_JUMP:bb[0-9]+]]
+//
+// CHECK: [[SOME_BB]]([[VAR:%.*]] : @trivial $Int):
+// CHECK: cond_br {{%.*}}, [[LOOP_BREAK_END_BLOCK:bb[0-9]+]], [[CONTINUE_CHECK_BLOCK:bb[0-9]+]]
+//
+// CHECK: [[LOOP_BREAK_END_BLOCK]]:
+// CHECK: [[LOOP_BREAK_FUNC:%.*]] = function_ref @loopBreakEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_BREAK_FUNC]]()
+// CHECK: br [[CONT_BLOCK:bb[0-9]+]]
+//
+// CHECK: [[CONTINUE_CHECK_BLOCK]]:
+// CHECK: cond_br {{%.*}}, [[LOOP_CONTINUE_END:bb[0-9]+]], [[LOOP_END_BLOCK:bb[0-9]+]]
+//
+// CHECK: [[LOOP_CONTINUE_END]]:
+// CHECK: [[LOOP_CONTINUE_FUNC:%.*]] = function_ref @loopContinueEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_CONTINUE_FUNC]]() : $@convention(thin) () -> ()
+// CHECK: br [[LOOP_DEST]]
+//
+// CHECK: [[LOOP_END_BLOCK]]:
+// CHECK: [[LOOP_BODY_FUNC:%.*]] = function_ref @loopBodyEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_BODY_FUNC]]()
+// CHECK: br [[LOOP_DEST]]
+//
+// CHECK: [[CONT_BLOCK_JUMP]]:
+// CHECK: br [[CONT_BLOCK]]
+//
+// CHECK: [[CONT_BLOCK]]
+// CHECK: destroy_value [[ITERATOR_BOX]] : ${ var IndexingIterator<Array<Int>> }
+// CHECK: [[FUNC_END_FUNC:%.*]] = function_ref @funcEnd : $@convention(thin) () -> ()
+// CHECK: apply [[FUNC_END_FUNC]]()
+// CHECK: } // end sil function '$S7foreach26trivialStructContinueBreakyySaySiGF'
+func trivialStructContinueBreak(_ xx: [Int]) {
+ for x in xx {
+ if (condition()) {
+ loopBreakEnd()
+ break
+ }
+
+ if (condition()) {
+ loopContinueEnd()
+ continue
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+
+//===----------------------------------------------------------------------===//
+// Existential
+//===----------------------------------------------------------------------===//
+
+func existential(_ xx: [P]) {
+ for x in xx {
+ loopBodyEnd()
+ }
+ funcEnd()
+}
+
+func existentialContinue(_ xx: [P]) {
+ for x in xx {
+ if (condition()) {
+ loopContinueEnd()
+ continue
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+func existentialBreak(_ xx: [P]) {
+ for x in xx {
+ if (condition()) {
+ loopBreakEnd()
+ break
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+// CHECK-LABEL: sil hidden @$S7foreach24existentialContinueBreakyySayAA1P_pGF : $@convention(thin) (@guaranteed Array<P>) -> () {
+// CHECK: bb0([[ARRAY:%.*]] : @guaranteed $Array<P>):
+// CHECK: [[ITERATOR_BOX:%.*]] = alloc_box ${ var IndexingIterator<Array<P>> }, var, name "$x$generator"
+// CHECK: [[PROJECT_ITERATOR_BOX:%.*]] = project_box [[ITERATOR_BOX]]
+// CHECK: [[BORROWED_ARRAY_STACK:%.*]] = alloc_stack $Array<P>
+// CHECK: store_borrow [[ARRAY]] to [[BORROWED_ARRAY_STACK]]
+// CHECK: [[MAKE_ITERATOR_FUNC:%.*]] = function_ref @$Ss10CollectionPss16IndexingIteratorVyxG0C0RtzrlE04makeC0AEyF : $@convention(method) <τ_0_0 where τ_0_0 : Collection, τ_0_0.Iterator == IndexingIterator<τ_0_0>> (@in_guaranteed τ_0_0) -> @out IndexingIterator<τ_0_0>
+// CHECK: apply [[MAKE_ITERATOR_FUNC]]<[P]>([[PROJECT_ITERATOR_BOX]], [[BORROWED_ARRAY_STACK]])
+// CHECK: [[ELT_STACK:%.*]] = alloc_stack $Optional<P>
+// CHECK: br [[LOOP_DEST:bb[0-9]+]]
+//
+// CHECK: [[LOOP_DEST]]:
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PROJECT_ITERATOR_BOX]] : $*IndexingIterator<Array<P>>
+// CHECK: [[FUNC_REF:%.*]] = function_ref @$Ss16IndexingIteratorV4next7ElementQzSgyF : $@convention(method)
+// CHECK: apply [[FUNC_REF]]<[P]>([[ELT_STACK]], [[WRITE]])
+// CHECK: switch_enum_addr [[ELT_STACK]] : $*Optional<P>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+// CHECK: [[NONE_BB]]:
+// CHECK: br [[CONT_BLOCK_JUMP:bb[0-9]+]]
+//
+// CHECK: [[SOME_BB]]:
+// CHECK: [[T0:%.*]] = alloc_stack $P, let, name "x"
+// CHECK: [[ELT_STACK_TAKE:%.*]] = unchecked_take_enum_data_addr [[ELT_STACK]] : $*Optional<P>, #Optional.some!enumelt.1
+// CHECK: copy_addr [take] [[ELT_STACK_TAKE]] to [initialization] [[T0]]
+// CHECK: cond_br {{%.*}}, [[LOOP_BREAK_END_BLOCK:bb[0-9]+]], [[CONTINUE_CHECK_BLOCK:bb[0-9]+]]
+//
+// CHECK: [[LOOP_BREAK_END_BLOCK]]:
+// CHECK: [[LOOP_BREAK_FUNC:%.*]] = function_ref @loopBreakEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_BREAK_FUNC]]()
+// CHECK: destroy_addr [[T0]]
+// CHECK: dealloc_stack [[T0]]
+// CHECK: br [[CONT_BLOCK:bb[0-9]+]]
+//
+// CHECK: [[CONTINUE_CHECK_BLOCK]]:
+// CHECK: cond_br {{%.*}}, [[LOOP_CONTINUE_END:bb[0-9]+]], [[LOOP_END_BLOCK:bb[0-9]+]]
+//
+// CHECK: [[LOOP_CONTINUE_END]]:
+// CHECK: [[LOOP_CONTINUE_FUNC:%.*]] = function_ref @loopContinueEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_CONTINUE_FUNC]]() : $@convention(thin) () -> ()
+// CHECK: destroy_addr [[T0]]
+// CHECK: dealloc_stack [[T0]]
+// CHECK: br [[LOOP_DEST]]
+//
+// CHECK: [[LOOP_END_BLOCK]]:
+// CHECK: [[LOOP_BODY_FUNC:%.*]] = function_ref @loopBodyEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_BODY_FUNC]]()
+// CHECK: destroy_addr [[T0]]
+// CHECK: dealloc_stack [[T0]]
+// CHECK: br [[LOOP_DEST]]
+//
+// CHECK: [[CONT_BLOCK_JUMP]]:
+// CHECK: br [[CONT_BLOCK]]
+//
+// CHECK: [[CONT_BLOCK]]
+// CHECK: dealloc_stack [[ELT_STACK]]
+// CHECK: destroy_value [[ITERATOR_BOX]] : ${ var IndexingIterator<Array<P>> }
+// CHECK: [[FUNC_END_FUNC:%.*]] = function_ref @funcEnd : $@convention(thin) () -> ()
+// CHECK: apply [[FUNC_END_FUNC]]()
+// CHECK: } // end sil function '$S7foreach24existentialContinueBreakyySayAA1P_pGF'
+func existentialContinueBreak(_ xx: [P]) {
+ for x in xx {
+ if (condition()) {
+ loopBreakEnd()
+ break
+ }
+
+ if (condition()) {
+ loopContinueEnd()
+ continue
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+//===----------------------------------------------------------------------===//
+// Class Constrainted Existential
+//===----------------------------------------------------------------------===//
+
+func existentialClass(_ xx: [ClassP]) {
+ for x in xx {
+ loopBodyEnd()
+ }
+ funcEnd()
+}
+
+func existentialClassContinue(_ xx: [ClassP]) {
+ for x in xx {
+ if (condition()) {
+ loopContinueEnd()
+ continue
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+func existentialClassBreak(_ xx: [ClassP]) {
+ for x in xx {
+ if (condition()) {
+ loopBreakEnd()
+ break
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+func existentialClassContinueBreak(_ xx: [ClassP]) {
+ for x in xx {
+ if (condition()) {
+ loopBreakEnd()
+ break
+ }
+
+ if (condition()) {
+ loopContinueEnd()
+ continue
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+//===----------------------------------------------------------------------===//
+// Generic Struct
+//===----------------------------------------------------------------------===//
+
+func genericStruct<T>(_ xx: [GenericStruct<T>]) {
+ for x in xx {
+ loopBodyEnd()
+ }
+ funcEnd()
+}
+
+func genericStructContinue<T>(_ xx: [GenericStruct<T>]) {
+ for x in xx {
+ if (condition()) {
+ loopContinueEnd()
+ continue
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+func genericStructBreak<T>(_ xx: [GenericStruct<T>]) {
+ for x in xx {
+ if (condition()) {
+ loopBreakEnd()
+ break
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+// CHECK-LABEL: sil hidden @$S7foreach26genericStructContinueBreakyySayAA07GenericC0VyxGGlF : $@convention(thin) <T> (@guaranteed Array<GenericStruct<T>>) -> () {
+// CHECK: bb0([[ARRAY:%.*]] : @guaranteed $Array<GenericStruct<T>>):
+// CHECK: [[ITERATOR_BOX:%.*]] = alloc_box $<τ_0_0> { var IndexingIterator<Array<GenericStruct<τ_0_0>>> } <T>, var, name "$x$generator"
+// CHECK: [[PROJECT_ITERATOR_BOX:%.*]] = project_box [[ITERATOR_BOX]]
+// CHECK: [[BORROWED_ARRAY_STACK:%.*]] = alloc_stack $Array<GenericStruct<T>>
+// CHECK: store_borrow [[ARRAY]] to [[BORROWED_ARRAY_STACK]]
+// CHECK: [[MAKE_ITERATOR_FUNC:%.*]] = function_ref @$Ss10CollectionPss16IndexingIteratorVyxG0C0RtzrlE04makeC0AEyF : $@convention(method) <τ_0_0 where τ_0_0 : Collection, τ_0_0.Iterator == IndexingIterator<τ_0_0>> (@in_guaranteed τ_0_0) -> @out IndexingIterator<τ_0_0>
+// CHECK: apply [[MAKE_ITERATOR_FUNC]]<[GenericStruct<T>]>([[PROJECT_ITERATOR_BOX]], [[BORROWED_ARRAY_STACK]])
+// CHECK: [[ELT_STACK:%.*]] = alloc_stack $Optional<GenericStruct<T>>
+// CHECK: br [[LOOP_DEST:bb[0-9]+]]
+//
+// CHECK: [[LOOP_DEST]]:
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PROJECT_ITERATOR_BOX]] : $*IndexingIterator<Array<GenericStruct<T>>>
+// CHECK: [[FUNC_REF:%.*]] = function_ref @$Ss16IndexingIteratorV4next7ElementQzSgyF : $@convention(method)
+// CHECK: apply [[FUNC_REF]]<[GenericStruct<T>]>([[ELT_STACK]], [[WRITE]])
+// CHECK: switch_enum_addr [[ELT_STACK]] : $*Optional<GenericStruct<T>>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+// CHECK: [[NONE_BB]]:
+// CHECK: br [[CONT_BLOCK_JUMP:bb[0-9]+]]
+//
+// CHECK: [[SOME_BB]]:
+// CHECK: [[T0:%.*]] = alloc_stack $GenericStruct<T>, let, name "x"
+// CHECK: [[ELT_STACK_TAKE:%.*]] = unchecked_take_enum_data_addr [[ELT_STACK]] : $*Optional<GenericStruct<T>>, #Optional.some!enumelt.1
+// CHECK: copy_addr [take] [[ELT_STACK_TAKE]] to [initialization] [[T0]]
+// CHECK: cond_br {{%.*}}, [[LOOP_BREAK_END_BLOCK:bb[0-9]+]], [[CONTINUE_CHECK_BLOCK:bb[0-9]+]]
+//
+// CHECK: [[LOOP_BREAK_END_BLOCK]]:
+// CHECK: [[LOOP_BREAK_FUNC:%.*]] = function_ref @loopBreakEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_BREAK_FUNC]]()
+// CHECK: destroy_addr [[T0]]
+// CHECK: dealloc_stack [[T0]]
+// CHECK: br [[CONT_BLOCK:bb[0-9]+]]
+//
+// CHECK: [[CONTINUE_CHECK_BLOCK]]:
+// CHECK: cond_br {{%.*}}, [[LOOP_CONTINUE_END:bb[0-9]+]], [[LOOP_END_BLOCK:bb[0-9]+]]
+//
+// CHECK: [[LOOP_CONTINUE_END]]:
+// CHECK: [[LOOP_CONTINUE_FUNC:%.*]] = function_ref @loopContinueEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_CONTINUE_FUNC]]() : $@convention(thin) () -> ()
+// CHECK: destroy_addr [[T0]]
+// CHECK: dealloc_stack [[T0]]
+// CHECK: br [[LOOP_DEST]]
+//
+// CHECK: [[LOOP_END_BLOCK]]:
+// CHECK: [[LOOP_BODY_FUNC:%.*]] = function_ref @loopBodyEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_BODY_FUNC]]()
+// CHECK: destroy_addr [[T0]]
+// CHECK: dealloc_stack [[T0]]
+// CHECK: br [[LOOP_DEST]]
+//
+// CHECK: [[CONT_BLOCK_JUMP]]:
+// CHECK: br [[CONT_BLOCK]]
+//
+// CHECK: [[CONT_BLOCK]]
+// CHECK: dealloc_stack [[ELT_STACK]]
+// CHECK: destroy_value [[ITERATOR_BOX]]
+// CHECK: [[FUNC_END_FUNC:%.*]] = function_ref @funcEnd : $@convention(thin) () -> ()
+// CHECK: apply [[FUNC_END_FUNC]]()
+// CHECK: } // end sil function '$S7foreach26genericStructContinueBreakyySayAA07GenericC0VyxGGlF'
+func genericStructContinueBreak<T>(_ xx: [GenericStruct<T>]) {
+ for x in xx {
+ if (condition()) {
+ loopBreakEnd()
+ break
+ }
+
+ if (condition()) {
+ loopContinueEnd()
+ continue
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+//===----------------------------------------------------------------------===//
+// Fully Generic Collection
+//===----------------------------------------------------------------------===//
+
+func genericCollection<T : Collection>(_ xx: T) {
+ for x in xx {
+ loopBodyEnd()
+ }
+ funcEnd()
+}
+
+func genericCollectionContinue<T : Collection>(_ xx: T) {
+ for x in xx {
+ if (condition()) {
+ loopContinueEnd()
+ continue
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+func genericCollectionBreak<T : Collection>(_ xx: T) {
+ for x in xx {
+ if (condition()) {
+ loopBreakEnd()
+ break
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+// CHECK-LABEL: sil hidden @$S7foreach30genericCollectionContinueBreakyyxs0C0RzlF : $@convention(thin) <T where T : Collection> (@in_guaranteed T) -> () {
+// CHECK: bb0([[COLLECTION:%.*]] : @trivial $*T):
+// CHECK: [[ITERATOR_BOX:%.*]] = alloc_box $<τ_0_0 where τ_0_0 : Collection> { var τ_0_0.Iterator } <T>, var, name "$x$generator"
+// CHECK: [[PROJECT_ITERATOR_BOX:%.*]] = project_box [[ITERATOR_BOX]]
+// CHECK: [[MAKE_ITERATOR_FUNC:%.*]] = witness_method $T, #Sequence.makeIterator!1 : <Self where Self : Sequence> (Self) -> () -> Self.Iterator : $@convention(witness_method: Sequence) <τ_0_0 where τ_0_0 : Sequence> (@in_guaranteed τ_0_0) -> @out τ_0_0.Iterator
+// CHECK: apply [[MAKE_ITERATOR_FUNC]]<T>([[PROJECT_ITERATOR_BOX]], [[COLLECTION]])
+// CHECK: [[ELT_STACK:%.*]] = alloc_stack $Optional<T.Element>
+// CHECK: br [[LOOP_DEST:bb[0-9]+]]
+//
+// CHECK: [[LOOP_DEST]]:
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PROJECT_ITERATOR_BOX]] : $*T.Iterator
+// CHECK: [[GET_NEXT_FUNC:%.*]] = witness_method $T.Iterator, #IteratorProtocol.next!1 : <Self where Self : IteratorProtocol> (inout Self) -> () -> Self.Element? : $@convention(witness_method: IteratorProtocol) <τ_0_0 where τ_0_0 : IteratorProtocol> (@inout τ_0_0) -> @out Optional<τ_0_0.Element>
+// CHECK: apply [[GET_NEXT_FUNC]]<T.Iterator>([[ELT_STACK]], [[WRITE]])
+// CHECK: switch_enum_addr [[ELT_STACK]] : $*Optional<T.Element>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+// CHECK: [[NONE_BB]]:
+// CHECK: br [[CONT_BLOCK_JUMP:bb[0-9]+]]
+//
+// CHECK: [[SOME_BB]]:
+// CHECK: [[T0:%.*]] = alloc_stack $T.Element, let, name "x"
+// CHECK: [[ELT_STACK_TAKE:%.*]] = unchecked_take_enum_data_addr [[ELT_STACK]] : $*Optional<T.Element>, #Optional.some!enumelt.1
+// CHECK: copy_addr [take] [[ELT_STACK_TAKE]] to [initialization] [[T0]]
+// CHECK: cond_br {{%.*}}, [[LOOP_BREAK_END_BLOCK:bb[0-9]+]], [[CONTINUE_CHECK_BLOCK:bb[0-9]+]]
+//
+// CHECK: [[LOOP_BREAK_END_BLOCK]]:
+// CHECK: [[LOOP_BREAK_FUNC:%.*]] = function_ref @loopBreakEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_BREAK_FUNC]]()
+// CHECK: destroy_addr [[T0]]
+// CHECK: dealloc_stack [[T0]]
+// CHECK: br [[CONT_BLOCK:bb[0-9]+]]
+//
+// CHECK: [[CONTINUE_CHECK_BLOCK]]:
+// CHECK: cond_br {{%.*}}, [[LOOP_CONTINUE_END:bb[0-9]+]], [[LOOP_END_BLOCK:bb[0-9]+]]
+//
+// CHECK: [[LOOP_CONTINUE_END]]:
+// CHECK: [[LOOP_CONTINUE_FUNC:%.*]] = function_ref @loopContinueEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_CONTINUE_FUNC]]() : $@convention(thin) () -> ()
+// CHECK: destroy_addr [[T0]]
+// CHECK: dealloc_stack [[T0]]
+// CHECK: br [[LOOP_DEST]]
+//
+// CHECK: [[LOOP_END_BLOCK]]:
+// CHECK: [[LOOP_BODY_FUNC:%.*]] = function_ref @loopBodyEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_BODY_FUNC]]()
+// CHECK: destroy_addr [[T0]]
+// CHECK: dealloc_stack [[T0]]
+// CHECK: br [[LOOP_DEST]]
+//
+// CHECK: [[CONT_BLOCK_JUMP]]:
+// CHECK: br [[CONT_BLOCK]]
+//
+// CHECK: [[CONT_BLOCK]]
+// CHECK: dealloc_stack [[ELT_STACK]]
+// CHECK: destroy_value [[ITERATOR_BOX]]
+// CHECK: [[FUNC_END_FUNC:%.*]] = function_ref @funcEnd : $@convention(thin) () -> ()
+// CHECK: apply [[FUNC_END_FUNC]]()
+// CHECK: } // end sil function '$S7foreach30genericCollectionContinueBreakyyxs0C0RzlF'
+func genericCollectionContinueBreak<T : Collection>(_ xx: T) {
+ for x in xx {
+ if (condition()) {
+ loopBreakEnd()
+ break
+ }
+
+ if (condition()) {
+ loopContinueEnd()
+ continue
+ }
+ loopBodyEnd()
+ }
+
+ funcEnd()
+}
+
+//===----------------------------------------------------------------------===//
+// Pattern Match Tests
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: sil hidden @$S7foreach13tupleElementsyySayAA1CC_ADtGF
+func tupleElements(_ xx: [(C, C)]) {
+ // CHECK: bb3([[PAYLOAD:%.*]] : @owned $(C, C)):
+ // CHECK: [[BORROWED_PAYLOAD:%.*]] = begin_borrow [[PAYLOAD]]
+ // CHECK: [[A:%.*]] = tuple_extract [[BORROWED_PAYLOAD]] : $(C, C), 0
+ // CHECK: [[COPY_A:%.*]] = copy_value [[A]]
+ // CHECK: [[B:%.*]] = tuple_extract [[BORROWED_PAYLOAD]] : $(C, C), 1
+ // CHECK: [[COPY_B:%.*]] = copy_value [[B]]
+ // CHECK: end_borrow [[BORROWED_PAYLOAD]] from [[PAYLOAD]]
+ // CHECK: destroy_value [[COPY_B]]
+ // CHECK: destroy_value [[COPY_A]]
+ // CHECK: destroy_value [[PAYLOAD]]
+ for (a, b) in xx {}
+ // CHECK: bb7([[PAYLOAD:%.*]] : @owned $(C, C)):
+ // CHECK: [[BORROWED_PAYLOAD:%.*]] = begin_borrow [[PAYLOAD]]
+ // CHECK: [[A:%.*]] = tuple_extract [[BORROWED_PAYLOAD]] : $(C, C), 0
+ // CHECK: [[COPY_A:%.*]] = copy_value [[A]]
+ // CHECK: [[B:%.*]] = tuple_extract [[BORROWED_PAYLOAD]] : $(C, C), 1
+ // CHECK: [[COPY_B:%.*]] = copy_value [[B]]
+ // CHECK: destroy_value [[COPY_B]]
+ // CHECK: end_borrow [[BORROWED_PAYLOAD]] from [[PAYLOAD]]
+ // CHECK: destroy_value [[COPY_A]]
+ // CHECK: destroy_value [[PAYLOAD]]
+ for (a, _) in xx {}
+ // CHECK: bb11([[PAYLOAD:%.*]] : @owned $(C, C)):
+ // CHECK: [[BORROWED_PAYLOAD:%.*]] = begin_borrow [[PAYLOAD]]
+ // CHECK: [[A:%.*]] = tuple_extract [[BORROWED_PAYLOAD]] : $(C, C), 0
+ // CHECK: [[COPY_A:%.*]] = copy_value [[A]]
+ // CHECK: [[B:%.*]] = tuple_extract [[BORROWED_PAYLOAD]] : $(C, C), 1
+ // CHECK: [[COPY_B:%.*]] = copy_value [[B]]
+ // CHECK: destroy_value [[COPY_A]]
+ // CHECK: end_borrow [[BORROWED_PAYLOAD]] from [[PAYLOAD]]
+ // CHECK: destroy_value [[COPY_B]]
+ // CHECK: destroy_value [[PAYLOAD]]
+ for (_, b) in xx {}
+ // CHECK: bb15([[PAYLOAD:%.*]] : @owned $(C, C)):
+ // CHECK: [[BORROWED_PAYLOAD:%.*]] = begin_borrow [[PAYLOAD]]
+ // CHECK: [[A:%.*]] = tuple_extract [[BORROWED_PAYLOAD]] : $(C, C), 0
+ // CHECK: [[COPY_A:%.*]] = copy_value [[A]]
+ // CHECK: [[B:%.*]] = tuple_extract [[BORROWED_PAYLOAD]] : $(C, C), 1
+ // CHECK: [[COPY_B:%.*]] = copy_value [[B]]
+ // CHECK: destroy_value [[COPY_B]]
+ // CHECK: destroy_value [[COPY_A]]
+ // CHECK: end_borrow [[BORROWED_PAYLOAD]] from [[PAYLOAD]]
+ // CHECK: destroy_value [[PAYLOAD]]
+ for (_, _) in xx {}
+ // CHECK: bb19([[PAYLOAD:%.*]] : @owned $(C, C)):
+ // CHECK: [[BORROWED_PAYLOAD:%.*]] = begin_borrow [[PAYLOAD]]
+ // CHECK: [[A:%.*]] = tuple_extract [[BORROWED_PAYLOAD]] : $(C, C), 0
+ // CHECK: [[COPY_A:%.*]] = copy_value [[A]]
+ // CHECK: [[B:%.*]] = tuple_extract [[BORROWED_PAYLOAD]] : $(C, C), 1
+ // CHECK: [[COPY_B:%.*]] = copy_value [[B]]
+ // CHECK: destroy_value [[COPY_B]]
+ // CHECK: destroy_value [[COPY_A]]
+ // CHECK: end_borrow [[BORROWED_PAYLOAD]] from [[PAYLOAD]]
+ // CHECK: destroy_value [[PAYLOAD]]
+ for _ in xx {}
+}
+
+// Make sure that when we have an unused value, we properly iterate over the
+// loop rather than run through the loop once.
+//
+// CHECK-LABEL: sil hidden @$S7foreach16unusedArgPatternyySaySiGF : $@convention(thin) (@guaranteed Array<Int>) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Array<Int>):
+// CHECK: br [[LOOP_DEST:bb[0-9]+]]
+//
+// CHECK: [[LOOP_DEST]]:
+// CHECK: switch_enum [[OPT_VAL:%.*]] : $Optional<Int>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+// CHECK: [[NONE_BB]]:
+// CHECK: br [[CONT_BB:bb[0-9]+]]
+//
+// CHECK: [[SOME_BB]]([[VAL:%.*]] : @trivial $Int):
+// CHECK: [[LOOP_END_FUNC:%.*]] = function_ref @loopBodyEnd : $@convention(thin) () -> ()
+// CHECK: apply [[LOOP_END_FUNC]]
+func unusedArgPattern(_ xx: [Int]) {
+ for _ in xx {
+ loopBodyEnd()
+ }
+}
diff --git a/test/SILGen/plus_zero_foreign_errors.swift b/test/SILGen/plus_zero_foreign_errors.swift
new file mode 100644
index 0000000..d004d8f
--- /dev/null
+++ b/test/SILGen/plus_zero_foreign_errors.swift
@@ -0,0 +1,311 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %build-clang-importer-objc-overlays
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -emit-silgen -parse-as-library %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+import errors
+
+// CHECK-LABEL: sil hidden @$S14foreign_errors5test0yyKF : $@convention(thin) () -> @error Error
+func test0() throws {
+ // Create a strong temporary holding nil before we perform any further parts of function emission.
+ // CHECK: [[ERR_TEMP0:%.*]] = alloc_stack $Optional<NSError>
+ // CHECK: inject_enum_addr [[ERR_TEMP0]] : $*Optional<NSError>, #Optional.none!enumelt
+
+ // CHECK: [[SELF:%.*]] = metatype $@objc_metatype ErrorProne.Type
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $@objc_metatype ErrorProne.Type, #ErrorProne.fail!1.foreign : (ErrorProne.Type) -> () throws -> (), $@convention(objc_method) (Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, @objc_metatype ErrorProne.Type) -> ObjCBool
+
+ // Create an unmanaged temporary, copy into it, and make a AutoreleasingUnsafeMutablePointer.
+ // CHECK: [[ERR_TEMP1:%.*]] = alloc_stack $@sil_unmanaged Optional<NSError>
+ // CHECK: [[T0:%.*]] = load_borrow [[ERR_TEMP0]]
+ // CHECK: [[T1:%.*]] = ref_to_unmanaged [[T0]]
+ // CHECK: store [[T1]] to [trivial] [[ERR_TEMP1]]
+ // CHECK: address_to_pointer [[ERR_TEMP1]]
+
+ // Call the method.
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]({{.*}}, [[SELF]])
+
+ // Writeback to the first temporary.
+ // CHECK: [[T0:%.*]] = load [trivial] [[ERR_TEMP1]]
+ // CHECK: [[T1:%.*]] = unmanaged_to_ref [[T0]]
+ // CHECK: [[T1_COPY:%.*]] = copy_value [[T1]]
+ // CHECK: assign [[T1_COPY]] to [[ERR_TEMP0]]
+
+ // Pull out the boolean value and compare it to zero.
+ // CHECK: [[BOOL_OR_INT:%.*]] = struct_extract [[RESULT]]
+ // CHECK: [[RAW_VALUE:%.*]] = struct_extract [[BOOL_OR_INT]]
+ // On some platforms RAW_VALUE will be compared against 0; on others it's
+ // already an i1 (bool) and those instructions will be skipped. Just do a
+ // looser check.
+ // CHECK: cond_br {{%.+}}, [[NORMAL_BB:bb[0-9]+]], [[ERROR_BB:bb[0-9]+]]
+ try ErrorProne.fail()
+
+ // Normal path: fall out and return.
+ // CHECK: [[NORMAL_BB]]:
+ // CHECK: return
+
+ // Error path: fall out and rethrow.
+ // CHECK: [[ERROR_BB]]:
+ // CHECK: [[T0:%.*]] = load [take] [[ERR_TEMP0]]
+ // CHECK: [[T1:%.*]] = function_ref @$S10Foundation22_convertNSErrorToErrorys0E0_pSo0C0CSgF : $@convention(thin) (@guaranteed Optional<NSError>) -> @owned Error
+ // CHECK: [[T2:%.*]] = apply [[T1]]([[T0]])
+ // CHECK: throw [[T2]] : $Error
+}
+
+extension NSObject {
+ @objc func abort() throws {
+ throw NSError(domain: "", code: 1, userInfo: [:])
+ }
+// CHECK-LABEL: sil hidden [thunk] @$SSo8NSObjectC14foreign_errorsE5abortyyKFTo : $@convention(objc_method) (Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, NSObject) -> ObjCBool
+// CHECK: [[T0:%.*]] = function_ref @$SSo8NSObjectC14foreign_errorsE5abortyyKF : $@convention(method) (@guaranteed NSObject) -> @error Error
+// CHECK: try_apply [[T0]](
+// CHECK: bb1(
+// CHECK: [[BITS:%.*]] = integer_literal $Builtin.Int{{[18]}}, {{1|-1}}
+// CHECK: [[VALUE:%.*]] = struct ${{Bool|UInt8}} ([[BITS]] : $Builtin.Int{{[18]}})
+// CHECK: [[BOOL:%.*]] = struct $ObjCBool ([[VALUE]] : ${{Bool|UInt8}})
+// CHECK: br bb6([[BOOL]] : $ObjCBool)
+// CHECK: bb2([[ERR:%.*]] : $Error):
+// CHECK: switch_enum %0 : $Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, case #Optional.some!enumelt.1: bb3, case #Optional.none!enumelt: bb4
+// CHECK: bb3([[UNWRAPPED_OUT:%.+]] : $AutoreleasingUnsafeMutablePointer<Optional<NSError>>):
+// CHECK: [[T0:%.*]] = function_ref @$S10Foundation22_convertErrorToNSErrorySo0E0Cs0C0_pF : $@convention(thin) (@guaranteed Error) -> @owned NSError
+// CHECK: [[T1:%.*]] = apply [[T0]]([[ERR]])
+// CHECK: [[OBJCERR:%.*]] = enum $Optional<NSError>, #Optional.some!enumelt.1, [[T1]] : $NSError
+// CHECK: [[TEMP:%.*]] = alloc_stack $Optional<NSError>
+// CHECK: store [[OBJCERR]] to [init] [[TEMP]]
+// CHECK: [[SETTER:%.*]] = function_ref @$Ss33AutoreleasingUnsafeMutablePointerV7pointeexvs :
+// CHECK: apply [[SETTER]]<Optional<NSError>>([[TEMP]], [[UNWRAPPED_OUT]])
+// CHECK: dealloc_stack [[TEMP]]
+// CHECK: br bb5
+// CHECK: bb4:
+// CHECK: destroy_value [[ERR]] : $Error
+// CHECK: br bb5
+// CHECK: bb5:
+// CHECK: [[BITS:%.*]] = integer_literal $Builtin.Int{{[18]}}, 0
+// CHECK: [[VALUE:%.*]] = struct ${{Bool|UInt8}} ([[BITS]] : $Builtin.Int{{[18]}})
+// CHECK: [[BOOL:%.*]] = struct $ObjCBool ([[VALUE]] : ${{Bool|UInt8}})
+// CHECK: br bb6([[BOOL]] : $ObjCBool)
+// CHECK: bb6([[BOOL:%.*]] : $ObjCBool):
+// CHECK: return [[BOOL]] : $ObjCBool
+
+ @objc func badDescription() throws -> String {
+ throw NSError(domain: "", code: 1, userInfo: [:])
+ }
+// CHECK-LABEL: sil hidden [thunk] @$SSo8NSObjectC14foreign_errorsE14badDescriptionSSyKFTo : $@convention(objc_method) (Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, NSObject) -> @autoreleased Optional<NSString> {
+// CHECK: bb0([[UNOWNED_ARG0:%.*]] : $Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, [[UNOWNED_ARG1:%.*]] : $NSObject):
+// CHECK: [[ARG1:%.*]] = copy_value [[UNOWNED_ARG1]]
+// CHECK: [[BORROWED_ARG1:%.*]] = begin_borrow [[ARG1]]
+// CHECK: [[T0:%.*]] = function_ref @$SSo8NSObjectC14foreign_errorsE14badDescriptionSSyKF : $@convention(method) (@guaranteed NSObject) -> (@owned String, @error Error)
+// CHECK: try_apply [[T0]]([[BORROWED_ARG1]]) : $@convention(method) (@guaranteed NSObject) -> (@owned String, @error Error), normal [[NORMAL_BB:bb[0-9][0-9]*]], error [[ERROR_BB:bb[0-9][0-9]*]]
+//
+// CHECK: [[NORMAL_BB]]([[RESULT:%.*]] : $String):
+// CHECK: [[T0:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF : $@convention(method) (@guaranteed String) -> @owned NSString
+// CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+// CHECK: [[T1:%.*]] = apply [[T0]]([[BORROWED_RESULT]])
+// CHECK: [[T2:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[T1]] : $NSString
+// CHECK: end_borrow [[BORROWED_RESULT]] from [[RESULT]]
+// CHECK: destroy_value [[RESULT]]
+// CHECK: br bb6([[T2]] : $Optional<NSString>)
+//
+// CHECK: [[ERROR_BB]]([[ERR:%.*]] : $Error):
+// CHECK: switch_enum [[UNOWNED_ARG0]] : $Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9][0-9]*]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9][0-9]*]]
+//
+// CHECK: [[SOME_BB]]([[UNWRAPPED_OUT:%.+]] : $AutoreleasingUnsafeMutablePointer<Optional<NSError>>):
+// CHECK: [[T0:%.*]] = function_ref @$S10Foundation22_convertErrorToNSErrorySo0E0Cs0C0_pF : $@convention(thin) (@guaranteed Error) -> @owned NSError
+// CHECK: [[T1:%.*]] = apply [[T0]]([[ERR]])
+// CHECK: [[OBJCERR:%.*]] = enum $Optional<NSError>, #Optional.some!enumelt.1, [[T1]] : $NSError
+// CHECK: [[TEMP:%.*]] = alloc_stack $Optional<NSError>
+// CHECK: store [[OBJCERR]] to [init] [[TEMP]]
+// CHECK: [[SETTER:%.*]] = function_ref @$Ss33AutoreleasingUnsafeMutablePointerV7pointeexvs :
+// CHECK: apply [[SETTER]]<Optional<NSError>>([[TEMP]], [[UNWRAPPED_OUT]])
+// CHECK: dealloc_stack [[TEMP]]
+// CHECK: br bb5
+//
+// CHECK: [[NONE_BB]]:
+// CHECK: destroy_value [[ERR]] : $Error
+// CHECK: br bb5
+//
+// CHECK: bb5:
+// CHECK: [[T0:%.*]] = enum $Optional<NSString>, #Optional.none!enumelt
+// CHECK: br bb6([[T0]] : $Optional<NSString>)
+//
+// CHECK: bb6([[T0:%.*]] : $Optional<NSString>):
+// CHECK: end_borrow [[BORROWED_ARG1]] from [[ARG1]]
+// CHECK: destroy_value [[ARG1]]
+// CHECK: return [[T0]] : $Optional<NSString>
+
+// CHECK-LABEL: sil hidden [thunk] @$SSo8NSObjectC14foreign_errorsE7takeIntyySiKFTo : $@convention(objc_method) (Int, Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, NSObject) -> ObjCBool
+// CHECK: bb0([[I:%[0-9]+]] : $Int, [[ERROR:%[0-9]+]] : $Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, [[SELF:%[0-9]+]] : $NSObject)
+ @objc func takeInt(_ i: Int) throws { }
+
+// CHECK-LABEL: sil hidden [thunk] @$SSo8NSObjectC14foreign_errorsE10takeDouble_3int7closureySd_S3iXEtKFTo : $@convention(objc_method) (Double, Int, Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, @convention(block) @noescape (Int) -> Int, NSObject) -> ObjCBool
+// CHECK: bb0([[D:%[0-9]+]] : $Double, [[INT:%[0-9]+]] : $Int, [[ERROR:%[0-9]+]] : $Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, [[CLOSURE:%[0-9]+]] : $@convention(block) @noescape (Int) -> Int, [[SELF:%[0-9]+]] : $NSObject):
+ @objc func takeDouble(_ d: Double, int: Int, closure: (Int) -> Int) throws {
+ throw NSError(domain: "", code: 1, userInfo: [:])
+ }
+}
+
+let fn = ErrorProne.fail
+// CHECK-LABEL: sil shared [serializable] [thunk] @$SSo10ErrorProneC4failyyKFZTcTO : $@convention(thin) (@thick ErrorProne.Type) -> @owned @callee_guaranteed () -> @error Error
+// CHECK: [[T0:%.*]] = function_ref @$SSo10ErrorProneC4failyyKFZTO : $@convention(method) (@thick ErrorProne.Type) -> @error Error
+// CHECK-NEXT: [[T1:%.*]] = partial_apply [callee_guaranteed] [[T0]](%0)
+// CHECK-NEXT: return [[T1]]
+
+// CHECK-LABEL: sil shared [serializable] [thunk] @$SSo10ErrorProneC4failyyKFZTO : $@convention(method) (@thick ErrorProne.Type) -> @error Error {
+// CHECK: [[SELF:%.*]] = thick_to_objc_metatype %0 : $@thick ErrorProne.Type to $@objc_metatype ErrorProne.Type
+// CHECK: [[METHOD:%.*]] = objc_method [[T0]] : $@objc_metatype ErrorProne.Type, #ErrorProne.fail!1.foreign : (ErrorProne.Type) -> () throws -> (), $@convention(objc_method) (Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, @objc_metatype ErrorProne.Type) -> ObjCBool
+// CHECK: [[TEMP:%.*]] = alloc_stack $Optional<NSError>
+// CHECK: [[RESULT:%.*]] = apply [[METHOD]]({{%.*}}, [[SELF]])
+// CHECK: cond_br
+// CHECK: return
+// CHECK: [[T0:%.*]] = load [take] [[TEMP]]
+// CHECK: [[T1:%.*]] = apply {{%.*}}([[T0]])
+// CHECK: throw [[T1]]
+
+func testArgs() throws {
+ try ErrorProne.consume(nil)
+}
+// CHECK-LABEL: sil hidden @$S14foreign_errors8testArgsyyKF : $@convention(thin) () -> @error Error
+// CHECK: debug_value undef : $Error, var, name "$error", argno 1
+// CHECK: objc_method {{.*}} : $@objc_metatype ErrorProne.Type, #ErrorProne.consume!1.foreign : (ErrorProne.Type) -> (Any?) throws -> (), $@convention(objc_method) (Optional<AnyObject>, Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, @objc_metatype ErrorProne.Type) -> ObjCBool
+
+func testBridgedResult() throws {
+ let array = try ErrorProne.collection(withCount: 0)
+}
+// CHECK-LABEL: sil hidden @$S14foreign_errors17testBridgedResultyyKF : $@convention(thin) () -> @error Error {
+// CHECK: debug_value undef : $Error, var, name "$error", argno 1
+// CHECK: objc_method {{.*}} : $@objc_metatype ErrorProne.Type, #ErrorProne.collection!1.foreign : (ErrorProne.Type) -> (Int) throws -> [Any], $@convention(objc_method) (Int, Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, @objc_metatype ErrorProne.Type) -> @autoreleased Optional<NSArray>
+
+// rdar://20861374
+// Clear out the self box before delegating.
+class VeryErrorProne : ErrorProne {
+ init(withTwo two: AnyObject?) throws {
+ try super.init(one: two)
+ }
+}
+
+// SEMANTIC SIL TODO: _TFC14foreign_errors14VeryErrorPronec has a lot more going
+// on than is being tested here, we should consider adding FileCheck tests for
+// it.
+
+// CHECK-LABEL: sil hidden @$S14foreign_errors14VeryErrorProneC7withTwoACyXlSg_tKcfc
+// CHECK: bb0([[ARG1:%.*]] : $Optional<AnyObject>, [[ARG2:%.*]] : $VeryErrorProne):
+// CHECK: [[BOX:%.*]] = alloc_box ${ var VeryErrorProne }
+// CHECK: [[MARKED_BOX:%.*]] = mark_uninitialized [derivedself] [[BOX]]
+// CHECK: [[PB:%.*]] = project_box [[MARKED_BOX]]
+// CHECK: store [[ARG2]] to [init] [[PB]]
+// CHECK: [[T0:%.*]] = load [take] [[PB]]
+// CHECK-NEXT: [[T1:%.*]] = upcast [[T0]] : $VeryErrorProne to $ErrorProne
+// CHECK: [[BORROWED_ARG1:%.*]] = begin_borrow [[ARG1]]
+// CHECK: [[ARG1_COPY:%.*]] = copy_value [[BORROWED_ARG1]]
+// CHECK-NOT: [[BOX]]{{^[0-9]}}
+// CHECK-NOT: [[PB]]{{^[0-9]}}
+// CHECK: [[BORROWED_T1:%.*]] = begin_borrow [[T1]]
+// CHECK-NEXT: [[DOWNCAST_BORROWED_T1:%.*]] = unchecked_ref_cast [[BORROWED_T1]] : $ErrorProne to $VeryErrorProne
+// CHECK-NEXT: [[T2:%.*]] = objc_super_method [[DOWNCAST_BORROWED_T1]] : $VeryErrorProne, #ErrorProne.init!initializer.1.foreign : (ErrorProne.Type) -> (Any?) throws -> ErrorProne, $@convention(objc_method) (Optional<AnyObject>, Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, @owned ErrorProne) -> @owned Optional<ErrorProne>
+// CHECK: end_borrow [[BORROWED_T1]] from [[T1]]
+// CHECK: apply [[T2]]([[ARG1_COPY]], {{%.*}}, [[T1]])
+
+// rdar://21051021
+// CHECK: sil hidden @$S14foreign_errors12testProtocolyySo010ErrorProneD0_pKF : $@convention(thin) (@guaranteed ErrorProneProtocol) -> @error Error
+// CHECK: bb0([[ARG0:%.*]] : $ErrorProneProtocol):
+func testProtocol(_ p: ErrorProneProtocol) throws {
+ // CHECK: [[T0:%.*]] = open_existential_ref [[ARG0]] : $ErrorProneProtocol to $[[OPENED:@opened(.*) ErrorProneProtocol]]
+ // CHECK: [[T1:%.*]] = objc_method [[T0]] : $[[OPENED]], #ErrorProneProtocol.obliterate!1.foreign : {{.*}}
+ // CHECK: apply [[T1]]<[[OPENED]]>({{%.*}}, [[T0]]) : $@convention(objc_method) <τ_0_0 where τ_0_0 : ErrorProneProtocol> (Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, τ_0_0) -> ObjCBool
+ try p.obliterate()
+
+ // CHECK: [[T0:%.*]] = open_existential_ref [[ARG0]] : $ErrorProneProtocol to $[[OPENED:@opened(.*) ErrorProneProtocol]]
+ // CHECK: [[T1:%.*]] = objc_method [[T0]] : $[[OPENED]], #ErrorProneProtocol.invigorate!1.foreign : {{.*}}
+ // CHECK: apply [[T1]]<[[OPENED]]>({{%.*}}, {{%.*}}, [[T0]]) : $@convention(objc_method) <τ_0_0 where τ_0_0 : ErrorProneProtocol> (Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, Optional<@convention(block) () -> ()>, τ_0_0) -> ObjCBool
+ try p.invigorate(callback: {})
+}
+
+// rdar://21144509 - Ensure that overrides of replace-with-() imports are possible.
+class ExtremelyErrorProne : ErrorProne {
+ override func conflict3(_ obj: Any, error: ()) throws {}
+}
+// CHECK-LABEL: sil hidden @$S14foreign_errors19ExtremelyErrorProneC9conflict3_5erroryyp_yttKF
+// CHECK-LABEL: sil hidden [thunk] @$S14foreign_errors19ExtremelyErrorProneC9conflict3_5erroryyp_yttKFTo : $@convention(objc_method) (AnyObject, Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, ExtremelyErrorProne) -> ObjCBool
+
+// These conventions are usable because of swift_error. rdar://21715350
+func testNonNilError() throws -> Float {
+ return try ErrorProne.bounce()
+}
+// CHECK-LABEL: sil hidden @$S14foreign_errors15testNonNilErrorSfyKF :
+// CHECK: [[OPTERR:%.*]] = alloc_stack $Optional<NSError>
+// CHECK: [[T0:%.*]] = metatype $@objc_metatype ErrorProne.Type
+// CHECK: [[T1:%.*]] = objc_method [[T0]] : $@objc_metatype ErrorProne.Type, #ErrorProne.bounce!1.foreign : (ErrorProne.Type) -> () throws -> Float, $@convention(objc_method) (Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, @objc_metatype ErrorProne.Type) -> Float
+// CHECK: [[RESULT:%.*]] = apply [[T1]](
+// CHECK: assign {{%.*}} to [[OPTERR]]
+// CHECK: [[T0:%.*]] = load [take] [[OPTERR]]
+// CHECK: switch_enum [[T0]] : $Optional<NSError>, case #Optional.some!enumelt.1: [[ERROR_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NORMAL_BB:bb[0-9]+]]
+// CHECK: [[NORMAL_BB]]:
+// CHECK-NOT: destroy_value
+// CHECK: return [[RESULT]]
+// CHECK: [[ERROR_BB]]
+
+func testPreservedResult() throws -> CInt {
+ return try ErrorProne.ounce()
+}
+// CHECK-LABEL: sil hidden @$S14foreign_errors19testPreservedResults5Int32VyKF
+// CHECK: [[OPTERR:%.*]] = alloc_stack $Optional<NSError>
+// CHECK: [[T0:%.*]] = metatype $@objc_metatype ErrorProne.Type
+// CHECK: [[T1:%.*]] = objc_method [[T0]] : $@objc_metatype ErrorProne.Type, #ErrorProne.ounce!1.foreign : (ErrorProne.Type) -> () throws -> Int32, $@convention(objc_method) (Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, @objc_metatype ErrorProne.Type) -> Int32
+// CHECK: [[RESULT:%.*]] = apply [[T1]](
+// CHECK: [[T0:%.*]] = struct_extract [[RESULT]]
+// CHECK: [[T1:%.*]] = integer_literal $[[PRIM:Builtin.Int[0-9]+]], 0
+// CHECK: [[T2:%.*]] = builtin "cmp_ne_Int32"([[T0]] : $[[PRIM]], [[T1]] : $[[PRIM]])
+// CHECK: cond_br [[T2]], [[NORMAL_BB:bb[0-9]+]], [[ERROR_BB:bb[0-9]+]]
+// CHECK: [[NORMAL_BB]]:
+// CHECK-NOT: destroy_value
+// CHECK: return [[RESULT]]
+// CHECK: [[ERROR_BB]]
+
+func testPreservedResultBridged() throws -> Int {
+ return try ErrorProne.ounceWord()
+}
+
+// CHECK-LABEL: sil hidden @$S14foreign_errors26testPreservedResultBridgedSiyKF
+// CHECK: [[OPTERR:%.*]] = alloc_stack $Optional<NSError>
+// CHECK: [[T0:%.*]] = metatype $@objc_metatype ErrorProne.Type
+// CHECK: [[T1:%.*]] = objc_method [[T0]] : $@objc_metatype ErrorProne.Type, #ErrorProne.ounceWord!1.foreign : (ErrorProne.Type) -> () throws -> Int, $@convention(objc_method) (Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, @objc_metatype ErrorProne.Type) -> Int
+// CHECK: [[RESULT:%.*]] = apply [[T1]](
+// CHECK: [[T0:%.*]] = struct_extract [[RESULT]]
+// CHECK: [[T1:%.*]] = integer_literal $[[PRIM:Builtin.Int[0-9]+]], 0
+// CHECK: [[T2:%.*]] = builtin "cmp_ne_Int{{.*}}"([[T0]] : $[[PRIM]], [[T1]] : $[[PRIM]])
+// CHECK: cond_br [[T2]], [[NORMAL_BB:bb[0-9]+]], [[ERROR_BB:bb[0-9]+]]
+// CHECK: [[NORMAL_BB]]:
+// CHECK-NOT: destroy_value
+// CHECK: return [[RESULT]]
+// CHECK: [[ERROR_BB]]
+
+func testPreservedResultInverted() throws {
+ try ErrorProne.once()
+}
+
+// CHECK-LABEL: sil hidden @$S14foreign_errors27testPreservedResultInvertedyyKF
+// CHECK: [[OPTERR:%.*]] = alloc_stack $Optional<NSError>
+// CHECK: [[T0:%.*]] = metatype $@objc_metatype ErrorProne.Type
+// CHECK: [[T1:%.*]] = objc_method [[T0]] : $@objc_metatype ErrorProne.Type, #ErrorProne.once!1.foreign : (ErrorProne.Type) -> () throws -> (), $@convention(objc_method) (Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, @objc_metatype ErrorProne.Type) -> Int32
+// CHECK: [[RESULT:%.*]] = apply [[T1]](
+// CHECK: [[T0:%.*]] = struct_extract [[RESULT]]
+// CHECK: [[T1:%.*]] = integer_literal $[[PRIM:Builtin.Int[0-9]+]], 0
+// CHECK: [[T2:%.*]] = builtin "cmp_ne_Int32"([[T0]] : $[[PRIM]], [[T1]] : $[[PRIM]])
+// CHECK: cond_br [[T2]], [[ERROR_BB:bb[0-9]+]], [[NORMAL_BB:bb[0-9]+]]
+// CHECK: [[NORMAL_BB]]:
+// CHECK-NOT: destroy_value
+// CHECK: return {{%.+}} : $()
+// CHECK: [[ERROR_BB]]
+
+// Make sure that we do not crash when emitting the error value here.
+//
+// TODO: Add some additional filecheck tests.
+extension NSURL {
+ func resourceValue<T>(forKey key: String) -> T? {
+ var prop: AnyObject? = nil
+ _ = try? self.getResourceValue(&prop, forKey: key)
+ return prop as? T
+ }
+}
diff --git a/test/SILGen/plus_zero_function_conversion.swift b/test/SILGen/plus_zero_function_conversion.swift
new file mode 100644
index 0000000..a3dc163
--- /dev/null
+++ b/test/SILGen/plus_zero_function_conversion.swift
@@ -0,0 +1,643 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -primary-file %s | %FileCheck %s
+// RUN: %target-swift-frontend -emit-ir -enable-sil-ownership -primary-file %s
+
+// Check SILGen against various FunctionConversionExprs emitted by Sema.
+
+// ==== Representation conversions
+
+// CHECK-LABEL: sil hidden @$S19function_conversion7cToFuncyS2icS2iXCF : $@convention(thin) (@convention(c) (Int) -> Int) -> @owned @callee_guaranteed (Int) -> Int
+// CHECK: [[THUNK:%.*]] = function_ref @$SS2iIetCyd_S2iIegyd_TR
+// CHECK: [[FUNC:%.*]] = partial_apply [callee_guaranteed] [[THUNK]](%0)
+// CHECK: return [[FUNC]]
+func cToFunc(_ arg: @escaping @convention(c) (Int) -> Int) -> (Int) -> Int {
+ return arg
+}
+
+// CHECK-LABEL: sil hidden @$S19function_conversion8cToBlockyS2iXBS2iXCF : $@convention(thin) (@convention(c) (Int) -> Int) -> @owned @convention(block) (Int) -> Int
+// CHECK: [[BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage
+// CHECK: [[BLOCK:%.*]] = init_block_storage_header [[BLOCK_STORAGE]]
+// CHECK: [[COPY:%.*]] = copy_block [[BLOCK]] : $@convention(block) (Int) -> Int
+// CHECK: return [[COPY]]
+func cToBlock(_ arg: @escaping @convention(c) (Int) -> Int) -> @convention(block) (Int) -> Int {
+ return arg
+}
+
+// ==== Throws variance
+
+// CHECK-LABEL: sil hidden @$S19function_conversion12funcToThrowsyyyKcyycF : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> @owned @callee_guaranteed () -> @error Error
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $@callee_guaranteed () -> ()):
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: [[FUNC:%.*]] = convert_function [[ARG_COPY]] : $@callee_guaranteed () -> () to $@callee_guaranteed () -> @error Error
+// CHECK: return [[FUNC]]
+// CHECK: } // end sil function '$S19function_conversion12funcToThrowsyyyKcyycF'
+func funcToThrows(_ x: @escaping () -> ()) -> () throws -> () {
+ return x
+}
+
+// CHECK-LABEL: sil hidden @$S19function_conversion12thinToThrowsyyyKXfyyXfF : $@convention(thin) (@convention(thin) () -> ()) -> @convention(thin) () -> @error Error
+// CHECK: [[FUNC:%.*]] = convert_function %0 : $@convention(thin) () -> () to $@convention(thin) () -> @error Error
+// CHECK: return [[FUNC]] : $@convention(thin) () -> @error Error
+func thinToThrows(_ x: @escaping @convention(thin) () -> ()) -> @convention(thin) () throws -> () {
+ return x
+}
+
+// FIXME: triggers an assert because we always do a thin to thick conversion on DeclRefExprs
+/*
+func thinFunc() {}
+
+func thinToThrows() {
+ let _: @convention(thin) () -> () = thinFunc
+}
+*/
+
+// ==== Class downcasts and upcasts
+
+class Feral {}
+class Domesticated : Feral {}
+
+// CHECK-LABEL: sil hidden @$S19function_conversion12funcToUpcastyAA5FeralCycAA12DomesticatedCycF : $@convention(thin) (@guaranteed @callee_guaranteed () -> @owned Domesticated) -> @owned @callee_guaranteed () -> @owned Feral {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $@callee_guaranteed () -> @owned Domesticated):
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: [[FUNC:%.*]] = convert_function [[ARG_COPY]] : $@callee_guaranteed () -> @owned Domesticated to $@callee_guaranteed () -> @owned Feral
+// CHECK: return [[FUNC]]
+// CHECK: } // end sil function '$S19function_conversion12funcToUpcastyAA5FeralCycAA12DomesticatedCycF'
+func funcToUpcast(_ x: @escaping () -> Domesticated) -> () -> Feral {
+ return x
+}
+
+// CHECK-LABEL: sil hidden @$S19function_conversion12funcToUpcastyyAA12DomesticatedCcyAA5FeralCcF : $@convention(thin) (@guaranteed @callee_guaranteed (@guaranteed Feral) -> ()) -> @owned @callee_guaranteed (@guaranteed Domesticated) -> ()
+// CHECK: bb0([[ARG:%.*]] :
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: [[FUNC:%.*]] = convert_function [[ARG_COPY]] : $@callee_guaranteed (@guaranteed Feral) -> () to $@callee_guaranteed (@guaranteed Domesticated) -> (){{.*}}
+// CHECK: return [[FUNC]]
+func funcToUpcast(_ x: @escaping (Feral) -> ()) -> (Domesticated) -> () {
+ return x
+}
+
+// ==== Optionals
+
+struct Trivial {
+ let n: Int8
+}
+
+class C {
+ let n: Int8
+
+ init(n: Int8) {
+ self.n = n
+ }
+}
+
+struct Loadable {
+ let c: C
+
+ var n: Int8 {
+ return c.n
+ }
+
+ init(n: Int8) {
+ c = C(n: n)
+ }
+}
+
+struct AddrOnly {
+ let a: Any
+
+ var n: Int8 {
+ return a as! Int8
+ }
+
+ init(n: Int8) {
+ a = n
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S19function_conversion19convOptionalTrivialyyAA0E0VADSgcF
+func convOptionalTrivial(_ t1: @escaping (Trivial?) -> Trivial) {
+// CHECK: function_ref @$S19function_conversion7TrivialVSgACIegyd_AcDIegyd_TR
+// CHECK: partial_apply
+ let _: (Trivial) -> Trivial? = t1
+
+// CHECK: function_ref @$S19function_conversion7TrivialVSgACIegyd_A2DIegyd_TR
+// CHECK: partial_apply
+ let _: (Trivial?) -> Trivial? = t1
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion7TrivialVSgACIegyd_AcDIegyd_TR : $@convention(thin) (Trivial, @guaranteed @callee_guaranteed (Optional<Trivial>) -> Trivial) -> Optional<Trivial>
+// CHECK: [[ENUM:%.*]] = enum $Optional<Trivial>
+// CHECK-NEXT: apply %1([[ENUM]])
+// CHECK-NEXT: enum $Optional<Trivial>
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion7TrivialVSgACIegyd_A2DIegyd_TR : $@convention(thin) (Optional<Trivial>, @guaranteed @callee_guaranteed (Optional<Trivial>) -> Trivial) -> Optional<Trivial>
+// CHECK: apply %1(%0)
+// CHECK-NEXT: enum $Optional<Trivial>
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil hidden @$S19function_conversion20convOptionalLoadableyyAA0E0VADSgcF
+func convOptionalLoadable(_ l1: @escaping (Loadable?) -> Loadable) {
+// CHECK: function_ref @$S19function_conversion8LoadableVSgACIeggo_AcDIeggo_TR
+// CHECK: partial_apply
+ let _: (Loadable) -> Loadable? = l1
+
+// CHECK: function_ref @$S19function_conversion8LoadableVSgACIeggo_A2DIeggo_TR
+// CHECK: partial_apply
+ let _: (Loadable?) -> Loadable? = l1
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion8LoadableVSgACIeggo_A2DIeggo_TR : $@convention(thin) (@guaranteed Optional<Loadable>, @guaranteed @callee_guaranteed (@guaranteed Optional<Loadable>) -> @owned Loadable) -> @owned Optional<Loadable>
+// CHECK: apply %1(%0)
+// CHECK-NEXT: enum $Optional<Loadable>
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil hidden @$S19function_conversion20convOptionalAddrOnlyyyAA0eF0VADSgcF
+func convOptionalAddrOnly(_ a1: @escaping (AddrOnly?) -> AddrOnly) {
+// CHECK: function_ref @$S19function_conversion8AddrOnlyVSgACIegnr_A2DIegnr_TR
+// CHECK: partial_apply
+ let _: (AddrOnly?) -> AddrOnly? = a1
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion8AddrOnlyVSgACIegnr_A2DIegnr_TR : $@convention(thin) (@in_guaranteed Optional<AddrOnly>, @guaranteed @callee_guaranteed (@in_guaranteed Optional<AddrOnly>) -> @out AddrOnly) -> @out Optional<AddrOnly>
+// CHECK: [[TEMP:%.*]] = alloc_stack $AddrOnly
+// CHECK-NEXT: apply %2([[TEMP]], %1)
+// CHECK-NEXT: init_enum_data_addr %0 : $*Optional<AddrOnly>
+// CHECK-NEXT: copy_addr [take] {{.*}} to [initialization] {{.*}} : $*AddrOnly
+// CHECK-NEXT: inject_enum_addr %0 : $*Optional<AddrOnly>
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: dealloc_stack {{.*}} : $*AddrOnly
+// CHECK-NEXT: return
+
+// ==== Existentials
+
+protocol Q {
+ var n: Int8 { get }
+}
+
+protocol P : Q {}
+
+extension Trivial : P {}
+extension Loadable : P {}
+extension AddrOnly : P {}
+
+// CHECK-LABEL: sil hidden @$S19function_conversion22convExistentialTrivial_2t3yAA0E0VAA1Q_pc_AeaF_pSgctF
+func convExistentialTrivial(_ t2: @escaping (Q) -> Trivial, t3: @escaping (Q?) -> Trivial) {
+// CHECK: function_ref @$S19function_conversion1Q_pAA7TrivialVIegnd_AdA1P_pIegyr_TR
+// CHECK: partial_apply
+ let _: (Trivial) -> P = t2
+
+// CHECK: function_ref @$S19function_conversion1Q_pSgAA7TrivialVIegnd_AESgAA1P_pIegyr_TR
+// CHECK: partial_apply
+ let _: (Trivial?) -> P = t3
+
+// CHECK: function_ref @$S19function_conversion1Q_pAA7TrivialVIegnd_AA1P_pAaE_pIegnr_TR
+// CHECK: partial_apply
+ let _: (P) -> P = t2
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion1Q_pAA7TrivialVIegnd_AdA1P_pIegyr_TR : $@convention(thin) (Trivial, @guaranteed @callee_guaranteed (@in_guaranteed Q) -> Trivial) -> @out P
+// CHECK: alloc_stack $Q
+// CHECK-NEXT: init_existential_addr
+// CHECK-NEXT: store
+// CHECK-NEXT: apply
+// CHECK-NEXT: init_existential_addr
+// CHECK-NEXT: store
+// CHECK: return
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion1Q_pSgAA7TrivialVIegnd_AESgAA1P_pIegyr_TR
+// CHECK: switch_enum
+// CHECK: bb1([[TRIVIAL:%.*]] : @trivial $Trivial):
+// CHECK: init_existential_addr
+// CHECK: init_enum_data_addr
+// CHECK: copy_addr
+// CHECK: inject_enum_addr
+// CHECK: bb2:
+// CHECK: inject_enum_addr
+// CHECK: bb3:
+// CHECK: apply
+// CHECK: init_existential_addr
+// CHECK: store
+// CHECK: return
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion1Q_pAA7TrivialVIegnd_AA1P_pAaE_pIegnr_TR : $@convention(thin) (@in_guaranteed P, @guaranteed @callee_guaranteed (@in_guaranteed Q) -> Trivial) -> @out P
+// CHECK: [[TMP:%.*]] = alloc_stack $Q
+// CHECK-NEXT: open_existential_addr immutable_access %1 : $*P
+// CHECK-NEXT: init_existential_addr [[TMP]] : $*Q
+// CHECK-NEXT: copy_addr {{.*}} to [initialization] {{.*}}
+// CHECK-NEXT: apply
+// CHECK-NEXT: init_existential_addr
+// CHECK-NEXT: store
+// CHECK: destroy_addr
+// CHECK: return
+
+// ==== Existential metatypes
+
+// CHECK-LABEL: sil hidden @$S19function_conversion23convExistentialMetatypeyyAA7TrivialVmAA1Q_pXpSgcF
+func convExistentialMetatype(_ em: @escaping (Q.Type?) -> Trivial.Type) {
+// CHECK: function_ref @$S19function_conversion1Q_pXmTSgAA7TrivialVXMtIegyd_AEXMtAA1P_pXmTIegyd_TR
+// CHECK: partial_apply
+ let _: (Trivial.Type) -> P.Type = em
+
+// CHECK: function_ref @$S19function_conversion1Q_pXmTSgAA7TrivialVXMtIegyd_AEXMtSgAA1P_pXmTIegyd_TR
+// CHECK: partial_apply
+ let _: (Trivial.Type?) -> P.Type = em
+
+// CHECK: function_ref @$S19function_conversion1Q_pXmTSgAA7TrivialVXMtIegyd_AA1P_pXmTAaF_pXmTIegyd_TR
+// CHECK: partial_apply
+ let _: (P.Type) -> P.Type = em
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion1Q_pXmTSgAA7TrivialVXMtIegyd_AEXMtAA1P_pXmTIegyd_TR : $@convention(thin) (@thin Trivial.Type, @guaranteed @callee_guaranteed (Optional<@thick Q.Type>) -> @thin Trivial.Type) -> @thick P.Type
+// CHECK: [[META:%.*]] = metatype $@thick Trivial.Type
+// CHECK-NEXT: init_existential_metatype [[META]] : $@thick Trivial.Type, $@thick Q.Type
+// CHECK-NEXT: enum $Optional<@thick Q.Type>
+// CHECK-NEXT: apply
+// CHECK-NEXT: metatype $@thick Trivial.Type
+// CHECK-NEXT: init_existential_metatype {{.*}} : $@thick Trivial.Type, $@thick P.Type
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion1Q_pXmTSgAA7TrivialVXMtIegyd_AEXMtSgAA1P_pXmTIegyd_TR : $@convention(thin) (Optional<@thin Trivial.Type>, @guaranteed @callee_guaranteed (Optional<@thick Q.Type>) -> @thin Trivial.Type) -> @thick P.Type
+// CHECK: switch_enum %0 : $Optional<@thin Trivial.Type>
+// CHECK: bb1([[META:%.*]] : @trivial $@thin Trivial.Type):
+// CHECK-NEXT: metatype $@thick Trivial.Type
+// CHECK-NEXT: init_existential_metatype {{.*}} : $@thick Trivial.Type, $@thick Q.Type
+// CHECK-NEXT: enum $Optional<@thick Q.Type>
+// CHECK: bb2:
+// CHECK-NEXT: enum $Optional<@thick Q.Type>
+// CHECK: bb3({{.*}}):
+// CHECK-NEXT: apply
+// CHECK-NEXT: metatype $@thick Trivial.Type
+// CHECK-NEXT: init_existential_metatype {{.*}} : $@thick Trivial.Type, $@thick P.Type
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion1Q_pXmTSgAA7TrivialVXMtIegyd_AA1P_pXmTAaF_pXmTIegyd_TR : $@convention(thin) (@thick P.Type, @guaranteed @callee_guaranteed (Optional<@thick Q.Type>) -> @thin Trivial.Type) -> @thick P.Type
+// CHECK: open_existential_metatype %0 : $@thick P.Type to $@thick (@opened({{.*}}) P).Type
+// CHECK-NEXT: init_existential_metatype %2 : $@thick (@opened({{.*}}) P).Type, $@thick Q.Type
+// CHECK-NEXT: enum $Optional<@thick Q.Type>
+// CHECK-NEXT: apply %1
+// CHECK-NEXT: metatype $@thick Trivial.Type
+// CHECK-NEXT: init_existential_metatype {{.*}} : $@thick Trivial.Type, $@thick P.Type
+// CHECK-NEXT: return
+
+// ==== Class metatype upcasts
+
+class Parent {}
+class Child : Parent {}
+
+// Note: we add a Trivial => Trivial? conversion here to force a thunk
+// to be generated
+
+// CHECK-LABEL: sil hidden @$S19function_conversion18convUpcastMetatype_2c5yAA5ChildCmAA6ParentCm_AA7TrivialVSgtc_AEmAGmSg_AJtctF
+func convUpcastMetatype(_ c4: @escaping (Parent.Type, Trivial?) -> Child.Type,
+ c5: @escaping (Parent.Type?, Trivial?) -> Child.Type) {
+// CHECK: function_ref @$S19function_conversion6ParentCXMTAA7TrivialVSgAA5ChildCXMTIegyyd_AHXMTAeCXMTIegyyd_TR
+// CHECK: partial_apply
+ let _: (Child.Type, Trivial) -> Parent.Type = c4
+
+// CHECK: function_ref @$S19function_conversion6ParentCXMTSgAA7TrivialVSgAA5ChildCXMTIegyyd_AIXMTAfCXMTIegyyd_TR
+// CHECK: partial_apply
+ let _: (Child.Type, Trivial) -> Parent.Type = c5
+
+// CHECK: function_ref @$S19function_conversion6ParentCXMTSgAA7TrivialVSgAA5ChildCXMTIegyyd_AIXMTSgAfDIegyyd_TR
+// CHECK: partial_apply
+ let _: (Child.Type?, Trivial) -> Parent.Type? = c5
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion6ParentCXMTAA7TrivialVSgAA5ChildCXMTIegyyd_AHXMTAeCXMTIegyyd_TR : $@convention(thin) (@thick Child.Type, Trivial, @guaranteed @callee_guaranteed (@thick Parent.Type, Optional<Trivial>) -> @thick Child.Type) -> @thick Parent.Type
+// CHECK: upcast %0 : $@thick Child.Type to $@thick Parent.Type
+// CHECK: apply
+// CHECK: upcast {{.*}} : $@thick Child.Type to $@thick Parent.Type
+// CHECK: return
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion6ParentCXMTSgAA7TrivialVSgAA5ChildCXMTIegyyd_AIXMTAfCXMTIegyyd_TR : $@convention(thin) (@thick Child.Type, Trivial, @guaranteed @callee_guaranteed (Optional<@thick Parent.Type>, Optional<Trivial>) -> @thick Child.Type) -> @thick Parent.Type
+// CHECK: upcast %0 : $@thick Child.Type to $@thick Parent.Type
+// CHECK: enum $Optional<@thick Parent.Type>
+// CHECK: apply
+// CHECK: upcast {{.*}} : $@thick Child.Type to $@thick Parent.Type
+// CHECK: return
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion6ParentCXMTSgAA7TrivialVSgAA5ChildCXMTIegyyd_AIXMTSgAfDIegyyd_TR : $@convention(thin) (Optional<@thick Child.Type>, Trivial, @guaranteed @callee_guaranteed (Optional<@thick Parent.Type>, Optional<Trivial>) -> @thick Child.Type) -> Optional<@thick Parent.Type>
+// CHECK: unchecked_trivial_bit_cast %0 : $Optional<@thick Child.Type> to $Optional<@thick Parent.Type>
+// CHECK: apply
+// CHECK: upcast {{.*}} : $@thick Child.Type to $@thick Parent.Type
+// CHECK: enum $Optional<@thick Parent.Type>
+// CHECK: return
+
+// ==== Function to existential -- make sure we maximally abstract it
+
+// CHECK-LABEL: sil hidden @$S19function_conversion19convFuncExistentialyyS2icypcF : $@convention(thin) (@guaranteed @callee_guaranteed (@in_guaranteed Any) -> @owned @callee_guaranteed (Int) -> Int) -> ()
+// CHECK: bb0([[ARG:%.*]] :
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: [[REABSTRACT_THUNK:%.*]] = function_ref @$SypS2iIegyd_Iegno_S2iIgyd_ypIegyr_TR
+// CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACT_THUNK]]([[ARG_COPY]])
+// CHECK: destroy_value [[PA]]
+// CHECK: } // end sil function '$S19function_conversion19convFuncExistentialyyS2icypcF'
+func convFuncExistential(_ f1: @escaping (Any) -> (Int) -> Int) {
+ let _: ((Int) -> Int) -> Any = f1
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SypS2iIegyd_Iegno_S2iIgyd_ypIegyr_TR : $@convention(thin) (@noescape @callee_guaranteed (Int) -> Int, @guaranteed @callee_guaranteed (@in_guaranteed Any) -> @owned @callee_guaranteed (Int) -> Int) -> @out Any
+// CHECK: alloc_stack $Any
+// CHECK: function_ref @$SS2iIgyd_S2iIegnr_TR
+// CHECK-NEXT: partial_apply
+// CHECK-NEXT: convert_escape_to_noescape
+// CHECK-NEXT: init_existential_addr %3 : $*Any, $(Int) -> Int
+// CHECK-NEXT: store
+// CHECK-NEXT: apply
+// CHECK: function_ref @$SS2iIegyd_S2iIegnr_TR
+// CHECK-NEXT: partial_apply
+// CHECK-NEXT: init_existential_addr %0 : $*Any, $(Int) -> Int
+// CHECK-NEXT: store {{.*}} to {{.*}} : $*@callee_guaranteed (@in_guaranteed Int) -> @out Int
+// CHECK: return
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SS2iIegyd_S2iIegnr_TR : $@convention(thin) (@in_guaranteed Int, @guaranteed @callee_guaranteed (Int) -> Int) -> @out Int
+// CHECK: [[LOADED:%.*]] = load [trivial] %1 : $*Int
+// CHECK-NEXT: apply %2([[LOADED]])
+// CHECK-NEXT: store {{.*}} to [trivial] %0
+// CHECK-NEXT: [[VOID:%.*]] = tuple ()
+// CHECK: return [[VOID]]
+
+// ==== Class-bound archetype upcast
+
+// CHECK-LABEL: sil hidden @$S19function_conversion29convClassBoundArchetypeUpcast{{[_0-9a-zA-Z]*}}F
+func convClassBoundArchetypeUpcast<T : Parent>(_ f1: @escaping (Parent) -> (T, Trivial)) {
+// CHECK: function_ref @$S19function_conversion6ParentCxAA7TrivialVIeggod_xAcESgIeggod_ACRbzlTR
+// CHECK: partial_apply
+ let _: (T) -> (Parent, Trivial?) = f1
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion6ParentCxAA7TrivialVIeggod_xAcESgIeggod_ACRbzlTR : $@convention(thin) <T where T : Parent> (@guaranteed T, @guaranteed @callee_guaranteed (@guaranteed Parent) -> (@owned T, Trivial)) -> (@owned Parent, Optional<Trivial>)
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $T, [[CLOSURE:%.*]] : @guaranteed $@callee_guaranteed (@guaranteed Parent) -> (@owned T, Trivial)):
+// CHECK: [[CASTED_ARG:%.*]] = upcast [[ARG]] : $T to $Parent
+// CHECK: [[RESULT:%.*]] = apply %1([[CASTED_ARG]])
+// CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]] : $(T, Trivial)
+// CHECK: [[FIRST_RESULT:%.*]] = tuple_extract [[BORROWED_RESULT]] : $(T, Trivial), 0
+// CHECK: [[COPIED_FIRST_RESULT:%.*]] = copy_value [[FIRST_RESULT]]
+// CHECK: tuple_extract [[BORROWED_RESULT]] : $(T, Trivial), 1
+// CHECK: destroy_value [[RESULT]]
+// CHECK: [[CAST_COPIED_FIRST_RESULT:%.*]] = upcast [[COPIED_FIRST_RESULT]] : $T to $Parent
+// CHECK: enum $Optional<Trivial>
+// CHECK: [[RESULT:%.*]] = tuple ([[CAST_COPIED_FIRST_RESULT]] : $Parent, {{.*}} : $Optional<Trivial>)
+// CHECK: return [[RESULT]]
+
+// CHECK-LABEL: sil hidden @$S19function_conversion37convClassBoundMetatypeArchetypeUpcast{{[_0-9a-zA-Z]*}}F
+func convClassBoundMetatypeArchetypeUpcast<T : Parent>(_ f1: @escaping (Parent.Type) -> (T.Type, Trivial)) {
+// CHECK: function_ref @$S19function_conversion6ParentCXMTxXMTAA7TrivialVIegydd_xXMTACXMTAESgIegydd_ACRbzlTR
+// CHECK: partial_apply
+ let _: (T.Type) -> (Parent.Type, Trivial?) = f1
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion6ParentCXMTxXMTAA7TrivialVIegydd_xXMTACXMTAESgIegydd_ACRbzlTR : $@convention(thin) <T where T : Parent> (@thick T.Type, @guaranteed @callee_guaranteed (@thick Parent.Type) -> (@thick T.Type, Trivial)) -> (@thick Parent.Type, Optional<Trivial>)
+// CHECK: upcast %0 : $@thick T.Type to $@thick Parent.Type
+// CHECK-NEXT: apply
+// CHECK-NEXT: tuple_extract
+// CHECK-NEXT: tuple_extract
+// CHECK-NEXT: upcast {{.*}} : $@thick T.Type to $@thick Parent.Type
+// CHECK-NEXT: enum $Optional<Trivial>
+// CHECK-NEXT: tuple
+// CHECK-NEXT: return
+
+// ==== Make sure we destructure one-element tuples
+
+// CHECK-LABEL: sil hidden @$S19function_conversion15convTupleScalar_2f22f3yyAA1Q_pc_yAaE_pcySi_SitSgctF
+// CHECK: function_ref @$S19function_conversion1Q_pIegn_AA1P_pIegn_TR
+// CHECK: function_ref @$S19function_conversion1Q_pIegn_AA1P_pIegn_TR
+// CHECK: function_ref @$SSi_SitSgIegy_S2iIegyy_TR
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S19function_conversion1Q_pIegn_AA1P_pIegn_TR : $@convention(thin) (@in_guaranteed P, @guaranteed @callee_guaranteed (@in_guaranteed Q) -> ()) -> ()
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SSi_SitSgIegy_S2iIegyy_TR : $@convention(thin) (Int, Int, @guaranteed @callee_guaranteed (Optional<(Int, Int)>) -> ()) -> ()
+
+func convTupleScalar(_ f1: @escaping (Q) -> (),
+ f2: @escaping (_ parent: Q) -> (),
+ f3: @escaping (_ tuple: (Int, Int)?) -> ()) {
+ let _: (P) -> () = f1
+ let _: (P) -> () = f2
+ let _: (Int, Int) -> () = f3
+}
+
+func convTupleScalarOpaque<T>(_ f: @escaping (T...) -> ()) -> ((_ args: T...) -> ())? {
+ return f
+}
+
+// CHECK-LABEL: sil hidden @$S19function_conversion25convTupleToOptionalDirectySi_SitSgSicSi_SitSicF : $@convention(thin) (@guaranteed @callee_guaranteed (Int) -> (Int, Int)) -> @owned @callee_guaranteed (Int) -> Optional<(Int, Int)>
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $@callee_guaranteed (Int) -> (Int, Int)):
+// CHECK: [[FN:%.*]] = copy_value [[ARG]]
+// CHECK: [[THUNK_FN:%.*]] = function_ref @$SS3iIegydd_S2i_SitSgIegyd_TR
+// CHECK-NEXT: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]([[FN]])
+// CHECK-NEXT: return [[THUNK]]
+// CHECK-NEXT: } // end sil function '$S19function_conversion25convTupleToOptionalDirectySi_SitSgSicSi_SitSicF'
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SS3iIegydd_S2i_SitSgIegyd_TR : $@convention(thin) (Int, @guaranteed @callee_guaranteed (Int) -> (Int, Int)) -> Optional<(Int, Int)>
+// CHECK: bb0(%0 : @trivial $Int, %1 : @guaranteed $@callee_guaranteed (Int) -> (Int, Int)):
+// CHECK: [[RESULT:%.*]] = apply %1(%0)
+// CHECK-NEXT: [[LEFT:%.*]] = tuple_extract [[RESULT]]
+// CHECK-NEXT: [[RIGHT:%.*]] = tuple_extract [[RESULT]]
+// CHECK-NEXT: [[RESULT:%.*]] = tuple ([[LEFT]] : $Int, [[RIGHT]] : $Int)
+// CHECK-NEXT: [[OPTIONAL:%.*]] = enum $Optional<(Int, Int)>, #Optional.some!enumelt.1, [[RESULT]]
+// CHECK-NEXT: return [[OPTIONAL]]
+
+func convTupleToOptionalDirect(_ f: @escaping (Int) -> (Int, Int)) -> (Int) -> (Int, Int)? {
+ return f
+}
+
+// CHECK-LABEL: sil hidden @$S19function_conversion27convTupleToOptionalIndirectyx_xtSgxcx_xtxclF : $@convention(thin) <T> (@guaranteed @callee_guaranteed (@in_guaranteed T) -> (@out T, @out T)) -> @owned @callee_guaranteed (@in_guaranteed T) -> @out Optional<(T, T)>
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $@callee_guaranteed (@in_guaranteed T) -> (@out T, @out T)):
+// CHECK: [[FN:%.*]] = copy_value [[ARG]]
+// CHECK: [[THUNK_FN:%.*]] = function_ref @$SxxxIegnrr_xx_xtSgIegnr_lTR
+// CHECK-NEXT: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<T>([[FN]])
+// CHECK-NEXT: return [[THUNK]]
+// CHECK-NEXT: } // end sil function '$S19function_conversion27convTupleToOptionalIndirectyx_xtSgxcx_xtxclF'
+
+// CHECK: sil shared [transparent] [serializable] [reabstraction_thunk] @$SxxxIegnrr_xx_xtSgIegnr_lTR : $@convention(thin) <T> (@in_guaranteed T, @guaranteed @callee_guaranteed (@in_guaranteed T) -> (@out T, @out T)) -> @out Optional<(T, T)>
+// CHECK: bb0(%0 : @trivial $*Optional<(T, T)>, %1 : @trivial $*T, %2 : @guaranteed $@callee_guaranteed (@in_guaranteed T) -> (@out T, @out T)):
+// CHECK: [[OPTIONAL:%.*]] = init_enum_data_addr %0 : $*Optional<(T, T)>, #Optional.some!enumelt.1
+// CHECK-NEXT: [[LEFT:%.*]] = tuple_element_addr [[OPTIONAL]] : $*(T, T), 0
+// CHECK-NEXT: [[RIGHT:%.*]] = tuple_element_addr [[OPTIONAL]] : $*(T, T), 1
+// CHECK-NEXT: apply %2([[LEFT]], [[RIGHT]], %1)
+// CHECK-NEXT: inject_enum_addr %0 : $*Optional<(T, T)>, #Optional.some!enumelt.1
+// CHECK-NEXT: [[VOID:%.*]] = tuple ()
+// CHECK: return [[VOID]]
+
+func convTupleToOptionalIndirect<T>(_ f: @escaping (T) -> (T, T)) -> (T) -> (T, T)? {
+ return f
+}
+
+// ==== Make sure we support AnyHashable erasure
+
+// CHECK-LABEL: sil hidden @$S19function_conversion15convAnyHashable1tyx_ts0E0RzlF
+// CHECK: function_ref @$S19function_conversion15convAnyHashable1tyx_ts0E0RzlFSbs0dE0V_AFtcfU_
+// CHECK: function_ref @$Ss11AnyHashableVABSbIegnnd_xxSbIegnnd_s0B0RzlTR
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$Ss11AnyHashableVABSbIegnnd_xxSbIegnnd_s0B0RzlTR : $@convention(thin) <T where T : Hashable> (@in_guaranteed T, @in_guaranteed T, @guaranteed @callee_guaranteed (@in_guaranteed AnyHashable, @in_guaranteed AnyHashable) -> Bool) -> Bool
+// CHECK: alloc_stack $AnyHashable
+// CHECK: function_ref @$Ss21_convertToAnyHashableys0cD0Vxs0D0RzlF
+// CHECK: apply {{.*}}<T>
+// CHECK: alloc_stack $AnyHashable
+// CHECK: function_ref @$Ss21_convertToAnyHashableys0cD0Vxs0D0RzlF
+// CHECK: apply {{.*}}<T>
+// CHECK: return
+
+func convAnyHashable<T : Hashable>(t: T) {
+ let fn: (T, T) -> Bool = {
+ (x: AnyHashable, y: AnyHashable) in x == y
+ }
+}
+
+// ==== Convert exploded tuples to Any or Optional<Any>
+
+// CHECK-LABEL: sil hidden @$S19function_conversion12convTupleAnyyyyyc_Si_SitycyypcyypSgctF
+// CHECK: function_ref @$SIeg_ypIegr_TR
+// CHECK: partial_apply
+// CHECK: function_ref @$SIeg_ypSgIegr_TR
+// CHECK: partial_apply
+// CHECK: function_ref @$SS2iIegdd_ypIegr_TR
+// CHECK: partial_apply
+// CHECK: function_ref @$SS2iIegdd_ypSgIegr_TR
+// CHECK: partial_apply
+// CHECK: function_ref @$SypIegn_S2iIegyy_TR
+// CHECK: partial_apply
+// CHECK: function_ref @$SypSgIegn_S2iIegyy_TR
+// CHECK: partial_apply
+
+func convTupleAny(_ f1: @escaping () -> (),
+ _ f2: @escaping () -> (Int, Int),
+ _ f3: @escaping (Any) -> (),
+ _ f4: @escaping (Any?) -> ()) {
+ let _: () -> Any = f1
+ let _: () -> Any? = f1
+
+ let _: () -> Any = f2
+ let _: () -> Any? = f2
+
+ let _: ((Int, Int)) -> () = f3
+
+ let _: ((Int, Int)) -> () = f4
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SIeg_ypIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> @out Any
+// CHECK: init_existential_addr %0 : $*Any, $()
+// CHECK-NEXT: apply %1()
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SIeg_ypSgIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> @out Optional<Any>
+// CHECK: [[ENUM_PAYLOAD:%.*]] = init_enum_data_addr %0 : $*Optional<Any>, #Optional.some!enumelt.1
+// CHECK-NEXT: init_existential_addr [[ENUM_PAYLOAD]] : $*Any, $()
+// CHECK-NEXT: apply %1()
+// CHECK-NEXT: inject_enum_addr %0 : $*Optional<Any>, #Optional.some!enumelt.1
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SS2iIegdd_ypIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> (Int, Int)) -> @out Any
+// CHECK: [[ANY_PAYLOAD:%.*]] = init_existential_addr %0
+// CHECK-NEXT: [[LEFT_ADDR:%.*]] = tuple_element_addr [[ANY_PAYLOAD]]
+// CHECK-NEXT: [[RIGHT_ADDR:%.*]] = tuple_element_addr [[ANY_PAYLOAD]]
+// CHECK-NEXT: [[RESULT:%.*]] = apply %1()
+// CHECK-NEXT: [[LEFT:%.*]] = tuple_extract [[RESULT]]
+// CHECK-NEXT: [[RIGHT:%.*]] = tuple_extract [[RESULT]]
+// CHECK-NEXT: store [[LEFT:%.*]] to [trivial] [[LEFT_ADDR]]
+// CHECK-NEXT: store [[RIGHT:%.*]] to [trivial] [[RIGHT_ADDR]]
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SS2iIegdd_ypSgIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> (Int, Int)) -> @out Optional<Any> {
+// CHECK: [[OPTIONAL_PAYLOAD:%.*]] = init_enum_data_addr %0
+// CHECK-NEXT: [[ANY_PAYLOAD:%.*]] = init_existential_addr [[OPTIONAL_PAYLOAD]]
+// CHECK-NEXT: [[LEFT_ADDR:%.*]] = tuple_element_addr [[ANY_PAYLOAD]]
+// CHECK-NEXT: [[RIGHT_ADDR:%.*]] = tuple_element_addr [[ANY_PAYLOAD]]
+// CHECK-NEXT: [[RESULT:%.*]] = apply %1()
+// CHECK-NEXT: [[LEFT:%.*]] = tuple_extract [[RESULT]]
+// CHECK-NEXT: [[RIGHT:%.*]] = tuple_extract [[RESULT]]
+// CHECK-NEXT: store [[LEFT:%.*]] to [trivial] [[LEFT_ADDR]]
+// CHECK-NEXT: store [[RIGHT:%.*]] to [trivial] [[RIGHT_ADDR]]
+// CHECK-NEXT: inject_enum_addr %0
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SypIegn_S2iIegyy_TR : $@convention(thin) (Int, Int, @guaranteed @callee_guaranteed (@in_guaranteed Any) -> ()) -> ()
+// CHECK: [[ANY_VALUE:%.*]] = alloc_stack $Any
+// CHECK-NEXT: [[ANY_PAYLOAD:%.*]] = init_existential_addr [[ANY_VALUE]]
+// CHECK-NEXT: [[LEFT_ADDR:%.*]] = tuple_element_addr [[ANY_PAYLOAD]]
+// CHECK-NEXT: store %0 to [trivial] [[LEFT_ADDR]]
+// CHECK-NEXT: [[RIGHT_ADDR:%.*]] = tuple_element_addr [[ANY_PAYLOAD]]
+// CHECK-NEXT: store %1 to [trivial] [[RIGHT_ADDR]]
+// CHECK-NEXT: apply %2([[ANY_VALUE]])
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: destroy_addr [[ANY_VALUE]]
+// CHECK-NEXT: dealloc_stack [[ANY_VALUE]]
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SypSgIegn_S2iIegyy_TR : $@convention(thin) (Int, Int, @guaranteed @callee_guaranteed (@in_guaranteed Optional<Any>) -> ()) -> ()
+// CHECK: [[ANY_VALUE:%.*]] = alloc_stack $Any
+// CHECK-NEXT: [[ANY_PAYLOAD:%.*]] = init_existential_addr [[ANY_VALUE]]
+// CHECK-NEXT: [[LEFT_ADDR:%.*]] = tuple_element_addr [[ANY_PAYLOAD]]
+// CHECK-NEXT: store %0 to [trivial] [[LEFT_ADDR]]
+// CHECK-NEXT: [[RIGHT_ADDR:%.*]] = tuple_element_addr [[ANY_PAYLOAD]]
+// CHECK-NEXT: store %1 to [trivial] [[RIGHT_ADDR]]
+// CHECK-NEXT: [[OPTIONAL_VALUE:%.*]] = alloc_stack $Optional<Any>
+// CHECK-NEXT: [[OPTIONAL_PAYLOAD:%.*]] = init_enum_data_addr [[OPTIONAL_VALUE]]
+// CHECK-NEXT: copy_addr [take] [[ANY_VALUE]] to [initialization] [[OPTIONAL_PAYLOAD]]
+// CHECK-NEXT: inject_enum_addr [[OPTIONAL_VALUE]]
+// CHECK-NEXT: apply %2([[OPTIONAL_VALUE]])
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: destroy_addr [[OPTIONAL_VALUE]]
+// CHECK-NEXT: dealloc_stack [[OPTIONAL_VALUE]]
+// CHECK-NEXT: dealloc_stack [[ANY_VALUE]]
+// CHECK-NEXT: return
+
+// ==== Support collection subtyping in function argument position
+
+protocol Z {}
+class A: Z {}
+
+func foo_arr<T: Z>(type: T.Type, _ fn: ([T]?) -> Void) {}
+func foo_map<T: Z>(type: T.Type, _ fn: ([Int: T]) -> Void) {}
+
+func rdar35702810() {
+ let fn_arr: ([Z]?) -> Void = { _ in }
+ let fn_map: ([Int: Z]) -> Void = { _ in }
+
+ // CHECK: function_ref @$Ss15_arrayForceCastySayq_GSayxGr0_lF : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Array<τ_0_1>
+ // CHECK: apply %5<A, Z>(%6) : $@convention(thin) <τ_0_0, τ_0_1> (@guaranteed Array<τ_0_0>) -> @owned Array<τ_0_1>
+ foo_arr(type: A.self, fn_arr)
+
+ // CHECK: function_ref @$Ss17_dictionaryUpCastys10DictionaryVyq0_q1_GACyxq_Gs8HashableRzsAFR0_r2_lF : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_0 : Hashable, τ_0_2 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned Dictionary<τ_0_2, τ_0_3>
+ // CHECK: apply %2<Int, A, Int, Z>(%0) : $@convention(thin) <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_0 : Hashable, τ_0_2 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned Dictionary<τ_0_2, τ_0_3>
+ // CHECK: apply %1(%4) : $@callee_guaranteed (@guaranteed Dictionary<Int, Z>) -> ()
+ foo_map(type: A.self, fn_map)
+}
+
+protocol X: Hashable {}
+class B: X {
+ var hashValue: Int { return 42 }
+ static func == (lhs: B, rhs: B) -> Bool {
+ return lhs.hashValue == rhs.hashValue
+ }
+}
+
+func bar_arr<T: X>(type: T.Type, _ fn: ([T]?) -> Void) {}
+func bar_map<T: X>(type: T.Type, _ fn: ([T: Int]) -> Void) {}
+func bar_set<T: X>(type: T.Type, _ fn: (Set<T>) -> Void) {}
+
+func rdar35702810_anyhashable() {
+ let fn_arr: ([AnyHashable]?) -> Void = { _ in }
+ let fn_map: ([AnyHashable: Int]) -> Void = { _ in }
+ let fn_set: (Set<AnyHashable>) -> Void = { _ in }
+
+
+ // CHECK: [[FN:%.*]] = function_ref @$SSays11AnyHashableVGSgIegg_Say19function_conversion1BCGSgIegg_TR : $@convention(thin) (@guaranteed Optional<Array<B>>, @guaranteed @callee_guaranteed (@guaranteed Optional<Array<AnyHashable>>) -> ()) -> ()
+ // CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[FN]](%{{[0-9]+}}) : $@convention(thin) (@guaranteed Optional<Array<B>>, @guaranteed @callee_guaranteed (@guaranteed Optional<Array<AnyHashable>>) -> ()) -> ()
+ // CHECK: convert_escape_to_noescape [[PA]] : $@callee_guaranteed (@guaranteed Optional<Array<B>>) -> () to $@noescape @callee_guaranteed (@guaranteed Optional<Array<B>>) -> ()
+ bar_arr(type: B.self, fn_arr)
+
+ // CHECK: [[FN:%.*]] = function_ref @$Ss10DictionaryVys11AnyHashableVSiGIegg_ABy19function_conversion1BCSiGIegg_TR : $@convention(thin) (@guaranteed Dictionary<B, Int>, @guaranteed @callee_guaranteed (@guaranteed Dictionary<AnyHashable, Int>) -> ()) -> ()
+ // CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[FN]](%{{[0-9]+}}) : $@convention(thin) (@guaranteed Dictionary<B, Int>, @guaranteed @callee_guaranteed (@guaranteed Dictionary<AnyHashable, Int>) -> ()) -> ()
+ // CHECK: convert_escape_to_noescape [[PA]] : $@callee_guaranteed (@guaranteed Dictionary<B, Int>) -> () to $@noescape @callee_guaranteed (@guaranteed Dictionary<B, Int>) -> ()
+ bar_map(type: B.self, fn_map)
+
+ // CHECK: [[FN:%.*]] = function_ref @$Ss3SetVys11AnyHashableVGIegg_ABy19function_conversion1BCGIegg_TR : $@convention(thin) (@guaranteed Set<B>, @guaranteed @callee_guaranteed (@guaranteed Set<AnyHashable>) -> ()) -> ()
+ // CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[FN]](%{{[0-9]+}}) : $@convention(thin) (@guaranteed Set<B>, @guaranteed @callee_guaranteed (@guaranteed Set<AnyHashable>) -> ()) -> ()
+ // CHECK: convert_escape_to_noescape [[PA]] : $@callee_guaranteed (@guaranteed Set<B>) -> () to $@noescape @callee_guaranteed (@guaranteed Set<B>) -> ()
+ bar_set(type: B.self, fn_set)
+}
diff --git a/test/SILGen/plus_zero_function_conversion_objc.swift b/test/SILGen/plus_zero_function_conversion_objc.swift
new file mode 100644
index 0000000..3314382
--- /dev/null
+++ b/test/SILGen/plus_zero_function_conversion_objc.swift
@@ -0,0 +1,118 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -sdk %S/Inputs %s -I %S/Inputs -enable-sil-ownership -enable-source-import -emit-silgen -verify | %FileCheck %s
+
+import Foundation
+
+// REQUIRES: objc_interop
+
+// ==== Metatype to object conversions
+
+// CHECK-LABEL: sil hidden @$S24function_conversion_objc20convMetatypeToObjectyySo8NSObjectCmADcF
+func convMetatypeToObject(_ f: @escaping (NSObject) -> NSObject.Type) {
+// CHECK: function_ref @$SSo8NSObjectCABXMTIeggd_AByXlIeggo_TR
+// CHECK: partial_apply
+ let _: (NSObject) -> AnyObject = f
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SSo8NSObjectCABXMTIeggd_AByXlIeggo_TR : $@convention(thin) (@guaranteed NSObject, @guaranteed @callee_guaranteed (@guaranteed NSObject) -> @thick NSObject.Type) -> @owned AnyObject {
+// CHECK: apply %1(%0)
+// CHECK: thick_to_objc_metatype {{.*}} : $@thick NSObject.Type to $@objc_metatype NSObject.Type
+// CHECK: objc_metatype_to_object {{.*}} : $@objc_metatype NSObject.Type to $AnyObject
+// CHECK: return
+
+@objc protocol NSBurrito {}
+
+// CHECK-LABEL: sil hidden @$S24function_conversion_objc31convExistentialMetatypeToObjectyyAA9NSBurrito_pXpAaC_pcF
+func convExistentialMetatypeToObject(_ f: @escaping (NSBurrito) -> NSBurrito.Type) {
+// CHECK: function_ref @$S24function_conversion_objc9NSBurrito_pAaB_pXmTIeggd_AaB_pyXlIeggo_TR
+// CHECK: partial_apply
+ let _: (NSBurrito) -> AnyObject = f
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S24function_conversion_objc9NSBurrito_pAaB_pXmTIeggd_AaB_pyXlIeggo_TR : $@convention(thin) (@guaranteed NSBurrito, @guaranteed @callee_guaranteed (@guaranteed NSBurrito) -> @thick NSBurrito.Type) -> @owned AnyObject
+// CHECK: apply %1(%0)
+// CHECK: thick_to_objc_metatype {{.*}} : $@thick NSBurrito.Type to $@objc_metatype NSBurrito.Type
+// CHECK: objc_existential_metatype_to_object {{.*}} : $@objc_metatype NSBurrito.Type to $AnyObject
+// CHECK: return
+
+// CHECK-LABEL: sil hidden @$S24function_conversion_objc28convProtocolMetatypeToObjectyyAA9NSBurrito_pmycF
+func convProtocolMetatypeToObject(_ f: @escaping () -> NSBurrito.Protocol) {
+// CHECK: function_ref @$S24function_conversion_objc9NSBurrito_pXMtIegd_So8ProtocolCIego_TR
+// CHECK: partial_apply
+ let _: () -> Protocol = f
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S24function_conversion_objc9NSBurrito_pXMtIegd_So8ProtocolCIego_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> @thin NSBurrito.Protocol) -> @owned Protocol
+// CHECK: apply %0() : $@callee_guaranteed () -> @thin NSBurrito.Protocol
+// CHECK: objc_protocol #NSBurrito : $Protocol
+// CHECK: copy_value
+// CHECK: return
+
+// ==== Representation conversions
+
+// CHECK-LABEL: sil hidden @$S24function_conversion_objc11funcToBlockyyyXByycF : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> @owned @convention(block) () -> ()
+// CHECK: [[BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage
+// CHECK: [[BLOCK:%.*]] = init_block_storage_header [[BLOCK_STORAGE]]
+// CHECK: [[COPY:%.*]] = copy_block [[BLOCK]] : $@convention(block) () -> ()
+// CHECK: return [[COPY]]
+func funcToBlock(_ x: @escaping () -> ()) -> @convention(block) () -> () {
+ return x
+}
+
+// CHECK-LABEL: sil hidden @$S24function_conversion_objc11blockToFuncyyycyyXBF : $@convention(thin) (@guaranteed @convention(block) () -> ()) -> @owned @callee_guaranteed () -> ()
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $@convention(block) () -> ()):
+// CHECK: [[COPIED:%.*]] = copy_block [[ARG]]
+// CHECK: [[BORROWED_COPIED:%.*]] = begin_borrow [[COPIED]]
+// CHECK: [[COPIED_2:%.*]] = copy_value [[BORROWED_COPIED]]
+// CHECK: [[THUNK:%.*]] = function_ref @$SIeyB_Ieg_TR
+// CHECK: [[FUNC:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[COPIED_2]])
+// CHECK: end_borrow [[BORROWED_COPIED]] from [[COPIED]]
+// CHECK: destroy_value [[COPIED]]
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return [[FUNC]]
+func blockToFunc(_ x: @escaping @convention(block) () -> ()) -> () -> () {
+ return x
+}
+
+// ==== Representation change + function type conversion
+
+// CHECK-LABEL: sil hidden @$S24function_conversion_objc22blockToFuncExistentialyypycSiyXBF : $@convention(thin) (@guaranteed @convention(block) () -> Int) -> @owned @callee_guaranteed () -> @out Any
+// CHECK: function_ref @$SSiIeyBd_SiIegd_TR
+// CHECK: partial_apply
+// CHECK: function_ref @$SSiIegd_ypIegr_TR
+// CHECK: partial_apply
+// CHECK: return
+func blockToFuncExistential(_ x: @escaping @convention(block) () -> Int) -> () -> Any {
+ return x
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SSiIeyBd_SiIegd_TR : $@convention(thin) (@guaranteed @convention(block) () -> Int) -> Int
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SSiIegd_ypIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> Int) -> @out Any
+
+// C function pointer conversions
+
+class A : NSObject {}
+class B : A {}
+
+// CHECK-LABEL: sil hidden @$S24function_conversion_objc18cFuncPtrConversionyyAA1BCXCyAA1ACXCF
+func cFuncPtrConversion(_ x: @escaping @convention(c) (A) -> ()) -> @convention(c) (B) -> () {
+// CHECK: convert_function %0 : $@convention(c) (A) -> () to $@convention(c) (B) -> ()
+// CHECK: return
+ return x
+}
+
+func cFuncPtr(_ a: A) {}
+
+// CHECK-LABEL: sil hidden @$S24function_conversion_objc19cFuncDeclConversionyAA1BCXCyF
+func cFuncDeclConversion() -> @convention(c) (B) -> () {
+// CHECK: function_ref @$S24function_conversion_objc8cFuncPtryyAA1ACFTo : $@convention(c) (A) -> ()
+// CHECK: convert_function %0 : $@convention(c) (A) -> () to $@convention(c) (B) -> ()
+// CHECK: return
+ return cFuncPtr
+}
+
+func cFuncPtrConversionUnsupported(_ x: @escaping @convention(c) (@convention(block) () -> ()) -> ())
+ -> @convention(c) (@convention(c) () -> ()) -> () {
+ return x // expected-error{{C function pointer signature '@convention(c) (@convention(block) () -> ()) -> ()' is not compatible with expected type '@convention(c) (@convention(c) () -> ()) -> ()'}}
+}
diff --git a/test/SILGen/plus_zero_functions.swift b/test/SILGen/plus_zero_functions.swift
new file mode 100644
index 0000000..e43048d
--- /dev/null
+++ b/test/SILGen/plus_zero_functions.swift
@@ -0,0 +1,592 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -parse-stdlib -parse-as-library -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+import Swift // just for Optional
+
+func markUsed<T>(_ t: T) {}
+
+typealias Int = Builtin.Int64
+typealias Int64 = Builtin.Int64
+typealias Bool = Builtin.Int1
+
+var zero = getInt()
+func getInt() -> Int { return zero }
+
+func standalone_function(_ x: Int, _ y: Int) -> Int {
+ return x
+}
+
+func higher_order_function(_ f: (_ x: Int, _ y: Int) -> Int, _ x: Int, _ y: Int) -> Int {
+ return f(x, y)
+}
+
+func higher_order_function2(_ f: (Int, Int) -> Int, _ x: Int, _ y: Int) -> Int {
+ return f(x, y)
+}
+
+struct SomeStruct {
+ // -- Constructors and methods are uncurried in 'self'
+ // -- Instance methods use 'method' cc
+
+ init(x:Int, y:Int) {}
+
+ mutating
+ func method(_ x: Int) {}
+
+ static func static_method(_ x: Int) {}
+
+ func generic_method<T>(_ x: T) {}
+}
+
+class SomeClass {
+ // -- Constructors and methods are uncurried in 'self'
+ // -- Instance methods use 'method' cc
+
+ // CHECK-LABEL: sil hidden @$S9functions9SomeClassC{{[_0-9a-zA-Z]*}}fC : $@convention(method) (Builtin.Int64, Builtin.Int64, @thick SomeClass.Type) -> @owned SomeClass
+ // CHECK: bb0(%0 : @trivial $Builtin.Int64, %1 : @trivial $Builtin.Int64, %2 : @trivial $@thick SomeClass.Type):
+
+ // CHECK-LABEL: sil hidden @$S9functions9SomeClassC{{[_0-9a-zA-Z]*}}fc : $@convention(method) (Builtin.Int64, Builtin.Int64, @owned SomeClass) -> @owned SomeClass
+ // CHECK: bb0(%0 : @trivial $Builtin.Int64, %1 : @trivial $Builtin.Int64, %2 : @owned $SomeClass):
+ init(x:Int, y:Int) {}
+
+ // CHECK-LABEL: sil hidden @$S9functions9SomeClassC6method{{[_0-9a-zA-Z]*}}F : $@convention(method) (Builtin.Int64, @guaranteed SomeClass) -> ()
+ // CHECK: bb0(%0 : @trivial $Builtin.Int64, %1 : @guaranteed $SomeClass):
+ func method(_ x: Int) {}
+
+ // CHECK-LABEL: sil hidden @$S9functions9SomeClassC13static_method{{[_0-9a-zA-Z]*}}FZ : $@convention(method) (Builtin.Int64, @thick SomeClass.Type) -> ()
+ // CHECK: bb0(%0 : @trivial $Builtin.Int64, %1 : @trivial $@thick SomeClass.Type):
+ class func static_method(_ x: Int) {}
+
+ var someProperty: Int {
+ get {
+ return zero
+ }
+ set {}
+ }
+
+ subscript(x:Int, y:Int) -> Int {
+ get {
+ return zero
+ }
+ set {}
+ }
+
+ func generic<T>(_ x: T) -> T {
+ return x
+ }
+}
+
+func SomeClassWithBenefits() -> SomeClass.Type {
+ return SomeClass.self
+}
+
+protocol SomeProtocol {
+ func method(_ x: Int)
+ static func static_method(_ x: Int)
+}
+
+struct ConformsToSomeProtocol : SomeProtocol {
+ func method(_ x: Int) { }
+ static func static_method(_ x: Int) { }
+}
+
+class SomeGeneric<T> {
+ init() { }
+ func method(_ x: T) -> T { return x }
+
+ func generic<U>(_ x: U) -> U { return x }
+}
+
+// CHECK-LABEL: sil hidden @$S9functions5calls{{[_0-9a-zA-Z]*}}F : $@convention(thin) (Builtin.Int64, Builtin.Int64, Builtin.Int64) -> ()
+func calls(_ i:Int, j:Int, k:Int) {
+ var i = i
+ var j = j
+ var k = k
+ // CHECK: bb0(%0 : @trivial $Builtin.Int64, %1 : @trivial $Builtin.Int64, %2 : @trivial $Builtin.Int64):
+ // CHECK: [[IBOX:%[0-9]+]] = alloc_box ${ var Builtin.Int64 }
+ // CHECK: [[IADDR:%.*]] = project_box [[IBOX]]
+ // CHECK: [[JBOX:%[0-9]+]] = alloc_box ${ var Builtin.Int64 }
+ // CHECK: [[JADDR:%.*]] = project_box [[JBOX]]
+ // CHECK: [[KBOX:%[0-9]+]] = alloc_box ${ var Builtin.Int64 }
+ // CHECK: [[KADDR:%.*]] = project_box [[KBOX]]
+
+ // CHECK: [[READI:%.*]] = begin_access [read] [unknown] [[IADDR]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READI]]
+ // CHECK: [[READJ:%.*]] = begin_access [read] [unknown] [[JADDR]]
+ // CHECK: [[J:%[0-9]+]] = load [trivial] [[READJ]]
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S9functions19standalone_function{{[_0-9a-zA-Z]*}}F : $@convention(thin) (Builtin.Int64, Builtin.Int64) -> Builtin.Int64
+ // CHECK: apply [[FUNC]]([[I]], [[J]])
+ standalone_function(i, j)
+
+ // -- Curry 'self' onto struct method argument lists.
+
+ // CHECK: [[ST_ADDR:%.*]] = alloc_box ${ var SomeStruct }
+ // CHECK: [[METATYPE:%.*]] = metatype $@thin SomeStruct.Type
+ // CHECK: [[READI:%.*]] = begin_access [read] [unknown] [[IADDR]]
+ // CHECK: [[I:%.*]] = load [trivial] [[READI]]
+ // CHECK: [[READJ:%.*]] = begin_access [read] [unknown] [[JADDR]]
+ // CHECK: [[J:%.*]] = load [trivial] [[READJ]]
+ // CHECK: [[CTOR:%.*]] = function_ref @$S9functions10SomeStructV{{[_0-9a-zA-Z]*}}fC : $@convention(method) (Builtin.Int64, Builtin.Int64, @thin SomeStruct.Type) -> SomeStruct
+ // CHECK: apply [[CTOR]]([[I]], [[J]], [[METATYPE]]) : $@convention(method) (Builtin.Int64, Builtin.Int64, @thin SomeStruct.Type) -> SomeStruct
+ var st = SomeStruct(x: i, y: j)
+
+ // -- Use of unapplied struct methods as values.
+
+ // CHECK: [[THUNK:%.*]] = function_ref @$S9functions10SomeStructV6method{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[THUNK_THICK:%.*]] = thin_to_thick_function [[THUNK]]
+ var stm1 = SomeStruct.method
+ stm1(&st)(i)
+
+ // -- Curry 'self' onto method argument lists dispatched using class_method.
+
+ // CHECK: [[CBOX:%[0-9]+]] = alloc_box ${ var SomeClass }
+ // CHECK: [[CADDR:%.*]] = project_box [[CBOX]]
+ // CHECK: [[META:%[0-9]+]] = metatype $@thick SomeClass.Type
+ // CHECK: [[READI:%.*]] = begin_access [read] [unknown] [[IADDR]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READI]]
+ // CHECK: [[READJ:%.*]] = begin_access [read] [unknown] [[JADDR]]
+ // CHECK: [[J:%[0-9]+]] = load [trivial] [[READJ]]
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S9functions9SomeClassC{{[_0-9a-zA-Z]*}}fC : $@convention(method) (Builtin.Int64, Builtin.Int64, @thick SomeClass.Type) -> @owned SomeClass
+ // CHECK: [[C:%[0-9]+]] = apply [[FUNC]]([[I]], [[J]], [[META]])
+ var c = SomeClass(x: i, y: j)
+
+ // CHECK: [[READC:%.*]] = begin_access [read] [unknown] [[CADDR]]
+ // CHECK: [[C:%[0-9]+]] = load [copy] [[READC]]
+ // CHECK: [[BORROWED_C:%.*]] = begin_borrow [[C]]
+ // CHECK: [[READI:%.*]] = begin_access [read] [unknown] [[IADDR]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READI]]
+ // CHECK: [[METHOD:%[0-9]+]] = class_method [[BORROWED_C]] : {{.*}}, #SomeClass.method!1
+ // CHECK: apply [[METHOD]]([[I]], [[BORROWED_C]])
+ // CHECK: end_borrow [[BORROWED_C]] from [[C]]
+ // CHECK: destroy_value [[C]]
+ c.method(i)
+
+ // -- Curry 'self' onto unapplied methods dispatched using class_method.
+ // CHECK: [[METHOD_CURRY_THUNK:%.*]] = function_ref @$S9functions9SomeClassC6method{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[METHOD_CURRY_THUNK]]
+ var cm1 = SomeClass.method(c)
+ cm1(i)
+
+ // CHECK: [[READC:%.*]] = begin_access [read] [unknown] [[CADDR]]
+ // CHECK: [[C:%[0-9]+]] = load [copy] [[READC]]
+ // CHECK: [[BORROWED_C:%.*]] = begin_borrow [[C]]
+ // CHECK: [[READI:%.*]] = begin_access [read] [unknown] [[IADDR]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READI]]
+ // CHECK: [[METHOD:%[0-9]+]] = class_method [[BORROWED_C]] : {{.*}}, #SomeClass.method!1
+ // CHECK: apply [[METHOD]]([[I]], [[BORROWED_C]])
+ // CHECK: end_borrow [[BORROWED_C]] from [[C]]
+ // CHECK: destroy_value [[C]]
+ SomeClass.method(c)(i)
+
+ // -- Curry the Type onto static method argument lists.
+
+ // CHECK: [[READC:%.*]] = begin_access [read] [unknown] [[CADDR]]
+ // CHECK: [[C:%[0-9]+]] = load [copy] [[READC]]
+ // CHECK: [[META:%.*]] = value_metatype $@thick SomeClass.Type, [[C]]
+ // CHECK: [[READI:%.*]] = begin_access [read] [unknown] [[IADDR]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READI]]
+ // CHECK: [[METHOD:%[0-9]+]] = class_method [[META]] : {{.*}}, #SomeClass.static_method!1
+ // CHECK: apply [[METHOD]]([[I]], [[META]])
+ type(of: c).static_method(i)
+
+ // -- Curry property accesses.
+
+ // -- FIXME: class_method-ify class getters.
+ // CHECK: [[READC:%.*]] = begin_access [read] [unknown] [[CADDR]]
+ // CHECK: [[C:%[0-9]+]] = load [copy] [[READC]]
+ // CHECK: [[BORROWED_C:%.*]] = begin_borrow [[C]]
+ // CHECK: [[GETTER:%[0-9]+]] = class_method {{.*}} : $SomeClass, #SomeClass.someProperty!getter.1
+ // CHECK: apply [[GETTER]]([[BORROWED_C]])
+ // CHECK: end_borrow [[BORROWED_C]] from [[C]]
+ // CHECK: destroy_value [[C]]
+ i = c.someProperty
+
+ // CHECK: [[READC:%.*]] = begin_access [read] [unknown] [[CADDR]]
+ // CHECK: [[C:%[0-9]+]] = load [copy] [[READC]]
+ // CHECK: [[READI:%.*]] = begin_access [read] [unknown] [[IADDR]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READI]]
+ // CHECK: [[BORROWED_C:%.*]] = begin_borrow [[C]]
+ // CHECK: [[SETTER:%[0-9]+]] = class_method [[BORROWED_C]] : $SomeClass, #SomeClass.someProperty!setter.1 : (SomeClass) -> (Builtin.Int64) -> ()
+ // CHECK: apply [[SETTER]]([[I]], [[BORROWED_C]])
+ // CHECK: end_borrow [[BORROWED_C]] from [[C]]
+ // CHECK: destroy_value [[C]]
+ c.someProperty = i
+
+ // CHECK: [[READC:%.*]] = begin_access [read] [unknown] [[CADDR]]
+ // CHECK: [[C:%[0-9]+]] = load [copy] [[READC]]
+ // CHECK: [[READJ:%.*]] = begin_access [read] [unknown] [[JADDR]]
+ // CHECK: [[J:%[0-9]+]] = load [trivial] [[READJ]]
+ // CHECK: [[READK:%.*]] = begin_access [read] [unknown] [[KADDR]]
+ // CHECK: [[K:%[0-9]+]] = load [trivial] [[READK]]
+ // CHECK: [[BORROWED_C:%.*]] = begin_borrow [[C]]
+ // CHECK: [[GETTER:%[0-9]+]] = class_method [[BORROWED_C]] : $SomeClass, #SomeClass.subscript!getter.1 : (SomeClass) -> (Builtin.Int64, Builtin.Int64) -> Builtin.Int64, $@convention(method) (Builtin.Int64, Builtin.Int64, @guaranteed SomeClass) -> Builtin.Int64
+ // CHECK: apply [[GETTER]]([[J]], [[K]], [[BORROWED_C]])
+ // CHECK: end_borrow [[BORROWED_C]] from [[C]]
+ // CHECK: destroy_value [[C]]
+ i = c[j, k]
+
+ // CHECK: [[READC:%.*]] = begin_access [read] [unknown] [[CADDR]]
+ // CHECK: [[C:%[0-9]+]] = load [copy] [[READC]]
+ // CHECK: [[READI:%.*]] = begin_access [read] [unknown] [[IADDR]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READI]]
+ // CHECK: [[READJ:%.*]] = begin_access [read] [unknown] [[JADDR]]
+ // CHECK: [[J:%[0-9]+]] = load [trivial] [[READJ]]
+ // CHECK: [[READK:%.*]] = begin_access [read] [unknown] [[KADDR]]
+ // CHECK: [[K:%[0-9]+]] = load [trivial] [[READK]]
+ // CHECK: [[BORROWED_C:%.*]] = begin_borrow [[C]]
+ // CHECK: [[SETTER:%[0-9]+]] = class_method [[BORROWED_C]] : $SomeClass, #SomeClass.subscript!setter.1 : (SomeClass) -> (Builtin.Int64, Builtin.Int64, Builtin.Int64) -> (), $@convention(method) (Builtin.Int64, Builtin.Int64, Builtin.Int64, @guaranteed SomeClass) -> ()
+ // CHECK: apply [[SETTER]]([[K]], [[I]], [[J]], [[BORROWED_C]])
+ // CHECK: end_borrow [[BORROWED_C]] from [[C]]
+ // CHECK: destroy_value [[C]]
+ c[i, j] = k
+
+ // -- Curry the projected concrete value in an existential (or its Type)
+ // -- onto protocol type methods dispatched using protocol_method.
+
+ // CHECK: [[PBOX:%[0-9]+]] = alloc_box ${ var SomeProtocol }
+ // CHECK: [[PADDR:%.*]] = project_box [[PBOX]]
+ var p : SomeProtocol = ConformsToSomeProtocol()
+
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PADDR]]
+ // CHECK: [[TEMP:%.*]] = alloc_stack $SomeProtocol
+ // CHECK: copy_addr [[READ]] to [initialization] [[TEMP]]
+ // CHECK: [[PVALUE:%[0-9]+]] = open_existential_addr immutable_access [[TEMP]] : $*SomeProtocol to $*[[OPENED:@opened(.*) SomeProtocol]]
+ // CHECK: [[READI:%.*]] = begin_access [read] [unknown] [[IADDR]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READI]]
+ // CHECK: [[PMETHOD:%[0-9]+]] = witness_method $[[OPENED]], #SomeProtocol.method!1
+ // CHECK: apply [[PMETHOD]]<[[OPENED]]>([[I]], [[PVALUE]])
+ // CHECK: destroy_addr [[TEMP]]
+ // CHECK: dealloc_stack [[TEMP]]
+ p.method(i)
+
+ // CHECK: [[PVALUE:%[0-9]+]] = open_existential_addr immutable_access [[PADDR:%.*]] : $*SomeProtocol to $*[[OPENED:@opened(.*) SomeProtocol]]
+ // CHECK: [[READI:%.*]] = begin_access [read] [unknown] [[IADDR]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READI]]
+ // CHECK: [[PMETHOD:%[0-9]+]] = witness_method $[[OPENED]], #SomeProtocol.method!1
+ // CHECK: apply [[PMETHOD]]<[[OPENED]]>([[I]], [[PVALUE]])
+ var sp : SomeProtocol = ConformsToSomeProtocol()
+ sp.method(i)
+
+ // FIXME: [[PMETHOD:%[0-9]+]] = witness_method $[[OPENED:@opened(.*) SomeProtocol]], #SomeProtocol.static_method!1
+ // FIXME: [[I:%[0-9]+]] = load [trivial] [[IADDR]]
+ // FIXME: apply [[PMETHOD]]([[I]], [[PMETA]])
+ // Needs existential metatypes
+ //type(of: p).static_method(i)
+
+ // -- Use an apply or partial_apply instruction to bind type parameters of a generic.
+
+ // CHECK: [[GBOX:%[0-9]+]] = alloc_box ${ var SomeGeneric<Builtin.Int64> }
+ // CHECK: [[GADDR:%.*]] = project_box [[GBOX]]
+ // CHECK: [[META:%[0-9]+]] = metatype $@thick SomeGeneric<Builtin.Int64>.Type
+ // CHECK: [[CTOR_GEN:%[0-9]+]] = function_ref @$S9functions11SomeGenericC{{[_0-9a-zA-Z]*}}fC : $@convention(method) <τ_0_0> (@thick SomeGeneric<τ_0_0>.Type) -> @owned SomeGeneric<τ_0_0>
+ // CHECK: apply [[CTOR_GEN]]<Builtin.Int64>([[META]])
+ var g = SomeGeneric<Builtin.Int64>()
+
+ // CHECK: [[TMPR:%.*]] = alloc_stack $Builtin.Int64
+ // CHECK: [[READG:%.*]] = begin_access [read] [unknown] [[GADDR]]
+ // CHECK: [[G:%[0-9]+]] = load [copy] [[READG]]
+ // CHECK: [[BORROWED_G:%.*]] = begin_borrow [[G]]
+ // CHECK: [[TMPI:%.*]] = alloc_stack $Builtin.Int64
+ // CHECK: [[METHOD_GEN:%[0-9]+]] = class_method [[BORROWED_G]] : {{.*}}, #SomeGeneric.method!1
+ // CHECK: apply [[METHOD_GEN]]<{{.*}}>([[TMPR]], [[TMPI]], [[BORROWED_G]])
+ // CHECK: end_borrow [[BORROWED_G]] from [[G]]
+ // CHECK: destroy_value [[G]]
+ g.method(i)
+
+ // CHECK: [[TMPR:%.*]] = alloc_stack $Builtin.Int64
+ // CHECK: [[READG:%.*]] = begin_access [read] [unknown] [[GADDR]]
+ // CHECK: [[G:%[0-9]+]] = load [copy] [[READG]]
+ // CHECK: [[BORROWED_G:%.*]] = begin_borrow [[G]]
+ // CHECK: [[TMPJ:%.*]] = alloc_stack $Builtin.Int64
+ // CHECK: [[METHOD_GEN:%[0-9]+]] = class_method [[BORROWED_G]] : {{.*}}, #SomeGeneric.generic!1
+ // CHECK: apply [[METHOD_GEN]]<{{.*}}>([[TMPR]], [[TMPJ]], [[BORROWED_G]])
+ // CHECK: end_borrow [[BORROWED_G]] from [[G]]
+ // CHECK: destroy_value [[G]]
+ g.generic(j)
+
+ // CHECK: [[TMPR:%.*]] = alloc_stack $Builtin.Int64
+ // CHECK: [[READC:%.*]] = begin_access [read] [unknown] [[CADDR]]
+ // CHECK: [[C:%[0-9]+]] = load [copy] [[READC]]
+ // CHECK: [[BORROWED_C:%.*]] = begin_borrow [[C]]
+ // CHECK: [[TMPK:%.*]] = alloc_stack $Builtin.Int64
+ // CHECK: [[METHOD_GEN:%[0-9]+]] = class_method [[BORROWED_C]] : {{.*}}, #SomeClass.generic!1
+ // CHECK: apply [[METHOD_GEN]]<{{.*}}>([[TMPR]], [[TMPK]], [[BORROWED_C]])
+ // CHECK: end_borrow [[BORROWED_C]] from [[C]]
+ // CHECK: destroy_value [[C]]
+ c.generic(k)
+
+ // FIXME: curried generic entry points
+ //var gm1 = g.method
+ //gm1(i)
+
+ //var gg1 : (Int) -> Int = g.generic
+ //gg1(j)
+
+ //var cg1 : (Int) -> Int = c.generic
+ //cg1(k)
+
+ // SIL-level "thin" function values need to be able to convert to
+ // "thick" function values when stored, returned, or passed as arguments.
+
+ // CHECK: [[FBOX:%[0-9]+]] = alloc_box ${ var @callee_guaranteed (Builtin.Int64, Builtin.Int64) -> Builtin.Int64 }
+ // CHECK: [[FADDR:%.*]] = project_box [[FBOX]]
+ // CHECK: [[FUNC_THIN:%[0-9]+]] = function_ref @$S9functions19standalone_function{{[_0-9a-zA-Z]*}}F : $@convention(thin) (Builtin.Int64, Builtin.Int64) -> Builtin.Int64
+ // CHECK: [[FUNC_THICK:%[0-9]+]] = thin_to_thick_function [[FUNC_THIN]]
+ // CHECK: store [[FUNC_THICK]] to [init] [[FADDR]]
+ var f = standalone_function
+ // CHECK: [[READF:%.*]] = begin_access [read] [unknown] [[FADDR]]
+ // CHECK: [[F:%[0-9]+]] = load [copy] [[READF]]
+ // CHECK: [[READI:%.*]] = begin_access [read] [unknown] [[IADDR]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READI]]
+ // CHECK: [[READJ:%.*]] = begin_access [read] [unknown] [[JADDR]]
+ // CHECK: [[J:%[0-9]+]] = load [trivial] [[READJ]]
+ // CHECK: [[BORROW:%.*]] = begin_borrow [[F]]
+ // CHECK: apply [[BORROW]]([[I]], [[J]])
+ // CHECK: end_borrow [[BORROW]]
+ // CHECK: destroy_value [[F]]
+ f(i, j)
+
+ // CHECK: [[FUNC_THIN:%[0-9]+]] = function_ref @$S9functions19standalone_function{{[_0-9a-zA-Z]*}}F : $@convention(thin) (Builtin.Int64, Builtin.Int64) -> Builtin.Int64
+ // CHECK: [[FUNC_THICK:%[0-9]+]] = thin_to_thick_function [[FUNC_THIN]]
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[FUNC_THICK]]
+ // CHECK: [[READI:%.*]] = begin_access [read] [unknown] [[IADDR]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READI]]
+ // CHECK: [[READJ:%.*]] = begin_access [read] [unknown] [[JADDR]]
+ // CHECK: [[J:%[0-9]+]] = load [trivial] [[READJ]]
+ // CHECK: [[HOF:%[0-9]+]] = function_ref @$S9functions21higher_order_function{{[_0-9a-zA-Z]*}}F : $@convention(thin) {{.*}}
+ // CHECK: apply [[HOF]]([[CONVERT]], [[I]], [[J]])
+ higher_order_function(standalone_function, i, j)
+
+ // CHECK: [[FUNC_THIN:%[0-9]+]] = function_ref @$S9functions19standalone_function{{[_0-9a-zA-Z]*}}F : $@convention(thin) (Builtin.Int64, Builtin.Int64) -> Builtin.Int64
+ // CHECK: [[FUNC_THICK:%.*]] = thin_to_thick_function [[FUNC_THIN]]
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[FUNC_THICK]]
+ // CHECK: [[READI:%.*]] = begin_access [read] [unknown] [[IADDR]]
+ // CHECK: [[I:%[0-9]+]] = load [trivial] [[READI]]
+ // CHECK: [[READJ:%.*]] = begin_access [read] [unknown] [[JADDR]]
+ // CHECK: [[J:%[0-9]+]] = load [trivial] [[READJ]]
+ // CHECK: [[HOF2:%[0-9]+]] = function_ref @$S9functions22higher_order_function2{{[_0-9a-zA-Z]*}}F : $@convention(thin) {{.*}}
+ // CHECK: apply [[HOF2]]([[CONVERT]], [[I]], [[J]])
+ higher_order_function2(standalone_function, i, j)
+}
+
+// -- Curried entry points
+// CHECK-LABEL: sil shared [thunk] @$S9functions10SomeStructV6method{{[_0-9a-zA-Z]*}}FTc : $@convention(thin) (@inout SomeStruct) -> @owned @callee_guaranteed (Builtin.Int64) -> () {
+// CHECK: [[UNCURRIED:%.*]] = function_ref @$S9functions10SomeStructV6method{{[_0-9a-zA-Z]*}}F : $@convention(method) (Builtin.Int64, @inout SomeStruct) -> (){{.*}} // user: %2
+// CHECK: [[CURRIED:%.*]] = partial_apply [callee_guaranteed] [[UNCURRIED]]
+// CHECK: return [[CURRIED]]
+
+// CHECK-LABEL: sil shared [thunk] @$S9functions9SomeClassC6method{{[_0-9a-zA-Z]*}}FTc : $@convention(thin) (@guaranteed SomeClass) -> @owned @callee_guaranteed (Builtin.Int64) -> ()
+// CHECK: bb0(%0 : @guaranteed $SomeClass):
+// CHECK: class_method %0 : $SomeClass, #SomeClass.method!1 : (SomeClass) -> (Builtin.Int64) -> ()
+// CHECK: %2 = copy_value %0 : $SomeClass
+// CHECK: %3 = partial_apply [callee_guaranteed] %1(%2)
+// CHECK: return %3
+
+func return_func() -> (_ x: Builtin.Int64, _ y: Builtin.Int64) -> Builtin.Int64 {
+ // CHECK: [[FUNC_THIN:%[0-9]+]] = function_ref @$S9functions19standalone_function{{[_0-9a-zA-Z]*}}F : $@convention(thin) (Builtin.Int64, Builtin.Int64) -> Builtin.Int64
+ // CHECK: [[FUNC_THICK:%[0-9]+]] = thin_to_thick_function [[FUNC_THIN]]
+ // CHECK: return [[FUNC_THICK]]
+ return standalone_function
+}
+
+func standalone_generic<T>(_ x: T, y: T) -> T { return x }
+
+// CHECK-LABEL: sil hidden @$S9functions14return_genericBi64_Bi64__Bi64_tcyF
+func return_generic() -> (_ x:Builtin.Int64, _ y:Builtin.Int64) -> Builtin.Int64 {
+ // CHECK: [[GEN:%.*]] = function_ref @$S9functions18standalone_generic{{[_0-9a-zA-Z]*}}F : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0) -> @out τ_0_0
+ // CHECK: [[SPEC:%.*]] = partial_apply [callee_guaranteed] [[GEN]]<Builtin.Int64>()
+ // CHECK: [[THUNK:%.*]] = function_ref @{{.*}} : $@convention(thin) (Builtin.Int64, Builtin.Int64, @guaranteed @callee_guaranteed (@in_guaranteed Builtin.Int64, @in_guaranteed Builtin.Int64) -> @out Builtin.Int64) -> Builtin.Int64
+ // CHECK: [[T0:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[SPEC]])
+ // CHECK: return [[T0]]
+ return standalone_generic
+}
+
+// CHECK-LABEL: sil hidden @$S9functions20return_generic_tuple{{[_0-9a-zA-Z]*}}F
+func return_generic_tuple()
+-> (_ x: (Builtin.Int64, Builtin.Int64), _ y: (Builtin.Int64, Builtin.Int64)) -> (Builtin.Int64, Builtin.Int64) {
+ // CHECK: [[GEN:%.*]] = function_ref @$S9functions18standalone_generic{{[_0-9a-zA-Z]*}}F : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0) -> @out τ_0_0
+ // CHECK: [[SPEC:%.*]] = partial_apply [callee_guaranteed] [[GEN]]<(Builtin.Int64, Builtin.Int64)>()
+ // CHECK: [[THUNK:%.*]] = function_ref @{{.*}} : $@convention(thin) (Builtin.Int64, Builtin.Int64, Builtin.Int64, Builtin.Int64, @guaranteed @callee_guaranteed (@in_guaranteed (Builtin.Int64, Builtin.Int64), @in_guaranteed (Builtin.Int64, Builtin.Int64)) -> @out (Builtin.Int64, Builtin.Int64)) -> (Builtin.Int64, Builtin.Int64)
+ // CHECK: [[T0:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[SPEC]])
+ // CHECK: return [[T0]]
+ return standalone_generic
+}
+
+// CHECK-LABEL: sil hidden @$S9functions16testNoReturnAttrs5NeverOyF : $@convention(thin) () -> Never
+func testNoReturnAttr() -> Never {}
+// CHECK-LABEL: sil hidden @$S9functions20testNoReturnAttrPoly{{[_0-9a-zA-Z]*}}F : $@convention(thin) <T> (@in_guaranteed T) -> Never
+func testNoReturnAttrPoly<T>(_ x: T) -> Never {}
+
+// CHECK-LABEL: sil hidden @$S9functions21testNoReturnAttrParam{{[_0-9a-zA-Z]*}}F : $@convention(thin) (@noescape @callee_guaranteed () -> Never) -> ()
+func testNoReturnAttrParam(_ fptr: () -> Never) -> () {}
+
+// CHECK-LABEL: sil hidden [transparent] @$S9functions15testTransparent{{[_0-9a-zA-Z]*}}F : $@convention(thin) (Builtin.Int1) -> Builtin.Int1
+@_transparent func testTransparent(_ x: Bool) -> Bool {
+ return x
+}
+
+// CHECK-LABEL: sil hidden @$S9functions16applyTransparent{{[_0-9a-zA-Z]*}}F : $@convention(thin) (Builtin.Int1) -> Builtin.Int1 {
+func applyTransparent(_ x: Bool) -> Bool {
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S9functions15testTransparent{{[_0-9a-zA-Z]*}}F : $@convention(thin) (Builtin.Int1) -> Builtin.Int1
+ // CHECK: apply [[FUNC]]({{%[0-9]+}}) : $@convention(thin) (Builtin.Int1) -> Builtin.Int1
+ return testTransparent(x)
+}
+
+// CHECK-LABEL: sil hidden [noinline] @$S9functions15noinline_calleeyyF : $@convention(thin) () -> ()
+@inline(never)
+func noinline_callee() {}
+
+// CHECK-LABEL: sil hidden [always_inline] @$S9functions20always_inline_calleeyyF : $@convention(thin) () -> ()
+@inline(__always)
+func always_inline_callee() {}
+
+// CHECK-LABEL: sil [serialized] [always_inline] @$S9functions27public_always_inline_calleeyyF : $@convention(thin) () -> ()
+@inline(__always)
+public func public_always_inline_callee() {}
+
+protocol AlwaysInline {
+ func alwaysInlined()
+}
+
+// CHECK-LABEL: sil hidden [always_inline] @$S9functions19AlwaysInlinedMemberV06alwaysC0{{[_0-9a-zA-Z]*}}F : $@convention(method) (AlwaysInlinedMember) -> () {
+
+// protocol witness for functions.AlwaysInline.alwaysInlined <A : functions.AlwaysInline>(functions.AlwaysInline.Self)() -> () in conformance functions.AlwaysInlinedMember : functions.AlwaysInline in functions
+// CHECK-LABEL: sil private [transparent] [thunk] [always_inline] @$S9functions19AlwaysInlinedMemberVAA0B6InlineA2aDP06alwaysC0{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AlwaysInline) (@in_guaranteed AlwaysInlinedMember) -> () {
+struct AlwaysInlinedMember : AlwaysInline {
+ @inline(__always)
+ func alwaysInlined() {}
+}
+
+// CHECK-LABEL: sil hidden [Onone] @$S9functions10onone_funcyyF : $@convention(thin) () -> ()
+@_optimize(none)
+func onone_func() {}
+
+// CHECK-LABEL: sil hidden [Ospeed] @$S9functions11ospeed_funcyyF : $@convention(thin) () -> ()
+@_optimize(speed)
+func ospeed_func() {}
+
+// CHECK-LABEL: sil hidden [Osize] @$S9functions10osize_funcyyF : $@convention(thin) () -> ()
+@_optimize(size)
+func osize_func() {}
+
+struct OptmodeTestStruct {
+
+ // CHECK-LABEL: sil hidden [Ospeed] @$S9functions17OptmodeTestStructV3fooyyF :
+ @_optimize(speed)
+ func foo() { }
+
+ // CHECK-LABEL: sil hidden [Ospeed] @$S9functions17OptmodeTestStructVACycfC :
+ @_optimize(speed)
+ init() { }
+
+ // CHECK-LABEL: sil hidden [Ospeed] @$S9functions17OptmodeTestStructV1xBi64_vg :
+ @_optimize(speed)
+ var x: Int { return getInt() }
+
+ // CHECK-LABEL: sil hidden [Ospeed] @$S9functions17OptmodeTestStructVyBi64_Bi64_cig :
+ @_optimize(speed)
+ subscript(l: Int) -> Int { return getInt() }
+}
+
+// CHECK-LABEL: sil hidden [_semantics "foo"] @$S9functions9semanticsyyF : $@convention(thin) () -> ()
+@_semantics("foo")
+func semantics() {}
+
+
+// <rdar://problem/17828355> curried final method on a class crashes in irgen
+final class r17828355Class {
+ func method(_ x : Int) {
+ var a : r17828355Class
+ var fn = a.method // currying a final method.
+ }
+}
+
+// The curry thunk for the method should not include a class_method instruction.
+// CHECK-LABEL: sil shared [thunk] @$S9functions14r17828355ClassC6method
+// CHECK: bb0(%0 : @guaranteed $r17828355Class):
+// CHECK-NEXT: // function_ref functions.r17828355Class.method(Builtin.Int64) -> ()
+// CHECK-NEXT: %1 = function_ref @$S9functions14r17828355ClassC6method{{[_0-9a-zA-Z]*}}F : $@convention(method) (Builtin.Int64, @guaranteed r17828355Class) -> ()
+// CHECK-NEXT: %2 = copy_value %0
+// CHECK-NEXT: partial_apply [callee_guaranteed] %1(%2) : $@convention(method) (Builtin.Int64, @guaranteed r17828355Class) -> ()
+// CHECK-NEXT: return
+
+
+
+// <rdar://problem/19981118> Swift 1.2 beta 2: Closures nested in closures copy, rather than reference, captured vars.
+func noescapefunc(f: () -> ()) {}
+func escapefunc(_ f : @escaping () -> ()) {}
+
+func testNoescape() {
+ // "a" must be captured by-box into noescapefunc because the inner closure
+ // could escape it.
+ var a = 0
+ noescapefunc {
+ escapefunc { a = 42 }
+ }
+ markUsed(a)
+}
+
+// CHECK-LABEL: functions.testNoescape() -> ()
+// CHECK-NEXT: sil hidden @$S9functions12testNoescapeyyF : $@convention(thin) () -> ()
+// CHECK: function_ref closure #1 () -> () in functions.testNoescape() -> ()
+// CHECK-NEXT: function_ref @$S9functions12testNoescapeyyFyyXEfU_ : $@convention(thin) (@guaranteed { var Int }) -> ()
+
+// Despite being a noescape closure, this needs to capture 'a' by-box so it can
+// be passed to the capturing closure.closure
+// CHECK: closure #1 () -> () in functions.testNoescape() -> ()
+// CHECK-NEXT: sil private @$S9functions12testNoescapeyyFyyXEfU_ : $@convention(thin) (@guaranteed { var Int }) -> () {
+
+
+
+func testNoescape2() {
+ // "a" must be captured by-box into noescapefunc because the inner closure
+ // could escape it. This also checks for when the outer closure captures it
+ // in a way that could be used with escape: the union of the two requirements
+ // doesn't allow a by-address capture.
+ var a = 0
+ noescapefunc {
+ escapefunc { a = 42 }
+ markUsed(a)
+ }
+ markUsed(a)
+}
+
+// CHECK-LABEL: sil hidden @$S9functions13testNoescape2yyF : $@convention(thin) () -> () {
+
+// CHECK: // closure #1 () -> () in functions.testNoescape2() -> ()
+// CHECK-NEXT: sil private @$S9functions13testNoescape2yyFyyXEfU_ : $@convention(thin) (@guaranteed { var Int }) -> () {
+
+// CHECK: // closure #1 () -> () in closure #1 () -> () in functions.testNoescape2() -> ()
+// CHECK-NEXT: sil private @$S9functions13testNoescape2yyFyyXEfU_yycfU_ : $@convention(thin) (@guaranteed { var Int }) -> () {
+
+enum PartialApplyEnumPayload<T, U> {
+ case Left(T)
+ case Right(U)
+}
+
+struct S {}
+struct C {}
+
+func partialApplyEnumCases(_ x: S, y: C) {
+ let left = PartialApplyEnumPayload<S, C>.Left
+ let left2 = left(S())
+
+ let right = PartialApplyEnumPayload<S, C>.Right
+ let right2 = right(C())
+}
+
+// CHECK-LABEL: sil shared [transparent] [thunk] @$S9functions23PartialApplyEnumPayloadO4Left{{[_0-9a-zA-Z]*}}F
+// CHECK: [[UNCURRIED:%.*]] = function_ref @$S9functions23PartialApplyEnumPayloadO4Left{{[_0-9a-zA-Z]*}}F
+// CHECK: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[UNCURRIED]]<T, U>(%0)
+// CHECK: [[CANONICAL_THUNK:%.*]] = function_ref @$Sx9functions23PartialApplyEnumPayloadOyxq_GIegir_xADIegnr_r0_lTR : $@convention(thin) <τ_0_0, τ_0_1> (@in_guaranteed τ_0_0, @guaranteed @callee_guaranteed (@in τ_0_0) -> @out PartialApplyEnumPayload<τ_0_0, τ_0_1>) -> @out PartialApplyEnumPayload<τ_0_0, τ_0_1>
+// CHECK: [[THUNKED_CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CANONICAL_THUNK]]<T, U>([[CLOSURE]])
+// CHECK: return [[THUNKED_CLOSURE]]
+// CHECK: } // end sil function '$S9functions23PartialApplyEnumPayloadO4Left{{[_0-9a-zA-Z]*}}F'
+
+// CHECK-LABEL: sil shared [transparent] [thunk] @$S9functions23PartialApplyEnumPayloadO5Right{{[_0-9a-zA-Z]*}}F
+// CHECK: [[UNCURRIED:%.*]] = function_ref @$S9functions23PartialApplyEnumPayloadO5Right{{[_0-9a-zA-Z]*}}F
+// CHECK: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[UNCURRIED]]<T, U>(%0)
+// CHECK: [[CANONICAL_THUNK:%.*]] = function_ref @$Sq_9functions23PartialApplyEnumPayloadOyxq_GIegir_q_ADIegnr_r0_lTR : $@convention(thin) <τ_0_0, τ_0_1> (@in_guaranteed τ_0_1, @guaranteed @callee_guaranteed (@in τ_0_1) -> @out PartialApplyEnumPayload<τ_0_0, τ_0_1>) -> @out PartialApplyEnumPayload<τ_0_0, τ_0_1>
+// CHECK: [[THUNKED_CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CANONICAL_THUNK]]<T, U>([[CLOSURE]])
+// CHECK: return [[THUNKED_CLOSURE]]
+// CHECK: } // end sil function '$S9functions23PartialApplyEnumPayloadO5Right{{[_0-9a-zA-Z]*}}F'
diff --git a/test/SILGen/plus_zero_generic_casts.swift b/test/SILGen/plus_zero_generic_casts.swift
new file mode 100644
index 0000000..1f857b0
--- /dev/null
+++ b/test/SILGen/plus_zero_generic_casts.swift
@@ -0,0 +1,290 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -enable-sil-ownership %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-%target-runtime %s
+
+protocol ClassBound : class {}
+protocol NotClassBound {}
+
+class C : ClassBound, NotClassBound {}
+struct S : NotClassBound {}
+struct Unloadable : NotClassBound { var x : NotClassBound }
+
+// CHECK-LABEL: sil hidden @$S13generic_casts020opaque_archetype_to_c1_D0{{[_0-9a-zA-Z]*}}F
+func opaque_archetype_to_opaque_archetype
+<T:NotClassBound, U>(_ t:T) -> U {
+ return t as! U
+ // CHECK: bb0([[RET:%.*]] : @trivial $*U, {{%.*}}: @trivial $*T):
+ // CHECK: unconditional_checked_cast_addr T in {{%.*}} : $*T to U in [[RET]] : $*U
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts020opaque_archetype_is_c1_D0{{[_0-9a-zA-Z]*}}F
+func opaque_archetype_is_opaque_archetype
+<T:NotClassBound, U>(_ t:T, u:U.Type) -> Bool {
+ return t is U
+ // CHECK: checked_cast_addr_br take_always T in [[VAL:%.*]] : $*T to U in [[DEST:%.*]] : $*U, [[YES:bb[0-9]+]], [[NO:bb[0-9]+]]
+ // CHECK: [[YES]]:
+ // CHECK: [[Y:%.*]] = integer_literal $Builtin.Int1, -1
+ // CHECK: destroy_addr [[DEST]]
+ // CHECK: br [[CONT:bb[0-9]+]]([[Y]] : $Builtin.Int1)
+ // CHECK: [[NO]]:
+ // CHECK: [[N:%.*]] = integer_literal $Builtin.Int1, 0
+ // CHECK: br [[CONT]]([[N]] : $Builtin.Int1)
+ // CHECK: [[CONT]]([[I1:%.*]] : @trivial $Builtin.Int1):
+ // -- apply the _getBool library fn
+ // CHECK-NEXT: function_ref Swift._getBool
+ // CHECK-NEXT: [[GETBOOL:%.*]] = function_ref @$Ss8_getBoolySbBi1_F :
+ // CHECK-NEXT: [[RES:%.*]] = apply [[GETBOOL]]([[I1]])
+ // -- we don't consume the checked value
+ // CHECK: return [[RES]] : $Bool
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts026opaque_archetype_to_class_D0{{[_0-9a-zA-Z]*}}F
+func opaque_archetype_to_class_archetype
+<T:NotClassBound, U:ClassBound> (_ t:T) -> U {
+ return t as! U
+ // CHECK: unconditional_checked_cast_addr T in {{%.*}} : $*T to U in [[DOWNCAST_ADDR:%.*]] : $*U
+ // CHECK: [[DOWNCAST:%.*]] = load [take] [[DOWNCAST_ADDR]] : $*U
+ // CHECK: return [[DOWNCAST]] : $U
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts026opaque_archetype_is_class_D0{{[_0-9a-zA-Z]*}}F
+func opaque_archetype_is_class_archetype
+<T:NotClassBound, U:ClassBound> (_ t:T, u:U.Type) -> Bool {
+ return t is U
+ // CHECK: copy_addr {{.*}} : $*T
+ // CHECK: checked_cast_addr_br take_always T in [[VAL:%.*]] : {{.*}} to U
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts019class_archetype_to_c1_D0{{[_0-9a-zA-Z]*}}F
+func class_archetype_to_class_archetype
+<T:ClassBound, U:ClassBound>(_ t:T) -> U {
+ return t as! U
+ // Error bridging can change the identity of class-constrained archetypes.
+ // CHECK-objc: unconditional_checked_cast_addr T in {{%.*}} : $*T to U in [[DOWNCAST_ADDR:%.*]] : $*U
+ // CHECK-objc: [[DOWNCAST:%.*]] = load [take] [[DOWNCAST_ADDR]]
+ // CHECK-objc: return [[DOWNCAST]] : $U
+
+ // CHECK-native: [[DOWNCAST:%.*]] = unconditional_checked_cast {{.*}} : $T to $U
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts019class_archetype_is_c1_D0{{[_0-9a-zA-Z]*}}F
+func class_archetype_is_class_archetype
+<T:ClassBound, U:ClassBound>(_ t:T, u:U.Type) -> Bool {
+ return t is U
+ // Error bridging can change the identity of class-constrained archetypes.
+ // CHECK-objc: checked_cast_addr_br {{.*}} T in {{%.*}} : $*T to U in {{%.*}} : $*U
+ // CHECK-native: checked_cast_br {{.*}} : $T to $U
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts38opaque_archetype_to_addr_only_concrete{{[_0-9a-zA-Z]*}}F
+func opaque_archetype_to_addr_only_concrete
+<T:NotClassBound> (_ t:T) -> Unloadable {
+ return t as! Unloadable
+ // CHECK: bb0([[RET:%.*]] : @trivial $*Unloadable, {{%.*}}: @trivial $*T):
+ // CHECK: unconditional_checked_cast_addr T in {{%.*}} : $*T to Unloadable in [[RET]] : $*Unloadable
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts38opaque_archetype_is_addr_only_concrete{{[_0-9a-zA-Z]*}}F
+func opaque_archetype_is_addr_only_concrete
+<T:NotClassBound> (_ t:T) -> Bool {
+ return t is Unloadable
+ // CHECK: checked_cast_addr_br take_always T in [[VAL:%.*]] : {{.*}} to Unloadable in
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts37opaque_archetype_to_loadable_concrete{{[_0-9a-zA-Z]*}}F
+func opaque_archetype_to_loadable_concrete
+<T:NotClassBound>(_ t:T) -> S {
+ return t as! S
+ // CHECK: unconditional_checked_cast_addr T in {{%.*}} : $*T to S in [[DOWNCAST_ADDR:%.*]] : $*S
+ // CHECK: [[DOWNCAST:%.*]] = load [trivial] [[DOWNCAST_ADDR]] : $*S
+ // CHECK: return [[DOWNCAST]] : $S
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts37opaque_archetype_is_loadable_concrete{{[_0-9a-zA-Z]*}}F
+func opaque_archetype_is_loadable_concrete
+<T:NotClassBound>(_ t:T) -> Bool {
+ return t is S
+ // CHECK: checked_cast_addr_br take_always T in {{%.*}} : $*T to S in
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts019class_archetype_to_C0{{[_0-9a-zA-Z]*}}F
+func class_archetype_to_class
+<T:ClassBound>(_ t:T) -> C {
+ return t as! C
+ // CHECK: [[DOWNCAST:%.*]] = unconditional_checked_cast {{%.*}} to $C
+ // CHECK: return [[DOWNCAST]] : $C
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts019class_archetype_is_C0{{[_0-9a-zA-Z]*}}F
+func class_archetype_is_class
+<T:ClassBound>(_ t:T) -> Bool {
+ return t is C
+ // CHECK: checked_cast_br {{%.*}} to $C
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts022opaque_existential_to_C10_archetype{{[_0-9a-zA-Z]*}}F
+func opaque_existential_to_opaque_archetype
+<T:NotClassBound>(_ p:NotClassBound) -> T {
+ return p as! T
+ // CHECK: bb0([[RET:%.*]] : @trivial $*T, [[ARG:%.*]] : @trivial $*NotClassBound):
+ // CHECK: [[TEMP:%.*]] = alloc_stack $NotClassBound
+ // CHECK-NEXT: copy_addr [[ARG]] to [initialization] [[TEMP]]
+ // CHECK-NEXT: unconditional_checked_cast_addr NotClassBound in [[TEMP]] : $*NotClassBound to T in [[RET]] : $*T
+ // CHECK-NEXT: dealloc_stack [[TEMP]]
+ // CHECK-NEXT: [[T0:%.*]] = tuple ()
+ // CHECK-NEXT: return [[T0]]
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts022opaque_existential_is_C10_archetype{{[_0-9a-zA-Z]*}}F
+func opaque_existential_is_opaque_archetype
+<T:NotClassBound>(_ p:NotClassBound, _: T) -> Bool {
+ return p is T
+ // CHECK: checked_cast_addr_br take_always NotClassBound in [[CONTAINER:%.*]] : {{.*}} to T in
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts37opaque_existential_to_class_archetype{{[_0-9a-zA-Z]*}}F
+func opaque_existential_to_class_archetype
+<T:ClassBound>(_ p:NotClassBound) -> T {
+ return p as! T
+ // CHECK: unconditional_checked_cast_addr NotClassBound in {{%.*}} : $*NotClassBound to T in [[DOWNCAST_ADDR:%.*]] : $*T
+ // CHECK: [[DOWNCAST:%.*]] = load [take] [[DOWNCAST_ADDR]] : $*T
+ // CHECK: return [[DOWNCAST]] : $T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts37opaque_existential_is_class_archetype{{[_0-9a-zA-Z]*}}F
+func opaque_existential_is_class_archetype
+<T:ClassBound>(_ p:NotClassBound, _: T) -> Bool {
+ return p is T
+ // CHECK: checked_cast_addr_br take_always NotClassBound in {{%.*}} : $*NotClassBound to T in
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts021class_existential_to_C10_archetype{{[_0-9a-zA-Z]*}}F
+func class_existential_to_class_archetype
+<T:ClassBound>(_ p:ClassBound) -> T {
+ return p as! T
+ // CHECK-objc: unconditional_checked_cast_addr ClassBound in {{%.*}} : $*ClassBound to T in [[DOWNCAST_ADDR:%.*]] : $*T
+ // CHECK-objc: [[DOWNCAST:%.*]] = load [take] [[DOWNCAST_ADDR]]
+ // CHECK-objc: return [[DOWNCAST]] : $T
+
+ // CHECK-native: [[DOWNCAST:%.*]] = unconditional_checked_cast {{.*}} : $ClassBound to $T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts021class_existential_is_C10_archetype{{[_0-9a-zA-Z]*}}F
+func class_existential_is_class_archetype
+<T:ClassBound>(_ p:ClassBound, _: T) -> Bool {
+ return p is T
+ // CHECK-objc: checked_cast_addr_br {{.*}} ClassBound in {{%.*}} : $*ClassBound to T in {{%.*}} : $*T
+ // CHECK-native: checked_cast_br {{.*}} : $ClassBound to $T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts40opaque_existential_to_addr_only_concrete{{[_0-9a-zA-Z]*}}F
+func opaque_existential_to_addr_only_concrete(_ p: NotClassBound) -> Unloadable {
+ return p as! Unloadable
+ // CHECK: bb0([[RET:%.*]] : @trivial $*Unloadable, {{%.*}}: @trivial $*NotClassBound):
+ // CHECK: unconditional_checked_cast_addr NotClassBound in {{%.*}} : $*NotClassBound to Unloadable in [[RET]] : $*Unloadable
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts40opaque_existential_is_addr_only_concrete{{[_0-9a-zA-Z]*}}F
+func opaque_existential_is_addr_only_concrete(_ p: NotClassBound) -> Bool {
+ return p is Unloadable
+ // CHECK: checked_cast_addr_br take_always NotClassBound in {{%.*}} : $*NotClassBound to Unloadable in
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts39opaque_existential_to_loadable_concrete{{[_0-9a-zA-Z]*}}F
+func opaque_existential_to_loadable_concrete(_ p: NotClassBound) -> S {
+ return p as! S
+ // CHECK: unconditional_checked_cast_addr NotClassBound in {{%.*}} : $*NotClassBound to S in [[DOWNCAST_ADDR:%.*]] : $*S
+ // CHECK: [[DOWNCAST:%.*]] = load [trivial] [[DOWNCAST_ADDR]] : $*S
+ // CHECK: return [[DOWNCAST]] : $S
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts39opaque_existential_is_loadable_concrete{{[_0-9a-zA-Z]*}}F
+func opaque_existential_is_loadable_concrete(_ p: NotClassBound) -> Bool {
+ return p is S
+ // CHECK: checked_cast_addr_br take_always NotClassBound in {{%.*}} : $*NotClassBound to S in
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts021class_existential_to_C0{{[_0-9a-zA-Z]*}}F
+func class_existential_to_class(_ p: ClassBound) -> C {
+ return p as! C
+ // CHECK: [[DOWNCAST:%.*]] = unconditional_checked_cast {{%.*}} to $C
+ // CHECK: return [[DOWNCAST]] : $C
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts021class_existential_is_C0{{[_0-9a-zA-Z]*}}F
+func class_existential_is_class(_ p: ClassBound) -> Bool {
+ return p is C
+ // CHECK: checked_cast_br {{%.*}} to $C
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts27optional_anyobject_to_classyAA1CCSgyXlSgF
+func optional_anyobject_to_class(_ p: AnyObject?) -> C? {
+ return p as? C
+ // CHECK: checked_cast_br {{%.*}} : $AnyObject to $C
+}
+
+// The below tests are to ensure we don't dig into an optional operand when
+// casting to a non-class archetype, as it could dynamically be an optional type.
+
+// CHECK-LABEL: sil hidden @$S13generic_casts32optional_any_to_opaque_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_to_opaque_archetype<T>(_ x: Any?) -> T {
+ return x as! T
+ // CHECK: bb0([[RET:%.*]] : @trivial $*T, {{%.*}} : @trivial $*Optional<Any>):
+ // CHECK: unconditional_checked_cast_addr Optional<Any> in {{%.*}} : $*Optional<Any> to T in [[RET]] : $*T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts46optional_any_conditionally_to_opaque_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_conditionally_to_opaque_archetype<T>(_ x: Any?) -> T? {
+ return x as? T
+ // CHECK: checked_cast_addr_br take_always Optional<Any> in {{%.*}} : $*Optional<Any> to T in {{%.*}} : $*T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts32optional_any_is_opaque_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_is_opaque_archetype<T>(_ x: Any?, _: T) -> Bool {
+ return x is T
+ // CHECK: checked_cast_addr_br take_always Optional<Any> in {{%.*}} : $*Optional<Any> to T in {{%.*}} : $*T
+}
+
+// But we can dig into at most one layer of the operand if it's
+// an optional archetype...
+
+// CHECK-LABEL: sil hidden @$S13generic_casts016optional_any_to_C17_opaque_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_to_optional_opaque_archetype<T>(_ x: Any?) -> T? {
+ return x as! T?
+ // CHECK: unconditional_checked_cast_addr Any in {{%.*}} : $*Any to T in {{%.*}} : $*T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts030optional_any_conditionally_to_C17_opaque_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_conditionally_to_optional_opaque_archetype<T>(_ x: Any?) -> T?? {
+ return x as? T?
+ // CHECK: checked_cast_addr_br take_always Any in {{%.*}} : $*Any to T in {{%.*}} : $*T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts016optional_any_is_C17_opaque_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_is_optional_opaque_archetype<T>(_ x: Any?, _: T) -> Bool {
+ return x is T?
+ // Because the levels of optional are the same, 'is' doesn't transform into an 'as?',
+ // so we just cast directly without digging into the optional operand.
+ // CHECK: checked_cast_addr_br take_always Optional<Any> in {{%.*}} : $*Optional<Any> to Optional<T> in {{%.*}} : $*Optional<T>
+}
+
+// And we can dig into the operand when casting to a class archetype, as it
+// cannot dynamically be optional...
+
+// CHECK-LABEL: sil hidden @$S13generic_casts31optional_any_to_class_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_to_class_archetype<T : AnyObject>(_ x: Any?) -> T {
+ return x as! T
+ // CHECK: unconditional_checked_cast_addr Any in {{%.*}} : $*Any to T in {{%.*}} : $*T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts45optional_any_conditionally_to_class_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_conditionally_to_class_archetype<T : AnyObject>(_ x: Any?) -> T? {
+ return x as? T
+ // CHECK: checked_cast_addr_br take_always Any in {{%.*}} : $*Any to T in {{%.*}} : $*T
+}
+
+// CHECK-LABEL: sil hidden @$S13generic_casts31optional_any_is_class_archetype{{[_0-9a-zA-Z]*}}F
+func optional_any_is_class_archetype<T : AnyObject>(_ x: Any?, _: T) -> Bool {
+ return x is T
+ // CHECK: checked_cast_addr_br take_always Any in {{%.*}} : $*Any to T in {{%.*}} : $*T
+}
+
diff --git a/test/SILGen/plus_zero_generic_closures.swift b/test/SILGen/plus_zero_generic_closures.swift
new file mode 100644
index 0000000..174912d
--- /dev/null
+++ b/test/SILGen/plus_zero_generic_closures.swift
@@ -0,0 +1,336 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -parse-stdlib -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+import Swift
+
+var zero: Int
+
+// CHECK-LABEL: sil hidden @$S16generic_closures0A21_nondependent_context{{[_0-9a-zA-Z]*}}F
+func generic_nondependent_context<T>(_ x: T, y: Int) -> Int {
+ func foo() -> Int { return y }
+
+ func bar() -> Int { return y }
+
+ // CHECK: [[FOO:%.*]] = function_ref @$S16generic_closures0A21_nondependent_context{{.*}} : $@convention(thin) (Int) -> Int
+ // CHECK: [[FOO_CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[FOO]](%1)
+ // CHECK: destroy_value [[FOO_CLOSURE]]
+ let _ = foo
+
+ // CHECK: [[BAR:%.*]] = function_ref @$S16generic_closures0A21_nondependent_context{{.*}} : $@convention(thin) (Int) -> Int
+ // CHECK: [[BAR_CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[BAR]](%1)
+ // CHECK: destroy_value [[BAR_CLOSURE]]
+ let _ = bar
+
+ // CHECK: [[FOO:%.*]] = function_ref @$S16generic_closures0A21_nondependent_context{{.*}} : $@convention(thin) (Int) -> Int
+ // CHECK: [[FOO_CLOSURE:%.*]] = apply [[FOO]]
+ _ = foo()
+
+ // CHECK: [[BAR:%.*]] = function_ref @$S16generic_closures0A21_nondependent_context{{.*}} : $@convention(thin) (Int) -> Int
+ // CHECK: [[BAR_CLOSURE:%.*]] = apply [[BAR]]
+
+ // CHECK: [[BAR_CLOSURE]]
+ return bar()
+}
+
+// CHECK-LABEL: sil hidden @$S16generic_closures0A8_capture{{[_0-9a-zA-Z]*}}F
+func generic_capture<T>(_ x: T) -> Any.Type {
+ func foo() -> Any.Type { return T.self }
+
+ // CHECK: [[FOO:%.*]] = function_ref @$S16generic_closures0A8_capture{{.*}} : $@convention(thin) <τ_0_0> () -> @thick Any.Type
+ // CHECK: [[FOO_CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[FOO]]<T>()
+ // CHECK: destroy_value [[FOO_CLOSURE]]
+ let _ = foo
+
+ // CHECK: [[FOO:%.*]] = function_ref @$S16generic_closures0A8_capture{{.*}} : $@convention(thin) <τ_0_0> () -> @thick Any.Type
+ // CHECK: [[FOO_CLOSURE:%.*]] = apply [[FOO]]<T>()
+
+ // CHECK: return [[FOO_CLOSURE]]
+ return foo()
+}
+
+// CHECK-LABEL: sil hidden @$S16generic_closures0A13_capture_cast{{[_0-9a-zA-Z]*}}F
+func generic_capture_cast<T>(_ x: T, y: Any) -> Bool {
+ func foo(_ a: Any) -> Bool { return a is T }
+
+ // CHECK: [[FOO:%.*]] = function_ref @$S16generic_closures0A13_capture_cast{{.*}} : $@convention(thin) <τ_0_0> (@in_guaranteed Any) -> Bool
+ // CHECK: [[FOO_CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[FOO]]<T>()
+ // CHECK: destroy_value [[FOO_CLOSURE]]
+ let _ = foo
+
+ // CHECK: [[FOO:%.*]] = function_ref @$S16generic_closures0A13_capture_cast{{.*}} : $@convention(thin) <τ_0_0> (@in_guaranteed Any) -> Bool
+ // CHECK: [[FOO_CLOSURE:%.*]] = apply [[FOO]]<T>([[ARG:%.*]])
+
+ // CHECK: return [[FOO_CLOSURE]]
+ return foo(y)
+}
+
+protocol Concept {
+ var sensical: Bool { get }
+}
+
+// CHECK-LABEL: sil hidden @$S16generic_closures0A22_nocapture_existential{{[_0-9a-zA-Z]*}}F
+func generic_nocapture_existential<T>(_ x: T, y: Concept) -> Bool {
+ func foo(_ a: Concept) -> Bool { return a.sensical }
+
+ // CHECK: [[FOO:%.*]] = function_ref @$S16generic_closures0A22_nocapture_existential{{.*}} : $@convention(thin) (@in_guaranteed Concept) -> Bool
+ // CHECK: [[FOO_CLOSURE:%.*]] = thin_to_thick_function [[FOO]]
+ // CHECK: destroy_value [[FOO_CLOSURE]]
+ let _ = foo
+
+ // CHECK: [[FOO:%.*]] = function_ref @$S16generic_closures0A22_nocapture_existential{{.*}} : $@convention(thin) (@in_guaranteed Concept) -> Bool
+ // CHECK: [[FOO_CLOSURE:%.*]] = apply [[FOO]]([[ARG:%.*]])
+
+ // CHECK: return [[FOO_CLOSURE]]
+ return foo(y)
+}
+
+// CHECK-LABEL: sil hidden @$S16generic_closures0A18_dependent_context{{[_0-9a-zA-Z]*}}F
+func generic_dependent_context<T>(_ x: T, y: Int) -> T {
+ func foo() -> T { return x }
+
+ // CHECK: [[FOO:%.*]] = function_ref @$S16generic_closures0A18_dependent_context{{.*}} : $@convention(thin) <τ_0_0> (@guaranteed <τ_0_0> { var τ_0_0 } <τ_0_0>) -> @out τ_0_0
+ // CHECK: [[FOO_CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[FOO]]<T>([[BOX:%.*]])
+ // CHECK: destroy_value [[FOO_CLOSURE]]
+ let _ = foo
+
+ // CHECK: [[FOO:%.*]] = function_ref @$S16generic_closures0A18_dependent_context{{.*}} : $@convention(thin) <τ_0_0> (@guaranteed <τ_0_0> { var τ_0_0 } <τ_0_0>) -> @out τ_0_0
+ // CHECK: [[FOO_CLOSURE:%.*]] = apply [[FOO]]<T>
+
+ // CHECK: return
+ return foo()
+}
+
+enum Optionable<Wrapped> {
+ case none
+ case some(Wrapped)
+}
+
+class NestedGeneric<U> {
+ class func generic_nondependent_context<T>(_ x: T, y: Int, z: U) -> Int {
+ func foo() -> Int { return y }
+ let _ = foo
+ return foo()
+ }
+
+ class func generic_dependent_inner_context<T>(_ x: T, y: Int, z: U) -> T {
+ func foo() -> T { return x }
+ let _ = foo
+ return foo()
+ }
+
+ class func generic_dependent_outer_context<T>(_ x: T, y: Int, z: U) -> U {
+ func foo() -> U { return z }
+ let _ = foo
+ return foo()
+ }
+
+ class func generic_dependent_both_contexts<T>(_ x: T, y: Int, z: U) -> (T, U) {
+ func foo() -> (T, U) { return (x, z) }
+ let _ = foo
+ return foo()
+ }
+
+ // CHECK-LABEL: sil hidden @$S16generic_closures13NestedGenericC20nested_reabstraction{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[REABSTRACT:%.*]] = function_ref @$SIeg_ytytIegnr_TR
+ // CHECK: partial_apply [callee_guaranteed] [[REABSTRACT]]
+ func nested_reabstraction<T>(_ x: T) -> Optionable<() -> ()> {
+ return .some({})
+ }
+}
+
+// <rdar://problem/15417773>
+// Ensure that nested closures capture the generic parameters of their nested
+// context.
+
+// CHECK: sil hidden @$S16generic_closures018nested_closure_in_A0yxxlF : $@convention(thin) <T> (@in_guaranteed T) -> @out T
+// CHECK: function_ref [[OUTER_CLOSURE:@\$S16generic_closures018nested_closure_in_A0yxxlFxyXEfU_]]
+// CHECK: sil private [[OUTER_CLOSURE]] : $@convention(thin) <T> (@inout_aliasable T) -> @out T
+// CHECK: function_ref [[INNER_CLOSURE:@\$S16generic_closures018nested_closure_in_A0yxxlFxyXEfU_xyXEfU_]]
+// CHECK: sil private [[INNER_CLOSURE]] : $@convention(thin) <T> (@inout_aliasable T) -> @out T {
+func nested_closure_in_generic<T>(_ x:T) -> T {
+ return { { x }() }()
+}
+
+// CHECK-LABEL: sil hidden @$S16generic_closures16local_properties{{[_0-9a-zA-Z]*}}F
+func local_properties<T>(_ t: inout T) {
+ var prop: T {
+ get {
+ return t
+ }
+ set {
+ t = newValue
+ }
+ }
+
+ // CHECK: [[GETTER_REF:%[0-9]+]] = function_ref [[GETTER_CLOSURE:@\$S16generic_closures16local_properties[_0-9a-zA-Z]*]] : $@convention(thin) <τ_0_0> (@inout_aliasable τ_0_0) -> @out τ_0_0
+ // CHECK: apply [[GETTER_REF]]
+ t = prop
+
+ // CHECK: [[SETTER_REF:%[0-9]+]] = function_ref [[SETTER_CLOSURE:@\$S16generic_closures16local_properties[_0-9a-zA-Z]*]] : $@convention(thin) <τ_0_0> (@in τ_0_0, @inout_aliasable τ_0_0) -> ()
+ // CHECK: apply [[SETTER_REF]]
+ prop = t
+
+ var prop2: T {
+ get {
+ return t
+ }
+ set {
+ // doesn't capture anything
+ }
+ }
+
+ // CHECK: [[GETTER2_REF:%[0-9]+]] = function_ref [[GETTER2_CLOSURE:@\$S16generic_closures16local_properties[_0-9a-zA-Z]*]] : $@convention(thin) <τ_0_0> (@inout_aliasable τ_0_0) -> @out τ_0_0
+ // CHECK: apply [[GETTER2_REF]]
+ t = prop2
+
+ // CHECK: [[SETTER2_REF:%[0-9]+]] = function_ref [[SETTER2_CLOSURE:@\$S16generic_closures16local_properties[_0-9a-zA-Z]*]] : $@convention(thin) <τ_0_0> (@in τ_0_0) -> ()
+ // CHECK: apply [[SETTER2_REF]]
+ prop2 = t
+}
+
+protocol Fooable {
+ static func foo() -> Bool
+}
+
+// <rdar://problem/16399018>
+func shmassert(_ f: @autoclosure () -> Bool) {}
+
+// CHECK-LABEL: sil hidden @$S16generic_closures08capture_A6_param{{[_0-9a-zA-Z]*}}F
+func capture_generic_param<A: Fooable>(_ x: A) {
+ shmassert(A.foo())
+}
+
+// Make sure we use the correct convention when capturing class-constrained
+// member types: <rdar://problem/24470533>
+class Class {}
+
+protocol HasClassAssoc { associatedtype Assoc : Class }
+
+// CHECK-LABEL: sil hidden @$S16generic_closures027captures_class_constrained_A0_1fyx_5AssocQzAEctAA08HasClassF0RzlF
+// CHECK: bb0([[ARG1:%.*]] : @trivial $*T, [[ARG2:%.*]] : @guaranteed $@callee_guaranteed (@guaranteed T.Assoc) -> @owned T.Assoc):
+// CHECK: [[GENERIC_FN:%.*]] = function_ref @$S16generic_closures027captures_class_constrained_A0_1fyx_5AssocQzAEctAA08HasClassF0RzlFA2EcycfU_
+// CHECK: [[ARG2_COPY:%.*]] = copy_value [[ARG2]]
+// CHECK: [[CONCRETE_FN:%.*]] = partial_apply [callee_guaranteed] [[GENERIC_FN]]<T>([[ARG2_COPY]])
+
+func captures_class_constrained_generic<T : HasClassAssoc>(_ x: T, f: @escaping (T.Assoc) -> T.Assoc) {
+ let _: () -> (T.Assoc) -> T.Assoc = { f }
+}
+
+// Make sure local generic functions can have captures
+
+// CHECK-LABEL: sil hidden @$S16generic_closures06outer_A01t1iyx_SitlF : $@convention(thin) <T> (@in_guaranteed T, Int) -> ()
+func outer_generic<T>(t: T, i: Int) {
+ func inner_generic_nocapture<U>(u: U) -> U {
+ return u
+ }
+
+ func inner_generic1<U>(u: U) -> Int {
+ return i
+ }
+
+ func inner_generic2<U>(u: U) -> T {
+ return t
+ }
+
+ let _: () -> () = inner_generic_nocapture
+ // CHECK: [[FN:%.*]] = function_ref @$S16generic_closures06outer_A01t1iyx_SitlF06inner_A10_nocaptureL_1uqd__qd___tr__lF : $@convention(thin) <τ_0_0><τ_1_0> (@in_guaranteed τ_1_0) -> @out τ_1_0
+ // CHECK: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[FN]]<T, ()>() : $@convention(thin) <τ_0_0><τ_1_0> (@in_guaranteed τ_1_0) -> @out τ_1_0
+ // CHECK: [[THUNK:%.*]] = function_ref @$SytytIegnr_Ieg_TR
+ // CHECK: [[THUNK_CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[CLOSURE]])
+ // CHECK: destroy_value [[THUNK_CLOSURE]]
+
+ // CHECK: [[FN:%.*]] = function_ref @$S16generic_closures06outer_A01t1iyx_SitlF06inner_A10_nocaptureL_1uqd__qd___tr__lF : $@convention(thin) <τ_0_0><τ_1_0> (@in_guaranteed τ_1_0) -> @out τ_1_0
+ // CHECK: [[RESULT:%.*]] = apply [[FN]]<T, T>({{.*}}) : $@convention(thin) <τ_0_0><τ_1_0> (@in_guaranteed τ_1_0) -> @out τ_1_0
+ _ = inner_generic_nocapture(u: t)
+
+ // CHECK: [[FN:%.*]] = function_ref @$S16generic_closures06outer_A01t1iyx_SitlF14inner_generic1L_1uSiqd___tr__lF : $@convention(thin) <τ_0_0><τ_1_0> (@in_guaranteed τ_1_0, Int) -> Int
+ // CHECK: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[FN]]<T, ()>(%1) : $@convention(thin) <τ_0_0><τ_1_0> (@in_guaranteed τ_1_0, Int) -> Int
+ // CHECK: [[THUNK:%.*]] = function_ref @$SytSiIegnd_SiIegd_TR
+ // CHECK: [[THUNK_CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[CLOSURE]])
+ // CHECK: destroy_value [[THUNK_CLOSURE]]
+ let _: () -> Int = inner_generic1
+
+ // CHECK: [[FN:%.*]] = function_ref @$S16generic_closures06outer_A01t1iyx_SitlF14inner_generic1L_1uSiqd___tr__lF : $@convention(thin) <τ_0_0><τ_1_0> (@in_guaranteed τ_1_0, Int) -> Int
+ // CHECK: [[RESULT:%.*]] = apply [[FN]]<T, T>({{.*}}) : $@convention(thin) <τ_0_0><τ_1_0> (@in_guaranteed τ_1_0, Int) -> Int
+ _ = inner_generic1(u: t)
+
+ // CHECK: [[FN:%.*]] = function_ref @$S16generic_closures06outer_A01t1iyx_SitlF14inner_generic2L_1uxqd___tr__lF : $@convention(thin) <τ_0_0><τ_1_0> (@in_guaranteed τ_1_0, @guaranteed <τ_0_0> { var τ_0_0 } <τ_0_0>) -> @out τ_0_0
+ // CHECK: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[FN]]<T, ()>([[ARG:%.*]]) : $@convention(thin) <τ_0_0><τ_1_0> (@in_guaranteed τ_1_0, @guaranteed <τ_0_0> { var τ_0_0 } <τ_0_0>) -> @out τ_0_0
+ // CHECK: [[THUNK:%.*]] = function_ref @$SytxIegnr_xIegr_lTR
+ // CHECK: [[THUNK_CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]<T>([[CLOSURE]])
+ // CHECK: destroy_value [[THUNK_CLOSURE]]
+ let _: () -> T = inner_generic2
+
+ // CHECK: [[FN:%.*]] = function_ref @$S16generic_closures06outer_A01t1iyx_SitlF14inner_generic2L_1uxqd___tr__lF : $@convention(thin) <τ_0_0><τ_1_0> (@in_guaranteed τ_1_0, @guaranteed <τ_0_0> { var τ_0_0 } <τ_0_0>) -> @out τ_0_0
+ // CHECK: [[RESULT:%.*]] = apply [[FN]]<T, T>({{.*}}) : $@convention(thin) <τ_0_0><τ_1_0> (@in_guaranteed τ_1_0, @guaranteed <τ_0_0> { var τ_0_0 } <τ_0_0>) -> @out τ_0_0
+ _ = inner_generic2(u: t)
+}
+
+// CHECK-LABEL: sil hidden @$S16generic_closures14outer_concrete1iySi_tF : $@convention(thin) (Int) -> ()
+func outer_concrete(i: Int) {
+ func inner_generic_nocapture<U>(u: U) -> U {
+ return u
+ }
+
+ func inner_generic<U>(u: U) -> Int {
+ return i
+ }
+
+ // CHECK: [[FN:%.*]] = function_ref @$S16generic_closures14outer_concrete1iySi_tF06inner_A10_nocaptureL_1uxx_tlF : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ // CHECK: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[FN]]<()>() : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ // CHECK: [[THUNK:%.*]] = function_ref @$SytytIegnr_Ieg_TR
+ // CHECK: [[THUNK_CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[CLOSURE]])
+ // CHECK: destroy_value [[THUNK_CLOSURE]]
+ let _: () -> () = inner_generic_nocapture
+
+ // CHECK: [[FN:%.*]] = function_ref @$S16generic_closures14outer_concrete1iySi_tF06inner_A10_nocaptureL_1uxx_tlF : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ // CHECK: [[RESULT:%.*]] = apply [[FN]]<Int>({{.*}}) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ _ = inner_generic_nocapture(u: i)
+
+ // CHECK: [[FN:%.*]] = function_ref @$S16generic_closures14outer_concrete1iySi_tF06inner_A0L_1uSix_tlF : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0, Int) -> Int
+ // CHECK: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[FN]]<()>(%0) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0, Int) -> Int
+ // CHECK: [[THUNK:%.*]] = function_ref @$SytSiIegnd_SiIegd_TR
+ // CHECK: [[THUNK_CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[CLOSURE]])
+ // CHECK: destroy_value [[THUNK_CLOSURE]]
+ let _: () -> Int = inner_generic
+
+ // CHECK: [[FN:%.*]] = function_ref @$S16generic_closures14outer_concrete1iySi_tF06inner_A0L_1uSix_tlF : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0, Int) -> Int
+ // CHECK: [[RESULT:%.*]] = apply [[FN]]<Int>({{.*}}) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0, Int) -> Int
+ _ = inner_generic(u: i)
+}
+
+// CHECK-LABEL: sil hidden @$S16generic_closures06mixed_A19_nongeneric_nesting1tyx_tlF : $@convention(thin) <T> (@in_guaranteed T) -> ()
+func mixed_generic_nongeneric_nesting<T>(t: T) {
+ func outer() {
+ func middle<U>(u: U) {
+ func inner() -> U {
+ return u
+ }
+ inner()
+ }
+ middle(u: 11)
+ }
+ outer()
+}
+
+// CHECK-LABEL: sil private @$S16generic_closures06mixed_A19_nongeneric_nesting1tyx_tlF5outerL_yylF : $@convention(thin) <T> () -> ()
+// CHECK-LABEL: sil private @$S16generic_closures06mixed_A19_nongeneric_nesting1tyx_tlF5outerL_yylF6middleL_1uyqd___tr__lF : $@convention(thin) <T><U> (@in_guaranteed U) -> ()
+// CHECK-LABEL: sil private @$S16generic_closures06mixed_A19_nongeneric_nesting1tyx_tlF5outerL_yylF6middleL_1uyqd___tr__lF5innerL_qd__yr__lF : $@convention(thin) <T><U> (@guaranteed <τ_0_0><τ_1_0> { var τ_1_0 } <T, U>) -> @out U
+
+protocol Doge {
+ associatedtype Nose : NoseProtocol
+}
+
+protocol NoseProtocol {
+ associatedtype Squeegee
+}
+
+protocol Doggo {}
+
+struct DogSnacks<A : Doggo> {}
+
+func capture_same_type_representative<Daisy: Doge, Roo: Doggo>(slobber: Roo, daisy: Daisy)
+ where Roo == Daisy.Nose.Squeegee {
+ var s = DogSnacks<Daisy.Nose.Squeegee>()
+ _ = { _ = s }
+}
diff --git a/test/SILGen/plus_zero_generic_property_base_lifetime.swift b/test/SILGen/plus_zero_generic_property_base_lifetime.swift
new file mode 100644
index 0000000..17f3823
--- /dev/null
+++ b/test/SILGen/plus_zero_generic_property_base_lifetime.swift
@@ -0,0 +1,118 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen %s -disable-objc-attr-requires-foundation-module -enable-sil-ownership | %FileCheck %s
+
+protocol ProtocolA: class {
+ var intProp: Int { get set }
+}
+
+protocol ProtocolB {
+ var intProp: Int { get }
+}
+
+@objc protocol ProtocolO: class {
+ var intProp: Int { get set }
+}
+
+
+// CHECK-LABEL: sil hidden @$S30generic_property_base_lifetime21getIntPropExistentialySiAA9ProtocolA_pF : $@convention(thin) (@guaranteed ProtocolA) -> Int {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $ProtocolA):
+// CHECK: [[PROJECTION:%.*]] = open_existential_ref [[ARG]]
+// CHECK: [[PROJECTION_COPY:%.*]] = copy_value [[PROJECTION]]
+// CHECK: [[BORROWED_PROJECTION_COPY:%.*]] = begin_borrow [[PROJECTION_COPY]]
+// CHECK: [[WITNESS_METHOD:%.*]] = witness_method $@opened({{.*}}) ProtocolA, #ProtocolA.intProp!getter.1 : {{.*}}, [[PROJECTION]]
+// CHECK: [[RESULT:%.*]] = apply [[WITNESS_METHOD]]<@opened{{.*}}>([[BORROWED_PROJECTION_COPY]])
+// CHECK: end_borrow [[BORROWED_PROJECTION_COPY]] from [[PROJECTION_COPY]]
+// CHECK: destroy_value [[PROJECTION_COPY]]
+// CHECK: return [[RESULT]]
+// CHECK: } // end sil function '$S30generic_property_base_lifetime21getIntPropExistentialySiAA9ProtocolA_pF'
+func getIntPropExistential(_ a: ProtocolA) -> Int {
+ return a.intProp
+}
+
+// CHECK-LABEL: sil hidden @$S30generic_property_base_lifetime21setIntPropExistentialyyAA9ProtocolA_pF : $@convention(thin) (@guaranteed ProtocolA) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $ProtocolA):
+// CHECK: [[PROJECTION:%.*]] = open_existential_ref [[ARG]]
+// CHECK: [[PROJECTION_COPY:%.*]] = copy_value [[PROJECTION]]
+// CHECK: [[BORROWED_PROJECTION_COPY:%.*]] = begin_borrow [[PROJECTION_COPY]]
+// CHECK: [[WITNESS_METHOD:%.*]] = witness_method $@opened({{.*}}) ProtocolA, #ProtocolA.intProp!setter.1 : {{.*}}, [[PROJECTION]]
+// CHECK: apply [[WITNESS_METHOD]]<@opened{{.*}}>({{%.*}}, [[BORROWED_PROJECTION_COPY]])
+// CHECK: end_borrow [[BORROWED_PROJECTION_COPY]] from [[PROJECTION_COPY]]
+// CHECK: destroy_value [[PROJECTION_COPY]]
+// CHECK: } // end sil function '$S30generic_property_base_lifetime21setIntPropExistentialyyAA9ProtocolA_pF'
+func setIntPropExistential(_ a: ProtocolA) {
+ a.intProp = 0
+}
+
+// CHECK-LABEL: sil hidden @$S30generic_property_base_lifetime17getIntPropGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $T):
+// CHECK: apply {{%.*}}<T>([[ARG]])
+// CHECK: } // end sil function '$S30generic_property_base_lifetime17getIntPropGeneric{{[_0-9a-zA-Z]*}}F'
+func getIntPropGeneric<T: ProtocolA>(_ a: T) -> Int {
+ return a.intProp
+}
+
+// CHECK-LABEL: sil hidden @$S30generic_property_base_lifetime17setIntPropGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $T):
+// CHECK: apply {{%.*}}<T>({{%.*}}, [[ARG]])
+func setIntPropGeneric<T: ProtocolA>(_ a: T) {
+ a.intProp = 0
+}
+
+// CHECK-LABEL: sil hidden @$S30generic_property_base_lifetime21getIntPropExistentialySiAA9ProtocolB_pF
+// CHECK: [[PROJECTION:%.*]] = open_existential_addr immutable_access %0
+// CHECK: [[STACK:%[0-9]+]] = alloc_stack $@opened({{".*"}}) ProtocolB
+// CHECK: copy_addr [[PROJECTION]] to [initialization] [[STACK]]
+// CHECK: apply {{%.*}}([[STACK]])
+// CHECK: destroy_addr [[STACK]]
+// CHECK: dealloc_stack [[STACK]]
+func getIntPropExistential(_ a: ProtocolB) -> Int {
+ return a.intProp
+}
+
+// CHECK-LABEL: sil hidden @$S30generic_property_base_lifetime17getIntPropGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: [[STACK:%[0-9]+]] = alloc_stack $T
+// CHECK: copy_addr %0 to [initialization] [[STACK]]
+// CHECK: apply {{%.*}}<T>([[STACK]])
+// CHECK: destroy_addr [[STACK]]
+// CHECK: dealloc_stack [[STACK]]
+func getIntPropGeneric<T: ProtocolB>(_ a: T) -> Int {
+ return a.intProp
+}
+
+// CHECK-LABEL: sil hidden @$S30generic_property_base_lifetime21getIntPropExistentialySiAA9ProtocolO_pF : $@convention(thin) (@guaranteed ProtocolO) -> Int {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $ProtocolO):
+// CHECK: [[PROJECTION:%.*]] = open_existential_ref [[ARG]]
+// CHECK: [[PROJECTION_COPY:%.*]] = copy_value [[PROJECTION]]
+// CHECK: [[METHOD:%.*]] = objc_method [[PROJECTION_COPY]] : $@opened({{.*}}) ProtocolO, #ProtocolO.intProp!getter.1.foreign : {{.*}}
+// CHECK: apply [[METHOD]]<@opened{{.*}}>([[PROJECTION_COPY]])
+// CHECK: destroy_value [[PROJECTION_COPY]]
+// CHECK: } // end sil function '$S30generic_property_base_lifetime21getIntPropExistentialySiAA9ProtocolO_pF'
+func getIntPropExistential(_ a: ProtocolO) -> Int {
+ return a.intProp
+}
+
+// CHECK-LABEL: sil hidden @$S30generic_property_base_lifetime21setIntPropExistentialyyAA9ProtocolO_pF : $@convention(thin) (@guaranteed ProtocolO) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $ProtocolO):
+// CHECK: [[PROJECTION:%.*]] = open_existential_ref [[ARG]]
+// CHECK: [[PROJECTION_COPY:%.*]] = copy_value [[PROJECTION]]
+// CHECK: [[METHOD:%.*]] = objc_method [[PROJECTION_COPY]] : $@opened({{.*}}) ProtocolO, #ProtocolO.intProp!setter.1.foreign : {{.*}}
+// CHECK: apply [[METHOD]]<@opened{{.*}}>({{.*}}, [[PROJECTION_COPY]])
+// CHECK: destroy_value [[PROJECTION_COPY]]
+// CHECK: } // end sil function '$S30generic_property_base_lifetime21setIntPropExistentialyyAA9ProtocolO_pF'
+func setIntPropExistential(_ a: ProtocolO) {
+ a.intProp = 0
+}
+
+// CHECK-LABEL: sil hidden @$S30generic_property_base_lifetime17getIntPropGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $T):
+// CHECK: apply {{%.*}}<T>([[ARG]])
+func getIntPropGeneric<T: ProtocolO>(_ a: T) -> Int {
+ return a.intProp
+}
+
+// CHECK-LABEL: sil hidden @$S30generic_property_base_lifetime17setIntPropGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $T):
+// CHECK: apply {{%.*}}<T>({{%.*}}, [[ARG]])
+func setIntPropGeneric<T: ProtocolO>(_ a: T) {
+ a.intProp = 0
+}
diff --git a/test/SILGen/plus_zero_generic_tuples.swift b/test/SILGen/plus_zero_generic_tuples.swift
new file mode 100644
index 0000000..d3053a1
--- /dev/null
+++ b/test/SILGen/plus_zero_generic_tuples.swift
@@ -0,0 +1,39 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -parse-as-library -enable-sil-ownership %s | %FileCheck %s
+
+
+func dup<T>(_ x: T) -> (T, T) { return (x,x) }
+// CHECK-LABEL: sil hidden @$S14generic_tuples3dup{{[_0-9a-zA-Z]*}}F
+// CHECK: ([[RESULT_0:%.*]] : @trivial $*T, [[RESULT_1:%.*]] : @trivial $*T, [[XVAR:%.*]] : @trivial $*T):
+// CHECK-NEXT: debug_value_addr [[XVAR]] : $*T, let, name "x"
+// CHECK-NEXT: copy_addr [[XVAR]] to [initialization] [[RESULT_0]]
+// CHECK-NEXT: copy_addr [[XVAR]] to [initialization] [[RESULT_1]]
+// CHECK-NEXT: [[T0:%.*]] = tuple ()
+// CHECK-NEXT: return [[T0]]
+
+// <rdar://problem/13822463>
+// Specializing a generic function on a tuple type changes the number of
+// SIL parameters, which caused a failure in the ownership conventions code.
+
+struct Blub {}
+// CHECK-LABEL: sil hidden @$S14generic_tuples3foo{{[_0-9a-zA-Z]*}}F
+func foo<T>(_ x: T) {}
+// CHECK-LABEL: sil hidden @$S14generic_tuples3bar{{[_0-9a-zA-Z]*}}F
+func bar(_ x: (Blub, Blub)) { foo(x) }
+
+
+// rdar://26279628
+// A type parameter constrained to be a concrete type must be handled
+// as that concrete type throughout SILGen. That's especially true
+// if it's constrained to be a tuple.
+
+protocol HasAssoc {
+ associatedtype A
+}
+extension HasAssoc where A == (Int, Int) {
+ func returnTupleAlias() -> A {
+ return (0, 0)
+ }
+}
+// CHECK-LABEL: sil hidden @$S14generic_tuples8HasAssocPAASi_Sit1ARtzrlE16returnTupleAliasSi_SityF : $@convention(method) <Self where Self : HasAssoc, Self.A == (Int, Int)> (@in_guaranteed Self) -> (Int, Int) {
+// CHECK: return {{.*}} : $(Int, Int)
diff --git a/test/SILGen/plus_zero_generic_witness.swift b/test/SILGen/plus_zero_generic_witness.swift
new file mode 100644
index 0000000..a450270
--- /dev/null
+++ b/test/SILGen/plus_zero_generic_witness.swift
@@ -0,0 +1,57 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+// RUN: %target-swift-frontend -emit-ir -enable-sil-ownership %s
+
+protocol Runcible {
+ func runce<A>(_ x: A)
+}
+
+// CHECK-LABEL: sil hidden @$S15generic_witness3foo{{[_0-9a-zA-Z]*}}F : $@convention(thin) <B where B : Runcible> (@in_guaranteed B) -> () {
+
+func foo<B : Runcible>(_ x: B) {
+ // CHECK: [[METHOD:%.*]] = witness_method $B, #Runcible.runce!1 : {{.*}} : $@convention(witness_method: Runcible) <τ_0_0 where τ_0_0 : Runcible><τ_1_0> (@in_guaranteed τ_1_0, @in_guaranteed τ_0_0) -> ()
+ // CHECK: apply [[METHOD]]<B, Int>
+ x.runce(5)
+}
+
+// CHECK-LABEL: sil hidden @$S15generic_witness3bar{{[_0-9a-zA-Z]*}}F : $@convention(thin) (@in_guaranteed Runcible) -> ()
+func bar(_ x: Runcible) {
+ var x = x
+ // CHECK: [[BOX:%.*]] = alloc_box ${ var Runcible }
+ // CHECK: [[TEMP:%.*]] = alloc_stack $Runcible
+ // CHECK: [[EXIST:%.*]] = open_existential_addr immutable_access [[TEMP]] : $*Runcible to $*[[OPENED:@opened(.*) Runcible]]
+ // CHECK: [[METHOD:%.*]] = witness_method $[[OPENED]], #Runcible.runce!1
+ // CHECK: apply [[METHOD]]<[[OPENED]], Int>
+ x.runce(5)
+}
+
+protocol Color {}
+
+protocol Ink {
+ associatedtype Paint
+}
+
+protocol Pen {}
+
+protocol Pencil : Pen {
+ associatedtype Stroke : Pen
+}
+
+protocol Medium {
+ associatedtype Texture : Ink
+
+ func draw<P : Pencil>(paint: Texture.Paint, pencil: P) where P.Stroke == Texture.Paint
+}
+
+struct Canvas<I : Ink> where I.Paint : Pen {
+ typealias Texture = I
+
+ func draw<P : Pencil>(paint: I.Paint, pencil: P) where P.Stroke == Texture.Paint { }
+}
+
+extension Canvas : Medium {}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15generic_witness6CanvasVyxGAA6MediumA2aEP4draw5paint6pencily6StrokeQyd___qd__tAA6PencilRd__7Texture_5PaintQZAKRSlFTW : $@convention(witness_method: Medium) <τ_0_0 where τ_0_0 : Ink><τ_1_0 where τ_1_0 : Pencil, τ_0_0.Paint == τ_1_0.Stroke> (@in_guaranteed τ_0_0.Paint, @in_guaranteed τ_1_0, @in_guaranteed Canvas<τ_0_0>) -> () {
+// CHECK: [[FN:%.*]] = function_ref @$S15generic_witness6CanvasV4draw5paint6pencily5PaintQz_qd__tAA6PencilRd__6StrokeQyd__AHRSlF : $@convention(method) <τ_0_0 where τ_0_0 : Ink><τ_1_0 where τ_1_0 : Pencil, τ_0_0.Paint == τ_1_0.Stroke> (@in_guaranteed τ_0_0.Paint, @in_guaranteed τ_1_0, Canvas<τ_0_0>) -> ()
+// CHECK: apply [[FN]]<τ_0_0, τ_1_0>({{.*}}) : $@convention(method) <τ_0_0 where τ_0_0 : Ink><τ_1_0 where τ_1_0 : Pencil, τ_0_0.Paint == τ_1_0.Stroke> (@in_guaranteed τ_0_0.Paint, @in_guaranteed τ_1_0, Canvas<τ_0_0>) -> ()
+// CHECK: }
diff --git a/test/SILGen/plus_zero_guaranteed_normal_args.swift b/test/SILGen/plus_zero_guaranteed_normal_args.swift
new file mode 100644
index 0000000..fdcec6c
--- /dev/null
+++ b/test/SILGen/plus_zero_guaranteed_normal_args.swift
@@ -0,0 +1,233 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -parse-as-library -module-name Swift -parse-stdlib -emit-silgen -enable-sil-ownership -enable-guaranteed-normal-arguments %s | %FileCheck %s
+
+// This test checks specific codegen related to normal arguments being passed at
+// +0. Eventually, it should be merged into normal SILGen tests.
+
+/////////////////
+// Fake Stdlib //
+/////////////////
+
+precedencegroup AssignmentPrecedence {
+ assignment: true
+}
+
+public protocol ExpressibleByNilLiteral {
+ init(nilLiteral: ())
+}
+
+protocol IteratorProtocol {
+ associatedtype Element
+ mutating func next() -> Element?
+}
+
+protocol Sequence {
+ associatedtype Element
+ associatedtype Iterator : IteratorProtocol where Iterator.Element == Element
+
+ func makeIterator() -> Iterator
+}
+
+enum Optional<T> {
+case none
+case some(T)
+}
+
+extension Optional : ExpressibleByNilLiteral {
+ public init(nilLiteral: ()) {
+ self = .none
+ }
+}
+
+func _diagnoseUnexpectedNilOptional(_filenameStart: Builtin.RawPointer,
+ _filenameLength: Builtin.Word,
+ _filenameIsASCII: Builtin.Int1,
+ _line: Builtin.Word) {
+ // This would usually contain an assert, but we don't need one since we are
+ // just emitting SILGen.
+}
+
+class Klass {
+ init() {}
+}
+
+struct Buffer {
+ var k: Klass
+ init(inK: Klass) {
+ k = inK
+ }
+}
+
+public typealias AnyObject = Builtin.AnyObject
+
+protocol Protocol {
+ associatedtype AssocType
+ static func useInput(_ input: Builtin.Int32, into processInput: (AssocType) -> ())
+}
+
+struct FakeArray<Element> {
+ // Just to make this type non-trivial
+ var k: Klass
+
+ // We are only interested in this being called. We are not interested in its
+ // implementation.
+ mutating func append(_ t: Element) {}
+}
+
+struct FakeDictionary<Key, Value> {
+}
+
+struct FakeDictionaryIterator<Key, Value> {
+ var dictionary: FakeDictionary<Key, Value>?
+
+ init(_ newDictionary: FakeDictionary<Key, Value>) {
+ dictionary = newDictionary
+ }
+}
+
+extension FakeDictionaryIterator : IteratorProtocol {
+ public typealias Element = (Key, Value)
+ public mutating func next() -> Element? {
+ return .none
+ }
+}
+
+extension FakeDictionary : Sequence {
+ public typealias Element = (Key, Value)
+ public typealias Iterator = FakeDictionaryIterator<Key, Value>
+ public func makeIterator() -> FakeDictionaryIterator<Key, Value> {
+ return FakeDictionaryIterator(self)
+ }
+}
+
+public struct Unmanaged<Instance : AnyObject> {
+ internal unowned(unsafe) var _value: Instance
+}
+
+///////////
+// Tests //
+///////////
+
+class KlassWithBuffer {
+ var buffer: Buffer
+
+ // Make sure that the allocating init forwards into the initializing init at +1.
+ // CHECK-LABEL: sil hidden @$Ss15KlassWithBufferC3inKABs0A0C_tcfC : $@convention(method) (@owned Klass, @thick KlassWithBuffer.Type) -> @owned KlassWithBuffer {
+ // CHECK: bb0([[ARG:%.*]] : @owned $Klass,
+ // CHECK: [[INITIALIZING_INIT:%.*]] = function_ref @$Ss15KlassWithBufferC3inKABs0A0C_tcfc : $@convention(method) (@owned Klass, @owned KlassWithBuffer) -> @owned KlassWithBuffer
+ // CHECK: apply [[INITIALIZING_INIT]]([[ARG]],
+ // CHECK: } // end sil function '$Ss15KlassWithBufferC3inKABs0A0C_tcfC'
+ init(inK: Klass = Klass()) {
+ buffer = Buffer(inK: inK)
+ }
+
+ // This test makes sure that we:
+ //
+ // 1. Are able to propagate a +0 value value buffer.k into a +0 value and that
+ // we then copy that +0 value into a +1 value, before we begin the epilog and
+ // then return that value.
+ // CHECK-LABEL: sil hidden @$Ss15KlassWithBufferC03getC14AsNativeObjectBoyF : $@convention(method) (@guaranteed KlassWithBuffer) -> @owned Builtin.NativeObject {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $KlassWithBuffer):
+ // CHECK: [[BUF_BOX:%.*]] = alloc_stack $Buffer
+ // CHECK: [[METHOD:%.*]] = class_method [[SELF]] : $KlassWithBuffer, #KlassWithBuffer.buffer!getter.1
+ // CHECK: [[BUF:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK: store [[BUF]] to [init] [[BUF_BOX]]
+ // CHECK: [[GEP:%.*]] = struct_element_addr [[BUF_BOX]] : $*Buffer, #Buffer.k
+ // CHECK: [[BUF_KLASS:%.*]] = load [copy] [[GEP]]
+ // CHECK: destroy_addr [[BUF_BOX]]
+ // CHECK: [[BORROWED_BUF_KLASS:%.*]] = begin_borrow [[BUF_KLASS]]
+ // CHECK: [[CASTED_BORROWED_BUF_KLASS:%.*]] = unchecked_ref_cast [[BORROWED_BUF_KLASS]]
+ // CHECK: [[COPY_CASTED_BORROWED_BUF_KLASS:%.*]] = copy_value [[CASTED_BORROWED_BUF_KLASS]]
+ // CHECK: end_borrow [[BORROWED_BUF_KLASS]]
+ // CHECK: destroy_value [[BUF_KLASS]]
+ // CHECK: return [[COPY_CASTED_BORROWED_BUF_KLASS]]
+ // CHECK: } // end sil function '$Ss15KlassWithBufferC03getC14AsNativeObjectBoyF'
+ func getBufferAsNativeObject() -> Builtin.NativeObject {
+ return Builtin.unsafeCastToNativeObject(buffer.k)
+ }
+}
+
+struct StructContainingBridgeObject {
+ var rawValue: Builtin.BridgeObject
+
+ // CHECK-LABEL: sil hidden @$Ss28StructContainingBridgeObjectV8swiftObjAByXl_tcfC : $@convention(method) (@owned AnyObject, @thin StructContainingBridgeObject.Type) -> @owned StructContainingBridgeObject {
+ // CHECK: bb0([[ARG:%.*]] : @owned $AnyObject,
+ // CHECK: [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]]
+ // CHECK: [[CASTED_ARG:%.*]] = unchecked_ref_cast [[BORROWED_ARG]] : $AnyObject to $Builtin.BridgeObject
+ // CHECK: [[COPY_CASTED_ARG:%.*]] = copy_value [[CASTED_ARG]]
+ // CHECK: assign [[COPY_CASTED_ARG]] to
+ // CHECK: } // end sil function '$Ss28StructContainingBridgeObjectV8swiftObjAByXl_tcfC'
+ init(swiftObj: AnyObject) {
+ rawValue = Builtin.reinterpretCast(swiftObj)
+ }
+}
+
+struct ReabstractionThunkTest : Protocol {
+ typealias AssocType = Builtin.Int32
+
+ static func useInput(_ input: Builtin.Int32, into processInput: (AssocType) -> ()) {
+ processInput(input)
+ }
+}
+
+// Make sure that we provide a cleanup to x properly before we pass it to
+// result.
+extension FakeDictionary {
+ // CHECK-LABEL: sil hidden @$Ss14FakeDictionaryV20makeSureToCopyTuplesyyF : $@convention(method) <Key, Value> (FakeDictionary<Key, Value>) -> () {
+ // CHECK: [[X:%.*]] = alloc_stack $(Key, Value), let, name "x"
+ // CHECK: [[INDUCTION_VAR:%.*]] = unchecked_take_enum_data_addr {{%.*}} : $*Optional<(Key, Value)>, #Optional.some!enumelt.1
+ // CHECK: [[INDUCTION_VAR_0:%.*]] = tuple_element_addr [[INDUCTION_VAR]] : $*(Key, Value), 0
+ // CHECK: [[INDUCTION_VAR_1:%.*]] = tuple_element_addr [[INDUCTION_VAR]] : $*(Key, Value), 1
+ // CHECK: [[X_0:%.*]] = tuple_element_addr [[X]] : $*(Key, Value), 0
+ // CHECK: [[X_1:%.*]] = tuple_element_addr [[X]] : $*(Key, Value), 1
+ // CHECK: copy_addr [take] [[INDUCTION_VAR_0]] to [initialization] [[X_0]]
+ // CHECK: copy_addr [take] [[INDUCTION_VAR_1]] to [initialization] [[X_1]]
+ // CHECK: [[X_0:%.*]] = tuple_element_addr [[X]] : $*(Key, Value), 0
+ // CHECK: [[X_1:%.*]] = tuple_element_addr [[X]] : $*(Key, Value), 1
+ // CHECK: [[TMP_X:%.*]] = alloc_stack $(Key, Value)
+ // CHECK: [[TMP_X_0:%.*]] = tuple_element_addr [[TMP_X]] : $*(Key, Value), 0
+ // CHECK: [[TMP_X_1:%.*]] = tuple_element_addr [[TMP_X]] : $*(Key, Value), 1
+ // CHECK: [[TMP_0:%.*]] = alloc_stack $Key
+ // CHECK: copy_addr [[X_0]] to [initialization] [[TMP_0]]
+ // CHECK: copy_addr [take] [[TMP_0]] to [initialization] [[TMP_X_0]]
+ // CHECK: [[TMP_1:%.*]] = alloc_stack $Value
+ // CHECK: copy_addr [[X_1]] to [initialization] [[TMP_1]]
+ // CHECK: copy_addr [take] [[TMP_1]] to [initialization] [[TMP_X_1]]
+ // CHECK: [[FUNC:%.*]] = function_ref @$Ss9FakeArrayV6appendyyxF : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @inout FakeArray<τ_0_0>) -> ()
+ // CHECK: apply [[FUNC]]<(Key, Value)>([[TMP_X]],
+ // CHECK: } // end sil function '$Ss14FakeDictionaryV20makeSureToCopyTuplesyyF'
+ func makeSureToCopyTuples() {
+ var result = FakeArray<Element>(k: Klass())
+ for x in self {
+ result.append(x)
+ }
+ }
+}
+
+extension Unmanaged {
+ // Just make sure that we do not crash on this.
+ func unsafeGuaranteedTest<Result>(
+ _ body: (Instance) -> Result
+ ) -> Result {
+ let (guaranteedInstance, token) = Builtin.unsafeGuaranteed(_value)
+ let result = body(guaranteedInstance)
+ Builtin.unsafeGuaranteedEnd(token)
+ return result
+ }
+}
+
+// Make sure that we properly forward x into memory and don't crash.
+public func forwardIntoMemory(fromNative x: AnyObject, y: Builtin.Word) -> Builtin.BridgeObject {
+ // y would normally be 0._builtinWordValue. We don't want to define that
+ // conformance.
+ let object = Builtin.castToBridgeObject(x, y)
+ return object
+}
+
+public struct StructWithOptionalAddressOnlyField<T> {
+ public let newValue: T?
+}
+
+func useStructWithOptionalAddressOnlyField<T>(t: T) -> StructWithOptionalAddressOnlyField<T> {
+ return StructWithOptionalAddressOnlyField<T>(newValue: t)
+}
diff --git a/test/SILGen/plus_zero_guaranteed_self.swift b/test/SILGen/plus_zero_guaranteed_self.swift
new file mode 100644
index 0000000..f8f4faa
--- /dev/null
+++ b/test/SILGen/plus_zero_guaranteed_self.swift
@@ -0,0 +1,557 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen %s -disable-objc-attr-requires-foundation-module -enable-sil-ownership | %FileCheck %s
+
+protocol Fooable {
+ init()
+ func foo(_ x: Int)
+ mutating func bar()
+ mutating func bas()
+
+ var prop1: Int { get set }
+ var prop2: Int { get set }
+ var prop3: Int { get nonmutating set }
+}
+
+protocol Barrable: class {
+ init()
+ func foo(_ x: Int)
+ func bar()
+ func bas()
+
+ var prop1: Int { get set }
+ var prop2: Int { get set }
+ var prop3: Int { get set }
+}
+
+struct S: Fooable {
+ var x: C? // Make the type nontrivial, so +0/+1 is observable.
+
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self1SV{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@thin S.Type) -> @owned S
+ init() {}
+ // TODO: Way too many redundant r/r pairs here. Should use +0 rvalues.
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self1SV3foo{{[_0-9a-zA-Z]*}}F : $@convention(method) (Int, @guaranteed S) -> () {
+ // CHECK: bb0({{.*}} [[SELF:%.*]] : @guaranteed $S):
+ // CHECK-NOT: copy_value [[SELF]]
+ // CHECK-NOT: destroy_value [[SELF]]
+ func foo(_ x: Int) {
+ self.foo(x)
+ }
+
+ func foooo(_ x: (Int, Bool)) {
+ self.foooo(x)
+ }
+
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self1SV3bar{{[_0-9a-zA-Z]*}}F : $@convention(method) (@inout S) -> ()
+ // CHECK: bb0([[SELF:%.*]] : @trivial $*S):
+ // CHECK-NOT: destroy_addr [[SELF]]
+ mutating func bar() {
+ self.bar()
+ }
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self1SV3bas{{[_0-9a-zA-Z]*}}F : $@convention(method) (@guaranteed S) -> ()
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $S):
+ // CHECK-NOT: copy_value [[SELF]]
+ // CHECK-NOT: destroy_value [[SELF]]
+ func bas() {
+ self.bas()
+ }
+
+ var prop1: Int = 0
+
+ // Getter for prop1
+ // CHECK-LABEL: sil hidden [transparent] @$S15guaranteed_self1SV5prop1Sivg : $@convention(method) (@guaranteed S) -> Int
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $S):
+ // CHECK-NOT: destroy_value [[SELF]]
+
+ // Setter for prop1
+ // CHECK-LABEL: sil hidden [transparent] @$S15guaranteed_self1SV5prop1Sivs : $@convention(method) (Int, @inout S) -> ()
+ // CHECK: bb0({{.*}} [[SELF_ADDR:%.*]] : @trivial $*S):
+ // CHECK-NOT: load [[SELF_ADDR]]
+ // CHECK-NOT: destroy_addr [[SELF_ADDR]]
+
+ // materializeForSet for prop1
+ // CHECK-LABEL: sil hidden [transparent] @$S15guaranteed_self1SV5prop1Sivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout S) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ // CHECK: bb0({{.*}} [[SELF_ADDR:%.*]] : @trivial $*S):
+ // CHECK-NOT: load [[SELF_ADDR]]
+ // CHECK-NOT: destroy_addr [[SELF_ADDR]]
+
+ var prop2: Int {
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self1SV5prop2Sivg : $@convention(method) (@guaranteed S) -> Int
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $S):
+ // CHECK-NOT: destroy_value [[SELF]]
+ get { return 0 }
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self1SV5prop2Sivs : $@convention(method) (Int, @inout S) -> ()
+ // CHECK-LABEL: sil hidden [transparent] @$S15guaranteed_self1SV5prop2Sivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout S) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ set { }
+ }
+
+ var prop3: Int {
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self1SV5prop3Sivg : $@convention(method) (@guaranteed S) -> Int
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $S):
+ // CHECK-NOT: destroy_value [[SELF]]
+ get { return 0 }
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self1SV5prop3Sivs : $@convention(method) (Int, @guaranteed S) -> ()
+ // CHECK: bb0({{.*}} [[SELF:%.*]] : @guaranteed $S):
+ // CHECK-NOT: destroy_value [[SELF]]
+ // CHECK-LABEL: sil hidden [transparent] @$S15guaranteed_self1SV5prop3Sivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed S) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ // CHECK: bb0({{.*}} [[SELF:%.*]] : @guaranteed $S):
+ // CHECK-NOT: destroy_value [[SELF]]
+ nonmutating set { }
+ }
+}
+
+// Witness thunk for nonmutating 'foo'
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self1SVAA7FooableA2aDP3foo{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: Fooable) (Int, @in_guaranteed S) -> () {
+// CHECK: bb0({{.*}} [[SELF_ADDR:%.*]] : @trivial $*S):
+// CHECK: [[SELF:%.*]] = load_borrow [[SELF_ADDR]]
+// CHECK-NOT: destroy_value [[SELF]]
+// CHECK-NOT: destroy_addr [[SELF_ADDR]]
+
+// Witness thunk for mutating 'bar'
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self1SVAA7FooableA2aDP3bar{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: Fooable) (@inout S) -> () {
+// CHECK: bb0([[SELF_ADDR:%.*]] : @trivial $*S):
+// CHECK-NOT: load [[SELF_ADDR]]
+// CHECK-NOT: destroy_addr [[SELF_ADDR]]
+
+// Witness thunk for 'bas', which is mutating in the protocol, but nonmutating
+// in the implementation
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self1SVAA7FooableA2aDP3bas{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: Fooable) (@inout S) -> ()
+// CHECK: bb0([[SELF_ADDR:%.*]] : @trivial $*S):
+// CHECK: [[SELF:%.*]] = load_borrow [[SELF_ADDR]]
+// CHECK: end_borrow [[SELF]]
+// CHECK-NOT: destroy_value [[SELF]]
+
+// Witness thunk for prop1 getter
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self1SVAA7FooableA2aDP5prop1SivgTW : $@convention(witness_method: Fooable) (@in_guaranteed S) -> Int
+// CHECK: bb0([[SELF_ADDR:%.*]] : @trivial $*S):
+// CHECK: [[SELF:%.*]] = load_borrow [[SELF_ADDR]]
+// CHECK-NOT: destroy_value [[SELF]]
+// CHECK-NOT: destroy_value [[SELF]]
+
+// Witness thunk for prop1 setter
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self1SVAA7FooableA2aDP5prop1SivsTW : $@convention(witness_method: Fooable) (Int, @inout S) -> () {
+// CHECK: bb0({{.*}} [[SELF_ADDR:%.*]] : @trivial $*S):
+// CHECK-NOT: destroy_addr [[SELF_ADDR]]
+
+// Witness thunk for prop1 materializeForSet
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self1SVAA7FooableA2aDP5prop1SivmTW : $@convention(witness_method: Fooable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout S) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0({{.*}} [[SELF_ADDR:%.*]] : @trivial $*S):
+// CHECK-NOT: destroy_addr [[SELF_ADDR]]
+
+// Witness thunk for prop2 getter
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self1SVAA7FooableA2aDP5prop2SivgTW : $@convention(witness_method: Fooable) (@in_guaranteed S) -> Int
+// CHECK: bb0([[SELF_ADDR:%.*]] : @trivial $*S):
+// CHECK: [[SELF:%.*]] = load_borrow [[SELF_ADDR]]
+// CHECK-NOT: destroy_value [[SELF]]
+// CHECK-NOT: destroy_addr [[SELF_ADDR]]
+
+// Witness thunk for prop2 setter
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self1SVAA7FooableA2aDP5prop2SivsTW : $@convention(witness_method: Fooable) (Int, @inout S) -> () {
+// CHECK: bb0({{.*}} [[SELF_ADDR:%.*]] : @trivial $*S):
+// CHECK-NOT: destroy_addr [[SELF_ADDR]]
+
+// Witness thunk for prop2 materializeForSet
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self1SVAA7FooableA2aDP5prop2SivmTW : $@convention(witness_method: Fooable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout S) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0({{.*}} [[SELF_ADDR:%.*]] : @trivial $*S):
+// CHECK-NOT: destroy_addr [[SELF_ADDR]]
+
+// Witness thunk for prop3 getter
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self1SVAA7FooableA2aDP5prop3SivgTW : $@convention(witness_method: Fooable) (@in_guaranteed S) -> Int
+// CHECK: bb0([[SELF_ADDR:%.*]] : @trivial $*S):
+// CHECK: [[SELF:%.*]] = load_borrow [[SELF_ADDR]]
+// CHECK-NOT: destroy_value [[SELF]]
+// CHECK-NOT: destroy_addr [[SELF_ADDR]]
+
+// Witness thunk for prop3 nonmutating setter
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self1SVAA7FooableA2aDP5prop3SivsTW : $@convention(witness_method: Fooable) (Int, @in_guaranteed S) -> ()
+// CHECK: bb0({{.*}} [[SELF_ADDR:%.*]] : @trivial $*S):
+// CHECK: [[SELF:%.*]] = load_borrow [[SELF_ADDR]]
+// CHECK-NOT: destroy_value [[SELF]]
+// CHECK-NOT: destroy_addr [[SELF_ADDR]]
+
+// Witness thunk for prop3 nonmutating materializeForSet
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self1SVAA7FooableA2aDP5prop3SivmTW : $@convention(witness_method: Fooable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed S) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+// CHECK: bb0({{.*}} [[SELF_ADDR:%.*]] : @trivial $*S):
+// CHECK: [[SELF:%.*]] = load_borrow [[SELF_ADDR]]
+// CHECK-NOT: destroy_value [[SELF]]
+// CHECK-NOT: destroy_addr [[SELF_ADDR]]
+// CHECK: } // end sil function '$S15guaranteed_self1SVAA7FooableA2aDP5prop3SivmTW'
+
+//
+// TODO: Expected output for the other cases
+//
+
+struct AO<T>: Fooable {
+ var x: T?
+
+ init() {}
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self2AOV3foo{{[_0-9a-zA-Z]*}}F : $@convention(method) <T> (Int, @in_guaranteed AO<T>) -> ()
+ // CHECK: bb0({{.*}} [[SELF_ADDR:%.*]] : @trivial $*AO<T>):
+ // CHECK: apply {{.*}} [[SELF_ADDR]]
+ // CHECK-NOT: destroy_addr [[SELF_ADDR]]
+ // CHECK: }
+ func foo(_ x: Int) {
+ self.foo(x)
+ }
+ mutating func bar() {
+ self.bar()
+ }
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self2AOV3bas{{[_0-9a-zA-Z]*}}F : $@convention(method) <T> (@in_guaranteed AO<T>) -> ()
+ // CHECK: bb0([[SELF_ADDR:%.*]] : @trivial $*AO<T>):
+ // CHECK-NOT: destroy_addr [[SELF_ADDR]]
+ func bas() {
+ self.bas()
+ }
+
+
+ var prop1: Int = 0
+ var prop2: Int {
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self2AOV5prop2Sivg : $@convention(method) <T> (@in_guaranteed AO<T>) -> Int {
+ // CHECK: bb0([[SELF_ADDR:%.*]] : @trivial $*AO<T>):
+ // CHECK-NOT: destroy_addr [[SELF_ADDR]]
+ get { return 0 }
+ set { }
+ }
+ var prop3: Int {
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self2AOV5prop3Sivg : $@convention(method) <T> (@in_guaranteed AO<T>) -> Int
+ // CHECK: bb0([[SELF_ADDR:%.*]] : @trivial $*AO<T>):
+ // CHECK-NOT: destroy_addr [[SELF_ADDR]]
+ get { return 0 }
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self2AOV5prop3Sivs : $@convention(method) <T> (Int, @in_guaranteed AO<T>) -> ()
+ // CHECK: bb0({{.*}} [[SELF_ADDR:%.*]] : @trivial $*AO<T>):
+ // CHECK-NOT: destroy_addr [[SELF_ADDR]]
+ // CHECK-LABEL: sil hidden [transparent] @$S15guaranteed_self2AOV5prop3Sivm : $@convention(method) <T> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed AO<T>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ // CHECK: bb0({{.*}} [[SELF_ADDR:%.*]] : @trivial $*AO<T>):
+ // CHECK-NOT: destroy_addr [[SELF_ADDR]]
+ // CHECK: }
+ nonmutating set { }
+ }
+}
+
+// Witness for nonmutating 'foo'
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self2AOVyxGAA7FooableA2aEP3foo{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: Fooable) <τ_0_0> (Int, @in_guaranteed AO<τ_0_0>) -> ()
+// CHECK: bb0({{.*}} [[SELF_ADDR:%.*]] : @trivial $*AO<τ_0_0>):
+// CHECK: apply {{.*}} [[SELF_ADDR]]
+// CHECK-NOT: destroy_addr [[SELF_ADDR]]
+
+// Witness for 'bar', which is mutating in protocol but nonmutating in impl
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15guaranteed_self2AOVyxGAA7FooableA2aEP3bar{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: Fooable) <τ_0_0> (@inout AO<τ_0_0>) -> ()
+// CHECK: bb0([[SELF_ADDR:%.*]] : @trivial $*AO<τ_0_0>):
+// -- NB: This copy is not necessary, since we're willing to assume an inout
+// parameter is not mutably aliased.
+// CHECK: apply {{.*}}([[SELF_ADDR]])
+// CHECK-NOT: destroy_addr [[SELF_ADDR]]
+
+class C: Fooable, Barrable {
+ // Allocating initializer
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self1CC{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@thick C.Type) -> @owned C
+ // CHECK: [[SELF1:%.*]] = alloc_ref $C
+ // CHECK-NOT: [[SELF1]]
+ // CHECK: [[SELF2:%.*]] = apply {{.*}}([[SELF1]])
+ // CHECK-NOT: [[SELF2]]
+ // CHECK: return [[SELF2]]
+
+ // Initializing constructors still have the +1 in, +1 out convention.
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self1CC{{[_0-9a-zA-Z]*}}fc : $@convention(method) (@owned C) -> @owned C {
+ // CHECK: bb0([[SELF:%.*]] : @owned $C):
+ // CHECK: [[MARKED_SELF:%.*]] = mark_uninitialized [rootself] [[SELF]]
+ // CHECK: [[MARKED_SELF_RESULT:%.*]] = copy_value [[MARKED_SELF]]
+ // CHECK: destroy_value [[MARKED_SELF]]
+ // CHECK: return [[MARKED_SELF_RESULT]]
+ // CHECK: } // end sil function '$S15guaranteed_self1CC{{[_0-9a-zA-Z]*}}fc'
+
+ // @objc thunk for initializing constructor
+ // CHECK-LABEL: sil hidden [thunk] @$S15guaranteed_self1CC{{[_0-9a-zA-Z]*}}fcTo : $@convention(objc_method) (@owned C) -> @owned C
+ // CHECK: bb0([[SELF:%.*]] : @owned $C):
+ // CHECK-NOT: copy_value [[SELF]]
+ // CHECK: [[SELF2:%.*]] = apply {{%.*}}([[SELF]])
+ // CHECK-NOT: destroy_value [[SELF]]
+ // CHECK-NOT: destroy_value [[SELF2]]
+ // CHECK: return [[SELF2]]
+ // CHECK: } // end sil function '$S15guaranteed_self1CC{{[_0-9a-zA-Z]*}}fcTo'
+ @objc required init() {}
+
+
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self1CC3foo{{[_0-9a-zA-Z]*}}F : $@convention(method) (Int, @guaranteed C) -> ()
+ // CHECK: bb0({{.*}} [[SELF:%.*]] : @guaranteed $C):
+ // CHECK-NOT: copy_value
+ // CHECK-NOT: destroy_value
+ // CHECK: } // end sil function '$S15guaranteed_self1CC3foo{{[_0-9a-zA-Z]*}}F'
+
+ // CHECK-LABEL: sil hidden [thunk] @$S15guaranteed_self1CC3foo{{[_0-9a-zA-Z]*}}FTo : $@convention(objc_method) (Int, C) -> () {
+ // CHECK: bb0({{.*}} [[SELF:%.*]] : @unowned $C):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: apply {{.*}}({{.*}}, [[BORROWED_SELF_COPY]])
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK-NOT: destroy_value [[SELF_COPY]]
+ // CHECK-NOT: destroy_value [[SELF]]
+ // CHECK: } // end sil function '$S15guaranteed_self1CC3foo{{[_0-9a-zA-Z]*}}FTo'
+ @objc func foo(_ x: Int) {
+ self.foo(x)
+ }
+ @objc func bar() {
+ self.bar()
+ }
+ @objc func bas() {
+ self.bas()
+ }
+
+ // CHECK-LABEL: sil hidden [transparent] [thunk] @$S15guaranteed_self1CC5prop1SivgTo : $@convention(objc_method) (C) -> Int
+ // CHECK: bb0([[SELF:%.*]] : @unowned $C):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: apply {{.*}}([[BORROWED_SELF_COPY]])
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK-NOT: destroy_value [[SELF]]
+ // CHECK-NOT: destroy_value [[SELF_COPY]]
+
+ // CHECK-LABEL: sil hidden [transparent] [thunk] @$S15guaranteed_self1CC5prop1SivsTo : $@convention(objc_method) (Int, C) -> ()
+ // CHECK: bb0({{.*}} [[SELF:%.*]] : @unowned $C):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: apply {{.*}} [[BORROWED_SELF_COPY]]
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK-NOT: destroy_value [[SELF_COPY]]
+ // CHECK-NOT: destroy_value [[SELF]]
+ // CHECK: }
+ @objc var prop1: Int = 0
+ @objc var prop2: Int {
+ get { return 0 }
+ set {}
+ }
+ @objc var prop3: Int {
+ get { return 0 }
+ set {}
+ }
+
+}
+
+class D: C {
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self1DC{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@thick D.Type) -> @owned D
+ // CHECK: [[SELF1:%.*]] = alloc_ref $D
+ // CHECK-NOT: [[SELF1]]
+ // CHECK: [[SELF2:%.*]] = apply {{.*}}([[SELF1]])
+ // CHECK-NOT: [[SELF1]]
+ // CHECK-NOT: [[SELF2]]
+ // CHECK: return [[SELF2]]
+
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self1DC{{[_0-9a-zA-Z]*}}fc : $@convention(method) (@owned D) -> @owned D
+ // CHECK: bb0([[SELF:%.*]] : @owned $D):
+ // CHECK: [[SELF_BOX:%.*]] = alloc_box ${ var D }
+ // CHECK-NEXT: [[MARKED_SELF_BOX:%.*]] = mark_uninitialized [derivedself] [[SELF_BOX]]
+ // CHECK-NEXT: [[PB:%.*]] = project_box [[MARKED_SELF_BOX]]
+ // CHECK-NEXT: store [[SELF]] to [init] [[PB]]
+ // CHECK-NOT: [[PB]]
+ // CHECK: [[SELF1:%.*]] = load [take] [[PB]]
+ // CHECK-NEXT: [[SUPER1:%.*]] = upcast [[SELF1]]
+ // CHECK-NOT: [[PB]]
+ // CHECK: [[SUPER2:%.*]] = apply {{.*}}([[SUPER1]])
+ // CHECK-NEXT: [[SELF2:%.*]] = unchecked_ref_cast [[SUPER2]]
+ // CHECK-NEXT: store [[SELF2]] to [init] [[PB]]
+ // CHECK-NOT: [[PB]]
+ // CHECK-NOT: [[SELF1]]
+ // CHECK-NOT: [[SUPER1]]
+ // CHECK-NOT: [[SELF2]]
+ // CHECK-NOT: [[SUPER2]]
+ // CHECK: [[SELF_FINAL:%.*]] = load [copy] [[PB]]
+ // CHECK-NEXT: destroy_value [[MARKED_SELF_BOX]]
+ // CHECK-NEXT: return [[SELF_FINAL]]
+ required init() {
+ super.init()
+ }
+
+ // CHECK-LABEL: sil shared [transparent] [serializable] [thunk] @$S15guaranteed_self1DC3foo{{[_0-9a-zA-Z]*}}FTD : $@convention(method) (Int, @guaranteed D) -> ()
+ // CHECK: bb0({{.*}} [[SELF:%.*]] : @guaranteed $D):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK-NOT: destroy_value [[SELF_COPY]]
+ // CHECK-NOT: destroy_value [[SELF]]
+ // CHECK: }
+ dynamic override func foo(_ x: Int) {
+ self.foo(x)
+ }
+}
+
+func S_curryThunk(_ s: S) -> ((S) -> (Int) -> ()/*, Int -> ()*/) {
+ return (S.foo /*, s.foo*/)
+}
+
+func AO_curryThunk<T>(_ ao: AO<T>) -> ((AO<T>) -> (Int) -> ()/*, Int -> ()*/) {
+ return (AO.foo /*, ao.foo*/)
+}
+
+// ----------------------------------------------------------------------------
+// Make sure that we properly translate in_guaranteed parameters
+// correctly if we are asked to.
+// ----------------------------------------------------------------------------
+
+
+// CHECK-LABEL: sil shared [transparent] [serialized] [thunk] @$S15guaranteed_self9FakeArrayVAA8SequenceA2aDP17_constrainElement{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: Sequence) (@in_guaranteed FakeElement, @in_guaranteed FakeArray) -> () {
+// CHECK: bb0([[ARG0_PTR:%.*]] : @trivial $*FakeElement, [[ARG1_PTR:%.*]] : @trivial $*FakeArray):
+// CHECK: [[ARG0:%.*]] = load [trivial] [[ARG0_PTR]]
+// CHECK: function_ref (extension in guaranteed_self):guaranteed_self.SequenceDefaults._constrainElement
+// CHECK: [[FUN:%.*]] = function_ref @{{.*}}
+// CHECK: apply [[FUN]]<FakeArray>([[ARG0]], [[ARG1_PTR]])
+
+class Z {}
+
+public struct FakeGenerator {}
+public struct FakeArray {
+ var z = Z()
+}
+public struct FakeElement {}
+
+public protocol FakeGeneratorProtocol {
+ associatedtype Element
+}
+
+extension FakeGenerator : FakeGeneratorProtocol {
+ public typealias Element = FakeElement
+}
+
+public protocol SequenceDefaults {
+ associatedtype Element
+ associatedtype Generator : FakeGeneratorProtocol
+}
+
+extension SequenceDefaults {
+ public func _constrainElement(_: FakeGenerator.Element) {}
+}
+
+public protocol Sequence : SequenceDefaults {
+ func _constrainElement(_: Element)
+}
+
+
+extension FakeArray : Sequence {
+ public typealias Element = FakeElement
+ public typealias Generator = FakeGenerator
+
+ func _containsElement(_: Element) {}
+}
+
+// -----------------------------------------------------------------------------
+// Make sure that we do not emit extra copy_values when accessing let fields of
+// guaranteed parameters.
+// -----------------------------------------------------------------------------
+
+class Kraken {
+ func enrage() {}
+}
+
+func destroyShip(_ k: Kraken) {}
+
+class LetFieldClass {
+ let letk = Kraken()
+ var vark = Kraken()
+
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self13LetFieldClassC10letkMethod{{[_0-9a-zA-Z]*}}F : $@convention(method) (@guaranteed LetFieldClass) -> () {
+ // CHECK: bb0([[CLS:%.*]] : @guaranteed $LetFieldClass):
+ // CHECK: [[KRAKEN_ADDR:%.*]] = ref_element_addr [[CLS]] : $LetFieldClass, #LetFieldClass.letk
+ // CHECK-NEXT: [[WRITE:%.*]] = begin_access [read] [dynamic] [[KRAKEN_ADDR]] : $*Kraken
+ // CHECK-NEXT: [[KRAKEN:%.*]] = load_borrow [[WRITE]]
+ // CHECK-NEXT: end_access [[WRITE]] : $*Kraken
+ // CHECK-NEXT: [[KRAKEN_METH:%.*]] = class_method [[KRAKEN]]
+ // CHECK-NEXT: apply [[KRAKEN_METH]]([[KRAKEN]])
+ // CHECK-NEXT: end_borrow [[KRAKEN]] from [[WRITE]]
+ // CHECK-NEXT: [[KRAKEN_ADDR:%.*]] = ref_element_addr [[CLS]] : $LetFieldClass, #LetFieldClass.letk
+ // CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[KRAKEN_ADDR]] : $*Kraken
+ // CHECK-NEXT: [[KRAKEN:%.*]] = load [copy] [[READ]]
+ // CHECK-NEXT: end_access [[READ]] : $*Kraken
+ // CHECK: [[BORROWED_KRAKEN:%.*]] = begin_borrow [[KRAKEN]]
+ // CHECK: [[DESTROY_SHIP_FUN:%.*]] = function_ref @$S15guaranteed_self11destroyShipyyAA6KrakenCF : $@convention(thin) (@guaranteed Kraken) -> ()
+ // CHECK-NEXT: apply [[DESTROY_SHIP_FUN]]([[BORROWED_KRAKEN]])
+ // CHECK-NEXT: end_borrow [[BORROWED_KRAKEN]] from [[KRAKEN]]
+ // CHECK-NEXT: [[KRAKEN_BOX:%.*]] = alloc_box ${ var Kraken }
+ // CHECK-NEXT: [[PB:%.*]] = project_box [[KRAKEN_BOX]]
+ // CHECK-NEXT: [[KRAKEN_ADDR:%.*]] = ref_element_addr [[CLS]] : $LetFieldClass, #LetFieldClass.letk
+ // CHECK-NEXT: [[READ:%.*]] = begin_access [read] [dynamic] [[KRAKEN_ADDR]] : $*Kraken
+ // CHECK-NEXT: [[KRAKEN2:%.*]] = load [copy] [[READ]]
+ // CHECK-NEXT: end_access [[READ]] : $*Kraken
+ // CHECK-NEXT: store [[KRAKEN2]] to [init] [[PB]]
+ // CHECK-NEXT: [[READ:%.*]] = begin_access [read] [unknown] [[PB]] : $*Kraken
+ // CHECK-NEXT: [[KRAKEN_COPY:%.*]] = load [copy] [[READ]]
+ // CHECK-NEXT: end_access [[READ]] : $*Kraken
+ // CHECK-NEXT: [[BORROWED_KRAKEN_COPY:%.*]] = begin_borrow [[KRAKEN_COPY]]
+ // CHECK: [[DESTROY_SHIP_FUN:%.*]] = function_ref @$S15guaranteed_self11destroyShipyyAA6KrakenCF : $@convention(thin) (@guaranteed Kraken) -> ()
+ // CHECK-NEXT: apply [[DESTROY_SHIP_FUN]]([[BORROWED_KRAKEN_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_KRAKEN_COPY]]
+ // CHECK-NEXT: destroy_value [[KRAKEN_COPY]]
+ // CHECK-NEXT: destroy_value [[KRAKEN_BOX]]
+ // CHECK-NEXT: destroy_value [[KRAKEN]]
+ // CHECK-NEXT: tuple
+ // CHECK-NEXT: return
+ func letkMethod() {
+ letk.enrage()
+ let ll = letk
+ destroyShip(ll)
+ var lv = letk
+ destroyShip(lv)
+ }
+
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self13LetFieldClassC10varkMethod{{[_0-9a-zA-Z]*}}F : $@convention(method) (@guaranteed LetFieldClass) -> () {
+ // CHECK: bb0([[CLS:%.*]] : @guaranteed $LetFieldClass):
+ // CHECK: [[KRAKEN_GETTER_FUN:%.*]] = class_method [[CLS]] : $LetFieldClass, #LetFieldClass.vark!getter.1 : (LetFieldClass) -> () -> Kraken, $@convention(method) (@guaranteed LetFieldClass) -> @owned Kraken
+ // CHECK-NEXT: [[KRAKEN:%.*]] = apply [[KRAKEN_GETTER_FUN]]([[CLS]])
+ // CHECK-NEXT: [[BORROWED_KRAKEN:%.*]] = begin_borrow [[KRAKEN]]
+ // CHECK-NEXT: [[KRAKEN_METH:%.*]] = class_method [[BORROWED_KRAKEN]]
+ // CHECK-NEXT: apply [[KRAKEN_METH]]([[BORROWED_KRAKEN]])
+ // CHECK-NEXT: end_borrow [[BORROWED_KRAKEN]] from [[KRAKEN]]
+ // CHECK-NEXT: destroy_value [[KRAKEN]]
+ // CHECK-NEXT: [[KRAKEN_GETTER_FUN:%.*]] = class_method [[CLS]] : $LetFieldClass, #LetFieldClass.vark!getter.1 : (LetFieldClass) -> () -> Kraken, $@convention(method) (@guaranteed LetFieldClass) -> @owned Kraken
+ // CHECK-NEXT: [[KRAKEN:%.*]] = apply [[KRAKEN_GETTER_FUN]]([[CLS]])
+ // CHECK: [[BORROWED_KRAKEN:%.*]] = begin_borrow [[KRAKEN]]
+ // CHECK: [[DESTROY_SHIP_FUN:%.*]] = function_ref @$S15guaranteed_self11destroyShipyyAA6KrakenCF : $@convention(thin) (@guaranteed Kraken) -> ()
+ // CHECK-NEXT: apply [[DESTROY_SHIP_FUN]]([[BORROWED_KRAKEN]])
+ // CHECK-NEXT: end_borrow [[BORROWED_KRAKEN]] from [[KRAKEN]]
+ // CHECK-NEXT: [[KRAKEN_BOX:%.*]] = alloc_box ${ var Kraken }
+ // CHECK-NEXT: [[PB:%.*]] = project_box [[KRAKEN_BOX]]
+ // CHECK-NEXT: [[KRAKEN_GETTER_FUN:%.*]] = class_method [[CLS]] : $LetFieldClass, #LetFieldClass.vark!getter.1 : (LetFieldClass) -> () -> Kraken, $@convention(method) (@guaranteed LetFieldClass) -> @owned Kraken
+ // CHECK-NEXT: [[KRAKEN2:%.*]] = apply [[KRAKEN_GETTER_FUN]]([[CLS]])
+ // CHECK-NEXT: store [[KRAKEN2]] to [init] [[PB]]
+ // CHECK-NEXT: [[WRITE:%.*]] = begin_access [read] [unknown] [[PB]] : $*Kraken
+ // CHECK-NEXT: [[KRAKEN_COPY:%.*]] = load [copy] [[WRITE]]
+ // CHECK-NEXT: end_access [[WRITE]] : $*Kraken
+ // CHECK-NEXT: [[BORROWED_KRAKEN_COPY:%.*]] = begin_borrow [[KRAKEN_COPY]]
+ // CHECK: [[DESTROY_SHIP_FUN:%.*]] = function_ref @$S15guaranteed_self11destroyShipyyAA6KrakenCF : $@convention(thin) (@guaranteed Kraken) -> ()
+ // CHECK-NEXT: apply [[DESTROY_SHIP_FUN]]([[BORROWED_KRAKEN_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_KRAKEN_COPY]]
+ // CHECK-NEXT: destroy_value [[KRAKEN_COPY]]
+ // CHECK-NEXT: destroy_value [[KRAKEN_BOX]]
+ // CHECK-NEXT: destroy_value [[KRAKEN]]
+ // CHECK-NEXT: tuple
+ // CHECK-NEXT: return
+ func varkMethod() {
+ vark.enrage()
+ let vl = vark
+ destroyShip(vl)
+ var vv = vark
+ destroyShip(vv)
+ }
+}
+
+// -----------------------------------------------------------------------------
+// Make sure that in all of the following cases find has only one copy_value in it.
+// -----------------------------------------------------------------------------
+
+class ClassIntTreeNode {
+ let value : Int
+ let left, right : ClassIntTreeNode
+
+ init() {}
+
+ // CHECK-LABEL: sil hidden @$S15guaranteed_self16ClassIntTreeNodeC4find{{[_0-9a-zA-Z]*}}F : $@convention(method) (Int, @guaranteed ClassIntTreeNode) -> @owned ClassIntTreeNode {
+ // CHECK-NOT: destroy_value
+ // CHECK: copy_value
+ // CHECK-NOT: copy_value
+ // CHECK-NOT: destroy_value
+ // CHECK: return
+ func find(_ v : Int) -> ClassIntTreeNode {
+ if v == value { return self }
+ if v < value { return left.find(v) }
+ return right.find(v)
+ }
+}
diff --git a/test/SILGen/plus_zero_if_while_binding.swift b/test/SILGen/plus_zero_if_while_binding.swift
new file mode 100644
index 0000000..4152501
--- /dev/null
+++ b/test/SILGen/plus_zero_if_while_binding.swift
@@ -0,0 +1,405 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+func foo() -> String? { return "" }
+func bar() -> String? { return "" }
+
+func a(_ x: String) {}
+func b(_ x: String) {}
+func c(_ x: String) {}
+
+func marker_1() {}
+func marker_2() {}
+func marker_3() {}
+
+
+// CHECK-LABEL: sil hidden @$S16if_while_binding0A8_no_else{{[_0-9a-zA-Z]*}}F
+func if_no_else() {
+ // CHECK: [[FOO:%.*]] = function_ref @$S16if_while_binding3fooSSSgyF
+ // CHECK: [[OPT_RES:%.*]] = apply [[FOO]]()
+ // CHECK: switch_enum [[OPT_RES]] : $Optional<String>, case #Optional.some!enumelt.1: [[YES:bb[0-9]+]], case #Optional.none!enumelt: [[NO:bb[0-9]+]]
+ //
+ // CHECK: [[NO]]:
+ // CHECK: br [[CONT:bb[0-9]+]]
+ if let x = foo() {
+ // CHECK: [[YES]]([[VAL:%[0-9]+]] : @owned $String):
+ // CHECK: [[BORROWED_VAL:%.*]] = begin_borrow [[VAL]]
+ // CHECK: [[A:%.*]] = function_ref @$S16if_while_binding1a
+ // CHECK: apply [[A]]([[BORROWED_VAL]])
+ // CHECK: end_borrow [[BORROWED_VAL]] from [[VAL]]
+ // CHECK: destroy_value [[VAL]]
+ // CHECK: br [[CONT]]
+ a(x)
+ }
+ // CHECK: [[CONT]]:
+ // CHECK-NEXT: tuple ()
+}
+// CHECK: } // end sil function '$S16if_while_binding0A8_no_else{{[_0-9a-zA-Z]*}}F'
+
+// CHECK-LABEL: sil hidden @$S16if_while_binding0A11_else_chainyyF : $@convention(thin) () -> () {
+func if_else_chain() {
+ // CHECK: [[FOO:%.*]] = function_ref @$S16if_while_binding3foo{{[_0-9a-zA-Z]*}}F
+ // CHECK-NEXT: [[OPT_RES:%.*]] = apply [[FOO]]()
+ // CHECK-NEXT: switch_enum [[OPT_RES]] : $Optional<String>, case #Optional.some!enumelt.1: [[YESX:bb[0-9]+]], case #Optional.none!enumelt: [[NOX:bb[0-9]+]]
+ if let x = foo() {
+ // CHECK: [[NOX]]:
+ // CHECK: br [[FAILURE_DESTX:bb[0-9]+]]
+ //
+ // CHECK: [[YESX]]([[VAL:%[0-9]+]] : @owned $String):
+ // CHECK: debug_value [[VAL]] : $String, let, name "x"
+ // CHECK: [[BORROWED_VAL:%.*]] = begin_borrow [[VAL]]
+ // CHECK: [[A:%.*]] = function_ref @$S16if_while_binding1a
+ // CHECK: apply [[A]]([[BORROWED_VAL]])
+ // CHECK: end_borrow [[BORROWED_VAL]] from [[VAL]]
+ // CHECK: destroy_value [[VAL]]
+ // CHECK: br [[CONT_X:bb[0-9]+]]
+ a(x)
+ //
+ // CHECK: [[FAILURE_DESTX]]:
+ // CHECK: alloc_box ${ var String }, var, name "y"
+ // CHECK: switch_enum {{.*}} : $Optional<String>, case #Optional.some!enumelt.1: [[YESY:bb[0-9]+]], case #Optional.none!enumelt: [[ELSE1:bb[0-9]+]]
+ // CHECK: [[ELSE1]]:
+ // CHECK: dealloc_box {{.*}} ${ var String }
+ // CHECK: br [[ELSE:bb[0-9]+]]
+ } else if var y = bar() {
+ // CHECK: [[YESY]]([[VAL:%[0-9]+]] : @owned $String):
+ // CHECK: br [[CONT_Y:bb[0-9]+]]
+ // CHECK: [[CONT_Y]]:
+ // CHECK: br [[CONT_Y2:bb[0-9]+]]
+ b(y)
+ } else {
+ // CHECK: [[ELSE]]:
+ // CHECK: function_ref if_while_binding.c
+ c("")
+ // CHECK: br [[CONT_Y2]]
+ }
+
+ // CHECK: [[CONT_Y2]]:
+ // br [[CONT_X]]
+ // CHECK: [[CONT_X]]:
+}
+
+// CHECK-LABEL: sil hidden @$S16if_while_binding0B5_loopyyF : $@convention(thin) () -> () {
+func while_loop() {
+ // CHECK: br [[LOOP_ENTRY:bb[0-9]+]]
+ //
+ // CHECK: [[LOOP_ENTRY]]:
+ // CHECK: switch_enum {{.*}} : $Optional<String>, case #Optional.some!enumelt.1: [[LOOP_BODY:bb[0-9]+]], case #Optional.none!enumelt: [[NO_TRAMPOLINE:bb[0-9]+]]
+ //
+ // CHECK: [[NO_TRAMPOLINE]]:
+ // CHECK: br [[LOOP_EXIT:bb[0-9]+]]
+ while let x = foo() {
+ // CHECK: [[LOOP_BODY]]([[X:%[0-9]+]] : @owned $String):
+ // CHECK: switch_enum {{.*}} : $Optional<String>, case #Optional.some!enumelt.1: [[YES:bb[0-9]+]], case #Optional.none!enumelt: [[NO_TRAMPOLINE_2:bb[0-9]+]]
+ //
+ // CHECK: [[NO_TRAMPOLINE_2]]:
+ // CHECK: br [[FAILURE_DEST_2:bb[0-9]+]]
+ if let y = bar() {
+ // CHECK: [[YES]]([[Y:%[0-9]+]] : @owned $String):
+ a(y)
+ break
+ // CHECK: destroy_value [[Y]]
+ // CHECK: destroy_value [[X]]
+ // CHECK: br [[LOOP_EXIT]]
+ }
+ // CHECK: [[FAILURE_DEST_2]]:
+ // CHECK: destroy_value [[X]]
+ // CHECK: br [[LOOP_ENTRY]]
+ }
+ // CHECK: [[LOOP_EXIT]]:
+ // CHECK-NEXT: tuple ()
+ // CHECK-NEXT: return
+}
+
+// Don't leak alloc_stacks for address-only conditional bindings in 'while'.
+// <rdar://problem/16202294>
+// CHECK-LABEL: sil hidden @$S16if_while_binding0B13_loop_generic{{[_0-9a-zA-Z]*}}F
+// CHECK: br [[COND:bb[0-9]+]]
+// CHECK: [[COND]]:
+// CHECK: [[X:%.*]] = alloc_stack $T, let, name "x"
+// CHECK: [[OPTBUF:%[0-9]+]] = alloc_stack $Optional<T>
+// CHECK: switch_enum_addr {{.*}}, case #Optional.some!enumelt.1: [[LOOPBODY:bb.*]], case #Optional.none!enumelt: [[OUT:bb[0-9]+]]
+// CHECK: [[OUT]]:
+// CHECK: dealloc_stack [[OPTBUF]]
+// CHECK: dealloc_stack [[X]]
+// CHECK: br [[DONE:bb[0-9]+]]
+// CHECK: [[LOOPBODY]]:
+// CHECK: [[ENUMVAL:%.*]] = unchecked_take_enum_data_addr
+// CHECK: copy_addr [take] [[ENUMVAL]] to [initialization] [[X]]
+// CHECK: destroy_addr [[X]]
+// CHECK: dealloc_stack [[X]]
+// CHECK: br [[COND]]
+// CHECK: [[DONE]]:
+// CHECK: return
+// CHECK: } // end sil function '$S16if_while_binding0B13_loop_generic{{[_0-9a-zA-Z]*}}F'
+func while_loop_generic<T>(_ source: () -> T?) {
+ while let x = source() {
+ }
+}
+
+// <rdar://problem/19382942> Improve 'if let' to avoid optional pyramid of doom
+// CHECK-LABEL: sil hidden @$S16if_while_binding0B11_loop_multiyyF
+func while_loop_multi() {
+ // CHECK: br [[LOOP_ENTRY:bb[0-9]+]]
+ // CHECK: [[LOOP_ENTRY]]:
+ // CHECK: switch_enum {{.*}}, case #Optional.some!enumelt.1: [[CHECKBUF2:bb.*]], case #Optional.none!enumelt: [[NONE_TRAMPOLINE:bb[0-9]+]]
+ //
+ // CHECK: [[NONE_TRAMPOLINE]]:
+ // CHECK: br [[LOOP_EXIT0:bb[0-9]+]]
+
+ // CHECK: [[CHECKBUF2]]([[A:%[0-9]+]] : @owned $String):
+ // CHECK: debug_value [[A]] : $String, let, name "a"
+
+ // CHECK: switch_enum {{.*}}, case #Optional.some!enumelt.1: [[LOOP_BODY:bb.*]], case #Optional.none!enumelt: [[LOOP_EXIT2a:bb[0-9]+]]
+
+ // CHECK: [[LOOP_EXIT2a]]:
+ // CHECK: destroy_value [[A]]
+ // CHECK: br [[LOOP_EXIT0]]
+
+ // CHECK: [[LOOP_BODY]]([[B:%[0-9]+]] : @owned $String):
+ while let a = foo(), let b = bar() {
+ // CHECK: debug_value [[B]] : $String, let, name "b"
+ // CHECK: [[BORROWED_A:%.*]] = begin_borrow [[A]]
+ // CHECK: [[A_COPY:%.*]] = copy_value [[BORROWED_A]]
+ // CHECK: debug_value [[A_COPY]] : $String, let, name "c"
+ // CHECK: end_borrow [[BORROWED_A]] from [[A]]
+ // CHECK: destroy_value [[A_COPY]]
+ // CHECK: destroy_value [[B]]
+ // CHECK: destroy_value [[A]]
+ // CHECK: br [[LOOP_ENTRY]]
+ let c = a
+ }
+ // CHECK: [[LOOP_EXIT0]]:
+ // CHECK-NEXT: tuple ()
+ // CHECK-NEXT: return
+}
+
+// CHECK-LABEL: sil hidden @$S16if_while_binding0A6_multiyyF
+func if_multi() {
+ // CHECK: switch_enum {{.*}}, case #Optional.some!enumelt.1: [[CHECKBUF2:bb.*]], case #Optional.none!enumelt: [[NONE_TRAMPOLINE:bb[0-9]+]]
+ //
+ // CHECK: [[NONE_TRAMPOLINE]]:
+ // CHECK: br [[IF_DONE:bb[0-9]+]]
+
+ // CHECK: [[CHECKBUF2]]([[A:%[0-9]+]] : @owned $String):
+ // CHECK: debug_value [[A]] : $String, let, name "a"
+ // CHECK: [[B:%[0-9]+]] = alloc_box ${ var String }, var, name "b"
+ // CHECK: [[PB:%[0-9]+]] = project_box [[B]]
+ // CHECK: switch_enum {{.*}}, case #Optional.some!enumelt.1: [[IF_BODY:bb.*]], case #Optional.none!enumelt: [[IF_EXIT1a:bb[0-9]+]]
+
+ // CHECK: [[IF_EXIT1a]]:
+ // CHECK: dealloc_box {{.*}} ${ var String }
+ // CHECK: destroy_value [[A]]
+ // CHECK: br [[IF_DONE]]
+
+ // CHECK: [[IF_BODY]]([[BVAL:%[0-9]+]] : @owned $String):
+ if let a = foo(), var b = bar() {
+ // CHECK: store [[BVAL]] to [init] [[PB]] : $*String
+ // CHECK: debug_value {{.*}} : $String, let, name "c"
+ // CHECK: destroy_value [[B]]
+ // CHECK: destroy_value [[A]]
+ // CHECK: br [[IF_DONE]]
+ let c = a
+ }
+ // CHECK: [[IF_DONE]]:
+ // CHECK-NEXT: tuple ()
+ // CHECK-NEXT: return
+}
+
+// CHECK-LABEL: sil hidden @$S16if_while_binding0A11_multi_elseyyF
+func if_multi_else() {
+ // CHECK: switch_enum {{.*}}, case #Optional.some!enumelt.1: [[CHECKBUF2:bb.*]], case #Optional.none!enumelt: [[NONE_TRAMPOLINE:bb[0-9]+]]
+ //
+ // CHECK: [[NONE_TRAMPOLINE]]:
+ // CHECK: br [[ELSE:bb[0-9]+]]
+ // CHECK: [[CHECKBUF2]]([[A:%[0-9]+]] : @owned $String):
+ // CHECK: debug_value [[A]] : $String, let, name "a"
+ // CHECK: [[B:%[0-9]+]] = alloc_box ${ var String }, var, name "b"
+ // CHECK: [[PB:%[0-9]+]] = project_box [[B]]
+ // CHECK: switch_enum {{.*}}, case #Optional.some!enumelt.1: [[IF_BODY:bb.*]], case #Optional.none!enumelt: [[IF_EXIT1a:bb[0-9]+]]
+
+ // CHECK: [[IF_EXIT1a]]:
+ // CHECK: dealloc_box {{.*}} ${ var String }
+ // CHECK: destroy_value [[A]]
+ // CHECK: br [[ELSE]]
+
+ // CHECK: [[IF_BODY]]([[BVAL:%[0-9]+]] : @owned $String):
+ if let a = foo(), var b = bar() {
+ // CHECK: store [[BVAL]] to [init] [[PB]] : $*String
+ // CHECK: debug_value {{.*}} : $String, let, name "c"
+ // CHECK: destroy_value [[B]]
+ // CHECK: destroy_value [[A]]
+ // CHECK: br [[IF_DONE:bb[0-9]+]]
+ let c = a
+ } else {
+ let d = 0
+ // CHECK: [[ELSE]]:
+ // CHECK: debug_value {{.*}} : $Int, let, name "d"
+ // CHECK: br [[IF_DONE]]
+ }
+ // CHECK: [[IF_DONE]]:
+ // CHECK-NEXT: tuple ()
+ // CHECK-NEXT: return
+}
+
+// CHECK-LABEL: sil hidden @$S16if_while_binding0A12_multi_whereyyF
+func if_multi_where() {
+ // CHECK: switch_enum {{.*}}, case #Optional.some!enumelt.1: [[CHECKBUF2:bb.*]], case #Optional.none!enumelt: [[NONE_TRAMPOLINE:bb[0-9]+]]
+ //
+ // CHECK: [[NONE_TRAMPOLINE]]:
+ // CHECK: br [[ELSE:bb[0-9]+]]
+ // CHECK: [[CHECKBUF2]]([[A:%[0-9]+]] : @owned $String):
+ // CHECK: debug_value [[A]] : $String, let, name "a"
+ // CHECK: [[BBOX:%[0-9]+]] = alloc_box ${ var String }, var, name "b"
+ // CHECK: [[PB:%[0-9]+]] = project_box [[BBOX]]
+ // CHECK: switch_enum {{.*}}, case #Optional.some!enumelt.1: [[CHECK_WHERE:bb.*]], case #Optional.none!enumelt: [[IF_EXIT1a:bb[0-9]+]]
+ // CHECK: [[IF_EXIT1a]]:
+ // CHECK: dealloc_box {{.*}} ${ var String }
+ // CHECK: destroy_value [[A]]
+ // CHECK: br [[ELSE]]
+
+ // CHECK: [[CHECK_WHERE]]([[B:%[0-9]+]] : @owned $String):
+ // CHECK: function_ref Swift.Bool._getBuiltinLogicValue() -> Builtin.Int1
+ // CHECK: cond_br {{.*}}, [[IF_BODY:bb[0-9]+]], [[IF_EXIT3:bb[0-9]+]]
+ // CHECK: [[IF_EXIT3]]:
+ // CHECK: destroy_value [[BBOX]]
+ // CHECK: destroy_value [[A]]
+ // CHECK: br [[IF_DONE:bb[0-9]+]]
+ if let a = foo(), var b = bar(), a == b {
+ // CHECK: [[IF_BODY]]:
+ // CHECK: destroy_value [[BBOX]]
+ // CHECK: destroy_value [[A]]
+ // CHECK: br [[IF_DONE]]
+ let c = a
+ }
+ // CHECK: [[IF_DONE]]:
+ // CHECK-NEXT: tuple ()
+ // CHECK-NEXT: return
+}
+
+
+// <rdar://problem/19797158> Swift 1.2's "if" has 2 behaviors. They could be unified.
+// CHECK-LABEL: sil hidden @$S16if_while_binding0A16_leading_booleanyySiF
+func if_leading_boolean(_ a : Int) {
+ // Test the boolean condition.
+
+ // CHECK: debug_value %0 : $Int, let, name "a"
+ // CHECK: [[EQRESULT:%[0-9]+]] = apply {{.*}}(%0, %0{{.*}}) : $@convention({{.*}}) (Int, Int{{.*}}) -> Bool
+
+ // CHECK: [[FN:%.*]] = function_ref {{.*}}
+ // CHECK-NEXT: [[EQRESULTI1:%[0-9]+]] = apply [[FN:%.*]]([[EQRESULT]]) : $@convention(method) (Bool) -> Builtin.Int1
+ // CHECK-NEXT: cond_br [[EQRESULTI1]], [[CHECKFOO:bb[0-9]+]], [[IFDONE:bb[0-9]+]]
+
+ // Call Foo and test for the optional being present.
+// CHECK: [[CHECKFOO]]:
+ // CHECK: [[OPTRESULT:%[0-9]+]] = apply {{.*}}() : $@convention(thin) () -> @owned Optional<String>
+
+ // CHECK: switch_enum [[OPTRESULT]] : $Optional<String>, case #Optional.some!enumelt.1: [[SUCCESS:bb.*]], case #Optional.none!enumelt: [[IF_DONE:bb[0-9]+]]
+
+// CHECK: [[SUCCESS]]([[B:%[0-9]+]] : @owned $String):
+ // CHECK: debug_value [[B]] : $String, let, name "b"
+ // CHECK: [[BORROWED_B:%.*]] = begin_borrow [[B]]
+ // CHECK: [[B_COPY:%.*]] = copy_value [[BORROWED_B]]
+ // CHECK: debug_value [[B_COPY]] : $String, let, name "c"
+ // CHECK: end_borrow [[BORROWED_B]] from [[B]]
+ // CHECK: destroy_value [[B_COPY]]
+ // CHECK: destroy_value [[B]]
+ // CHECK: br [[IFDONE]]
+ if a == a, let b = foo() {
+ let c = b
+ }
+ // CHECK: [[IFDONE]]:
+ // CHECK-NEXT: tuple ()
+
+}
+
+
+/// <rdar://problem/20364869> Assertion failure when using 'as' pattern in 'if let'
+class BaseClass {}
+class DerivedClass : BaseClass {}
+
+// CHECK-LABEL: sil hidden @$S16if_while_binding20testAsPatternInIfLetyyAA9BaseClassCSgF
+func testAsPatternInIfLet(_ a : BaseClass?) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Optional<BaseClass>):
+ // CHECK: debug_value [[ARG]] : $Optional<BaseClass>, let, name "a"
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]] : $Optional<BaseClass>
+ // CHECK: switch_enum [[ARG_COPY]] : $Optional<BaseClass>, case #Optional.some!enumelt.1: [[OPTPRESENTBB:bb[0-9]+]], case #Optional.none!enumelt: [[NILBB:bb[0-9]+]]
+
+ // CHECK: [[NILBB]]:
+ // CHECK: br [[EXITBB:bb[0-9]+]]
+
+ // CHECK: [[OPTPRESENTBB]]([[CLS:%.*]] : @owned $BaseClass):
+ // CHECK: checked_cast_br [[CLS]] : $BaseClass to $DerivedClass, [[ISDERIVEDBB:bb[0-9]+]], [[ISBASEBB:bb[0-9]+]]
+
+ // CHECK: [[ISDERIVEDBB]]([[DERIVED_CLS:%.*]] : @owned $DerivedClass):
+ // CHECK: [[DERIVED_CLS_SOME:%.*]] = enum $Optional<DerivedClass>, #Optional.some!enumelt.1, [[DERIVED_CLS]] : $DerivedClass
+ // CHECK: br [[MERGE:bb[0-9]+]]([[DERIVED_CLS_SOME]] : $Optional<DerivedClass>)
+
+ // CHECK: [[ISBASEBB]]([[BASECLASS:%.*]] : @owned $BaseClass):
+ // CHECK: destroy_value [[BASECLASS]] : $BaseClass
+ // CHECK: = enum $Optional<DerivedClass>, #Optional.none!enumelt
+ // CHECK: br [[MERGE]](
+
+ // CHECK: [[MERGE]]([[OPTVAL:%[0-9]+]] : @owned $Optional<DerivedClass>):
+ // CHECK: switch_enum [[OPTVAL]] : $Optional<DerivedClass>, case #Optional.some!enumelt.1: [[ISDERIVEDBB:bb[0-9]+]], case #Optional.none!enumelt: [[NILBB:bb[0-9]+]]
+
+ // CHECK: [[ISDERIVEDBB]]([[DERIVEDVAL:%[0-9]+]] : @owned $DerivedClass):
+ // CHECK: debug_value [[DERIVEDVAL]] : $DerivedClass
+ // => SEMANTIC SIL TODO: This is benign, but scoping wise, this end borrow should be after derived val.
+ // CHECK: destroy_value [[DERIVEDVAL]] : $DerivedClass
+ // CHECK: br [[EXITBB]]
+
+ // CHECK: [[EXITBB]]:
+ // CHECK: tuple ()
+ // CHECK: return
+ if case let b as DerivedClass = a {
+
+ }
+}
+
+// <rdar://problem/22312114> if case crashes swift - bools not supported in let/else yet
+// CHECK-LABEL: sil hidden @$S16if_while_binding12testCaseBoolyySbSgF
+func testCaseBool(_ value : Bool?) {
+ // CHECK: bb0([[ARG:%.*]] : @trivial $Optional<Bool>):
+ // CHECK: switch_enum [[ARG]] : $Optional<Bool>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_TRAMPOLINE:bb[0-9]+]]
+ //
+ // CHECK: [[NONE_TRAMPOLINE]]:
+ // CHECK: br [[CONT_BB:bb[0-9]+]]
+ //
+ // CHECK: [[SOME_BB]]([[PAYLOAD:%.*]] : @trivial $Bool):
+ // CHECK: [[ISTRUE:%[0-9]+]] = struct_extract [[PAYLOAD]] : $Bool, #Bool._value
+ // CHECK: cond_br [[ISTRUE]], [[TRUE_TRAMPOLINE_BB:bb[0-9]+]], [[CONT_BB]]
+ //
+ // CHECK: [[TRUE_TRAMPOLINE_BB:bb[0-9]+]]
+ // CHECK: br [[TRUE_BB:bb[0-9]+]]
+ //
+ // CHECK: [[TRUE_BB]]:
+ // CHECK: function_ref @$S16if_while_binding8marker_1yyF
+ // CHECK: br [[CONT_BB]]
+ if case true? = value {
+ marker_1()
+ }
+
+ // CHECK: [[CONT_BB]]:
+ // CHECK: switch_enum [[ARG]] : $Optional<Bool>, case #Optional.some!enumelt.1: [[SUCC_BB_2:bb[0-9]+]], case #Optional.none!enumelt: [[NO_TRAMPOLINE_2:bb[0-9]+]]
+
+ // CHECK: [[NO_TRAMPOLINE_2]]:
+ // CHECK: br [[EPILOG_BB:bb[0-9]+]]
+
+ // CHECK: [[SUCC_BB_2]]([[PAYLOAD2:%.*]] : @trivial $Bool):
+ // CHECK: [[ISTRUE:%[0-9]+]] = struct_extract [[PAYLOAD2]] : $Bool, #Bool._value
+ // CHECK: cond_br [[ISTRUE]], [[EPILOG_BB]], [[FALSE2_TRAMPOLINE_BB:bb[0-9]+]]
+
+ // CHECK: [[FALSE2_TRAMPOLINE_BB]]:
+ // CHECK: br [[FALSE2_BB:bb[0-9]+]]
+ //
+ // CHECK: [[FALSE2_BB]]:
+ // CHECK: function_ref @$S16if_while_binding8marker_2yyF
+ // CHECK: br [[EPILOG_BB]]
+
+ // CHECK: [[EPILOG_BB]]:
+ // CHECK: return
+ if case false? = value {
+ marker_2()
+ }
+}
diff --git a/test/SILGen/plus_zero_implicitly_unwrapped_optional.swift b/test/SILGen/plus_zero_implicitly_unwrapped_optional.swift
new file mode 100644
index 0000000..55f3112
--- /dev/null
+++ b/test/SILGen/plus_zero_implicitly_unwrapped_optional.swift
@@ -0,0 +1,81 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+func foo(f f: (() -> ())!) {
+ var f: (() -> ())! = f
+ f?()
+}
+// CHECK: sil hidden @{{.*}}foo{{.*}} : $@convention(thin) (@guaranteed Optional<@callee_guaranteed () -> ()>) -> () {
+// CHECK: bb0([[T0:%.*]] : @guaranteed $Optional<@callee_guaranteed () -> ()>):
+// CHECK: [[F:%.*]] = alloc_box ${ var Optional<@callee_guaranteed () -> ()> }
+// CHECK: [[PF:%.*]] = project_box [[F]]
+// CHECK: [[T0_COPY:%.*]] = copy_value [[T0]]
+// CHECK: store [[T0_COPY]] to [init] [[PF]]
+// CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PF]] : $*Optional<@callee_guaranteed () -> ()>
+// CHECK: [[T1:%.*]] = select_enum_addr [[READ]]
+// CHECK: cond_br [[T1]], bb2, bb1
+// If it does, project and load the value out of the implicitly unwrapped
+// optional...
+// CHECK: bb2:
+// CHECK-NEXT: [[FN0_ADDR:%.*]] = unchecked_take_enum_data_addr [[READ]]
+// CHECK-NEXT: [[FN0:%.*]] = load [copy] [[FN0_ADDR]]
+// .... then call it
+// CHECK: [[B:%.*]] = begin_borrow [[FN0]]
+// CHECK: apply [[B]]() : $@callee_guaranteed () -> ()
+// CHECK: end_borrow [[B]]
+// CHECK: br bb3
+// CHECK: bb3(
+// CHECK: destroy_value [[F]]
+// CHECK: return
+// CHECK: bb4:
+// CHECK: enum $Optional<()>, #Optional.none!enumelt
+// CHECK: br bb3
+// The rest of this is tested in optional.swift
+// } // end sil function '{{.*}}foo{{.*}}'
+
+func wrap<T>(x x: T) -> T! { return x }
+
+// CHECK-LABEL: sil hidden @$S29implicitly_unwrapped_optional16wrap_then_unwrap{{[_0-9a-zA-Z]*}}F
+func wrap_then_unwrap<T>(x x: T) -> T {
+ // CHECK: switch_enum_addr {{%.*}}, case #Optional.some!enumelt.1: [[OK:bb[0-9]+]], case #Optional.none!enumelt: [[FAIL:bb[0-9]+]]
+ // CHECK: [[FAIL]]:
+ // CHECK: unreachable
+ // CHECK: [[OK]]:
+ return wrap(x: x)!
+}
+
+// CHECK-LABEL: sil hidden @$S29implicitly_unwrapped_optional10tuple_bind1xSSSgSi_SStSg_tF : $@convention(thin) (@guaranteed Optional<(Int, String)>) -> @owned Optional<String> {
+func tuple_bind(x x: (Int, String)!) -> String? {
+ return x?.1
+ // CHECK: cond_br {{%.*}}, [[NONNULL:bb[0-9]+]], [[NULL:bb[0-9]+]]
+ // CHECK: [[NONNULL]]:
+ // CHECK: [[STRING:%.*]] = tuple_extract {{%.*}} : $(Int, String), 1
+ // CHECK-NOT: destroy_value [[STRING]]
+}
+
+// CHECK-LABEL: sil hidden @$S29implicitly_unwrapped_optional011tuple_bind_a1_B01xSSSi_SStSg_tF
+func tuple_bind_implicitly_unwrapped(x x: (Int, String)!) -> String {
+ return x.1
+}
+
+func return_any() -> AnyObject! { return nil }
+func bind_any() {
+ let object : AnyObject? = return_any()
+}
+
+// CHECK-LABEL: sil hidden @$S29implicitly_unwrapped_optional6sr3758yyF
+func sr3758() {
+ // Verify that there are no additional reabstractions introduced.
+ // CHECK: [[CLOSURE:%.+]] = function_ref @$S29implicitly_unwrapped_optional6sr3758yyFyypSgcfU_ : $@convention(thin) (@in_guaranteed Optional<Any>) -> ()
+ // CHECK: [[F:%.+]] = thin_to_thick_function [[CLOSURE]] : $@convention(thin) (@in_guaranteed Optional<Any>) -> () to $@callee_guaranteed (@in_guaranteed Optional<Any>) -> ()
+ // CHECK: [[BORROWED_F:%.*]] = begin_borrow [[F]]
+ // CHECK: [[CALLEE:%.+]] = copy_value [[BORROWED_F]] : $@callee_guaranteed (@in_guaranteed Optional<Any>) -> ()
+ // CHECK: [[BORROWED_CALLEE:%.*]] = begin_borrow [[CALLEE]]
+ // CHECK: = apply [[BORROWED_CALLEE]]({{%.+}}) : $@callee_guaranteed (@in_guaranteed Optional<Any>) -> ()
+ // CHECK: end_borrow [[BORROWED_CALLEE]]
+ // destroy_value [[CALLEE]]
+ // CHECK: end_borrow [[BORROWED_F]] from [[F]]
+ // CHECK: destroy_value [[F]]
+ let f: ((Any?) -> Void) = { (arg: Any!) in }
+ f(nil)
+} // CHECK: end sil function '$S29implicitly_unwrapped_optional6sr3758yyF'
diff --git a/test/SILGen/plus_zero_indirect_enum.swift b/test/SILGen/plus_zero_indirect_enum.swift
new file mode 100644
index 0000000..2d609f0
--- /dev/null
+++ b/test/SILGen/plus_zero_indirect_enum.swift
@@ -0,0 +1,518 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-print-debuginfo -emit-silgen %s | %FileCheck %s
+
+indirect enum TreeA<T> {
+ case Nil
+ case Leaf(T)
+ case Branch(left: TreeA<T>, right: TreeA<T>)
+}
+
+// CHECK-LABEL: sil hidden @$S13indirect_enum11TreeA_cases_1l1ryx_AA0C1AOyxGAGtlF : $@convention(thin) <T> (@in_guaranteed T, @guaranteed TreeA<T>, @guaranteed TreeA<T>) -> () {
+func TreeA_cases<T>(_ t: T, l: TreeA<T>, r: TreeA<T>) {
+// CHECK: bb0([[ARG1:%.*]] : $*T, [[ARG2:%.*]] : $TreeA<T>, [[ARG3:%.*]] : $TreeA<T>):
+// CHECK: [[METATYPE:%.*]] = metatype $@thin TreeA<T>.Type
+// CHECK-NEXT: [[NIL:%.*]] = enum $TreeA<T>, #TreeA.Nil!enumelt
+// CHECK-NOT: destroy_value [[NIL]]
+ let _ = TreeA<T>.Nil
+
+// CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin TreeA<T>.Type
+// CHECK-NEXT: [[BOX:%.*]] = alloc_box $<τ_0_0> { var τ_0_0 } <T>
+// CHECK-NEXT: [[PB:%.*]] = project_box [[BOX]]
+// CHECK-NEXT: copy_addr [[ARG1]] to [initialization] [[PB]]
+// CHECK-NEXT: [[LEAF:%.*]] = enum $TreeA<T>, #TreeA.Leaf!enumelt.1, [[BOX]]
+// CHECK-NEXT: destroy_value [[LEAF]]
+ let _ = TreeA<T>.Leaf(t)
+
+// CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin TreeA<T>.Type
+// CHECK-NEXT: [[BOX:%.*]] = alloc_box $<τ_0_0> { var (left: TreeA<τ_0_0>, right: TreeA<τ_0_0>) } <T>
+// CHECK-NEXT: [[PB:%.*]] = project_box [[BOX]]
+// CHECK-NEXT: [[LEFT:%.*]] = tuple_element_addr [[PB]] : $*(left: TreeA<T>, right: TreeA<T>), 0
+// CHECK-NEXT: [[RIGHT:%.*]] = tuple_element_addr [[PB]] : $*(left: TreeA<T>, right: TreeA<T>), 1
+// CHECK-NEXT: [[ARG2_COPY:%.*]] = copy_value [[ARG2]]
+// CHECK-NEXT: store [[ARG2_COPY]] to [init] [[LEFT]]
+// CHECK-NEXT: [[ARG3_COPY:%.*]] = copy_value [[ARG3]]
+// CHECK-NEXT: store [[ARG3_COPY]] to [init] [[RIGHT]]
+// CHECK-NEXT: [[BRANCH:%.*]] = enum $TreeA<T>, #TreeA.Branch!enumelt.1, [[BOX]]
+// CHECK-NEXT: destroy_value [[BRANCH]]
+ let _ = TreeA<T>.Branch(left: l, right: r)
+
+}
+// CHECK: // end sil function '$S13indirect_enum11TreeA_cases_1l1ryx_AA0C1AOyxGAGtlF'
+
+
+// CHECK-LABEL: sil hidden @$S13indirect_enum16TreeA_reabstractyyS2icF : $@convention(thin) (@guaranteed @callee_guaranteed (Int) -> Int) -> () {
+func TreeA_reabstract(_ f: @escaping (Int) -> Int) {
+// CHECK: bb0([[ARG:%.*]] : $@callee_guaranteed (Int) -> Int):
+// CHECK: [[METATYPE:%.*]] = metatype $@thin TreeA<(Int) -> Int>.Type
+// CHECK-NEXT: [[BOX:%.*]] = alloc_box $<τ_0_0> { var τ_0_0 } <(Int) -> Int>
+// CHECK-NEXT: [[PB:%.*]] = project_box [[BOX]]
+// CHECK-NEXT: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: [[THUNK:%.*]] = function_ref @$SS2iIegyd_S2iIegnr_TR
+// CHECK-NEXT: [[FN:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[ARG_COPY]])
+// CHECK-NEXT: store [[FN]] to [init] [[PB]]
+// CHECK-NEXT: [[LEAF:%.*]] = enum $TreeA<(Int) -> Int>, #TreeA.Leaf!enumelt.1, [[BOX]]
+// CHECK-NEXT: destroy_value [[LEAF]]
+// CHECK: return
+ let _ = TreeA<(Int) -> Int>.Leaf(f)
+}
+// CHECK: } // end sil function '$S13indirect_enum16TreeA_reabstractyyS2icF'
+
+enum TreeB<T> {
+ case Nil
+ case Leaf(T)
+ indirect case Branch(left: TreeB<T>, right: TreeB<T>)
+}
+
+// CHECK-LABEL: sil hidden @$S13indirect_enum11TreeB_cases_1l1ryx_AA0C1BOyxGAGtlF
+func TreeB_cases<T>(_ t: T, l: TreeB<T>, r: TreeB<T>) {
+
+// CHECK: [[METATYPE:%.*]] = metatype $@thin TreeB<T>.Type
+// CHECK: [[NIL:%.*]] = alloc_stack $TreeB<T>
+// CHECK-NEXT: inject_enum_addr [[NIL]] : $*TreeB<T>, #TreeB.Nil!enumelt
+// CHECK-NEXT: destroy_addr [[NIL]]
+// CHECK-NEXT: dealloc_stack [[NIL]]
+ let _ = TreeB<T>.Nil
+
+// CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin TreeB<T>.Type
+// CHECK-NEXT: [[LEAF:%.*]] = alloc_stack $TreeB<T>
+// CHECK-NEXT: [[PAYLOAD:%.*]] = init_enum_data_addr [[LEAF]] : $*TreeB<T>, #TreeB.Leaf!enumelt.1
+// CHECK-NEXT: copy_addr %0 to [initialization] [[PAYLOAD]]
+// CHECK-NEXT: inject_enum_addr [[LEAF]] : $*TreeB<T>, #TreeB.Leaf!enumelt
+// CHECK-NEXT: destroy_addr [[LEAF]]
+// CHECK-NEXT: dealloc_stack [[LEAF]]
+ let _ = TreeB<T>.Leaf(t)
+
+// CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin TreeB<T>.Type
+// CHECK-NEXT: [[BOX:%.*]] = alloc_box $<τ_0_0> { var (left: TreeB<τ_0_0>, right: TreeB<τ_0_0>) } <T>
+// CHECK-NEXT: [[PB:%.*]] = project_box [[BOX]]
+// CHECK-NEXT: [[LEFT:%.*]] = tuple_element_addr [[PB]]
+// CHECK-NEXT: [[RIGHT:%.*]] = tuple_element_addr [[PB]]
+// CHECK-NEXT: copy_addr %1 to [initialization] [[LEFT]] : $*TreeB<T>
+// CHECK-NEXT: copy_addr %2 to [initialization] [[RIGHT]] : $*TreeB<T>
+// CHECK-NEXT: [[BRANCH:%.*]] = alloc_stack $TreeB<T>
+// CHECK-NEXT: [[PAYLOAD:%.*]] = init_enum_data_addr [[BRANCH]]
+// CHECK-NEXT: store [[BOX]] to [init] [[PAYLOAD]]
+// CHECK-NEXT: inject_enum_addr [[BRANCH]] : $*TreeB<T>, #TreeB.Branch!enumelt.1
+// CHECK-NEXT: destroy_addr [[BRANCH]]
+// CHECK-NEXT: dealloc_stack [[BRANCH]]
+ let _ = TreeB<T>.Branch(left: l, right: r)
+
+// CHECK: return
+
+}
+
+// CHECK-LABEL: sil hidden @$S13indirect_enum13TreeInt_cases_1l1rySi_AA0cD0OAFtF : $@convention(thin) (Int, @guaranteed TreeInt, @guaranteed TreeInt) -> ()
+func TreeInt_cases(_ t: Int, l: TreeInt, r: TreeInt) {
+// CHECK: bb0([[ARG1:%.*]] : $Int, [[ARG2:%.*]] : $TreeInt, [[ARG3:%.*]] : $TreeInt):
+// CHECK: [[METATYPE:%.*]] = metatype $@thin TreeInt.Type
+// CHECK-NEXT: [[NIL:%.*]] = enum $TreeInt, #TreeInt.Nil!enumelt
+// CHECK-NOT: destroy_value [[NIL]]
+ let _ = TreeInt.Nil
+
+// CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin TreeInt.Type
+// CHECK-NEXT: [[LEAF:%.*]] = enum $TreeInt, #TreeInt.Leaf!enumelt.1, [[ARG1]]
+// CHECK-NOT: destroy_value [[LEAF]]
+ let _ = TreeInt.Leaf(t)
+
+// CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin TreeInt.Type
+// CHECK-NEXT: [[BOX:%.*]] = alloc_box ${ var (left: TreeInt, right: TreeInt) }
+// CHECK-NEXT: [[PB:%.*]] = project_box [[BOX]]
+// CHECK-NEXT: [[LEFT:%.*]] = tuple_element_addr [[PB]]
+// CHECK-NEXT: [[RIGHT:%.*]] = tuple_element_addr [[PB]]
+// CHECK-NEXT: [[ARG2_COPY:%.*]] = copy_value [[ARG2]]
+// CHECK-NEXT: store [[ARG2_COPY]] to [init] [[LEFT]]
+// CHECK-NEXT: [[ARG3_COPY:%.*]] = copy_value [[ARG3]]
+// CHECK-NEXT: store [[ARG3_COPY]] to [init] [[RIGHT]]
+// CHECK-NEXT: [[BRANCH:%.*]] = enum $TreeInt, #TreeInt.Branch!enumelt.1, [[BOX]]
+// CHECK-NEXT: destroy_value [[BRANCH]]
+ let _ = TreeInt.Branch(left: l, right: r)
+}
+// CHECK: } // end sil function '$S13indirect_enum13TreeInt_cases_1l1rySi_AA0cD0OAFtF'
+
+enum TreeInt {
+ case Nil
+ case Leaf(Int)
+ indirect case Branch(left: TreeInt, right: TreeInt)
+}
+
+
+enum TrivialButIndirect {
+ case Direct(Int)
+ indirect case Indirect(Int)
+}
+
+func a() {}
+func b<T>(_ x: T) {}
+func c<T>(_ x: T, _ y: T) {}
+func d() {}
+
+// CHECK-LABEL: sil hidden @$S13indirect_enum11switchTreeAyyAA0D1AOyxGlF : $@convention(thin) <T> (@guaranteed TreeA<T>) -> () {
+func switchTreeA<T>(_ x: TreeA<T>) {
+ // CHECK: bb0([[ARG:%.*]] : $TreeA<T>):
+ // -- x +2
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: switch_enum [[ARG_COPY]] : $TreeA<T>,
+ // CHECK: case #TreeA.Nil!enumelt: [[NIL_CASE:bb1]],
+ // CHECK: case #TreeA.Leaf!enumelt.1: [[LEAF_CASE:bb2]],
+ // CHECK: case #TreeA.Branch!enumelt.1: [[BRANCH_CASE:bb3]],
+ switch x {
+ // CHECK: [[NIL_CASE]]:
+ // CHECK: function_ref @$S13indirect_enum1ayyF
+ // CHECK: br [[OUTER_CONT:bb[0-9]+]]
+ case .Nil:
+ a()
+ // CHECK: [[LEAF_CASE]]([[LEAF_BOX:%.*]] : $<τ_0_0> { var τ_0_0 } <T>):
+ // CHECK: [[VALUE:%.*]] = project_box [[LEAF_BOX]]
+ // CHECK: copy_addr [[VALUE]] to [initialization] [[X:%.*]] : $*T
+ // CHECK: function_ref @$S13indirect_enum1b{{[_0-9a-zA-Z]*}}F
+ // CHECK: destroy_addr [[X]]
+ // CHECK: dealloc_stack [[X]]
+ // -- x +1
+ // CHECK: destroy_value [[LEAF_BOX]]
+ // CHECK: br [[OUTER_CONT]]
+ case .Leaf(let x):
+ b(x)
+
+ // CHECK: [[BRANCH_CASE]]([[NODE_BOX:%.*]] : $<τ_0_0> { var (left: TreeA<τ_0_0>, right: TreeA<τ_0_0>) } <T>):
+ // CHECK: [[TUPLE_ADDR:%.*]] = project_box [[NODE_BOX]]
+ // CHECK: [[TUPLE:%.*]] = load_borrow [[TUPLE_ADDR]]
+ // CHECK: [[LEFT:%.*]] = tuple_extract [[TUPLE]] {{.*}}, 0
+ // CHECK: [[RIGHT:%.*]] = tuple_extract [[TUPLE]] {{.*}}, 1
+ // CHECK: switch_enum [[LEFT]] : $TreeA<T>,
+ // CHECK: case #TreeA.Leaf!enumelt.1: [[LEAF_CASE_LEFT:bb[0-9]+]],
+ // CHECK: default [[FAIL_LEFT:bb[0-9]+]]
+
+ // CHECK: [[LEAF_CASE_LEFT]]([[LEFT_LEAF_BOX:%.*]] : $<τ_0_0> { var τ_0_0 } <T>):
+ // CHECK: [[LEFT_LEAF_VALUE:%.*]] = project_box [[LEFT_LEAF_BOX]]
+ // CHECK: switch_enum [[RIGHT]] : $TreeA<T>,
+ // CHECK: case #TreeA.Leaf!enumelt.1: [[LEAF_CASE_RIGHT:bb[0-9]+]],
+ // CHECK: default [[FAIL_RIGHT:bb[0-9]+]]
+
+ // CHECK: [[LEAF_CASE_RIGHT]]([[RIGHT_LEAF_BOX:%.*]] : $<τ_0_0> { var τ_0_0 } <T>):
+ // CHECK: [[RIGHT_LEAF_VALUE:%.*]] = project_box [[RIGHT_LEAF_BOX]]
+ // CHECK: copy_addr [[LEFT_LEAF_VALUE]]
+ // CHECK: copy_addr [[RIGHT_LEAF_VALUE]]
+ // -- x +1
+ // CHECK: destroy_value [[NODE_BOX]]
+ // CHECK: br [[OUTER_CONT]]
+
+ // CHECK: [[FAIL_RIGHT]]:
+ // CHECK: br [[DEFAULT:bb[0-9]+]]
+
+ // CHECK: [[FAIL_LEFT]]:
+ // CHECK: br [[DEFAULT]]
+
+ case .Branch(.Leaf(let x), .Leaf(let y)):
+ c(x, y)
+
+ // CHECK: [[DEFAULT]]:
+ // -- x +1
+ // CHECK: destroy_value [[ARG_COPY]]
+ default:
+ d()
+ }
+
+ // CHECK: [[OUTER_CONT:%.*]]:
+ // -- x +0
+}
+// CHECK: } // end sil function '$S13indirect_enum11switchTreeAyyAA0D1AOyxGlF'
+
+// CHECK-LABEL: sil hidden @$S13indirect_enum11switchTreeB{{[_0-9a-zA-Z]*}}F
+func switchTreeB<T>(_ x: TreeB<T>) {
+ // CHECK: copy_addr %0 to [initialization] [[SCRATCH:%.*]] :
+ // CHECK: switch_enum_addr [[SCRATCH]]
+ switch x {
+
+ // CHECK: bb{{.*}}:
+ // CHECK: destroy_addr [[SCRATCH]]
+ // CHECK: dealloc_stack [[SCRATCH]]
+ // CHECK: function_ref @$S13indirect_enum1ayyF
+ // CHECK: br [[OUTER_CONT:bb[0-9]+]]
+ case .Nil:
+ a()
+
+ // CHECK: bb{{.*}}:
+ // CHECK: copy_addr [[SCRATCH]] to [initialization] [[LEAF_COPY:%.*]] :
+ // CHECK: [[LEAF_ADDR:%.*]] = unchecked_take_enum_data_addr [[LEAF_COPY]]
+ // CHECK: copy_addr [take] [[LEAF_ADDR]] to [initialization] [[LEAF:%.*]] :
+ // CHECK: function_ref @$S13indirect_enum1b{{[_0-9a-zA-Z]*}}F
+ // CHECK: destroy_addr [[LEAF]]
+ // CHECK: dealloc_stack [[LEAF]]
+ // CHECK-NOT: destroy_addr [[LEAF_COPY]]
+ // CHECK: dealloc_stack [[LEAF_COPY]]
+ // CHECK: destroy_addr [[SCRATCH]]
+ // CHECK: dealloc_stack [[SCRATCH]]
+ // CHECK: br [[OUTER_CONT]]
+ case .Leaf(let x):
+ b(x)
+
+ // CHECK: bb{{.*}}:
+ // CHECK: copy_addr [[SCRATCH]] to [initialization] [[TREE_COPY:%.*]] :
+ // CHECK: [[TREE_ADDR:%.*]] = unchecked_take_enum_data_addr [[TREE_COPY]]
+ // -- box +1 immutable
+ // CHECK: [[BOX:%.*]] = load [take] [[TREE_ADDR]]
+ // CHECK: [[TUPLE:%.*]] = project_box [[BOX]]
+ // CHECK: [[LEFT:%.*]] = tuple_element_addr [[TUPLE]]
+ // CHECK: [[RIGHT:%.*]] = tuple_element_addr [[TUPLE]]
+ // CHECK: switch_enum_addr [[LEFT]] {{.*}}, default [[LEFT_FAIL:bb[0-9]+]]
+
+ // CHECK: bb{{.*}}:
+ // CHECK: copy_addr [[LEFT]] to [initialization] [[LEFT_COPY:%.*]] :
+ // CHECK: [[LEFT_LEAF:%.*]] = unchecked_take_enum_data_addr [[LEFT_COPY]] : $*TreeB<T>, #TreeB.Leaf
+ // CHECK: switch_enum_addr [[RIGHT]] {{.*}}, default [[RIGHT_FAIL:bb[0-9]+]]
+
+ // CHECK: bb{{.*}}:
+ // CHECK: copy_addr [[RIGHT]] to [initialization] [[RIGHT_COPY:%.*]] :
+ // CHECK: [[RIGHT_LEAF:%.*]] = unchecked_take_enum_data_addr [[RIGHT_COPY]] : $*TreeB<T>, #TreeB.Leaf
+ // CHECK: copy_addr [take] [[LEFT_LEAF]] to [initialization] [[X:%.*]] :
+ // CHECK: copy_addr [take] [[RIGHT_LEAF]] to [initialization] [[Y:%.*]] :
+ // CHECK: function_ref @$S13indirect_enum1c{{[_0-9a-zA-Z]*}}F
+ // CHECK: destroy_addr [[Y]]
+ // CHECK: dealloc_stack [[Y]]
+ // CHECK: destroy_addr [[X]]
+ // CHECK: dealloc_stack [[X]]
+ // CHECK-NOT: destroy_addr [[RIGHT_COPY]]
+ // CHECK: dealloc_stack [[RIGHT_COPY]]
+ // CHECK-NOT: destroy_addr [[LEFT_COPY]]
+ // CHECK: dealloc_stack [[LEFT_COPY]]
+ // -- box +0
+ // CHECK: destroy_value [[BOX]]
+ // CHECK-NOT: destroy_addr [[TREE_COPY]]
+ // CHECK: dealloc_stack [[TREE_COPY]]
+ // CHECK: destroy_addr [[SCRATCH]]
+ // CHECK: dealloc_stack [[SCRATCH]]
+ case .Branch(.Leaf(let x), .Leaf(let y)):
+ c(x, y)
+
+ // CHECK: [[RIGHT_FAIL]]:
+ // CHECK: destroy_addr [[LEFT_LEAF]]
+ // CHECK-NOT: destroy_addr [[LEFT_COPY]]
+ // CHECK: dealloc_stack [[LEFT_COPY]]
+ // CHECK: destroy_value [[BOX]]
+ // CHECK-NOT: destroy_addr [[TREE_COPY]]
+ // CHECK: dealloc_stack [[TREE_COPY]]
+ // CHECK: br [[INNER_CONT:bb[0-9]+]]
+
+ // CHECK: [[LEFT_FAIL]]:
+ // CHECK: destroy_value [[BOX]]
+ // CHECK-NOT: destroy_addr [[TREE_COPY]]
+ // CHECK: dealloc_stack [[TREE_COPY]]
+ // CHECK: br [[INNER_CONT:bb[0-9]+]]
+
+ // CHECK: [[INNER_CONT]]:
+ // CHECK: destroy_addr [[SCRATCH]]
+ // CHECK: dealloc_stack [[SCRATCH]]
+ // CHECK: function_ref @$S13indirect_enum1dyyF
+ // CHECK: br [[OUTER_CONT]]
+ default:
+ d()
+ }
+ // CHECK: [[OUTER_CONT]]:
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S13indirect_enum10guardTreeA{{[_0-9a-zA-Z]*}}F
+func guardTreeA<T>(_ tree: TreeA<T>) {
+ // CHECK: bb0([[ARG:%.*]] : $TreeA<T>):
+ do {
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: switch_enum [[ARG_COPY]] : $TreeA<T>, case #TreeA.Nil!enumelt: [[YES:bb[0-9]+]], default [[NO:bb[0-9]+]]
+ // CHECK: [[NO]]([[ORIGINAL_VALUE:%.*]] : $TreeA<T>):
+ // CHECK: destroy_value [[ORIGINAL_VALUE]]
+ // CHECK: [[YES]]:
+ guard case .Nil = tree else { return }
+
+ // CHECK: [[X:%.*]] = alloc_stack $T
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: switch_enum [[ARG_COPY]] : $TreeA<T>, case #TreeA.Leaf!enumelt.1: [[YES:bb[0-9]+]], default [[NO:bb[0-9]+]]
+ // CHECK: [[NO]]([[ORIGINAL_VALUE:%.*]] : $TreeA<T>):
+ // CHECK: destroy_value [[ORIGINAL_VALUE]]
+ // CHECK: [[YES]]([[BOX:%.*]] : $<τ_0_0> { var τ_0_0 } <T>):
+ // CHECK: [[VALUE_ADDR:%.*]] = project_box [[BOX]]
+ // CHECK: [[TMP:%.*]] = alloc_stack
+ // CHECK: copy_addr [[VALUE_ADDR]] to [initialization] [[TMP]]
+ // CHECK: copy_addr [take] [[TMP]] to [initialization] [[X]]
+ // CHECK: destroy_value [[BOX]]
+ guard case .Leaf(let x) = tree else { return }
+
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: switch_enum [[ARG_COPY]] : $TreeA<T>, case #TreeA.Branch!enumelt.1: [[YES:bb[0-9]+]], default [[NO:bb[0-9]+]]
+ // CHECK: [[NO]]([[ORIGINAL_VALUE:%.*]] : $TreeA<T>):
+ // CHECK: destroy_value [[ORIGINAL_VALUE]]
+ // CHECK: [[YES]]([[BOX:%.*]] : $<τ_0_0> { var (left: TreeA<τ_0_0>, right: TreeA<τ_0_0>) } <T>):
+ // CHECK: [[VALUE_ADDR:%.*]] = project_box [[BOX]]
+ // CHECK: [[TUPLE:%.*]] = load [take] [[VALUE_ADDR]]
+ // CHECK: [[TUPLE_COPY:%.*]] = copy_value [[TUPLE]]
+ // CHECK: [[BORROWED_TUPLE_COPY:%.*]] = begin_borrow [[TUPLE_COPY]]
+ // CHECK: [[L:%.*]] = tuple_extract [[BORROWED_TUPLE_COPY]]
+ // CHECK: [[COPY_L:%.*]] = copy_value [[L]]
+ // CHECK: [[R:%.*]] = tuple_extract [[BORROWED_TUPLE_COPY]]
+ // CHECK: [[COPY_R:%.*]] = copy_value [[R]]
+ // CHECK: end_borrow [[BORROWED_TUPLE_COPY]] from [[TUPLE_COPY]]
+ // CHECK: destroy_value [[TUPLE_COPY]]
+ // CHECK: destroy_value [[BOX]]
+ guard case .Branch(left: let l, right: let r) = tree else { return }
+
+ // CHECK: destroy_value [[COPY_R]]
+ // CHECK: destroy_value [[COPY_L]]
+ // CHECK: destroy_addr [[X]]
+ }
+
+ do {
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: switch_enum [[ARG_COPY]] : $TreeA<T>, case #TreeA.Nil!enumelt: [[YES:bb[0-9]+]], default [[NO:bb[0-9]+]]
+ // CHECK: [[NO]]([[ORIGINAL_VALUE:%.*]] : $TreeA<T>):
+ // CHECK: destroy_value [[ORIGINAL_VALUE]]
+ // CHECK: [[YES]]:
+ // CHECK: br
+ if case .Nil = tree { }
+
+ // CHECK: [[X:%.*]] = alloc_stack $T
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: switch_enum [[ARG_COPY]] : $TreeA<T>, case #TreeA.Leaf!enumelt.1: [[YES:bb[0-9]+]], default [[NO:bb[0-9]+]]
+ // CHECK: [[NO]]([[ORIGINAL_VALUE:%.*]] : $TreeA<T>):
+ // CHECK: destroy_value [[ORIGINAL_VALUE]]
+ // CHECK: [[YES]]([[BOX:%.*]] : $<τ_0_0> { var τ_0_0 } <T>):
+ // CHECK: [[VALUE_ADDR:%.*]] = project_box [[BOX]]
+ // CHECK: [[TMP:%.*]] = alloc_stack
+ // CHECK: copy_addr [[VALUE_ADDR]] to [initialization] [[TMP]]
+ // CHECK: copy_addr [take] [[TMP]] to [initialization] [[X]]
+ // CHECK: destroy_value [[BOX]]
+ // CHECK: destroy_addr [[X]]
+ if case .Leaf(let x) = tree { }
+
+
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: switch_enum [[ARG_COPY]] : $TreeA<T>, case #TreeA.Branch!enumelt.1: [[YES:bb[0-9]+]], default [[NO:bb[0-9]+]]
+ // CHECK: [[NO]]([[ORIGINAL_VALUE:%.*]] : $TreeA<T>):
+ // CHECK: destroy_value [[ORIGINAL_VALUE]]
+ // CHECK: [[YES]]([[BOX:%.*]] : $<τ_0_0> { var (left: TreeA<τ_0_0>, right: TreeA<τ_0_0>) } <T>):
+ // CHECK: [[VALUE_ADDR:%.*]] = project_box [[BOX]]
+ // CHECK: [[TUPLE:%.*]] = load [take] [[VALUE_ADDR]]
+ // CHECK: [[TUPLE_COPY:%.*]] = copy_value [[TUPLE]]
+ // CHECK: [[BORROWED_TUPLE_COPY:%.*]] = begin_borrow [[TUPLE_COPY]]
+ // CHECK: [[L:%.*]] = tuple_extract [[BORROWED_TUPLE_COPY]]
+ // CHECK: [[COPY_L:%.*]] = copy_value [[L]]
+ // CHECK: [[R:%.*]] = tuple_extract [[BORROWED_TUPLE_COPY]]
+ // CHECK: [[COPY_R:%.*]] = copy_value [[R]]
+ // CHECK: end_borrow [[BORROWED_TUPLE_COPY]] from [[TUPLE_COPY]]
+ // CHECK: destroy_value [[TUPLE_COPY]]
+ // CHECK: destroy_value [[BOX]]
+ // CHECK: destroy_value [[COPY_R]]
+ // CHECK: destroy_value [[COPY_L]]
+ if case .Branch(left: let l, right: let r) = tree { }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S13indirect_enum10guardTreeB{{[_0-9a-zA-Z]*}}F
+func guardTreeB<T>(_ tree: TreeB<T>) {
+ do {
+ // CHECK: copy_addr %0 to [initialization] [[TMP:%.*]] :
+ // CHECK: switch_enum_addr [[TMP]] : $*TreeB<T>, case #TreeB.Nil!enumelt: [[YES:bb[0-9]+]], default [[NO:bb[0-9]+]]
+ // CHECK: [[NO]]:
+ // CHECK: destroy_addr [[TMP]]
+ // CHECK: [[YES]]:
+ // CHECK: destroy_addr [[TMP]]
+ guard case .Nil = tree else { return }
+
+ // CHECK: [[X:%.*]] = alloc_stack $T
+ // CHECK: copy_addr %0 to [initialization] [[TMP:%.*]] :
+ // CHECK: switch_enum_addr [[TMP]] : $*TreeB<T>, case #TreeB.Leaf!enumelt.1: [[YES:bb[0-9]+]], default [[NO:bb[0-9]+]]
+ // CHECK: [[NO]]:
+ // CHECK: destroy_addr [[TMP]]
+ // CHECK: [[YES]]:
+ // CHECK: [[VALUE:%.*]] = unchecked_take_enum_data_addr [[TMP]]
+ // CHECK: copy_addr [take] [[VALUE]] to [initialization] [[X]]
+ // CHECK: dealloc_stack [[TMP]]
+ guard case .Leaf(let x) = tree else { return }
+
+ // CHECK: [[L:%.*]] = alloc_stack $TreeB
+ // CHECK: [[R:%.*]] = alloc_stack $TreeB
+ // CHECK: copy_addr %0 to [initialization] [[TMP:%.*]] :
+ // CHECK: switch_enum_addr [[TMP]] : $*TreeB<T>, case #TreeB.Branch!enumelt.1: [[YES:bb[0-9]+]], default [[NO:bb[0-9]+]]
+ // CHECK: [[NO]]:
+ // CHECK: destroy_addr [[TMP]]
+ // CHECK: [[YES]]:
+ // CHECK: [[BOX_ADDR:%.*]] = unchecked_take_enum_data_addr [[TMP]]
+ // CHECK: [[BOX:%.*]] = load [take] [[BOX_ADDR]]
+ // CHECK: [[TUPLE_ADDR:%.*]] = project_box [[BOX]]
+ // CHECK: copy_addr [[TUPLE_ADDR]] to [initialization] [[TUPLE_COPY:%.*]] :
+ // CHECK: [[L_COPY:%.*]] = tuple_element_addr [[TUPLE_COPY]]
+ // CHECK: copy_addr [take] [[L_COPY]] to [initialization] [[L]]
+ // CHECK: [[R_COPY:%.*]] = tuple_element_addr [[TUPLE_COPY]]
+ // CHECK: copy_addr [take] [[R_COPY]] to [initialization] [[R]]
+ // CHECK: destroy_value [[BOX]]
+ guard case .Branch(left: let l, right: let r) = tree else { return }
+
+ // CHECK: destroy_addr [[R]]
+ // CHECK: destroy_addr [[L]]
+ // CHECK: destroy_addr [[X]]
+ }
+
+ do {
+ // CHECK: copy_addr %0 to [initialization] [[TMP:%.*]] :
+ // CHECK: switch_enum_addr [[TMP]] : $*TreeB<T>, case #TreeB.Nil!enumelt: [[YES:bb[0-9]+]], default [[NO:bb[0-9]+]]
+ // CHECK: [[NO]]:
+ // CHECK: destroy_addr [[TMP]]
+ // CHECK: [[YES]]:
+ // CHECK: destroy_addr [[TMP]]
+ if case .Nil = tree { }
+
+ // CHECK: [[X:%.*]] = alloc_stack $T
+ // CHECK: copy_addr %0 to [initialization] [[TMP:%.*]] :
+ // CHECK: switch_enum_addr [[TMP]] : $*TreeB<T>, case #TreeB.Leaf!enumelt.1: [[YES:bb[0-9]+]], default [[NO:bb[0-9]+]]
+ // CHECK: [[NO]]:
+ // CHECK: destroy_addr [[TMP]]
+ // CHECK: [[YES]]:
+ // CHECK: [[VALUE:%.*]] = unchecked_take_enum_data_addr [[TMP]]
+ // CHECK: copy_addr [take] [[VALUE]] to [initialization] [[X]]
+ // CHECK: dealloc_stack [[TMP]]
+ // CHECK: destroy_addr [[X]]
+ if case .Leaf(let x) = tree { }
+
+ // CHECK: [[L:%.*]] = alloc_stack $TreeB
+ // CHECK: [[R:%.*]] = alloc_stack $TreeB
+ // CHECK: copy_addr %0 to [initialization] [[TMP:%.*]] :
+ // CHECK: switch_enum_addr [[TMP]] : $*TreeB<T>, case #TreeB.Branch!enumelt.1: [[YES:bb[0-9]+]], default [[NO:bb[0-9]+]]
+ // CHECK: [[NO]]:
+ // CHECK: destroy_addr [[TMP]]
+ // CHECK: [[YES]]:
+ // CHECK: [[BOX_ADDR:%.*]] = unchecked_take_enum_data_addr [[TMP]]
+ // CHECK: [[BOX:%.*]] = load [take] [[BOX_ADDR]]
+ // CHECK: [[TUPLE_ADDR:%.*]] = project_box [[BOX]]
+ // CHECK: copy_addr [[TUPLE_ADDR]] to [initialization] [[TUPLE_COPY:%.*]] :
+ // CHECK: [[L_COPY:%.*]] = tuple_element_addr [[TUPLE_COPY]]
+ // CHECK: copy_addr [take] [[L_COPY]] to [initialization] [[L]]
+ // CHECK: [[R_COPY:%.*]] = tuple_element_addr [[TUPLE_COPY]]
+ // CHECK: copy_addr [take] [[R_COPY]] to [initialization] [[R]]
+ // CHECK: destroy_value [[BOX]]
+ // CHECK: destroy_addr [[R]]
+ // CHECK: destroy_addr [[L]]
+ if case .Branch(left: let l, right: let r) = tree { }
+ }
+}
+
+// SEMANTIC ARC TODO: This test needs to be made far more comprehensive.
+// CHECK-LABEL: sil hidden @$S13indirect_enum35dontDisableCleanupOfIndirectPayloadyyAA010TrivialButG0OF : $@convention(thin) (@guaranteed TrivialButIndirect) -> () {
+func dontDisableCleanupOfIndirectPayload(_ x: TrivialButIndirect) {
+ // CHECK: bb0([[ARG:%.*]] : $TrivialButIndirect):
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: switch_enum [[ARG_COPY]] : $TrivialButIndirect, case #TrivialButIndirect.Direct!enumelt.1: [[YES:bb[0-9]+]], case #TrivialButIndirect.Indirect!enumelt.1: [[NO:bb[0-9]+]]
+ //
+ // CHECK: [[NO]]([[PAYLOAD:%.*]] : ${ var Int }):
+ // CHECK: destroy_value [[PAYLOAD]]
+ guard case .Direct(let foo) = x else { return }
+
+ // CHECK: [[YES]]({{%.*}} : $Int):
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: switch_enum [[ARG_COPY]] : $TrivialButIndirect, case #TrivialButIndirect.Indirect!enumelt.1: [[YES:bb[0-9]+]], case #TrivialButIndirect.Direct!enumelt.1: [[NO:bb[0-9]+]]
+
+ // CHECK: [[NO]]({{%.*}} : $Int):
+ // CHECK-NOT: destroy_value
+
+ // CHECK: [[YES]]([[BOX:%.*]] : ${ var Int }):
+ // CHECK: destroy_value [[BOX]]
+
+ guard case .Indirect(let bar) = x else { return }
+}
+// CHECK: } // end sil function '$S13indirect_enum35dontDisableCleanupOfIndirectPayloadyyAA010TrivialButG0OF'
diff --git a/test/SILGen/plus_zero_inlineable_attribute.swift b/test/SILGen/plus_zero_inlineable_attribute.swift
new file mode 100644
index 0000000..097ea60
--- /dev/null
+++ b/test/SILGen/plus_zero_inlineable_attribute.swift
@@ -0,0 +1,101 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -emit-verbose-sil %s | %FileCheck %s
+
+// CHECK-LABEL: sil [serialized] @$S20inlineable_attribute15fragileFunctionyyF : $@convention(thin) () -> ()
+@_inlineable public func fragileFunction() {
+
+}
+
+public struct MySt {
+ // CHECK-LABEL: sil [serialized] @$S20inlineable_attribute4MyStV6methodyyF : $@convention(method) (MySt) -> ()
+ @_inlineable public func method() {}
+
+ // CHECK-LABEL: sil [serialized] @$S20inlineable_attribute4MyStV8propertySivg : $@convention(method) (MySt) -> Int
+ @_inlineable public var property: Int {
+ return 5
+ }
+
+ // CHECK-LABEL: sil [serialized] @$S20inlineable_attribute4MyStVyS2icig : $@convention(method) (Int, MySt) -> Int
+ @_inlineable public subscript(x: Int) -> Int {
+ return x
+ }
+}
+
+public class MyCls {
+ // CHECK-LABEL: sil [serialized] @$S20inlineable_attribute5MyClsCfD : $@convention(method) (@owned MyCls) -> ()
+ @_inlineable deinit {}
+
+ // Allocating entry point is [serialized]
+
+ // CHECK-LABEL: sil [serialized] @$S20inlineable_attribute5MyClsC14designatedInitACyt_tcfC : $@convention(method) (@thick MyCls.Type) -> @owned MyCls
+ public init(designatedInit: ()) {}
+
+ // Note -- convenience init is intentionally not [serialized]
+
+ // CHECK-LABEL: sil @$S20inlineable_attribute5MyClsC15convenienceInitACyt_tcfC : $@convention(method) (@thick MyCls.Type) -> @owned MyCls
+ public convenience init(convenienceInit: ()) {
+ self.init(designatedInit: ())
+ }
+}
+
+// Make sure enum case constructors for public and versioned enums are
+// [serialized].
+@_versioned enum MyEnum {
+ case c(MySt)
+}
+
+// CHECK-LABEL: sil shared [transparent] [serialized] [thunk] @$S20inlineable_attribute6MyEnumO1cyAcA0C2StVcACmFTc : $@convention(thin) (@thin MyEnum.Type) -> @owned @callee_guaranteed (MySt) -> MyEnum
+
+@_inlineable public func referencesMyEnum() {
+ _ = MyEnum.c
+}
+
+// CHECK-LABEL: sil non_abi [transparent] [serialized] @$S20inlineable_attribute15HasInitializersV1xSivpfi : $@convention(thin) () -> Int
+// CHECK-LABEL: sil non_abi [transparent] [serialized] @$S20inlineable_attribute15HasInitializersV1ySivpfi : $@convention(thin) () -> Int
+
+@_fixed_layout
+public struct HasInitializers {
+ public let x = 1234
+ internal let y = 4321
+
+ @_inlineable public init() {}
+}
+
+public class Horse {
+ public func gallop() {}
+}
+
+// CHECK-LABEL: sil [serialized] @$S20inlineable_attribute15talkAboutAHorse1hyAA5HorseC_tF : $@convention(thin) (@guaranteed Horse) -> () {
+// CHECK: function_ref @$S20inlineable_attribute5HorseC6gallopyyFTc
+// CHECK: return
+// CHECK: }
+
+// CHECK-LABEL: sil shared [serializable] [thunk] @$S20inlineable_attribute5HorseC6gallopyyFTc : $@convention(thin) (@guaranteed Horse) -> @owned @callee_guaranteed () -> () {
+// CHECK: class_method
+// CHECK: return
+// CHECK: }
+
+@_inlineable public func talkAboutAHorse(h: Horse) {
+ _ = h.gallop
+}
+
+@_versioned
+@_fixed_layout
+class Base {
+ @_versioned
+ @_inlineable
+ init(horse: Horse) {}
+}
+
+// CHECK-LABEL: sil [serialized] @$S20inlineable_attribute7DerivedCfd : $@convention(method) (@guaranteed Derived) -> @owned Builtin.NativeObject
+// CHECK-LABEL: sil [serialized] @$S20inlineable_attribute7DerivedCfD : $@convention(method) (@owned Derived) -> ()
+
+// Make sure the synthesized delegating initializer is inlineable also
+
+// CHECK-LABEL: sil [serialized] @$S20inlineable_attribute7DerivedC5horseAcA5HorseC_tcfc : $@convention(method) (@owned Horse, @owned Derived) -> @owned Derived
+@_versioned
+@_fixed_layout
+class Derived : Base {
+ // Allow @_inlineable deinits
+ @_inlineable deinit {}
+}
diff --git a/test/SILGen/plus_zero_inlineable_attribute_objc.swift b/test/SILGen/plus_zero_inlineable_attribute_objc.swift
new file mode 100644
index 0000000..a963567
--- /dev/null
+++ b/test/SILGen/plus_zero_inlineable_attribute_objc.swift
@@ -0,0 +1,35 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %build-silgen-test-overlays
+
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -Xllvm -sil-full-demangle -primary-file %s -emit-silgen | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+
+public class Horse : NSObject {
+ public dynamic func gallop() {}
+}
+
+// Make sure we can reference dynamic thunks and curry thunks
+// from inlineable scopes
+
+// CHECK-LABEL: sil [serialized] @$S25inlineable_attribute_objc15talkAboutAHorse1hyAA5HorseC_tF : $@convention(thin) (@guaranteed Horse) -> () {
+// CHECK: function_ref @$S25inlineable_attribute_objc5HorseC6gallopyyFTc : $@convention(thin) (@guaranteed Horse) -> @owned @callee_guaranteed () -> ()
+// CHECK: return
+// CHECK: }
+
+// CHECK-LABEL: sil shared [serializable] [thunk] @$S25inlineable_attribute_objc5HorseC6gallopyyFTc : $@convention(thin) (@guaranteed Horse) -> @owned @callee_guaranteed () -> ()
+// CHECK: %1 = function_ref @$S25inlineable_attribute_objc5HorseC6gallopyyFTD
+// CHECK: return
+// CHECK: }
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [thunk] @$S25inlineable_attribute_objc5HorseC6gallopyyFTD : $@convention(method) (@guaranteed Horse) -> ()
+// CHECK: objc_method
+// CHECK: return
+// CHECK: }
+
+@_inlineable public func talkAboutAHorse(h: Horse) {
+ _ = h.gallop
+}
diff --git a/test/SILGen/plus_zero_keypath_application.swift b/test/SILGen/plus_zero_keypath_application.swift
new file mode 100644
index 0000000..1dbd44e
--- /dev/null
+++ b/test/SILGen/plus_zero_keypath_application.swift
@@ -0,0 +1,124 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+class A {}
+class B {}
+protocol P {}
+protocol Q {}
+
+// CHECK-LABEL: sil hidden @{{.*}}loadable
+func loadable(readonly: A, writable: inout A,
+ value: B,
+ kp: KeyPath<A, B>,
+ wkp: WritableKeyPath<A, B>,
+ rkp: ReferenceWritableKeyPath<A, B>) {
+ // CHECK: [[ROOT_TMP:%.*]] = alloc_stack $A
+ // CHECK: [[ROOT_COPY:%.*]] = copy_value %0
+ // CHECK: store [[ROOT_COPY]] to [init] [[ROOT_TMP]]
+ // CHECK: [[KP_COPY:%.*]] = copy_value %3
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}_projectKeyPathReadOnly
+ // CHECK: [[BORROWED_KP_COPY:%.*]] = begin_borrow [[KP_COPY]]
+ // CHECK: [[RESULT_TMP:%.*]] = alloc_stack $B
+ // CHECK: apply [[PROJECT]]<A, B>([[RESULT_TMP]], [[ROOT_TMP]], [[BORROWED_KP_COPY]])
+ // CHECK: [[RESULT:%.*]] = load [take] [[RESULT_TMP]]
+ // CHECK: destroy_value [[RESULT]]
+ _ = readonly[keyPath: kp]
+ _ = writable[keyPath: kp]
+ _ = readonly[keyPath: wkp]
+
+ // CHECK: function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = writable[keyPath: wkp]
+
+ // CHECK: function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = readonly[keyPath: rkp]
+ // CHECK: function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = writable[keyPath: rkp]
+
+ // CHECK: function_ref @{{.*}}_projectKeyPathWritable
+ writable[keyPath: wkp] = value
+ // CHECK: function_ref @{{.*}}_projectKeyPathReferenceWritable
+ readonly[keyPath: rkp] = value
+ // CHECK: function_ref @{{.*}}_projectKeyPathReferenceWritable
+ writable[keyPath: rkp] = value
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}addressOnly
+func addressOnly(readonly: P, writable: inout P,
+ value: Q,
+ kp: KeyPath<P, Q>,
+ wkp: WritableKeyPath<P, Q>,
+ rkp: ReferenceWritableKeyPath<P, Q>) {
+ // CHECK: function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = readonly[keyPath: kp]
+ // CHECK: function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = writable[keyPath: kp]
+ // CHECK: function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = readonly[keyPath: wkp]
+
+ // CHECK: function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = writable[keyPath: wkp]
+
+ // CHECK: function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = readonly[keyPath: rkp]
+ // CHECK: function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = writable[keyPath: rkp]
+
+ // CHECK: function_ref @{{.*}}_projectKeyPathWritable
+ writable[keyPath: wkp] = value
+ // CHECK: function_ref @{{.*}}_projectKeyPathReferenceWritable
+ readonly[keyPath: rkp] = value
+ // CHECK: function_ref @{{.*}}_projectKeyPathReferenceWritable
+ writable[keyPath: rkp] = value
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}reabstracted
+func reabstracted(readonly: @escaping () -> (),
+ writable: inout () -> (),
+ value: @escaping (A) -> B,
+ kp: KeyPath<() -> (), (A) -> B>,
+ wkp: WritableKeyPath<() -> (), (A) -> B>,
+ rkp: ReferenceWritableKeyPath<() -> (), (A) -> B>) {
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = readonly[keyPath: kp]
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = writable[keyPath: kp]
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = readonly[keyPath: wkp]
+
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = writable[keyPath: wkp]
+
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = readonly[keyPath: rkp]
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}_projectKeyPathReadOnly
+ _ = writable[keyPath: rkp]
+
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}_projectKeyPathWritable
+ writable[keyPath: wkp] = value
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}_projectKeyPathReferenceWritable
+ readonly[keyPath: rkp] = value
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}_projectKeyPathReferenceWritable
+ writable[keyPath: rkp] = value
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}partial
+func partial<A>(valueA: A,
+ valueB: Int,
+ pkpA: PartialKeyPath<A>,
+ pkpB: PartialKeyPath<Int>,
+ akp: AnyKeyPath) {
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}projectKeyPathAny
+ // CHECK: apply [[PROJECT]]<A>
+ _ = valueA[keyPath: akp]
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}projectKeyPathPartial
+ // CHECK: apply [[PROJECT]]<A>
+ _ = valueA[keyPath: pkpA]
+
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}projectKeyPathAny
+ // CHECK: apply [[PROJECT]]<Int>
+ _ = valueB[keyPath: akp]
+ // CHECK: [[PROJECT:%.*]] = function_ref @{{.*}}projectKeyPathPartial
+ // CHECK: apply [[PROJECT]]<Int>
+ _ = valueB[keyPath: pkpB]
+}
+
diff --git a/test/SILGen/plus_zero_keypaths.swift b/test/SILGen/plus_zero_keypaths.swift
new file mode 100644
index 0000000..db06785
--- /dev/null
+++ b/test/SILGen/plus_zero_keypaths.swift
@@ -0,0 +1,339 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+struct S<T> {
+ var x: T
+ let y: String
+ var z: C<T>
+
+ var computed: C<T> { fatalError() }
+ var observed: C<T> { didSet { fatalError() } }
+ var reabstracted: () -> ()
+}
+class C<T> {
+ final var x: T
+ final let y: String
+ final var z: S<T>
+
+ var nonfinal: S<T>
+ var computed: S<T> { fatalError() }
+ var observed: S<T> { didSet { fatalError() } }
+ final var reabstracted: () -> ()
+
+ init() { fatalError() }
+}
+
+protocol P {
+ var x: Int { get }
+ var y: String { get set }
+}
+
+extension P {
+ var z: String {
+ return y
+ }
+ var w: String {
+ get { return "" }
+ nonmutating set { }
+ }
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}storedProperties
+func storedProperties<T>(_: T) {
+ // CHECK: keypath $WritableKeyPath<S<T>, T>, <τ_0_0> (root $S<τ_0_0>; stored_property #S.x : $τ_0_0) <T>
+ _ = \S<T>.x
+ // CHECK: keypath $KeyPath<S<T>, String>, <τ_0_0> (root $S<τ_0_0>; stored_property #S.y : $String) <T>
+ _ = \S<T>.y
+ // CHECK: keypath $ReferenceWritableKeyPath<S<T>, T>, <τ_0_0> (root $S<τ_0_0>; stored_property #S.z : $C<τ_0_0>; stored_property #C.x : $τ_0_0) <T>
+ _ = \S<T>.z.x
+ // CHECK: keypath $ReferenceWritableKeyPath<C<T>, T>, <τ_0_0> (root $C<τ_0_0>; stored_property #C.x : $τ_0_0) <T>
+ _ = \C<T>.x
+ // CHECK: keypath $KeyPath<C<T>, String>, <τ_0_0> (root $C<τ_0_0>; stored_property #C.y : $String) <T>
+ _ = \C<T>.y
+ // CHECK: keypath $ReferenceWritableKeyPath<C<T>, T>, <τ_0_0> (root $C<τ_0_0>; stored_property #C.z : $S<τ_0_0>; stored_property #S.x : $τ_0_0) <T>
+ _ = \C<T>.z.x
+ // CHECK: keypath $KeyPath<C<T>, String>, <τ_0_0> (root $C<τ_0_0>; stored_property #C.z : $S<τ_0_0>; stored_property #S.z : $C<τ_0_0>; stored_property #C.y : $String) <T>
+ _ = \C<T>.z.z.y
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}computedProperties
+func computedProperties<T: P>(_: T) {
+ // CHECK: keypath $ReferenceWritableKeyPath<C<T>, S<T>>, <τ_0_0 where τ_0_0 : P> (
+ // CHECK-SAME: root $C<τ_0_0>;
+ // CHECK-SAME: settable_property $S<τ_0_0>,
+ // CHECK-SAME: id #C.nonfinal!getter.1 : <T> (C<T>) -> () -> S<T>,
+ // CHECK-SAME: getter @$S8keypaths1CC8nonfinalAA1SVyxGvpAA1PRzlACyxGTK : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed C<τ_0_0>) -> @out S<τ_0_0>,
+ // CHECK-SAME: setter @$S8keypaths1CC8nonfinalAA1SVyxGvpAA1PRzlACyxGTk : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed S<τ_0_0>, @in_guaranteed C<τ_0_0>) -> ()
+ // CHECK-SAME: ) <T>
+ _ = \C<T>.nonfinal
+
+ // CHECK: keypath $KeyPath<C<T>, S<T>>, <τ_0_0 where τ_0_0 : P> (
+ // CHECK-SAME: root $C<τ_0_0>;
+ // CHECK-SAME: gettable_property $S<τ_0_0>,
+ // CHECK-SAME: id #C.computed!getter.1 : <T> (C<T>) -> () -> S<T>,
+ // CHECK-SAME: getter @$S8keypaths1CC8computedAA1SVyxGvpAA1PRzlACyxGTK : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed C<τ_0_0>) -> @out S<τ_0_0>
+ // CHECK-SAME: ) <T>
+ _ = \C<T>.computed
+
+ // CHECK: keypath $ReferenceWritableKeyPath<C<T>, S<T>>, <τ_0_0 where τ_0_0 : P> (
+ // CHECK-SAME: root $C<τ_0_0>;
+ // CHECK-SAME: settable_property $S<τ_0_0>,
+ // CHECK-SAME: id #C.observed!getter.1 : <T> (C<T>) -> () -> S<T>,
+ // CHECK-SAME: getter @$S8keypaths1CC8observedAA1SVyxGvpAA1PRzlACyxGTK : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed C<τ_0_0>) -> @out S<τ_0_0>,
+ // CHECK-SAME: setter @$S8keypaths1CC8observedAA1SVyxGvpAA1PRzlACyxGTk : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed S<τ_0_0>, @in_guaranteed C<τ_0_0>) -> ()
+ // CHECK-SAME: ) <T>
+ _ = \C<T>.observed
+
+ _ = \C<T>.nonfinal.x
+ _ = \C<T>.computed.x
+ _ = \C<T>.observed.x
+ _ = \C<T>.z.computed
+ _ = \C<T>.z.observed
+ _ = \C<T>.observed.x
+
+ // CHECK: keypath $ReferenceWritableKeyPath<C<T>, () -> ()>, <τ_0_0 where τ_0_0 : P> (
+ // CHECK-SAME: root $C<τ_0_0>;
+ // CHECK-SAME: settable_property $() -> (),
+ // CHECK-SAME: id ##C.reabstracted,
+ // CHECK-SAME: getter @$S8keypaths1CC12reabstractedyycvpAA1PRzlACyxGTK : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed C<τ_0_0>) -> @out @callee_guaranteed (@in_guaranteed ()) -> @out (),
+ // CHECK-SAME: setter @$S8keypaths1CC12reabstractedyycvpAA1PRzlACyxGTk : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed @callee_guaranteed (@in_guaranteed ()) -> @out (), @in_guaranteed C<τ_0_0>) -> ()
+ // CHECK-SAME: ) <T>
+ _ = \C<T>.reabstracted
+
+ // CHECK: keypath $KeyPath<S<T>, C<T>>, <τ_0_0 where τ_0_0 : P> (
+ // CHECK-SAME: root $S<τ_0_0>; gettable_property $C<τ_0_0>,
+ // CHECK-SAME: id @$S8keypaths1SV8computedAA1CCyxGvg : $@convention(method) <τ_0_0> (@in_guaranteed S<τ_0_0>) -> @owned C<τ_0_0>,
+ // CHECK-SAME: getter @$S8keypaths1SV8computedAA1CCyxGvpAA1PRzlACyxGTK : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed S<τ_0_0>) -> @out C<τ_0_0>
+ // CHECK-SAME: ) <T>
+ _ = \S<T>.computed
+
+ // CHECK: keypath $WritableKeyPath<S<T>, C<T>>, <τ_0_0 where τ_0_0 : P> (
+ // CHECK-SAME: root $S<τ_0_0>;
+ // CHECK-SAME: settable_property $C<τ_0_0>,
+ // CHECK-SAME: id @$S8keypaths1SV8observedAA1CCyxGvg : $@convention(method) <τ_0_0> (@in_guaranteed S<τ_0_0>) -> @owned C<τ_0_0>,
+ // CHECK-SAME: getter @$S8keypaths1SV8observedAA1CCyxGvpAA1PRzlACyxGTK : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed S<τ_0_0>) -> @out C<τ_0_0>,
+ // CHECK-SAME: setter @$S8keypaths1SV8observedAA1CCyxGvpAA1PRzlACyxGTk : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed C<τ_0_0>, @inout S<τ_0_0>) -> ()
+ // CHECK-SAME: ) <T>
+ _ = \S<T>.observed
+ _ = \S<T>.z.nonfinal
+ _ = \S<T>.z.computed
+ _ = \S<T>.z.observed
+ _ = \S<T>.computed.x
+ _ = \S<T>.computed.y
+ // CHECK: keypath $WritableKeyPath<S<T>, () -> ()>, <τ_0_0 where τ_0_0 : P> (
+ // CHECK-SAME: root $S<τ_0_0>;
+ // CHECK-SAME: settable_property $() -> (),
+ // CHECK-SAME: id ##S.reabstracted,
+ // CHECK-SAME: getter @$S8keypaths1SV12reabstractedyycvpAA1PRzlACyxGTK : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed S<τ_0_0>) -> @out @callee_guaranteed (@in_guaranteed ()) -> @out (),
+ // CHECK-SAME: setter @$S8keypaths1SV12reabstractedyycvpAA1PRzlACyxGTk : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed @callee_guaranteed (@in_guaranteed ()) -> @out (), @inout S<τ_0_0>) -> ()
+ // CHECK-SAME: ) <T>
+ _ = \S<T>.reabstracted
+
+ // CHECK: keypath $KeyPath<T, Int>, <τ_0_0 where τ_0_0 : P> (
+ // CHECK-SAME: root $τ_0_0;
+ // CHECK-SAME: gettable_property $Int,
+ // CHECK-SAME: id #P.x!getter.1 : <Self where Self : P> (Self) -> () -> Int,
+ // CHECK-SAME: getter @$S8keypaths1PP1xSivpAaBRzlxTK : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> @out Int
+ // CHECK-SAME: ) <T>
+ _ = \T.x
+ // CHECK: keypath $WritableKeyPath<T, String>, <τ_0_0 where τ_0_0 : P> (
+ // CHECK-SAME: root $τ_0_0;
+ // CHECK-SAME: settable_property $String,
+ // CHECK-SAME: id #P.y!getter.1 : <Self where Self : P> (Self) -> () -> String,
+ // CHECK-SAME: getter @$S8keypaths1PP1ySSvpAaBRzlxTK : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> @out String,
+ // CHECK-SAME: setter @$S8keypaths1PP1ySSvpAaBRzlxTk : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed String, @inout τ_0_0) -> ()
+ // CHECK-SAME: ) <T>
+ _ = \T.y
+
+ // CHECK: keypath $KeyPath<T, String>, <τ_0_0 where τ_0_0 : P> (
+ // CHECK-SAME: root $τ_0_0;
+ // CHECK-SAME: gettable_property $String,
+ // CHECK-SAME: id @$S8keypaths1PPAAE1zSSvg
+ _ = \T.z
+}
+
+struct Concrete: P {
+ var x: Int
+ var y: String
+}
+
+// CHECK-LABEL: sil hidden @$S8keypaths35keyPathsWithSpecificGenericInstanceyyF
+func keyPathsWithSpecificGenericInstance() {
+ // CHECK: keypath $KeyPath<Concrete, String>, (
+ // CHECK-SAME: gettable_property $String,
+ // CHECK-SAME: id @$S8keypaths1PPAAE1zSSvg
+ // CHECK-SAME: getter @$S8keypaths1PPAAE1zSSvpAA8ConcreteVTK : $@convention(thin) (@in_guaranteed Concrete) -> @out String
+ _ = \Concrete.z
+ _ = \S<Concrete>.computed
+}
+
+class AA<T> {
+ var a: Int { get { return 0 } set { } }
+}
+class BB<U, V>: AA<V> {
+}
+
+func keyPathForInheritedMember() {
+ _ = \BB<Int, String>.a
+}
+
+func keyPathForExistentialMember() {
+ _ = \P.x
+ _ = \P.y
+ _ = \P.z
+ _ = \P.w
+}
+
+struct OptionalFields {
+ var x: S<Int>?
+}
+struct OptionalFields2 {
+ var y: OptionalFields?
+}
+
+// CHECK-LABEL: sil hidden @$S8keypaths18keyPathForOptionalyyF
+func keyPathForOptional() {
+ // CHECK: keypath $WritableKeyPath<OptionalFields, S<Int>>, (
+ // CHECK-SAME: stored_property #OptionalFields.x : $Optional<S<Int>>;
+ // CHECK-SAME: optional_force : $S<Int>)
+ _ = \OptionalFields.x!
+ // CHECK: keypath $KeyPath<OptionalFields, Optional<String>>, (
+ // CHECK-SAME: stored_property #OptionalFields.x : $Optional<S<Int>>;
+ // CHECK-SAME: optional_chain : $S<Int>;
+ // CHECK-SAME: stored_property #S.y : $String;
+ // CHECK-SAME: optional_wrap : $Optional<String>)
+ _ = \OptionalFields.x?.y
+ // CHECK: keypath $KeyPath<OptionalFields2, Optional<S<Int>>>, (
+ // CHECK-SAME: root $OptionalFields2;
+ // CHECK-SAME: stored_property #OptionalFields2.y : $Optional<OptionalFields>;
+ // CHECK-SAME: optional_chain : $OptionalFields;
+ // CHECK-SAME: stored_property #OptionalFields.x : $Optional<S<Int>>)
+ _ = \OptionalFields2.y?.x
+}
+
+class StorageQualified {
+ weak var tooWeak: StorageQualified?
+ unowned var disowned: StorageQualified
+
+ init() { fatalError() }
+}
+
+final class FinalStorageQualified {
+ weak var tooWeak: StorageQualified?
+ unowned var disowned: StorageQualified
+
+ init() { fatalError() }
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}keyPathForStorageQualified
+func keyPathForStorageQualified() {
+ // CHECK: = keypath $ReferenceWritableKeyPath<StorageQualified, Optional<StorageQualified>>,
+ // CHECK-SAME: settable_property $Optional<StorageQualified>, id #StorageQualified.tooWeak!getter.1
+ _ = \StorageQualified.tooWeak
+ // CHECK: = keypath $ReferenceWritableKeyPath<StorageQualified, StorageQualified>,
+ // CHECK-SAME: settable_property $StorageQualified, id #StorageQualified.disowned!getter.1
+ _ = \StorageQualified.disowned
+
+ // CHECK: = keypath $ReferenceWritableKeyPath<FinalStorageQualified, Optional<StorageQualified>>,
+ // CHECK-SAME: settable_property $Optional<StorageQualified>, id ##FinalStorageQualified.tooWeak
+ _ = \FinalStorageQualified.tooWeak
+ // CHECK: = keypath $ReferenceWritableKeyPath<FinalStorageQualified, StorageQualified>,
+ // CHECK-SAME: settable_property $StorageQualified, id ##FinalStorageQualified.disowned
+ _ = \FinalStorageQualified.disowned
+}
+
+struct IUOProperty {
+ var iuo: IUOBlob!
+}
+
+struct IUOBlob {
+ var x: Int
+ subscript(y: String) -> String {
+ get { return y }
+ set {}
+ }
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}11iuoKeyPaths
+func iuoKeyPaths() {
+ // CHECK: = keypath $WritableKeyPath<IUOProperty, Int>,
+ // CHECK-SAME: stored_property #IUOProperty.iuo
+ // CHECK-SAME: optional_force
+ // CHECK-SAME: stored_property #IUOBlob.x
+ _ = \IUOProperty.iuo.x
+ // CHECK: = keypath $WritableKeyPath<IUOProperty, Int>,
+ // CHECK-SAME: stored_property #IUOProperty.iuo
+ // CHECK-SAME: optional_force
+ // CHECK-SAME: stored_property #IUOBlob.x
+ _ = \IUOProperty.iuo!.x
+}
+
+class Bass: Hashable {
+ static func ==(_: Bass, _: Bass) -> Bool { return false }
+ var hashValue: Int { return 0 }
+}
+
+class Treble: Bass { }
+
+struct Subscripts<T> {
+ subscript() -> T {
+ get { fatalError() }
+ set { fatalError() }
+ }
+ subscript(generic x: T) -> T {
+ get { fatalError() }
+ set { fatalError() }
+ }
+ subscript(concrete x: String) -> String {
+ get { fatalError() }
+ set { fatalError() }
+ }
+ subscript(x: String, y: String) -> String {
+ get { fatalError() }
+ set { fatalError() }
+ }
+ subscript<U>(subGeneric z: U) -> U {
+ get { fatalError() }
+ set { fatalError() }
+ }
+ subscript(mutable x: T) -> T {
+ get { fatalError() }
+ set { fatalError() }
+ }
+ subscript(bass: Bass) -> Bass {
+ get { return bass }
+ set { }
+ }
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}10subscripts
+func subscripts<T: Hashable, U: Hashable>(x: T, y: U, s: String) {
+ _ = \Subscripts<T>.[]
+ _ = \Subscripts<T>.[generic: x]
+ _ = \Subscripts<T>.[concrete: s]
+ _ = \Subscripts<T>.[s, s]
+ _ = \Subscripts<T>.[subGeneric: s]
+ _ = \Subscripts<T>.[subGeneric: x]
+ _ = \Subscripts<T>.[subGeneric: y]
+
+ _ = \Subscripts<U>.[]
+ _ = \Subscripts<U>.[generic: y]
+ _ = \Subscripts<U>.[concrete: s]
+ _ = \Subscripts<U>.[s, s]
+ _ = \Subscripts<U>.[subGeneric: s]
+ _ = \Subscripts<U>.[subGeneric: x]
+ _ = \Subscripts<U>.[subGeneric: y]
+
+ _ = \Subscripts<String>.[]
+ _ = \Subscripts<String>.[generic: s]
+ _ = \Subscripts<String>.[concrete: s]
+ _ = \Subscripts<String>.[s, s]
+ _ = \Subscripts<String>.[subGeneric: s]
+ _ = \Subscripts<String>.[subGeneric: x]
+ _ = \Subscripts<String>.[subGeneric: y]
+
+ _ = \Subscripts<T>.[s, s].count
+
+ _ = \Subscripts<T>.[Bass()]
+ _ = \Subscripts<T>.[Treble()]
+}
diff --git a/test/SILGen/plus_zero_let_decls.swift b/test/SILGen/plus_zero_let_decls.swift
new file mode 100644
index 0000000..d0f7379
--- /dev/null
+++ b/test/SILGen/plus_zero_let_decls.swift
@@ -0,0 +1,518 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+func takeClosure(_ a : () -> Int) {}
+
+// Let decls don't get boxes for trivial types.
+//
+// CHECK-LABEL: sil hidden @{{.*}}test1
+func test1(_ a : Int) -> Int {
+ // CHECK-NOT: alloc_box
+ // FIXME(integers): the following check should be updated for the new way +
+ // gets invoked. <rdar://problem/29939484>
+ // XCHECK-NOT: alloc_stack
+
+ let (b,c) = (a, 32)
+
+ return b+c
+
+ // CHECK: return
+}
+
+// rdar://15716277
+// CHECK: @{{.*}}_destructuring
+func let_destructuring() -> Int {
+ let (a, b) = ((1,2), 5)
+ return a.1+a.0+b
+}
+
+// Let decls being closed over.
+//
+// CHECK-LABEL: sil hidden @{{.*}}test2
+func test2() {
+ // No allocations.
+ // CHECK-NOT: alloc_box
+ // CHECK-NOT: alloc_stack
+
+ let x = 42
+
+ takeClosure({x})
+
+
+ // CHECK: return
+}
+
+// The closure just returns its value, which it captured directly.
+
+// CHECK: sil private @$S9let_decls5test2yyFSiyXEfU_ : $@convention(thin) (Int) -> Int
+// CHECK: bb0(%0 : @trivial $Int):
+// CHECK: return %0 : $Int
+
+// Verify that we can close over let decls of tuple type.
+struct RegularStruct {
+ var a: Int
+}
+func testTupleLetCapture() {
+ let t = (RegularStruct(a: 41), 42)
+
+ takeClosure( { t.0.a })
+}
+
+
+
+func getAString() -> String { return "" }
+func useAString(_ a : String) {}
+
+// rdar://15689514 - Verify that the cleanup for the let decl runs at the end of
+// the 'let' lifetime, not at the end of the initializing expression.
+//
+// CHECK-LABEL: sil hidden @{{.*}}test3
+func test3() {
+ // CHECK: [[GETFN:%[0-9]+]] = function_ref{{.*}}getAString
+ // CHECK-NEXT: [[STR:%[0-9]+]] = apply [[GETFN]]()
+ let o = getAString()
+
+ // CHECK-NEXT: debug_value
+ // CHECK-NOT: destroy_value
+
+ // CHECK-NEXT: [[STR_BORROW:%.*]] = begin_borrow [[STR]]
+ // CHECK: [[USEFN:%[0-9]+]] = function_ref{{.*}}useAString
+ // CHECK-NEXT: [[USE:%[0-9]+]] = apply [[USEFN]]([[STR_BORROW]])
+ useAString(o)
+
+ // CHECK: destroy_value [[STR]]
+}
+// CHECK: } // end sil function '{{.*}}test3{{.*}}'
+
+
+
+struct AddressOnlyStruct<T> {
+ var elt : T
+ var str : String
+}
+
+func produceAddressOnlyStruct<T>(_ x : T) -> AddressOnlyStruct<T> {}
+
+// CHECK-LABEL: sil hidden @{{.*}}testAddressOnlyStructString
+// CHECK: bb0([[FUNC_ARG:%.*]] : @trivial $*T):
+func testAddressOnlyStructString<T>(_ a : T) -> String {
+ return produceAddressOnlyStruct(a).str
+
+ // CHECK: [[TMPSTRUCT:%[0-9]+]] = alloc_stack $AddressOnlyStruct<T>
+ // CHECK: [[PRODFN:%[0-9]+]] = function_ref @{{.*}}produceAddressOnlyStruct
+ // CHECK: apply [[PRODFN]]<T>([[TMPSTRUCT]], [[FUNC_ARG]])
+ // CHECK-NEXT: [[STRADDR:%[0-9]+]] = struct_element_addr [[TMPSTRUCT]] : $*AddressOnlyStruct<T>, #AddressOnlyStruct.str
+ // CHECK-NEXT: [[STRVAL:%[0-9]+]] = load [copy] [[STRADDR]]
+ // CHECK-NEXT: destroy_addr [[TMPSTRUCT]]
+ // CHECK-NEXT: dealloc_stack [[TMPSTRUCT]]
+ // CHECK: return [[STRVAL]]
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}testAddressOnlyStructElt
+func testAddressOnlyStructElt<T>(_ a : T) -> T {
+ return produceAddressOnlyStruct(a).elt
+ // CHECK: bb0([[ARG0:%.*]] : @trivial $*T, [[ARG1:%.*]] : @trivial $*T):
+ // CHECK: [[TMPSTRUCT:%[0-9]+]] = alloc_stack $AddressOnlyStruct<T>
+ // CHECK: [[PRODFN:%[0-9]+]] = function_ref @{{.*}}produceAddressOnlyStruct
+ // CHECK: apply [[PRODFN]]<T>([[TMPSTRUCT]], [[ARG1]])
+ // CHECK-NEXT: [[ELTADDR:%[0-9]+]] = struct_element_addr [[TMPSTRUCT]] : $*AddressOnlyStruct<T>, #AddressOnlyStruct.elt
+ // CHECK-NEXT: copy_addr [[ELTADDR]] to [initialization] %0 : $*T
+ // CHECK-NEXT: destroy_addr [[TMPSTRUCT]]
+}
+
+
+
+// rdar://15717123 - let decls of address-only type.
+
+// CHECK-LABEL: sil hidden @{{.*}}testAddressOnlyLet
+func testAddressOnlyLet<T>(_ a : T) {
+ let x = produceAddressOnlyStruct(a)
+}
+
+
+func produceSubscriptableRValue() -> [String] {}
+
+// CHECK-LABEL: sil hidden @{{.*}}subscriptRValue
+func subscriptRValue() {
+ var a = produceSubscriptableRValue()[0]
+}
+
+
+struct GetOnlySubscriptStruct {
+ // get-only subscript
+ subscript (i : Int) -> Int { get {} }
+}
+
+
+// CHECK-LABEL: sil hidden @{{.*}}testGetOnlySubscript
+func testGetOnlySubscript(_ x : GetOnlySubscriptStruct, idx : Int) -> Int {
+ return x[idx]
+
+ // CHECK: [[SUBFN:%[0-9]+]] = function_ref @{{.*}}i
+ // CHECK-NEXT: [[CALL:%[0-9]+]] = apply [[SUBFN]](
+ // CHECK: return [[CALL]]
+}
+
+// Address-only let's get captured by box.
+extension Optional {
+ func getLV() -> Int { }
+}
+struct CloseOverAddressOnlyConstant<T> {
+ func isError() {
+ let AOV: T?
+ takeClosure({ AOV.getLV() })
+ }
+
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}callThroughLet
+func callThroughLet(_ predicate: @escaping (Int, Int) -> Bool) {
+ let p = predicate
+ if p(1, 2) {
+ }
+}
+
+
+// Verify that we can emit address-only rvalues directly into the result slot in
+// chained calls.
+struct GenericTestStruct<T> {
+ func pass_address_only_rvalue_result(_ i: Int) -> T {
+ return self[i]
+ }
+ subscript (i : Int) -> T {
+ get {}
+ set {}
+ }
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}pass_address_only_rvalue_result
+// CHECK: bb0(%0 : @trivial $*T,
+// CHECK: [[FN:%[0-9]+]] = function_ref @{{.*}}GenericTestStructV{{.*}}ig
+// CHECK: apply [[FN]]<T>(%0,
+
+
+struct NonMutableSubscriptable {
+ subscript(x : Int) -> Int {
+ get {}
+ nonmutating
+ set {}
+ }
+}
+
+func produceNMSubscriptableRValue() -> NonMutableSubscriptable {}
+
+
+// CHECK-LABEL: sil hidden @{{.*}}test_nm_subscript_get
+// CHECK: bb0(%0 : @trivial $Int):
+// CHECK: [[FR1:%[0-9]+]] = function_ref @{{.*}}produceNMSubscriptableRValue
+// CHECK-NEXT: [[RES:%[0-9]+]] = apply [[FR1]]()
+// CHECK: [[GETFN:%[0-9]+]] = function_ref @$S9let_decls23NonMutableSubscriptableV{{[_0-9a-zA-Z]*}}ig
+// CHECK-NEXT: [[RES2:%[0-9]+]] = apply [[GETFN]](%0, [[RES]])
+// CHECK-NEXT: return [[RES2]]
+func test_nm_subscript_get(_ a : Int) -> Int {
+ return produceNMSubscriptableRValue()[a]
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}test_nm_subscript_set
+// CHECK: bb0(%0 : @trivial $Int):
+// CHECK: [[FR1:%[0-9]+]] = function_ref @{{.*}}produceNMSubscriptableRValue
+// CHECK-NEXT: [[RES:%[0-9]+]] = apply [[FR1]]()
+// CHECK: [[SETFN:%[0-9]+]] = function_ref @$S9let_decls23NonMutableSubscriptableV{{[_0-9a-zA-Z]*}}is
+// CHECK-NEXT: [[RES2:%[0-9]+]] = apply [[SETFN]](%0, %0, [[RES]])
+func test_nm_subscript_set(_ a : Int) {
+ produceNMSubscriptableRValue()[a] = a
+}
+
+struct WeirdPropertyTest {
+ // This property has a mutating getter and !mutating setter.
+ var p : Int {
+ mutating
+ get {}
+ nonmutating
+ set {}
+ }
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}test_weird_property
+func test_weird_property(_ v : WeirdPropertyTest, i : Int) -> Int {
+ var v = v
+ // CHECK: [[VBOX:%[0-9]+]] = alloc_box ${ var WeirdPropertyTest }
+ // CHECK: [[PB:%.*]] = project_box [[VBOX]]
+ // CHECK: store %0 to [trivial] [[PB]]
+
+ // The setter isn't mutating, so we need to load the box.
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PB]]
+ // CHECK: [[VVAL:%[0-9]+]] = load [trivial] [[READ]]
+ // CHECK: [[SETFN:%[0-9]+]] = function_ref @$S9let_decls17WeirdPropertyTestV1pSivs
+ // CHECK: apply [[SETFN]](%1, [[VVAL]])
+ v.p = i
+
+ // The getter is mutating, so it takes the box address.
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB]]
+ // CHECK: [[GETFN:%[0-9]+]] = function_ref @$S9let_decls17WeirdPropertyTestV1pSivg
+ // CHECK-NEXT: [[RES:%[0-9]+]] = apply [[GETFN]]([[WRITE]])
+ // CHECK: return [[RES]]
+ return v.p
+}
+
+
+// CHECK-LABEL: sil hidden @{{.*}}generic_identity
+// CHECK: bb0(%0 : @trivial $*T, %1 : @trivial $*T):
+// CHECK-NEXT: debug_value_addr %1 : $*T
+// CHECK-NEXT: copy_addr %1 to [initialization] %0 : $*T
+// CHECK-NOT: destroy_addr %1
+// CHECK: } // end sil function '{{.*}}generic_identity{{.*}}'
+func generic_identity<T>(_ a : T) -> T {
+ // Should be a single copy_addr, with no temporary.
+ return a
+}
+
+struct StaticLetMember {
+ static let x = 5
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}testStaticLetMember
+func testStaticLetMember() -> Int {
+
+ // CHECK: function_ref @{{.*}}StaticLetMemberV1xSi
+ // CHECK: load {{.*}} : $*Int
+ // CHECK-NEXT: return
+ return StaticLetMember.x
+}
+
+protocol SimpleProtocol {
+ func doSomethingGreat()
+}
+
+// Verify that no temporaries+copies are produced when calling non-@mutable
+// methods on protocol and archetypes calls.
+
+// CHECK-LABEL: sil hidden @{{.*}}testLetProtocolBases
+// CHECK: bb0(%0 : @trivial $*SimpleProtocol):
+func testLetProtocolBases(_ p : SimpleProtocol) {
+ // CHECK-NEXT: debug_value_addr
+ // CHECK-NEXT: open_existential_addr
+ // CHECK-NEXT: witness_method
+ // CHECK-NEXT: apply
+ p.doSomethingGreat()
+
+ // CHECK-NEXT: open_existential_addr
+ // CHECK-NEXT: witness_method
+ // CHECK-NEXT: apply
+ p.doSomethingGreat()
+
+ // CHECK-NOT: destroy_addr %0
+ // CHECK-NEXT: tuple
+ // CHECK-NEXT: return
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}testLetArchetypeBases
+// CHECK: bb0(%0 : @trivial $*T):
+func testLetArchetypeBases<T : SimpleProtocol>(_ p : T) {
+ // CHECK-NEXT: debug_value_addr
+ // CHECK-NEXT: witness_method $T
+ // CHECK-NEXT: apply
+ p.doSomethingGreat()
+ // CHECK-NEXT: witness_method $T
+ // CHECK-NEXT: apply
+ p.doSomethingGreat()
+
+ // CHECK-NOT: destroy_addr %0
+ // CHECK-NEXT: tuple
+ // CHECK-NEXT: return
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}testDebugValue
+// CHECK: bb0(%0 : @trivial $Int, %1 : @trivial $*SimpleProtocol):
+// CHECK-NEXT: debug_value %0 : $Int, let, name "a"
+// CHECK-NEXT: debug_value_addr %1 : $*SimpleProtocol, let, name "b"
+func testDebugValue(_ a : Int, b : SimpleProtocol) -> Int {
+
+ // CHECK-NEXT: debug_value %0 : $Int, let, name "x"
+ let x = a
+
+ // CHECK: apply
+ b.doSomethingGreat()
+
+ // CHECK-NOT: destroy_addr
+
+ // CHECK: return %0
+ return x
+}
+
+
+// CHECK-LABEL: sil hidden @{{.*}}testAddressOnlyTupleArgument
+func testAddressOnlyTupleArgument(_ bounds: (start: SimpleProtocol, pastEnd: Int)) {
+// CHECK: bb0(%0 : @trivial $*SimpleProtocol, %1 : @trivial $Int):
+// CHECK-NEXT: %2 = alloc_stack $(start: SimpleProtocol, pastEnd: Int), let, name "bounds"
+// CHECK-NEXT: %3 = tuple_element_addr %2 : $*(start: SimpleProtocol, pastEnd: Int), 0
+// CHECK-NEXT: copy_addr %0 to [initialization] %3 : $*SimpleProtocol
+// CHECK-NEXT: %5 = tuple_element_addr %2 : $*(start: SimpleProtocol, pastEnd: Int), 1
+// CHECK-NEXT: store %1 to [trivial] %5 : $*Int
+// CHECK-NEXT: debug_value_addr %2
+// CHECK-NEXT: destroy_addr %2 : $*(start: SimpleProtocol, pastEnd: Int)
+// CHECK-NEXT: dealloc_stack %2 : $*(start: SimpleProtocol, pastEnd: Int)
+}
+
+
+func address_only_let_closure<T>(_ x:T) -> T {
+ return { { x }() }()
+}
+
+struct GenericFunctionStruct<T, U> {
+ var f: (T) -> U
+}
+
+
+// CHECK-LABEL: sil hidden @{{.*}}member_ref_abstraction_change
+// CHECK: function_ref reabstraction thunk helper
+// CHECK: return
+func member_ref_abstraction_change(_ x: GenericFunctionStruct<Int, Int>) -> (Int) -> Int {
+ return x.f
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}call_auto_closure
+// CHECK: bb0([[CLOSURE:%.*]] : @trivial $@noescape @callee_guaranteed () -> Bool):
+// CHECK: apply [[CLOSURE]]() : $@noescape @callee_guaranteed () -> Bool
+// CHECK: } // end sil function '{{.*}}call_auto_closure{{.*}}'
+func call_auto_closure(x: @autoclosure () -> Bool) -> Bool {
+ return x() // Calls of autoclosures should be marked transparent.
+}
+
+
+class SomeClass {}
+
+struct AnotherStruct {
+ var i : Int
+ var c : SomeClass
+}
+
+struct StructMemberTest {
+ var c : SomeClass
+ var i = 42
+ var s : AnotherStruct
+ var t : (Int, AnotherStruct)
+
+ // rdar://15867140 - Accessing the int member here should not copy_value the
+ // whole struct.
+ func testIntMemberLoad() -> Int {
+ return i
+ }
+ // CHECK-LABEL: sil hidden @$S9let_decls16StructMemberTestV07testIntD4LoadSiyF : $@convention(method) (@guaranteed StructMemberTest)
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $StructMemberTest):
+ // CHECK: debug_value [[ARG]] : $StructMemberTest, let, name "self"
+ // CHECK: [[TRIVIAL_VALUE:%.*]] = struct_extract [[ARG]] : $StructMemberTest, #StructMemberTest.i
+ // CHECK-NOT: destroy_value [[ARG]] : $StructMemberTest
+ // CHECK-NOT: destroy_value [[BORROWED_ARG]] : $StructMemberTest
+ // CHECK: return [[TRIVIAL_VALUE]] : $Int
+
+ // Accessing the int member in s should not copy_value the whole struct.
+ func testRecursiveIntMemberLoad() -> Int {
+ return s.i
+ }
+ // CHECK-LABEL: sil hidden @$S9let_decls16StructMemberTestV016testRecursiveIntD4LoadSiyF : $@convention(method) (@guaranteed StructMemberTest)
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $StructMemberTest):
+ // CHECK: debug_value %0 : $StructMemberTest, let, name "self"
+ // CHECK: %2 = struct_extract %0 : $StructMemberTest, #StructMemberTest.s
+ // CHECK: %3 = struct_extract %2 : $AnotherStruct, #AnotherStruct.i
+ // CHECK-NOT: destroy_value %0 : $StructMemberTest
+ // CHECK: return %3 : $Int
+
+ func testTupleMemberLoad() -> Int {
+ return t.1.i
+ }
+ // CHECK-LABEL: sil hidden @$S9let_decls16StructMemberTestV09testTupleD4LoadSiyF : $@convention(method) (@guaranteed StructMemberTest)
+ // CHECK: bb0(%0 : @guaranteed $StructMemberTest):
+ // CHECK-NEXT: debug_value %0 : $StructMemberTest, let, name "self"
+ // CHECK-NEXT: [[T0:%.*]] = struct_extract %0 : $StructMemberTest, #StructMemberTest.t
+ // CHECK-NEXT: [[T1:%.*]] = tuple_extract [[T0]] : $(Int, AnotherStruct), 0
+ // CHECK-NEXT: [[T2:%.*]] = tuple_extract [[T0]] : $(Int, AnotherStruct), 1
+ // CHECK-NEXT: [[T3:%.*]] = struct_extract [[T2]] : $AnotherStruct, #AnotherStruct.i
+ // CHECK-NEXT: return [[T3]] : $Int
+
+}
+
+struct GenericStruct<T> {
+ var a : T
+ var b : Int
+
+ func getA() -> T {
+ return a
+ }
+ // CHECK-LABEL: sil hidden @{{.*}}GenericStructV4getA{{.*}} : $@convention(method) <T> (@in_guaranteed GenericStruct<T>) -> @out T
+ // CHECK: bb0(%0 : @trivial $*T, %1 : @trivial $*GenericStruct<T>):
+ // CHECK-NEXT: debug_value_addr %1 : $*GenericStruct<T>, let, name "self"
+ // CHECK-NEXT: %3 = struct_element_addr %1 : $*GenericStruct<T>, #GenericStruct.a
+ // CHECK-NEXT: copy_addr %3 to [initialization] %0 : $*T
+ // CHECK-NEXT: %5 = tuple ()
+ // CHECK-NEXT: return %5 : $()
+
+ func getB() -> Int {
+ return b
+ }
+
+ // CHECK-LABEL: sil hidden @{{.*}}GenericStructV4getB{{.*}} : $@convention(method) <T> (@in_guaranteed GenericStruct<T>) -> Int
+ // CHECK: bb0([[SELF_ADDR:%.*]] : @trivial $*GenericStruct<T>):
+ // CHECK-NEXT: debug_value_addr [[SELF_ADDR]] : $*GenericStruct<T>, let, name "self"
+ // CHECK-NEXT: [[PROJ_ADDR:%.*]] = struct_element_addr [[SELF_ADDR]] : $*GenericStruct<T>, #GenericStruct.b
+ // CHECK-NEXT: [[PROJ_VAL:%.*]] = load [trivial] [[PROJ_ADDR]] : $*Int
+ // CHECK-NOT: destroy_addr [[SELF]] : $*GenericStruct<T>
+ // CHECK-NEXT: return [[PROJ_VAL]] : $Int
+}
+
+
+// rdar://15877337
+struct LetPropertyStruct {
+ let lp : Int
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}testLetPropertyAccessOnLValueBase
+// CHECK: bb0(%0 : @trivial $LetPropertyStruct):
+// CHECK: [[ABOX:%[0-9]+]] = alloc_box ${ var LetPropertyStruct }
+// CHECK: [[A:%[0-9]+]] = project_box [[ABOX]]
+// CHECK: store %0 to [trivial] [[A]] : $*LetPropertyStruct
+// CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[A]]
+// CHECK: [[STRUCT:%[0-9]+]] = load [trivial] [[READ]] : $*LetPropertyStruct
+// CHECK: [[PROP:%[0-9]+]] = struct_extract [[STRUCT]] : $LetPropertyStruct, #LetPropertyStruct.lp
+// CHECK: destroy_value [[ABOX]] : ${ var LetPropertyStruct }
+// CHECK: return [[PROP]] : $Int
+func testLetPropertyAccessOnLValueBase(_ a : LetPropertyStruct) -> Int {
+ var a = a
+ return a.lp
+}
+
+
+var addressOnlyGetOnlyGlobalProperty : SimpleProtocol { get {} }
+
+// CHECK-LABEL: sil hidden @$S9let_decls018testAddressOnlyGetE14GlobalPropertyAA14SimpleProtocol_pyF
+// CHECK: bb0(%0 : @trivial $*SimpleProtocol):
+// CHECK-NEXT: // function_ref
+// CHECK-NEXT: %1 = function_ref @$S9let_decls014addressOnlyGetD14GlobalPropertyAA14SimpleProtocol_pvg
+// CHECK-NEXT: %2 = apply %1(%0) : $@convention(thin) () -> @out SimpleProtocol
+// CHECK-NEXT: %3 = tuple ()
+// CHECK-NEXT: return %3 : $()
+// CHECK-NEXT: }
+func testAddressOnlyGetOnlyGlobalProperty() -> SimpleProtocol {
+ return addressOnlyGetOnlyGlobalProperty
+}
+
+
+// rdar://15962740
+struct LetDeclInStruct {
+ let immutable: Int
+ init() {
+ immutable = 1
+ }
+}
+
+// rdar://19854166 - Swift 1.2 uninitialized constant causes crash
+// The destroy_addr for a let stack temporary should be generated against
+// mark_uninitialized instruction, so DI will see it.
+func test_unassigned_let_constant() {
+ let string : String
+}
+// CHECK: [[S:%[0-9]+]] = alloc_stack $String, let, name "string"
+// CHECK-NEXT: [[MUI:%[0-9]+]] = mark_uninitialized [var] [[S]] : $*String
+// CHECK-NEXT: destroy_addr [[MUI]] : $*String
+// CHECK-NEXT: dealloc_stack [[S]] : $*String
+
diff --git a/test/SILGen/plus_zero_lifetime.swift b/test/SILGen/plus_zero_lifetime.swift
new file mode 100644
index 0000000..f5917ab
--- /dev/null
+++ b/test/SILGen/plus_zero_lifetime.swift
@@ -0,0 +1,812 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -parse-as-library -emit-silgen -primary-file %s | %FileCheck %s
+
+struct Buh<T> {
+ var x: Int {
+ get {}
+ set {}
+ }
+}
+
+class Ref {
+ init() { }
+}
+struct Val {
+}
+
+// CHECK-LABEL: sil hidden @$S8lifetime13local_valtypeyyF
+func local_valtype() {
+ var b: Val
+ // CHECK: [[B:%[0-9]+]] = alloc_box ${ var Val }
+ // CHECK: [[MARKED_B:%.*]] = mark_uninitialized [var] [[B]]
+ // CHECK: destroy_value [[MARKED_B]]
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S8lifetime20local_valtype_branch{{[_0-9a-zA-Z]*}}F
+func local_valtype_branch(_ a: Bool) {
+ var a = a
+ // CHECK: [[A:%[0-9]+]] = alloc_box ${ var Bool }
+
+ if a { return }
+ // CHECK: cond_br
+ // CHECK: {{bb.*:}}
+ // CHECK: br [[EPILOG:bb[0-9]+]]
+
+ var x:Int
+ // CHECK: [[X:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[MARKED_X:%.*]] = mark_uninitialized [var] [[X]]
+
+ if a { return }
+ // CHECK: cond_br
+ // CHECK: {{bb.*:}}
+ // CHECK: destroy_value [[MARKED_X]]
+ // CHECK: br [[EPILOG]]
+
+ while a {
+ // CHECK: cond_br
+ if a { break }
+ // CHECK: cond_br
+ // CHECK: {{bb.*:}}
+ // CHECK-NOT: destroy_value [[X]]
+ // CHECK: br
+
+ if a { return }
+ // CHECK: cond_br
+ // CHECK: {{bb.*:}}
+ // CHECK: destroy_value [[MARKED_X]]
+ // CHECK: br [[EPILOG]]
+
+ var y:Int
+ // CHECK: [[Y:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[MARKED_Y:%.*]] = mark_uninitialized [var] [[Y]]
+
+ if a { break }
+ // CHECK: cond_br
+ // CHECK: {{bb.*:}}
+ // CHECK: destroy_value [[MARKED_Y]]
+ // CHECK-NOT: destroy_value [[MARKED_X]]
+ // CHECK-NOT: destroy_value [[A]]
+ // CHECK: br
+
+ if a { return }
+ // CHECK: cond_br
+ // CHECK: {{bb.*:}}
+ // CHECK: destroy_value [[MARKED_Y]]
+ // CHECK: destroy_value [[MARKED_X]]
+ // CHECK: br [[EPILOG]]
+
+ if true {
+ var z:Int
+ // CHECK: [[Z:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[MARKED_Z:%.*]] = mark_uninitialized [var] [[Z]]
+
+ if a { break }
+ // CHECK: cond_br
+ // CHECK: {{bb.*:}}
+ // CHECK: destroy_value [[MARKED_Z]]
+ // CHECK: destroy_value [[MARKED_Y]]
+ // CHECK-NOT: destroy_value [[MARKED_X]]
+ // CHECK-NOT: destroy_value [[A]]
+ // CHECK: br
+
+ if a { return }
+ // CHECK: cond_br
+ // CHECK: {{bb.*:}}
+ // CHECK: destroy_value [[MARKED_Z]]
+ // CHECK: destroy_value [[MARKED_Y]]
+ // CHECK: destroy_value [[MARKED_X]]
+ // CHECK: br [[EPILOG]]
+
+ // CHECK: destroy_value [[MARKED_Z]]
+ }
+ if a { break }
+ // CHECK: cond_br
+ // CHECK: {{bb.*:}}
+ // CHECK: destroy_value [[MARKED_Y]]
+ // CHECK-NOT: destroy_value [[MARKED_X]]
+ // CHECK-NOT: destroy_value [[A]]
+ // CHECK: br
+
+ // CHECK: {{bb.*:}}
+ // CHECK: destroy_value [[MARKED_Y]]
+ // CHECK: br
+ }
+ // CHECK: destroy_value [[MARKED_X]]
+ // CHECK: [[EPILOG]]:
+ // CHECK: return
+}
+
+func reftype_func() -> Ref {}
+func reftype_func_with_arg(_ x: Ref) -> Ref {}
+
+// CHECK-LABEL: sil hidden @$S8lifetime14reftype_returnAA3RefCyF
+func reftype_return() -> Ref {
+ return reftype_func()
+ // CHECK: [[RF:%[0-9]+]] = function_ref @$S8lifetime12reftype_funcAA3RefCyF : $@convention(thin) () -> @owned Ref
+ // CHECK-NOT: destroy_value
+ // CHECK: [[RET:%[0-9]+]] = apply [[RF]]()
+ // CHECK-NOT: destroy_value
+ // CHECK: return [[RET]]
+}
+
+// CHECK-LABEL: sil hidden @$S8lifetime11reftype_argyyAA3RefCF : $@convention(thin) (@guaranteed Ref) -> () {
+// CHECK: bb0([[A:%[0-9]+]] : $Ref):
+// CHECK: [[AADDR:%[0-9]+]] = alloc_box ${ var Ref }
+// CHECK: [[PA:%[0-9]+]] = project_box [[AADDR]]
+// CHECK: [[A_COPY:%.*]] = copy_value [[A]]
+// CHECK: store [[A_COPY]] to [init] [[PA]]
+// CHECK: destroy_value [[AADDR]]
+// CHECK-NOT: destroy_value [[A]]
+// CHECK: return
+// CHECK: } // end sil function '$S8lifetime11reftype_argyyAA3RefCF'
+func reftype_arg(_ a: Ref) {
+ var a = a
+}
+
+// CHECK-LABEL: sil hidden @$S8lifetime26reftype_call_ignore_returnyyF
+func reftype_call_ignore_return() {
+ reftype_func()
+ // CHECK: = function_ref @$S8lifetime12reftype_funcAA3RefCyF : $@convention(thin) () -> @owned Ref
+ // CHECK-NEXT: [[R:%[0-9]+]] = apply
+ // CHECK: destroy_value [[R]]
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S8lifetime27reftype_call_store_to_localyyF
+func reftype_call_store_to_local() {
+ var a = reftype_func()
+ // CHECK: [[A:%[0-9]+]] = alloc_box ${ var Ref }
+ // CHECK-NEXT: [[PB:%.*]] = project_box [[A]]
+ // CHECK: = function_ref @$S8lifetime12reftype_funcAA3RefCyF : $@convention(thin) () -> @owned Ref
+ // CHECK-NEXT: [[R:%[0-9]+]] = apply
+ // CHECK-NOT: copy_value [[R]]
+ // CHECK: store [[R]] to [init] [[PB]]
+ // CHECK-NOT: destroy_value [[R]]
+ // CHECK: destroy_value [[A]]
+ // CHECK-NOT: destroy_value [[R]]
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S8lifetime16reftype_call_argyyF
+func reftype_call_arg() {
+ reftype_func_with_arg(reftype_func())
+ // CHECK: [[RF:%[0-9]+]] = function_ref @$S8lifetime12reftype_func{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[R1:%[0-9]+]] = apply [[RF]]
+ // CHECK: [[RFWA:%[0-9]+]] = function_ref @$S8lifetime21reftype_func_with_arg{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[R2:%[0-9]+]] = apply [[RFWA]]([[R1]])
+ // CHECK: destroy_value [[R2]]
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S8lifetime21reftype_call_with_arg{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[A1:%[0-9]+]] : $Ref):
+// CHECK: [[AADDR:%[0-9]+]] = alloc_box ${ var Ref }
+// CHECK: [[PB:%.*]] = project_box [[AADDR]]
+// CHECK: [[A1_COPY:%.*]] = copy_value [[A1]]
+// CHECK: store [[A1_COPY]] to [init] [[PB]]
+// CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PB]]
+// CHECK: [[A2:%[0-9]+]] = load [copy] [[READ]]
+// CHECK: [[RFWA:%[0-9]+]] = function_ref @$S8lifetime21reftype_func_with_arg{{[_0-9a-zA-Z]*}}F
+// CHECK: [[RESULT:%.*]] = apply [[RFWA]]([[A2]])
+// CHECK: destroy_value [[RESULT]]
+// CHECK: destroy_value [[AADDR]]
+// CHECK-NOT: destroy_value [[A1]]
+// CHECK: return
+func reftype_call_with_arg(_ a: Ref) {
+ var a = a
+
+ reftype_func_with_arg(a)
+}
+
+// CHECK-LABEL: sil hidden @$S8lifetime16reftype_reassign{{[_0-9a-zA-Z]*}}F
+func reftype_reassign(_ a: inout Ref, b: Ref) {
+ var b = b
+ // CHECK: bb0([[AADDR:%[0-9]+]] : $*Ref, [[B1:%[0-9]+]] : $Ref):
+ // CHECK: [[BADDR:%[0-9]+]] = alloc_box ${ var Ref }
+ // CHECK: [[PBB:%.*]] = project_box [[BADDR]]
+ a = b
+ // CHECK: destroy_value
+
+ // CHECK: return
+}
+
+func tuple_with_ref_elements() -> (Val, (Ref, Val), Ref) {}
+
+// CHECK-LABEL: sil hidden @$S8lifetime28tuple_with_ref_ignore_returnyyF
+func tuple_with_ref_ignore_return() {
+ tuple_with_ref_elements()
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S8lifetime23tuple_with_ref_elementsAA3ValV_AA3RefC_ADtAFtyF
+ // CHECK: [[TUPLE:%[0-9]+]] = apply [[FUNC]]
+ // CHECK: [[BORROWED_TUPLE:%.*]] = begin_borrow [[TUPLE]]
+ // CHECK: [[T0:%[0-9]+]] = tuple_extract [[BORROWED_TUPLE]] : {{.*}}, 0
+ // CHECK: [[T1_0:%[0-9]+]] = tuple_extract [[BORROWED_TUPLE]] : {{.*}}, 1
+ // CHECK: [[T1_0_COPY:%.*]] = copy_value [[T1_0]]
+ // CHECK: [[T1_1:%[0-9]+]] = tuple_extract [[BORROWED_TUPLE]] : {{.*}}, 2
+ // CHECK: [[T2:%[0-9]+]] = tuple_extract [[BORROWED_TUPLE]] : {{.*}}, 3
+ // CHECK: [[T2_COPY:%.*]] = copy_value [[T2]]
+ // CHECK: end_borrow [[BORROWED_TUPLE]] from [[TUPLE]]
+ // CHECK: destroy_value [[TUPLE]]
+ // CHECK: destroy_value [[T2_COPY]]
+ // CHECK: destroy_value [[T1_0_COPY]]
+ // CHECK: return
+}
+
+struct Aleph {
+ var a:Ref
+ var b:Val
+
+ // -- loadable value constructor:
+ // CHECK-LABEL: sil hidden @$S8lifetime5AlephV{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@owned Ref, Val, @thin Aleph.Type) -> @owned Aleph
+ // CHECK: bb0([[A:%.*]] : $Ref, [[B:%.*]] : $Val, {{%.*}} : $@thin Aleph.Type):
+ // CHECK-NEXT: [[RET:%.*]] = struct $Aleph ([[A]] : {{.*}}, [[B]] : {{.*}})
+ // CHECK-NEXT: return [[RET]]
+}
+
+struct Beth {
+ var a:Val
+ var b:Aleph
+ var c:Ref
+
+ func gimel() {}
+}
+
+protocol Unloadable {}
+
+struct Daleth {
+ var a:Aleph
+ var b:Beth
+ var c:Unloadable
+
+ // -- address-only value constructor:
+ // CHECK-LABEL: sil hidden @$S8lifetime6DalethV{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@owned Aleph, @owned Beth, @in Unloadable, @thin Daleth.Type) -> @out Daleth {
+ // CHECK: bb0([[THIS:%.*]] : $*Daleth, [[A:%.*]] : $Aleph, [[B:%.*]] : $Beth, [[C:%.*]] : $*Unloadable, {{%.*}} : $@thin Daleth.Type):
+ // CHECK-NEXT: [[A_ADDR:%.*]] = struct_element_addr [[THIS]] : $*Daleth, #Daleth.a
+ // CHECK-NEXT: store [[A]] to [init] [[A_ADDR]]
+ // CHECK-NEXT: [[B_ADDR:%.*]] = struct_element_addr [[THIS]] : $*Daleth, #Daleth.b
+ // CHECK-NEXT: store [[B]] to [init] [[B_ADDR]]
+ // CHECK-NEXT: [[C_ADDR:%.*]] = struct_element_addr [[THIS]] : $*Daleth, #Daleth.c
+ // CHECK-NEXT: copy_addr [take] [[C]] to [initialization] [[C_ADDR]]
+ // CHECK-NEXT: tuple ()
+ // CHECK-NEXT: return
+}
+
+class He {
+
+ // -- default allocator:
+ // CHECK-LABEL: sil hidden @$S8lifetime2HeC{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@thick He.Type) -> @owned He {
+ // CHECK: bb0({{%.*}} : $@thick He.Type):
+ // CHECK-NEXT: [[THIS:%.*]] = alloc_ref $He
+ // CHECK-NEXT: // function_ref lifetime.He.init
+ // CHECK-NEXT: [[INIT:%.*]] = function_ref @$S8lifetime2HeC{{[_0-9a-zA-Z]*}}fc : $@convention(method) (@owned He) -> @owned He
+ // CHECK-NEXT: [[THIS1:%.*]] = apply [[INIT]]([[THIS]])
+ // CHECK-NEXT: return [[THIS1]]
+ // CHECK-NEXT: }
+
+ // -- default initializer:
+ // CHECK-LABEL: sil hidden @$S8lifetime2HeC{{[_0-9a-zA-Z]*}}fc : $@convention(method) (@owned He) -> @owned He {
+ // CHECK: bb0([[SELF:%.*]] : $He):
+ // CHECK-NEXT: debug_value
+ // CHECK-NEXT: [[UNINITIALIZED_SELF:%.*]] = mark_uninitialized [rootself] [[SELF]]
+ // CHECK-NEXT: [[UNINITIALIZED_SELF_COPY:%.*]] = copy_value [[UNINITIALIZED_SELF]]
+ // CHECK-NEXT: destroy_value [[UNINITIALIZED_SELF]]
+ // CHECK-NEXT: return [[UNINITIALIZED_SELF_COPY]]
+ // CHECK: } // end sil function '$S8lifetime2HeC{{[_0-9a-zA-Z]*}}fc'
+
+ init() { }
+}
+
+struct Waw {
+ var a:(Ref, Val)
+ var b:Val
+
+ // -- loadable value initializer with tuple destructuring:
+ // CHECK-LABEL: sil hidden @$S8lifetime3WawV{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@owned Ref, Val, Val, @thin Waw.Type) -> @owned Waw
+ // CHECK: bb0([[A0:%.*]] : $Ref, [[A1:%.*]] : $Val, [[B:%.*]] : $Val, {{%.*}} : $@thin Waw.Type):
+ // CHECK-NEXT: [[A:%.*]] = tuple ([[A0]] : {{.*}}, [[A1]] : {{.*}})
+ // CHECK-NEXT: [[RET:%.*]] = struct $Waw ([[A]] : {{.*}}, [[B]] : {{.*}})
+ // CHECK-NEXT: return [[RET]]
+}
+
+struct Zayin {
+ var a:(Unloadable, Val)
+ var b:Unloadable
+
+ // -- address-only value initializer with tuple destructuring:
+ // CHECK-LABEL: sil hidden @$S8lifetime5ZayinV{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@in Unloadable, Val, @in Unloadable, @thin Zayin.Type) -> @out Zayin
+ // CHECK: bb0([[THIS:%.*]] : $*Zayin, [[A0:%.*]] : $*Unloadable, [[A1:%.*]] : $Val, [[B:%.*]] : $*Unloadable, {{%.*}} : $@thin Zayin.Type):
+ // CHECK-NEXT: [[THIS_A_ADDR:%.*]] = struct_element_addr [[THIS]] : $*Zayin, #Zayin.a
+ // CHECK-NEXT: [[THIS_A0_ADDR:%.*]] = tuple_element_addr [[THIS_A_ADDR]] : {{.*}}, 0
+ // CHECK-NEXT: [[THIS_A1_ADDR:%.*]] = tuple_element_addr [[THIS_A_ADDR]] : {{.*}}, 1
+ // CHECK-NEXT: copy_addr [take] [[A0]] to [initialization] [[THIS_A0_ADDR]]
+ // CHECK-NEXT: store [[A1]] to [trivial] [[THIS_A1_ADDR]]
+ // CHECK-NEXT: [[THIS_B_ADDR:%.*]] = struct_element_addr [[THIS]] : $*Zayin, #Zayin.b
+ // CHECK-NEXT: copy_addr [take] [[B]] to [initialization] [[THIS_B_ADDR]]
+ // CHECK-NEXT: tuple ()
+ // CHECK-NEXT: return
+}
+
+func fragile_struct_with_ref_elements() -> Beth {}
+
+// CHECK-LABEL: sil hidden @$S8lifetime29struct_with_ref_ignore_returnyyF
+func struct_with_ref_ignore_return() {
+ fragile_struct_with_ref_elements()
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S8lifetime32fragile_struct_with_ref_elementsAA4BethVyF
+ // CHECK: [[STRUCT:%[0-9]+]] = apply [[FUNC]]
+ // CHECK: destroy_value [[STRUCT]] : $Beth
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S8lifetime28struct_with_ref_materializedyyF
+func struct_with_ref_materialized() {
+ fragile_struct_with_ref_elements().gimel()
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S8lifetime32fragile_struct_with_ref_elementsAA4BethVyF
+ // CHECK: [[STRUCT:%[0-9]+]] = apply [[FUNC]]
+ // CHECK: [[METHOD:%[0-9]+]] = function_ref @$S8lifetime4BethV5gimel{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[METHOD]]([[STRUCT]])
+}
+
+class RefWithProp {
+ var int_prop: Int { get {} set {} }
+ var aleph_prop: Aleph { get {} set {} }
+}
+
+// CHECK-LABEL: sil hidden @$S8lifetime015logical_lvalue_A0yyAA11RefWithPropC_SiAA3ValVtF : $@convention(thin) (@guaranteed RefWithProp, Int, Val) -> () {
+func logical_lvalue_lifetime(_ r: RefWithProp, _ i: Int, _ v: Val) {
+ var r = r
+ var i = i
+ var v = v
+ // CHECK: [[RADDR:%[0-9]+]] = alloc_box ${ var RefWithProp }
+ // CHECK: [[PR:%[0-9]+]] = project_box [[RADDR]]
+ // CHECK: [[IADDR:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[PI:%[0-9]+]] = project_box [[IADDR]]
+ // CHECK: store %1 to [trivial] [[PI]]
+ // CHECK: [[VADDR:%[0-9]+]] = alloc_box ${ var Val }
+ // CHECK: [[PV:%[0-9]+]] = project_box [[VADDR]]
+
+ // -- Reference types need to be copy_valued as property method args.
+ r.int_prop = i
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PR]]
+ // CHECK: [[R1:%[0-9]+]] = load [copy] [[READ]]
+ // CHECK: [[SETTER_METHOD:%[0-9]+]] = class_method {{.*}} : $RefWithProp, #RefWithProp.int_prop!setter.1 : (RefWithProp) -> (Int) -> (), $@convention(method) (Int, @guaranteed RefWithProp) -> ()
+ // CHECK: apply [[SETTER_METHOD]]({{.*}}, [[R1]])
+ // CHECK: destroy_value [[R1]]
+
+ r.aleph_prop.b = v
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PR]]
+ // CHECK: [[R2:%[0-9]+]] = load [copy] [[READ]]
+ // CHECK: [[STORAGE:%.*]] = alloc_stack $Builtin.UnsafeValueBuffer
+ // CHECK: [[ALEPH_PROP_TEMP:%[0-9]+]] = alloc_stack $Aleph
+ // CHECK: [[BORROWED_R2:%.*]] = begin_borrow [[R2]]
+ // CHECK: [[T0:%.*]] = address_to_pointer [[ALEPH_PROP_TEMP]]
+ // CHECK: [[MATERIALIZE_METHOD:%[0-9]+]] = class_method [[BORROWED_R2]] : $RefWithProp, #RefWithProp.aleph_prop!materializeForSet.1 :
+ // CHECK: [[MATERIALIZE:%.*]] = apply [[MATERIALIZE_METHOD]]([[T0]], [[STORAGE]], [[BORROWED_R2]])
+ // CHECK: [[PTR:%.*]] = tuple_extract [[MATERIALIZE]] : {{.*}}, 0
+ // CHECK: [[OPTCALLBACK:%.*]] = tuple_extract [[MATERIALIZE]] : {{.*}}, 1
+ // CHECK: [[ADDR:%.*]] = pointer_to_address [[PTR]]
+ // CHECK: [[MARKED_ADDR:%.*]] = mark_dependence [[ADDR]] : $*Aleph on [[R2]]
+ // CHECK: {{.*}}([[CALLBACK_ADDR:%.*]] :
+ // CHECK: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout RefWithProp, @thick RefWithProp.Type) -> ()
+ // CHECK: [[TEMP:%.*]] = alloc_stack $RefWithProp
+ // CHECK: store [[R2]] to [init] [[TEMP]]
+ // CHECK: apply [[CALLBACK]]({{.*}}, [[STORAGE]], [[TEMP]], {{%.*}})
+}
+
+func bar() -> Int {}
+
+class Foo<T> {
+ var x : Int
+ var y = (Int(), Ref())
+ var z : T
+ var w = Ref()
+
+ class func makeT() -> T {}
+
+ // Class initializer
+ init() {
+ // -- allocating entry point
+ // CHECK-LABEL: sil hidden @$S8lifetime3FooC{{[_0-9a-zA-Z]*}}fC :
+ // CHECK: bb0([[METATYPE:%[0-9]+]] : $@thick Foo<T>.Type):
+ // CHECK: [[THIS:%[0-9]+]] = alloc_ref $Foo<T>
+ // CHECK: [[INIT_METHOD:%[0-9]+]] = function_ref @$S8lifetime3FooC{{[_0-9a-zA-Z]*}}fc
+ // CHECK: [[INIT_THIS:%[0-9]+]] = apply [[INIT_METHOD]]<{{.*}}>([[THIS]])
+ // CHECK: return [[INIT_THIS]]
+
+ // -- initializing entry point
+ // CHECK-LABEL: sil hidden @$S8lifetime3FooC{{[_0-9a-zA-Z]*}}fc :
+ // CHECK: bb0([[THISIN:%[0-9]+]] : $Foo<T>):
+ // CHECK: [[THIS:%[0-9]+]] = mark_uninitialized
+
+ // -- initialization for y
+ // CHECK: [[Y_INIT:%[0-9]+]] = function_ref @$S8lifetime3FooC1ySi_AA3RefCtvpfi : $@convention(thin) <τ_0_0> () -> (Int, @owned Ref)
+ // CHECK: [[Y_VALUE:%[0-9]+]] = apply [[Y_INIT]]<T>()
+ // CHECK: [[BORROWED_Y_VALUE:%.*]] = begin_borrow [[Y_VALUE]]
+ // CHECK: [[Y_EXTRACTED_0:%.*]] = tuple_extract [[BORROWED_Y_VALUE]] : $(Int, Ref), 0
+ // CHECK: [[Y_EXTRACTED_1:%.*]] = tuple_extract [[BORROWED_Y_VALUE]] : $(Int, Ref), 1
+ // CHECK: [[COPIED_Y_EXTRACTED_1:%.*]] = copy_value [[Y_EXTRACTED_1]]
+ // CHECK: end_borrow [[BORROWED_Y_VALUE]] from [[Y_VALUE]]
+ // CHECK: destroy_value [[Y_VALUE]]
+ // CHECK: [[BORROWED_THIS:%.*]] = begin_borrow [[THIS]]
+ // CHECK: [[THIS_Y:%.*]] = ref_element_addr [[BORROWED_THIS]] : {{.*}}, #Foo.y
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[THIS_Y]] : $*(Int, Ref)
+ // CHECK: [[THIS_Y_0:%.*]] = tuple_element_addr [[WRITE]] : $*(Int, Ref), 0
+ // CHECK: assign [[Y_EXTRACTED_0]] to [[THIS_Y_0]]
+ // CHECK: [[THIS_Y_1:%.*]] = tuple_element_addr [[WRITE]] : $*(Int, Ref), 1
+ // CHECK: assign [[COPIED_Y_EXTRACTED_1]] to [[THIS_Y_1]]
+ // CHECK: end_access [[WRITE]] : $*(Int, Ref)
+ // CHECK: end_borrow [[BORROWED_THIS]] from [[THIS]]
+
+ // -- Initialization for w
+ // CHECK: [[Z_FUNC:%.*]] = function_ref @$S{{.*}}8lifetime3FooC1wAA3RefCvpfi : $@convention(thin) <τ_0_0> () -> @owned Ref
+ // CHECK: [[Z_RESULT:%.*]] = apply [[Z_FUNC]]<T>()
+ // CHECK: [[BORROWED_THIS:%.*]] = begin_borrow [[THIS]]
+ // CHECK: [[THIS_Z:%.*]] = ref_element_addr [[BORROWED_THIS]]
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[THIS_Z]] : $*Ref
+ // CHECK: assign [[Z_RESULT]] to [[WRITE]]
+ // CHECK: end_borrow [[BORROWED_THIS]] from [[THIS]]
+
+ // -- Initialization for x
+ // CHECK: [[BORROWED_THIS:%.*]] = begin_borrow [[THIS]]
+ // CHECK: [[THIS_X:%[0-9]+]] = ref_element_addr [[BORROWED_THIS]] : {{.*}}, #Foo.x
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[THIS_X]] : $*Int
+ // CHECK: assign {{.*}} to [[WRITE]]
+ // CHECK: end_borrow [[BORROWED_THIS]] from [[THIS]]
+
+ x = bar()
+
+ z = Foo<T>.makeT()
+ // CHECK: [[FOOMETA:%[0-9]+]] = metatype $@thick Foo<T>.Type
+ // CHECK: [[MAKET:%[0-9]+]] = class_method [[FOOMETA]] : {{.*}}, #Foo.makeT!1
+ // CHECK: ref_element_addr
+
+ // -- cleanup this lvalue and return this
+ // CHECK: [[THIS_RESULT:%.*]] = copy_value [[THIS]]
+ // -- TODO: This copy should be unnecessary.
+ // CHECK: destroy_value [[THIS]]
+ // CHECK: return [[THIS_RESULT]]
+
+ }
+
+ init(chi:Int) {
+ var chi = chi
+ z = Foo<T>.makeT()
+
+ // -- allocating entry point
+ // CHECK-LABEL: sil hidden @$S8lifetime3FooC{{[_0-9a-zA-Z]*}}fC :
+ // CHECK: bb0([[CHI:%[0-9]+]] : $Int, [[METATYPE:%[0-9]+]] : $@thick Foo<T>.Type):
+ // CHECK: [[THIS:%[0-9]+]] = alloc_ref $Foo<T>
+ // CHECK: [[INIT_METHOD:%[0-9]+]] = function_ref @$S8lifetime3FooC{{[_0-9a-zA-Z]*}}fc
+ // CHECK: [[INIT_THIS:%[0-9]+]] = apply [[INIT_METHOD]]<{{.*}}>([[CHI]], [[THIS]])
+ // CHECK: return [[INIT_THIS]]
+
+ // -- initializing entry point
+ // CHECK-LABEL: sil hidden @$S8lifetime3FooC3chiACyxGSi_tcfc : $@convention(method) <T> (Int, @owned Foo<T>) -> @owned Foo<T> {
+ // CHECK: bb0([[CHI:%[0-9]+]] : $Int, [[THISIN:%[0-9]+]] : $Foo<T>):
+ // CHECK: [[THIS:%[0-9]+]] = mark_uninitialized [rootself] [[THISIN]]
+
+ // -- First we initialize #Foo.y.
+ // CHECK: [[BORROWED_THIS:%.*]] = begin_borrow [[THIS]]
+ // CHECK: [[THIS_Y:%.*]] = ref_element_addr [[BORROWED_THIS]] : $Foo<T>, #Foo.y
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[THIS_Y]] : $*(Int, Ref)
+ // CHECK: [[THIS_Y_1:%.*]] = tuple_element_addr [[WRITE]] : $*(Int, Ref), 0
+ // CHECK: assign {{.*}} to [[THIS_Y_1]] : $*Int
+ // CHECK: [[THIS_Y_2:%.*]] = tuple_element_addr [[WRITE]] : $*(Int, Ref), 1
+ // CHECK: assign {{.*}} to [[THIS_Y_2]] : $*Ref
+ // CHECK: end_borrow [[BORROWED_THIS]] from [[THIS]]
+
+ // -- Then we create a box that we will use to perform a copy_addr into #Foo.x a bit later.
+ // CHECK: [[CHIADDR:%[0-9]+]] = alloc_box ${ var Int }, var, name "chi"
+ // CHECK: [[PCHI:%[0-9]+]] = project_box [[CHIADDR]]
+ // CHECK: store [[CHI]] to [trivial] [[PCHI]]
+
+ // -- Then we initialize #Foo.z
+ // CHECK: [[BORROWED_THIS:%.*]] = begin_borrow [[THIS]]
+ // CHECK: [[THIS_Z:%.*]] = ref_element_addr [[BORROWED_THIS]] : {{.*}}, #Foo.z
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[THIS_Z]] : $*T
+ // CHECK: copy_addr [take] {{.*}} to [[WRITE]]
+ // CHECK: end_borrow [[BORROWED_THIS]] from [[THIS]]
+
+ // -- Then initialize #Foo.x using the earlier stored value of CHI to THIS_Z.
+ x = chi
+ // CHECK: [[BORROWED_THIS:%.*]] = begin_borrow [[THIS]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PCHI]]
+ // CHECK: [[X:%.*]] = load [trivial] [[READ]]
+ // CHECK: [[THIS_X:%[0-9]+]] = ref_element_addr [[BORROWED_THIS]] : {{.*}}, #Foo.x
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[THIS_X]] : $*Int
+ // CHECK: assign [[X]] to [[WRITE]]
+ // CHECK: end_borrow [[BORROWED_THIS]] from [[THIS]]
+
+ // -- cleanup chi
+ // CHECK: destroy_value [[CHIADDR]]
+
+ // -- Then begin the epilogue sequence
+ // CHECK: [[THIS_RETURN:%.*]] = copy_value [[THIS]]
+ // CHECK: destroy_value [[THIS]]
+ // CHECK: return [[THIS_RETURN]]
+ // CHECK: } // end sil function '$S8lifetime3FooC3chiACyxGSi_tcfc'
+ }
+
+ // -- allocating entry point
+ // CHECK-LABEL: sil hidden @$S8lifetime3FooC{{[_0-9a-zA-Z]*}}fC :
+ // CHECK: [[INIT_METHOD:%[0-9]+]] = function_ref @$S8lifetime3FooC{{[_0-9a-zA-Z]*}}fc
+
+ // -- initializing entry point
+ // CHECK-LABEL: sil hidden @$S8lifetime3FooC{{[_0-9a-zA-Z]*}}fc :
+
+ init<U:Intifiable>(chi:U) {
+ z = Foo<T>.makeT()
+
+ x = chi.intify()
+ }
+
+ // CHECK-LABEL: sil hidden @$S8lifetime3FooCfd : $@convention(method) <T> (@guaranteed Foo<T>) -> @owned Builtin.NativeObject
+
+ deinit {
+ // CHECK: bb0([[THIS:%[0-9]+]] : $Foo<T>):
+ bar()
+ // CHECK: function_ref @$S8lifetime3barSiyF
+ // CHECK: apply
+
+ // -- don't need to destroy_value x because it's trivial
+ // CHECK-NOT: ref_element_addr [[THIS]] : {{.*}}, #Foo.x
+ // -- destroy_value y
+ // CHECK: [[YADDR:%[0-9]+]] = ref_element_addr [[THIS]] : {{.*}}, #Foo.y
+ // CHECK: destroy_addr [[YADDR]]
+ // -- destroy_value z
+ // CHECK: [[ZADDR:%[0-9]+]] = ref_element_addr [[THIS]] : {{.*}}, #Foo.z
+ // CHECK: destroy_addr [[ZADDR]]
+ // -- destroy_value w
+ // CHECK: [[WADDR:%[0-9]+]] = ref_element_addr [[THIS]] : {{.*}}, #Foo.w
+ // CHECK: destroy_addr [[WADDR]]
+ // -- return back this
+ // CHECK: [[PTR:%.*]] = unchecked_ref_cast [[THIS]] : $Foo<T> to $Builtin.NativeObject
+ // CHECK: [[PTR_OWNED:%.*]] = unchecked_ownership_conversion [[PTR]] : $Builtin.NativeObject, @guaranteed to @owned
+ // CHECK: return [[PTR_OWNED]]
+ // CHECK: } // end sil function '$S8lifetime3FooCfd'
+ }
+
+ // Deallocating destructor for Foo.
+ // CHECK-LABEL: sil hidden @$S8lifetime3FooCfD : $@convention(method) <T> (@owned Foo<T>) -> ()
+ // CHECK: bb0([[SELF:%[0-9]+]] : $Foo<T>):
+ // CHECK: [[DESTROYING_REF:%[0-9]+]] = function_ref @$S8lifetime3FooCfd : $@convention(method) <τ_0_0> (@guaranteed Foo<τ_0_0>) -> @owned Builtin.NativeObject
+ // CHECK-NEXT: [[BORROWED_SELF:%.*]] = begin_borrow [[SELF]]
+ // CHECK-NEXT: [[RESULT_SELF:%[0-9]+]] = apply [[DESTROYING_REF]]<T>([[BORROWED_SELF]]) : $@convention(method) <τ_0_0> (@guaranteed Foo<τ_0_0>) -> @owned Builtin.NativeObject
+ // CHECK-NEXT: end_borrow [[BORROWED_SELF]] from [[SELF]]
+ // CHECK-NEXT: end_lifetime [[SELF]]
+ // CHECK-NEXT: [[SELF:%[0-9]+]] = unchecked_ref_cast [[RESULT_SELF]] : $Builtin.NativeObject to $Foo<T>
+ // CHECK-NEXT: dealloc_ref [[SELF]] : $Foo<T>
+ // CHECK-NEXT: [[RESULT:%[0-9]+]] = tuple ()
+ // CHECK-NEXT: return [[RESULT]] : $()
+ // CHECK-NEXT: } // end sil function '$S8lifetime3FooCfD'
+
+}
+
+class FooSubclass<T> : Foo<T> {
+
+ // CHECK-LABEL: sil hidden @$S8lifetime11FooSubclassCfd : $@convention(method) <T> (@guaranteed FooSubclass<T>) -> @owned Builtin.NativeObject
+ // CHECK: bb0([[THIS:%[0-9]+]] : $FooSubclass<T>):
+ // -- base dtor
+ // CHECK: [[BASE:%[0-9]+]] = upcast [[THIS]] : ${{.*}} to $Foo<T>
+ // CHECK: [[BASE_DTOR:%[0-9]+]] = function_ref @$S8lifetime3FooCfd : $@convention(method) <τ_0_0> (@guaranteed Foo<τ_0_0>) -> @owned Builtin.NativeObject
+ // CHECK: [[PTR:%.*]] = apply [[BASE_DTOR]]<T>([[BASE]])
+ // CHECK: [[BORROWED_PTR:%.*]] = begin_borrow [[PTR]]
+ // CHECK: end_borrow [[BORROWED_PTR]] from [[PTR]]
+ // CHECK: return [[PTR]]
+
+
+ deinit {
+ bar()
+ }
+}
+
+class ImplicitDtor {
+ var x:Int
+ var y:(Int, Ref)
+ var w:Ref
+ init() { }
+
+ // CHECK-LABEL: sil hidden @$S8lifetime12ImplicitDtorCfd
+ // CHECK: bb0([[THIS:%[0-9]+]] : $ImplicitDtor):
+ // -- don't need to destroy_value x because it's trivial
+ // CHECK-NOT: ref_element_addr [[THIS]] : {{.*}}, #ImplicitDtor.x
+ // -- destroy_value y
+ // CHECK: [[YADDR:%[0-9]+]] = ref_element_addr [[THIS]] : {{.*}}, #ImplicitDtor.y
+ // CHECK: destroy_addr [[YADDR]]
+ // -- destroy_value w
+ // CHECK: [[WADDR:%[0-9]+]] = ref_element_addr [[THIS]] : {{.*}}, #ImplicitDtor.w
+ // CHECK: destroy_addr [[WADDR]]
+ // CHECK: return
+}
+
+class ImplicitDtorDerived<T> : ImplicitDtor {
+ var z:T
+
+ init(z : T) {
+ super.init()
+ self.z = z
+ }
+
+ // CHECK: sil hidden @$S8lifetime19ImplicitDtorDerivedCfd : $@convention(method) <T> (@guaranteed ImplicitDtorDerived<T>) -> @owned Builtin.NativeObject {
+ // CHECK: bb0([[THIS:%[0-9]+]] : $ImplicitDtorDerived<T>):
+ // -- base dtor
+ // CHECK: [[BASE:%[0-9]+]] = upcast [[THIS]] : ${{.*}} to $ImplicitDtor
+ // CHECK: [[BASE_DTOR:%[0-9]+]] = function_ref @$S8lifetime12ImplicitDtorCfd
+ // CHECK: [[PTR:%.*]] = apply [[BASE_DTOR]]([[BASE]])
+ // -- destroy_value z
+ // CHECK: [[BORROWED_PTR:%.*]] = begin_borrow [[PTR]]
+ // CHECK: [[CAST_BORROWED_PTR:%.*]] = unchecked_ref_cast [[BORROWED_PTR]] : $Builtin.NativeObject to $ImplicitDtorDerived<T>
+ // CHECK: [[ZADDR:%[0-9]+]] = ref_element_addr [[CAST_BORROWED_PTR]] : {{.*}}, #ImplicitDtorDerived.z
+ // CHECK: destroy_addr [[ZADDR]]
+ // CHECK: end_borrow [[BORROWED_PTR]] from [[PTR]]
+ // -- epilog
+ // CHECK-NOT: unchecked_ref_cast
+ // CHECK-NOT: unchecked_ownership_conversion
+ // CHECK: return [[PTR]]
+}
+
+class ImplicitDtorDerivedFromGeneric<T> : ImplicitDtorDerived<Int> {
+ init() { super.init(z: 5) }
+
+ // CHECK-LABEL: sil hidden @$S8lifetime30ImplicitDtorDerivedFromGenericC{{[_0-9a-zA-Z]*}}fc
+ // CHECK: bb0([[THIS:%[0-9]+]] : $ImplicitDtorDerivedFromGeneric<T>):
+ // -- base dtor
+ // CHECK: [[BASE:%[0-9]+]] = upcast [[THIS]] : ${{.*}} to $ImplicitDtorDerived<Int>
+ // CHECK: [[BASE_DTOR:%[0-9]+]] = function_ref @$S8lifetime19ImplicitDtorDerivedCfd
+ // CHECK: [[PTR:%.*]] = apply [[BASE_DTOR]]<Int>([[BASE]])
+ // CHECK: return [[PTR]]
+}
+
+protocol Intifiable {
+ func intify() -> Int
+}
+
+struct Bar {
+ var x:Int
+
+ // Loadable struct initializer
+ // CHECK-LABEL: sil hidden @$S8lifetime3BarV{{[_0-9a-zA-Z]*}}fC
+ init() {
+ // CHECK: bb0([[METATYPE:%[0-9]+]] : $@thin Bar.Type):
+ // CHECK: [[SELF_BOX:%[0-9]+]] = alloc_box ${ var Bar }
+ // CHECK: [[MARKED_SELF_BOX:%[0-9]+]] = mark_uninitialized [rootself] [[SELF_BOX]]
+ // CHECK: [[PB_BOX:%.*]] = project_box [[MARKED_SELF_BOX]]
+
+ x = bar()
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB_BOX]]
+ // CHECK: [[SELF_X:%[0-9]+]] = struct_element_addr [[WRITE]] : $*Bar, #Bar.x
+ // CHECK: assign {{.*}} to [[SELF_X]]
+
+ // -- load and return this
+ // CHECK: [[SELF_VAL:%[0-9]+]] = load [trivial] [[PB_BOX]]
+ // CHECK: destroy_value [[MARKED_SELF_BOX]]
+ // CHECK: return [[SELF_VAL]]
+ }
+
+ init<T:Intifiable>(xx:T) {
+ x = xx.intify()
+ }
+}
+
+struct Bas<T> {
+ var x:Int
+ var y:T
+
+ // Address-only struct initializer
+ // CHECK-LABEL: sil hidden @$S8lifetime3BasV{{[_0-9a-zA-Z]*}}fC
+ init(yy:T) {
+ // CHECK: bb0([[THISADDRPTR:%[0-9]+]] : $*Bas<T>, [[YYADDR:%[0-9]+]] : $*T, [[META:%[0-9]+]] : $@thin Bas<T>.Type):
+ // CHECK: [[SELF_BOX:%[0-9]+]] = alloc_box $<τ_0_0> { var Bas<τ_0_0> } <T>
+ // CHECK: [[MARKED_SELF_BOX:%[0-9]+]] = mark_uninitialized [rootself] [[SELF_BOX]]
+ // CHECK: [[PB_BOX:%.*]] = project_box [[MARKED_SELF_BOX]]
+
+ x = bar()
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB_BOX]]
+ // CHECK: [[SELF_X:%[0-9]+]] = struct_element_addr [[WRITE]] : $*Bas<T>, #Bas.x
+ // CHECK: assign {{.*}} to [[SELF_X]]
+
+ y = yy
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB_BOX]]
+ // CHECK: [[SELF_Y:%[0-9]+]] = struct_element_addr [[WRITE]] : $*Bas<T>, #Bas.y
+ // CHECK: copy_addr {{.*}} to [[SELF_Y]]
+ // CHECK: destroy_value
+
+ // -- 'self' was emplaced into indirect return slot
+ // CHECK: return
+ }
+
+ init<U:Intifiable>(xx:U, yy:T) {
+ x = xx.intify()
+ y = yy
+ }
+}
+
+class B { init(y:Int) {} }
+class D : B {
+ // CHECK-LABEL: sil hidden @$S8lifetime1DC1x1yACSi_Sitcfc
+ // CHECK: bb0([[X:%[0-9]+]] : $Int, [[Y:%[0-9]+]] : $Int, [[SELF:%[0-9]+]] : $D):
+ init(x: Int, y: Int) {
+ var x = x
+ var y = y
+ // CHECK: [[SELF_BOX:%[0-9]+]] = alloc_box ${ var D }
+ // CHECK: [[MARKED_SELF_BOX:%[0-9]+]] = mark_uninitialized [derivedself] [[SELF_BOX]]
+ // CHECK: [[PB_BOX:%[0-9]+]] = project_box [[MARKED_SELF_BOX]]
+ // CHECK: store [[SELF]] to [init] [[PB_BOX]]
+ // CHECK: [[XADDR:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[PX:%[0-9]+]] = project_box [[XADDR]]
+ // CHECK: store [[X]] to [trivial] [[PX]]
+ // CHECK: [[YADDR:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[PY:%[0-9]+]] = project_box [[YADDR]]
+ // CHECK: store [[Y]] to [trivial] [[PY]]
+
+ super.init(y: y)
+ // CHECK: [[THIS1:%[0-9]+]] = load [take] [[PB_BOX]]
+ // CHECK: [[THIS1_SUP:%[0-9]+]] = upcast [[THIS1]] : ${{.*}} to $B
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PY]]
+ // CHECK: [[Y:%[0-9]+]] = load [trivial] [[READ]]
+ // CHECK: [[SUPER_CTOR:%[0-9]+]] = function_ref @$S8lifetime1BC1yACSi_tcfc : $@convention(method) (Int, @owned B) -> @owned B
+ // CHECK: [[THIS2_SUP:%[0-9]+]] = apply [[SUPER_CTOR]]([[Y]], [[THIS1_SUP]])
+ // CHECK: [[THIS2:%[0-9]+]] = unchecked_ref_cast [[THIS2_SUP]] : $B to $D
+ // CHECK: [[THIS1:%[0-9]+]] = load [copy] [[PB_BOX]]
+ // CHECK: destroy_value [[MARKED_SELF_BOX]]
+ }
+
+ func foo() {}
+}
+
+// CHECK-LABEL: sil hidden @$S8lifetime8downcast{{[_0-9a-zA-Z]*}}F
+func downcast(_ b: B) {
+ var b = b
+ // CHECK: [[BADDR:%[0-9]+]] = alloc_box ${ var B }
+ // CHECK: [[PB:%[0-9]+]] = project_box [[BADDR]]
+ (b as! D).foo()
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PB]]
+ // CHECK: [[B:%[0-9]+]] = load [copy] [[READ]]
+ // CHECK: [[D:%[0-9]+]] = unconditional_checked_cast [[B]] : {{.*}} to $D
+ // CHECK: apply {{.*}}([[D]])
+ // CHECK-NOT: destroy_value [[B]]
+ // CHECK: destroy_value [[D]]
+ // CHECK: destroy_value [[BADDR]]
+ // CHECK: return
+}
+
+func int(_ x: Int) {}
+func ref(_ x: Ref) {}
+
+func tuple() -> (Int, Ref) { return (1, Ref()) }
+
+func tuple_explosion() {
+ int(tuple().0)
+ // CHECK: [[F:%[0-9]+]] = function_ref @$S8lifetime5tupleSi_AA3RefCtyF
+ // CHECK: [[TUPLE:%[0-9]+]] = apply [[F]]()
+ // CHECK: [[BORROWED_TUPLE:%.*]] = begin_borrow [[TUPLE]]
+ // CHECK: [[T1:%[0-9]+]] = tuple_extract [[BORROWED_TUPLE]] : {{.*}}, 1
+ // CHECK: [[T1_COPY:%.*]] = copy_value [[T1]]
+ // CHECK: end_borrow [[BORROWED_TUPLE]] from [[TUPLE]]
+ // CHECK: destroy_value [[T1_COPY]]
+ // CHECK-NOT: tuple_extract [[TUPLE]] : {{.*}}, 1
+ // CHECK-NOT: destroy_value
+
+ ref(tuple().1)
+ // CHECK: [[F:%[0-9]+]] = function_ref @$S8lifetime5tupleSi_AA3RefCtyF
+ // CHECK: [[TUPLE:%[0-9]+]] = apply [[F]]()
+ // CHECK: [[BORROWED_TUPLE:%.*]] = begin_borrow [[TUPLE]]
+ // CHECK: [[T1:%[0-9]+]] = tuple_extract [[BORROWED_TUPLE]] : {{.*}}, 1
+ // CHECK: [[T1_COPY:%.*]] = copy_value [[T1]]
+ // CHECK: end_borrow [[BORROWED_TUPLE]] from [[TUPLE]]
+ // CHECK: destroy_value [[TUPLE]]
+ // CHECK-NOT: destroy_value [[T1]]
+ // CHECK-NOT: tuple_extract [[TUPLE]] : {{.*}}, 1
+ // CHECK-NOT: destroy_value [[TUPLE]]
+}
+
+class C {
+ var v = ""
+ // CHECK-LABEL: sil hidden @$S8lifetime1CC18ignored_assignment{{[_0-9a-zA-Z]*}}F
+ func ignored_assignment() {
+ // CHECK: [[STRING:%.*]] = alloc_stack $String
+ // CHECK: [[UNINIT:%.*]] = mark_uninitialized [var] [[STRING]]
+ // CHECK: assign {{%.*}} to [[UNINIT]]
+ // CHECK: destroy_addr [[UNINIT]]
+ _ = self.v
+ }
+}
diff --git a/test/SILGen/plus_zero_mangling.swift b/test/SILGen/plus_zero_mangling.swift
new file mode 100644
index 0000000..a0357ce
--- /dev/null
+++ b/test/SILGen/plus_zero_mangling.swift
@@ -0,0 +1,191 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -sdk %S/Inputs -I %S/Inputs -enable-source-import %s -emit-silgen -enable-sil-ownership | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import gizmo
+
+// Test mangling of Unicode identifiers.
+// These examples are from RFC 3492, which defines the Punycode encoding used
+// by name mangling.
+
+// CHECK-LABEL: sil hidden @$S8mangling0022egbpdajGbuEbxfgehfvwxnyyF
+func ليهمابتكلموشعربي؟() { }
+// CHECK-LABEL: sil hidden @$S8mangling0024ihqwcrbEcvIaIdqgAFGpqjyeyyF
+func 他们为什么不说中文() { }
+// CHECK-LABEL: sil hidden @$S8mangling0027ihqwctvzcJBfGFJdrssDxIboAybyyF
+func 他們爲什麽不說中文() { }
+// CHECK-LABEL: sil hidden @$S8mangling0030Proprostnemluvesky_uybCEdmaEBayyF
+func Pročprostěnemluvíčesky() { }
+
+// <rdar://problem/13757744> Variadic tuples need a different mangling from
+// non-variadic tuples.
+
+// CHECK-LABEL: sil hidden @$S8mangling9r137577441xySaySiG_tF
+func r13757744(x: [Int]) {}
+// CHECK-LABEL: sil hidden @$S8mangling9r137577441xySid_tF
+func r13757744(x: Int...) {}
+
+// <rdar://problem/13757750> Prefix, postfix, and infix operators need
+// distinct manglings.
+
+prefix operator +-
+postfix operator +-
+infix operator +-
+
+// CHECK-LABEL: sil hidden @$S8mangling2psopyyxlF
+prefix func +- <T>(a: T) {}
+// CHECK-LABEL: sil hidden @$S8mangling2psoPyyxlF
+postfix func +- <T>(a: T) {}
+
+// CHECK-LABEL: sil hidden @$S8mangling2psoiyyx_xtlF
+func +- <T>(a: T, b: T) {}
+
+// CHECK-LABEL: sil hidden @$S8mangling2psopyyx1a_x1bt_tlF
+prefix func +- <T>(_: (a: T, b: T)) {}
+// CHECK-LABEL: sil hidden @$S8mangling2psoPyyx1a_x1bt_tlF
+postfix func +- <T>(_: (a: T, b: T)) {}
+
+infix operator «+» {}
+
+// CHECK-LABEL: sil hidden @$S8mangling007p_qcaDcoiyS2i_SitF
+func «+»(a: Int, b: Int) -> Int { return a + b }
+
+protocol Foo {}
+protocol Bar {}
+
+// Ensure protocol list manglings are '_' terminated regardless of length
+// CHECK-LABEL: sil hidden @$S8mangling12any_protocolyyypF
+func any_protocol(_: Any) {}
+// CHECK-LABEL: sil hidden @$S8mangling12one_protocolyyAA3Foo_pF
+func one_protocol(_: Foo) {}
+// CHECK-LABEL: sil hidden @$S8mangling18one_protocol_twiceyyAA3Foo_p_AaC_ptF
+func one_protocol_twice(_: Foo, _: Foo) {}
+// CHECK-LABEL: sil hidden @$S8mangling12two_protocolyyAA3Bar_AA3FoopF
+func two_protocol(_: Foo & Bar) {}
+
+// Ensure archetype depths are mangled correctly.
+class Zim<T> {
+ // CHECK-LABEL: sil hidden @$S8mangling3ZimC4zangyyx_qd__tlF
+ func zang<U>(_: T, _: U) {}
+ // CHECK-LABEL: sil hidden @$S8mangling3ZimC4zungyyqd___xtlF
+ func zung<U>(_: U, _: T) {}
+}
+
+// Don't crash mangling single-protocol "composition" types.
+// CHECK-LABEL: sil hidden @$S8mangling27single_protocol_composition1xyAA3Foo_p_tF
+func single_protocol_composition(x: protocol<Foo>) {} // expected-warning {{'protocol<...>' composition syntax is deprecated; join the protocols using '&'}}
+
+// Clang-imported classes and protocols get mangled into a magic 'So' context
+// to make collisions into link errors. <rdar://problem/14221244>
+// CHECK-LABEL: sil hidden @$S8mangling28uses_objc_class_and_protocol1o1p2p2ySo8NSObjectC_So8NSAnsing_pSo14NSBetterAnsing_ptF
+func uses_objc_class_and_protocol(o: NSObject, p: NSAnsing, p2: BetterAnsing) {}
+
+// Clang-imported structs get mangled using their Clang module name.
+// FIXME: Temporarily mangles everything into the virtual module __C__
+// <rdar://problem/14221244>
+// CHECK-LABEL: sil hidden @$S8mangling17uses_clang_struct1rySo6NSRectV_tF
+func uses_clang_struct(r: NSRect) {}
+
+// CHECK-LABEL: sil hidden @$S8mangling14uses_optionals1xs7UnicodeO6ScalarVSgSiSg_tF
+func uses_optionals(x: Int?) -> UnicodeScalar? { return nil }
+
+enum GenericUnion<T> {
+ // CHECK-LABEL: sil shared [transparent] @$S8mangling12GenericUnionO3FooyACyxGSicAEmlF
+ case Foo(Int)
+}
+
+func instantiateGenericUnionConstructor<T>(_ t: T) {
+ _ = GenericUnion<T>.Foo
+}
+
+struct HasVarInit {
+ static var state = true && false
+}
+// CHECK-LABEL: // function_ref implicit closure #1 : @autoclosure () throws -> Swift.Bool in variable initialization expression of static mangling.HasVarInit.state : Swift.Bool
+// CHECK-NEXT: function_ref @$S8mangling10HasVarInitV5stateSbvpZfiSbyKXKfu_
+
+// auto_closures should not collide with the equivalent non-auto_closure
+// function type.
+
+// CHECK-LABEL: sil hidden @$S8mangling19autoClosureOverload1fySiyXK_tF : $@convention(thin) (@noescape @callee_guaranteed () -> Int) -> () {
+func autoClosureOverload(f: @autoclosure () -> Int) {}
+// CHECK-LABEL: sil hidden @$S8mangling19autoClosureOverload1fySiyXE_tF : $@convention(thin) (@noescape @callee_guaranteed () -> Int) -> () {
+func autoClosureOverload(f: () -> Int) {}
+
+// CHECK-LABEL: sil hidden @$S8mangling24autoClosureOverloadCallsyyF : $@convention(thin) () -> () {
+func autoClosureOverloadCalls() {
+ // CHECK: function_ref @$S8mangling19autoClosureOverload1fySiyXK_tF
+ autoClosureOverload(f: 1)
+ // CHECK: function_ref @$S8mangling19autoClosureOverload1fySiyXE_tF
+ autoClosureOverload {1}
+}
+
+// <rdar://problem/16079822> Associated type requirements need to appear in the
+// mangling.
+
+protocol AssocReqt {}
+
+protocol HasAssocType {
+ associatedtype Assoc
+}
+
+// CHECK-LABEL: sil hidden @$S8mangling4fooAyyxAA12HasAssocTypeRzlF : $@convention(thin) <T where T : HasAssocType> (@in_guaranteed T) -> ()
+func fooA<T: HasAssocType>(_: T) {}
+// CHECK-LABEL: sil hidden @$S8mangling4fooByyxAA12HasAssocTypeRzAA0D4Reqt0D0RpzlF : $@convention(thin) <T where T : HasAssocType, T.Assoc : AssocReqt> (@in_guaranteed T) -> ()
+func fooB<T: HasAssocType>(_: T) where T.Assoc: AssocReqt {}
+
+// CHECK-LABEL: sil hidden @$S8mangling2qqoiyySi_SitF
+func ??(x: Int, y: Int) {}
+
+struct InstanceAndClassProperty {
+ var property: Int {
+ // CHECK-LABEL: sil hidden @$S8mangling24InstanceAndClassPropertyV8propertySivg
+ get { return 0 }
+ // CHECK-LABEL: sil hidden @$S8mangling24InstanceAndClassPropertyV8propertySivs
+ set {}
+ }
+ static var property: Int {
+ // CHECK-LABEL: sil hidden @$S8mangling24InstanceAndClassPropertyV8propertySivgZ
+ get { return 0 }
+ // CHECK-LABEL: sil hidden @$S8mangling24InstanceAndClassPropertyV8propertySivsZ
+ set {}
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S8mangling6curry1yyF : $@convention(thin) () -> ()
+func curry1() {
+
+}
+
+// CHECK-LABEL: sil hidden @$S8mangling3barSiyKF : $@convention(thin) () -> (Int, @error Error)
+func bar() throws -> Int { return 0 }
+
+// CHECK-LABEL: sil hidden @$S8mangling12curry1ThrowsyyKF : $@convention(thin) () -> @error Error
+func curry1Throws() throws {
+
+}
+
+// CHECK-LABEL: sil hidden @$S8mangling12curry2ThrowsyycyKF : $@convention(thin) () -> (@owned @callee_guaranteed () -> (), @error Error)
+func curry2Throws() throws -> () -> () {
+ return curry1
+}
+
+// CHECK-LABEL: sil hidden @$S8mangling6curry3yyKcyF : $@convention(thin) () -> @owned @callee_guaranteed () -> @error Error
+func curry3() -> () throws -> () {
+ return curry1Throws
+}
+
+// CHECK-LABEL: sil hidden @$S8mangling12curry3ThrowsyyKcyKF : $@convention(thin) () -> (@owned @callee_guaranteed () -> @error Error, @error Error)
+func curry3Throws() throws -> () throws -> () {
+ return curry1Throws
+}
+
+// CHECK-LABEL: sil hidden @$S8mangling14varargsVsArray3arr1nySid_SStF : $@convention(thin) (@guaranteed Array<Int>, @guaranteed String) -> ()
+func varargsVsArray(arr: Int..., n: String) { }
+
+// CHECK-LABEL: sil hidden @$S8mangling14varargsVsArray3arr1nySaySiG_SStF : $@convention(thin) (@guaranteed Array<Int>, @guaranteed String) -> ()
+func varargsVsArray(arr: [Int], n: String) { }
+
+// CHECK-LABEL: sil hidden @$S8mangling14varargsVsArray3arr1nySaySiGd_SStF : $@convention(thin) (@guaranteed Array<Array<Int>>, @guaranteed String) -> ()
+func varargsVsArray(arr: [Int]..., n: String) { }
diff --git a/test/SILGen/plus_zero_materializeForSet.swift b/test/SILGen/plus_zero_materializeForSet.swift
new file mode 100644
index 0000000..f742400a
--- /dev/null
+++ b/test/SILGen/plus_zero_materializeForSet.swift
@@ -0,0 +1,677 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
+// RUN: %target-swift-frontend -emit-silgen -enforce-exclusivity=unchecked %s | %FileCheck --check-prefix=UNCHECKED %s
+
+class Base {
+ var stored: Int = 0
+
+// CHECK-LABEL: sil hidden [transparent] @$S17materializeForSet4BaseC6storedSivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed Base) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $Base):
+// CHECK: [[T0:%.*]] = ref_element_addr [[SELF]] : $Base, #Base.stored
+// CHECK: [[T1:%.*]] = address_to_pointer [[T0]] : $*Int to $Builtin.RawPointer
+// CHECK: [[T2:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some
+// CHECK: [[T3:%.*]] = tuple ([[T1]] : $Builtin.RawPointer, [[T2]] : $Optional<Builtin.RawPointer>)
+// CHECK: return [[T3]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+// CHECK: }
+
+// UNCHECKED-LABEL: sil hidden [transparent] @$S17materializeForSet4BaseC6storedSivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed Base) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// UNCHECKED: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $Base):
+// UNCHECKED: [[T0:%.*]] = ref_element_addr [[SELF]] : $Base, #Base.stored
+// UNCHECKED: [[T1:%.*]] = address_to_pointer [[T0]] : $*Int to $Builtin.RawPointer
+// UNCHECKED: [[T2:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.none
+// UNCHECKED: [[T3:%.*]] = tuple ([[T1]] : $Builtin.RawPointer, [[T2]] : $Optional<Builtin.RawPointer>)
+// UNCHECKED: return [[T3]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+// UNCHECKED: }
+
+// CHECK-LABEL: sil private [transparent] @$S17materializeForSet4BaseC8computedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Base, @thick Base.Type) -> () {
+// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $*Base, [[SELFTYPE:%.*]] : $@thick Base.Type):
+// CHECK: [[T0:%.*]] = load_borrow [[SELF]]
+// CHECK: [[T1:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
+// CHECK: [[T2:%.*]] = load [trivial] [[T1]] : $*Int
+// CHECK: [[SETTER:%.*]] = function_ref @$S17materializeForSet4BaseC8computedSivs
+// CHECK: apply [[SETTER]]([[T2]], [[T0]])
+
+// CHECK-LABEL: sil hidden [transparent] @$S17materializeForSet4BaseC8computedSivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed Base) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $Base):
+// CHECK: [[ADDR:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
+// CHECK: [[T0:%.*]] = function_ref @$S17materializeForSet4BaseC8computedSivg
+// CHECK: [[T1:%.*]] = apply [[T0]]([[SELF]])
+// CHECK: store [[T1]] to [trivial] [[ADDR]] : $*Int
+// CHECK: [[BUFFER:%.*]] = address_to_pointer [[ADDR]]
+// CHECK: [[T0:%.*]] = function_ref @$S17materializeForSet4BaseC8computedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Base, @thick Base.Type) -> ()
+// CHECK: [[T2:%.*]] = thin_function_to_pointer [[T0]]
+// CHECK: [[T3:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[T2]] : $Builtin.RawPointer
+// CHECK: [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, [[T3]] : $Optional<Builtin.RawPointer>)
+// CHECK: return [[T4]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+// CHECK: }
+
+ var computed: Int {
+ get { return 0 }
+ set(value) {}
+ }
+
+ var storedFunction: () -> Int = { 0 }
+ final var finalStoredFunction: () -> Int = { 0 }
+ var computedFunction: () -> Int {
+ get { return {0} }
+ set {}
+ }
+ static var staticFunction: () -> Int {
+ get { return {0} }
+ set {}
+ }
+}
+
+class Derived : Base {}
+
+protocol Abstractable {
+ associatedtype Result
+ var storedFunction: () -> Result { get set }
+ var finalStoredFunction: () -> Result { get set }
+ var computedFunction: () -> Result { get set }
+ static var staticFunction: () -> Result { get set }
+}
+
+// Validate that we thunk materializeForSet correctly when there's
+// an abstraction pattern present.
+
+extension Derived : Abstractable {}
+
+// CHECK-LABEL: sil private [transparent] @$S17materializeForSet7DerivedCAA12AbstractableA2aDP14storedFunction6ResultQzycvmytfU_TW : $@convention(witness_method: Abstractable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Derived, @thick Derived.Type) -> ()
+// CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*Derived, %3 : $@thick Derived.Type):
+// CHECK-NEXT: [[T0:%.*]] = load_borrow %2 : $*Derived
+// CHECK-NEXT: [[SELF:%.*]] = upcast [[T0]] : $Derived to $Base
+// CHECK-NEXT: [[RESULT_ADDR:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_guaranteed () -> @out Int
+// CHECK-NEXT: [[VALUE:%.*]] = load [take] [[RESULT_ADDR]] : $*@callee_guaranteed () -> @out Int
+// CHECK-NEXT: function_ref
+// CHECK-NEXT: [[REABSTRACTOR:%.*]] = function_ref @$SSiIegr_SiIegd_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> @out Int) -> Int
+// CHECK-NEXT: [[NEWVALUE:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACTOR]]([[VALUE]])
+// CHECK-NEXT: [[FN:%.*]] = class_method [[SELF]] : $Base, #Base.storedFunction!setter.1 : (Base) -> (@escaping () -> Int) -> ()
+// CHECK-NEXT: apply [[FN]]([[NEWVALUE]], [[SELF]])
+// CHECK-NEXT: end_borrow [[T0]] from %2
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S17materializeForSet7DerivedCAA12AbstractableA2aDP14storedFunction{{[_0-9a-zA-Z]*}}vmTW
+// CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*Derived):
+// CHECK-NEXT: [[RESULT_ADDR:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_guaranteed () -> @out Int
+// CHECK-NEXT: [[T0:%.*]] = load_borrow %2 : $*Derived
+// CHECK-NEXT: [[SELF:%.*]] = upcast [[T0]] : $Derived to $Base
+// CHECK-NEXT: [[TEMP:%.*]] = alloc_stack $@callee_guaranteed () -> Int
+// CHECK-NEXT: [[FN:%.*]] = class_method [[SELF]] : $Base, #Base.storedFunction!getter.1
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[FN]]([[SELF]])
+// CHECK-NEXT: store [[RESULT]] to [init] [[TEMP]]
+// CHECK-NEXT: [[RESULT:%.*]] = load [copy] [[TEMP]]
+// CHECK-NEXT: function_ref
+// CHECK-NEXT: [[REABSTRACTOR:%.*]] = function_ref @$SSiIegd_SiIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> Int) -> @out Int
+// CHECK-NEXT: [[T1:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACTOR]]([[RESULT]])
+// CHECK-NEXT: destroy_addr [[TEMP]]
+// CHECK-NEXT: store [[T1]] to [init] [[RESULT_ADDR]]
+// CHECK-NEXT: [[RESULT_PTR:%.*]] = address_to_pointer [[RESULT_ADDR]] : $*@callee_guaranteed () -> @out Int to $Builtin.RawPointer
+// CHECK-NEXT: function_ref
+// CHECK-NEXT: [[T2:%.*]] = function_ref @$S17materializeForSet7DerivedCAA12AbstractableA2aDP14storedFunction6ResultQzycvmytfU_TW
+// CHECK-NEXT: [[T3:%.*]] = thin_function_to_pointer [[T2]]
+// CHECK-NEXT: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[T3]]
+// CHECK-NEXT: [[T4:%.*]] = tuple ([[RESULT_PTR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
+// CHECK-NEXT: dealloc_stack [[TEMP]]
+// CHECK-NEXT: end_borrow [[T0]] from %2
+// CHECK-NEXT: return [[T4]]
+
+// CHECK-LABEL: sil private [transparent] @$S17materializeForSet7DerivedCAA12AbstractableA2aDP19finalStoredFunction6ResultQzycvmytfU_TW :
+// CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*Derived, %3 : $@thick Derived.Type):
+// CHECK-NEXT: [[T0:%.*]] = load_borrow %2 : $*Derived
+// CHECK-NEXT: [[SELF:%.*]] = upcast [[T0]] : $Derived to $Base
+// CHECK-NEXT: [[RESULT_ADDR:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_guaranteed () -> @out Int
+// CHECK-NEXT: [[VALUE:%.*]] = load [take] [[RESULT_ADDR]] : $*@callee_guaranteed () -> @out Int
+// CHECK-NEXT: // function_ref
+// CHECK-NEXT: [[REABSTRACTOR:%.*]] = function_ref @$SSiIegr_SiIegd_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> @out Int) -> Int
+// CHECK-NEXT: [[NEWVALUE:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACTOR]]([[VALUE]])
+// CHECK-NEXT: [[ADDR:%.*]] = ref_element_addr [[SELF]] : $Base, #Base.finalStoredFunction
+// CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[ADDR]] : $*@callee_guaranteed () -> Int
+// CHECK-NEXT: assign [[NEWVALUE]] to [[WRITE]]
+// CHECK-NEXT: end_access [[WRITE]] : $*@callee_guaranteed () -> Int
+// CHECK-NEXT: end_borrow [[T0]] from %2
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: return
+
+// UNCHECKED-LABEL: sil private [transparent] @$S17materializeForSet7DerivedCAA12AbstractableA2aDP19finalStoredFunction6ResultQzycvmytfU_TW :
+// UNCHECKED: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*Derived, %3 : $@thick Derived.Type):
+// UNCHECKED-NEXT: [[T0:%.*]] = load_borrow %2 : $*Derived
+// UNCHECKED-NEXT: [[SELF:%.*]] = upcast [[T0]] : $Derived to $Base
+// UNCHECKED-NEXT: [[RESULT_ADDR:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_guaranteed () -> @out Int
+// UNCHECKED-NEXT: [[VALUE:%.*]] = load [take] [[RESULT_ADDR]] : $*@callee_guaranteed () -> @out Int
+// UNCHECKED-NEXT: // function_ref
+// UNCHECKED-NEXT: [[REABSTRACTOR:%.*]] = function_ref @$SSiIegr_SiIegd_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> @out Int) -> Int
+// UNCHECKED-NEXT: [[NEWVALUE:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACTOR]]([[VALUE]])
+// UNCHECKED-NEXT: [[ADDR:%.*]] = ref_element_addr [[SELF]] : $Base, #Base.finalStoredFunction
+// UNCHECKED-NEXT: assign [[NEWVALUE]] to [[ADDR]]
+// UNCHECKED-NEXT: end_borrow [[T0]] from %2
+// UNCHECKED-NEXT: tuple ()
+// UNCHECKED-NEXT: return
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S17materializeForSet7DerivedCAA12AbstractableA2aDP19finalStoredFunction{{[_0-9a-zA-Z]*}}vmTW
+// CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*Derived):
+// CHECK-NEXT: [[RESULT_ADDR:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_guaranteed () -> @out Int
+// CHECK-NEXT: [[T0:%.*]] = load_borrow %2 : $*Derived
+// CHECK-NEXT: [[SELF:%.*]] = upcast [[T0]] : $Derived to $Base
+// CHECK-NEXT: [[ADDR:%.*]] = ref_element_addr [[SELF]] : $Base, #Base.finalStoredFunction
+// CHECK-NEXT: [[READ:%.*]] = begin_access [read] [dynamic] [[ADDR]] : $*@callee_guaranteed () -> Int
+// CHECK-NEXT: [[RESULT:%.*]] = load [copy] [[READ]]
+// CHECK-NEXT: function_ref
+// CHECK-NEXT: [[REABSTRACTOR:%.*]] = function_ref @$SSiIegd_SiIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> Int) -> @out Int
+// CHECK-NEXT: [[T1:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACTOR]]([[RESULT]])
+// CHECK-NEXT: end_access [[READ]] : $*@callee_guaranteed () -> Int
+// CHECK-NEXT: store [[T1]] to [init] [[RESULT_ADDR]]
+// CHECK-NEXT: [[RESULT_PTR:%.*]] = address_to_pointer [[RESULT_ADDR]] : $*@callee_guaranteed () -> @out Int to $Builtin.RawPointer
+// CHECK-NEXT: function_ref
+// CHECK-NEXT: [[T2:%.*]] = function_ref @$S17materializeForSet7DerivedCAA12AbstractableA2aDP19finalStoredFunction6ResultQzycvmytfU_TW
+// CHECK-NEXT: [[T3:%.*]] = thin_function_to_pointer [[T2]]
+// CHECK-NEXT: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[T3]]
+// CHECK-NEXT: [[T4:%.*]] = tuple ([[RESULT_PTR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
+// CHECK-NEXT: end_borrow [[T0]] from %2
+// CHECK-NEXT: return [[T4]]
+
+// UNCHECKED-LABEL: sil private [transparent] [thunk] @$S17materializeForSet7DerivedCAA12AbstractableA2aDP19finalStoredFunction{{[_0-9a-zA-Z]*}}vmTW
+// UNCHECKED: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*Derived):
+// UNCHECKED-NEXT: [[RESULT_ADDR:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_guaranteed () -> @out Int
+// UNCHECKED-NEXT: [[T0:%.*]] = load_borrow %2 : $*Derived
+// UNCHECKED-NEXT: [[SELF:%.*]] = upcast [[T0]] : $Derived to $Base
+// UNCHECKED-NEXT: [[ADDR:%.*]] = ref_element_addr [[SELF]] : $Base, #Base.finalStoredFunction
+// UNCHECKED-NEXT: [[RESULT:%.*]] = load [copy] [[ADDR]]
+// UNCHECKED-NEXT: function_ref
+// UNCHECKED-NEXT: [[REABSTRACTOR:%.*]] = function_ref @$SSiIegd_SiIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> Int) -> @out Int
+// UNCHECKED-NEXT: [[T1:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACTOR]]([[RESULT]])
+// UNCHECKED-NEXT: store [[T1]] to [init] [[RESULT_ADDR]]
+// UNCHECKED-NEXT: [[RESULT_PTR:%.*]] = address_to_pointer [[RESULT_ADDR]] : $*@callee_guaranteed () -> @out Int to $Builtin.RawPointer
+// UNCHECKED-NEXT: function_ref
+// UNCHECKED-NEXT: [[T2:%.*]] = function_ref @$S17materializeForSet7DerivedCAA12AbstractableA2aDP19finalStoredFunction6ResultQzycvmytfU_TW
+// UNCHECKED-NEXT: [[T3:%.*]] = thin_function_to_pointer [[T2]]
+// UNCHECKED-NEXT: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[T3]]
+// UNCHECKED-NEXT: [[T4:%.*]] = tuple ([[RESULT_PTR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
+// UNCHECKED-NEXT: end_borrow [[T0]] from %2
+// UNCHECKED-NEXT: return [[T4]]
+
+// CHECK-LABEL: sil private [transparent] @$S17materializeForSet7DerivedCAA12AbstractableA2aDP14staticFunction6ResultQzycvmZytfU_TW
+// CHECK: bb0([[ARG1:%.*]] : $Builtin.RawPointer, [[ARG2:%.*]] : $*Builtin.UnsafeValueBuffer, [[ARG3:%.*]] : $*@thick Derived.Type, [[ARG4:%.*]] : $@thick Derived.Type.Type):
+// CHECK-NEXT: [[SELF:%.*]] = load [trivial] [[ARG3]] : $*@thick Derived.Type
+// CHECK-NEXT: [[BASE_SELF:%.*]] = upcast [[SELF]] : $@thick Derived.Type to $@thick Base.Type
+// CHECK-NEXT: [[BUFFER:%.*]] = pointer_to_address [[ARG1]] : $Builtin.RawPointer to [strict] $*@callee_guaranteed () -> @out Int
+// CHECK-NEXT: [[VALUE:%.*]] = load [take] [[BUFFER]] : $*@callee_guaranteed () -> @out Int
+// CHECK: [[REABSTRACTOR:%.*]] = function_ref @$SSiIegr_SiIegd_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> @out Int) -> Int
+// CHECK-NEXT: [[NEWVALUE:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACTOR]]([[VALUE]]) : $@convention(thin) (@guaranteed @callee_guaranteed () -> @out Int) -> Int
+// CHECK: [[SETTER_FN:%.*]] = function_ref @$S17materializeForSet4BaseC14staticFunctionSiycvsZ : $@convention(method) (@owned @callee_guaranteed () -> Int, @thick Base.Type) -> ()
+// CHECK-NEXT: apply [[SETTER_FN]]([[NEWVALUE]], [[BASE_SELF]]) : $@convention(method) (@owned @callee_guaranteed () -> Int, @thick Base.Type) -> ()
+// CHECK-NEXT: [[RESULT:%.*]] = tuple ()
+// CHECK-NEXT: return [[RESULT]] : $()
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S17materializeForSet7DerivedCAA12AbstractableA2aDP14staticFunction6ResultQzycvmZTW
+// CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $@thick Derived.Type):
+// CHECK-NEXT: [[RESULT_ADDR:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_guaranteed () -> @out Int
+// CHECK-NEXT: [[SELF:%.*]] = upcast %2 : $@thick Derived.Type to $@thick Base.Type
+// CHECK-NEXT: [[OUT:%.*]] = alloc_stack $@callee_guaranteed () -> Int
+// CHECK: [[GETTER:%.*]] = function_ref @$S17materializeForSet4BaseC14staticFunctionSiycvgZ : $@convention(method) (@thick Base.Type) -> @owned @callee_guaranteed () -> Int
+// CHECK-NEXT: [[VALUE:%.*]] = apply [[GETTER]]([[SELF]]) : $@convention(method) (@thick Base.Type) -> @owned @callee_guaranteed () -> Int
+// CHECK-NEXT: store [[VALUE]] to [init] [[OUT]] : $*@callee_guaranteed () -> Int
+// CHECK-NEXT: [[VALUE:%.*]] = load [copy] [[OUT]] : $*@callee_guaranteed () -> Int
+// CHECK: [[REABSTRACTOR:%.*]] = function_ref @$SSiIegd_SiIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> Int) -> @out Int
+// CHECK-NEXT: [[NEWVALUE:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACTOR]]([[VALUE]])
+// CHECK-NEXT: destroy_addr [[OUT]] : $*@callee_guaranteed () -> Int
+// CHECK-NEXT: store [[NEWVALUE]] to [init] [[RESULT_ADDR]] : $*@callee_guaranteed () -> @out Int
+// CHECK-NEXT: [[ADDR:%.*]] = address_to_pointer [[RESULT_ADDR]] : $*@callee_guaranteed () -> @out Int to $Builtin.RawPointer
+// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S17materializeForSet7DerivedCAA12AbstractableA2aDP14staticFunction6ResultQzycvmZytfU_TW : $@convention(witness_method: Abstractable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout @thick Derived.Type, @thick Derived.Type.Type) -> ()
+// CHECK-NEXT: [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]] : $@convention(witness_method: Abstractable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout @thick Derived.Type, @thick Derived.Type.Type) -> () to $Builtin.RawPointer
+// CHECK-NEXT: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]] : $Builtin.RawPointer
+// CHECK-NEXT: [[RESULT:%.*]] = tuple ([[ADDR]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
+// CHECK-NEXT: dealloc_stack [[OUT]] : $*@callee_guaranteed () -> Int
+// CHECK-NEXT: return [[RESULT]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+
+protocol ClassAbstractable : class {
+ associatedtype Result
+ var storedFunction: () -> Result { get set }
+ var finalStoredFunction: () -> Result { get set }
+ var computedFunction: () -> Result { get set }
+ static var staticFunction: () -> Result { get set }
+}
+
+extension Derived : ClassAbstractable {}
+
+protocol Signatures {
+ associatedtype Result
+ var computedFunction: () -> Result { get set }
+}
+protocol Implementations {}
+extension Implementations {
+ var computedFunction: () -> Int {
+ get { return {0} }
+ set {}
+ }
+}
+
+class ImplementingClass : Implementations, Signatures {}
+struct ImplementingStruct : Implementations, Signatures {
+ var ref: ImplementingClass?
+}
+
+class HasDidSet : Base {
+ override var stored: Int {
+ didSet {}
+ }
+
+// CHECK-LABEL: sil hidden [transparent] @$S17materializeForSet06HasDidC0C6storedSivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed HasDidSet) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $HasDidSet):
+// CHECK: [[T2:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
+// CHECK: [[T0:%.*]] = function_ref @$S17materializeForSet06HasDidC0C6storedSivg
+// CHECK: [[T1:%.*]] = apply [[T0]]([[SELF]])
+// CHECK: store [[T1]] to [trivial] [[T2]] : $*Int
+// CHECK: [[BUFFER:%.*]] = address_to_pointer [[T2]]
+// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S17materializeForSet06HasDidC0C6storedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasDidSet, @thick HasDidSet.Type) -> ()
+// CHECK: [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]]
+// CHECK: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]]
+// CHECK: [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
+// CHECK: return [[T4]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+// CHECK: }
+
+ override var computed: Int {
+ get { return 0 }
+ set(value) {}
+ }
+
+// CHECK-LABEL: sil hidden [transparent] @$S17materializeForSet06HasDidC0C8computedSivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed HasDidSet) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $HasDidSet):
+// CHECK: [[T2:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
+// CHECK: [[T0:%.*]] = function_ref @$S17materializeForSet06HasDidC0C8computedSivg
+// CHECK: [[T1:%.*]] = apply [[T0]]([[SELF]])
+// CHECK: store [[T1]] to [trivial] [[T2]] : $*Int
+// CHECK: [[BUFFER:%.*]] = address_to_pointer [[T2]]
+// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S17materializeForSet06HasDidC0C8computedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasDidSet, @thick HasDidSet.Type) -> ()
+// CHECK: [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]]
+// CHECK: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]]
+// CHECK: [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
+// CHECK: return [[T4]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+// CHECK: }
+}
+
+class HasStoredDidSet {
+ var stored: Int = 0 {
+ didSet {}
+ }
+
+// CHECK-LABEL: sil private [transparent] @$S17materializeForSet012HasStoredDidC0C6storedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasStoredDidSet, @thick HasStoredDidSet.Type) -> () {
+// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $*HasStoredDidSet, [[METATYPE:%.*]] : $@thick HasStoredDidSet.Type):
+// CHECK: [[SELF_VALUE:%.*]] = load_borrow [[SELF]] : $*HasStoredDidSet
+// CHECK: [[BUFFER_ADDR:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
+// CHECK: [[VALUE:%.*]] = load [trivial] [[BUFFER_ADDR]] : $*Int
+// CHECK: [[SETTER_FN:%.*]] = function_ref @$S17materializeForSet012HasStoredDidC0C6storedSivs : $@convention(method) (Int, @guaranteed HasStoredDidSet) -> ()
+// CHECK: apply [[SETTER_FN]]([[VALUE]], [[SELF_VALUE]]) : $@convention(method) (Int, @guaranteed HasStoredDidSet) -> ()
+// CHECK: return
+// CHECK: }
+
+// CHECK-LABEL: sil hidden [transparent] @$S17materializeForSet012HasStoredDidC0C6storedSivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed HasStoredDidSet) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $HasStoredDidSet):
+// CHECK: [[T2:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Int
+// CHECK: [[T0:%.*]] = function_ref @$S17materializeForSet012HasStoredDidC0C6storedSivg
+// CHECK: [[T1:%.*]] = apply [[T0]]([[SELF]])
+// CHECK: store [[T1]] to [trivial] [[T2]] : $*Int
+// CHECK: [[BUFFER:%.*]] = address_to_pointer [[T2]]
+// CHECK: [[CALLBACK_FN:%.*]] = function_ref @$S17materializeForSet012HasStoredDidC0C6storedSivmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasStoredDidSet, @thick HasStoredDidSet.Type) -> ()
+// CHECK: [[CALLBACK_ADDR:%.*]] = thin_function_to_pointer [[CALLBACK_FN]]
+// CHECK: [[CALLBACK:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_ADDR]]
+// CHECK: [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, [[CALLBACK]] : $Optional<Builtin.RawPointer>)
+// CHECK: return [[T4]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+// CHECK: }
+}
+
+class HasWeak {
+ weak var weakvar: HasWeak?
+}
+// CHECK-LABEL: sil hidden [transparent] @$S17materializeForSet7HasWeakC7weakvarACSgXwvm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed HasWeak) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $HasWeak):
+// CHECK: [[T2:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Optional<HasWeak>
+// CHECK: [[T0:%.*]] = ref_element_addr [[SELF]] : $HasWeak, #HasWeak.weakvar
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[T0]] : $*@sil_weak Optional<HasWeak>
+// CHECK: [[T1:%.*]] = load_weak [[READ]] : $*@sil_weak Optional<HasWeak>
+// CHECK: end_access [[READ]] : $*@sil_weak Optional<HasWeak>
+// CHECK: store [[T1]] to [init] [[T2]] : $*Optional<HasWeak>
+// CHECK: [[BUFFER:%.*]] = address_to_pointer [[T2]]
+// CHECK: [[T0:%.*]] = function_ref @$S17materializeForSet7HasWeakC7weakvarACSgXwvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasWeak, @thick HasWeak.Type) -> ()
+// CHECK: [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, {{.*}} : $Optional<Builtin.RawPointer>)
+// CHECK: return [[T4]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+// CHECK: }
+
+// UNCHECKED-LABEL: sil hidden [transparent] @$S17materializeForSet7HasWeakC7weakvarACSgXwvm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed HasWeak) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// UNCHECKED: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $HasWeak):
+// UNCHECKED: [[T2:%.*]] = pointer_to_address [[BUFFER]] : $Builtin.RawPointer to [strict] $*Optional<HasWeak>
+// UNCHECKED: [[T0:%.*]] = ref_element_addr [[SELF]] : $HasWeak, #HasWeak.weakvar
+// UNCHECKED: [[T1:%.*]] = load_weak [[T0]] : $*@sil_weak Optional<HasWeak>
+// UNCHECKED: store [[T1]] to [init] [[T2]] : $*Optional<HasWeak>
+// UNCHECKED: [[BUFFER:%.*]] = address_to_pointer [[T2]]
+// UNCHECKED: [[T0:%.*]] = function_ref @$S17materializeForSet7HasWeakC7weakvarACSgXwvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasWeak, @thick HasWeak.Type) -> ()
+// UNCHECKED: [[T4:%.*]] = tuple ([[BUFFER]] : $Builtin.RawPointer, {{.*}} : $Optional<Builtin.RawPointer>)
+// UNCHECKED: return [[T4]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+// UNCHECKED: }
+
+// rdar://22109071
+// Test that we don't use materializeForSet from a protocol extension.
+protocol Magic {}
+extension Magic {
+ var hocus: Int {
+ get { return 0 }
+ set {}
+ }
+}
+struct Wizard : Magic {}
+func improve(_ x: inout Int) {}
+func improveWizard(_ wizard: inout Wizard) {
+ improve(&wizard.hocus)
+}
+// CHECK-LABEL: sil hidden @$S17materializeForSet13improveWizardyyAA0E0VzF
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] %0 : $*Wizard
+// CHECK-NEXT: [[TEMP:%.*]] = alloc_stack $Int
+// Call the getter and materialize the result in the temporary.
+// CHECK-NEXT: [[T0:%.*]] = load [trivial] [[WRITE:.*]] : $*Wizard
+// CHECK: [[WTEMP:%.*]] = alloc_stack $Wizard
+// CHECK-NEXT: store [[T0]] to [trivial] [[WTEMP]]
+// CHECK: [[GETTER:%.*]] = function_ref @$S17materializeForSet5MagicPAAE5hocusSivg
+// CHECK-NEXT: [[T0:%.*]] = apply [[GETTER]]<Wizard>([[WTEMP]])
+// CHECK-NEXT: dealloc_stack [[WTEMP]]
+// CHECK-NEXT: store [[T0]] to [trivial] [[TEMP]]
+// Call improve.
+// CHECK: [[IMPROVE:%.*]] = function_ref @$S17materializeForSet7improveyySizF :
+// CHECK-NEXT: apply [[IMPROVE]]([[TEMP]])
+// CHECK-NEXT: [[T0:%.*]] = load [trivial] [[TEMP]]
+// CHECK: [[SETTER:%.*]] = function_ref @$S17materializeForSet5MagicPAAE5hocusSivs
+// CHECK-NEXT: apply [[SETTER]]<Wizard>([[T0]], [[WRITE]])
+// CHECK-NEXT: end_access [[WRITE]] : $*Wizard
+// CHECK-NEXT: dealloc_stack [[TEMP]]
+
+protocol Totalled {
+ var total: Int { get set }
+}
+
+struct Bill : Totalled {
+ var total: Int
+}
+
+// CHECK-LABEL: sil hidden [transparent] @$S17materializeForSet4BillV5totalSivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Bill) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $*Bill):
+// CHECK: [[T0:%.*]] = struct_element_addr [[SELF]] : $*Bill, #Bill.total
+// CHECK: [[T1:%.*]] = address_to_pointer [[T0]] : $*Int to $Builtin.RawPointer
+// CHECK: [[T3:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.none!enumelt
+// CHECK: [[T4:%.*]] = tuple ([[T1]] : $Builtin.RawPointer, [[T3]] : $Optional<Builtin.RawPointer>)
+// CHECK: return [[T4]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+// CHECK: }
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S17materializeForSet4BillVAA8TotalledA2aDP5totalSivmTW : $@convention(witness_method: Totalled) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Bill) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0([[BUFFER:%.*]] : $Builtin.RawPointer, [[STORAGE:%.*]] : $*Builtin.UnsafeValueBuffer, [[SELF:%.*]] : $*Bill):
+// CHECK: [[T0:%.*]] = function_ref @$S17materializeForSet4BillV5totalSivm
+// CHECK-NEXT: [[T1:%.*]] = apply [[T0]]([[BUFFER]], [[STORAGE]], [[SELF]])
+// CHECK-NEXT: [[LEFT:%.*]] = tuple_extract [[T1]]
+// CHECK-NEXT: [[RIGHT:%.*]] = tuple_extract [[T1]]
+// CHECK-NEXT: [[T1:%.*]] = tuple ([[LEFT]] : $Builtin.RawPointer, [[RIGHT]] : $Optional<Builtin.RawPointer>)
+// CHECK-NEXT: return [[T1]] :
+
+protocol AddressOnlySubscript {
+ associatedtype Index
+ subscript(i: Index) -> Index { get set }
+}
+
+struct Foo<T>: AddressOnlySubscript {
+ subscript(i: T) -> T {
+ get { return i }
+ set { print("\(i) = \(newValue)") }
+ }
+}
+
+func increment(_ x: inout Int) { x += 1 }
+
+// Generic subscripts.
+
+protocol GenericSubscriptProtocol {
+ subscript<T>(_: T) -> T { get set }
+}
+
+struct GenericSubscriptWitness : GenericSubscriptProtocol {
+ subscript<T>(_: T) -> T { get { } set { } }
+}
+
+// CHECK-LABEL: sil private [transparent] @$S17materializeForSet23GenericSubscriptWitnessVyxxcluimytfU_ : $@convention(method) <T> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout GenericSubscriptWitness, @thick GenericSubscriptWitness.Type) -> () {
+// CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*GenericSubscriptWitness, %3 : $@thick GenericSubscriptWitness.Type):
+// CHECK: [[BUFFER:%.*]] = project_value_buffer $T in %1 : $*Builtin.UnsafeValueBuffer
+// CHECK-NEXT: [[INDICES:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*T
+// CHECK: [[SETTER:%.*]] = function_ref @$S17materializeForSet23GenericSubscriptWitnessVyxxcluis : $@convention(method) <τ_0_0> (@in τ_0_0, @in τ_0_0, @inout GenericSubscriptWitness) -> ()
+// CHECK-NEXT: apply [[SETTER]]<T>([[INDICES]], [[BUFFER]], %2) : $@convention(method) <τ_0_0> (@in τ_0_0, @in τ_0_0, @inout GenericSubscriptWitness) -> ()
+// CHECK-NEXT: dealloc_value_buffer $*T in %1 : $*Builtin.UnsafeValueBuffer
+// CHECK-NEXT: [[RESULT:%.*]] = tuple ()
+// CHECK-NEXT: return [[RESULT]] : $()
+
+// CHECK-LABEL: sil hidden [transparent] @$S17materializeForSet23GenericSubscriptWitnessVyxxcluim : $@convention(method) <T> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed T, @inout GenericSubscriptWitness) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $*T, %3 : $*GenericSubscriptWitness):
+// CHECK-NEXT: [[BUFFER:%.*]] = alloc_value_buffer $T in %1 : $*Builtin.UnsafeValueBuffer
+// CHECK-NEXT: copy_addr %2 to [initialization] [[BUFFER]] : $*T
+// CHECK-NEXT: [[VALUE:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*T
+// CHECK-NEXT: [[SELF:%.*]] = load [trivial] %3 : $*GenericSubscriptWitness
+// CHECK: [[GETTER:%.*]] = function_ref @$S17materializeForSet23GenericSubscriptWitnessVyxxcluig : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, GenericSubscriptWitness) -> @out τ_0_0
+// CHECK-NEXT: apply [[GETTER]]<T>([[VALUE]], %2, [[SELF]]) : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, GenericSubscriptWitness) -> @out τ_0_0
+// CHECK-NEXT: [[VALUE_PTR:%.*]] = address_to_pointer [[VALUE]] : $*T to $Builtin.RawPointer
+// CHECK: [[CALLBACK:%.*]] = function_ref @$S17materializeForSet23GenericSubscriptWitnessVyxxcluimytfU_
+// CHECK-NEXT: [[CALLBACK_PTR:%.*]] = thin_function_to_pointer [[CALLBACK]] : $@convention(method) <τ_0_0> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout GenericSubscriptWitness, @thick GenericSubscriptWitness.Type) -> () to $Builtin.RawPointer
+// CHECK-NEXT: [[CALLBACK_OPTIONAL:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[CALLBACK_PTR]] : $Builtin.RawPointer
+// CHECK-NEXT: [[RESULT:%.*]] = tuple ([[VALUE_PTR]] : $Builtin.RawPointer, [[CALLBACK_OPTIONAL]] : $Optional<Builtin.RawPointer>)
+// CHECK-NEXT: return [[RESULT]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+
+extension GenericSubscriptProtocol {
+ subscript<T>(t: T) -> T { get { } set { } }
+}
+
+struct GenericSubscriptDefaultWitness : GenericSubscriptProtocol { }
+
+// Make sure we correctly infer the 'T : Magic' requirement on all the accessors
+// of the subscript.
+
+struct GenericTypeWithRequirement<T : Magic> {}
+
+protocol InferredRequirementOnSubscriptProtocol {
+ subscript<T>(i: Int) -> GenericTypeWithRequirement<T> { get set }
+}
+
+struct InferredRequirementOnSubscript : InferredRequirementOnSubscriptProtocol {
+ subscript<T>(i: Int) -> GenericTypeWithRequirement<T> {
+ get { }
+ set { }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S17materializeForSet30InferredRequirementOnSubscriptVyAA015GenericTypeWithE0VyxGSicAA5MagicRzluig : $@convention(method) <T where T : Magic> (Int, InferredRequirementOnSubscript) -> GenericTypeWithRequirement<T>
+
+// CHECK-LABEL: sil hidden @$S17materializeForSet30InferredRequirementOnSubscriptVyAA015GenericTypeWithE0VyxGSicAA5MagicRzluis : $@convention(method) <T where T : Magic> (GenericTypeWithRequirement<T>, Int, @inout InferredRequirementOnSubscript) -> ()
+
+// CHECK-LABEL: sil hidden [transparent] @$S17materializeForSet30InferredRequirementOnSubscriptVyAA015GenericTypeWithE0VyxGSicAA5MagicRzluim : $@convention(method) <T where T : Magic> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, Int, @inout InferredRequirementOnSubscript) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+
+// Test for materializeForSet vs static properties of structs.
+
+protocol Beverage {
+ static var abv: Int { get set }
+}
+
+struct Beer : Beverage {
+ static var abv: Int {
+ get {
+ return 7
+ }
+ set { }
+ }
+}
+
+struct Wine<Color> : Beverage {
+ static var abv: Int {
+ get {
+ return 14
+ }
+ set { }
+ }
+}
+
+// Make sure we can perform an inout access of such a property too.
+
+func inoutAccessOfStaticProperty<T : Beverage>(_ t: T.Type) {
+ increment(&t.abv)
+}
+
+// Test for materializeForSet vs overridden computed property of classes.
+class BaseForOverride {
+ var valueStored: Int
+ var valueComputed: Int { get { } set { } }
+
+ init(valueStored: Int) {
+ self.valueStored = valueStored
+ }
+}
+
+class DerivedForOverride : BaseForOverride {
+ override var valueStored: Int { get { } set { } }
+ override var valueComputed: Int { get { } set { } }
+}
+
+// Test for materializeForSet vs static properties of classes.
+
+class ReferenceBeer {
+ class var abv: Int {
+ get {
+ return 7
+ }
+ set { }
+ }
+}
+
+func inoutAccessOfClassProperty() {
+ increment(&ReferenceBeer.abv)
+}
+
+// Test for materializeForSet when Self is re-abstracted.
+//
+// We have to open-code the materializeForSelf witness, and not screw up
+// the re-abstraction.
+
+protocol Panda {
+ var x: (Self) -> Self { get set }
+}
+
+func id<T>(_ t: T) -> T { return t }
+
+extension Panda {
+ var x: (Self) -> Self {
+ get { return id }
+ set { }
+ }
+}
+
+struct TuxedoPanda : Panda { }
+
+// CHECK-LABEL: sil private [transparent] @$S17materializeForSet11TuxedoPandaVAA0E0A2aDP1xyxxcvmytfU_TW : $@convention(witness_method: Panda) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout TuxedoPanda, @thick TuxedoPanda.Type) -> ()
+
+ // FIXME: Useless re-abstractions
+
+ // CHECK: function_ref @$S17materializeForSet11TuxedoPandaVACIegnr_A2CIegyd_TR : $@convention(thin) (TuxedoPanda, @guaranteed @callee_guaranteed (@in_guaranteed TuxedoPanda) -> @out TuxedoPanda) -> TuxedoPanda
+
+ // CHECK: function_ref @$S17materializeForSet11TuxedoPandaVACIegyd_A2CIegnr_TR : $@convention(thin) (@in_guaranteed TuxedoPanda, @guaranteed @callee_guaranteed (TuxedoPanda) -> TuxedoPanda) -> @out TuxedoPanda
+
+ // CHECK: function_ref @$S17materializeForSet5PandaPAAE1xyxxcvs : $@convention(method) <τ_0_0 where τ_0_0 : Panda> (@owned @callee_guaranteed (@in_guaranteed τ_0_0) -> @out τ_0_0, @inout τ_0_0) -> ()
+
+// CHECK: }
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S17materializeForSet11TuxedoPandaVAA0E0A2aDP1xyxxcvmTW
+
+// Call the getter:
+
+ // CHECK: function_ref @$S17materializeForSet5PandaPAAE1xyxxcvg : $@convention(method) <τ_0_0 where τ_0_0 : Panda> (@in_guaranteed τ_0_0) -> @owned @callee_guaranteed (@in_guaranteed τ_0_0) -> @out τ_0_0
+
+// Result of calling the getter is re-abstracted to the maximally substituted type
+// by SILGenFunction::emitApply():
+
+ // CHECK: function_ref @$S17materializeForSet11TuxedoPandaVACIegnr_A2CIegyd_TR : $@convention(thin) (TuxedoPanda, @guaranteed @callee_guaranteed (@in_guaranteed TuxedoPanda) -> @out TuxedoPanda) -> TuxedoPanda
+
+// ... then we re-abstract to the requirement signature:
+// FIXME: Peephole this away with the previous one since there's actually no
+// abstraction change in this case.
+
+ // CHECK: function_ref @$S17materializeForSet11TuxedoPandaVACIegyd_A2CIegnr_TR : $@convention(thin) (@in_guaranteed TuxedoPanda, @guaranteed @callee_guaranteed (TuxedoPanda) -> TuxedoPanda) -> @out TuxedoPanda
+
+// The callback:
+
+ // CHECK: function_ref @$S17materializeForSet11TuxedoPandaVAA0E0A2aDP1xyxxcvmytfU_TW : $@convention(witness_method: Panda) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout TuxedoPanda, @thick TuxedoPanda.Type) -> ()
+
+// CHECK: }
+
+
+// Test for materializeForSet vs lazy properties of structs.
+
+struct LazyStructProperty {
+ lazy var cat: Int = 5
+}
+
+// CHECK-LABEL: sil hidden @$S17materializeForSet31inoutAccessOfLazyStructProperty1lyAA0ghI0Vz_tF
+// CHECK: function_ref @$S17materializeForSet18LazyStructPropertyV3catSivg
+// CHECK: function_ref @$S17materializeForSet18LazyStructPropertyV3catSivs
+func inoutAccessOfLazyStructProperty(l: inout LazyStructProperty) {
+ increment(&l.cat)
+}
+
+// Test for materializeForSet vs lazy properties of classes.
+
+// CHECK-LABEL: sil hidden [transparent] @$S17materializeForSet17LazyClassPropertyC3catSivm
+
+class LazyClassProperty {
+ lazy var cat: Int = 5
+}
+
+// CHECK-LABEL: sil hidden @$S17materializeForSet30inoutAccessOfLazyClassProperty1lyAA0ghI0Cz_tF
+// CHECK: class_method {{.*}} : $LazyClassProperty, #LazyClassProperty.cat!materializeForSet.1
+func inoutAccessOfLazyClassProperty(l: inout LazyClassProperty) {
+ increment(&l.cat)
+}
+
+// Test for materializeForSet vs lazy properties of final classes.
+
+final class LazyFinalClassProperty {
+ lazy var cat: Int = 5
+}
+
+// CHECK-LABEL: sil hidden @$S17materializeForSet35inoutAccessOfLazyFinalClassProperty1lyAA0ghiJ0Cz_tF
+// CHECK: function_ref @$S17materializeForSet22LazyFinalClassPropertyC3catSivg
+// CHECK: function_ref @$S17materializeForSet22LazyFinalClassPropertyC3catSivs
+func inoutAccessOfLazyFinalClassProperty(l: inout LazyFinalClassProperty) {
+ increment(&l.cat)
+}
+
+// Make sure the below doesn't crash SILGen
+struct FooClosure {
+ var computed: (((Int) -> Int) -> Int)? {
+ get { return stored }
+ set {}
+ }
+ var stored: (((Int) -> Int) -> Int)? = nil
+}
+
+// CHECK-LABEL: $S17materializeForSet22testMaterializedSetteryyF
+func testMaterializedSetter() {
+ // CHECK: function_ref @$S17materializeForSet10FooClosureVACycfC
+ var f = FooClosure()
+ // CHECK: function_ref @$S17materializeForSet10FooClosureV8computedS3iXEcSgvg
+ // CHECK: function_ref @$S17materializeForSet10FooClosureV8computedS3iXEcSgvs
+ f.computed = f.computed
+}
+
+// CHECK-LABEL: sil_vtable DerivedForOverride {
+// CHECK: #BaseForOverride.valueStored!getter.1: (BaseForOverride) -> () -> Int : @$S17materializeForSet07DerivedB8OverrideC11valueStoredSivg
+// CHECK: #BaseForOverride.valueStored!setter.1: (BaseForOverride) -> (Int) -> () : @$S17materializeForSet07DerivedB8OverrideC11valueStoredSivs
+// CHECK: #BaseForOverride.valueStored!materializeForSet.1: (BaseForOverride) -> (Builtin.RawPointer, inout Builtin.UnsafeValueBuffer) -> (Builtin.RawPointer, Builtin.RawPointer?) : @$S17materializeForSet07DerivedB8OverrideC11valueStoredSivm
+// CHECK: #BaseForOverride.valueComputed!getter.1: (BaseForOverride) -> () -> Int : @$S17materializeForSet07DerivedB8OverrideC13valueComputedSivg
+// CHECK: #BaseForOverride.valueComputed!setter.1: (BaseForOverride) -> (Int) -> () : @$S17materializeForSet07DerivedB8OverrideC13valueComputedSivs
+// CHECK: #BaseForOverride.valueComputed!materializeForSet.1: (BaseForOverride) -> (Builtin.RawPointer, inout Builtin.UnsafeValueBuffer) -> (Builtin.RawPointer, Builtin.RawPointer?) : @$S17materializeForSet07DerivedB8OverrideC13valueComputedSivm
+// CHECK: }
+
+// CHECK-LABEL: sil_witness_table hidden Bill: Totalled module materializeForSet {
+// CHECK: method #Totalled.total!getter.1: {{.*}} : @$S17materializeForSet4BillVAA8TotalledA2aDP5totalSivgTW
+// CHECK: method #Totalled.total!setter.1: {{.*}} : @$S17materializeForSet4BillVAA8TotalledA2aDP5totalSivsTW
+// CHECK: method #Totalled.total!materializeForSet.1: {{.*}} : @$S17materializeForSet4BillVAA8TotalledA2aDP5totalSivmTW
+// CHECK: }
diff --git a/test/SILGen/plus_zero_metatype_abstraction.swift b/test/SILGen/plus_zero_metatype_abstraction.swift
new file mode 100644
index 0000000..8dfa81f
--- /dev/null
+++ b/test/SILGen/plus_zero_metatype_abstraction.swift
@@ -0,0 +1,142 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -module-name Swift -parse-stdlib %s | %FileCheck %s
+
+enum Optional<Wrapped> {
+ case none
+ case some(Wrapped)
+}
+
+struct S {}
+class C {}
+
+struct Generic<T> {
+ var value: T
+}
+
+struct GenericMetatype<T> {
+ var value: T.Type
+}
+
+// CHECK-LABEL: sil hidden @$Ss26genericMetatypeFromGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: [[ADDR:%.*]] = struct_element_addr {{%.*}} : $*Generic<T.Type>, #Generic.value
+// CHECK: [[META:%.*]] = load [trivial] [[ADDR]] : $*@thick T.Type
+// CHECK: return [[META]] : $@thick T.Type
+// CHECK: }
+func genericMetatypeFromGeneric<T>(_ x: Generic<T.Type>) -> T.Type {
+ var x = x
+ return x.value
+}
+// CHECK-LABEL: sil hidden @$Ss26dynamicMetatypeFromGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: [[ADDR:%.*]] = struct_element_addr {{%.*}} : $*Generic<C.Type>, #Generic.value
+// CHECK: [[META:%.*]] = load [trivial] [[ADDR]] : $*@thick C.Type
+// CHECK: return [[META]] : $@thick C.Type
+// CHECK: }
+func dynamicMetatypeFromGeneric(_ x: Generic<C.Type>) -> C.Type {
+ var x = x
+ return x.value
+}
+// CHECK-LABEL: sil hidden @$Ss25staticMetatypeFromGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: [[META:%.*]] = metatype $@thin S.Type
+// CHECK: return [[META]] : $@thin S.Type
+// CHECK: }
+func staticMetatypeFromGeneric(_ x: Generic<S.Type>) -> S.Type {
+ return x.value
+}
+
+// CHECK-LABEL: sil hidden @$Ss026genericMetatypeFromGenericB0{{[_0-9a-zA-Z]*}}F
+// CHECK: [[ADDR:%.*]] = struct_element_addr {{%.*}} : $*GenericMetatype<T>, #GenericMetatype.value
+// CHECK: [[META:%.*]] = load [trivial] [[ADDR]] : $*@thick T.Type
+// CHECK: return [[META]] : $@thick T.Type
+// CHECK: }
+func genericMetatypeFromGenericMetatype<T>(_ x: GenericMetatype<T>)-> T.Type {
+ var x = x
+ return x.value
+}
+// CHECK-LABEL: sil hidden @$Ss026dynamicMetatypeFromGenericB0ys1CCms0dB0VyACGF
+// CHECK: [[XBOX:%[0-9]+]] = alloc_box ${ var GenericMetatype<C> }
+// CHECK: [[PX:%[0-9]+]] = project_box [[XBOX]]
+// CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PX]] : $*GenericMetatype<C>
+// CHECK: [[ADDR:%.*]] = struct_element_addr [[READ]] : $*GenericMetatype<C>, #GenericMetatype.value
+// CHECK: [[META:%.*]] = load [trivial] [[ADDR]] : $*@thick C.Type
+// CHECK: return [[META]] : $@thick C.Type
+// CHECK: }
+func dynamicMetatypeFromGenericMetatype(_ x: GenericMetatype<C>) -> C.Type {
+ var x = x
+ return x.value
+}
+
+func takeGeneric<T>(_ x: T) {}
+func takeGenericMetatype<T>(_ x: T.Type) {}
+
+// CHECK-LABEL: sil hidden @$Ss23staticMetatypeToGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: [[MAT:%.*]] = alloc_stack $@thick S.Type
+// CHECK: [[META:%.*]] = metatype $@thick S.Type
+// CHECK: store [[META]] to [trivial] [[MAT]] : $*@thick S.Type
+// CHECK: apply {{%.*}}<S.Type>([[MAT]])
+func staticMetatypeToGeneric(_ x: S.Type) {
+ takeGeneric(x)
+}
+// CHECK-LABEL: sil hidden @$Ss023staticMetatypeToGenericB0{{[_0-9a-zA-Z]*}}F
+// CHECK: [[META:%.*]] = metatype $@thick S.Type
+// CHECK: apply {{%.*}}<S>([[META]])
+func staticMetatypeToGenericMetatype(_ x: S.Type) {
+ takeGenericMetatype(x)
+}
+// CHECK-LABEL: sil hidden @$Ss24dynamicMetatypeToGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: [[MAT:%.*]] = alloc_stack $@thick C.Type
+// CHECK: apply {{%.*}}<C.Type>([[MAT]]) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
+func dynamicMetatypeToGeneric(_ x: C.Type) {
+ var x = x
+ takeGeneric(x)
+}
+// CHECK-LABEL: sil hidden @$Ss024dynamicMetatypeToGenericB0yys1CCmF
+// CHECK: [[XBOX:%[0-9]+]] = alloc_box ${ var @thick C.Type }
+// CHECK: [[PX:%[0-9]+]] = project_box [[XBOX]]
+// CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PX]] : $*@thick C.Type
+// CHECK: [[META:%.*]] = load [trivial] [[READ]] : $*@thick C.Type
+// CHECK: apply {{%.*}}<C>([[META]]) : $@convention(thin) <τ_0_0> (@thick τ_0_0.Type) -> ()
+func dynamicMetatypeToGenericMetatype(_ x: C.Type) {
+ var x = x
+ takeGenericMetatype(x)
+}
+// CHECK-LABEL: sil hidden @$Ss24genericMetatypeToGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: [[MAT:%.*]] = alloc_stack $@thick U.Type
+// CHECK: apply {{%.*}}<U.Type>([[MAT]]) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
+func genericMetatypeToGeneric<U>(_ x: U.Type) {
+ var x = x
+ takeGeneric(x)
+}
+func genericMetatypeToGenericMetatype<U>(_ x: U.Type) {
+ takeGenericMetatype(x)
+}
+
+// CHECK-LABEL: sil hidden @$Ss019static_metatype_of_B0ys1SVmmACF
+// CHECK: metatype $@thin S.Type.Type
+func static_metatype_of_metatype(_ x: S) -> S.Type.Type {
+ return type(of: type(of: x))
+}
+
+// CHECK-LABEL: sil hidden @$Ss018class_metatype_of_B0ys1CCmmACF
+// CHECK: [[METATYPE:%.*]] = value_metatype $@thick C.Type
+// CHECK: [[META_METATYPE:%.*]] = value_metatype $@thick C.Type.Type, [[METATYPE]]
+func class_metatype_of_metatype(_ x: C) -> C.Type.Type {
+ return type(of: type(of: x))
+}
+
+// CHECK-LABEL: sil hidden @$Ss020generic_metatype_of_B0{{[_0-9a-zA-Z]*}}F
+// CHECK: [[METATYPE:%.*]] = value_metatype $@thick T.Type
+// CHECK: [[META_METATYPE:%.*]] = value_metatype $@thick T.Type.Type, [[METATYPE]]
+func generic_metatype_of_metatype<T>(_ x: T) -> T.Type.Type {
+ return type(of: type(of: x))
+}
+
+// FIXME rdar://problem/18419772
+/*
+func existential_metatype_of_metatype(_ x: Any) -> Any.Type.Type {
+ return type(of: type(of: x))
+}
+ */
+
+func function_metatype_of_metatype(_ x: @escaping () -> ()) -> (() -> ()).Type.Type {
+ return type(of: type(of: x))
+}
diff --git a/test/SILGen/plus_zero_multi_file.swift b/test/SILGen/plus_zero_multi_file.swift
new file mode 100644
index 0000000..aaccbcc
--- /dev/null
+++ b/test/SILGen/plus_zero_multi_file.swift
@@ -0,0 +1,53 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -primary-file %s %S/Inputs/multi_file_helper.swift | %FileCheck %s
+
+func markUsed<T>(_ t: T) {}
+
+// CHECK-LABEL: sil hidden @$S10multi_file12rdar16016713{{[_0-9a-zA-Z]*}}F
+func rdar16016713(_ r: Range) {
+ // CHECK: [[LIMIT:%[0-9]+]] = function_ref @$S10multi_file5RangeV5limitSivg : $@convention(method) (Range) -> Int
+ // CHECK: {{%[0-9]+}} = apply [[LIMIT]]({{%[0-9]+}}) : $@convention(method) (Range) -> Int
+ markUsed(r.limit)
+}
+
+// CHECK-LABEL: sil hidden @$S10multi_file26lazyPropertiesAreNotStored{{[_0-9a-zA-Z]*}}F
+func lazyPropertiesAreNotStored(_ container: LazyContainer) {
+ var container = container
+ // CHECK: {{%[0-9]+}} = function_ref @$S10multi_file13LazyContainerV7lazyVarSivg : $@convention(method) (@inout LazyContainer) -> Int
+ markUsed(container.lazyVar)
+}
+
+// CHECK-LABEL: sil hidden @$S10multi_file29lazyRefPropertiesAreNotStored{{[_0-9a-zA-Z]*}}F
+func lazyRefPropertiesAreNotStored(_ container: LazyContainerClass) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $LazyContainerClass):
+ // CHECK: {{%[0-9]+}} = class_method [[ARG]] : $LazyContainerClass, #LazyContainerClass.lazyVar!getter.1 : (LazyContainerClass) -> () -> Int, $@convention(method) (@guaranteed LazyContainerClass) -> Int
+ markUsed(container.lazyVar)
+}
+
+// CHECK-LABEL: sil hidden @$S10multi_file25finalVarsAreDevirtualizedyyAA18FinalPropertyClassCF
+func finalVarsAreDevirtualized(_ obj: FinalPropertyClass) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $FinalPropertyClass):
+ // CHECK: ref_element_addr [[ARG]] : $FinalPropertyClass, #FinalPropertyClass.foo
+ markUsed(obj.foo)
+ // CHECK: class_method [[ARG]] : $FinalPropertyClass, #FinalPropertyClass.bar!getter.1
+ markUsed(obj.bar)
+}
+
+// rdar://18448869
+// CHECK-LABEL: sil hidden @$S10multi_file34finalVarsDontNeedMaterializeForSetyyAA27ObservingPropertyFinalClassCF
+func finalVarsDontNeedMaterializeForSet(_ obj: ObservingPropertyFinalClass) {
+ obj.foo += 1
+ // CHECK: function_ref @$S10multi_file27ObservingPropertyFinalClassC3fooSivg
+ // CHECK: function_ref @$S10multi_file27ObservingPropertyFinalClassC3fooSivs
+}
+
+// rdar://18503960
+// Ensure that we type-check the materializeForSet accessor from the protocol.
+class HasComputedProperty: ProtocolWithProperty {
+ var foo: Int {
+ get { return 1 }
+ set {}
+ }
+}
+// CHECK-LABEL: sil hidden [transparent] @$S10multi_file19HasComputedPropertyC3fooSivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed HasComputedProperty) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK-LABEL: sil private [transparent] [thunk] @$S10multi_file19HasComputedPropertyCAA012ProtocolWithE0A2aDP3fooSivmTW : $@convention(witness_method: ProtocolWithProperty) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout HasComputedProperty) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
diff --git a/test/SILGen/plus_zero_nested_generics.swift b/test/SILGen/plus_zero_nested_generics.swift
new file mode 100644
index 0000000..32abb9f
--- /dev/null
+++ b/test/SILGen/plus_zero_nested_generics.swift
@@ -0,0 +1,261 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -Xllvm -sil-full-demangle -emit-silgen -parse-as-library %s | %FileCheck %s
+// RUN: %target-swift-frontend -enable-sil-ownership -Xllvm -sil-full-demangle -emit-sil -parse-as-library %s > /dev/null
+// RUN: %target-swift-frontend -enable-sil-ownership -Xllvm -sil-full-demangle -emit-sil -O -parse-as-library %s > /dev/null
+// RUN: %target-swift-frontend -enable-sil-ownership -Xllvm -sil-full-demangle -emit-ir -parse-as-library %s > /dev/null
+
+// TODO:
+// - test generated SIL -- mostly we're just testing mangling here
+// - class_method calls
+// - witness_method calls
+// - inner generic parameters on protocol requirements
+// - generic parameter list on method in nested type
+// - types nested inside unconstrained extensions of generic types
+
+protocol Pizza : class {
+ associatedtype Topping
+}
+
+protocol HotDog {
+ associatedtype Condiment
+}
+
+protocol CuredMeat {}
+
+// Generic nested inside generic
+
+struct Lunch<T : Pizza> where T.Topping : CuredMeat {
+ struct Dinner<U : HotDog> where U.Condiment == Deli<Pepper>.Mustard {
+ let firstCourse: T
+ let secondCourse: U?
+
+ var leftovers: T
+ var transformation: (T) -> U
+
+ func coolCombination(t: T.Topping, u: U.Condiment) {
+ func nestedGeneric<X, Y>(x: X, y: Y) -> (X, Y) {
+ return (x, y)
+ }
+ _ = nestedGeneric(x: t, y: u)
+ }
+ }
+}
+
+// CHECK-LABEL: // nested_generics.Lunch.Dinner.coolCombination(t: A.Topping, u: nested_generics.Deli<nested_generics.Pepper>.Mustard) -> ()
+// CHECK-LABEL: sil hidden @$S15nested_generics5LunchV6DinnerV15coolCombination1t1uy7ToppingQz_AA4DeliC7MustardOyAA6PepperV_GtF : $@convention(method) <T where T : Pizza, T.Topping : CuredMeat><U where U : HotDog, U.Condiment == Deli<Pepper>.Mustard> (@in_guaranteed T.Topping, Deli<Pepper>.Mustard, @in_guaranteed Lunch<T>.Dinner<U>) -> ()
+
+// CHECK-LABEL: // nestedGeneric #1 <A><A1><A2, B2 where A: nested_generics.Pizza, A1: nested_generics.HotDog, A.Topping: nested_generics.CuredMeat, A1.Condiment == nested_generics.Deli<nested_generics.Pepper>.Mustard>(x: A2, y: B2) -> (A2, B2) in nested_generics.Lunch.Dinner.coolCombination(t: A.Topping, u: nested_generics.Deli<nested_generics.Pepper>.Mustard) -> ()
+// CHECK-LABEL: sil private @$S15nested_generics5LunchV6DinnerV15coolCombination1t1uy7ToppingQz_AA4DeliC7MustardOyAA6PepperV_GtF0A7GenericL_1x1yqd0___qd0_0_tqd0___qd0_0_tAA5PizzaRzAA6HotDogRd__AA9CuredMeatAJRQAQ9CondimentRtd__r__0_lF : $@convention(thin) <T where T : Pizza, T.Topping : CuredMeat><U where U : HotDog, U.Condiment == Deli<Pepper>.Mustard><X, Y> (@in_guaranteed X, @in_guaranteed Y) -> (@out X, @out Y)
+
+// CHECK-LABEL: // nested_generics.Lunch.Dinner.init(firstCourse: A, secondCourse: Swift.Optional<A1>, leftovers: A, transformation: (A) -> A1) -> nested_generics.Lunch<A>.Dinner<A1>
+// CHECK-LABEL: sil hidden @$S15nested_generics5LunchV6DinnerV11firstCourse06secondF09leftovers14transformationAEyx_qd__Gx_qd__Sgxqd__xctcfC : $@convention(method) <T where T : Pizza, T.Topping : CuredMeat><U where U : HotDog, U.Condiment == Deli<Pepper>.Mustard> (@owned T, @in Optional<U>, @owned T, @owned @callee_guaranteed (@guaranteed T) -> @out U, @thin Lunch<T>.Dinner<U>.Type) -> @out Lunch<T>.Dinner<U>
+
+// Non-generic nested inside generic
+
+class Deli<Spices> : CuredMeat {
+
+ class Pepperoni : CuredMeat {}
+ struct Sausage : CuredMeat {}
+
+ enum Mustard {
+ case Yellow
+ case Dijon
+ case DeliStyle(Spices)
+ }
+}
+
+// CHECK-LABEL: // nested_generics.Deli.Pepperoni.init() -> nested_generics.Deli<A>.Pepperoni
+// CHECK-LABEL: sil hidden @$S15nested_generics4DeliC9PepperoniCAEyx_Gycfc : $@convention(method) <Spices> (@owned Deli<Spices>.Pepperoni) -> @owned Deli<Spices>.Pepperoni
+
+// Typealiases referencing outer generic parameters
+
+struct Pizzas<Spices> {
+ class NewYork : Pizza {
+ typealias Topping = Deli<Spices>.Pepperoni
+ }
+
+ class DeepDish : Pizza {
+ typealias Topping = Deli<Spices>.Sausage
+ }
+}
+
+class HotDogs {
+ struct Bratwurst : HotDog {
+ typealias Condiment = Deli<Pepper>.Mustard
+ }
+ struct American : HotDog {
+ typealias Condiment = Deli<Pepper>.Mustard
+ }
+}
+
+// Local type in extension of type in another module
+extension String {
+ func foo() {
+ // CHECK-LABEL: // init(material: A) -> Cheese #1 in (extension in nested_generics):Swift.String.foo() -> ()<A> in Cheese #1 in (extension in nested_generics):Swift.String.foo() -> ()
+ // CHECK-LABEL: sil private @$SSS15nested_genericsE3fooyyF6CheeseL_V8materialADyxGx_tcfC
+ struct Cheese<Milk> {
+ let material: Milk
+ }
+ let _ = Cheese(material: "cow")
+ }
+}
+
+// Local type in extension of type in same module
+extension HotDogs {
+ func applyRelish() {
+ // CHECK-LABEL: // init(material: A) -> Relish #1 in nested_generics.HotDogs.applyRelish() -> ()<A> in Relish #1 in nested_generics.HotDogs.applyRelish() -> ()
+ // CHECK-LABEL: sil private @$S15nested_generics7HotDogsC11applyRelishyyF0F0L_V8materialAFyxGx_tcfC
+
+ struct Relish<Material> {
+ let material: Material
+ }
+ let _ = Relish(material: "pickles")
+ }
+}
+
+struct Pepper {}
+struct ChiliFlakes {}
+
+// CHECK-LABEL: // nested_generics.eatDinnerGeneric<A, B where A: nested_generics.Pizza, B: nested_generics.HotDog, A.Topping: nested_generics.CuredMeat, B.Condiment == nested_generics.Deli<nested_generics.Pepper>.Mustard>(d: inout nested_generics.Lunch<A>.Dinner<B>, t: A.Topping, u: nested_generics.Deli<nested_generics.Pepper>.Mustard) -> ()
+// CHECK-LABEL: sil hidden @$S15nested_generics16eatDinnerGeneric1d1t1uyAA5LunchV0D0Vyx_q_Gz_7ToppingQzAA4DeliC7MustardOyAA6PepperV_GtAA5PizzaRzAA6HotDogR_AA9CuredMeatALRQAS9CondimentRt_r0_lF : $@convention(thin) <T, U where T : Pizza, U : HotDog, T.Topping : CuredMeat, U.Condiment == Deli<Pepper>.Mustard> (@inout Lunch<T>.Dinner<U>, @in_guaranteed T.Topping, Deli<Pepper>.Mustard) -> ()
+
+func eatDinnerGeneric<T, U>(d: inout Lunch<T>.Dinner<U>, t: T.Topping, u: U.Condiment) {
+ // Method call
+ _ = d.coolCombination(t: t, u: u)
+
+ // Read a let, store into var
+ d.leftovers = d.firstCourse
+
+ // Read a var
+ let _ = d.secondCourse
+
+ // Call property of function type
+ _ = d.transformation(d.leftovers)
+}
+
+// Overloading concrete function with different bound generic arguments in parent type
+
+// CHECK-LABEL: // nested_generics.eatDinnerConcrete(d: inout nested_generics.Lunch<nested_generics.Pizzas<nested_generics.ChiliFlakes>.NewYork>.Dinner<nested_generics.HotDogs.American>, t: nested_generics.Deli<nested_generics.ChiliFlakes>.Pepperoni, u: nested_generics.Deli<nested_generics.Pepper>.Mustard) -> ()
+// CHECK-LABEL: sil hidden @$S15nested_generics17eatDinnerConcrete1d1t1uyAA5LunchV0D0VyAA6PizzasV7NewYorkCyAA11ChiliFlakesV_G_AA7HotDogsC8AmericanVGz_AA4DeliC9PepperoniCyAO_GAW7MustardOyAA6PepperV_GtF : $@convention(thin) (@inout Lunch<Pizzas<ChiliFlakes>.NewYork>.Dinner<HotDogs.American>, @guaranteed Deli<ChiliFlakes>.Pepperoni, Deli<Pepper>.Mustard) -> ()
+
+func eatDinnerConcrete(d: inout Lunch<Pizzas<ChiliFlakes>.NewYork>.Dinner<HotDogs.American>,
+ t: Deli<ChiliFlakes>.Pepperoni,
+ u: Deli<Pepper>.Mustard) {
+ // Method call
+ _ = d.coolCombination(t: t, u: u)
+
+ // Read a let, store into var
+ d.leftovers = d.firstCourse
+
+ // Read a var
+ let _ = d.secondCourse
+
+ // Call property of function type
+ _ = d.transformation(d.leftovers)
+}
+
+// CHECK-LABEL: // reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed nested_generics.Pizzas<nested_generics.ChiliFlakes>.NewYork) -> (@out nested_generics.HotDogs.American) to @escaping @callee_guaranteed (@guaranteed nested_generics.Pizzas<nested_generics.ChiliFlakes>.NewYork) -> (@unowned nested_generics.HotDogs.American)
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S15nested_generics6PizzasV7NewYorkCyAA11ChiliFlakesV_GAA7HotDogsC8AmericanVIeggr_AhLIeggd_TR : $@convention(thin) (@guaranteed Pizzas<ChiliFlakes>.NewYork, @guaranteed @callee_guaranteed (@guaranteed Pizzas<ChiliFlakes>.NewYork) -> @out HotDogs.American) -> HotDogs.American
+
+// CHECK-LABEL: // nested_generics.eatDinnerConcrete(d: inout nested_generics.Lunch<nested_generics.Pizzas<nested_generics.Pepper>.NewYork>.Dinner<nested_generics.HotDogs.American>, t: nested_generics.Deli<nested_generics.Pepper>.Pepperoni, u: nested_generics.Deli<nested_generics.Pepper>.Mustard) -> ()
+// CHECK-LABEL: sil hidden @$S15nested_generics17eatDinnerConcrete1d1t1uyAA5LunchV0D0VyAA6PizzasV7NewYorkCyAA6PepperV_G_AA7HotDogsC8AmericanVGz_AA4DeliC9PepperoniCyAO_GAW7MustardOyAO_GtF : $@convention(thin) (@inout Lunch<Pizzas<Pepper>.NewYork>.Dinner<HotDogs.American>, @guaranteed Deli<Pepper>.Pepperoni, Deli<Pepper>.Mustard) -> ()
+
+func eatDinnerConcrete(d: inout Lunch<Pizzas<Pepper>.NewYork>.Dinner<HotDogs.American>,
+ t: Deli<Pepper>.Pepperoni,
+ u: Deli<Pepper>.Mustard) {
+ // Method call
+ _ = d.coolCombination(t: t, u: u)
+
+ // Read a let, store into var
+ d.leftovers = d.firstCourse
+
+ // Read a var
+ let _ = d.secondCourse
+
+ // Call property of function type
+ _ = d.transformation(d.leftovers)
+}
+
+// CHECK-LABEL: // reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed nested_generics.Pizzas<nested_generics.Pepper>.NewYork) -> (@out nested_generics.HotDogs.American) to @escaping @callee_guaranteed (@guaranteed nested_generics.Pizzas<nested_generics.Pepper>.NewYork) -> (@unowned nested_generics.HotDogs.American)
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S15nested_generics6PizzasV7NewYorkCyAA6PepperV_GAA7HotDogsC8AmericanVIeggr_AhLIeggd_TR : $@convention(thin) (@guaranteed Pizzas<Pepper>.NewYork, @guaranteed @callee_guaranteed (@guaranteed Pizzas<Pepper>.NewYork) -> @out HotDogs.American) -> HotDogs.American
+
+// CHECK-LABEL: // closure #1 (nested_generics.Pizzas<nested_generics.Pepper>.NewYork) -> nested_generics.HotDogs.American in nested_generics.calls() -> ()
+// CHECK-LABEL: sil private @$S15nested_generics5callsyyFAA7HotDogsC8AmericanVAA6PizzasV7NewYorkCyAA6PepperV_GcfU_ : $@convention(thin) (@guaranteed Pizzas<Pepper>.NewYork) -> HotDogs.American
+
+func calls() {
+
+ let firstCourse = Pizzas<Pepper>.NewYork()
+ let secondCourse = HotDogs.American()
+
+ var dinner = Lunch<Pizzas<Pepper>.NewYork>.Dinner<HotDogs.American>(
+ firstCourse: firstCourse,
+ secondCourse: secondCourse,
+ leftovers: firstCourse,
+ transformation: { _ in HotDogs.American() })
+
+ let topping = Deli<Pepper>.Pepperoni()
+
+ let condiment1 = Deli<Pepper>.Mustard.Dijon
+ let condiment2 = Deli<Pepper>.Mustard.DeliStyle(Pepper())
+
+ eatDinnerGeneric(d: &dinner, t: topping, u: condiment1)
+ eatDinnerConcrete(d: &dinner, t: topping, u: condiment2)
+
+}
+
+protocol ProtocolWithGenericRequirement {
+ associatedtype T
+ associatedtype U
+ func method<V>(t: T, u: U, v: V) -> (T, U, V)
+}
+
+class OuterRing<T> {
+ class InnerRing<U> : ProtocolWithGenericRequirement {
+ func method<V>(t: T, u: U, v: V) -> (T, U, V) {
+ return (t, u, v)
+ }
+ }
+}
+
+class SubclassOfInner<T, U> : OuterRing<T>.InnerRing<U> {
+ override func method<V>(t: T, u: U, v: V) -> (T, U, V) {
+ return super.method(t: t, u: u, v: v)
+ }
+}
+
+// CHECK-LABEL: // reabstraction thunk helper from @escaping @callee_guaranteed (@guaranteed nested_generics.Pizzas<nested_generics.Pepper>.NewYork) -> (@unowned nested_generics.HotDogs.American) to @escaping @callee_guaranteed (@guaranteed nested_generics.Pizzas<nested_generics.Pepper>.NewYork) -> (@out nested_generics.HotDogs.American)
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S15nested_generics6PizzasV7NewYorkCyAA6PepperV_GAA7HotDogsC8AmericanVIeggd_AhLIeggr_TR : $@convention(thin) (@guaranteed Pizzas<Pepper>.NewYork, @guaranteed @callee_guaranteed (@guaranteed Pizzas<Pepper>.NewYork) -> HotDogs.American) -> @out HotDogs.American
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15nested_generics9OuterRingC05InnerD0Cyx_qd__GAA30ProtocolWithGenericRequirementA2aGP6method1t1u1v1TQz_1UQzqd__tAN_APqd__tlFTW : $@convention(witness_method: ProtocolWithGenericRequirement) <τ_0_0><τ_1_0><τ_2_0> (@in_guaranteed τ_0_0, @in_guaranteed τ_1_0, @in_guaranteed τ_2_0, @in_guaranteed OuterRing<τ_0_0>.InnerRing<τ_1_0>) -> (@out τ_0_0, @out τ_1_0, @out τ_2_0) {
+// CHECK: bb0([[T:%[0-9]+]] : @trivial $*τ_0_0, [[U:%[0-9]+]] : @trivial $*τ_1_0, [[V:%[0-9]+]] : @trivial $*τ_2_0, [[TOut:%[0-9]+]] : @trivial $*τ_0_0, [[UOut:%[0-9]+]] : @trivial $*τ_1_0, [[VOut:%[0-9]+]] : @trivial $*τ_2_0, [[SELF:%[0-9]+]] : @trivial $*OuterRing<τ_0_0>.InnerRing<τ_1_0>):
+// CHECK: [[SELF_COPY_VAL:%[0-9]+]] = load_borrow [[SELF]] : $*OuterRing<τ_0_0>.InnerRing<τ_1_0>
+// CHECK: [[METHOD:%[0-9]+]] = class_method [[SELF_COPY_VAL]] : $OuterRing<τ_0_0>.InnerRing<τ_1_0>, #OuterRing.InnerRing.method!1 : <T><U><V> (OuterRing<T>.InnerRing<U>) -> (T, U, V) -> (T, U, V), $@convention(method) <τ_0_0><τ_1_0><τ_2_0> (@in_guaranteed τ_0_0, @in_guaranteed τ_1_0, @in_guaranteed τ_2_0, @guaranteed OuterRing<τ_0_0>.InnerRing<τ_1_0>) -> (@out τ_0_0, @out τ_1_0, @out τ_2_0)
+// CHECK: apply [[METHOD]]<τ_0_0, τ_1_0, τ_2_0>([[T]], [[U]], [[V]], [[TOut]], [[UOut]], [[VOut]], [[SELF_COPY_VAL]]) : $@convention(method) <τ_0_0><τ_1_0><τ_2_0> (@in_guaranteed τ_0_0, @in_guaranteed τ_1_0, @in_guaranteed τ_2_0, @guaranteed OuterRing<τ_0_0>.InnerRing<τ_1_0>) -> (@out τ_0_0, @out τ_1_0, @out τ_2_0)
+// CHECK: [[RESULT:%[0-9]+]] = tuple ()
+// CHECK: end_borrow [[SELF_COPY_VAL]] from [[SELF]]
+// CHECK: return [[RESULT]] : $()
+
+// CHECK: sil_witness_table hidden <Spices> Deli<Spices>.Pepperoni: CuredMeat module nested_generics {
+// CHECK: }
+
+// CHECK: sil_witness_table hidden <Spices> Deli<Spices>.Sausage: CuredMeat module nested_generics {
+// CHECK: }
+
+// CHECK: sil_witness_table hidden <Spices> Deli<Spices>: CuredMeat module nested_generics {
+// CHECK: }
+
+// CHECK: sil_witness_table hidden <Spices> Pizzas<Spices>.NewYork: Pizza module nested_generics {
+// CHECK: associated_type Topping: Deli<Spices>.Pepperoni
+// CHECK: }
+
+// CHECK: sil_witness_table hidden <Spices> Pizzas<Spices>.DeepDish: Pizza module nested_generics {
+// CHECK: associated_type Topping: Deli<Spices>.Sausage
+// CHECK: }
+
+// CHECK: sil_witness_table hidden HotDogs.Bratwurst: HotDog module nested_generics {
+// CHECK: associated_type Condiment: Deli<Pepper>.Mustard
+// CHECK: }
+
+// CHECK: sil_witness_table hidden HotDogs.American: HotDog module nested_generics {
+// CHECK: associated_type Condiment: Deli<Pepper>.Mustard
+// CHECK: }
diff --git a/test/SILGen/plus_zero_nested_types_referencing_nested_functions.swift b/test/SILGen/plus_zero_nested_types_referencing_nested_functions.swift
new file mode 100644
index 0000000..a0aa92e
--- /dev/null
+++ b/test/SILGen/plus_zero_nested_types_referencing_nested_functions.swift
@@ -0,0 +1,34 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+do {
+ func foo() { bar(2) }
+ func bar<T>(_: T) { foo() }
+
+ class Foo {
+ // CHECK-LABEL: sil private @$S025nested_types_referencing_A10_functions3FooL_CACycfc : $@convention(method) (@owned Foo) -> @owned Foo {
+ init() {
+ foo()
+ }
+ // CHECK-LABEL: sil private @$S025nested_types_referencing_A10_functions3FooL_C3zimyyF : $@convention(method) (@guaranteed Foo) -> ()
+ func zim() {
+ foo()
+ }
+ // CHECK-LABEL: sil private @$S025nested_types_referencing_A10_functions3FooL_C4zangyyxlF : $@convention(method) <T> (@in_guaranteed T, @guaranteed Foo) -> ()
+ func zang<T>(_ x: T) {
+ bar(x)
+ }
+ // CHECK-LABEL: sil private @$S025nested_types_referencing_A10_functions3FooL_CfD : $@convention(method) (@owned Foo) -> ()
+ deinit {
+ foo()
+ }
+ }
+
+ let x = Foo()
+ x.zim()
+ x.zang(1)
+ _ = Foo.zim
+ _ = Foo.zang as (Foo) -> (Int) -> ()
+ _ = x.zim
+ _ = x.zang as (Int) -> ()
+}
diff --git a/test/SILGen/plus_zero_newtype.swift b/test/SILGen/plus_zero_newtype.swift
new file mode 100644
index 0000000..778e1bb
--- /dev/null
+++ b/test/SILGen/plus_zero_newtype.swift
@@ -0,0 +1,86 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -sdk %S/Inputs -I %S/Inputs -enable-source-import %s | %FileCheck %s -check-prefix=CHECK-RAW
+
+// RUN: %target-swift-frontend -emit-sil -sdk %S/Inputs -I %S/Inputs -enable-source-import %s | %FileCheck %s -check-prefix=CHECK-CANONICAL
+
+// REQUIRES: objc_interop
+
+import Newtype
+
+// CHECK-CANONICAL-LABEL: sil hidden @$S7newtype17createErrorDomain{{[_0-9a-zA-Z]*}}F
+// CHECK-CANONICAL: bb0([[STR:%[0-9]+]] : $String)
+func createErrorDomain(str: String) -> ErrorDomain {
+ // CHECK-CANONICAL: [[BRIDGE_FN:%[0-9]+]] = function_ref @{{.*}}_bridgeToObjectiveC
+ // CHECK-CANONICAL-NEXT: [[BRIDGED:%[0-9]+]] = apply [[BRIDGE_FN]]([[STR]])
+ // CHECK-CANONICAL: struct $ErrorDomain ([[BRIDGED]] : $NSString)
+ return ErrorDomain(rawValue: str)
+}
+
+// CHECK-RAW-LABEL: sil shared [transparent] [serializable] @$SSo14SNTErrorDomaina8rawValueABSS_tcfC
+// CHECK-RAW: bb0([[STR:%[0-9]+]] : $String,
+// CHECK-RAW: [[SELF_BOX:%[0-9]+]] = alloc_box ${ var ErrorDomain }, var, name "self"
+// CHECK-RAW: [[MARKED_SELF_BOX:%[0-9]+]] = mark_uninitialized [rootself] [[SELF_BOX]]
+// CHECK-RAW: [[PB_BOX:%[0-9]+]] = project_box [[MARKED_SELF_BOX]]
+// CHECK-RAW: [[BORROWED_STR:%.*]] = begin_borrow [[STR]]
+// CHECK-RAW: [[COPIED_STR:%.*]] = copy_value [[BORROWED_STR]]
+// CHECK-RAW: [[BRIDGE_FN:%[0-9]+]] = function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK-RAW: [[BORROWED_COPIED_STR:%.*]] = begin_borrow [[COPIED_STR]]
+// CHECK-RAW: [[BRIDGED:%[0-9]+]] = apply [[BRIDGE_FN]]([[BORROWED_COPIED_STR]])
+// CHECK-RAW: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB_BOX]]
+// CHECK-RAW: [[RAWVALUE_ADDR:%[0-9]+]] = struct_element_addr [[WRITE]]
+// CHECK-RAW: assign [[BRIDGED]] to [[RAWVALUE_ADDR]]
+// CHECK-RAW: end_borrow [[BORROWED_COPIED_STR]] from [[COPIED_STR]]
+// CHECK-RAW: end_borrow [[BORROWED_STR]] from [[STR]]
+
+func getRawValue(ed: ErrorDomain) -> String {
+ return ed.rawValue
+}
+
+// CHECK-RAW-LABEL: sil shared [serializable] @$SSo14SNTErrorDomaina8rawValueSSvg
+// CHECK-RAW: bb0([[SELF:%[0-9]+]] : $ErrorDomain):
+// CHECK-RAW: [[STORED_VALUE:%[0-9]+]] = struct_extract [[SELF]] : $ErrorDomain, #ErrorDomain._rawValue
+// CHECK-RAW: [[STORED_VALUE_COPY:%.*]] = copy_value [[STORED_VALUE]]
+// CHECK-RAW: [[BRIDGE_FN:%[0-9]+]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+// CHECK-RAW: [[OPT_STORED_VALUE_COPY:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[STORED_VALUE_COPY]]
+// CHECK-RAW: [[STRING_META:%[0-9]+]] = metatype $@thin String.Type
+// CHECK-RAW: [[STRING_RESULT:%[0-9]+]] = apply [[BRIDGE_FN]]([[OPT_STORED_VALUE_COPY]], [[STRING_META]])
+// CHECK-RAW: return [[STRING_RESULT]]
+
+class ObjCTest {
+ // CHECK-RAW-LABEL: sil hidden @$S7newtype8ObjCTestC19optionalPassThroughySo14SNTErrorDomainaSgAGF : $@convention(method) (@guaranteed Optional<ErrorDomain>, @guaranteed ObjCTest) -> @owned Optional<ErrorDomain> {
+ // CHECK-RAW: sil hidden [thunk] @$S7newtype8ObjCTestC19optionalPassThroughySo14SNTErrorDomainaSgAGFTo : $@convention(objc_method) (Optional<ErrorDomain>, ObjCTest) -> Optional<ErrorDomain> {
+ @objc func optionalPassThrough(_ ed: ErrorDomain?) -> ErrorDomain? {
+ return ed
+ }
+
+ // CHECK-RAW-LABEL: sil hidden @$S7newtype8ObjCTestC18integerPassThroughySo5MyIntaAFF : $@convention(method) (MyInt, @guaranteed ObjCTest) -> MyInt {
+ // CHECK-RAW: sil hidden [thunk] @$S7newtype8ObjCTestC18integerPassThroughySo5MyIntaAFFTo : $@convention(objc_method) (MyInt, ObjCTest) -> MyInt {
+ @objc func integerPassThrough(_ ed: MyInt) -> MyInt {
+ return ed
+ }
+}
+
+// These use a bridging conversion with a specialization of a generic witness.
+// CHECK-RAW-LABEL: sil hidden @$S7newtype15bridgeToNewtypeSo8MyStringayF
+func bridgeToNewtype() -> MyString {
+// CHECK-RAW: [[STRING:%.*]] = apply
+// CHECK-RAW: [[TO_NS:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+// CHECK-RAW: [[BORROW:%.*]] = begin_borrow [[STRING]]
+// CHECK-RAW: [[NS:%.*]] = apply [[TO_NS]]([[BORROW]])
+// CHECK-RAW: [[TO_MY:%.*]] = function_ref @$Ss20_SwiftNewtypeWrapperPss21_ObjectiveCBridgeable8RawValueRpzrlE026_unconditionallyBridgeFromD1CyxAD_01_D5CTypeQZSgFZ : $@convention(method) <τ_0_0 where τ_0_0 : _SwiftNewtypeWrapper, τ_0_0.RawValue : _ObjectiveCBridgeable> (@guaranteed Optional<τ_0_0.RawValue._ObjectiveCType>, @thick τ_0_0.Type)
+// CHECK-RAW: [[OPTNS:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[NS]]
+// CHECK-RAW: [[META:%.*]] = metatype $@thick MyString.Type
+// CHECK-RAW: apply [[TO_MY]]<MyString, String>({{.*}}, [[OPTNS]], [[META]])
+ return "foo" as NSString as MyString
+}
+
+// CHECK-RAW-LABEL: sil hidden @$S7newtype17bridgeFromNewtype6stringSSSo8MyStringa_tF
+func bridgeFromNewtype(string: MyString) -> String {
+// CHECK-RAW: [[FROM_MY:%.*]] = function_ref @$Ss20_SwiftNewtypeWrapperPss21_ObjectiveCBridgeable8RawValueRpzrlE09_bridgeToD1CAD_01_D5CTypeQZyF : $@convention(method) <τ_0_0 where τ_0_0 : _SwiftNewtypeWrapper, τ_0_0.RawValue : _ObjectiveCBridgeable> (@in_guaranteed τ_0_0) -> @owned τ_0_0.RawValue._ObjectiveCType
+// CHECK-RAW: [[NS:%.*]] = apply [[FROM_MY]]<MyString, String>(
+// CHECK-RAW: [[FROM_NS:%.*]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+// CHECK-RAW: [[OPTNS:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[NS]]
+// CHECK-RAW: [[META:%.*]] = metatype $@thin String.Type
+// CHECK-RAW: apply [[FROM_NS]]([[OPTNS]], [[META]])
+ return string as NSString as String
+}
diff --git a/test/SILGen/plus_zero_noescape_reabstraction.swift b/test/SILGen/plus_zero_noescape_reabstraction.swift
new file mode 100644
index 0000000..36d8a93
--- /dev/null
+++ b/test/SILGen/plus_zero_noescape_reabstraction.swift
@@ -0,0 +1,24 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+struct S {}
+
+func noescape_concrete(_ x: (S) -> S) {
+ noescape_generic(x)
+}
+
+func noescape_generic<T>(_ x: (T) -> T) {
+}
+
+// CHECK-LABEL: sil hidden @$S22noescape_reabstraction0A9_concreteyyAA1SVADXEF
+// CHECK: function_ref [[REABSTRACTION_THUNK:@\$S22noescape_reabstraction1SVACIgyd_A2CIegnr_TR]]
+
+func concrete(_ x: (S) -> S) {
+ noescape_generic(x)
+}
+
+func generic<T>(_ x: (T) -> T) {
+}
+
+// CHECK-LABEL: sil hidden @$S22noescape_reabstraction8concreteyyAA1SVADXEF
+// CHECK: function_ref [[REABSTRACTION_THUNK]]
diff --git a/test/SILGen/plus_zero_objc_attr_NSManaged.swift b/test/SILGen/plus_zero_objc_attr_NSManaged.swift
new file mode 100644
index 0000000..64754aa
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_attr_NSManaged.swift
@@ -0,0 +1,137 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -sdk %S/Inputs %s -I %S/Inputs -enable-source-import -emit-silgen -enable-sil-ownership | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+// This file is also used by objc_attr_NSManaged_multi.swift.
+
+import Foundation
+import gizmo
+
+@objc class X : NSObject {
+ func foo() -> X { return self }
+}
+
+class SwiftGizmo : Gizmo {
+ @NSManaged var x: X
+
+ @NSManaged func kvc()
+
+ // CHECK-NOT: sil hidden @$S19objc_attr_NSManaged10SwiftGizmoC1x{{[_0-9a-zA-Z]*}}fgTo
+ // CHECK-NOT: sil hidden @$S19objc_attr_NSManaged10SwiftGizmoC1x{{[_0-9a-zA-Z]*}}fsTo
+ // CHECK-NOT: sil hidden @$S19objc_attr_NSManaged10SwiftGizmoC3kvc{{[_0-9a-zA-Z]*}}FTo
+
+ // Make sure that we're calling through the @objc entry points.
+ // CHECK-LABEL: sil hidden @$S19objc_attr_NSManaged10SwiftGizmoC7modifyX{{[_0-9a-zA-Z]*}}F : $@convention(method) (@guaranteed SwiftGizmo) -> () {
+ func modifyX() {
+ // CHECK: [[GETTER:%[0-9]+]] = objc_method [[SELF:%.*]] : $SwiftGizmo, #SwiftGizmo.x!getter.1.foreign : (SwiftGizmo) -> () -> X, $@convention(objc_method) (SwiftGizmo) -> @autoreleased X
+ // CHECK-NEXT: apply [[GETTER]]([[SELF]]) : $@convention(objc_method) (SwiftGizmo) -> @autoreleased X
+ // CHECK-NOT: return
+ // CHECK: [[SETTER:%[0-9]+]] = objc_method [[SELF]] : $SwiftGizmo, #SwiftGizmo.x!setter.1.foreign : (SwiftGizmo) -> (X) -> (), $@convention(objc_method) (X, SwiftGizmo) -> ()
+ // CHECK: apply [[SETTER]]([[XMOD:%.*]], [[SELF]]) : $@convention(objc_method) (X, SwiftGizmo) -> ()
+ x = x.foo()
+ // CHECK: return
+ }
+
+ // CHECK-LABEL: sil hidden @$S19objc_attr_NSManaged10SwiftGizmoC8testFunc{{[_0-9a-zA-Z]*}}F
+ func testFunc() {
+ // CHECK: = objc_method %0 : $SwiftGizmo, #SwiftGizmo.kvc!1.foreign : (SwiftGizmo) -> () -> (), $@convention(objc_method) (SwiftGizmo) -> ()
+ // CHECK: return
+ kvc()
+ }
+}
+
+extension SwiftGizmo {
+ @NSManaged func extKVC()
+
+ // CHECK-LABEL: $S19objc_attr_NSManaged10SwiftGizmoC7testExt{{[_0-9a-zA-Z]*}}F
+ func testExt() {
+ // CHECK: = objc_method %0 : $SwiftGizmo, #SwiftGizmo.extKVC!1.foreign : (SwiftGizmo) -> () -> (), $@convention(objc_method) (SwiftGizmo) -> ()
+ // CHECK: return
+ extKVC()
+ }
+}
+
+final class FinalGizmo : SwiftGizmo {
+ @NSManaged var y: String
+
+ @NSManaged func kvc2()
+}
+
+extension FinalGizmo {
+ @NSManaged func extKVC2()
+
+ // CHECK-LABEL: $S19objc_attr_NSManaged10FinalGizmoC8testExt2{{[_0-9a-zA-Z]*}}F
+ func testExt2() {
+ // CHECK: = objc_method %0 : $FinalGizmo, #FinalGizmo.extKVC2!1.foreign : (FinalGizmo) -> () -> (), $@convention(objc_method) (FinalGizmo) -> ()
+ // CHECK: return
+ extKVC2()
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S19objc_attr_NSManaged9testFinalySSAA0E5GizmoCF : $@convention(thin) (@guaranteed FinalGizmo) -> @owned String {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $FinalGizmo):
+// CHECK: objc_method [[ARG]] : $FinalGizmo, #FinalGizmo.kvc2!1.foreign : (FinalGizmo) -> () -> (), $@convention(objc_method) (FinalGizmo) -> ()
+// CHECK-NOT: return
+// CHECK: objc_method [[ARG]] : $FinalGizmo, #FinalGizmo.y!getter.1.foreign : (FinalGizmo) -> () -> String, $@convention(objc_method) (FinalGizmo) -> @autoreleased NSString
+// CHECK: return
+func testFinal(_ obj: FinalGizmo) -> String {
+ obj.kvc2()
+ return obj.y
+}
+
+// SR-2673: @NSManaged property can't satisfy protocol requirement
+@objc protocol ObjCProto {
+ var managedProp: String { get set }
+ var managedExtProp: AnyObject { get }
+}
+
+class ProtoAdopter: Gizmo, ObjCProto {
+ @NSManaged var managedProp: String
+}
+extension ProtoAdopter {
+ @NSManaged var managedExtProp: AnyObject
+}
+
+
+// SR-6534: @NSManaged properties can be 'final'
+protocol EntityIDProto {
+ var entityID: String { get set }
+}
+
+class FinalEntity: NSObject, EntityIDProto {
+ @NSManaged final var entityID: String
+}
+
+// CHECK-LABEL: sil private @$S19objc_attr_NSManaged11FinalEntityC8entityIDSSvmytfU_ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout FinalEntity, @thick FinalEntity.Type) -> ()
+// CHECK: objc_method {{.*}} : $FinalEntity, #FinalEntity.entityID!setter.1.foreign
+// CHECK: return
+
+// CHECK-LABEL: sil hidden @$S19objc_attr_NSManaged11FinalEntityC8entityIDSSvm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed FinalEntity) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+// CHECK: objc_method {{.*}} : $FinalEntity, #FinalEntity.entityID!getter.1.foreign
+// CHECK: return
+
+// CHECK-NOT: sil hidden @$S19objc_attr_NSManaged10SwiftGizmoC1xAA1XCfgTo : $@convention(objc_method) (SwiftGizmo) -> @autoreleased X
+// CHECK-NOT: sil hidden @$S19objc_attr_NSManaged10SwiftGizmoC1xAA1XCfsTo
+// CHECK-NOT: sil hidden @$S19objc_attr_NSManaged10{{[_0-9a-zA-Z]*}}FinalGizmoC1yytfgTo
+
+// The vtable should not contain any entry points for getters and setters.
+// CHECK-LABEL: sil_vtable SwiftGizmo {
+// CHECK-NEXT: #SwiftGizmo.modifyX!1: {{.*}} : @$S19objc_attr_NSManaged10SwiftGizmoC7modifyXyyF
+// CHECK-NEXT: #SwiftGizmo.testFunc!1: {{.*}} : @$S19objc_attr_NSManaged10SwiftGizmoC8testFuncyyF
+// CHECK-NEXT: #SwiftGizmo.init!initializer.1: {{.*}} : @$S19objc_attr_NSManaged10SwiftGizmoCACSgycfc
+// CHECK-NEXT: #SwiftGizmo.init!initializer.1: {{.*}} : @$S19objc_attr_NSManaged10SwiftGizmoC7bellsOnACSgSi_tcfc
+// CHECK-NEXT: #SwiftGizmo.deinit!deallocator: @$S19objc_attr_NSManaged10SwiftGizmoCfD
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil_vtable FinalGizmo {
+// CHECK-NEXT: #SwiftGizmo.modifyX!1: {{.*}} : @$S19objc_attr_NSManaged10SwiftGizmoC7modifyX{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: #SwiftGizmo.testFunc!1: {{.*}} : @$S19objc_attr_NSManaged10SwiftGizmoC8testFunc{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: #SwiftGizmo.init!initializer.1: {{.*}} : @$S19objc_attr_NSManaged10FinalGizmoC{{[_0-9a-zA-Z]*}}fc
+// CHECK-NEXT: #SwiftGizmo.init!initializer.1: {{.*}} : @$S19objc_attr_NSManaged10FinalGizmoC{{[_0-9a-zA-Z]*}}fc
+// CHECK-NEXT: #FinalGizmo.deinit!deallocator: @$S19objc_attr_NSManaged10FinalGizmoCfD
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil_vtable ProtoAdopter {
+// CHECK-NOT: managed{{.*}}Prop
+// CHECK: {{^}$}}
diff --git a/test/SILGen/plus_zero_objc_attr_NSManaged_multi.swift b/test/SILGen/plus_zero_objc_attr_NSManaged_multi.swift
new file mode 100644
index 0000000..c1c9a5f
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_attr_NSManaged_multi.swift
@@ -0,0 +1,34 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -sdk %S/Inputs -primary-file %s %S/objc_attr_NSManaged.swift -I %S/Inputs -enable-source-import -emit-silgen -enable-sil-ownership | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+
+// CHECK-LABEL: sil hidden @$S25objc_attr_NSManaged_multi9testMultiyyXlAA10SwiftGizmoCF : $@convention(thin) (@guaranteed SwiftGizmo) -> @owned AnyObject {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $SwiftGizmo):
+// CHECK: = objc_method [[ARG]] : $SwiftGizmo, #SwiftGizmo.kvc!1.foreign : (SwiftGizmo) -> () -> (), $@convention(objc_method) (SwiftGizmo) -> ()
+// CHECK-NOT: return
+// CHECK: = objc_method [[ARG]] : $SwiftGizmo, #SwiftGizmo.extKVC!1.foreign : (SwiftGizmo) -> () -> (), $@convention(objc_method) (SwiftGizmo) -> ()
+// CHECK-NOT: return
+// CHECK: objc_method [[ARG]] : $SwiftGizmo, #SwiftGizmo.x!getter.1.foreign : (SwiftGizmo) -> () -> X, $@convention(objc_method) (SwiftGizmo) -> @autoreleased X
+// CHECK: return
+func testMulti(_ obj: SwiftGizmo) -> AnyObject {
+ obj.kvc()
+ obj.extKVC()
+ return obj.x
+}
+
+// CHECK-LABEL: sil hidden @$S25objc_attr_NSManaged_multi14testFinalMultiySSAA0F5GizmoCF : $@convention(thin) (@guaranteed FinalGizmo) -> @owned String {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $FinalGizmo):
+// CHECK: objc_method [[ARG]] : $FinalGizmo, #FinalGizmo.kvc2!1.foreign : (FinalGizmo) -> () -> (), $@convention(objc_method) (FinalGizmo) -> ()
+// CHECK-NOT: return
+// CHECK: objc_method [[ARG]] : $FinalGizmo, #FinalGizmo.extKVC2!1.foreign : (FinalGizmo) -> () -> (), $@convention(objc_method) (FinalGizmo) -> ()
+// CHECK-NOT: return
+// CHECK: objc_method [[ARG]] : $FinalGizmo, #FinalGizmo.y!getter.1.foreign : (FinalGizmo) -> () -> String, $@convention(objc_method) (FinalGizmo) -> @autoreleased NSString
+// CHECK: return
+func testFinalMulti(_ obj: FinalGizmo) -> String {
+ obj.kvc2()
+ obj.extKVC2()
+ return obj.y
+}
diff --git a/test/SILGen/plus_zero_objc_blocks_bridging.swift b/test/SILGen/plus_zero_objc_blocks_bridging.swift
new file mode 100644
index 0000000..06b79c0
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_blocks_bridging.swift
@@ -0,0 +1,202 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %build-silgen-test-overlays
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -verify -emit-silgen -I %S/Inputs -disable-objc-attr-requires-foundation-module -enable-sil-ownership %s | %FileCheck %s
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -verify -emit-silgen -I %S/Inputs -disable-objc-attr-requires-foundation-module -enable-sil-ownership %s | %FileCheck %s --check-prefix=GUARANTEED
+
+// REQUIRES: objc_interop
+
+import Foundation
+
+@objc class Foo {
+// CHECK-LABEL: sil hidden [thunk] @$S20objc_blocks_bridging3FooC3foo_1xS3iXE_SitFTo :
+ // CHECK: bb0([[ARG1:%.*]] : @unowned $@convention(block) @noescape (Int) -> Int, {{.*}}, [[SELF:%.*]] : @unowned $Foo):
+ // CHECK: [[ARG1_COPY:%.*]] = copy_block [[ARG1]]
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[THUNK:%.*]] = function_ref @$SS2iIyByd_S2iIegyd_TR
+ // CHECK: [[BRIDGED:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[ARG1_COPY]])
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[BRIDGED]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[NATIVE:%.*]] = function_ref @$S20objc_blocks_bridging3FooC3foo{{[_0-9a-zA-Z]*}}F : $@convention(method) (@noescape @callee_guaranteed (Int) -> Int, Int, @guaranteed Foo) -> Int
+ // CHECK: apply [[NATIVE]]([[CONVERT]], {{.*}}, [[BORROWED_SELF_COPY]])
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: } // end sil function '$S20objc_blocks_bridging3FooC3foo_1xS3iXE_SitFTo'
+ dynamic func foo(_ f: (Int) -> Int, x: Int) -> Int {
+ return f(x)
+ }
+
+ // CHECK-LABEL: sil hidden [thunk] @$S20objc_blocks_bridging3FooC3bar_1xS3SXE_SStFTo : $@convention(objc_method) (@convention(block) @noescape (NSString) -> @autoreleased NSString, NSString, Foo) -> @autoreleased NSString {
+ // CHECK: bb0([[BLOCK:%.*]] : @unowned $@convention(block) @noescape (NSString) -> @autoreleased NSString, [[NSSTRING:%.*]] : @unowned $NSString, [[SELF:%.*]] : @unowned $Foo):
+ // CHECK: [[BLOCK_COPY:%.*]] = copy_block [[BLOCK]]
+ // CHECK: [[NSSTRING_COPY:%.*]] = copy_value [[NSSTRING]]
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[THUNK:%.*]] = function_ref @$SSo8NSStringCABIyBya_S2SIeggo_TR
+ // CHECK: [[BRIDGED:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[BLOCK_COPY]])
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[BRIDGED]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[NATIVE:%.*]] = function_ref @$S20objc_blocks_bridging3FooC3bar{{[_0-9a-zA-Z]*}}F : $@convention(method) (@noescape @callee_guaranteed (@guaranteed String) -> @owned String, @guaranteed String, @guaranteed Foo) -> @owned String
+ // CHECK: apply [[NATIVE]]([[CONVERT]], {{%.*}}, [[BORROWED_SELF_COPY]])
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: } // end sil function '$S20objc_blocks_bridging3FooC3bar_1xS3SXE_SStFTo'
+ dynamic func bar(_ f: (String) -> String, x: String) -> String {
+ return f(x)
+ }
+
+ // GUARANTEED-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SSo8NSStringCABIyBya_S2SIeggo_TR : $@convention(thin) (@guaranteed String, @guaranteed @convention(block) @noescape (NSString) -> @autoreleased NSString) -> @owned String {
+ // GUARANTEED: bb0(%0 : @guaranteed $String, [[BLOCK:%.*]] : @guaranteed $@convention(block) @noescape (NSString) -> @autoreleased NSString):
+ // GUARANTEED: [[BRIDGE:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+ // GUARANTEED: [[NSSTR:%.*]] = apply [[BRIDGE]](%0)
+ // GUARANTEED: apply [[BLOCK]]([[NSSTR]]) : $@convention(block) @noescape (NSString) -> @autoreleased NSString
+ // GUARANTEED: } // end sil function '$SSo8NSStringCABIyBya_S2SIeggo_TR'
+
+ // CHECK-LABEL: sil hidden [thunk] @$S20objc_blocks_bridging3FooC3bas_1xSSSgA2FXE_AFtFTo : $@convention(objc_method) (@convention(block) @noescape (Optional<NSString>) -> @autoreleased Optional<NSString>, Optional<NSString>, Foo) -> @autoreleased Optional<NSString> {
+ // CHECK: bb0([[BLOCK:%.*]] : @unowned $@convention(block) @noescape (Optional<NSString>) -> @autoreleased Optional<NSString>, [[OPT_STRING:%.*]] : @unowned $Optional<NSString>, [[SELF:%.*]] : @unowned $Foo):
+ // CHECK: [[BLOCK_COPY:%.*]] = copy_block [[BLOCK]]
+ // CHECK: [[OPT_STRING_COPY:%.*]] = copy_value [[OPT_STRING]]
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[THUNK:%.*]] = function_ref @$SSo8NSStringCSgACIyBya_SSSgADIeggo_TR
+ // CHECK: [[BRIDGED:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[BLOCK_COPY]])
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[BRIDGED]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[NATIVE:%.*]] = function_ref @$S20objc_blocks_bridging3FooC3bas{{[_0-9a-zA-Z]*}}F : $@convention(method) (@noescape @callee_guaranteed (@guaranteed Optional<String>) -> @owned Optional<String>, @guaranteed Optional<String>, @guaranteed Foo) -> @owned Optional<String>
+ // CHECK: apply [[NATIVE]]([[CONVERT]], {{%.*}}, [[BORROWED_SELF_COPY]])
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ dynamic func bas(_ f: (String?) -> String?, x: String?) -> String? {
+ return f(x)
+ }
+
+ // CHECK-LABEL: sil hidden [thunk] @$S20objc_blocks_bridging3FooC16cFunctionPointer{{[_0-9a-zA-Z]*}}FTo
+ // CHECK: bb0([[F:%.*]] : @trivial $@convention(c) @noescape (Int) -> Int, [[X:%.*]] : @trivial $Int, [[SELF:%.*]] : @unowned $Foo):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[NATIVE:%.*]] = function_ref @$S20objc_blocks_bridging3FooC16cFunctionPointer{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[NATIVE]]([[F]], [[X]], [[BORROWED_SELF_COPY]])
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ dynamic func cFunctionPointer(_ fp: @convention(c) (Int) -> Int, x: Int) -> Int {
+ _ = fp(x)
+ }
+
+ // Blocks and C function pointers must not be reabstracted when placed in optionals.
+ // CHECK-LABEL: sil hidden [thunk] @$S20objc_blocks_bridging3FooC7optFunc{{[_0-9a-zA-Z]*}}FTo
+ // CHECK: bb0([[ARG0:%.*]] : @unowned $Optional<@convention(block) (NSString) -> @autoreleased NSString>,
+ // CHECK: [[COPY:%.*]] = copy_block [[ARG0]]
+ // CHECK: switch_enum [[COPY]] : $Optional<@convention(block) (NSString) -> @autoreleased NSString>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+ // CHECK: [[SOME_BB]]([[BLOCK:%.*]] : @owned $@convention(block) (NSString) -> @autoreleased NSString):
+ // TODO: redundant reabstractions here
+ // CHECK: [[BLOCK_THUNK:%.*]] = function_ref @$SSo8NSStringCABIeyBya_S2SIeggo_TR
+ // CHECK: [[BRIDGED:%.*]] = partial_apply [callee_guaranteed] [[BLOCK_THUNK]]([[BLOCK]])
+ // CHECK: enum $Optional<@callee_guaranteed (@guaranteed String) -> @owned String>, #Optional.some!enumelt.1, [[BRIDGED]]
+ // CHECK: [[NATIVE:%.*]] = function_ref @$S20objc_blocks_bridging3FooC7optFunc{{[_0-9a-zA-Z]*}}F : $@convention(method) (@guaranteed Optional<@callee_guaranteed (@guaranteed String) -> @owned String>, @guaranteed String, @guaranteed Foo) -> @owned Optional<String>
+ // CHECK: apply [[NATIVE]]
+ dynamic func optFunc(_ f: ((String) -> String)?, x: String) -> String? {
+ return f?(x)
+ }
+
+ // CHECK-LABEL: sil hidden @$S20objc_blocks_bridging3FooC19optCFunctionPointer{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[FP_BUF:%.*]] = unchecked_enum_data %0
+ dynamic func optCFunctionPointer(_ fp: (@convention(c) (String) -> String)?, x: String) -> String? {
+ return fp?(x)
+ }
+}
+
+// => SEMANTIC SIL TODO: This test needs to be filled out more for ownership
+//
+// CHECK-LABEL: sil hidden @$S20objc_blocks_bridging10callBlocks{{[_0-9a-zA-Z]*}}F
+func callBlocks(_ x: Foo,
+ f: @escaping (Int) -> Int,
+ g: @escaping (String) -> String,
+ h: @escaping (String?) -> String?
+) -> (Int, String, String?, String?) {
+ // CHECK: bb0([[ARG0:%.*]] : @guaranteed $Foo, [[ARG1:%.*]] : @guaranteed $@callee_guaranteed (Int) -> Int, [[ARG2:%.*]] : @guaranteed $@callee_guaranteed (@guaranteed String) -> @owned String, [[ARG3:%.*]] : @guaranteed $@callee_guaranteed (@guaranteed Optional<String>) -> @owned Optional<String>):
+ // CHECK: [[CLOSURE_COPY:%.*]] = copy_value [[ARG1]]
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[CLOSURE_COPY]]
+ // CHECK: [[F_BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage
+ // CHECK: [[F_BLOCK_CAPTURE:%.*]] = project_block_storage [[F_BLOCK_STORAGE]]
+ // CHECK: store [[CONVERT]] to [trivial] [[F_BLOCK_CAPTURE]]
+ // CHECK: [[F_BLOCK_INVOKE:%.*]] = function_ref @$SS2iIgyd_S2iIyByd_TR
+ // CHECK: [[F_STACK_BLOCK:%.*]] = init_block_storage_header [[F_BLOCK_STORAGE]] : {{.*}}, invoke [[F_BLOCK_INVOKE]]
+ // CHECK: [[F_BLOCK:%.*]] = copy_block [[F_STACK_BLOCK]]
+ // CHECK: [[FOO:%.*]] = objc_method [[ARG0]] : $Foo, #Foo.foo!1.foreign
+ // CHECK: apply [[FOO]]([[F_BLOCK]]
+
+ // CHECK: [[G_BLOCK_INVOKE:%.*]] = function_ref @$SS2SIggo_So8NSStringCABIyBya_TR
+ // CHECK: [[G_STACK_BLOCK:%.*]] = init_block_storage_header {{.*}}, invoke [[G_BLOCK_INVOKE]]
+ // CHECK: [[G_BLOCK:%.*]] = copy_block [[G_STACK_BLOCK]]
+ // CHECK: [[BAR:%.*]] = objc_method [[ARG0]] : $Foo, #Foo.bar!1.foreign
+ // CHECK: apply [[BAR]]([[G_BLOCK]]
+
+ // CHECK: [[H_BLOCK_INVOKE:%.*]] = function_ref @$SSSSgAAIggo_So8NSStringCSgADIyBya_TR
+ // CHECK: [[H_STACK_BLOCK:%.*]] = init_block_storage_header {{.*}}, invoke [[H_BLOCK_INVOKE]]
+ // CHECK: [[H_BLOCK:%.*]] = copy_block [[H_STACK_BLOCK]]
+ // CHECK: [[BAS:%.*]] = objc_method [[ARG0]] : $Foo, #Foo.bas!1.foreign
+ // CHECK: apply [[BAS]]([[H_BLOCK]]
+
+ // CHECK: [[G_BLOCK:%.*]] = copy_block {{%.*}} : $@convention(block) (NSString) -> @autoreleased NSString
+ // CHECK: enum $Optional<@convention(block) (NSString) -> @autoreleased NSString>, #Optional.some!enumelt.1, [[G_BLOCK]]
+
+ return (x.foo(f, x: 0), x.bar(g, x: "one"), x.bas(h, x: "two"), x.optFunc(g, x: "three"))
+}
+
+class Test: NSObject {
+ func blockTakesBlock() -> ((Int) -> Int) -> Int {}
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SS2iIgyd_SiIegyd_S2iIyByd_SiIeyByd_TR
+// CHECK: [[BLOCK_COPY:%.*]] = copy_block [[ORIG_BLOCK:%.*]] :
+// CHECK: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] {{%.*}}([[BLOCK_COPY]])
+// CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[CLOSURE]]
+// CHECK: [[RESULT:%.*]] = apply {{%.*}}([[CONVERT]])
+// CHECK: return [[RESULT]]
+
+func clearDraggingItemImageComponentsProvider(_ x: NSDraggingItem) {
+ x.imageComponentsProvider = {}
+}
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SSayypGIego_So7NSArrayCSgIeyBa_TR
+// CHECK: [[CONVERT:%.*]] = function_ref @$SSa10FoundationE19_bridgeToObjectiveCSo7NSArrayCyF
+// CHECK: [[CONVERTED:%.*]] = apply [[CONVERT]]
+// CHECK: [[OPTIONAL:%.*]] = enum $Optional<NSArray>, #Optional.some!enumelt.1, [[CONVERTED]]
+// CHECK: return [[OPTIONAL]]
+
+// CHECK-LABEL: sil hidden @{{.*}}bridgeNonnullBlockResult{{.*}}
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SSSIego_So8NSStringCSgIeyBa_TR
+// CHECK: [[CONVERT:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+// CHECK: [[BRIDGED:%.*]] = apply [[CONVERT]]
+// CHECK: [[OPTIONAL_BRIDGED:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[BRIDGED]]
+// CHECK: return [[OPTIONAL_BRIDGED]]
+func bridgeNonnullBlockResult() {
+ nonnullStringBlockResult { return "test" }
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}bridgeNoescapeBlock{{.*}}
+func bridgeNoescapeBlock() {
+ // CHECK: function_ref @$SIg_IyB_TR
+ noescapeBlockAlias { }
+ // CHECK: function_ref @$SIg_IyB_TR
+ noescapeNonnullBlockAlias { }
+}
+
+class ObjCClass : NSObject {}
+
+extension ObjCClass {
+ func someDynamicMethod(closure: (() -> ()) -> ()) {}
+}
+
+struct GenericStruct<T> {
+ let closure: (() -> ()) -> ()
+
+ func doStuff(o: ObjCClass) {
+ o.someDynamicMethod(closure: closure)
+ }
+}
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SIg_Igy_IyB_IyBy_TR : $@convention(c) (@inout_aliasable @block_storage @noescape @callee_guaranteed (@noescape @callee_guaranteed () -> ()) -> (), @convention(block) @noescape () -> ()) -> () {
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SIyB_Ieg_TR : $@convention(thin) (@guaranteed @convention(block) @noescape () -> ()) -> ()
+
+// rdar://35402696
+func takeOptStringFunction(fn: (String) -> String?) {}
+func testGlobalBlock() {
+ takeOptStringFunction(fn: GlobalBlock)
+}
+// CHECK-LABEL: sil hidden @$S20objc_blocks_bridging15testGlobalBlockyyF
+// CHECK: global_addr @GlobalBlock : $*@convention(block) (NSString) -> @autoreleased Optional<NSString>
+// CHECK: function_ref @$SSo8NSStringCABSgIeyBya_S2SIeggo_TR : $@convention(thin) (@guaranteed String, @guaranteed @convention(block) (NSString) -> @autoreleased Optional<NSString>) -> @owned String
diff --git a/test/SILGen/plus_zero_objc_bridged_results.swift b/test/SILGen/plus_zero_objc_bridged_results.swift
new file mode 100644
index 0000000..862c5b1
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_bridged_results.swift
@@ -0,0 +1,154 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %build-silgen-test-overlays
+
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -emit-silgen %s -Xllvm -sil-print-debuginfo -import-objc-header %S/Inputs/objc_bridged_results.h -enable-sil-ownership | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+
+// CHECK-LABEL: sil hidden @$S20objc_bridged_results11testNonnullySayypGSo4TestCF
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Test):
+// CHECK: [[METHOD:%[0-9]+]] = objc_method [[ARG]] : $Test, #Test.nonnullArray!getter.1.foreign : (Test) -> () -> [Any], $@convention(objc_method) (Test) -> @autoreleased Optional<NSArray>
+// CHECK: [[COCOA_VAL:%[0-9]+]] = apply [[METHOD]]([[ARG]]) : $@convention(objc_method) (Test) -> @autoreleased Optional<NSArray>
+// CHECK: [[CONVERT:%[0-9]+]] = function_ref @$SSa10FoundationE36_unconditionallyBridgeFromObjectiveCySayxGSo7NSArrayCSgFZ
+// CHECK: [[ARRAY_META:%[0-9]+]] = metatype $@thin Array<Any>.Type
+// CHECK: [[RESULT:%[0-9]+]] = apply [[CONVERT]]<Any>([[COCOA_VAL]], [[ARRAY_META]])
+// CHECK-NOT: destroy_value %0 : $Test
+// CHECK: return [[RESULT]] : $Array<Any>
+func testNonnull(_ obj: Test) -> [Any] {
+ return obj.nonnullArray
+} // CHECK: } // end sil function '$S20objc_bridged_results11testNonnullySayypGSo4TestCF'
+
+// CHECK-LABEL: sil hidden @$S20objc_bridged_results12testNullableySayypGSgSo4TestCF
+func testNullable(_ obj: Test) -> [Any]? {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Test):
+ // CHECK: [[METHOD:%[0-9]+]] = objc_method [[ARG]] : $Test, #Test.nullableArray!getter.1.foreign : (Test) -> () -> [Any]?, $@convention(objc_method) (Test) -> @autoreleased Optional<NSArray>
+ // CHECK: [[COCOA_VAL:%[0-9]+]] = apply [[METHOD]]([[ARG]]) : $@convention(objc_method) (Test) -> @autoreleased Optional<NSArray>
+ // CHECK: switch_enum [[COCOA_VAL]] : $Optional<NSArray>, case #Optional.some!enumelt.1: [[CASE_NON_NIL:bb[0-9]+]], case #Optional.none!enumelt: [[CASE_NIL:bb[0-9]+]]
+ //
+ // CHECK: [[CASE_NON_NIL]]([[COCOA_VAL_NON_NIL:%.*]] : @owned $NSArray):
+ // CHECK-NOT: unchecked_enum_data
+ // CHECK: [[CONVERT:%[0-9]+]] = function_ref @$SSa10FoundationE36_unconditionallyBridgeFromObjectiveCySayxGSo7NSArrayCSgFZ
+ // CHECK: [[COCOA_SOME_VAL:%[0-9]+]] = enum $Optional<NSArray>, #Optional.some!enumelt.1, [[COCOA_VAL_NON_NIL]]
+ // CHECK: [[ARRAY_META:%[0-9]+]] = metatype $@thin Array<Any>.Type
+ // CHECK: [[RESULT_VAL:%[0-9]+]] = apply [[CONVERT]]<Any>([[COCOA_SOME_VAL]], [[ARRAY_META]])
+ // CHECK: [[RESULT_SOME:%[0-9]+]] = enum $Optional<Array<Any>>, #Optional.some!enumelt.1, [[RESULT_VAL]] : $Array<Any>
+ // CHECK: br [[FINISH:bb[0-9]+]]([[RESULT_SOME]] : $Optional<Array<Any>>)
+
+ // CHECK: [[CASE_NIL]]:
+ // CHECK: [[RESULT_NONE:%[0-9]+]] = enum $Optional<Array<Any>>, #Optional.none!enumelt
+ // CHECK: br [[FINISH]]([[RESULT_NONE]] : $Optional<Array<Any>>)
+
+ // CHECK: [[FINISH]]([[RESULT:%[0-9]+]] : @owned $Optional<Array<Any>>):
+ // CHECK-NOT: destroy_value [[ARG]] : $Test
+ // CHECK: return [[RESULT]] : $Optional<Array<Any>>
+ return obj.nullableArray
+} // CHECK: } // end sil function '$S20objc_bridged_results12testNullableySayypGSgSo4TestCF'
+
+// CHECK-LABEL: sil hidden @$S20objc_bridged_results19testNullUnspecifiedySayypGSgSo4TestCF
+func testNullUnspecified(_ obj: Test) -> [Any]! {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Test):
+ // CHECK: [[METHOD:%[0-9]+]] = objc_method [[ARG]] : $Test, #Test.nullUnspecifiedArray!getter.1.foreign : (Test) -> () -> [Any]?, $@convention(objc_method) (Test) -> @autoreleased Optional<NSArray>
+ // CHECK: [[COCOA_VAL:%[0-9]+]] = apply [[METHOD]]([[ARG]]) : $@convention(objc_method) (Test) -> @autoreleased Optional<NSArray>
+ // CHECK: switch_enum [[COCOA_VAL]] : $Optional<NSArray>, case #Optional.some!enumelt.1: [[CASE_NON_NIL:bb[0-9]+]], case #Optional.none!enumelt: [[CASE_NIL:bb[0-9]+]]
+
+ // CHECK: [[CASE_NON_NIL]]([[COCOA_VAL_NON_NIL:%.*]] : @owned $NSArray):
+ // CHECK-NOT: unchecked_enum_data
+ // CHECK: [[CONVERT:%[0-9]+]] = function_ref @$SSa10FoundationE36_unconditionallyBridgeFromObjectiveCySayxGSo7NSArrayCSgFZ
+ // CHECK: [[COCOA_SOME_VAL:%[0-9]+]] = enum $Optional<NSArray>, #Optional.some!enumelt.1, [[COCOA_VAL_NON_NIL]]
+ // CHECK: [[ARRAY_META:%[0-9]+]] = metatype $@thin Array<Any>.Type
+ // CHECK: [[RESULT_VAL:%[0-9]+]] = apply [[CONVERT]]<Any>([[COCOA_SOME_VAL]], [[ARRAY_META]])
+ // CHECK: [[RESULT_SOME:%[0-9]+]] = enum $Optional<Array<Any>>, #Optional.some!enumelt.1, [[RESULT_VAL]] : $Array<Any>
+ // CHECK: br [[FINISH:bb[0-9]+]]([[RESULT_SOME]] : $Optional<Array<Any>>)
+
+ // CHECK: [[CASE_NIL]]:
+ // CHECK: [[RESULT_NONE:%[0-9]+]] = enum $Optional<Array<Any>>, #Optional.none!enumelt
+ // CHECK: br [[FINISH]]([[RESULT_NONE]] : $Optional<Array<Any>>)
+
+ // CHECK: [[FINISH]]([[RESULT:%[0-9]+]] : @owned $Optional<Array<Any>>):
+ // CHECK-NOT: destroy_value [[ARG]] : $Test
+ // CHECK: return [[RESULT]] : $Optional<Array<Any>>
+ return obj.nullUnspecifiedArray
+} // CHECK: } // end sil function '$S20objc_bridged_results19testNullUnspecifiedySayypGSgSo4TestCF'
+
+
+// CHECK-LABEL: sil hidden @$S20objc_bridged_results21testNonnullDictionaryys0F0Vys11AnyHashableVypGSo4TestCF
+func testNonnullDictionary(_ obj: Test) -> [AnyHashable: Any] {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Test):
+ // CHECK: [[METHOD:%[0-9]+]] = objc_method [[ARG]] : $Test, #Test.nonnullDictionary!getter.1.foreign : (Test) -> () -> [AnyHashable : Any], $@convention(objc_method) (Test) -> @autoreleased Optional<NSDictionary>
+ // CHECK: [[COCOA_VAL:%[0-9]+]] = apply [[METHOD]]([[ARG]]) : $@convention(objc_method) (Test) -> @autoreleased Optional<NSDictionary>
+ // CHECK: [[CONVERT:%[0-9]+]] = function_ref @$Ss10DictionaryV10FoundationE36_unconditionallyBridgeFromObjectiveCyAByxq_GSo12NSDictionaryCSgFZ
+ // CHECK: [[DICT_META:%[0-9]+]] = metatype $@thin Dictionary<AnyHashable, Any>.Type
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[CONVERT]]<AnyHashable, Any>([[COCOA_VAL]], [[DICT_META]])
+ // CHECK-NOT: destroy_value [[ARG]] : $Test
+ // CHECK: return [[RESULT]] : $Dictionary<AnyHashable, Any>
+ return obj.nonnullDictionary
+} // CHECK: } // end sil function '$S20objc_bridged_results21testNonnullDictionaryys0F0Vys11AnyHashableVypGSo4TestCF'
+
+// CHECK-LABEL: sil hidden @$S20objc_bridged_results14testNonnullSetys0F0Vys11AnyHashableVGSo4TestCF
+func testNonnullSet(_ obj: Test) -> Set<AnyHashable> {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Test):
+ // CHECK: [[METHOD:%[0-9]+]] = objc_method [[ARG]] : $Test, #Test.nonnullSet!getter.1.foreign : (Test) -> () -> Set<AnyHashable>, $@convention(objc_method) (Test) -> @autoreleased Optional<NSSet>
+ // CHECK: [[COCOA_VAL:%[0-9]+]] = apply [[METHOD]]([[ARG]]) : $@convention(objc_method) (Test) -> @autoreleased Optional<NSSet>
+ // CHECK: [[CONVERT:%[0-9]+]] = function_ref @$Ss3SetV10FoundationE36_unconditionallyBridgeFromObjectiveCyAByxGSo5NSSetCSgFZ
+ // CHECK: [[SET_META:%[0-9]+]] = metatype $@thin Set<AnyHashable>.Type
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[CONVERT]]<AnyHashable>([[COCOA_VAL]], [[SET_META]])
+ // CHECK-NOT: destroy_value [[ARG]] : $Test
+ // CHECK: return [[RESULT]] : $Set<AnyHashable>
+ return obj.nonnullSet
+} // CHECK: } // end sil function '$S20objc_bridged_results14testNonnullSetys0F0Vys11AnyHashableVGSo4TestCF'
+
+// CHECK-LABEL: sil hidden @$S20objc_bridged_results17testNonnullStringySSSo4TestCF
+func testNonnullString(_ obj: Test) -> String {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Test):
+ // CHECK: [[METHOD:%[0-9]+]] = objc_method [[ARG]] : $Test, #Test.nonnullString!getter.1.foreign : (Test) -> () -> String, $@convention(objc_method) (Test) -> @autoreleased Optional<NSString>
+ // CHECK: [[COCOA_VAL:%[0-9]+]] = apply [[METHOD]]([[ARG]]) : $@convention(objc_method) (Test) -> @autoreleased Optional<NSString>
+ // CHECK: [[CONVERT:%[0-9]+]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: [[STRING_META:%[0-9]+]] = metatype $@thin String.Type
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[CONVERT]]([[COCOA_VAL]], [[STRING_META]]) : $@convention(method) (@guaranteed Optional<NSString>, @thin String.Type) -> @owned String
+ // CHECK-NOT: destroy_value [[ARG]] : $Test
+ // CHECK: return [[RESULT]] : $String
+ return obj.nonnullString
+} // CHECK: } // end sil function '$S20objc_bridged_results17testNonnullStringySSSo4TestCF'
+
+// CHECK-LABEL: sil hidden @$S20objc_bridged_results13testClassPropSSyF
+func testClassProp() -> String {
+ // CHECK: [[CLASS:%.+]] = metatype $@objc_metatype Test.Type
+ // CHECK: [[METHOD:%.+]] = objc_method [[CLASS]] : $@objc_metatype Test.Type, #Test.nonnullSharedString!getter.1.foreign : (Test.Type) -> () -> String, $@convention(objc_method) (@objc_metatype Test.Type) -> @autoreleased Optional<NSString>
+ // CHECK: [[COCOA_VAL:%[0-9]+]] = apply [[METHOD]]([[CLASS]]) : $@convention(objc_method) (@objc_metatype Test.Type) -> @autoreleased Optional<NSString>
+ // CHECK: [[CONVERT:%[0-9]+]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: [[STRING_META:%[0-9]+]] = metatype $@thin String.Type
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[CONVERT]]([[COCOA_VAL]], [[STRING_META]]) : $@convention(method) (@guaranteed Optional<NSString>, @thin String.Type) -> @owned String
+ // CHECK: return [[RESULT]] : $String
+ return Test.nonnullSharedString
+} // CHECK: } // end sil function '$S20objc_bridged_results13testClassPropSSyF'
+
+
+// Note: This doesn't really "work" in that it doesn't accept a nil value the
+// way the others do, because subscripts are thunked. But the main thing is
+// not to crash trying to generate the thunk.
+// CHECK-LABEL: sil hidden @$S20objc_bridged_results20testNonnullSubscriptySayypGSo4TestCF
+func testNonnullSubscript(_ obj: Test) -> [Any] {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Test):
+ // CHECK: [[METHOD:%[0-9]+]] = objc_method [[ARG]] : $Test, #Test.subscript!getter.1.foreign : (Test) -> (Int) -> [Any], $@convention(objc_method) (Int, Test) -> @autoreleased Optional<NSArray>
+ // CHECK: [[COCOA_VAL:%[0-9]+]] = apply [[METHOD]]({{%[0-9]+}}, [[ARG]]) : $@convention(objc_method) (Int, Test) -> @autoreleased Optional<NSArray>
+ // CHECK: [[CONVERT:%[0-9]+]] = function_ref @$SSa10FoundationE36_unconditionallyBridgeFromObjectiveCySayxGSo7NSArrayCSgFZ
+ // CHECK: [[ARRAY_META:%[0-9]+]] = metatype $@thin Array<Any>.Type,
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[CONVERT]]<Any>([[COCOA_VAL]], [[ARRAY_META]])
+ // CHECK-NOT: destroy_value [[ARG]] : $Test
+ // CHECK: return [[RESULT]] : $Array<Any>
+ return obj[0]
+} // CHECK: } // end sil function '$S20objc_bridged_results20testNonnullSubscriptySayypGSo4TestCF'
+
+
+// CHECK-LABEL: sil hidden @$S20objc_bridged_results19testPerformSelectoryySo8NSObjectCF
+func testPerformSelector(_ obj: NSObject) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $NSObject):
+ // CHECK: [[METHOD:%[0-9]+]] = objc_method [[ARG]] : $NSObject, #NSObject.perform!1.foreign
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[METHOD]]({{%[0-9]+}}, {{%[0-9]+}}, [[ARG]])
+ _ = obj.perform("foo", with: nil)
+ // CHECK-NOT: {{(retain|release).+}}[[RESULT]]
+ // CHECK-NOT: {{(retain|release).+}}[[RESULT]]
+} // CHECK: } // end sil function '$S20objc_bridged_results19testPerformSelectoryySo8NSObjectCF'
diff --git a/test/SILGen/plus_zero_objc_bridging.swift b/test/SILGen/plus_zero_objc_bridging.swift
new file mode 100644
index 0000000..c4c6e1a
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_bridging.swift
@@ -0,0 +1,648 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %build-silgen-test-overlays
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -emit-module -o %t -I %S/../Inputs/ObjCBridging %S/../Inputs/ObjCBridging/Appliances.swift
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -I %S/../Inputs/ObjCBridging -Xllvm -sil-full-demangle -emit-silgen %s -enable-sil-ownership | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-cpu --check-prefix=CHECK-%target-os-%target-cpu
+
+// REQUIRES: objc_interop
+
+import Foundation
+import Appliances
+
+
+func getDescription(_ o: NSObject) -> String {
+ return o.description
+}
+// CHECK-LABEL: sil hidden @$S13objc_bridging14getDescription{{.*}}F
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $NSObject):
+// CHECK: [[DESCRIPTION:%.*]] = objc_method [[ARG]] : $NSObject, #NSObject.description!getter.1.foreign
+// CHECK: [[OPT_BRIDGED:%.*]] = apply [[DESCRIPTION]]([[ARG]])
+// CHECK: switch_enum [[OPT_BRIDGED]] : $Optional<NSString>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+// CHECK: [[SOME_BB]]([[BRIDGED:%.*]] : @owned $NSString):
+// CHECK-NOT: unchecked_enum_data
+// CHECK: [[NSSTRING_TO_STRING:%.*]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+// CHECK: [[BRIDGED_BOX:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[BRIDGED]]
+// CHECK: [[NATIVE:%.*]] = apply [[NSSTRING_TO_STRING]]([[BRIDGED_BOX]],
+// CHECK: [[OPT_NATIVE:%.*]] = enum $Optional<String>, #Optional.some!enumelt.1, [[NATIVE]]
+// CHECK: br [[CONT_BB:bb[0-9]+]]([[OPT_NATIVE]] : $Optional<String>)
+//
+// CHECK: [[NONE_BB]]:
+// CHECK: [[OPT_NATIVE:%.*]] = enum $Optional<String>, #Optional.none!enumelt
+// CHECK: br [[CONT_BB]]([[OPT_NATIVE]] : $Optional<String>)
+//
+// CHECK: [[CONT_BB]]([[OPT_NATIVE:%.*]] : @owned $Optional<String>):
+// CHECK: switch_enum [[OPT_NATIVE]] : $Optional<String>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+// CHECK: [[NONE_BB]]:
+// CHECK: unreachable
+//
+// CHECK: [[SOME_BB]]([[NATIVE:%.*]] : @owned $String):
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return [[NATIVE]]
+// CHECK:}
+
+func getUppercaseString(_ s: NSString) -> String {
+ return s.uppercase()
+}
+// CHECK-LABEL: sil hidden @$S13objc_bridging18getUppercaseString{{.*}}F
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $NSString):
+// -- The 'self' argument of NSString methods doesn't bridge.
+// CHECK-NOT: function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+// CHECK-NOT: function_ref @swift_StringToNSString
+// CHECK: [[UPPERCASE_STRING:%.*]] = objc_method [[ARG]] : $NSString, #NSString.uppercase!1.foreign
+// CHECK: [[OPT_BRIDGED:%.*]] = apply [[UPPERCASE_STRING]]([[ARG]]) : $@convention(objc_method) (NSString) -> @autoreleased Optional<NSString>
+// CHECK: switch_enum [[OPT_BRIDGED]] : $Optional<NSString>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+//
+// CHECK: [[SOME_BB]]([[BRIDGED:%.*]] :
+// CHECK-NOT: unchecked_enum_data
+// CHECK: [[NSSTRING_TO_STRING:%.*]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+// CHECK: [[BRIDGED_BOX:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[BRIDGED]]
+// CHECK: [[NATIVE:%.*]] = apply [[NSSTRING_TO_STRING]]([[BRIDGED_BOX]]
+// CHECK: [[OPT_NATIVE:%.*]] = enum $Optional<String>, #Optional.some!enumelt.1, [[NATIVE]]
+// CHECK: br [[CONT_BB:bb[0-9]+]]([[OPT_NATIVE]] : $Optional<String>)
+//
+// CHECK: [[NONE_BB]]:
+// CHECK: [[OPT_NATIVE:%.*]] = enum $Optional<String>, #Optional.none!enumelt
+// CHECK: br [[CONT_BB]]([[OPT_NATIVE]] : $Optional<String>)
+//
+// CHECK: [[CONT_BB]]([[OPT_NATIVE:%.*]] : @owned $Optional<String>):
+// CHECK: switch_enum [[OPT_NATIVE]] : $Optional<String>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+// CHECK: [[NONE_BB]]:
+// CHECK: unreachable
+//
+// CHECK: [[SOME_BB]]([[NATIVE:%.*]] : @owned $String):
+// CHECK: return [[NATIVE]]
+// CHECK: }
+
+// @interface Foo -(void) setFoo: (NSString*)s; @end
+func setFoo(_ f: Foo, s: String) {
+ var s = s
+ f.setFoo(s)
+}
+// CHECK-LABEL: sil hidden @$S13objc_bridging6setFoo{{.*}}F
+// CHECK: bb0([[ARG0:%.*]] : @guaranteed $Foo, {{%.*}} : @guaranteed $String):
+// CHECK: [[NATIVE:%.*]] = load
+// CHECK: [[STRING_TO_NSSTRING:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+// CHECK: [[BORROWED_NATIVE:%.*]] = begin_borrow [[NATIVE]]
+// CHECK: [[BRIDGED:%.*]] = apply [[STRING_TO_NSSTRING]]([[BORROWED_NATIVE]])
+// CHECK: [[OPT_BRIDGED:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[BRIDGED]]
+// CHECK: [[SET_FOO:%.*]] = objc_method [[ARG0]] : $Foo, #Foo.setFoo!1.foreign
+// CHECK: apply [[SET_FOO]]([[OPT_BRIDGED]], [[ARG0]]) : $@convention(objc_method) (Optional<NSString>, Foo) -> ()
+// CHECK: destroy_value [[OPT_BRIDGED]]
+// CHECK-NOT: destroy_value [[ARG0]]
+// CHECK: }
+
+// @interface Foo -(BOOL) zim; @end
+func getZim(_ f: Foo) -> Bool {
+ return f.zim()
+}
+
+// CHECK-ios-i386-LABEL: sil hidden @$S13objc_bridging6getZim{{.*}}F
+// CHECK-ios-i386: bb0([[SELF:%.*]] : @guaranteed $Foo):
+// CHECK-ios-i386: [[BORROWED_SELF:%.*]] = begin_borrow [[SELF]]
+// CHECK-ios-i386: [[METHOD:%.*]] = objc_method [[BORROWED_SELF]] : $Foo, #Foo.zim!1.foreign : (Foo) -> () -> Bool
+// CHECK-ios-i386: [[OBJC_BOOL:%.*]] = apply [[METHOD]]([[BORROWED_SELF]]) : $@convention(objc_method) (Foo) -> ObjCBool
+// CHECK-ios-i386: end_borrow [[BORROWED_SELF]] from [[SELF]]
+// CHECK-ios-i386: [[CONVERT:%.*]] = function_ref @swift_ObjCBoolToBool : $@convention(thin) (ObjCBool) -> Bool
+// CHECK-ios-i386: [[SWIFT_BOOL:%.*]] = apply [[CONVERT]]([[OBJC_BOOL]]) : $@convention(thin) (ObjCBool) -> Bool
+// CHECK-ios-i386: return [[SWIFT_BOOL]] : $Bool
+// CHECK-ios-i386: }
+
+// CHECK-watchos-i386-LABEL: sil hidden @$S13objc_bridging6getZim{{.*}}F
+// CHECK-watchos-i386: bb0([[SELF:%.*]] : @guaranteed $Foo):
+// CHECK-watchos-i386: [[BORROWED_SELF:%.*]] = begin_borrow [[SELF]]
+// CHECK-watchos-i386: [[METHOD:%.*]] = objc_method [[BORROWED_SELF]] : $Foo, #Foo.zim!1.foreign : (Foo) -> () -> Boo
+// CHECK-watchos-i386: [[BOOL:%.*]] = apply [[METHOD]]([[BORROWED_SELF]]) : $@convention(objc_method) (Foo) -> Bool
+// CHECK-watchos-i386: end_borrow [[BORROWED_SELF]] from [[SELF]]
+// CHECK-watchos-i386: return [[BOOL]] : $Bool
+// CHECK-watchos-i386: }
+
+// CHECK-macosx-x86_64-LABEL: sil hidden @$S13objc_bridging6getZim{{.*}}F
+// CHECK-macosx-x86_64: bb0([[SELF:%.*]] : @guaranteed $Foo):
+// CHECK-macosx-x86_64: [[METHOD:%.*]] = objc_method [[SELF]] : $Foo, #Foo.zim!1.foreign : (Foo) -> () -> Bool
+// CHECK-macosx-x86_64: [[OBJC_BOOL:%.*]] = apply [[METHOD]]([[SELF]]) : $@convention(objc_method) (Foo) -> ObjCBool
+// CHECK-macosx-x86_64: [[CONVERT:%.*]] = function_ref @swift_ObjCBoolToBool : $@convention(thin) (ObjCBool) -> Bool
+// CHECK-macosx-x86_64: [[SWIFT_BOOL:%.*]] = apply [[CONVERT]]([[OBJC_BOOL]]) : $@convention(thin) (ObjCBool) -> Bool
+// CHECK-macosx-x86_64: return [[SWIFT_BOOL]] : $Bool
+// CHECK-macosx-x86_64: }
+
+// CHECK-ios-x86_64-LABEL: sil hidden @$S13objc_bridging6getZim{{.*}}F
+// CHECK-ios-x86_64: bb0([[SELF:%.*]] : @guaranteed $Foo):
+// CHECK-ios-x86_64: [[METHOD:%.*]] = objc_method [[SELF]] : $Foo, #Foo.zim!1.foreign : (Foo) -> () -> Boo
+// CHECK-ios-x86_64: [[BOOL:%.*]] = apply [[METHOD]]([[SELF]]) : $@convention(objc_method) (Foo) -> Bool
+// CHECK-ios-x86_64: return [[BOOL]] : $Bool
+// CHECK-ios-x86_64: }
+
+// CHECK-arm64-LABEL: sil hidden @$S13objc_bridging6getZim{{.*}}F
+// CHECK-arm64: bb0([[SELF:%.*]] : @guaranteed $Foo):
+// CHECK-arm64: [[METHOD:%.*]] = objc_method [[SELF]] : $Foo, #Foo.zim!1.foreign : (Foo) -> () -> Boo
+// CHECK-arm64: [[BOOL:%.*]] = apply [[METHOD]]([[SELF]]) : $@convention(objc_method) (Foo) -> Bool
+// CHECK-arm64: return [[BOOL]] : $Bool
+// CHECK-arm64: }
+
+// @interface Foo -(void) setZim: (BOOL)b; @end
+func setZim(_ f: Foo, b: Bool) {
+ f.setZim(b)
+}
+// CHECK-ios-i386-LABEL: sil hidden @$S13objc_bridging6setZim{{.*}}F
+// CHECK-ios-i386: bb0([[ARG0:%.*]] : @guaranteed $Foo, [[ARG1:%.*]] : @trivial $Bool):
+// CHECK-ios-i386: [[CONVERT:%.*]] = function_ref @swift_BoolToObjCBool : $@convention(thin) (Bool) -> ObjCBool
+// CHECK-ios-i386: [[OBJC_BOOL:%.*]] = apply [[CONVERT]]([[ARG1]]) : $@convention(thin) (Bool) -> ObjCBool
+// CHECK-ios-i386: [[METHOD:%.*]] = objc_method [[ARG0]] : $Foo, #Foo.setZim!1.foreign
+// CHECK-ios-i386: apply [[METHOD]]([[OBJC_BOOL]], [[ARG0]]) : $@convention(objc_method) (ObjCBool, Foo) -> ()
+// CHECK-ios-i386-NOT: destroy_value [[ARG0]]
+// CHECK-ios-i386: }
+
+// CHECK-macosx-x86_64-LABEL: sil hidden @$S13objc_bridging6setZim{{.*}}F
+// CHECK-macosx-x86_64: bb0([[ARG0:%.*]] : @guaranteed $Foo, [[ARG1:%.*]] : @trivial $Bool):
+// CHECK-macosx-x86_64: [[CONVERT:%.*]] = function_ref @swift_BoolToObjCBool : $@convention(thin) (Bool) -> ObjCBool
+// CHECK-macosx-x86_64: [[OBJC_BOOL:%.*]] = apply [[CONVERT]]([[ARG1]]) : $@convention(thin) (Bool) -> ObjCBool
+// CHECK-macosx-x86_64: [[METHOD:%.*]] = objc_method [[ARG0]] : $Foo, #Foo.setZim!1.foreign
+// CHECK-macosx-x86_64: apply [[METHOD]]([[OBJC_BOOL]], [[ARG0]]) : $@convention(objc_method) (ObjCBool, Foo) -> ()
+// CHECK-macosx-x86_64-NOT: destroy_value [[ARG0]]
+// CHECK-macosx-x86_64: }
+
+// CHECK-ios-x86_64-LABEL: sil hidden @$S13objc_bridging6setZim{{.*}}F
+// CHECK-ios-x86_64: bb0([[ARG0:%.*]] : @guaranteed $Foo, [[ARG1:%.*]] : @trivial $Bool):
+// CHECK-ios-x86_64: [[METHOD:%.*]] = objc_method [[ARG0]] : $Foo, #Foo.setZim!1.foreign
+// CHECK-ios-x86_64: apply [[METHOD]]([[ARG1]], [[ARG0]]) : $@convention(objc_method) (Bool, Foo) -> ()
+// CHECK-ios-x86_64-NOT: destroy_value [[ARG0]]
+// CHECK-ios-x86_64: }
+
+// CHECK-arm64-LABEL: sil hidden @$S13objc_bridging6setZim{{.*}}F
+// CHECK-arm64: bb0([[ARG0:%.*]] : @guaranteed $Foo, [[ARG1:%.*]] : @trivial $Bool):
+// CHECK-arm64: [[BORROWED_ARG0:%.*]] = begin_borrow [[ARG0]]
+// CHECK-arm64: [[METHOD:%.*]] = objc_method [[BORROWED_ARG0]] : $Foo, #Foo.setZim!1.foreign
+// CHECK-arm64: apply [[METHOD]]([[ARG1]], [[BORROWED_ARG0]]) : $@convention(objc_method) (Bool, Foo) -> ()
+// CHECK-arm64: end_borrow [[BORROWED_ARG0]] from [[ARG0]]
+// CHECK-arm64: destroy_value [[ARG0]]
+// CHECK-arm64: }
+
+// CHECK-watchos-i386-LABEL: sil hidden @$S13objc_bridging6setZim{{.*}}F
+// CHECK-watchos-i386: bb0([[ARG0:%.*]] : @guaranteed $Foo, [[ARG1:%.*]] : @trivial $Bool):
+// CHECK-watchos-i386: [[BORROWED_ARG0:%.*]] = begin_borrow [[ARG0]]
+// CHECK-watchos-i386: [[METHOD:%.*]] = objc_method [[BORROWED_ARG0]] : $Foo, #Foo.setZim!1.foreign
+// CHECK-watchos-i386: apply [[METHOD]]([[ARG1]], [[BORROWED_ARG0]]) : $@convention(objc_method) (Bool, Foo) -> ()
+// CHECK-watchos-i386: end_borrow [[BORROWED_ARG0]] from [[ARG0]]
+// CHECK-watchos-i386: destroy_value [[ARG0]]
+// CHECK-watchos-i386: }
+
+// @interface Foo -(_Bool) zang; @end
+func getZang(_ f: Foo) -> Bool {
+ return f.zang()
+}
+// CHECK-LABEL: sil hidden @$S13objc_bridging7getZangySbSo3FooCF
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Foo)
+// CHECK: [[METHOD:%.*]] = objc_method [[ARG]] : $Foo, #Foo.zang!1.foreign
+// CHECK: [[BOOL:%.*]] = apply [[METHOD]]([[ARG]]) : $@convention(objc_method) (Foo) -> Bool
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return [[BOOL]]
+
+// @interface Foo -(void) setZang: (_Bool)b; @end
+func setZang(_ f: Foo, _ b: Bool) {
+ f.setZang(b)
+}
+// CHECK-LABEL: sil hidden @$S13objc_bridging7setZangyySo3FooC_SbtF
+// CHECK: bb0([[ARG0:%.*]] : @guaranteed $Foo, [[ARG1:%.*]] : @trivial $Bool):
+// CHECK: [[METHOD:%.*]] = objc_method [[ARG0]] : $Foo, #Foo.setZang!1.foreign
+// CHECK: apply [[METHOD]]([[ARG1]], [[ARG0]]) : $@convention(objc_method) (Bool, Foo) -> ()
+// CHECK-NOT: destroy_value [[ARG0]]
+// CHECK: } // end sil function '$S13objc_bridging7setZangyySo3FooC_SbtF'
+
+// NSString *bar(void);
+func callBar() -> String {
+ return bar()
+}
+// CHECK-LABEL: sil hidden @$S13objc_bridging7callBar{{.*}}F
+// CHECK: bb0:
+// CHECK: [[BAR:%.*]] = function_ref @bar
+// CHECK: [[OPT_BRIDGED:%.*]] = apply [[BAR]]() : $@convention(c) () -> @autoreleased Optional<NSString>
+// CHECK: switch_enum [[OPT_BRIDGED]] : $Optional<NSString>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+
+// CHECK: [[SOME_BB]]([[BRIDGED:%.*]] : @owned $NSString):
+// CHECK: [[NSSTRING_TO_STRING:%.*]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+// CHECK: [[BRIDGED_BOX:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[BRIDGED]]
+// CHECK: [[NATIVE:%.*]] = apply [[NSSTRING_TO_STRING]]([[BRIDGED_BOX]]
+// CHECK: [[OPT_NATIVE:%.*]] = enum $Optional<String>, #Optional.some!enumelt.1, [[NATIVE]]
+// CHECK: bb5([[NATIVE:%.*]] : @owned $String):
+// CHECK: return [[NATIVE]]
+// CHECK: }
+
+// void setBar(NSString *s);
+func callSetBar(_ s: String) {
+ var s = s
+ setBar(s)
+}
+// CHECK-LABEL: sil hidden @$S13objc_bridging10callSetBar{{.*}}F
+// CHECK: bb0({{%.*}} : @guaranteed $String):
+// CHECK: [[NATIVE:%.*]] = load
+// CHECK: [[STRING_TO_NSSTRING:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+// CHECK: [[BORROWED_NATIVE:%.*]] = begin_borrow [[NATIVE]]
+// CHECK: [[BRIDGED:%.*]] = apply [[STRING_TO_NSSTRING]]([[BORROWED_NATIVE]])
+// CHECK: [[OPT_BRIDGED:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[BRIDGED]]
+// CHECK: end_borrow [[BORROWED_NATIVE]] from [[NATIVE]]
+// CHECK: [[SET_BAR:%.*]] = function_ref @setBar
+// CHECK: apply [[SET_BAR]]([[OPT_BRIDGED]])
+// CHECK: destroy_value [[OPT_BRIDGED]]
+// CHECK: }
+
+var NSS: NSString
+
+// -- NSString methods don't convert 'self'
+extension NSString {
+ var nsstrFakeProp: NSString {
+ get { return NSS }
+ set {}
+ }
+ // CHECK-LABEL: sil hidden [thunk] @$SSo8NSStringC13objc_bridgingE13nsstrFakePropABvgTo
+ // CHECK-NOT: swift_StringToNSString
+ // CHECK-NOT: $SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: }
+ // CHECK-LABEL: sil hidden [thunk] @$SSo8NSStringC13objc_bridgingE13nsstrFakePropABvsTo
+ // CHECK-NOT: swift_StringToNSString
+ // CHECK-NOT: $SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: }
+
+ func nsstrResult() -> NSString { return NSS }
+ // CHECK-LABEL: sil hidden [thunk] @$SSo8NSStringC13objc_bridgingE11nsstrResultAByFTo
+ // CHECK-NOT: swift_StringToNSString
+ // CHECK-NOT: $SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: }
+
+ func nsstrArg(_ s: NSString) { }
+ // CHECK-LABEL: sil hidden [thunk] @$SSo8NSStringC13objc_bridgingE8nsstrArgyyABFTo
+ // CHECK-NOT: swift_StringToNSString
+ // CHECK-NOT: $SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: }
+
+}
+
+class Bas : NSObject {
+ // -- Bridging thunks for String properties convert between NSString
+ var strRealProp: String = "Hello"
+ // CHECK-LABEL: sil hidden [thunk] @$S13objc_bridging3BasC11strRealPropSSvgTo : $@convention(objc_method) (Bas) -> @autoreleased NSString {
+ // CHECK: bb0([[THIS:%.*]] : @unowned $Bas):
+ // CHECK: [[THIS_COPY:%.*]] = copy_value [[THIS]] : $Bas
+ // CHECK: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK: // function_ref objc_bridging.Bas.strRealProp.getter
+ // CHECK: [[PROPIMPL:%.*]] = function_ref @$S13objc_bridging3BasC11strRealPropSSvg
+ // CHECK: [[PROP_COPY:%.*]] = apply [[PROPIMPL]]([[BORROWED_THIS_COPY]]) : $@convention(method) (@guaranteed Bas) -> @owned String
+ // CHECK: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK: destroy_value [[THIS_COPY]]
+ // CHECK: [[STRING_TO_NSSTRING:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+ // CHECK: [[BORROWED_PROP_COPY:%.*]] = begin_borrow [[PROP_COPY]]
+ // CHECK: [[NSSTR:%.*]] = apply [[STRING_TO_NSSTRING]]([[BORROWED_PROP_COPY]])
+ // CHECK: end_borrow [[BORROWED_PROP_COPY]] from [[PROP_COPY]]
+ // CHECK: destroy_value [[PROP_COPY]]
+ // CHECK: return [[NSSTR]]
+ // CHECK: }
+
+
+ // CHECK-LABEL: sil hidden @$S13objc_bridging3BasC11strRealPropSSvg
+ // CHECK: [[PROP_ADDR:%.*]] = ref_element_addr %0 : {{.*}}, #Bas.strRealProp
+ // CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[PROP_ADDR]] : $*String
+ // CHECK: [[PROP:%.*]] = load [copy] [[READ]]
+
+
+ // CHECK-LABEL: sil hidden [thunk] @$S13objc_bridging3BasC11strRealPropSSvsTo : $@convention(objc_method) (NSString, Bas) -> () {
+ // CHECK: bb0([[VALUE:%.*]] : @unowned $NSString, [[THIS:%.*]] : @unowned $Bas):
+ // CHECK: [[VALUE_COPY:%.*]] = copy_value [[VALUE]]
+ // CHECK: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK: [[NSSTRING_TO_STRING:%.*]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: [[VALUE_BOX:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[VALUE_COPY]]
+ // CHECK: [[STR:%.*]] = apply [[NSSTRING_TO_STRING]]([[VALUE_BOX]]
+
+ // CHECK: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK: [[SETIMPL:%.*]] = function_ref @$S13objc_bridging3BasC11strRealPropSSvs
+ // CHECK: apply [[SETIMPL]]([[STR]], [[BORROWED_THIS_COPY]])
+ // CHECK: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK: destroy_value [[THIS_COPY]]
+ // CHECK: } // end sil function '$S13objc_bridging3BasC11strRealPropSSvsTo'
+
+ // CHECK-LABEL: sil hidden @$S13objc_bridging3BasC11strRealPropSSvs
+ // CHECK: bb0(%0 : @owned $String, %1 : @guaranteed $Bas):
+
+ // CHECK: [[STR_ADDR:%.*]] = ref_element_addr %1 : {{.*}}, #Bas.strRealProp
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[STR_ADDR]] : $*String
+ // CHECK: assign {{.*}} to [[WRITE]]
+ // CHECK: }
+
+ var strFakeProp: String {
+ get { return "" }
+ set {}
+ }
+ // CHECK-LABEL: sil hidden [thunk] @$S13objc_bridging3BasC11strFakePropSSvgTo : $@convention(objc_method) (Bas) -> @autoreleased NSString {
+ // CHECK: bb0([[THIS:%.*]] : @unowned $Bas):
+ // CHECK: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK: [[GETTER:%.*]] = function_ref @$S13objc_bridging3BasC11strFakePropSSvg
+ // CHECK: [[STR:%.*]] = apply [[GETTER]]([[BORROWED_THIS_COPY]])
+ // CHECK: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK: destroy_value [[THIS_COPY]]
+ // CHECK: [[STRING_TO_NSSTRING:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+ // CHECK: [[BORROWED_STR:%.*]] = begin_borrow [[STR]]
+ // CHECK: [[NSSTR:%.*]] = apply [[STRING_TO_NSSTRING]]([[BORROWED_STR]])
+ // CHECK: end_borrow [[BORROWED_STR]] from [[STR]]
+ // CHECK: destroy_value [[STR]]
+ // CHECK: return [[NSSTR]]
+ // CHECK: }
+
+ // CHECK-LABEL: sil hidden [thunk] @$S13objc_bridging3BasC11strFakePropSSvsTo : $@convention(objc_method) (NSString, Bas) -> () {
+ // CHECK: bb0([[NSSTR:%.*]] : @unowned $NSString, [[THIS:%.*]] : @unowned $Bas):
+ // CHECK: [[NSSTR_COPY:%.*]] = copy_value [[NSSTR]]
+ // CHECK: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK: [[NSSTRING_TO_STRING:%.*]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: [[NSSTR_BOX:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[NSSTR_COPY]]
+ // CHECK: [[STR:%.*]] = apply [[NSSTRING_TO_STRING]]([[NSSTR_BOX]]
+ // CHECK: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK: [[SETTER:%.*]] = function_ref @$S13objc_bridging3BasC11strFakePropSSvs
+ // CHECK: apply [[SETTER]]([[STR]], [[BORROWED_THIS_COPY]])
+ // CHECK: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK: destroy_value [[THIS_COPY]]
+ // CHECK: } // end sil function '$S13objc_bridging3BasC11strFakePropSSvsTo'
+
+ // -- Bridging thunks for explicitly NSString properties don't convert
+ var nsstrRealProp: NSString
+ var nsstrFakeProp: NSString {
+ get { return NSS }
+ set {}
+ }
+ // CHECK-LABEL: sil hidden [thunk] @$S13objc_bridging3BasC13nsstrRealPropSo8NSStringCvgTo : $@convention(objc_method) (Bas) -> @autoreleased NSString {
+ // CHECK-NOT: swift_StringToNSString
+ // CHECK-NOT: $SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: }
+
+ // CHECK-LABEL: sil hidden [thunk] @$S13objc_bridging3BasC13nsstrRealPropSo8NSStringCvsTo : $@convention(objc_method) (NSString, Bas) ->
+ // CHECK-NOT: swift_StringToNSString
+ // CHECK-NOT: $SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: }
+
+ // -- Bridging thunks for String methods convert between NSString
+ func strResult() -> String { return "" }
+ // CHECK-LABEL: sil hidden [thunk] @$S13objc_bridging3BasC9strResultSSyFTo
+ // CHECK: bb0([[THIS:%.*]] : @unowned $Bas):
+ // CHECK: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK: [[METHOD:%.*]] = function_ref @$S13objc_bridging3BasC9strResultSSyF
+ // CHECK: [[STR:%.*]] = apply [[METHOD]]([[BORROWED_THIS_COPY]])
+ // CHECK: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK: destroy_value [[THIS_COPY]]
+ // CHECK: [[STRING_TO_NSSTRING:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+ // CHECK: [[BORROWED_STR:%.*]] = begin_borrow [[STR]]
+ // CHECK: [[NSSTR:%.*]] = apply [[STRING_TO_NSSTRING]]([[BORROWED_STR]])
+ // CHECK: end_borrow [[BORROWED_STR]] from [[STR]]
+ // CHECK: destroy_value [[STR]]
+ // CHECK: return [[NSSTR]]
+ // CHECK: }
+ func strArg(_ s: String) { }
+ // CHECK-LABEL: sil hidden [thunk] @$S13objc_bridging3BasC6strArgyySSFTo
+ // CHECK: bb0([[NSSTR:%.*]] : @unowned $NSString, [[THIS:%.*]] : @unowned $Bas):
+ // CHECK: [[NSSTR_COPY:%.*]] = copy_value [[NSSTR]]
+ // CHECK: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK: [[NSSTRING_TO_STRING:%.*]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: [[NSSTR_BOX:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[NSSTR_COPY]]
+ // CHECK: [[STR:%.*]] = apply [[NSSTRING_TO_STRING]]([[NSSTR_BOX]]
+ // CHECK: [[BORROWED_STR:%.*]] = begin_borrow [[STR]]
+ // CHECK: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK: [[METHOD:%.*]] = function_ref @$S13objc_bridging3BasC6strArgyySSF
+ // CHECK: apply [[METHOD]]([[BORROWED_STR]], [[BORROWED_THIS_COPY]])
+ // CHECK: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK: destroy_value [[THIS_COPY]]
+ // CHECK: } // end sil function '$S13objc_bridging3BasC6strArgyySSFTo'
+
+ // -- Bridging thunks for explicitly NSString properties don't convert
+ func nsstrResult() -> NSString { return NSS }
+ // CHECK-LABEL: sil hidden [thunk] @$S13objc_bridging3BasC11nsstrResultSo8NSStringCyFTo
+ // CHECK-NOT: swift_StringToNSString
+ // CHECK-NOT: $SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: }
+ func nsstrArg(_ s: NSString) { }
+ // CHECK-LABEL: sil hidden @$S13objc_bridging3BasC8nsstrArgyySo8NSStringCF
+ // CHECK-NOT: swift_StringToNSString
+ // CHECK-NOT: $SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: }
+
+ init(str: NSString) {
+ nsstrRealProp = str
+ super.init()
+ }
+
+ // CHECK-LABEL: sil hidden [thunk] @$S13objc_bridging3BasC8arrayArgyySayyXlGFTo : $@convention(objc_method) (NSArray, Bas) -> ()
+ // CHECK: bb0([[NSARRAY:%[0-9]+]] : @unowned $NSArray, [[SELF:%[0-9]+]] : @unowned $Bas):
+ // CHECK: [[NSARRAY_COPY:%.*]] = copy_value [[NSARRAY]] : $NSArray
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $Bas
+ // CHECK: [[CONV_FN:%[0-9]+]] = function_ref @$SSa10FoundationE36_unconditionallyBridgeFromObjectiveCySayxGSo7NSArrayCSgFZ
+ // CHECK: [[OPT_NSARRAY:%[0-9]+]] = enum $Optional<NSArray>, #Optional.some!enumelt.1, [[NSARRAY_COPY]] : $NSArray
+ // CHECK: [[ARRAY_META:%[0-9]+]] = metatype $@thin Array<AnyObject>.Type
+ // CHECK: [[ARRAY:%[0-9]+]] = apply [[CONV_FN]]<AnyObject>([[OPT_NSARRAY]], [[ARRAY_META]])
+ // CHECK: [[BORROWED_ARRAY:%.*]] = begin_borrow [[ARRAY]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[SWIFT_FN:%[0-9]+]] = function_ref @$S13objc_bridging3BasC8arrayArgyySayyXlGF : $@convention(method) (@guaranteed Array<AnyObject>, @guaranteed Bas) -> ()
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[SWIFT_FN]]([[BORROWED_ARRAY]], [[BORROWED_SELF_COPY]]) : $@convention(method) (@guaranteed Array<AnyObject>, @guaranteed Bas) -> ()
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]] : $Bas
+ // CHECK: return [[RESULT]] : $()
+ func arrayArg(_ array: [AnyObject]) { }
+
+ // CHECK-LABEL: sil hidden [thunk] @$S13objc_bridging3BasC11arrayResultSayyXlGyFTo : $@convention(objc_method) (Bas) -> @autoreleased NSArray
+ // CHECK: bb0([[SELF:%[0-9]+]] : @unowned $Bas):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $Bas
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[SWIFT_FN:%[0-9]+]] = function_ref @$S13objc_bridging3BasC11arrayResultSayyXlGyF : $@convention(method) (@guaranteed Bas) -> @owned Array<AnyObject>
+ // CHECK: [[ARRAY:%[0-9]+]] = apply [[SWIFT_FN]]([[BORROWED_SELF_COPY]]) : $@convention(method) (@guaranteed Bas) -> @owned Array<AnyObject>
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK: [[CONV_FN:%[0-9]+]] = function_ref @$SSa10FoundationE19_bridgeToObjectiveCSo7NSArrayCyF
+ // CHECK: [[BORROWED_ARRAY:%.*]] = begin_borrow [[ARRAY]]
+ // CHECK: [[NSARRAY:%[0-9]+]] = apply [[CONV_FN]]<AnyObject>([[BORROWED_ARRAY]]) : $@convention(method) <τ_0_0> (@guaranteed Array<τ_0_0>) -> @owned NSArray
+ // CHECK: end_borrow [[BORROWED_ARRAY]] from [[ARRAY]]
+ // CHECK: destroy_value [[ARRAY]]
+ // CHECK: return [[NSARRAY]]
+ func arrayResult() -> [AnyObject] { return [] }
+
+ // CHECK-LABEL: sil hidden [thunk] @$S13objc_bridging3BasC9arrayPropSaySSGvgTo : $@convention(objc_method) (Bas) -> @autoreleased NSArray
+ // CHECK-LABEL: sil hidden [thunk] @$S13objc_bridging3BasC9arrayPropSaySSGvsTo : $@convention(objc_method) (NSArray, Bas) -> ()
+ var arrayProp: [String] = []
+}
+
+// CHECK-LABEL: sil hidden @$S13objc_bridging16applyStringBlock_1xS3SXB_SStF
+func applyStringBlock(_ f: @convention(block) (String) -> String, x: String) -> String {
+ // CHECK: bb0([[BLOCK:%.*]] : @guaranteed $@convention(block) @noescape (NSString) -> @autoreleased NSString, [[STRING:%.*]] : @guaranteed $String):
+ // CHECK: [[BLOCK_COPY:%.*]] = copy_block [[BLOCK]]
+ // CHECK: [[BORROWED_BLOCK_COPY:%.*]] = begin_borrow [[BLOCK_COPY]]
+ // CHECK: [[BLOCK_COPY_COPY:%.*]] = copy_value [[BORROWED_BLOCK_COPY]]
+ // CHECK: [[STRING_COPY:%.*]] = copy_value [[STRING]]
+ // CHECK: [[STRING_TO_NSSTRING:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+ // CHECK: [[BORROWED_STRING_COPY:%.*]] = begin_borrow [[STRING_COPY]]
+ // CHECK: [[NSSTR:%.*]] = apply [[STRING_TO_NSSTRING]]([[BORROWED_STRING_COPY]]) : $@convention(method) (@guaranteed String)
+ // CHECK: end_borrow [[BORROWED_STRING_COPY]] from [[STRING_COPY]]
+ // CHECK: destroy_value [[STRING_COPY]]
+ // CHECK: [[RESULT_NSSTR:%.*]] = apply [[BLOCK_COPY_COPY]]([[NSSTR]]) : $@convention(block) @noescape (NSString) -> @autoreleased NSString
+ // CHECK: destroy_value [[NSSTR]]
+ // CHECK: [[FINAL_BRIDGE:%.*]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: [[OPTIONAL_NSSTR:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[RESULT_NSSTR]]
+ // CHECK: [[RESULT:%.*]] = apply [[FINAL_BRIDGE]]([[OPTIONAL_NSSTR]], {{.*}}) : $@convention(method) (@guaranteed Optional<NSString>, @thin String.Type) -> @owned String
+ // CHECK: destroy_value [[BLOCK_COPY_COPY]]
+ // CHECK-NOT: destroy_value [[STRING]]
+ // CHECK: destroy_value [[BLOCK_COPY]]
+ // CHECK-NOT: destroy_value [[BLOCK]]
+ // CHECK: return [[RESULT]] : $String
+ return f(x)
+}
+// CHECK: } // end sil function '$S13objc_bridging16applyStringBlock_1xS3SXB_SStF'
+
+// CHECK-LABEL: sil hidden @$S13objc_bridging15bridgeCFunction{{.*}}F
+func bridgeCFunction() -> (String?) -> (String?) {
+ // CHECK: [[THUNK:%.*]] = function_ref @$SSo18NSStringFromStringySSSgABFTO : $@convention(thin) (@guaranteed Optional<String>) -> @owned Optional<String>
+ // CHECK: [[THICK:%.*]] = thin_to_thick_function [[THUNK]]
+ // CHECK: return [[THICK]]
+ return NSStringFromString
+}
+
+func forceNSArrayMembers() -> (NSArray, NSArray) {
+ let x = NSArray(objects: nil, count: 0)
+ return (x, x)
+}
+
+// Check that the allocating initializer shim for initializers that take pointer
+// arguments lifetime-extends the bridged pointer for the right duration.
+// <rdar://problem/16738050>
+
+// CHECK-LABEL: sil shared [serializable] @$SSo7NSArrayC7objects5countABSPyyXlSgGSg_s5Int32VtcfC
+// CHECK: [[SELF:%.*]] = alloc_ref_dynamic
+// CHECK: [[METHOD:%.*]] = function_ref @$SSo7NSArrayC7objects5countABSPyyXlSgGSg_s5Int32VtcfcTO
+// CHECK: [[RESULT:%.*]] = apply [[METHOD]]
+// CHECK: return [[RESULT]]
+
+// Check that type lowering preserves the bool/BOOL distinction when bridging
+// imported C functions.
+
+// CHECK-ios-i386-LABEL: sil hidden @$S13objc_bridging5boolsySb_SbtSbF
+// CHECK-ios-i386: function_ref @useBOOL : $@convention(c) (ObjCBool) -> ()
+// CHECK-ios-i386: function_ref @useBool : $@convention(c) (Bool) -> ()
+// CHECK-ios-i386: function_ref @getBOOL : $@convention(c) () -> ObjCBool
+// CHECK-ios-i386: function_ref @getBool : $@convention(c) () -> Bool
+
+// CHECK-macosx-x86_64-LABEL: sil hidden @$S13objc_bridging5boolsySb_SbtSbF
+// CHECK-macosx-x86_64: function_ref @useBOOL : $@convention(c) (ObjCBool) -> ()
+// CHECK-macosx-x86_64: function_ref @useBool : $@convention(c) (Bool) -> ()
+// CHECK-macosx-x86_64: function_ref @getBOOL : $@convention(c) () -> ObjCBool
+// CHECK-macosx-x86_64: function_ref @getBool : $@convention(c) () -> Bool
+
+// FIXME: no distinction on x86_64, arm64 or watchos-i386, since SILGen looks
+// at the underlying Clang decl of the bridged decl to decide whether it needs
+// bridging.
+//
+// CHECK-watchos-i386-LABEL: sil hidden @$S13objc_bridging5boolsySb_SbtSbF
+// CHECK-watchos-i386: function_ref @useBOOL : $@convention(c) (Bool) -> ()
+// CHECK-watchos-i386: function_ref @useBool : $@convention(c) (Bool) -> ()
+// CHECK-watchos-i386: function_ref @getBOOL : $@convention(c) () -> Bool
+// CHECK-watchos-i386: function_ref @getBool : $@convention(c) () -> Bool
+
+// CHECK-ios-x86_64-LABEL: sil hidden @$S13objc_bridging5boolsySb_SbtSbF
+// CHECK-ios-x86_64: function_ref @useBOOL : $@convention(c) (Bool) -> ()
+// CHECK-ios-x86_64: function_ref @useBool : $@convention(c) (Bool) -> ()
+// CHECK-ios-x86_64: function_ref @getBOOL : $@convention(c) () -> Bool
+// CHECK-ios-x86_64: function_ref @getBool : $@convention(c) () -> Bool
+
+// CHECK-arm64-LABEL: sil hidden @$S13objc_bridging5boolsySb_SbtSbF
+// CHECK-arm64: function_ref @useBOOL : $@convention(c) (Bool) -> ()
+// CHECK-arm64: function_ref @useBool : $@convention(c) (Bool) -> ()
+// CHECK-arm64: function_ref @getBOOL : $@convention(c) () -> Bool
+// CHECK-arm64: function_ref @getBool : $@convention(c) () -> Bool
+
+func bools(_ x: Bool) -> (Bool, Bool) {
+ useBOOL(x)
+ useBool(x)
+
+ return (getBOOL(), getBool())
+}
+
+// CHECK-LABEL: sil hidden @$S13objc_bridging9getFridge{{.*}}F
+// CHECK: bb0([[HOME:%[0-9]+]] : @guaranteed $APPHouse):
+func getFridge(_ home: APPHouse) -> Refrigerator {
+ // CHECK: [[GETTER:%[0-9]+]] = objc_method [[HOME]] : $APPHouse, #APPHouse.fridge!getter.1.foreign
+ // CHECK: [[OBJC_RESULT:%[0-9]+]] = apply [[GETTER]]([[HOME]])
+ // CHECK: [[BRIDGE_FN:%[0-9]+]] = function_ref @$S10Appliances12RefrigeratorV36_unconditionallyBridgeFromObjectiveCyACSo15APPRefrigeratorCSgFZ
+ // CHECK: [[REFRIGERATOR_META:%[0-9]+]] = metatype $@thin Refrigerator.Type
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[BRIDGE_FN]]([[OBJC_RESULT]], [[REFRIGERATOR_META]])
+ // CHECK-NOT: destroy_value [[HOME]] : $APPHouse
+ // CHECK: return [[RESULT]] : $Refrigerator
+ return home.fridge
+}
+
+// FIXME(integers): the following checks should be updated for the new integer
+// protocols. <rdar://problem/29939484>
+// XCHECK-LABEL: sil hidden @$S13objc_bridging16updateFridgeTemp{{.*}}F
+// XCHECK: bb0([[HOME:%[0-9]+]] : $APPHouse, [[DELTA:%[0-9]+]] : $Double):
+func updateFridgeTemp(_ home: APPHouse, delta: Double) {
+ // +=
+ // XCHECK: [[PLUS_EQ:%[0-9]+]] = function_ref @$Ss2peoiyySdz_SdtF
+
+ // Temporary fridge
+ // XCHECK: [[TEMP_FRIDGE:%[0-9]+]] = alloc_stack $Refrigerator
+
+ // Get operation
+ // CHECK: [[GETTER:%[0-9]+]] = objc_method [[HOME]] : $APPHouse, #APPHouse.fridge!getter.1.foreign
+ // CHECK: [[OBJC_FRIDGE:%[0-9]+]] = apply [[GETTER]]([[HOME]])
+ // CHECK: [[BRIDGE_FROM_FN:%[0-9]+]] = function_ref @$S10Appliances12RefrigeratorV36_unconditionallyBridgeFromObjectiveCyACSo15APPRefrigeratorCSgFZ
+ // CHECK: [[REFRIGERATOR_META:%[0-9]+]] = metatype $@thin Refrigerator.Type
+ // CHECK: [[FRIDGE:%[0-9]+]] = apply [[BRIDGE_FROM_FN]]([[OBJC_FRIDGE]], [[REFRIGERATOR_META]])
+
+ // Addition
+ // XCHECK: [[TEMP:%[0-9]+]] = struct_element_addr [[TEMP_FRIDGE]] : $*Refrigerator, #Refrigerator.temperature
+ // XCHECK: apply [[PLUS_EQ]]([[TEMP]], [[DELTA]])
+
+ // Setter
+ // XCHECK: [[FRIDGE:%[0-9]+]] = load [trivial] [[TEMP_FRIDGE]] : $*Refrigerator
+ // XCHECK: [[SETTER:%[0-9]+]] = objc_method [[BORROWED_HOME]] : $APPHouse, #APPHouse.fridge!setter.1.foreign
+ // XCHECK: [[BRIDGE_TO_FN:%[0-9]+]] = function_ref @$S10Appliances12RefrigeratorV19_bridgeToObjectiveCSo15APPRefrigeratorCyF
+ // XCHECK: [[OBJC_ARG:%[0-9]+]] = apply [[BRIDGE_TO_FN]]([[FRIDGE]])
+ // XCHECK: apply [[SETTER]]([[OBJC_ARG]], [[BORROWED_HOME]]) : $@convention(objc_method) (APPRefrigerator, APPHouse) -> ()
+ // XCHECK: destroy_value [[OBJC_ARG]]
+ // XCHECK: end_borrow [[BORROWED_HOME]] from [[HOME]]
+ // XCHECK: destroy_value [[HOME]]
+ home.fridge.temperature += delta
+}
+
+// CHECK-LABEL: sil hidden @$S13objc_bridging20callNonStandardBlock5valueySi_tF
+func callNonStandardBlock(value: Int) {
+ // CHECK: enum $Optional<@convention(block) () -> @owned Optional<AnyObject>>
+ takesNonStandardBlock { return value }
+}
+
+func takeTwoAnys(_ lhs: Any, _ rhs: Any) -> Any { return lhs }
+
+// CHECK-LABEL: sil hidden @$S13objc_bridging22defineNonStandardBlock1xyyp_tF
+func defineNonStandardBlock(x: Any) {
+ // CHECK: function_ref @$S13objc_bridging22defineNonStandardBlock1xyyp_tFypypcfU_
+ // CHECK: function_ref @$SypypIegnr_yXlyXlIeyBya_TR : $@convention(c) (@inout_aliasable @block_storage @callee_guaranteed (@in_guaranteed Any) -> @out Any, AnyObject) -> @autoreleased AnyObject
+
+ let fn : @convention(block) (Any) -> Any = { y in takeTwoAnys(x, y) }
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SypypIegnr_yXlyXlIeyBya_TR : $@convention(c) (@inout_aliasable @block_storage @callee_guaranteed (@in_guaranteed Any) -> @out Any, AnyObject) -> @autoreleased AnyObject
+// CHECK: bb0(%0 : @trivial $*@block_storage @callee_guaranteed (@in_guaranteed Any) -> @out Any, %1 : @unowned $AnyObject):
+// CHECK: [[T0:%.*]] = copy_value %1 : $AnyObject
+// CHECK: [[T1:%.*]] = open_existential_ref [[T0]] : $AnyObject
+// CHECK: [[ARG:%.*]] = alloc_stack $Any
+// CHECK: [[T2:%.*]] = init_existential_addr [[ARG]]
+// CHECK: store [[T1]] to [init] [[T2]]
+// CHECK: [[RESULT:%.*]] = alloc_stack $Any
+// CHECK: apply {{.*}}([[RESULT]], [[ARG]])
+
+// CHECK-LABEL: sil hidden @$S13objc_bridging15castToCFunction3ptrySV_tF : $@convention(thin) (UnsafeRawPointer) -> () {
+func castToCFunction(ptr: UnsafeRawPointer) {
+ // CHECK: [[OUT:%.*]] = alloc_stack $@convention(c) (Optional<AnyObject>) -> ()
+ // CHECK: [[IN:%.]] = alloc_stack $UnsafeRawPointer
+ // CHECK: store %0 to [trivial] [[IN]] : $*UnsafeRawPointer
+ // CHECK: [[META:%.*]] = metatype $@thick (@convention(c) (Optional<AnyObject>) -> ()).Type
+ // CHECK: [[CASTFN:%.*]] = function_ref @$Ss13unsafeBitCast_2toq_x_q_mtr0_lF
+ // CHECK: apply [[CASTFN]]<UnsafeRawPointer, @convention(c) (AnyObject?) -> ()>([[OUT]], [[IN]], [[META]]) : $@convention(thin) <τ_0_0, τ_0_1> (@in_guaranteed τ_0_0, @thick τ_0_1.Type) -> @out τ_0_1
+ // CHECK: [[RESULT:%.*]] = load [trivial] [[OUT]] : $*@convention(c) (Optional<AnyObject>) -> ()
+ typealias Fn = @convention(c) (AnyObject?) -> Void
+ unsafeBitCast(ptr, to: Fn.self)(nil)
+}
diff --git a/test/SILGen/plus_zero_objc_bridging_any.swift b/test/SILGen/plus_zero_objc_bridging_any.swift
new file mode 100644
index 0000000..6e994ee
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_bridging_any.swift
@@ -0,0 +1,692 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -Xllvm -sil-print-debuginfo -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+// REQUIRES: objc_interop
+
+import Foundation
+import objc_generics
+
+protocol P {}
+protocol CP: class {}
+
+struct KnownUnbridged {}
+
+// CHECK-LABEL: sil hidden @$S17objc_bridging_any11passingToId{{.*}}F
+func passingToId<T: CP, U>(receiver: NSIdLover,
+ string: String,
+ nsString: NSString,
+ object: AnyObject,
+ classGeneric: T,
+ classExistential: CP,
+ generic: U,
+ existential: P,
+ error: Error,
+ any: Any,
+ knownUnbridged: KnownUnbridged,
+ optionalA: String?,
+ optionalB: NSString?,
+ optionalC: Any?) {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $NSIdLover,
+ // CHECK: debug_value [[STRING:%.*]] : $String
+ // CHECK: debug_value [[NSSTRING:%.*]] : $NSString
+ // CHECK: debug_value [[OBJECT:%.*]] : $AnyObject
+ // CHECK: debug_value [[CLASS_GENERIC:%.*]] : $T
+ // CHECK: debug_value [[CLASS_EXISTENTIAL:%.*]] : $CP
+ // CHECK: debug_value_addr [[GENERIC:%.*]] : $*U
+ // CHECK: debug_value_addr [[EXISTENTIAL:%.*]] : $*P
+ // CHECK: debug_value [[ERROR:%.*]] : $Error
+ // CHECK: debug_value_addr [[ANY:%.*]] : $*Any
+ // CHECK: debug_value [[KNOWN_UNBRIDGED:%.*]] : $KnownUnbridged
+ // CHECK: debug_value [[OPT_STRING:%.*]] : $Optional<String>
+ // CHECK: debug_value [[OPT_NSSTRING:%.*]] : $Optional<NSString>
+ // CHECK: debug_value_addr [[OPT_ANY:%.*]] : $*Optional<Any>
+
+ // CHECK: [[STRING_COPY:%.*]] = copy_value [[STRING]]
+ // CHECK: [[BRIDGE_STRING:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+ // CHECK: [[BORROWED_STRING_COPY:%.*]] = begin_borrow [[STRING_COPY]]
+ // CHECK: [[BRIDGED:%.*]] = apply [[BRIDGE_STRING]]([[BORROWED_STRING_COPY]])
+ // CHECK: [[ANYOBJECT:%.*]] = init_existential_ref [[BRIDGED]] : $NSString : $NSString, $AnyObject
+ // CHECK: end_borrow [[BORROWED_STRING_COPY]] from [[STRING_COPY]]
+ // CHECK: destroy_value [[STRING_COPY]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]]
+ // CHECK: apply [[METHOD]]([[ANYOBJECT]], [[SELF]])
+ // CHECK: destroy_value [[ANYOBJECT]]
+ receiver.takesId(string)
+
+ // CHECK: [[NSSTRING_COPY:%.*]] = copy_value [[NSSTRING]]
+ // CHECK: [[ANYOBJECT:%.*]] = init_existential_ref [[NSSTRING_COPY]] : $NSString : $NSString, $AnyObject
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[ANYOBJECT]], [[SELF]])
+ // CHECK: destroy_value [[ANYOBJECT]]
+ receiver.takesId(nsString)
+
+ // CHECK: [[CLASS_GENERIC_COPY:%.*]] = copy_value [[CLASS_GENERIC]]
+ // CHECK: [[ANYOBJECT:%.*]] = init_existential_ref [[CLASS_GENERIC_COPY]] : $T : $T, $AnyObject
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[ANYOBJECT]], [[SELF]])
+ // CHECK: destroy_value [[ANYOBJECT]]
+ receiver.takesId(classGeneric)
+
+ // CHECK: [[OBJECT_COPY:%.*]] = copy_value [[OBJECT]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[OBJECT_COPY]], [[SELF]])
+ // CHECK: destroy_value [[OBJECT_COPY]]
+ receiver.takesId(object)
+
+ // CHECK: [[CLASS_EXISTENTIAL_COPY:%.*]] = copy_value [[CLASS_EXISTENTIAL]]
+ // CHECK: [[OPENED:%.*]] = open_existential_ref [[CLASS_EXISTENTIAL_COPY]] : $CP
+ // CHECK: [[ANYOBJECT:%.*]] = init_existential_ref [[OPENED]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[ANYOBJECT]], [[SELF]])
+ // CHECK: destroy_value [[ANYOBJECT]]
+ receiver.takesId(classExistential)
+
+ // These cases perform a universal bridging conversion.
+
+ // CHECK: [[COPY:%.*]] = alloc_stack $U
+ // CHECK: copy_addr [[GENERIC]] to [initialization] [[COPY]]
+ // CHECK: // function_ref _bridgeAnythingToObjectiveC
+ // CHECK: [[BRIDGE_ANYTHING:%.*]] = function_ref
+ // CHECK: [[ANYOBJECT:%.*]] = apply [[BRIDGE_ANYTHING]]<U>([[COPY]])
+ // CHECK: dealloc_stack [[COPY]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[ANYOBJECT]], [[SELF]])
+ // CHECK: destroy_value [[ANYOBJECT]]
+ receiver.takesId(generic)
+
+ // CHECK: [[COPY:%.*]] = alloc_stack $P
+ // CHECK: copy_addr [[EXISTENTIAL]] to [initialization] [[COPY]]
+ // CHECK: [[OPENED_COPY:%.*]] = open_existential_addr immutable_access [[COPY]] : $*P to $*[[OPENED_TYPE:@opened.*P]],
+ // CHECK: [[TMP:%.*]] = alloc_stack $[[OPENED_TYPE]]
+ // CHECK: copy_addr [[OPENED_COPY]] to [initialization] [[TMP]]
+ // CHECK: // function_ref _bridgeAnythingToObjectiveC
+ // CHECK: [[BRIDGE_ANYTHING:%.*]] = function_ref
+ // CHECK: [[ANYOBJECT:%.*]] = apply [[BRIDGE_ANYTHING]]<[[OPENED_TYPE]]>([[TMP]])
+ // CHECK: dealloc_stack [[TMP]]
+ // CHECK: destroy_addr [[COPY]]
+ // CHECK: dealloc_stack [[COPY]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[ANYOBJECT]], [[SELF]])
+ // CHECK: destroy_value [[ANYOBJECT]]
+ receiver.takesId(existential)
+
+ // CHECK: [[ERROR_COPY:%.*]] = copy_value [[ERROR]] : $Error
+ // CHECK: [[ERROR_BOX:%[0-9]+]] = open_existential_box [[ERROR_COPY]] : $Error to $*@opened([[ERROR_ARCHETYPE:"[^"]*"]]) Error
+ // CHECK: [[ERROR_STACK:%[0-9]+]] = alloc_stack $@opened([[ERROR_ARCHETYPE]]) Error
+ // CHECK: copy_addr [[ERROR_BOX]] to [initialization] [[ERROR_STACK]] : $*@opened([[ERROR_ARCHETYPE]]) Error
+ // CHECK: [[BRIDGE_FUNCTION:%[0-9]+]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK: [[BRIDGED_ERROR:%[0-9]+]] = apply [[BRIDGE_FUNCTION]]<@opened([[ERROR_ARCHETYPE]]) Error>([[ERROR_STACK]])
+ // CHECK: dealloc_stack [[ERROR_STACK]] : $*@opened([[ERROR_ARCHETYPE]]) Error
+ // CHECK: destroy_value [[ERROR_COPY]] : $Error
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[BRIDGED_ERROR]], [[SELF]])
+ // CHECK: destroy_value [[BRIDGED_ERROR]] : $AnyObject
+ receiver.takesId(error)
+
+ // CHECK: [[COPY:%.*]] = alloc_stack $Any
+ // CHECK: copy_addr [[ANY]] to [initialization] [[COPY]]
+ // CHECK: [[OPENED_COPY:%.*]] = open_existential_addr immutable_access [[COPY]] : $*Any to $*[[OPENED_TYPE:@opened.*Any]],
+ // CHECK: [[TMP:%.*]] = alloc_stack $[[OPENED_TYPE]]
+ // CHECK: copy_addr [[OPENED_COPY]] to [initialization] [[TMP]]
+ // CHECK: // function_ref _bridgeAnythingToObjectiveC
+ // CHECK: [[BRIDGE_ANYTHING:%.*]] = function_ref
+ // CHECK: [[ANYOBJECT:%.*]] = apply [[BRIDGE_ANYTHING]]<[[OPENED_TYPE]]>([[TMP]])
+ // CHECK: destroy_addr [[COPY]]
+ // CHECK: dealloc_stack [[COPY]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[ANYOBJECT]], [[SELF]])
+ // CHECK: destroy_value [[ANYOBJECT]]
+ receiver.takesId(any)
+
+ // CHECK: [[TMP:%.*]] = alloc_stack $KnownUnbridged
+ // CHECK: store [[KNOWN_UNBRIDGED]] to [trivial] [[TMP]]
+ // CHECK: [[BRIDGE_ANYTHING:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveC{{.*}}F
+ // CHECK: [[ANYOBJECT:%.*]] = apply [[BRIDGE_ANYTHING]]<KnownUnbridged>([[TMP]])
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[ANYOBJECT]], [[SELF]])
+ receiver.takesId(knownUnbridged)
+
+ // These cases bridge using Optional's _ObjectiveCBridgeable conformance.
+
+ // CHECK: [[OPT_STRING_COPY:%.*]] = copy_value [[OPT_STRING]]
+ // CHECK: [[BRIDGE_OPTIONAL:%.*]] = function_ref @$SSq19_bridgeToObjectiveCyXlyF
+ // CHECK: [[TMP:%.*]] = alloc_stack $Optional<String>
+ // CHECK: [[BORROWED_OPT_STRING_COPY:%.*]] = begin_borrow [[OPT_STRING_COPY]]
+ // CHECK: store_borrow [[BORROWED_OPT_STRING_COPY]] to [[TMP]]
+ // CHECK: [[ANYOBJECT:%.*]] = apply [[BRIDGE_OPTIONAL]]<String>([[TMP]])
+ // CHECK: end_borrow [[BORROWED_OPT_STRING_COPY]] from [[OPT_STRING_COPY]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[ANYOBJECT]], [[SELF]])
+ receiver.takesId(optionalA)
+
+ // CHECK: [[OPT_NSSTRING_COPY:%.*]] = copy_value [[OPT_NSSTRING]]
+ // CHECK: [[BRIDGE_OPTIONAL:%.*]] = function_ref @$SSq19_bridgeToObjectiveCyXlyF
+ // CHECK: [[TMP:%.*]] = alloc_stack $Optional<NSString>
+ // CHECK: [[BORROWED_OPT_NSSTRING_COPY:%.*]] = begin_borrow [[OPT_NSSTRING_COPY]]
+ // CHECK: store_borrow [[BORROWED_OPT_NSSTRING_COPY]] to [[TMP]]
+ // CHECK: [[ANYOBJECT:%.*]] = apply [[BRIDGE_OPTIONAL]]<NSString>([[TMP]])
+ // CHECK: end_borrow [[BORROWED_OPT_NSSTRING_COPY]] from [[OPT_NSSTRING]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[ANYOBJECT]], [[SELF]])
+ receiver.takesId(optionalB)
+
+ // CHECK: [[TMP:%.*]] = alloc_stack $Optional<Any>
+ // CHECK: copy_addr [[OPT_ANY]] to [initialization] [[TMP]]
+ // CHECK: [[BRIDGE_OPTIONAL:%.*]] = function_ref @$SSq19_bridgeToObjectiveCyXlyF
+ // CHECK: [[ANYOBJECT:%.*]] = apply [[BRIDGE_OPTIONAL]]<Any>([[TMP]])
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[ANYOBJECT]], [[SELF]])
+ receiver.takesId(optionalC)
+
+ // TODO: Property and subscript setters
+}
+
+// Once upon a time, as a workaround for rdar://problem/28318984, we had
+// to skip the peephole for types with nontrivial SIL lowerings because we
+// didn't correctly form the substitutions for a generic
+// _bridgeAnythingToObjectiveC call. That's not true anymore.
+func zim() {}
+struct Zang {}
+// CHECK-LABEL: sil hidden @$S17objc_bridging_any27typesWithNontrivialLowering8receiverySo9NSIdLoverC_tF
+func typesWithNontrivialLowering(receiver: NSIdLover) {
+ // CHECK: apply {{.*}}<() -> ()>
+ receiver.takesId(zim)
+ // CHECK: apply {{.*}}<Zang.Type>
+ receiver.takesId(Zang.self)
+ // CHECK: apply {{.*}}<(() -> (), Zang.Type)>
+ receiver.takesId((zim, Zang.self))
+ // CHECK: apply {{%.*}}<(Int, String)>
+ receiver.takesId((0, "one"))
+}
+
+// CHECK-LABEL: sil hidden @$S17objc_bridging_any19passingToNullableId{{.*}}F
+func passingToNullableId<T: CP, U>(receiver: NSIdLover,
+ string: String,
+ nsString: NSString,
+ object: AnyObject,
+ classGeneric: T,
+ classExistential: CP,
+ generic: U,
+ existential: P,
+ error: Error,
+ any: Any,
+ knownUnbridged: KnownUnbridged,
+ optString: String?,
+ optNSString: NSString?,
+ optObject: AnyObject?,
+ optClassGeneric: T?,
+ optClassExistential: CP?,
+ optGeneric: U?,
+ optExistential: P?,
+ optAny: Any?,
+ optKnownUnbridged: KnownUnbridged?,
+ optOptA: String??,
+ optOptB: NSString??,
+ optOptC: Any??)
+{
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $NSIdLover,
+ // CHECK: [[STRING:%.*]] : $String,
+ // CHECK: [[NSSTRING:%.*]] : $NSString
+ // CHECK: [[OBJECT:%.*]] : $AnyObject
+ // CHECK: [[CLASS_GENERIC:%.*]] : $T
+ // CHECK: [[CLASS_EXISTENTIAL:%.*]] : $CP
+ // CHECK: [[GENERIC:%.*]] : $*U
+ // CHECK: [[EXISTENTIAL:%.*]] : $*P
+ // CHECK: [[ERROR:%.*]] : $Error
+ // CHECK: [[ANY:%.*]] : $*Any,
+ // CHECK: [[KNOWN_UNBRIDGED:%.*]] : $KnownUnbridged,
+ // CHECK: [[OPT_STRING:%.*]] : $Optional<String>,
+ // CHECK: [[OPT_NSSTRING:%.*]] : $Optional<NSString>
+ // CHECK: [[OPT_OBJECT:%.*]] : $Optional<AnyObject>
+ // CHECK: [[OPT_CLASS_GENERIC:%.*]] : $Optional<T>
+ // CHECK: [[OPT_CLASS_EXISTENTIAL:%.*]] : $Optional<CP>
+ // CHECK: [[OPT_GENERIC:%.*]] : $*Optional<U>
+ // CHECK: [[OPT_EXISTENTIAL:%.*]] : $*Optional<P>
+ // CHECK: [[OPT_ANY:%.*]] : $*Optional<Any>
+ // CHECK: [[OPT_KNOWN_UNBRIDGED:%.*]] : $Optional<KnownUnbridged>
+ // CHECK: [[OPT_OPT_A:%.*]] : $Optional<Optional<String>>
+ // CHECK: [[OPT_OPT_B:%.*]] : $Optional<Optional<NSString>>
+ // CHECK: [[OPT_OPT_C:%.*]] : $*Optional<Optional<Any>>
+
+ // CHECK: [[STRING_COPY:%.*]] = copy_value [[STRING]]
+ // CHECK: [[BRIDGE_STRING:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+ // CHECK: [[BORROWED_STRING_COPY:%.*]] = begin_borrow [[STRING_COPY]]
+ // CHECK: [[BRIDGED:%.*]] = apply [[BRIDGE_STRING]]([[BORROWED_STRING_COPY]])
+ // CHECK: [[ANYOBJECT:%.*]] = init_existential_ref [[BRIDGED]] : $NSString : $NSString, $AnyObject
+ // CHECK: [[OPT_ANYOBJECT:%.*]] = enum {{.*}} [[ANYOBJECT]]
+ // CHECK: end_borrow [[BORROWED_STRING_COPY]] from [[STRING_COPY]]
+ // CHECK: destroy_value [[STRING_COPY]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]]
+ // CHECK: apply [[METHOD]]([[OPT_ANYOBJECT]], [[SELF]])
+ // CHECK: destroy_value [[OPT_ANYOBJECT]]
+ receiver.takesNullableId(string)
+
+ // CHECK: [[NSSTRING_COPY:%.*]] = copy_value [[NSSTRING]]
+ // CHECK: [[ANYOBJECT:%.*]] = init_existential_ref [[NSSTRING_COPY]] : $NSString : $NSString, $AnyObject
+ // CHECK: [[OPT_ANYOBJECT:%.*]] = enum {{.*}} [[ANYOBJECT]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[OPT_ANYOBJECT]], [[SELF]])
+ receiver.takesNullableId(nsString)
+
+ // CHECK: [[OBJECT_COPY:%.*]] = copy_value [[OBJECT]]
+ // CHECK: [[OPT_ANYOBJECT:%.*]] = enum {{.*}} [[OBJECT_COPY]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[OPT_ANYOBJECT]], [[SELF]])
+ receiver.takesNullableId(object)
+
+ // CHECK: [[CLASS_GENERIC_COPY:%.*]] = copy_value [[CLASS_GENERIC]]
+ // CHECK: [[ANYOBJECT:%.*]] = init_existential_ref [[CLASS_GENERIC_COPY]] : $T : $T, $AnyObject
+ // CHECK: [[OPT_ANYOBJECT:%.*]] = enum {{.*}} [[ANYOBJECT]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[OPT_ANYOBJECT]], [[SELF]])
+ receiver.takesNullableId(classGeneric)
+
+ // CHECK: [[CLASS_EXISTENTIAL_COPY:%.*]] = copy_value [[CLASS_EXISTENTIAL]]
+ // CHECK: [[OPENED:%.*]] = open_existential_ref [[CLASS_EXISTENTIAL_COPY]] : $CP
+ // CHECK: [[ANYOBJECT:%.*]] = init_existential_ref [[OPENED]]
+ // CHECK: [[OPT_ANYOBJECT:%.*]] = enum {{.*}} [[ANYOBJECT]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[OPT_ANYOBJECT]], [[SELF]])
+ // CHECK: destroy_value [[OPT_ANYOBJECT]]
+ receiver.takesNullableId(classExistential)
+
+ // CHECK-NEXT: [[COPY:%.*]] = alloc_stack $U
+ // CHECK-NEXT: copy_addr [[GENERIC]] to [initialization] [[COPY]]
+ // CHECK-NEXT: // function_ref _bridgeAnythingToObjectiveC
+ // CHECK-NEXT: [[BRIDGE_ANYTHING:%.*]] = function_ref
+ // CHECK-NEXT: [[ANYOBJECT:%.*]] = apply [[BRIDGE_ANYTHING]]<U>([[COPY]])
+ // CHECK-NEXT: [[OPT_ANYOBJECT:%.*]] = enum {{.*}} [[ANYOBJECT]]
+ // CHECK-NEXT: destroy_addr [[COPY]]
+ // CHECK-NEXT: dealloc_stack [[COPY]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK-NEXT: apply [[METHOD]]([[OPT_ANYOBJECT]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[OPT_ANYOBJECT]]
+ receiver.takesNullableId(generic)
+
+ // CHECK-NEXT: [[COPY:%.*]] = alloc_stack $P
+ // CHECK-NEXT: copy_addr [[EXISTENTIAL]] to [initialization] [[COPY]]
+ // CHECK-NEXT: [[OPENED_COPY:%.*]] = open_existential_addr immutable_access [[COPY]] : $*P to $*[[OPENED_TYPE:@opened.*P]],
+ // CHECK: [[TMP:%.*]] = alloc_stack $[[OPENED_TYPE]]
+ // CHECK: copy_addr [[OPENED_COPY]] to [initialization] [[TMP]]
+ // CHECK-NEXT: // function_ref _bridgeAnythingToObjectiveC
+ // CHECK-NEXT: [[BRIDGE_ANYTHING:%.*]] = function_ref
+ // CHECK-NEXT: [[ANYOBJECT:%.*]] = apply [[BRIDGE_ANYTHING]]<[[OPENED_TYPE]]>([[TMP]])
+ // CHECK-NEXT: [[OPT_ANYOBJECT:%.*]] = enum {{.*}} [[ANYOBJECT]]
+ // CHECK-NEXT: destroy_addr [[TMP]]
+ // CHECK-NEXT: dealloc_stack [[TMP]]
+ // CHECK-NEXT: destroy_addr [[COPY]]
+ // CHECK-NEXT: dealloc_stack [[COPY]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK-NEXT: apply [[METHOD]]([[OPT_ANYOBJECT]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[OPT_ANYOBJECT]]
+ receiver.takesNullableId(existential)
+
+ // CHECK-NEXT: [[ERROR_COPY:%.*]] = copy_value [[ERROR]] : $Error
+ // CHECK-NEXT: [[ERROR_BOX:%[0-9]+]] = open_existential_box [[ERROR_COPY]] : $Error to $*@opened([[ERROR_ARCHETYPE:"[^"]*"]]) Error
+ // CHECK-NEXT: [[ERROR_STACK:%[0-9]+]] = alloc_stack $@opened([[ERROR_ARCHETYPE]]) Error
+ // CHECK-NEXT: copy_addr [[ERROR_BOX]] to [initialization] [[ERROR_STACK]] : $*@opened([[ERROR_ARCHETYPE]]) Error
+ // CHECK: [[BRIDGE_FUNCTION:%[0-9]+]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK-NEXT: [[BRIDGED_ERROR:%[0-9]+]] = apply [[BRIDGE_FUNCTION]]<@opened([[ERROR_ARCHETYPE]]) Error>([[ERROR_STACK]])
+ // CHECK-NEXT: [[BRIDGED_ERROR_OPT:%[0-9]+]] = enum $Optional<AnyObject>, #Optional.some!enumelt.1, [[BRIDGED_ERROR]] : $AnyObject
+ // CHECK-NEXT: destroy_addr [[ERROR_STACK]]
+ // CHECK-NEXT: dealloc_stack [[ERROR_STACK]] : $*@opened([[ERROR_ARCHETYPE]]) Error
+ // CHECK-NEXT: destroy_value [[ERROR_COPY]] : $Error
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK-NEXT: apply [[METHOD]]([[BRIDGED_ERROR_OPT]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[BRIDGED_ERROR_OPT]]
+ receiver.takesNullableId(error)
+
+ // CHECK-NEXT: [[COPY:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: copy_addr [[ANY]] to [initialization] [[COPY]]
+ // CHECK-NEXT: [[OPENED_COPY:%.*]] = open_existential_addr immutable_access [[COPY]] : $*Any to $*[[OPENED_TYPE:@opened.*Any]],
+ // CHECK: [[TMP:%.*]] = alloc_stack $[[OPENED_TYPE]]
+ // CHECK: copy_addr [[OPENED_COPY]] to [initialization] [[TMP]]
+ // CHECK-NEXT: // function_ref _bridgeAnythingToObjectiveC
+ // CHECK-NEXT: [[BRIDGE_ANYTHING:%.*]] = function_ref
+ // CHECK-NEXT: [[ANYOBJECT:%.*]] = apply [[BRIDGE_ANYTHING]]<[[OPENED_TYPE]]>([[TMP]])
+ // CHECK-NEXT: [[OPT_ANYOBJECT:%.*]] = enum {{.*}} [[ANYOBJECT]]
+ // CHECK-NEXT: destroy_addr [[TMP]]
+ // CHECK-NEXT: dealloc_stack [[TMP]]
+ // CHECK-NEXT: destroy_addr [[COPY]]
+ // CHECK-NEXT: dealloc_stack [[COPY]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK-NEXT: apply [[METHOD]]([[OPT_ANYOBJECT]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[OPT_ANYOBJECT]]
+ receiver.takesNullableId(any)
+
+ // CHECK: [[TMP:%.*]] = alloc_stack $KnownUnbridged
+ // CHECK: store [[KNOWN_UNBRIDGED]] to [trivial] [[TMP]]
+ // CHECK: [[BRIDGE_ANYTHING:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveC{{.*}}F
+ // CHECK: [[ANYOBJECT:%.*]] = apply [[BRIDGE_ANYTHING]]<KnownUnbridged>([[TMP]])
+ // CHECK: [[OPT_ANYOBJECT:%.*]] = enum {{.*}} [[ANYOBJECT]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $NSIdLover,
+ // CHECK: apply [[METHOD]]([[OPT_ANYOBJECT]], [[SELF]])
+ receiver.takesNullableId(knownUnbridged)
+
+ // CHECK: [[OPT_STRING_COPY:%.*]] = copy_value [[OPT_STRING]]
+ // CHECK: switch_enum [[OPT_STRING_COPY]] : $Optional<String>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+ //
+ // CHECK: [[SOME_BB]]([[STRING_DATA:%.*]] : @owned $String):
+ // CHECK: [[BRIDGE_STRING:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+ // CHECK: [[BORROWED_STRING_DATA:%.*]] = begin_borrow [[STRING_DATA]]
+ // CHECK: [[BRIDGED:%.*]] = apply [[BRIDGE_STRING]]([[BORROWED_STRING_DATA]])
+ // CHECK: [[ANYOBJECT:%.*]] = init_existential_ref [[BRIDGED]] : $NSString : $NSString, $AnyObject
+ // CHECK: [[OPT_ANYOBJECT:%.*]] = enum {{.*}} [[ANYOBJECT]]
+ // CHECK: end_borrow [[BORROWED_STRING_DATA]] from [[STRING_DATA]]
+ // CHECK: destroy_value [[STRING_DATA]]
+ // CHECK: br [[JOIN:bb.*]]([[OPT_ANYOBJECT]]
+ //
+ // CHECK: [[NONE_BB]]:
+ // CHECK: [[OPT_NONE:%.*]] = enum $Optional<AnyObject>, #Optional.none!enumelt
+ // CHECK: br [[JOIN]]([[OPT_NONE]]
+ //
+ // CHECK: [[JOIN]]([[PHI:%.*]] : @owned $Optional<AnyObject>):
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]]
+ // CHECK: apply [[METHOD]]([[PHI]], [[SELF]])
+ // CHECK: destroy_value [[PHI]]
+ receiver.takesNullableId(optString)
+
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]]
+ receiver.takesNullableId(optNSString)
+
+ // CHECK: [[OPT_OBJECT_COPY:%.*]] = copy_value [[OPT_OBJECT]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]]
+ // CHECK: apply [[METHOD]]([[OPT_OBJECT_COPY]], [[SELF]])
+ receiver.takesNullableId(optObject)
+ receiver.takesNullableId(optClassGeneric)
+ receiver.takesNullableId(optClassExistential)
+ receiver.takesNullableId(optGeneric)
+ receiver.takesNullableId(optExistential)
+ receiver.takesNullableId(optAny)
+ receiver.takesNullableId(optKnownUnbridged)
+
+ receiver.takesNullableId(optOptA)
+ receiver.takesNullableId(optOptB)
+ receiver.takesNullableId(optOptC)
+}
+
+protocol Anyable {
+ init(any: Any)
+ init(anyMaybe: Any?)
+ var anyProperty: Any { get }
+ var maybeAnyProperty: Any? { get }
+}
+
+// Make sure we generate correct bridging thunks
+class SwiftIdLover : NSObject, Anyable {
+
+ func methodReturningAny() -> Any {}
+ // SEMANTIC ARC TODO: This is another case of pattern matching the body of one
+ // function in a different function... Just pattern match the unreachable case
+ // to preserve behavior. We should check if it is correct.
+
+ // CHECK-LABEL: sil hidden @$S17objc_bridging_any12SwiftIdLoverC18methodReturningAnyypyF : $@convention(method) (@guaranteed SwiftIdLover) -> @out Any
+ // CHECK: unreachable
+ // CHECK: } // end sil function '$S17objc_bridging_any12SwiftIdLoverC18methodReturningAnyypyF'
+
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_bridging_any12SwiftIdLoverC18methodReturningAnyypyFTo : $@convention(objc_method) (SwiftIdLover) -> @autoreleased AnyObject {
+ // CHECK: bb0([[SELF:%[0-9]+]] : @unowned $SwiftIdLover):
+ // CHECK: [[NATIVE_RESULT:%.*]] = alloc_stack $Any
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $SwiftIdLover
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[NATIVE_IMP:%.*]] = function_ref @$S17objc_bridging_any12SwiftIdLoverC18methodReturningAnyypyF
+ // CHECK: apply [[NATIVE_IMP]]([[NATIVE_RESULT]], [[BORROWED_SELF_COPY]])
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK: [[OPEN_RESULT:%.*]] = open_existential_addr immutable_access [[NATIVE_RESULT]]
+ // CHECK: [[TMP:%.*]] = alloc_stack
+ // CHECK: copy_addr [[OPEN_RESULT]] to [initialization] [[TMP]]
+ // CHECK: [[BRIDGE_ANYTHING:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveC{{.*}}F
+ // CHECK: [[OBJC_RESULT:%.*]] = apply [[BRIDGE_ANYTHING]]<{{.*}}>([[TMP]])
+ // CHECK: return [[OBJC_RESULT]]
+ // CHECK: } // end sil function '$S17objc_bridging_any12SwiftIdLoverC18methodReturningAnyypyFTo'
+
+ func methodReturningOptionalAny() -> Any? {}
+ // CHECK-LABEL: sil hidden @$S17objc_bridging_any12SwiftIdLoverC26methodReturningOptionalAnyypSgyF
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_bridging_any12SwiftIdLoverC26methodReturningOptionalAnyypSgyFTo
+ // CHECK: function_ref @$Ss27_bridgeAnythingToObjectiveC{{.*}}F
+
+ @objc func methodTakingAny(a: Any) {}
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_bridging_any12SwiftIdLoverC15methodTakingAny1ayyp_tFTo : $@convention(objc_method) (AnyObject, SwiftIdLover) -> ()
+ // CHECK: bb0([[ARG:%.*]] : @unowned $AnyObject, [[SELF:%.*]] : @unowned $SwiftIdLover):
+ // CHECK-NEXT: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK-NEXT: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK-NEXT: [[OPENED_SELF:%.*]] = open_existential_ref [[ARG_COPY]]
+ // CHECK-NEXT: [[RESULT:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: [[INIT:%.*]] = init_existential_addr [[RESULT]] : $*Any
+ // CHECK-NEXT: store [[OPENED_SELF]] to [init] [[INIT]]
+ // CHECK-NEXT: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[METHOD:%.*]] = function_ref @$S17objc_bridging_any12SwiftIdLoverC15methodTakingAny1ayyp_tF
+ // CHECK-NEXT: apply [[METHOD]]([[RESULT]], [[BORROWED_SELF_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK-NEXT: destroy_addr [[RESULT]]
+ // CHECK-NEXT: dealloc_stack [[RESULT]]
+ // CHECK-NEXT: destroy_value [[SELF_COPY]]
+ // CHECK-NEXT: return
+
+ func methodTakingOptionalAny(a: Any?) {}
+ // CHECK-LABEL: sil hidden @$S17objc_bridging_any12SwiftIdLoverC23methodTakingOptionalAny1ayypSg_tF
+
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_bridging_any12SwiftIdLoverC23methodTakingOptionalAny1ayypSg_tFTo
+
+ // CHECK-LABEL: sil hidden @$S17objc_bridging_any12SwiftIdLoverC017methodTakingBlockH3AnyyyyypXEF : $@convention(method) (@noescape @callee_guaranteed (@in_guaranteed Any) -> (), @guaranteed SwiftIdLover) -> ()
+
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_bridging_any12SwiftIdLoverC017methodTakingBlockH3AnyyyyypXEFTo : $@convention(objc_method) (@convention(block) @noescape (AnyObject) -> (), SwiftIdLover) -> ()
+ // CHECK: bb0([[BLOCK:%.*]] : @unowned $@convention(block) @noescape (AnyObject) -> (), [[SELF:%.*]] : @unowned $SwiftIdLover):
+ // CHECK-NEXT: [[BLOCK_COPY:%.*]] = copy_block [[BLOCK]]
+ // CHECK-NEXT: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$SyXlIyBy_ypIegn_TR
+ // CHECK-NEXT: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]([[BLOCK_COPY]])
+ // CHECK-NEXT: [[THUNK_CVT:%.*]] = convert_escape_to_noescape [[THUNK]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[METHOD:%.*]] = function_ref @$S17objc_bridging_any12SwiftIdLoverC017methodTakingBlockH3AnyyyyypXEF
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[THUNK_CVT]], [[BORROWED_SELF_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK-NEXT: destroy_value [[THUNK]]
+ // CHECK-NEXT: destroy_value [[SELF_COPY]]
+ // CHECK-NEXT: return [[RESULT]]
+
+ // CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SyXlIyBy_ypIegn_TR
+ // CHECK: bb0([[ANY:%.*]] : @trivial $*Any, [[BLOCK:%.*]] : @guaranteed $@convention(block) @noescape (AnyObject) -> ()):
+ // CHECK-NEXT: [[OPENED_ANY:%.*]] = open_existential_addr immutable_access [[ANY]] : $*Any to $*[[OPENED_TYPE:@opened.*Any]],
+ // CHECK: [[TMP:%.*]] = alloc_stack
+ // CHECK: copy_addr [[OPENED_ANY]] to [initialization] [[TMP]]
+ // CHECK-NEXT: // function_ref _bridgeAnythingToObjectiveC
+ // CHECK-NEXT: [[BRIDGE_ANYTHING:%.*]] = function_ref
+ // CHECK-NEXT: [[BRIDGED:%.*]] = apply [[BRIDGE_ANYTHING]]<[[OPENED_TYPE]]>([[TMP]])
+ // CHECK-NEXT: apply [[BLOCK]]([[BRIDGED]])
+ // CHECK-NEXT: [[VOID:%.*]] = tuple ()
+ // CHECK-NEXT: destroy_value [[BRIDGED]]
+ // CHECK-NEXT: destroy_addr [[TMP]]
+ // CHECK-NEXT: dealloc_stack [[TMP]]
+ // CHECK-NEXT: return [[VOID]]
+
+ @objc func methodTakingBlockTakingAny(_: (Any) -> ()) {}
+
+ // CHECK-LABEL: sil hidden @$S17objc_bridging_any12SwiftIdLoverC29methodReturningBlockTakingAnyyypcyF : $@convention(method) (@guaranteed SwiftIdLover) -> @owned @callee_guaranteed (@in_guaranteed Any) -> ()
+
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_bridging_any12SwiftIdLoverC29methodReturningBlockTakingAnyyypcyFTo : $@convention(objc_method) (SwiftIdLover) -> @autoreleased @convention(block) (AnyObject) -> ()
+ // CHECK: bb0([[SELF:%.*]] : @unowned $SwiftIdLover):
+ // CHECK-NEXT: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK-NEXT: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[METHOD:%.*]] = function_ref @$S17objc_bridging_any12SwiftIdLoverC29methodReturningBlockTakingAnyyypcyF
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD:%.*]]([[BORROWED_SELF_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK-NEXT: destroy_value [[SELF_COPY]]
+ // CHECK-NEXT: [[BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage @callee_guaranteed (@in_guaranteed Any) -> ()
+ // CHECK-NEXT: [[BLOCK_STORAGE_ADDR:%.*]] = project_block_storage [[BLOCK_STORAGE]]
+ // CHECK-NEXT: store [[RESULT:%.*]] to [init] [[BLOCK_STORAGE_ADDR]]
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$SypIegn_yXlIeyBy_TR
+ // CHECK-NEXT: [[BLOCK_HEADER:%.*]] = init_block_storage_header [[BLOCK_STORAGE]] : $*@block_storage @callee_guaranteed (@in_guaranteed Any) -> (), invoke [[THUNK_FN]]
+ // CHECK-NEXT: [[BLOCK:%.*]] = copy_block [[BLOCK_HEADER]]
+ // CHECK-NEXT: destroy_addr [[BLOCK_STORAGE_ADDR]]
+ // CHECK-NEXT: dealloc_stack [[BLOCK_STORAGE]]
+ // CHECK-NEXT: return [[BLOCK]]
+
+ // CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SypIegn_yXlIeyBy_TR : $@convention(c) (@inout_aliasable @block_storage @callee_guaranteed (@in_guaranteed Any) -> (), AnyObject) -> ()
+ // CHECK: bb0([[BLOCK_STORAGE:%.*]] : @trivial $*@block_storage @callee_guaranteed (@in_guaranteed Any) -> (), [[ANY:%.*]] : @unowned $AnyObject):
+ // CHECK-NEXT: [[BLOCK_STORAGE_ADDR:%.*]] = project_block_storage [[BLOCK_STORAGE]]
+ // CHECK-NEXT: [[FUNCTION:%.*]] = load [copy] [[BLOCK_STORAGE_ADDR]]
+ // CHECK-NEXT: [[ANY_COPY:%.*]] = copy_value [[ANY]]
+ // CHECK-NEXT: [[OPENED_ANY:%.*]] = open_existential_ref [[ANY_COPY]]
+ // CHECK-NEXT: [[RESULT:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: [[INIT:%.*]] = init_existential_addr [[RESULT]] : $*Any
+ // CHECK-NEXT: store [[OPENED_ANY]] to [init] [[INIT]]
+ // CHECK-NEXT: [[BORROW_FUN:%.*]] = begin_borrow [[FUNCTION]]
+ // CHECK-NEXT: apply [[BORROW_FUN]]([[RESULT]])
+ // CHECK-NEXT: end_borrow [[BORROW_FUN]] from [[FUNCTION]]
+ // CHECK-NEXT: [[VOID:%.*]] = tuple ()
+ // CHECK-NEXT: destroy_addr [[RESULT]]
+ // CHECK-NEXT: dealloc_stack [[RESULT]]
+ // CHECK-NEXT: destroy_value [[FUNCTION]]
+ // CHECK-NEXT: return [[VOID]] : $()
+
+ @objc func methodTakingBlockTakingOptionalAny(_: (Any?) -> ()) {}
+
+ @objc func methodReturningBlockTakingAny() -> ((Any) -> ()) {}
+
+ // CHECK-LABEL: sil hidden @$S17objc_bridging_any12SwiftIdLoverC29methodTakingBlockReturningAnyyyypyXEF : $@convention(method) (@noescape @callee_guaranteed () -> @out Any, @guaranteed SwiftIdLover) -> () {
+
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_bridging_any12SwiftIdLoverC29methodTakingBlockReturningAnyyyypyXEFTo : $@convention(objc_method) (@convention(block) @noescape () -> @autoreleased AnyObject, SwiftIdLover) -> ()
+ // CHECK: bb0([[BLOCK:%.*]] : @unowned $@convention(block) @noescape () -> @autoreleased AnyObject, [[ANY:%.*]] : @unowned $SwiftIdLover):
+ // CHECK-NEXT: [[BLOCK_COPY:%.*]] = copy_block [[BLOCK]]
+ // CHECK-NEXT: [[ANY_COPY:%.*]] = copy_value [[ANY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[THUNK_FN:%.*]] = function_ref @$SyXlIyBa_ypIegr_TR
+ // CHECK-NEXT: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]([[BLOCK_COPY]])
+ // CHECK-NEXT: [[THUNK_CVT:%.*]] = convert_escape_to_noescape [[THUNK]]
+ // CHECK-NEXT: [[BORROWED_ANY_COPY:%.*]] = begin_borrow [[ANY_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[METHOD:%.*]] = function_ref @$S17objc_bridging_any12SwiftIdLoverC29methodTakingBlockReturningAnyyyypyXEF
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[THUNK_CVT]], [[BORROWED_ANY_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_ANY_COPY]] from [[ANY_COPY]]
+ // CHECK-NEXT: destroy_value [[THUNK]]
+ // CHECK-NEXT: destroy_value [[ANY_COPY]]
+ // CHECK-NEXT: return [[RESULT]]
+
+ // CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SyXlIyBa_ypIegr_TR : $@convention(thin) (@guaranteed @convention(block) @noescape () -> @autoreleased AnyObject) -> @out Any
+ // CHECK: bb0([[ANY_ADDR:%.*]] : @trivial $*Any, [[BLOCK:%.*]] : @guaranteed $@convention(block) @noescape () -> @autoreleased AnyObject):
+ // CHECK-NEXT: [[BRIDGED:%.*]] = apply [[BLOCK]]()
+ // CHECK-NEXT: [[OPTIONAL:%.*]] = unchecked_ref_cast [[BRIDGED]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[BRIDGE_TO_ANY:%.*]] = function_ref [[BRIDGE_TO_ANY_FUNC:@.*]] :
+ // CHECK-NEXT: [[BORROWED_OPTIONAL:%.*]] = begin_borrow [[OPTIONAL]]
+ // CHECK-NEXT: [[RESULT_VAL:%.*]] = apply [[BRIDGE_TO_ANY]]([[ANY_ADDR]], [[BORROWED_OPTIONAL]])
+ // CHECK-NEXT: [[EMPTY:%.*]] = tuple ()
+ // CHECK-NEXT: end_borrow [[BORROWED_OPTIONAL]]
+ // CHECK-NEXT: destroy_value [[OPTIONAL]]
+ // CHECK-NEXT: return [[EMPTY]]
+
+ @objc func methodReturningBlockTakingOptionalAny() -> ((Any?) -> ()) {}
+
+ @objc func methodTakingBlockReturningAny(_: () -> Any) {}
+
+ // CHECK-LABEL: sil hidden @$S17objc_bridging_any12SwiftIdLoverC020methodReturningBlockH3AnyypycyF : $@convention(method) (@guaranteed SwiftIdLover) -> @owned @callee_guaranteed () -> @out Any
+
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_bridging_any12SwiftIdLoverC020methodReturningBlockH3AnyypycyFTo : $@convention(objc_method) (SwiftIdLover) -> @autoreleased @convention(block) () -> @autoreleased AnyObject
+ // CHECK: bb0([[SELF:%.*]] : @unowned $SwiftIdLover):
+ // CHECK-NEXT: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK-NEXT: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[METHOD:%.*]] = function_ref @$S17objc_bridging_any12SwiftIdLoverC020methodReturningBlockH3AnyypycyF
+ // CHECK-NEXT: [[FUNCTION:%.*]] = apply [[METHOD]]([[BORROWED_SELF_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK-NEXT: destroy_value [[SELF_COPY]]
+ // CHECK-NEXT: [[BLOCK_STORAGE:%.*]] = alloc_stack $@block_storage @callee_guaranteed () -> @out Any
+ // CHECK-NEXT: [[BLOCK_STORAGE_ADDR:%.*]] = project_block_storage [[BLOCK_STORAGE]]
+ // CHECK-NEXT: store [[FUNCTION]] to [init] [[BLOCK_STORAGE_ADDR]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[THUNK_FN:%.*]] = function_ref @$SypIegr_yXlIeyBa_TR
+ // CHECK-NEXT: [[BLOCK_HEADER:%.*]] = init_block_storage_header [[BLOCK_STORAGE]] : $*@block_storage @callee_guaranteed () -> @out Any, invoke [[THUNK_FN]]
+ // CHECK-NEXT: [[BLOCK:%.*]] = copy_block [[BLOCK_HEADER]]
+ // CHECK-NEXT: destroy_addr [[BLOCK_STORAGE_ADDR]]
+ // CHECK-NEXT: dealloc_stack [[BLOCK_STORAGE]]
+ // CHECK-NEXT: return [[BLOCK]]
+
+ // CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SypIegr_yXlIeyBa_TR : $@convention(c) (@inout_aliasable @block_storage @callee_guaranteed () -> @out Any) -> @autoreleased AnyObject
+ // CHECK: bb0(%0 : @trivial $*@block_storage @callee_guaranteed () -> @out Any):
+ // CHECK-NEXT: [[BLOCK_STORAGE_ADDR:%.*]] = project_block_storage %0
+ // CHECK-NEXT: [[FUNCTION:%.*]] = load [copy] [[BLOCK_STORAGE_ADDR]]
+ // CHECK-NEXT: [[RESULT:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: [[BORROW_FUN:%.*]] = begin_borrow [[FUNCTION]]
+ // CHECK-NEXT: apply [[BORROW_FUN]]([[RESULT]])
+ // CHECK-NEXT: end_borrow [[BORROW_FUN]] from [[FUNCTION]]
+ // CHECK-NEXT: [[OPENED:%.*]] = open_existential_addr immutable_access [[RESULT]] : $*Any to $*[[OPENED_TYPE:@opened.*Any]],
+ // CHECK: [[TMP:%.*]] = alloc_stack $[[OPENED_TYPE]]
+ // CHECK: copy_addr [[OPENED]] to [initialization] [[TMP]]
+ // CHECK-NEXT: // function_ref _bridgeAnythingToObjectiveC
+ // CHECK-NEXT: [[BRIDGE_ANYTHING:%.*]] = function_ref
+ // CHECK-NEXT: [[BRIDGED:%.*]] = apply [[BRIDGE_ANYTHING]]<[[OPENED_TYPE]]>([[TMP]])
+ // CHECK-NEXT: destroy_addr [[TMP]]
+ // CHECK-NEXT: dealloc_stack [[TMP]]
+ // CHECK-NEXT: destroy_addr [[RESULT]]
+ // CHECK-NEXT: dealloc_stack [[RESULT]]
+ // CHECK-NEXT: destroy_value [[FUNCTION]]
+ // CHECK-NEXT: return [[BRIDGED]]
+
+ @objc func methodTakingBlockReturningOptionalAny(_: () -> Any?) {}
+
+ @objc func methodReturningBlockReturningAny() -> (() -> Any) {}
+
+ @objc func methodReturningBlockReturningOptionalAny() -> (() -> Any?) {}
+ // CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SypSgIegr_yXlSgIeyBa_TR
+ // CHECK: function_ref @$Ss27_bridgeAnythingToObjectiveC{{.*}}F
+
+ override init() { super.init() }
+ @objc dynamic required convenience init(any: Any) { self.init() }
+ @objc dynamic required convenience init(anyMaybe: Any?) { self.init() }
+ @objc dynamic var anyProperty: Any
+ @objc dynamic var maybeAnyProperty: Any?
+
+ subscript(_: IndexForAnySubscript) -> Any { get {} set {} }
+
+ @objc func methodReturningAnyOrError() throws -> Any {}
+}
+
+class IndexForAnySubscript {}
+
+func dynamicLookup(x: AnyObject) {
+ _ = x.anyProperty
+ _ = x[IndexForAnySubscript()]
+}
+
+extension GenericClass {
+ // CHECK-LABEL: sil hidden @$SSo12GenericClassC17objc_bridging_anyE23pseudogenericAnyErasure1xypx_tF :
+ func pseudogenericAnyErasure(x: T) -> Any {
+ // CHECK: bb0([[ANY_OUT:%.*]] : @trivial $*Any, [[ARG:%.*]] : @guaranteed $T, [[SELF:%.*]] : @guaranteed $GenericClass<T>
+ // CHECK: [[ANY_BUF:%.*]] = init_existential_addr [[ANY_OUT]] : $*Any, $AnyObject
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: [[ANYOBJECT:%.*]] = init_existential_ref [[ARG_COPY]] : $T : $T, $AnyObject
+ // CHECK: store [[ANYOBJECT]] to [init] [[ANY_BUF]]
+ return x
+ }
+ // CHECK: } // end sil function '$SSo12GenericClassC17objc_bridging_anyE23pseudogenericAnyErasure1xypx_tF'
+}
+
+// Make sure AnyHashable erasure marks Hashable conformance as used
+class AnyHashableClass : NSObject {
+ // CHECK-LABEL: sil hidden @$S17objc_bridging_any16AnyHashableClassC07returnsdE0s0dE0VyF
+ // CHECK: [[FN:%.*]] = function_ref @$Ss21_convertToAnyHashableys0cD0Vxs0D0RzlF
+ // CHECK: apply [[FN]]<GenericOption>({{.*}})
+ func returnsAnyHashable() -> AnyHashable {
+ return GenericOption.multithreaded
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S17objc_bridging_any33bridgeOptionalFunctionToAnyObject2fnyXlyycSg_tF : $@convention(thin) (@guaranteed Optional<@callee_guaranteed () -> ()>) -> @owned AnyObject
+// CHECK: [[BRIDGE:%.*]] = function_ref @$SSq19_bridgeToObjectiveCyXlyF
+// CHECK: [[FN:%.*]] = function_ref @$SIeg_ytytIegnr_TR
+// CHECK: partial_apply [callee_guaranteed] [[FN]]
+// CHECK: [[SELF:%.*]] = alloc_stack $Optional<@callee_guaranteed (@in_guaranteed ()) -> @out ()>
+// CHECK: apply [[BRIDGE]]<() -> ()>([[SELF]])
+func bridgeOptionalFunctionToAnyObject(fn: (() -> ())?) -> AnyObject {
+ return fn as AnyObject
+}
+
+// CHECK-LABEL: sil_witness_table shared [serialized] GenericOption: Hashable module objc_generics {
+// CHECK-NEXT: base_protocol Equatable: GenericOption: Equatable module objc_generics
+// CHECK-NEXT: method #Hashable.hashValue!getter.1: {{.*}} : @$SSo13GenericOptionas8HashableSCsACP9hashValueSivgTW
+// CHECK-NEXT: method #Hashable._hash!1: {{.*}} : @$SSo13GenericOptionas8HashableSCsACP5_hash4intoys7_HasherVz_tFTW
+// CHECK-NEXT: }
diff --git a/test/SILGen/plus_zero_objc_bridging_peephole.swift b/test/SILGen/plus_zero_objc_bridging_peephole.swift
new file mode 100644
index 0000000..8797bc5
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_bridging_peephole.swift
@@ -0,0 +1,617 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+// REQUIRES: objc_interop
+
+import Foundation
+import OtherSubscripts
+import objc_generics
+
+func useNS(_ : NSString) {}
+func useOptNS(_ : NSString?) {}
+func makeNS() -> NSString { return "help" as NSString }
+func makeOptNS() -> NSString? { return nil }
+
+func useAnyObject(_: AnyObject) {}
+func useOptAnyObject(_: AnyObject?) {}
+
+/*** Return values ***********************************************************/
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole16testMethodResult5dummyySo10DummyClassC_tF
+func testMethodResult(dummy: DummyClass) {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $DummyClass):
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $DummyClass, #DummyClass.fetchNullableString!1.foreign
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK-NEXT: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole8useOptNSyySo8NSStringCSgF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_RESULT]])
+ useOptNS(dummy.fetchNullableString() as NSString?)
+
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $DummyClass, #DummyClass.fetchNullproneString!1.foreign
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole8useOptNSyySo8NSStringCSgF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_RESULT]])
+ useOptNS(dummy.fetchNullproneString() as NSString?)
+
+ // CHECK: [[METHOD:%.*]] = objc_method [[SELF]] : $DummyClass, #DummyClass.fetchNonnullString!1.foreign
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole8useOptNSyySo8NSStringCSgF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_RESULT]])
+ useOptNS(dummy.fetchNonnullString() as NSString?)
+
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK-NEXT: [[ANYOBJECT:%.*]] = unchecked_ref_cast [[RESULT]] : $Optional<NSString> to $Optional<AnyObject>
+ // CHECK-NEXT: [[BORROWED_ANYOBJECT:%.*]] = begin_borrow [[ANYOBJECT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole15useOptAnyObjectyyyXlSgF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_ANYOBJECT]])
+ useOptAnyObject(dummy.fetchNullableString() as AnyObject?)
+
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK-NEXT: [[ANYOBJECT:%.*]] = unchecked_ref_cast [[RESULT]] : $Optional<NSString> to $Optional<AnyObject>
+ // CHECK: [[BORROWED_ANYOBJECT:%.*]] = begin_borrow [[ANYOBJECT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole15useOptAnyObjectyyyXlSgF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_ANYOBJECT]])
+ useOptAnyObject(dummy.fetchNullproneString() as AnyObject?)
+
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK-NEXT: [[ANYOBJECT:%.*]] = unchecked_ref_cast [[RESULT]] : $Optional<NSString> to $Optional<AnyObject>
+ // CHECK: [[BORROWED_ANYOBJECT:%.*]] = begin_borrow [[ANYOBJECT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole15useOptAnyObjectyyyXlSgF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_ANYOBJECT]])
+ useOptAnyObject(dummy.fetchNonnullString() as AnyObject?)
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole23testNonNullMethodResult5dummyySo10DummyClassC_tF
+func testNonNullMethodResult(dummy: DummyClass) {
+ // CHECK: bb0([[ARG:%.*]] @guaranteed $DummyClass):
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK-NEXT: switch_enum [[RESULT]]
+ //
+ // CHECK: bb1:
+ // CHECK: function_ref @$Ss30_diagnoseUnexpectedNilOptional14_filenameStart01_E6Length01_E7IsASCII5_lineyBp_BwBi1_BwtF
+ // CHECK: bb2([[RESULT:%.*]] : @owned $NSString):
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole5useNSyySo8NSStringCF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_RESULT]])
+ useNS(dummy.fetchNonnullString() as NSString)
+
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK-NEXT: switch_enum [[RESULT]]
+ // CHECK: bb3:
+ // CHECK: function_ref @$Ss30_diagnoseUnexpectedNilOptional14_filenameStart01_E6Length01_E7IsASCII5_lineyBp_BwBi1_BwtF
+ // CHECK: bb4([[RESULT:%.*]] : @owned $NSString):
+ // CHECK-NEXT: [[ANYOBJECT:%.*]] = init_existential_ref [[RESULT]] : $NSString : $NSString, $AnyObject
+ // CHECK-NEXT: [[BORROWED_ANYOBJECT:%.*]] = begin_borrow [[ANYOBJECT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole12useAnyObjectyyyXlF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_ANYOBJECT]])
+ useAnyObject(dummy.fetchNonnullString() as AnyObject)
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole22testForcedMethodResult5dummyySo10DummyClassC_tF
+// CHECK: bb0([[SELF:%.*]] : @guaranteed $DummyClass):
+func testForcedMethodResult(dummy: DummyClass) {
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK-NEXT: switch_enum [[RESULT]]
+ // CHECK: bb1:
+ // CHECK: function_ref @$Ss30_diagnoseUnexpectedNilOptional14_filenameStart01_E6Length01_E7IsASCII5_lineyBp_BwBi1_BwtF
+ // CHECK: bb2([[RESULT:%.*]] : @owned $NSString):
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole5useNSyySo8NSStringCF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_RESULT]])
+ useNS(dummy.fetchNullproneString() as NSString)
+
+ // This is not a force.
+ // TODO: we could do it more efficiently than this, though
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK-NEXT: switch_enum [[RESULT]]
+ //
+ // CHECK: bb3([[RESULT:%.*]] : @owned $NSString):
+ // CHECK: function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ //
+ // CHECK: bb4:
+ // CHECK: enum $Optional<String>, #Optional.none
+ //
+ // CHECK: bb5([[OPTSTRING:%.*]] : @owned $Optional<String>):
+ // CHECK: [[BRIDGE:%.*]] = function_ref @$SSq19_bridgeToObjectiveCyXlyF
+ // CHECK-NEXT: [[TEMP:%.*]] = alloc_stack $Optional<String>
+ // CHECK-NEXT: [[BORROW:%.*]] = begin_borrow [[OPTSTRING]]
+ // CHECK-NEXT: store_borrow [[BORROW]] to [[TEMP]] : $*Optional<String>
+ // CHECK-NEXT: [[ANYOBJECT:%.*]] = apply [[BRIDGE]]<String>([[TEMP]])
+ // CHECK: [[BORROWED_ANYOBJECT:%.*]] = begin_borrow [[ANYOBJECT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole12useAnyObjectyyyXlF
+ // CHECK: apply [[USE]]([[BORROWED_ANYOBJECT]])
+ useAnyObject(dummy.fetchNullproneString() as AnyObject)
+
+ // CHECK: return
+}
+
+/*** Property loads **********************************************************/
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole17testPropertyValue5dummyySo10DummyClassC_tF
+// CHECK: bb0([[SELF:%.*]] : @guaranteed $DummyClass):
+func testPropertyValue(dummy: DummyClass) {
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole8useOptNSyySo8NSStringCSgF
+ // CHECK: apply [[USE]]([[BORROWED_RESULT]])
+ useOptNS(dummy.nullableStringProperty as NSString?)
+
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole8useOptNSyySo8NSStringCSgF
+ // CHECK: apply [[USE]]([[BORROWED_RESULT]])
+ useOptNS(dummy.nullproneStringProperty as NSString?)
+
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole8useOptNSyySo8NSStringCSgF
+ // CHECK: apply [[USE]]([[BORROWED_RESULT]])
+ useOptNS(dummy.nonnullStringProperty as NSString?)
+
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK: [[ANYOBJECT:%.*]] = unchecked_ref_cast [[RESULT]] : $Optional<NSString> to $Optional<AnyObject>
+ // CHECK: [[BORROWED_ANYOBJECT:%.*]] = begin_borrow [[ANYOBJECT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole15useOptAnyObjectyyyXlSgF
+ // CHECK: apply [[USE]]([[BORROWED_ANYOBJECT]])
+ useOptAnyObject(dummy.nullableStringProperty as AnyObject?)
+
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK: [[ANYOBJECT:%.*]] = unchecked_ref_cast [[RESULT]] : $Optional<NSString> to $Optional<AnyObject>
+ // CHECK: [[BORROWED_ANYOBJECT:%.*]] = begin_borrow [[ANYOBJECT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole15useOptAnyObjectyyyXlSgF
+ // CHECK: apply [[USE]]([[BORROWED_ANYOBJECT]])
+ useOptAnyObject(dummy.nullproneStringProperty as AnyObject?)
+
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK: [[ANYOBJECT:%.*]] = unchecked_ref_cast [[RESULT]] : $Optional<NSString> to $Optional<AnyObject>
+ // CHECK: [[BORROWED_ANYOBJECT:%.*]] = begin_borrow [[ANYOBJECT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole15useOptAnyObjectyyyXlSgF
+ // CHECK: apply [[USE]]([[BORROWED_ANYOBJECT]])
+ useOptAnyObject(dummy.nonnullStringProperty as AnyObject?)
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole24testNonNullPropertyValue5dummyySo10DummyClassC_tF
+func testNonNullPropertyValue(dummy: DummyClass) {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $DummyClass):
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK: switch_enum [[RESULT]]
+ // CHECK: bb1:
+ // CHECK: function_ref @$Ss30_diagnoseUnexpectedNilOptional14_filenameStart01_E6Length01_E7IsASCII5_lineyBp_BwBi1_BwtF
+ // CHECK: bb2([[RESULT:%.*]] : @owned $NSString):
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole5useNSyySo8NSStringCF
+ // CHECK: apply [[USE]]([[BORROWED_RESULT]])
+ useNS(dummy.nonnullStringProperty as NSString)
+
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK: switch_enum [[RESULT]]
+ // CHECK: bb3:
+ // CHECK: function_ref @$Ss30_diagnoseUnexpectedNilOptional14_filenameStart01_E6Length01_E7IsASCII5_lineyBp_BwBi1_BwtF
+ // CHECK: bb4([[RESULT:%.*]] : @owned $NSString):
+ // CHECK: [[ANYOBJECT:%.*]] = init_existential_ref [[RESULT]] : $NSString : $NSString, $AnyObject
+ // CHECK: [[BORROWED_ANYOBJECT:%.*]] = begin_borrow [[ANYOBJECT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole12useAnyObjectyyyXlF
+ // CHECK: apply [[USE]]([[BORROWED_ANYOBJECT]])
+ useAnyObject(dummy.nonnullStringProperty as AnyObject)
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole23testForcedPropertyValue5dummyySo10DummyClassC_tF
+func testForcedPropertyValue(dummy: DummyClass) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $DummyClass):
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK: switch_enum [[RESULT]]
+ // CHECK: bb1:
+ // CHECK: function_ref @$Ss30_diagnoseUnexpectedNilOptional14_filenameStart01_E6Length01_E7IsASCII5_lineyBp_BwBi1_BwtF
+ // CHECK: bb2([[RESULT:%.*]] : @owned $NSString):
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole5useNSyySo8NSStringCF
+ // CHECK: apply [[USE]]([[BORROWED_RESULT]])
+ useNS(dummy.nullproneStringProperty as NSString)
+
+ // This is not a force.
+ // TODO: we could do it more efficiently than this, though
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[SELF]])
+ // CHECK: switch_enum [[RESULT]]
+ // CHECK: bb3([[RESULT:%.*]] : @owned $NSString):
+ // CHECK: function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+ // CHECK: bb4:
+ // CHECK: enum $Optional<String>, #Optional.none
+ // CHECK: bb5([[OPTSTRING:%.*]] : @owned $Optional<String>):
+ // CHECK: [[BRIDGE:%.*]] = function_ref @$SSq19_bridgeToObjectiveCyXlyF
+ // CHECK-NEXT: [[TEMP:%.*]] = alloc_stack $Optional<String>
+ // CHECK-NEXT: [[BORROW:%.*]] = begin_borrow [[OPTSTRING]]
+ // CHECK-NEXT: store_borrow [[BORROW]] to [[TEMP]] : $*Optional<String>
+ // CHECK-NEXT: [[ANYOBJECT:%.*]] = apply [[BRIDGE]]<String>([[TEMP]])
+ // CHECK: [[BORROWED_ANYOBJECT:%.*]] = begin_borrow [[ANYOBJECT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole12useAnyObjectyyyXlF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_ANYOBJECT]])
+ // CHECK: dealloc_stack [[TEMP]]
+ // CHECK: destroy_value [[OPTSTRING]]
+ useAnyObject(dummy.nullproneStringProperty as AnyObject)
+
+ // CHECK: return
+}
+
+/*** Subscript loads *********************************************************/
+
+// FIXME: apply peepholes to indices, too!
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole23testNonnullSubscriptGet6object5indexySo0eF0C_yXltF
+func testNonnullSubscriptGet(object: NonnullSubscript, index: AnyObject) {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $NonnullSubscript,
+ // CHECK: [[BRIDGE_TO_ID:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK-NEXT: [[INDEX:%.*]] = apply [[BRIDGE_TO_ID]]
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[INDEX]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[INDEX]] : $AnyObject
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole8useOptNSyySo8NSStringCSgF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_RESULT]])
+ useOptNS(object[index] as NSString?)
+
+ // CHECK: [[BRIDGE_TO_ID:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK-NEXT: [[INDEX:%.*]] = apply [[BRIDGE_TO_ID]]
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[INDEX]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[INDEX]] : $AnyObject
+ // CHECK-NEXT: switch_enum [[RESULT]]
+ // CHECK: function_ref @$Ss30_diagnoseUnexpectedNilOptional14_filenameStart01_E6Length01_E7IsASCII5_lineyBp_BwBi1_BwtF
+ // CHECK: bb{{[0-9]+}}([[RESULT:%.*]] : @owned $NSString):
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole5useNSyySo8NSStringCF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_RESULT]])
+ useNS(object[index] as NSString)
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole24testNullableSubscriptGet6object5indexySo0eF0C_yXltF
+func testNullableSubscriptGet(object: NullableSubscript, index: AnyObject) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $NullableSubscript,
+ // CHECK: [[BRIDGE_TO_ID:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK-NEXT: [[INDEX:%.*]] = apply [[BRIDGE_TO_ID]]
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[INDEX]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[INDEX]] : $AnyObject
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole8useOptNSyySo8NSStringCSgF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_RESULT]])
+ useOptNS(object[index] as NSString?)
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole25testNullproneSubscriptGet6object5indexySo0eF0C_yXltF
+func testNullproneSubscriptGet(object: NullproneSubscript, index: AnyObject) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $NullproneSubscript,
+ // CHECK: [[BRIDGE_TO_ID:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK-NEXT: [[INDEX:%.*]] = apply [[BRIDGE_TO_ID]]
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[INDEX]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[INDEX]] : $AnyObject
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole8useOptNSyySo8NSStringCSgF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_RESULT]])
+ useOptNS(object[index] as NSString?)
+
+ // CHECK: [[BRIDGE_TO_ID:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK-NEXT: [[INDEX:%.*]] = apply [[BRIDGE_TO_ID]]
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[INDEX]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[INDEX]] : $AnyObject
+ // CHECK-NEXT: switch_enum [[RESULT]]
+ // CHECK: function_ref @$Ss30_diagnoseUnexpectedNilOptional14_filenameStart01_E6Length01_E7IsASCII5_lineyBp_BwBi1_BwtF
+ // CHECK: bb{{[0-9]+}}([[RESULT:%.*]] : @owned $NSString):
+ // CHECK: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK: [[USE:%.*]] = function_ref @$S22objc_bridging_peephole5useNSyySo8NSStringCF
+ // CHECK-NEXT: apply [[USE]]([[BORROWED_RESULT]])
+ useNS(object[index] as NSString)
+
+ // CHECK: return
+}
+
+/*** Call arguments **********************************************************/
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole18testMethodArgument5dummyySo10DummyClassC_tF
+func testMethodArgument(dummy: DummyClass) {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $DummyClass):
+ // CHECK: // function_ref
+ // CHECK-NEXT: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[ARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[ARG]]
+ dummy.takeNonnullString(makeNS() as String)
+
+ // CHECK: // function_ref
+ // CHECK-NEXT: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[OPTARG:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[ARG]] : $NSString
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[OPTARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[OPTARG]]
+ dummy.takeNullableString(makeNS() as String)
+
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[OPTARG:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[ARG]] : $NSString
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[OPTARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[OPTARG]]
+ dummy.takeNullproneString(makeNS() as String)
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole28testValueToOptMethodArgument5dummyySo10DummyClassC_tF
+func testValueToOptMethodArgument(dummy: DummyClass) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $DummyClass):
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[OPTARG:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[ARG]] : $NSString
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[OPTARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[OPTARG]]
+ dummy.takeNullableString(makeNS() as String?)
+
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[OPTARG:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[ARG]] : $NSString
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[OPTARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[OPTARG]]
+ dummy.takeNullproneString(makeNS() as String?)
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole09testOptToE14MethodArgument5dummyySo10DummyClassC_tF
+func testOptToOptMethodArgument(dummy: DummyClass) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $DummyClass):
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole9makeOptNSSo8NSStringCSgyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[ARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[ARG]]
+ dummy.takeNullableString(makeOptNS() as String?)
+
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole9makeOptNSSo8NSStringCSgyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[ARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[ARG]]
+ dummy.takeNullproneString(makeOptNS() as String?)
+
+ // CHECK: return
+}
+
+/*** Property assignments ****************************************************/
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole18testPropertySetter5dummyySo10DummyClassC_tF
+func testPropertySetter(dummy: DummyClass) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $DummyClass):
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[ARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[ARG]]
+ dummy.nonnullStringProperty = makeNS() as String
+
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[OPTARG:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[ARG]] : $NSString
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[OPTARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[OPTARG]]
+ dummy.nullableStringProperty = makeNS() as String
+
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[OPTARG:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[ARG]] : $NSString
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[OPTARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[OPTARG]]
+ dummy.nullproneStringProperty = makeNS() as String
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole28testValueToOptPropertySetter5dummyySo10DummyClassC_tF
+func testValueToOptPropertySetter(dummy: DummyClass) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $DummyClass):
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[OPTARG:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[ARG]] : $NSString
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[OPTARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[OPTARG]]
+ dummy.nullableStringProperty = makeNS() as String?
+
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[OPTARG:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[ARG]] : $NSString
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[OPTARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[OPTARG]]
+ dummy.nullproneStringProperty = makeNS() as String?
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole09testOptToE14PropertySetter5dummyySo10DummyClassC_tF
+func testOptToOptPropertySetter(dummy: DummyClass) {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $DummyClass):
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole9makeOptNSSo8NSStringCSgyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[ARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[ARG]]
+ dummy.nullableStringProperty = makeOptNS() as String?
+
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole9makeOptNSSo8NSStringCSgyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[METHOD:%.*]] = objc_method
+ // CHECK-NEXT: apply [[METHOD]]([[ARG]], [[SELF]])
+ // CHECK-NEXT: destroy_value [[ARG]]
+ dummy.nullproneStringProperty = makeOptNS() as String?
+
+ // CHECK: return
+}
+
+/*** Subscript assignments ***************************************************/
+
+// FIXME: apply peepholes to indices, too!
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole23testNonnullSubscriptSet6object5indexySo0eF0C_yXltF
+func testNonnullSubscriptSet(object: NonnullSubscript, index: AnyObject) {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $NonnullSubscript,
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK: [[BRIDGE_TO_ID:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK-NEXT: [[INDEX:%.*]] = apply [[BRIDGE_TO_ID]]
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: apply [[METHOD]]([[ARG]], [[INDEX]], [[SELF]])
+ // CHECK: destroy_value [[INDEX]]
+ // CHECK: destroy_value [[ARG]]
+ object[index] = makeNS() as String
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole24testNullableSubscriptSet6object5indexySo0eF0C_yXltF
+func testNullableSubscriptSet(object: NullableSubscript, index: AnyObject) {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $NullableSubscript,
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[OPTARG:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[ARG]]
+ // CHECK: [[BRIDGE_TO_ID:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK-NEXT: [[INDEX:%.*]] = apply [[BRIDGE_TO_ID]]
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: apply [[METHOD]]([[OPTARG]], [[INDEX]], [[SELF]])
+ // CHECK: destroy_value [[INDEX]]
+ // CHECK: destroy_value [[OPTARG]]
+ object[index] = makeNS() as String
+
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[OPTARG:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[ARG]]
+ // CHECK: [[BRIDGE_TO_ID:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK-NEXT: [[INDEX:%.*]] = apply [[BRIDGE_TO_ID]]
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: apply [[METHOD]]([[OPTARG]], [[INDEX]], [[SELF]])
+ // CHECK: destroy_value [[INDEX]]
+ // CHECK: destroy_value [[OPTARG]]
+ object[index] = makeNS() as String?
+
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole9makeOptNSSo8NSStringCSgyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK: [[BRIDGE_TO_ID:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK-NEXT: [[INDEX:%.*]] = apply [[BRIDGE_TO_ID]]
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: apply [[METHOD]]([[ARG]], [[INDEX]], [[SELF]])
+ // CHECK: destroy_value [[INDEX]]
+ // CHECK: destroy_value [[ARG]]
+ object[index] = makeOptNS() as String?
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole25testNullproneSubscriptSet6object5indexySo0eF0C_yXltF
+func testNullproneSubscriptSet(object: NullproneSubscript, index: AnyObject) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $NullproneSubscript,
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[OPTARG:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[ARG]]
+ // CHECK: [[BRIDGE_TO_ID:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK-NEXT: [[INDEX:%.*]] = apply [[BRIDGE_TO_ID]]
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: apply [[METHOD]]([[OPTARG]], [[INDEX]], [[SELF]])
+ // CHECK: destroy_value [[INDEX]]
+ // CHECK: destroy_value [[OPTARG]]
+ object[index] = makeNS() as String
+
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole6makeNSSo8NSStringCyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK-NEXT: [[OPTARG:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[ARG]]
+ // CHECK: [[BRIDGE_TO_ID:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK-NEXT: [[INDEX:%.*]] = apply [[BRIDGE_TO_ID]]
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: apply [[METHOD]]([[OPTARG]], [[INDEX]], [[SELF]])
+ // CHECK: destroy_value [[INDEX]]
+ // CHECK: destroy_value [[OPTARG]]
+ object[index] = makeNS() as String?
+
+ // CHECK: [[MAKE:%.*]] = function_ref @$S22objc_bridging_peephole9makeOptNSSo8NSStringCSgyF
+ // CHECK-NEXT: [[ARG:%.*]] = apply [[MAKE]]()
+ // CHECK: [[BRIDGE_TO_ID:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF
+ // CHECK-NEXT: [[INDEX:%.*]] = apply [[BRIDGE_TO_ID]]
+ // CHECK: [[METHOD:%.*]] = objc_method
+ // CHECK: apply [[METHOD]]([[ARG]], [[INDEX]], [[SELF]])
+ // CHECK: destroy_value [[INDEX]]
+ // CHECK: destroy_value [[ARG]]
+ object[index] = makeOptNS() as String?
+
+ // CHECK: return
+}
+
+/*** Bugfixes ***************************************************************/
+
+protocol P {
+ var title : String { get }
+}
+
+func foo(p: P) {
+ DummyClass().takeNullableString(p.title)
+}
+
+// rdar://35402853
+// Make sure that we don't peephole AnyObject? -> Any? -> AnyObject naively.
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole017testOptionalToNonE6BridgeyyF
+func testOptionalToNonOptionalBridge() {
+ // CHECK: apply {{.*}}() : $@convention(c) () -> @autoreleased Optional<AnyObject>
+ // CHECK: function_ref @$Ss018_bridgeAnyObjectToB0yypyXlSgF :
+ // CHECK: [[T0:%.*]] = function_ref @$SSq19_bridgeToObjectiveCyXlyF
+ // CHECK: apply [[T0]]<Any>
+ useAnyObject(returnNullableId() as AnyObject)
+} // CHECK: end sil function '$S22objc_bridging_peephole017testOptionalToNonE6BridgeyyF'
+
+// CHECK-LABEL: sil hidden @$S22objc_bridging_peephole34testBlockToOptionalAnyObjectBridge5blockyyyXB_tF
+func testBlockToOptionalAnyObjectBridge(block: @escaping @convention(block) () -> ()) {
+ // CHECK: [[T0:%.*]] = begin_borrow {{%.*}} : $@convention(block) () -> ()
+ // CHECK-NEXT: [[T1:%.*]] = copy_value [[T0]]
+ // CHECK-NEXT: [[REF:%.*]] = unchecked_ref_cast [[T1]] : $@convention(block) () -> () to $AnyObject
+ // CHECK-NEXT: [[OPTREF:%.*]] = enum $Optional<AnyObject>, #Optional.some!enumelt.1, [[REF]] : $AnyObject
+ // CHECK-NEXT: end_borrow [[T0]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[FN:%.*]] = function_ref @takeNullableId : $@convention(c) (Optional<AnyObject>) -> ()
+ // CHECK-NEXT: apply [[FN]]([[OPTREF]])
+ // CHECK-NEXT: destroy_value [[OPTREF]]
+ takeNullableId(block as Any)
+}
diff --git a/test/SILGen/plus_zero_objc_currying.swift b/test/SILGen/plus_zero_objc_currying.swift
new file mode 100644
index 0000000..8094585
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_currying.swift
@@ -0,0 +1,212 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %build-silgen-test-overlays
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -enable-sil-ownership -emit-silgen %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+import gizmo
+
+func curry_pod(_ x: CurryTest) -> (Int) -> Int {
+ return x.pod
+}
+// CHECK-LABEL: sil hidden @$S13objc_currying9curry_podyS2icSo9CurryTestCF : $@convention(thin) (@guaranteed CurryTest) -> @owned @callee_guaranteed (Int) -> Int
+// CHECK: bb0([[ARG1:%.*]] : @guaranteed $CurryTest):
+// CHECK: [[THUNK:%.*]] = function_ref @[[THUNK_FOO_1:\$SSo9CurryTestC3podyS2iFTcTO]] : $@convention(thin) (@guaranteed CurryTest) -> @owned @callee_guaranteed (Int) -> Int
+// CHECK: [[FN:%.*]] = apply [[THUNK]]([[ARG1]])
+// CHECK-NOT: destroy_value
+// CHECK: return [[FN]]
+// CHECK: } // end sil function '$S13objc_currying9curry_podyS2icSo9CurryTestCF'
+
+// CHECK: sil shared [serializable] [thunk] @[[THUNK_FOO_1]] : $@convention(thin) (@guaranteed CurryTest) -> @owned @callee_guaranteed (Int) -> Int
+// CHECK: bb0([[ARG1:%.*]] : @guaranteed $CurryTest):
+// CHECK: [[THUNK:%.*]] = function_ref @[[THUNK_FOO_2:\$SSo9CurryTestC3podyS2iFTO]]
+// CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]]
+// CHECK: [[FN:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[ARG1_COPY]])
+// CHECK-NOT: destroy_value
+// CHECK: return [[FN]]
+// CHECK: } // end sil function '[[THUNK_FOO_1]]'
+
+// CHECK: sil shared [serializable] [thunk] @[[THUNK_FOO_2]] : $@convention(method) (Int, @guaranteed CurryTest) -> Int
+// CHECK: bb0([[ARG1:%.*]] : @trivial $Int, [[ARG2:%.*]] : @guaranteed $CurryTest):
+// CHECK: [[COPIED_ARG2:%.*]] = copy_value [[ARG2]]
+// CHECK: [[METHOD:%.*]] = objc_method [[COPIED_ARG2]] : $CurryTest, #CurryTest.pod!1.foreign
+// CHECK: [[RESULT:%.*]] = apply [[METHOD]]([[ARG1]], [[COPIED_ARG2]])
+// CHECK: destroy_value [[COPIED_ARG2]]
+// CHECK: return [[RESULT]]
+// CHECK: } // end sil function '[[THUNK_FOO_2]]'
+
+func curry_bridged(_ x: CurryTest) -> (String?) -> String? {
+ return x.bridged
+}
+// CHECK-LABEL: sil hidden @$S13objc_currying13curry_bridgedySSSgACcSo9CurryTestCF : $@convention(thin) (@guaranteed CurryTest) -> @owned @callee_guaranteed (@guaranteed Optional<String>) -> @owned Optional<String>
+// CHECK: bb0([[ARG1:%.*]] : @guaranteed $CurryTest):
+// CHECK: [[THUNK:%.*]] = function_ref @[[THUNK_BAR_1:\$SSo9CurryTestC7bridgedySSSgADFTcTO]]
+// CHECK: [[FN:%.*]] = apply [[THUNK]]([[ARG1]])
+// CHECK-NOT: destroy_value [[ARG1]]
+// CHECK: return [[FN]]
+// CHECK: } // end sil function '$S13objc_currying13curry_bridgedySSSgACcSo9CurryTestCF'
+
+// CHECK: sil shared [serializable] [thunk] @[[THUNK_BAR_1]] : $@convention(thin) (@guaranteed CurryTest) -> @owned @callee_guaranteed (@guaranteed Optional<String>) -> @owned Optional<String>
+// CHECK: bb0([[ARG1:%.*]] : @guaranteed $CurryTest):
+// CHECK: [[THUNK:%.*]] = function_ref @[[THUNK_BAR_2:\$SSo9CurryTestC7bridgedySSSgADFTO]]
+// CHECK: [[COPY_ARG1:%.*]] = copy_value [[ARG1]]
+// CHECK: [[FN:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[COPY_ARG1]])
+// CHECK: return [[FN]]
+// CHECK: } // end sil function '[[THUNK_BAR_1]]'
+
+// CHECK: sil shared [serializable] [thunk] @[[THUNK_BAR_2]] : $@convention(method) (@guaranteed Optional<String>, @guaranteed CurryTest) -> @owned Optional<String>
+// CHECK: bb0([[OPT_STRING:%.*]] : @guaranteed $Optional<String>, [[SELF:%.*]] : @guaranteed $CurryTest):
+// CHECK: [[COPY_OPT_STRING:%.*]] = copy_value [[OPT_STRING]]
+// CHECK: switch_enum [[COPY_OPT_STRING]] : $Optional<String>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]],
+//
+// CHECK: [[SOME_BB]]([[STRING:%.*]] : @owned $String):
+// CHECK: [[BRIDGING_FUNC:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+// CHECK: [[BORROWED_STRING:%.*]] = begin_borrow [[STRING]]
+// CHECK: [[NSSTRING:%.*]] = apply [[BRIDGING_FUNC]]([[BORROWED_STRING]])
+// CHECK: [[OPT_NSSTRING:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[NSSTRING]] : $NSString
+// CHECK: end_borrow [[BORROWED_STRING]] from [[STRING]]
+// CHECK: destroy_value [[STRING]]
+// CHECK: br bb3([[OPT_NSSTRING]] : $Optional<NSString>)
+
+// CHECK: bb2:
+// CHECK: [[OPT_NONE:%.*]] = enum $Optional<NSString>, #Optional.none!enumelt
+// CHECK: br bb3([[OPT_NONE]] : $Optional<NSString>)
+
+// CHECK: bb3([[OPT_NSSTRING:%.*]] : @owned $Optional<NSString>):
+// CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+// CHECK: [[METHOD:%.*]] = objc_method [[SELF_COPY]] : $CurryTest, #CurryTest.bridged!1.foreign
+// CHECK: [[RESULT_OPT_NSSTRING:%.*]] = apply [[METHOD]]([[OPT_NSSTRING]], [[SELF_COPY]]) : $@convention(objc_method) (Optional<NSString>, CurryTest) -> @autoreleased Optional<NSString>
+// CHECK: switch_enum [[RESULT_OPT_NSSTRING]] : $Optional<NSString>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]],
+
+// CHECK: [[SOME_BB]]([[RESULT_NSSTRING:%.*]] : @owned $NSString):
+// CHECK: [[BRIDGE_FUNC:%.*]] = function_ref @$SSS10FoundationE36_unconditionallyBridgeFromObjectiveCySSSo8NSStringCSgFZ
+// CHECK: [[REWRAP_RESULT_NSSTRING:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[RESULT_NSSTRING]]
+// CHECK: [[RESULT_STRING:%.*]] = apply [[BRIDGE_FUNC]]([[REWRAP_RESULT_NSSTRING]]
+// CHECK: [[WRAPPED_RESULT_STRING:%.*]] = enum $Optional<String>, #Optional.some!enumelt.1, [[RESULT_STRING]]
+// CHECK: br bb6([[WRAPPED_RESULT_STRING]] : $Optional<String>)
+
+// CHECK: bb5:
+// CHECK: [[OPT_NONE:%.*]] = enum $Optional<String>, #Optional.none!enumelt
+// CHECK: br bb6([[OPT_NONE]] : $Optional<String>)
+
+// CHECK: bb6([[FINAL_RESULT:%.*]] : @owned $Optional<String>):
+// CHECK: destroy_value [[SELF_COPY]]
+// CHECK: destroy_value [[OPT_NSSTRING]]
+// CHECK: return [[FINAL_RESULT]] : $Optional<String>
+// CHECK: } // end sil function '[[THUNK_BAR_2]]'
+
+func curry_returnsInnerPointer(_ x: CurryTest) -> () -> UnsafeMutableRawPointer? {
+ return x.returnsInnerPointer
+}
+// CHECK-LABEL: sil hidden @$S13objc_currying25curry_returnsInnerPointerySvSgycSo9CurryTestCF : $@convention(thin) (@guaranteed CurryTest) -> @owned @callee_guaranteed () -> Optional<UnsafeMutableRawPointer> {
+// CHECK: bb0([[SELF:%.*]] : @guaranteed $CurryTest):
+// CHECK: [[THUNK:%.*]] = function_ref @[[THUNK_RETURNSINNERPOINTER:\$SSo9CurryTestC19returnsInnerPointerSvSgyFTcTO]]
+// CHECK: [[FN:%.*]] = apply [[THUNK]]([[SELF]])
+// CHECK-NOT: destroy_value [[SELF]]
+// CHECK: return [[FN]]
+// CHECK: } // end sil function '$S13objc_currying25curry_returnsInnerPointerySvSgycSo9CurryTestCF'
+
+// CHECK: sil shared [serializable] [thunk] @[[THUNK_RETURNSINNERPOINTER]] : $@convention(thin) (@guaranteed CurryTest) -> @owned @callee_guaranteed () -> Optional<UnsafeMutableRawPointer>
+// CHECK: bb0([[ARG1:%.*]] : @guaranteed
+// CHECK: [[THUNK:%.*]] = function_ref @[[THUNK_RETURNSINNERPOINTER_2:\$SSo9CurryTestC19returnsInnerPointerSvSgyFTO]]
+// CHECK: [[COPY_ARG1:%.*]] = copy_value [[ARG1]]
+// CHECK: [[FN:%.*]] = partial_apply [callee_guaranteed] [[THUNK]]([[COPY_ARG1]])
+// CHECK: return [[FN]]
+// CHECK: } // end sil function '[[THUNK_RETURNSINNERPOINTER]]'
+
+// CHECK: sil shared [serializable] [thunk] @[[THUNK_RETURNSINNERPOINTER_2]] : $@convention(method) (@guaranteed CurryTest) -> Optional<UnsafeMutableRawPointer>
+// CHECK: bb0([[ARG1:%.*]] : @guaranteed $CurryTest):
+// CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]]
+// CHECK: [[METHOD:%.*]] = objc_method [[ARG1_COPY]] : $CurryTest, #CurryTest.returnsInnerPointer!1.foreign
+// CHECK: [[RES:%.*]] = apply [[METHOD]]([[ARG1_COPY]]) : $@convention(objc_method) (CurryTest) -> @unowned_inner_pointer Optional<UnsafeMutableRawPointer>
+// CHECK: autorelease_value
+// CHECK: return [[RES]]
+// CHECK: } // end sil function '[[THUNK_RETURNSINNERPOINTER_2]]'
+
+// CHECK-LABEL: sil hidden @$S13objc_currying19curry_pod_AnyObjectyS2icyXlF : $@convention(thin) (@guaranteed AnyObject) -> @owned @callee_guaranteed (Int) -> Int
+// CHECK: bb0([[ANY:%.*]] : @guaranteed $AnyObject):
+// CHECK: [[OPENED_ANY:%.*]] = open_existential_ref [[ANY]]
+// CHECK: [[OPENED_ANY_COPY:%.*]] = copy_value [[OPENED_ANY]]
+// CHECK: dynamic_method_br [[OPENED_ANY_COPY]] : $@opened({{.*}}) AnyObject, #CurryTest.pod!1.foreign, [[HAS_METHOD:bb[0-9]+]]
+// CHECK: [[HAS_METHOD]]([[METHOD:%.*]] : @trivial $@convention(objc_method) (Int, @opened({{.*}}) AnyObject) -> Int):
+// CHECK: [[OPENED_ANY_COPY_2:%.*]] = copy_value [[OPENED_ANY_COPY]]
+// CHECK: partial_apply [callee_guaranteed] [[METHOD]]([[OPENED_ANY_COPY_2]])
+// CHECK: } // end sil function '$S13objc_currying19curry_pod_AnyObjectyS2icyXlF'
+func curry_pod_AnyObject(_ x: AnyObject) -> (Int) -> Int {
+ return x.pod!
+}
+
+// normalOwnership requires a thunk to bring the method to Swift conventions
+// CHECK-LABEL: sil hidden @$S13objc_currying31curry_normalOwnership_AnyObjectySo9CurryTestCSgAEcyXlF : $@convention(thin) (@guaranteed AnyObject) -> @owned @callee_guaranteed (@guaranteed Optional<CurryTest>) -> @owned Optional<CurryTest> {
+// CHECK: bb0([[ANY:%.*]] : @guaranteed $AnyObject):
+// CHECK: [[OPENED_ANY:%.*]] = open_existential_ref [[ANY]]
+// CHECK: [[OPENED_ANY_COPY:%.*]] = copy_value [[OPENED_ANY]]
+// CHECK: dynamic_method_br [[OPENED_ANY_COPY]] : $@opened({{.*}}) AnyObject, #CurryTest.normalOwnership!1.foreign, [[HAS_METHOD:bb[0-9]+]]
+// CHECK: [[HAS_METHOD]]([[METHOD:%.*]] : @trivial $@convention(objc_method) (Optional<CurryTest>, @opened({{.*}}) AnyObject) -> @autoreleased Optional<CurryTest>):
+// CHECK: [[OPENED_ANY_COPY_2:%.*]] = copy_value [[OPENED_ANY_COPY]]
+// CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[METHOD]]([[OPENED_ANY_COPY_2]])
+// CHECK: [[THUNK:%.*]] = function_ref @$SSo9CurryTestCSgACIegyo_A2CIeggo_TR
+// CHECK: partial_apply [callee_guaranteed] [[THUNK]]([[PA]])
+// CHECK: } // end sil function '$S13objc_currying31curry_normalOwnership_AnyObjectySo9CurryTestCSgAEcyXlF'
+func curry_normalOwnership_AnyObject(_ x: AnyObject) -> (CurryTest?) -> CurryTest? {
+ return x.normalOwnership!
+}
+
+// weirdOwnership is NS_RETURNS_RETAINED and NS_CONSUMES_SELF so already
+// follows Swift conventions
+// CHECK-LABEL: sil hidden @$S13objc_currying30curry_weirdOwnership_AnyObjectySo9CurryTestCSgAEcyXlF : $@convention(thin) (@guaranteed AnyObject) -> @owned @callee_guaranteed (@guaranteed Optional<CurryTest>) -> @owned Optional<CurryTest>
+// CHECK: bb0([[ANY:%.*]] : @guaranteed $AnyObject):
+// CHECK: [[OPENED_ANY:%.*]] = open_existential_ref [[ANY]]
+// CHECK: [[OPENED_ANY_COPY:%.*]] = copy_value [[OPENED_ANY]]
+// CHECK: dynamic_method_br [[SELF:%.*]] : $@opened({{.*}}) AnyObject, #CurryTest.weirdOwnership!1.foreign, [[HAS_METHOD:bb[0-9]+]]
+//
+// CHECK: bb1([[METHOD:%.*]] : @trivial $@convention(objc_method) (@owned Optional<CurryTest>, @owned @opened({{.*}}) AnyObject) -> @owned Optional<CurryTest>):
+// CHECK: [[OPENED_ANY_COPY_2:%.*]] = copy_value [[OPENED_ANY_COPY]]
+// CHECK: partial_apply [callee_guaranteed] [[METHOD]]([[OPENED_ANY_COPY_2]])
+// CHECK: } // end sil function '$S13objc_currying30curry_weirdOwnership_AnyObjectySo9CurryTestCSgAEcyXlF'
+func curry_weirdOwnership_AnyObject(_ x: AnyObject) -> (CurryTest?) -> CurryTest? {
+ return x.weirdOwnership!
+}
+
+// bridged requires a thunk to handle bridging conversions
+// CHECK-LABEL: sil hidden @$S13objc_currying23curry_bridged_AnyObjectySSSgACcyXlF : $@convention(thin) (@guaranteed AnyObject) -> @owned @callee_guaranteed (@guaranteed Optional<String>) -> @owned Optional<String>
+// CHECK: bb0([[ANY:%.*]] : @guaranteed $AnyObject):
+// CHECK: [[OPENED_ANY:%.*]] = open_existential_ref [[ANY]]
+// CHECK: [[OPENED_ANY_COPY:%.*]] = copy_value [[OPENED_ANY]]
+// CHECK: dynamic_method_br [[OPENED_ANY_COPY]] : $@opened({{.*}}) AnyObject, #CurryTest.bridged!1.foreign, [[HAS_METHOD:bb[0-9]+]]
+// CHECK: } // end sil function '$S13objc_currying23curry_bridged_AnyObjectySSSgACcyXlF'
+func curry_bridged_AnyObject(_ x: AnyObject) -> (String?) -> String? {
+ return x.bridged!
+}
+
+// check that we substitute Self = AnyObject correctly for Self-returning
+// methods
+// CHECK-LABEL: sil hidden @$S13objc_currying27curry_returnsSelf_AnyObjectyyXlSgycyXlF : $@convention(thin) (@guaranteed AnyObject) -> @owned @callee_guaranteed () -> @owned Optional<AnyObject> {
+// CHECK: bb0([[ANY:%.*]] : @guaranteed $AnyObject):
+// CHECK: [[OPENED_ANY:%.*]] = open_existential_ref [[ANY]]
+// CHECK: [[OPENED_ANY_COPY:%.*]] = copy_value [[OPENED_ANY]]
+// CHECK: dynamic_method_br [[OPENED_ANY_COPY]] : $@opened({{.*}}) AnyObject, #CurryTest.returnsSelf!1.foreign, [[HAS_METHOD:bb[0-9]+]]
+// CHECK: [[HAS_METHOD]]([[METHOD:%.*]] : @trivial $@convention(objc_method) (@opened({{.*}}) AnyObject) -> @autoreleased Optional<AnyObject>):
+// CHECK: [[OPENED_ANY_COPY_2:%.*]] = copy_value [[OPENED_ANY_COPY]]
+// CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[METHOD]]([[OPENED_ANY_COPY_2]])
+// CHECK: } // end sil function '$S13objc_currying27curry_returnsSelf_AnyObjectyyXlSgycyXlF'
+func curry_returnsSelf_AnyObject(_ x: AnyObject) -> () -> AnyObject? {
+ return x.returnsSelf!
+}
+
+// CHECK-LABEL: sil hidden @$S13objc_currying35curry_returnsInnerPointer_AnyObjectySvSgycyXlF : $@convention(thin) (@guaranteed AnyObject) -> @owned @callee_guaranteed () -> Optional<UnsafeMutableRawPointer> {
+// CHECK: bb0([[ANY:%.*]] : @guaranteed $AnyObject):
+// CHECK: [[OPENED_ANY:%.*]] = open_existential_ref [[ANY]]
+// CHECK: [[OPENED_ANY_COPY:%.*]] = copy_value [[OPENED_ANY]]
+// CHECK: dynamic_method_br [[OPENED_ANY_COPY]] : $@opened({{.*}}) AnyObject, #CurryTest.returnsInnerPointer!1.foreign, [[HAS_METHOD:bb[0-9]+]]
+// CHECK: [[HAS_METHOD]]([[METHOD:%.*]] : @trivial $@convention(objc_method) (@opened({{.*}}) AnyObject) -> @unowned_inner_pointer Optional<UnsafeMutableRawPointer>):
+// CHECK: [[OPENED_ANY_COPY_2:%.*]] = copy_value [[OPENED_ANY_COPY]]
+// CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[METHOD]]([[OPENED_ANY_COPY_2]])
+// CHECK: } // end sil function '$S13objc_currying35curry_returnsInnerPointer_AnyObjectySvSgycyXlF'
+
+func curry_returnsInnerPointer_AnyObject(_ x: AnyObject) -> () -> UnsafeMutableRawPointer? {
+ return x.returnsInnerPointer!
+}
+
diff --git a/test/SILGen/plus_zero_objc_dictionary_bridging.swift b/test/SILGen/plus_zero_objc_dictionary_bridging.swift
new file mode 100644
index 0000000..cee9ad3
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_dictionary_bridging.swift
@@ -0,0 +1,96 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %build-silgen-test-overlays
+
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+import gizmo
+
+@objc class Foo : NSObject {
+ // Bridging dictionary parameters
+ // CHECK-LABEL: sil hidden [thunk] @$S24objc_dictionary_bridging3FooC23bridge_Dictionary_param{{[_0-9a-zA-Z]*}}FTo : $@convention(objc_method) (NSDictionary, Foo) -> ()
+ func bridge_Dictionary_param(_ dict: Dictionary<Foo, Foo>) {
+ // CHECK: bb0([[NSDICT:%[0-9]+]] : @unowned $NSDictionary, [[SELF:%[0-9]+]] : @unowned $Foo):
+ // CHECK: [[NSDICT_COPY:%.*]] = copy_value [[NSDICT]]
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[CONVERTER:%[0-9]+]] = function_ref @$Ss10DictionaryV10FoundationE36_unconditionallyBridgeFromObjectiveCyAByxq_GSo12NSDictionaryCSgFZ
+ // CHECK: [[OPT_NSDICT:%[0-9]+]] = enum $Optional<NSDictionary>, #Optional.some!enumelt.1, [[NSDICT_COPY]] : $NSDictionary
+ // CHECK: [[DICT_META:%[0-9]+]] = metatype $@thin Dictionary<Foo, Foo>.Type
+ // CHECK: [[DICT:%[0-9]+]] = apply [[CONVERTER]]<Foo, Foo>([[OPT_NSDICT]], [[DICT_META]])
+ // CHECK: [[BORROWED_DICT:%.*]] = begin_borrow [[DICT]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[SWIFT_FN:%[0-9]+]] = function_ref @$S24objc_dictionary_bridging3FooC23bridge_Dictionary_param{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[SWIFT_FN]]([[BORROWED_DICT]], [[BORROWED_SELF_COPY]]) : $@convention(method) (@guaranteed Dictionary<Foo, Foo>, @guaranteed Foo) -> ()
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK: return [[RESULT]] : $()
+ }
+ // CHECK: } // end sil function '$S24objc_dictionary_bridging3FooC23bridge_Dictionary_param{{[_0-9a-zA-Z]*}}FTo'
+
+ // Bridging dictionary results
+ // CHECK-LABEL: sil hidden [thunk] @$S24objc_dictionary_bridging3FooC24bridge_Dictionary_result{{[_0-9a-zA-Z]*}}FTo : $@convention(objc_method) (Foo) -> @autoreleased NSDictionary
+ func bridge_Dictionary_result() -> Dictionary<Foo, Foo> {
+ // CHECK: bb0([[SELF:%[0-9]+]] : @unowned $Foo):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[SWIFT_FN:%[0-9]+]] = function_ref @$S24objc_dictionary_bridging3FooC24bridge_Dictionary_result{{[_0-9a-zA-Z]*}}F : $@convention(method) (@guaranteed Foo) -> @owned Dictionary<Foo, Foo>
+ // CHECK: [[DICT:%[0-9]+]] = apply [[SWIFT_FN]]([[BORROWED_SELF_COPY]]) : $@convention(method) (@guaranteed Foo) -> @owned Dictionary<Foo, Foo>
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+
+ // CHECK: [[CONVERTER:%[0-9]+]] = function_ref @$Ss10DictionaryV10FoundationE19_bridgeToObjectiveCSo12NSDictionaryCyF
+ // CHECK: [[BORROWED_DICT:%.*]] = begin_borrow [[DICT]]
+ // CHECK: [[NSDICT:%[0-9]+]] = apply [[CONVERTER]]<Foo, Foo>([[BORROWED_DICT]]) : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned NSDictionary
+ // CHECK: end_borrow [[BORROWED_DICT]] from [[DICT]]
+ // CHECK: destroy_value [[DICT]]
+ // CHECK: return [[NSDICT]] : $NSDictionary
+ }
+ // CHECK: } // end sil function '$S24objc_dictionary_bridging3FooC24bridge_Dictionary_result{{[_0-9a-zA-Z]*}}FTo'
+
+ var property: Dictionary<Foo, Foo> = [:]
+
+ // Property getter
+ // CHECK-LABEL: sil hidden [thunk] @$S24objc_dictionary_bridging3FooC8propertys10DictionaryVyA2CSo8NSObjectCs8Hashable10Foundationg_GvgTo : $@convention(objc_method) (Foo) -> @autoreleased NSDictionary
+ // @$S24objc_dictionary_bridging3FooC8propertys10DictionaryVyA2CSo8NSObjectCs8Hashable10Foundationg_Gvpfi
+ // CHECK: bb0([[SELF:%[0-9]+]] : @unowned $Foo):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[GETTER:%[0-9]+]] = function_ref @$S24objc_dictionary_bridging3FooC8propertys10DictionaryVyA2CSo8NSObjectCs8Hashable10Foundationg_Gvg : $@convention(method) (@guaranteed Foo) -> @owned Dictionary<Foo, Foo>
+ // CHECK: [[DICT:%[0-9]+]] = apply [[GETTER]]([[BORROWED_SELF_COPY]]) : $@convention(method) (@guaranteed Foo) -> @owned Dictionary<Foo, Foo>
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK: [[CONVERTER:%[0-9]+]] = function_ref @$Ss10DictionaryV10FoundationE19_bridgeToObjectiveCSo12NSDictionaryCyF
+ // CHECK: [[BORROWED_DICT:%.*]] = begin_borrow [[DICT]]
+ // CHECK: [[NSDICT:%[0-9]+]] = apply [[CONVERTER]]<Foo, Foo>([[BORROWED_DICT]]) : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned NSDictionary
+ // CHECK: end_borrow [[BORROWED_DICT]] from [[DICT]]
+ // CHECK: destroy_value [[DICT]]
+ // CHECK: return [[NSDICT]] : $NSDictionary
+ // CHECK: } // end sil function
+
+ // Property setter
+ // CHECK-LABEL: sil hidden [thunk] @$S24objc_dictionary_bridging3FooC8propertys10DictionaryVyA2CSo8NSObjectCs8Hashable10Foundationg_GvsTo : $@convention(objc_method) (NSDictionary, Foo) -> ()
+ // CHECK: bb0([[NSDICT:%[0-9]+]] : @unowned $NSDictionary, [[SELF:%[0-9]+]] : @unowned $Foo):
+ // CHECK: [[NSDICT_COPY:%.*]] = copy_value [[NSDICT]]
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[CONVERTER:%[0-9]+]] = function_ref @$Ss10DictionaryV10FoundationE36_unconditionallyBridgeFromObjectiveCyAByxq_GSo12NSDictionaryCSgFZ
+ // CHECK: [[OPT_NSDICT:%[0-9]+]] = enum $Optional<NSDictionary>, #Optional.some!enumelt.1, [[NSDICT_COPY]] : $NSDictionary
+ // CHECK: [[DICT_META:%[0-9]+]] = metatype $@thin Dictionary<Foo, Foo>.Type
+ // CHECK: [[DICT:%[0-9]+]] = apply [[CONVERTER]]<Foo, Foo>([[OPT_NSDICT]], [[DICT_META]])
+
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[SETTER:%[0-9]+]] = function_ref @$S24objc_dictionary_bridging3FooC8propertys10DictionaryVyA2CSo8NSObjectCs8Hashable10Foundationg_Gvs : $@convention(method) (@owned Dictionary<Foo, Foo>, @guaranteed Foo) -> ()
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[SETTER]]([[DICT]], [[BORROWED_SELF_COPY]]) : $@convention(method) (@owned Dictionary<Foo, Foo>, @guaranteed Foo) -> ()
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK: return [[RESULT]] : $()
+
+ // CHECK-LABEL: sil hidden [thunk] @$S24objc_dictionary_bridging3FooC19nonVerbatimProperty{{[_0-9a-zA-Z]*}}vgTo : $@convention(objc_method) (Foo) -> @autoreleased NSDictionary
+
+ // CHECK-LABEL: sil hidden [thunk] @$S24objc_dictionary_bridging3FooC19nonVerbatimProperty{{[_0-9a-zA-Z]*}}vsTo : $@convention(objc_method) (NSDictionary, Foo) -> ()
+ @objc var nonVerbatimProperty: Dictionary<String, Int> = [:]
+}
+
+func ==(x: Foo, y: Foo) -> Bool { }
diff --git a/test/SILGen/plus_zero_objc_error.swift b/test/SILGen/plus_zero_objc_error.swift
new file mode 100644
index 0000000..e48d19c
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_error.swift
@@ -0,0 +1,173 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %build-clang-importer-objc-overlays
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+
+// CHECK-LABEL: sil hidden @$S10objc_error20NSErrorError_erasureys0D0_pSo0C0CF : $@convention(thin) (@guaranteed NSError) -> @owned Error {
+// CHECK: bb0([[ERROR:%.*]] : @guaranteed $NSError):
+// CHECK: [[ERROR_COPY:%.*]] = copy_value [[ERROR]]
+// CHECK: [[ERROR_TYPE:%.*]] = init_existential_ref [[ERROR_COPY]] : $NSError : $NSError, $Error
+// CHECK-NOT: destroy_value [[ERROR]]
+// CHECK: return [[ERROR_TYPE]]
+// CHECK: } // end sil function '$S10objc_error20NSErrorError_erasureys0D0_pSo0C0CF'
+func NSErrorError_erasure(_ x: NSError) -> Error {
+ return x
+}
+
+// CHECK-LABEL: sil hidden @$S10objc_error30NSErrorError_archetype_erasureys0D0_pxSo0C0CRbzlF : $@convention(thin) <T where T : NSError> (@guaranteed T) -> @owned Error {
+// CHECK: bb0([[ERROR:%.*]] : @guaranteed $T):
+// CHECK: [[ERROR_COPY:%.*]] = copy_value [[ERROR]]
+// CHECK: [[T0:%.*]] = upcast [[ERROR_COPY]] : $T to $NSError
+// CHECK: [[ERROR_TYPE:%.*]] = init_existential_ref [[T0]] : $NSError : $NSError, $Error
+// CHECK-NOT: destroy_value [[ERROR]]
+// CHECK: return [[ERROR_TYPE]]
+// CHECK: } // end sil function '$S10objc_error30NSErrorError_archetype_erasureys0D0_pxSo0C0CRbzlF'
+func NSErrorError_archetype_erasure<T : NSError>(_ t: T) -> Error {
+ return t
+}
+
+// Test patterns that are non-trivial, but irrefutable. SILGen shouldn't crash
+// on these.
+func test_doesnt_throw() {
+ do {
+ throw NSError(domain: "", code: 1, userInfo: [:])
+ } catch is Error { // expected-warning {{'is' test is always true}}
+ }
+
+ do {
+ throw NSError(domain: "", code: 1, userInfo: [:])
+ } catch let e as NSError { // ok.
+ _ = e
+ }
+}
+
+class ErrorClass: Error {
+ let _domain = ""
+ let _code = 0
+}
+
+// Class-to-NSError casts must be done as indirect casts since they require
+// a representation change, and checked_cast_br currently doesn't allow that.
+
+// CHECK-LABEL: sil hidden @$S10objc_error20test_cast_to_nserroryyF
+func test_cast_to_nserror() {
+ let e = ErrorClass()
+
+ // CHECK: function_ref @$S10Foundation22_convertErrorToNSErrorySo0E0Cs0C0_pF
+ let nsCoerced = e as Error as NSError
+
+ // CHECK: unconditional_checked_cast_addr AnyObject in {{%.*}} : $*AnyObject to NSError in {{%.*}} : $*NSError
+ let nsForcedCast = (e as AnyObject) as! NSError
+
+ // CHECK: checked_cast_addr_br {{.*}} Error in {{%.*}} : $*Error to NSError in {{%.*}} : $*NSError, bb3, bb4
+ do {
+ throw e
+ } catch _ as NSError {
+
+ }
+}
+
+// A class-constrained archetype may be NSError, so we can't use scalar casts
+// in that case either.
+// CHECK-LABEL: sil hidden @$S10objc_error28test_cast_to_class_archetype{{[_0-9a-zA-Z]*}}F
+func test_cast_to_class_archetype<T: AnyObject>(_: T) {
+ // CHECK: unconditional_checked_cast_addr ErrorClass in {{%.*}} : $*ErrorClass to T in {{.*}} : $*T
+ let e = ErrorClass()
+ let forcedCast = e as! T
+}
+
+// CHECK-LABEL: sil hidden @$S10objc_error15testAcceptError{{[_0-9a-zA-Z]*}}F
+func testAcceptError(error: Error) {
+ // CHECK-NOT: return
+ // CHECK: function_ref @$S10Foundation22_convertErrorToNSErrorySo0E0Cs0C0_pF
+ acceptError(error)
+}
+
+// CHECK-LABEL: sil hidden @$S10objc_error16testProduceError{{[_0-9a-zA-Z]*}}F
+func testProduceError() -> Error {
+ // CHECK: function_ref @produceError : $@convention(c) () -> @autoreleased NSError
+ // CHECK: init_existential_ref {{.*}} : $NSError : $NSError, $Error
+ return produceError()
+}
+
+// CHECK-LABEL: sil hidden @$S10objc_error24testProduceOptionalError{{[_0-9a-zA-Z]*}}F
+func testProduceOptionalError() -> Error? {
+ // CHECK: function_ref @produceOptionalError
+ // CHECK: init_existential_ref {{.*}} : $NSError : $NSError, $Error
+ return produceOptionalError();
+}
+
+class MyNSError : NSError {
+ override init() {
+ super.init(domain: "MyNSError", code: 0, userInfo: [:])
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10objc_error14eraseMyNSError{{[_0-9a-zA-Z]*}}F : $@convention(thin) () -> @owned Error {
+// CHECK: bb0:
+// CHECK: [[NSERROR_SUBCLASS:%.*]] = apply {{.*}}({{.*}}) : $@convention(method) (@thick MyNSError.Type) -> @owned MyNSError
+// CHECK: [[UPCAST:%.*]] = upcast [[NSERROR_SUBCLASS]] : $MyNSError to $NSError
+// CHECK: [[EXISTENTIAL_REF:%.*]] = init_existential_ref [[UPCAST]]
+// CHECK: [[BORROWED_EXISTENTIAL_REF:%.*]] = begin_borrow [[EXISTENTIAL_REF]]
+// CHECK: [[COPY_BORROWED_EXISTENTIAL_REF:%.*]] = copy_value [[BORROWED_EXISTENTIAL_REF]]
+// CHECK: end_borrow [[BORROWED_EXISTENTIAL_REF]] from [[EXISTENTIAL_REF]]
+// CHECK: destroy_value [[EXISTENTIAL_REF]]
+// CHECK: return [[COPY_BORROWED_EXISTENTIAL_REF]]
+// CHECK: } // end sil function '$S10objc_error14eraseMyNSError{{[_0-9a-zA-Z]*}}F'
+func eraseMyNSError() -> Error {
+ let x: Error = MyNSError()
+ return x
+}
+
+// CHECK-LABEL: sil hidden @$S10objc_error25eraseFictionalServerErrors0F0_pyF
+func eraseFictionalServerError() -> Error {
+ // CHECK-NOT: return
+ // CHECK: [[NSERROR:%[0-9]+]] = struct_extract {{.*}} : $FictionalServerError, #FictionalServerError._nsError
+ // CHECK: [[NSERROR_COPY:%.*]] = copy_value [[NSERROR]]
+ // CHECK: [[ERROR:%[0-9]+]] = init_existential_ref [[NSERROR_COPY]]
+ // CHECK: return [[ERROR]]
+ return FictionalServerError(.meltedDown)
+}
+// CHECK: } // end sil function '$S10objc_error25eraseFictionalServerErrors0F0_pyF'
+
+// SR-1562
+extension Error {
+ // CHECK-LABEL: sil hidden @$Ss5ErrorP10objc_errorE16convertToNSErrorSo0F0CyF
+ // CHECK: bb0([[SELF:%[0-9]+]] : @trivial $*Self)
+ func convertToNSError() -> NSError {
+ // CHECK: [[COPY:%.*]] = alloc_stack $Self
+ // CHECK: copy_addr [[SELF]] to [initialization] [[COPY]]
+ // CHECK: [[COPY2:%.*]] = alloc_stack $Self
+ // CHECK: copy_addr [[COPY]] to [initialization] [[COPY2]]
+ // CHECK: [[GET_EMBEDDED_FN:%[0-9]+]] = function_ref @$Ss24_getErrorEmbeddedNSErroryyXlSgxs0B0RzlF
+ // CHECK: [[EMBEDDED_RESULT_OPT:%[0-9]+]] = apply [[GET_EMBEDDED_FN]]<Self>([[COPY2]])
+ // CHECK: switch_enum [[EMBEDDED_RESULT_OPT]] : $Optional<AnyObject>,
+ // CHECK-SAME: case #Optional.some!enumelt.1: [[SUCCESS:bb[0-9]+]],
+ // CHECK-SAME: case #Optional.none!enumelt: [[FAILURE:bb[0-9]+]]
+
+ // CHECK: [[SUCCESS]]([[EMBEDDED_RESULT:%.*]] : @owned $AnyObject):
+ // CHECK: [[EMBEDDED_NSERROR:%[0-9]+]] = unchecked_ref_cast [[EMBEDDED_RESULT]] : $AnyObject to $NSError
+ // CHECK: [[ERROR:%[0-9]+]] = init_existential_ref [[EMBEDDED_NSERROR]] : $NSError : $NSError, $Error
+ // CHECK: destroy_addr [[COPY]] : $*Self
+ // CHECK: br [[CONTINUATION:bb[0-9]+]]([[ERROR]] : $Error)
+
+ // CHECK: [[FAILURE]]:
+ // CHECK: [[ERROR_BOX:%[0-9]+]] = alloc_existential_box $Error, $Self
+ // CHECK: [[ERROR_PROJECTED:%[0-9]+]] = project_existential_box $Self in [[ERROR_BOX]] : $Error
+ // CHECK: copy_addr [take] [[COPY]] to [initialization] [[ERROR_PROJECTED]] : $*Self
+ // CHECK: br [[CONTINUATION]]([[ERROR_BOX]] : $Error)
+
+ // CHECK: [[CONTINUATION]]([[ERROR_ARG:%[0-9]+]] : @owned $Error):
+ return self as NSError
+ }
+}
+
+class Gizmoid : NSObject {
+ // CHECK-LABEL: sil hidden [thunk] @$S10objc_error7GizmoidC3fooACyt_tKcfcTo : $@convention(objc_method) (Optional<AutoreleasingUnsafeMutablePointer<Optional<NSError>>>, @owned Gizmoid) -> @owned Optional<Gizmoid>
+ @objc init(foo: ()) throws {}
+}
diff --git a/test/SILGen/plus_zero_objc_extensions.swift b/test/SILGen/plus_zero_objc_extensions.swift
new file mode 100644
index 0000000..96a4c49
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_extensions.swift
@@ -0,0 +1,187 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -emit-silgen -sdk %S/Inputs/ -I %S/Inputs -enable-source-import %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+import objc_extensions_helper
+
+class Sub : Base {}
+
+extension Sub {
+ override var prop: String! {
+ didSet {
+ // Ignore it.
+ }
+
+ // Make sure that we are generating the @objc thunk and are calling the actual method.
+ //
+ // CHECK-LABEL: sil hidden [thunk] @$S15objc_extensions3SubC4propSSSgvgTo : $@convention(objc_method) (Sub) -> @autoreleased Optional<NSString> {
+ // CHECK: bb0([[SELF:%.*]] : @unowned $Sub):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[GETTER_FUNC:%.*]] = function_ref @$S15objc_extensions3SubC4propSSSgvg : $@convention(method) (@guaranteed Sub) -> @owned Optional<String>
+ // CHECK: apply [[GETTER_FUNC]]([[BORROWED_SELF_COPY]])
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK: } // end sil function '$S15objc_extensions3SubC4propSSSgvgTo'
+
+ // Then check the body of the getter calls the super_method.
+ // CHECK-LABEL: sil hidden @$S15objc_extensions3SubC4propSSSgvg : $@convention(method) (@guaranteed Sub) -> @owned Optional<String> {
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $Sub):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[SELF_COPY_CAST:%.*]] = upcast [[SELF_COPY]] : $Sub to $Base
+ // CHECK: [[BORROWED_SELF_COPY_CAST:%.*]] = begin_borrow [[SELF_COPY_CAST]]
+ // CHECK: [[CAST_BACK:%.*]] = unchecked_ref_cast [[BORROWED_SELF_COPY_CAST]] : $Base to $Sub
+ // CHECK: [[SUPER_METHOD:%.*]] = objc_super_method [[CAST_BACK]] : $Sub, #Base.prop!getter.1.foreign
+ // CHECK: end_borrow [[BORROWED_SELF_COPY_CAST]]
+ // CHECK: [[RESULT:%.*]] = apply [[SUPER_METHOD]]([[SELF_COPY_CAST]])
+ // CHECK: bb3(
+ // CHECK: destroy_value [[SELF_COPY_CAST]]
+ // CHECK: } // end sil function '$S15objc_extensions3SubC4propSSSgvg'
+
+ // Then check the setter @objc thunk.
+ //
+ // CHECK-LABEL: sil hidden [thunk] @$S15objc_extensions3SubC4propSSSgvsTo : $@convention(objc_method) (Optional<NSString>, Sub) -> () {
+ // CHECK: bb0([[NEW_VALUE:%.*]] : @unowned $Optional<NSString>, [[SELF:%.*]] : @unowned $Sub):
+ // CHECK: [[NEW_VALUE_COPY:%.*]] = copy_value [[NEW_VALUE]]
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $Sub
+ // CHECK: switch_enum [[NEW_VALUE_COPY]] : $Optional<NSString>, case #Optional.some!enumelt.1: [[SUCC_BB:bb[0-9]+]], case #Optional.none!enumelt: [[FAIL_BB:bb[0-9]+]]
+ // CHECK: [[SUCC_BB]]([[STR:%.*]] : @owned $NSString):
+ // CHECK: [[FAIL_BB]]:
+ // CHECK: bb3([[BRIDGED_NEW_VALUE:%.*]] : @owned $Optional<String>):
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[NORMAL_FUNC:%.*]] = function_ref @$S15objc_extensions3SubC4propSSSgvs : $@convention(method) (@owned Optional<String>, @guaranteed Sub) -> ()
+ // CHECK: apply [[NORMAL_FUNC]]([[BRIDGED_NEW_VALUE]], [[BORROWED_SELF_COPY]])
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK: } // end sil function '$S15objc_extensions3SubC4propSSSgvsTo'
+
+ // Then check the body of the actually setter value and make sure that we
+ // call the didSet function.
+ // CHECK-LABEL: sil hidden @$S15objc_extensions3SubC4propSSSgvs : $@convention(method) (@owned Optional<String>, @guaranteed Sub) -> () {
+
+ // First we get the old value.
+ // CHECK: bb0([[NEW_VALUE:%.*]] : @owned $Optional<String>, [[SELF:%.*]] : @guaranteed $Sub):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[UPCAST_SELF_COPY:%.*]] = upcast [[SELF_COPY]] : $Sub to $Base
+ // CHECK: [[BORROWED_UPCAST_SELF_COPY:%.*]] = begin_borrow [[UPCAST_SELF_COPY]]
+ // CHECK: [[CAST_BACK:%.*]] = unchecked_ref_cast [[BORROWED_UPCAST_SELF_COPY]] : $Base to $Sub
+ // CHECK: [[GET_SUPER_METHOD:%.*]] = objc_super_method [[CAST_BACK]] : $Sub, #Base.prop!getter.1.foreign : (Base) -> () -> String?, $@convention(objc_method) (Base) -> @autoreleased Optional<NSString>
+ // CHECK: end_borrow [[BORROWED_UPCAST_SELF_COPY]] from [[UPCAST_SELF_COPY]]
+ // CHECK: [[OLD_NSSTRING:%.*]] = apply [[GET_SUPER_METHOD]]([[UPCAST_SELF_COPY]])
+
+ // CHECK: bb3([[OLD_NSSTRING_BRIDGED:%.*]] : @owned $Optional<String>):
+ // This next line is completely not needed. But we are emitting it now.
+ // CHECK: destroy_value [[UPCAST_SELF_COPY]]
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[UPCAST_SELF_COPY:%.*]] = upcast [[SELF_COPY]] : $Sub to $Base
+ // CHECK: [[BORROWED_NEW_VALUE:%.*]] = begin_borrow [[NEW_VALUE]]
+ // CHECK: [[NEW_VALUE_COPY:%.*]] = copy_value [[BORROWED_NEW_VALUE]]
+ // CHECK: switch_enum [[NEW_VALUE_COPY]] : $Optional<String>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+ //
+ // CHECK: bb4([[OLD_STRING:%.*]] : @owned $String):
+ // CHECK: bb6([[BRIDGED_NEW_STRING:%.*]] : @owned $Optional<NSString>):
+ // CHECK: end_borrow [[BORROWED_NEW_VALUE]]
+ // CHECK: [[BORROWED_UPCAST_SELF:%.*]] = begin_borrow [[UPCAST_SELF_COPY]] : $Base
+ // CHECK: [[SUPERREF_DOWNCAST:%.*]] = unchecked_ref_cast [[BORROWED_UPCAST_SELF]] : $Base to $Sub
+ // CHECK: [[SET_SUPER_METHOD:%.*]] = objc_super_method [[SUPERREF_DOWNCAST]] : $Sub, #Base.prop!setter.1.foreign : (Base) -> (String?) -> (), $@convention(objc_method) (Optional<NSString>, Base) -> ()
+ // CHECK: apply [[SET_SUPER_METHOD]]([[BRIDGED_NEW_STRING]], [[UPCAST_SELF_COPY]])
+ // CHECK: destroy_value [[BRIDGED_NEW_STRING]]
+ // CHECK: destroy_value [[UPCAST_SELF_COPY]]
+ // CHECK: [[BORROWED_OLD_NSSTRING_BRIDGED:%.*]] = begin_borrow [[OLD_NSSTRING_BRIDGED]]
+ // This is an identity cast that should be eliminated by SILGen peepholes.
+ // CHECK: [[DIDSET_NOTIFIER:%.*]] = function_ref @$S15objc_extensions3SubC4propSSSgvW : $@convention(method) (@guaranteed Optional<String>, @guaranteed Sub) -> ()
+ // CHECK: apply [[DIDSET_NOTIFIER]]([[BORROWED_OLD_NSSTRING_BRIDGED]], [[SELF]])
+ // CHECK: end_borrow [[BORROWED_OLD_NSSTRING_BRIDGED]] from [[OLD_NSSTRING_BRIDGED]]
+ // CHECK: destroy_value [[OLD_NSSTRING_BRIDGED]]
+ // CHECK: destroy_value [[NEW_VALUE]]
+ // CHECK: } // end sil function '$S15objc_extensions3SubC4propSSSgvs'
+
+ }
+
+ func foo() {
+ }
+
+ override func objCBaseMethod() {}
+}
+
+// CHECK-LABEL: sil hidden @$S15objc_extensions20testOverridePropertyyyAA3SubCF
+func testOverrideProperty(_ obj: Sub) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Sub):
+ // CHECK: = objc_method [[ARG]] : $Sub, #Sub.prop!setter.1.foreign : (Sub) -> (String?) -> ()
+ obj.prop = "abc"
+} // CHECK: } // end sil function '$S15objc_extensions20testOverridePropertyyyAA3SubCF'
+
+testOverrideProperty(Sub())
+
+// CHECK-LABEL: sil shared [thunk] @$S15objc_extensions3SubC3fooyyFTc
+// CHECK: function_ref @$S15objc_extensions3SubC3fooyyFTD
+// CHECK: } // end sil function '$S15objc_extensions3SubC3fooyyFTc'
+// CHECK: sil shared [transparent] [serializable] [thunk] @$S15objc_extensions3SubC3fooyyFTD
+// CHECK: bb0([[SELF:%.*]] : @guaranteed $Sub):
+// CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+// CHECK: objc_method [[SELF_COPY]] : $Sub, #Sub.foo!1.foreign
+// CHECK: } // end sil function '$S15objc_extensions3SubC3fooyyFTD'
+func testCurry(_ x: Sub) {
+ _ = x.foo
+}
+
+extension Sub {
+ var otherProp: String {
+ get { return "hello" }
+ set { }
+ }
+}
+
+class SubSub : Sub {
+ // CHECK-LABEL: sil hidden @$S15objc_extensions03SubC0C14objCBaseMethodyyF :
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $SubSub):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[UPCAST_SELF_COPY:%.*]] = upcast [[SELF_COPY]] : $SubSub to $Sub
+ // CHECK: [[BORROWED_UPCAST_SELF_COPY:%.*]] = begin_borrow [[UPCAST_SELF_COPY]]
+ // CHECK: [[DOWNCAST:%.*]] = unchecked_ref_cast [[BORROWED_UPCAST_SELF_COPY]] : $Sub to $SubSub
+ // CHECK: objc_super_method [[DOWNCAST]] : $SubSub, #Sub.objCBaseMethod!1.foreign : (Sub) -> () -> (), $@convention(objc_method) (Sub) -> ()
+ // CHECK: end_borrow [[BORROWED_UPCAST_SELF_COPY]] from [[UPCAST_SELF_COPY]]
+ // CHECK: } // end sil function '$S15objc_extensions03SubC0C14objCBaseMethodyyF'
+ override func objCBaseMethod() {
+ super.objCBaseMethod()
+ }
+}
+
+extension SubSub {
+ // CHECK-LABEL: sil hidden @$S15objc_extensions03SubC0C9otherPropSSvs
+ // CHECK: bb0([[NEW_VALUE:%.*]] : @owned $String, [[SELF:%.*]] : @guaranteed $SubSub):
+ // CHECK: [[SELF_COPY_1:%.*]] = copy_value [[SELF]]
+ // CHECK: [[UPCAST_SELF_COPY_1:%.*]] = upcast [[SELF_COPY_1]] : $SubSub to $Sub
+ // CHECK: [[BORROWED_UPCAST_SELF_COPY_1:%.*]] = begin_borrow [[UPCAST_SELF_COPY_1]]
+ // CHECK: [[DOWNCAST_BORROWED_UPCAST_SELF_COPY_1:%.*]] = unchecked_ref_cast [[BORROWED_UPCAST_SELF_COPY_1]] : $Sub to $SubSub
+ // CHECK: = objc_super_method [[DOWNCAST_BORROWED_UPCAST_SELF_COPY_1]] : $SubSub, #Sub.otherProp!getter.1.foreign
+ // CHECK: end_borrow [[BORROWED_UPCAST_SELF_COPY_1]] from [[UPCAST_SELF_COPY_1]]
+
+ // CHECK: [[SELF_COPY_2:%.*]] = copy_value [[SELF]]
+ // CHECK: [[UPCAST_SELF_COPY_2:%.*]] = upcast [[SELF_COPY_2]] : $SubSub to $Sub
+ // CHECK: [[BORROWED_UPCAST_SELF_COPY_2:%.*]] = begin_borrow [[UPCAST_SELF_COPY_2]]
+ // CHECK: [[DOWNCAST_BORROWED_UPCAST_SELF_COPY_2:%.*]] = unchecked_ref_cast [[BORROWED_UPCAST_SELF_COPY_2]] : $Sub to $SubSub
+ // CHECK: = objc_super_method [[DOWNCAST_BORROWED_UPCAST_SELF_COPY_2]] : $SubSub, #Sub.otherProp!setter.1.foreign
+ // CHECK: end_borrow [[BORROWED_UPCAST_SELF_COPY_2]] from [[UPCAST_SELF_COPY_2]]
+ // CHECK: } // end sil function '$S15objc_extensions03SubC0C9otherPropSSvs'
+ override var otherProp: String {
+ didSet {
+ // Ignore it.
+ }
+ }
+}
+
+// SR-1025
+extension Base {
+ fileprivate static var x = 1
+}
+
+// CHECK-LABEL: sil hidden @$S15objc_extensions19testStaticVarAccessyyF
+func testStaticVarAccess() {
+ // CHECK: [[F:%.*]] = function_ref @$SSo4BaseC15objc_extensionsE1x33_1F05E59585E0BB585FCA206FBFF1A92DLLSivau
+ // CHECK: [[PTR:%.*]] = apply [[F]]()
+ // CHECK: [[ADDR:%.*]] = pointer_to_address [[PTR]]
+ _ = Base.x
+}
diff --git a/test/SILGen/plus_zero_objc_imported_generic.swift b/test/SILGen/plus_zero_objc_imported_generic.swift
new file mode 100644
index 0000000..f874ba7
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_imported_generic.swift
@@ -0,0 +1,144 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-silgen %s -enable-sil-ownership | %FileCheck %s
+// For integration testing, ensure we get through IRGen too.
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-ir -verify -DIRGEN_INTEGRATION_TEST %s
+
+// REQUIRES: objc_interop
+
+import objc_generics
+
+func callInitializer() {
+ _ = GenericClass(thing: NSObject())
+}
+
+// CHECK-LABEL: sil shared [serializable] @$SSo12GenericClassC5thingAByxGSgxSg_tcfC
+// CHECK: thick_to_objc_metatype {{%.*}} : $@thick GenericClass<T>.Type to $@objc_metatype GenericClass<T>.Type
+
+public func genericMethodOnAnyObject(o: AnyObject, b: Bool) -> AnyObject {
+ return o.thing!()!
+}
+
+// CHECK-LABEL: sil @$S21objc_imported_generic0C17MethodOnAnyObject{{[_0-9a-zA-Z]*}}F
+// CHECK: objc_method {{%.*}} : $@opened([[TAG:.*]]) AnyObject, #GenericClass.thing!1.foreign : <T where T : AnyObject> (GenericClass<T>) -> () -> T?, $@convention(objc_method) @pseudogeneric (@opened([[TAG]]) AnyObject) -> @autoreleased Optional<AnyObject>
+
+public func genericMethodOnAnyObjectChained(o: AnyObject, b: Bool) -> AnyObject? {
+ return o.thing?()
+}
+
+// CHECK-LABEL: sil @$S21objc_imported_generic0C24MethodOnAnyObjectChained1o1byXlSgyXl_SbtF
+// CHECK: bb0([[ANY:%.*]] : @guaranteed $AnyObject, [[BOOL:%.*]] : @trivial $Bool):
+// CHECK: [[OPENED_ANY:%.*]] = open_existential_ref [[ANY]]
+// CHECK: [[OPENED_ANY_COPY:%.*]] = copy_value [[OPENED_ANY]]
+// CHECK: dynamic_method_br [[OPENED_ANY_COPY]] : $@opened([[TAG:.*]]) AnyObject, #GenericClass.thing!1.foreign, bb1
+// CHECK: bb1({{%.*}} : @trivial $@convention(objc_method) @pseudogeneric (@opened([[TAG]]) AnyObject) -> @autoreleased Optional<AnyObject>):
+// CHECK: } // end sil function '$S21objc_imported_generic0C24MethodOnAnyObjectChained1o1byXlSgyXl_SbtF'
+
+public func genericSubscriptOnAnyObject(o: AnyObject, b: Bool) -> AnyObject? {
+ return o[0 as UInt16]
+}
+
+// CHECK-LABEL: sil @$S21objc_imported_generic0C20SubscriptOnAnyObject1o1byXlSgyXl_SbtF
+// CHECK: bb0([[ANY:%.*]]
+// CHCEK: [[OPENED_ANY:%.*]] = open_existential_ref [[ANY]]
+// CHECK: [[OPENED_ANY_COPY:%.*]] = copy_value [[OPENED_ANY]]
+// CHECK: dynamic_method_br [[OPENED_ANY_COPY]] : $@opened([[TAG:.*]]) AnyObject, #GenericClass.subscript!getter.1.foreign, bb1
+// CHECK: bb1({{%.*}} : @trivial $@convention(objc_method) @pseudogeneric (UInt16, @opened([[TAG]]) AnyObject) -> @autoreleased AnyObject):
+// CHECK: } // end sil function '$S21objc_imported_generic0C20SubscriptOnAnyObject1o1byXlSgyXl_SbtF'
+
+public func genericPropertyOnAnyObject(o: AnyObject, b: Bool) -> AnyObject?? {
+ return o.propertyThing
+}
+
+// CHECK-LABEL: sil @$S21objc_imported_generic0C19PropertyOnAnyObject1o1byXlSgSgyXl_SbtF
+// CHECK: bb0([[ANY:%.*]] : @guaranteed $AnyObject, [[BOOL:%.*]] : @trivial $Bool):
+// CHECK: [[OPENED_ANY:%.*]] = open_existential_ref [[ANY]]
+// CHECK: [[OPENED_ANY_COPY:%.*]] = copy_value [[OPENED_ANY]]
+// CHECK: dynamic_method_br [[OPENED_ANY_COPY]] : $@opened([[TAG:.*]]) AnyObject, #GenericClass.propertyThing!getter.1.foreign, bb1
+// CHECK: bb1({{%.*}} : @trivial $@convention(objc_method) @pseudogeneric (@opened([[TAG]]) AnyObject) -> @autoreleased Optional<AnyObject>):
+// CHECK: } // end sil function '$S21objc_imported_generic0C19PropertyOnAnyObject1o1byXlSgSgyXl_SbtF'
+
+public protocol ThingHolder {
+ associatedtype Thing
+
+ init!(thing: Thing!)
+ func thing() -> Thing?
+ func arrayOfThings() -> [Thing]
+ func setArrayOfThings(_: [Thing])
+ static func classThing() -> Thing?
+
+ var propertyThing: Thing? { get set }
+ var propertyArrayOfThings: [Thing]? { get set }
+}
+
+// TODO: Crashes in IRGen because the type metadata for `T` is not found in
+// the witness thunk to satisfy the associated type requirement. This could be
+// addressed by teaching IRGen to fulfill erased type parameters from protocol
+// witness tables (rdar://problem/26602097).
+#if !IRGEN_INTEGRATION_TEST
+extension GenericClass: ThingHolder {}
+#endif
+
+public protocol Ansible: class {
+ associatedtype Anser: ThingHolder
+}
+
+public func genericBlockBridging<T: Ansible>(x: GenericClass<T>) {
+ let block = x.blockForPerformingOnThings()
+ x.performBlock(onThings: block)
+}
+
+// CHECK-LABEL: sil @$S21objc_imported_generic0C13BlockBridging{{[_0-9a-zA-Z]*}}F
+// CHECK: [[BLOCK_TO_FUNC:%.*]] = function_ref @$SxxIeyBya_xxIeggo_21objc_imported_generic7AnsibleRzlTR
+// CHECK: partial_apply [callee_guaranteed] [[BLOCK_TO_FUNC]]<T>
+// CHECK: [[FUNC_TO_BLOCK:%.*]] = function_ref @$SxxIeggo_xxIeyBya_21objc_imported_generic7AnsibleRzlTR
+// CHECK: init_block_storage_header {{.*}} invoke [[FUNC_TO_BLOCK]]<T>
+
+// CHECK-LABEL: sil @$S21objc_imported_generic20arraysOfGenericParam{{[_0-9a-zA-Z]*}}F
+public func arraysOfGenericParam<T: AnyObject>(y: Array<T>) {
+ // CHECK: function_ref @$SSo12GenericClassC13arrayOfThingsAByxGSgSayxG_tcfC : $@convention(method) <τ_0_0 where τ_0_0 : AnyObject> (@owned Array<τ_0_0>, @thick GenericClass<τ_0_0>.Type) -> @owned Optional<GenericClass<τ_0_0>>
+ let x = GenericClass<T>(arrayOfThings: y)!
+ // CHECK: objc_method {{%.*}} : $GenericClass<T>, #GenericClass.setArrayOfThings!1.foreign {{.*}}, $@convention(objc_method) @pseudogeneric <τ_0_0 where τ_0_0 : AnyObject> (NSArray, GenericClass<τ_0_0>) -> ()
+ x.setArrayOfThings(y)
+ // CHECK: objc_method {{%.*}} : $GenericClass<T>, #GenericClass.propertyArrayOfThings!getter.1.foreign {{.*}}, $@convention(objc_method) @pseudogeneric <τ_0_0 where τ_0_0 : AnyObject> (GenericClass<τ_0_0>) -> @autoreleased Optional<NSArray>
+ _ = x.propertyArrayOfThings
+ // CHECK: objc_method {{%.*}} : $GenericClass<T>, #GenericClass.propertyArrayOfThings!setter.1.foreign {{.*}}, $@convention(objc_method) @pseudogeneric <τ_0_0 where τ_0_0 : AnyObject> (Optional<NSArray>, GenericClass<τ_0_0>) -> ()
+ x.propertyArrayOfThings = y
+}
+
+// CHECK-LABEL: sil private @$S21objc_imported_generic0C4FuncyyxmRlzClFyycfU_ : $@convention(thin) <V where V : AnyObject> () -> () {
+// CHECK: [[META:%.*]] = metatype $@thick GenericClass<V>.Type
+// CHECK: [[INIT:%.*]] = function_ref @$SSo12GenericClassCAByxGycfC : $@convention(method) <τ_0_0 where τ_0_0 : AnyObject> (@thick GenericClass<τ_0_0>.Type) -> @owned GenericClass<τ_0_0>
+// CHECK: apply [[INIT]]<V>([[META]])
+// CHECK: return
+func genericFunc<V: AnyObject>(_ v: V.Type) {
+ let _ = {
+ var _ = GenericClass<V>()
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S21objc_imported_generic23configureWithoutOptionsyyF : $@convention(thin) () -> ()
+// CHECK: [[NIL_FN:%.*]] = function_ref @$SSq10nilLiteralxSgyt_tcfC : $@convention(method) <τ_0_0> (@thin Optional<τ_0_0>.Type) -> @out Optional<τ_0_0>
+// CHECK: apply [[NIL_FN]]<[GenericOption : Any]>({{.*}})
+// CHECK: return
+func configureWithoutOptions() {
+ _ = GenericClass<NSObject>(options: nil)
+}
+
+// This gets emitted down here for some reason
+
+// CHECK-LABEL: sil shared [serializable] [thunk] @$SSo12GenericClassC13arrayOfThingsAByxGSgSayxG_tcfcTO
+// CHECK: objc_method {{%.*}} : $GenericClass<T>, #GenericClass.init!initializer.1.foreign {{.*}}, $@convention(objc_method) @pseudogeneric <τ_0_0 where τ_0_0 : AnyObject> (NSArray, @owned GenericClass<τ_0_0>) -> @owned Optional<GenericClass<τ_0_0>>
+
+// foreign to native thunk for init(options:), uses GenericOption : Hashable
+// conformance
+
+// CHECK-LABEL: sil shared [serializable] [thunk] @$SSo12GenericClassC7optionsAByxGSgs10DictionaryVySo0A6OptionaypGSg_tcfcTO : $@convention(method) <T where T : AnyObject> (@owned Optional<Dictionary<GenericOption, Any>>, @owned GenericClass<T>) -> @owned Optional<GenericClass<T>>
+// CHECK: [[FN:%.*]] = function_ref @$Ss10DictionaryV10FoundationE19_bridgeToObjectiveCSo12NSDictionaryCyF : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned NSDictionary
+// CHECK: apply [[FN]]<GenericOption, Any>({{.*}}) : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@guaranteed Dictionary<τ_0_0, τ_0_1>) -> @owned NSDictionary
+// CHECK: return
+
+// Make sure we emitted the witness table for the above conformance
+
+// CHECK-LABEL: sil_witness_table shared [serialized] GenericOption: Hashable module objc_generics {
+// CHECK: method #Hashable.hashValue!getter.1: {{.*}}: @$SSo13GenericOptionas8HashableSCsACP9hashValueSivgTW
+// CHECK: }
diff --git a/test/SILGen/plus_zero_objc_ownership_conventions.swift b/test/SILGen/plus_zero_objc_ownership_conventions.swift
new file mode 100644
index 0000000..3ef9bb6
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_ownership_conventions.swift
@@ -0,0 +1,226 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -sdk %S/Inputs -I %S/Inputs -enable-source-import %s -emit-silgen -enable-sil-ownership | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import gizmo
+
+// CHECK-LABEL: sil hidden @$S26objc_ownership_conventions5test3So8NSObjectCyF
+func test3() -> NSObject {
+ // initializer returns at +1
+ return Gizmo()
+ // CHECK: [[GIZMO_META:%[0-9]+]] = metatype $@thick Gizmo.Type
+ // CHECK: [[CTOR:%[0-9]+]] = function_ref @$SSo5GizmoC{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@thick Gizmo.Type) -> @owned Optional<Gizmo>
+ // CHECK-NEXT: [[GIZMO:%[0-9]+]] = apply [[CTOR]]([[GIZMO_META]]) : $@convention(method) (@thick Gizmo.Type) -> @owned Optional<Gizmo>
+ // CHECK: [[GIZMO_NS:%[0-9]+]] = upcast [[GIZMO:%[0-9]+]] : $Gizmo to $NSObject
+ // CHECK: return [[GIZMO_NS]] : $NSObject
+
+ // CHECK-LABEL: sil shared [serializable] @$SSo5GizmoC{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@thick Gizmo.Type) -> @owned Optional<Gizmo>
+ // alloc is implicitly ns_returns_retained
+ // init is implicitly ns_consumes_self and ns_returns_retained
+ // CHECK: bb0([[GIZMO_META:%[0-9]+]] : @trivial $@thick Gizmo.Type):
+ // CHECK-NEXT: [[GIZMO_META_OBJC:%[0-9]+]] = thick_to_objc_metatype [[GIZMO_META]] : $@thick Gizmo.Type to $@objc_metatype Gizmo.Type
+ // CHECK-NEXT: [[GIZMO:%[0-9]+]] = alloc_ref_dynamic [objc] [[GIZMO_META_OBJC]] : $@objc_metatype Gizmo.Type, $Gizmo
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[INIT_CTOR:%[0-9]+]] = function_ref @$SSo5GizmoC{{[_0-9a-zA-Z]*}}fcTO
+ // CHECK-NEXT: [[RESULT:%[0-9]+]] = apply [[INIT_CTOR]]([[GIZMO]]) : $@convention(method) (@owned Gizmo) -> @owned Optional<Gizmo>
+ // CHECK-NEXT: return [[RESULT]] : $Optional<Gizmo>
+}
+
+
+
+// Normal message send with argument, no transfers.
+// CHECK-LABEL: sil hidden @$S26objc_ownership_conventions5test5{{[_0-9a-zA-Z]*}}F
+func test5(_ g: Gizmo) {
+ var g = g
+ Gizmo.inspect(g)
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Gizmo):
+ // CHECK: [[GIZMO_BOX:%.*]] = alloc_box ${ var Gizmo }
+ // CHECK: [[GIZMO_BOX_PB:%.*]] = project_box [[GIZMO_BOX]]
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: store [[ARG_COPY]] to [init] [[GIZMO_BOX_PB]]
+ // CHECK: [[CLASS:%.*]] = metatype $@objc_metatype Gizmo.Type
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[GIZMO_BOX_PB]] : $*Gizmo
+ // CHECK: [[V:%.*]] = load [copy] [[READ]]
+ // CHECK: [[G:%.*]] = enum $Optional<Gizmo>, #Optional.some!enumelt.1, [[V]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[CLASS]] : {{.*}}, #Gizmo.inspect!1.foreign
+ // CHECK: apply [[METHOD]]([[G]], [[CLASS]])
+ // CHECK: destroy_value [[G]]
+ // CHECK: destroy_value [[GIZMO_BOX]]
+ // CHECK-NOT: destroy_value [[ARG]]
+}
+// CHECK: } // end sil function '$S26objc_ownership_conventions5test5{{[_0-9a-zA-Z]*}}F'
+
+// The argument to consume is __attribute__((ns_consumed)).
+// CHECK-LABEL: sil hidden @$S26objc_ownership_conventions5test6{{[_0-9a-zA-Z]*}}F
+func test6(_ g: Gizmo) {
+ var g = g
+ Gizmo.consume(g)
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Gizmo):
+ // CHECK: [[GIZMO_BOX:%.*]] = alloc_box ${ var Gizmo }
+ // CHECK: [[GIZMO_BOX_PB:%.*]] = project_box [[GIZMO_BOX]]
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: store [[ARG_COPY]] to [init] [[GIZMO_BOX_PB]]
+ // CHECK: [[CLASS:%.*]] = metatype $@objc_metatype Gizmo.Type
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[GIZMO_BOX_PB]] : $*Gizmo
+ // CHECK: [[V:%.*]] = load [copy] [[READ]]
+ // CHECK: [[G:%.*]] = enum $Optional<Gizmo>, #Optional.some!enumelt.1, [[V]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[CLASS]] : {{.*}}, #Gizmo.consume!1.foreign
+ // CHECK: apply [[METHOD]]([[G]], [[CLASS]])
+ // CHECK-NOT: destroy_value [[G]]
+ // CHECK: destroy_value [[GIZMO_BOX]]
+ // CHECK-NOT: destroy_value [[G]]
+ // CHECK-NOT: destroy_value [[ARG]]
+ // CHECK-NOT: destroy_value [[G]]
+}
+// CHECK: } // end sil function '$S26objc_ownership_conventions5test6{{[_0-9a-zA-Z]*}}F'
+
+// fork is __attribute__((ns_consumes_self)).
+// CHECK-LABEL: sil hidden @$S26objc_ownership_conventions5test7{{[_0-9a-zA-Z]*}}F
+func test7(_ g: Gizmo) {
+ var g = g
+ g.fork()
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Gizmo):
+ // CHECK: [[GIZMO_BOX:%.*]] = alloc_box ${ var Gizmo }
+ // CHECK: [[GIZMO_BOX_PB:%.*]] = project_box [[GIZMO_BOX]]
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: store [[ARG_COPY]] to [init] [[GIZMO_BOX_PB]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[GIZMO_BOX_PB]] : $*Gizmo
+ // CHECK: [[G:%.*]] = load [copy] [[READ]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[G]] : {{.*}}, #Gizmo.fork!1.foreign
+ // CHECK: apply [[METHOD]]([[G]])
+ // CHECK-NOT: destroy_value [[G]]
+ // CHECK: destroy_value [[GIZMO_BOX]]
+ // CHECK-NOT: destroy_value [[G]]
+ // CHECK-NOT: destroy_value [[ARG]]
+ // CHECK-NOT: destroy_value [[G]]
+}
+// CHECK: } // end sil function '$S26objc_ownership_conventions5test7{{[_0-9a-zA-Z]*}}F'
+
+// clone is __attribute__((ns_returns_retained)).
+// CHECK-LABEL: sil hidden @$S26objc_ownership_conventions5test8{{[_0-9a-zA-Z]*}}F
+func test8(_ g: Gizmo) -> Gizmo {
+ return g.clone()
+ // CHECK: bb0([[G:%.*]] : @guaranteed $Gizmo):
+ // CHECK-NOT: copy_value
+ // CHECK: [[METHOD:%.*]] = objc_method [[G]] : {{.*}}, #Gizmo.clone!1.foreign
+ // CHECK-NOT: copy_value [[RESULT]]
+ // CHECK: bb2([[RESULT:%.*]] : @owned $Gizmo):
+ // CHECK-NOT: copy_value [[RESULT]]
+ // CHECK-NOT: destroy_value [[G]]
+ // CHECK-NEXT: return [[RESULT]]
+}
+// duplicate returns an autoreleased object at +0.
+// CHECK-LABEL: sil hidden @$S26objc_ownership_conventions5test9{{[_0-9a-zA-Z]*}}F
+func test9(_ g: Gizmo) -> Gizmo {
+ return g.duplicate()
+ // CHECK: bb0([[G:%.*]] : @guaranteed $Gizmo):
+ // CHECK-NOT: copy_value [[G:%0]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[G]] : {{.*}}, #Gizmo.duplicate!1.foreign
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[G]])
+ // CHECK-NOT: copy_value [[RESULT]]
+ // CHECK: bb2([[RESULT:%.*]] : @owned $Gizmo):
+ // CHECK-NOT: copy_value [[RESULT]]
+ // CHECK-NOT: destroy_value [[G]]
+ // CHECK-NEXT: return [[RESULT]]
+}
+
+// CHECK-LABEL: sil hidden @$S26objc_ownership_conventions6test10{{[_0-9a-zA-Z]*}}F
+func test10(_ g: Gizmo) -> AnyClass {
+ // CHECK: bb0([[G:%[0-9]+]] : @guaranteed $Gizmo):
+ // CHECK: [[G_COPY:%.*]] = copy_value [[G]]
+ // CHECK-NEXT: [[NS_G_COPY:%[0-9]+]] = upcast [[G_COPY]] : $Gizmo to $NSObject
+ // CHECK-NEXT: [[GETTER:%[0-9]+]] = objc_method [[NS_G_COPY]] : $NSObject, #NSObject.classProp!getter.1.foreign : (NSObject) -> () -> AnyObject.Type?, $@convention(objc_method) (NSObject) -> Optional<@objc_metatype AnyObject.Type>
+ // CHECK-NEXT: [[OPT_OBJC:%.*]] = apply [[GETTER]]([[NS_G_COPY]]) : $@convention(objc_method) (NSObject) -> Optional<@objc_metatype AnyObject.Type>
+ // CHECK-NEXT: switch_enum [[OPT_OBJC]] : $Optional<{{.*}}>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+ //
+ // CHECK: [[SOME_BB]]([[OBJC:%.*]] : @trivial $@objc_metatype AnyObject.Type):
+ // CHECK-NEXT: [[THICK:%.*]] = objc_to_thick_metatype [[OBJC]]
+ // CHECK: [[T0:%.*]] = enum $Optional<@thick AnyObject.Type>, #Optional.some!enumelt.1, [[THICK]]
+ // CHECK: bb{{.*}}(%{{.*}} : @trivial $Optional<@thick AnyObject.Type>):
+ // CHECK: destroy_value [[NS_G_COPY]] : $NSObject
+ // CHECK: bb{{.*}}([[RES:%.*]] : @trivial $@thick AnyObject.Type):
+ // CHECK-NOT: destroy_value [[G]] : $Gizmo
+ // CHECK-NEXT: return [[RES]] : $@thick AnyObject.Type
+ return g.classProp
+}
+
+// CHECK-LABEL: sil hidden @$S26objc_ownership_conventions6test11{{[_0-9a-zA-Z]*}}F
+func test11(_ g: Gizmo) -> AnyClass {
+ // CHECK: bb0([[G:%[0-9]+]] : @guaranteed $Gizmo):
+ // CHECK: [[G_COPY:%.*]] = copy_value [[G]]
+ // CHECK: [[NS_G_COPY:%[0-9]+]] = upcast [[G_COPY:%[0-9]+]] : $Gizmo to $NSObject
+ // CHECK-NEXT: [[GETTER:%[0-9]+]] = objc_method [[NS_G_COPY]] : $NSObject, #NSObject.qualifiedClassProp!getter.1.foreign : (NSObject) -> () -> NSAnsing.Type?, $@convention(objc_method) (NSObject) -> Optional<@objc_metatype NSAnsing.Type>
+ // CHECK-NEXT: [[OPT_OBJC:%.*]] = apply [[GETTER]]([[NS_G_COPY]]) : $@convention(objc_method) (NSObject) -> Optional<@objc_metatype NSAnsing.Type>
+ // CHECK-NEXT: switch_enum [[OPT_OBJC]] : $Optional<{{.*}}>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+ //
+ // CHECK: [[SOME_BB]]([[OBJC:%.*]] : @trivial $@objc_metatype NSAnsing.Type):
+ // CHECK-NEXT: [[THICK:%.*]] = objc_to_thick_metatype [[OBJC]]
+ // CHECK: [[T0:%.*]] = enum $Optional<@thick NSAnsing.Type>, #Optional.some!enumelt.1, [[THICK]]
+ // CHECK: bb{{.*}}(%{{.*}} : @trivial $Optional<@thick NSAnsing.Type>):
+ // CHECK: destroy_value [[NS_G_COPY]] : $NSObject
+ // CHECK: bb{{.*}}([[RES:%.*]] : @trivial $@thick NSAnsing.Type):
+ // CHECK: [[OPENED:%.*]] = open_existential_metatype [[RES]]
+ // CHECK: [[RES_ANY:%.*]] = init_existential_metatype [[OPENED]]
+ // CHECK-NOT: destroy_value [[G]] : $Gizmo
+ // CHECK-NEXT: return [[RES_ANY]] : $@thick AnyObject.Type
+ return g.qualifiedClassProp
+}
+
+// ObjC blocks should have cdecl calling convention and follow C/ObjC
+// ownership conventions, where the callee, arguments, and return are all +0.
+// CHECK-LABEL: sil hidden @$S26objc_ownership_conventions10applyBlock{{[_0-9a-zA-Z]*}}F
+func applyBlock(_ f: @convention(block) (Gizmo) -> Gizmo, x: Gizmo) -> Gizmo {
+ // CHECK: bb0([[BLOCK:%.*]] : @guaranteed $@convention(block) @noescape (Gizmo) -> @autoreleased Gizmo, [[ARG:%.*]] : @guaranteed $Gizmo):
+ // CHECK: [[BLOCK_COPY:%.*]] = copy_block [[BLOCK]]
+ // CHECK: [[BORROWED_BLOCK_COPY:%.*]] = begin_borrow [[BLOCK_COPY]]
+ // CHECK: [[BLOCK_COPY_COPY:%.*]] = copy_value [[BORROWED_BLOCK_COPY]]
+ // CHECK: [[RESULT:%.*]] = apply [[BLOCK_COPY_COPY]]([[ARG]])
+ // CHECK: destroy_value [[BLOCK_COPY_COPY]]
+ // CHECK: end_borrow [[BORROWED_BLOCK_COPY]] from [[BLOCK_COPY]]
+ // CHECK-NOT: destroy_value [[ARG]]
+ // CHECK: destroy_value [[BLOCK_COPY]]
+ // CHECK-NOT: destroy_value [[BLOCK]]
+ // CHECK: return [[RESULT]]
+ return f(x)
+}
+
+// CHECK-LABEL: sil hidden @$S26objc_ownership_conventions15maybeApplyBlock{{[_0-9a-zA-Z]*}}F
+func maybeApplyBlock(_ f: (@convention(block) (Gizmo) -> Gizmo)?, x: Gizmo) -> Gizmo? {
+ // CHECK: bb0([[BLOCK:%.*]] : @guaranteed $Optional<@convention(block) (Gizmo) -> @autoreleased Gizmo>, [[ARG:%.*]] : @guaranteed $Gizmo):
+ // CHECK: [[BLOCK_COPY:%.*]] = copy_block [[BLOCK]]
+ return f?(x)
+}
+
+func useInnerPointer(_ p: UnsafeMutableRawPointer) {}
+
+// Handle inner-pointer methods by autoreleasing self after the call.
+// CHECK-LABEL: sil hidden @$S26objc_ownership_conventions18innerPointerMethodyySo5GizmoCF : $@convention(thin) (@guaranteed Gizmo) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Gizmo):
+// CHECK: [[METHOD:%.*]] = objc_method [[ARG]] : $Gizmo, #Gizmo.getBytes!1.foreign : (Gizmo) -> () -> UnsafeMutableRawPointer, $@convention(objc_method) (Gizmo) -> @unowned_inner_pointer UnsafeMutableRawPointer
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// => SEMANTIC ARC TODO: The apply below /should/ be on ARG_COPY. It is safe how
+// it is today though since we are using a reference type.
+// CHECK: [[PTR:%.*]] = apply [[METHOD]]([[ARG]])
+// CHECK: autorelease_value [[ARG_COPY]]
+// CHECK: [[USE:%.*]] = function_ref @$S26objc_ownership_conventions15useInnerPointer{{[_0-9a-zA-Z]*}}F
+// CHECK: apply [[USE]]([[PTR]])
+// CHECK-NOT: destroy_value [[ARG]]
+func innerPointerMethod(_ g: Gizmo) {
+ useInnerPointer(g.getBytes())
+}
+
+// CHECK-LABEL: sil hidden @$S26objc_ownership_conventions20innerPointerPropertyyySo5GizmoCF : $@convention(thin) (@guaranteed Gizmo) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Gizmo):
+// CHECK: [[METHOD:%.*]] = objc_method [[ARG]] : $Gizmo, #Gizmo.innerProperty!getter.1.foreign : (Gizmo) -> () -> UnsafeMutableRawPointer, $@convention(objc_method) (Gizmo) -> @unowned_inner_pointer UnsafeMutableRawPointer
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// => SEMANTIC ARC TODO: The apply below should be on ARG_COPY. It is benign since objc objects are reference types.
+// CHECK: [[PTR:%.*]] = apply [[METHOD]]([[ARG]])
+// CHECK: autorelease_value [[ARG_COPY]]
+// CHECK: [[USE:%.*]] = function_ref @$S26objc_ownership_conventions15useInnerPointer{{[_0-9a-zA-Z]*}}F
+// CHECK: apply [[USE]]([[PTR]])
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: } // end sil function '$S26objc_ownership_conventions20innerPointerPropertyyySo5GizmoCF'
+func innerPointerProperty(_ g: Gizmo) {
+ useInnerPointer(g.innerProperty)
+}
diff --git a/test/SILGen/plus_zero_objc_protocol_native_thunk.swift b/test/SILGen/plus_zero_objc_protocol_native_thunk.swift
new file mode 100644
index 0000000..3d75ecf
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_protocol_native_thunk.swift
@@ -0,0 +1,17 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+// REQUIRES: objc_interop
+
+import Foundation
+
+@objc protocol P {
+ func p(_: String)
+}
+@objc class C: NSObject {
+ func c(_: String) {}
+}
+
+// CHECK-LABEL: sil shared [serializable] [thunk] @$S{{.*}}1P{{.*}}1p{{.*}} : $@convention(method) <Self where Self : P> (@guaranteed String, @guaranteed Self) -> ()
+func foo(x: Bool, y: C & P) -> (String) -> () {
+ return x ? y.c : y.p
+}
diff --git a/test/SILGen/plus_zero_objc_protocols.swift b/test/SILGen/plus_zero_objc_protocols.swift
new file mode 100644
index 0000000..5052509
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_protocols.swift
@@ -0,0 +1,293 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -sdk %S/Inputs -I %S/Inputs -enable-source-import %s -emit-silgen -disable-objc-attr-requires-foundation-module -enable-sil-ownership | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import gizmo
+import objc_protocols_Bas
+
+@objc protocol NSRuncing {
+ func runce() -> NSObject
+ func copyRuncing() -> NSObject
+
+ func foo()
+
+ static func mince() -> NSObject
+}
+
+@objc protocol NSFunging {
+ func funge()
+
+ func foo()
+}
+
+protocol Ansible {
+ func anse()
+}
+
+// CHECK-LABEL: sil hidden @$S14objc_protocols0A8_generic{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[THIS:%.*]] : @guaranteed $T):
+// -- Result of runce is autoreleased according to default objc conv
+// CHECK: [[METHOD:%.*]] = objc_method [[THIS]] : {{\$.*}}, #NSRuncing.runce!1.foreign
+// CHECK: [[RESULT1:%.*]] = apply [[METHOD]]<T>([[THIS:%.*]]) : $@convention(objc_method) <τ_0_0 where τ_0_0 : NSRuncing> (τ_0_0) -> @autoreleased NSObject
+
+// -- Result of copyRuncing is received copy_valued according to -copy family
+// CHECK: [[METHOD:%.*]] = objc_method [[THIS]] : {{\$.*}}, #NSRuncing.copyRuncing!1.foreign
+// CHECK: [[RESULT2:%.*]] = apply [[METHOD]]<T>([[THIS:%.*]]) : $@convention(objc_method) <τ_0_0 where τ_0_0 : NSRuncing> (τ_0_0) -> @owned NSObject
+
+// -- Arguments are not consumed by objc calls
+// CHECK-NOT: destroy_value [[THIS]]
+func objc_generic<T : NSRuncing>(_ x: T) -> (NSObject, NSObject) {
+ return (x.runce(), x.copyRuncing())
+}
+
+// CHECK-LABEL: sil hidden @$S14objc_protocols0A22_generic_partial_applyyyxAA9NSRuncingRzlF : $@convention(thin) <T where T : NSRuncing> (@guaranteed T) -> () {
+func objc_generic_partial_apply<T : NSRuncing>(_ x: T) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $T):
+ // CHECK: [[FN:%.*]] = function_ref @[[THUNK1:\$S14objc_protocols9NSRuncingP5runceSo8NSObjectCyFTcTO]] :
+ // CHECK: [[METHOD:%.*]] = apply [[FN]]<T>([[ARG]])
+ // CHECK: destroy_value [[METHOD]]
+ _ = x.runce
+
+ // CHECK: [[FN:%.*]] = function_ref @[[THUNK1]] :
+ // CHECK: [[METHOD:%.*]] = partial_apply [callee_guaranteed] [[FN]]<T>()
+ // CHECK: destroy_value [[METHOD]]
+ _ = T.runce
+
+ // CHECK: [[METATYPE:%.*]] = metatype $@thick T.Type
+ // CHECK: [[FN:%.*]] = function_ref @[[THUNK2:\$S14objc_protocols9NSRuncingP5minceSo8NSObjectCyFZTcTO]]
+ // CHECK: [[METHOD:%.*]] = apply [[FN]]<T>([[METATYPE]])
+ // CHECK: destroy_value [[METHOD:%.*]]
+ _ = T.mince
+ // CHECK-NOT: destroy_value [[ARG]]
+}
+// CHECK: } // end sil function '$S14objc_protocols0A22_generic_partial_applyyyxAA9NSRuncingRzlF'
+
+// CHECK: sil shared [serializable] [thunk] @[[THUNK1]] :
+// CHECK: bb0([[SELF:%.*]] : @guaranteed $Self):
+// CHECK: [[FN:%.*]] = function_ref @[[THUNK1_THUNK:\$S14objc_protocols9NSRuncingP5runceSo8NSObjectCyFTO]] :
+// CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+// CHECK: [[METHOD:%.*]] = partial_apply [callee_guaranteed] [[FN]]<Self>([[SELF_COPY]])
+// CHECK: return [[METHOD]]
+// CHECK: } // end sil function '[[THUNK1]]'
+
+// CHECK: sil shared [serializable] [thunk] @[[THUNK1_THUNK]]
+// CHECK: bb0([[SELF:%.*]] : @guaranteed $Self):
+// CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+// CHECK: [[FN:%.*]] = objc_method [[SELF_COPY]] : $Self, #NSRuncing.runce!1.foreign
+// CHECK: [[RESULT:%.*]] = apply [[FN]]<Self>([[SELF_COPY]])
+// CHECK: destroy_value [[SELF_COPY]]
+// CHECK: return [[RESULT]]
+// CHECK: } // end sil function '[[THUNK1_THUNK]]'
+
+// CHECK: sil shared [serializable] [thunk] @[[THUNK2]] :
+// CHECK: [[FN:%.*]] = function_ref @[[THUNK2_THUNK:\$S14objc_protocols9NSRuncingP5minceSo8NSObjectCyFZTO]]
+// CHECK: [[METHOD:%.*]] = partial_apply [callee_guaranteed] [[FN]]<Self>(%0)
+// CHECK: return [[METHOD]]
+// CHECK: } // end sil function '[[THUNK2]]'
+
+// CHECK: sil shared [serializable] [thunk] @[[THUNK2_THUNK]] :
+// CHECK: [[FN:%.*]] = objc_method %0 : $@thick Self.Type, #NSRuncing.mince!1.foreign
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[FN]]<Self>(%0)
+// CHECK-NEXT: return [[RESULT]]
+// CHECK: } // end sil function '[[THUNK2_THUNK]]'
+
+// CHECK-LABEL: sil hidden @$S14objc_protocols0A9_protocol{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[THIS:%.*]] : @guaranteed $NSRuncing):
+// -- Result of runce is autoreleased according to default objc conv
+// CHECK: [[THIS1:%.*]] = open_existential_ref [[THIS]] : $NSRuncing to $[[OPENED:@opened(.*) NSRuncing]]
+// CHECK: [[METHOD:%.*]] = objc_method [[THIS1]] : $[[OPENED]], #NSRuncing.runce!1.foreign
+// CHECK: [[RESULT1:%.*]] = apply [[METHOD]]<[[OPENED]]>([[THIS1]])
+
+// -- Result of copyRuncing is received copy_valued according to -copy family
+// CHECK: [[THIS2:%.*]] = open_existential_ref [[THIS]] : $NSRuncing to $[[OPENED2:@opened(.*) NSRuncing]]
+// CHECK: [[METHOD:%.*]] = objc_method [[THIS2]] : $[[OPENED2]], #NSRuncing.copyRuncing!1.foreign
+// CHECK: [[RESULT2:%.*]] = apply [[METHOD]]<[[OPENED2]]>([[THIS2:%.*]])
+
+// -- Arguments are not consumed by objc calls
+// CHECK-NOT: destroy_value [[THIS]]
+func objc_protocol(_ x: NSRuncing) -> (NSObject, NSObject) {
+ return (x.runce(), x.copyRuncing())
+}
+
+// CHECK-LABEL: sil hidden @$S14objc_protocols0A23_protocol_partial_applyyyAA9NSRuncing_pF : $@convention(thin) (@guaranteed NSRuncing) -> () {
+func objc_protocol_partial_apply(_ x: NSRuncing) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $NSRuncing):
+ // CHECK: [[OPENED_ARG:%.*]] = open_existential_ref [[ARG]] : $NSRuncing to $[[OPENED:@opened(.*) NSRuncing]]
+ // CHECK: [[FN:%.*]] = function_ref @$S14objc_protocols9NSRuncingP5runceSo8NSObjectCyFTcTO
+ // CHECK: [[RESULT:%.*]] = apply [[FN]]<[[OPENED]]>([[OPENED_ARG]])
+ // CHECK: destroy_value [[RESULT]]
+ // CHECK-NOT: destroy_value [[ARG]]
+ _ = x.runce
+
+ // FIXME: rdar://21289579
+ // _ = NSRuncing.runce
+}
+// CHECK : } // end sil function '$S14objc_protocols0A23_protocol_partial_applyyyAA9NSRuncing_pF'
+
+// CHECK-LABEL: sil hidden @$S14objc_protocols0A21_protocol_composition{{[_0-9a-zA-Z]*}}F
+func objc_protocol_composition(_ x: NSRuncing & NSFunging) {
+ // CHECK: [[THIS:%.*]] = open_existential_ref [[THIS_ORIG:%.*]] : $NSFunging & NSRuncing to $[[OPENED:@opened(.*) NSFunging & NSRuncing]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[THIS]] : $[[OPENED]], #NSRuncing.runce!1.foreign
+ // CHECK: apply [[METHOD]]<[[OPENED]]>([[THIS]])
+ x.runce()
+
+ // CHECK: [[THIS:%.*]] = open_existential_ref [[THIS_ORIG:%.*]] : $NSFunging & NSRuncing to $[[OPENED:@opened(.*) NSFunging & NSRuncing]]
+ // CHECK: [[METHOD:%.*]] = objc_method [[THIS]] : $[[OPENED]], #NSFunging.funge!1.foreign
+ // CHECK: apply [[METHOD]]<[[OPENED]]>([[THIS]])
+ x.funge()
+}
+// -- ObjC thunks get emitted for ObjC protocol conformances
+
+class Foo : NSRuncing, NSFunging, Ansible {
+ // -- NSRuncing
+ @objc func runce() -> NSObject { return NSObject() }
+ @objc func copyRuncing() -> NSObject { return NSObject() }
+
+ @objc static func mince() -> NSObject { return NSObject() }
+
+ // -- NSFunging
+ @objc func funge() {}
+
+ // -- Both NSRuncing and NSFunging
+ @objc func foo() {}
+
+ // -- Ansible
+ func anse() {}
+}
+
+// CHECK-LABEL: sil hidden [thunk] @$S14objc_protocols3FooC5runce{{[_0-9a-zA-Z]*}}FTo
+// CHECK-LABEL: sil hidden [thunk] @$S14objc_protocols3FooC11copyRuncing{{[_0-9a-zA-Z]*}}FTo
+// CHECK-LABEL: sil hidden [thunk] @$S14objc_protocols3FooC5funge{{[_0-9a-zA-Z]*}}FTo
+// CHECK-LABEL: sil hidden [thunk] @$S14objc_protocols3FooC3foo{{[_0-9a-zA-Z]*}}FTo
+// CHECK-NOT: sil hidden @_TToF{{.*}}anse{{.*}}
+
+class Bar { }
+
+extension Bar : NSRuncing {
+ @objc func runce() -> NSObject { return NSObject() }
+ @objc func copyRuncing() -> NSObject { return NSObject() }
+ @objc func foo() {}
+ @objc static func mince() -> NSObject { return NSObject() }
+}
+
+// CHECK-LABEL: sil hidden [thunk] @$S14objc_protocols3BarC5runce{{[_0-9a-zA-Z]*}}FTo
+// CHECK-LABEL: sil hidden [thunk] @$S14objc_protocols3BarC11copyRuncing{{[_0-9a-zA-Z]*}}FTo
+// CHECK-LABEL: sil hidden [thunk] @$S14objc_protocols3BarC3foo{{[_0-9a-zA-Z]*}}FTo
+
+// class Bas from objc_protocols_Bas module
+extension Bas : NSRuncing {
+ // runce() implementation from the original definition of Bas
+ @objc func copyRuncing() -> NSObject { return NSObject() }
+ @objc func foo() {}
+ @objc static func mince() -> NSObject { return NSObject() }
+}
+
+// CHECK-LABEL: sil hidden [thunk] @$S18objc_protocols_Bas0C0C0a1_B0E11copyRuncing{{[_0-9a-zA-Z]*}}FTo
+// CHECK-LABEL: sil hidden [thunk] @$S18objc_protocols_Bas0C0C0a1_B0E3foo{{[_0-9a-zA-Z]*}}FTo
+
+// -- Inherited objc protocols
+
+protocol Fungible : NSFunging { }
+
+class Zim : Fungible {
+ @objc func funge() {}
+ @objc func foo() {}
+}
+
+// CHECK-LABEL: sil hidden [thunk] @$S14objc_protocols3ZimC5funge{{[_0-9a-zA-Z]*}}FTo
+// CHECK-LABEL: sil hidden [thunk] @$S14objc_protocols3ZimC3foo{{[_0-9a-zA-Z]*}}FTo
+
+// class Zang from objc_protocols_Bas module
+extension Zang : Fungible {
+ // funge() implementation from the original definition of Zim
+ @objc func foo() {}
+}
+
+// CHECK-LABEL: sil hidden [thunk] @$S18objc_protocols_Bas4ZangC0a1_B0E3foo{{[_0-9a-zA-Z]*}}FTo
+
+// -- objc protocols with property requirements in extensions
+// <rdar://problem/16284574>
+
+@objc protocol NSCounting {
+ var count: Int {get}
+}
+
+class StoredPropertyCount {
+ @objc let count = 0
+}
+
+extension StoredPropertyCount: NSCounting {}
+// CHECK-LABEL: sil hidden [transparent] [thunk] @$S14objc_protocols19StoredPropertyCountC5countSivgTo
+
+class ComputedPropertyCount {
+ @objc var count: Int { return 0 }
+}
+
+extension ComputedPropertyCount: NSCounting {}
+// CHECK-LABEL: sil hidden [thunk] @$S14objc_protocols21ComputedPropertyCountC5countSivgTo
+
+// -- adding @objc protocol conformances to native ObjC classes should not
+// emit thunks since the methods are already available to ObjC.
+
+// Gizmo declared in Inputs/usr/include/Gizmo.h
+extension Gizmo : NSFunging { }
+
+// CHECK-NOT: _TTo{{.*}}5Gizmo{{.*}}
+
+@objc class InformallyFunging {
+ @objc func funge() {}
+ @objc func foo() {}
+}
+
+extension InformallyFunging: NSFunging { }
+
+@objc protocol Initializable {
+ init(int: Int)
+}
+
+// CHECK-LABEL: sil hidden @$S14objc_protocols28testInitializableExistential_1iAA0D0_pAaD_pXp_SitF : $@convention(thin) (@thick Initializable.Type, Int) -> @owned Initializable {
+func testInitializableExistential(_ im: Initializable.Type, i: Int) -> Initializable {
+ // CHECK: bb0([[META:%[0-9]+]] : @trivial $@thick Initializable.Type, [[I:%[0-9]+]] : @trivial $Int):
+ // CHECK: [[I2_BOX:%[0-9]+]] = alloc_box ${ var Initializable }
+ // CHECK: [[PB:%.*]] = project_box [[I2_BOX]]
+ // CHECK: [[ARCHETYPE_META:%[0-9]+]] = open_existential_metatype [[META]] : $@thick Initializable.Type to $@thick (@opened([[N:".*"]]) Initializable).Type
+ // CHECK: [[ARCHETYPE_META_OBJC:%[0-9]+]] = thick_to_objc_metatype [[ARCHETYPE_META]] : $@thick (@opened([[N]]) Initializable).Type to $@objc_metatype (@opened([[N]]) Initializable).Type
+ // CHECK: [[I2_ALLOC:%[0-9]+]] = alloc_ref_dynamic [objc] [[ARCHETYPE_META_OBJC]] : $@objc_metatype (@opened([[N]]) Initializable).Type, $@opened([[N]]) Initializable
+ // CHECK: [[INIT_WITNESS:%[0-9]+]] = objc_method [[I2_ALLOC]] : $@opened([[N]]) Initializable, #Initializable.init!initializer.1.foreign : {{.*}}
+ // CHECK: [[I2:%[0-9]+]] = apply [[INIT_WITNESS]]<@opened([[N]]) Initializable>([[I]], [[I2_ALLOC]]) : $@convention(objc_method) <τ_0_0 where τ_0_0 : Initializable> (Int, @owned τ_0_0) -> @owned τ_0_0
+ // CHECK: [[I2_EXIST_CONTAINER:%[0-9]+]] = init_existential_ref [[I2]] : $@opened([[N]]) Initializable : $@opened([[N]]) Initializable, $Initializable
+ // CHECK: store [[I2_EXIST_CONTAINER]] to [init] [[PB]] : $*Initializable
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PB]] : $*Initializable
+ // CHECK: [[I2:%[0-9]+]] = load [copy] [[READ]] : $*Initializable
+ // CHECK: destroy_value [[I2_BOX]] : ${ var Initializable }
+ // CHECK: return [[I2]] : $Initializable
+ var i2 = im.init(int: i)
+ return i2
+}
+// CHECK: } // end sil function '$S14objc_protocols28testInitializableExistential_1iAA0D0_pAaD_pXp_SitF'
+
+class InitializableConformer: Initializable {
+ @objc required init(int: Int) {}
+}
+// CHECK-LABEL: sil hidden [thunk] @$S14objc_protocols22InitializableConformerC{{[_0-9a-zA-Z]*}}fcTo
+
+final class InitializableConformerByExtension {
+ init() {}
+}
+
+extension InitializableConformerByExtension: Initializable {
+ @objc convenience init(int: Int) {
+ self.init()
+ }
+}
+// CHECK-LABEL: sil hidden [thunk] @$S14objc_protocols33InitializableConformerByExtensionC{{[_0-9a-zA-Z]*}}fcTo
+
+// Make sure we're crashing from trying to use materializeForSet here.
+@objc protocol SelectionItem {
+ var time: Double { get set }
+}
+
+func incrementTime(contents: SelectionItem) {
+ contents.time += 1.0
+}
diff --git a/test/SILGen/plus_zero_objc_set_bridging.swift b/test/SILGen/plus_zero_objc_set_bridging.swift
new file mode 100644
index 0000000..3c790c1
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_set_bridging.swift
@@ -0,0 +1,92 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %build-silgen-test-overlays
+
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -emit-silgen %s -enable-sil-ownership | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+import gizmo
+
+@objc class Foo : NSObject {
+ // Bridging set parameters
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_set_bridging3FooC16bridge_Set_param{{[_0-9a-zA-Z]*}}FTo : $@convention(objc_method) (NSSet, Foo) -> ()
+ func bridge_Set_param(_ s: Set<Foo>) {
+ // CHECK: bb0([[NSSET:%[0-9]+]] : @unowned $NSSet, [[SELF:%[0-9]+]] : @unowned $Foo):
+ // CHECK: [[NSSET_COPY:%.*]] = copy_value [[NSSET]] : $NSSet
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $Foo
+ // CHECK: [[CONVERTER:%[0-9]+]] = function_ref @$Ss3SetV10FoundationE36_unconditionallyBridgeFromObjectiveCyAByxGSo5NSSetCSgFZ
+ // CHECK: [[OPT_NSSET:%[0-9]+]] = enum $Optional<NSSet>, #Optional.some!enumelt.1, [[NSSET_COPY]] : $NSSet
+ // CHECK: [[SET_META:%[0-9]+]] = metatype $@thin Set<Foo>.Type
+ // CHECK: [[SET:%[0-9]+]] = apply [[CONVERTER]]<Foo>([[OPT_NSSET]], [[SET_META]])
+ // CHECK: [[BORROWED_SET:%.*]] = begin_borrow [[SET]]
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[SWIFT_FN:%[0-9]+]] = function_ref @$S17objc_set_bridging3FooC16bridge_Set_param{{[_0-9a-zA-Z]*}}F : $@convention(method) (@guaranteed Set<Foo>, @guaranteed Foo) -> ()
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[SWIFT_FN]]([[BORROWED_SET]], [[BORROWED_SELF_COPY]]) : $@convention(method) (@guaranteed Set<Foo>, @guaranteed Foo) -> ()
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK: return [[RESULT]] : $()
+ }
+ // CHECK: // end sil function '$S17objc_set_bridging3FooC16bridge_Set_param{{[_0-9a-zA-Z]*}}FTo'
+
+ // Bridging set results
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_set_bridging3FooC17bridge_Set_result{{[_0-9a-zA-Z]*}}FTo : $@convention(objc_method) (Foo) -> @autoreleased NSSet {
+ func bridge_Set_result() -> Set<Foo> {
+ // CHECK: bb0([[SELF:%[0-9]+]] : @unowned $Foo):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $Foo
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[SWIFT_FN:%[0-9]+]] = function_ref @$S17objc_set_bridging3FooC17bridge_Set_result{{[_0-9a-zA-Z]*}}F : $@convention(method) (@guaranteed Foo) -> @owned Set<Foo>
+ // CHECK: [[SET:%[0-9]+]] = apply [[SWIFT_FN]]([[BORROWED_SELF_COPY]]) : $@convention(method) (@guaranteed Foo) -> @owned Set<Foo>
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK: [[CONVERTER:%[0-9]+]] = function_ref @$Ss3SetV10FoundationE19_bridgeToObjectiveCSo5NSSetCyF
+ // CHECK: [[BORROWED_SET:%.*]] = begin_borrow [[SET]]
+ // CHECK: [[NSSET:%[0-9]+]] = apply [[CONVERTER]]<Foo>([[BORROWED_SET]]) : $@convention(method) <τ_0_0 where τ_0_0 : Hashable> (@guaranteed Set<τ_0_0>) -> @owned NSSet
+ // CHECK: end_borrow [[BORROWED_SET]] from [[SET]]
+ // CHECK: destroy_value [[SET]]
+ // CHECK: return [[NSSET]] : $NSSet
+ }
+ // CHECK: } // end sil function '$S17objc_set_bridging3FooC17bridge_Set_result{{[_0-9a-zA-Z]*}}FTo'
+
+ var property: Set<Foo> = Set()
+
+ // Property getter
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_set_bridging3FooC8property{{[_0-9a-zA-Z]*}}vgTo : $@convention(objc_method) (Foo) -> @autoreleased NSSet
+ // CHECK: bb0([[SELF:%[0-9]+]] : @unowned $Foo):
+ // CHECK: [[SELF_COPY]] = copy_value [[SELF]] : $Foo
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[GETTER:%[0-9]+]] = function_ref @$S17objc_set_bridging3FooC8property{{[_0-9a-zA-Z]*}}vg : $@convention(method) (@guaranteed Foo) -> @owned Set<Foo>
+ // CHECK: [[SET:%[0-9]+]] = apply [[GETTER]]([[BORROWED_SELF_COPY]]) : $@convention(method) (@guaranteed Foo) -> @owned Set<Foo>
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK: [[CONVERTER:%[0-9]+]] = function_ref @$Ss3SetV10FoundationE19_bridgeToObjectiveCSo5NSSetCyF
+ // CHECK: [[BORROWED_SET:%.*]] = begin_borrow [[SET]]
+ // CHECK: [[NSSET:%[0-9]+]] = apply [[CONVERTER]]<Foo>([[BORROWED_SET]]) : $@convention(method) <τ_0_0 where τ_0_0 : Hashable> (@guaranteed Set<τ_0_0>) -> @owned NSSet
+ // CHECK: end_borrow [[BORROWED_SET]] from [[SET]]
+ // CHECK: destroy_value [[SET]]
+ // CHECK: return [[NSSET]] : $NSSet
+ // CHECK: } // end sil function '$S17objc_set_bridging3FooC8property{{[_0-9a-zA-Z]*}}vgTo'
+
+ // Property setter
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_set_bridging3FooC8property{{[_0-9a-zA-Z]*}}vsTo : $@convention(objc_method) (NSSet, Foo) -> () {
+ // CHECK: bb0([[NSSET:%[0-9]+]] : @unowned $NSSet, [[SELF:%[0-9]+]] : @unowned $Foo):
+ // CHECK: [[NSSET_COPY:%.*]] = copy_value [[NSSET]] : $NSSet
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $Foo
+ // CHECK: [[CONVERTER:%[0-9]+]] = function_ref @$Ss3SetV10FoundationE36_unconditionallyBridgeFromObjectiveCyAByxGSo5NSSetCSgFZ
+ // CHECK: [[OPT_NSSET:%[0-9]+]] = enum $Optional<NSSet>, #Optional.some!enumelt.1, [[NSSET_COPY]] : $NSSet
+ // CHECK: [[SET_META:%[0-9]+]] = metatype $@thin Set<Foo>.Type
+ // CHECK: [[SET:%[0-9]+]] = apply [[CONVERTER]]<Foo>([[OPT_NSSET]], [[SET_META]])
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[SETTER:%[0-9]+]] = function_ref @$S17objc_set_bridging3FooC8property{{[_0-9a-zA-Z]*}}vs : $@convention(method) (@owned Set<Foo>, @guaranteed Foo) -> ()
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[SETTER]]([[SET]], [[BORROWED_SELF_COPY]]) : $@convention(method) (@owned Set<Foo>, @guaranteed Foo) -> ()
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]] : $Foo
+ // CHECK: return [[RESULT]] : $()
+
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_set_bridging3FooC19nonVerbatimProperty{{[_0-9a-zA-Z]*}}vgTo : $@convention(objc_method) (Foo) -> @autoreleased NSSet
+ // CHECK-LABEL: sil hidden [thunk] @$S17objc_set_bridging3FooC19nonVerbatimProperty{{[_0-9a-zA-Z]*}}vsTo : $@convention(objc_method) (NSSet, Foo) -> () {
+ @objc var nonVerbatimProperty: Set<String> = Set()
+}
+
+func ==(x: Foo, y: Foo) -> Bool { }
diff --git a/test/SILGen/plus_zero_objc_thunks.swift b/test/SILGen/plus_zero_objc_thunks.swift
new file mode 100644
index 0000000..0a40a32
--- /dev/null
+++ b/test/SILGen/plus_zero_objc_thunks.swift
@@ -0,0 +1,542 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -Xllvm -sil-print-debuginfo -sdk %S/Inputs -I %S/Inputs -enable-source-import %s -emit-silgen -emit-verbose-sil -enable-sil-ownership | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import gizmo
+import ansible
+
+class Hoozit : Gizmo {
+ @objc func typical(_ x: Int, y: Gizmo) -> Gizmo { return y }
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC7typical_1ySo5GizmoCSi_AGtFTo : $@convention(objc_method) (Int, Gizmo, Hoozit) -> @autoreleased Gizmo {
+ // CHECK: bb0([[X:%.*]] : @trivial $Int, [[Y:%.*]] : @unowned $Gizmo, [[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[Y_COPY:%.*]] = copy_value [[Y]]
+ // CHECK-NEXT: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK-NEXT: [[BORROWED_Y_COPY:%.*]] = begin_borrow [[Y_COPY]]
+ // CHECK-NEXT: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK-NEXT: // function_ref objc_thunks.Hoozit.typical
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC7typical_1ySo5GizmoCSi_AGtF : $@convention(method) (Int, @guaranteed Gizmo, @guaranteed Hoozit) -> @owned Gizmo
+ // CHECK-NEXT: [[RES:%.*]] = apply [[NATIVE]]([[X]], [[BORROWED_Y_COPY]], [[BORROWED_THIS_COPY]]) {{.*}} line:[[@LINE-9]]:14:auto_gen
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK-NEXT: end_borrow [[BORROWED_Y_COPY]] from [[Y_COPY]]
+ // CHECK-NEXT: destroy_value [[THIS_COPY]] : $Hoozit
+ // CHECK-NEXT: destroy_value [[Y_COPY]]
+ // CHECK-NEXT: return [[RES]] : $Gizmo{{.*}} line:[[@LINE-14]]:14:auto_gen
+ // CHECK-NEXT: } // end sil function '$S11objc_thunks6HoozitC7typical_1ySo5GizmoCSi_AGtFTo'
+
+ // NS_CONSUMES_SELF by inheritance
+ override func fork() { }
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC4forkyyFTo : $@convention(objc_method) (@owned Hoozit) -> () {
+ // CHECK: bb0([[THIS:%.*]] : @owned $Hoozit):
+ // CHECK-NEXT: [[BORROWED_THIS:%.*]] = begin_borrow [[THIS]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC4forkyyF : $@convention(method) (@guaranteed Hoozit) -> ()
+ // CHECK-NEXT: apply [[NATIVE]]([[BORROWED_THIS]])
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS]] from [[THIS]]
+ // CHECK-NEXT: destroy_value [[THIS]]
+ // CHECK-NEXT: return
+ // CHECK-NEXT: }
+
+ // NS_CONSUMED 'gizmo' argument by inheritance
+ override class func consume(_ gizmo: Gizmo?) { }
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC7consumeyySo5GizmoCSgFZTo : $@convention(objc_method) (@owned Optional<Gizmo>, @objc_metatype Hoozit.Type) -> () {
+ // CHECK: bb0([[GIZMO:%.*]] : @owned $Optional<Gizmo>, [[THIS:%.*]] : @trivial $@objc_metatype Hoozit.Type):
+ // CHECK-NEXT: [[BORROWED_GIZMO:%.*]] = begin_borrow [[GIZMO]]
+ // CHECK-NEXT: [[THICK_THIS:%[0-9]+]] = objc_to_thick_metatype [[THIS]] : $@objc_metatype Hoozit.Type to $@thick Hoozit.Type
+ // CHECK: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC7consumeyySo5GizmoCSgFZ : $@convention(method) (@guaranteed Optional<Gizmo>, @thick Hoozit.Type) -> ()
+ // CHECK-NEXT: apply [[NATIVE]]([[BORROWED_GIZMO]], [[THICK_THIS]])
+ // CHECK-NEXT: end_borrow [[BORROWED_GIZMO]]
+ // CHECK-NEXT: destroy_value [[GIZMO]]
+ // CHECK-NEXT: return
+ // CHECK-NEXT: }
+
+ // NS_RETURNS_RETAINED by family (-copy)
+ @objc func copyFoo() -> Gizmo { return self }
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC7copyFooSo5GizmoCyFTo : $@convention(objc_method) (Hoozit) -> @owned Gizmo
+ // CHECK: bb0([[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK-NEXT: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC7copyFooSo5GizmoCyF : $@convention(method) (@guaranteed Hoozit) -> @owned Gizmo
+ // CHECK-NEXT: [[RES:%.*]] = apply [[NATIVE]]([[BORROWED_THIS_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK-NEXT: destroy_value [[THIS_COPY]]
+ // CHECK-NEXT: return [[RES]]
+ // CHECK-NEXT: }
+
+ // NS_RETURNS_RETAINED by family (-copy)
+ @objc(copyDuplicate) func makeDuplicate() -> Gizmo { return self }
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC13makeDuplicateSo5GizmoCyFTo : $@convention(objc_method) (Hoozit) -> @owned Gizmo
+ // CHECK: bb0([[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK-NEXT: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC13makeDuplicateSo5GizmoCyF : $@convention(method) (@guaranteed Hoozit) -> @owned Gizmo
+ // CHECK-NEXT: [[RES:%.*]] = apply [[NATIVE]]([[BORROWED_THIS_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK-NEXT: destroy_value [[THIS_COPY]]
+ // CHECK-NEXT: return [[RES]]
+ // CHECK-NEXT: }
+
+ // Override the normal family conventions to make this non-consuming and
+ // returning at +0.
+ @objc func initFoo() -> Gizmo { return self }
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC7initFooSo5GizmoCyFTo : $@convention(objc_method) (Hoozit) -> @autoreleased Gizmo
+ // CHECK: bb0([[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK-NEXT: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC7initFooSo5GizmoCyF : $@convention(method) (@guaranteed Hoozit) -> @owned Gizmo
+ // CHECK-NEXT: [[RES:%.*]] = apply [[NATIVE]]([[BORROWED_THIS_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK-NEXT: destroy_value [[THIS_COPY]]
+ // CHECK-NEXT: return [[RES]]
+ // CHECK-NEXT: }
+
+ @objc var typicalProperty: Gizmo
+ // -- getter
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC15typicalPropertySo5GizmoCvgTo : $@convention(objc_method) (Hoozit) -> @autoreleased Gizmo {
+ // CHECK: bb0([[SELF:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK-NEXT: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK-NEXT: // function_ref objc_thunks.Hoozit.typicalProperty.getter
+ // CHECK-NEXT: [[GETIMPL:%.*]] = function_ref @$S11objc_thunks6HoozitC15typicalPropertySo5GizmoCvg
+ // CHECK-NEXT: [[RES:%.*]] = apply [[GETIMPL]]([[BORROWED_SELF_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK-NEXT: destroy_value [[SELF_COPY]]
+ // CHECK-NEXT: return [[RES]] : $Gizmo
+ // CHECK-NEXT: }
+
+ // CHECK-LABEL: sil hidden @$S11objc_thunks6HoozitC15typicalPropertySo5GizmoCvg : $@convention(method) (@guaranteed Hoozit) -> @owned Gizmo
+ // CHECK: bb0(%0 : @guaranteed $Hoozit):
+ // CHECK-NEXT: debug_value %0
+ // CHECK-NEXT: [[ADDR:%.*]] = ref_element_addr %0 : {{.*}}, #Hoozit.typicalProperty
+ // CHECK-NEXT: [[READ:%.*]] = begin_access [read] [dynamic] [[ADDR]] : $*Gizmo
+ // CHECK-NEXT: [[RES:%.*]] = load [copy] [[READ]] {{.*}}
+ // CHECK-NEXT: end_access [[READ]] : $*Gizmo
+ // CHECK-NEXT: return [[RES]]
+
+ // -- setter
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC15typicalPropertySo5GizmoCvsTo : $@convention(objc_method) (Gizmo, Hoozit) -> () {
+ // CHECK: bb0([[VALUE:%.*]] : @unowned $Gizmo, [[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK: [[VALUE_COPY:%.*]] = copy_value [[VALUE]] : $Gizmo
+ // CHECK: [[THIS_COPY:%.*]] = copy_value [[THIS]] : $Hoozit
+ // CHECK: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK: // function_ref objc_thunks.Hoozit.typicalProperty.setter
+ // CHECK: [[FR:%.*]] = function_ref @$S11objc_thunks6HoozitC15typicalPropertySo5GizmoCvs
+ // CHECK: [[RES:%.*]] = apply [[FR]]([[VALUE_COPY]], [[BORROWED_THIS_COPY]])
+ // CHECK: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK: destroy_value [[THIS_COPY]]
+ // CHECK: return [[RES]] : $(), loc {{.*}}, scope {{.*}} // id: {{.*}} line:[[@LINE-34]]:13:auto_gen
+ // CHECK: } // end sil function '$S11objc_thunks6HoozitC15typicalPropertySo5GizmoCvsTo'
+
+ // CHECK-LABEL: sil hidden @$S11objc_thunks6HoozitC15typicalPropertySo5GizmoCvs
+ // CHECK: bb0([[ARG0:%.*]] : @owned $Gizmo, [[ARG1:%.*]] : @guaranteed $Hoozit):
+ // CHECK: [[BORROWED_ARG0:%.*]] = begin_borrow [[ARG0]]
+ // CHECK: [[ARG0_COPY:%.*]] = copy_value [[BORROWED_ARG0]]
+ // CHECK: [[ADDR:%.*]] = ref_element_addr [[ARG1]] : {{.*}}, #Hoozit.typicalProperty
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[ADDR]] : $*Gizmo
+ // CHECK: assign [[ARG0_COPY]] to [[WRITE]] : $*Gizmo
+ // CHECK: end_access [[WRITE]] : $*Gizmo
+ // CHECK: end_borrow [[BORROWED_ARG0]] from [[ARG0]]
+ // CHECK: destroy_value [[ARG0]]
+ // CHECK: } // end sil function '$S11objc_thunks6HoozitC15typicalPropertySo5GizmoCvs'
+
+ // NS_RETURNS_RETAINED getter by family (-copy)
+ @objc var copyProperty: Gizmo
+ // -- getter
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC12copyPropertySo5GizmoCvgTo : $@convention(objc_method) (Hoozit) -> @owned Gizmo {
+ // CHECK: bb0([[SELF:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK-NEXT: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK-NEXT: // function_ref objc_thunks.Hoozit.copyProperty.getter
+ // CHECK-NEXT: [[FR:%.*]] = function_ref @$S11objc_thunks6HoozitC12copyPropertySo5GizmoCvg
+ // CHECK-NEXT: [[RES:%.*]] = apply [[FR]]([[BORROWED_SELF_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK-NEXT: destroy_value [[SELF_COPY]]
+ // CHECK-NEXT: return [[RES]]
+ // CHECK-NEXT: }
+
+ // CHECK-LABEL: sil hidden @$S11objc_thunks6HoozitC12copyPropertySo5GizmoCvg
+ // CHECK: bb0(%0 : @guaranteed $Hoozit):
+ // CHECK: [[ADDR:%.*]] = ref_element_addr %0 : {{.*}}, #Hoozit.copyProperty
+ // CHECK-NEXT: [[READ:%.*]] = begin_access [read] [dynamic] [[ADDR]] : $*Gizmo
+ // CHECK-NEXT: [[RES:%.*]] = load [copy] [[READ]]
+ // CHECK-NEXT: end_access [[READ]] : $*Gizmo
+ // CHECK-NEXT: return [[RES]]
+
+ // -- setter is normal
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC12copyPropertySo5GizmoCvsTo : $@convention(objc_method) (Gizmo, Hoozit) -> () {
+ // CHECK: bb0([[VALUE:%.*]] : @unowned $Gizmo, [[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[VALUE_COPY:%.*]] = copy_value [[VALUE]]
+ // CHECK-NEXT: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK-NEXT: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK-NEXT: // function_ref objc_thunks.Hoozit.copyProperty.setter
+ // CHECK-NEXT: [[FR:%.*]] = function_ref @$S11objc_thunks6HoozitC12copyPropertySo5GizmoCvs
+ // CHECK-NEXT: [[RES:%.*]] = apply [[FR]]([[VALUE_COPY]], [[BORROWED_THIS_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK-NEXT: destroy_value [[THIS_COPY]]
+ // CHECK-NEXT: return [[RES]]
+
+ // CHECK-LABEL: sil hidden @$S11objc_thunks6HoozitC12copyPropertySo5GizmoCvs
+ // CHECK: bb0([[ARG1:%.*]] : @owned $Gizmo, [[SELF:%.*]] : @guaranteed $Hoozit):
+ // CHECK: [[BORROWED_ARG1:%.*]] = begin_borrow [[ARG1]]
+ // CHECK: [[ARG1_COPY:%.*]] = copy_value [[BORROWED_ARG1]]
+ // CHECK: [[ADDR:%.*]] = ref_element_addr [[SELF]] : {{.*}}, #Hoozit.copyProperty
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[ADDR]] : $*Gizmo
+ // CHECK: assign [[ARG1_COPY]] to [[WRITE]]
+ // CHECK: end_access [[WRITE]] : $*Gizmo
+ // CHECK: end_borrow [[BORROWED_ARG1]] from [[ARG1]]
+ // CHECK: destroy_value [[ARG1]]
+ // CHECK: } // end sil function '$S11objc_thunks6HoozitC12copyPropertySo5GizmoCvs'
+
+ @objc var roProperty: Gizmo { return self }
+ // -- getter
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC10roPropertySo5GizmoCvgTo : $@convention(objc_method) (Hoozit) -> @autoreleased Gizmo {
+ // CHECK: bb0([[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK-NEXT: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC10roPropertySo5GizmoCvg : $@convention(method) (@guaranteed Hoozit) -> @owned Gizmo
+ // CHECK-NEXT: [[RES:%.*]] = apply [[NATIVE]]([[BORROWED_THIS_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK-NEXT: destroy_value [[THIS_COPY]] : $Hoozit
+ // CHECK-NEXT: return [[RES]] : $Gizmo
+ // CHECK-NEXT: } // end sil function '$S11objc_thunks6HoozitC10roPropertySo5GizmoCvgTo'
+
+ // -- no setter
+ // CHECK-NOT: sil hidden [thunk] @$S11objc_thunks6HoozitC10roPropertySo5GizmoCvsTo
+
+ @objc var rwProperty: Gizmo {
+ get {
+ return self
+ }
+ set {}
+ }
+ // -- getter
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC10rwPropertySo5GizmoCvgTo : $@convention(objc_method) (Hoozit) -> @autoreleased Gizmo
+
+ // -- setter
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC10rwPropertySo5GizmoCvsTo : $@convention(objc_method) (Gizmo, Hoozit) -> () {
+ // CHECK: bb0([[VALUE:%.*]] : @unowned $Gizmo, [[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[VALUE_COPY:%.*]] = copy_value [[VALUE]]
+ // CHECK-NEXT: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK-NEXT: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC10rwPropertySo5GizmoCvs : $@convention(method) (@owned Gizmo, @guaranteed Hoozit) -> ()
+ // CHECK-NEXT: apply [[NATIVE]]([[VALUE_COPY]], [[BORROWED_THIS_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK-NEXT: destroy_value [[THIS_COPY]]
+ // CHECK-NEXT: return
+ // CHECK-NEXT: }
+
+ @objc var copyRWProperty: Gizmo {
+ get {
+ return self
+ }
+ set {}
+ }
+ // -- getter
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC14copyRWPropertySo5GizmoCvgTo : $@convention(objc_method) (Hoozit) -> @owned Gizmo {
+ // CHECK: bb0([[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK-NEXT: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC14copyRWPropertySo5GizmoCvg : $@convention(method) (@guaranteed Hoozit) -> @owned Gizmo
+ // CHECK-NEXT: [[RES:%.*]] = apply [[NATIVE]]([[BORROWED_THIS_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK-NEXT: destroy_value [[THIS_COPY]]
+ // CHECK-NOT: return
+ // CHECK-NEXT: return [[RES]]
+ // CHECK-NEXT: }
+
+ // -- setter is normal
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC14copyRWPropertySo5GizmoCvsTo : $@convention(objc_method) (Gizmo, Hoozit) -> () {
+ // CHECK: bb0([[VALUE:%.*]] : @unowned $Gizmo, [[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[VALUE_COPY:%.*]] = copy_value [[VALUE]]
+ // CHECK-NEXT: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK-NEXT: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC14copyRWPropertySo5GizmoCvs : $@convention(method) (@owned Gizmo, @guaranteed Hoozit) -> ()
+ // CHECK-NEXT: apply [[NATIVE]]([[VALUE_COPY]], [[BORROWED_THIS_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK-NEXT: destroy_value [[THIS_COPY]]
+ // CHECK-NEXT: return
+ // CHECK-NEXT: }
+
+ @objc var initProperty: Gizmo
+ // -- getter
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC12initPropertySo5GizmoCvgTo : $@convention(objc_method) (Hoozit) -> @autoreleased Gizmo {
+ // CHECK: bb0([[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK-NEXT: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC12initPropertySo5GizmoCvg : $@convention(method) (@guaranteed Hoozit) -> @owned Gizmo
+ // CHECK-NEXT: [[RES:%.*]] = apply [[NATIVE]]([[BORROWED_THIS_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK-NEXT: destroy_value [[THIS_COPY]]
+ // CHECK-NEXT: return [[RES]]
+ // CHECK-NEXT: }
+
+ // -- setter
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC12initPropertySo5GizmoCvsTo : $@convention(objc_method) (Gizmo, Hoozit) -> () {
+ // CHECK: bb0([[VALUE:%.*]] : @unowned $Gizmo, [[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[VALUE_COPY:%.*]] = copy_value [[VALUE]]
+ // CHECK-NEXT: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK-NEXT: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC12initPropertySo5GizmoCvs : $@convention(method) (@owned Gizmo, @guaranteed Hoozit) -> ()
+ // CHECK-NEXT: apply [[NATIVE]]([[VALUE_COPY]], [[BORROWED_THIS_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK-NEXT: destroy_value [[THIS_COPY]]
+ // CHECK-NEXT: return
+ // CHECK-NEXT: }
+
+ @objc var propComputed: Gizmo {
+ @objc(initPropComputedGetter) get { return self }
+ @objc(initPropComputedSetter:) set {}
+ }
+ // -- getter
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC12propComputedSo5GizmoCvgTo : $@convention(objc_method) (Hoozit) -> @autoreleased Gizmo {
+ // CHECK: bb0([[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK-NEXT: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC12propComputedSo5GizmoCvg : $@convention(method) (@guaranteed Hoozit) -> @owned Gizmo
+ // CHECK-NEXT: [[RES:%.*]] = apply [[NATIVE]]([[BORROWED_THIS_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK-NEXT: destroy_value [[THIS_COPY]]
+ // CHECK-NEXT: return [[RES]]
+ // CHECK-NEXT: }
+
+ // -- setter
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC12propComputedSo5GizmoCvsTo : $@convention(objc_method) (Gizmo, Hoozit) -> () {
+ // CHECK: bb0([[VALUE:%.*]] : @unowned $Gizmo, [[THIS:%.*]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[VALUE_COPY:%.*]] = copy_value [[VALUE]]
+ // CHECK-NEXT: [[THIS_COPY:%.*]] = copy_value [[THIS]]
+ // CHECK-NEXT: [[BORROWED_THIS_COPY:%.*]] = begin_borrow [[THIS_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6HoozitC12propComputedSo5GizmoCvs : $@convention(method) (@owned Gizmo, @guaranteed Hoozit) -> ()
+ // CHECK-NEXT: apply [[NATIVE]]([[VALUE_COPY]], [[BORROWED_THIS_COPY]])
+ // CHECK-NEXT: end_borrow [[BORROWED_THIS_COPY]] from [[THIS_COPY]]
+ // CHECK-NEXT: destroy_value [[THIS_COPY]]
+ // CHECK-NEXT: return
+ // CHECK-NEXT: }
+
+ // Don't export generics to ObjC yet
+ func generic<T>(_ x: T) {}
+ // CHECK-NOT: sil hidden [thunk] @_TToFC11objc_thunks6Hoozit7generic{{.*}}
+
+ // Constructor.
+ // CHECK-LABEL: sil hidden @$S11objc_thunks6HoozitC7bellsOnACSi_tcfc : $@convention(method) (Int, @owned Hoozit) -> @owned Hoozit {
+ // CHECK: [[SELF_BOX:%[0-9]+]] = alloc_box ${ var Hoozit }
+ // CHECK: [[MARKED_SELF_BOX:%[0-9]+]] = mark_uninitialized [derivedself] [[SELF_BOX]]
+ // CHECK: [[PB_BOX:%.*]] = project_box [[MARKED_SELF_BOX]]
+ // CHECK: [[GIZMO:%[0-9]+]] = upcast [[SELF:%[0-9]+]] : $Hoozit to $Gizmo
+ // CHECK: [[BORROWED_GIZMO:%.*]] = begin_borrow [[GIZMO]]
+ // CHECK: [[CAST_BORROWED_GIZMO:%.*]] = unchecked_ref_cast [[BORROWED_GIZMO]] : $Gizmo to $Hoozit
+ // CHECK: [[SUPERMETHOD:%[0-9]+]] = objc_super_method [[CAST_BORROWED_GIZMO]] : $Hoozit, #Gizmo.init!initializer.1.foreign : (Gizmo.Type) -> (Int) -> Gizmo?, $@convention(objc_method) (Int, @owned Gizmo) -> @owned Optional<Gizmo>
+ // CHECK-NEXT: end_borrow [[BORROWED_GIZMO]] from [[GIZMO]]
+ // CHECK-NEXT: [[SELF_REPLACED:%[0-9]+]] = apply [[SUPERMETHOD]](%0, [[X:%[0-9]+]]) : $@convention(objc_method) (Int, @owned Gizmo) -> @owned Optional<Gizmo>
+ // CHECK-NOT: unconditional_checked_cast downcast [[SELF_REPLACED]] : $Gizmo to $Hoozit
+ // CHECK: unchecked_ref_cast
+ // CHECK: return
+ override init(bellsOn x : Int) {
+ super.init(bellsOn: x)
+ other()
+ }
+
+ // Subscript
+ @objc subscript (i: Int) -> Hoozit {
+ // Getter
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitCyACSicigTo : $@convention(objc_method) (Int, Hoozit) -> @autoreleased Hoozit
+ // CHECK: bb0([[I:%[0-9]+]] : @trivial $Int, [[SELF:%[0-9]+]] : @unowned $Hoozit):
+ // CHECK-NEXT: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $Hoozit
+ // CHECK-NEXT: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%[0-9]+]] = function_ref @$S11objc_thunks6HoozitCyACSicig : $@convention(method) (Int, @guaranteed Hoozit) -> @owned Hoozit
+ // CHECK-NEXT: [[RESULT:%[0-9]+]] = apply [[NATIVE]]([[I]], [[BORROWED_SELF_COPY]]) : $@convention(method) (Int, @guaranteed Hoozit) -> @owned Hoozit
+ // CHECK-NEXT: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK-NEXT: destroy_value [[SELF_COPY]]
+ // CHECK-NEXT: return [[RESULT]] : $Hoozit
+ get {
+ return self
+ }
+
+ // Setter
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitCyACSicisTo : $@convention(objc_method) (Hoozit, Int, Hoozit) -> ()
+ // CHECK: bb0([[VALUE:%[0-9]+]] : @unowned $Hoozit, [[I:%[0-9]+]] : @trivial $Int, [[SELF:%[0-9]+]] : @unowned $Hoozit):
+ // CHECK: [[VALUE_COPY:%.*]] = copy_value [[VALUE]] : $Hoozit
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $Hoozit
+ // CHECK: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK: [[NATIVE:%[0-9]+]] = function_ref @$S11objc_thunks6HoozitCyACSicis : $@convention(method) (@owned Hoozit, Int, @guaranteed Hoozit) -> ()
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[NATIVE]]([[VALUE_COPY]], [[I]], [[BORROWED_SELF_COPY]]) : $@convention(method) (@owned Hoozit, Int, @guaranteed Hoozit) -> ()
+ // CHECK: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK: destroy_value [[SELF_COPY]]
+ // CHECK: return [[RESULT]] : $()
+ // CHECK: } // end sil function '$S11objc_thunks6HoozitCyACSicisTo'
+ set {}
+ }
+}
+
+class Wotsit<T> : Gizmo {
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6WotsitC5plainyyFTo : $@convention(objc_method) <T> (Wotsit<T>) -> () {
+ // CHECK: bb0([[SELF:%.*]] : @unowned $Wotsit<T>):
+ // CHECK-NEXT: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $Wotsit<T>
+ // CHECK-NEXT: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6WotsitC5plainyyF : $@convention(method) <τ_0_0> (@guaranteed Wotsit<τ_0_0>) -> ()
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[NATIVE]]<T>([[BORROWED_SELF_COPY]]) : $@convention(method) <τ_0_0> (@guaranteed Wotsit<τ_0_0>) -> ()
+ // CHECK-NEXT: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK-NEXT: destroy_value [[SELF_COPY]] : $Wotsit<T>
+ // CHECK-NEXT: return [[RESULT]] : $()
+ // CHECK-NEXT: }
+ @objc func plain() { }
+
+ func generic<U>(_ x: U) {}
+
+ var property : T
+
+ init(t: T) {
+ self.property = t
+ super.init()
+ }
+
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6WotsitC11descriptionSSvgTo : $@convention(objc_method) <T> (Wotsit<T>) -> @autoreleased NSString {
+ // CHECK: bb0([[SELF:%.*]] : @unowned $Wotsit<T>):
+ // CHECK-NEXT: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $Wotsit<T>
+ // CHECK-NEXT: [[BORROWED_SELF_COPY:%.*]] = begin_borrow [[SELF_COPY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[NATIVE:%.*]] = function_ref @$S11objc_thunks6WotsitC11descriptionSSvg : $@convention(method) <τ_0_0> (@guaranteed Wotsit<τ_0_0>) -> @owned String
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[NATIVE:%.*]]<T>([[BORROWED_SELF_COPY]]) : $@convention(method) <τ_0_0> (@guaranteed Wotsit<τ_0_0>) -> @owned String
+ // CHECK-NEXT: end_borrow [[BORROWED_SELF_COPY]] from [[SELF_COPY]]
+ // CHECK-NEXT: destroy_value [[SELF_COPY]] : $Wotsit<T>
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[BRIDGE:%.*]] = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
+ // CHECK-NEXT: [[BORROWED_RESULT:%.*]] = begin_borrow [[RESULT]]
+ // CHECK-NEXT: [[NSRESULT:%.*]] = apply [[BRIDGE]]([[BORROWED_RESULT]]) : $@convention(method) (@guaranteed String) -> @owned NSString
+ // CHECK-NEXT: end_borrow [[BORROWED_RESULT]] from [[RESULT]]
+ // CHECK-NEXT: destroy_value [[RESULT]]
+ // CHECK-NEXT: return [[NSRESULT]] : $NSString
+ // CHECK-NEXT: }
+ override var description : String {
+ return "Hello, world."
+ }
+
+ // Ivar destroyer
+ // CHECK: sil hidden @$S11objc_thunks6WotsitCfETo
+
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6WotsitCACyxGSgycfcTo : $@convention(objc_method) <T> (@owned Wotsit<T>) -> @owned Optional<Wotsit<T>>
+
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6WotsitC7bellsOnACyxGSgSi_tcfcTo : $@convention(objc_method) <T> (Int, @owned Wotsit<T>) -> @owned Optional<Wotsit<T>>
+}
+
+// CHECK-NOT: sil hidden [thunk] @_TToF{{.*}}Wotsit{{.*}}
+
+// Extension initializers, properties and methods need thunks too.
+extension Hoozit {
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC3intACSi_tcfcTo : $@convention(objc_method) (Int, @owned Hoozit) -> @owned Hoozit
+ @objc dynamic convenience init(int i: Int) { self.init(bellsOn: i) }
+
+ // CHECK-LABEL: sil hidden @$S11objc_thunks6HoozitC6doubleACSd_tcfc : $@convention(method) (Double, @owned Hoozit) -> @owned Hoozit
+ convenience init(double d: Double) {
+ // CHECK: [[SELF_BOX:%[0-9]+]] = alloc_box ${ var Hoozit }
+ // CHECK: [[MARKED_SELF_BOX:%[0-9]+]] = mark_uninitialized [delegatingself] [[SELF_BOX]]
+ // CHECK: [[PB_BOX:%.*]] = project_box [[MARKED_SELF_BOX]]
+ // CHECK: [[X_BOX:%[0-9]+]] = alloc_box ${ var X }
+ var x = X()
+ // CHECK: [[CTOR:%[0-9]+]] = objc_method [[SELF:%[0-9]+]] : $Hoozit, #Hoozit.init!initializer.1.foreign : (Hoozit.Type) -> (Int) -> Hoozit, $@convention(objc_method) (Int, @owned Hoozit) -> @owned Hoozit
+ // CHECK: [[NEW_SELF:%[0-9]+]] = apply [[CTOR]]
+ // CHECK: store [[NEW_SELF]] to [init] [[PB_BOX]] : $*Hoozit
+ // CHECK: return
+ self.init(int:Int(d))
+ other()
+ }
+
+ func foof() {}
+ // CHECK-LABEL: sil hidden [thunk] @$S11objc_thunks6HoozitC4foofyyFTo : $@convention(objc_method) (Hoozit) -> () {
+
+ var extensionProperty: Int { return 0 }
+ // CHECK-LABEL: sil hidden @$S11objc_thunks6HoozitC17extensionPropertySivg : $@convention(method) (@guaranteed Hoozit) -> Int
+}
+
+// Calling objc methods of subclass should go through native entry points
+func useHoozit(_ h: Hoozit) {
+// sil @$S11objc_thunks9useHoozit1hyAA0D0C_tF
+ // In the class decl, overrides importd method, 'dynamic' was inferred
+ h.fork()
+ // CHECK: objc_method {{%.*}} : {{.*}}, #Hoozit.fork!1.foreign
+
+ // In an extension, 'dynamic' was inferred.
+ h.foof()
+ // CHECK: objc_method {{%.*}} : {{.*}}, #Hoozit.foof!1.foreign
+}
+
+func useWotsit(_ w: Wotsit<String>) {
+// sil @$S11objc_thunks9useWotsit1wySo0D0CySSG_tF
+ w.plain()
+ // CHECK: class_method {{%.*}} : {{.*}}, #Wotsit.plain!1 :
+ w.generic(2)
+ // CHECK: class_method {{%.*}} : {{.*}}, #Wotsit.generic!1 :
+
+ // Inherited methods only have objc entry points
+ w.clone()
+ // CHECK: objc_method {{%.*}} : {{.*}}, #Gizmo.clone!1.foreign
+}
+
+func other() { }
+
+class X { }
+
+// CHECK-LABEL: sil hidden @$S11objc_thunks8propertyySiSo5GizmoCF
+func property(_ g: Gizmo) -> Int {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Gizmo):
+ // CHECK: objc_method [[ARG]] : $Gizmo, #Gizmo.count!getter.1.foreign
+ return g.count
+}
+
+// CHECK-LABEL: sil hidden @$S11objc_thunks13blockPropertyyySo5GizmoCF
+func blockProperty(_ g: Gizmo) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $Gizmo):
+ // CHECK: objc_method [[ARG]] : $Gizmo, #Gizmo.block!setter.1.foreign
+ g.block = { }
+ // CHECK: objc_method [[ARG]] : $Gizmo, #Gizmo.block!getter.1.foreign
+ g.block()
+}
+
+class DesignatedStubs : Gizmo {
+ var i: Int
+
+ override init() { i = 5 }
+
+ // CHECK-LABEL: sil hidden @$S11objc_thunks15DesignatedStubsC7bellsOnACSgSi_tcfc
+ // CHECK: string_literal utf8 "objc_thunks.DesignatedStubs"
+ // CHECK: string_literal utf8 "init(bellsOn:)"
+ // CHECK: string_literal utf8 "{{.*}}objc_thunks.swift"
+ // CHECK: function_ref @$Ss25_unimplementedInitializer9className04initD04file4line6columns5NeverOs12StaticStringV_A2JS2utF
+ // CHECK: return
+
+ // CHECK-NOT: sil hidden @_TFCSo15DesignatedStubsc{{.*}}
+}
+
+class DesignatedOverrides : Gizmo {
+ var i: Int = 5
+
+ // CHECK-LABEL: sil hidden @$S11objc_thunks19DesignatedOverridesCACSgycfc
+ // CHECK-NOT: return
+ // CHECK: function_ref @$S11objc_thunks19DesignatedOverridesC1iSivpfi : $@convention(thin) () -> Int
+ // CHECK: objc_super_method [[SELF:%[0-9]+]] : $DesignatedOverrides, #Gizmo.init!initializer.1.foreign : (Gizmo.Type) -> () -> Gizmo?, $@convention(objc_method) (@owned Gizmo) -> @owned Optional<Gizmo>
+ // CHECK: return
+
+ // CHECK-LABEL: sil hidden @$S11objc_thunks19DesignatedOverridesC7bellsOnACSgSi_tcfc
+ // CHECK: function_ref @$S11objc_thunks19DesignatedOverridesC1iSivpfi : $@convention(thin) () -> Int
+ // CHECK: objc_super_method [[SELF:%[0-9]+]] : $DesignatedOverrides, #Gizmo.init!initializer.1.foreign : (Gizmo.Type) -> (Int) -> Gizmo?, $@convention(objc_method) (Int, @owned Gizmo) -> @owned Optional<Gizmo>
+ // CHECK: return
+}
+
+// Make sure we copy blocks passed in as IUOs - <rdar://problem/22471309>
+
+func registerAnsible() {
+ // CHECK: function_ref @$S11objc_thunks15registerAnsibleyyFyyycSgcfU_
+ Ansible.anseAsync({ completion in completion!() })
+}
diff --git a/test/SILGen/plus_zero_opaque_ownership.swift b/test/SILGen/plus_zero_opaque_ownership.swift
new file mode 100644
index 0000000..622ffaf
--- /dev/null
+++ b/test/SILGen/plus_zero_opaque_ownership.swift
@@ -0,0 +1,257 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-opaque-values -enable-sil-ownership -emit-sorted-sil -Xllvm -sil-full-demangle -emit-silgen -parse-stdlib -parse-as-library -module-name Swift %s | %FileCheck %s
+// RUN: %target-swift-frontend -target x86_64-apple-macosx10.9 -enable-sil-opaque-values -enable-sil-ownership -emit-sorted-sil -Xllvm -sil-full-demangle -emit-silgen -parse-stdlib -parse-as-library -module-name Swift %s | %FileCheck --check-prefix=CHECK-OSX %s
+
+public typealias AnyObject = Builtin.AnyObject
+
+precedencegroup AssignmentPrecedence {}
+precedencegroup CastingPrecedence {}
+precedencegroup ComparisonPrecedence {}
+
+public protocol _ObjectiveCBridgeable {}
+
+public protocol UnkeyedDecodingContainer {
+ var isAtEnd: Builtin.Int1 { get }
+}
+
+public protocol Decoder {
+ func unkeyedContainer() throws -> UnkeyedDecodingContainer
+}
+
+// Test open_existential_value ownership
+// ---
+// CHECK-LABEL: sil @$Ss11takeDecoder4fromBi1_s0B0_p_tKF : $@convention(thin) (@in_guaranteed Decoder) -> (Builtin.Int1, @error Error) {
+// CHECK: bb0(%0 : @guaranteed $Decoder):
+// CHECK: [[OPENED:%.*]] = open_existential_value %0 : $Decoder to $@opened("{{.*}}") Decoder
+// CHECK: [[WT:%.*]] = witness_method $@opened("{{.*}}") Decoder, #Decoder.unkeyedContainer!1 : <Self where Self : Decoder> (Self) -> () throws -> UnkeyedDecodingContainer, %3 : $@opened("{{.*}}") Decoder : $@convention(witness_method: Decoder) <τ_0_0 where τ_0_0 : Decoder> (@in_guaranteed τ_0_0) -> (@out UnkeyedDecodingContainer, @error Error)
+// CHECK: try_apply [[WT]]<@opened("{{.*}}") Decoder>([[OPENED]]) : $@convention(witness_method: Decoder) <τ_0_0 where τ_0_0 : Decoder> (@in_guaranteed τ_0_0) -> (@out UnkeyedDecodingContainer, @error Error), normal bb2, error bb1
+//
+// CHECK:bb{{.*}}([[RET1:%.*]] : @owned $UnkeyedDecodingContainer):
+// CHECK: [[BORROW2:%.*]] = begin_borrow [[RET1]] : $UnkeyedDecodingContainer
+// CHECK: [[OPENED2:%.*]] = open_existential_value [[BORROW2]] : $UnkeyedDecodingContainer to $@opened("{{.*}}") UnkeyedDecodingContainer
+// CHECK: [[WT2:%.*]] = witness_method $@opened("{{.*}}") UnkeyedDecodingContainer, #UnkeyedDecodingContainer.isAtEnd!getter.1 : <Self where Self : UnkeyedDecodingContainer> (Self) -> () -> Builtin.Int1, [[OPENED2]] : $@opened("{{.*}}") UnkeyedDecodingContainer : $@convention(witness_method: UnkeyedDecodingContainer) <τ_0_0 where τ_0_0 : UnkeyedDecodingContainer> (@in_guaranteed τ_0_0) -> Builtin.Int1
+// CHECK: [[RET2:%.*]] = apply [[WT2]]<@opened("{{.*}}") UnkeyedDecodingContainer>([[OPENED2]]) : $@convention(witness_method: UnkeyedDecodingContainer) <τ_0_0 where τ_0_0 : UnkeyedDecodingContainer> (@in_guaranteed τ_0_0) -> Builtin.Int1
+// CHECK: end_borrow [[BORROW2]] from [[RET1]] : $UnkeyedDecodingContainer, $UnkeyedDecodingContainer
+// CHECK: destroy_value [[RET1]] : $UnkeyedDecodingContainer
+// CHECK-NOT: destroy_value %0 : $Decoder
+// CHECK: return [[RET2]] : $Builtin.Int1
+// CHECK-LABEL: } // end sil function '$Ss11takeDecoder4fromBi1_s0B0_p_tKF'
+public func takeDecoder(from decoder: Decoder) throws -> Builtin.Int1 {
+ let container = try decoder.unkeyedContainer()
+ return container.isAtEnd
+}
+
+// Test unsafe_bitwise_cast nontrivial ownership.
+// ---
+// CHECK-LABEL: sil @$Ss13unsafeBitCast_2toq_x_q_mtr0_lF : $@convention(thin) <T, U> (@in_guaranteed T, @thick U.Type) -> @out U {
+// CHECK: bb0([[ARG0:%.*]] : @guaranteed $T, [[ARG1:%.*]] : @trivial $@thick U.Type):
+// CHECK: [[RESULT:%.*]] = unchecked_bitwise_cast [[ARG0]] : $T to $U
+// CHECK: [[RESULT_COPY:%.*]] = copy_value [[RESULT]] : $U
+// CHECK: return [[RESULT_COPY]] : $U
+// CHECK-LABEL: } // end sil function '$Ss13unsafeBitCast_2toq_x_q_mtr0_lF'
+public func unsafeBitCast<T, U>(_ x: T, to type: U.Type) -> U {
+ return Builtin.reinterpretCast(x)
+}
+
+// A lot of standard library support is necessary to support raw enums.
+// --------------------------------------------------------------------
+
+infix operator == : ComparisonPrecedence
+infix operator ~= : ComparisonPrecedence
+
+public struct Bool {
+ var _value: Builtin.Int1
+
+ public init() {
+ let zero: Int64 = 0
+ self._value = Builtin.trunc_Int64_Int1(zero._value)
+ }
+
+ internal init(_ v: Builtin.Int1) { self._value = v }
+
+ public init(_ value: Bool) {
+ self = value
+ }
+}
+
+extension Bool {
+ public func _getBuiltinLogicValue() -> Builtin.Int1 {
+ return _value
+ }
+}
+
+public protocol Equatable {
+ /// Returns a Boolean value indicating whether two values are equal.
+ ///
+ /// Equality is the inverse of inequality. For any values `a` and `b`,
+ /// `a == b` implies that `a != b` is `false`.
+ ///
+ /// - Parameters:
+ /// - lhs: A value to compare.
+ /// - rhs: Another value to compare.
+ static func == (lhs: Self, rhs: Self) -> Bool
+}
+
+public func ~= <T : Equatable>(a: T, b: T) -> Bool {
+ return a == b
+}
+
+public protocol RawRepresentable {
+ associatedtype RawValue
+
+ init?(rawValue: RawValue)
+
+ var rawValue: RawValue { get }
+}
+
+public func == <T : RawRepresentable>(lhs: T, rhs: T) -> Bool
+ where T.RawValue : Equatable {
+ return lhs.rawValue == rhs.rawValue
+}
+
+public typealias _MaxBuiltinIntegerType = Builtin.Int2048
+
+public protocol _ExpressibleByBuiltinIntegerLiteral {
+ init(_builtinIntegerLiteral value: _MaxBuiltinIntegerType)
+}
+
+public protocol ExpressibleByIntegerLiteral {
+ associatedtype IntegerLiteralType : _ExpressibleByBuiltinIntegerLiteral
+
+ init(integerLiteral value: IntegerLiteralType)
+}
+
+extension ExpressibleByIntegerLiteral
+ where Self : _ExpressibleByBuiltinIntegerLiteral {
+ @_transparent
+ public init(integerLiteral value: Self) {
+ self = value
+ }
+}
+
+public protocol ExpressibleByStringLiteral {}
+public protocol ExpressibleByFloatLiteral {}
+public protocol ExpressibleByUnicodeScalarLiteral {}
+public protocol ExpressibleByExtendedGraphemeClusterLiteral {}
+
+public struct Int64 : ExpressibleByIntegerLiteral, _ExpressibleByBuiltinIntegerLiteral, Equatable {
+ public var _value: Builtin.Int64
+ public init(_builtinIntegerLiteral x: _MaxBuiltinIntegerType) {
+ _value = Builtin.s_to_s_checked_trunc_Int2048_Int64(x).0
+ }
+ public typealias IntegerLiteralType = Int64
+ public init(integerLiteral value: Int64) {
+ self = value
+ }
+ public static func ==(_ lhs: Int64, rhs: Int64) -> Bool {
+ return Bool(Builtin.cmp_eq_Int64(lhs._value, rhs._value))
+ }
+}
+
+// Test ownership of multi-case Enum values in the context of @trivial to @in thunks.
+// ---
+// CHECK-LABEL: sil shared [transparent] [serialized] [thunk] @$Ss17FloatingPointSignOs9EquatablessACP2eeoiySbx_xtFZTW : $@convention(witness_method: Equatable) (@in_guaranteed FloatingPointSign, @in_guaranteed FloatingPointSign, @thick FloatingPointSign.Type) -> Bool {
+// CHECK: bb0(%0 : @trivial $FloatingPointSign, %1 : @trivial $FloatingPointSign, %2 : @trivial $@thick FloatingPointSign.Type):
+// CHECK: %3 = function_ref @$Ss2eeoiySbx_xts16RawRepresentableRzs9Equatable0B5ValueRpzlF : $@convention(thin) <τ_0_0 where τ_0_0 : RawRepresentable, τ_0_0.RawValue : Equatable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0) -> Bool
+// CHECK: %4 = apply %3<FloatingPointSign, Int64>(%0, %1) : $@convention(thin) <τ_0_0 where τ_0_0 : RawRepresentable, τ_0_0.RawValue : Equatable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0) -> Bool
+// CHECK: return %4 : $Bool
+// CHECK-LABEL: } // end sil function '$Ss17FloatingPointSignOs9EquatablessACP2eeoiySbx_xtFZTW'
+public enum FloatingPointSign: Int64 {
+ /// The sign for a positive value.
+ case plus
+
+ /// The sign for a negative value.
+ case minus
+}
+
+#if os(OSX)
+// Test open_existential_value used in a conversion context.
+// (the actual bridging call is dropped because we don't import Swift).
+// ---
+// CHECK-OSX-LABEL: sil @$Ss26_unsafeDowncastToAnyObject04fromD0yXlyp_tF : $@convention(thin) (@in_guaranteed Any) -> @owned AnyObject {
+// CHECK-OSX: bb0(%0 : @guaranteed $Any):
+// CHECK-OSX: [[COPY:%.*]] = copy_value %0 : $Any
+// CHECK-OSX: [[BORROW2:%.*]] = begin_borrow [[COPY]] : $Any
+// CHECK-OSX: [[VAL:%.*]] = open_existential_value [[BORROW2]] : $Any to $@opened
+// CHECK-OSX: [[COPY2:%.*]] = copy_value [[VAL]] : $@opened
+// CHECK-OSX: destroy_value [[COPY2]] : $@opened
+// CHECK-OSX: end_borrow [[BORROW2]] from [[COPY]] : $Any, $Any
+// CHECK-OSX: destroy_value [[COPY]] : $Any
+// CHECK-OSX-NOT: destroy_value %0 : $Any
+// CHECK-OSX: return undef : $AnyObject
+// CHECK-OSX-LABEL: } // end sil function '$Ss26_unsafeDowncastToAnyObject04fromD0yXlyp_tF'
+public func _unsafeDowncastToAnyObject(fromAny any: Any) -> AnyObject {
+ return any as AnyObject
+}
+#endif
+
+public protocol Error {}
+
+#if os(OSX)
+// Test open_existential_box_value in a conversion context.
+// ---
+// CHECK-OSX-LABEL: sil @$Ss3foo1eys5Error_pSg_tF : $@convention(thin) (@guaranteed Optional<Error>) -> () {
+// CHECK-OSX: [[BORROW:%.*]] = begin_borrow %{{.*}} : $Error
+// CHECK-OSX: [[VAL:%.*]] = open_existential_box_value [[BORROW]] : $Error to $@opened
+// CHECK-OSX: [[COPY:%.*]] = copy_value [[VAL]] : $@opened
+// CHECK-OSX: [[ANY:%.*]] = init_existential_value [[COPY]] : $@opened
+// CHECK-OSX: end_borrow [[BORROW]] from %{{.*}} : $Error, $Error
+// CHECK-OSX-LABEL: } // end sil function '$Ss3foo1eys5Error_pSg_tF'
+public func foo(e: Error?) {
+ if let u = e {
+ let a: Any = u
+ _ = a
+ }
+}
+#endif
+
+public enum Optional<Wrapped> {
+ case none
+ case some(Wrapped)
+}
+
+public protocol IP {}
+
+public protocol Seq {
+ associatedtype Iterator : IP
+
+ func makeIterator() -> Iterator
+}
+
+extension Seq where Self.Iterator == Self {
+ public func makeIterator() -> Self {
+ return self
+ }
+}
+
+public struct EnumIter<Base : IP> : IP, Seq {
+ internal var _base: Base
+
+ public typealias Iterator = EnumIter<Base>
+}
+
+// Test passing a +1 RValue to @in_guaranteed.
+// ---
+// CHECK-LABEL: sil @$Ss7EnumSeqV12makeIterators0A4IterVy0D0QzGyF : $@convention(method) <Base where Base : Seq> (@in_guaranteed EnumSeq<Base>) -> @out EnumIter<Base.Iterator> {
+// CHECK: bb0(%0 : @guaranteed $EnumSeq<Base>):
+// CHECK: [[MT:%.*]] = metatype $@thin EnumIter<Base.Iterator>.Type
+// CHECK: [[FIELD:%.*]] = struct_extract %0 : $EnumSeq<Base>, #EnumSeq._base
+// CHECK: [[COPY:%.*]] = copy_value [[FIELD]] : $Base
+// CHECK: [[BORROW:%.*]] = begin_borrow [[COPY]] : $Base
+// CHECK: [[WT:%.*]] = witness_method $Base, #Seq.makeIterator!1 : <Self where Self : Seq> (Self) -> () -> Self.Iterator : $@convention(witness_method: Seq) <τ_0_0 where τ_0_0 : Seq> (@in_guaranteed τ_0_0) -> @out τ_0_0.Iterator
+// CHECK: [[ITER:%.*]] = apply [[WT]]<Base>([[BORROW]]) : $@convention(witness_method: Seq) <τ_0_0 where τ_0_0 : Seq> (@in_guaranteed τ_0_0) -> @out τ_0_0.Iterator
+// CHECK: end_borrow [[BORROW]] from [[COPY]] : $Base, $Base
+// CHECK: destroy_value [[COPY]] : $Base
+// CHECK: [[FN:%.*]] = function_ref @$Ss8EnumIterV5_baseAByxGx_tcfC : $@convention(method) <τ_0_0 where τ_0_0 : IP> (@in τ_0_0, @thin EnumIter<τ_0_0>.Type) -> @out EnumIter<τ_0_0>
+// CHECK: [[RET:%.*]] = apply [[FN]]<Base.Iterator>([[ITER]], [[MT]]) : $@convention(method) <τ_0_0 where τ_0_0 : IP> (@in τ_0_0, @thin EnumIter<τ_0_0>.Type) -> @out EnumIter<τ_0_0>
+// CHECK: return [[RET]] : $EnumIter<Base.Iterator>
+// CHECK-LABEL: } // end sil function '$Ss7EnumSeqV12makeIterators0A4IterVy0D0QzGyF'
+public struct EnumSeq<Base : Seq> : Seq {
+ public typealias Iterator = EnumIter<Base.Iterator>
+
+ internal var _base: Base
+
+ public func makeIterator() -> Iterator {
+ return EnumIter(_base: _base.makeIterator())
+ }
+}
diff --git a/test/SILGen/plus_zero_opaque_values_silgen.swift b/test/SILGen/plus_zero_opaque_values_silgen.swift
new file mode 100644
index 0000000..1c7f8f7
--- /dev/null
+++ b/test/SILGen/plus_zero_opaque_values_silgen.swift
@@ -0,0 +1,1236 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-opaque-values -emit-sorted-sil -Xllvm -sil-full-demangle -emit-silgen %s | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-runtime
+
+// UNSUPPORTED: resilient_stdlib
+
+struct TrivialStruct {
+ var x: Int
+}
+
+protocol Foo {
+ func foo()
+}
+
+protocol P {
+ var x : Int { get }
+}
+
+protocol P2 : P {}
+
+extension TrivialStruct : P2 {}
+
+struct Box<T> {
+ let t: T
+}
+
+protocol EmptyP {}
+
+struct AddressOnlyStruct : EmptyP {}
+
+struct AnyStruct {
+ let a: Any
+}
+
+protocol Clonable {
+ func maybeClone() -> Self?
+}
+
+indirect enum IndirectEnum<T> {
+ case Nil
+ case Node(T)
+}
+
+protocol SubscriptableGet {
+ subscript(a : Int) -> Int { get }
+}
+
+protocol SubscriptableGetSet {
+ subscript(a : Int) -> Int { get set }
+}
+
+var subscriptableGet : SubscriptableGet
+var subscriptableGetSet : SubscriptableGetSet
+
+class OpaqueClass<T> {
+ typealias ObnoxiousTuple = (T, (T.Type, (T) -> T))
+
+ func inAndOut(x: T) -> T { return x }
+ func variantOptionalityTuples(x: ObnoxiousTuple) -> ObnoxiousTuple? { return x }
+}
+
+class StillOpaqueClass<T>: OpaqueClass<T> {
+ override func variantOptionalityTuples(x: ObnoxiousTuple?) -> ObnoxiousTuple { return x! }
+}
+
+class OpaqueTupleClass<U>: OpaqueClass<(U, U)> {
+ override func inAndOut(x: (U, U)) -> (U, U) { return x }
+}
+
+func unreachableF<T>() -> (Int, T)? { }
+
+func s010_hasVarArg(_ args: Any...) {}
+
+// Tests Address only enums's construction
+// CHECK-LABEL: sil shared [transparent] @$S20opaque_values_silgen15AddressOnlyEnumO4mereyAcA6EmptyP_pcACmF : $@convention(method) (@in EmptyP, @thin AddressOnlyEnum.Type) -> @out AddressOnlyEnum {
+// CHECK: bb0([[ARG0:%.*]] : $EmptyP, [[ARG1:%.*]] : $@thin AddressOnlyEnum.Type):
+// CHECK: [[RETVAL:%.*]] = enum $AddressOnlyEnum, #AddressOnlyEnum.mere!enumelt.1, [[ARG0]] : $EmptyP
+// CHECK: return [[RETVAL]] : $AddressOnlyEnum
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen15AddressOnlyEnumO4mereyAcA6EmptyP_pcACmF'
+
+// CHECK-LABEL: sil shared [transparent] [thunk] @$S20opaque_values_silgen15AddressOnlyEnumO4mereyAcA6EmptyP_pcACmFTc : $@convention(thin) (@thin AddressOnlyEnum.Type) -> @owned @callee_guaranteed (@in_guaranteed EmptyP) -> @out AddressOnlyEnum {
+// CHECK: bb0([[ARG:%.*]] : $@thin AddressOnlyEnum.Type):
+// CHECK: [[RETVAL:%.*]] = partial_apply {{.*}}([[ARG]]) : $@convention(method) (@in EmptyP, @thin AddressOnlyEnum.Type) -> @out AddressOnlyEnum
+// CHECK: [[CANONICAL_THUNK_FN:%.*]] = function_ref @$S20opaque_values_silgen6EmptyP_pAA15AddressOnlyEnumOIegir_AaB_pADIegnr_TR : $@convention(thin) (@in_guaranteed EmptyP, @guaranteed @callee_guaranteed (@in EmptyP) -> @out AddressOnlyEnum) -> @out AddressOnlyEnum
+// CHECK: [[CANONICAL_THUNK:%.*]] = partial_apply [callee_guaranteed] [[CANONICAL_THUNK_FN]]([[RETVAL]])
+// CHECK: return [[CANONICAL_THUNK]] : $@callee_guaranteed (@in_guaranteed EmptyP) -> @out AddressOnlyEnum
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen15AddressOnlyEnumO4mereyAcA6EmptyP_pcACmFTc'
+enum AddressOnlyEnum {
+ case nought
+ case mere(EmptyP)
+ case phantom(AddressOnlyStruct)
+}
+
+// Test vtables - OpaqueTupleClass
+// ---
+// CHECK-LABEL: sil private @$S20opaque_values_silgen16OpaqueTupleClassC8inAndOut1xx_xtx_xt_tFAA0dF0CAdExx_tFTV : $@convention(method) <U> (@in_guaranteed (U, U), @guaranteed OpaqueTupleClass<U>) -> @out (U, U) {
+// CHECK: bb0([[ARG0:%.*]] : $(U, U), [[ARG1:%.*]] : $OpaqueTupleClass<U>):
+// CHECK: ([[TELEM0:%.*]], [[TELEM1:%.*]]) = destructure_tuple [[ARG0]] : $(U, U)
+// CHECK: [[APPLY:%.*]] = apply {{.*}}<U>([[TELEM0]], [[TELEM1]], [[ARG1]]) : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0, @guaranteed OpaqueTupleClass<τ_0_0>) -> (@out τ_0_0, @out τ_0_0)
+// CHECK: [[BORROWED_CALL:%.*]] = begin_borrow [[APPLY]]
+// CHECK: [[BORROWED_CALL_EXT0:%.*]] = tuple_extract [[BORROWED_CALL]] : $(U, U), 0
+// CHECK: [[RETVAL0:%.*]] = copy_value [[BORROWED_CALL_EXT0]] : $U
+// CHECK: [[BORROWED_CALL_EXT1:%.*]] = tuple_extract [[BORROWED_CALL]] : $(U, U), 1
+// CHECK: [[RETVAL1:%.*]] = copy_value [[BORROWED_CALL_EXT1]] : $U
+// CHECK: end_borrow [[BORROWED_CALL]]
+// CHECK: [[RETVAL:%.*]] = tuple ([[RETVAL0]] : $U, [[RETVAL1]] : $U)
+// CHECK: return [[RETVAL]]
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen16OpaqueTupleClassC8inAndOut1xx_xtx_xt_tFAA0dF0CAdExx_tFTV'
+
+// Test vtables - StillOpaqueClass
+// ---
+// CHECK-LABEL: sil private @$S20opaque_values_silgen16StillOpaqueClassC24variantOptionalityTuples1xx_xm_xxcttx_xm_xxcttSg_tFAA0eF0CAdeFx_xm_xxctt_tFTV : $@convention(method) <T> (@in_guaranteed T, @thick T.Type, @guaranteed @callee_guaranteed (@in_guaranteed T) -> @out T, @guaranteed StillOpaqueClass<T>) -> @out Optional<(T, (@thick T.Type, @callee_guaranteed (@in_guaranteed T) -> @out T))> {
+// CHECK: bb0([[ARG0:%.*]] : $T, [[ARG1:%.*]] : $@thick T.Type, [[ARG2:%.*]] : $@callee_guaranteed (@in_guaranteed T) -> @out T, [[ARG3:%.*]] : $StillOpaqueClass<T>):
+// CHECK: [[TELEM0:%.*]] = tuple ([[ARG1]] : $@thick T.Type, [[ARG2]] : $@callee_guaranteed (@in_guaranteed T) -> @out T)
+// CHECK: [[TELEM1:%.*]] = tuple ([[ARG0]] : $T, [[TELEM0]] : $(@thick T.Type, @callee_guaranteed (@in_guaranteed T) -> @out T))
+// CHECK: [[ENUMOPT0:%.*]] = enum $Optional<(T, (@thick T.Type, @callee_guaranteed (@in_guaranteed T) -> @out T))>, #Optional.some!enumelt.1, [[TELEM1]] : $(T, (@thick T.Type, @callee_guaranteed (@in_guaranteed T) -> @out T))
+// CHECK: [[APPLY:%.*]] = apply {{.*}}<T>([[ENUMOPT0]], [[ARG3]]) : $@convention(method) <τ_0_0> (@in_guaranteed Optional<(τ_0_0, (@thick τ_0_0.Type, @callee_guaranteed (@in_guaranteed τ_0_0) -> @out τ_0_0))>, @guaranteed StillOpaqueClass<τ_0_0>) -> (@out τ_0_0, @thick τ_0_0.Type, @owned @callee_guaranteed (@in_guaranteed τ_0_0) -> @out τ_0_0)
+// CHECK: [[BORROWED_T:%.*]] = begin_borrow [[APPLY]]
+// CHECK: [[BORROWED_T_EXT0:%.*]] = tuple_extract [[BORROWED_T]] : $(T, @thick T.Type, @callee_guaranteed (@in_guaranteed T) -> @out T), 0
+// CHECK: [[RETVAL0:%.*]] = copy_value [[BORROWED_T_EXT0]]
+// CHECK: [[BORROWED_T_EXT1:%.*]] = tuple_extract [[BORROWED_T]] : $(T, @thick T.Type, @callee_guaranteed (@in_guaranteed T) -> @out T), 1
+// CHECK: [[BORROWED_T_EXT2:%.*]] = tuple_extract [[BORROWED_T]] : $(T, @thick T.Type, @callee_guaranteed (@in_guaranteed T) -> @out T), 2
+// CHECK: [[RETVAL1:%.*]] = copy_value [[BORROWED_T_EXT2]]
+// CHECK: end_borrow [[BORROWED_T]]
+// CHECK: [[RETTUPLE0:%.*]] = tuple ([[BORROWED_T_EXT1]] : $@thick T.Type, [[RETVAL1]] : $@callee_guaranteed (@in_guaranteed T) -> @out T)
+// CHECK: [[RETTUPLE1:%.*]] = tuple ([[RETVAL0]] : $T, [[RETTUPLE0]] : $(@thick T.Type, @callee_guaranteed (@in_guaranteed T) -> @out T))
+// CHECK: [[RETVAL:%.*]] = enum $Optional<(T, (@thick T.Type, @callee_guaranteed (@in_guaranteed T) -> @out T))>, #Optional.some!enumelt.1, [[RETTUPLE1]] : $(T, (@thick T.Type, @callee_guaranteed (@in_guaranteed T) -> @out T))
+// CHECK: return [[RETVAL]]
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen16StillOpaqueClassC24variantOptionalityTuples1xx_xm_xxcttx_xm_xxcttSg_tFAA0eF0CAdeFx_xm_xxctt_tFTV'
+
+
+// part of s280_convExistTrivial: conversion between existential types - reabstraction thunk
+// ---
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S20opaque_values_silgen1P_pAA13TrivialStructVIegnd_AA2P2_pAaE_pIegnr_TR : $@convention(thin) (@in_guaranteed P2, @guaranteed @callee_guaranteed (@in_guaranteed P) -> TrivialStruct) -> @out P2 {
+// CHECK: bb0([[ARG0:%.*]] : $P2, [[ARG1:%.*]] : $@callee_guaranteed (@in_guaranteed P) -> TrivialStruct):
+// CHECK: [[OPENED_ARG:%.*]] = open_existential_value [[ARG]] : $P2 to $@opened({{.*}}) P2
+// CHECK: [[COPIED_VAL:%.*]] = copy_value [[OPENED_ARG]]
+// CHECK: [[INIT_P:%.*]] = init_existential_value [[COPIED_VAL]] : $@opened({{.*}}) P2, $@opened({{.*}}) P2, $P
+// CHECK: [[BORROWED_INIT_P:%.*]] = begin_borrow [[INIT_P]]
+// CHECK: [[APPLY_P:%.*]] = apply [[ARG1]]([[BORROWED_INIT_P]]) : $@callee_guaranteed (@in_guaranteed P) -> TrivialStruct
+// CHECK: [[RETVAL:%.*]] = init_existential_value [[APPLY_P]] : $TrivialStruct, $TrivialStruct, $P2
+// CHECK: end_borrow [[BORROWED_INIT_P]]
+// CHECK-NOT: destroy_value [[ARG0]]
+// CHECK: return [[RETVAL]] : $P2
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen1P_pAA13TrivialStructVIegnd_AA2P2_pAaE_pIegnr_TR'
+
+// part of s290_convOptExistTriv: conversion between existential types - reabstraction thunk - optionals case
+// ---
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S20opaque_values_silgen1P_pSgAA13TrivialStructVIegnd_AESgAA2P2_pIegyr_TR : $@convention(thin) (Optional<TrivialStruct>, @guaranteed @callee_guaranteed (@in_guaranteed Optional<P>) -> TrivialStruct) -> @out P2 {
+// CHECK: bb0([[ARG0:%.*]] : $Optional<TrivialStruct>, [[ARG1:%.*]] : $@callee_guaranteed (@in_guaranteed Optional<P>) -> TrivialStruct):
+// CHECK: switch_enum [[ARG0]] : $Optional<TrivialStruct>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb1
+// CHECK: bb1:
+// CHECK: [[ONONE:%.*]] = enum $Optional<P>, #Optional.none!enumelt
+// CHECK: br bb3([[ONONE]] : $Optional<P>)
+// CHECK: bb2([[OSOME:%.*]] : $TrivialStruct):
+// CHECK: [[INIT_S:%.*]] = init_existential_value [[OSOME]] : $TrivialStruct, $TrivialStruct, $P
+// CHECK: [[ENUM_S:%.*]] = enum $Optional<P>, #Optional.some!enumelt.1, [[INIT_S]] : $P
+// CHECK: br bb3([[ENUM_S]] : $Optional<P>)
+// CHECK: bb3([[OPT_S:%.*]] : $Optional<P>):
+// CHECK: [[BORROWED_OPT_S:%.*]] = begin_borrow [[OPT_S]]
+// CHECK: [[APPLY_P:%.*]] = apply [[ARG1]]([[BORROWED_OPT_S]]) : $@callee_guaranteed (@in_guaranteed Optional<P>) -> TrivialStruct
+// CHECK: [[RETVAL:%.*]] = init_existential_value [[APPLY_P]] : $TrivialStruct, $TrivialStruct, $P2
+// CHECK: return [[RETVAL]] : $P2
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen1P_pSgAA13TrivialStructVIegnd_AESgAA2P2_pIegyr_TR'
+
+// Test array initialization - we are still (somewhat) using addresses
+// ---
+// CHECK-LABEL: sil @$S20opaque_values_silgen21s020_______callVarArgyyF : $@convention(thin) () -> () {
+// CHECK: %[[APY:.*]] = apply %{{.*}}<Any>(%{{.*}}) : $@convention(thin) <τ_0_0> (Builtin.Word) -> (@owned Array<τ_0_0>, Builtin.RawPointer)
+// CHECK: %[[BRW:.*]] = begin_borrow %[[APY]]
+// CHECK: %[[TPL:.*]] = tuple_extract %[[BRW]] : $(Array<Any>, Builtin.RawPointer), 1
+// CHECK: end_borrow %[[BRW]] from %[[APY]] : $(Array<Any>, Builtin.RawPointer), $(Array<Any>, Builtin.RawPointer)
+// CHECK: destroy_value %[[APY]]
+// CHECK: %[[PTR:.*]] = pointer_to_address %[[TPL]] : $Builtin.RawPointer to [strict] $*Any
+// CHECK: [[IOPAQUE:%.*]] = init_existential_value %{{.*}} : $Int, $Int, $Any
+// CHECK: store [[IOPAQUE]] to [init] %[[PTR]] : $*Any
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s020_______callVarArgyyF'
+public func s020_______callVarArg() {
+ s010_hasVarArg(3)
+}
+
+// Test emitSemanticStore.
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s030______assigninoutyyxz_xtlF : $@convention(thin) <T> (@inout T, @in_guaranteed T) -> () {
+// CHECK: bb0([[ARG0:%.*]] : $*T, [[ARG1:%.*]] : $T):
+// CHECK: [[CPY:%.*]] = copy_value [[ARG1]] : $T
+// CHECK: [[READ:%.*]] = begin_access [modify] [unknown] [[ARG0]] : $*T
+// CHECK: assign [[CPY]] to [[READ]] : $*T
+// CHECK-NOT: destroy_value [[ARG1]] : $T
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s030______assigninoutyyxz_xtlF'
+func s030______assigninout<T>(_ a: inout T, _ b: T) {
+ a = b
+}
+
+// Test that we no longer use copy_addr or tuple_element_addr when copy by value is possible
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s040___tupleReturnIntyS2i_xt_tlF : $@convention(thin) <T> (Int, @in_guaranteed T) -> Int {
+// CHECK: bb0([[ARG0:%.*]] : $Int, [[ARG1:%.*]] : $T):
+// CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]]
+// CHECK: [[TPL:%.*]] = tuple ([[ARG0]] : $Int, [[ARG1_COPY]] : $T)
+// CHECK: [[BORROWED_ARG1:%.*]] = begin_borrow [[TPL]] : $(Int, T)
+// CHECK: [[CPY:%.*]] = copy_value [[BORROWED_ARG1]] : $(Int, T)
+// CHECK: [[BORROWED_CPY:%.*]] = begin_borrow [[CPY]]
+// CHECK: [[INT:%.*]] = tuple_extract [[BORROWED_CPY]] : $(Int, T), 0
+// CHECK: [[GEN:%.*]] = tuple_extract [[BORROWED_CPY]] : $(Int, T), 1
+// CHECK: [[COPY_GEN:%.*]] = copy_value [[GEN]]
+// CHECK: destroy_value [[COPY_GEN]]
+// CHECK: end_borrow [[BORROWED_CPY]] from [[CPY]]
+// CHECK: destroy_value [[CPY]]
+// CHECK: end_borrow [[BORROWED_ARG1]] from [[TPL]] : $(Int, T), $(Int, T)
+// CHECK: destroy_value [[TPL]] : $(Int, T)
+// CHECK: return [[INT]]
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s040___tupleReturnIntyS2i_xt_tlF'
+func s040___tupleReturnInt<T>(_ x: (Int, T)) -> Int {
+ let y = x.0
+ return y
+}
+
+// Test returning an opaque tuple of tuples.
+// ---
+// CHECK-LABEL: sil hidden [noinline] @$S20opaque_values_silgen21s050______multiResultyx_x_xttxlF : $@convention(thin) <T> (@in_guaranteed T) -> (@out T, @out T, @out T) {
+// CHECK: bb0(%0 : $T):
+// CHECK: %[[CP1:.*]] = copy_value %{{.*}} : $T
+// CHECK: %[[CP2:.*]] = copy_value %{{.*}} : $T
+// CHECK: %[[CP3:.*]] = copy_value %{{.*}} : $T
+// CHECK-NOT: destroy_value %0 : $T
+// CHECK: %[[TPL:.*]] = tuple (%[[CP1]] : $T, %[[CP2]] : $T, %[[CP3]] : $T)
+// CHECK: return %[[TPL]] : $(T, T, T)
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s050______multiResultyx_x_xttxlF'
+@inline(never)
+func s050______multiResult<T>(_ t: T) -> (T, (T, T)) {
+ return (t, (t, t))
+}
+
+// Test returning an opaque tuple of tuples as a concrete tuple.
+// ---
+// CHECK-LABEL: sil @$S20opaque_values_silgen21s060__callMultiResult1iSi_Si_SittSi_tF : $@convention(thin) (Int) -> (Int, Int, Int) {
+// CHECK: bb0(%0 : $Int):
+// CHECK: %[[FN:.*]] = function_ref @$S20opaque_values_silgen21s050______multiResultyx_x_xttxlF : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> (@out τ_0_0, @out τ_0_0, @out τ_0_0)
+// CHECK: %[[TPL:.*]] = apply %[[FN]]<Int>(%0) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> (@out τ_0_0, @out τ_0_0, @out τ_0_0)
+// CHECK: %[[I1:.*]] = tuple_extract %[[TPL]] : $(Int, Int, Int), 0
+// CHECK: %[[I2:.*]] = tuple_extract %[[TPL]] : $(Int, Int, Int), 1
+// CHECK: %[[I3:.*]] = tuple_extract %[[TPL]] : $(Int, Int, Int), 2
+// CHECK: %[[R:.*]] = tuple (%[[I1]] : $Int, %[[I2]] : $Int, %[[I3]] : $Int)
+// CHECK: return %[[R]] : $(Int, Int, Int)
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s060__callMultiResult1iSi_Si_SittSi_tF'
+public func s060__callMultiResult(i: Int) -> (Int, (Int, Int)) {
+ return s050______multiResult(i)
+}
+
+// SILGen, prepareArchetypeCallee. Materialize a
+// non-class-constrainted self from a class-constrained archetype.
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s070__materializeSelf1tyx_tRlzCAA3FooRzlF : $@convention(thin) <T where T : AnyObject, T : Foo> (@guaranteed T) -> () {
+// CHECK: bb0([[ARG:%.*]] : $T):
+// CHECK: [[WITNESS_METHOD:%.*]] = witness_method $T, #Foo.foo!1 : <Self where Self : Foo> (Self) -> () -> () : $@convention(witness_method: Foo) <τ_0_0 where τ_0_0 : Foo> (@in_guaranteed τ_0_0) -> ()
+// CHECK: apply [[WITNESS_METHOD]]<T>([[ARG]]) : $@convention(witness_method: Foo) <τ_0_0 where τ_0_0 : Foo> (@in_guaranteed τ_0_0) -> ()
+// CHECK-NOT: destroy_value [[ARG]] : $T
+// CHECK: return %{{[0-9]+}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s070__materializeSelf1tyx_tRlzCAA3FooRzlF'
+func s070__materializeSelf<T: Foo>(t: T) where T: AnyObject {
+ t.foo()
+}
+
+// Test open existential with opaque values
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s080______________bar1pSiAA1P_p_tF : $@convention(thin) (@in_guaranteed P) -> Int {
+// CHECK: bb0([[ARG:%.*]] : $P):
+// CHECK: [[OPENED_ARG:%.*]] = open_existential_value [[ARG]] : $P to $@opened
+// CHECK: [[WITNESS_FUNC:%.*]] = witness_method $@opened
+// CHECK: [[RESULT:%.*]] = apply [[WITNESS_FUNC]]<{{.*}}>([[OPENED_ARG]]) : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> Int
+// CHECK-NOT: destroy_value [[ARG]] : $P
+// CHECK: return [[RESULT]] : $Int
+func s080______________bar(p: P) -> Int {
+ return p.x
+}
+
+// Test OpaqueTypeLowering copyValue and destroyValue.
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s090___________calleryxxlF : $@convention(thin) <T> (@in_guaranteed T) -> @out T {
+// CHECK: bb0([[ARG:%.*]] : $T):
+// CHECK-NOT: copy_value
+// CHECK: [[RESULT:%.*]] = apply {{%.*}}<T>([[ARG]]) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out τ_0_0
+// CHECK-NOT: destroy_value [[ARG]] : $T
+// CHECK: return %{{.*}} : $T
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s090___________calleryxxlF'
+func s090___________caller<T>(_ t: T) -> T {
+ return s090___________caller(t)
+}
+
+// Test a simple opaque parameter and return value.
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s100_________identityyxxlF : $@convention(thin) <T> (@in_guaranteed T) -> @out T {
+// CHECK: bb0([[ARG:%.*]] : $T):
+// CHECK: [[COPY_ARG:%.*]] = copy_value [[ARG]] : $T
+// CHECK-NOT: destroy_value [[ARG]] : $T
+// CHECK: return [[COPY_ARG]] : $T
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s100_________identityyxxlF'
+func s100_________identity<T>(_ t: T) -> T {
+ return t
+}
+
+// Test a guaranteed opaque parameter.
+// ---
+// CHECK-LABEL: sil private [transparent] [thunk] @$S20opaque_values_silgen21s110___GuaranteedSelfVAA3FooA2aDP3fooyyFTW : $@convention(witness_method: Foo) (@in_guaranteed s110___GuaranteedSelf) -> () {
+// CHECK: bb0(%0 : $s110___GuaranteedSelf):
+// CHECK: %[[F:.*]] = function_ref @$S20opaque_values_silgen21s110___GuaranteedSelfV3fooyyF : $@convention(method) (s110___GuaranteedSelf) -> ()
+// CHECK: apply %[[F]](%0) : $@convention(method) (s110___GuaranteedSelf) -> ()
+// CHECK: return
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s110___GuaranteedSelfVAA3FooA2aDP3fooyyFTW'
+struct s110___GuaranteedSelf : Foo {
+ func foo() {}
+}
+
+// Tests a corner case wherein we used to do a temporary and return a pointer to T instead of T
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s120______returnValueyxxlF : $@convention(thin) <T> (@in_guaranteed T) -> @out T {
+// CHECK: bb0([[ARG:%.*]] : $T):
+// CHECK: [[COPY_ARG1:%.*]] = copy_value [[ARG]] : $T
+// CHECK: [[BORROWED_ARG2:%.*]] = begin_borrow [[COPY_ARG1]]
+// CHECK: [[COPY_ARG2:%.*]] = copy_value [[BORROWED_ARG2]] : $T
+// CHECK: end_borrow [[BORROWED_ARG2]] from [[COPY_ARG1]]
+// CHECK: return [[COPY_ARG2]] : $T
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s120______returnValueyxxlF'
+func s120______returnValue<T>(_ x: T) -> T {
+ let y = x
+ return y
+}
+
+// Tests Optional initialization by value
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s130_____________wrapyxSgxlF : $@convention(thin) <T> (@in_guaranteed T) -> @out Optional<T> {
+// CHECK: bb0([[ARG:%.*]] : $T):
+// CHECK: [[COPY_ARG:%.*]] = copy_value [[ARG]] : $T
+// CHECK: [[OPTIONAL_ARG:%.*]] = enum $Optional<T>, #Optional.some!enumelt.1, [[COPY_ARG]] : $T
+// CHECK-NOT: destroy_value [[ARG]] : $T
+// CHECK: return [[OPTIONAL_ARG]] : $Optional<T>
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s130_____________wrapyxSgxlF'
+func s130_____________wrap<T>(_ x: T) -> T? {
+ return x
+}
+
+// Tests For-each statements
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s140______forEachStmtyyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK: [[PROJ_BOX_ARG:%.*]] = project_box %{{.*}} : ${ var IndexingIterator<Range<Int>> }
+// CHECK: [[APPLY_ARG1:%.*]] = apply
+// CHECK-NOT: alloc_stack $Int
+// CHECK-NOT: store [[APPLY_ARG1]] to [trivial]
+// CHECK-NOT: alloc_stack $Range<Int>
+// CHECK-NOT: dealloc_stack
+// CHECK: [[APPLY_ARG2:%.*]] = apply %{{.*}}<Range<Int>>
+// CHECK: store [[APPLY_ARG2]] to [trivial] [[PROJ_BOX_ARG]]
+// CHECK: br bb1
+// CHECK: bb1:
+// CHECK-NOT: alloc_stack $Optional<Int>
+// CHECK: [[APPLY_ARG3:%.*]] = apply %{{.*}}<Range<Int>>
+// CHECK-NOT: dealloc_stack
+// CHECK: switch_enum [[APPLY_ARG3]]
+// CHECK: bb2:
+// CHECK: br bb3
+// CHECK: bb3:
+// CHECK: return %{{.*}} : $()
+// CHECK: bb4([[ENUM_ARG:%.*]] : $Int):
+// CHECK-NOT: unchecked_enum_data
+// CHECK: br bb1
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s140______forEachStmtyyF'
+func s140______forEachStmt() {
+ for _ in 1..<42 {
+ }
+}
+
+func s150___________anyArg(_: Any) {}
+
+// Tests init of opaque existentials
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s160_______callAnyArgyyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK: [[INT_TYPE:%.*]] = metatype $@thin Int.Type
+// CHECK: [[INT_LIT:%.*]] = integer_literal $Builtin.Int2048, 42
+// CHECK: [[INT_ARG:%.*]] = apply %{{.*}}([[INT_LIT]], [[INT_TYPE]]) : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int
+// CHECK: [[INIT_OPAQUE:%.*]] = init_existential_value [[INT_ARG]] : $Int, $Int, $Any
+// CHECK: apply %{{.*}}([[INIT_OPAQUE]]) : $@convention(thin) (@in_guaranteed Any) -> ()
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s160_______callAnyArgyyF'
+func s160_______callAnyArg() {
+ s150___________anyArg(42)
+}
+
+// Tests unconditional_checked_cast for opaque values
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s170____force_convertxylF : $@convention(thin) <T> () -> @out T {
+// CHECK: bb0:
+// CHECK-NOT: alloc_stack
+// CHECK: [[INT_TYPE:%.*]] = metatype $@thin Int.Type
+// CHECK: [[INT_LIT:%.*]] = integer_literal $Builtin.Int2048, 42
+// CHECK: [[INT_ARG:%.*]] = apply %{{.*}}([[INT_LIT]], [[INT_TYPE]]) : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int
+// CHECK: [[INT_CAST:%.*]] = unconditional_checked_cast_value [[INT_ARG]] : $Int to $T
+// CHECK: [[CAST_BORROW:%.*]] = begin_borrow [[INT_CAST]] : $T
+// CHECK: [[RETURN_VAL:%.*]] = copy_value [[CAST_BORROW]] : $T
+// CHECK: end_borrow [[CAST_BORROW]] from [[INT_CAST]] : $T, $T
+// CHECK: destroy_value [[INT_CAST]] : $T
+// CHECK: return [[RETURN_VAL]] : $T
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s170____force_convertxylF'
+func s170____force_convert<T>() -> T {
+ let x : T = 42 as! T
+ return x
+}
+
+// Tests supporting function for s190___return_foo_var - cast and return of protocol
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s180_______return_fooAA3Foo_pyF : $@convention(thin) () -> @out Foo {
+// CHECK: bb0:
+// CHECK: [[INT_LIT:%.*]] = integer_literal $Builtin.Int2048, 42
+// CHECK: [[INT_ARG:%.*]] = apply %{{.*}}([[INT_LIT]], [[INT_TYPE]]) : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int
+// CHECK: [[INT_CAST:%.*]] = unconditional_checked_cast_value [[INT_ARG]] : $Int to $Foo
+// CHECK: return [[INT_CAST]] : $Foo
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s180_______return_fooAA3Foo_pyF'
+func s180_______return_foo() -> Foo {
+ return 42 as! Foo
+}
+var foo_var : Foo = s180_______return_foo()
+
+// Tests return of global variables by doing a load of copy
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s190___return_foo_varAA3Foo_pyF : $@convention(thin) () -> @out Foo {
+// CHECK: bb0:
+// CHECK: [[GLOBAL:%.*]] = global_addr {{.*}} : $*Foo
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[GLOBAL]] : $*Foo
+// CHECK: [[LOAD_GLOBAL:%.*]] = load [copy] [[READ]] : $*Foo
+// CHECK: return [[LOAD_GLOBAL]] : $Foo
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s190___return_foo_varAA3Foo_pyF'
+func s190___return_foo_var() -> Foo {
+ return foo_var
+}
+
+// Tests deinit of opaque existentials
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s200______use_foo_varyyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK: [[GLOBAL:%.*]] = global_addr {{.*}} : $*Foo
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[GLOBAL]] : $*Foo
+// CHECK: [[LOAD_GLOBAL:%.*]] = load [copy] [[READ]] : $*Foo
+// CHECK: [[BORROW:%.*]] = begin_borrow [[LOAD_GLOBAL]] : $Foo
+// CHECK: [[OPEN_VAR:%.*]] = open_existential_value [[BORROW]] : $Foo
+// CHECK: [[WITNESS:%.*]] = witness_method $@opened
+// CHECK: apply [[WITNESS]]
+// CHECK: end_borrow [[BORROW]]
+// CHECK: destroy_value [[LOAD_GLOBAL]]
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s200______use_foo_varyyF'
+func s200______use_foo_var() {
+ foo_var.foo()
+}
+
+// Tests composition erasure of opaque existentials + copy into of opaques
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s210______compErasureys5Error_psAC_AA3FoopF : $@convention(thin) (@in_guaranteed Error & Foo) -> @owned Error {
+// CHECK: bb0([[ARG:%.*]] : $Error & Foo):
+// CHECK: [[OPAQUE_ARG:%.*]] = open_existential_value [[ARG]] : $Error & Foo to $@opened({{.*}}) Error & Foo
+// CHECK: [[EXIST_BOX:%.*]] = alloc_existential_box $Error, $@opened({{.*}}) Error & Foo
+// CHECK: [[PROJ_BOX:%.*]] = project_existential_box $@opened({{.*}}) Error & Foo in [[EXIST_BOX]]
+// CHECK: [[COPY_OPAQUE:%.*]] = copy_value [[OPAQUE_ARG]] : $@opened({{.*}}) Error & Foo
+// CHECK: store [[COPY_OPAQUE]] to [init] [[PROJ_BOX]] : $*@opened({{.*}}) Error & Foo
+// CHECK-NOT: destroy_value [[ARG]] : $Error & Foo
+// CHECK: return [[EXIST_BOX]] : $Error
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s210______compErasureys5Error_psAC_AA3FoopF'
+func s210______compErasure(_ x: Foo & Error) -> Error {
+ return x
+}
+
+// Tests that existential boxes can contain opaque types
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s220_____openExistBoxySSs5Error_pF : $@convention(thin) (@guaranteed Error) -> @owned String {
+// CHECK: bb0([[ARG:%.*]] : $Error):
+// CHECK: [[OPAQUE_ARG:%.*]] = open_existential_box_value [[ARG]] : $Error to $@opened({{.*}}) Error
+// CHECK: [[ALLOC_OPEN:%.*]] = alloc_stack $@opened({{.*}}) Error
+// CHECK: store_borrow [[OPAQUE_ARG]] to [[ALLOC_OPEN]]
+// CHECK: dealloc_stack [[ALLOC_OPEN]]
+// CHECK-NOT: destroy_value [[ARG]] : $Error
+// CHECK: return {{.*}} : $String
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s220_____openExistBoxySSs5Error_pF'
+func s220_____openExistBox(_ x: Error) -> String {
+ return x._domain
+}
+
+// Tests conditional value casts and correspondingly generated reabstraction thunk
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s230______condFromAnyyyypF : $@convention(thin) (@in_guaranteed Any) -> () {
+// CHECK: bb0([[ARG:%.*]] : $Any):
+// CHECK: [[COPY__ARG:%.*]] = copy_value [[ARG]]
+// CHECK: checked_cast_value_br [[COPY__ARG]] : $Any to $@callee_guaranteed (@in_guaranteed (Int, (Int, (Int, Int)), Int)) -> @out (Int, (Int, (Int, Int)), Int), bb2, bb1
+// CHECK: bb2([[THUNK_PARAM:%.*]] : $@callee_guaranteed (@in_guaranteed (Int, (Int, (Int, Int)), Int)) -> @out (Int, (Int, (Int, Int)), Int)):
+// CHECK: [[THUNK_REF:%.*]] = function_ref @{{.*}} : $@convention(thin) (Int, Int, Int, Int, Int, @guaranteed @callee_guaranteed (@in_guaranteed (Int, (Int, (Int, Int)), Int)) -> @out (Int, (Int, (Int, Int)), Int)) -> (Int, Int, Int, Int, Int)
+// CHECK: partial_apply [callee_guaranteed] [[THUNK_REF]]([[THUNK_PARAM]])
+// CHECK: bb6:
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s230______condFromAnyyyypF'
+func s230______condFromAny(_ x: Any) {
+ if let f = x as? (Int, (Int, (Int, Int)), Int) -> (Int, (Int, (Int, Int)), Int) {
+ _ = f(24, (4,(2, 42)), 42)
+ }
+}
+
+// Tests LValue of error types / existential boxes
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s240_____propOfLValueySSs5Error_pF : $@convention(thin) (@guaranteed Error) -> @owned String {
+// CHECK: bb0([[ARG:%.*]] : $Error):
+// CHECK: [[ALLOC_OF_BOX:%.*]] = alloc_box ${ var Error }
+// CHECK: [[PROJ_BOX:%.*]] = project_box [[ALLOC_OF_BOX]]
+// CHECK: [[COPY_ARG:%.*]] = copy_value [[ARG]]
+// CHECK: store [[COPY_ARG]] to [init] [[PROJ_BOX]]
+// CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PROJ_BOX]] : $*Error
+// CHECK: [[LOAD_BOX:%.*]] = load [copy] [[READ]]
+// CHECK: [[OPAQUE_ARG:%.*]] = open_existential_box [[LOAD_BOX]] : $Error to $*@opened({{.*}}) Error
+// CHECK: [[LOAD_OPAQUE:%.*]] = load [copy] [[OPAQUE_ARG]]
+// CHECK: [[ALLOC_OPEN:%.*]] = alloc_stack $@opened({{.*}}) Error
+// CHECK: store [[LOAD_OPAQUE]] to [init] [[ALLOC_OPEN]]
+// CHECK: [[RET_VAL:%.*]] = apply {{.*}}<@opened({{.*}}) Error>([[ALLOC_OPEN]])
+// CHECK: return [[RET_VAL]] : $String
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s240_____propOfLValueySSs5Error_pF'
+func s240_____propOfLValue(_ x: Error) -> String {
+ var x = x
+ return x._domain
+}
+
+// Tests Implicit Value Construction under Opaque value mode
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s250_________testBoxTyyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK: [[BOX_MTYPE:%.*]] = metatype $@thin Box<Int>.Type
+// CHECK: [[MTYPE:%.*]] = metatype $@thin Int.Type
+// CHECK: [[INTLIT:%.*]] = integer_literal $Builtin.Int2048, 42
+// CHECK: [[AINT:%.*]] = apply {{.*}}([[INTLIT]], [[MTYPE]]) : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int
+// CHECK: apply {{.*}}<Int>([[AINT]], [[BOX_MTYPE]]) : $@convention(method) <τ_0_0> (@in τ_0_0, @thin Box<τ_0_0>.Type) -> @out Box<τ_0_0>
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s250_________testBoxTyyF'
+func s250_________testBoxT() {
+ let _ = Box(t: 42)
+}
+
+// Tests Address only enums
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s260_______AOnly_enumyyAA17AddressOnlyStructVF : $@convention(thin) (AddressOnlyStruct) -> () {
+// CHECK: bb0([[ARG:%.*]] : $AddressOnlyStruct):
+// CHECK: [[MTYPE1:%.*]] = metatype $@thin AddressOnlyEnum.Type
+// CHECK: [[APPLY1:%.*]] = apply {{.*}}([[MTYPE1]]) : $@convention(thin) (@thin AddressOnlyEnum.Type) -> @owned @callee_guaranteed (@in_guaranteed EmptyP) -> @out AddressOnlyEnum
+// CHECK: destroy_value [[APPLY1]]
+// CHECK: [[MTYPE2:%.*]] = metatype $@thin AddressOnlyEnum.Type
+// CHECK: [[ENUM1:%.*]] = enum $AddressOnlyEnum, #AddressOnlyEnum.nought!enumelt
+// CHECK: [[MTYPE3:%.*]] = metatype $@thin AddressOnlyEnum.Type
+// CHECK: [[INIT_OPAQUE:%.*]] = init_existential_value [[ARG]] : $AddressOnlyStruct, $AddressOnlyStruct, $EmptyP
+// CHECK: [[ENUM2:%.*]] = enum $AddressOnlyEnum, #AddressOnlyEnum.mere!enumelt.1, [[INIT_OPAQUE]] : $EmptyP
+// CHECK: destroy_value [[ENUM2]]
+// CHECK: [[MTYPE4:%.*]] = metatype $@thin AddressOnlyEnum.Type
+// CHECK: [[ENUM3:%.*]] = enum $AddressOnlyEnum, #AddressOnlyEnum.phantom!enumelt.1, [[ARG]] : $AddressOnlyStruct
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s260_______AOnly_enumyyAA17AddressOnlyStructVF'
+func s260_______AOnly_enum(_ s: AddressOnlyStruct) {
+ _ = AddressOnlyEnum.mere
+
+ _ = AddressOnlyEnum.nought
+
+ _ = AddressOnlyEnum.mere(s)
+
+ _ = AddressOnlyEnum.phantom(s)
+}
+
+// Tests InjectOptional for opaque value types + conversion of opaque structs
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s270_convOptAnyStructyyAA0gH0VADSgcF : $@convention(thin) (@guaranteed @callee_guaranteed (@in_guaranteed Optional<AnyStruct>) -> @out AnyStruct) -> () {
+// CHECK: bb0([[ARG:%.*]] : $@callee_guaranteed (@in_guaranteed Optional<AnyStruct>) -> @out AnyStruct):
+// CHECK: [[COPY_ARG:%.*]] = copy_value [[ARG]]
+// CHECK: [[PAPPLY:%.*]] = partial_apply [callee_guaranteed] %{{.*}}([[COPY_ARG]]) : $@convention(thin) (@in_guaranteed Optional<AnyStruct>, @guaranteed @callee_guaranteed (@in_guaranteed Optional<AnyStruct>) -> @out AnyStruct) -> @out Optional<AnyStruct>
+// CHECK: destroy_value [[PAPPLY]] : $@callee_guaranteed (@in_guaranteed Optional<AnyStruct>) -> @out Optional<AnyStruct>
+// CHECK-NOT: destroy_value [[ARG]] : $@callee_guaranteed (@in_guaranteed Optional<AnyStruct>) -> @out AnyStruct
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s270_convOptAnyStructyyAA0gH0VADSgcF'
+func s270_convOptAnyStruct(_ a1: @escaping (AnyStruct?) -> AnyStruct) {
+ let _: (AnyStruct?) -> AnyStruct? = a1
+}
+
+// Tests conversion between existential types
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s280_convExistTrivialyyAA0G6StructVAA1P_pcF : $@convention(thin) (@guaranteed @callee_guaranteed (@in_guaranteed P) -> TrivialStruct) -> () {
+// CHECK: bb0([[ARG:%.*]] : $@callee_guaranteed (@in_guaranteed P) -> TrivialStruct):
+// CHECK: [[COPY_ARG:%.*]] = copy_value [[ARG]]
+// CHECK: [[PAPPLY:%.*]] = partial_apply [callee_guaranteed] %{{.*}}([[COPY_ARG]]) : $@convention(thin) (@in_guaranteed P2, @guaranteed @callee_guaranteed (@in_guaranteed P) -> TrivialStruct) -> @out P2
+// CHECK: destroy_value [[PAPPLY]] : $@callee_guaranteed (@in_guaranteed P2) -> @out P2
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s280_convExistTrivialyyAA0G6StructVAA1P_pcF'
+func s280_convExistTrivial(_ s: @escaping (P) -> TrivialStruct) {
+ let _: (P2) -> P2 = s
+}
+
+// Tests conversion between existential types - optionals case
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s290_convOptExistTrivyyAA13TrivialStructVAA1P_pSgcF : $@convention(thin) (@guaranteed @callee_guaranteed (@in_guaranteed Optional<P>) -> TrivialStruct) -> () {
+// CHECK: bb0([[ARG:%.*]] : $@callee_guaranteed (@in_guaranteed Optional<P>) -> TrivialStruct):
+// CHECK: [[COPY_ARG:%.*]] = copy_value [[ARG]]
+// CHECK: [[PAPPLY:%.*]] = partial_apply [callee_guaranteed] %{{.*}}([[COPY_ARG]]) : $@convention(thin) (Optional<TrivialStruct>, @guaranteed @callee_guaranteed (@in_guaranteed Optional<P>) -> TrivialStruct) -> @out P2
+// CHECK: destroy_value [[PAPPLY]] : $@callee_guaranteed (Optional<TrivialStruct>) -> @out P2
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s290_convOptExistTrivyyAA13TrivialStructVAA1P_pSgcF'
+func s290_convOptExistTriv(_ s: @escaping (P?) -> TrivialStruct) {
+ let _: (TrivialStruct?) -> P2 = s
+}
+
+// Tests corner-case: reabstraction of an empty tuple to any
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s300__convETupleToAnyyyyycF : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> () {
+// CHECK: bb0([[ARG:%.*]] : $@callee_guaranteed () -> ()):
+// CHECK: [[COPY_ARG:%.*]] = copy_value [[ARG]]
+// CHECK: [[PAPPLY:%.*]] = partial_apply [callee_guaranteed] %{{.*}}([[COPY_ARG]]) : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> @out Any
+// CHECK: destroy_value [[PAPPLY]] : $@callee_guaranteed () -> @out Any
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s300__convETupleToAnyyyyycF'
+func s300__convETupleToAny(_ t: @escaping () -> ()) {
+ let _: () -> Any = t
+}
+
+// Tests corner-case: reabstraction of a non-empty tuple to any
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s310__convIntTupleAnyyySi_SitycF : $@convention(thin) (@guaranteed @callee_guaranteed () -> (Int, Int)) -> () {
+// CHECK: bb0([[ARG:%.*]] : $@callee_guaranteed () -> (Int, Int)):
+// CHECK: [[COPY_ARG:%.*]] = copy_value [[ARG]]
+// CHECK: [[PAPPLY:%.*]] = partial_apply [callee_guaranteed] %{{.*}}([[COPY_ARG]]) : $@convention(thin) (@guaranteed @callee_guaranteed () -> (Int, Int)) -> @out Any
+// CHECK: destroy_value [[PAPPLY]] : $@callee_guaranteed () -> @out Any
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s310__convIntTupleAnyyySi_SitycF'
+func s310__convIntTupleAny(_ t: @escaping () -> (Int, Int)) {
+ let _: () -> Any = t
+}
+
+// Tests translating and imploding into Any under opaque value mode
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s320__transImplodeAnyyyyypcF : $@convention(thin) (@guaranteed @callee_guaranteed (@in_guaranteed Any) -> ()) -> () {
+// CHECK: bb0([[ARG:%.*]] : $@callee_guaranteed (@in_guaranteed Any) -> ()):
+// CHECK: [[COPY_ARG:%.*]] = copy_value [[ARG]]
+// CHECK: [[PAPPLY:%.*]] = partial_apply [callee_guaranteed] %{{.*}}([[COPY_ARG]]) : $@convention(thin) (Int, Int, @guaranteed @callee_guaranteed (@in_guaranteed Any) -> ()) -> ()
+// CHECK: destroy_value [[PAPPLY]] : $@callee_guaranteed (Int, Int) -> ()
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s320__transImplodeAnyyyyypcF'
+func s320__transImplodeAny(_ t: @escaping (Any) -> ()) {
+ let _: ((Int, Int)) -> () = t
+}
+
+// Tests support for address only let closures under opaque value mode - they are not by-address anymore
+// ---
+// CHECK-LABEL: sil private @$S20opaque_values_silgen21s330___addrLetClosureyxxlFxyXEfU_xyXEfU_ : $@convention(thin) <T> (@in_guaranteed T) -> @out T {
+// CHECK: bb0([[ARG:%.*]] : $T):
+// CHECK: [[COPY_ARG:%.*]] = copy_value [[ARG]] : $T
+// CHECK: return [[COPY_ARG]] : $T
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s330___addrLetClosureyxxlFxyXEfU_xyXEfU_'
+func s330___addrLetClosure<T>(_ x:T) -> T {
+ return { { x }() }()
+}
+
+// Tests support for capture of a mutable opaque value type
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s340_______captureBoxyyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK: [[ALLOC_OF_BOX:%.*]] = alloc_box ${ var EmptyP }, var, name "mutableAddressOnly"
+// CHECK: [[PROJ_BOX:%.*]] = project_box [[ALLOC_OF_BOX]]
+// CHECK: [[APPLY_FOR_BOX:%.*]] = apply %{{.*}}(%{{.*}}) : $@convention(method) (@thin AddressOnlyStruct.Type) -> AddressOnlyStruct
+// CHECK: [[INIT_OPAQUE:%.*]] = init_existential_value [[APPLY_FOR_BOX]] : $AddressOnlyStruct, $AddressOnlyStruct, $EmptyP
+// CHECK: store [[INIT_OPAQUE]] to [init] [[PROJ_BOX]] : $*EmptyP
+// CHECK: [[BORROW_BOX:%.*]] = begin_borrow [[ALLOC_OF_BOX]] : ${ var EmptyP }
+// CHECK: mark_function_escape [[PROJ_BOX]] : $*EmptyP
+// CHECK: apply %{{.*}}([[BORROW_BOX]]) : $@convention(thin) (@guaranteed { var EmptyP }) -> ()
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s340_______captureBoxyyF'
+func s340_______captureBox() {
+ var mutableAddressOnly: EmptyP = AddressOnlyStruct()
+
+ func captureEverything() {
+ _ = s100_________identity((mutableAddressOnly))
+ }
+
+ captureEverything()
+}
+
+// Tests support for if statements for opaque value(s) under new mode
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s350_______addrOnlyIf1xAA6EmptyP_pSb_tF : $@convention(thin) (Bool) -> @out EmptyP {
+// CHECK: bb0([[ARG:%.*]] : $Bool):
+// CHECK: [[ALLOC_OF_BOX:%.*]] = alloc_box ${ var EmptyP }, var
+// CHECK: [[PROJ_BOX:%.*]] = project_box [[ALLOC_OF_BOX]]
+// CHECK: [[APPLY_FOR_BOX:%.*]] = apply %{{.*}}(%{{.*}}) : $@convention(method) (@thin AddressOnlyStruct.Type) -> AddressOnlyStruct
+// CHECK: [[INIT_OPAQUE:%.*]] = init_existential_value [[APPLY_FOR_BOX]] : $AddressOnlyStruct, $AddressOnlyStruct, $EmptyP
+// CHECK: store [[INIT_OPAQUE]] to [init] [[PROJ_BOX]] : $*EmptyP
+// CHECK: [[APPLY_FOR_BRANCH:%.*]] = apply %{{.*}}([[ARG]]) : $@convention(method) (Bool) -> Builtin.Int1
+// CHECK: cond_br [[APPLY_FOR_BRANCH]], bb2, bb1
+// CHECK: bb1:
+// CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PROJ_BOX]] : $*EmptyP
+// CHECK: [[RETVAL1:%.*]] = load [copy] [[READ]] : $*EmptyP
+// CHECK: br bb3([[RETVAL1]] : $EmptyP)
+// CHECK: bb2:
+// CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PROJ_BOX]] : $*EmptyP
+// CHECK: [[RETVAL2:%.*]] = load [copy] [[READ]] : $*EmptyP
+// CHECK: br bb3([[RETVAL2]] : $EmptyP)
+// CHECK: bb3([[RETVAL:%.*]] : $EmptyP):
+// CHECK: destroy_value [[ALLOC_OF_BOX]]
+// CHECK: return [[RETVAL]] : $EmptyP
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s350_______addrOnlyIf1xAA6EmptyP_pSb_tF'
+func s350_______addrOnlyIf(x: Bool) -> EmptyP {
+ var a : EmptyP = AddressOnlyStruct()
+
+ return x ? a : a
+}
+
+// Tests support for guards and indirect enums for opaque values
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s360________guardEnumyyAA08IndirectF0OyxGlF : $@convention(thin) <T> (@guaranteed IndirectEnum<T>) -> () {
+// CHECK: bb0([[ARG:%.*]] : $IndirectEnum<T>):
+// CHECK: [[COPY__ARG:%.*]] = copy_value [[ARG]]
+// CHECK: switch_enum [[COPY__ARG]] : $IndirectEnum<T>, case #IndirectEnum.Node!enumelt.1: [[NODE_BB:bb[0-9]+]], case #IndirectEnum.Nil!enumelt: [[NIL_BB:bb[0-9]+]]
+//
+// CHECK: [[NIL_BB]]:
+// CHECK: br [[NIL_TRAMPOLINE:bb[0-9]+]]
+//
+// CHECK: [[NIL_TRAMPOLINE]]:
+// CHECK: br [[EPILOG_BB:bb[0-9]+]]
+//
+// CHECK: [[NODE_BB]]([[EARG:%.*]] : $<τ_0_0> { var τ_0_0 } <T>):
+// CHECK: [[PROJ_BOX:%.*]] = project_box [[EARG]]
+// CHECK: [[LOAD_BOX:%.*]] = load [take] [[PROJ_BOX]] : $*T
+// CHECK: [[COPY_BOX:%.*]] = copy_value [[LOAD_BOX]] : $T
+// CHECK: destroy_value [[EARG]]
+// CHECK: br [[CONT_BB:bb[0-9]+]]
+//
+// CHECK: [[CONT_BB]]:
+// CHECK: destroy_value [[COPY_BOX]]
+// CHECK: br [[EPILOG_BB]]
+//
+// CHECK: [[EPILOG_BB]]:
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s360________guardEnumyyAA08IndirectF0OyxGlF'
+func s360________guardEnum<T>(_ e: IndirectEnum<T>) {
+ do {
+ guard case .Node(let x) = e else { return }
+ _ = x
+ }
+}
+
+// Tests contextual init() of opaque value types
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s370_____optToOptCastyxSgAClF : $@convention(thin) <T> (@in_guaranteed Optional<T>) -> @out Optional<T> {
+// CHECK: bb0([[ARG:%.*]] : $Optional<T>):
+// CHECK: [[COPY__ARG:%.*]] = copy_value [[ARG]]
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return [[COPY__ARG]] : $Optional<T>
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s370_____optToOptCastyxSgAClF'
+func s370_____optToOptCast<T>(_ x : T!) -> T? {
+ return x
+}
+
+// Tests casting optional opaques to optional opaques
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s380___contextualInityySiSgF : $@convention(thin) (Optional<Int>) -> () {
+// CHECK: bb0([[ARG:%.*]] : $Optional<Int>):
+// CHECK: [[ALLOC_OF_BOX:%.*]] = alloc_box ${ var Optional<Int> }, var
+// CHECK: [[PROJ_BOX:%.*]] = project_box [[ALLOC_OF_BOX]]
+// CHECK: store [[ARG]] to [trivial] [[PROJ_BOX]] : $*Optional<Int>
+// CHECK: destroy_value [[ALLOC_OF_BOX]]
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s380___contextualInityySiSgF'
+func s380___contextualInit(_ a : Int?) {
+ var x: Int! = a
+ _ = x
+}
+
+// Tests opaque call result types
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s390___addrCallResultyyxycSglF : $@convention(thin) <T> (@guaranteed Optional<@callee_guaranteed () -> @out T>) -> () {
+// CHECK: bb0([[ARG:%.*]] : $Optional<@callee_guaranteed () -> @out T>):
+// CHECK: [[ALLOC_OF_BOX:%.*]] = alloc_box $<τ_0_0> { var Optional<τ_0_0> } <T>
+// CHECK: [[PROJ_BOX:%.*]] = project_box [[ALLOC_OF_BOX]]
+// CHECK: [[COPY__ARG:%.*]] = copy_value [[ARG]]
+// CHECK: [[SENUM:%.*]] = select_enum [[COPY__ARG]]
+// CHECK: cond_br [[SENUM]], bb3, bb1
+// CHECK: bb1:
+// CHECK: br bb2
+// CHECK: bb2:
+// CHECK: [[ONONE:%.*]] = enum $Optional<T>, #Optional.none!enumelt
+// CHECK: br bb4([[ONONE]] : $Optional<T>)
+// CHECK: bb4(%{{.*}} : $Optional<T>):
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s390___addrCallResultyyxycSglF'
+func s390___addrCallResult<T>(_ f: (() -> T)?) {
+ var x = f?()
+ _ = x
+}
+
+// Tests reabstraction / partial apply of protocols under opaque value mode
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s400______maybeCloneP1cyAA8Clonable_p_tF : $@convention(thin) (@in_guaranteed Clonable) -> () {
+// CHECK: bb0([[ARG:%.*]] : $Clonable):
+// CHECK: [[OPEN_ARG:%.*]] = open_existential_value [[ARG]] : $Clonable
+// CHECK: [[APPLY_OPAQUE:%.*]] = apply %{{.*}}<@opened({{.*}}) Clonable>([[OPEN_ARG]]) : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@in_guaranteed τ_0_0) -> @owned @callee_guaranteed () -> @out Optional<τ_0_0>
+// CHECK: [[PAPPLY:%.*]] = partial_apply [callee_guaranteed] %{{.*}}<@opened({{.*}}) Clonable>([[APPLY_OPAQUE]]) : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @out Optional<τ_0_0>) -> @out Optional<Clonable>
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s400______maybeCloneP1cyAA8Clonable_p_tF'
+func s400______maybeCloneP(c: Clonable) {
+ let _: () -> Clonable? = c.maybeClone
+}
+
+// Tests global opaque values / subscript rvalues
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s410__globalRvalueGetyS2iF : $@convention(thin) (Int) -> Int {
+// CHECK: bb0([[ARG:%.*]] : $Int):
+// CHECK: [[GLOBAL_ADDR:%.*]] = global_addr @$S20opaque_values_silgen16subscriptableGetAA013SubscriptableE0_pvp : $*SubscriptableGet
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[GLOBAL_ADDR]] : $*SubscriptableGet
+// CHECK: [[OPEN_ARG:%.*]] = open_existential_addr immutable_access [[READ]] : $*SubscriptableGet to $*@opened
+// CHECK: [[GET_OPAQUE:%.*]] = load [copy] [[OPEN_ARG]] : $*@opened
+// CHECK: [[RETVAL:%.*]] = apply %{{.*}}<@opened({{.*}}) SubscriptableGet>([[ARG]], [[GET_OPAQUE]]) : $@convention(witness_method: SubscriptableGet) <τ_0_0 where τ_0_0 : SubscriptableGet> (Int, @in_guaranteed τ_0_0) -> Int
+// CHECK: destroy_value [[GET_OPAQUE]]
+// CHECK: return [[RETVAL]] : $Int
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s410__globalRvalueGetyS2iF'
+func s410__globalRvalueGet(_ i : Int) -> Int {
+ return subscriptableGet[i]
+}
+
+// Tests global opaque values / subscript lvalues
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s420__globalLvalueGetyS2iF : $@convention(thin) (Int) -> Int {
+// CHECK: bb0([[ARG:%.*]] : $Int):
+// CHECK: [[GLOBAL_ADDR:%.*]] = global_addr @$S20opaque_values_silgen19subscriptableGetSetAA013SubscriptableeF0_pvp : $*SubscriptableGetSet
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[GLOBAL_ADDR]] : $*SubscriptableGetSet
+// CHECK: [[OPEN_ARG:%.*]] = open_existential_addr immutable_access [[READ]] : $*SubscriptableGetSet to $*@opened
+// CHECK: [[GET_OPAQUE:%.*]] = load [copy] [[OPEN_ARG]] : $*@opened
+// CHECK: [[RETVAL:%.*]] = apply %{{.*}}<@opened({{.*}}) SubscriptableGetSet>([[ARG]], [[GET_OPAQUE]]) : $@convention(witness_method: SubscriptableGetSet) <τ_0_0 where τ_0_0 : SubscriptableGetSet> (Int, @in_guaranteed τ_0_0) -> Int
+// CHECK: destroy_value [[GET_OPAQUE]]
+// CHECK: return [[RETVAL]] : $Int
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s420__globalLvalueGetyS2iF'
+func s420__globalLvalueGet(_ i : Int) -> Int {
+ return subscriptableGetSet[i]
+}
+
+// Tests tuple transformation
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s430_callUnreachableF1tyx_tlF : $@convention(thin) <T> (@in_guaranteed T) -> () {
+// CHECK: bb0([[ARG:%.*]] : $T):
+// CHECK: [[APPLY_T:%.*]] = apply %{{.*}}<((T) -> (), T)>() : $@convention(thin) <τ_0_0> () -> @out Optional<(Int, τ_0_0)>
+// CHECK: switch_enum [[APPLY_T]] : $Optional<(Int, (@callee_guaranteed (@in_guaranteed T) -> @out (), T))>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb1
+// CHECK: bb2([[ENUMARG:%.*]] : $(Int, (@callee_guaranteed (@in_guaranteed T) -> @out (), T))):
+// CHECK: ([[TELEM0:%.*]], [[TELEM1:%.*]]) = destructure_tuple [[ENUMARG]] : $(Int, (@callee_guaranteed (@in_guaranteed T) -> @out (), T))
+// CHECK: ([[TELEM10:%.*]], [[TELEM11:%.*]]) = destructure_tuple [[TELEM1]] : $(@callee_guaranteed (@in_guaranteed T) -> @out (), T)
+// CHECK: [[PAPPLY:%.*]] = partial_apply [callee_guaranteed] %{{.*}}<T>([[TELEM10]]) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0, @guaranteed @callee_guaranteed (@in_guaranteed τ_0_0) -> @out ()) -> ()
+// CHECK: [[NEWT0:%.*]] = tuple ([[PAPPLY]] : $@callee_guaranteed (@in_guaranteed T) -> (), [[TELEM11]] : $T)
+// CHECK: [[NEWT1:%.*]] = tuple ([[TELEM0]] : $Int, [[NEWT0]] : $(@callee_guaranteed (@in_guaranteed T) -> (), T))
+// CHECK: [[NEWENUM:%.*]] = enum $Optional<(Int, (@callee_guaranteed (@in_guaranteed T) -> (), T))>, #Optional.some!enumelt.1, [[NEWT1]] : $(Int, (@callee_guaranteed (@in_guaranteed T) -> (), T))
+// CHECK: br bb3([[NEWENUM]] : $Optional<(Int, (@callee_guaranteed (@in_guaranteed T) -> (), T))>)
+// CHECK: bb3([[ENUMIN:%.*]] : $Optional<(Int, (@callee_guaranteed (@in_guaranteed T) -> (), T))>):
+// CHECK: destroy_value [[ENUMIN]]
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s430_callUnreachableF1tyx_tlF'
+func s430_callUnreachableF<T>(t: T) {
+ let _: (Int, ((T) -> (), T))? = unreachableF()
+}
+
+// Further testing for conditional checked cast under opaque value mode - make sure we don't create a buffer for results
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s440__cleanupEmissionyyxlF : $@convention(thin) <T> (@in_guaranteed T) -> () {
+// CHECK: bb0([[ARG:%.*]] : $T):
+// CHECK: [[COPY_ARG:%.*]] = copy_value [[ARG]]
+// CHECK: checked_cast_value_br [[COPY_ARG]] : $T to $EmptyP, bb2, bb1
+//
+// CHECK: bb2([[PTYPE:%.*]] : $EmptyP):
+// CHECK: [[PSOME:%.*]] = enum $Optional<EmptyP>, #Optional.some!enumelt.1, [[PTYPE]] : $EmptyP
+// CHECK: br bb3([[PSOME]] : $Optional<EmptyP>)
+//
+// CHECK: bb3([[ENUMRES:%.*]] : $Optional<EmptyP>):
+// CHECK: switch_enum [[ENUMRES]] : $Optional<EmptyP>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+//
+// CHECK: [[NONE_BB]]:
+// CHECK: br [[NONE_TRAMPOLINE:bb[0-9]+]]
+//
+// CHECK: [[NONE_TRAMPOLINE]]:
+// CHECK: br [[EPILOG_BB:bb[0-9]+]]
+//
+// CHECK: [[SOME_BB]]([[ENUMRES2:%.*]] : $EmptyP):
+// CHECK: br [[CONT_BB:bb[0-9]+]]
+//
+// CHECK: [[CONT_BB]]:
+// CHECK: destroy_value [[ENUMRES2]]
+// CHECK: br [[EPILOG_BB]]
+//
+// CHECK: [[EPILOG_BB]]:
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s440__cleanupEmissionyyxlF'
+func s440__cleanupEmission<T>(_ x: T) {
+ guard let x2 = x as? EmptyP else { return }
+ _ = x2
+}
+
+// Test SILGenBuilder.loadCopy().
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s450__________lastValyxxd_tlF : $@convention(thin) <T> (@guaranteed Array<T>) -> @out T
+// CHECK: [[LOAD:%.*]] = load [copy] %{{.*}} : $*T
+// CHECK: return [[LOAD]] : $T
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s450__________lastValyxxd_tlF'
+func s450__________lastVal<T>(_ rest: T...) -> T {
+ var minValue: T
+ for value in rest {
+ minValue = value
+ }
+ return minValue
+}
+
+// Test SILGenFunction::emitPointerToPointer.
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s460______________foo1pSRyxGSPyxG_tlF : $@convention(thin) <Element> (UnsafePointer<Element>) -> UnsafeBufferPointer<Element> {
+// CHECK: [[F:%.*]] = function_ref @$Ss017_convertPointerToB8Argumentyq_xs01_B0RzsABR_r0_lF : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : _Pointer, τ_0_1 : _Pointer> (@in_guaranteed τ_0_0) -> @out τ_0_1
+// CHECK: apply [[F]]<UnsafePointer<Element>, UnsafePointer<Element>>(%0) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : _Pointer, τ_0_1 : _Pointer> (@in_guaranteed τ_0_0) -> @out τ_0_1
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s460______________foo1pSRyxGSPyxG_tlF'
+func s460______________foo<Element>(p: UnsafePointer<Element>) -> UnsafeBufferPointer<Element> {
+ return UnsafeBufferPointer(start: p, count: 1)
+}
+
+// Test emitNativeToCBridgedNonoptionalValue.
+// ---
+// CHECK-objc-LABEL: sil hidden @$S20opaque_values_silgen21s470________nativeToC7fromAnyyXlyp_tF : $@convention(thin) (@in_guaranteed Any) -> @owned AnyObject {
+// CHECK-objc bb0(%0 : $Any):
+// CHECK-objc [[BORROW:%.*]] = begin_borrow %0 : $Any
+// CHECK-objc [[SRC:%.*]] = copy_value [[BORROW]] : $Any
+// CHECK-objc [[OPEN:%.*]] = open_existential_opaque [[SRC]] : $Any to $@opened
+// CHECK-objc [[COPY:%.*]] = copy_value [[OPEN]] : $@opened
+// CHECK-objc [[F:%.*]] = function_ref @$Ss27_bridgeAnythingToObjectiveCyyXlxlF : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @owned AnyObject
+// CHECK-objc [[RET:%.*]] = apply [[F]]<@opened("{{.*}}") Any>([[COPY]]) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @owned AnyObject
+// CHECK-objc destroy_value [[SRC]] : $Any
+// CHECK-objc destroy_value %0 : $Any
+// CHECK-objc return [[RET]] : $AnyObject
+// CHECK-objc-LABEL: } // end sil function '$S20opaque_values_silgen21s470________nativeToC7fromAnyyXlyp_tF'
+#if _runtime(_ObjC)
+func s470________nativeToC(fromAny any: Any) -> AnyObject {
+ return any as AnyObject
+}
+#endif
+
+// Test emitOpenExistential.
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s480_________getError04someF0yps0F0_p_tF : $@convention(thin) (@guaranteed Error) -> @out Any {
+// CHECK: bb0([[ARG:%.*]] : $Error):
+// CHECK: [[VAL:%.*]] = open_existential_box_value [[ARG]] : $Error to $@opened("{{.*}}") Error
+// CHECK: [[COPY:%.*]] = copy_value [[VAL]] : $@opened("{{.*}}") Error
+// CHECK: [[ANY:%.*]] = init_existential_value [[COPY]] : $@opened("{{.*}}") Error, $@opened("{{.*}}") Error, $Any
+// CHECK-NOT: destroy_value [[ARG]] : $Error
+// CHECK: return [[ANY]] : $Any
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s480_________getError04someF0yps0F0_p_tF'
+func s480_________getError(someError: Error) -> Any {
+ return someError
+}
+
+// Test SILBuilder.createLoadBorrow.
+// ---
+// CHECK-LABEL: sil private @$S20opaque_values_silgen21s490_______loadBorrowyyF3FooL_V3foo3pos7ElementQzSg5IndexQz_tF : $@convention(method) <Elements where Elements : Collection> (@in_guaranteed Elements.Index, @inout Foo<Elements>) -> @out Optional<Elements.Element> {
+// CHECK: bb0([[ARG0:%.*]] : $Elements.Index, [[ARG1:%.*]] : $*Foo<Elements>):
+// CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[ARG1]] : $*Foo<Elements>
+// CHECK: [[LOAD:%.*]] = load [copy] [[READ]] : $*Foo<Elements>
+// CHECK: end_access [[READ]] : $*Foo<Elements>
+// CHECK: [[BORROW_LOAD:%.*]] = begin_borrow [[LOAD]]
+// CHECK: [[EXTRACT:%.*]] = struct_extract [[BORROW_LOAD]] : $Foo<Elements>, #<abstract function>Foo._elements
+// CHECK: [[COPYELT:%.*]] = copy_value [[EXTRACT]] : $Elements
+// CHECK: [[COPYIDX:%.*]] = copy_value [[ARG0]] : $Elements.Index
+// CHECK: [[WT:%.*]] = witness_method $Elements, #Collection.subscript!getter.1 : <Self where Self : Collection> (Self) -> (Self.Index) -> Self.Element : $@convention(witness_method: Collection) <τ_0_0 where τ_0_0 : Collection> (@in_guaranteed τ_0_0.Index, @in_guaranteed τ_0_0) -> @out τ_0_0.Element
+// CHECK: [[RESULT:%.*]] = apply [[WT]]<Elements>([[COPYIDX]], [[COPYELT]]) : $@convention(witness_method: Collection) <τ_0_0 where τ_0_0 : Collection> (@in_guaranteed τ_0_0.Index, @in_guaranteed τ_0_0) -> @out τ_0_0.Element
+// CHECK: destroy_value [[COPYELT]] : $Elements
+// CHECK: [[ENUM_RESULT:%.*]] = enum $Optional<Elements.Element>, #Optional.some!enumelt.1, [[RESULT]] : $Elements.Element
+// CHECK: destroy_value [[LOAD]]
+// CHECK-NOT: destroy_value [[ARG0]] : $Elements.Index
+// CHECK: return [[ENUM_RESULT]] : $Optional<Elements.Element>
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s490_______loadBorrowyyF3FooL_V3foo3pos7ElementQzSg5IndexQz_tF'
+
+func s490_______loadBorrow() {
+ struct Foo<Elements : Collection> {
+ internal let _elements: Elements
+
+ public mutating func foo(pos: Elements.Index) -> Elements.Element? {
+ return _elements[pos]
+ }
+ }
+ var foo = Foo(_elements: [])
+ _ = foo.foo(pos: 1)
+}
+
+protocol ConvertibleToP {
+ func asP() -> P
+}
+
+// Test visitBindOptionalExpr
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s500_______getAnyHashyAA1P_pSgAA14ConvertibleToP_pSgF : $@convention(thin) (@in_guaranteed Optional<ConvertibleToP>) -> @out Optional<P> {
+// CHECK: bb0(%0 : $Optional<ConvertibleToP>):
+// CHECK: [[COPY:%.*]] = copy_value [[ARG]] : $Optional<ConvertibleToP>
+// CHECK: [[DATA:%.*]] = unchecked_enum_data [[COPY]] : $Optional<ConvertibleToP>, #Optional.some!enumelt.1
+// CHECK: [[BORROW_DATA:%.*]] = begin_borrow [[DATA]] : $ConvertibleToP
+// CHECK: [[VAL:%.*]] = open_existential_value [[BORROW_DATA]] : $ConvertibleToP to $@opened("{{.*}}") ConvertibleToP
+// CHECK: [[WT:%.*]] = witness_method $@opened("{{.*}}") ConvertibleToP, #ConvertibleToP.asP!1 : <Self where Self : ConvertibleToP> (Self) -> () -> P, [[VAL]] : $@opened("{{.*}}") ConvertibleToP : $@convention(witness_method: ConvertibleToP) <τ_0_0 where τ_0_0 : ConvertibleToP> (@in_guaranteed τ_0_0) -> @out P
+// CHECK: [[AS_P:%.*]] = apply [[WT]]<@opened("{{.*}}") ConvertibleToP>([[VAL]]) : $@convention(witness_method: ConvertibleToP) <τ_0_0 where τ_0_0 : ConvertibleToP> (@in_guaranteed τ_0_0) -> @out P
+// CHECK: [[ENUM:%.*]] = enum $Optional<P>, #Optional.some!enumelt.1, [[AS_P]] : $P
+// CHECK: destroy_value [[DATA]] : $ConvertibleToP
+// CHECK: br bb{{.*}}([[ENUM]] : $Optional<P>)
+// CHECK: // end sil function '$S20opaque_values_silgen21s500_______getAnyHashyAA1P_pSgAA14ConvertibleToP_pSgF'
+func s500_______getAnyHash(_ value: ConvertibleToP?) -> P? {
+ return value?.asP()
+}
+
+public protocol FooP {
+ func foo() -> Self
+}
+
+// Test emitting a protocol witness for a method (with @in_guaranteed self) on a dependent generic type.
+// ---
+// CHECK-LABEL: sil private [transparent] [thunk] @$S20opaque_values_silgen21s510_______OpaqueSelfVyxGAA4FooPA2aEP3fooxyFTW : $@convention(witness_method: FooP) <τ_0_0> (@in_guaranteed s510_______OpaqueSelf<τ_0_0>) -> @out s510_______OpaqueSelf<τ_0_0> {
+// CHECK: bb0(%0 : $s510_______OpaqueSelf<τ_0_0>):
+// CHECK: [[FN:%.*]] = function_ref @$S20opaque_values_silgen21s510_______OpaqueSelfV3fooACyxGyF : $@convention(method) <τ_0_0> (@in_guaranteed s510_______OpaqueSelf<τ_0_0>) -> @out s510_______OpaqueSelf<τ_0_0>
+// CHECK: [[RESULT:%.*]] = apply [[FN]]<τ_0_0>(%0) : $@convention(method) <τ_0_0> (@in_guaranteed s510_______OpaqueSelf<τ_0_0>) -> @out s510_______OpaqueSelf<τ_0_0>
+// CHECK: return [[RESULT]] : $s510_______OpaqueSelf<τ_0_0>
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s510_______OpaqueSelfVyxGAA4FooPA2aEP3fooxyFTW'
+struct s510_______OpaqueSelf<Base> : FooP {
+ var x: Base
+
+ func foo() -> s510_______OpaqueSelf<Base> {
+ return self
+ }
+}
+
+// Tests conditional value casts and correspondingly generated reabstraction thunk, with <T> types
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen21s999_____condTFromAnyyyyp_xtlF : $@convention(thin) <T> (@in_guaranteed Any, @in_guaranteed T) -> () {
+// CHECK: bb0([[ARG0:%.*]] : $Any, [[ARG1:%.*]] : $T):
+// CHECK: [[COPY__ARG:%.*]] = copy_value [[ARG]]
+// CHECK: checked_cast_value_br [[COPY__ARG]] : $Any to $@callee_guaranteed (@in_guaranteed (Int, T)) -> @out (Int, T), bb2, bb1
+// CHECK: bb2([[THUNK_PARAM:%.*]] : $@callee_guaranteed (@in_guaranteed (Int, T)) -> @out (Int, T)):
+// CHECK: [[THUNK_REF:%.*]] = function_ref @{{.*}} : $@convention(thin) <τ_0_0> (Int, @in_guaranteed τ_0_0, @guaranteed @callee_guaranteed (@in_guaranteed (Int, τ_0_0)) -> @out (Int, τ_0_0)) -> (Int, @out τ_0_0)
+// CHECK: partial_apply [callee_guaranteed] [[THUNK_REF]]<T>([[THUNK_PARAM]])
+// CHECK: bb6:
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen21s999_____condTFromAnyyyyp_xtlF'
+func s999_____condTFromAny<T>(_ x: Any, _ y: T) {
+ if let f = x as? (Int, T) -> (Int, T) {
+ _ = f(42, y)
+ }
+}
+
+// Make sure that we insert a destroy of the box even though we used an Int type.
+// CHECK-LABEL: sil @$S20opaque_values_silgen22s020_______assignToVaryyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK: [[Y_BOX:%.*]] = alloc_box ${ var Int }, var, name "y"
+// CHECK: [[PROJECT_Y_BOX:%.*]] = project_box [[Y_BOX]] : ${ var Int }, 0
+// CHECK: [[X_BOX:%.*]] = alloc_box ${ var Any }, var, name "x"
+// CHECK: [[PROJECT_X_BOX:%.*]] = project_box [[X_BOX]] : ${ var Any }, 0
+// CHECK: [[ACCESS_PROJECT_Y_BOX:%.*]] = begin_access [read] [unknown] [[PROJECT_Y_BOX]] : $*Int
+// CHECK: [[Y:%.*]] = load [trivial] [[ACCESS_PROJECT_Y_BOX]] : $*Int
+// CHECK: [[Y_ANY_FOR_X:%.*]] = init_existential_value [[Y]] : $Int, $Int, $Any
+// CHECK: store [[Y_ANY_FOR_X]] to [init] [[PROJECT_X_BOX]]
+// CHECK: [[ACCESS_PROJECT_Y_BOX:%.*]] = begin_access [read] [unknown] [[PROJECT_Y_BOX]] : $*Int
+// CHECK: [[Y:%.*]] = load [trivial] [[ACCESS_PROJECT_Y_BOX]] : $*Int
+// CHECK: [[Y_ANY_FOR_Z:%.*]] = init_existential_value [[Y]] : $Int, $Int, $Any
+// CHECK: destroy_value [[Y_ANY_FOR_Z]]
+// CEHCK: destroy_value [[X_BOX]]
+// CHECK: destroy_value [[Y_BOX]]
+// CHECK: } // end sil function '$S20opaque_values_silgen22s020_______assignToVaryyF'
+public func s020_______assignToVar() {
+ var y: Int = 3
+ var x: Any = y
+ let z: Any = y
+}
+
+// s250_________testBoxT continued Test Implicit Value Construction under Opaque value mode
+// ---
+// CHECK-LABEL: sil hidden @$S20opaque_values_silgen3BoxV1tACyxGx_tcfC : $@convention(method) <T> (@in T, @thin Box<T>.Type) -> @out Box<T> {
+// CHECK: bb0([[ARG0:%.*]] : $T, [[ARG1:%.*]] : $@thin Box<T>.Type):
+// CHECK: [[RETVAL:%.*]] = struct $Box<T> ([[ARG0]] : $T)
+// CHECK: return [[RETVAL]] : $Box<T>
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen3BoxV1tACyxGx_tcfC'
+
+// s270_convOptAnyStruct continued Test: reabstraction thunk helper
+// ---
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S20opaque_values_silgen9AnyStructVSgACIegnr_A2DIegnr_TR : $@convention(thin) (@in_guaranteed Optional<AnyStruct>, @guaranteed @callee_guaranteed (@in_guaranteed Optional<AnyStruct>) -> @out AnyStruct) -> @out Optional<AnyStruct> {
+// CHECK: bb0([[ARG0:%.*]] : $Optional<AnyStruct>, [[ARG1:%.*]] : $@callee_guaranteed (@in_guaranteed Optional<AnyStruct>) -> @out AnyStruct):
+// CHECK: [[APPLYARG:%.*]] = apply [[ARG1]]([[ARG0]]) : $@callee_guaranteed (@in_guaranteed Optional<AnyStruct>) -> @out AnyStruct
+// CHECK: [[RETVAL:%.*]] = enum $Optional<AnyStruct>, #Optional.some!enumelt.1, [[APPLYARG]] : $AnyStruct
+// CHECK: return [[RETVAL]] : $Optional<AnyStruct>
+// CHECK-LABEL: } // end sil function '$S20opaque_values_silgen9AnyStructVSgACIegnr_A2DIegnr_TR'
+
+// s300__convETupleToAny continued Test: reabstraction of () to Any
+// ---
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SIeg_ypIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> ()) -> @out Any {
+// CHECK: bb0([[ARG:%.*]] : $@callee_guaranteed () -> ()):
+// CHECK: [[ASTACK:%.*]] = alloc_stack $Any
+// CHECK: [[IADDR:%.*]] = init_existential_addr [[ASTACK]] : $*Any, $()
+// CHECK: [[APPLYARG:%.*]] = apply [[ARG]]() : $@callee_guaranteed () -> ()
+// CHECK: [[LOAD_EXIST:%.*]] = load [trivial] [[IADDR]] : $*()
+// CHECK: [[RETVAL:%.*]] = init_existential_value [[LOAD_EXIST]] : $(), $(), $Any
+// CHECK: return [[RETVAL]] : $Any
+// CHECK-LABEL: } // end sil function '$SIeg_ypIegr_TR'
+
+// s310_convIntTupleAny continued Test: reabstraction of non-empty tuple to Any
+// ---
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SS2iIegdd_ypIegr_TR : $@convention(thin) (@guaranteed @callee_guaranteed () -> (Int, Int)) -> @out Any {
+// CHECK: bb0([[ARG:%.*]] : $@callee_guaranteed () -> (Int, Int)):
+// CHECK: [[ASTACK:%.*]] = alloc_stack $Any
+// CHECK: [[IADDR:%.*]] = init_existential_addr [[ASTACK]] : $*Any, $(Int, Int)
+// CHECK: [[TADDR0:%.*]] = tuple_element_addr [[IADDR]] : $*(Int, Int), 0
+// CHECK: [[TADDR1:%.*]] = tuple_element_addr [[IADDR]] : $*(Int, Int), 1
+// CHECK: [[APPLYARG:%.*]] = apply [[ARG]]() : $@callee_guaranteed () -> (Int, Int)
+// CHECK: [[TEXTRACT0:%.*]] = tuple_extract [[APPLYARG]] : $(Int, Int), 0
+// CHECK: [[TEXTRACT1:%.*]] = tuple_extract [[APPLYARG]] : $(Int, Int), 1
+// CHECK: store [[TEXTRACT0]] to [trivial] [[TADDR0]] : $*Int
+// CHECK: store [[TEXTRACT1]] to [trivial] [[TADDR1]] : $*Int
+// CHECK: [[LOAD_EXIST:%.*]] = load [trivial] [[IADDR]] : $*(Int, Int)
+// CHECK: [[RETVAL:%.*]] = init_existential_value [[LOAD_EXIST]] : $(Int, Int), $(Int, Int), $Any
+// CHECK: dealloc_stack [[ASTACK]] : $*Any
+// CHECK: return [[RETVAL]] : $Any
+// CHECK-LABEL: } // end sil function '$SS2iIegdd_ypIegr_TR'
+
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @{{.*}} : $@convention(thin) (Int, Int, Int, Int, Int, @guaranteed @callee_guaranteed (@in_guaranteed (Int, (Int, (Int, Int)), Int)) -> @out (Int, (Int, (Int, Int)), Int)) -> (Int, Int, Int, Int, Int)
+// CHECK: bb0([[ARG0:%.*]] : $Int, [[ARG1:%.*]] : $Int, [[ARG2:%.*]] : $Int, [[ARG3:%.*]] : $Int, [[ARG4:%.*]] : $Int, [[ARG5:%.*]] : $@callee_guaranteed (@in_guaranteed (Int, (Int, (Int, Int)), Int)) -> @out (Int, (Int, (Int, Int)), Int)):
+// CHECK: [[TUPLE_TO_APPLY0:%.*]] = tuple ([[ARG2]] : $Int, [[ARG3]] : $Int)
+// CHECK: [[TUPLE_TO_APPLY1:%.*]] = tuple ([[ARG1]] : $Int, [[TUPLE_TO_APPLY0]] : $(Int, Int))
+// CHECK: [[TUPLE_TO_APPLY2:%.*]] = tuple ([[ARG0]] : $Int, [[TUPLE_TO_APPLY1]] : $(Int, (Int, Int)), [[ARG4]] : $Int)
+// CHECK: [[TUPLE_APPLY:%.*]] = apply [[ARG5]]([[TUPLE_TO_APPLY2]]) : $@callee_guaranteed (@in_guaranteed (Int, (Int, (Int, Int)), Int)) -> @out (Int, (Int, (Int, Int)), Int)
+// CHECK: [[RET_VAL0:%.*]] = tuple_extract [[TUPLE_APPLY]] : $(Int, (Int, (Int, Int)), Int), 0
+// CHECK: [[TUPLE_EXTRACT1:%.*]] = tuple_extract [[TUPLE_APPLY]] : $(Int, (Int, (Int, Int)), Int), 1
+// CHECK: [[RET_VAL1:%.*]] = tuple_extract [[TUPLE_EXTRACT1]] : $(Int, (Int, Int)), 0
+// CHECK: [[TUPLE_EXTRACT2:%.*]] = tuple_extract [[TUPLE_EXTRACT1]] : $(Int, (Int, Int)), 1
+// CHECK: [[RET_VAL2:%.*]] = tuple_extract [[TUPLE_EXTRACT2]] : $(Int, Int), 0
+// CHECK: [[RET_VAL3:%.*]] = tuple_extract [[TUPLE_EXTRACT2]] : $(Int, Int), 1
+// CHECK: [[RET_VAL4:%.*]] = tuple_extract [[TUPLE_APPLY]] : $(Int, (Int, (Int, Int)), Int), 2
+// CHECK: [[RET_VAL_TUPLE:%.*]] = tuple ([[RET_VAL0]] : $Int, [[RET_VAL1]] : $Int, [[RET_VAL2]] : $Int, [[RET_VAL3]] : $Int, [[RET_VAL4]] : $Int)
+// CHECK: return [[RET_VAL_TUPLE]] : $(Int, Int, Int, Int, Int)
+// CHECK-LABEL: } // end sil function '{{.*}}'
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @{{.*}} : $@convention(thin) <T> (Int, @in_guaranteed T, @guaranteed @callee_guaranteed (@in_guaranteed (Int, T)) -> @out (Int, T)) -> (Int, @out T) {
+// CHECK: bb0([[ARG0:%.*]] : $Int, [[ARG1:%.*]] : $T, [[ARG2:%.*]] : $@callee_guaranteed (@in_guaranteed (Int, T)) -> @out (Int, T)):
+// CHECK: [[TUPLE_TO_APPLY:%.*]] = tuple ([[ARG0]] : $Int, [[ARG1]] : $T)
+// CHECK: [[TUPLE_APPLY:%.*]] = apply [[ARG2]]([[TUPLE_TO_APPLY]]) : $@callee_guaranteed (@in_guaranteed (Int, T)) -> @out (Int, T)
+// CHECK: [[TUPLE_BORROW:%.*]] = begin_borrow [[TUPLE_APPLY]] : $(Int, T)
+// CHECK: [[RET_VAL0:%.*]] = tuple_extract [[TUPLE_BORROW]] : $(Int, T), 0
+// CHECK: [[TUPLE_EXTRACT:%.*]] = tuple_extract [[TUPLE_BORROW]] : $(Int, T), 1
+// CHECK: [[RET_VAL1:%.*]] = copy_value [[TUPLE_EXTRACT]] : $T
+// CHECK: end_borrow [[TUPLE_BORROW]] from [[TUPLE_APPLY]] : $(Int, T), $(Int, T)
+// CHECK: destroy_value [[TUPLE_APPLY]] : $(Int, T)
+// CHECK: [[RET_VAL_TUPLE:%.*]] = tuple ([[RET_VAL0]] : $Int, [[RET_VAL1]] : $T)
+// CHECK: return [[RET_VAL_TUPLE]] : $(Int, T)
+// CHECK-LABEL: } // end sil function '{{.*}}'
+
+
+// Tests LogicalPathComponent's writeback for opaque value types
+// ---
+// CHECK-LABEL: sil @$Ss10DictionaryV20opaque_values_silgenE22inoutAccessOfSubscript3keyyq__tF : $@convention(method) <Key, Value where Key : Hashable> (@in_guaranteed Value, @inout Dictionary<Key, Value>) -> () {
+// CHECK: bb0([[ARG0:%.*]] : $Value, [[ARG1:%.*]] : $*Dictionary<Key, Value>):
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[ARG1]] : $*Dictionary<Key, Value>
+// CHECK: [[OPTIONAL_ALLOC:%.*]] = alloc_stack $Optional<Value>
+// CHECK: switch_enum_addr [[OPTIONAL_ALLOC]] : $*Optional<Value>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb1
+// CHECK: bb2:
+// CHECK: [[OPTIONAL_LOAD:%.*]] = load [take] [[OPTIONAL_ALLOC]] : $*Optional<Value>
+// CHECK: apply {{.*}}<Key, Value>([[OPTIONAL_LOAD]], {{.*}}, [[WRITE]]) : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@in Optional<τ_0_1>, @in τ_0_1, @inout Dictionary<τ_0_0, τ_0_1>) -> ()
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$Ss10DictionaryV20opaque_values_silgenE22inoutAccessOfSubscript3keyyq__tF'
+
+// Tests materializeForSet's createSetterCallback for opaque values
+// ---
+// CHECK-LABEL: sil shared [transparent] [serialized] @$Ss10DictionaryV20opaque_values_silgenEyq_Sgq_cimytfU_ : $@convention(method) <Key, Value where Key : Hashable> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Dictionary<Key, Value>, @thick Dictionary<Key, Value>.Type) -> () {
+// CHECK: bb0([[ARG0:%.*]] : $Builtin.RawPointer, [[ARG1:%.*]] : $*Builtin.UnsafeValueBuffer, [[ARG2:%.*]] : $*Dictionary<Key, Value>, [[ARG3:%.*]] : $@thick Dictionary<Key, Value>.Type):
+// CHECK: [[PROJ_VAL1:%.*]] = project_value_buffer $Value in [[ARG1]] : $*Builtin.UnsafeValueBuffer
+// CHECK: [[LOAD_VAL1:%.*]] = load [take] [[PROJ_VAL1]] : $*Value
+// CHECK: [[ADDR_VAL0:%.*]] = pointer_to_address [[ARG0]] : $Builtin.RawPointer to [strict] $*Optional<Value>
+// CHECK: [[LOAD_VAL0:%.*]] = load [take] [[ADDR_VAL0]] : $*Optional<Value>
+// CHECK: apply {{.*}}<Key, Value>([[LOAD_VAL0]], [[LOAD_VAL1]], [[ARG2]]) : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@in Optional<τ_0_1>, @in τ_0_1, @inout Dictionary<τ_0_0, τ_0_1>) -> ()
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$Ss10DictionaryV20opaque_values_silgenEyq_Sgq_cimytfU_'
+extension Dictionary {
+ public subscript(key: Value) -> Value? {
+ @inline(__always)
+ get {
+ return key
+ }
+ set(newValue) {
+ }
+ }
+
+ public mutating func inoutAccessOfSubscript(key: Value) {
+ func increment(x: inout Value) { }
+
+ increment(x: &self[key]!)
+ }
+}
+
+// s400______maybeCloneP continued Test: reabstraction thunk
+// ---
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SxSgIegr_20opaque_values_silgen8Clonable_pSgIegr_AbCRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @out Optional<τ_0_0>) -> @out Optional<Clonable> {
+// CHECK: bb0([[ARG:%.*]] : $@callee_guaranteed () -> @out Optional<τ_0_0>):
+// CHECK: [[APPLY_ARG:%.*]] = apply [[ARG]]() : $@callee_guaranteed () -> @out Optional<τ_0_0>
+// CHECK: switch_enum [[APPLY_ARG]] : $Optional<τ_0_0>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb1
+// CHECK: bb1:
+// CHECK: [[ONONE:%.*]] = enum $Optional<Clonable>, #Optional.none!enumelt
+// CHECK: br bb3([[ONONE]] : $Optional<Clonable>)
+// CHECK: bb2([[ENUM_SOME:%.*]] : $τ_0_0):
+// CHECK: [[INIT_OPAQUE:%.*]] = init_existential_value [[ENUM_SOME]] : $τ_0_0, $τ_0_0, $Clonable
+// CHECK: [[OSOME:%.*]] = enum $Optional<Clonable>, #Optional.some!enumelt.1, [[INIT_OPAQUE]] : $Clonable
+// CHECK: br bb3([[OSOME]] : $Optional<Clonable>)
+// CHECK: bb3([[RETVAL:%.*]] : $Optional<Clonable>):
+// CHECK: return [[RETVAL]] : $Optional<Clonable>
+// CHECK-LABEL: } // end sil function '$SxSgIegr_20opaque_values_silgen8Clonable_pSgIegr_AbCRzlTR'
+
+// s320__transImplodeAny continued Test: reabstraction thunk
+// ---
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SypIegn_S2iIegyy_TR : $@convention(thin) (Int, Int, @guaranteed @callee_guaranteed (@in_guaranteed Any) -> ()) -> () {
+// CHECK: bb0([[ARG0:%.*]] : $Int, [[ARG1:%.*]] : $Int, [[ARG2:%.*]] : $@callee_guaranteed (@in_guaranteed Any) -> ()):
+// CHECK: [[ASTACK:%.*]] = alloc_stack $Any
+// CHECK: [[IADDR:%.*]] = init_existential_addr [[ASTACK]] : $*Any, $(Int, Int)
+// CHECK: [[TADDR0:%.*]] = tuple_element_addr [[IADDR]] : $*(Int, Int), 0
+// CHECK: store [[ARG0]] to [trivial] [[TADDR0]] : $*Int
+// CHECK: [[TADDR1:%.*]] = tuple_element_addr [[IADDR]] : $*(Int, Int), 1
+// CHECK: store [[ARG1]] to [trivial] [[TADDR1]] : $*Int
+// CHECK: [[LOAD_EXIST:%.*]] = load [trivial] [[IADDR]] : $*(Int, Int)
+// CHECK: [[INIT_OPAQUE:%.*]] = init_existential_value [[LOAD_EXIST]] : $(Int, Int), $(Int, Int), $Any
+// CHECK: [[BORROWED_INIT_OPAQUE:%.*]] = begin_borrow [[INIT_OPAQUE]]
+// CHECK: [[APPLYARG:%.*]] = apply [[ARG2]]([[BORROWED_INIT_OPAQUE]]) : $@callee_guaranteed (@in_guaranteed Any) -> ()
+// CHECK: dealloc_stack [[ASTACK]] : $*Any
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$SypIegn_S2iIegyy_TR'
diff --git a/test/SILGen/plus_zero_opaque_values_silgen_lib.swift b/test/SILGen/plus_zero_opaque_values_silgen_lib.swift
new file mode 100644
index 0000000..fa43ee0
--- /dev/null
+++ b/test/SILGen/plus_zero_opaque_values_silgen_lib.swift
@@ -0,0 +1,77 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -enable-sil-opaque-values -emit-sorted-sil -Xllvm -sil-full-demangle -parse-stdlib -parse-as-library -emit-silgen -module-name Swift %s | %FileCheck %s
+// UNSUPPORTED: resilient_stdlib
+
+precedencegroup AssignmentPrecedence { assignment: true }
+
+enum Optional<Wrapped> {
+ case none
+ case some(Wrapped)
+}
+
+protocol EmptyP {}
+
+struct String { var ptr: Builtin.NativeObject }
+
+// Tests Empty protocol + Builtin.NativeObject enum (including opaque tuples as a return value)
+// ---
+// CHECK-LABEL: sil hidden @$Ss21s010______PAndS_casesyyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK: [[MTYPE:%.*]] = metatype $@thin PAndSEnum.Type
+// CHECK: [[EAPPLY:%.*]] = apply {{.*}}([[MTYPE]]) : $@convention(thin) (@thin PAndSEnum.Type) -> @owned @callee_guaranteed (@in_guaranteed EmptyP, @guaranteed String) -> @out PAndSEnum
+// CHECK: destroy_value [[EAPPLY]]
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '$Ss21s010______PAndS_casesyyF'
+func s010______PAndS_cases() {
+ _ = PAndSEnum.A
+}
+
+// Test emitBuiltinReinterpretCast.
+// ---
+// CHECK-LABEL: sil hidden @$Ss21s020__________bitCast_2toq_x_q_mtr0_lF : $@convention(thin) <T, U> (@in_guaranteed T, @thick U.Type) -> @out U {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $T,
+// CHECK: [[CAST:%.*]] = unchecked_bitwise_cast [[ARG]] : $T to $U
+// CHECK: [[RET:%.*]] = copy_value [[CAST]] : $U
+// CHECK-NOT: destroy_value [[COPY]] : $T
+// CHECK: return [[RET]] : $U
+// CHECK-LABEL: } // end sil function '$Ss21s020__________bitCast_2toq_x_q_mtr0_lF'
+func s020__________bitCast<T, U>(_ x: T, to type: U.Type) -> U {
+ return Builtin.reinterpretCast(x)
+}
+
+// Test emitBuiltinCastReference
+// ---
+// CHECK-LABEL: sil hidden @$Ss21s030__________refCast_2toq_x_q_mtr0_lF : $@convention(thin) <T, U> (@in_guaranteed T, @thick U.Type) -> @out U {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $T, %1 : @trivial $@thick U.Type):
+// CHECK: [[COPY:%.*]] = copy_value [[ARG]] : $T
+// CHECK: [[SRC:%.*]] = alloc_stack $T
+// CHECK: store [[COPY]] to [init] [[SRC]] : $*T
+// CHECK: [[DEST:%.*]] = alloc_stack $U
+// CHECK: unchecked_ref_cast_addr T in [[SRC]] : $*T to U in [[DEST]] : $*U
+// CHECK: [[LOAD:%.*]] = load [take] [[DEST]] : $*U
+// CHECK: dealloc_stack [[DEST]] : $*U
+// CHECK: dealloc_stack [[SRC]] : $*T
+// CHECK-NOT: destroy_value [[ARG]] : $T
+// CHECK: return [[LOAD]] : $U
+// CHECK-LABEL: } // end sil function '$Ss21s030__________refCast_2toq_x_q_mtr0_lF'
+func s030__________refCast<T, U>(_ x: T, to: U.Type) -> U {
+ return Builtin.castReference(x)
+}
+
+// Init of Empty protocol + Builtin.NativeObject enum (including opaque tuples as a return value)
+// ---
+// CHECK-LABEL: sil shared [transparent] @$Ss9PAndSEnumO1AyABs6EmptyP_p_SStcABmF : $@convention(method) (@in EmptyP, @owned String, @thin PAndSEnum.Type) -> @out PAndSEnum {
+// CHECK: bb0([[ARG0:%.*]] : @owned $EmptyP, [[ARG1:%.*]] : @owned $String, [[ARG2:%.*]] : @trivial $@thin PAndSEnum.Type):
+// CHECK: [[RTUPLE:%.*]] = tuple ([[ARG0]] : $EmptyP, [[ARG1]] : $String)
+// CHECK: [[RETVAL:%.*]] = enum $PAndSEnum, #PAndSEnum.A!enumelt.1, [[RTUPLE]] : $(EmptyP, String)
+// CHECK: return [[RETVAL]] : $PAndSEnum
+// CHECK-LABEL: } // end sil function '$Ss9PAndSEnumO1AyABs6EmptyP_p_SStcABmF'
+// CHECK-LABEL: sil shared [transparent] [thunk] @$Ss9PAndSEnumO1AyABs6EmptyP_p_SStcABmFTc : $@convention(thin) (@thin PAndSEnum.Type) -> @owned @callee_guaranteed (@in_guaranteed EmptyP, @guaranteed String) -> @out PAndSEnum {
+// CHECK: bb0([[ARG:%.*]] : @trivial $@thin PAndSEnum.Type):
+// CHECK: [[RETVAL:%.*]] = partial_apply [callee_guaranteed] {{.*}}([[ARG]]) : $@convention(method) (@in EmptyP, @owned String, @thin PAndSEnum.Type) -> @out PAndSEnum
+// CHECK: [[CANONICAL_THUNK_FN:%.*]] = function_ref @$Ss6EmptyP_pSSs9PAndSEnumOIegixr_sAA_pSSACIegngr_TR : $@convention(thin) (@in_guaranteed EmptyP, @guaranteed String, @guaranteed @callee_guaranteed (@in EmptyP, @owned String) -> @out PAndSEnum) -> @out PAndSEnum
+// CHECK: [[CANONICAL_THUNK:%.*]] = partial_apply [callee_guaranteed] [[CANONICAL_THUNK_FN]]([[RETVAL]])
+// CHECK: return [[CANONICAL_THUNK]] : $@callee_guaranteed (@in_guaranteed EmptyP, @guaranteed String) -> @out PAndSEnum
+// CHECK-LABEL: } // end sil function '$Ss9PAndSEnumO1AyABs6EmptyP_p_SStcABmFTc'
+enum PAndSEnum { case A(EmptyP, String) }
+
diff --git a/test/SILGen/plus_zero_optional-cast.swift b/test/SILGen/plus_zero_optional-cast.swift
new file mode 100644
index 0000000..0c0ca83
--- /dev/null
+++ b/test/SILGen/plus_zero_optional-cast.swift
@@ -0,0 +1,226 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+class A {}
+class B : A {}
+
+// CHECK-LABEL: sil hidden @$S4main3fooyyAA1ACSgF : $@convention(thin) (@guaranteed Optional<A>) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Optional<A>):
+// CHECK: [[X:%.*]] = alloc_box ${ var Optional<B> }, var, name "x"
+// CHECK-NEXT: [[PB:%.*]] = project_box [[X]]
+// Check whether the temporary holds a value.
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: [[T1:%.*]] = select_enum [[ARG_COPY]]
+// CHECK-NEXT: cond_br [[T1]], [[IS_PRESENT:bb.*]], [[NOT_PRESENT:bb[0-9]+]]
+//
+// CHECK: [[NOT_PRESENT]]:
+// CHECK: br [[NOT_PRESENT_FINISH:bb[0-9]+]]
+//
+// If so, pull the value out and check whether it's a B.
+// CHECK: [[IS_PRESENT]]:
+// CHECK-NEXT: [[VAL:%.*]] = unchecked_enum_data [[ARG_COPY]] : $Optional<A>, #Optional.some!enumelt.1
+// CHECK-NEXT: [[X_VALUE:%.*]] = init_enum_data_addr [[PB]] : $*Optional<B>, #Optional.some
+// CHECK-NEXT: checked_cast_br [[VAL]] : $A to $B, [[IS_B:bb.*]], [[NOT_B:bb[0-9]+]]
+//
+// If so, materialize that and inject it into x.
+// CHECK: [[IS_B]]([[T0:%.*]] : @owned $B):
+// CHECK-NEXT: store [[T0]] to [init] [[X_VALUE]] : $*B
+// CHECK-NEXT: inject_enum_addr [[PB]] : $*Optional<B>, #Optional.some
+// CHECK-NEXT: br [[CONT:bb[0-9]+]]
+//
+// If not, destroy_value the A and inject nothing into x.
+// CHECK: [[NOT_B]]([[ORIGINAL_VALUE:%.*]] : @owned $A):
+// CHECK-NEXT: destroy_value [[ORIGINAL_VALUE]]
+// CHECK-NEXT: inject_enum_addr [[PB]] : $*Optional<B>, #Optional.none
+// CHECK-NEXT: br [[CONT]]
+//
+// Finish the present path.
+// CHECK: [[CONT]]:
+// CHECK-NEXT: br [[RETURN_BB:bb[0-9]+]]
+//
+// Finish.
+// CHECK: [[RETURN_BB]]:
+// CHECK-NEXT: destroy_value [[X]]
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK-NEXT: tuple
+// CHECK-NEXT: return
+//
+// Finish the not-present path.
+// CHECK: [[NOT_PRESENT_FINISH]]:
+// CHECK-NEXT: inject_enum_addr [[PB]] {{.*}}none
+// CHECK-NEXT: br [[RETURN_BB]]
+func foo(_ y : A?) {
+ var x = (y as? B)
+}
+
+// CHECK-LABEL: sil hidden @$S4main3baryyAA1ACSgSgSgSgF : $@convention(thin) (@guaranteed Optional<Optional<Optional<Optional<A>>>>) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Optional<Optional<Optional<Optional<A>>>>):
+// CHECK: [[X:%.*]] = alloc_box ${ var Optional<Optional<Optional<B>>> }, var, name "x"
+// CHECK-NEXT: [[PB:%.*]] = project_box [[X]]
+// -- Check for some(...)
+// CHECK-NEXT: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: [[T1:%.*]] = select_enum [[ARG_COPY]]
+// CHECK-NEXT: cond_br [[T1]], [[P:bb.*]], [[NIL_DEPTH_1:bb[0-9]+]]
+//
+// CHECK: [[NIL_DEPTH_1]]:
+// CHECK: br [[FINISH_NIL_0:bb[0-9]+]]
+//
+// If so, drill down another level and check for some(some(...)).
+// CHECK: [[P]]:
+// CHECK-NEXT: [[VALUE_OOOA:%.*]] = unchecked_enum_data [[ARG_COPY]]
+// CHECK: [[T1:%.*]] = select_enum [[VALUE_OOOA]]
+// CHECK-NEXT: cond_br [[T1]], [[PP:bb.*]], [[NIL_DEPTH_2:bb[0-9]+]]
+//
+// CHECK: [[NIL_DEPTH_2]]:
+// CHECK: br [[FINISH_NIL_0]]
+//
+// If so, drill down another level and check for some(some(some(...))).
+// CHECK: [[PP]]:
+// CHECK-NEXT: [[VALUE_OOA:%.*]] = unchecked_enum_data [[VALUE_OOOA]]
+// CHECK: [[T1:%.*]] = select_enum [[VALUE_OOA]]
+// CHECK-NEXT: cond_br [[T1]], [[PPP:bb.*]], [[NIL_DEPTH_3:bb[0-9]+]]
+//
+// CHECK: [[NIL_DEPTH_3]]:
+// CHECK: br [[FINISH_NIL_1:bb[0-9]+]]
+//
+// If so, drill down another level and check for some(some(some(some(...)))).
+// CHECK: [[PPP]]:
+// CHECK-NEXT: [[VALUE_OA:%.*]] = unchecked_enum_data [[VALUE_OOA]]
+// CHECK: [[T1:%.*]] = select_enum [[VALUE_OA]]
+// CHECK-NEXT: cond_br [[T1]], [[PPPP:bb.*]], [[NIL_DEPTH_4:bb[0-9]+]]
+//
+// CHECK: [[NIL_DEPTH_4]]:
+// CHECK: br [[FINISH_NIL_2:bb[0-9]+]]
+//
+// If so, pull out the A and check whether it's a B.
+// CHECK: [[PPPP]]:
+// CHECK-NEXT: [[VAL:%.*]] = unchecked_enum_data [[VALUE_OA]]
+// CHECK-NEXT: checked_cast_br [[VAL]] : $A to $B, [[IS_B:bb.*]], [[NOT_B:bb[0-9]+]]
+//
+// If so, inject it back into an optional.
+// TODO: We're going to switch back out of this; we really should peephole it.
+// CHECK: [[IS_B]]([[T0:%.*]] : @owned $B):
+// CHECK-NEXT: enum $Optional<B>, #Optional.some!enumelt.1, [[T0]]
+// CHECK-NEXT: br [[SWITCH_OB2:bb[0-9]+]](
+//
+// If not, inject nothing into an optional.
+// CHECK: [[NOT_B]]([[ORIGINAL_VALUE:%.*]] : @owned $A):
+// CHECK-NEXT: destroy_value [[ORIGINAL_VALUE]]
+// CHECK-NEXT: enum $Optional<B>, #Optional.none!enumelt
+// CHECK-NEXT: br [[SWITCH_OB2]](
+//
+// Switch out on the value in [[OB2]].
+// CHECK: [[SWITCH_OB2]]([[VAL:%[0-9]+]] : @owned $Optional<B>):
+// CHECK: [[T0:%.*]] = select_enum [[VAL]]
+// CHECK: cond_br [[T0]], [[HAVE_B:bb[0-9]+]], [[FINISH_NIL_4:bb[0-9]+]]
+//
+// CHECK: [[FINISH_NIL_4]]:
+// CHECK: br [[FINISH_NIL_0]]
+//
+// CHECK: [[HAVE_B]]:
+// CHECK: [[UNWRAPPED_VAL:%.*]] = unchecked_enum_data [[VAL]]
+// CHECK: [[REWRAPPED_VAL:%.*]] = enum $Optional<B>, #Optional.some!enumelt.1, [[UNWRAPPED_VAL]]
+// CHECK: br [[DONE_DEPTH0:bb[0-9]+]]
+//
+// CHECK: [[DONE_DEPTH0]](
+// CHECK-NEXT: enum $Optional<Optional<B>>, #Optional.some!enumelt.1,
+// CHECK-NEXT: br [[DONE_DEPTH1:bb[0-9]+]]
+//
+// Set X := some(OOB).
+// CHECK: [[DONE_DEPTH1]]
+// CHECK-NEXT: enum $Optional<Optional<Optional<B>>>, #Optional.some!enumelt.1,
+// CHECK: br [[DONE_DEPTH2:bb[0-9]+]]
+// CHECK: [[DONE_DEPTH2]]
+// CHECK-NEXT: destroy_value [[X]]
+// CHECK-NOT: destroy_value %0
+// CHECK: return
+//
+// On various failure paths, set OOB := nil.
+// CHECK: [[FINISH_NIL_2]]:
+// CHECK-NEXT: enum $Optional<B>, #Optional.none!enumelt
+// CHECK-NEXT: br [[DONE_DEPTH0]]
+//
+// CHECK: [[FINISH_NIL_1]]:
+// CHECK-NEXT: enum $Optional<Optional<B>>, #Optional.none!enumelt
+// CHECK-NEXT: br [[DONE_DEPTH1]]
+//
+// On various failure paths, set X := nil.
+// CHECK: [[FINISH_NIL_0]]:
+// CHECK-NEXT: inject_enum_addr [[PB]] {{.*}}none
+// CHECK-NEXT: br [[DONE_DEPTH2]]
+// Done.
+func bar(_ y : A????) {
+ var x = (y as? B??)
+}
+
+
+// CHECK-LABEL: sil hidden @$S4main3bazyyyXlSgF : $@convention(thin) (@guaranteed Optional<AnyObject>) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Optional<AnyObject>):
+// CHECK: [[X:%.*]] = alloc_box ${ var Optional<B> }, var, name "x"
+// CHECK-NEXT: [[PB:%.*]] = project_box [[X]]
+// CHECK-NEXT: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: [[T1:%.*]] = select_enum [[ARG_COPY]]
+// CHECK: bb1:
+// CHECK: [[VAL:%.*]] = unchecked_enum_data [[ARG_COPY]]
+// CHECK-NEXT: [[X_VALUE:%.*]] = init_enum_data_addr [[PB]] : $*Optional<B>, #Optional.some
+// CHECK-NEXT: checked_cast_br [[VAL]] : $AnyObject to $B, [[IS_B:bb.*]], [[NOT_B:bb[0-9]+]]
+// CHECK: [[IS_B]]([[CASTED_VALUE:%.*]] : @owned $B):
+// CHECK: store [[CASTED_VALUE]] to [init] [[X_VALUE]]
+// CHECK: [[NOT_B]]([[ORIGINAL_VALUE:%.*]] : @owned $AnyObject):
+// CHECK: destroy_value [[ORIGINAL_VALUE]]
+// CHECK: } // end sil function '$S4main3bazyyyXlSgF'
+func baz(_ y : AnyObject?) {
+ var x = (y as? B)
+}
+
+
+// <rdar://problem/17013042> T! <-> T? conversions should not produce a diamond
+
+// CHECK-LABEL: sil hidden @$S4main07opt_to_B8_trivialySiSgACF
+// CHECK: bb0(%0 : @trivial $Optional<Int>):
+// CHECK-NEXT: debug_value %0 : $Optional<Int>, let, name "x"
+// CHECK-NEXT: return %0 : $Optional<Int>
+// CHECK-NEXT:}
+func opt_to_opt_trivial(_ x: Int?) -> Int! {
+ return x
+}
+
+// CHECK-LABEL: sil hidden @$S4main07opt_to_B10_referenceyAA1CCSgAEF
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Optional<C>):
+// CHECK: debug_value [[ARG]] : $Optional<C>, let, name "x"
+// CHECK: [[RESULT:%.*]] = copy_value [[ARG]]
+// CHECK-NOT: destroy_value [[ARG]]
+// CHECK: return [[RESULT]] : $Optional<C>
+// CHECK: } // end sil function '$S4main07opt_to_B10_referenceyAA1CCSgAEF'
+func opt_to_opt_reference(_ x : C!) -> C? { return x }
+
+// CHECK-LABEL: sil hidden @$S4main07opt_to_B12_addressOnly{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0(%0 : @trivial $*Optional<T>, %1 : @trivial $*Optional<T>):
+// CHECK-NEXT: debug_value_addr %1 : $*Optional<T>, let, name "x"
+// CHECK-NEXT: copy_addr %1 to [initialization] %0
+// CHECK-NOT: destroy_addr %1
+func opt_to_opt_addressOnly<T>(_ x : T!) -> T? { return x }
+
+class C {}
+
+public struct TestAddressOnlyStruct<T> {
+ func f(_ a : T?) {}
+
+ // CHECK-LABEL: sil hidden @$S4main21TestAddressOnlyStructV8testCall{{[_0-9a-zA-Z]*}}F
+ // CHECK: bb0(%0 : @trivial $*Optional<T>, %1 : @trivial $TestAddressOnlyStruct<T>):
+ // CHECK: apply {{.*}}<T>(%0, %1)
+ func testCall(_ a : T!) {
+ f(a)
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S4main35testContextualInitOfNonAddrOnlyTypeyySiSgF
+// CHECK: bb0(%0 : @trivial $Optional<Int>):
+// CHECK-NEXT: debug_value %0 : $Optional<Int>, let, name "a"
+// CHECK-NEXT: [[X:%.*]] = alloc_box ${ var Optional<Int> }, var, name "x"
+// CHECK-NEXT: [[PB:%.*]] = project_box [[X]]
+// CHECK-NEXT: store %0 to [trivial] [[PB]] : $*Optional<Int>
+// CHECK-NEXT: destroy_value [[X]] : ${ var Optional<Int> }
+func testContextualInitOfNonAddrOnlyType(_ a : Int?) {
+ var x: Int! = a
+}
diff --git a/test/SILGen/plus_zero_optional.swift b/test/SILGen/plus_zero_optional.swift
new file mode 100644
index 0000000..038a0ab
--- /dev/null
+++ b/test/SILGen/plus_zero_optional.swift
@@ -0,0 +1,105 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+func testCall(_ f: (() -> ())?) {
+ f?()
+}
+// CHECK: sil hidden @{{.*}}testCall{{.*}}
+// CHECK: bb0([[T0:%.*]] : @guaranteed $Optional<@callee_guaranteed () -> ()>):
+// CHECK: [[T0_COPY:%.*]] = copy_value [[T0]]
+// CHECK: [[T1:%.*]] = select_enum [[T0_COPY]]
+// CHECK-NEXT: cond_br [[T1]], [[SOME:bb[0-9]+]], [[NONE:bb[0-9]+]]
+
+// CHECK: [[NONE]]:
+// CHECK: br [[NOTHING_BLOCK_EXIT:bb[0-9]+]]
+
+// If it does, project and load the value out of the implicitly unwrapped
+// optional...
+
+// CHECK: [[SOME]]:
+// CHECK-NEXT: [[FN0:%.*]] = unchecked_enum_data [[T0_COPY]] : $Optional<@callee_guaranteed () -> ()>, #Optional.some!enumelt.1
+// .... then call it
+// CHECK-NEXT: [[B:%.*]] = begin_borrow [[FN0]]
+// CHECK-NEXT: apply [[B]]()
+// CHECK: destroy_value [[FN0]]
+// CHECK: br [[EXIT:bb[0-9]+]](
+
+// (first nothing block)
+// CHECK: [[NOTHING_BLOCK_EXIT]]:
+// CHECK-NEXT: enum $Optional<()>, #Optional.none!enumelt
+// CHECK-NEXT: br [[EXIT]]
+// CHECK: } // end sil function '$S8optional8testCallyyyycSgF'
+
+func testAddrOnlyCallResult<T>(_ f: (() -> T)?) {
+ var f = f
+ var x = f?()
+}
+// CHECK-LABEL: sil hidden @{{.*}}testAddrOnlyCallResult{{.*}} : $@convention(thin) <T> (@guaranteed Optional<@callee_guaranteed () -> @out T>) -> ()
+// CHECK: bb0([[T0:%.*]] : @guaranteed $Optional<@callee_guaranteed () -> @out T>):
+// CHECK: [[F:%.*]] = alloc_box $<τ_0_0> { var Optional<@callee_guaranteed () -> @out τ_0_0> } <T>, var, name "f"
+// CHECK-NEXT: [[PBF:%.*]] = project_box [[F]]
+// CHECK: [[T0_COPY:%.*]] = copy_value [[T0]]
+// CHECK: store [[T0_COPY]] to [init] [[PBF]]
+// CHECK-NEXT: [[X:%.*]] = alloc_box $<τ_0_0> { var Optional<τ_0_0> } <T>, var, name "x"
+// CHECK-NEXT: [[PBX:%.*]] = project_box [[X]]
+// CHECK-NEXT: [[TEMP:%.*]] = init_enum_data_addr [[PBX]]
+// CHECK-NEXT: [[READ:%.*]] = begin_access [read] [unknown] [[PBF]]
+// Check whether 'f' holds a value.
+// CHECK: [[T1:%.*]] = select_enum_addr [[READ]]
+// CHECK-NEXT: cond_br [[T1]], bb2, bb1
+// If so, pull out the value...
+// CHECK: bb2:
+// CHECK-NEXT: [[T1:%.*]] = unchecked_take_enum_data_addr [[READ]]
+// CHECK-NEXT: [[T0:%.*]] = load [copy] [[T1]]
+// CHECK-NEXT: end_access [[READ]]
+// ...evaluate the rest of the suffix...
+// CHECK: [[B:%.*]] = begin_borrow [[T0]]
+// CHECK-NEXT: apply [[B]]([[TEMP]])
+// ...and coerce to T?
+// CHECK: inject_enum_addr [[PBX]] {{.*}}some
+// CHECK: destroy_value [[T0]]
+// CHECK-NEXT: br bb3
+// Continuation block.
+// CHECK: bb3
+// CHECK-NEXT: destroy_value [[X]]
+// CHECK-NEXT: destroy_value [[F]]
+// CHECK-NOT: destroy_value %0
+// CHECK-NEXT: [[T0:%.*]] = tuple ()
+// CHECK-NEXT: return [[T0]] : $()
+
+// Nothing block.
+// CHECK: bb4:
+// CHECK-NEXT: inject_enum_addr [[PBX]] {{.*}}none
+// CHECK-NEXT: br bb3
+
+
+// <rdar://problem/15180622>
+
+func wrap<T>(_ x: T) -> T? { return x }
+
+// CHECK-LABEL: sil hidden @$S8optional16wrap_then_unwrap{{[_0-9a-zA-Z]*}}F
+func wrap_then_unwrap<T>(_ x: T) -> T {
+ // CHECK: switch_enum_addr {{.*}}, case #Optional.some!enumelt.1: [[OK:bb[0-9]+]], case #Optional.none!enumelt: [[FAIL:bb[0-9]+]]
+ // CHECK: [[FAIL]]:
+ // CHECK: unreachable
+ // CHECK: [[OK]]:
+ // CHECK: unchecked_take_enum_data_addr
+ return wrap(x)!
+}
+
+// CHECK-LABEL: sil hidden @$S8optional10tuple_bind{{[_0-9a-zA-Z]*}}F
+func tuple_bind(_ x: (Int, String)?) -> String? {
+ return x?.1
+ // CHECK: cond_br {{%.*}}, [[NONNULL:bb[0-9]+]], [[NULL:bb[0-9]+]]
+ // CHECK: [[NONNULL]]:
+ // CHECK: [[STRING:%.*]] = tuple_extract {{%.*}} : $(Int, String), 1
+ // CHECK-NOT: destroy_value [[STRING]]
+}
+
+// rdar://21883752 - We were crashing on this function because the deallocation happened
+// out of scope.
+// CHECK-LABEL: sil hidden @$S8optional16crash_on_deallocyys10DictionaryVySiSaySiGGFfA_
+func crash_on_dealloc(_ dict : [Int : [Int]] = [:]) {
+ var dict = dict
+ dict[1]?.append(2)
+}
diff --git a/test/SILGen/plus_zero_optional_lvalue.swift b/test/SILGen/plus_zero_optional_lvalue.swift
new file mode 100644
index 0000000..d2a4f17
--- /dev/null
+++ b/test/SILGen/plus_zero_optional_lvalue.swift
@@ -0,0 +1,74 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+// CHECK-LABEL: sil hidden @$S15optional_lvalue07assign_a1_B0yySiSgz_SitF
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] %0 : $*Optional<Int>
+// CHECK: [[PRECOND:%.*]] = function_ref @$Ss30_diagnoseUnexpectedNilOptional{{[_0-9a-zA-Z]*}}F
+// CHECK: apply [[PRECOND]](
+// CHECK: [[PAYLOAD:%.*]] = unchecked_take_enum_data_addr [[WRITE]] : $*Optional<Int>, #Optional.some!enumelt.1
+// CHECK: assign {{%.*}} to [[PAYLOAD]]
+func assign_optional_lvalue(_ x: inout Int?, _ y: Int) {
+ x! = y
+}
+
+// CHECK-LABEL: sil hidden @$S15optional_lvalue011assign_iuo_B0yySiSgz_SitF
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] %0 : $*Optional<Int>
+// CHECK: [[PRECOND:%.*]] = function_ref @$Ss30_diagnoseUnexpectedNilOptional{{[_0-9a-zA-Z]*}}F
+// CHECK: apply [[PRECOND]](
+// CHECK: [[PAYLOAD:%.*]] = unchecked_take_enum_data_addr [[WRITE]] : $*Optional<Int>, #Optional.some!enumelt.1
+// CHECK: assign {{%.*}} to [[PAYLOAD]]
+func assign_iuo_lvalue(_ x: inout Int!, _ y: Int) {
+ x! = y
+}
+
+struct S {
+ var x: Int
+
+ var computed: Int {
+ get {}
+ set {}
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S15optional_lvalue011assign_iuo_B9_implicityyAA1SVSgz_SitF
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] %0 : $*Optional<S>
+// CHECK: [[SOME:%.*]] = unchecked_take_enum_data_addr [[WRITE]]
+// CHECK: [[X:%.*]] = struct_element_addr [[SOME]]
+func assign_iuo_lvalue_implicit(_ s: inout S!, _ y: Int) {
+ s.x = y
+}
+
+struct Struct<T> {
+ var value: T?
+}
+
+// CHECK-LABEL: sil hidden @$S15optional_lvalue07assign_a1_B13_reabstractedyyAA6StructVyS2icGz_S2ictF
+// CHECK: [[REABSTRACT:%.*]] = function_ref @$SS2iIegyd_S2iIegnr_TR
+// CHECK: [[REABSTRACTED:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACT]]
+// CHECK: assign [[REABSTRACTED]] to {{%.*}} : $*@callee_guaranteed (@in_guaranteed Int) -> @out Int
+func assign_optional_lvalue_reabstracted(_ x: inout Struct<(Int) -> Int>,
+ _ y: @escaping (Int) -> Int) {
+ x.value! = y
+}
+
+// CHECK-LABEL: sil hidden @$S15optional_lvalue07assign_a1_B9_computedySiAA1SVSgz_SitF
+// CHECK: function_ref @$S15optional_lvalue1SV8computedSivs
+// CHECK: function_ref @$S15optional_lvalue1SV8computedSivg
+func assign_optional_lvalue_computed(_ x: inout S?, _ y: Int) -> Int {
+ x!.computed = y
+ return x!.computed
+}
+
+func generate_int() -> Int { return 0 }
+
+// CHECK-LABEL: sil hidden @$S15optional_lvalue013assign_bound_a1_B0yySiSgzF
+// CHECK: select_enum_addr
+// CHECK: cond_br {{%.*}}, [[SOME:bb[0-9]+]], [[NONE:bb[0-9]+]]
+// CHECK: [[SOME]]:
+// CHECK: [[PAYLOAD:%.*]] = unchecked_take_enum_data_addr
+// CHECK: [[FN:%.*]] = function_ref
+// CHECK: [[T0:%.*]] = apply [[FN]]()
+// CHECK: assign [[T0]] to [[PAYLOAD]]
+func assign_bound_optional_lvalue(_ x: inout Int?) {
+ x? = generate_int()
+}
diff --git a/test/SILGen/plus_zero_partial_apply_generic.swift b/test/SILGen/plus_zero_partial_apply_generic.swift
new file mode 100644
index 0000000..dc1f4c5
--- /dev/null
+++ b/test/SILGen/plus_zero_partial_apply_generic.swift
@@ -0,0 +1,91 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+protocol Panda {
+ associatedtype Cuddles : Foo
+}
+
+protocol Foo {
+ static func staticFunc()
+ func instanceFunc()
+
+ func makesSelfNonCanonical<T : Panda>(_: T) where T.Cuddles == Self
+}
+
+// CHECK-LABEL: sil hidden @$S21partial_apply_generic14getStaticFunc1{{[_0-9a-zA-Z]*}}F
+func getStaticFunc1<T: Foo>(t: T.Type) -> () -> () {
+// CHECK: [[REF:%.*]] = function_ref @$S21partial_apply_generic3FooP10staticFunc{{[_0-9a-zA-Z]*}}FZ
+// CHECK-NEXT: apply [[REF]]<T>(%0)
+ return t.staticFunc
+// CHECK-NEXT: return
+}
+
+// CHECK-LABEL: sil shared [thunk] @$S21partial_apply_generic3FooP10staticFunc{{[_0-9a-zA-Z]*}}FZ
+// CHECK: [[REF:%.*]] = witness_method $Self, #Foo.staticFunc!1
+// CHECK-NEXT: partial_apply [callee_guaranteed] [[REF]]<Self>(%0)
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil hidden @$S21partial_apply_generic14getStaticFunc2{{[_0-9a-zA-Z]*}}F
+func getStaticFunc2<T: Foo>(t: T) -> () -> () {
+// CHECK: [[REF:%.*]] = function_ref @$S21partial_apply_generic3FooP10staticFunc{{[_0-9a-zA-Z]*}}FZ
+// CHECK: apply [[REF]]<T>
+ return T.staticFunc
+// CHECK-NOT: destroy_addr %0 : $*T
+// CHECK-NEXT: return
+}
+
+// CHECK-LABEL: sil hidden @$S21partial_apply_generic16getInstanceFunc1{{[_0-9a-zA-Z]*}}F
+func getInstanceFunc1<T: Foo>(t: T) -> () -> () {
+// CHECK-NOT: alloc_stack $T
+// CHECK-NOT: copy_addr %0 to [initialization]
+// CHECK: [[REF:%.*]] = function_ref @$S21partial_apply_generic3FooP12instanceFunc{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: apply [[REF]]<T>
+ return t.instanceFunc
+// CHECK-NOT: dealloc_stack
+// CHECK-NOT: destroy_addr %0 : $*T
+// CHECK-NEXT: return
+}
+
+// CHECK-LABEL: sil shared [thunk] @$S21partial_apply_generic3FooP12instanceFunc{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[ARG:%.*]] : @trivial $*Self):
+// CHECK: [[REF:%.*]] = witness_method $Self, #Foo.instanceFunc!1
+// CHECK-NEXT: [[STACK:%.*]] = alloc_stack $Self
+// CHECK-NEXT: copy_addr [[ARG]] to [initialization] [[STACK]]
+// CHECK-NEXT: partial_apply [callee_guaranteed] [[REF]]<Self>([[STACK]])
+// CHECK-NEXT: dealloc_stack
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil hidden @$S21partial_apply_generic16getInstanceFunc2{{[_0-9a-zA-Z]*}}F
+func getInstanceFunc2<T: Foo>(t: T) -> (T) -> () -> () {
+// CHECK: [[REF:%.*]] = function_ref @$S21partial_apply_generic3FooP12instanceFunc{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: partial_apply [callee_guaranteed] [[REF]]<T>(
+ return T.instanceFunc
+// CHECK-NOT: destroy_addr %0 : $*
+// CHECK-NEXT: return
+}
+
+// CHECK-LABEL: sil hidden @$S21partial_apply_generic16getInstanceFunc3{{[_0-9a-zA-Z]*}}F
+func getInstanceFunc3<T: Foo>(t: T.Type) -> (T) -> () -> () {
+// CHECK: [[REF:%.*]] = function_ref @$S21partial_apply_generic3FooP12instanceFunc{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: partial_apply [callee_guaranteed] [[REF]]<T>(
+ return t.instanceFunc
+// CHECK-NEXT: return
+}
+
+// CHECK-LABEL: sil hidden @$S21partial_apply_generic23getNonCanonicalSelfFunc1tyq_cxcxm_t7CuddlesQy_RszAA5PandaR_r0_lF : $@convention(thin) <T, U where T == U.Cuddles, U : Panda> (@thick T.Type) -> @owned @callee_guaranteed (@in_guaranteed T) -> @owned @callee_guaranteed (@in_guaranteed U) -> () {
+func getNonCanonicalSelfFunc<T : Foo, U : Panda>(t: T.Type) -> (T) -> (U) -> () where U.Cuddles == T {
+// CHECK: [[REF:%.*]] = function_ref @$S21partial_apply_generic3FooP21makesSelfNonCanonicalyyqd__7CuddlesQyd__RszAA5PandaRd__lFTc : $@convention(thin) <τ_0_0><τ_1_0 where τ_0_0 == τ_1_0.Cuddles, τ_1_0 : Panda> (@in_guaranteed τ_0_0) -> @owned @callee_guaranteed (@in_guaranteed τ_1_0) -> ()
+// CHECK-NEXT: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[REF]]<T, U>()
+ return t.makesSelfNonCanonical
+// CHECK-NEXT: return [[CLOSURE]]
+}
+
+// curry thunk of Foo.makesSelfNonCanonical<A where ...> (A1) -> ()
+// CHECK-LABEL: sil shared [thunk] @$S21partial_apply_generic3FooP21makesSelfNonCanonicalyyqd__7CuddlesQyd__RszAA5PandaRd__lFTc : $@convention(thin) <Self><T where Self == T.Cuddles, T : Panda> (@in_guaranteed Self) -> @owned @callee_guaranteed (@in_guaranteed T) -> () {
+// CHECK: bb0([[ARG:%.*]] : @trivial $*Self):
+// CHECK: [[REF:%.*]] = witness_method $Self, #Foo.makesSelfNonCanonical!1 : <Self><T where Self == T.Cuddles, T : Panda> (Self) -> (T) -> () : $@convention(witness_method: Foo) <τ_0_0><τ_1_0 where τ_0_0 == τ_1_0.Cuddles, τ_1_0 : Panda> (@in_guaranteed τ_1_0, @in_guaranteed τ_0_0) -> ()
+// CHECK-NEXT: [[STACK:%.*]] = alloc_stack $Self
+// CHECK-NEXT: copy_addr [[ARG]] to [initialization] [[STACK]] : $*Self
+// CHECK-NEXT: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[REF]]<Self, T>([[STACK]])
+// CHECK-NEXT: dealloc_stack
+// CHECK-NEXT: return [[CLOSURE]]
diff --git a/test/SILGen/plus_zero_partial_apply_protocol.swift b/test/SILGen/plus_zero_partial_apply_protocol.swift
new file mode 100644
index 0000000..ba46add
--- /dev/null
+++ b/test/SILGen/plus_zero_partial_apply_protocol.swift
@@ -0,0 +1,159 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -emit-silgen -primary-file %s | %FileCheck %s
+// RUN: %target-swift-frontend -enable-sil-ownership -emit-ir -primary-file %s
+
+protocol Clonable {
+ func clone() -> Self
+ func maybeClone() -> Self?
+ func cloneMetatype() -> Self.Type
+ func getCloneFn() -> () -> Self
+
+ func genericClone<T>(t: T) -> Self
+ func genericGetCloneFn<T>(t: T) -> () -> Self
+}
+
+//===----------------------------------------------------------------------===//
+// Partial apply of methods returning Self-derived types
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: sil hidden @$S22partial_apply_protocol12testClonable1cyAA0E0_p_tF : $@convention(thin) (@in_guaranteed Clonable) -> ()
+func testClonable(c: Clonable) {
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$SxIegr_22partial_apply_protocol8Clonable_pIegr_AaBRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @out τ_0_0) -> @out Clonable
+ // CHECK: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<@opened("{{.*}}") Clonable>({{.*}})
+ let _: () -> Clonable = c.clone
+
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$SxSgIegr_22partial_apply_protocol8Clonable_pSgIegr_AbCRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @out Optional<τ_0_0>) -> @out Optional<Clonable>
+ // CHECK: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<@opened("{{.*}}") Clonable>({{.*}})
+ let _: () -> Clonable? = c.maybeClone
+
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$SxXMTIegd_22partial_apply_protocol8Clonable_pXmTIegd_AaBRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @thick τ_0_0.Type) -> @thick Clonable.Type
+ // CHECK: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<@opened("{{.*}}") Clonable>({{.*}}) : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @thick τ_0_0.Type) -> @thick Clonable.Type
+ let _: () -> Clonable.Type = c.cloneMetatype
+
+ // CHECK: [[METHOD_FN:%.*]] = witness_method $@opened("{{.*}}") Clonable, #Clonable.getCloneFn!1 : {{.*}}, {{.*}} : $*@opened("{{.*}}") Clonable : $@convention(witness_method: Clonable) <τ_0_0 where τ_0_0 : Clonable> (@in_guaranteed τ_0_0) -> @owned @callee_guaranteed () -> @out τ_0_0
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD_FN]]<@opened("{{.*}}") Clonable>({{.*}}) : $@convention(witness_method: Clonable) <τ_0_0 where τ_0_0 : Clonable> (@in_guaranteed τ_0_0) -> @owned @callee_guaranteed () -> @out τ_0_0
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$SxIegr_22partial_apply_protocol8Clonable_pIegr_AaBRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @out τ_0_0) -> @out Clonable
+ // CHECK: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<@opened("{{.*}}") Clonable>([[RESULT]])
+ let _: () -> Clonable = c.getCloneFn()
+
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$SxIegr_Iego_22partial_apply_protocol8Clonable_pIegr_Iego_AaBRzlTR
+ // CHECK: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<@opened("{{.*}}") Clonable>({{.*}})
+ let _: () -> () -> Clonable = c.getCloneFn
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SxIegr_22partial_apply_protocol8Clonable_pIegr_AaBRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @out τ_0_0) -> @out Clonable
+// CHECK: bb0(%0 : @trivial $*Clonable, %1 : @guaranteed $@callee_guaranteed () -> @out τ_0_0):
+// CHECK-NEXT: [[INNER_RESULT:%.*]] = alloc_stack $τ_0_0
+// CHECK-NEXT: apply %1([[INNER_RESULT]])
+// CHECK-NEXT: [[OUTER_RESULT:%.*]] = init_existential_addr %0
+// CHECK-NEXT: copy_addr [take] [[INNER_RESULT]] to [initialization] [[OUTER_RESULT]]
+// CHECK-NEXT: [[EMPTY:%.*]] = tuple ()
+// CHECK-NEXT: dealloc_stack [[INNER_RESULT]]
+// CHECK-NEXT: return [[EMPTY]]
+
+// FIXME: This is horribly inefficient, too much alloc_stack / copy_addr!
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SxSgIegr_22partial_apply_protocol8Clonable_pSgIegr_AbCRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @out Optional<τ_0_0>) -> @out Optional<Clonable>
+// CHECK: bb0(%0 : @trivial $*Optional<Clonable>, %1 : @guaranteed $@callee_guaranteed () -> @out Optional<τ_0_0>):
+// CHECK-NEXT: [[INNER_RESULT:%.*]] = alloc_stack $Optional<τ_0_0>
+// CHECK-NEXT: apply %1([[INNER_RESULT]])
+// CHECK-NEXT: [[OUTER_RESULT:%.*]] = alloc_stack $Optional<Clonable>
+// CHECK-NEXT: switch_enum_addr [[INNER_RESULT]] : $*Optional<{{.*}}>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]],
+// CHECK: [[SOME_BB]]:
+// CHECK-NEXT: [[INNER_RESULT_ADDR:%.*]] = unchecked_take_enum_data_addr [[INNER_RESULT]]
+// CHECK-NEXT: [[SOME_PAYLOAD:%.*]] = alloc_stack $Clonable
+// CHECK-NEXT: [[SOME_PAYLOAD_ADDR:%.*]] = init_existential_addr [[SOME_PAYLOAD]]
+// CHECK-NEXT: copy_addr [take] [[INNER_RESULT_ADDR]] to [initialization] [[SOME_PAYLOAD_ADDR]]
+// CHECK-NEXT: [[OUTER_RESULT_ADDR:%.*]] = init_enum_data_addr [[OUTER_RESULT]]
+// CHECK-NEXT: copy_addr [take] [[SOME_PAYLOAD]] to [initialization] [[OUTER_RESULT_ADDR]]
+// CHECK-NEXT: inject_enum_addr [[OUTER_RESULT]]
+// CHECK-NEXT: dealloc_stack [[SOME_PAYLOAD]]
+// CHECK-NEXT: br bb3
+// CHECK: bb2:
+// CHECK-NEXT: inject_enum_addr [[OUTER_RESULT]]
+// CHECK-NEXT: br bb3
+// CHECK: bb3:
+// CHECK-NEXT: copy_addr [take] [[OUTER_RESULT]] to [initialization] %0
+// CHECK-NEXT: [[EMPTY:%.*]] = tuple ()
+// CHECK-NEXT: dealloc_stack [[OUTER_RESULT]]
+// CHECK-NEXT: dealloc_stack [[INNER_RESULT]]
+// CHECK-NEXT: return [[EMPTY]]
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SxXMTIegd_22partial_apply_protocol8Clonable_pXmTIegd_AaBRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @thick τ_0_0.Type) -> @thick Clonable.Type
+// CHECK: bb0(%0 : @guaranteed $@callee_guaranteed () -> @thick τ_0_0.Type):
+// CHECK-NEXT: [[INNER_RESULT:%.*]] = apply %0()
+// CHECK-NEXT: [[OUTER_RESULT:%.*]] = init_existential_metatype [[INNER_RESULT]]
+// CHECK-NEXT: return [[OUTER_RESULT]]
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SxIegr_Iego_22partial_apply_protocol8Clonable_pIegr_Iego_AaBRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @owned @callee_guaranteed () -> @out τ_0_0) -> @owned @callee_guaranteed () -> @out Clonable
+// CHECK: bb0(%0 : @guaranteed $@callee_guaranteed () -> @owned @callee_guaranteed () -> @out τ_0_0):
+// CHECK-NEXT: [[INNER_RESULT:%.*]] = apply %0()
+// CHECK: [[THUNK_FN:%.*]] = function_ref @$SxIegr_22partial_apply_protocol8Clonable_pIegr_AaBRzlTR
+// CHECK-NEXT: [[OUTER_RESULT:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<τ_0_0>([[INNER_RESULT]])
+// CHECK-NEXT: return [[OUTER_RESULT]]
+
+//===----------------------------------------------------------------------===//
+// Partial apply of methods returning Self-derived types from generic context
+//
+// Make sure the thunk only has the context generic parameters if needed!
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: sil hidden @$S22partial_apply_protocol28testClonableInGenericContext1c1tyAA0E0_p_xtlF : $@convention(thin) <T> (@in_guaranteed Clonable, @in_guaranteed T) -> ()
+func testClonableInGenericContext<T>(c: Clonable, t: T) {
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$SxIegr_22partial_apply_protocol8Clonable_pIegr_AaBRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @out τ_0_0) -> @out Clonable
+ // CHECK: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<@opened("{{.*}}") Clonable>({{.*}})
+ let _: () -> Clonable = c.clone
+
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$SxSgIegr_22partial_apply_protocol8Clonable_pSgIegr_AbCRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @out Optional<τ_0_0>) -> @out Optional<Clonable>
+ // CHECK: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<@opened("{{.*}}") Clonable>({{.*}}) : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @out Optional<τ_0_0>) -> @out Optional<Clonable>
+ let _: () -> Clonable? = c.maybeClone
+
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$SxXMTIegd_22partial_apply_protocol8Clonable_pXmTIegd_AaBRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @thick τ_0_0.Type) -> @thick Clonable.Type
+ // CHECK: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<@opened("{{.*}}") Clonable>({{.*}}) : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @thick τ_0_0.Type) -> @thick Clonable.Type
+ let _: () -> Clonable.Type = c.cloneMetatype
+
+ // CHECK: [[METHOD_FN:%.*]] = witness_method $@opened("{{.*}}") Clonable, #Clonable.getCloneFn!1 : {{.*}}, {{.*}} : $*@opened("{{.*}}") Clonable : $@convention(witness_method: Clonable) <τ_0_0 where τ_0_0 : Clonable> (@in_guaranteed τ_0_0) -> @owned @callee_guaranteed () -> @out τ_0_0
+ // CHECK: [[RESULT:%.*]] = apply [[METHOD_FN]]<@opened("{{.*}}") Clonable>({{.*}}) : $@convention(witness_method: Clonable) <τ_0_0 where τ_0_0 : Clonable> (@in_guaranteed τ_0_0) -> @owned @callee_guaranteed () -> @out τ_0_0
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$SxIegr_22partial_apply_protocol8Clonable_pIegr_AaBRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @out τ_0_0) -> @out Clonable
+ // CHECK: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<@opened("{{.*}}") Clonable>([[RESULT]]) : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @out τ_0_0) -> @out Clonable
+ let _: () -> Clonable = c.getCloneFn()
+
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$SxIegr_Iego_22partial_apply_protocol8Clonable_pIegr_Iego_AaBRzlTR
+ // CHECK: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<@opened("{{.*}}") Clonable>({{.*}}) : $@convention(thin) <τ_0_0 where τ_0_0 : Clonable> (@guaranteed @callee_guaranteed () -> @owned @callee_guaranteed () -> @out τ_0_0) -> @owned @callee_guaranteed () -> @out Clonable
+ let _: () -> () -> Clonable = c.getCloneFn
+
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$Sxqd__Iegnr_x22partial_apply_protocol8Clonable_pIegnr_AaBRd__r__lTR : $@convention(thin) <τ_0_0><τ_1_0 where τ_1_0 : Clonable> (@in_guaranteed τ_0_0, @guaranteed @callee_guaranteed (@in_guaranteed τ_0_0) -> @out τ_1_0) -> @out Clonable
+ // CHECK: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<T, @opened("{{.*}}") Clonable>({{.*}}) : $@convention(thin) <τ_0_0><τ_1_0 where τ_1_0 : Clonable> (@in_guaranteed τ_0_0, @guaranteed @callee_guaranteed (@in_guaranteed τ_0_0) -> @out τ_1_0) -> @out Clonable
+ let _: (T) -> Clonable = c.genericClone
+
+ // CHECK: [[THUNK_FN:%.*]] = function_ref @$Sxqd__Iegr_Iegno_x22partial_apply_protocol8Clonable_pIegr_Iegno_AaBRd__r__lTR : $@convention(thin) <τ_0_0><τ_1_0 where τ_1_0 : Clonable> (@in_guaranteed τ_0_0, @guaranteed @callee_guaranteed (@in_guaranteed τ_0_0) -> @owned @callee_guaranteed () -> @out τ_1_0) -> @owned @callee_guaranteed () -> @out Clonable
+ // CHECK: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<T, @opened("{{.*}}") Clonable>({{.*}}) : $@convention(thin) <τ_0_0><τ_1_0 where τ_1_0 : Clonable> (@in_guaranteed τ_0_0, @guaranteed @callee_guaranteed (@in_guaranteed τ_0_0) -> @owned @callee_guaranteed () -> @out τ_1_0) -> @owned @callee_guaranteed () -> @out Clonable
+ let _: (T) -> () -> Clonable = c.genericGetCloneFn
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$Sxqd__Iegnr_x22partial_apply_protocol8Clonable_pIegnr_AaBRd__r__lTR : $@convention(thin) <τ_0_0><τ_1_0 where τ_1_0 : Clonable> (@in_guaranteed τ_0_0, @guaranteed @callee_guaranteed (@in_guaranteed τ_0_0) -> @out τ_1_0) -> @out Clonable
+// CHECK: bb0(%0 : @trivial $*Clonable, %1 : @trivial $*τ_0_0, %2 : @guaranteed $@callee_guaranteed (@in_guaranteed τ_0_0) -> @out τ_1_0):
+// CHECK-NEXT: [[INNER_RESULT:%.*]] = alloc_stack $τ_1_0
+// CHECK-NEXT: apply %2([[INNER_RESULT]], %1)
+// CHECK-NEXT: [[OUTER_RESULT:%.*]] = init_existential_addr %0
+// CHECK-NEXT: copy_addr [take] [[INNER_RESULT]] to [initialization] [[OUTER_RESULT]]
+// CHECK-NEXT: [[EMPTY:%.*]] = tuple ()
+// CHECK-NEXT: dealloc_stack [[INNER_RESULT]]
+// CHECK-NEXT: return [[EMPTY]]
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$Sxqd__Iegr_Iegno_x22partial_apply_protocol8Clonable_pIegr_Iegno_AaBRd__r__lTR : $@convention(thin) <τ_0_0><τ_1_0 where τ_1_0 : Clonable> (@in_guaranteed τ_0_0, @guaranteed @callee_guaranteed (@in_guaranteed τ_0_0) -> @owned @callee_guaranteed () -> @out τ_1_0) -> @owned @callee_guaranteed () -> @out Clonable
+// CHECK: bb0(%0 : @trivial $*τ_0_0, %1 : @guaranteed $@callee_guaranteed (@in_guaranteed τ_0_0) -> @owned @callee_guaranteed () -> @out τ_1_0):
+// CHECK-NEXT: [[RES:%.*]] = apply %1(%0)
+// CHECK: [[THUNK_FN:%.*]] = function_ref @$Sqd__Iegr_22partial_apply_protocol8Clonable_pIegr_AaBRd__r__lTR
+// CHECK-NEXT: [[RESULT:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<τ_0_0, τ_1_0>([[RES]])
+// CHECK-NEXT: return [[RESULT]]
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$Sqd__Iegr_22partial_apply_protocol8Clonable_pIegr_AaBRd__r__lTR : $@convention(thin) <τ_0_0><τ_1_0 where τ_1_0 : Clonable> (@guaranteed @callee_guaranteed () -> @out τ_1_0) -> @out Clonable {
+// CHECK: bb0(%0 : @trivial $*Clonable, %1 : @guaranteed $@callee_guaranteed () -> @out τ_1_0):
+// CHECK-NEXT: [[INNER_RESULT:%.*]] = alloc_stack $τ_1_0
+// CHECK-NEXT: apply %1([[INNER_RESULT]])
+// CHECK-NEXT: [[OUTER_RESULT:%.*]] = init_existential_addr %0
+// CHECK-NEXT: copy_addr [take] [[INNER_RESULT]] to [initialization] [[OUTER_RESULT]]
+// CHECK-NEXT: [[EMPTY:%.*]] = tuple ()
+// CHECK-NEXT: dealloc_stack [[INNER_RESULT:%.*]]
+// CHECK-NEXT: return [[EMPTY]]
diff --git a/test/SILGen/plus_zero_partial_apply_protocol_class_refinement_method.swift b/test/SILGen/plus_zero_partial_apply_protocol_class_refinement_method.swift
new file mode 100644
index 0000000..ec4c8be
--- /dev/null
+++ b/test/SILGen/plus_zero_partial_apply_protocol_class_refinement_method.swift
@@ -0,0 +1,16 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+protocol P { func foo() }
+protocol Q: class, P {}
+
+// CHECK-LABEL: sil hidden @$S46partial_apply_protocol_class_refinement_method0A5ApplyyyycAA1Q_pF : $@convention
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Q):
+func partialApply(_ q: Q) -> () -> () {
+ // CHECK: [[OPENED:%.*]] = open_existential_ref [[ARG]]
+ // CHECK: [[TMP:%.*]] = alloc_stack
+ // CHECK: store_borrow [[OPENED]] to [[TMP:%.*]] :
+ // CHECK: apply {{%.*}}<{{.*}}>([[TMP]])
+ // CHECK-NEXT: dealloc_stack [[TMP]]
+ return q.foo
+}
diff --git a/test/SILGen/plus_zero_partial_apply_super.swift b/test/SILGen/plus_zero_partial_apply_super.swift
new file mode 100644
index 0000000..0a823f1
--- /dev/null
+++ b/test/SILGen/plus_zero_partial_apply_super.swift
@@ -0,0 +1,320 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -enable-sil-ownership -I %t -emit-module -emit-module-path=%t/resilient_struct.swiftmodule -module-name resilient_struct %S/../Inputs/resilient_struct.swift
+// RUN: %target-swift-frontend -enable-sil-ownership -I %t -emit-module -emit-module-path=%t/resilient_class.swiftmodule -module-name resilient_class %S/../Inputs/resilient_class.swift
+// RUN: %target-swift-frontend -enable-sil-ownership -enable-resilience -emit-silgen -parse-as-library -I %t %s | %FileCheck %s
+
+import resilient_class
+
+func doFoo(_ f: () -> ()) {
+ f()
+}
+
+public class Parent {
+ public init() {}
+ public func method() {}
+ public final func finalMethod() {}
+ public class func classMethod() {}
+ public final class func finalClassMethod() {}
+}
+
+public class GenericParent<A> {
+ let a: A
+ public init(a: A) {
+ self.a = a
+ }
+ public func method() {}
+ public final func finalMethod() {}
+ public class func classMethod() {}
+ public final class func finalClassMethod() {}
+}
+
+class Child : Parent {
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super5ChildC6methodyyF : $@convention(method) (@guaranteed Child) -> ()
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $Child):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = upcast [[SELF_COPY]] : $Child to $Parent
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[SUPER_METHOD:%.*]] = function_ref @$S19partial_apply_super6ParentC6methodyyFTcTd : $@convention(thin) (@guaranteed Parent) -> @owned @callee_guaranteed () -> ()
+ // CHECK: [[PARTIAL_APPLY:%.*]] = apply [[SUPER_METHOD]]([[BORROWED_CASTED_SELF_COPY]]) : $@convention(thin) (@guaranteed Parent) -> @owned @callee_guaranteed () -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super5ChildC6methodyyF'
+ override func method() {
+ doFoo(super.method)
+ }
+
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super5ChildC11classMethodyyFZ : $@convention(method) (@thick Child.Type) -> () {
+ // CHECK: [[CASTED_SELF:%.*]] = upcast %0 : $@thick Child.Type to $@thick Parent.Type
+ // CHECK: [[SUPER_METHOD:%.*]] = function_ref @$S19partial_apply_super6ParentC11classMethodyyFZTcTd : $@convention(thin) (@thick Parent.Type) -> @owned @callee_guaranteed () -> ()
+ // CHECK: [[PARTIAL_APPLY:%.*]] = apply [[SUPER_METHOD]]([[CASTED_SELF]]) : $@convention(thin) (@thick Parent.Type) -> @owned @callee_guaranteed () -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super5ChildC11classMethodyyFZ'
+ override class func classMethod() {
+ doFoo(super.classMethod)
+ }
+
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super5ChildC20callFinalSuperMethodyyF : $@convention(method) (@guaranteed Child) -> ()
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $Child):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = upcast [[SELF_COPY]] : $Child to $Parent
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[SUPER_METHOD:%.*]] = function_ref @$S19partial_apply_super6ParentC11finalMethodyyFTc : $@convention(thin) (@guaranteed Parent) -> @owned @callee_guaranteed () -> ()
+ // CHECK: [[APPLIED_SELF:%.*]] = apply [[SUPER_METHOD]]([[BORROWED_CASTED_SELF_COPY]]) : $@convention(thin) (@guaranteed Parent) -> @owned @callee_guaranteed () -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[APPLIED_SELF]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super5ChildC20callFinalSuperMethodyyF'
+ func callFinalSuperMethod() {
+ doFoo(super.finalMethod)
+ }
+
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super5ChildC25callFinalSuperClassMethodyyFZ : $@convention(method) (@thick Child.Type) -> ()
+ // CHECK: bb0([[ARG:%.*]] : @trivial $@thick Child.Type):
+ // CHECK: [[CASTED_SELF:%.*]] = upcast [[ARG]] : $@thick Child.Type to $@thick Parent.Type
+ // CHECK: [[SUPER_METHOD:%.*]] = function_ref @$S19partial_apply_super6ParentC16finalClassMethodyyFZTc : $@convention(thin) (@thick Parent.Type) -> @owned @callee_guaranteed () -> ()
+ // CHECK: [[APPLIED_SELF:%.*]] = apply [[SUPER_METHOD]]([[CASTED_SELF]]) : $@convention(thin) (@thick Parent.Type) -> @owned @callee_guaranteed () -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[APPLIED_SELF]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super5ChildC25callFinalSuperClassMethodyyFZ'
+ class func callFinalSuperClassMethod() {
+ doFoo(super.finalClassMethod)
+ }
+}
+
+class GenericChild<A> : GenericParent<A> {
+ override init(a: A) {
+ super.init(a: a)
+ }
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super12GenericChildC6methodyyF : $@convention(method) <A> (@guaranteed GenericChild<A>) -> ()
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $GenericChild<A>):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = upcast [[SELF_COPY]] : $GenericChild<A> to $GenericParent<A>
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[SUPER_METHOD:%.*]] = function_ref @$S19partial_apply_super13GenericParentC6methodyyFTcTd : $@convention(thin) <τ_0_0> (@guaranteed GenericParent<τ_0_0>) -> @owned @callee_guaranteed () -> ()
+ // CHECK: [[PARTIAL_APPLY:%.*]] = apply [[SUPER_METHOD]]<A>([[BORROWED_CASTED_SELF_COPY]]) : $@convention(thin) <τ_0_0> (@guaranteed GenericParent<τ_0_0>) -> @owned @callee_guaranteed () -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super12GenericChildC6methodyyF'
+ override func method() {
+ doFoo(super.method)
+ }
+
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super12GenericChildC11classMethodyyFZ : $@convention(method) <A> (@thick GenericChild<A>.Type) -> ()
+ // CHECK: [[CASTED_SELF:%.*]] = upcast %0 : $@thick GenericChild<A>.Type to $@thick GenericParent<A>.Type
+ // CHECK: [[SUPER_METHOD:%.*]] = function_ref @$S19partial_apply_super13GenericParentC11classMethodyyFZTcTd : $@convention(thin) <τ_0_0> (@thick GenericParent<τ_0_0>.Type) -> @owned @callee_guaranteed () -> ()
+ // CHECK: [[PARTIAL_APPLY:%.*]] = apply [[SUPER_METHOD]]<A>([[CASTED_SELF]]) : $@convention(thin) <τ_0_0> (@thick GenericParent<τ_0_0>.Type) -> @owned @callee_guaranteed () -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super12GenericChildC11classMethodyyFZ'
+ override class func classMethod() {
+ doFoo(super.classMethod)
+ }
+}
+
+class ChildToFixedOutsideParent : OutsideParent {
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super25ChildToFixedOutsideParentC6methodyyF
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $ChildToFixedOutsideParent):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = upcast [[SELF_COPY]] : $ChildToFixedOutsideParent to $OutsideParent
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = copy_value [[BORROWED_CASTED_SELF_COPY]]
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[DOWNCAST_BORROWED_CASTED_SELF_COPY:%.*]] = unchecked_ref_cast [[BORROWED_CASTED_SELF_COPY]]
+ // Semantic SIL TODO: This super_method used to take
+ // ChildToFixedOutsideParent. Since super_method IIRC goes through
+ // objc_runtime, this shouldn't matter, but we should look into it before we
+ // turn on +0.
+ // CHECK: [[SUPER_METHOD:%.*]] = super_method [[DOWNCAST_BORROWED_CASTED_SELF_COPY]] : $OutsideParent, #OutsideParent.method!1 : (OutsideParent) -> () -> (), $@convention(method) (@guaranteed OutsideParent) -> ()
+ // CHECK: [[PARTIAL_APPLY:%.*]] = partial_apply [callee_guaranteed] [[SUPER_METHOD]]([[CASTED_SELF_COPY]]) : $@convention(method) (@guaranteed OutsideParent) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super25ChildToFixedOutsideParentC6methodyyF'
+ override func method() {
+ doFoo(super.method)
+ }
+
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super25ChildToFixedOutsideParentC11classMethodyyFZ
+ // CHECK: [[CASTED_SELF:%.*]] = upcast %0 : $@thick ChildToFixedOutsideParent.Type to $@thick OutsideParent.Type
+ // CHECK: [[SUPER_METHOD:%.*]] = super_method %0 : $@thick ChildToFixedOutsideParent.Type, #OutsideParent.classMethod!1 : (OutsideParent.Type) -> () -> (), $@convention(method) (@thick OutsideParent.Type) -> (){{.*}}
+ // CHECK: [[PARTIAL_APPLY:%.*]] = partial_apply [callee_guaranteed] [[SUPER_METHOD]]([[CASTED_SELF]]) : $@convention(method) (@thick OutsideParent.Type) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super25ChildToFixedOutsideParentC11classMethodyyFZ'
+ override class func classMethod() {
+ doFoo(super.classMethod)
+ }
+}
+
+class ChildToResilientOutsideParent : ResilientOutsideParent {
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super29ChildToResilientOutsideParentC6methodyyF : $@convention
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $ChildToResilientOutsideParent):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = upcast [[SELF_COPY]] : $ChildToResilientOutsideParent to $ResilientOutsideParent
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = copy_value [[BORROWED_CASTED_SELF_COPY]]
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[DOWNCAST_BORROWED_CASTED_SELF_COPY:%.*]] = unchecked_ref_cast [[BORROWED_CASTED_SELF_COPY]]
+ // CHECK: [[SUPER_METHOD:%.*]] = super_method [[DOWNCAST_BORROWED_CASTED_SELF_COPY]] : $ResilientOutsideParent, #ResilientOutsideParent.method!1 : (ResilientOutsideParent) -> () -> (), $@convention(method) (@guaranteed ResilientOutsideParent) -> ()
+ // CHECK: end_borrow [[BORROWED_CASTED_SELF_COPY]] from [[CASTED_SELF_COPY]]
+ // CHECK: [[PARTIAL_APPLY:%.*]] = partial_apply [callee_guaranteed] [[SUPER_METHOD]]([[CASTED_SELF_COPY]]) : $@convention(method) (@guaranteed ResilientOutsideParent) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super29ChildToResilientOutsideParentC6methodyyF'
+ override func method() {
+ doFoo(super.method)
+ }
+
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super29ChildToResilientOutsideParentC11classMethodyyFZ
+ // CHECK: [[CASTED_SELF:%.*]] = upcast %0 : $@thick ChildToResilientOutsideParent.Type to $@thick ResilientOutsideParent.Type
+ // CHECK: [[SUPER_METHOD:%.*]] = super_method %0 : $@thick ChildToResilientOutsideParent.Type, #ResilientOutsideParent.classMethod!1 : (ResilientOutsideParent.Type) -> () -> (), $@convention(method) (@thick ResilientOutsideParent.Type) -> ()
+ // CHECK: [[PARTIAL_APPLY:%.*]] = partial_apply [callee_guaranteed] [[SUPER_METHOD]]([[CASTED_SELF]]) : $@convention(method) (@thick ResilientOutsideParent.Type) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super29ChildToResilientOutsideParentC11classMethodyyFZ'
+ override class func classMethod() {
+ doFoo(super.classMethod)
+ }
+}
+
+class GrandchildToFixedOutsideChild : OutsideChild {
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super29GrandchildToFixedOutsideChildC6methodyyF
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $GrandchildToFixedOutsideChild):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = upcast [[SELF_COPY]] : $GrandchildToFixedOutsideChild to $OutsideChild
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = copy_value [[BORROWED_CASTED_SELF_COPY]]
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[DOWNCAST_BORROWED_CASTED_SELF_COPY:%.*]] = unchecked_ref_cast [[BORROWED_CASTED_SELF_COPY]]
+ // CHECK: [[SUPER_METHOD:%.*]] = super_method [[DOWNCAST_BORROWED_CASTED_SELF_COPY]] : $OutsideChild, #OutsideChild.method!1 : (OutsideChild) -> () -> (), $@convention(method) (@guaranteed OutsideChild) -> ()
+ // CHECK: end_borrow [[BORROWED_CASTED_SELF_COPY]] from [[CASTED_SELF_COPY]]
+ // CHECK: [[PARTIAL_APPLY:%.*]] = partial_apply [callee_guaranteed] [[SUPER_METHOD]]([[CASTED_SELF_COPY]]) : $@convention(method) (@guaranteed OutsideChild) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super29GrandchildToFixedOutsideChildC6methodyyF'
+ override func method() {
+ doFoo(super.method)
+ }
+
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super29GrandchildToFixedOutsideChildC11classMethodyyFZ
+ // CHECK: [[CASTED_SELF:%.*]] = upcast %0 : $@thick GrandchildToFixedOutsideChild.Type to $@thick OutsideChild.Type
+ // CHECK: [[SUPER_METHOD:%.*]] = super_method %0 : $@thick GrandchildToFixedOutsideChild.Type, #OutsideChild.classMethod!1 : (OutsideChild.Type) -> () -> (), $@convention(method) (@thick OutsideChild.Type) -> ()
+ // CHECK: [[PARTIAL_APPLY:%.*]] = partial_apply [callee_guaranteed] [[SUPER_METHOD]]([[CASTED_SELF]]) : $@convention(method) (@thick OutsideChild.Type) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super29GrandchildToFixedOutsideChildC11classMethodyyFZ'
+ override class func classMethod() {
+ doFoo(super.classMethod)
+ }
+}
+
+class GrandchildToResilientOutsideChild : ResilientOutsideChild {
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super33GrandchildToResilientOutsideChildC6methodyyF
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $GrandchildToResilientOutsideChild):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = upcast [[SELF_COPY]] : $GrandchildToResilientOutsideChild to $ResilientOutsideChild
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = copy_value [[BORROWED_CASTED_SELF_COPY]]
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[DOWNCAST_BORROWED_CASTED_SELF_COPY:%.*]] = unchecked_ref_cast [[BORROWED_CASTED_SELF_COPY]]
+ // CHECK: [[SUPER_METHOD:%.*]] = super_method [[DOWNCAST_BORROWED_CASTED_SELF_COPY]] : $ResilientOutsideChild, #ResilientOutsideChild.method!1 : (ResilientOutsideChild) -> () -> (), $@convention(method) (@guaranteed ResilientOutsideChild) -> ()
+ // CHEC: end_borrow [[BORROWED_CASTED_SELF_COPY]] from [[CASTED_SELF_COPY]]
+ // CHECK: [[PARTIAL_APPLY:%.*]] = partial_apply [callee_guaranteed] [[SUPER_METHOD]]([[CASTED_SELF_COPY]]) : $@convention(method) (@guaranteed ResilientOutsideChild) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super33GrandchildToResilientOutsideChildC6methodyyF'
+ override func method() {
+ doFoo(super.method)
+ }
+
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super33GrandchildToResilientOutsideChildC11classMethodyyFZ
+ // CHECK: [[CASTED_SELF:%.*]] = upcast %0 : $@thick GrandchildToResilientOutsideChild.Type to $@thick ResilientOutsideChild.Type
+ // CHECK: [[SUPER_METHOD:%.*]] = super_method %0 : $@thick GrandchildToResilientOutsideChild.Type, #ResilientOutsideChild.classMethod!1 : (ResilientOutsideChild.Type) -> () -> (), $@convention(method) (@thick ResilientOutsideChild.Type) -> ()
+ // CHECK: [[PARTIAL_APPLY:%.*]] = partial_apply [callee_guaranteed] [[SUPER_METHOD]]([[CASTED_SELF]]) : $@convention(method) (@thick ResilientOutsideChild.Type) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super33GrandchildToResilientOutsideChildC11classMethodyyFZ'
+ override class func classMethod() {
+ doFoo(super.classMethod)
+ }
+}
+
+class GenericChildToFixedGenericOutsideParent<A> : GenericOutsideParent<A> {
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super019GenericChildToFixedD13OutsideParentC6methodyyF
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $GenericChildToFixedGenericOutsideParent<A>):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = upcast [[SELF_COPY]] : $GenericChildToFixedGenericOutsideParent<A> to $GenericOutsideParent<A>
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = copy_value [[BORROWED_CASTED_SELF_COPY]]
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[DOWNCAST_BORROWED_CASTED_SELF_COPY:%.*]] = unchecked_ref_cast [[BORROWED_CASTED_SELF_COPY]]
+ // CHECK: [[SUPER_METHOD:%.*]] = super_method [[DOWNCAST_BORROWED_CASTED_SELF_COPY]] : $GenericOutsideParent<A>, #GenericOutsideParent.method!1 : <A> (GenericOutsideParent<A>) -> () -> (), $@convention(method) <τ_0_0> (@guaranteed GenericOutsideParent<τ_0_0>) -> ()
+ // CHECK: end_borrow [[BORROWED_CASTED_SELF_COPY]] from [[CASTED_SELF_COPY]]
+ // CHECK: [[PARTIAL_APPLY:%.*]] = partial_apply [callee_guaranteed] [[SUPER_METHOD]]<A>([[CASTED_SELF_COPY]]) : $@convention(method) <τ_0_0> (@guaranteed GenericOutsideParent<τ_0_0>) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super019GenericChildToFixedD13OutsideParentC6methodyyF'
+ override func method() {
+ doFoo(super.method)
+ }
+
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super019GenericChildToFixedD13OutsideParentC11classMethodyyFZ
+ // CHECK: [[CASTED_SELF:%.*]] = upcast %0 : $@thick GenericChildToFixedGenericOutsideParent<A>.Type to $@thick GenericOutsideParent<A>.Type
+ // CHECK: [[SUPER_METHOD:%.*]] = super_method %0 : $@thick GenericChildToFixedGenericOutsideParent<A>.Type, #GenericOutsideParent.classMethod!1 : <A> (GenericOutsideParent<A>.Type) -> () -> (), $@convention(method) <τ_0_0> (@thick GenericOutsideParent<τ_0_0>.Type) -> ()
+ // CHECK: [[PARTIAL_APPLY:%.*]] = partial_apply [callee_guaranteed] [[SUPER_METHOD]]<A>([[CASTED_SELF]]) : $@convention(method) <τ_0_0> (@thick GenericOutsideParent<τ_0_0>.Type) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super019GenericChildToFixedD13OutsideParentC11classMethodyyFZ'
+ override class func classMethod() {
+ doFoo(super.classMethod)
+ }
+}
+
+class GenericChildToResilientGenericOutsideParent<A> : ResilientGenericOutsideParent<A> {
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super023GenericChildToResilientD13OutsideParentC6methodyyF
+ // CHECK: bb0([[SELF:%.*]] : @guaranteed $GenericChildToResilientGenericOutsideParent<A>):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = upcast [[SELF_COPY]] : $GenericChildToResilientGenericOutsideParent<A> to $ResilientGenericOutsideParent<A>
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[CASTED_SELF_COPY:%.*]] = copy_value [[BORROWED_CASTED_SELF_COPY]]
+ // CHECK: [[BORROWED_CASTED_SELF_COPY:%.*]] = begin_borrow [[CASTED_SELF_COPY]]
+ // CHECK: [[DOWNCAST_BORROWED_CASTED_SELF_COPY:%.*]] = unchecked_ref_cast [[BORROWED_CASTED_SELF_COPY]]
+ // CHECK: [[SUPER_METHOD:%.*]] = super_method [[DOWNCAST_BORROWED_CASTED_SELF_COPY]] : $ResilientGenericOutsideParent<A>, #ResilientGenericOutsideParent.method!1 : <A> (ResilientGenericOutsideParent<A>) -> () -> (), $@convention(method) <τ_0_0> (@guaranteed ResilientGenericOutsideParent<τ_0_0>) -> ()
+ // CHECK: end_borrow [[BORROWED_CASTED_SELF_COPY]] from [[CASTED_SELF_COPY]]
+ // CHECK: [[PARTIAL_APPLY:%.*]] = partial_apply [callee_guaranteed] [[SUPER_METHOD]]<A>([[CASTED_SELF_COPY]]) : $@convention(method) <τ_0_0> (@guaranteed ResilientGenericOutsideParent<τ_0_0>) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super023GenericChildToResilientD13OutsideParentC6methodyyF'
+ override func method() {
+ doFoo(super.method)
+ }
+
+ // CHECK-LABEL: sil hidden @$S19partial_apply_super023GenericChildToResilientD13OutsideParentC11classMethodyyFZ
+ // CHECK: [[CASTED_SELF:%.*]] = upcast %0 : $@thick GenericChildToResilientGenericOutsideParent<A>.Type to $@thick ResilientGenericOutsideParent<A>.Type
+ // CHECK: [[SUPER_METHOD:%.*]] = super_method %0 : $@thick GenericChildToResilientGenericOutsideParent<A>.Type, #ResilientGenericOutsideParent.classMethod!1 : <A> (ResilientGenericOutsideParent<A>.Type) -> () -> (), $@convention(method) <τ_0_0> (@thick ResilientGenericOutsideParent<τ_0_0>.Type) -> ()
+ // CHECK: [[PARTIAL_APPLY:%.*]] = partial_apply [callee_guaranteed] [[SUPER_METHOD]]<A>([[CASTED_SELF]]) : $@convention(method) <τ_0_0> (@thick ResilientGenericOutsideParent<τ_0_0>.Type) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[PARTIAL_APPLY]]
+ // CHECK: [[DOFOO:%.*]] = function_ref @$S19partial_apply_super5doFooyyyyXEF : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: apply [[DOFOO]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+ // CHECK: } // end sil function '$S19partial_apply_super023GenericChildToResilientD13OutsideParentC11classMethodyyFZ'
+ override class func classMethod() {
+ doFoo(super.classMethod)
+ }
+}
diff --git a/test/SILGen/plus_zero_pgo_checked_cast.swift b/test/SILGen/plus_zero_pgo_checked_cast.swift
new file mode 100644
index 0000000..a479e87
--- /dev/null
+++ b/test/SILGen/plus_zero_pgo_checked_cast.swift
@@ -0,0 +1,72 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift %s -profile-generate -Xfrontend -disable-incremental-llvm-codegen -module-name pgo_checked_cast -o %t/main
+// RUN: env LLVM_PROFILE_FILE=%t/default.profraw %target-run %t/main
+// RUN: %llvm-profdata merge %t/default.profraw -o %t/default.profdata
+// RUN: %target-swift-frontend %s -Xllvm -sil-full-demangle -profile-use=%t/default.profdata -emit-sorted-sil -emit-sil -module-name pgo_checked_cast -o - | %FileCheck %s --check-prefix=SIL
+// need to lower checked_cast_addr_br(addr) into IR for this
+// %target-swift-frontend %s -Xllvm -sil-full-demangle -profile-use=%t/default.profdata -emit-ir -module-name pgo_checked_cast -o - | %FileCheck %s --check-prefix=IR
+// RUN: %target-swift-frontend %s -Xllvm -sil-full-demangle -profile-use=%t/default.profdata -O -emit-sorted-sil -emit-sil -module-name pgo_checked_cast -o - | %FileCheck %s --check-prefix=SIL-OPT
+// need to lower checked_cast_addr_br(addr) into IR for this
+// %target-swift-frontend %s -Xllvm -sil-full-demangle -profile-use=%t/default.profdata -O -emit-ir -module-name pgo_checked_cast -o - | %FileCheck %s --check-prefix=IR-OPT
+
+// REQUIRES: profile_runtime
+// REQUIRES: OS=macosx
+
+// SIL-LABEL: // pgo_checked_cast.check1<A>(Any, A) -> A
+// SIL-LABEL: sil @$S16pgo_checked_cast6check1yxyp_xtlF : $@convention(thin) <T> (@in_guaranteed Any, @in_guaranteed T) -> @out T !function_entry_count(5001) {
+// IR-LABEL: define swiftcc i32 @$S6pgo_checked_cast6guess1s5Int32VAD1x_tF
+// IR-OPT-LABEL: define swiftcc i32 @$S6pgo_checked_cast6guess1s5Int32VAD1x_tF
+public func check1<T>(_ a : Any, _ t : T) -> T {
+ // SIL: checked_cast_addr_br take_always Any in {{.*}} : $*Any to T in {{.*}} : $*T, {{.*}}, {{.*}} !true_count(5000) !false_count(1)
+ // SIL-OPT: checked_cast_addr_br take_always Any in {{.*}} : $*Any to T in {{.*}} : $*T, {{.*}}, {{.*}} !true_count(5000) !false_count(1)
+ if let x = a as? T {
+ return x
+ } else {
+ return t
+ }
+}
+
+public class B {}
+public class C : B {}
+public class D : C {}
+
+// SIL-LABEL: // pgo_checked_cast.check2(pgo_checked_cast.B) -> Swift.Int32
+// SIL-LABEL: sil @$S16pgo_checked_cast6check2ys5Int32VAA1BCF : $@convention(thin) (@guaranteed B) -> Int32 !function_entry_count(5003) {
+// IR-LABEL: define swiftcc i32 @$S6pgo_checked_cast6guess1s5Int32VAD1x_tF
+// IR-OPT-LABEL: define swiftcc i32 @$S6pgo_checked_cast6guess1s5Int32VAD1x_tF
+public func check2(_ a : B) -> Int32 {
+ // SIL: checked_cast_br %0 : $B to $D, {{.*}}, {{.*}} !true_count(5000)
+ // SIL: checked_cast_br %0 : $B to $C, {{.*}}, {{.*}} !true_count(2)
+ // SIL-OPT: checked_cast_br %0 : $B to $D, {{.*}}, {{.*}} !true_count(5000)
+ // SIL-OPT: checked_cast_br %0 : $B to $C, {{.*}}, {{.*}} !true_count(2)
+ switch a {
+ case is D:
+ return 42
+ case is C:
+ return 23
+ default:
+ return 13
+ }
+}
+
+func main() {
+ let answer : Int32 = 42
+ var sum : Int32 = 0
+
+ sum += check1("The answer to the life, the universe, and everything", answer)
+
+ sum += check2(B())
+ sum += check2(C())
+ sum += check2(C())
+
+ for i : Int32 in 1...5000 {
+ sum += check1(i, answer)
+ sum += check2(D())
+ }
+}
+
+main()
+
+// IR: !{!"branch_weights", i32 5001, i32 2}
+// IR-OPT: !{!"branch_weights", i32 5001, i32 2}
diff --git a/test/SILGen/plus_zero_pgo_switchenum.swift b/test/SILGen/plus_zero_pgo_switchenum.swift
new file mode 100644
index 0000000..405912d
--- /dev/null
+++ b/test/SILGen/plus_zero_pgo_switchenum.swift
@@ -0,0 +1,100 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift %s -Xfrontend -enable-sil-ownership -profile-generate -Xfrontend -disable-incremental-llvm-codegen -module-name pgo_switchenum -o %t/main
+// RUN: env LLVM_PROFILE_FILE=%t/default.profraw %target-run %t/main
+// RUN: %llvm-profdata merge %t/default.profraw -o %t/default.profdata
+// need to move counts attached to expr for this
+// RUN: %target-swift-frontend %s -Xllvm -sil-full-demangle -profile-use=%t/default.profdata -enable-sil-ownership -emit-sorted-sil -emit-sil -module-name pgo_switchenum -o - | %FileCheck %s --check-prefix=SIL
+// need to lower switch_enum(addr) into IR for this
+// %target-swift-frontend %s -enable-sil-ownership -Xllvm -sil-full-demangle -profile-use=%t/default.profdata -emit-ir -module-name pgo_switchenum -o - | %FileCheck %s --check-prefix=IR
+// need to check Opt support
+// %target-swift-frontend %s -enable-sil-ownership -Xllvm -sil-full-demangle -profile-use=%t/default.profdata -O -emit-sorted-sil -emit-sil -module-name pgo_switchenum -o - | %FileCheck %s --check-prefix=SIL-OPT
+// need to lower switch_enum(addr) into IR for this
+// %target-swift-frontend -enable-sil-ownership %s -Xllvm -sil-full-demangle -profile-use=%t/default.profdata -O -emit-ir -module-name pgo_switchenum -o - | %FileCheck %s --check-prefix=IR-OPT
+
+// REQUIRES: profile_runtime
+// REQUIRES: OS=macosx
+
+public enum MaybePair {
+ case Neither
+ case Left(Int32)
+ case Right(String)
+ case Both(Int32, String)
+}
+
+// SIL-LABEL: // pgo_switchenum.guess1
+// SIL-LABEL: sil @$S14pgo_switchenum6guess11xs5Int32VAA9MaybePairO_tF : $@convention(thin) (@guaranteed MaybePair) -> Int32 !function_entry_count(5011) {
+// IR-LABEL: define swiftcc i32 @$S9pgo_switchenum6guess1s5Int32VAD1x_tF
+// IR-OPT-LABEL: define swiftcc i32 @$S9pgo_switchenum6guess1s5Int32VAD1x_tF
+
+public func guess1(x: MaybePair) -> Int32 {
+ // SIL: switch_enum {{.*}} : $MaybePair, case #MaybePair.Neither!enumelt: {{.*}} !case_count(2), case #MaybePair.Left!enumelt.1: {{.*}} !case_count(5001), case #MaybePair.Right!enumelt.1: {{.*}} !case_count(3), case #MaybePair.Both!enumelt.1: {{.*}} !case_count(5)
+ // SIL-OPT: switch_enum {{.*}} : $MaybePair, case #MaybePair.Neither!enumelt: {{.*}} !case_count(2), case #MaybePair.Left!enumelt.1: {{.*}} !case_count(5001), case #MaybePair.Right!enumelt.1: {{.*}} !case_count(3), case #MaybePair.Both!enumelt.1: {{.*}} !case_count(5)
+ switch x {
+ case .Neither:
+ return 1
+ case let .Left(val):
+ return val*2
+ case let .Right(val):
+ return Int32(val.count)
+ case let .Both(valNum, valStr):
+ return valNum + Int32(valStr.count)
+ }
+}
+
+// SIL-LABEL: // pgo_switchenum.guess2
+// SIL-LABEL: sil @$S14pgo_switchenum6guess21xs5Int32VAA9MaybePairO_tF : $@convention(thin) (@guaranteed MaybePair) -> Int32 !function_entry_count(5011) {
+public func guess2(x: MaybePair) -> Int32 {
+ // SIL: switch_enum {{.*}} : $MaybePair, case #MaybePair.Neither!enumelt: {{.*}} !case_count(2), case #MaybePair.Left!enumelt.1: {{.*}} !case_count(5001), default {{.*}} !default_count(8)
+ // SIL-OPT: switch_enum {{.*}} : $MaybePair, case #MaybePair.Neither!enumelt: {{.*}} !case_count(2), case #MaybePair.Left!enumelt.1: {{.*}} !case_count(5001), default {{.*}} !default_count(8)
+ switch x {
+ case .Neither:
+ return 1
+ case let .Left(val):
+ return val*2
+ default:
+ return 42;
+ }
+}
+
+
+func main() {
+ var guesses : Int32 = 0;
+
+ guesses += guess1(x: MaybePair.Neither)
+ guesses += guess1(x: MaybePair.Neither)
+ guesses += guess1(x: MaybePair.Left(42))
+ guesses += guess1(x: MaybePair.Right("The Answer"))
+ guesses += guess1(x: MaybePair.Right("The Answer"))
+ guesses += guess1(x: MaybePair.Right("The Answer"))
+ guesses += guess1(x: MaybePair.Both(42, "The Answer"))
+ guesses += guess1(x: MaybePair.Both(42, "The Answer"))
+ guesses += guess1(x: MaybePair.Both(42, "The Answer"))
+ guesses += guess1(x: MaybePair.Both(42, "The Answer"))
+ guesses += guess1(x: MaybePair.Both(42, "The Answer"))
+
+ for _ in 1...5000 {
+ guesses += guess1(x: MaybePair.Left(10))
+ }
+
+ guesses += guess2(x: MaybePair.Neither)
+ guesses += guess2(x: MaybePair.Neither)
+ guesses += guess2(x: MaybePair.Left(42))
+ guesses += guess2(x: MaybePair.Right("The Answer"))
+ guesses += guess2(x: MaybePair.Right("The Answer"))
+ guesses += guess2(x: MaybePair.Right("The Answer"))
+ guesses += guess2(x: MaybePair.Both(42, "The Answer"))
+ guesses += guess2(x: MaybePair.Both(42, "The Answer"))
+ guesses += guess2(x: MaybePair.Both(42, "The Answer"))
+ guesses += guess2(x: MaybePair.Both(42, "The Answer"))
+ guesses += guess2(x: MaybePair.Both(42, "The Answer"))
+
+ for _ in 1...5000 {
+ guesses += guess2(x: MaybePair.Left(10))
+ }
+}
+
+main()
+
+// IR: !{!"branch_weights", i32 5001, i32 3}
+// IR-OPT: !{!"branch_weights", i32 5001, i32 3}
diff --git a/test/SILGen/plus_zero_pointer_conversion.swift b/test/SILGen/plus_zero_pointer_conversion.swift
new file mode 100644
index 0000000..a07a9cf
--- /dev/null
+++ b/test/SILGen/plus_zero_pointer_conversion.swift
@@ -0,0 +1,457 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -emit-silgen -sdk %S/Inputs -I %S/Inputs -enable-source-import %s | %FileCheck %s
+
+// FIXME: rdar://problem/19648117 Needs splitting objc parts out
+// XFAIL: linux
+
+import Foundation
+
+func sideEffect1() -> Int { return 1 }
+func sideEffect2() -> Int { return 2 }
+func takesMutablePointer(_ x: UnsafeMutablePointer<Int>) {}
+func takesConstPointer(_ x: UnsafePointer<Int>) {}
+func takesOptConstPointer(_ x: UnsafePointer<Int>?, and: Int) {}
+func takesOptOptConstPointer(_ x: UnsafePointer<Int>??, and: Int) {}
+func takesMutablePointer(_ x: UnsafeMutablePointer<Int>, and: Int) {}
+func takesConstPointer(_ x: UnsafePointer<Int>, and: Int) {}
+func takesMutableVoidPointer(_ x: UnsafeMutableRawPointer) {}
+func takesConstVoidPointer(_ x: UnsafeRawPointer) {}
+func takesMutableRawPointer(_ x: UnsafeMutableRawPointer) {}
+func takesConstRawPointer(_ x: UnsafeRawPointer) {}
+func takesOptConstRawPointer(_ x: UnsafeRawPointer?, and: Int) {}
+func takesOptOptConstRawPointer(_ x: UnsafeRawPointer??, and: Int) {}
+
+// CHECK-LABEL: sil hidden @$S18pointer_conversion0A9ToPointeryySpySiG_SPySiGSvtF
+// CHECK: bb0([[MP:%.*]] : $UnsafeMutablePointer<Int>, [[CP:%.*]] : $UnsafePointer<Int>, [[MRP:%.*]] : $UnsafeMutableRawPointer):
+func pointerToPointer(_ mp: UnsafeMutablePointer<Int>,
+ _ cp: UnsafePointer<Int>, _ mrp: UnsafeMutableRawPointer) {
+
+ // There should be no conversion here
+ takesMutablePointer(mp)
+ // CHECK: [[TAKES_MUTABLE_POINTER:%.*]] = function_ref @$S18pointer_conversion19takesMutablePointer{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[TAKES_MUTABLE_POINTER]]([[MP]])
+
+ takesMutableVoidPointer(mp)
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss017_convertPointerToB8Argument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<UnsafeMutablePointer<Int>, UnsafeMutableRawPointer>
+ // CHECK: [[TAKES_MUTABLE_VOID_POINTER:%.*]] = function_ref @$S18pointer_conversion23takesMutableVoidPointer{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[TAKES_MUTABLE_VOID_POINTER]]
+
+ takesMutableRawPointer(mp)
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss017_convertPointerToB8Argument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<UnsafeMutablePointer<Int>, UnsafeMutableRawPointer>
+ // CHECK: [[TAKES_MUTABLE_RAW_POINTER:%.*]] = function_ref @$S18pointer_conversion22takesMutableRawPointeryySvF :
+ // CHECK: apply [[TAKES_MUTABLE_RAW_POINTER]]
+
+ takesConstPointer(mp)
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss017_convertPointerToB8Argument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<UnsafeMutablePointer<Int>, UnsafePointer<Int>>
+ // CHECK: [[TAKES_CONST_POINTER:%.*]] = function_ref @$S18pointer_conversion17takesConstPointeryySPySiGF
+ // CHECK: apply [[TAKES_CONST_POINTER]]
+
+ takesConstVoidPointer(mp)
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss017_convertPointerToB8Argument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<UnsafeMutablePointer<Int>, UnsafeRawPointer>
+ // CHECK: [[TAKES_CONST_VOID_POINTER:%.*]] = function_ref @$S18pointer_conversion21takesConstVoidPointeryySVF
+ // CHECK: apply [[TAKES_CONST_VOID_POINTER]]
+
+ takesConstRawPointer(mp)
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss017_convertPointerToB8Argument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<UnsafeMutablePointer<Int>, UnsafeRawPointer>
+ // CHECK: [[TAKES_CONST_RAW_POINTER:%.*]] = function_ref @$S18pointer_conversion20takesConstRawPointeryySVF :
+ // CHECK: apply [[TAKES_CONST_RAW_POINTER]]
+
+ takesConstPointer(cp)
+ // CHECK: [[TAKES_CONST_POINTER:%.*]] = function_ref @$S18pointer_conversion17takesConstPointeryySPySiGF
+ // CHECK: apply [[TAKES_CONST_POINTER]]([[CP]])
+
+ takesConstVoidPointer(cp)
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss017_convertPointerToB8Argument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<UnsafePointer<Int>, UnsafeRawPointer>
+ // CHECK: [[TAKES_CONST_VOID_POINTER:%.*]] = function_ref @$S18pointer_conversion21takesConstVoidPointeryySVF
+ // CHECK: apply [[TAKES_CONST_VOID_POINTER]]
+
+ takesConstRawPointer(cp)
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss017_convertPointerToB8Argument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<UnsafePointer<Int>, UnsafeRawPointer>
+ // CHECK: [[TAKES_CONST_RAW_POINTER:%.*]] = function_ref @$S18pointer_conversion20takesConstRawPointeryySVF
+ // CHECK: apply [[TAKES_CONST_RAW_POINTER]]
+
+ takesConstRawPointer(mrp)
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss017_convertPointerToB8Argument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<UnsafeMutableRawPointer, UnsafeRawPointer>
+ // CHECK: [[TAKES_CONST_RAW_POINTER:%.*]] = function_ref @$S18pointer_conversion20takesConstRawPointeryySVF
+ // CHECK: apply [[TAKES_CONST_RAW_POINTER]]
+}
+
+// CHECK-LABEL: sil hidden @$S18pointer_conversion14arrayToPointeryyF
+func arrayToPointer() {
+ var ints = [1,2,3]
+
+ takesMutablePointer(&ints)
+ // CHECK: [[CONVERT_MUTABLE:%.*]] = function_ref @$Ss37_convertMutableArrayToPointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[OWNER:%.*]] = apply [[CONVERT_MUTABLE]]<Int, UnsafeMutablePointer<Int>>([[POINTER_BUF:%[0-9]*]],
+ // CHECK: [[POINTER:%.*]] = load [trivial] [[POINTER_BUF]]
+ // CHECK: [[DEPENDENT:%.*]] = mark_dependence [[POINTER]] : $UnsafeMutablePointer<Int> on [[OWNER]]
+ // CHECK: [[TAKES_MUTABLE_POINTER:%.*]] = function_ref @$S18pointer_conversion19takesMutablePointer{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[TAKES_MUTABLE_POINTER]]([[DEPENDENT]])
+ // CHECK: destroy_value [[OWNER]]
+
+ takesConstPointer(ints)
+ // CHECK: [[CONVERT_CONST:%.*]] = function_ref @$Ss35_convertConstArrayToPointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[OWNER:%.*]] = apply [[CONVERT_CONST]]<Int, UnsafePointer<Int>>([[POINTER_BUF:%[0-9]*]],
+ // CHECK: [[POINTER:%.*]] = load [trivial] [[POINTER_BUF]]
+ // CHECK: [[DEPENDENT:%.*]] = mark_dependence [[POINTER]] : $UnsafePointer<Int> on [[OWNER]]
+ // CHECK: [[TAKES_CONST_POINTER:%.*]] = function_ref @$S18pointer_conversion17takesConstPointeryySPySiGF
+ // CHECK: apply [[TAKES_CONST_POINTER]]([[DEPENDENT]])
+ // CHECK: destroy_value [[OWNER]]
+
+ takesMutableRawPointer(&ints)
+ // CHECK: [[CONVERT_MUTABLE:%.*]] = function_ref @$Ss37_convertMutableArrayToPointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[OWNER:%.*]] = apply [[CONVERT_MUTABLE]]<Int, UnsafeMutableRawPointer>([[POINTER_BUF:%[0-9]*]],
+ // CHECK: [[POINTER:%.*]] = load [trivial] [[POINTER_BUF]]
+ // CHECK: [[DEPENDENT:%.*]] = mark_dependence [[POINTER]] : $UnsafeMutableRawPointer on [[OWNER]]
+ // CHECK: [[TAKES_MUTABLE_RAW_POINTER:%.*]] = function_ref @$S18pointer_conversion22takesMutableRawPointeryySvF :
+ // CHECK: apply [[TAKES_MUTABLE_RAW_POINTER]]([[DEPENDENT]])
+ // CHECK: destroy_value [[OWNER]]
+
+ takesConstRawPointer(ints)
+ // CHECK: [[CONVERT_CONST:%.*]] = function_ref @$Ss35_convertConstArrayToPointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[OWNER:%.*]] = apply [[CONVERT_CONST]]<Int, UnsafeRawPointer>([[POINTER_BUF:%[0-9]*]],
+ // CHECK: [[POINTER:%.*]] = load [trivial] [[POINTER_BUF]]
+ // CHECK: [[DEPENDENT:%.*]] = mark_dependence [[POINTER]] : $UnsafeRawPointer on [[OWNER]]
+ // CHECK: [[TAKES_CONST_RAW_POINTER:%.*]] = function_ref @$S18pointer_conversion20takesConstRawPointeryySVF :
+ // CHECK: apply [[TAKES_CONST_RAW_POINTER]]([[DEPENDENT]])
+ // CHECK: destroy_value [[OWNER]]
+
+ takesOptConstPointer(ints, and: sideEffect1())
+ // CHECK: [[SIDE1:%.*]] = function_ref @$S18pointer_conversion11sideEffect1SiyF
+ // CHECK: [[RESULT1:%.*]] = apply [[SIDE1]]()
+ // CHECK: [[CONVERT_CONST:%.*]] = function_ref @$Ss35_convertConstArrayToPointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[OWNER:%.*]] = apply [[CONVERT_CONST]]<Int, UnsafePointer<Int>>([[POINTER_BUF:%[0-9]*]],
+ // CHECK: [[POINTER:%.*]] = load [trivial] [[POINTER_BUF]]
+ // CHECK: [[DEPENDENT:%.*]] = mark_dependence [[POINTER]] : $UnsafePointer<Int> on [[OWNER]]
+ // CHECK: [[OPTPTR:%.*]] = enum $Optional<UnsafePointer<Int>>, #Optional.some!enumelt.1, [[DEPENDENT]]
+ // CHECK: [[TAKES_OPT_CONST_POINTER:%.*]] = function_ref @$S18pointer_conversion20takesOptConstPointer_3andySPySiGSg_SitF :
+ // CHECK: apply [[TAKES_OPT_CONST_POINTER]]([[OPTPTR]], [[RESULT1]])
+ // CHECK: destroy_value [[OWNER]]
+}
+
+// CHECK-LABEL: sil hidden @$S18pointer_conversion15stringToPointeryySSF
+func stringToPointer(_ s: String) {
+ takesConstVoidPointer(s)
+ // CHECK: [[CONVERT_STRING:%.*]] = function_ref @$Ss40_convertConstStringToUTF8PointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[OWNER:%.*]] = apply [[CONVERT_STRING]]<UnsafeRawPointer>([[POINTER_BUF:%[0-9]*]],
+ // CHECK: [[POINTER:%.*]] = load [trivial] [[POINTER_BUF]]
+ // CHECK: [[DEPENDENT:%.*]] = mark_dependence [[POINTER]] : $UnsafeRawPointer on [[OWNER]]
+ // CHECK: [[TAKES_CONST_VOID_POINTER:%.*]] = function_ref @$S18pointer_conversion21takesConstVoidPointeryySV{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[TAKES_CONST_VOID_POINTER]]([[DEPENDENT]])
+ // CHECK: destroy_value [[OWNER]]
+
+ takesConstRawPointer(s)
+ // CHECK: [[CONVERT_STRING:%.*]] = function_ref @$Ss40_convertConstStringToUTF8PointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[OWNER:%.*]] = apply [[CONVERT_STRING]]<UnsafeRawPointer>([[POINTER_BUF:%[0-9]*]],
+ // CHECK: [[POINTER:%.*]] = load [trivial] [[POINTER_BUF]]
+ // CHECK: [[DEPENDENT:%.*]] = mark_dependence [[POINTER]] : $UnsafeRawPointer on [[OWNER]]
+ // CHECK: [[TAKES_CONST_RAW_POINTER:%.*]] = function_ref @$S18pointer_conversion20takesConstRawPointeryySV{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[TAKES_CONST_RAW_POINTER]]([[DEPENDENT]])
+ // CHECK: destroy_value [[OWNER]]
+
+ takesOptConstRawPointer(s, and: sideEffect1())
+ // CHECK: [[SIDE1:%.*]] = function_ref @$S18pointer_conversion11sideEffect1SiyF
+ // CHECK: [[RESULT1:%.*]] = apply [[SIDE1]]()
+ // CHECK: [[CONVERT_STRING:%.*]] = function_ref @$Ss40_convertConstStringToUTF8PointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[OWNER:%.*]] = apply [[CONVERT_STRING]]<UnsafeRawPointer>([[POINTER_BUF:%[0-9]*]],
+ // CHECK: [[POINTER:%.*]] = load [trivial] [[POINTER_BUF]]
+ // CHECK: [[DEPENDENT:%.*]] = mark_dependence [[POINTER]] : $UnsafeRawPointer on [[OWNER]]
+ // CHECK: [[OPTPTR:%.*]] = enum $Optional<UnsafeRawPointer>, #Optional.some!enumelt.1, [[DEPENDENT]]
+ // CHECK: [[TAKES_OPT_CONST_RAW_POINTER:%.*]] = function_ref @$S18pointer_conversion23takesOptConstRawPointer_3andySVSg_SitF :
+ // CHECK: apply [[TAKES_OPT_CONST_RAW_POINTER]]([[OPTPTR]], [[RESULT1]])
+ // CHECK: destroy_value [[OWNER]]
+}
+
+// CHECK-LABEL: sil hidden @$S18pointer_conversion14inoutToPointeryyF
+func inoutToPointer() {
+ var int = 0
+ // CHECK: [[INT:%.*]] = alloc_box ${ var Int }
+ // CHECK: [[PB:%.*]] = project_box [[INT]]
+ takesMutablePointer(&int)
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB]]
+ // CHECK: [[POINTER:%.*]] = address_to_pointer [[WRITE]]
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss30_convertInOutToPointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<UnsafeMutablePointer<Int>>({{%.*}}, [[POINTER]])
+ // CHECK: [[TAKES_MUTABLE:%.*]] = function_ref @$S18pointer_conversion19takesMutablePointer{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[TAKES_MUTABLE]]
+
+ var logicalInt: Int {
+ get { return 0 }
+ set { }
+ }
+ takesMutablePointer(&logicalInt)
+ // CHECK: [[GETTER:%.*]] = function_ref @$S18pointer_conversion14inoutToPointeryyF10logicalIntL_Sivg
+ // CHECK: apply [[GETTER]]
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss30_convertInOutToPointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<UnsafeMutablePointer<Int>>
+ // CHECK: [[TAKES_MUTABLE:%.*]] = function_ref @$S18pointer_conversion19takesMutablePointer{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[TAKES_MUTABLE]]
+ // CHECK: [[SETTER:%.*]] = function_ref @$S18pointer_conversion14inoutToPointeryyF10logicalIntL_Sivs
+ // CHECK: apply [[SETTER]]
+
+ takesMutableRawPointer(&int)
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB]]
+ // CHECK: [[POINTER:%.*]] = address_to_pointer [[WRITE]]
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss30_convertInOutToPointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<UnsafeMutableRawPointer>({{%.*}}, [[POINTER]])
+ // CHECK: [[TAKES_MUTABLE:%.*]] = function_ref @$S18pointer_conversion22takesMutableRawPointer{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[TAKES_MUTABLE]]
+
+ takesMutableRawPointer(&logicalInt)
+ // CHECK: [[GETTER:%.*]] = function_ref @$S18pointer_conversion14inoutToPointeryyF10logicalIntL_Sivg
+ // CHECK: apply [[GETTER]]
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss30_convertInOutToPointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<UnsafeMutableRawPointer>
+ // CHECK: [[TAKES_MUTABLE:%.*]] = function_ref @$S18pointer_conversion22takesMutableRawPointer{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[TAKES_MUTABLE]]
+ // CHECK: [[SETTER:%.*]] = function_ref @$S18pointer_conversion14inoutToPointeryyF10logicalIntL_Sivs
+ // CHECK: apply [[SETTER]]
+}
+
+class C {}
+
+func takesPlusOnePointer(_ x: UnsafeMutablePointer<C>) {}
+func takesPlusZeroPointer(_ x: AutoreleasingUnsafeMutablePointer<C>) {}
+func takesPlusZeroOptionalPointer(_ x: AutoreleasingUnsafeMutablePointer<C?>) {}
+
+// CHECK-LABEL: sil hidden @$S18pointer_conversion19classInoutToPointeryyF
+func classInoutToPointer() {
+ var c = C()
+ // CHECK: [[VAR:%.*]] = alloc_box ${ var C }
+ // CHECK: [[PB:%.*]] = project_box [[VAR]]
+ takesPlusOnePointer(&c)
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB]]
+ // CHECK: [[POINTER:%.*]] = address_to_pointer [[WRITE]]
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss30_convertInOutToPointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<UnsafeMutablePointer<C>>({{%.*}}, [[POINTER]])
+ // CHECK: [[TAKES_PLUS_ONE:%.*]] = function_ref @$S18pointer_conversion19takesPlusOnePointer{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[TAKES_PLUS_ONE]]
+
+ takesPlusZeroPointer(&c)
+ // CHECK: [[WRITEBACK:%.*]] = alloc_stack $@sil_unmanaged C
+ // CHECK: [[OWNED:%.*]] = load_borrow [[PB]]
+ // CHECK: [[UNOWNED:%.*]] = ref_to_unmanaged [[OWNED]]
+ // CHECK: store [[UNOWNED]] to [trivial] [[WRITEBACK]]
+ // CHECK: [[POINTER:%.*]] = address_to_pointer [[WRITEBACK]]
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss30_convertInOutToPointerArgument{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[CONVERT]]<AutoreleasingUnsafeMutablePointer<C>>({{%.*}}, [[POINTER]])
+ // CHECK: [[TAKES_PLUS_ZERO:%.*]] = function_ref @$S18pointer_conversion20takesPlusZeroPointeryys026AutoreleasingUnsafeMutableF0VyAA1CCGF
+ // CHECK: apply [[TAKES_PLUS_ZERO]]
+ // CHECK: [[UNOWNED_OUT:%.*]] = load [trivial] [[WRITEBACK]]
+ // CHECK: [[OWNED_OUT:%.*]] = unmanaged_to_ref [[UNOWNED_OUT]]
+ // CHECK: [[OWNED_OUT_COPY:%.*]] = copy_value [[OWNED_OUT]]
+ // CHECK: assign [[OWNED_OUT_COPY]] to [[PB]]
+
+ var cq: C? = C()
+ takesPlusZeroOptionalPointer(&cq)
+}
+
+// Check that pointer types don't bridge anymore.
+@objc class ObjCMethodBridging : NSObject {
+ // CHECK-LABEL: sil hidden [thunk] @$S18pointer_conversion18ObjCMethodBridgingC0A4Args{{[_0-9a-zA-Z]*}}FTo : $@convention(objc_method) (UnsafeMutablePointer<Int>, UnsafePointer<Int>, AutoreleasingUnsafeMutablePointer<ObjCMethodBridging>, ObjCMethodBridging)
+ @objc func pointerArgs(_ x: UnsafeMutablePointer<Int>,
+ y: UnsafePointer<Int>,
+ z: AutoreleasingUnsafeMutablePointer<ObjCMethodBridging>) {}
+}
+
+// rdar://problem/21505805
+// CHECK-LABEL: sil hidden @$S18pointer_conversion22functionInoutToPointeryyF
+func functionInoutToPointer() {
+ // CHECK: [[BOX:%.*]] = alloc_box ${ var @callee_guaranteed () -> () }
+ var f: () -> () = {}
+
+ // CHECK: [[REABSTRACT_BUF:%.*]] = alloc_stack $@callee_guaranteed (@in_guaranteed ()) -> @out ()
+ // CHECK: address_to_pointer [[REABSTRACT_BUF]]
+ takesMutableVoidPointer(&f)
+}
+
+// rdar://problem/31781386
+// CHECK-LABEL: sil hidden @$S18pointer_conversion20inoutPointerOrderingyyF
+func inoutPointerOrdering() {
+ // CHECK: [[ARRAY_BOX:%.*]] = alloc_box ${ var Array<Int> }
+ // CHECK: [[ARRAY:%.*]] = project_box [[ARRAY_BOX]] :
+ // CHECK: store {{.*}} to [init] [[ARRAY]]
+ var array = [Int]()
+
+ // CHECK: [[SIDE1:%.*]] = function_ref @$S18pointer_conversion11sideEffect1SiyF
+ // CHECK: [[RESULT1:%.*]] = apply [[SIDE1]]()
+ // CHECK: [[SIDE2:%.*]] = function_ref @$S18pointer_conversion11sideEffect2SiyF
+ // CHECK: [[RESULT2:%.*]] = apply [[SIDE2]]()
+ // CHECK: [[ACCESS:%.*]] = begin_access [modify] [unknown] [[ARRAY]] : $*Array<Int>
+ // CHECK: [[TAKES_MUTABLE:%.*]] = function_ref @$S18pointer_conversion19takesMutablePointer_3andySpySiG_SitF
+ // CHECK: apply [[TAKES_MUTABLE]]({{.*}}, [[RESULT2]])
+ // CHECK: strong_unpin
+ // CHECK: end_access [[ACCESS]]
+ takesMutablePointer(&array[sideEffect1()], and: sideEffect2())
+
+ // CHECK: [[SIDE1:%.*]] = function_ref @$S18pointer_conversion11sideEffect1SiyF
+ // CHECK: [[RESULT1:%.*]] = apply [[SIDE1]]()
+ // CHECK: [[SIDE2:%.*]] = function_ref @$S18pointer_conversion11sideEffect2SiyF
+ // CHECK: [[RESULT2:%.*]] = apply [[SIDE2]]()
+ // CHECK: [[ACCESS:%.*]] = begin_access [read] [unknown] [[ARRAY]] : $*Array<Int>
+ // CHECK: [[TAKES_CONST:%.*]] = function_ref @$S18pointer_conversion17takesConstPointer_3andySPySiG_SitF
+ // CHECK: apply [[TAKES_CONST]]({{.*}}, [[RESULT2]])
+ // CHECK: end_access [[ACCESS]]
+ takesConstPointer(&array[sideEffect1()], and: sideEffect2())
+}
+
+// rdar://problem/31542269
+// CHECK-LABEL: sil hidden @$S18pointer_conversion20optArrayToOptPointer5arrayySaySiGSg_tF
+func optArrayToOptPointer(array: [Int]?) {
+ // CHECK: [[COPY:%.*]] = copy_value %0
+ // CHECK: [[SIDE1:%.*]] = function_ref @$S18pointer_conversion11sideEffect1SiyF
+ // CHECK: [[RESULT1:%.*]] = apply [[SIDE1]]()
+ // CHECK: [[T0:%.*]] = select_enum [[COPY]]
+ // CHECK: cond_br [[T0]], [[SOME_BB:bb[0-9]+]], [[NONE_BB:bb[0-9]+]]
+ // CHECK: [[SOME_BB]]:
+ // CHECK: [[SOME_VALUE:%.*]] = unchecked_enum_data [[COPY]]
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss35_convertConstArrayToPointerArgumentyyXlSg_q_tSayxGs01_E0R_r0_lF
+ // CHECK: [[TEMP:%.*]] = alloc_stack $UnsafePointer<Int>
+ // CHECK: [[OWNER:%.*]] = apply [[CONVERT]]<Int, UnsafePointer<Int>>([[TEMP:%.*]], [[SOME_VALUE]])
+ // CHECK: [[PTR:%.*]] = load [trivial] [[TEMP]]
+ // CHECK: [[DEP:%.*]] = mark_dependence [[PTR]] : $UnsafePointer<Int> on [[OWNER]]
+ // CHECK: [[OPTPTR:%.*]] = enum $Optional<UnsafePointer<Int>>, #Optional.some!enumelt.1, [[DEP]]
+ // CHECK: dealloc_stack [[TEMP]]
+ // CHECK: br [[CONT_BB:bb[0-9]+]]([[OPTPTR]] : $Optional<UnsafePointer<Int>>, [[OWNER]] : $Optional<AnyObject>)
+ // CHECK: [[CONT_BB]]([[OPTPTR:%.*]] : $Optional<UnsafePointer<Int>>, [[OWNER:%.*]] : $Optional<AnyObject>):
+ // CHECK: [[OPTDEP:%.*]] = mark_dependence [[OPTPTR]] : $Optional<UnsafePointer<Int>> on [[OWNER]]
+ // CHECK: [[TAKES:%.*]] = function_ref @$S18pointer_conversion20takesOptConstPointer_3andySPySiGSg_SitF
+ // CHECK: apply [[TAKES]]([[OPTDEP]], [[RESULT1]])
+ // CHECK: destroy_value [[OWNER]]
+ // CHECK-NOT: destroy_value %0
+ // CHECK: [[NONE_BB]]:
+ // CHECK: [[NO_VALUE:%.*]] = enum $Optional<UnsafePointer<Int>>, #Optional.none
+ // CHECK: [[NO_OWNER:%.*]] = enum $Optional<AnyObject>, #Optional.none
+ // CHECK: br [[CONT_BB]]([[NO_VALUE]] : $Optional<UnsafePointer<Int>>, [[NO_OWNER]] : $Optional<AnyObject>)
+ takesOptConstPointer(array, and: sideEffect1())
+}
+
+// CHECK-LABEL: sil hidden @$S18pointer_conversion013optOptArrayTodD7Pointer5arrayySaySiGSgSg_tF
+func optOptArrayToOptOptPointer(array: [Int]??) {
+ // CHECK: [[COPY:%.*]] = copy_value %0
+ // CHECK: [[SIDE1:%.*]] = function_ref @$S18pointer_conversion11sideEffect1SiyF
+ // CHECK: [[RESULT1:%.*]] = apply [[SIDE1]]()
+ // CHECK: [[T0:%.*]] = select_enum [[COPY]]
+ // CHECK: cond_br [[T0]], [[SOME_BB:bb[0-9]+]], [[NONE_BB:bb[0-9]+]]
+ // CHECK: [[SOME_BB]]:
+ // CHECK: [[SOME_VALUE:%.*]] = unchecked_enum_data [[COPY]]
+ // CHECK: [[T0:%.*]] = select_enum [[SOME_VALUE]]
+ // CHECK: cond_br [[T0]], [[SOME_SOME_BB:bb[0-9]+]], [[SOME_NONE_BB:bb[0-9]+]]
+ // CHECK: [[SOME_NONE_BB]]:
+ // CHECK: destroy_value [[SOME_VALUE]]
+ // CHECK: br [[SOME_NONE_BB2:bb[0-9]+]]
+ // CHECK: [[SOME_SOME_BB]]:
+ // CHECK: [[SOME_SOME_VALUE:%.*]] = unchecked_enum_data [[SOME_VALUE]]
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss35_convertConstArrayToPointerArgumentyyXlSg_q_tSayxGs01_E0R_r0_lF
+ // CHECK: [[TEMP:%.*]] = alloc_stack $UnsafePointer<Int>
+ // CHECK: [[OWNER:%.*]] = apply [[CONVERT]]<Int, UnsafePointer<Int>>([[TEMP:%.*]], [[SOME_SOME_VALUE]])
+ // CHECK: [[PTR:%.*]] = load [trivial] [[TEMP]]
+ // CHECK: [[DEP:%.*]] = mark_dependence [[PTR]] : $UnsafePointer<Int> on [[OWNER]]
+ // CHECK: [[OPTPTR:%.*]] = enum $Optional<UnsafePointer<Int>>, #Optional.some!enumelt.1, [[DEP]]
+ // CHECK: dealloc_stack [[TEMP]]
+ // CHECK: br [[SOME_SOME_CONT_BB:bb[0-9]+]]([[OPTPTR]] : $Optional<UnsafePointer<Int>>, [[OWNER]] : $Optional<AnyObject>)
+ // CHECK: [[SOME_SOME_CONT_BB]]([[OPTPTR:%.*]] : $Optional<UnsafePointer<Int>>, [[OWNER:%.*]] : $Optional<AnyObject>):
+ // CHECK: [[OPTDEP:%.*]] = mark_dependence [[OPTPTR]] : $Optional<UnsafePointer<Int>> on [[OWNER]]
+ // CHECK: [[OPTOPTPTR:%.*]] = enum $Optional<Optional<UnsafePointer<Int>>>, #Optional.some!enumelt.1, [[OPTDEP]]
+ // CHECK: br [[SOME_CONT_BB:bb[0-9]+]]([[OPTOPTPTR]] : $Optional<Optional<UnsafePointer<Int>>>, [[OWNER]] : $Optional<AnyObject>)
+ // CHECK: [[SOME_CONT_BB]]([[OPTOPTPTR:%.*]] : $Optional<Optional<UnsafePointer<Int>>>, [[OWNER:%.*]] : $Optional<AnyObject>):
+ // CHECK: [[OPTOPTDEP:%.*]] = mark_dependence [[OPTOPTPTR]] : $Optional<Optional<UnsafePointer<Int>>> on [[OWNER]]
+ // CHECK: [[TAKES:%.*]] = function_ref @$S18pointer_conversion08takesOptD12ConstPointer_3andySPySiGSgSg_SitF
+ // CHECK: apply [[TAKES]]([[OPTOPTDEP]], [[RESULT1]])
+ // CHECK: destroy_value [[OWNER]]
+ // CHECK-NOT: destroy_value %0
+ // CHECK: [[SOME_NONE_BB2]]:
+ // CHECK: [[NO_VALUE:%.*]] = enum $Optional<UnsafePointer<Int>>, #Optional.none
+ // CHECK: [[NO_OWNER:%.*]] = enum $Optional<AnyObject>, #Optional.none
+ // CHECK: br [[SOME_SOME_CONT_BB]]([[NO_VALUE]] : $Optional<UnsafePointer<Int>>, [[NO_OWNER]] : $Optional<AnyObject>)
+ // CHECK: [[NONE_BB]]:
+ // CHECK: [[NO_VALUE:%.*]] = enum $Optional<Optional<UnsafePointer<Int>>>, #Optional.none
+ // CHECK: [[NO_OWNER:%.*]] = enum $Optional<AnyObject>, #Optional.none
+ // CHECK: br [[SOME_CONT_BB]]([[NO_VALUE]] : $Optional<Optional<UnsafePointer<Int>>>, [[NO_OWNER]] : $Optional<AnyObject>)
+ takesOptOptConstPointer(array, and: sideEffect1())
+}
+
+// CHECK-LABEL: sil hidden @$S18pointer_conversion21optStringToOptPointer6stringySSSg_tF
+func optStringToOptPointer(string: String?) {
+ // CHECK: [[COPY:%.*]] = copy_value %0
+ // CHECK: [[SIDE1:%.*]] = function_ref @$S18pointer_conversion11sideEffect1SiyF
+ // CHECK: [[RESULT1:%.*]] = apply [[SIDE1]]()
+ // CHECK: [[T0:%.*]] = select_enum [[COPY]]
+ // CHECK: cond_br [[T0]], [[SOME_BB:bb[0-9]+]], [[NONE_BB:bb[0-9]+]]
+ // CHECK: [[SOME_BB]]:
+ // CHECK: [[SOME_VALUE:%.*]] = unchecked_enum_data [[COPY]]
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss40_convertConstStringToUTF8PointerArgumentyyXlSg_xtSSs01_F0RzlF
+ // CHECK: [[TEMP:%.*]] = alloc_stack $UnsafeRawPointer
+ // CHECK: [[OWNER:%.*]] = apply [[CONVERT]]<UnsafeRawPointer>([[TEMP:%.*]], [[SOME_VALUE]])
+ // CHECK: [[PTR:%.*]] = load [trivial] [[TEMP]]
+ // CHECK: [[DEP:%.*]] = mark_dependence [[PTR]] : $UnsafeRawPointer on [[OWNER]]
+ // CHECK: [[OPTPTR:%.*]] = enum $Optional<UnsafeRawPointer>, #Optional.some!enumelt.1, [[DEP]]
+ // CHECK: dealloc_stack [[TEMP]]
+ // CHECK: br [[CONT_BB:bb[0-9]+]]([[OPTPTR]] : $Optional<UnsafeRawPointer>, [[OWNER]] : $Optional<AnyObject>)
+ // CHECK: [[CONT_BB]]([[OPTPTR:%.*]] : $Optional<UnsafeRawPointer>, [[OWNER:%.*]] : $Optional<AnyObject>):
+ // CHECK: [[OPTDEP:%.*]] = mark_dependence [[OPTPTR]] : $Optional<UnsafeRawPointer> on [[OWNER]]
+ // CHECK: [[TAKES:%.*]] = function_ref @$S18pointer_conversion23takesOptConstRawPointer_3andySVSg_SitF
+ // CHECK: apply [[TAKES]]([[OPTDEP]], [[RESULT1]])
+ // CHECK: destroy_value [[OWNER]]
+ // CHECK-NOT: destroy_value %0
+ // CHECK: [[NONE_BB]]:
+ // CHECK: [[NO_VALUE:%.*]] = enum $Optional<UnsafeRawPointer>, #Optional.none
+ // CHECK: [[NO_OWNER:%.*]] = enum $Optional<AnyObject>, #Optional.none
+ // CHECK: br [[CONT_BB]]([[NO_VALUE]] : $Optional<UnsafeRawPointer>, [[NO_OWNER]] : $Optional<AnyObject>)
+ takesOptConstRawPointer(string, and: sideEffect1())
+}
+
+// CHECK-LABEL: sil hidden @$S18pointer_conversion014optOptStringTodD7Pointer6stringySSSgSg_tF
+func optOptStringToOptOptPointer(string: String??) {
+ // CHECK: [[COPY:%.*]] = copy_value %0
+ // CHECK: [[SIDE1:%.*]] = function_ref @$S18pointer_conversion11sideEffect1SiyF
+ // CHECK: [[RESULT1:%.*]] = apply [[SIDE1]]()
+ // CHECK: [[T0:%.*]] = select_enum [[COPY]]
+ // FIXME: this should really go somewhere that will make nil, not some(nil)
+ // CHECK: cond_br [[T0]], [[SOME_BB:bb[0-9]+]], [[NONE_BB:bb[0-9]+]]
+ // CHECK: [[SOME_BB]]:
+ // CHECK: [[SOME_VALUE:%.*]] = unchecked_enum_data [[COPY]]
+ // CHECK: [[T0:%.*]] = select_enum [[SOME_VALUE]]
+ // CHECK: cond_br [[T0]], [[SOME_SOME_BB:bb[0-9]+]], [[SOME_NONE_BB:bb[0-9]+]]
+ // CHECK: [[SOME_NONE_BB]]:
+ // CHECK: destroy_value [[SOME_VALUE]]
+ // CHECK: br [[SOME_NONE_BB2:bb[0-9]+]]
+ // CHECK: [[SOME_SOME_BB]]:
+ // CHECK: [[SOME_SOME_VALUE:%.*]] = unchecked_enum_data [[SOME_VALUE]]
+ // CHECK: [[CONVERT:%.*]] = function_ref @$Ss40_convertConstStringToUTF8PointerArgumentyyXlSg_xtSSs01_F0RzlF
+ // CHECK: [[TEMP:%.*]] = alloc_stack $UnsafeRawPointer
+ // CHECK: [[OWNER:%.*]] = apply [[CONVERT]]<UnsafeRawPointer>([[TEMP:%.*]], [[SOME_SOME_VALUE]])
+ // CHECK: [[PTR:%.*]] = load [trivial] [[TEMP]]
+ // CHECK: [[DEP:%.*]] = mark_dependence [[PTR]] : $UnsafeRawPointer on [[OWNER]]
+ // CHECK: [[OPTPTR:%.*]] = enum $Optional<UnsafeRawPointer>, #Optional.some!enumelt.1, [[DEP]]
+ // CHECK: dealloc_stack [[TEMP]]
+ // CHECK: br [[SOME_SOME_CONT_BB:bb[0-9]+]]([[OPTPTR]] : $Optional<UnsafeRawPointer>, [[OWNER]] : $Optional<AnyObject>)
+ // CHECK: [[SOME_SOME_CONT_BB]]([[OPTPTR:%.*]] : $Optional<UnsafeRawPointer>, [[OWNER:%.*]] : $Optional<AnyObject>):
+ // CHECK: [[OPTDEP:%.*]] = mark_dependence [[OPTPTR]] : $Optional<UnsafeRawPointer> on [[OWNER]]
+ // CHECK: [[OPTOPTPTR:%.*]] = enum $Optional<Optional<UnsafeRawPointer>>, #Optional.some!enumelt.1, [[OPTDEP]]
+ // CHECK: br [[SOME_CONT_BB:bb[0-9]+]]([[OPTOPTPTR]] : $Optional<Optional<UnsafeRawPointer>>, [[OWNER]] : $Optional<AnyObject>)
+ // CHECK: [[SOME_CONT_BB]]([[OPTOPTPTR:%.*]] : $Optional<Optional<UnsafeRawPointer>>, [[OWNER:%.*]] : $Optional<AnyObject>):
+ // CHECK: [[OPTOPTDEP:%.*]] = mark_dependence [[OPTOPTPTR]] : $Optional<Optional<UnsafeRawPointer>> on [[OWNER]]
+ // CHECK: [[TAKES:%.*]] = function_ref @$S18pointer_conversion08takesOptD15ConstRawPointer_3andySVSgSg_SitF
+ // CHECK: apply [[TAKES]]([[OPTOPTDEP]], [[RESULT1]])
+ // CHECK: destroy_value [[OWNER]]
+ // CHECK: end_borrow [[BORROW]]
+ // CHECK: destroy_value %0
+ // CHECK: [[SOME_NONE_BB2]]:
+ // CHECK: [[NO_VALUE:%.*]] = enum $Optional<UnsafeRawPointer>, #Optional.none
+ // CHECK: [[NO_OWNER:%.*]] = enum $Optional<AnyObject>, #Optional.none
+ // CHECK: br [[SOME_SOME_CONT_BB]]([[NO_VALUE]] : $Optional<UnsafeRawPointer>, [[NO_OWNER]] : $Optional<AnyObject>)
+ // CHECK: [[NONE_BB]]:
+ // CHECK: [[NO_VALUE:%.*]] = enum $Optional<Optional<UnsafeRawPointer>>, #Optional.none
+ // CHECK: [[NO_OWNER:%.*]] = enum $Optional<AnyObject>, #Optional.none
+ // CHECK: br [[SOME_CONT_BB]]([[NO_VALUE]] : $Optional<Optional<UnsafeRawPointer>>, [[NO_OWNER]] : $Optional<AnyObject>)
+ takesOptOptConstRawPointer(string, and: sideEffect1())
+}
diff --git a/test/SILGen/plus_zero_properties.swift b/test/SILGen/plus_zero_properties.swift
new file mode 100644
index 0000000..76dd9c9
--- /dev/null
+++ b/test/SILGen/plus_zero_properties.swift
@@ -0,0 +1,1191 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -parse-as-library -emit-silgen -disable-objc-attr-requires-foundation-module %s | %FileCheck %s
+
+var zero: Int = 0
+
+func use(_: Int) {}
+func use(_: Double) {}
+func getInt() -> Int { return zero }
+
+// CHECK-LABEL: sil hidden @{{.*}}physical_tuple_lvalue
+// CHECK: bb0(%0 : $Int):
+func physical_tuple_lvalue(_ c: Int) {
+ var x : (Int, Int)
+ // CHECK: [[BOX:%[0-9]+]] = alloc_box ${ var (Int, Int) }
+ // CHECK: [[MARKED_BOX:%[0-9]+]] = mark_uninitialized [var] [[BOX]]
+ // CHECK: [[XADDR:%.*]] = project_box [[MARKED_BOX]]
+ x.1 = c
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[XADDR]]
+ // CHECK: [[X_1:%[0-9]+]] = tuple_element_addr [[WRITE]] : {{.*}}, 1
+ // CHECK: assign %0 to [[X_1]]
+}
+
+func tuple_rvalue() -> (Int, Int) {}
+
+// CHECK-LABEL: sil hidden @{{.*}}physical_tuple_rvalue
+func physical_tuple_rvalue() -> Int {
+ return tuple_rvalue().1
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S10properties12tuple_rvalue{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[TUPLE:%[0-9]+]] = apply [[FUNC]]()
+ // CHECK: [[RET:%[0-9]+]] = tuple_extract [[TUPLE]] : {{.*}}, 1
+ // CHECK: return [[RET]]
+}
+
+// CHECK-LABEL: sil hidden @$S10properties16tuple_assignment{{[_0-9a-zA-Z]*}}F
+func tuple_assignment(_ a: inout Int, b: inout Int) {
+ // CHECK: bb0([[A_ADDR:%[0-9]+]] : $*Int, [[B_ADDR:%[0-9]+]] : $*Int):
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[B_ADDR]]
+ // CHECK: [[B:%[0-9]+]] = load [trivial] [[READ]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[A_ADDR]]
+ // CHECK: [[A:%[0-9]+]] = load [trivial] [[READ]]
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[A_ADDR]]
+ // CHECK: assign [[B]] to [[WRITE]]
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[B_ADDR]]
+ // CHECK: assign [[A]] to [[WRITE]]
+ (a, b) = (b, a)
+}
+
+// CHECK-LABEL: sil hidden @$S10properties18tuple_assignment_2{{[_0-9a-zA-Z]*}}F
+func tuple_assignment_2(_ a: inout Int, b: inout Int, xy: (Int, Int)) {
+ // CHECK: bb0([[A_ADDR:%[0-9]+]] : $*Int, [[B_ADDR:%[0-9]+]] : $*Int, [[X:%[0-9]+]] : $Int, [[Y:%[0-9]+]] : $Int):
+ (a, b) = xy
+ // CHECK: [[XY2:%[0-9]+]] = tuple ([[X]] : $Int, [[Y]] : $Int)
+ // CHECK: [[X:%[0-9]+]] = tuple_extract [[XY2]] : {{.*}}, 0
+ // CHECK: [[Y:%[0-9]+]] = tuple_extract [[XY2]] : {{.*}}, 1
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[A_ADDR]]
+ // CHECK: assign [[X]] to [[WRITE]]
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[B_ADDR]]
+ // CHECK: assign [[Y]] to [[WRITE]]
+}
+
+class Ref {
+ var x, y : Int
+ var ref : Ref
+
+ var z: Int { get {} set {} }
+
+ var val_prop: Val { get {} set {} }
+
+ subscript(i: Int) -> Float { get {} set {} }
+
+ init(i: Int) {
+ x = i
+ y = i
+ ref = self
+ }
+}
+
+class RefSubclass : Ref {
+ var w : Int
+
+ override init (i: Int) {
+ w = i
+ super.init(i: i)
+ }
+}
+
+struct Val {
+ var x, y : Int
+ var ref : Ref
+
+ var z: Int { get {} set {} }
+
+ var z_tuple: (Int, Int) { get {} set {} }
+
+ subscript(i: Int) -> Float { get {} set {} }
+}
+
+// CHECK-LABEL: sil hidden @$S10properties22physical_struct_lvalue{{[_0-9a-zA-Z]*}}F
+func physical_struct_lvalue(_ c: Int) {
+ var v : Val
+ // CHECK: [[VADDR:%[0-9]+]] = alloc_box ${ var Val }
+ v.y = c
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown]
+ // CHECK: [[YADDR:%.*]] = struct_element_addr [[WRITE]]
+ // CHECK: assign %0 to [[YADDR]]
+}
+
+// CHECK-LABEL: sil hidden @$S10properties21physical_class_lvalue{{[_0-9a-zA-Z]*}}F : $@convention(thin) (@guaranteed Ref, Int) -> ()
+// CHECK: bb0([[ARG0:%.*]] : $Ref,
+ func physical_class_lvalue(_ r: Ref, a: Int) {
+ r.y = a
+ // CHECK: [[FN:%[0-9]+]] = class_method [[ARG0]] : $Ref, #Ref.y!setter.1
+ // CHECK: apply [[FN]](%1, [[ARG0]]) : $@convention(method) (Int, @guaranteed Ref) -> ()
+ }
+
+
+// CHECK-LABEL: sil hidden @$S10properties24physical_subclass_lvalue{{[_0-9a-zA-Z]*}}F
+func physical_subclass_lvalue(_ r: RefSubclass, a: Int) {
+ // CHECK: bb0([[ARG1:%.*]] : $RefSubclass, [[ARG2:%.*]] : $Int):
+ r.y = a
+ // CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]] : $RefSubclass
+ // CHECK: [[R_SUP:%[0-9]+]] = upcast [[ARG1_COPY]] : $RefSubclass to $Ref
+ // CHECK: [[FN:%[0-9]+]] = class_method [[R_SUP]] : $Ref, #Ref.y!setter.1 : (Ref) -> (Int) -> (), $@convention(method) (Int, @guaranteed Ref) -> ()
+ // CHECK: apply [[FN]]([[ARG2]], [[R_SUP]]) :
+ // CHECK: destroy_value [[R_SUP]]
+ r.w = a
+
+ // CHECK: [[FN:%[0-9]+]] = class_method [[ARG1]] : $RefSubclass, #RefSubclass.w!setter.1
+ // CHECK: apply [[FN]](%1, [[ARG1]]) : $@convention(method) (Int, @guaranteed RefSubclass) -> ()
+ // CHECK-NOT: destroy_value [[ARG1]]
+ // CHECK: } // end sil function '$S10properties24physical_subclass_lvalue{{[_0-9a-zA-Z]*}}F'
+}
+
+
+
+func struct_rvalue() -> Val {}
+
+// CHECK-LABEL: sil hidden @$S10properties22physical_struct_rvalue{{[_0-9a-zA-Z]*}}F
+func physical_struct_rvalue() -> Int {
+ return struct_rvalue().y
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S10properties13struct_rvalueAA3ValVyF
+ // CHECK: [[STRUCT:%[0-9]+]] = apply [[FUNC]]()
+ // CHECK: [[BORROWED_STRUCT:%.*]] = begin_borrow [[STRUCT]]
+ // CHECK: [[RET:%[0-9]+]] = struct_extract [[BORROWED_STRUCT]] : $Val, #Val.y
+ // CHECK: end_borrow [[BORROWED_STRUCT]] from [[STRUCT]]
+ // CHECK: destroy_value [[STRUCT]]
+ // CHECK: return [[RET]]
+}
+
+func class_rvalue() -> Ref {}
+
+// CHECK-LABEL: sil hidden @$S10properties21physical_class_rvalue{{[_0-9a-zA-Z]*}}F
+func physical_class_rvalue() -> Int {
+ return class_rvalue().y
+ // CHECK: [[FUNC:%[0-9]+]] = function_ref @$S10properties12class_rvalueAA3RefCyF
+ // CHECK: [[CLASS:%[0-9]+]] = apply [[FUNC]]()
+ // CHECK: [[FN:%[0-9]+]] = class_method [[CLASS]] : $Ref, #Ref.y!getter.1
+ // CHECK: [[RET:%[0-9]+]] = apply [[FN]]([[CLASS]])
+ // CHECK: return [[RET]]
+}
+
+// CHECK-LABEL: sil hidden @$S10properties18logical_struct_get{{[_0-9a-zA-Z]*}}F
+func logical_struct_get() -> Int {
+ return struct_rvalue().z
+ // CHECK: [[GET_RVAL:%[0-9]+]] = function_ref @$S10properties13struct_rvalue{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[STRUCT:%[0-9]+]] = apply [[GET_RVAL]]()
+ // CHECK: [[GET_METHOD:%[0-9]+]] = function_ref @$S10properties3ValV1z{{[_0-9a-zA-Z]*}}vg
+ // CHECK: [[VALUE:%[0-9]+]] = apply [[GET_METHOD]]([[STRUCT]])
+ // CHECK: return [[VALUE]]
+}
+
+// CHECK-LABEL: sil hidden @$S10properties18logical_struct_set{{[_0-9a-zA-Z]*}}F
+func logical_struct_set(_ value: inout Val, z: Int) {
+ // CHECK: bb0([[VAL:%[0-9]+]] : $*Val, [[Z:%[0-9]+]] : $Int):
+ value.z = z
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[VAL]]
+ // CHECK: [[Z_SET_METHOD:%[0-9]+]] = function_ref @$S10properties3ValV1z{{[_0-9a-zA-Z]*}}vs
+ // CHECK: apply [[Z_SET_METHOD]]([[Z]], [[WRITE]])
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S10properties27logical_struct_in_tuple_set{{[_0-9a-zA-Z]*}}F
+func logical_struct_in_tuple_set(_ value: inout (Int, Val), z: Int) {
+ // CHECK: bb0([[VAL:%[0-9]+]] : $*(Int, Val), [[Z:%[0-9]+]] : $Int):
+ value.1.z = z
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[VAL]]
+ // CHECK: [[VAL_1:%[0-9]+]] = tuple_element_addr [[WRITE]] : {{.*}}, 1
+ // CHECK: [[Z_SET_METHOD:%[0-9]+]] = function_ref @$S10properties3ValV1z{{[_0-9a-zA-Z]*}}vs
+ // CHECK: apply [[Z_SET_METHOD]]([[Z]], [[VAL_1]])
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S10properties29logical_struct_in_reftype_set{{[_0-9a-zA-Z]*}}F
+func logical_struct_in_reftype_set(_ value: inout Val, z1: Int) {
+ // CHECK: bb0([[VAL:%[0-9]+]] : $*Val, [[Z1:%[0-9]+]] : $Int):
+ value.ref.val_prop.z_tuple.1 = z1
+ // -- val.ref
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[VAL]]
+ // CHECK: [[VAL_REF_ADDR:%[0-9]+]] = struct_element_addr [[READ]] : $*Val, #Val.ref
+ // CHECK: [[VAL_REF:%[0-9]+]] = load [copy] [[VAL_REF_ADDR]]
+ // -- getters and setters
+ // -- val.ref.val_prop
+ // CHECK: [[STORAGE:%.*]] = alloc_stack $Builtin.UnsafeValueBuffer
+ // CHECK: [[VAL_REF_VAL_PROP_TEMP:%.*]] = alloc_stack $Val
+ // CHECK: [[VAL_REF_BORROWED:%.*]] = begin_borrow [[VAL_REF]]
+ // CHECK: [[T0:%.*]] = address_to_pointer [[VAL_REF_VAL_PROP_TEMP]] : $*Val to $Builtin.RawPointer
+ // CHECK: [[MAT_VAL_PROP_METHOD:%[0-9]+]] = class_method {{.*}} : $Ref, #Ref.val_prop!materializeForSet.1 : (Ref) -> (Builtin.RawPointer, inout Builtin.UnsafeValueBuffer) -> (Builtin.RawPointer, Builtin.RawPointer?)
+ // CHECK: [[MAT_RESULT:%[0-9]+]] = apply [[MAT_VAL_PROP_METHOD]]([[T0]], [[STORAGE]], [[VAL_REF_BORROWED]])
+ // CHECK: [[T0:%.*]] = tuple_extract [[MAT_RESULT]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>), 0
+ // CHECK: [[OPT_CALLBACK:%.*]] = tuple_extract [[MAT_RESULT]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>), 1
+ // CHECK: [[T1:%[0-9]+]] = pointer_to_address [[T0]] : $Builtin.RawPointer to [strict] $*Val
+ // CHECK: [[VAL_REF_VAL_PROP_MAT:%.*]] = mark_dependence [[T1]] : $*Val on [[VAL_REF]]
+ // CHECK: end_borrow [[VAL_REF_BORROWED]] from [[VAL_REF]]
+ // -- val.ref.val_prop.z_tuple
+ // CHECK: [[V_R_VP_Z_TUPLE_MAT:%[0-9]+]] = alloc_stack $(Int, Int)
+ // CHECK: [[LD:%[0-9]+]] = load_borrow [[VAL_REF_VAL_PROP_MAT]]
+ // CHECK: [[A0:%.*]] = tuple_element_addr [[V_R_VP_Z_TUPLE_MAT]] : {{.*}}, 0
+ // CHECK: [[A1:%.*]] = tuple_element_addr [[V_R_VP_Z_TUPLE_MAT]] : {{.*}}, 1
+ // CHECK: [[GET_Z_TUPLE_METHOD:%[0-9]+]] = function_ref @$S10properties3ValV7z_tupleSi_Sitvg
+ // CHECK: [[V_R_VP_Z_TUPLE:%[0-9]+]] = apply [[GET_Z_TUPLE_METHOD]]([[LD]])
+ // CHECK: [[T0:%.*]] = tuple_extract [[V_R_VP_Z_TUPLE]] : {{.*}}, 0
+ // CHECK: [[T1:%.*]] = tuple_extract [[V_R_VP_Z_TUPLE]] : {{.*}}, 1
+ // CHECK: store [[T0]] to [trivial] [[A0]]
+ // CHECK: store [[T1]] to [trivial] [[A1]]
+ // CHECK: end_borrow [[LD]] from [[VAL_REF_VAL_PROP_MAT]]
+ // -- write to val.ref.val_prop.z_tuple.1
+ // CHECK: [[V_R_VP_Z_TUPLE_1:%[0-9]+]] = tuple_element_addr [[V_R_VP_Z_TUPLE_MAT]] : {{.*}}, 1
+ // CHECK: assign [[Z1]] to [[V_R_VP_Z_TUPLE_1]]
+ // -- writeback to val.ref.val_prop.z_tuple
+ // CHECK: [[WB_V_R_VP_Z_TUPLE:%[0-9]+]] = load [trivial] [[V_R_VP_Z_TUPLE_MAT]]
+ // CHECK: [[SET_Z_TUPLE_METHOD:%[0-9]+]] = function_ref @$S10properties3ValV7z_tupleSi_Sitvs
+ // CHECK: apply [[SET_Z_TUPLE_METHOD]]({{%[0-9]+, %[0-9]+}}, [[VAL_REF_VAL_PROP_MAT]])
+ // -- writeback to val.ref.val_prop
+ // CHECK: switch_enum [[OPT_CALLBACK]] : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: [[WRITEBACK:bb[0-9]+]], case #Optional.none!enumelt: [[CONT:bb[0-9]+]]
+ // CHECK: [[WRITEBACK]]([[CALLBACK_ADDR:%.*]] : $Builtin.RawPointer):
+ // CHECK: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Ref, @thick Ref.Type) -> ()
+ // CHECK: [[REF_MAT:%.*]] = alloc_stack $Ref
+ // CHECK: store [[VAL_REF]] to [init] [[REF_MAT]]
+ // CHECK: [[T0:%.*]] = metatype $@thick Ref.Type
+ // CHECK: [[T1:%.*]] = address_to_pointer [[VAL_REF_VAL_PROP_MAT]]
+ // CHECK: apply [[CALLBACK]]([[T1]], [[STORAGE]], [[REF_MAT]], [[T0]])
+ // CHECK: br [[CONT]]
+ // CHECK: [[CONT]]:
+ // -- cleanup
+ // CHECK: dealloc_stack [[V_R_VP_Z_TUPLE_MAT]]
+ // CHECK: dealloc_stack [[VAL_REF_VAL_PROP_TEMP]]
+ // -- don't need to write back to val.ref because it's a ref type
+}
+
+func reftype_rvalue() -> Ref {}
+
+// CHECK-LABEL: sil hidden @$S10properties18reftype_rvalue_set{{[_0-9a-zA-Z]*}}F
+func reftype_rvalue_set(_ value: Val) {
+ reftype_rvalue().val_prop = value
+}
+
+// CHECK-LABEL: sil hidden @$S10properties27tuple_in_logical_struct_set{{[_0-9a-zA-Z]*}}F
+func tuple_in_logical_struct_set(_ value: inout Val, z1: Int) {
+ // CHECK: bb0([[VAL:%[0-9]+]] : $*Val, [[Z1:%[0-9]+]] : $Int):
+ value.z_tuple.1 = z1
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[VAL]]
+ // CHECK: [[Z_TUPLE_MATERIALIZED:%[0-9]+]] = alloc_stack $(Int, Int)
+ // CHECK: [[VAL1:%[0-9]+]] = load_borrow [[WRITE]]
+ // CHECK: [[A0:%.*]] = tuple_element_addr [[Z_TUPLE_MATERIALIZED]] : {{.*}}, 0
+ // CHECK: [[A1:%.*]] = tuple_element_addr [[Z_TUPLE_MATERIALIZED]] : {{.*}}, 1
+ // CHECK: [[Z_GET_METHOD:%[0-9]+]] = function_ref @$S10properties3ValV7z_tupleSi_Sitvg
+ // CHECK: [[Z_TUPLE:%[0-9]+]] = apply [[Z_GET_METHOD]]([[VAL1]])
+ // CHECK: [[T0:%.*]] = tuple_extract [[Z_TUPLE]] : {{.*}}, 0
+ // CHECK: [[T1:%.*]] = tuple_extract [[Z_TUPLE]] : {{.*}}, 1
+ // CHECK: store [[T0]] to [trivial] [[A0]]
+ // CHECK: store [[T1]] to [trivial] [[A1]]
+ // CHECK: end_borrow [[VAL1]] from [[WRITE]]
+ // CHECK: [[Z_TUPLE_1:%[0-9]+]] = tuple_element_addr [[Z_TUPLE_MATERIALIZED]] : {{.*}}, 1
+ // CHECK: assign [[Z1]] to [[Z_TUPLE_1]]
+ // CHECK: [[Z_TUPLE_MODIFIED:%[0-9]+]] = load [trivial] [[Z_TUPLE_MATERIALIZED]]
+ // CHECK: [[Z_SET_METHOD:%[0-9]+]] = function_ref @$S10properties3ValV7z_tupleSi_Sitvs
+ // CHECK: apply [[Z_SET_METHOD]]({{%[0-9]+, %[0-9]+}}, [[WRITE]])
+ // CHECK: dealloc_stack [[Z_TUPLE_MATERIALIZED]]
+ // CHECK: return
+}
+
+var global_prop : Int {
+ // CHECK-LABEL: sil hidden @$S10properties11global_prop{{[_0-9a-zA-Z]*}}vg
+ get {
+ return zero
+ }
+ // CHECK-LABEL: sil hidden @$S10properties11global_prop{{[_0-9a-zA-Z]*}}vs
+ set {
+ use(newValue)
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10properties18logical_global_get{{[_0-9a-zA-Z]*}}F
+func logical_global_get() -> Int {
+ return global_prop
+ // CHECK: [[GET:%[0-9]+]] = function_ref @$S10properties11global_prop{{[_0-9a-zA-Z]*}}vg
+ // CHECK: [[VALUE:%[0-9]+]] = apply [[GET]]()
+ // CHECK: return [[VALUE]]
+}
+
+// CHECK-LABEL: sil hidden @$S10properties18logical_global_set{{[_0-9a-zA-Z]*}}F
+func logical_global_set(_ x: Int) {
+ global_prop = x
+ // CHECK: [[SET:%[0-9]+]] = function_ref @$S10properties11global_prop{{[_0-9a-zA-Z]*}}vs
+ // CHECK: apply [[SET]](%0)
+}
+
+// CHECK-LABEL: sil hidden @$S10properties17logical_local_get{{[_0-9a-zA-Z]*}}F
+func logical_local_get(_ x: Int) -> Int {
+ var prop : Int {
+ get {
+ return x
+ }
+ }
+ // CHECK: [[GET_REF:%[0-9]+]] = function_ref [[PROP_GET_CLOSURE:@\$S10properties17logical_local_getyS2iF4propL_Sivg]]
+ // CHECK: apply [[GET_REF]](%0)
+ return prop
+}
+// CHECK-: sil private [[PROP_GET_CLOSURE]]
+// CHECK: bb0(%{{[0-9]+}} : $Int):
+
+func logical_generic_local_get<T>(_ x: Int, _: T) {
+ var prop1: Int {
+ get {
+ return x
+ }
+ }
+
+ _ = prop1
+
+ var prop2: Int {
+ get {
+ _ = T.self
+ return x
+ }
+ }
+
+ _ = prop2
+}
+
+// CHECK-LABEL: sil hidden @$S10properties26logical_local_captured_get{{[_0-9a-zA-Z]*}}F
+func logical_local_captured_get(_ x: Int) -> Int {
+ var prop : Int {
+ get {
+ return x
+ }
+ }
+ func get_prop() -> Int {
+ return prop
+ }
+
+ return get_prop()
+ // CHECK: [[FUNC_REF:%[0-9]+]] = function_ref @$S10properties26logical_local_captured_getyS2iF0E5_propL_SiyF
+ // CHECK: apply [[FUNC_REF]](%0)
+}
+// CHECK: sil private @$S10properties26logical_local_captured_get{{.*}}vg
+// CHECK: bb0(%{{[0-9]+}} : $Int):
+
+func inout_arg(_ x: inout Int) {}
+
+// CHECK-LABEL: sil hidden @$S10properties14physical_inout{{[_0-9a-zA-Z]*}}F
+func physical_inout(_ x: Int) {
+ var x = x
+ // CHECK: [[XADDR:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[PB:%.*]] = project_box [[XADDR]]
+ inout_arg(&x)
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB]]
+ // CHECK: [[INOUT_ARG:%[0-9]+]] = function_ref @$S10properties9inout_arg{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[INOUT_ARG]]([[WRITE]])
+}
+
+
+/* TODO check writeback to more complex logical prop, check that writeback
+ * reuses temporaries */
+
+// CHECK-LABEL: sil hidden @$S10properties17val_subscript_get{{[_0-9a-zA-Z]*}}F : $@convention(thin) (@guaranteed Val, Int) -> Float
+// CHECK: bb0([[VVAL:%[0-9]+]] : $Val, [[I:%[0-9]+]] : $Int):
+func val_subscript_get(_ v: Val, i: Int) -> Float {
+ return v[i]
+ // CHECK: [[SUBSCRIPT_GET_METHOD:%[0-9]+]] = function_ref @$S10properties3ValV{{[_0-9a-zA-Z]*}}ig
+ // CHECK: [[RET:%[0-9]+]] = apply [[SUBSCRIPT_GET_METHOD]]([[I]], [[VVAL]]) : $@convention(method) (Int, @guaranteed Val)
+ // CHECK: return [[RET]]
+}
+
+// CHECK-LABEL: sil hidden @$S10properties17val_subscript_set{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0(%0 : $Val, [[I:%[0-9]+]] : $Int, [[X:%[0-9]+]] : $Float):
+func val_subscript_set(_ v: Val, i: Int, x: Float) {
+ var v = v
+ v[i] = x
+ // CHECK: [[VADDR:%[0-9]+]] = alloc_box ${ var Val }
+ // CHECK: [[PB:%.*]] = project_box [[VADDR]]
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB]]
+ // CHECK: [[SUBSCRIPT_SET_METHOD:%[0-9]+]] = function_ref @$S10properties3ValV{{[_0-9a-zA-Z]*}}is
+ // CHECK: apply [[SUBSCRIPT_SET_METHOD]]([[X]], [[I]], [[WRITE]])
+}
+
+struct Generic<T> {
+ var mono_phys:Int
+ var mono_log: Int { get {} set {} }
+ var typevar_member:T
+
+ subscript(x: Int) -> Float { get {} set {} }
+
+ subscript(x: T) -> T { get {} set {} }
+
+ // CHECK-LABEL: sil hidden @$S10properties7GenericV19copy_typevar_member{{[_0-9a-zA-Z]*}}F
+ mutating
+ func copy_typevar_member(_ x: Generic<T>) {
+ typevar_member = x.typevar_member
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10properties21generic_mono_phys_get{{[_0-9a-zA-Z]*}}F
+func generic_mono_phys_get<T>(_ g: Generic<T>) -> Int {
+ return g.mono_phys
+ // CHECK: struct_element_addr %{{.*}}, #Generic.mono_phys
+}
+
+// CHECK-LABEL: sil hidden @$S10properties20generic_mono_log_get{{[_0-9a-zA-Z]*}}F
+func generic_mono_log_get<T>(_ g: Generic<T>) -> Int {
+ return g.mono_log
+ // CHECK: [[GENERIC_GET_METHOD:%[0-9]+]] = function_ref @$S10properties7GenericV8mono_log{{[_0-9a-zA-Z]*}}vg
+ // CHECK: apply [[GENERIC_GET_METHOD]]<
+}
+
+// CHECK-LABEL: sil hidden @$S10properties20generic_mono_log_set{{[_0-9a-zA-Z]*}}F
+func generic_mono_log_set<T>(_ g: Generic<T>, x: Int) {
+ var g = g
+ g.mono_log = x
+ // CHECK: [[GENERIC_SET_METHOD:%[0-9]+]] = function_ref @$S10properties7GenericV8mono_log{{[_0-9a-zA-Z]*}}vs
+ // CHECK: apply [[GENERIC_SET_METHOD]]<
+}
+
+// CHECK-LABEL: sil hidden @$S10properties26generic_mono_subscript_get{{[_0-9a-zA-Z]*}}F
+func generic_mono_subscript_get<T>(_ g: Generic<T>, i: Int) -> Float {
+ return g[i]
+ // CHECK: [[GENERIC_GET_METHOD:%[0-9]+]] = function_ref @$S10properties7GenericV{{[_0-9a-zA-Z]*}}ig
+ // CHECK: apply [[GENERIC_GET_METHOD]]<
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}generic_mono_subscript_set
+func generic_mono_subscript_set<T>(_ g: inout Generic<T>, i: Int, x: Float) {
+ g[i] = x
+ // CHECK: [[GENERIC_SET_METHOD:%[0-9]+]] = function_ref @$S10properties7GenericV{{[_0-9a-zA-Z]*}}is
+ // CHECK: apply [[GENERIC_SET_METHOD]]<
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}bound_generic_mono_phys_get
+func bound_generic_mono_phys_get(_ g: inout Generic<UnicodeScalar>, x: Int) -> Int {
+ return g.mono_phys
+ // CHECK: struct_element_addr %{{.*}}, #Generic.mono_phys
+}
+
+// CHECK-LABEL: sil hidden @$S10properties26bound_generic_mono_log_get{{[_0-9a-zA-Z]*}}F
+func bound_generic_mono_log_get(_ g: Generic<UnicodeScalar>, x: Int) -> Int {
+ return g.mono_log
+// CHECK: [[GENERIC_GET_METHOD:%[0-9]+]] = function_ref @$S10properties7GenericV8mono_log{{[_0-9a-zA-Z]*}}vg
+ // CHECK: apply [[GENERIC_GET_METHOD]]<
+}
+
+// CHECK-LABEL: sil hidden @$S10properties22generic_subscript_type{{[_0-9a-zA-Z]*}}F
+func generic_subscript_type<T>(_ g: Generic<T>, i: T, x: T) -> T {
+ var g = g
+ g[i] = x
+ return g[i]
+}
+
+/*TODO: archetype and existential properties and subscripts */
+
+struct StaticProperty {
+ static var foo: Int {
+ get {
+ return zero
+ }
+ set {}
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10properties10static_get{{[_0-9a-zA-Z]*}}F
+// CHECK: function_ref @$S10properties14StaticPropertyV3foo{{[_0-9a-zA-Z]*}}vgZ : $@convention(method) (@thin StaticProperty.Type) -> Int
+func static_get() -> Int {
+ return StaticProperty.foo
+}
+
+// CHECK-LABEL: sil hidden @$S10properties10static_set{{[_0-9a-zA-Z]*}}F
+// CHECK: function_ref @$S10properties14StaticPropertyV3foo{{[_0-9a-zA-Z]*}}vsZ : $@convention(method) (Int, @thin StaticProperty.Type) -> ()
+func static_set(_ x: Int) {
+ StaticProperty.foo = x
+}
+
+func takeInt(_ a : Int) {}
+
+protocol ForceAccessors {
+ var a: Int { get set }
+}
+
+struct DidSetWillSetTests: ForceAccessors {
+ var a: Int {
+ willSet(newA) {
+ // CHECK-LABEL: // {{.*}}.DidSetWillSetTests.a.willset
+ // CHECK-NEXT: sil hidden @$S10properties010DidSetWillC5TestsV1a{{[_0-9a-zA-Z]*}}vw
+ // CHECK: bb0(%0 : $Int, %1 : $*DidSetWillSetTests):
+ // CHECK-NEXT: debug_value %0
+ // CHECK-NEXT: debug_value_addr %1 : $*DidSetWillSetTests
+
+ takeInt(a)
+
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] %1
+ // CHECK-NEXT: [[FIELDPTR:%.*]] = struct_element_addr [[READ]] : $*DidSetWillSetTests, #DidSetWillSetTests.a
+ // CHECK-NEXT: [[A:%.*]] = load [trivial] [[FIELDPTR]] : $*Int
+ // CHECK-NEXT: end_access [[READ]]
+ // CHECK: [[TAKEINTFN:%.*]] = function_ref @$S10properties7takeInt{{[_0-9a-zA-Z]*}}F
+ // CHECK-NEXT: apply [[TAKEINTFN]]([[A]]) : $@convention(thin) (Int) -> ()
+
+ takeInt(newA)
+
+ // CHECK-NEXT: // function_ref properties.takeInt(Swift.Int) -> ()
+ // CHECK-NEXT: [[TAKEINTFN:%.*]] = function_ref @$S10properties7takeInt{{[_0-9a-zA-Z]*}}F
+ // CHECK-NEXT: apply [[TAKEINTFN]](%0) : $@convention(thin) (Int) -> ()
+ }
+
+ didSet {
+ // CHECK-LABEL: // {{.*}}.DidSetWillSetTests.a.didset
+ // CHECK-NEXT: sil hidden @$S10properties010DidSetWillC5TestsV1a{{[_0-9a-zA-Z]*}}vW
+ // CHECK: bb0(%0 : $Int, %1 : $*DidSetWillSetTests):
+ // CHECK-NEXT: debug
+ // CHECK-NEXT: debug_value_addr %1 : $*DidSetWillSetTests
+
+ takeInt(a)
+
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] %1
+ // CHECK-NEXT: [[AADDR:%.*]] = struct_element_addr [[READ]] : $*DidSetWillSetTests, #DidSetWillSetTests.a
+ // CHECK-NEXT: [[A:%.*]] = load [trivial] [[AADDR]] : $*Int
+ // CHECK-NEXT: end_access [[READ]]
+ // CHECK-NEXT: // function_ref properties.takeInt(Swift.Int) -> ()
+ // CHECK-NEXT: [[TAKEINTFN:%.*]] = function_ref @$S10properties7takeInt{{[_0-9a-zA-Z]*}}F
+ // CHECK-NEXT: apply [[TAKEINTFN]]([[A]]) : $@convention(thin) (Int) -> ()
+
+ a = zero // reassign, but don't infinite loop.
+
+ // CHECK-NEXT: // function_ref properties.zero.unsafeMutableAddressor : Swift.Int
+ // CHECK-NEXT: [[ZEROFN:%.*]] = function_ref @$S10properties4zero{{[_0-9a-zA-Z]*}}vau
+ // CHECK-NEXT: [[ZERORAW:%.*]] = apply [[ZEROFN]]() : $@convention(thin) () -> Builtin.RawPointer
+ // CHECK-NEXT: [[ZEROADDR:%.*]] = pointer_to_address [[ZERORAW]] : $Builtin.RawPointer to [strict] $*Int
+ // CHECK-NEXT: [[READ:%.*]] = begin_access [read] [dynamic] [[ZEROADDR]] : $*Int
+ // CHECK-NEXT: [[ZERO:%.*]] = load [trivial] [[READ]]
+ // CHECK-NEXT: end_access [[READ]] : $*Int
+ // CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [unknown] %1
+ // CHECK-NEXT: [[AADDR:%.*]] = struct_element_addr [[WRITE]] : $*DidSetWillSetTests, #DidSetWillSetTests.a
+ // CHECK-NEXT: assign [[ZERO]] to [[AADDR]]
+ }
+ }
+
+ init(x : Int) {
+ // Accesses to didset/willset variables are direct in init methods and dtors.
+ a = x
+ a = x
+ }
+
+ // These are the synthesized getter and setter for the willset/didset variable.
+
+ // CHECK-LABEL: // {{.*}}.DidSetWillSetTests.a.getter
+ // CHECK-NEXT: sil hidden [transparent] @$S10properties010DidSetWillC5TestsV1aSivg
+ // CHECK: bb0(%0 : $DidSetWillSetTests):
+ // CHECK-NEXT: debug_value %0
+ // CHECK-NEXT: %2 = struct_extract %0 : $DidSetWillSetTests, #DidSetWillSetTests.a
+ // CHECK-NEXT: return %2 : $Int{{.*}} // id: %3
+
+ // CHECK-LABEL: // {{.*}}.DidSetWillSetTests.a.setter
+ // CHECK-NEXT: sil hidden @$S10properties010DidSetWillC5TestsV1aSivs
+ // CHECK: bb0(%0 : $Int, %1 : $*DidSetWillSetTests):
+ // CHECK-NEXT: debug_value %0
+ // CHECK-NEXT: debug_value_addr %1
+
+ // CHECK-NEXT: [[READ:%.*]] = begin_access [read] [unknown] %1
+ // CHECK-NEXT: [[AADDR:%.*]] = struct_element_addr [[READ]] : $*DidSetWillSetTests, #DidSetWillSetTests.a
+ // CHECK-NEXT: [[OLDVAL:%.*]] = load [trivial] [[AADDR]] : $*Int
+ // CHECK-NEXT: end_access [[READ]]
+ // CHECK-NEXT: debug_value [[OLDVAL]] : $Int, let, name "tmp"
+
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] %1
+ // CHECK-NEXT: // function_ref {{.*}}.DidSetWillSetTests.a.willset : Swift.Int
+ // CHECK-NEXT: [[WILLSETFN:%.*]] = function_ref @$S10properties010DidSetWillC5TestsV1a{{[_0-9a-zA-Z]*}}vw
+ // CHECK-NEXT: apply [[WILLSETFN]](%0, [[WRITE]]) : $@convention(method) (Int, @inout DidSetWillSetTests) -> ()
+ // CHECK-NEXT: end_access [[WRITE]]
+ // CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [unknown] %1
+ // CHECK-NEXT: [[AADDR:%.*]] = struct_element_addr [[WRITE]] : $*DidSetWillSetTests, #DidSetWillSetTests.a
+ // CHECK-NEXT: assign %0 to [[AADDR]] : $*Int
+ // CHECK-NEXT: end_access [[WRITE]]
+ // CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [unknown] %1
+ // CHECK-NEXT: // function_ref {{.*}}.DidSetWillSetTests.a.didset : Swift.Int
+ // CHECK-NEXT: [[DIDSETFN:%.*]] = function_ref @$S10properties010DidSetWillC5TestsV1a{{[_0-9a-zA-Z]*}}vW : $@convention(method) (Int, @inout DidSetWillSetTests) -> ()
+ // CHECK-NEXT: apply [[DIDSETFN]]([[OLDVAL]], [[WRITE]]) : $@convention(method) (Int, @inout DidSetWillSetTests) -> ()
+
+ // CHECK-LABEL: sil hidden @$S10properties010DidSetWillC5TestsV{{[_0-9a-zA-Z]*}}fC
+ // CHECK: bb0(%0 : $Int, %1 : $@thin DidSetWillSetTests.Type):
+ // CHECK: [[SELF:%.*]] = mark_uninitialized [rootself]
+ // CHECK: [[PB_SELF:%.*]] = project_box [[SELF]]
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB_SELF]]
+ // CHECK: [[P1:%.*]] = struct_element_addr [[WRITE]] : $*DidSetWillSetTests, #DidSetWillSetTests.a
+ // CHECK-NEXT: assign %0 to [[P1]]
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB_SELF]]
+ // CHECK: [[P2:%.*]] = struct_element_addr [[WRITE]] : $*DidSetWillSetTests, #DidSetWillSetTests.a
+ // CHECK-NEXT: assign %0 to [[P2]]
+}
+
+
+// Test global observing properties.
+
+var global_observing_property : Int = zero {
+ didSet {
+ takeInt(global_observing_property)
+ }
+}
+
+func force_global_observing_property_setter() {
+ let x = global_observing_property
+ global_observing_property = x
+}
+
+// The property is initialized with "zero".
+// CHECK-LABEL: sil private @globalinit_{{.*}}_func1 : $@convention(c) () -> () {
+// CHECK: bb0:
+// CHECK-NEXT: alloc_global @$S10properties25global_observing_propertySiv
+// CHECK-NEXT: %1 = global_addr @$S10properties25global_observing_propertySivp : $*Int
+// CHECK: properties.zero.unsafeMutableAddressor
+// CHECK: return
+
+// The didSet implementation needs to call takeInt.
+
+// CHECK-LABEL: sil hidden @$S10properties25global_observing_property{{[_0-9a-zA-Z]*}}vW
+// CHECK: function_ref properties.takeInt
+// CHECK-NEXT: function_ref @$S10properties7takeInt{{[_0-9a-zA-Z]*}}F
+
+// The setter needs to call didSet implementation.
+
+// CHECK-LABEL: sil hidden @$S10properties25global_observing_property{{[_0-9a-zA-Z]*}}vs
+// CHECK: function_ref properties.global_observing_property.unsafeMutableAddressor
+// CHECK-NEXT: function_ref @$S10properties25global_observing_property{{[_0-9a-zA-Z]*}}vau
+// CHECK: function_ref properties.global_observing_property.didset
+// CHECK-NEXT: function_ref @$S10properties25global_observing_property{{[_0-9a-zA-Z]*}}vW
+
+
+// Test local observing properties.
+
+func local_observing_property(_ arg: Int) {
+ var localproperty: Int = arg {
+ didSet {
+ takeInt(localproperty)
+ }
+ }
+
+ takeInt(localproperty)
+ localproperty = arg
+}
+
+// This is the local_observing_property function itself. First alloc and
+// initialize the property to the argument value.
+
+// CHECK-LABEL: sil hidden @{{.*}}local_observing_property
+// CHECK: bb0([[ARG:%[0-9]+]] : $Int)
+// CHECK: [[BOX:%[0-9]+]] = alloc_box ${ var Int }
+// CHECK: [[PB:%.*]] = project_box [[BOX]]
+// CHECK: store [[ARG]] to [trivial] [[PB]]
+
+func local_generic_observing_property<T>(_ arg: Int, _: T) {
+ var localproperty1: Int = arg {
+ didSet {
+ takeInt(localproperty1)
+ }
+ }
+
+ takeInt(localproperty1)
+ localproperty1 = arg
+
+ var localproperty2: Int = arg {
+ didSet {
+ _ = T.self
+ takeInt(localproperty2)
+ }
+ }
+
+ takeInt(localproperty2)
+ localproperty2 = arg
+}
+
+
+// <rdar://problem/16006333> observing properties don't work in @objc classes
+@objc
+class ObservingPropertyInObjCClass {
+ var bounds: Int {
+ willSet {}
+ didSet {}
+ }
+
+ init(b: Int) { bounds = b }
+}
+
+
+
+// Superclass init methods should not get direct access to be class properties.
+// rdar://16151899
+
+class rdar16151899Base {
+ var x: Int = zero {
+ willSet {
+ use(x)
+ }
+ }
+}
+
+class rdar16151899Derived : rdar16151899Base {
+ // CHECK-LABEL: sil hidden @$S10properties19rdar16151899DerivedC{{[_0-9a-zA-Z]*}}fc
+ override init() {
+ super.init()
+ // CHECK: upcast {{.*}} : $rdar16151899Derived to $rdar16151899Base
+ // CHECK: function_ref @$S10properties16rdar16151899BaseCACycfc : $@convention(method) (@owned rdar16151899Base) -> @owned rdar16151899Base
+
+ // This should not be a direct access, it should call the setter in the
+ // base.
+ x = zero
+
+ // CHECK: [[BASEPTR:%[0-9]+]] = upcast {{.*}} : $rdar16151899Derived to $rdar16151899Base
+ // CHECK: load{{.*}}Int
+ // CHECK-NEXT: end_access {{.*}} : $*Int
+ // CHECK-NEXT: [[SETTER:%[0-9]+]] = class_method {{.*}} : $rdar16151899Base, #rdar16151899Base.x!setter.1 : (rdar16151899Base)
+ // CHECK-NEXT: apply [[SETTER]]({{.*}}, [[BASEPTR]])
+ }
+}
+
+
+func propertyWithDidSetTakingOldValue() {
+ var p : Int = zero {
+ didSet(oldValue) {
+ // access to oldValue
+ use(oldValue)
+ // and newValue.
+ use(p)
+ }
+ }
+
+ p = zero
+}
+
+// CHECK: // setter of p #1 : Swift.Int in properties.propertyWithDidSetTakingOldValue()
+// CHECK-NEXT: sil {{.*}} @$S10properties32propertyWithDidSetTakingOldValueyyF1pL_Sivs
+// CHECK: bb0([[ARG1:%.*]] : $Int, [[ARG2:%.*]] : ${ var Int }):
+// CHECK-NEXT: debug_value [[ARG1]] : $Int, let, name "newValue", argno 1
+// CHECK-NEXT: [[ARG2_PB:%.*]] = project_box [[ARG2]]
+// CHECK-NEXT: debug_value_addr [[ARG2_PB]] : $*Int, var, name "p", argno 2
+// CHECK-NEXT: [[READ:%.*]] = begin_access [read] [unknown] [[ARG2_PB]]
+// CHECK-NEXT: [[ARG2_PB_VAL:%.*]] = load [trivial] [[READ]] : $*Int
+// CHECK-NEXT: end_access [[READ]]
+// CHECK-NEXT: debug_value [[ARG2_PB_VAL]] : $Int
+// CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [unknown] [[ARG2_PB]]
+// CHECK-NEXT: assign [[ARG1]] to [[WRITE]] : $*Int
+// CHECK-NEXT: end_access [[WRITE]]
+// SEMANTIC ARC TODO: Another case where we need to put the mark_function_escape on a new projection after a copy.
+// CHECK-NEXT: mark_function_escape [[ARG2_PB]]
+// CHECK-NEXT: // function_ref
+// CHECK-NEXT: [[FUNC:%.*]] = function_ref @$S10properties32propertyWithDidSetTakingOldValueyyF1pL_SivW : $@convention(thin) (Int, @guaranteed { var Int }) -> ()
+// CHECK-NEXT: %{{.*}} = apply [[FUNC]]([[ARG2_PB_VAL]], [[ARG2]]) : $@convention(thin) (Int, @guaranteed { var Int }) -> ()
+// CHECK-NEXT: %{{.*}} = tuple ()
+// CHECK-NEXT: return %{{.*}} : $()
+// CHECK-NEXT:} // end sil function '$S10properties32propertyWithDidSetTakingOldValue{{[_0-9a-zA-Z]*}}'
+
+
+class BaseProperty {
+ var x : Int { get {} set {} }
+}
+
+class DerivedProperty : BaseProperty {
+ override var x : Int { get {} set {} }
+
+ func super_property_reference() -> Int {
+ return super.x
+ }
+}
+
+// rdar://16381392 - Super property references in non-objc classes should be direct.
+
+// CHECK-LABEL: sil hidden @$S10properties15DerivedPropertyC24super_property_referenceSiyF : $@convention(method) (@guaranteed DerivedProperty) -> Int {
+// CHECK: bb0([[SELF:%.*]] : $DerivedProperty):
+// CHECK: [[SELF_COPY:%[0-9]+]] = copy_value [[SELF]]
+// CHECK: [[BASEPTR:%[0-9]+]] = upcast [[SELF_COPY]] : $DerivedProperty to $BaseProperty
+// CHECK: [[FN:%[0-9]+]] = function_ref @$S10properties12BasePropertyC1xSivg : $@convention(method) (@guaranteed BaseProperty) -> Int
+// CHECK: [[RESULT:%.*]] = apply [[FN]]([[BASEPTR]]) : $@convention(method) (@guaranteed BaseProperty) -> Int
+// CHECK: destroy_value [[BASEPTR]]
+// CHECK: return [[RESULT]] : $Int
+// CHECK: } // end sil function '$S10properties15DerivedPropertyC24super_property_referenceSiyF'
+
+
+// <rdar://problem/16411449> ownership qualifiers don't work with non-mutating struct property
+struct ReferenceStorageTypeRValues {
+ unowned var p1 : Ref
+
+ func testRValueUnowned() -> Ref {
+ return p1
+ }
+// CHECK: sil hidden @{{.*}}testRValueUnowned{{.*}} : $@convention(method) (@guaranteed ReferenceStorageTypeRValues) -> @owned Ref {
+// CHECK: bb0([[ARG:%.*]] : $ReferenceStorageTypeRValues):
+// CHECK-NEXT: debug_value [[ARG]] : $ReferenceStorageTypeRValues
+// CHECK-NEXT: [[UNOWNED_ARG_FIELD:%.*]] = struct_extract [[ARG]] : $ReferenceStorageTypeRValues, #ReferenceStorageTypeRValues.p1
+// CHECK-NEXT: [[COPIED_VALUE:%.*]] = copy_unowned_value [[UNOWNED_ARG_FIELD]]
+// CHECK-NEXT: return [[COPIED_VALUE]] : $Ref
+
+ init() {
+ }
+}
+
+
+// <rdar://problem/16406886> Observing properties don't work with ownership types
+struct ObservingPropertiesWithOwnershipTypes {
+ unowned var alwaysPresent : Ref {
+ didSet {
+ }
+ }
+
+ init(res: Ref) {
+ alwaysPresent = res
+ }
+}
+
+struct ObservingPropertiesWithOwnershipTypesInferred {
+ unowned var alwaysPresent = Ref(i: 0) {
+ didSet {
+ }
+ }
+
+ weak var maybePresent = nil as Ref? {
+ willSet {
+ }
+ }
+}
+
+// <rdar://problem/16554876> property accessor synthesization of weak variables doesn't work
+protocol WeakPropertyProtocol {
+ var maybePresent : Ref? { get set }
+}
+
+struct WeakPropertyStruct : WeakPropertyProtocol {
+ weak var maybePresent : Ref?
+
+ init() {
+ maybePresent = nil
+ }
+}
+
+// <rdar://problem/16629598> direct property accesses to generic struct
+// properties were being mischecked as computed property accesses.
+
+struct SomeGenericStruct<T> {
+ var x: Int
+}
+
+// CHECK-LABEL: sil hidden @$S10properties4getX{{[_0-9a-zA-Z]*}}F
+// CHECK: struct_extract {{%.*}} : $SomeGenericStruct<T>, #SomeGenericStruct.x
+func getX<T>(_ g: SomeGenericStruct<T>) -> Int {
+ return g.x
+}
+
+
+// <rdar://problem/16189360> [DF] Assert on subscript with variadic parameter
+struct VariadicSubscript {
+ subscript(subs: Int...) -> Int {
+ get {
+ return 42
+ }
+ }
+
+ func test() {
+ var s = VariadicSubscript()
+ var x = s[0, 1, 2]
+ }
+}
+
+
+//<rdar://problem/16620121> Initializing constructor tries to initialize computed property overridden with willSet/didSet
+class ObservedBase {
+ var printInfo: Ref!
+}
+class ObservedDerived : ObservedBase {
+ override init() {}
+ override var printInfo: Ref! {
+ didSet { }
+ }
+}
+
+
+
+/// <rdar://problem/16953517> Class properties should be allowed in protocols, even without stored class properties
+protocol ProtoWithClassProp {
+ static var x: Int { get }
+}
+
+class ClassWithClassProp : ProtoWithClassProp {
+ class var x: Int {
+ return 42
+ }
+}
+
+struct StructWithClassProp : ProtoWithClassProp {
+ static var x: Int {
+ return 19
+ }
+}
+
+
+func getX<T : ProtoWithClassProp>(_ a : T) -> Int {
+ return T.x
+}
+
+func testClassPropertiesInProtocol() -> Int {
+ return getX(ClassWithClassProp())+getX(StructWithClassProp())
+}
+
+class GenericClass<T> {
+ var x: T
+ var y: Int
+ final let z: T
+
+ init() { fatalError("scaffold") }
+}
+
+// CHECK-LABEL: sil hidden @$S10properties12genericPropsyyAA12GenericClassCySSGF : $@convention(thin) (@guaranteed GenericClass<String>) -> () {
+func genericProps(_ x: GenericClass<String>) {
+ // CHECK: bb0([[ARG:%.*]] : $GenericClass<String>):
+ // CHECK: class_method [[ARG]] : $GenericClass<String>, #GenericClass.x!getter.1
+ // CHECK: apply {{.*}}<String>({{.*}}, [[ARG]]) : $@convention(method) <τ_0_0> (@guaranteed GenericClass<τ_0_0>) -> @out τ_0_0
+ let _ = x.x
+ // CHECK: class_method [[ARG]] : $GenericClass<String>, #GenericClass.y!getter.1
+ // CHECK: apply {{.*}}<String>([[ARG]]) : $@convention(method) <τ_0_0> (@guaranteed GenericClass<τ_0_0>) -> Int
+ let _ = x.y
+ // CHECK: [[Z:%.*]] = ref_element_addr [[ARG]] : $GenericClass<String>, #GenericClass.z
+ // CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[Z]] : $*String
+ // CHECK: [[LOADED_Z:%.*]] = load [copy] [[READ]] : $*String
+ // CHECK: destroy_value [[LOADED_Z]]
+ // CHECK-NOT: destroy_value [[ARG]]
+ let _ = x.z
+}
+
+// CHECK-LABEL: sil hidden @$S10properties28genericPropsInGenericContext{{[_0-9a-zA-Z]*}}F
+func genericPropsInGenericContext<U>(_ x: GenericClass<U>) {
+ // CHECK: bb0([[ARG:%.*]] : $GenericClass<U>):
+ // CHECK: [[Z:%.*]] = ref_element_addr [[ARG]] : $GenericClass<U>, #GenericClass.z
+ // CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[Z]] : $*U
+ // CHECK: copy_addr [[READ]] {{.*}} : $*U
+ let _ = x.z
+}
+
+
+// <rdar://problem/18275556> 'let' properties in a class should be implicitly final
+class ClassWithLetProperty {
+ let p = 42
+ dynamic let q = 97
+
+ // We shouldn't have any dynamic dispatch within this method, just load p.
+ func ReturnConstant() -> Int { return p }
+// CHECK-LABEL: sil hidden @$S10properties20ClassWithLetPropertyC14ReturnConstant{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[ARG:%.*]] : $ClassWithLetProperty):
+// CHECK-NEXT: debug_value
+// CHECK-NEXT: [[PTR:%[0-9]+]] = ref_element_addr [[ARG]] : $ClassWithLetProperty, #ClassWithLetProperty.p
+// CHECK-NEXT: [[READ:%.*]] = begin_access [read] [dynamic] [[PTR]] : $*Int
+// CHECK-NEXT: [[VAL:%[0-9]+]] = load [trivial] [[READ]] : $*Int
+// CHECK-NEXT: end_access [[READ]] : $*Int
+// CHECK-NEXT: return [[VAL]] : $Int
+
+
+ // This property is marked dynamic, so go through the getter, always.
+ func ReturnDynamicConstant() -> Int { return q }
+// CHECK-LABEL: sil hidden @$S10properties20ClassWithLetPropertyC21ReturnDynamicConstant{{[_0-9a-zA-Z]*}}F
+// CHECK: objc_method %0 : $ClassWithLetProperty, #ClassWithLetProperty.q!getter.1.foreign
+}
+
+
+// <rdar://problem/19254812> DI bug when referencing let member of a class
+class r19254812Base {}
+class r19254812Derived: r19254812Base{
+ let pi = 3.14159265359
+
+ init(x : ()) {
+ use(pi)
+ }
+
+// Accessing the "pi" property should not copy_value/release self.
+// CHECK-LABEL: sil hidden @$S10properties16r19254812DerivedC{{[_0-9a-zA-Z]*}}fc
+// CHECK: [[MARKED_SELF_BOX:%.*]] = mark_uninitialized [derivedself]
+// CHECK: [[PB_BOX:%.*]] = project_box [[MARKED_SELF_BOX]]
+
+// Initialization of the pi field: no copy_values/releases.
+// CHECK: [[SELF:%[0-9]+]] = load_borrow [[PB_BOX]] : $*r19254812Derived
+// CHECK-NEXT: [[PIPTR:%[0-9]+]] = ref_element_addr [[SELF]] : $r19254812Derived, #r19254812Derived.pi
+// CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[PIPTR]] : $*Double
+// CHECK-NEXT: assign {{.*}} to [[WRITE]] : $*Double
+
+// CHECK-NOT: destroy_value
+// CHECK-NOT: copy_value
+
+// Load of the pi field: no copy_values/releases.
+// CHECK: [[SELF:%[0-9]+]] = load_borrow [[PB_BOX]] : $*r19254812Derived
+// CHECK-NEXT: [[PIPTR:%[0-9]+]] = ref_element_addr [[SELF]] : $r19254812Derived, #r19254812Derived.pi
+// CHECK-NEXT: [[READ:%.*]] = begin_access [read] [dynamic] [[PIPTR]] : $*Double
+// CHECK-NEXT: {{.*}} = load [trivial] [[READ]] : $*Double
+// CHECK-NEXT: end_access [[READ]] : $*Double
+// CHECK: return
+}
+
+
+class RedundantSelfRetains {
+ final var f : RedundantSelfRetains
+
+ init() {
+ f = RedundantSelfRetains()
+ }
+
+ // <rdar://problem/19275047> Extraneous copy_values/releases of self are bad
+ func testMethod1() {
+ f = RedundantSelfRetains()
+ }
+ // CHECK-LABEL: sil hidden @$S10properties20RedundantSelfRetainsC11testMethod1{{[_0-9a-zA-Z]*}}F
+ // CHECK: bb0(%0 : $RedundantSelfRetains):
+
+ // CHECK-NOT: copy_value
+
+ // CHECK: [[FPTR:%[0-9]+]] = ref_element_addr %0 : $RedundantSelfRetains, #RedundantSelfRetains.f
+ // CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[FPTR]] : $*RedundantSelfRetains
+ // CHECK-NEXT: assign {{.*}} to [[WRITE]] : $*RedundantSelfRetains
+
+ // CHECK: return
+}
+
+class RedundantRetains {
+ final var field = 0
+}
+
+func testRedundantRetains() {
+ let a = RedundantRetains()
+ a.field = 4 // no copy_value/release of a necessary here.
+}
+
+// CHECK-LABEL: sil hidden @$S10properties20testRedundantRetainsyyF : $@convention(thin) () -> () {
+// CHECK: [[A:%[0-9]+]] = apply
+// CHECK-NOT: copy_value
+// CHECK: destroy_value [[A]] : $RedundantRetains
+// CHECK-NOT: copy_value
+// CHECK-NOT: destroy_value
+// CHECK: return
+
+struct AddressOnlyNonmutatingSet<T> {
+ var x: T
+ init(x: T) { self.x = x }
+ var prop: Int {
+ get { return 0 }
+ nonmutating set { }
+ }
+}
+
+func addressOnlyNonmutatingProperty<T>(_ x: AddressOnlyNonmutatingSet<T>)
+-> Int {
+ x.prop = 0
+ return x.prop
+}
+// CHECK-LABEL: sil hidden @$S10properties30addressOnlyNonmutatingProperty{{[_0-9a-zA-Z]*}}F
+// CHECK: [[SET:%.*]] = function_ref @$S10properties25AddressOnlyNonmutatingSetV4propSivs
+// CHECK: apply [[SET]]<T>({{%.*}}, [[TMP:%[0-9]*]])
+// CHECK: destroy_addr [[TMP]]
+// CHECK: dealloc_stack [[TMP]]
+// CHECK: [[GET:%.*]] = function_ref @$S10properties25AddressOnlyNonmutatingSetV4propSivg
+// CHECK: apply [[GET]]<T>([[TMP:%[0-9]*]])
+// CHECK: destroy_addr [[TMP]]
+// CHECK: dealloc_stack [[TMP]]
+
+protocol MakeAddressOnly {}
+struct AddressOnlyReadOnlySubscript {
+ var x: MakeAddressOnly?
+
+ subscript(z: Int) -> Int { return z }
+}
+
+// CHECK-LABEL: sil hidden @$S10properties015addressOnlyReadC24SubscriptFromMutableBase
+// CHECK: [[BASE:%.*]] = alloc_box ${ var AddressOnlyReadOnlySubscript }
+// CHECK: copy_addr [[BASE:%.*]] to [initialization] [[COPY:%.*]] :
+// CHECK: [[GETTER:%.*]] = function_ref @$S10properties015AddressOnlyReadC9SubscriptV{{[_0-9a-zA-Z]*}}ig
+// CHECK: apply [[GETTER]]({{%.*}}, [[COPY]])
+func addressOnlyReadOnlySubscriptFromMutableBase(_ x: Int) {
+ var base = AddressOnlyReadOnlySubscript()
+ _ = base[x]
+}
+
+
+
+/// <rdar://problem/20912019> passing unmaterialized r-value as inout argument
+struct MutatingGetterStruct {
+ var write: Int {
+ mutating get { }
+ }
+
+ // CHECK-LABEL: sil hidden @$S10properties20MutatingGetterStructV4test
+ // CHECK: [[X:%.*]] = alloc_box ${ var MutatingGetterStruct }, var, name "x"
+ // CHECK-NEXT: [[PB:%.*]] = project_box [[X]]
+ // CHECK: store {{.*}} to [trivial] [[PB]] : $*MutatingGetterStruct
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB]]
+ // CHECK: apply {{%.*}}([[WRITE]]) : $@convention(method) (@inout MutatingGetterStruct) -> Int
+ static func test() {
+ var x = MutatingGetterStruct()
+ _ = x.write
+ }
+}
+
+
+protocol ProtocolWithReadWriteSubscript {
+ subscript(i: Int) -> Int { get set }
+}
+
+struct CrashWithUnnamedSubscript : ProtocolWithReadWriteSubscript {
+ subscript(_: Int) -> Int { get { } set { } }
+}
+
+
+/// <rdar://problem/26408353> crash when overriding internal property with
+/// public property
+
+public class BaseClassWithInternalProperty {
+ var x: () = ()
+}
+
+public class DerivedClassWithPublicProperty : BaseClassWithInternalProperty {
+ public override var x: () {
+ didSet {}
+ }
+}
+
+// CHECK-LABEL: sil hidden [transparent] @$S10properties29BaseClassWithInternalPropertyC1xytvg
+
+// CHECK-LABEL: sil [transparent] [serialized] @$S10properties30DerivedClassWithPublicPropertyC1xytvg
+// CHECK: bb0([[SELF:%.*]] : $DerivedClassWithPublicProperty):
+// CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]] : $DerivedClassWithPublicProperty
+// CHECK-NEXT: [[SUPER:%.*]] = upcast [[SELF_COPY]] : $DerivedClassWithPublicProperty to $BaseClassWithInternalProperty
+// CHECK-NEXT: [[BORROWED_SUPER:%.*]] = begin_borrow [[SUPER]]
+// CHECK-NEXT: [[DOWNCAST_BORROWED_SUPER:%.*]] = unchecked_ref_cast [[BORROWED_SUPER]] : $BaseClassWithInternalProperty to $DerivedClassWithPublicProperty
+// CHECK-NEXT: [[METHOD:%.*]] = super_method [[DOWNCAST_BORROWED_SUPER]] : $DerivedClassWithPublicProperty, #BaseClassWithInternalProperty.x!getter.1 : (BaseClassWithInternalProperty) -> () -> (), $@convention(method) (@guaranteed BaseClassWithInternalProperty) -> ()
+// CHECK-NEXT: end_borrow [[BORROWED_SUPER]] from [[SUPER]]
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]([[SUPER]]) : $@convention(method) (@guaranteed BaseClassWithInternalProperty) -> ()
+// CHECK-NEXT: destroy_value [[SUPER]] : $BaseClassWithInternalProperty
+// CHECK: } // end sil function '$S10properties30DerivedClassWithPublicPropertyC1xytvg'
+
+// Make sure that we can handle this AST:
+// (load_expr
+// (open_existential_expr
+// (opaque_expr A)
+// ...
+// (load_expr
+// (opaque_expr ))))
+
+class ReferenceType {
+ var p: NonmutatingProtocol
+ init(p: NonmutatingProtocol) { self.p = p }
+}
+
+protocol NonmutatingProtocol {
+ var x: Int { get nonmutating set }
+}
+
+// sil hidden @$S10properties19overlappingLoadExpr1cyAA13ReferenceTypeCz_tF : $@convention(thin) (@inout ReferenceType) -> () {
+// CHECK: [[RESULT:%.*]] = alloc_stack $Int
+// CHECK-NEXT: [[UNINIT:%.*]] = mark_uninitialized [var] [[RESULT]] : $*Int
+// CHECK-NEXT: [[C_INOUT:%.*]] = begin_access [read] [unknown] %0 : $*ReferenceType
+// CHECK-NEXT: [[C:%.*]] = load [copy] [[C_INOUT:%.*]] : $*ReferenceType
+// CHECK-NEXT: end_access [[C_INOUT]] : $*ReferenceType
+// CHECK-NEXT: [[C_FIELD_BOX:%.*]] = alloc_stack $NonmutatingProtocol
+// CHECK-NEXT: [[GETTER:%.*]] = class_method [[C]] : $ReferenceType, #ReferenceType.p!getter.1 : (ReferenceType) -> () -> NonmutatingProtocol, $@convention(method) (@guaranteed ReferenceType) -> @out NonmutatingProtocol
+// CHECK-NEXT: apply [[GETTER]]([[C_FIELD_BOX]], [[C]]) : $@convention(method) (@guaranteed ReferenceType) -> @out NonmutatingProtocol
+
+// CHECK-NEXT: [[C_FIELD_PAYLOAD:%.*]] = open_existential_addr immutable_access [[C_FIELD_BOX]] : $*NonmutatingProtocol to $*@opened("{{.*}}") NonmutatingProtocol
+// CHECK-NEXT: [[C_FIELD_COPY:%.*]] = alloc_stack $@opened("{{.*}}") NonmutatingProtocol
+// CHECK-NEXT: copy_addr [[C_FIELD_PAYLOAD]] to [initialization] [[C_FIELD_COPY]] : $*@opened("{{.*}}") NonmutatingProtocol
+// CHECK-NEXT: [[GETTER:%.*]] = witness_method $@opened("{{.*}}") NonmutatingProtocol, #NonmutatingProtocol.x!getter.1 : <Self where Self : NonmutatingProtocol> (Self) -> () -> Int, [[C_FIELD_PAYLOAD]] : $*@opened("{{.*}}") NonmutatingProtocol : $@convention(witness_method: NonmutatingProtocol) <τ_0_0 where τ_0_0 : NonmutatingProtocol> (@in_guaranteed τ_0_0) -> Int
+// CHECK-NEXT: [[RESULT_VALUE:%.*]] = apply [[GETTER]]<@opened("{{.*}}") NonmutatingProtocol>([[C_FIELD_COPY]]) : $@convention(witness_method: NonmutatingProtocol) <τ_0_0 where τ_0_0 : NonmutatingProtocol> (@in_guaranteed τ_0_0) -> Int
+// CHECK-NEXT: assign [[RESULT_VALUE]] to [[UNINIT]] : $*Int
+// CHECK-NEXT: destroy_addr [[C_FIELD_COPY]] : $*@opened("{{.*}}") NonmutatingProtocol
+// CHECK-NEXT: destroy_addr [[C_FIELD_BOX]] : $*NonmutatingProtocol
+// CHECK-NEXT: destroy_value [[C]] : $ReferenceType
+// CHECK-NEXT: dealloc_stack [[C_FIELD_COPY]] : $*@opened("{{.*}}") NonmutatingProtocol
+// CHECK-NEXT: dealloc_stack [[C_FIELD_BOX]] : $*NonmutatingProtocol
+// CHECK-NEXT: dealloc_stack [[RESULT]] : $*Int
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: return
+
+func overlappingLoadExpr(c: inout ReferenceType) {
+ _ = c.p.x
+}
diff --git a/test/SILGen/plus_zero_property_abstraction.swift b/test/SILGen/plus_zero_property_abstraction.swift
new file mode 100644
index 0000000..ab74768
--- /dev/null
+++ b/test/SILGen/plus_zero_property_abstraction.swift
@@ -0,0 +1,144 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -emit-silgen %s | %FileCheck %s
+
+struct Int {
+ mutating func foo() {}
+}
+
+struct Foo<T, U> {
+ var f: (T) -> U
+
+ var g: T
+}
+
+// CHECK-LABEL: sil hidden @$S20property_abstraction4getF{{[_0-9a-zA-Z]*}}Foo{{.*}}F : $@convention(thin) (@guaranteed Foo<Int, Int>) -> @owned @callee_guaranteed (Int) -> Int {
+// CHECK: bb0([[X_ORIG:%.*]] : @guaranteed $Foo<Int, Int>):
+// CHECK: [[F_ORIG:%.*]] = struct_extract [[X_ORIG]] : $Foo<Int, Int>, #Foo.f
+// CHECK: [[F_ORIG_COPY:%.*]] = copy_value [[F_ORIG]]
+// CHECK: [[REABSTRACT_FN:%.*]] = function_ref @$S{{.*}}TR :
+// CHECK: [[F_SUBST:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACT_FN]]([[F_ORIG_COPY]])
+// CHECK: return [[F_SUBST]]
+// CHECK: } // end sil function '$S20property_abstraction4getF{{[_0-9a-zA-Z]*}}F'
+func getF(_ x: Foo<Int, Int>) -> (Int) -> Int {
+ return x.f
+}
+
+// CHECK-LABEL: sil hidden @$S20property_abstraction4setF{{[_0-9a-zA-Z]*}}F
+// CHECK: [[REABSTRACT_FN:%.*]] = function_ref @$S{{.*}}TR :
+// CHECK: [[F_ORIG:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACT_FN]]({{%.*}})
+// CHECK: [[F_ADDR:%.*]] = struct_element_addr {{%.*}} : $*Foo<Int, Int>, #Foo.f
+// CHECK: assign [[F_ORIG]] to [[F_ADDR]]
+func setF(_ x: inout Foo<Int, Int>, f: @escaping (Int) -> Int) {
+ x.f = f
+}
+
+func inOutFunc(_ f: inout ((Int) -> Int)) { }
+
+// CHECK-LABEL: sil hidden @$S20property_abstraction6inOutF{{[_0-9a-zA-Z]*}}F :
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Foo<Int, Int>):
+// CHECK: [[XBOX:%.*]] = alloc_box ${ var Foo<Int, Int> }, var, name "x"
+// CHECK: [[XBOX_PB:%.*]] = project_box [[XBOX]] : ${ var Foo<Int, Int> }, 0
+// CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK: store [[ARG_COPY]] to [init] [[XBOX_PB]]
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[XBOX_PB]] : $*Foo<Int, Int>
+// CHECK: [[F_ADDR:%.*]] = struct_element_addr [[WRITE]] : $*Foo<Int, Int>, #Foo.f
+// CHECK: [[F_SUBST_MAT:%.*]] = alloc_stack
+// CHECK: [[F_ORIG:%.*]] = load [copy] [[F_ADDR]]
+// CHECK: [[REABSTRACT_FN:%.*]] = function_ref @$S{{.*}}TR :
+// CHECK: [[F_SUBST_IN:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACT_FN]]([[F_ORIG]])
+// CHECK: store [[F_SUBST_IN]] to [init] [[F_SUBST_MAT]]
+// CHECK: [[INOUTFUNC:%.*]] = function_ref @$S20property_abstraction9inOutFunc{{[_0-9a-zA-Z]*}}F
+// CHECK: apply [[INOUTFUNC]]([[F_SUBST_MAT]])
+// CHECK: [[F_SUBST_OUT:%.*]] = load [take] [[F_SUBST_MAT]]
+// CHECK: [[REABSTRACT_FN:%.*]] = function_ref @$S{{.*}}TR :
+// CHECK: [[F_ORIG:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACT_FN]]([[F_SUBST_OUT]])
+// CHECK: assign [[F_ORIG]] to [[F_ADDR]]
+// CHECK: destroy_value [[XBOX]]
+// CHECK: } // end sil function '$S20property_abstraction6inOutF{{[_0-9a-zA-Z]*}}F'
+func inOutF(_ x: Foo<Int, Int>) {
+ var x = x
+ inOutFunc(&x.f)
+}
+
+// Don't produce a writeback for generic lvalues when there's no real
+// abstraction difference. <rdar://problem/16530674>
+// CHECK-LABEL: sil hidden @$S20property_abstraction23noAbstractionDifference{{[_0-9a-zA-Z]*}}F
+func noAbstractionDifference(_ x: Foo<Int, Int>) {
+ var x = x
+ // CHECK: [[ADDR:%.*]] = struct_element_addr {{%.*}}, #Foo.g
+ // CHECK: apply {{%.*}}([[ADDR]])
+ x.g.foo()
+}
+
+protocol P {}
+
+struct AddressOnlyLet<T> {
+ let f: (T) -> T
+ let makeAddressOnly: P
+}
+
+// CHECK-LABEL: sil hidden @$S20property_abstraction34getAddressOnlyReabstractedProperty{{[_0-9a-zA-Z]*}}F : $@convention(thin) (@in_guaranteed AddressOnlyLet<Int>) -> @owned @callee_guaranteed (Int) -> Int
+// CHECK: bb0([[ARG:%.*]] : @trivial $*AddressOnlyLet<Int>):
+// CHECK: [[CLOSURE_ADDR:%.*]] = struct_element_addr {{%.*}} : $*AddressOnlyLet<Int>, #AddressOnlyLet.f
+// CHECK: [[CLOSURE_ORIG:%.*]] = load [copy] [[CLOSURE_ADDR]]
+// CHECK: [[REABSTRACT:%.*]] = function_ref
+// CHECK: [[CLOSURE_SUBST:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACT]]([[CLOSURE_ORIG]])
+// CHECK-NOT: destroy_addr [[ARG]]
+// CHECK: return [[CLOSURE_SUBST]]
+// CHECK: } // end sil function '$S20property_abstraction34getAddressOnlyReabstractedProperty{{[_0-9a-zA-Z]*}}F'
+func getAddressOnlyReabstractedProperty(_ x: AddressOnlyLet<Int>) -> (Int) -> Int {
+ return x.f
+}
+
+enum Bar<T, U> {
+ case F((T) -> U)
+}
+
+func getF(_ x: Bar<Int, Int>) -> (Int) -> Int {
+ switch x {
+ case .F(var f):
+ return f
+ }
+}
+
+func makeF(_ f: @escaping (Int) -> Int) -> Bar<Int, Int> {
+ return Bar.F(f)
+}
+
+struct ArrayLike<T> {
+ subscript(x: ()) -> T { get {} set {} }
+}
+
+typealias Test20341012 = (title: (), action: () -> ())
+
+struct T20341012 {
+ private var options: ArrayLike<Test20341012> { get {} set {} }
+
+ // CHECK-LABEL: sil hidden @$S20property_abstraction9T20341012V1t{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[TMP1:%.*]] = alloc_stack $(title: (), action: @callee_guaranteed (@in_guaranteed ()) -> @out ())
+ // CHECK: apply {{.*}}<(title: (), action: () -> ())>([[TMP1]],
+ mutating func t() {
+ _ = self.options[].title
+ }
+}
+
+class MyClass {}
+
+// When simply assigning to a property, reabstract the r-value and assign
+// to the base instead of materializing and then assigning.
+protocol Factory {
+ associatedtype Product
+ var builder : () -> Product { get set }
+}
+func setBuilder<F: Factory where F.Product == MyClass>(_ factory: inout F) {
+ factory.builder = { return MyClass() }
+}
+// CHECK: sil hidden @$S20property_abstraction10setBuilder{{[_0-9a-zA-Z]*}}F : $@convention(thin) <F where F : Factory, F.Product == MyClass> (@inout F) -> ()
+// CHECK: bb0(%0 : @trivial $*F):
+// CHECK: [[F0:%.*]] = function_ref @$S20property_abstraction10setBuilder{{[_0-9a-zA-Z]*}} : $@convention(thin) () -> @owned MyClass
+// CHECK: [[F1:%.*]] = thin_to_thick_function [[F0]]
+// CHECK: [[REABSTRACTOR:%.*]] = function_ref @$S{{.*}}TR :
+// CHECK: [[F2:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACTOR]]([[F1]])
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] %0 : $*F
+// CHECK: [[SETTER:%.*]] = witness_method $F, #Factory.builder!setter.1
+// CHECK: apply [[SETTER]]<F>([[F2]], [[WRITE]])
diff --git a/test/SILGen/plus_zero_protocol_extensions.swift b/test/SILGen/plus_zero_protocol_extensions.swift
new file mode 100644
index 0000000..ec1dd26
--- /dev/null
+++ b/test/SILGen/plus_zero_protocol_extensions.swift
@@ -0,0 +1,901 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -disable-objc-attr-requires-foundation-module -emit-silgen %s | %FileCheck %s
+
+public protocol P1 {
+ func reqP1a()
+ subscript(i: Int) -> Int { get set }
+}
+
+struct Box {
+ var number: Int
+}
+
+extension P1 {
+ // CHECK-LABEL: sil hidden @$S19protocol_extensions2P1PAAE6extP1a{{[_0-9a-zA-Z]*}}F : $@convention(method) <Self where Self : P1> (@in_guaranteed Self) -> () {
+ // CHECK: bb0([[SELF:%[0-9]+]] : $*Self):
+ func extP1a() {
+ // CHECK: [[WITNESS:%[0-9]+]] = witness_method $Self, #P1.reqP1a!1 : {{.*}} : $@convention(witness_method: P1) <τ_0_0 where τ_0_0 : P1> (@in_guaranteed τ_0_0) -> ()
+ // CHECK-NEXT: apply [[WITNESS]]<Self>([[SELF]]) : $@convention(witness_method: P1) <τ_0_0 where τ_0_0 : P1> (@in_guaranteed τ_0_0) -> ()
+ reqP1a()
+ // CHECK: return
+ }
+
+ // CHECK-LABEL: sil @$S19protocol_extensions2P1PAAE6extP1b{{[_0-9a-zA-Z]*}}F : $@convention(method) <Self where Self : P1> (@in_guaranteed Self) -> () {
+ // CHECK: bb0([[SELF:%[0-9]+]] : $*Self):
+ public func extP1b() {
+ // CHECK: [[FN:%[0-9]+]] = function_ref @$S19protocol_extensions2P1PAAE6extP1a{{[_0-9a-zA-Z]*}}F : $@convention(method) <τ_0_0 where τ_0_0 : P1> (@in_guaranteed τ_0_0) -> ()
+ // CHECK-NEXT: apply [[FN]]<Self>([[SELF]]) : $@convention(method) <τ_0_0 where τ_0_0 : P1> (@in_guaranteed τ_0_0) -> ()
+ extP1a()
+ // CHECK: return
+ }
+
+ subscript(i: Int) -> Int {
+ // materializeForSet can do static dispatch to peer accessors (tested later, in the emission of the concrete conformance)
+ get {
+ return 0
+ }
+ set {}
+ }
+
+ func callSubscript() -> Int {
+ // But here we have to do a witness method call:
+
+ // CHECK-LABEL: sil hidden @$S19protocol_extensions2P1PAAE13callSubscript{{[_0-9a-zA-Z]*}}F
+ // CHECK: bb0(%0 : $*Self):
+ // CHECK: witness_method $Self, #P1.subscript!getter.1
+ // CHECK: return
+ return self[0]
+ }
+
+ static var staticReadOnlyProperty: Int {
+ return 0
+ }
+
+ static var staticReadWrite1: Int {
+ get { return 0 }
+ set { }
+ }
+
+ static var staticReadWrite2: Box {
+ get { return Box(number: 0) }
+ set { }
+ }
+}
+
+// ----------------------------------------------------------------------------
+// Using protocol extension members with concrete types
+// ----------------------------------------------------------------------------
+class C : P1 {
+ func reqP1a() { }
+}
+
+// (materializeForSet test from above)
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_extensions1CCAA2P1A2aDPyS2icimTW
+// CHECK: bb0(%0 : $Builtin.RawPointer, %1 : $*Builtin.UnsafeValueBuffer, %2 : $Int, %3 : $*τ_0_0):
+// CHECK: function_ref @$S19protocol_extensions2P1PAAEyS2icig
+// CHECK: return
+
+class D : C { }
+
+struct S : P1 {
+ func reqP1a() { }
+}
+
+struct G<T> : P1 {
+ func reqP1a() { }
+}
+
+struct MetaHolder {
+ var d: D.Type = D.self
+ var s: S.Type = S.self
+}
+
+struct GenericMetaHolder<T> {
+ var g: G<T>.Type = G<T>.self
+}
+
+func inout_func(_ n: inout Int) {}
+
+// CHECK-LABEL: sil hidden @$S19protocol_extensions5testD_2dd1dyAA10MetaHolderV_AA1DCmAHtF : $@convention(thin) (MetaHolder, @thick D.Type, @guaranteed D) -> ()
+// CHECK: bb0([[M:%[0-9]+]] : $MetaHolder, [[DD:%[0-9]+]] : $@thick D.Type, [[D:%[0-9]+]] : $D):
+func testD(_ m: MetaHolder, dd: D.Type, d: D) {
+ // CHECK: [[D2:%[0-9]+]] = alloc_box ${ var D }
+ // CHECK: [[RESULT:%.*]] = project_box [[D2]]
+ // CHECK: [[MATERIALIZED_BORROWED_D:%[0-9]+]] = alloc_stack $D
+ // CHECK: store_borrow [[D]] to [[MATERIALIZED_BORROWED_D]]
+ // CHECK: [[FN:%[0-9]+]] = function_ref @$S19protocol_extensions2P1PAAE11returnsSelf{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[FN]]<D>([[RESULT]], [[MATERIALIZED_BORROWED_D]]) : $@convention(method) <τ_0_0 where τ_0_0 : P1> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ // CHECK-NEXT: dealloc_stack [[MATERIALIZED_BORROWED_D]]
+ var d2: D = d.returnsSelf()
+
+ // CHECK: metatype $@thick D.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE22staticReadOnlyPropertySivgZ
+ let _ = D.staticReadOnlyProperty
+
+ // CHECK: metatype $@thick D.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ D.staticReadWrite1 = 1
+
+ // CHECK: metatype $@thick D.Type
+ // CHECK: alloc_stack $Int
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ // CHECK: dealloc_stack
+ D.staticReadWrite1 += 1
+
+ // CHECK: metatype $@thick D.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ D.staticReadWrite2 = Box(number: 2)
+
+ // CHECK: metatype $@thick D.Type
+ // CHECK: alloc_stack $Box
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ D.staticReadWrite2.number += 5
+
+ // CHECK: metatype $@thick D.Type
+ // CHECK: alloc_stack $Box
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: function_ref @$S19protocol_extensions10inout_funcyySizF
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ inout_func(&D.staticReadWrite2.number)
+
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE22staticReadOnlyPropertySivgZ
+ let _ = dd.staticReadOnlyProperty
+
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ dd.staticReadWrite1 = 1
+
+ // CHECK: alloc_stack $Int
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ // CHECK: dealloc_stack
+ dd.staticReadWrite1 += 1
+
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ dd.staticReadWrite2 = Box(number: 2)
+
+ // CHECK: alloc_stack $Box
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ dd.staticReadWrite2.number += 5
+
+ // CHECK: alloc_stack $Box
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: function_ref @$S19protocol_extensions10inout_funcyySizF
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ inout_func(&dd.staticReadWrite2.number)
+
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE22staticReadOnlyPropertySivgZ
+ let _ = m.d.staticReadOnlyProperty
+
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ m.d.staticReadWrite1 = 1
+
+ // CHECK: alloc_stack $Int
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ // CHECK: dealloc_stack
+ m.d.staticReadWrite1 += 1
+
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ m.d.staticReadWrite2 = Box(number: 2)
+
+ // CHECK: alloc_stack $Box
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ m.d.staticReadWrite2.number += 5
+
+ // CHECK: alloc_stack $Box
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: function_ref @$S19protocol_extensions10inout_funcyySizF
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ inout_func(&m.d.staticReadWrite2.number)
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S19protocol_extensions5testS_2ssyAA10MetaHolderV_AA1SVmtF
+func testS(_ m: MetaHolder, ss: S.Type) {
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE22staticReadOnlyPropertySivgZ
+ let _ = S.staticReadOnlyProperty
+
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ S.staticReadWrite1 = 1
+
+ // CHECK: alloc_stack $Int
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ // CHECK: dealloc_stack
+ S.staticReadWrite1 += 1
+
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ S.staticReadWrite2 = Box(number: 2)
+
+ // CHECK: alloc_stack $Box
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ S.staticReadWrite2.number += 5
+
+ // CHECK: alloc_stack $Box
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: function_ref @$S19protocol_extensions10inout_funcyySizF
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ inout_func(&S.staticReadWrite2.number)
+
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE22staticReadOnlyPropertySivgZ
+ let _ = ss.staticReadOnlyProperty
+
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ ss.staticReadWrite1 = 1
+
+ // CHECK: alloc_stack $Int
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ // CHECK: dealloc_stack
+ ss.staticReadWrite1 += 1
+
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ ss.staticReadWrite2 = Box(number: 2)
+
+ // CHECK: alloc_stack $Box
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ ss.staticReadWrite2.number += 5
+
+ // CHECK: alloc_stack $Box
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: function_ref @$S19protocol_extensions10inout_funcyySizF
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ inout_func(&ss.staticReadWrite2.number)
+
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE22staticReadOnlyPropertySivgZ
+ let _ = m.s.staticReadOnlyProperty
+
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ m.s.staticReadWrite1 = 1
+
+ // CHECK: alloc_stack $Int
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ // CHECK: dealloc_stack
+ m.s.staticReadWrite1 += 1
+
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ m.s.staticReadWrite2 = Box(number: 2)
+
+ // CHECK: alloc_stack $Box
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ m.s.staticReadWrite2.number += 5
+
+ // CHECK: alloc_stack $Box
+ // CHECK: metatype $@thick S.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: function_ref @$S19protocol_extensions10inout_funcyySizF
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ inout_func(&m.s.staticReadWrite2.number)
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S19protocol_extensions5testG{{[_0-9a-zA-Z]*}}F
+func testG<T>(_ m: GenericMetaHolder<T>, gg: G<T>.Type) {
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE22staticReadOnlyPropertySivgZ
+ let _ = G<T>.staticReadOnlyProperty
+
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ G<T>.staticReadWrite1 = 1
+
+ // CHECK: alloc_stack $Int
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ // CHECK: dealloc_stack
+ G<T>.staticReadWrite1 += 1
+
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ G<T>.staticReadWrite2 = Box(number: 2)
+
+ // CHECK: alloc_stack $Box
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ G<T>.staticReadWrite2.number += 5
+
+ // CHECK: alloc_stack $Box
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: function_ref @$S19protocol_extensions10inout_funcyySizF
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ inout_func(&G<T>.staticReadWrite2.number)
+
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE22staticReadOnlyPropertySivgZ
+ let _ = gg.staticReadOnlyProperty
+
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ gg.staticReadWrite1 = 1
+
+ // CHECK: alloc_stack $Int
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ // CHECK: dealloc_stack
+ gg.staticReadWrite1 += 1
+
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ gg.staticReadWrite2 = Box(number: 2)
+
+ // CHECK: alloc_stack $Box
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ gg.staticReadWrite2.number += 5
+
+ // CHECK: alloc_stack $Box
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: function_ref @$S19protocol_extensions10inout_funcyySizF
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ inout_func(&gg.staticReadWrite2.number)
+
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE22staticReadOnlyPropertySivgZ
+ let _ = m.g.staticReadOnlyProperty
+
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ m.g.staticReadWrite1 = 1
+
+ // CHECK: alloc_stack $Int
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite1SivsZ
+ // CHECK: dealloc_stack
+ m.g.staticReadWrite1 += 1
+
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ m.g.staticReadWrite2 = Box(number: 2)
+
+ // CHECK: alloc_stack $Box
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ m.g.staticReadWrite2.number += 5
+
+ // CHECK: alloc_stack $Box
+ // CHECK: metatype $@thick G<T>.Type
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvgZ
+ // CHECK: store
+ // CHECK: function_ref @$S19protocol_extensions10inout_funcyySizF
+ // CHECK: load
+ // CHECK: function_ref @$S19protocol_extensions2P1PAAE16staticReadWrite2AA3BoxVvsZ
+ // CHECK: dealloc_stack
+ inout_func(&m.g.staticReadWrite2.number)
+
+ // CHECK: return
+}
+
+// ----------------------------------------------------------------------------
+// Using protocol extension members with existentials
+// ----------------------------------------------------------------------------
+extension P1 {
+ func f1() { }
+
+ subscript (i: Int64) -> Bool {
+ get { return true }
+ }
+
+ var prop: Bool {
+ get { return true }
+ }
+
+ func returnsSelf() -> Self { return self }
+
+ var prop2: Bool {
+ get { return true }
+ set { }
+ }
+
+ subscript (b: Bool) -> Bool {
+ get { return b }
+ set { }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S19protocol_extensions17testExistentials1{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[P:%[0-9]+]] : $*P1, [[B:%[0-9]+]] : $Bool, [[I:%[0-9]+]] : $Int64):
+func testExistentials1(_ p1: P1, b: Bool, i: Int64) {
+ // CHECK: [[POPENED:%[0-9]+]] = open_existential_addr immutable_access [[P]] : $*P1 to $*@opened([[UUID:".*"]])
+ // CHECK: [[F1:%[0-9]+]] = function_ref @$S19protocol_extensions2P1PAAE2f1{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[F1]]<@opened([[UUID]]) P1>([[POPENED]]) : $@convention(method) <τ_0_0 where τ_0_0 : P1> (@in_guaranteed τ_0_0) -> ()
+ p1.f1()
+
+ // CHECK: [[POPENED:%[0-9]+]] = open_existential_addr immutable_access [[P]] : $*P1 to $*@opened([[UUID:".*"]]) P1
+ // CHECK: copy_addr [[POPENED]] to [initialization] [[POPENED_COPY:%.*]] :
+ // CHECK: [[GETTER:%[0-9]+]] = function_ref @$S19protocol_extensions2P1PAAEySbs5Int64Vcig
+ // CHECK: apply [[GETTER]]<@opened([[UUID]]) P1>([[I]], [[POPENED_COPY]]) : $@convention(method) <τ_0_0 where τ_0_0 : P1> (Int64, @in_guaranteed τ_0_0) -> Bool
+ // CHECK: store{{.*}} : $*Bool
+ // CHECK: destroy_addr [[POPENED_COPY]]
+ // CHECK: dealloc_stack [[POPENED_COPY]]
+ var b2 = p1[i]
+
+ // CHECK: [[POPENED:%[0-9]+]] = open_existential_addr immutable_access [[P]] : $*P1 to $*@opened([[UUID:".*"]]) P1
+ // CHECK: copy_addr [[POPENED]] to [initialization] [[POPENED_COPY:%.*]] :
+ // CHECK: [[GETTER:%[0-9]+]] = function_ref @$S19protocol_extensions2P1PAAE4propSbvg
+ // CHECK: apply [[GETTER]]<@opened([[UUID]]) P1>([[POPENED_COPY]]) : $@convention(method) <τ_0_0 where τ_0_0 : P1> (@in_guaranteed τ_0_0) -> Bool
+ // CHECK: store{{.*}} : $*Bool
+ // CHECK: dealloc_stack [[POPENED_COPY]]
+ var b3 = p1.prop
+}
+
+// CHECK-LABEL: sil hidden @$S19protocol_extensions17testExistentials2{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[P:%[0-9]+]] : $*P1):
+func testExistentials2(_ p1: P1) {
+ // CHECK: [[P1A:%[0-9]+]] = alloc_box ${ var P1 }
+ // CHECK: [[PB:%.*]] = project_box [[P1A]]
+ // CHECK: [[POPENED:%[0-9]+]] = open_existential_addr immutable_access [[P]] : $*P1 to $*@opened([[UUID:".*"]]) P1
+ // CHECK: [[P1AINIT:%[0-9]+]] = init_existential_addr [[PB]] : $*P1, $@opened([[UUID2:".*"]]) P1
+ // CHECK: [[FN:%[0-9]+]] = function_ref @$S19protocol_extensions2P1PAAE11returnsSelf{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[FN]]<@opened([[UUID]]) P1>([[P1AINIT]], [[POPENED]]) : $@convention(method) <τ_0_0 where τ_0_0 : P1> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ var p1a: P1 = p1.returnsSelf()
+}
+
+// CHECK-LABEL: sil hidden @$S19protocol_extensions23testExistentialsGetters{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[P:%[0-9]+]] : $*P1):
+func testExistentialsGetters(_ p1: P1) {
+ // CHECK: [[POPENED:%[0-9]+]] = open_existential_addr immutable_access [[P]] : $*P1 to $*@opened([[UUID:".*"]]) P1
+ // CHECK: copy_addr [[POPENED]] to [initialization] [[POPENED_COPY:%.*]] :
+ // CHECK: [[FN:%[0-9]+]] = function_ref @$S19protocol_extensions2P1PAAE5prop2Sbvg
+ // CHECK: [[B:%[0-9]+]] = apply [[FN]]<@opened([[UUID]]) P1>([[POPENED_COPY]]) : $@convention(method) <τ_0_0 where τ_0_0 : P1> (@in_guaranteed τ_0_0) -> Bool
+ let b: Bool = p1.prop2
+
+ // CHECK: [[POPENED:%[0-9]+]] = open_existential_addr immutable_access [[P]] : $*P1 to $*@opened([[UUID:".*"]]) P1
+ // CHECK: copy_addr [[POPENED]] to [initialization] [[POPENED_COPY:%.*]] :
+ // CHECK: [[GETTER:%[0-9]+]] = function_ref @$S19protocol_extensions2P1PAAEyS2bcig
+ // CHECK: apply [[GETTER]]<@opened([[UUID]]) P1>([[B]], [[POPENED_COPY]]) : $@convention(method) <τ_0_0 where τ_0_0 : P1> (Bool, @in_guaranteed τ_0_0) -> Bool
+ let b2: Bool = p1[b]
+}
+
+// CHECK-LABEL: sil hidden @$S19protocol_extensions22testExistentialSetters{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[P:%[0-9]+]] : $*P1, [[B:%[0-9]+]] : $Bool):
+func testExistentialSetters(_ p1: P1, b: Bool) {
+ var p1 = p1
+ // CHECK: [[PBOX:%[0-9]+]] = alloc_box ${ var P1 }
+ // CHECK: [[PBP:%[0-9]+]] = project_box [[PBOX]]
+ // CHECK-NEXT: copy_addr [[P]] to [initialization] [[PBP]] : $*P1
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PBP]]
+ // CHECK: [[POPENED:%[0-9]+]] = open_existential_addr mutable_access [[WRITE]] : $*P1 to $*@opened([[UUID:".*"]]) P1
+ // CHECK: [[GETTER:%[0-9]+]] = function_ref @$S19protocol_extensions2P1PAAE5prop2Sbvs
+ // CHECK: apply [[GETTER]]<@opened([[UUID]]) P1>([[B]], [[POPENED]]) : $@convention(method) <τ_0_0 where τ_0_0 : P1> (Bool, @inout τ_0_0) -> ()
+ // CHECK-NOT: deinit_existential_addr
+ p1.prop2 = b
+
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PBP]]
+ // CHECK: [[POPENED:%[0-9]+]] = open_existential_addr mutable_access [[WRITE]] : $*P1 to $*@opened([[UUID:".*"]]) P1
+ // CHECK: [[SUBSETTER:%[0-9]+]] = function_ref @$S19protocol_extensions2P1PAAEyS2bcis
+ // CHECK: apply [[SUBSETTER]]<@opened([[UUID]]) P1>([[B]], [[B]], [[POPENED]]) : $@convention(method) <τ_0_0 where τ_0_0 : P1> (Bool, Bool, @inout τ_0_0) -> ()
+ // CHECK-NOT: deinit_existential_addr [[PB]] : $*P1
+ p1[b] = b
+
+ // CHECK: return
+}
+
+struct HasAP1 {
+ var p1: P1
+
+ var someP1: P1 {
+ get { return p1 }
+ set { p1 = newValue }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S19protocol_extensions29testLogicalExistentialSetters{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[HASP1:%[0-9]+]] : $*HasAP1, [[B:%[0-9]+]] : $Bool)
+func testLogicalExistentialSetters(_ hasAP1: HasAP1, _ b: Bool) {
+ var hasAP1 = hasAP1
+ // CHECK: [[HASP1_BOX:%[0-9]+]] = alloc_box ${ var HasAP1 }
+ // CHECK: [[PBHASP1:%[0-9]+]] = project_box [[HASP1_BOX]]
+ // CHECK-NEXT: copy_addr [[HASP1]] to [initialization] [[PBHASP1]] : $*HasAP1
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PBHASP1]]
+ // CHECK: [[P1_COPY:%[0-9]+]] = alloc_stack $P1
+ // CHECK-NEXT: [[HASP1_COPY:%[0-9]+]] = alloc_stack $HasAP1
+ // CHECK-NEXT: copy_addr [[WRITE]] to [initialization] [[HASP1_COPY]] : $*HasAP1
+ // CHECK: [[SOMEP1_GETTER:%[0-9]+]] = function_ref @$S19protocol_extensions6HasAP1V6someP1AA0F0_pvg : $@convention(method) (@in_guaranteed HasAP1) -> @out P1
+ // CHECK: [[RESULT:%[0-9]+]] = apply [[SOMEP1_GETTER]]([[P1_COPY]], [[HASP1_COPY]]) : $@convention(method) (@in_guaranteed HasAP1) -> @out P1
+ // CHECK: [[P1_OPENED:%[0-9]+]] = open_existential_addr mutable_access [[P1_COPY]] : $*P1 to $*@opened([[UUID:".*"]]) P1
+ // CHECK: [[PROP2_SETTER:%[0-9]+]] = function_ref @$S19protocol_extensions2P1PAAE5prop2Sbvs : $@convention(method) <τ_0_0 where τ_0_0 : P1> (Bool, @inout τ_0_0) -> ()
+ // CHECK: apply [[PROP2_SETTER]]<@opened([[UUID]]) P1>([[B]], [[P1_OPENED]]) : $@convention(method) <τ_0_0 where τ_0_0 : P1> (Bool, @inout τ_0_0) -> ()
+ // CHECK: [[SOMEP1_SETTER:%[0-9]+]] = function_ref @$S19protocol_extensions6HasAP1V6someP1AA0F0_pvs : $@convention(method) (@in P1, @inout HasAP1) -> ()
+ // CHECK: apply [[SOMEP1_SETTER]]([[P1_COPY]], [[WRITE]]) : $@convention(method) (@in P1, @inout HasAP1) -> ()
+ // CHECK-NOT: deinit_existential_addr
+ hasAP1.someP1.prop2 = b
+ // CHECK: return
+}
+
+func plusOneP1() -> P1 {}
+
+// CHECK-LABEL: sil hidden @$S19protocol_extensions38test_open_existential_semantics_opaque{{[_0-9a-zA-Z]*}}F
+func test_open_existential_semantics_opaque(_ guaranteed: P1,
+ immediate: P1) {
+ var immediate = immediate
+ // CHECK: [[IMMEDIATE_BOX:%.*]] = alloc_box ${ var P1 }
+ // CHECK: [[PB:%.*]] = project_box [[IMMEDIATE_BOX]]
+ // CHECK: [[VALUE:%.*]] = open_existential_addr immutable_access %0
+ // CHECK: [[METHOD:%.*]] = function_ref
+ // CHECK: apply [[METHOD]]<{{.*}}>([[VALUE]])
+
+ guaranteed.f1()
+
+ // -- Need a guaranteed copy because it's immutable
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PB]]
+ // CHECK: copy_addr [[READ]] to [initialization] [[IMMEDIATE:%.*]] :
+ // CHECK: [[VALUE:%.*]] = open_existential_addr immutable_access [[IMMEDIATE]]
+ // CHECK: [[METHOD:%.*]] = function_ref
+ // -- Can consume the value from our own copy
+ // CHECK: apply [[METHOD]]<{{.*}}>([[VALUE]])
+ // CHECK: destroy_addr [[IMMEDIATE]]
+ // CHECK: dealloc_stack [[IMMEDIATE]]
+ immediate.f1()
+
+ // CHECK: [[PLUS_ONE:%.*]] = alloc_stack $P1
+ // CHECK: [[VALUE:%.*]] = open_existential_addr immutable_access [[PLUS_ONE]]
+ // CHECK: [[METHOD:%.*]] = function_ref
+ // -- Can consume the value from our own copy
+ // CHECK: apply [[METHOD]]<{{.*}}>([[VALUE]])
+ // CHECK: destroy_addr [[PLUS_ONE]]
+ // CHECK: dealloc_stack [[PLUS_ONE]]
+ plusOneP1().f1()
+}
+
+protocol CP1: class {}
+
+extension CP1 {
+ func f1() { }
+}
+
+func plusOneCP1() -> CP1 {}
+
+// CHECK-LABEL: sil hidden @$S19protocol_extensions37test_open_existential_semantics_class{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0([[ARG0:%.*]] : $CP1, [[ARG1:%.*]] : $CP1):
+func test_open_existential_semantics_class(_ guaranteed: CP1,
+ immediate: CP1) {
+ var immediate = immediate
+ // CHECK: [[IMMEDIATE_BOX:%.*]] = alloc_box ${ var CP1 }
+ // CHECK: [[PB:%.*]] = project_box [[IMMEDIATE_BOX]]
+
+ // CHECK-NOT: copy_value [[ARG0]]
+ // CHECK: [[VALUE:%.*]] = open_existential_ref [[ARG0]]
+ // CHECK: [[METHOD:%.*]] = function_ref
+ // CHECK: apply [[METHOD]]<{{.*}}>([[VALUE]])
+ // CHECK-NOT: destroy_value [[VALUE]]
+ // CHECK-NOT: destroy_value [[ARG0]]
+ guaranteed.f1()
+
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PB]]
+ // CHECK: [[IMMEDIATE:%.*]] = load [copy] [[READ]]
+ // CHECK: [[VALUE:%.*]] = open_existential_ref [[IMMEDIATE]]
+ // CHECK: [[METHOD:%.*]] = function_ref
+ // CHECK: apply [[METHOD]]<{{.*}}>([[VALUE]])
+ // CHECK: destroy_value [[VALUE]]
+ // CHECK-NOT: destroy_value [[IMMEDIATE]]
+ immediate.f1()
+
+ // CHECK: [[F:%.*]] = function_ref {{.*}}plusOneCP1
+ // CHECK: [[PLUS_ONE:%.*]] = apply [[F]]()
+ // CHECK: [[VALUE:%.*]] = open_existential_ref [[PLUS_ONE]]
+ // CHECK: [[METHOD:%.*]] = function_ref
+ // CHECK: apply [[METHOD]]<{{.*}}>([[VALUE]])
+ // CHECK: destroy_value [[VALUE]]
+ // CHECK-NOT: destroy_value [[PLUS_ONE]]
+ plusOneCP1().f1()
+}
+// CHECK: } // end sil function '$S19protocol_extensions37test_open_existential_semantics_class{{[_0-9a-zA-Z]*}}F'
+
+protocol InitRequirement {
+ init(c: C)
+}
+
+extension InitRequirement {
+ // CHECK-LABEL: sil hidden @$S19protocol_extensions15InitRequirementPAAE1dxAA1DC_tcfC : $@convention(method) <Self where Self : InitRequirement> (@owned D, @thick Self.Type) -> @out Self
+ // CHECK: bb0([[OUT:%.*]] : $*Self, [[ARG:%.*]] : $D, [[SELF_TYPE:%.*]] : $@thick Self.Type):
+ init(d: D) {
+ // CHECK: [[SELF_BOX:%.*]] = alloc_box
+ // CHECK-NEXT: [[UNINIT_SELF:%.*]] = mark_uninitialized [delegatingself] [[SELF_BOX]]
+ // CHECK-NEXT: [[SELF_BOX_ADDR:%.*]] = project_box [[UNINIT_SELF]]
+ // CHECK: [[SELF_BOX:%.*]] = alloc_stack $Self
+ // CHECK-NEXT: [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]]
+ // CHECK-NEXT: [[ARG_COPY:%.*]] = copy_value [[BORROWED_ARG]]
+ // CHECK-NEXT: [[ARG_COPY_CAST:%.*]] = upcast [[ARG_COPY]]
+ // CHECK: [[DELEGATEE:%.*]] = witness_method $Self, #InitRequirement.init!allocator.1 : {{.*}} : $@convention(witness_method: InitRequirement) <τ_0_0 where τ_0_0 : InitRequirement> (@owned C, @thick τ_0_0.Type) -> @out τ_0_0
+ // CHECK-NEXT: apply [[DELEGATEE]]<Self>([[SELF_BOX]], [[ARG_COPY_CAST]], [[SELF_TYPE]])
+ // CHECK-NEXT: end_borrow [[BORROWED_ARG]] from [[ARG]]
+ // CHECK-NEXT: copy_addr [take] [[SELF_BOX]] to [[SELF_BOX_ADDR]]
+ // CHECK-NEXT: dealloc_stack [[SELF_BOX]]
+ // CHECK-NEXT: copy_addr [[SELF_BOX_ADDR]] to [initialization] [[OUT]]
+ // CHECK-NEXT: destroy_value [[ARG]]
+ // CHECK-NEXT: destroy_value [[UNINIT_SELF]]
+ // CHECK: return
+ self.init(c: d)
+ }
+
+ // CHECK-LABEL: sil hidden @$S19protocol_extensions15InitRequirementPAAE2d2xAA1DC_tcfC : $@convention(method)
+ // CHECK: bb0([[OUT:%.*]] : $*Self, [[ARG:%.*]] : $D, [[SELF_TYPE:%.*]] : $@thick Self.Type):
+ init(d2: D) {
+ // CHECK: [[SELF_BOX:%.*]] = alloc_box
+ // CHECK-NEXT: [[UNINIT_SELF:%.*]] = mark_uninitialized [delegatingself] [[SELF_BOX]]
+ // CHECK-NEXT: [[SELF_BOX_ADDR:%.*]] = project_box [[UNINIT_SELF]]
+ // CHECK: [[SELF_BOX:%.*]] = alloc_stack $Self
+ // CHECK-NEXT: [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]]
+ // CHECK-NEXT: [[ARG_COPY:%.*]] = copy_value [[BORROWED_ARG]]
+ // CHECK: [[DELEGATEE:%.*]] = function_ref @$S19protocol_extensions15InitRequirementPAAE1dxAA1DC_tcfC
+ // CHECK-NEXT: apply [[DELEGATEE]]<Self>([[SELF_BOX]], [[ARG_COPY]], [[SELF_TYPE]])
+ // CHECK-NEXT: end_borrow [[BORROWED_ARG]] from [[ARG]]
+ // CHECK-NEXT: copy_addr [take] [[SELF_BOX]] to [[SELF_BOX_ADDR]]
+ // CHECK-NEXT: dealloc_stack [[SELF_BOX]]
+ // CHECK-NEXT: copy_addr [[SELF_BOX_ADDR]] to [initialization] [[OUT]]
+ // CHECK-NEXT: destroy_value [[ARG]]
+ // CHECK-NEXT: destroy_value [[UNINIT_SELF]]
+ // CHECK: return
+ self.init(d: d2)
+ }
+
+ // CHECK-LABEL: sil hidden @$S19protocol_extensions15InitRequirementPAAE2c2xAA1CC_tcfC : $@convention(method)
+ // CHECK: bb0([[OUT:%.*]] : $*Self, [[ARG:%.*]] : $C, [[SELF_TYPE:%.*]] : $@thick Self.Type):
+ init(c2: C) {
+ // CHECK: [[SELF_BOX:%.*]] = alloc_box
+ // CHECK-NEXT: [[UNINIT_SELF:%.*]] = mark_uninitialized [delegatingself] [[SELF_BOX]]
+ // CHECK-NEXT: [[SELF_BOX_ADDR:%.*]] = project_box [[UNINIT_SELF]]
+ // CHECK: [[SELF_BOX:%.*]] = alloc_stack $Self
+ // CHECK-NEXT: [[SELF_TYPE:%.*]] = metatype $@thick Self.Type
+ // CHECK-NEXT: [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]]
+ // CHECK-NEXT: [[ARG_COPY:%.*]] = copy_value [[BORROWED_ARG]]
+ // CHECK: [[DELEGATEE:%.*]] = witness_method $Self, #InitRequirement.init!allocator.1
+ // CHECK-NEXT: apply [[DELEGATEE]]<Self>([[SELF_BOX]], [[ARG_COPY]], [[SELF_TYPE]])
+ // CHECK-NEXT: end_borrow [[BORROWED_ARG]] from [[ARG]]
+ // CHECK-NEXT: [[ACCESS:%.*]] = begin_access [modify] [unknown] [[SELF_BOX_ADDR]]
+ // CHECK-NEXT: copy_addr [take] [[SELF_BOX]] to [[ACCESS]]
+ // CHECK-NEXT: end_access [[ACCESS]]
+ // CHECK-NEXT: dealloc_stack [[SELF_BOX]]
+ // CHECK-NEXT: copy_addr [[SELF_BOX_ADDR]] to [initialization] [[OUT]]
+ // CHECK-NEXT: destroy_value [[ARG]]
+ // CHECK-NEXT: destroy_value [[UNINIT_SELF]]
+ // CHECK: return
+ self = Self(c: c2)
+ }
+}
+
+protocol ClassInitRequirement: class {
+ init(c: C)
+}
+
+extension ClassInitRequirement {
+ // CHECK-LABEL: sil hidden @$S19protocol_extensions20ClassInitRequirementPAAE{{[_0-9a-zA-Z]*}}fC : $@convention(method) <Self where Self : ClassInitRequirement> (@owned D, @thick Self.Type) -> @owned Self
+ // CHECK: bb0([[ARG:%.*]] : $D, [[SELF_TYPE:%.*]] : $@thick Self.Type):
+ // CHECK: [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]]
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[BORROWED_ARG]]
+ // CHECK: [[ARG_COPY_CAST:%.*]] = upcast [[ARG_COPY]]
+ // CHECK: [[DELEGATEE:%.*]] = witness_method $Self, #ClassInitRequirement.init!allocator.1 : {{.*}} : $@convention(witness_method: ClassInitRequirement) <τ_0_0 where τ_0_0 : ClassInitRequirement> (@owned C, @thick τ_0_0.Type) -> @owned τ_0_0
+ // CHECK: apply [[DELEGATEE]]<Self>([[ARG_COPY_CAST]], [[SELF_TYPE]])
+ // CHECK: end_borrow [[BORROWED_ARG]] from [[ARG]]
+
+ // CHECK: } // end sil function '$S19protocol_extensions20ClassInitRequirementPAAE{{[_0-9a-zA-Z]*}}fC'
+ init(d: D) {
+ self.init(c: d)
+ }
+}
+
+@objc class OC {}
+@objc class OD: OC {}
+
+@objc protocol ObjCInitRequirement {
+ init(c: OC, d: OC)
+}
+
+func foo(_ t: ObjCInitRequirement.Type, c: OC) -> ObjCInitRequirement {
+ return t.init(c: OC(), d: OC())
+}
+
+extension ObjCInitRequirement {
+ // CHECK-LABEL: sil hidden @$S19protocol_extensions19ObjCInitRequirementPAAE{{[_0-9a-zA-Z]*}}fC : $@convention(method) <Self where Self : ObjCInitRequirement> (@owned OD, @thick Self.Type) -> @owned Self
+ // CHECK: bb0([[ARG:%.*]] : $OD, [[SELF_TYPE:%.*]] : $@thick Self.Type):
+ // CHECK: [[OBJC_SELF_TYPE:%.*]] = thick_to_objc_metatype [[SELF_TYPE]]
+ // CHECK: [[SELF:%.*]] = alloc_ref_dynamic [objc] [[OBJC_SELF_TYPE]] : $@objc_metatype Self.Type, $Self
+ // CHECK: [[BORROWED_ARG_1:%.*]] = begin_borrow [[ARG]]
+ // CHECK: [[BORROWED_ARG_1_UPCAST:%.*]] = upcast [[BORROWED_ARG_1]]
+ // CHECK: [[BORROWED_ARG_2:%.*]] = begin_borrow [[ARG]]
+ // CHECK: [[BORROWED_ARG_2_UPCAST:%.*]] = upcast [[BORROWED_ARG_2]]
+ // CHECK: [[WITNESS:%.*]] = objc_method [[SELF]] : $Self, #ObjCInitRequirement.init!initializer.1.foreign : {{.*}}, $@convention(objc_method) <τ_0_0 where τ_0_0 : ObjCInitRequirement> (OC, OC, @owned τ_0_0) -> @owned τ_0_0
+ // CHECK: apply [[WITNESS]]<Self>([[BORROWED_ARG_1_UPCAST]], [[BORROWED_ARG_2_UPCAST]], [[SELF]])
+ // CHECK: end_borrow [[BORROWED_ARG_2]] from [[ARG]]
+ // CHECK: end_borrow [[BORROWED_ARG_1]] from [[ARG]]
+ // CHECK: } // end sil function '$S19protocol_extensions19ObjCInitRequirementPAAE{{[_0-9a-zA-Z]*}}fC'
+ init(d: OD) {
+ self.init(c: d, d: d)
+ }
+}
+
+// rdar://problem/21370992 - delegation from an initializer in a
+// protocol extension to an @objc initializer in a class.
+class ObjCInitClass {
+ @objc required init() { }
+}
+
+protocol ProtoDelegatesToObjC { }
+
+extension ProtoDelegatesToObjC where Self : ObjCInitClass {
+ // CHECK-LABEL: sil hidden @$S19protocol_extensions20ProtoDelegatesToObjCPA2A0F10CInitClassC{{[_0-9a-zA-Z]*}}fC
+ // CHECK: bb0([[STR:%[0-9]+]] : $String, [[SELF_META:%[0-9]+]] : $@thick Self.Type):
+ init(string: String) {
+ // CHECK: [[SELF_BOX:%[0-9]+]] = alloc_box $<τ_0_0 where τ_0_0 : ObjCInitClass, τ_0_0 : ProtoDelegatesToObjC> { var τ_0_0 } <Self>
+ // CHECK: [[MARKED_SELF_BOX:%[0-9]+]] = mark_uninitialized [delegatingself] [[SELF_BOX]]
+ // CHECK: [[PB_SELF_BOX:%.*]] = project_box [[MARKED_SELF_BOX]]
+ // CHECK: [[SELF_META_OBJC:%[0-9]+]] = thick_to_objc_metatype [[SELF_META]] : $@thick Self.Type to $@objc_metatype Self.Type
+ // CHECK: [[SELF_ALLOC:%[0-9]+]] = alloc_ref_dynamic [objc] [[SELF_META_OBJC]] : $@objc_metatype Self.Type, $Self
+ // CHECK: [[SELF_ALLOC_C:%[0-9]+]] = upcast [[SELF_ALLOC]] : $Self to $ObjCInitClass
+ // CHECK: [[OBJC_INIT:%[0-9]+]] = class_method [[SELF_ALLOC_C]] : $ObjCInitClass, #ObjCInitClass.init!initializer.1 : (ObjCInitClass.Type) -> () -> ObjCInitClass, $@convention(method) (@owned ObjCInitClass) -> @owned ObjCInitClass
+ // CHECK: [[SELF_RESULT:%[0-9]+]] = apply [[OBJC_INIT]]([[SELF_ALLOC_C]]) : $@convention(method) (@owned ObjCInitClass) -> @owned ObjCInitClass
+ // CHECK: [[SELF_RESULT_AS_SELF:%[0-9]+]] = unchecked_ref_cast [[SELF_RESULT]] : $ObjCInitClass to $Self
+ // CHECK: assign [[SELF_RESULT_AS_SELF]] to [[PB_SELF_BOX]] : $*Self
+ self.init()
+ }
+}
+
+// Delegating from an initializer in a protocol extension where Self
+// has a superclass to a required initializer of that class.
+class RequiredInitClass {
+ required init() { }
+}
+
+protocol ProtoDelegatesToRequired { }
+
+extension ProtoDelegatesToRequired where Self : RequiredInitClass {
+ // CHECK-LABEL: sil hidden @$S19protocol_extensions24ProtoDelegatesToRequiredPA2A0F9InitClassC{{[_0-9a-zA-Z]*}}fC
+ // CHECK: bb0([[STR:%[0-9]+]] : $String, [[SELF_META:%[0-9]+]] : $@thick Self.Type):
+ init(string: String) {
+ // CHECK: [[SELF_BOX:%[0-9]+]] = alloc_box $<τ_0_0 where τ_0_0 : RequiredInitClass, τ_0_0 : ProtoDelegatesToRequired> { var τ_0_0 } <Self>
+ // CHECK: [[MARKED_SELF_BOX:%[0-9]+]] = mark_uninitialized [delegatingself] [[SELF_BOX]]
+ // CHECK: [[PB_SELF_BOX:%.*]] = project_box [[MARKED_SELF_BOX]]
+ // CHECK: [[SELF_META_AS_CLASS_META:%[0-9]+]] = upcast [[SELF_META]] : $@thick Self.Type to $@thick RequiredInitClass.Type
+ // CHECK: [[INIT:%[0-9]+]] = class_method [[SELF_META_AS_CLASS_META]] : $@thick RequiredInitClass.Type, #RequiredInitClass.init!allocator.1 : (RequiredInitClass.Type) -> () -> RequiredInitClass, $@convention(method) (@thick RequiredInitClass.Type) -> @owned RequiredInitClass
+ // CHECK: [[SELF_RESULT:%[0-9]+]] = apply [[INIT]]([[SELF_META_AS_CLASS_META]]) : $@convention(method) (@thick RequiredInitClass.Type) -> @owned RequiredInitClass
+ // CHECK: [[SELF_RESULT_AS_SELF:%[0-9]+]] = unchecked_ref_cast [[SELF_RESULT]] : $RequiredInitClass to $Self
+ // CHECK: assign [[SELF_RESULT_AS_SELF]] to [[PB_SELF_BOX]] : $*Self
+ self.init()
+ }
+}
+
+// ----------------------------------------------------------------------------
+// Default implementations via protocol extensions
+// ----------------------------------------------------------------------------
+
+protocol P2 {
+ associatedtype A
+ func f1(_ a: A)
+ func f2(_ a: A)
+ var x: A { get }
+}
+
+extension P2 {
+ // CHECK-LABEL: sil hidden @$S19protocol_extensions2P2PAAE2f1{{[_0-9a-zA-Z]*}}F
+ // CHECK: witness_method $Self, #P2.f2!1
+ // CHECK: function_ref @$S19protocol_extensions2P2PAAE2f3{{[_0-9a-zA-Z]*}}F
+ // CHECK: return
+ func f1(_ a: A) {
+ f2(a)
+ f3(a)
+ }
+
+ // CHECK-LABEL: sil hidden @$S19protocol_extensions2P2PAAE2f2{{[_0-9a-zA-Z]*}}F
+ // CHECK: witness_method $Self, #P2.f1!1
+ // CHECK: function_ref @$S19protocol_extensions2P2PAAE2f3{{[_0-9a-zA-Z]*}}F
+ // CHECK: return
+ func f2(_ a: A) {
+ f1(a)
+ f3(a)
+ }
+
+ func f3(_ a: A) {}
+
+ // CHECK-LABEL: sil hidden @$S19protocol_extensions2P2PAAE2f4{{[_0-9a-zA-Z]*}}F
+ // CHECK: witness_method $Self, #P2.f1!1
+ // CHECK: witness_method $Self, #P2.f2!1
+ // CHECK: return
+ func f4() {
+ f1(x)
+ f2(x)
+ }
+}
diff --git a/test/SILGen/plus_zero_protocol_optional.swift b/test/SILGen/plus_zero_protocol_optional.swift
new file mode 100644
index 0000000..25e1dd6
--- /dev/null
+++ b/test/SILGen/plus_zero_protocol_optional.swift
@@ -0,0 +1,68 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -parse-as-library -emit-silgen -disable-objc-attr-requires-foundation-module -enable-sil-ownership %s | %FileCheck %s
+
+@objc protocol P1 {
+ @objc optional func method(_ x: Int)
+
+ @objc optional var prop: Int { get }
+
+ @objc optional subscript (i: Int) -> Int { get }
+}
+
+// CHECK-LABEL: sil hidden @$S17protocol_optional0B13MethodGeneric1tyx_tAA2P1RzlF : $@convention(thin) <T where T : P1> (@guaranteed T) -> ()
+func optionalMethodGeneric<T : P1>(t t : T) {
+ var t = t
+ // CHECK: bb0([[T:%[0-9]+]] : @guaranteed $T):
+ // CHECK: [[TBOX:%[0-9]+]] = alloc_box $<τ_0_0 where τ_0_0 : P1> { var τ_0_0 } <T>
+ // CHECK: [[PT:%[0-9]+]] = project_box [[TBOX]]
+ // CHECK: [[T_COPY:%.*]] = copy_value [[T]]
+ // CHECK: store [[T_COPY]] to [init] [[PT]] : $*T
+ // CHECK: [[OPT_BOX:%[0-9]+]] = alloc_box ${ var Optional<@callee_guaranteed (Int) -> ()> }
+ // CHECK: project_box [[OPT_BOX]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PT]] : $*T
+ // CHECK: [[T:%[0-9]+]] = load [copy] [[READ]] : $*T
+ // CHECK: alloc_stack $Optional<@callee_guaranteed (Int) -> ()>
+ // CHECK: dynamic_method_br [[T]] : $T, #P1.method!1.foreign
+ var methodRef = t.method
+}
+// CHECK: } // end sil function '$S17protocol_optional0B13MethodGeneric1tyx_tAA2P1RzlF'
+
+// CHECK-LABEL: sil hidden @$S17protocol_optional0B15PropertyGeneric{{[_0-9a-zA-Z]*}}F : $@convention(thin) <T where T : P1> (@guaranteed T) -> ()
+func optionalPropertyGeneric<T : P1>(t t : T) {
+ var t = t
+ // CHECK: bb0([[T:%[0-9]+]] : @guaranteed $T):
+ // CHECK: [[TBOX:%[0-9]+]] = alloc_box $<τ_0_0 where τ_0_0 : P1> { var τ_0_0 } <T>
+ // CHECK: [[PT:%[0-9]+]] = project_box [[TBOX]]
+ // CHECK: [[T_COPY:%.*]] = copy_value [[T]]
+ // CHECK: store [[T_COPY]] to [init] [[PT]] : $*T
+ // CHECK: [[OPT_BOX:%[0-9]+]] = alloc_box ${ var Optional<Int> }
+ // CHECK: project_box [[OPT_BOX]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PT]] : $*T
+ // CHECK: [[T:%[0-9]+]] = load [copy] [[READ]] : $*T
+ // CHECK: alloc_stack $Optional<Int>
+ // CHECK: dynamic_method_br [[T]] : $T, #P1.prop!getter.1.foreign
+ var propertyRef = t.prop
+}
+// CHECK: } // end sil function '$S17protocol_optional0B15PropertyGeneric{{[_0-9a-zA-Z]*}}F'
+
+// CHECK-LABEL: sil hidden @$S17protocol_optional0B16SubscriptGeneric{{[_0-9a-zA-Z]*}}F : $@convention(thin) <T where T : P1> (@guaranteed T) -> ()
+func optionalSubscriptGeneric<T : P1>(t t : T) {
+ var t = t
+ // CHECK: bb0([[T:%[0-9]+]] : @guaranteed $T):
+ // CHECK: [[TBOX:%[0-9]+]] = alloc_box $<τ_0_0 where τ_0_0 : P1> { var τ_0_0 } <T>
+ // CHECK: [[PT:%[0-9]+]] = project_box [[TBOX]]
+ // CHECK: [[T_COPY:%.*]] = copy_value [[T]]
+ // CHECK: store [[T_COPY]] to [init] [[PT]] : $*T
+ // CHECK: [[OPT_BOX:%[0-9]+]] = alloc_box ${ var Optional<Int> }
+ // CHECK: project_box [[OPT_BOX]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PT]] : $*T
+ // CHECK: [[T:%[0-9]+]] = load [copy] [[READ]] : $*T
+ // CHECK: [[INT64:%[0-9]+]] = metatype $@thin Int.Type
+ // CHECK: [[FIVELIT:%[0-9]+]] = integer_literal $Builtin.Int2048, 5
+ // CHECK: [[INTCONV:%[0-9]+]] = function_ref @$SSi2{{[_0-9a-zA-Z]*}}fC
+ // CHECK: [[FIVE:%[0-9]+]] = apply [[INTCONV]]([[FIVELIT]], [[INT64]]) : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int
+ // CHECK: alloc_stack $Optional<Int>
+ // CHECK: dynamic_method_br [[T]] : $T, #P1.subscript!getter.1.foreign
+ var subscriptRef = t[5]
+}
+// CHECK: } // end sil function '$S17protocol_optional0B16SubscriptGeneric{{[_0-9a-zA-Z]*}}F'
diff --git a/test/SILGen/plus_zero_protocol_resilience.swift b/test/SILGen/plus_zero_protocol_resilience.swift
new file mode 100644
index 0000000..df24b0f
--- /dev/null
+++ b/test/SILGen/plus_zero_protocol_resilience.swift
@@ -0,0 +1,318 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -enable-sil-ownership -enable-resilience -emit-module-path=%t/resilient_protocol.swiftmodule -module-name=resilient_protocol %S/../Inputs/resilient_protocol.swift
+// RUN: %target-swift-frontend -I %t -emit-silgen -enable-sil-ownership -enable-resilience %s | %FileCheck %s
+
+import resilient_protocol
+
+prefix operator ~~~ {}
+infix operator <*> {}
+infix operator <**> {}
+infix operator <===> {}
+
+public protocol P {}
+
+
+// Protocol is public -- needs resilient witness table
+public protocol ResilientMethods {
+ associatedtype AssocType : P
+
+ func defaultWitness()
+ func anotherDefaultWitness(_ x: Int) -> Self
+ func defaultWitnessWithAssociatedType(_ a: AssocType)
+ func defaultWitnessMoreAbstractThanRequirement(_ a: AssocType, b: Int)
+ func defaultWitnessMoreAbstractThanGenericRequirement<T>(_ a: AssocType, t: T)
+
+ func noDefaultWitness()
+ func defaultWitnessIsNotPublic()
+
+ static func staticDefaultWitness(_ x: Int) -> Self
+}
+
+extension ResilientMethods {
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientMethodsP14defaultWitnessyyF
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientMethodsPAAE14defaultWitnessyyF
+ public func defaultWitness() {}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientMethodsP21anotherDefaultWitnessyxSiF
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientMethodsPAAE21anotherDefaultWitnessyxSiF
+ public func anotherDefaultWitness(_ x: Int) -> Self {}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientMethodsP32defaultWitnessWithAssociatedTypeyy05AssocI0QzF
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientMethodsPAAE32defaultWitnessWithAssociatedTypeyy05AssocI0QzF
+ public func defaultWitnessWithAssociatedType(_ a: AssocType) {}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientMethodsP41defaultWitnessMoreAbstractThanRequirement_1by9AssocTypeQz_SitF
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientMethodsPAAE41defaultWitnessMoreAbstractThanRequirement_1byqd___qd_0_tr0_lF
+ public func defaultWitnessMoreAbstractThanRequirement<A, T>(_ a: A, b: T) {}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientMethodsP48defaultWitnessMoreAbstractThanGenericRequirement_1ty9AssocTypeQz_qd__tlF
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientMethodsPAAE48defaultWitnessMoreAbstractThanGenericRequirement_1tyqd___qd_0_tr0_lF
+ public func defaultWitnessMoreAbstractThanGenericRequirement<A, T>(_ a: A, t: T) {}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientMethodsP20staticDefaultWitnessyxSiFZ
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientMethodsPAAE20staticDefaultWitnessyxSiFZ
+ public static func staticDefaultWitness(_ x: Int) -> Self {}
+
+// CHECK-LABEL: sil private @$S19protocol_resilience16ResilientMethodsPAAE25defaultWitnessIsNotPublic{{.*}}F
+ private func defaultWitnessIsNotPublic() {}
+
+}
+
+
+public protocol ResilientConstructors {
+ init(noDefault: ())
+ init(default: ())
+ init?(defaultIsOptional: ())
+ init?(defaultNotOptional: ())
+ init(optionalityMismatch: ())
+}
+
+extension ResilientConstructors {
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience21ResilientConstructorsP7defaultxyt_tcfC
+// CHECK-LABEL: sil @$S19protocol_resilience21ResilientConstructorsPAAE7defaultxyt_tcfC
+ public init(default: ()) {
+ self.init(noDefault: ())
+ }
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience21ResilientConstructorsP17defaultIsOptionalxSgyt_tcfC
+// CHECK-LABEL: sil @$S19protocol_resilience21ResilientConstructorsPAAE17defaultIsOptionalxSgyt_tcfC
+ public init?(defaultIsOptional: ()) {
+ self.init(noDefault: ())
+ }
+
+// CHECK-LABEL: sil @$S19protocol_resilience21ResilientConstructorsPAAE20defaultIsNotOptionalxyt_tcfC
+ public init(defaultIsNotOptional: ()) {
+ self.init(noDefault: ())
+ }
+
+// CHECK-LABEL: sil @$S19protocol_resilience21ResilientConstructorsPAAE19optionalityMismatchxSgyt_tcfC
+ public init?(optionalityMismatch: ()) {
+ self.init(noDefault: ())
+ }
+}
+
+
+public protocol ResilientStorage {
+ associatedtype T : ResilientConstructors
+
+ var propertyWithDefault: Int { get }
+ var propertyWithNoDefault: Int { get }
+ var mutablePropertyWithDefault: Int { get set }
+ var mutablePropertyNoDefault: Int { get set }
+ var mutableGenericPropertyWithDefault: T { get set }
+
+ subscript(x: T) -> T { get set }
+
+ var mutatingGetterWithNonMutatingDefault: Int { mutating get set }
+}
+
+extension ResilientStorage {
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientStorageP19propertyWithDefaultSivg
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientStoragePAAE19propertyWithDefaultSivg
+ public var propertyWithDefault: Int {
+ get { return 0 }
+ }
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientStorageP26mutablePropertyWithDefaultSivg
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientStoragePAAE26mutablePropertyWithDefaultSivg
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientStorageP26mutablePropertyWithDefaultSivs
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientStoragePAAE26mutablePropertyWithDefaultSivs
+// CHECK-LABEL: sil private [transparent] @$S19protocol_resilience16ResilientStorageP26mutablePropertyWithDefaultSivmytfU_
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientStorageP26mutablePropertyWithDefaultSivm
+ public var mutablePropertyWithDefault: Int {
+ get { return 0 }
+ set { }
+ }
+
+ public private(set) var mutablePropertyNoDefault: Int {
+ get { return 0 }
+ set { }
+ }
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientStorageP33mutableGenericPropertyWithDefault1TQzvg
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientStoragePAAE33mutableGenericPropertyWithDefault1TQzvg
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientStorageP33mutableGenericPropertyWithDefault1TQzvs
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientStoragePAAE33mutableGenericPropertyWithDefault1TQzvs
+// CHECK-LABEL: sil private [transparent] @$S19protocol_resilience16ResilientStorageP33mutableGenericPropertyWithDefault1TQzvmytfU_
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientStorageP33mutableGenericPropertyWithDefault1TQzvm
+ public var mutableGenericPropertyWithDefault: T {
+ get {
+ return T(default: ())
+ }
+ set { }
+ }
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientStoragePy1TQzAEcig
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientStoragePAAEy1TQzAEcig
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientStoragePy1TQzAEcis
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientStoragePAAEy1TQzAEcis
+// CHECK-LABEL: sil private [transparent] @$S19protocol_resilience16ResilientStoragePy1TQzAEcimytfU_
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientStoragePy1TQzAEcim
+ public subscript(x: T) -> T {
+ get {
+ return x
+ }
+ set { }
+ }
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientStorageP36mutatingGetterWithNonMutatingDefaultSivg
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientStoragePAAE36mutatingGetterWithNonMutatingDefaultSivg
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientStorageP36mutatingGetterWithNonMutatingDefaultSivs
+// CHECK-LABEL: sil @$S19protocol_resilience16ResilientStoragePAAE36mutatingGetterWithNonMutatingDefaultSivs
+// CHECK-LABEL: sil private [transparent] @$S19protocol_resilience16ResilientStorageP36mutatingGetterWithNonMutatingDefaultSivmytfU_
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience16ResilientStorageP36mutatingGetterWithNonMutatingDefaultSivm
+ public var mutatingGetterWithNonMutatingDefault: Int {
+ get {
+ return 0
+ }
+ set { }
+ }
+}
+
+
+public protocol ResilientOperators {
+ associatedtype AssocType : P
+
+ static prefix func ~~~(s: Self)
+ static func <*><T>(s: Self, t: T)
+ static func <**><T>(t: T, s: Self) -> AssocType
+ static func <===><T : ResilientOperators>(t: T, s: Self) -> T.AssocType
+}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience18ResilientOperatorsP3tttopyyxFZ
+// CHECK-LABEL: sil @$S19protocol_resilience3tttopyyxlF
+public prefix func ~~~<S>(s: S) {}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience18ResilientOperatorsP3lmgoiyyx_qd__tlFZ
+// CHECK-LABEL: sil @$S19protocol_resilience3lmgoiyyq__xtr0_lF
+public func <*><T, S>(s: S, t: T) {}
+
+// Swap the generic parameters to make sure we don't mix up our DeclContexts
+// when mapping interface types in and out
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience18ResilientOperatorsP4lmmgoiy9AssocTypeQzqd___xtlFZ
+// CHECK-LABEL: sil @$S19protocol_resilience4lmmgoiy9AssocTypeQzq__xtAA18ResilientOperatorsRzr0_lF
+public func <**><S : ResilientOperators, T>(t: T, s: S) -> S.AssocType {}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience18ResilientOperatorsP5leeegoiy9AssocTypeQyd__qd___xtAaBRd__lFZ
+// CHECK-LABEL: sil @$S19protocol_resilience5leeegoiy9AssocTypeQzx_q_tAA18ResilientOperatorsRzAaER_r0_lF
+public func <===><T : ResilientOperators, S : ResilientOperators>(t: T, s: S) -> T.AssocType {}
+
+
+public protocol ReabstractSelfBase {
+ // No requirements
+}
+
+public protocol ReabstractSelfRefined : class, ReabstractSelfBase {
+ // A requirement with 'Self' abstracted as a class instance
+ var callback: (Self) -> Self { get set }
+}
+
+func id<T>(_ t: T) -> T {}
+
+extension ReabstractSelfBase {
+ // A witness for the above requirement, but with 'Self' maximally abstracted
+ public var callback: (Self) -> Self {
+ get { return id }
+ nonmutating set { }
+ }
+}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S19protocol_resilience21ReabstractSelfRefinedP8callbackyxxcvg : $@convention(witness_method: ReabstractSelfRefined) <τ_0_0 where τ_0_0 : ReabstractSelfRefined> (@guaranteed τ_0_0) -> @owned @callee_guaranteed (@guaranteed τ_0_0) -> @owned τ_0_0
+// CHECK: [[SELF_BOX:%.*]] = alloc_stack $τ_0_0
+// CHECK-NEXT: [[SELF_COPY:%.*]] = copy_value %0 : $τ_0_0
+// CHECK-NEXT: store [[SELF_COPY]] to [init] [[SELF_BOX]] : $*τ_0_0
+// CHECK: [[WITNESS:%.*]] = function_ref @$S19protocol_resilience18ReabstractSelfBasePAAE8callbackyxxcvg
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[WITNESS]]<τ_0_0>([[SELF_BOX]])
+// CHECK: [[THUNK_FN:%.*]] = function_ref @$SxxIegnr_xxIeggo_19protocol_resilience21ReabstractSelfRefinedRzlTR
+// CHECK-NEXT: [[THUNK:%.*]] = partial_apply [callee_guaranteed] [[THUNK_FN]]<τ_0_0>([[RESULT]])
+// CHECK-NEXT: destroy_addr [[SELF_BOX]]
+// CHECK-NEXT: dealloc_stack [[SELF_BOX]]
+// CHECK-NEXT: return [[THUNK]]
+
+final class X : ReabstractSelfRefined {}
+
+func inoutFunc(_ x: inout Int) {}
+
+// CHECK-LABEL: sil hidden @$S19protocol_resilience22inoutResilientProtocolyy010resilient_A005OtherdE0_pzF
+func inoutResilientProtocol(_ x: inout OtherResilientProtocol) {
+ // CHECK: function_ref @$S18resilient_protocol22OtherResilientProtocolPAAE19propertyInExtensionSivm
+ inoutFunc(&x.propertyInExtension)
+}
+
+struct OtherConformingType : OtherResilientProtocol {}
+
+// CHECK-LABEL: sil hidden @$S19protocol_resilience22inoutResilientProtocolyyAA19OtherConformingTypeVzF
+func inoutResilientProtocol(_ x: inout OtherConformingType) {
+ // CHECK: function_ref @$S18resilient_protocol22OtherResilientProtocolPAAE19propertyInExtensionSivm
+ inoutFunc(&x.propertyInExtension)
+
+ // CHECK: function_ref @$S18resilient_protocol22OtherResilientProtocolPAAE25staticPropertyInExtensionSivmZ
+ inoutFunc(&OtherConformingType.staticPropertyInExtension)
+}
+
+// CHECK-LABEL: sil_default_witness_table P {
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil_default_witness_table ResilientMethods {
+// CHECK-NEXT: no_default
+// CHECK-NEXT: no_default
+// CHECK-NEXT: method #ResilientMethods.defaultWitness!1: {{.*}} : @$S19protocol_resilience16ResilientMethodsP14defaultWitnessyyF
+// CHECK-NEXT: method #ResilientMethods.anotherDefaultWitness!1: {{.*}} : @$S19protocol_resilience16ResilientMethodsP21anotherDefaultWitnessyxSiF
+// CHECK-NEXT: method #ResilientMethods.defaultWitnessWithAssociatedType!1: {{.*}} : @$S19protocol_resilience16ResilientMethodsP32defaultWitnessWithAssociatedTypeyy05AssocI0QzF
+// CHECK-NEXT: method #ResilientMethods.defaultWitnessMoreAbstractThanRequirement!1: {{.*}} : @$S19protocol_resilience16ResilientMethodsP41defaultWitnessMoreAbstractThanRequirement_1by9AssocTypeQz_SitF
+// CHECK-NEXT: method #ResilientMethods.defaultWitnessMoreAbstractThanGenericRequirement!1: {{.*}} : @$S19protocol_resilience16ResilientMethodsP48defaultWitnessMoreAbstractThanGenericRequirement_1ty9AssocTypeQz_qd__tlF
+// CHECK-NEXT: no_default
+// CHECK-NEXT: no_default
+// CHECK-NEXT: method #ResilientMethods.staticDefaultWitness!1: {{.*}} : @$S19protocol_resilience16ResilientMethodsP20staticDefaultWitnessyxSiFZ
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil_default_witness_table ResilientConstructors {
+// CHECK-NEXT: no_default
+// CHECK-NEXT: method #ResilientConstructors.init!allocator.1: {{.*}} : @$S19protocol_resilience21ResilientConstructorsP7defaultxyt_tcfC
+// CHECK-NEXT: method #ResilientConstructors.init!allocator.1: {{.*}} : @$S19protocol_resilience21ResilientConstructorsP17defaultIsOptionalxSgyt_tcfC
+// CHECK-NEXT: no_default
+// CHECK-NEXT: no_default
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil_default_witness_table ResilientStorage {
+// CHECK-NEXT: no_default
+// CHECK-NEXT: no_default
+// CHECK-NEXT: method #ResilientStorage.propertyWithDefault!getter.1: {{.*}} : @$S19protocol_resilience16ResilientStorageP19propertyWithDefaultSivg
+// CHECK-NEXT: no_default
+// CHECK-NEXT: method #ResilientStorage.mutablePropertyWithDefault!getter.1: {{.*}} : @$S19protocol_resilience16ResilientStorageP26mutablePropertyWithDefaultSivg
+// CHECK-NEXT: method #ResilientStorage.mutablePropertyWithDefault!setter.1: {{.*}} : @$S19protocol_resilience16ResilientStorageP26mutablePropertyWithDefaultSivs
+// CHECK-NEXT: method #ResilientStorage.mutablePropertyWithDefault!materializeForSet.1: {{.*}} : @$S19protocol_resilience16ResilientStorageP26mutablePropertyWithDefaultSivm
+// CHECK-NEXT: no_default
+// CHECK-NEXT: no_default
+// CHECK-NEXT: no_default
+// CHECK-NEXT: method #ResilientStorage.mutableGenericPropertyWithDefault!getter.1: {{.*}} : @$S19protocol_resilience16ResilientStorageP33mutableGenericPropertyWithDefault1TQzvg
+// CHECK-NEXT: method #ResilientStorage.mutableGenericPropertyWithDefault!setter.1: {{.*}} : @$S19protocol_resilience16ResilientStorageP33mutableGenericPropertyWithDefault1TQzvs
+// CHECK-NEXT: method #ResilientStorage.mutableGenericPropertyWithDefault!materializeForSet.1: {{.*}} : @$S19protocol_resilience16ResilientStorageP33mutableGenericPropertyWithDefault1TQzvm
+// CHECK-NEXT: method #ResilientStorage.subscript!getter.1: {{.*}} : @$S19protocol_resilience16ResilientStoragePy1TQzAEcig
+// CHECK-NEXT: method #ResilientStorage.subscript!setter.1: {{.*}} : @$S19protocol_resilience16ResilientStoragePy1TQzAEcis
+// CHECK-NEXT: method #ResilientStorage.subscript!materializeForSet.1: {{.*}} : @$S19protocol_resilience16ResilientStoragePy1TQzAEcim
+// CHECK-NEXT: method #ResilientStorage.mutatingGetterWithNonMutatingDefault!getter.1: {{.*}} : @$S19protocol_resilience16ResilientStorageP36mutatingGetterWithNonMutatingDefaultSivg
+// CHECK-NEXT: method #ResilientStorage.mutatingGetterWithNonMutatingDefault!setter.1: {{.*}} : @$S19protocol_resilience16ResilientStorageP36mutatingGetterWithNonMutatingDefaultSivs
+// CHECK-NEXT: method #ResilientStorage.mutatingGetterWithNonMutatingDefault!materializeForSet.1: {{.*}} : @$S19protocol_resilience16ResilientStorageP36mutatingGetterWithNonMutatingDefaultSivm
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil_default_witness_table ResilientOperators {
+// CHECK-NEXT: no_default
+// CHECK-NEXT: no_default
+// CHECK-NEXT: method #ResilientOperators."~~~"!1: {{.*}} : @$S19protocol_resilience18ResilientOperatorsP3tttopyyxFZ
+// CHECK-NEXT: method #ResilientOperators."<*>"!1: {{.*}} : @$S19protocol_resilience18ResilientOperatorsP3lmgoiyyx_qd__tlFZ
+// CHECK-NEXT: method #ResilientOperators."<**>"!1: {{.*}} : @$S19protocol_resilience18ResilientOperatorsP4lmmgoiy9AssocTypeQzqd___xtlFZ
+// CHECK-NEXT: method #ResilientOperators."<===>"!1: {{.*}} : @$S19protocol_resilience18ResilientOperatorsP5leeegoiy9AssocTypeQyd__qd___xtAaBRd__lFZ
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil_default_witness_table ReabstractSelfRefined {
+// CHECK-NEXT: no_default
+// CHECK-NEXT: method #ReabstractSelfRefined.callback!getter.1: {{.*}} : @$S19protocol_resilience21ReabstractSelfRefinedP8callbackyxxcvg
+// CHECK-NEXT: method #ReabstractSelfRefined.callback!setter.1: {{.*}} : @$S19protocol_resilience21ReabstractSelfRefinedP8callbackyxxcvs
+// CHECK-NEXT: method #ReabstractSelfRefined.callback!materializeForSet.1: {{.*}} : @$S19protocol_resilience21ReabstractSelfRefinedP8callbackyxxcvm
+// CHECK-NEXT: }
diff --git a/test/SILGen/plus_zero_protocols.swift b/test/SILGen/plus_zero_protocols.swift
new file mode 100644
index 0000000..20cb940
--- /dev/null
+++ b/test/SILGen/plus_zero_protocols.swift
@@ -0,0 +1,472 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+//===----------------------------------------------------------------------===//
+// Calling Existential Subscripts
+//===----------------------------------------------------------------------===//
+
+protocol SubscriptableGet {
+ subscript(a : Int) -> Int { get }
+}
+
+protocol SubscriptableGetSet {
+ subscript(a : Int) -> Int { get set }
+}
+
+var subscriptableGet : SubscriptableGet
+var subscriptableGetSet : SubscriptableGetSet
+
+func use_subscript_rvalue_get(_ i : Int) -> Int {
+ return subscriptableGet[i]
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}use_subscript_rvalue_get
+// CHECK: bb0(%0 : @trivial $Int):
+// CHECK: [[GLOB:%[0-9]+]] = global_addr @$S9protocols16subscriptableGetAA013SubscriptableC0_pvp : $*SubscriptableGet
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[GLOB]] : $*SubscriptableGet
+// CHECK: [[PROJ:%[0-9]+]] = open_existential_addr immutable_access [[READ]] : $*SubscriptableGet to $*[[OPENED:@opened(.*) SubscriptableGet]]
+// CHECK: [[ALLOCSTACK:%[0-9]+]] = alloc_stack $[[OPENED]]
+// CHECK: copy_addr [[PROJ]] to [initialization] [[ALLOCSTACK]] : $*[[OPENED]]
+// CHECK-NEXT: [[METH:%[0-9]+]] = witness_method $[[OPENED]], #SubscriptableGet.subscript!getter.1
+// CHECK-NEXT: [[RESULT:%[0-9]+]] = apply [[METH]]<[[OPENED]]>(%0, [[ALLOCSTACK]])
+// CHECK-NEXT: destroy_addr [[ALLOCSTACK]]
+// CHECK-NEXT: end_access [[READ]] : $*SubscriptableGet
+// CHECK-NEXT: dealloc_stack [[ALLOCSTACK]] : $*[[OPENED]]
+// CHECK-NEXT: return [[RESULT]]
+
+func use_subscript_lvalue_get(_ i : Int) -> Int {
+ return subscriptableGetSet[i]
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}use_subscript_lvalue_get
+// CHECK: bb0(%0 : @trivial $Int):
+// CHECK: [[GLOB:%[0-9]+]] = global_addr @$S9protocols19subscriptableGetSetAA013SubscriptablecD0_pvp : $*SubscriptableGetSet
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[GLOB]] : $*SubscriptableGetSet
+// CHECK: [[PROJ:%[0-9]+]] = open_existential_addr immutable_access [[READ]] : $*SubscriptableGetSet to $*[[OPENED:@opened(.*) SubscriptableGetSet]]
+// CHECK: [[ALLOCSTACK:%[0-9]+]] = alloc_stack $[[OPENED]]
+// CHECK: copy_addr [[PROJ]] to [initialization] [[ALLOCSTACK]] : $*[[OPENED]]
+// CHECK-NEXT: [[METH:%[0-9]+]] = witness_method $[[OPENED]], #SubscriptableGetSet.subscript!getter.1
+// CHECK-NEXT: [[RESULT:%[0-9]+]] = apply [[METH]]<[[OPENED]]>(%0, [[ALLOCSTACK]])
+// CHECK-NEXT: destroy_addr [[ALLOCSTACK]] : $*[[OPENED]]
+// CHECK-NEXT: end_access [[READ]] : $*SubscriptableGetSet
+// CHECK-NEXT: dealloc_stack [[ALLOCSTACK]] : $*[[OPENED]]
+// CHECK-NEXT: return [[RESULT]]
+
+func use_subscript_lvalue_set(_ i : Int) {
+ subscriptableGetSet[i] = i
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}use_subscript_lvalue_set
+// CHECK: bb0(%0 : @trivial $Int):
+// CHECK: [[GLOB:%[0-9]+]] = global_addr @$S9protocols19subscriptableGetSetAA013SubscriptablecD0_pvp : $*SubscriptableGetSet
+// CHECK: [[READ:%.*]] = begin_access [modify] [dynamic] [[GLOB]] : $*SubscriptableGetSet
+// CHECK: [[PROJ:%[0-9]+]] = open_existential_addr mutable_access [[READ]] : $*SubscriptableGetSet to $*[[OPENED:@opened(.*) SubscriptableGetSet]]
+// CHECK-NEXT: [[METH:%[0-9]+]] = witness_method $[[OPENED]], #SubscriptableGetSet.subscript!setter.1
+// CHECK-NEXT: apply [[METH]]<[[OPENED]]>(%0, %0, [[PROJ]])
+
+
+//===----------------------------------------------------------------------===//
+// Calling Archetype Subscripts
+//===----------------------------------------------------------------------===//
+
+func use_subscript_archetype_rvalue_get<T : SubscriptableGet>(_ generic : T, idx : Int) -> Int {
+ return generic[idx]
+}
+// CHECK-LABEL: sil hidden @{{.*}}use_subscript_archetype_rvalue_get
+// CHECK: bb0(%0 : @trivial $*T, %1 : @trivial $Int):
+// CHECK: [[STACK:%[0-9]+]] = alloc_stack $T
+// CHECK: copy_addr %0 to [initialization] [[STACK]]
+// CHECK: [[METH:%[0-9]+]] = witness_method $T, #SubscriptableGet.subscript!getter.1
+// CHECK-NEXT: apply [[METH]]<T>(%1, [[STACK]])
+// CHECK-NEXT: destroy_addr [[STACK]] : $*T
+// CHECK-NEXT: dealloc_stack [[STACK]] : $*T
+// CHECK: } // end sil function '${{.*}}use_subscript_archetype_rvalue_get
+
+
+func use_subscript_archetype_lvalue_get<T : SubscriptableGetSet>(_ generic: inout T, idx : Int) -> Int {
+ return generic[idx]
+}
+// CHECK-LABEL: sil hidden @{{.*}}use_subscript_archetype_lvalue_get
+// CHECK: bb0(%0 : @trivial $*T, %1 : @trivial $Int):
+// CHECK: [[READ:%.*]] = begin_access [read] [unknown] %0 : $*T
+// CHECK: [[GUARANTEEDSTACK:%[0-9]+]] = alloc_stack $T
+// CHECK: copy_addr [[READ]] to [initialization] [[GUARANTEEDSTACK]] : $*T
+// CHECK: [[METH:%[0-9]+]] = witness_method $T, #SubscriptableGetSet.subscript!getter.1
+// CHECK-NEXT: [[APPLYRESULT:%[0-9]+]] = apply [[METH]]<T>(%1, [[GUARANTEEDSTACK]])
+// CHECK-NEXT: destroy_addr [[GUARANTEEDSTACK]] : $*T
+// CHECK-NEXT: end_access [[READ]]
+// CHECK-NEXT: dealloc_stack [[GUARANTEEDSTACK]] : $*T
+// CHECK: return [[APPLYRESULT]]
+
+
+func use_subscript_archetype_lvalue_set<T : SubscriptableGetSet>(_ generic: inout T, idx : Int) {
+ generic[idx] = idx
+}
+// CHECK-LABEL: sil hidden @{{.*}}use_subscript_archetype_lvalue_set
+// CHECK: bb0(%0 : @trivial $*T, %1 : @trivial $Int):
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] %0 : $*T
+// CHECK: [[METH:%[0-9]+]] = witness_method $T, #SubscriptableGetSet.subscript!setter.1
+// CHECK-NEXT: apply [[METH]]<T>(%1, %1, [[WRITE]])
+
+
+//===----------------------------------------------------------------------===//
+// Calling Existential Properties
+//===----------------------------------------------------------------------===//
+
+protocol PropertyWithGetter {
+ var a : Int { get }
+}
+
+protocol PropertyWithGetterSetter {
+ var b : Int { get set }
+}
+
+
+var propertyGet : PropertyWithGetter
+var propertyGetSet : PropertyWithGetterSetter
+
+func use_property_rvalue_get() -> Int {
+ return propertyGet.a
+}
+// CHECK-LABEL: sil hidden @{{.*}}use_property_rvalue_get
+// CHECK: [[GLOB:%[0-9]+]] = global_addr @$S9protocols11propertyGetAA18PropertyWithGetter_pvp : $*PropertyWithGetter
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[GLOB]] : $*PropertyWithGetter
+// CHECK: [[PROJ:%[0-9]+]] = open_existential_addr immutable_access [[READ]] : $*PropertyWithGetter to $*[[OPENED:@opened(.*) PropertyWithGetter]]
+// CHECK: [[COPY:%.*]] = alloc_stack $[[OPENED]]
+// CHECK-NEXT: copy_addr [[PROJ]] to [initialization] [[COPY]] : $*[[OPENED]]
+// CHECK-NEXT: [[METH:%[0-9]+]] = witness_method $[[OPENED]], #PropertyWithGetter.a!getter.1
+// CHECK-NEXT: apply [[METH]]<[[OPENED]]>([[COPY]])
+// CHECK: end_access [[READ]] : $*PropertyWithGetter
+
+func use_property_lvalue_get() -> Int {
+ return propertyGetSet.b
+}
+// CHECK-LABEL: sil hidden @{{.*}}use_property_lvalue_get
+// CHECK: [[GLOB:%[0-9]+]] = global_addr @$S9protocols14propertyGetSetAA24PropertyWithGetterSetter_pvp : $*PropertyWithGetterSetter
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[GLOB]] : $*PropertyWithGetterSetter
+// CHECK: [[PROJ:%[0-9]+]] = open_existential_addr immutable_access [[READ]] : $*PropertyWithGetterSetter to $*[[OPENED:@opened(.*) PropertyWithGetterSetter]]
+// CHECK: [[STACK:%[0-9]+]] = alloc_stack $[[OPENED]]
+// CHECK: copy_addr [[PROJ]] to [initialization] [[STACK]]
+// CHECK-NEXT: [[METH:%[0-9]+]] = witness_method $[[OPENED]], #PropertyWithGetterSetter.b!getter.1
+// CHECK-NEXT: apply [[METH]]<[[OPENED]]>([[STACK]])
+
+func use_property_lvalue_set(_ x : Int) {
+ propertyGetSet.b = x
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}use_property_lvalue_set
+// CHECK: bb0(%0 : @trivial $Int):
+// CHECK: [[GLOB:%[0-9]+]] = global_addr @$S9protocols14propertyGetSetAA24PropertyWithGetterSetter_pvp : $*PropertyWithGetterSetter
+// CHECK: [[READ:%.*]] = begin_access [modify] [dynamic] [[GLOB]] : $*PropertyWithGetterSetter
+// CHECK: [[PROJ:%[0-9]+]] = open_existential_addr mutable_access [[READ]] : $*PropertyWithGetterSetter to $*[[OPENED:@opened(.*) PropertyWithGetterSetter]]
+// CHECK-NEXT: [[METH:%[0-9]+]] = witness_method $[[OPENED]], #PropertyWithGetterSetter.b!setter.1
+// CHECK-NEXT: apply [[METH]]<[[OPENED]]>(%0, [[PROJ]])
+
+//===----------------------------------------------------------------------===//
+// Calling Archetype Properties
+//===----------------------------------------------------------------------===//
+
+func use_property_archetype_rvalue_get<T : PropertyWithGetter>(_ generic : T) -> Int {
+ return generic.a
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}use_property_archetype_rvalue_get
+// CHECK: bb0(%0 : @trivial $*T):
+// CHECK: [[STACK:%[0-9]+]] = alloc_stack $T
+// CHECK: copy_addr %0 to [initialization] [[STACK]]
+// CHECK: [[METH:%[0-9]+]] = witness_method $T, #PropertyWithGetter.a!getter.1
+// CHECK-NEXT: apply [[METH]]<T>([[STACK]])
+// CHECK-NEXT: destroy_addr [[STACK]]
+// CHECK-NEXT: dealloc_stack [[STACK]]
+// CHECK: } // end sil function '{{.*}}use_property_archetype_rvalue_get
+
+
+func use_property_archetype_lvalue_get<T : PropertyWithGetterSetter>(_ generic : T) -> Int {
+ return generic.b
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}use_property_archetype_lvalue_get
+// CHECK: bb0(%0 : @trivial $*T):
+// CHECK: [[STACK:%[0-9]+]] = alloc_stack $T
+// CHECK: copy_addr %0 to [initialization] [[STACK]] : $*T
+// CHECK: [[METH:%[0-9]+]] = witness_method $T, #PropertyWithGetterSetter.b!getter.1
+// CHECK-NEXT: apply [[METH]]<T>([[STACK]])
+// CHECK-NEXT: destroy_addr [[STACK]] : $*T
+// CHECK-NEXT: dealloc_stack [[STACK]] : $*T
+// CHECK: } // end sil function '${{.*}}use_property_archetype_lvalue_get
+
+
+func use_property_archetype_lvalue_set<T : PropertyWithGetterSetter>(_ generic: inout T, v : Int) {
+ generic.b = v
+}
+// CHECK-LABEL: sil hidden @{{.*}}use_property_archetype_lvalue_set
+// CHECK: bb0(%0 : @trivial $*T, %1 : @trivial $Int):
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] %0 : $*T
+// CHECK: [[METH:%[0-9]+]] = witness_method $T, #PropertyWithGetterSetter.b!setter.1
+// CHECK-NEXT: apply [[METH]]<T>(%1, [[WRITE]])
+
+//===----------------------------------------------------------------------===//
+// Calling Initializers
+//===----------------------------------------------------------------------===//
+protocol Initializable {
+ init(int: Int)
+}
+
+// CHECK-LABEL: sil hidden @$S9protocols27use_initializable_archetype{{[_0-9a-zA-Z]*}}F
+func use_initializable_archetype<T: Initializable>(_ t: T, i: Int) {
+ // CHECK: [[T_RESULT:%[0-9]+]] = alloc_stack $T
+ // CHECK: [[T_META:%[0-9]+]] = metatype $@thick T.Type
+ // CHECK: [[T_INIT:%[0-9]+]] = witness_method $T, #Initializable.init!allocator.1 : {{.*}} : $@convention(witness_method: Initializable) <τ_0_0 where τ_0_0 : Initializable> (Int, @thick τ_0_0.Type) -> @out τ_0_0
+ // CHECK: [[T_RESULT_ADDR:%[0-9]+]] = apply [[T_INIT]]<T>([[T_RESULT]], %1, [[T_META]]) : $@convention(witness_method: Initializable) <τ_0_0 where τ_0_0 : Initializable> (Int, @thick τ_0_0.Type) -> @out τ_0_0
+ // CHECK: destroy_addr [[T_RESULT]] : $*T
+ // CHECK: dealloc_stack [[T_RESULT]] : $*T
+ // CHECK: [[RESULT:%[0-9]+]] = tuple ()
+ // CHECK: return [[RESULT]] : $()
+ T(int: i)
+}
+
+// CHECK: sil hidden @$S9protocols29use_initializable_existential{{[_0-9a-zA-Z]*}}F
+func use_initializable_existential(_ im: Initializable.Type, i: Int) {
+// CHECK: bb0([[IM:%[0-9]+]] : @trivial $@thick Initializable.Type, [[I:%[0-9]+]] : @trivial $Int):
+// CHECK: [[ARCHETYPE_META:%[0-9]+]] = open_existential_metatype [[IM]] : $@thick Initializable.Type to $@thick (@opened([[N:".*"]]) Initializable).Type
+// CHECK: [[TEMP_VALUE:%[0-9]+]] = alloc_stack $Initializable
+// CHECK: [[TEMP_ADDR:%[0-9]+]] = init_existential_addr [[TEMP_VALUE]] : $*Initializable, $@opened([[N]]) Initializable
+// CHECK: [[INIT_WITNESS:%[0-9]+]] = witness_method $@opened([[N]]) Initializable, #Initializable.init!allocator.1 : {{.*}}, [[ARCHETYPE_META]]{{.*}} : $@convention(witness_method: Initializable) <τ_0_0 where τ_0_0 : Initializable> (Int, @thick τ_0_0.Type) -> @out τ_0_0
+// CHECK: [[INIT_RESULT:%[0-9]+]] = apply [[INIT_WITNESS]]<@opened([[N]]) Initializable>([[TEMP_ADDR]], [[I]], [[ARCHETYPE_META]]) : $@convention(witness_method: Initializable) <τ_0_0 where τ_0_0 : Initializable> (Int, @thick τ_0_0.Type) -> @out τ_0_0
+// CHECK: destroy_addr [[TEMP_VALUE]] : $*Initializable
+// CHECK: dealloc_stack [[TEMP_VALUE]] : $*Initializable
+ im.init(int: i)
+// CHECK: [[RESULT:%[0-9]+]] = tuple ()
+// CHECK: return [[RESULT]] : $()
+}
+
+//===----------------------------------------------------------------------===//
+// Protocol conformance and witness table generation
+//===----------------------------------------------------------------------===//
+
+class ClassWithGetter : PropertyWithGetter {
+ var a: Int {
+ get {
+ return 42
+ }
+ }
+}
+
+// Make sure we are generating a protocol witness that calls the class method on
+// ClassWithGetter.
+// CHECK-LABEL: sil private [transparent] [thunk] @$S9protocols15ClassWithGetterCAA08PropertycD0A2aDP1aSivgTW : $@convention(witness_method: PropertyWithGetter) (@in_guaranteed ClassWithGetter) -> Int {
+// CHECK: bb0([[C:%.*]] : @trivial $*ClassWithGetter):
+// CHECK-NEXT: [[CCOPY_LOADED:%.*]] = load_borrow %0
+// CHECK-NEXT: [[FUN:%.*]] = class_method [[CCOPY_LOADED]] : $ClassWithGetter, #ClassWithGetter.a!getter.1 : (ClassWithGetter) -> () -> Int, $@convention(method) (@guaranteed ClassWithGetter) -> Int
+// CHECK-NEXT: apply [[FUN]]([[CCOPY_LOADED]])
+// CHECK-NEXT: end_borrow [[CCOPY_LOADED]] from %0
+// CHECK-NEXT: return
+
+class ClassWithGetterSetter : PropertyWithGetterSetter, PropertyWithGetter {
+ var a: Int {
+ get {
+ return 1
+ }
+ set {}
+ }
+ var b: Int {
+ get {
+ return 2
+ }
+ set {}
+ }
+}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S9protocols21ClassWithGetterSetterCAA08PropertycdE0A2aDP1bSivgTW : $@convention(witness_method: PropertyWithGetterSetter) (@in_guaranteed ClassWithGetterSetter) -> Int {
+// CHECK: bb0([[C:%.*]] : @trivial $*ClassWithGetterSetter):
+// CHECK-NEXT: [[CCOPY_LOADED:%.*]] = load_borrow %0
+// CHECK-NEXT: [[FUN:%.*]] = class_method [[CCOPY_LOADED]] : $ClassWithGetterSetter, #ClassWithGetterSetter.b!getter.1 : (ClassWithGetterSetter) -> () -> Int, $@convention(method) (@guaranteed ClassWithGetterSetter) -> Int
+// CHECK-NEXT: apply [[FUN]]([[CCOPY_LOADED]])
+// CHECK-NEXT: end_borrow [[CCOPY_LOADED]] from %0
+// CHECK-NEXT: return
+
+// Stored variables fulfilling property requirements
+//
+class ClassWithStoredProperty : PropertyWithGetter {
+ var a : Int = 0
+
+ // Make sure that accesses go through the generated accessors for classes.
+ func methodUsingProperty() -> Int {
+ return a
+ }
+ // CHECK-LABEL: sil hidden @$S9protocols23ClassWithStoredPropertyC011methodUsingE0SiyF
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $ClassWithStoredProperty):
+ // CHECK-NEXT: debug_value [[ARG]]
+ // CHECK-NOT: copy_value
+ // CHECK-NEXT: [[FUN:%.*]] = class_method [[ARG]] : $ClassWithStoredProperty, #ClassWithStoredProperty.a!getter.1 : (ClassWithStoredProperty) -> () -> Int, $@convention(method) (@guaranteed ClassWithStoredProperty) -> Int
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[FUN]]([[ARG]])
+ // CHECK-NOT: destroy_value
+ // CHECK-NEXT: return [[RESULT]] : $Int
+}
+
+struct StructWithStoredProperty : PropertyWithGetter {
+ var a : Int
+
+ // Make sure that accesses aren't going through the generated accessors.
+ func methodUsingProperty() -> Int {
+ return a
+ }
+ // CHECK-LABEL: sil hidden @$S9protocols24StructWithStoredPropertyV011methodUsingE0SiyF
+ // CHECK: bb0(%0 : @trivial $StructWithStoredProperty):
+ // CHECK-NEXT: debug_value %0
+ // CHECK-NEXT: %2 = struct_extract %0 : $StructWithStoredProperty, #StructWithStoredProperty.a
+ // CHECK-NEXT: return %2 : $Int
+}
+
+// Make sure that we generate direct function calls for out struct protocol
+// witness since structs don't do virtual calls for methods.
+//
+// *NOTE* Even though at first glance the copy_addr looks like a leak
+// here, StructWithStoredProperty is a trivial struct implying that no
+// leak is occurring. See the test with StructWithStoredClassProperty
+// that makes sure in such a case we don't leak. This is due to the
+// thunking code being too dumb but it is harmless to program
+// correctness.
+//
+// CHECK-LABEL: sil private [transparent] [thunk] @$S9protocols24StructWithStoredPropertyVAA0eC6GetterA2aDP1aSivgTW : $@convention(witness_method: PropertyWithGetter) (@in_guaranteed StructWithStoredProperty) -> Int {
+// CHECK: bb0([[C:%.*]] : @trivial $*StructWithStoredProperty):
+// CHECK-NEXT: [[CCOPY_LOADED:%.*]] = load [trivial] [[C]]
+// CHECK-NEXT: function_ref
+// CHECK-NEXT: [[FUN:%.*]] = function_ref @$S9protocols24StructWithStoredPropertyV1aSivg : $@convention(method) (StructWithStoredProperty) -> Int
+// CHECK-NEXT: apply [[FUN]]([[CCOPY_LOADED]])
+// CHECK-NEXT: return
+
+class C {}
+
+// Make sure that if the getter has a class property, we pass it in
+// in_guaranteed and don't leak.
+struct StructWithStoredClassProperty : PropertyWithGetter {
+ var a : Int
+ var c: C = C()
+
+ // Make sure that accesses aren't going through the generated accessors.
+ func methodUsingProperty() -> Int {
+ return a
+ }
+ // CHECK-LABEL: sil hidden @$S9protocols29StructWithStoredClassPropertyV011methodUsingF0SiyF
+ // CHECK: bb0(%0 : @guaranteed $StructWithStoredClassProperty):
+ // CHECK-NEXT: debug_value %0
+ // CHECK-NEXT: %2 = struct_extract %0 : $StructWithStoredClassProperty, #StructWithStoredClassProperty.a
+ // CHECK-NEXT: return %2 : $Int
+}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S9protocols29StructWithStoredClassPropertyVAA0fC6GetterA2aDP1aSivgTW : $@convention(witness_method: PropertyWithGetter) (@in_guaranteed StructWithStoredClassProperty) -> Int {
+// CHECK: bb0([[C:%.*]] : @trivial $*StructWithStoredClassProperty):
+// CHECK-NEXT: [[CCOPY_LOADED:%.*]] = load_borrow [[C]]
+// CHECK-NEXT: function_ref
+// CHECK-NEXT: [[FUN:%.*]] = function_ref @$S9protocols29StructWithStoredClassPropertyV1aSivg : $@convention(method) (@guaranteed StructWithStoredClassProperty) -> Int
+// CHECK-NEXT: apply [[FUN]]([[CCOPY_LOADED]])
+// CHECK-NEXT: end_borrow [[CCOPY_LOADED]] from %0
+// CHECK-NEXT: return
+
+// rdar://22676810
+
+protocol ExistentialProperty {
+ var p: PropertyWithGetterSetter { get set }
+}
+
+func testExistentialPropertyRead<T: ExistentialProperty>(_ t: inout T) {
+ let b = t.p.b
+}
+// CHECK-LABEL: sil hidden @$S9protocols27testExistentialPropertyRead{{[_0-9a-zA-Z]*}}F
+// CHECK: [[READ:%.*]] = begin_access [read] [unknown] %0 : $*T
+// CHECK: [[P_TEMP:%.*]] = alloc_stack $PropertyWithGetterSetter
+// CHECK: [[T_TEMP:%.*]] = alloc_stack $T
+// CHECK: copy_addr [[READ]] to [initialization] [[T_TEMP]] : $*T
+// CHECK: [[P_GETTER:%.*]] = witness_method $T, #ExistentialProperty.p!getter.1 :
+// CHECK-NEXT: apply [[P_GETTER]]<T>([[P_TEMP]], [[T_TEMP]])
+// CHECK-NEXT: destroy_addr [[T_TEMP]]
+// CHECK-NEXT: [[OPEN:%.*]] = open_existential_addr immutable_access [[P_TEMP]] : $*PropertyWithGetterSetter to $*[[P_OPENED:@opened(.*) PropertyWithGetterSetter]]
+// CHECK-NEXT: [[T0:%.*]] = alloc_stack $[[P_OPENED]]
+// CHECK-NEXT: copy_addr [[OPEN]] to [initialization] [[T0]]
+// CHECK-NEXT: [[B_GETTER:%.*]] = witness_method $[[P_OPENED]], #PropertyWithGetterSetter.b!getter.1
+// CHECK-NEXT: apply [[B_GETTER]]<[[P_OPENED]]>([[T0]])
+// CHECK-NEXT: debug_value
+// CHECK-NEXT: destroy_addr [[T0]]
+// CHECK-NOT: witness_method
+// CHECK: return
+
+func modify(_ x: inout Int) {}
+
+// Make sure we call the materializeForSet callback with the correct
+// generic signature.
+
+func modifyProperty<T : PropertyWithGetterSetter>(_ x: inout T) {
+ modify(&x.b)
+}
+// CHECK-LABEL: sil hidden @$S9protocols14modifyPropertyyyxzAA0C16WithGetterSetterRzlF
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] %0 : $*T
+// CHECK: [[WITNESS_FN:%.*]] = witness_method $T, #PropertyWithGetterSetter.b!materializeForSet.1
+// CHECK: [[RESULT:%.*]] = apply [[WITNESS_FN]]<T>
+// CHECK: [[TEMPORARY:%.*]] = tuple_extract [[RESULT]]
+// CHECK: [[CALLBACK:%.*]] = tuple_extract [[RESULT]]
+// CHECK: [[TEMPORARY_ADDR_TMP:%.*]] = pointer_to_address [[TEMPORARY]] : $Builtin.RawPointer to [strict] $*Int
+// CHECK: [[TEMPORARY_ADDR:%.*]] = mark_dependence [[TEMPORARY_ADDR_TMP]] : $*Int on [[WRITE]] : $*T
+// CHECK: [[MODIFY_FN:%.*]] = function_ref @$S9protocols6modifyyySizF
+// CHECK: apply [[MODIFY_FN]]([[TEMPORARY_ADDR]])
+// CHECK: switch_enum [[CALLBACK]] : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2
+// CHECK: bb1([[CALLBACK_ADDR:%.*]] : @trivial $Builtin.RawPointer):
+// CHECK: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]]
+// CHECK: [[METATYPE:%.*]] = metatype $@thick T.Type
+// CHECK: [[TEMPORARY:%.*]] = address_to_pointer [[TEMPORARY_ADDR]] : $*Int to $Builtin.RawPointer
+// CHECK: apply [[CALLBACK]]<T>
+
+public struct Val {
+ public var x: Int = 0
+}
+
+public protocol Proto {
+ var val: Val { get nonmutating set}
+}
+
+public func test(_ p: Proto) {
+ p.val.x += 1
+}
+
+// CHECK-LABEL: sil @$S9protocols4testyyAA5Proto_pF : $@convention(thin) (@in_guaranteed Proto) -> ()
+// CHECK: [[OPEN:%.*]] = open_existential_addr immutable_access
+// CHECK: [[MAT:%.*]] = witness_method $@opened("{{.*}}") Proto, #Proto.val!materializeForSet
+// CHECK: [[BUF:%.*]] = apply [[MAT]]
+// CHECK: [[WB:%.*]] = pointer_to_thin_function
+// This use looks like it is mutating but really is not. We use to assert in the SIL verifier.
+// CHECK: apply [[WB]]{{.*}}({{.*}}[[OPEN]]
+// CHECK: return
+
+// CHECK-LABEL: sil_witness_table hidden ClassWithGetter: PropertyWithGetter module protocols {
+// CHECK-NEXT: method #PropertyWithGetter.a!getter.1: {{.*}} : @$S9protocols15ClassWithGetterCAA08PropertycD0A2aDP1aSivgTW
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil_witness_table hidden ClassWithGetterSetter: PropertyWithGetterSetter module protocols {
+// CHECK-NEXT: method #PropertyWithGetterSetter.b!getter.1: {{.*}} : @$S9protocols21ClassWithGetterSetterCAA08PropertycdE0A2aDP1bSivgTW
+// CHECK-NEXT: method #PropertyWithGetterSetter.b!setter.1: {{.*}} : @$S9protocols21ClassWithGetterSetterCAA08PropertycdE0A2aDP1bSivsTW
+// CHECK-NEXT: method #PropertyWithGetterSetter.b!materializeForSet.1: {{.*}} : @$S9protocols21ClassWithGetterSetterCAA08PropertycdE0A2aDP1bSivmTW
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil_witness_table hidden ClassWithGetterSetter: PropertyWithGetter module protocols {
+// CHECK-NEXT: method #PropertyWithGetter.a!getter.1: {{.*}} : @$S9protocols21ClassWithGetterSetterCAA08PropertycD0A2aDP1aSivgTW
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil_witness_table hidden StructWithStoredProperty: PropertyWithGetter module protocols {
+// CHECK-NEXT: method #PropertyWithGetter.a!getter.1: {{.*}} : @$S9protocols24StructWithStoredPropertyVAA0eC6GetterA2aDP1aSivgTW
+// CHECK-NEXT: }
+
+// CHECK-LABEL: sil_witness_table hidden StructWithStoredClassProperty: PropertyWithGetter module protocols {
+// CHECK-NEXT: method #PropertyWithGetter.a!getter.1: {{.*}} : @$S9protocols29StructWithStoredClassPropertyVAA0fC6GetterA2aDP1aSivgTW
+// CHECK-NEXT: }
+
+//
+// rdar://problem/37031037
+//
+
+protocol MethodWithDefaultArgGenerator {}
+extension MethodWithDefaultArgGenerator {
+ mutating func foo(_ x: Int = 0) {}
+}
+func invokeMethodWithDefaultArg(x: inout MethodWithDefaultArgGenerator) {
+ x.foo()
+}
diff --git a/test/SILGen/plus_zero_reabstract-tuple.swift b/test/SILGen/plus_zero_reabstract-tuple.swift
new file mode 100644
index 0000000..8553bba
--- /dev/null
+++ b/test/SILGen/plus_zero_reabstract-tuple.swift
@@ -0,0 +1,63 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -emit-silgen -verify %s | %FileCheck %s
+
+// SR-3090:
+
+class Box<T> {
+ public let value: T
+
+ public init(_ value: T) {
+ self.value = value
+ }
+}
+
+// CHECK: sil @$S4main7testBoxyyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK: // function_ref closure #1 in testBox()
+// CHECK: [[CLOSURE:%.*]] = function_ref @$S4main7testBoxyyFyycfU_ : $@convention(thin) () -> ()
+// CHECK: [[THICK:%.*]] = thin_to_thick_function [[CLOSURE]] : $@convention(thin) () -> () to $@callee_guaranteed () -> ()
+// CHECK: [[TUPLEA:%.*]] = tuple (%{{.*}} : $Int, [[THICK]] : $@callee_guaranteed () -> ())
+// CHECK: ([[ELTA_0:%.*]], [[ELTA_1:%.*]]) = destructure_tuple [[TUPLEA]] : $(Int, @callee_guaranteed () -> ())
+// CHECK: [[THUNK1:%.*]] = function_ref @$SIeg_ytytIegnr_TR : $@convention(thin) (@in_guaranteed (), @guaranteed @callee_guaranteed () -> ()) -> @out ()
+// CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[THUNK1]]([[ELTA_1]]) : $@convention(thin) (@in_guaranteed (), @guaranteed @callee_guaranteed () -> ()) -> @out ()
+// CHECK: [[TUPLEB:%.*]] = tuple ([[ELTA_0]] : $Int, [[PA]] : $@callee_guaranteed (@in_guaranteed ()) -> @out ())
+// CHECK: [[BORROWB:%.*]] = begin_borrow [[TUPLEB]] : $(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ())
+// CHECK: [[TUPLEB_0:%.*]] = tuple_extract [[BORROWB]] : $(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ()), 0
+// CHECK: [[TUPLEB_1:%.*]] = tuple_extract [[BORROWB]] : $(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ()), 1
+// CHECK: [[COPYB_1:%.*]] = copy_value [[TUPLEB_1]] : $@callee_guaranteed (@in_guaranteed ()) -> @out ()
+// CHECK: // function_ref Box.__allocating_init(_:)
+// CHECK: [[INIT_F:%.*]] = function_ref @$S4main3BoxCyACyxGxcfC : $@convention(method) <τ_0_0> (@in τ_0_0, @thick Box<τ_0_0>.Type) -> @owned Box<τ_0_0>
+// CHECK: [[CALL:%.*]] = apply [[INIT_F]]<(Int, () -> ())>(%{{.*}}, %{{.*}}) : $@convention(method) <τ_0_0> (@in τ_0_0, @thick Box<τ_0_0>.Type) -> @owned Box<τ_0_0>
+// CHECK: end_borrow [[BORROWB]] from %{{.*}} : $(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ()), $(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ())
+// CHECK: destroy_value [[TUPLEB]] : $(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ())
+// CHECK: [[BORROW_CALL:%.*]] = begin_borrow [[CALL]] : $Box<(Int, () -> ())>
+// CHECK: [[REF:%.*]] = ref_element_addr [[BORROW_CALL]] : $Box<(Int, () -> ())>, #Box.value
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[REF]] : $*(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ())
+// CHECK: [[TUPLEC:%.*]] = load [copy] [[READ]] : $*(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ())
+// CHECK: [[BORROW_TUPLEC:%.*]] = begin_borrow [[TUPLEC]] : $(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ())
+// CHECK: [[TUPLEC_0:%.*]] = tuple_extract [[BORROW_TUPLEC]] : $(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ()), 0
+// CHECK: [[TUPLEC_1:%.*]] = tuple_extract [[BORROW_TUPLEC]] : $(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ()), 1
+// CHECK: [[COPYC_1:%.*]] = copy_value [[TUPLEC_1]] : $@callee_guaranteed (@in_guaranteed ()) -> @out ()
+// CHECK: [[THUNK2:%.*]] = function_ref @$SytytIegnr_Ieg_TR : $@convention(thin) (@guaranteed @callee_guaranteed (@in_guaranteed ()) -> @out ()) -> ()
+// CHECK: [[PA2:%.*]] = partial_apply [callee_guaranteed] [[THUNK2]]([[COPYC_1]]) : $@convention(thin) (@guaranteed @callee_guaranteed (@in_guaranteed ()) -> @out ()) -> ()
+// CHECK: end_access [[READ]] : $*(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ())
+// CHECK: destroy_value [[PA2]] : $@callee_guaranteed () -> ()
+// CHECK: end_borrow [[BORROW_TUPLEC]] from %{{.*}} : $(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ()), $(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ())
+// CHECK: destroy_value [[TUPLEC]] : $(Int, @callee_guaranteed (@in_guaranteed ()) -> @out ())
+// CHECK: end_borrow [[BORROW_CALL]] from %{{.*}} : $Box<(Int, () -> ())>, $Box<(Int, () -> ())>
+// CHECK-LABEL: } // end sil function '$S4main7testBoxyyF'
+public func testBox() {
+ let box = Box((22, { () in }))
+ let foo = box.value.0
+ print(foo)
+}
+
+
+// Another crash -- re-abstracting function type inside optional in tuple
+// in-place
+
+func g<T>() -> (Int, T)? { }
+
+func f<T>(t: T) {
+ let _: (Int, ((T) -> (), T))? = g()
+}
diff --git a/test/SILGen/plus_zero_reabstract.swift b/test/SILGen/plus_zero_reabstract.swift
new file mode 100644
index 0000000..03389c7
--- /dev/null
+++ b/test/SILGen/plus_zero_reabstract.swift
@@ -0,0 +1,82 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+func takeFn<T>(_ f : (T) -> T?) {}
+func liftOptional(_ x : Int) -> Int? { return x }
+
+func test0() {
+ takeFn(liftOptional)
+}
+// CHECK: sil hidden @$S10reabstract5test0yyF : $@convention(thin) () -> () {
+// Emit a generalized reference to liftOptional.
+// TODO: just emit a globalized thunk
+// CHECK: reabstract.liftOptional
+// CHECK-NEXT: [[T1:%.*]] = function_ref @$S10reabstract12liftOptional{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: [[T2:%.*]] = thin_to_thick_function [[T1]]
+// CHECK-NEXT: [[CVT:%.*]] = convert_escape_to_noescape [[T2]]
+// CHECK-NEXT: reabstraction thunk
+// CHECK-NEXT: [[T3:%.*]] = function_ref [[THUNK:@.*]] :
+// CHECK-NEXT: [[T4:%.*]] = partial_apply [callee_guaranteed] [[T3]]([[CVT]])
+// CHECK-NEXT: [[CVT:%.*]] = convert_escape_to_noescape [[T4]]
+// CHECK: [[T0:%.*]] = function_ref @$S10reabstract6takeFn{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: apply [[T0]]<Int>([[CVT]])
+// CHECK-NEXT: destroy_value [[T2]]
+// CHECK-NEXT: destroy_value [[T4]]
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: return
+// CHECK-NEXT: } // end sil function '$S10reabstract5test0yyF'
+
+// CHECK: sil shared [transparent] [serializable] [reabstraction_thunk] [[THUNK]] : $@convention(thin) (@in_guaranteed Int, @noescape @callee_guaranteed (Int) -> Optional<Int>) -> @out Optional<Int> {
+// CHECK: [[T0:%.*]] = load [trivial] %1 : $*Int
+// CHECK-NEXT: [[T1:%.*]] = apply %2([[T0]])
+// CHECK-NEXT: store [[T1]] to [trivial] %0
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: return
+
+// CHECK-LABEL: sil hidden @$S10reabstract10testThrowsyyypF
+// CHECK: function_ref @$SytytIegnr_Ieg_TR
+// CHECK: function_ref @$Sytyts5Error_pIegnrzo_sAA_pIegzo_TR
+func testThrows(_ x: Any) {
+ _ = x as? () -> ()
+ _ = x as? () throws -> ()
+}
+
+// Make sure that we preserve inout-ness when lowering types with maximum
+// abstraction level -- <rdar://problem/21329377>
+class C {}
+
+struct Box<T> {
+ let t: T
+}
+
+func notFun(_ c: inout C, i: Int) {}
+
+func testInoutOpaque(_ c: C, i: Int) {
+ var c = c
+ let box = Box(t: notFun)
+ box.t(&c, i)
+}
+
+// CHECK-LABEL: sil hidden @$S10reabstract15testInoutOpaque_1iyAA1CC_SitF
+// CHECK: function_ref @$S10reabstract6notFun_1iyAA1CCz_SitF
+// CHECK: thin_to_thick_function {{%[0-9]+}}
+// CHECK: function_ref @$S10reabstract1CCSiIegly_ACSiytIeglnr_TR
+// CHECK: partial_apply
+// CHECK: store
+// CHECK: load
+// CHECK: function_ref @$S10reabstract1CCSiytIeglnr_ACSiIegly_TR
+// CHECK: partial_apply
+// CHECK: apply
+// CHECK: } // end sil function '$S10reabstract15testInoutOpaque_1iyAA1CC_SitF'
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S10reabstract1CCSiIegly_ACSiytIeglnr_TR : $@convention(thin) (@inout C, @in_guaranteed Int, @guaranteed @callee_guaranteed (@inout C, Int) -> ()) -> @out () {
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$S10reabstract1CCSiytIeglnr_ACSiIegly_TR : $@convention(thin) (@inout C, Int, @guaranteed @callee_guaranteed (@inout C, @in_guaranteed Int) -> @out ()) -> () {
+
+func closureTakingOptional(_ fn: (Int?) -> ()) {}
+closureTakingOptional({ (_: Any) -> () in })
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SypIgn_SiSgIegy_TR : $@convention(thin) (Optional<Int>, @noescape @callee_guaranteed (@in_guaranteed Any) -> ()) -> ()
+// CHECK: [[ANYADDR:%.*]] = alloc_stack $Any
+// CHECK: [[OPTADDR:%.*]] = init_existential_addr [[ANYADDR]] : $*Any, $Optional<Int>
+// CHECK: store %0 to [trivial] [[OPTADDR]] : $*Optional<Int>
+// CHECK: apply %1([[ANYADDR]]) : $@noescape @callee_guaranteed (@in_guaranteed Any) -> ()
diff --git a/test/SILGen/plus_zero_reabstract_lvalue.swift b/test/SILGen/plus_zero_reabstract_lvalue.swift
new file mode 100644
index 0000000..66a9907
--- /dev/null
+++ b/test/SILGen/plus_zero_reabstract_lvalue.swift
@@ -0,0 +1,48 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+struct MyMetatypeIsThin {}
+
+// CHECK-LABEL: sil hidden @$S17reabstract_lvalue19consumeGenericInOut{{[_0-9a-zA-Z]*}}F : $@convention(thin) <T> (@inout T) -> ()
+func consumeGenericInOut<T>(_ x: inout T) {}
+
+// CHECK-LABEL: sil hidden @$S17reabstract_lvalue9transformySdSiF : $@convention(thin) (Int) -> Double
+func transform(_ i: Int) -> Double {
+ return Double(i)
+}
+
+// CHECK-LABEL: sil hidden @$S17reabstract_lvalue0A13FunctionInOutyyF : $@convention(thin) () -> ()
+func reabstractFunctionInOut() {
+ // CHECK: [[BOX:%.*]] = alloc_box ${ var @callee_guaranteed (Int) -> Double }
+ // CHECK: [[PB:%.*]] = project_box [[BOX]]
+ // CHECK: [[ARG:%.*]] = function_ref @$S17reabstract_lvalue9transformySdSiF
+ // CHECK: [[THICK_ARG:%.*]] = thin_to_thick_function [[ARG]]
+ // CHECK: store [[THICK_ARG:%.*]] to [init] [[PB]]
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PB]] : $*@callee_guaranteed (Int) -> Double
+ // CHECK: [[ABSTRACTED_BOX:%.*]] = alloc_stack $@callee_guaranteed (@in_guaranteed Int) -> @out Double
+ // CHECK: [[THICK_ARG:%.*]] = load [copy] [[WRITE]]
+ // CHECK: [[THUNK1:%.*]] = function_ref @$SSiSdIegyd_SiSdIegnr_TR
+ // CHECK: [[ABSTRACTED_ARG:%.*]] = partial_apply [callee_guaranteed] [[THUNK1]]([[THICK_ARG]])
+ // CHECK: store [[ABSTRACTED_ARG]] to [init] [[ABSTRACTED_BOX]]
+ // CHECK: [[FUNC:%.*]] = function_ref @$S17reabstract_lvalue19consumeGenericInOut{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[FUNC]]<(Int) -> Double>([[ABSTRACTED_BOX]])
+ // CHECK: [[NEW_ABSTRACTED_ARG:%.*]] = load [take] [[ABSTRACTED_BOX]]
+ // CHECK: [[THUNK2:%.*]] = function_ref @$SSiSdIegnr_SiSdIegyd_TR
+ // CHECK: [[NEW_ARG:%.*]] = partial_apply [callee_guaranteed] [[THUNK2]]([[NEW_ABSTRACTED_ARG]])
+ var minimallyAbstracted = transform
+ consumeGenericInOut(&minimallyAbstracted)
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SSiSdIegyd_SiSdIegnr_TR : $@convention(thin) (@in_guaranteed Int, @guaranteed @callee_guaranteed (Int) -> Double) -> @out Double
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SSiSdIegnr_SiSdIegyd_TR : $@convention(thin) (Int, @guaranteed @callee_guaranteed (@in_guaranteed Int) -> @out Double) -> Double
+
+// CHECK-LABEL: sil hidden @$S17reabstract_lvalue0A13MetatypeInOutyyF : $@convention(thin) () -> ()
+func reabstractMetatypeInOut() {
+ var thinMetatype = MyMetatypeIsThin.self
+ // CHECK: [[BOX:%.*]] = alloc_stack $@thick MyMetatypeIsThin.Type
+ // CHECK: [[THICK:%.*]] = metatype $@thick MyMetatypeIsThin.Type
+ // CHECK: store [[THICK]] to [trivial] [[BOX]]
+ // CHECK: [[FUNC:%.*]] = function_ref @$S17reabstract_lvalue19consumeGenericInOut{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[FUNC]]<MyMetatypeIsThin.Type>([[BOX]])
+ consumeGenericInOut(&thinMetatype)
+}
diff --git a/test/SILGen/plus_zero_result_abstraction.swift b/test/SILGen/plus_zero_result_abstraction.swift
new file mode 100644
index 0000000..af83741
--- /dev/null
+++ b/test/SILGen/plus_zero_result_abstraction.swift
@@ -0,0 +1,60 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+struct S {}
+struct R {}
+
+protocol ReturnsMetatype {
+ associatedtype Assoc
+ mutating
+ func getAssocMetatype() -> Assoc.Type
+}
+
+struct ConformsToReturnsMetatype : ReturnsMetatype {
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S18result_abstraction25ConformsToReturnsMetatypeVAA0eF0A2aDP08getAssocF0{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: ReturnsMetatype) (@inout ConformsToReturnsMetatype) -> @thick S.Type
+ // CHECK: function_ref @$S18result_abstraction25ConformsToReturnsMetatypeV08getAssocF0{{[_0-9a-zA-Z]*}}F : $@convention(method) (@inout ConformsToReturnsMetatype) -> @thin S.Type
+ mutating
+ func getAssocMetatype() -> S.Type {
+ return S.self
+ }
+}
+
+protocol ReturnsFunction {
+ associatedtype Arg
+ associatedtype Result
+ func getFunc() -> (Arg) -> Result
+}
+
+struct ConformsToReturnsFunction : ReturnsFunction {
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S18result_abstraction25ConformsToReturnsFunctionVAA0eF0A2aDP7getFunc{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: ReturnsFunction) (@in_guaranteed ConformsToReturnsFunction) -> @owned @callee_guaranteed (@in_guaranteed S) -> @out R
+ // CHECK: function_ref @$S18result_abstraction1SVAA1RVIegyd_AcEIegnr_TR : $@convention(thin) (@in_guaranteed S, @guaranteed @callee_guaranteed (S) -> R) -> @out R
+ func getFunc() -> (S) -> R {
+ return {s in R()}
+ }
+}
+
+protocol ReturnsAssoc {
+ associatedtype Assoc
+ mutating
+ func getAssoc() -> Assoc
+}
+
+struct ConformsToReturnsAssocWithMetatype : ReturnsAssoc {
+ typealias Assoc = S.Type
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S18result_abstraction34ConformsToReturnsAssocWithMetatypeVAA0eF0A2aDP03getF0{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: ReturnsAssoc) (@inout ConformsToReturnsAssocWithMetatype) -> @out @thick S.Type
+ // CHECK: function_ref @$S18result_abstraction34ConformsToReturnsAssocWithMetatypeV03getF0{{[_0-9a-zA-Z]*}}F : $@convention(method) (@inout ConformsToReturnsAssocWithMetatype) -> @thin S.Type
+ mutating
+ func getAssoc() -> S.Type {
+ return S.self
+ }
+}
+
+struct ConformsToReturnsAssocWithFunction : ReturnsAssoc {
+ typealias Assoc = (S) -> R
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S18result_abstraction34ConformsToReturnsAssocWithFunctionVAA0eF0A2aDP03getF0{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: ReturnsAssoc) (@inout ConformsToReturnsAssocWithFunction) -> @out @callee_guaranteed (@in_guaranteed S) -> @out R
+ // CHECK: function_ref @$S18result_abstraction34ConformsToReturnsAssocWithFunctionV03getF0{{[_0-9a-zA-Z]*}}F : $@convention(method) (@inout ConformsToReturnsAssocWithFunction) -> @owned @callee_guaranteed (S) -> R
+ mutating
+ func getAssoc() -> (S) -> R {
+ return {s in R()}
+ }
+}
diff --git a/test/SILGen/plus_zero_retaining_globals.swift b/test/SILGen/plus_zero_retaining_globals.swift
new file mode 100644
index 0000000..481a643
--- /dev/null
+++ b/test/SILGen/plus_zero_retaining_globals.swift
@@ -0,0 +1,75 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -import-objc-header %S/Inputs/globals.h -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+// REQUIRES: objc_interop
+
+
+// This test makes sure loading from globals properly retains/releases loads from globals.
+// NSString was the only real problem, as the compiler treats NSString globals specially.
+// The rest of these are just hedges against future changes.
+
+// From header:
+// globalString: __strong NSString*
+// globalObject: __strong NSObject*
+// globalID: __strong id
+// globalArray: __strong NSArray*
+// globalConstArray: __strong NSArray *const
+
+func main() {
+ Globals.sharedInstance() // Initialize globals (dispatch_once)
+
+ // CHECK: global_addr @globalConstArray : $*Optional<NSArray>
+ // CHECK: global_addr @globalArray : $*Optional<NSArray>
+ // CHECK: global_addr @globalId : $*Optional<AnyObject>
+ // CHECK: global_addr @globalObject : $*Optional<NSObject>
+ // CHECK: global_addr @globalString : $*NSString
+
+
+
+ // CHECK: [[globalString:%.*]] = load [copy] {{%.*}} : $*NSString
+ // CHECK: [[bridgeStringFunc:%.*]] = function_ref @{{.*}} : $@convention(method) (@guaranteed Optional<NSString>, @thin String.Type) -> @owned String
+ // CHECK: [[wrappedString:%.*]] = enum $Optional<NSString>, #Optional.some!enumelt.1, [[globalString]] : $NSString
+ // CHECK: [[stringMetaType:%.*]] = metatype $@thin String.Type
+ // CHECK: [[bridgedString:%.*]] = apply [[bridgeStringFunc]]([[wrappedString]], [[stringMetaType]]) : $@convention(method) (@guaranteed Optional<NSString>, @thin String.Type) -> @owned String
+ let string = globalString // Problematic case, wasn't being retained
+
+ // CHECK: [[load_1:%.*]] = load [copy] {{%.*}} : $*Optional<NSObject>
+ let object = globalObject
+
+ // CHECK: [[load_2:%.*]] = load [copy] {{%.*}} : $*Optional<AnyObject>
+ let id = globalId
+
+ // CHECK: [[load_3:%.*]] = load [copy] {{%.*}} : $*Optional<NSArray>
+ let arr = globalArray
+
+ // CHECK: [[load_4:%.*]] = load [copy] {{%.*}} : $*Optional<NSArray>
+ let constArr = globalConstArray
+
+ // Make sure there's no more copies
+ // CHECK-NOT: load [copy]
+
+ print(string as Any)
+ print(object as Any)
+ print(id as Any)
+ print(arr as Any)
+ print(constArr as Any)
+
+ // CHECK: [[PRINT_FUN:%.*]] = function_ref @$Ss5print_9separator10terminatoryypd_S2StF : $@convention(thin) (@guaranteed Array<Any>, @guaranteed String, @guaranteed String) -> ()
+ // CHECK: apply [[PRINT_FUN]]({{.*}})
+ // CHECK: destroy_value [[load_4]]
+ // CHECK: destroy_value [[load_3]]
+ // CHECK: destroy_value [[load_2]]
+ // CHECK: destroy_value [[load_1]]
+ // CHECK: destroy_value [[bridgedString]]
+
+ // Make sure there's no more destroys
+ // CHECK-NOT: destroy_value
+ // CHECK: } // end sil function '$S17retaining_globals4mainyyF'
+}
+
+
+main()
+main() // Used to crash here, due to use-after-free.
+main()
+main()
+main()
+main()
diff --git a/test/SILGen/plus_zero_rethrows.swift b/test/SILGen/plus_zero_rethrows.swift
new file mode 100644
index 0000000..0b5dfe7
--- /dev/null
+++ b/test/SILGen/plus_zero_rethrows.swift
@@ -0,0 +1,90 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -emit-sil -verify %s | %FileCheck %s
+
+@discardableResult
+func rethrower(_ fn: () throws -> Int) rethrows -> Int {
+ return try fn()
+}
+func thrower() throws -> Int { return 0 }
+func nonthrower() -> Int { return 0 }
+
+// CHECK-LABEL: sil hidden @$S8rethrows5test0yyKF : $@convention(thin) () -> @error Error {
+// CHECK: [[THROWER:%.*]] = function_ref @$S8rethrows7throwerSiyKF : $@convention(thin) () -> (Int, @error Error)
+// CHECK: [[T0:%.*]] = thin_to_thick_function [[THROWER]]
+// CHECK: [[CVT:%.*]] = convert_escape_to_noescape [[T0]]
+// CHECK: [[RETHROWER:%.*]] = function_ref @$S8rethrows9rethroweryS2iyKXEKF : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error)
+// CHECK: try_apply [[RETHROWER]]([[CVT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error), normal [[NORMAL:bb1]], error [[ERROR:bb2]]
+// CHECK: [[NORMAL]]([[RESULT_T0:%.*]] : $Int):
+// FIXME - SR-6979: We should be able to eliminate this strong_release.
+// CHECK-NEXT: strong_release [[T0]]
+// CHECK-NEXT: [[T1:%.*]] = tuple ()
+// CHECK-NEXT: return [[T1]]
+// CHECK: [[ERROR]]([[RESULT_T0:%.*]] : $Error):
+// FIXME - SR-6979: We should be able to eliminate this strong_release.
+// CHECK-NEXT: strong_release [[T0]]
+// CHECK-NEXT: throw [[RESULT_T0]]
+func test0() throws {
+ try rethrower(thrower)
+}
+
+// CHECK-LABEL: sil hidden @$S8rethrows5test1yyKF : $@convention(thin) () -> @error Error {
+// CHECK: [[CLOSURE:%.*]] = function_ref @$S8rethrows5test1yyKFSiyKXEfU_ : $@convention(thin) () -> (Int, @error Error)
+// CHECK: [[CVT:%.*]] = convert_function [[CLOSURE]]
+// CHECK: [[T0:%.*]] = thin_to_thick_function [[CVT]]
+// CHECK: [[RETHROWER:%.*]] = function_ref @$S8rethrows9rethroweryS2iyKXEKF : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error)
+// CHECK: try_apply [[RETHROWER]]([[T0]]) : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error), normal [[NORMAL:bb1]], error [[ERROR:bb2]]
+// CHECK: [[NORMAL]]({{%.*}} : $Int):
+// CHECK-NEXT: [[T1:%.*]] = tuple ()
+// CHECK-NEXT: return [[T1]]
+// CHECK: [[ERROR]]([[ERROR:%.*]] : $Error):
+// CHECK-NEXT: throw [[ERROR]]
+// Closure.
+// CHECK-LABEL: sil private @$S8rethrows5test1yyKFSiyKXEfU_ : $@convention(thin) () -> (Int, @error Error) {
+// CHECK: [[THROWER:%.*]] = function_ref @$S8rethrows7throwerSiyKF : $@convention(thin) () -> (Int, @error Error)
+// CHECK: [[T0:%.*]] = thin_to_thick_function [[THROWER]]
+// CHECK: [[CVT:%.*]] = convert_escape_to_noescape [[T0]]
+// CHECK: [[RETHROWER:%.*]] = function_ref @$S8rethrows9rethroweryS2iyKXEKF : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error)
+// CHECK: try_apply [[RETHROWER]]([[CVT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error), normal [[NORMAL:bb1]], error [[ERROR:bb2]]
+// CHECK: [[NORMAL]]([[RESULT:%.*]] : $Int):
+// CHECK-NEXT: strong_release [[T0]]
+// CHECK-NEXT: return [[RESULT]]
+// CHECK: [[ERROR]]([[ERROR:%.*]] : $Error):
+// CHECK-NEXT: strong_release [[T0]]
+// CHECK-NEXT: throw [[ERROR]]
+func test1() throws {
+ try rethrower { try rethrower(thrower) }
+}
+
+// CHECK-LABEL: sil hidden @$S8rethrows5test2yyF : $@convention(thin) () -> () {
+// CHECK: [[NONTHROWER:%.*]] = function_ref @$S8rethrows10nonthrowerSiyF : $@convention(thin) () -> Int
+// CHECK: [[T0:%.*]] = thin_to_thick_function [[NONTHROWER]]
+// CHECK: [[T1:%.*]] = convert_function [[T0]] : $@callee_guaranteed () -> Int to $@callee_guaranteed () -> (Int, @error Error)
+// CHECK: [[T2:%.*]] = convert_escape_to_noescape [[T1]]
+// CHECK: [[RETHROWER:%.*]] = function_ref @$S8rethrows9rethroweryS2iyKXEKF : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error)
+// CHECK: try_apply [[RETHROWER]]([[T2]]) : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error), normal [[NORMAL:bb1]], error [[ERROR:bb2]]
+// CHECK: [[NORMAL]]([[T0:%.*]] : $Int):
+// CHECK-NEXT: strong_release [[T1]]
+// CHECK-NEXT: [[RESULT:%.*]] = tuple ()
+// CHECK-NEXT: return [[RESULT]]
+// CHECK: [[ERROR]]([[T0:%.*]] : $Error):
+// CHECK-NEXT: unreachable
+func test2() {
+ rethrower(nonthrower)
+}
+
+// CHECK-LABEL: sil hidden @$S8rethrows5test3yyF : $@convention(thin) () -> () {
+// CHECK: [[CLOSURE:%.*]] = function_ref @$S8rethrows5test3yyFSiyXEfU_ : $@convention(thin) () -> Int
+// CHECK: [[CVT:%.*]] = convert_function [[CLOSURE]] : $@convention(thin) () -> Int to $@convention(thin) @noescape () -> Int
+// CHECK: [[T0:%.*]] = thin_to_thick_function [[CVT]]
+// CHECK: [[T1:%.*]] = convert_function [[T0]] : $@noescape @callee_guaranteed () -> Int to $@noescape @callee_guaranteed () -> (Int, @error Error)
+// CHECK: [[RETHROWER:%.*]] = function_ref @$S8rethrows9rethroweryS2iyKXEKF : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error)
+// CHECK: try_apply [[RETHROWER]]([[T1]]) : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error), normal [[NORMAL:bb1]], error [[ERROR:bb2]]
+// CHECK: [[NORMAL]]({{%.*}} : $Int):
+// CHECK-NEXT: [[RESULT:%.*]] = tuple ()
+// CHECK-NEXT: return [[RESULT]]
+// CHECK: [[ERROR]]([[ERROR:%.*]] : $Error):
+// CHECK-NEXT: unreachable
+// CHECK-LABEL: // end sil function '$S8rethrows5test3yyF'
+func test3() {
+ rethrower { rethrower(nonthrower) }
+}
diff --git a/test/SILGen/plus_zero_scalar_to_tuple_args.swift b/test/SILGen/plus_zero_scalar_to_tuple_args.swift
new file mode 100644
index 0000000..b6bfb8a
--- /dev/null
+++ b/test/SILGen/plus_zero_scalar_to_tuple_args.swift
@@ -0,0 +1,82 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+func inoutWithDefaults(_ x: inout Int, y: Int = 0, z: Int = 0) {}
+func inoutWithCallerSideDefaults(_ x: inout Int, y: Int = #line) {}
+
+func scalarWithDefaults(_ x: Int, y: Int = 0, z: Int = 0) {}
+func scalarWithCallerSideDefaults(_ x: Int, y: Int = #line) {}
+
+func tupleWithDefaults(x x: (Int, Int), y: Int = 0, z: Int = 0) {}
+
+func variadicFirst(_ x: Int...) {}
+func variadicSecond(_ x: Int, _ y: Int...) {}
+
+var x = 0
+// CHECK: [[X_ADDR:%.*]] = global_addr @$S20scalar_to_tuple_args1xSivp : $*Int
+// CHECK: [[DEFAULT_Y:%.*]] = apply {{.*}} : $@convention(thin) () -> Int
+// CHECK: [[DEFAULT_Z:%.*]] = apply {{.*}} : $@convention(thin) () -> Int
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[X_ADDR]] : $*Int
+// CHECK: [[INOUT_WITH_DEFAULTS:%.*]] = function_ref @$S20scalar_to_tuple_args17inoutWithDefaults_1y1zySiz_S2itF
+// CHECK: apply [[INOUT_WITH_DEFAULTS]]([[WRITE]], [[DEFAULT_Y]], [[DEFAULT_Z]])
+inoutWithDefaults(&x)
+
+// CHECK: [[LINE_VAL:%.*]] = integer_literal
+// CHECK: [[LINE:%.*]] = apply {{.*}}([[LINE_VAL]]
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[X_ADDR]] : $*Int
+// CHECK: [[INOUT_WITH_CALLER_DEFAULTS:%.*]] = function_ref @$S20scalar_to_tuple_args27inoutWithCallerSideDefaults_1yySiz_SitF
+// CHECK: apply [[INOUT_WITH_CALLER_DEFAULTS]]([[WRITE]], [[LINE]])
+inoutWithCallerSideDefaults(&x)
+
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[X_ADDR]] : $*Int
+// CHECK: [[X:%.*]] = load [trivial] [[READ]]
+// CHECK: [[DEFAULT_Y:%.*]] = apply {{.*}} : $@convention(thin) () -> Int
+// CHECK: [[DEFAULT_Z:%.*]] = apply {{.*}} : $@convention(thin) () -> Int
+// CHECK: [[SCALAR_WITH_DEFAULTS:%.*]] = function_ref @$S20scalar_to_tuple_args0A12WithDefaults_1y1zySi_S2itF
+// CHECK: apply [[SCALAR_WITH_DEFAULTS]]([[X]], [[DEFAULT_Y]], [[DEFAULT_Z]])
+scalarWithDefaults(x)
+
+// CHECK: [[X:%.*]] = load [trivial] [[X_ADDR]]
+// CHECK: [[LINE_VAL:%.*]] = integer_literal
+// CHECK: [[LINE:%.*]] = apply {{.*}}([[LINE_VAL]]
+// CHECK: [[SCALAR_WITH_CALLER_DEFAULTS:%.*]] = function_ref @$S20scalar_to_tuple_args0A22WithCallerSideDefaults_1yySi_SitF
+// CHECK: apply [[SCALAR_WITH_CALLER_DEFAULTS]]([[X]], [[LINE]])
+scalarWithCallerSideDefaults(x)
+
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[X_ADDR]] : $*Int
+// CHECK: [[X1:%.*]] = load [trivial] [[READ]]
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[X_ADDR]] : $*Int
+// CHECK: [[X2:%.*]] = load [trivial] [[READ]]
+// CHECK: [[DEFAULT_Y:%.*]] = apply {{.*}} : $@convention(thin) () -> Int
+// CHECK: [[DEFAULT_Z:%.*]] = apply {{.*}} : $@convention(thin) () -> Int
+// CHECK: [[TUPLE_WITH_DEFAULTS:%.*]] = function_ref @$S20scalar_to_tuple_args0C12WithDefaults1x1y1zySi_Sit_S2itF
+// CHECK: apply [[TUPLE_WITH_DEFAULTS]]([[X1]], [[X2]], [[DEFAULT_Y]], [[DEFAULT_Z]])
+tupleWithDefaults(x: (x,x))
+
+// CHECK: [[ALLOC_ARRAY:%.*]] = apply {{.*}} -> (@owned Array<τ_0_0>, Builtin.RawPointer)
+// CHECK: [[BORROWED_ALLOC_ARRAY:%.*]] = begin_borrow [[ALLOC_ARRAY]]
+// CHECK: [[BORROWED_ARRAY:%.*]] = tuple_extract [[BORROWED_ALLOC_ARRAY]] {{.*}}, 0
+// CHECK: [[ARRAY:%.*]] = copy_value [[BORROWED_ARRAY]]
+// CHECK: [[MEMORY:%.*]] = tuple_extract [[BORROWED_ALLOC_ARRAY]] {{.*}}, 1
+// CHECK: end_borrow [[BORROWED_ALLOC_ARRAY]] from [[ALLOC_ARRAY]]
+// CHECK: destroy_value [[ALLOC_ARRAY]]
+// CHECK: [[ADDR:%.*]] = pointer_to_address [[MEMORY]]
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[X_ADDR]] : $*Int
+// CHECK: [[X:%.*]] = load [trivial] [[READ]]
+// CHECK: store [[X]] to [trivial] [[ADDR]]
+// CHECK: [[BORROWED_ARRAY:%.*]] = begin_borrow [[ARRAY]]
+// CHECK: [[VARIADIC_FIRST:%.*]] = function_ref @$S20scalar_to_tuple_args13variadicFirstyySid_tF
+// CHECK: apply [[VARIADIC_FIRST]]([[BORROWED_ARRAY]])
+variadicFirst(x)
+
+// CHECK: [[ALLOC_ARRAY:%.*]] = apply {{.*}} -> (@owned Array<τ_0_0>, Builtin.RawPointer)
+// CHECK: [[BORROWED_ALLOC_ARRAY:%.*]] = begin_borrow [[ALLOC_ARRAY]]
+// CHECK: [[BORROWED_ARRAY:%.*]] = tuple_extract [[BORROWED_ALLOC_ARRAY]] {{.*}}, 0
+// CHECK: [[ARRAY:%.*]] = copy_value [[BORROWED_ARRAY]]
+// CHECK: end_borrow [[BORROWED_ALLOC_ARRAY]] from [[ALLOC_ARRAY]]
+// CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[X_ADDR]] : $*Int
+// CHECK: [[X:%.*]] = load [trivial] [[READ]]
+// CHECK: [[BORROWED_ARRAY:%.*]] = begin_borrow [[ARRAY]]
+// CHECK: [[VARIADIC_SECOND:%.*]] = function_ref @$S20scalar_to_tuple_args14variadicSecondyySi_SidtF
+// CHECK: apply [[VARIADIC_SECOND]]([[X]], [[BORROWED_ARRAY]])
+variadicSecond(x)
diff --git a/test/SILGen/plus_zero_shared.swift b/test/SILGen/plus_zero_shared.swift
new file mode 100644
index 0000000..46ec6da
--- /dev/null
+++ b/test/SILGen/plus_zero_shared.swift
@@ -0,0 +1,184 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen %s -disable-objc-attr-requires-foundation-module -enable-sil-ownership | %FileCheck %s
+
+// REQUIRES: owned_parameters
+
+class RefAggregate {}
+struct ValueAggregate { let x = RefAggregate() }
+
+
+// CHECK-LABEL: sil hidden @$S6shared0A10_arguments7trivial5value3refySih_AA14ValueAggregateVhAA03RefG0ChtF : $@convention(thin) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()
+func shared_arguments(trivial : __shared Int, value : __shared ValueAggregate, ref : __shared RefAggregate) {
+ // CHECK: bb0([[TRIVIAL_VAL:%[0-9]+]] : @trivial $Int, [[VALUE_VAL:%[0-9]+]] : @guaranteed $ValueAggregate, [[REF_VAL:%[0-9]+]] : @guaranteed $RefAggregate):
+ // CHECK: [[COPY_VALUE_VAL:%[0-9]+]] = copy_value [[VALUE_VAL]] : $ValueAggregate
+ // CHECK: [[COPY_REF_VAL:%[0-9]+]] = copy_value [[REF_VAL]] : $RefAggregate
+ // CHECK: [[OWNED_FUNC:%[0-9]+]] = function_ref @$S6shared15owned_arguments7trivial5value3refySi_AA14ValueAggregateVAA03RefH0CtF
+ // CHECK: {{%.*}} = apply [[OWNED_FUNC]]([[TRIVIAL_VAL]], [[COPY_VALUE_VAL]], [[COPY_REF_VAL]]) : $@convention(thin) (Int, @owned ValueAggregate, @owned RefAggregate) -> ()
+ // CHECK: } // end sil function '$S6shared0A10_arguments7trivial5value3refySih_AA14ValueAggregateVhAA03RefG0ChtF'
+ return owned_arguments(trivial: trivial, value: value, ref: ref)
+}
+
+// CHECK-LABEL: sil hidden @$S6shared15owned_arguments7trivial5value3refySi_AA14ValueAggregateVAA03RefH0CtF : $@convention(thin) (Int, @owned ValueAggregate, @owned RefAggregate) -> ()
+func owned_arguments(trivial : Int, value : ValueAggregate, ref : RefAggregate) {
+ // CHECK: bb0([[TRIVIAL_VAL:%[0-9]+]] : @trivial $Int, [[VALUE_VAL:%[0-9]+]] : @owned $ValueAggregate, [[REF_VAL:%[0-9]+]] : @owned $RefAggregate):
+ // CHECK: [[BORROW_VALUE_VAL:%[0-9]+]] = begin_borrow [[VALUE_VAL]] : $ValueAggregate
+ // CHECK: [[BORROW_REF_VAL:%[0-9]+]] = begin_borrow [[REF_VAL]] : $RefAggregate
+ // CHECK: [[SHARED_FUNC:%[0-9]+]] = function_ref @$S6shared0A10_arguments7trivial5value3refySih_AA14ValueAggregateVhAA03RefG0ChtF
+ // CHECK: {{%.*}} = apply [[SHARED_FUNC]]([[TRIVIAL_VAL]], [[BORROW_VALUE_VAL]], [[BORROW_REF_VAL]])
+ // CHECK: end_borrow [[BORROW_REF_VAL]] from [[REF_VAL]] : $RefAggregate, $RefAggregate
+ // CHECK: end_borrow [[BORROW_VALUE_VAL]] from [[VALUE_VAL]] : $ValueAggregate, $ValueAggregate
+ // CHECK: destroy_value [[REF_VAL]] : $RefAggregate
+ // CHECK: destroy_value [[VALUE_VAL]] : $ValueAggregate
+ // CHECK: } // end sil function '$S6shared15owned_arguments7trivial5value3refySi_AA14ValueAggregateVAA03RefH0CtF'
+ return shared_arguments(trivial: trivial, value: value, ref: ref)
+}
+
+// CHECK-LABEL: sil hidden @$S6shared0A17_argument_capture7trivial5value3refySih_AA14ValueAggregateVhAA03RefH0ChtF : $@convention(thin) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()
+func shared_argument_capture(trivial : __shared Int, value : __shared ValueAggregate, ref : __shared RefAggregate) {
+ // CHECK: bb0([[TRIVIAL_VAL:%[0-9]+]] : @trivial $Int, [[VALUE_VAL:%[0-9]+]] : @guaranteed $ValueAggregate, [[REF_VAL:%[0-9]+]] : @guaranteed $RefAggregate):
+ // CHECK: [[CLO_1:%[0-9]+]] = function_ref @$S6shared0A17_argument_capture7trivial5value3refySih_AA14ValueAggregateVhAA03RefH0ChtFyyXEfU_
+ // CHECK: {{%.*}} = apply [[CLO_1]]([[TRIVIAL_VAL]], [[VALUE_VAL]], [[REF_VAL]]) : $@convention(thin) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()
+ _ = {
+ return shared_arguments(trivial: trivial, value: value, ref: ref)
+ }()
+
+ // CHECK: [[CLO_2:%[0-9]+]] = function_ref @$S6shared0A17_argument_capture7trivial5value3refySih_AA14ValueAggregateVhAA03RefH0ChtFyyXEfU0_ : $@convention(thin) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()
+ // CHECK: {{%.*}} = apply [[CLO_2]]([[TRIVIAL_VAL]], [[VALUE_VAL]], [[REF_VAL]]) : $@convention(thin) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()
+ _ = {
+ return owned_arguments(trivial: trivial, value: value, ref: ref)
+ }()
+
+ // CHECK: } // end sil function '$S6shared0A17_argument_capture7trivial5value3refySih_AA14ValueAggregateVhAA03RefH0ChtF'
+
+ // ======== FIRST CLOSURE ==========
+
+ // CHECK-LABEL: sil private @$S6shared0A17_argument_capture7trivial5value3refySih_AA14ValueAggregateVhAA03RefH0ChtFyyXEfU_ : $@convention(thin) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()
+ // CHECK: bb0([[TRIVIAL_VAL:%[0-9]+]] : @trivial $Int, [[VALUE_VAL:%[0-9]+]] : @guaranteed $ValueAggregate, [[REF_VAL:%[0-9]+]] : @guaranteed $RefAggregate):
+ // CHECK: [[SHARED_CALL:%[0-9]+]] = function_ref @$S6shared0A10_arguments7trivial5value3refySih_AA14ValueAggregateVhAA03RefG0ChtF : $@convention(thin) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()
+ // CHECK: {{%.*}} = apply [[SHARED_CALL]]([[TRIVIAL_VAL]], [[VALUE_VAL]], [[REF_VAL]]) : $@convention(thin) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()
+ // CHECK: } // end sil function '$S6shared0A17_argument_capture7trivial5value3refySih_AA14ValueAggregateVhAA03RefH0ChtFyyXEfU_'
+
+ // ======== SECOND CLOSURE ==========
+
+ // CHECK-LABEL: sil private @$S6shared0A17_argument_capture7trivial5value3refySih_AA14ValueAggregateVhAA03RefH0ChtFyyXEfU0_ : $@convention(thin) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> () {
+ // CHECK: bb0([[TRIVIAL_VAL:%[0-9]+]] : @trivial $Int, [[VALUE_VAL:%[0-9]+]] : @guaranteed $ValueAggregate, [[REF_VAL:%[0-9]+]] : @guaranteed $RefAggregate):
+ // CHECK: [[COPY_BORROW_VALUE_VAL:%[0-9]+]] = copy_value [[VALUE_VAL]] : $ValueAggregate
+ // CHECK: [[COPY_BORROW_REF_VAL:%[0-9]+]] = copy_value [[REF_VAL]] : $RefAggregate
+ // CHECK: [[OWNED_CALL:%[0-9]+]] = function_ref @$S6shared15owned_arguments7trivial5value3refySi_AA14ValueAggregateVAA03RefH0CtF : $@convention(thin) (Int, @owned ValueAggregate, @owned RefAggregate) -> ()
+ // CHECK: {{%.*}} = apply [[OWNED_CALL]]([[TRIVIAL_VAL]], [[COPY_BORROW_VALUE_VAL]], [[COPY_BORROW_REF_VAL]]) : $@convention(thin) (Int, @owned ValueAggregate, @owned RefAggregate) -> ()
+ // CHECK: } // end sil function '$S6shared0A17_argument_capture7trivial5value3refySih_AA14ValueAggregateVhAA03RefH0ChtFyyXEfU0_'
+}
+
+// CHECK-LABEL: sil hidden @$S6shared0A20_to_owned_conversionyyySih_AA14ValueAggregateVhAA03RefF0ChtXEF : $@convention(thin) (@noescape @callee_guaranteed (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()) -> ()
+func shared_to_owned_conversion(_ f : (__shared Int, __shared ValueAggregate, __shared RefAggregate) -> Void) {
+ // CHECK: bb0([[UNUSED_FUNC:%[0-9]+]] : @trivial $@noescape @callee_guaranteed (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()):
+ // CHECK: [[OWNED_THUNK:%[0-9]+]] = function_ref @$S6shared0A20_to_owned_conversionyyySih_AA14ValueAggregateVhAA03RefF0ChtXEFySi_AdFtXEfU_ : $@convention(thin) (Int, @owned ValueAggregate, @owned RefAggregate) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_function [[OWNED_THUNK]]
+ // CHECK: [[THICK_OWNED_THUNK:%[0-9]+]] = thin_to_thick_function [[CONVERT]] : $@convention(thin) @noescape (Int, @owned ValueAggregate, @owned RefAggregate) -> () to $@noescape @callee_guaranteed (Int, @owned ValueAggregate, @owned RefAggregate) -> ()
+ // CHECK: [[GUARANTEED_TO_OWNED_THUNK:%[0-9]+]] = function_ref @$SSi6shared14ValueAggregateVAA03RefC0CIgyxx_SiAcEIegygg_TR : $@convention(thin) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate, @noescape @callee_guaranteed (Int, @owned ValueAggregate, @owned RefAggregate) -> ()) -> ()
+ // CHECK: [[APPLIED_THUNK:%[0-9]+]] = partial_apply [callee_guaranteed] [[GUARANTEED_TO_OWNED_THUNK]]([[THICK_OWNED_THUNK]]) : $@convention(thin) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate, @noescape @callee_guaranteed (Int, @owned ValueAggregate, @owned RefAggregate) -> ()) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[APPLIED_THUNK]]
+ // CHECK: [[RECUR_FN:%[0-9]+]] = function_ref @$S6shared0A20_to_owned_conversionyyySih_AA14ValueAggregateVhAA03RefF0ChtXEF : $@convention(thin) (@noescape @callee_guaranteed (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()) -> ()
+ // CHECK: {{%.*}} = apply [[RECUR_FN]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()) -> ()
+ // CHECK-NOT: destroy_value [[UNUSED_FUNC]]
+ // CHECK: } // end sil function '$S6shared0A20_to_owned_conversionyyySih_AA14ValueAggregateVhAA03RefF0ChtXEF'
+
+ // ======== REABSTRACTION THUNK =========
+
+ // CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SSi6shared14ValueAggregateVAA03RefC0CIgyxx_SiAcEIegygg_TR : $@convention(thin) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate, @noescape @callee_guaranteed (Int, @owned ValueAggregate, @owned RefAggregate) -> ()) -> ()
+ // CHECK: bb0([[TRIVIAL_VAL:%[0-9]+]] : @trivial $Int, [[VALUE_VAL:%[0-9]+]] : @guaranteed $ValueAggregate, [[REF_VAL:%[0-9]+]] : @guaranteed $RefAggregate, [[FUNC:%[0-9]+]] : @trivial $@noescape @callee_guaranteed (Int, @owned ValueAggregate, @owned RefAggregate) -> ()):
+ // CHECK: [[COPY_VALUE_VAL:%[0-9]+]] = copy_value [[VALUE_VAL]] : $ValueAggregate
+ // CHECK: [[COPY_REF_VAL:%[0-9]+]] = copy_value [[REF_VAL]] : $RefAggregate
+ // CHECK: {{%.*}} = apply [[FUNC]]([[TRIVIAL_VAL]], [[COPY_VALUE_VAL]], [[COPY_REF_VAL]]) : $@noescape @callee_guaranteed (Int, @owned ValueAggregate, @owned RefAggregate) -> ()
+ // CHECK: } // end sil function '$SSi6shared14ValueAggregateVAA03RefC0CIgyxx_SiAcEIegygg_TR'
+
+ return shared_to_owned_conversion { (trivial : Int, val : ValueAggregate, ref : RefAggregate) in }
+}
+
+// CHECK-LABEL: sil hidden @$S6shared09owned_to_A11_conversionyyySi_AA14ValueAggregateVAA03RefF0CtXEF : $@convention(thin) (@noescape @callee_guaranteed (Int, @owned ValueAggregate, @owned RefAggregate) -> ()) -> ()
+func owned_to_shared_conversion(_ f : (Int, ValueAggregate, RefAggregate) -> Void) {
+ // CHECK: bb0([[UNUSED_FUNC:%[0-9]+]] : @trivial $@noescape @callee_guaranteed (Int, @owned ValueAggregate, @owned RefAggregate) -> ()):
+ // CHECK: [[SHARED_THUNK:%[0-9]+]] = function_ref @$S6shared09owned_to_A11_conversionyyySi_AA14ValueAggregateVAA03RefF0CtXEFySih_ADhAFhtXEfU_ : $@convention(thin) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_function [[SHARED_THUNK]]
+ // CHECK: [[THICK_SHARED_THUNK:%[0-9]+]] = thin_to_thick_function [[CONVERT]] : $@convention(thin) @noescape (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> () to $@noescape @callee_guaranteed (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()
+ // CHECK: [[OWNED_TO_GUARANTEED_THUNK:%[0-9]+]] = function_ref @$SSi6shared14ValueAggregateVAA03RefC0CIgygg_SiAcEIegyxx_TR : $@convention(thin) (Int, @owned ValueAggregate, @owned RefAggregate, @noescape @callee_guaranteed (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()) -> ()
+ // CHECK: [[APPLIED_THUNK:%[0-9]+]] = partial_apply [callee_guaranteed] [[OWNED_TO_GUARANTEED_THUNK]]([[THICK_SHARED_THUNK]]) : $@convention(thin) (Int, @owned ValueAggregate, @owned RefAggregate, @noescape @callee_guaranteed (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()) -> ()
+ // CHECK: [[CONVERT:%.*]] = convert_escape_to_noescape [[APPLIED_THUNK]]
+ // CHECK: [[RECUR_FN:%[0-9]+]] = function_ref @$S6shared09owned_to_A11_conversionyyySi_AA14ValueAggregateVAA03RefF0CtXEF : $@convention(thin) (@noescape @callee_guaranteed (Int, @owned ValueAggregate, @owned RefAggregate) -> ()) -> ()
+ // CHECK: {{%.*}} = apply [[RECUR_FN]]([[CONVERT]]) : $@convention(thin) (@noescape @callee_guaranteed (Int, @owned ValueAggregate, @owned RefAggregate) -> ()) -> ()
+ // CHECK-NOT: destroy_value [[UNUSED_FUNC]]
+ // CHECK: } // end sil function '$S6shared09owned_to_A11_conversionyyySi_AA14ValueAggregateVAA03RefF0CtXEF'
+
+ // ======== REABSTRACTION THUNK =========
+
+ // CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @$SSi6shared14ValueAggregateVAA03RefC0CIgygg_SiAcEIegyxx_TR : $@convention(thin) (Int, @owned ValueAggregate, @owned RefAggregate, @noescape @callee_guaranteed (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()) -> ()
+ // CHECK: bb0([[TRIVIAL_VAL:%[0-9]+]] : @trivial $Int, [[VALUE_VAL:%[0-9]+]] : @owned $ValueAggregate, [[REF_VAL:%[0-9]+]] : @owned $RefAggregate, [[FUNC:%[0-9]+]] : @trivial $@noescape @callee_guaranteed (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()):
+ // CHECK: [[BORROW_VALUE_VAL:%[0-9]+]] = begin_borrow [[VALUE_VAL]] : $ValueAggregate
+ // CHECK: [[BORROW_REF_VAL:%[0-9]+]] = begin_borrow [[REF_VAL]] : $RefAggregate
+ // CHECK: {{%.*}} = apply [[FUNC]]([[TRIVIAL_VAL]], [[BORROW_VALUE_VAL]], [[BORROW_REF_VAL]]) : $@noescape @callee_guaranteed (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate) -> ()
+ // CHECK: end_borrow [[BORROW_REF_VAL]] from [[REF_VAL]] : $RefAggregate, $RefAggregate
+ // CHECK: end_borrow [[BORROW_VALUE_VAL]] from [[VALUE_VAL]] : $ValueAggregate, $ValueAggregate
+ // CHECK: destroy_value [[REF_VAL]] : $RefAggregate
+ // CHECK: destroy_value [[VALUE_VAL]] : $ValueAggregate
+ // CHECK: } // end sil function '$SSi6shared14ValueAggregateVAA03RefC0CIgygg_SiAcEIegyxx_TR'
+
+ return owned_to_shared_conversion { (trivial : __shared Int, val : __shared ValueAggregate, ref : __shared RefAggregate) in }
+}
+
+// CHECK-LABEL: sil hidden @$S6shared0A17_closure_loweringyyySi_AA14ValueAggregateVAA03RefE0CtchF : $@convention(thin) (@guaranteed @callee_guaranteed (Int, @owned ValueAggregate, @owned RefAggregate) -> ()) -> ()
+func shared_closure_lowering(_ f : __shared (Int, ValueAggregate, RefAggregate) -> Void) {}
+
+struct Foo {
+ var x: ValueAggregate
+
+ // CHECK-LABEL: sil hidden @$S6shared3FooV21methodSharedArguments7trivial5value3refySih_AA14ValueAggregateVhAA03RefJ0ChtF : $@convention(method) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate, @guaranteed Foo) -> () {
+ func methodSharedArguments(trivial : __shared Int, value : __shared ValueAggregate, ref : __shared RefAggregate) {
+ // CHECK: bb0([[TRIVIAL_VAL:%[0-9]+]] : @trivial $Int, [[VALUE_VAL:%[0-9]+]] : @guaranteed $ValueAggregate, [[REF_VAL:%[0-9]+]] : @guaranteed $RefAggregate, [[SELF:%[0-9]+]] : @guaranteed $Foo):
+ // CHECK: [[COPY_VALUE_VAL:%[0-9]+]] = copy_value [[VALUE_VAL]] : $ValueAggregate
+ // CHECK: [[COPY_REF_VAL:%[0-9]+]] = copy_value [[REF_VAL]] : $RefAggregate
+ // CHECK: [[OWNED_FUNC:%[0-9]+]] = function_ref @$S6shared3FooV20methodOwnedArguments7trivial5value3refySi_AA14ValueAggregateVAA03RefJ0CtF
+ // CHECK: {{%.*}} = apply [[OWNED_FUNC]]([[TRIVIAL_VAL]], [[COPY_VALUE_VAL]], [[COPY_REF_VAL]], [[SELF]]) : $@convention(method) (Int, @owned ValueAggregate, @owned RefAggregate, @guaranteed Foo) -> ()
+ // CHECK: } // end sil function '$S6shared3FooV21methodSharedArguments7trivial5value3refySih_AA14ValueAggregateVhAA03RefJ0ChtF'
+ return methodOwnedArguments(trivial: trivial, value: value, ref: ref)
+ }
+
+ // CHECK-LABEL: sil hidden @$S6shared3FooV20methodOwnedArguments7trivial5value3refySi_AA14ValueAggregateVAA03RefJ0CtF : $@convention(method) (Int, @owned ValueAggregate, @owned RefAggregate, @guaranteed Foo) -> () {
+ func methodOwnedArguments(trivial : Int, value : ValueAggregate, ref : RefAggregate) {
+ // CHECK: bb0([[TRIVIAL_VAL:%[0-9]+]] : @trivial $Int, [[VALUE_VAL:%[0-9]+]] : @owned $ValueAggregate, [[REF_VAL:%[0-9]+]] : @owned $RefAggregate, [[SELF:%[0-9]+]] : @guaranteed $Foo):
+ // CHECK: [[BORROW_VALUE_VAL:%[0-9]+]] = begin_borrow [[VALUE_VAL]] : $ValueAggregate
+ // CHECK: [[BORROW_REF_VAL:%[0-9]+]] = begin_borrow [[REF_VAL]] : $RefAggregate
+ // CHECK: [[SHARED_FUNC:%[0-9]+]] = function_ref @$S6shared3FooV21methodSharedArguments7trivial5value3refySih_AA14ValueAggregateVhAA03RefJ0ChtF
+ // CHECK: {{%.*}} = apply [[SHARED_FUNC]]([[TRIVIAL_VAL]], [[BORROW_VALUE_VAL]], [[BORROW_REF_VAL]], [[SELF]])
+ // CHECK: end_borrow [[BORROW_REF_VAL]] from [[REF_VAL]] : $RefAggregate, $RefAggregate
+ // CHECK: end_borrow [[BORROW_VALUE_VAL]] from [[VALUE_VAL]] : $ValueAggregate, $ValueAggregate
+ // CHECK: destroy_value [[REF_VAL]] : $RefAggregate
+ // CHECK: destroy_value [[VALUE_VAL]] : $ValueAggregate
+ // CHECK: } // end sil function '$S6shared3FooV20methodOwnedArguments7trivial5value3refySi_AA14ValueAggregateVAA03RefJ0CtF'
+ return methodSharedArguments(trivial: trivial, value: value, ref: ref)
+ }
+
+ // CHECK-LABEL: sil hidden @$S6shared3FooV21staticSharedArguments7trivial5value3refySih_AA14ValueAggregateVhAA03RefJ0ChtFZ : $@convention(method) (Int, @guaranteed ValueAggregate, @guaranteed RefAggregate, @thin Foo.Type) -> () {
+ static func staticSharedArguments(trivial : __shared Int, value : __shared ValueAggregate, ref : __shared RefAggregate) {
+ // CHECK: bb0([[TRIVIAL_VAL:%[0-9]+]] : @trivial $Int, [[VALUE_VAL:%[0-9]+]] : @guaranteed $ValueAggregate, [[REF_VAL:%[0-9]+]] : @guaranteed $RefAggregate, [[SELF_METATYPE:%[0-9]+]] : @trivial $@thin Foo.Type):
+ // CHECK: [[COPY_VALUE_VAL:%[0-9]+]] = copy_value [[VALUE_VAL]] : $ValueAggregate
+ // CHECK: [[COPY_REF_VAL:%[0-9]+]] = copy_value [[REF_VAL]] : $RefAggregate
+ // CHECK: [[OWNED_FUNC:%[0-9]+]] = function_ref @$S6shared3FooV20staticOwnedArguments7trivial5value3refySi_AA14ValueAggregateVAA03RefJ0CtFZ
+ // CHECK: {{%.*}} = apply [[OWNED_FUNC]]([[TRIVIAL_VAL]], [[COPY_VALUE_VAL]], [[COPY_REF_VAL]], [[SELF_METATYPE]]) : $@convention(method) (Int, @owned ValueAggregate, @owned RefAggregate, @thin Foo.Type) -> ()
+ // CHECK: } // end sil function '$S6shared3FooV21staticSharedArguments7trivial5value3refySih_AA14ValueAggregateVhAA03RefJ0ChtFZ'
+ return staticOwnedArguments(trivial: trivial, value: value, ref: ref)
+ }
+ // CHECK-LABEL: sil hidden @$S6shared3FooV20staticOwnedArguments7trivial5value3refySi_AA14ValueAggregateVAA03RefJ0CtFZ : $@convention(method) (Int, @owned ValueAggregate, @owned RefAggregate, @thin Foo.Type) -> () {
+ static func staticOwnedArguments(trivial : Int, value : ValueAggregate, ref : RefAggregate) {
+ // CHECK: bb0([[TRIVIAL_VAL:%[0-9]+]] : @trivial $Int, [[VALUE_VAL:%[0-9]+]] : @owned $ValueAggregate, [[REF_VAL:%[0-9]+]] : @owned $RefAggregate, [[SELF_METATYPE:%[0-9]+]] : @trivial $@thin Foo.Type):
+ // CHECK: [[BORROW_VALUE_VAL:%[0-9]+]] = begin_borrow [[VALUE_VAL]] : $ValueAggregate
+ // CHECK: [[BORROW_REF_VAL:%[0-9]+]] = begin_borrow [[REF_VAL]] : $RefAggregate
+ // CHECK: [[SHARED_FUNC:%[0-9]+]] = function_ref @$S6shared3FooV21staticSharedArguments7trivial5value3refySih_AA14ValueAggregateVhAA03RefJ0ChtFZ
+ // CHECK: {{%.*}} = apply [[SHARED_FUNC]]([[TRIVIAL_VAL]], [[BORROW_VALUE_VAL]], [[BORROW_REF_VAL]], [[SELF_METATYPE]])
+ // CHECK: end_borrow [[BORROW_REF_VAL]] from [[REF_VAL]] : $RefAggregate, $RefAggregate
+ // CHECK: end_borrow [[BORROW_VALUE_VAL]] from [[VALUE_VAL]] : $ValueAggregate, $ValueAggregate
+ // CHECK: destroy_value [[REF_VAL]] : $RefAggregate
+ // CHECK: destroy_value [[VALUE_VAL]] : $ValueAggregate
+ // CHECK: } // end sil function '$S6shared3FooV20staticOwnedArguments7trivial5value3refySi_AA14ValueAggregateVAA03RefJ0CtFZ'
+ return staticSharedArguments(trivial: trivial, value: value, ref: ref)
+ }
+}
diff --git a/test/SILGen/plus_zero_sil_locations.swift b/test/SILGen/plus_zero_sil_locations.swift
new file mode 100644
index 0000000..19f9b55
--- /dev/null
+++ b/test/SILGen/plus_zero_sil_locations.swift
@@ -0,0 +1,400 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -Xllvm -sil-print-debuginfo -emit-verbose-sil -enable-sil-ownership %s | %FileCheck %s
+
+// FIXME: Not sure if this an ideal source info for the branch -
+// it points to if, not the last instruction in the block.
+func ifexpr() -> Int {
+ var x : Int = 0
+ if true {
+ x+=1
+ }
+ return x
+ // CHECK-LABEL: sil hidden @$S13sil_locations6ifexprSiyF
+ // CHECK: apply {{.*}}, loc "{{.*}}":[[@LINE-5]]:6
+ // CHECK: cond_br {{%.*}}, [[TRUE_BB:bb[0-9]+]], [[FALSE_BB:bb[0-9]+]], loc "{{.*}}":[[@LINE-6]]:6
+ // CHECK: br [[FALSE_BB]], loc "{{.*}}":[[@LINE-5]]:3
+ // CHECK: return {{.*}}, loc "{{.*}}":[[@LINE-5]]:3, {{.*}}:return
+}
+
+func ifelseexpr() -> Int {
+ var x : Int = 0
+ if true {
+ x+=1
+ } else {
+ x-=1
+ }
+ return x
+ // CHECK-LABEL: sil hidden @$S13sil_locations10ifelseexprSiyF
+ // CHECK: cond_br {{%.*}}, [[TRUE_BB:bb[0-9]+]], [[FALSE_BB:bb[0-9]+]], loc "{{.*}}":[[@LINE-7]]:6
+ // CHECK: [[TRUE_BB]]:
+ // CHECK: br bb{{[0-9]+}}, loc "{{.*}}":[[@LINE-7]]:3
+ // CHECK: [[FALSE_BB]]:
+ // CHECK: br bb{{[0-9]+}}, loc "{{.*}}":[[@LINE-7]]:3
+ // CHECK: return {{.*}}, loc "{{.*}}":[[@LINE-7]]:3, {{.*}}:return
+}
+
+// The source locations are handled differently here - since
+// the return is unified, we keep the location of the return(not the if)
+// in the branch.
+func ifexpr_return() -> Int {
+ if true {
+ return 5
+ }
+ return 6
+ // CHECK-LABEL: sil hidden @$S13sil_locations13ifexpr_returnSiyF
+ // CHECK: apply {{.*}}, loc "{{.*}}":[[@LINE-5]]:6
+ // CHECK: cond_br {{%.*}}, [[TRUE_BB:bb[0-9]+]], [[FALSE_BB:bb[0-9]+]], loc "{{.*}}":[[@LINE-6]]:6
+ // CHECK: [[TRUE_BB]]:
+ // CHECK: br bb{{[0-9]+}}({{%.*}}), loc "{{.*}}":[[@LINE-7]]:5, {{.*}}:return
+ // CHECK: [[FALSE_BB]]:
+ // CHECK: br bb{{[0-9]+}}({{%.*}}), loc "{{.*}}":[[@LINE-7]]:3, {{.*}}:return
+ // CHECK: return {{.*}}, loc "{{.*}}":[[@LINE+1]]:1, {{.*}}:cleanup
+}
+
+func ifexpr_rval() -> Int {
+ var x = true ? 5 : 6
+ return x
+ // CHECK-LABEL: sil hidden @$S13sil_locations11ifexpr_rvalSiyF
+ // CHECK: apply {{.*}}, loc "{{.*}}":[[@LINE-3]]:11
+ // CHECK: cond_br {{%.*}}, [[TRUE_BB:bb[0-9]+]], [[FALSE_BB:bb[0-9]+]], loc "{{.*}}":[[@LINE-4]]:11
+ // CHECK: [[TRUE_BB]]:
+ // CHECK: br bb{{[0-9]+}}({{%.*}}), loc "{{.*}}":[[@LINE-6]]:18
+ // CHECK: [[FALSE_BB]]:
+ // CHECK: br bb{{[0-9]+}}({{%.*}}), loc "{{.*}}":[[@LINE-8]]:22
+}
+
+// --- Test function calls.
+func simpleDirectCallTest(_ i: Int) -> Int {
+ return simpleDirectCallTest(i)
+ // CHECK-LABEL: sil hidden @$S13sil_locations20simpleDirectCallTestyS2iF
+ // CHECK: function_ref @$S13sil_locations20simpleDirectCallTestyS2iF : {{.*}}, loc "{{.*}}":[[@LINE-2]]:10
+ // CHECK: {{%.*}} apply {{%.*}} line:[[@LINE-3]]:10
+}
+
+func templateTest<T>(_ value: T) -> T {
+ return value
+}
+func useTemplateTest() -> Int {
+ return templateTest(5);
+ // CHECK-LABEL: sil hidden @$S13sil_locations15useTemplateTestSiyF
+ // CHECK: function_ref @$SSi2{{[_0-9a-zA-Z]*}}fC :{{.*}}, loc "{{.*}}":77
+}
+
+func foo(_ x: Int) -> Int {
+ func bar(_ y: Int) -> Int {
+ return x + y
+ }
+ return bar(1)
+ // CHECK-LABEL: sil hidden @$S13sil_locations3foo{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[CLOSURE:%[0-9]+]] = function_ref {{.*}}, loc "{{.*}}":[[@LINE-2]]:10
+ // CHECK: apply [[CLOSURE:%[0-9]+]]
+}
+
+class LocationClass {
+ func mem() {}
+}
+func testMethodCall() {
+ var l: LocationClass
+ l.mem();
+ // CHECK-LABEL: sil hidden @$S13sil_locations14testMethodCallyyF
+
+ // CHECK: class_method {{.[0-9]+}} : $LocationClass, #LocationClass.mem!1 {{.*}}, loc "{{.*}}":[[@LINE-3]]:5
+}
+
+func multipleReturnsImplicitAndExplicit() {
+ var x = 5+3
+ if x > 10 {
+ return
+ }
+ x += 1
+ // CHECK-LABEL: sil hidden @$S13sil_locations34multipleReturnsImplicitAndExplicityyF
+ // CHECK: cond_br
+ // CHECK: br bb{{[0-9]+}}, loc "{{.*}}":[[@LINE-5]]:5, {{.*}}:return
+ // CHECK: br bb{{[0-9]+}}, loc "{{.*}}":[[@LINE+2]]:1, {{.*}}:imp_return
+ // CHECK: return {{.*}}, loc "{{.*}}":[[@LINE+1]]:1, {{.*}}:cleanup
+}
+
+func simplifiedImplicitReturn() -> () {
+ var y = 0
+ // CHECK-LABEL: sil hidden @$S13sil_locations24simplifiedImplicitReturnyyF
+ // CHECK: return {{.*}}, loc "{{.*}}":[[@LINE+1]]:1, {{.*}}:imp_return
+}
+
+func switchfoo() -> Int { return 0 }
+func switchbar() -> Int { return 0 }
+
+// CHECK-LABEL: sil hidden @$S13sil_locations10testSwitchyyF
+func testSwitch() {
+ var x:Int
+ x = 0
+ switch (switchfoo(), switchbar()) {
+ // CHECK: store {{.*}}, loc "{{.*}}":[[@LINE+1]]
+ case (1,2):
+ // CHECK: integer_literal $Builtin.Int2048, 2, loc "{{.*}}":[[@LINE-1]]:11
+ // FIXME: Location info is missing.
+ // CHECK: cond_br
+ //
+ var z: Int = 200
+ // CHECK: [[VAR_Z:%[0-9]+]] = alloc_box ${ var Int }, var, name "z"{{.*}}line:[[@LINE-1]]:9
+ // CHECK: integer_literal $Builtin.Int2048, 200, loc "{{.*}}":[[@LINE-2]]:18
+ x = z
+ // CHECK: destroy_value [[VAR_Z]]{{.*}}, loc "{{.*}}":[[@LINE-1]]:9, {{.*}}:cleanup
+ case (3, let y):
+ x += 1
+ default:
+ ()
+ }
+}
+
+func testIf() {
+ if true {
+ var y:Int
+ } else {
+ var x:Int
+ }
+ // CHECK-LABEL: sil hidden @$S13sil_locations6testIfyyF
+ //
+ // FIXME: Missing location info here.
+ // CHECK: function_ref
+ // CHECK: apply
+ //
+ //
+ //
+ // CHECK: br {{.*}}, loc "{{.*}}":[[@LINE-13]]:6
+}
+
+func testFor() {
+ for i in 0..<10 {
+ var y: Int = 300
+ y+=1
+ if true {
+ break
+ }
+ y-=1
+ continue
+ }
+
+ // CHECK-LABEL: sil hidden @$S13sil_locations7testForyyF
+ // CHECK: [[VAR_Y_IN_FOR:%[0-9]+]] = alloc_box ${ var Int }, var, name "y", loc "{{.*}}":[[@LINE-10]]:9
+ // CHECK: integer_literal $Builtin.Int2048, 300, loc "{{.*}}":[[@LINE-11]]:18
+ // CHECK: destroy_value [[VAR_Y_IN_FOR]] : ${ var Int }
+ // CHECK: br bb{{.*}}, loc "{{.*}}":[[@LINE-10]]:7
+ // CHECK: destroy_value [[VAR_Y_IN_FOR]] : ${ var Int }
+ // CHECK: br bb{{.*}}, loc "{{.*}}":[[@LINE-9]]:5
+
+
+}
+
+func testTuples() {
+ var t = (2,3)
+ var tt = (2, (4,5))
+ var d = "foo"
+ // CHECK-LABEL: sil hidden @$S13sil_locations10testTuplesyyF
+ // CHECK: tuple_element_addr {{.*}}, loc "{{.*}}":[[@LINE-4]]:11
+ // CHECK: integer_literal $Builtin.Int2048, 2, loc "{{.*}}":[[@LINE-5]]:12
+ // CHECK: integer_literal $Builtin.Int2048, 3, loc "{{.*}}":[[@LINE-6]]:14
+ // CHECK: tuple_element_addr {{.*}}, loc "{{.*}}":[[@LINE-6]]:12
+ // CHECK: tuple_element_addr {{.*}}, loc "{{.*}}":[[@LINE-7]]:16
+}
+
+// Test tuple imploding/exploding.
+protocol Ordinable {
+ func ord() -> Int
+}
+
+func b<T : Ordinable>(_ seq: T) -> (Int) -> Int {
+ return {i in i + seq.ord() }
+}
+
+func captures_tuple<T, U>(x: (T, U)) -> () -> (T, U) {
+ return {x}
+ // CHECK-LABEL: sil hidden @$S13sil_locations14captures_tuple{{[_0-9a-zA-Z]*}}F
+ // CHECK: tuple_element_addr {{.*}}, loc "{{.*}}":[[@LINE-3]]:27
+ // CHECK: copy_addr {{.*}}, loc "{{.*}}":[[@LINE-4]]:27
+ // CHECK: function_ref {{.*}}, loc "{{.*}}":[[@LINE-4]]:10
+
+ // CHECK-LABEL: sil private @$S13sil_locations14captures_tuple{{.*}}fU_
+ // CHECK: copy_addr {{.*}}, loc "{{.*}}":[[@LINE-7]]:11
+}
+
+func interpolated_string(_ x: Int, y: String) -> String {
+ return "The \(x) Million Dollar \(y)"
+ // CHECK-LABEL: sil hidden @$S13sil_locations19interpolated_string{{[_0-9a-zA-Z]*}}F
+ // CHECK: copy_value{{.*}}, loc "{{.*}}":[[@LINE-2]]:37
+}
+
+
+func int(_ x: Int) {}
+func tuple() -> (Int, Float) { return (1, 1.0) }
+func tuple_element(_ x: (Int, Float)) {
+ int(tuple().0)
+ // CHECK-LABEL: sil hidden @$S13sil_locations13tuple_element{{[_0-9a-zA-Z]*}}F
+
+ // CHECK: apply {{.*}} line:[[@LINE-3]]:7
+ // CHECK: tuple_extract{{.*}}, 0, {{.*}}line:[[@LINE-4]]:7
+ // CHECK: tuple_extract{{.*}}, 1, {{.*}}line:[[@LINE-5]]:7
+ // CHECK: apply {{.*}} line:[[@LINE-6]]:3
+
+}
+
+func containers() -> ([Int], Dictionary<String, Int>) {
+ return ([1, 2, 3], ["Ankeny": 1, "Burnside": 2, "Couch": 3])
+ // CHECK-LABEL: sil hidden @$S13sil_locations10containers{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply {{%.*}}<(String, Int)>({{%.*}}), loc "{{.*}}":[[@LINE-2]]:22
+
+ // CHECK: string_literal utf8 "Ankeny", loc "{{.*}}":[[@LINE-4]]:23
+
+ // CHECK: integer_literal $Builtin.Int2048, 1, loc "{{.*}}":[[@LINE-6]]:33
+ // CHECK: integer_literal $Builtin.Int2048, 2, loc "{{.*}}":[[@LINE-7]]:48
+
+
+
+}
+
+
+func a() {}
+func b() -> Int { return 0 }
+protocol P { func p() }
+struct X : P { func p() {} }
+func test_isa_2(_ p: P) {
+ switch (p, b()) {
+ case (is X, b()):
+ a()
+ case _:
+ a()
+ }
+
+
+
+ // CHECK-LABEL: sil hidden @$S13sil_locations10test_isa_2{{[_0-9a-zA-Z]*}}F
+ // CHECK: alloc_stack $(P, Int), loc "{{.*}}":[[@LINE-10]]:10
+ // CHECK: tuple_element_addr{{.*}} $*(P, Int), 0, loc "{{.*}}":[[@LINE-11]]:10
+ // CHECK: tuple_element_addr{{.*}} $*(P, Int), 1, loc "{{.*}}":[[@LINE-12]]:10
+ // CHECK: load {{.*}}, loc "{{.*}}":[[@LINE-12]]:8
+ //
+ // CHECK: checked_cast_addr_br {{.*}}, loc "{{.*}}":[[@LINE-14]]:9
+ // CHECK: load {{.*}}, loc "{{.*}}":[[@LINE-15]]:9
+
+}
+
+func runcibleWhy() {}
+protocol Runcible {
+ func runce()
+}
+enum SinglePayloadAddressOnly {
+ case x(Runcible)
+ case y
+}
+func printSinglePayloadAddressOnly(_ v:SinglePayloadAddressOnly) {
+ switch v {
+ case .x(let runcible):
+ runcible.runce()
+ case .y:
+ runcibleWhy()
+ }
+
+
+ // CHECK_LABEL: sil hidden @$S13sil_locations29printSinglePayloadAddressOnly{{[_0-9a-zA-Z]*}}F
+ // CHECK: bb0
+ // CHECK: switch_enum_addr {{.*}} [[FALSE_BB:bb[0-9]+]], {{.*}}line:[[@LINE-10]]:3
+ // CHECK: [[FALSE_BB]]:
+
+}
+
+
+func testStringForEachStmt() {
+ var i = 0
+ for index in 1..<20 {
+ i += 1
+ if i == 15 {
+ break
+ }
+ }
+
+ // CHECK-LABEL: sil hidden @$S13sil_locations21testStringForEachStmtyyF
+ // CHECK: br {{.*}} line:[[@LINE-8]]:3
+ // CHECK: switch_enum {{.*}} line:[[@LINE-9]]:3
+ // CHECK: cond_br {{.*}} line:[[@LINE-8]]:8
+ // Break branch:
+ // CHECK: br {{.*}} line:[[@LINE-9]]:7
+ // Looping back branch:
+ // CHECK: br {{.*}} line:[[@LINE-9]]:3
+ // Condition is false branch:
+ // CHECK: br {{.*}} line:[[@LINE-16]]:3
+
+
+
+
+}
+
+
+func testForStmt() {
+
+ var m = 0
+ for i in 0..<10 {
+ m += 1
+ if m == 15 {
+ break
+ } else {
+ continue
+ }
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
+
+
+func testRepeatWhile() {
+ var m = 0
+ repeat {
+ m += 1
+ } while (m < 200)
+
+
+ // CHECK-LABEL: sil hidden @$S13sil_locations15testRepeatWhileyyF
+ // CHECK: br {{.*}} line:[[@LINE-6]]:3
+ // CHECK: cond_br {{.*}} line:[[@LINE-5]]:11
+ // Loop back branch:
+ // CHECK: br {{.*}} line:[[@LINE-7]]:11
+}
+
+
+
+func testWhile() {
+ var m = 0
+ while m < 100 {
+ m += 1
+ if m > 5 {
+ break
+ }
+ m += 1
+ }
+
+ // CHECK-LABEL: sil hidden @$S13sil_locations9testWhileyyF
+ // CHECK: br {{.*}} line:[[@LINE-9]]:3
+ // While loop conditional branch:
+ // CHECK: cond_br {{.*}} line:[[@LINE-11]]:9
+ // If stmt condition branch:
+ // CHECK: cond_br {{.*}} line:[[@LINE-11]]:8
+ // Break branch:
+ // CHECK: br {{.*}} line:[[@LINE-12]]:7
+ // Looping back branch:
+ // CHECK: br {{.*}} line:[[@LINE-11]]:3
+
+
+
+}
diff --git a/test/SILGen/plus_zero_source_location.swift b/test/SILGen/plus_zero_source_location.swift
new file mode 100644
index 0000000..b61fef9
--- /dev/null
+++ b/test/SILGen/plus_zero_source_location.swift
@@ -0,0 +1,25 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -Xllvm -sil-print-debuginfo -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+func printSourceLocation(file: String = #file, line: Int = #line) {}
+
+#sourceLocation(file: "caller.swift", line: 10000)
+_ = printSourceLocation()
+// CHECK: [[CALLER_FILE_VAL:%.*]] = string_literal utf16 "caller.swift",
+// CHECK: [[CALLER_FILE:%.*]] = apply {{.*}}([[CALLER_FILE_VAL]],
+// CHECK: [[BORROWED_CALLER_FILE:%.*]] = begin_borrow [[CALLER_FILE]]
+// CHECK: [[CALLER_LINE_VAL:%.*]] = integer_literal $Builtin.Int{{[0-9]+}}, 10000,
+// CHECK: [[CALLER_LINE:%.*]] = apply {{.*}}([[CALLER_LINE_VAL]],
+// CHECK: [[PRINT_SOURCE_LOCATION:%.*]] = function_ref @$S15source_location19printSourceLocation4file4lineySS_SitF
+// CHECK: apply [[PRINT_SOURCE_LOCATION]]([[BORROWED_CALLER_FILE]], [[CALLER_LINE]])
+
+#sourceLocation(file: "inplace.swift", line: 20000)
+let FILE = #file, LINE = #line
+// CHECK: [[FILE_ADDR:%.*]] = global_addr @$S15source_location4FILESSv
+// CHECK: [[INPLACE_FILE_VAL:%.*]] = string_literal utf16 "inplace.swift",
+// CHECK: [[INPLACE_FILE:%.*]] = apply {{.*}}([[INPLACE_FILE_VAL]],
+// CHECK: store [[INPLACE_FILE]] to [init] [[FILE_ADDR]]
+// CHECK: [[LINE_ADDR:%.*]] = global_addr @$S15source_location4LINESiv
+// CHECK: [[INPLACE_LINE_VAL:%.*]] = integer_literal $Builtin.Int{{[0-9]+}}, 20000,
+// CHECK: [[INPLACE_LINE:%.*]] = apply {{.*}}([[INPLACE_LINE_VAL]],
+// CHECK: store [[INPLACE_LINE]] to [trivial] [[LINE_ADDR]]
diff --git a/test/SILGen/plus_zero_specialize_attr.swift b/test/SILGen/plus_zero_specialize_attr.swift
new file mode 100644
index 0000000..7ee8a18
--- /dev/null
+++ b/test/SILGen/plus_zero_specialize_attr.swift
@@ -0,0 +1,109 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -emit-verbose-sil %s | %FileCheck %s
+
+// CHECK-LABEL: @_specialize(exported: false, kind: full, where T == Int, U == Float)
+// CHECK-NEXT: func specializeThis<T, U>(_ t: T, u: U)
+@_specialize(where T == Int, U == Float)
+func specializeThis<T, U>(_ t: T, u: U) {}
+
+public protocol PP {
+ associatedtype PElt
+}
+public protocol QQ {
+ associatedtype QElt
+}
+
+public struct RR : PP {
+ public typealias PElt = Float
+}
+public struct SS : QQ {
+ public typealias QElt = Int
+}
+
+public struct GG<T : PP> {}
+
+// CHECK-LABEL: public class CC<T> where T : PP {
+// CHECK-NEXT: @_specialize(exported: false, kind: full, where T == RR, U == SS)
+// CHECK-NEXT: @inline(never) public func foo<U>(_ u: U, g: GG<T>) -> (U, GG<T>) where U : QQ
+public class CC<T : PP> {
+ @inline(never)
+ @_specialize(where T == RR, U == SS)
+ public func foo<U : QQ>(_ u: U, g: GG<T>) -> (U, GG<T>) {
+ return (u, g)
+ }
+}
+
+// CHECK-LABEL: sil hidden [_specialize exported: false, kind: full, where T == Int, U == Float] @$S15specialize_attr0A4This_1uyx_q_tr0_lF : $@convention(thin) <T, U> (@in_guaranteed T, @in_guaranteed U) -> () {
+
+// CHECK-LABEL: sil [noinline] [_specialize exported: false, kind: full, where T == RR, U == SS] @$S15specialize_attr2CCC3foo_1gqd___AA2GGVyxGtqd___AHtAA2QQRd__lF : $@convention(method) <T where T : PP><U where U : QQ> (@in_guaranteed U, GG<T>, @guaranteed CC<T>) -> (@out U, GG<T>) {
+
+// -----------------------------------------------------------------------------
+// Test user-specialized subscript accessors.
+
+public protocol TestSubscriptable {
+ associatedtype Element
+ subscript(i: Int) -> Element { get set }
+}
+
+public class ASubscriptable<Element> : TestSubscriptable {
+ var storage: UnsafeMutablePointer<Element>
+
+ init(capacity: Int) {
+ storage = UnsafeMutablePointer<Element>.allocate(capacity: capacity)
+ }
+
+ public subscript(i: Int) -> Element {
+ @_specialize(where Element == Int)
+ get {
+ return storage[i]
+ }
+ @_specialize(where Element == Int)
+ set(rhs) {
+ storage[i] = rhs
+ }
+ }
+}
+
+// ASubscriptable.subscript.getter with _specialize
+// CHECK-LABEL: sil [_specialize exported: false, kind: full, where Element == Int] @$S15specialize_attr14ASubscriptableCyxSicig : $@convention(method) <Element> (Int, @guaranteed ASubscriptable<Element>) -> @out Element {
+
+// ASubscriptable.subscript.setter with _specialize
+// CHECK-LABEL: sil [_specialize exported: false, kind: full, where Element == Int] @$S15specialize_attr14ASubscriptableCyxSicis : $@convention(method) <Element> (@in Element, Int, @guaranteed ASubscriptable<Element>) -> () {
+
+// ASubscriptable.subscript.materializeForSet with no attribute
+// CHECK-LABEL: sil [transparent] [serialized] @$S15specialize_attr14ASubscriptableCyxSicim : $@convention(method) <Element> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, Int, @guaranteed ASubscriptable<Element>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+
+public class Addressable<Element> : TestSubscriptable {
+ var storage: UnsafeMutablePointer<Element>
+
+ init(capacity: Int) {
+ storage = UnsafeMutablePointer<Element>.allocate(capacity: capacity)
+ }
+
+ public subscript(i: Int) -> Element {
+ @_specialize(where Element == Int)
+ unsafeAddress {
+ return UnsafePointer<Element>(storage + i)
+ }
+ @_specialize(where Element == Int)
+ unsafeMutableAddress {
+ return UnsafeMutablePointer<Element>(storage + i)
+ }
+ }
+}
+
+// Addressable.subscript.getter with no attribute
+// CHECK-LABEL: sil [transparent] [serialized] @$S15specialize_attr11AddressableCyxSicig : $@convention(method) <Element> (Int, @guaranteed Addressable<Element>) -> @out Element {
+
+// Addressable.subscript.unsafeAddressor with _specialize
+// CHECK-LABEL: sil [_specialize exported: false, kind: full, where Element == Int] @$S15specialize_attr11AddressableCyxSicilu : $@convention(method) <Element> (Int, @guaranteed Addressable<Element>) -> UnsafePointer<Element> {
+
+// Addressable.subscript.setter with no attribute
+// CHECK-LABEL: sil [transparent] [serialized] @$S15specialize_attr11AddressableCyxSicis : $@convention(method) <Element> (@in Element, Int, @guaranteed Addressable<Element>) -> () {
+
+// Addressable.subscript.unsafeMutableAddressor with _specialize
+// CHECK-LABEL: sil [_specialize exported: false, kind: full, where Element == Int] @$S15specialize_attr11AddressableCyxSiciau : $@convention(method) <Element> (Int, @guaranteed Addressable<Element>) -> UnsafeMutablePointer<Element> {
+
+// Addressable.subscript.materializeForSet with no attribute
+// CHECK-LABEL: sil [transparent] [serialized] @$S15specialize_attr11AddressableCyxSicim : $@convention(method) <Element> (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, Int, @guaranteed Addressable<Element>) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+
diff --git a/test/SILGen/plus_zero_statements.swift b/test/SILGen/plus_zero_statements.swift
new file mode 100644
index 0000000..d3fe1bd
--- /dev/null
+++ b/test/SILGen/plus_zero_statements.swift
@@ -0,0 +1,697 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -parse-as-library -emit-silgen -enable-sil-ownership -verify %s | %FileCheck %s
+
+class MyClass {
+ func foo() { }
+}
+
+func markUsed<T>(_ t: T) {}
+
+func marker_1() {}
+func marker_2() {}
+func marker_3() {}
+
+class BaseClass {}
+class DerivedClass : BaseClass {}
+
+var global_cond: Bool = false
+
+func bar(_ x: Int) {}
+func foo(_ x: Int, _ y: Bool) {}
+
+func abort() -> Never { abort() }
+
+
+
+func assignment(_ x: Int, y: Int) {
+ var x = x
+ var y = y
+ x = 42
+ y = 57
+ _ = x
+ _ = y
+ (x, y) = (1,2)
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}assignment
+// CHECK: integer_literal $Builtin.Int2048, 42
+// CHECK: assign
+// CHECK: integer_literal $Builtin.Int2048, 57
+// CHECK: assign
+
+func if_test(_ x: Int, y: Bool) {
+ if (y) {
+ bar(x);
+ }
+ bar(x);
+}
+
+// CHECK-LABEL: sil hidden @$S10statements7if_test{{[_0-9a-zA-Z]*}}F
+
+func if_else(_ x: Int, y: Bool) {
+ if (y) {
+ bar(x);
+ } else {
+ foo(x, y);
+ }
+ bar(x);
+}
+
+// CHECK-LABEL: sil hidden @$S10statements7if_else{{[_0-9a-zA-Z]*}}F
+
+func nested_if(_ x: Int, y: Bool, z: Bool) {
+ if (y) {
+ if (z) {
+ bar(x);
+ }
+ } else {
+ if (z) {
+ foo(x, y);
+ }
+ }
+ bar(x);
+}
+
+// CHECK-LABEL: sil hidden @$S10statements9nested_if{{[_0-9a-zA-Z]*}}F
+
+func nested_if_merge_noret(_ x: Int, y: Bool, z: Bool) {
+ if (y) {
+ if (z) {
+ bar(x);
+ }
+ } else {
+ if (z) {
+ foo(x, y);
+ }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10statements21nested_if_merge_noret{{[_0-9a-zA-Z]*}}F
+
+func nested_if_merge_ret(_ x: Int, y: Bool, z: Bool) -> Int {
+ if (y) {
+ if (z) {
+ bar(x);
+ }
+ return 1
+ } else {
+ if (z) {
+ foo(x, y);
+ }
+ }
+ return 2
+}
+
+// CHECK-LABEL: sil hidden @$S10statements19nested_if_merge_ret{{[_0-9a-zA-Z]*}}F
+
+func else_break(_ x: Int, y: Bool, z: Bool) {
+ while z {
+ if y {
+ } else {
+ break
+ }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10statements10else_break{{[_0-9a-zA-Z]*}}F
+
+func loop_with_break(_ x: Int, _ y: Bool, _ z: Bool) -> Int {
+ while (x > 2) {
+ if (y) {
+ bar(x);
+ break
+ }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10statements15loop_with_break{{[_0-9a-zA-Z]*}}F
+
+func loop_with_continue(_ x: Int, y: Bool, z: Bool) -> Int {
+ while (x > 2) {
+ if (y) {
+ bar(x);
+ continue
+ }
+ _ = loop_with_break(x, y, z);
+ }
+ bar(x);
+}
+
+// CHECK-LABEL: sil hidden @$S10statements18loop_with_continue{{[_0-9a-zA-Z]*}}F
+
+func do_loop_with_continue(_ x: Int, y: Bool, z: Bool) -> Int {
+ repeat {
+ if (x < 42) {
+ bar(x);
+ continue
+ }
+ _ = loop_with_break(x, y, z);
+ }
+ while (x > 2);
+ bar(x);
+}
+
+// CHECK-LABEL: sil hidden @$S10statements21do_loop_with_continue{{[_0-9a-zA-Z]*}}F
+
+
+// CHECK-LABEL: sil hidden @{{.*}}for_loops1
+func for_loops1(_ x: Int, c: Bool) {
+ for i in 1..<100 {
+ markUsed(i)
+ }
+
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}for_loops2
+func for_loops2() {
+ // rdar://problem/19316670
+ // CHECK: alloc_stack $Optional<MyClass>
+ // CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [unknown]
+ // CHECK: [[NEXT:%[0-9]+]] = function_ref @$Ss16IndexingIteratorV4next{{[_0-9a-zA-Z]*}}F
+ // CHECK-NEXT: apply [[NEXT]]<[MyClass]>
+ // CHECK: class_method [[OBJ:%[0-9]+]] : $MyClass, #MyClass.foo!1
+ let objects = [MyClass(), MyClass() ]
+ for obj in objects {
+ obj.foo()
+ }
+
+ return
+}
+
+func void_return() {
+ let b:Bool
+ if b {
+ return
+ }
+}
+// CHECK-LABEL: sil hidden @$S10statements11void_return{{[_0-9a-zA-Z]*}}F
+// CHECK: cond_br {{%[0-9]+}}, [[BB1:bb[0-9]+]], [[BB2:bb[0-9]+]]
+// CHECK: [[BB1]]:
+// CHECK: br [[EPILOG:bb[0-9]+]]
+// CHECK: [[BB2]]:
+// CHECK: br [[EPILOG]]
+// CHECK: [[EPILOG]]:
+// CHECK: [[R:%[0-9]+]] = tuple ()
+// CHECK: return [[R]]
+
+func foo() {}
+
+// <rdar://problem/13549626>
+// CHECK-LABEL: sil hidden @$S10statements14return_from_if{{[_0-9a-zA-Z]*}}F
+func return_from_if(_ a: Bool) -> Int {
+ // CHECK: bb0(%0 : @trivial $Bool):
+ // CHECK: cond_br {{.*}}, [[THEN:bb[0-9]+]], [[ELSE:bb[0-9]+]]
+ if a {
+ // CHECK: [[THEN]]:
+ // CHECK: br [[EPILOG:bb[0-9]+]]({{%.*}})
+ return 1
+ } else {
+ // CHECK: [[ELSE]]:
+ // CHECK: br [[EPILOG]]({{%.*}})
+ return 0
+ }
+ // CHECK-NOT: function_ref @foo
+ // CHECK: [[EPILOG]]([[RET:%.*]] : @trivial $Int):
+ // CHECK: return [[RET]]
+ foo() // expected-warning {{will never be executed}}
+}
+
+class C {}
+
+func use(_ c: C) {}
+
+func for_each_loop(_ x: [C]) {
+ for i in x {
+ use(i)
+ }
+ _ = 0
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}test_break
+func test_break(_ i : Int) {
+ switch i {
+ case (let x) where x != 17:
+ if x == 42 { break }
+ markUsed(x)
+ default:
+ break
+ }
+}
+
+
+// <rdar://problem/19150249> Allow labeled "break" from an "if" statement
+
+// CHECK-LABEL: sil hidden @$S10statements13test_if_breakyyAA1CCSgF : $@convention(thin) (@guaranteed Optional<C>) -> () {
+func test_if_break(_ c : C?) {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Optional<C>):
+label1:
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: switch_enum [[ARG_COPY]] : $Optional<C>, case #Optional.some!enumelt.1: [[TRUE:bb[0-9]+]], case #Optional.none!enumelt: [[FALSE:bb[0-9]+]]
+ if let x = c {
+// CHECK: [[TRUE]]({{.*}} : @owned $C):
+
+ // CHECK: apply
+ foo()
+
+ // CHECK: destroy_value
+ // CHECK: br [[FALSE:bb[0-9]+]]
+ break label1
+ use(x) // expected-warning {{will never be executed}}
+ }
+
+ // CHECK: [[FALSE]]:
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S10statements18test_if_else_breakyyAA1CCSgF : $@convention(thin) (@guaranteed Optional<C>) -> () {
+func test_if_else_break(_ c : C?) {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Optional<C>):
+label2:
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: switch_enum [[ARG_COPY]] : $Optional<C>, case #Optional.some!enumelt.1: [[TRUE:bb[0-9]+]], case #Optional.none!enumelt: [[FALSE:bb[0-9]+]]
+
+ // CHECK: [[FALSE]]:
+ // CHECK: br [[AFTER_FALSE:bb[0-9]+]]
+ if let x = c {
+ // CHECK: [[TRUE]]({{.*}} : @owned $C):
+ use(x)
+ // CHECK: br [[CONT:bb[0-9]+]]
+ // CHECK: [[CONT]]:
+ // CHECK: br [[EPILOG:bb[0-9]+]]
+ } else {
+ // CHECK: [[AFTER_FALSE]]:
+ // CHECK: apply
+ // CHECK: br [[EPILOG]]
+ foo()
+ break label2
+ foo() // expected-warning {{will never be executed}}
+ }
+ // CHECK: [[EPILOG]]:
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S10statements23test_if_else_then_breakyySb_AA1CCSgtF
+func test_if_else_then_break(_ a : Bool, _ c : C?) {
+label3:
+ // CHECK: bb0({{.*}}, [[ARG2:%.*]] : @guaranteed $Optional<C>):
+ // CHECK: [[ARG2_COPY:%.*]] = copy_value [[ARG2]]
+ // CHECK: switch_enum [[ARG2_COPY]] : $Optional<C>, case #Optional.some!enumelt.1: [[TRUE:bb[0-9]+]], case #Optional.none!enumelt: [[FALSE:bb[0-9]+]]
+
+ // CHECK: [[FALSE]]:
+ // CHECK: br [[COND2:bb[0-9]+]]
+ if let x = c {
+ // CHECK: [[TRUE]]({{.*}} : @owned $C):
+ use(x)
+ // CHECK: br [[TRUE_TRAMPOLINE:bb[0-9]+]]
+ //
+ // CHECK: [[TRUE_TRAMPOLINE]]:
+ // CHECK: br [[EPILOG_BB:bb[0-9]+]]
+ } else if a {
+ // CHECK: [[COND2]]:
+ // CHECK: cond_br {{.*}}, [[TRUE2:bb[0-9]+]], [[FALSE2:bb[0-9]+]]
+ //
+ // CHECK: [[TRUE2]]:
+ // CHECK: apply
+ // CHECK: br [[EPILOG_BB]]
+ foo()
+ break label3
+ foo() // expected-warning {{will never be executed}}
+ }
+ // CHECK: [[FALSE2]]:
+ // CHECK: br [[EPILOG_BB]]
+
+ // CHECK: [[EPILOG_BB]]:
+ // CHECK: return
+
+
+}
+
+
+// CHECK-LABEL: sil hidden @$S10statements13test_if_breakyySbF
+func test_if_break(_ a : Bool) {
+ // CHECK: br [[LOOP:bb[0-9]+]]
+ // CHECK: [[LOOP]]:
+ // CHECK: function_ref @$SSb21_getBuiltinLogicValue{{[_0-9a-zA-Z]*}}F
+ // CHECK-NEXT: apply
+ // CHECK-NEXT: cond_br {{.*}}, [[LOOPTRUE:bb[0-9]+]], [[OUT:bb[0-9]+]]
+ while a {
+ if a {
+ foo()
+ break // breaks out of while, not if.
+ }
+ foo()
+ }
+
+ // CHECK: [[LOOPTRUE]]:
+ // CHECK: function_ref @$SSb21_getBuiltinLogicValue{{[_0-9a-zA-Z]*}}F
+ // CHECK-NEXT: apply
+ // CHECK-NEXT: cond_br {{.*}}, [[IFTRUE:bb[0-9]+]], [[IFFALSE:bb[0-9]+]]
+
+ // [[IFTRUE]]:
+ // CHECK: function_ref statements.foo
+ // CHECK: br [[OUT]]
+
+ // CHECK: [[IFFALSE]]:
+ // CHECK: function_ref statements.foo
+ // CHECK: br [[LOOP]]
+
+ // CHECK: [[OUT]]:
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S10statements7test_doyyF
+func test_do() {
+ // CHECK: integer_literal $Builtin.Int2048, 0
+ // CHECK: [[BAR:%.*]] = function_ref @$S10statements3baryySiF
+ // CHECK: apply [[BAR]](
+ bar(0)
+ // CHECK-NOT: br bb
+ do {
+ // CHECK: [[CTOR:%.*]] = function_ref @$S10statements7MyClassC{{[_0-9a-zA-Z]*}}fC
+ // CHECK: [[OBJ:%.*]] = apply [[CTOR]](
+ let obj = MyClass()
+ _ = obj
+
+ // CHECK: integer_literal $Builtin.Int2048, 1
+ // CHECK: [[BAR:%.*]] = function_ref @$S10statements3baryySiF
+ // CHECK: apply [[BAR]](
+ bar(1)
+
+ // CHECK-NOT: br bb
+ // CHECK: destroy_value [[OBJ]]
+ // CHECK-NOT: br bb
+ }
+
+ // CHECK: integer_literal $Builtin.Int2048, 2
+ // CHECK: [[BAR:%.*]] = function_ref @$S10statements3baryySiF
+ // CHECK: apply [[BAR]](
+ bar(2)
+}
+
+// CHECK-LABEL: sil hidden @$S10statements15test_do_labeledyyF
+func test_do_labeled() {
+ // CHECK: integer_literal $Builtin.Int2048, 0
+ // CHECK: [[BAR:%.*]] = function_ref @$S10statements3baryySiF
+ // CHECK: apply [[BAR]](
+ bar(0)
+ // CHECK: br bb1
+ // CHECK: bb1:
+ lbl: do {
+ // CHECK: [[CTOR:%.*]] = function_ref @$S10statements7MyClassC{{[_0-9a-zA-Z]*}}fC
+ // CHECK: [[OBJ:%.*]] = apply [[CTOR]](
+ let obj = MyClass()
+ _ = obj
+
+ // CHECK: integer_literal $Builtin.Int2048, 1
+ // CHECK: [[BAR:%.*]] = function_ref @$S10statements3baryySiF
+ // CHECK: apply [[BAR]](
+ bar(1)
+
+ // CHECK: [[GLOBAL:%.*]] = function_ref @$S10statements11global_condSbvau
+ // CHECK: cond_br {{%.*}}, bb2, bb3
+ if (global_cond) {
+ // CHECK: bb2:
+ // CHECK: destroy_value [[OBJ]]
+ // CHECK: br bb1
+ continue lbl
+ }
+
+ // CHECK: bb3:
+ // CHECK: integer_literal $Builtin.Int2048, 2
+ // CHECK: [[BAR:%.*]] = function_ref @$S10statements3baryySiF
+ // CHECK: apply [[BAR]](
+ bar(2)
+
+ // CHECK: [[GLOBAL:%.*]] = function_ref @$S10statements11global_condSbvau
+ // CHECK: cond_br {{%.*}}, bb4, bb5
+ if (global_cond) {
+ // CHECK: bb4:
+ // CHECK: destroy_value [[OBJ]]
+ // CHECK: br bb6
+ break lbl
+ }
+
+ // CHECK: bb5:
+ // CHECK: integer_literal $Builtin.Int2048, 3
+ // CHECK: [[BAR:%.*]] = function_ref @$S10statements3baryySiF
+ // CHECK: apply [[BAR]](
+ bar(3)
+
+ // CHECK: destroy_value [[OBJ]]
+ // CHECK: br bb6
+ }
+
+ // CHECK: integer_literal $Builtin.Int2048, 4
+ // CHECK: [[BAR:%.*]] = function_ref @$S10statements3baryySiF
+ // CHECK: apply [[BAR]](
+ bar(4)
+}
+
+
+func callee1() {}
+func callee2() {}
+func callee3() {}
+
+// CHECK-LABEL: sil hidden @$S10statements11defer_test1yyF
+func defer_test1() {
+ defer { callee1() }
+ defer { callee2() }
+ callee3()
+
+ // CHECK: [[C3:%.*]] = function_ref @$S10statements7callee3yyF
+ // CHECK: apply [[C3]]
+ // CHECK: [[C2:%.*]] = function_ref @$S10statements11defer_test1yyF6
+ // CHECK: apply [[C2]]
+ // CHECK: [[C1:%.*]] = function_ref @$S10statements11defer_test1yyF6
+ // CHECK: apply [[C1]]
+}
+// CHECK: sil private @$S10statements11defer_test1yyF6
+// CHECK: function_ref @{{.*}}callee1yyF
+
+// CHECK: sil private @$S10statements11defer_test1yyF6
+// CHECK: function_ref @{{.*}}callee2yyF
+
+// CHECK-LABEL: sil hidden @$S10statements11defer_test2yySbF
+func defer_test2(_ cond : Bool) {
+ // CHECK: [[C3:%.*]] = function_ref @{{.*}}callee3yyF
+ // CHECK: apply [[C3]]
+ // CHECK: br [[LOOP:bb[0-9]+]]
+ callee3()
+
+// CHECK: [[LOOP]]:
+// test the condition.
+// CHECK: [[CONDTRUE:%.*]] = apply {{.*}}(%0)
+// CHECK: cond_br [[CONDTRUE]], [[BODY:bb[0-9]+]], [[EXIT:bb[0-9]+]]
+ while cond {
+// CHECK: [[BODY]]:
+ // CHECK: [[C2:%.*]] = function_ref @{{.*}}callee2yyF
+ // CHECK: apply [[C2]]
+
+ // CHECK: [[C1:%.*]] = function_ref @$S10statements11defer_test2yySbF6
+ // CHECK: apply [[C1]]
+ // CHECK: br [[EXIT]]
+ defer { callee1() }
+ callee2()
+ break
+ }
+
+// CHECK: [[EXIT]]:
+// CHECK: [[C3:%.*]] = function_ref @{{.*}}callee3yyF
+// CHECK: apply [[C3]]
+
+ callee3()
+}
+
+func generic_callee_1<T>(_: T) {}
+func generic_callee_2<T>(_: T) {}
+func generic_callee_3<T>(_: T) {}
+
+// CHECK-LABEL: sil hidden @$S10statements16defer_in_generic{{[_0-9a-zA-Z]*}}F
+func defer_in_generic<T>(_ x: T) {
+ // CHECK: [[C3:%.*]] = function_ref @$S10statements16generic_callee_3{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply [[C3]]<T>
+ // CHECK: [[C2:%.*]] = function_ref @$S10statements16defer_in_genericyyxlF6
+ // CHECK: apply [[C2]]<T>
+ // CHECK: [[C1:%.*]] = function_ref @$S10statements16defer_in_genericyyxlF6
+ // CHECK: apply [[C1]]<T>
+ defer { generic_callee_1(x) }
+ defer { generic_callee_2(x) }
+ generic_callee_3(x)
+}
+
+// CHECK-LABEL: sil hidden @$S10statements017defer_in_closure_C8_genericyyxlF : $@convention(thin) <T> (@in_guaranteed T) -> ()
+func defer_in_closure_in_generic<T>(_ x: T) {
+ // CHECK-LABEL: sil private @$S10statements017defer_in_closure_C8_genericyyxlFyycfU_ : $@convention(thin) <T> () -> ()
+ _ = {
+ // CHECK-LABEL: sil private @$S10statements017defer_in_closure_C8_genericyyxlFyycfU_6$deferL_yylF : $@convention(thin) <T> () -> ()
+ defer { generic_callee_1(T.self) }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10statements13defer_mutableyySiF
+func defer_mutable(_ x: Int) {
+ var x = x
+ // CHECK: [[BOX:%.*]] = alloc_box ${ var Int }
+ // CHECK-NEXT: project_box [[BOX]]
+ // CHECK-NOT: [[BOX]]
+ // CHECK: function_ref @$S10statements13defer_mutableyySiF6$deferL_yyF : $@convention(thin) (@inout_aliasable Int) -> ()
+ // CHECK-NOT: [[BOX]]
+ // CHECK: destroy_value [[BOX]]
+ defer { _ = x }
+}
+
+protocol StaticFooProtocol { static func foo() }
+
+func testDeferOpenExistential(_ b: Bool, type: StaticFooProtocol.Type) {
+ defer { type.foo() }
+ if b { return }
+ return
+}
+
+
+
+
+// CHECK-LABEL: sil hidden @$S10statements22testRequireExprPatternyySiF
+
+func testRequireExprPattern(_ a : Int) {
+ marker_1()
+ // CHECK: [[M1:%[0-9]+]] = function_ref @$S10statements8marker_1yyF : $@convention(thin) () -> ()
+ // CHECK-NEXT: apply [[M1]]() : $@convention(thin) () -> ()
+
+ // CHECK: function_ref Swift.~= infix<A where A: Swift.Equatable>(A, A) -> Swift.Bool
+ // CHECK: cond_br {{.*}}, bb1, bb2
+ guard case 4 = a else { marker_2(); return }
+
+ // Fall through case comes first.
+
+ // CHECK: bb1:
+ // CHECK: [[M3:%[0-9]+]] = function_ref @$S10statements8marker_3yyF : $@convention(thin) () -> ()
+ // CHECK-NEXT: apply [[M3]]() : $@convention(thin) () -> ()
+ // CHECK-NEXT: br bb3
+ marker_3()
+
+ // CHECK: bb2:
+ // CHECK: [[M2:%[0-9]+]] = function_ref @$S10statements8marker_2yyF : $@convention(thin) () -> ()
+ // CHECK-NEXT: apply [[M2]]() : $@convention(thin) () -> ()
+ // CHECK-NEXT: br bb3
+
+ // CHECK: bb3:
+ // CHECK-NEXT: tuple ()
+ // CHECK-NEXT: return
+}
+
+
+// CHECK-LABEL: sil hidden @$S10statements20testRequireOptional1yS2iSgF
+// CHECK: bb0([[ARG:%.*]] : @trivial $Optional<Int>):
+// CHECK-NEXT: debug_value [[ARG]] : $Optional<Int>, let, name "a"
+// CHECK-NEXT: switch_enum [[ARG]] : $Optional<Int>, case #Optional.some!enumelt.1: [[SOME:bb[0-9]+]], case #Optional.none!enumelt: [[NONE:bb[0-9]+]]
+func testRequireOptional1(_ a : Int?) -> Int {
+
+ // CHECK: [[NONE]]:
+ // CHECK: br [[ABORT:bb[0-9]+]]
+
+ // CHECK: [[SOME]]([[PAYLOAD:%.*]] : @trivial $Int):
+ // CHECK-NEXT: debug_value [[PAYLOAD]] : $Int, let, name "t"
+ // CHECK-NEXT: br [[EPILOG:bb[0-9]+]]
+ //
+ // CHECK: [[EPILOG]]:
+ // CHECK-NEXT: return [[PAYLOAD]] : $Int
+ guard let t = a else { abort() }
+
+ // CHECK: [[ABORT]]:
+ // CHECK-NEXT: // function_ref statements.abort() -> Swift.Never
+ // CHECK-NEXT: [[FUNC_REF:%.*]] = function_ref @$S10statements5aborts5NeverOyF
+ // CHECK-NEXT: apply [[FUNC_REF]]() : $@convention(thin) () -> Never
+ // CHECK-NEXT: unreachable
+ return t
+}
+
+// CHECK-LABEL: sil hidden @$S10statements20testRequireOptional2yS2SSgF
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $Optional<String>):
+// CHECK-NEXT: debug_value [[ARG]] : $Optional<String>, let, name "a"
+// CHECK-NEXT: [[ARG_COPY:%.*]] = copy_value [[ARG]] : $Optional<String>
+// CHECK-NEXT: switch_enum [[ARG_COPY]] : $Optional<String>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+func testRequireOptional2(_ a : String?) -> String {
+ guard let t = a else { abort() }
+
+ // CHECK: [[NONE_BB]]:
+ // CHECK-NEXT: br [[ABORT_BB:bb[0-9]+]]
+
+ // CHECK: [[SOME_BB]]([[STR:%.*]] : @owned $String):
+ // CHECK-NEXT: debug_value [[STR]] : $String, let, name "t"
+ // CHECK-NEXT: br [[CONT_BB:bb[0-9]+]]
+ // CHECK: [[CONT_BB]]:
+ // CHECK-NEXT: [[BORROWED_STR:%.*]] = begin_borrow [[STR]]
+ // CHECK-NEXT: [[RETURN:%.*]] = copy_value [[BORROWED_STR]]
+ // CHECK-NEXT: end_borrow [[BORROWED_STR]] from [[STR]]
+ // CHECK-NEXT: destroy_value [[STR]] : $String
+ // CHECK-NEXT: return [[RETURN]] : $String
+
+ // CHECK: [[ABORT_BB]]:
+ // CHECK-NEXT: // function_ref statements.abort() -> Swift.Never
+ // CHECK-NEXT: [[ABORT_FUNC:%.*]] = function_ref @$S10statements5aborts5NeverOyF
+ // CHECK-NEXT: [[NEVER:%.*]] = apply [[ABORT_FUNC]]()
+ // CHECK-NEXT: unreachable
+ return t
+}
+
+
+// CHECK-LABEL: sil hidden @$S10statements19testCleanupEmission{{[_0-9a-zA-Z]*}}F
+// <rdar://problem/20563234> let-else problem: cleanups for bound patterns shouldn't be run in the else block
+protocol MyProtocol {}
+func testCleanupEmission<T>(_ x: T) {
+ // SILGen shouldn't crash/verify abort on this example.
+ guard let x2 = x as? MyProtocol else { return }
+ _ = x2
+}
+
+
+// CHECK-LABEL: sil hidden @$S10statements15test_is_patternyyAA9BaseClassCF
+func test_is_pattern(_ y : BaseClass) {
+ // checked_cast_br %0 : $BaseClass to $DerivedClass
+ guard case is DerivedClass = y else { marker_1(); return }
+
+ marker_2()
+}
+
+// CHECK-LABEL: sil hidden @$S10statements15test_as_patternyAA12DerivedClassCAA04BaseF0CF
+func test_as_pattern(_ y : BaseClass) -> DerivedClass {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $BaseClass):
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: checked_cast_br [[ARG_COPY]] : $BaseClass to $DerivedClass
+ guard case let result as DerivedClass = y else { }
+ // CHECK: bb{{.*}}({{.*}} : @owned $DerivedClass):
+
+
+ // CHECK: bb{{.*}}([[PTR:%[0-9]+]] : @owned $DerivedClass):
+ // CHECK-NEXT: debug_value [[PTR]] : $DerivedClass, let, name "result"
+ // CHECK-NEXT: br [[CONT_BB:bb[0-9]+]]
+ // CHECK: [[CONT_BB]]:
+ // CHECK-NEXT: [[BORROWED_PTR:%.*]] = begin_borrow [[PTR]]
+ // CHECK-NEXT: [[RESULT:%.*]] = copy_value [[BORROWED_PTR]]
+ // CHECK-NEXT: end_borrow [[BORROWED_PTR]] from [[PTR]]
+ // CHECK-NEXT: destroy_value [[PTR]] : $DerivedClass
+ // CHECK-NEXT: return [[RESULT]] : $DerivedClass
+ return result
+}
+// CHECK-LABEL: sil hidden @$S10statements22let_else_tuple_bindingyS2i_SitSgF
+func let_else_tuple_binding(_ a : (Int, Int)?) -> Int {
+
+ // CHECK: bb0([[ARG:%.*]] : @trivial $Optional<(Int, Int)>):
+ // CHECK-NEXT: debug_value [[ARG]] : $Optional<(Int, Int)>, let, name "a"
+ // CHECK-NEXT: switch_enum [[ARG]] : $Optional<(Int, Int)>, case #Optional.some!enumelt.1: [[SOME_BB:bb[0-9]+]], case #Optional.none!enumelt: [[NONE_BB:bb[0-9]+]]
+
+ guard let (x, y) = a else { }
+ _ = y
+ return x
+
+ // CHECK: [[SOME_BB]]([[PAYLOAD:%.*]] : @trivial $(Int, Int)):
+ // CHECK-NEXT: [[PAYLOAD_1:%.*]] = tuple_extract [[PAYLOAD]] : $(Int, Int), 0
+ // CHECK-NEXT: debug_value [[PAYLOAD_1]] : $Int, let, name "x"
+ // CHECK-NEXT: [[PAYLOAD_2:%.*]] = tuple_extract [[PAYLOAD]] : $(Int, Int), 1
+ // CHECK-NEXT: debug_value [[PAYLOAD_2]] : $Int, let, name "y"
+ // CHECK-NEXT: br [[CONT_BB:bb[0-9]+]]
+ // CHECK: [[CONT_BB]]:
+ // CHECK-NEXT: return [[PAYLOAD_1]] : $Int
+}
+
diff --git a/test/SILGen/plus_zero_struct_resilience.swift b/test/SILGen/plus_zero_struct_resilience.swift
new file mode 100644
index 0000000..b11d502
--- /dev/null
+++ b/test/SILGen/plus_zero_struct_resilience.swift
@@ -0,0 +1,284 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_struct.swiftmodule -enable-sil-ownership -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
+// RUN: %target-swift-frontend -I %t -enable-sil-ownership -emit-silgen -enable-resilience %s | %FileCheck %s
+
+import resilient_struct
+
+// Resilient structs are always address-only
+
+// CHECK-LABEL: sil hidden @$S17struct_resilience26functionWithResilientTypes_1f010resilient_A04SizeVAF_A2FXEtF : $@convention(thin) (@in_guaranteed Size, @noescape @callee_guaranteed (@in_guaranteed Size) -> @out Size) -> @out Size
+// CHECK: bb0(%0 : @trivial $*Size, %1 : @trivial $*Size, %2 : @trivial $@noescape @callee_guaranteed (@in_guaranteed Size) -> @out Size):
+func functionWithResilientTypes(_ s: Size, f: (Size) -> Size) -> Size {
+
+ // Stored properties of resilient structs from outside our resilience
+ // domain are accessed through accessors
+
+// CHECK: copy_addr %1 to [initialization] [[OTHER_SIZE_BOX:%[0-9]*]] : $*Size
+ var s2 = s
+
+// CHECK: copy_addr %1 to [initialization] [[SIZE_BOX:%.*]] : $*Size
+// CHECK: [[GETTER:%.*]] = function_ref @$S16resilient_struct4SizeV1wSivg : $@convention(method) (@in_guaranteed Size) -> Int
+// CHECK: [[RESULT:%.*]] = apply [[GETTER]]([[SIZE_BOX]])
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[OTHER_SIZE_BOX]] : $*Size
+// CHECK: [[SETTER:%.*]] = function_ref @$S16resilient_struct4SizeV1wSivs : $@convention(method) (Int, @inout Size) -> ()
+// CHECK: apply [[SETTER]]([[RESULT]], [[WRITE]])
+ s2.w = s.w
+
+// CHECK: copy_addr %1 to [initialization] [[SIZE_BOX:%.*]] : $*Size
+// CHECK: [[FN:%.*]] = function_ref @$S16resilient_struct4SizeV1hSivg : $@convention(method) (@in_guaranteed Size) -> Int
+// CHECK: [[RESULT:%.*]] = apply [[FN]]([[SIZE_BOX]])
+ _ = s.h
+
+// CHECK: apply %2(%0, %1)
+// CHECK-NOT: destroy_value %2
+// CHECK: return
+ return f(s)
+}
+
+// Use materializeForSet for inout access of properties in resilient structs
+// from a different resilience domain
+
+public func inoutFunc(_ x: inout Int) {}
+
+// CHECK-LABEL: sil hidden @$S17struct_resilience18resilientInOutTestyy0c1_A04SizeVzF : $@convention(thin) (@inout Size) -> ()
+
+func resilientInOutTest(_ s: inout Size) {
+
+// CHECK: function_ref @$S16resilient_struct4SizeV1wSivm
+// CHECK: function_ref @$S17struct_resilience9inoutFuncyySizF
+
+ inoutFunc(&s.w)
+
+// CHECK: return
+}
+
+// Fixed-layout structs may be trivial or loadable
+
+// CHECK-LABEL: sil hidden @$S17struct_resilience28functionWithFixedLayoutTypes_1f010resilient_A05PointVAF_A2FXEtF : $@convention(thin) (Point, @noescape @callee_guaranteed (Point) -> Point) -> Point
+// CHECK: bb0(%0 : @trivial $Point, %1 : @trivial $@noescape @callee_guaranteed (Point) -> Point):
+func functionWithFixedLayoutTypes(_ p: Point, f: (Point) -> Point) -> Point {
+
+ // Stored properties of fixed layout structs are accessed directly
+ var p2 = p
+
+// CHECK: [[RESULT:%.*]] = struct_extract %0 : $Point, #Point.x
+// CHECK: [[DEST:%.*]] = struct_element_addr [[POINT_BOX:%[0-9]*]] : $*Point, #Point.x
+// CHECK: assign [[RESULT]] to [[DEST]] : $*Int
+ p2.x = p.x
+
+// CHECK: [[RESULT:%.*]] = struct_extract %0 : $Point, #Point.y
+ _ = p.y
+
+// CHECK: [[NEW_POINT:%.*]] = apply %1(%0)
+// CHECK: return [[NEW_POINT]]
+ return f(p)
+}
+
+// Fixed-layout struct with resilient stored properties is still address-only
+
+// CHECK-LABEL: sil hidden @$S17struct_resilience39functionWithFixedLayoutOfResilientTypes_1f010resilient_A09RectangleVAF_A2FXEtF : $@convention(thin) (@in_guaranteed Rectangle, @noescape @callee_guaranteed (@in_guaranteed Rectangle) -> @out Rectangle) -> @out Rectangle
+// CHECK: bb0(%0 : @trivial $*Rectangle, %1 : @trivial $*Rectangle, %2 : @trivial $@noescape @callee_guaranteed (@in_guaranteed Rectangle) -> @out Rectangle):
+func functionWithFixedLayoutOfResilientTypes(_ r: Rectangle, f: (Rectangle) -> Rectangle) -> Rectangle {
+ return f(r)
+}
+
+// Make sure we generate getters and setters for stored properties of
+// resilient structs
+
+public struct MySize {
+
+ // Static computed property
+
+// CHECK-LABEL: sil @$S17struct_resilience6MySizeV10expirationSivgZ : $@convention(method) (@thin MySize.Type) -> Int
+// CHECK-LABEL: sil @$S17struct_resilience6MySizeV10expirationSivsZ : $@convention(method) (Int, @thin MySize.Type) -> ()
+// CHECK-LABEL: sil @$S17struct_resilience6MySizeV10expirationSivmZ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @thin MySize.Type) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ public static var expiration: Int {
+ get { return copyright + 70 }
+ set { copyright = newValue - 70 }
+ }
+
+ // Instance computed property
+
+// CHECK-LABEL: sil @$S17struct_resilience6MySizeV1dSivg : $@convention(method) (@in_guaranteed MySize) -> Int
+// CHECK-LABEL: sil @$S17struct_resilience6MySizeV1dSivs : $@convention(method) (Int, @inout MySize) -> ()
+// CHECK-LABEL: sil @$S17struct_resilience6MySizeV1dSivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout MySize) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ public var d: Int {
+ get { return 0 }
+ set { }
+ }
+
+ // Instance stored property
+
+// CHECK-LABEL: sil @$S17struct_resilience6MySizeV1wSivg : $@convention(method) (@in_guaranteed MySize) -> Int
+// CHECK-LABEL: sil @$S17struct_resilience6MySizeV1wSivs : $@convention(method) (Int, @inout MySize) -> ()
+// CHECK-LABEL: sil @$S17struct_resilience6MySizeV1wSivm : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout MySize) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ public var w: Int
+
+ // Read-only instance stored property
+
+// CHECK-LABEL: sil @$S17struct_resilience6MySizeV1hSivg : $@convention(method) (@in_guaranteed MySize) -> Int
+ public let h: Int
+
+ // Static stored property
+
+// CHECK-LABEL: sil @$S17struct_resilience6MySizeV9copyrightSivgZ : $@convention(method) (@thin MySize.Type) -> Int
+// CHECK-LABEL: sil @$S17struct_resilience6MySizeV9copyrightSivsZ : $@convention(method) (Int, @thin MySize.Type) -> ()
+// CHECK-LABEL: sil @$S17struct_resilience6MySizeV9copyrightSivmZ : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @thin MySize.Type) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ public static var copyright: Int = 0
+}
+
+// CHECK-LABEL: sil @$S17struct_resilience28functionWithMyResilientTypes_1fAA0E4SizeVAE_A2EXEtF : $@convention(thin) (@in_guaranteed MySize, @noescape @callee_guaranteed (@in_guaranteed MySize) -> @out MySize) -> @out MySize
+public func functionWithMyResilientTypes(_ s: MySize, f: (MySize) -> MySize) -> MySize {
+
+ // Stored properties of resilient structs from inside our resilience
+ // domain are accessed directly
+
+// CHECK: copy_addr %1 to [initialization] [[SIZE_BOX:%[0-9]*]] : $*MySize
+ var s2 = s
+
+// CHECK: [[SRC_ADDR:%.*]] = struct_element_addr %1 : $*MySize, #MySize.w
+// CHECK: [[SRC:%.*]] = load [trivial] [[SRC_ADDR]] : $*Int
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[SIZE_BOX]] : $*MySize
+// CHECK: [[DEST_ADDR:%.*]] = struct_element_addr [[WRITE]] : $*MySize, #MySize.w
+// CHECK: assign [[SRC]] to [[DEST_ADDR]] : $*Int
+ s2.w = s.w
+
+// CHECK: [[RESULT_ADDR:%.*]] = struct_element_addr %1 : $*MySize, #MySize.h
+// CHECK: [[RESULT:%.*]] = load [trivial] [[RESULT_ADDR]] : $*Int
+ _ = s.h
+
+// CHECK: apply %2(%0, %1)
+// CHECK-NOT: destroy_value %2
+// CHECK: return
+ return f(s)
+}
+
+// CHECK-LABEL: sil [transparent] [serialized] @$S17struct_resilience25publicTransparentFunctionySiAA6MySizeVF : $@convention(thin) (@in_guaranteed MySize) -> Int
+@_transparent public func publicTransparentFunction(_ s: MySize) -> Int {
+
+ // Since the body of a public transparent function might be inlined into
+ // other resilience domains, we have to use accessors
+
+// CHECK: [[SELF:%.*]] = alloc_stack $MySize
+// CHECK-NEXT: copy_addr %0 to [initialization] [[SELF]]
+
+// CHECK: [[GETTER:%.*]] = function_ref @$S17struct_resilience6MySizeV1wSivg
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[GETTER]]([[SELF]])
+// CHECK-NEXT: destroy_addr [[SELF]]
+// CHECK-NEXT: dealloc_stack [[SELF]]
+// CHECK-NEXT: return [[RESULT]]
+ return s.w
+}
+
+// CHECK-LABEL: sil [transparent] [serialized] @$S17struct_resilience30publicTransparentLocalFunctionySiycAA6MySizeVF : $@convention(thin) (@in_guaranteed MySize) -> @owned @callee_guaranteed () -> Int
+@_transparent public func publicTransparentLocalFunction(_ s: MySize) -> () -> Int {
+
+// CHECK-LABEL: sil shared [serialized] @$S17struct_resilience30publicTransparentLocalFunctionySiycAA6MySizeVFSiycfU_ : $@convention(thin) (@guaranteed { var MySize }) -> Int
+// CHECK: function_ref @$S17struct_resilience6MySizeV1wSivg : $@convention(method) (@in_guaranteed MySize) -> Int
+// CHECK: return {{.*}} : $Int
+
+ return { s.w }
+
+}
+
+// CHECK-LABEL: sil hidden [transparent] @$S17struct_resilience27internalTransparentFunctionySiAA6MySizeVF : $@convention(thin) (@in_guaranteed MySize) -> Int
+// CHECK: bb0([[ARG:%.*]] : @trivial $*MySize):
+@_transparent func internalTransparentFunction(_ s: MySize) -> Int {
+
+ // The body of an internal transparent function will not be inlined into
+ // other resilience domains, so we can access storage directly
+
+// CHECK: [[W_ADDR:%.*]] = struct_element_addr [[ARG]] : $*MySize, #MySize.w
+// CHECK-NEXT: [[RESULT:%.*]] = load [trivial] [[W_ADDR]] : $*Int
+// CHECK-NEXT: return [[RESULT]]
+ return s.w
+}
+
+// CHECK-LABEL: sil [serialized] [always_inline] @$S17struct_resilience26publicInlineAlwaysFunctionySiAA6MySizeVF : $@convention(thin) (@in_guaranteed MySize) -> Int
+@inline(__always) public func publicInlineAlwaysFunction(_ s: MySize) -> Int {
+
+ // Since the body of a public transparent function might be inlined into
+ // other resilience domains, we have to use accessors
+
+// CHECK: [[SELF:%.*]] = alloc_stack $MySize
+// CHECK-NEXT: copy_addr %0 to [initialization] [[SELF]]
+
+// CHECK: [[GETTER:%.*]] = function_ref @$S17struct_resilience6MySizeV1wSivg
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[GETTER]]([[SELF]])
+// CHECK-NEXT: destroy_addr [[SELF]]
+// CHECK-NEXT: dealloc_stack [[SELF]]
+// CHECK-NEXT: return [[RESULT]]
+ return s.w
+
+}
+
+// Make sure that @_versioned entities can be resilient
+
+@_versioned struct VersionedResilientStruct {
+ @_versioned let x: Int
+ @_versioned let y: Int
+
+ @_versioned init(x: Int, y: Int) {
+ self.x = x
+ self.y = y
+ }
+
+ // Non-inlineable initializer, assigns to self -- treated as a root initializer
+
+ // CHECK-LABEL: sil @$S17struct_resilience24VersionedResilientStructV5otherA2C_tcfC : $@convention(method) (@in VersionedResilientStruct, @thin VersionedResilientStruct.Type) -> @out VersionedResilientStruct
+ // CHECK: [[SELF_BOX:%.*]] = alloc_box ${ var VersionedResilientStruct }
+ // CHECK-NEXT: [[SELF_UNINIT:%.*]] = mark_uninitialized [rootself] [[SELF_BOX]]
+ // CHECK: return
+ @_versioned init(other: VersionedResilientStruct) {
+ self = other
+ }
+
+ // Inlineable initializer, assigns to self -- treated as a delegating initializer
+
+ // CHECK-LABEL: sil [serialized] @$S17struct_resilience24VersionedResilientStructV6other2A2C_tcfC : $@convention(method) (@in VersionedResilientStruct, @thin VersionedResilientStruct.Type) -> @out VersionedResilientStruct
+ // CHECK: [[SELF_BOX:%.*]] = alloc_box ${ var VersionedResilientStruct }
+ // CHECK-NEXT: [[SELF_UNINIT:%.*]] = mark_uninitialized [delegatingself] [[SELF_BOX]]
+ // CHECK: return
+ @_versioned @_inlineable init(other2: VersionedResilientStruct) {
+ self = other2
+ }
+}
+
+// CHECK-LABEL: sil [transparent] [serialized] @$S17struct_resilience27useVersionedResilientStructyAA0deF0VADF : $@convention(thin) (@in_guaranteed VersionedResilientStruct) -> @out VersionedResilientStruct
+@_versioned
+@_transparent func useVersionedResilientStruct(_ s: VersionedResilientStruct)
+ -> VersionedResilientStruct {
+ // CHECK: function_ref @$S17struct_resilience24VersionedResilientStructV1ySivg
+ // CHECK: function_ref @$S17struct_resilience24VersionedResilientStructV1xSivg
+ // CHECK: function_ref @$S17struct_resilience24VersionedResilientStructV1x1yACSi_SitcfC
+
+ return VersionedResilientStruct(x: s.y, y: s.x)
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil [serialized] @$S17struct_resilience19inlineableInoutTestyyAA6MySizeVzF : $@convention(thin) (@inout MySize) -> ()
+@_inlineable public func inlineableInoutTest(_ s: inout MySize) {
+ // Inlineable functions can be inlined in other resiliene domains.
+ //
+ // Make sure we use materializeForSet for an inout access of a resilient struct
+ // property inside an inlinable function.
+
+ // CHECK: function_ref @$S17struct_resilience6MySizeV1wSivm
+ inoutFunc(&s.w)
+
+ // CHECK: return
+}
+
+// Initializers for resilient structs
+extension Size {
+
+ // CHECK-LABEL: sil hidden @$S16resilient_struct4SizeV0B11_resilienceE5otherA2C_tcfC : $@convention(method) (@in Size, @thin Size.Type) -> @out Size
+ // CHECK: [[SELF_BOX:%.*]] = alloc_box ${ var Size }
+ // CHECK-NEXT: [[SELF_UNINIT:%.*]] = mark_uninitialized [delegatingself] [[SELF_BOX]] : ${ var Size }
+ // CHECK: return
+ init(other: Size) {
+ self = other
+ }
+}
diff --git a/test/SILGen/plus_zero_subclass_existentials.swift b/test/SILGen/plus_zero_subclass_existentials.swift
new file mode 100644
index 0000000..0189ede
--- /dev/null
+++ b/test/SILGen/plus_zero_subclass_existentials.swift
@@ -0,0 +1,469 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -parse-as-library -primary-file %s -verify | %FileCheck %s
+// RUN: %target-swift-frontend -emit-ir -parse-as-library -primary-file %s
+
+// Note: we pass -verify above to ensure there are no spurious
+// compiler warnings relating to casts.
+
+protocol Q {}
+
+class Base<T> : Q {
+ required init(classInit: ()) {}
+ func classSelfReturn() -> Self {
+ return self
+ }
+ static func classSelfReturn() -> Self {
+ return self.init(classInit: ())
+ }
+}
+
+protocol P {
+ init(protocolInit: ())
+ func protocolSelfReturn() -> Self
+ static func protocolSelfReturn() -> Self
+}
+
+class Derived : Base<Int>, P {
+ required init(protocolInit: ()) {
+ super.init(classInit: ())
+ }
+
+ required init(classInit: ()) {
+ super.init(classInit: ())
+ }
+
+ func protocolSelfReturn() -> Self {
+ return self
+ }
+ static func protocolSelfReturn() -> Self {
+ return self.init(classInit: ())
+ }
+}
+
+protocol R {}
+
+// CHECK-LABEL: sil hidden @$S21subclass_existentials11conversions8baseAndP7derived0fE1R0dE5PType0F4Type0fE5RTypeyAA1P_AA4BaseCySiGXc_AA7DerivedCAA1R_ANXcAaI_ALXcXpANmAaO_ANXcXptF : $@convention(thin) (@guaranteed Base<Int> & P, @guaranteed Derived, @guaranteed Derived & R, @thick (Base<Int> & P).Type, @thick Derived.Type, @thick (Derived & R).Type) -> () {
+// CHECK: bb0([[ARG0:%.*]] : $Base<Int> & P,
+
+func conversions(
+ baseAndP: Base<Int> & P,
+ derived: Derived,
+ derivedAndR: Derived & R,
+
+ baseAndPType: (Base<Int> & P).Type,
+ derivedType: Derived.Type,
+ derivedAndRType: (Derived & R).Type) {
+
+ // Values
+
+ // CHECK: [[PAYLOAD:%.*]] = open_existential_ref [[ARG0]] : $Base<Int> & P
+ // CHECK: [[REF:%.*]] = copy_value [[PAYLOAD]]
+ // CHECK: [[BASE:%.*]] = upcast [[REF]] : $@opened("{{.*}}") Base<Int> & P to $Base<Int>
+ // CHECK: destroy_value [[BASE]] : $Base<Int>
+ let _: Base<Int> = baseAndP
+
+ // CHECK: [[PAYLOAD:%.*]] = open_existential_ref [[ARG0]] : $Base<Int> & P
+ // CHECK: [[RESULT:%.*]] = alloc_stack $P
+ // CHECK: [[RESULT_PAYLOAD:%.*]] = init_existential_addr [[RESULT]] : $*P, $@opened("{{.*}}") Base<Int> & P
+ // CHECK: [[REF:%.*]] = copy_value [[PAYLOAD]]
+ // CHECK: store [[REF]] to [init] [[RESULT_PAYLOAD]]
+ // CHECK: destroy_addr [[RESULT]] : $*P
+ // CHECK: dealloc_stack [[RESULT]] : $*P
+ let _: P = baseAndP
+
+ // CHECK: [[PAYLOAD:%.*]] = open_existential_ref [[ARG0]] : $Base<Int> & P
+ // CHECK: [[RESULT:%.*]] = alloc_stack $Q
+ // CHECK: [[RESULT_PAYLOAD:%.*]] = init_existential_addr [[RESULT]] : $*Q, $@opened("{{.*}}") Base<Int> & P
+ // CHECK: [[REF:%.*]] = copy_value [[PAYLOAD]]
+ // CHECK: store [[REF]] to [init] [[RESULT_PAYLOAD]]
+ // CHECK: destroy_addr [[RESULT]] : $*Q
+ // CHECK: dealloc_stack [[RESULT]] : $*Q
+ let _: Q = baseAndP
+
+ // CHECK: [[PAYLOAD:%.*]] = open_existential_ref [[ARG2:%.*]] : $Derived & R
+ // CHECK: [[REF:%.*]] = copy_value [[PAYLOAD]]
+ // CHECK: [[RESULT:%.*]] = init_existential_ref [[REF]] : $@opened("{{.*}}") Derived & R : $@opened("{{.*}}") Derived & R, $Base<Int> & P
+ // CHECK: destroy_value [[RESULT]]
+ let _: Base<Int> & P = derivedAndR
+
+ // Metatypes
+
+ // CHECK: [[PAYLOAD:%.*]] = open_existential_metatype %3 : $@thick (Base<Int> & P).Type to $@thick (@opened("{{.*}}") (Base<Int> & P)).Type
+ // CHECK: [[RESULT:%.*]] = upcast [[PAYLOAD]] : $@thick (@opened("{{.*}}") (Base<Int> & P)).Type to $@thick Base<Int>.Type
+ let _: Base<Int>.Type = baseAndPType
+
+ // CHECK: [[PAYLOAD:%.*]] = open_existential_metatype %3 : $@thick (Base<Int> & P).Type to $@thick (@opened("{{.*}}") (Base<Int> & P)).Type
+ // CHECK: [[RESULT:%.*]] = init_existential_metatype [[PAYLOAD]] : $@thick (@opened("{{.*}}") (Base<Int> & P)).Type, $@thick P.Type
+ let _: P.Type = baseAndPType
+
+ // CHECK: [[PAYLOAD:%.*]] = open_existential_metatype %3 : $@thick (Base<Int> & P).Type to $@thick (@opened("{{.*}}") (Base<Int> & P)).Type
+ // CHECK: [[RESULT:%.*]] = init_existential_metatype [[PAYLOAD]] : $@thick (@opened("{{.*}}") (Base<Int> & P)).Type, $@thick Q.Type
+ let _: Q.Type = baseAndPType
+
+ // CHECK: [[RESULT:%.*]] = init_existential_metatype %4 : $@thick Derived.Type, $@thick (Base<Int> & P).Type
+ let _: (Base<Int> & P).Type = derivedType
+
+ // CHECK: [[PAYLOAD:%.*]] = open_existential_metatype %5 : $@thick (Derived & R).Type to $@thick (@opened("{{.*}}") (Derived & R)).Type
+ // CHECK: [[RESULT:%.*]] = init_existential_metatype [[PAYLOAD]] : $@thick (@opened("{{.*}}") (Derived & R)).Type, $@thick (Base<Int> & P).Type
+ let _: (Base<Int> & P).Type = derivedAndRType
+
+ // CHECK: return
+}
+
+// CHECK-LABEL: sil hidden @$S21subclass_existentials11methodCalls8baseAndP0eF5PTypeyAA1P_AA4BaseCySiGXc_AaE_AHXcXptF : $@convention(thin) (@guaranteed Base<Int> & P, @thick (Base<Int> & P).Type) -> () {
+
+func methodCalls(
+ baseAndP: Base<Int> & P,
+ baseAndPType: (Base<Int> & P).Type) {
+ // CHECK: bb0([[ARG0:%.*]] : $Base<Int> & P,
+ // CHECK: [[PAYLOAD:%.*]] = open_existential_ref [[ARG0]] : $Base<Int> & P to $@opened("{{.*}}") Base<Int> & P
+ // CHECK: [[REF:%.*]] = copy_value [[PAYLOAD]] : $@opened("{{.*}}") Base<Int> & P
+ // CHECK: [[CLASS_REF:%.*]] = upcast [[REF]] : $@opened("{{.*}}") Base<Int> & P to $Base<Int>
+ // CHECK: [[METHOD:%.*]] = class_method [[CLASS_REF]] : $Base<Int>, #Base.classSelfReturn!1 : <T> (Base<T>) -> () -> @dynamic_self Base<T>, $@convention(method) <τ_0_0> (@guaranteed Base<τ_0_0>) -> @owned Base<τ_0_0>
+ // CHECK: [[RESULT_CLASS_REF:%.*]] = apply [[METHOD]]<Int>([[CLASS_REF]]) : $@convention(method) <τ_0_0> (@guaranteed Base<τ_0_0>) -> @owned Base<τ_0_0>
+ // CHECK: destroy_value [[CLASS_REF]] : $Base<Int>
+ // CHECK: [[RESULT_REF:%.*]] = unchecked_ref_cast [[RESULT_CLASS_REF]] : $Base<Int> to $@opened("{{.*}}") Base<Int> & P
+ // CHECK: [[RESULT:%.*]] = init_existential_ref [[RESULT_REF]] : $@opened("{{.*}}") Base<Int> & P : $@opened("{{.*}}") Base<Int> & P, $Base<Int> & P
+ // CHECK: destroy_value [[RESULT]] : $Base<Int> & P
+ let _: Base<Int> & P = baseAndP.classSelfReturn()
+
+ // CHECK: [[PAYLOAD:%.*]] = open_existential_ref [[ARG0]] : $Base<Int> & P to $@opened("{{.*}}") Base<Int> & P
+ // CHECK: [[RESULT_BOX:%.*]] = alloc_stack $@opened("{{.*}}") Base<Int> & P
+ // CHECK: [[SELF_BOX:%.*]] = alloc_stack $@opened("{{.*}}") Base<Int> & P
+ // CHECK: store_borrow [[PAYLOAD]] to [[SELF_BOX]] : $*@opened("{{.*}}") Base<Int> & P
+ // CHECK: [[METHOD:%.*]] = witness_method $@opened("{{.*}}") Base<Int> & P, #P.protocolSelfReturn!1 : <Self where Self : P> (Self) -> () -> @dynamic_self Self, [[PAYLOAD]] : $@opened("{{.*}}") Base<Int> & P : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ // CHECK: apply [[METHOD]]<@opened("{{.*}}") Base<Int> & P>([[RESULT_BOX]], [[SELF_BOX]]) : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ // CHECK: dealloc_stack [[SELF_BOX]] : $*@opened("{{.*}}") Base<Int> & P
+ // CHECK: [[RESULT_REF:%.*]] = load [take] [[RESULT_BOX]] : $*@opened("{{.*}}") Base<Int> & P
+ // CHECK: [[RESULT:%.*]] = init_existential_ref [[RESULT_REF]] : $@opened("{{.*}}") Base<Int> & P : $@opened("{{.*}}") Base<Int> & P, $Base<Int> & P
+ // CHECK: destroy_value [[RESULT]] : $Base<Int> & P
+ // CHECK: dealloc_stack [[RESULT_BOX]] : $*@opened("{{.*}}") Base<Int> & P
+ let _: Base<Int> & P = baseAndP.protocolSelfReturn()
+
+ // CHECK: [[METATYPE:%.*]] = open_existential_metatype %1 : $@thick (Base<Int> & P).Type to $@thick (@opened("{{.*}}") (Base<Int> & P)).Type
+ // CHECK: [[METATYPE_REF:%.*]] = upcast [[METATYPE]] : $@thick (@opened("{{.*}}") (Base<Int> & P)).Type to $@thick Base<Int>.Type
+ // CHECK: [[METHOD:%.*]] = function_ref @$S21subclass_existentials4BaseC15classSelfReturnACyxGXDyFZ : $@convention(method) <τ_0_0> (@thick Base<τ_0_0>.Type) -> @owned Base<τ_0_0>
+ // CHECK: [[RESULT_REF2:%.*]] = apply [[METHOD]]<Int>([[METATYPE_REF]])
+ // CHECK: [[RESULT_REF:%.*]] = unchecked_ref_cast [[RESULT_REF2]] : $Base<Int> to $@opened("{{.*}}") (Base<Int> & P)
+ // CHECK: [[RESULT:%.*]] = init_existential_ref [[RESULT_REF]] : $@opened("{{.*}}") (Base<Int> & P) : $@opened("{{.*}}") (Base<Int> & P), $Base<Int> & P
+ // CHECK: destroy_value [[RESULT]]
+ let _: Base<Int> & P = baseAndPType.classSelfReturn()
+
+ // CHECK: [[METATYPE:%.*]] = open_existential_metatype %1 : $@thick (Base<Int> & P).Type to $@thick (@opened("{{.*}}") (Base<Int> & P)).Type
+ // CHECK: [[RESULT:%.*]] = alloc_stack $@opened("{{.*}}") (Base<Int> & P)
+ // CHECK: [[METHOD:%.*]] = witness_method $@opened("{{.*}}") (Base<Int> & P), #P.protocolSelfReturn!1 : <Self where Self : P> (Self.Type) -> () -> @dynamic_self Self, [[METATYPE]] : $@thick (@opened("{{.*}}") (Base<Int> & P)).Type : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@thick τ_0_0.Type) -> @out τ_0_0
+ // CHECK: apply [[METHOD]]<@opened("{{.*}}") (Base<Int> & P)>([[RESULT]], [[METATYPE]]) : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@thick τ_0_0.Type) -> @out τ_0_0
+ // CHECK: [[RESULT_REF:%.*]] = load [take] [[RESULT]] : $*@opened("{{.*}}") (Base<Int> & P)
+ // CHECK: [[RESULT_VALUE:%.*]] = init_existential_ref [[RESULT_REF]] : $@opened("{{.*}}") (Base<Int> & P) : $@opened("{{.*}}") (Base<Int> & P), $Base<Int> & P
+ // CHECK: destroy_value [[RESULT_VALUE]]
+ // CHECK: dealloc_stack [[RESULT]]
+ let _: Base<Int> & P = baseAndPType.protocolSelfReturn()
+
+ // Partial applications
+ let _: () -> (Base<Int> & P) = baseAndP.classSelfReturn
+ let _: () -> (Base<Int> & P) = baseAndP.protocolSelfReturn
+
+ let _: () -> (Base<Int> & P) = baseAndPType.classSelfReturn
+ let _: () -> (Base<Int> & P) = baseAndPType.protocolSelfReturn
+
+ let _: () -> (Base<Int> & P) = baseAndPType.init(classInit:)
+ let _: () -> (Base<Int> & P) = baseAndPType.init(protocolInit:)
+
+ // CHECK: return
+ // CHECK-NEXT: }
+}
+
+protocol PropertyP {
+ var p: PropertyP & PropertyC { get set }
+
+ subscript(key: Int) -> Int { get set }
+}
+
+class PropertyC {
+ var c: PropertyP & PropertyC {
+ get {
+ return self as! PropertyP & PropertyC
+ }
+ set { }
+ }
+
+ subscript(key: (Int, Int)) -> Int {
+ get {
+ return 0
+ } set { }
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S21subclass_existentials16propertyAccessesyyAA9PropertyP_AA0E1CCXcF : $@convention(thin) (@guaranteed PropertyC & PropertyP) -> () {
+func propertyAccesses(_ x: PropertyP & PropertyC) {
+ var xx = x
+ xx.p.p = x
+ xx.c.c = x
+
+ propertyAccesses(xx.p)
+ propertyAccesses(xx.c)
+
+ _ = xx[1]
+ xx[1] = 1
+ xx[1] += 1
+
+ _ = xx[(1, 2)]
+ xx[(1, 2)] = 1
+ xx[(1, 2)] += 1
+}
+
+// CHECK-LABEL: sil hidden @$S21subclass_existentials19functionConversions15returnsBaseAndP0efG5PType0E7Derived0eI4Type0eiG1R0eiG5RTypeyAA1P_AA0F0CySiGXcyc_AaI_ALXcXpycAA0I0CycANmycAA1R_ANXcycAaO_ANXcXpyctF : $@convention(thin) (@guaranteed @callee_guaranteed () -> @owned Base<Int> & P, @guaranteed @callee_guaranteed () -> @thick (Base<Int> & P).Type, @guaranteed @callee_guaranteed () -> @owned Derived, @guaranteed @callee_guaranteed () -> @thick Derived.Type, @guaranteed @callee_guaranteed () -> @owned Derived & R, @guaranteed @callee_guaranteed () -> @thick (Derived & R).Type) -> () {
+func functionConversions(
+ returnsBaseAndP: @escaping () -> (Base<Int> & P),
+ returnsBaseAndPType: @escaping () -> (Base<Int> & P).Type,
+ returnsDerived: @escaping () -> Derived,
+ returnsDerivedType: @escaping () -> Derived.Type,
+ returnsDerivedAndR: @escaping () -> Derived & R,
+ returnsDerivedAndRType: @escaping () -> (Derived & R).Type) {
+
+ let _: () -> Base<Int> = returnsBaseAndP
+ let _: () -> Base<Int>.Type = returnsBaseAndPType
+
+ let _: () -> P = returnsBaseAndP
+ let _: () -> P.Type = returnsBaseAndPType
+
+ let _: () -> (Base<Int> & P) = returnsDerived
+ let _: () -> (Base<Int> & P).Type = returnsDerivedType
+
+ let _: () -> Base<Int> = returnsDerivedAndR
+ let _: () -> Base<Int>.Type = returnsDerivedAndRType
+
+ let _: () -> (Base<Int> & P) = returnsDerivedAndR
+ let _: () -> (Base<Int> & P).Type = returnsDerivedAndRType
+
+ let _: () -> P = returnsDerivedAndR
+ let _: () -> P.Type = returnsDerivedAndRType
+
+ // CHECK: return %
+ // CHECK-NEXT: }
+}
+
+// CHECK-LABEL: sil hidden @$S21subclass_existentials9downcasts8baseAndP7derived0dE5PType0F4TypeyAA1P_AA4BaseCySiGXc_AA7DerivedCAaG_AJXcXpALmtF : $@convention(thin) (@guaranteed Base<Int> & P, @guaranteed Derived, @thick (Base<Int> & P).Type, @thick Derived.Type) -> () {
+func downcasts(
+ baseAndP: Base<Int> & P,
+ derived: Derived,
+ baseAndPType: (Base<Int> & P).Type,
+ derivedType: Derived.Type) {
+ // CHECK: bb0([[ARG0:%.*]] : $Base<Int> & P, [[ARG1:%.*]] : $Derived, [[ARG2:%.*]] : $@thick (Base<Int> & P).Type, [[ARG3:%.*]] : $@thick Derived.Type):
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG0]] : $Base<Int> & P
+ // CHECK-NEXT: checked_cast_br [[COPIED]] : $Base<Int> & P to $Derived
+ let _ = baseAndP as? Derived
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG0]] : $Base<Int> & P
+ // CHECK-NEXT: unconditional_checked_cast [[COPIED]] : $Base<Int> & P to $Derived
+ let _ = baseAndP as! Derived
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG0]] : $Base<Int> & P
+ // CHECK-NEXT: checked_cast_br [[COPIED]] : $Base<Int> & P to $Derived & R
+ let _ = baseAndP as? (Derived & R)
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG0]] : $Base<Int> & P
+ // CHECK-NEXT: unconditional_checked_cast [[COPIED]] : $Base<Int> & P to $Derived & R
+ let _ = baseAndP as! (Derived & R)
+
+ // CHECK: checked_cast_br %3 : $@thick Derived.Type to $@thick (Derived & R).Type
+ let _ = derivedType as? (Derived & R).Type
+
+ // CHECK: unconditional_checked_cast %3 : $@thick Derived.Type to $@thick (Derived & R).Type
+ let _ = derivedType as! (Derived & R).Type
+
+ // CHECK: checked_cast_br %2 : $@thick (Base<Int> & P).Type to $@thick Derived.Type
+ let _ = baseAndPType as? Derived.Type
+
+ // CHECK: unconditional_checked_cast %2 : $@thick (Base<Int> & P).Type to $@thick Derived.Type
+ let _ = baseAndPType as! Derived.Type
+
+ // CHECK: checked_cast_br %2 : $@thick (Base<Int> & P).Type to $@thick (Derived & R).Type
+ let _ = baseAndPType as? (Derived & R).Type
+
+ // CHECK: unconditional_checked_cast %2 : $@thick (Base<Int> & P).Type to $@thick (Derived & R).Type
+ let _ = baseAndPType as! (Derived & R).Type
+
+ // CHECK: return
+ // CHECK-NEXT: }
+}
+
+// CHECK-LABEL: sil hidden @$S21subclass_existentials16archetypeUpcasts9baseTAndP0E7IntAndP7derivedyq__q0_q1_tAA4BaseCyxGRb_AA1PR_AGySiGRb0_AaIR0_AA7DerivedCRb1_r2_lF : $@convention(thin) <T, BaseTAndP, BaseIntAndP, DerivedT where BaseTAndP : Base<T>, BaseTAndP : P, BaseIntAndP : Base<Int>, BaseIntAndP : P, DerivedT : Derived> (@guaranteed BaseTAndP, @guaranteed BaseIntAndP, @guaranteed DerivedT) -> () {
+func archetypeUpcasts<T,
+ BaseTAndP : Base<T> & P,
+ BaseIntAndP : Base<Int> & P,
+ DerivedT : Derived>(
+ baseTAndP: BaseTAndP,
+ baseIntAndP : BaseIntAndP,
+ derived : DerivedT) {
+ // CHECK: bb0([[ARG0:%.*]] : $BaseTAndP, [[ARG1:%.*]] : $BaseIntAndP, [[ARG2:%.*]] : $DerivedT)
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG0]] : $BaseTAndP
+ // CHECK-NEXT: init_existential_ref [[COPIED]] : $BaseTAndP : $BaseTAndP, $Base<T> & P
+ let _: Base<T> & P = baseTAndP
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG1]] : $BaseIntAndP
+ // CHECK-NEXT: init_existential_ref [[COPIED]] : $BaseIntAndP : $BaseIntAndP, $Base<Int> & P
+ let _: Base<Int> & P = baseIntAndP
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG2]] : $DerivedT
+ // CHECK-NEXT: init_existential_ref [[COPIED]] : $DerivedT : $DerivedT, $Base<Int> & P
+ let _: Base<Int> & P = derived
+
+ // CHECK: return
+ // CHECK-NEXT: }
+}
+
+// CHECK-LABEL: sil hidden @$S21subclass_existentials18archetypeDowncasts1s1t2pt5baseT0F3Int0f6TAndP_C00fg5AndP_C008derived_C00ji2R_C00fH10P_concrete0fgi2P_K0yx_q_q0_q1_q2_q3_q4_q5_AA1R_AA7DerivedCXcAA1P_AA4BaseCyq_GXcAaQ_ASySiGXctAaQR0_ATRb1_AURb2_ATRb3_AaQR3_AURb4_AaQR4_APRb5_r6_lF : $@convention(thin) <S, T, PT, BaseT, BaseInt, BaseTAndP, BaseIntAndP, DerivedT where PT : P, BaseT : Base<T>, BaseInt : Base<Int>, BaseTAndP : Base<T>, BaseTAndP : P, BaseIntAndP : Base<Int>, BaseIntAndP : P, DerivedT : Derived> (@in_guaranteed S, @in_guaranteed T, @in_guaranteed PT, @guaranteed BaseT, @guaranteed BaseInt, @guaranteed BaseTAndP, @guaranteed BaseIntAndP, @guaranteed DerivedT, @guaranteed Derived & R, @guaranteed Base<T> & P, @guaranteed Base<Int> & P) -> () {
+func archetypeDowncasts<S,
+ T,
+ PT : P,
+ BaseT : Base<T>,
+ BaseInt : Base<Int>,
+ BaseTAndP : Base<T> & P,
+ BaseIntAndP : Base<Int> & P,
+ DerivedT : Derived>(
+ s: S,
+ t: T,
+ pt: PT,
+ baseT : BaseT,
+ baseInt : BaseInt,
+
+ baseTAndP_archetype: BaseTAndP,
+ baseIntAndP_archetype : BaseIntAndP,
+ derived_archetype : DerivedT,
+ derivedAndR_archetype : Derived & R,
+
+ baseTAndP_concrete: Base<T> & P,
+ baseIntAndP_concrete: Base<Int> & P) {
+
+ // CHECK: ([[ARG0:%.*]] : $*S, [[ARG1:%.*]] : $*T, [[ARG2:%.*]] : $*PT, [[ARG3:%.*]] : $BaseT, [[ARG4:%.*]] : $BaseInt, [[ARG5:%.*]] : $BaseTAndP, [[ARG6:%.*]] : $BaseIntAndP, [[ARG7:%.*]] : $DerivedT, [[ARG8:%.*]] : $Derived & R, [[ARG9:%.*]] : $Base<T> & P, [[ARG10:%.*]] : $Base<Int> & P)
+
+ // CHECK: [[COPY:%.*]] = alloc_stack $S
+ // CHECK-NEXT: copy_addr %0 to [initialization] [[COPY]] : $*S
+ // CHECK-NEXT: [[RESULT:%.*]] = alloc_stack $Base<T> & P
+ // CHECK-NEXT: checked_cast_addr_br take_always S in [[COPY]] : $*S to Base<T> & P in [[RESULT]] : $*Base<T> & P
+ let _ = s as? (Base<T> & P)
+
+ // CHECK: [[COPY:%.*]] = alloc_stack $S
+ // CHECK-NEXT: copy_addr [[ARG0]] to [initialization] [[COPY]] : $*S
+ // CHECK-NEXT: [[RESULT:%.*]] = alloc_stack $Base<T> & P
+ // CHECK-NEXT: unconditional_checked_cast_addr S in [[COPY]] : $*S to Base<T> & P in [[RESULT]] : $*Base<T> & P
+ let _ = s as! (Base<T> & P)
+
+ // CHECK: [[COPY:%.*]] = alloc_stack $S
+ // CHECK-NEXT: copy_addr [[ARG0]] to [initialization] [[COPY]] : $*S
+ // CHECK-NEXT: [[RESULT:%.*]] = alloc_stack $Base<Int> & P
+ // CHECK-NEXT: checked_cast_addr_br take_always S in [[COPY]] : $*S to Base<Int> & P in [[RESULT]] : $*Base<Int> & P
+ let _ = s as? (Base<Int> & P)
+
+ // CHECK: [[COPY:%.*]] = alloc_stack $S
+ // CHECK-NEXT: copy_addr [[ARG0]] to [initialization] [[COPY]] : $*S
+ // CHECK-NEXT: [[RESULT:%.*]] = alloc_stack $Base<Int> & P
+ // CHECK-NEXT: unconditional_checked_cast_addr S in [[COPY]] : $*S to Base<Int> & P in [[RESULT]] : $*Base<Int> & P
+ let _ = s as! (Base<Int> & P)
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG5]] : $BaseTAndP
+ // CHECK-NEXT: checked_cast_br [[COPIED]] : $BaseTAndP to $Derived & R
+ let _ = baseTAndP_archetype as? (Derived & R)
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG5]] : $BaseTAndP
+ // CHECK-NEXT: unconditional_checked_cast [[COPIED]] : $BaseTAndP to $Derived & R
+ let _ = baseTAndP_archetype as! (Derived & R)
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG9]] : $Base<T> & P
+ // CHECK-NEXT: [[COPY:%.*]] = alloc_stack $Base<T> & P
+ // CHECK-NEXT: store [[COPIED]] to [init] [[COPY]] : $*Base<T> & P
+ // CHECK-NEXT: [[RESULT:%.*]] = alloc_stack $Optional<S>
+ // CHECK-NEXT: [[PAYLOAD:%.*]] = init_enum_data_addr [[RESULT]] : $*Optional<S>, #Optional.some
+ // CHECK-NEXT: checked_cast_addr_br take_always Base<T> & P in [[COPY]] : $*Base<T> & P to S in [[PAYLOAD]] : $*S
+ let _ = baseTAndP_concrete as? S
+
+ // CHECK: [[COPY:%.*]] = alloc_stack $Base<T> & P
+ // CHECK-NEXT: [[COPIED:%.*]] = copy_value [[ARG9]] : $Base<T> & P
+ // CHECK-NEXT: store [[COPIED]] to [init] [[COPY]] : $*Base<T> & P
+ // CHECK-NEXT: [[RESULT:%.*]] = alloc_stack $S
+ // CHECK-NEXT: unconditional_checked_cast_addr Base<T> & P in [[COPY]] : $*Base<T> & P to S in [[RESULT]] : $*S
+ let _ = baseTAndP_concrete as! S
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG9]] : $Base<T> & P
+ // CHECK-NEXT: checked_cast_br [[COPIED]] : $Base<T> & P to $BaseT
+ let _ = baseTAndP_concrete as? BaseT
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG9]] : $Base<T> & P
+ // CHECK-NEXT: unconditional_checked_cast [[COPIED]] : $Base<T> & P to $BaseT
+ let _ = baseTAndP_concrete as! BaseT
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG9]] : $Base<T> & P
+ // CHECK-NEXT: checked_cast_br [[COPIED]] : $Base<T> & P to $BaseInt
+ let _ = baseTAndP_concrete as? BaseInt
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG9]] : $Base<T> & P
+ // CHECK-NEXT: unconditional_checked_cast [[COPIED]] : $Base<T> & P to $BaseInt
+ let _ = baseTAndP_concrete as! BaseInt
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG9]] : $Base<T> & P
+ // CHECK-NEXT: checked_cast_br [[COPIED]] : $Base<T> & P to $BaseTAndP
+ let _ = baseTAndP_concrete as? BaseTAndP
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG9]] : $Base<T> & P
+ // CHECK-NEXT: unconditional_checked_cast [[COPIED]] : $Base<T> & P to $BaseTAndP
+ let _ = baseTAndP_concrete as! BaseTAndP
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG6]] : $BaseIntAndP
+ // CHECK-NEXT: checked_cast_br [[COPIED]] : $BaseIntAndP to $Derived & R
+ let _ = baseIntAndP_archetype as? (Derived & R)
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG6]] : $BaseIntAndP
+ // CHECK-NEXT: unconditional_checked_cast [[COPIED]] : $BaseIntAndP to $Derived & R
+ let _ = baseIntAndP_archetype as! (Derived & R)
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG10]] : $Base<Int> & P
+ // CHECK-NEXT: [[COPY:%.*]] = alloc_stack $Base<Int> & P
+ // CHECK-NEXT: store [[COPIED]] to [init] [[COPY]] : $*Base<Int> & P
+ // CHECK-NEXT: [[RESULT:%.*]] = alloc_stack $Optional<S>
+ // CHECK-NEXT: [[PAYLOAD:%.*]] = init_enum_data_addr [[RESULT]] : $*Optional<S>, #Optional.some
+ // CHECK-NEXT: checked_cast_addr_br take_always Base<Int> & P in [[COPY]] : $*Base<Int> & P to S in [[PAYLOAD]] : $*S
+ let _ = baseIntAndP_concrete as? S
+
+ // CHECK: [[COPY:%.*]] = alloc_stack $Base<Int> & P
+ // CHECK-NEXT: [[COPIED:%.*]] = copy_value [[ARG10]] : $Base<Int> & P
+ // CHECK-NEXT: store [[COPIED]] to [init] [[COPY]] : $*Base<Int> & P
+ // CHECK-NEXT: [[RESULT:%.*]] = alloc_stack $S
+ // CHECK-NEXT: unconditional_checked_cast_addr Base<Int> & P in [[COPY]] : $*Base<Int> & P to S in [[RESULT]] : $*S
+ let _ = baseIntAndP_concrete as! S
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG10]] : $Base<Int> & P
+ // CHECK-NEXT: checked_cast_br [[COPIED]] : $Base<Int> & P to $DerivedT
+ let _ = baseIntAndP_concrete as? DerivedT
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG10]] : $Base<Int> & P
+ // CHECK-NEXT: unconditional_checked_cast [[COPIED]] : $Base<Int> & P to $DerivedT
+ let _ = baseIntAndP_concrete as! DerivedT
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG10]] : $Base<Int> & P
+ // CHECK-NEXT: checked_cast_br [[COPIED]] : $Base<Int> & P to $BaseT
+ let _ = baseIntAndP_concrete as? BaseT
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG10]] : $Base<Int> & P
+ // CHECK-NEXT: unconditional_checked_cast [[COPIED]] : $Base<Int> & P to $BaseT
+ let _ = baseIntAndP_concrete as! BaseT
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG10]] : $Base<Int> & P
+ // CHECK-NEXT: checked_cast_br [[COPIED]] : $Base<Int> & P to $BaseInt
+ let _ = baseIntAndP_concrete as? BaseInt
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG10]] : $Base<Int> & P
+ // CHECK-NEXT: unconditional_checked_cast [[COPIED]] : $Base<Int> & P to $BaseInt
+ let _ = baseIntAndP_concrete as! BaseInt
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG10]] : $Base<Int> & P
+ // CHECK-NEXT: checked_cast_br [[COPIED]] : $Base<Int> & P to $BaseTAndP
+ let _ = baseIntAndP_concrete as? BaseTAndP
+
+ // CHECK: [[COPIED:%.*]] = copy_value [[ARG10]] : $Base<Int> & P
+ // CHECK-NEXT: unconditional_checked_cast [[COPIED]] : $Base<Int> & P to $BaseTAndP
+ let _ = baseIntAndP_concrete as! BaseTAndP
+
+ // CHECK: return
+ // CHECK-NEXT: }
+}
diff --git a/test/SILGen/plus_zero_super.swift b/test/SILGen/plus_zero_super.swift
new file mode 100644
index 0000000..5184967
--- /dev/null
+++ b/test/SILGen/plus_zero_super.swift
@@ -0,0 +1,202 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -I %t -emit-module -emit-module-path=%t/resilient_struct.swiftmodule -module-name resilient_struct %S/../Inputs/resilient_struct.swift
+// RUN: %target-swift-frontend -I %t -emit-module -emit-module-path=%t/resilient_class.swiftmodule -module-name resilient_class %S/../Inputs/resilient_class.swift
+// RUN: %target-swift-frontend -emit-silgen -parse-as-library -I %t %s | %FileCheck %s
+
+import resilient_class
+
+public class Parent {
+ public final var finalProperty: String {
+ return "Parent.finalProperty"
+ }
+
+ public var property: String {
+ return "Parent.property"
+ }
+
+ public final class var finalClassProperty: String {
+ return "Parent.finalProperty"
+ }
+
+ public class var classProperty: String {
+ return "Parent.property"
+ }
+
+ public func methodOnlyInParent() {}
+ public final func finalMethodOnlyInParent() {}
+ public func method() {}
+
+ public final class func finalClassMethodOnlyInParent() {}
+ public class func classMethod() {}
+}
+
+public class Child : Parent {
+ // CHECK-LABEL: sil @$S5super5ChildC8propertySSvg : $@convention(method) (@guaranteed Child) -> @owned String {
+ // CHECK: bb0([[SELF:%.*]] : $Child):
+ // CHECK: [[SELF_COPY:%.*]] = copy_value [[SELF]]
+ // CHECK: [[CASTED_SELF_COPY:%[0-9]+]] = upcast [[SELF_COPY]] : $Child to $Parent
+ // CHECK: [[SUPER_METHOD:%[0-9]+]] = function_ref @$S5super6ParentC8propertySSvg : $@convention(method) (@guaranteed Parent) -> @owned String
+ // CHECK: [[RESULT:%.*]] = apply [[SUPER_METHOD]]([[CASTED_SELF_COPY]])
+ // CHECK: destroy_value [[CASTED_SELF_COPY]]
+ // CHECK: return [[RESULT]]
+ public override var property: String {
+ return super.property
+ }
+
+ // CHECK-LABEL: sil @$S5super5ChildC13otherPropertySSvg : $@convention(method) (@guaranteed Child) -> @owned String {
+ // CHECK: bb0([[SELF:%.*]] : $Child):
+ // CHECK: [[COPIED_SELF:%.*]] = copy_value [[SELF]]
+ // CHECK: [[CASTED_SELF_COPY:%[0-9]+]] = upcast [[COPIED_SELF]] : $Child to $Parent
+ // CHECK: [[SUPER_METHOD:%[0-9]+]] = function_ref @$S5super6ParentC13finalPropertySSvg
+ // CHECK: [[RESULT:%.*]] = apply [[SUPER_METHOD]]([[CASTED_SELF_COPY]])
+ // CHECK: destroy_value [[CASTED_SELF_COPY]]
+ // CHECK: return [[RESULT]]
+ public var otherProperty: String {
+ return super.finalProperty
+ }
+}
+
+public class Grandchild : Child {
+ // CHECK-LABEL: sil @$S5super10GrandchildC06onlyInB0yyF
+ public func onlyInGrandchild() {
+ // CHECK: function_ref @$S5super6ParentC012methodOnlyInB0yyF : $@convention(method) (@guaranteed Parent) -> ()
+ super.methodOnlyInParent()
+ // CHECK: function_ref @$S5super6ParentC017finalMethodOnlyInB0yyF
+ super.finalMethodOnlyInParent()
+ }
+
+ // CHECK-LABEL: sil @$S5super10GrandchildC6methodyyF
+ public override func method() {
+ // CHECK: function_ref @$S5super6ParentC6methodyyF : $@convention(method) (@guaranteed Parent) -> ()
+ super.method()
+ }
+}
+
+public class GreatGrandchild : Grandchild {
+ // CHECK-LABEL: sil @$S5super15GreatGrandchildC6methodyyF
+ public override func method() {
+ // CHECK: function_ref @$S5super10GrandchildC6methodyyF : $@convention(method) (@guaranteed Grandchild) -> ()
+ super.method()
+ }
+}
+
+public class ChildToResilientParent : ResilientOutsideParent {
+ // CHECK-LABEL: sil @$S5super22ChildToResilientParentC6methodyyF : $@convention(method) (@guaranteed ChildToResilientParent) -> ()
+ public override func method() {
+ // CHECK: bb0([[SELF:%.*]] : $ChildToResilientParent):
+ // CHECK: [[COPY_SELF:%.*]] = copy_value [[SELF]]
+ // CHECK: [[UPCAST_SELF:%.*]] = upcast [[COPY_SELF]]
+ // CHECK: [[BORROW_UPCAST_SELF:%.*]] = begin_borrow [[UPCAST_SELF]]
+ // CHECK: [[CAST_BORROW_BACK_TO_BASE:%.*]] = unchecked_ref_cast [[BORROW_UPCAST_SELF]]
+ // CHECK: [[FUNC:%.*]] = super_method [[CAST_BORROW_BACK_TO_BASE]] : $ChildToResilientParent, #ResilientOutsideParent.method!1 : (ResilientOutsideParent) -> () -> (), $@convention(method) (@guaranteed ResilientOutsideParent) -> ()
+ // CHECK: end_borrow [[BORROW_UPCAST_SELF]] from [[UPCAST_SELF]]
+ // CHECK: apply [[FUNC]]([[UPCAST_SELF]])
+ super.method()
+ }
+ // CHECK: } // end sil function '$S5super22ChildToResilientParentC6methodyyF'
+
+ // CHECK-LABEL: sil @$S5super22ChildToResilientParentC11classMethodyyFZ : $@convention(method) (@thick ChildToResilientParent.Type) -> ()
+ public override class func classMethod() {
+ // CHECK: bb0([[METASELF:%.*]] : $@thick ChildToResilientParent.Type):
+ // CHECK: [[UPCAST_METASELF:%.*]] = upcast [[METASELF]]
+ // CHECK: [[FUNC:%.*]] = super_method [[SELF]] : $@thick ChildToResilientParent.Type, #ResilientOutsideParent.classMethod!1 : (ResilientOutsideParent.Type) -> () -> (), $@convention(method) (@thick ResilientOutsideParent.Type) -> ()
+ // CHECK: apply [[FUNC]]([[UPCAST_METASELF]])
+ super.classMethod()
+ }
+ // CHECK: } // end sil function '$S5super22ChildToResilientParentC11classMethodyyFZ'
+
+ // CHECK-LABEL: sil @$S5super22ChildToResilientParentC11returnsSelfACXDyFZ : $@convention(method) (@thick ChildToResilientParent.Type) -> @owned ChildToResilientParent
+ public class func returnsSelf() -> Self {
+ // CHECK: bb0([[METASELF:%.*]] : $@thick ChildToResilientParent.Type):
+ // CHECK: [[CAST_METASELF:%.*]] = unchecked_trivial_bit_cast [[METASELF]] : $@thick ChildToResilientParent.Type to $@thick @dynamic_self ChildToResilientParent.Type
+ // CHECK: [[UPCAST_CAST_METASELF:%.*]] = upcast [[CAST_METASELF]] : $@thick @dynamic_self ChildToResilientParent.Type to $@thick ResilientOutsideParent.Type
+ // CHECK: [[FUNC:%.*]] = super_method [[METASELF]] : $@thick ChildToResilientParent.Type, #ResilientOutsideParent.classMethod!1 : (ResilientOutsideParent.Type) -> () -> ()
+ // CHECK: apply [[FUNC]]([[UPCAST_CAST_METASELF]])
+ // CHECK: unreachable
+ super.classMethod()
+ }
+ // CHECK: } // end sil function '$S5super22ChildToResilientParentC11returnsSelfACXDyFZ'
+}
+
+public class ChildToFixedParent : OutsideParent {
+ // CHECK-LABEL: sil @$S5super18ChildToFixedParentC6methodyyF : $@convention(method) (@guaranteed ChildToFixedParent) -> ()
+ public override func method() {
+ // CHECK: bb0([[SELF:%.*]] : $ChildToFixedParent):
+ // CHECK: [[COPY_SELF:%.*]] = copy_value [[SELF]]
+ // CHECK: [[UPCAST_COPY_SELF:%.*]] = upcast [[COPY_SELF]]
+ // CHECK: [[BORROWED_UPCAST_COPY_SELF:%.*]] = begin_borrow [[UPCAST_COPY_SELF]]
+ // CHECK: [[DOWNCAST_BORROWED_UPCAST_COPY_SELF:%.*]] = unchecked_ref_cast [[BORROWED_UPCAST_COPY_SELF]] : $OutsideParent to $ChildToFixedParent
+ // CHECK: [[FUNC:%.*]] = super_method [[DOWNCAST_BORROWED_UPCAST_COPY_SELF]] : $ChildToFixedParent, #OutsideParent.method!1 : (OutsideParent) -> () -> (), $@convention(method) (@guaranteed OutsideParent) -> ()
+ // CHECK: end_borrow [[BORROWED_UPCAST_COPY_SELF]] from [[UPCAST_COPY_SELF]]
+ // CHECK: apply [[FUNC]]([[UPCAST_COPY_SELF]])
+ super.method()
+ }
+ // CHECK: } // end sil function '$S5super18ChildToFixedParentC6methodyyF'
+
+ // CHECK-LABEL: sil @$S5super18ChildToFixedParentC11classMethodyyFZ : $@convention(method) (@thick ChildToFixedParent.Type) -> ()
+ public override class func classMethod() {
+ // CHECK: bb0([[SELF:%.*]] : $@thick ChildToFixedParent.Type):
+ // CHECK: [[UPCAST_SELF:%.*]] = upcast [[SELF]]
+ // CHECK: [[FUNC:%.*]] = super_method [[SELF]] : $@thick ChildToFixedParent.Type, #OutsideParent.classMethod!1 : (OutsideParent.Type) -> () -> (), $@convention(method) (@thick OutsideParent.Type) -> ()
+ // CHECK: apply [[FUNC]]([[UPCAST_SELF]])
+ super.classMethod()
+ }
+ // CHECK: } // end sil function '$S5super18ChildToFixedParentC11classMethodyyFZ'
+
+ // CHECK-LABEL: sil @$S5super18ChildToFixedParentC11returnsSelfACXDyFZ : $@convention(method) (@thick ChildToFixedParent.Type) -> @owned ChildToFixedParent
+ public class func returnsSelf() -> Self {
+ // CHECK: bb0([[SELF:%.*]] : $@thick ChildToFixedParent.Type):
+ // CHECK: [[FIRST_CAST:%.*]] = unchecked_trivial_bit_cast [[SELF]]
+ // CHECK: [[SECOND_CAST:%.*]] = upcast [[FIRST_CAST]]
+ // CHECK: [[FUNC:%.*]] = super_method [[SELF]] : $@thick ChildToFixedParent.Type, #OutsideParent.classMethod!1 : (OutsideParent.Type) -> () -> ()
+ // CHECK: apply [[FUNC]]([[SECOND_CAST]])
+ // CHECK: unreachable
+ super.classMethod()
+ }
+ // CHECK: } // end sil function '$S5super18ChildToFixedParentC11returnsSelfACXDyFZ'
+}
+
+public extension ResilientOutsideChild {
+ public func callSuperMethod() {
+ super.method()
+ }
+
+ public class func callSuperClassMethod() {
+ super.classMethod()
+ }
+}
+
+public class GenericBase<T> {
+ public func method() {}
+}
+
+public class GenericDerived<T> : GenericBase<T> {
+ public override func method() {
+ // CHECK-LABEL: sil private @$S5super14GenericDerivedC6methodyyFyyXEfU_ : $@convention(thin) <T> (@guaranteed GenericDerived<T>) -> ()
+ // CHECK: upcast {{.*}} : $GenericDerived<T> to $GenericBase<T>
+ // CHECK: return
+ {
+ super.method()
+ }()
+ // CHECK: } // end sil function '$S5super14GenericDerivedC6methodyyFyyXEfU_'
+
+ // CHECK-LABEL: sil private @$S5super14GenericDerivedC6methodyyF13localFunctionL_yylF : $@convention(thin) <T> (@guaranteed GenericDerived<T>) -> ()
+ // CHECK: upcast {{.*}} : $GenericDerived<T> to $GenericBase<T>
+ // CHECK: return
+ // CHECK: } // end sil function '$S5super14GenericDerivedC6methodyyF13localFunctionL_yylF'
+ func localFunction() {
+ super.method()
+ }
+ localFunction()
+
+ // CHECK-LABEL: sil private @$S5super14GenericDerivedC6methodyyF15genericFunctionL_yyqd__r__lF : $@convention(thin) <T><U> (@in_guaranteed U, @guaranteed GenericDerived<T>) -> ()
+ // CHECK: upcast {{.*}} : $GenericDerived<T> to $GenericBase<T>
+ // CHECK: return
+ func genericFunction<U>(_: U) {
+ super.method()
+ }
+ // CHECK: } // end sil function '$S5super14GenericDerivedC6methodyyF15genericFunctionL_yyqd__r__lF'
+ genericFunction(0)
+ }
+}
diff --git a/test/SILGen/plus_zero_switch.swift b/test/SILGen/plus_zero_switch.swift
new file mode 100644
index 0000000..e81e078
--- /dev/null
+++ b/test/SILGen/plus_zero_switch.swift
@@ -0,0 +1,1125 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
+
+func markUsed<T>(_ t: T) {}
+
+// TODO: Implement tuple equality in the library.
+// BLOCKED: <rdar://problem/13822406>
+func ~= (x: (Int, Int), y: (Int, Int)) -> Bool {
+ return x.0 == y.0 && x.1 == y.1
+}
+
+// Some fake predicates for pattern guards.
+func runced() -> Bool { return true }
+func funged() -> Bool { return true }
+func ansed() -> Bool { return true }
+
+func foo() -> Int { return 0 }
+func bar() -> Int { return 0 }
+func foobar() -> (Int, Int) { return (0, 0) }
+
+func a() {}
+func b() {}
+func c() {}
+func d() {}
+func e() {}
+func f() {}
+func g() {}
+
+// CHECK-LABEL: sil hidden @$S6switch5test1yyF
+func test1() {
+ switch foo() {
+ // CHECK: function_ref @$S6switch3fooSiyF
+ case _:
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1byyF
+ b()
+}
+
+// CHECK-LABEL: sil hidden @$S6switch5test2yyF
+func test2() {
+ switch foo() {
+ // CHECK: function_ref @$S6switch3fooSiyF
+ case _:
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+ case _: // The second case is unreachable.
+ b()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1cyyF
+ c()
+}
+
+// CHECK-LABEL: sil hidden @$S6switch5test3yyF
+func test3() {
+ switch foo() {
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: function_ref @$S6switch6runcedSbyF
+ // CHECK: cond_br {{%.*}}, [[CASE1:bb[0-9]+]], [[NO_CASE2:bb[0-9]+]]
+
+ case _ where runced():
+ // CHECK: [[CASE1]]:
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+
+ // CHECK: [[NO_CASE2]]:
+ // CHECK: br [[CASE2:bb[0-9]+]]
+ case _:
+ // CHECK: [[CASE2]]:
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[CONT]]
+ b()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1cyyF
+ c()
+}
+
+// CHECK-LABEL: sil hidden @$S6switch5test4yyF
+func test4() {
+ switch (foo(), bar()) {
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: function_ref @$S6switch3barSiyF
+ case _:
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1byyF
+ b()
+}
+
+// CHECK-LABEL: sil hidden @$S6switch5test5yyF
+func test5() {
+ switch (foo(), bar()) {
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: function_ref @$S6switch3barSiyF
+ // CHECK: function_ref @$S6switch6runcedSbyF
+ // CHECK: cond_br {{%.*}}, [[CASE1:bb[0-9]+]], [[NOT_CASE1:bb[0-9]+]]
+ case _ where runced():
+ // CHECK: [[CASE1]]:
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+
+ // CHECK: [[NOT_CASE1]]:
+ // CHECK: function_ref @$S6switch6fungedSbyF
+ // CHECK: cond_br {{%.*}}, [[YES_CASE2:bb[0-9]+]], [[NOT_CASE2:bb[0-9]+]]
+ // CHECK: [[YES_CASE2]]:
+ case (_, _) where funged():
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[CONT]]
+ b()
+
+ // CHECK: [[NOT_CASE2]]:
+ // CHECK: br [[CASE3:bb[0-9]+]]
+ case _:
+ // CHECK: [[CASE3]]:
+ // CHECK: function_ref @$S6switch1cyyF
+ // CHECK: br [[CONT]]
+ c()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1dyyF
+ d()
+}
+
+// CHECK-LABEL: sil hidden @$S6switch5test6yyF
+func test6() {
+ switch (foo(), bar()) {
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: function_ref @$S6switch3barSiyF
+ case (_, _):
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+ case (_, _): // The second case is unreachable.
+ b()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1cyyF
+ c()
+}
+
+// CHECK-LABEL: sil hidden @$S6switch5test7yyF
+func test7() {
+ switch (foo(), bar()) {
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: function_ref @$S6switch3barSiyF
+ // CHECK: function_ref @$S6switch6runcedSbyF
+ // CHECK: cond_br {{%.*}}, [[YES_CASE1:bb[0-9]+]], [[NOT_CASE1:bb[0-9]+]]
+ // CHECK: [[YES_CASE1]]:
+ case (_, _) where runced():
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+
+ // CHECK: [[NOT_CASE1]]:
+ // CHECK: br [[CASE2:bb[0-9]+]]
+ case (_, _):
+ // CHECK: [[CASE2]]:
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[CONT]]
+ b()
+ }
+ c()
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1cyyF
+}
+
+// CHECK-LABEL: sil hidden @$S6switch5test8yyF
+func test8() {
+ switch (foo(), bar()) {
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: function_ref @$S6switch3barSiyF
+ // CHECK: function_ref @$S6switch6foobarSi_SityF
+ // CHECK: cond_br {{%.*}}, [[CASE1:bb[0-9]+]], [[NOT_CASE1:bb[0-9]+]]
+ case foobar():
+ // CHECK: [[CASE1]]:
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+
+ // CHECK: [[NOT_CASE1]]:
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: cond_br {{%.*}}, [[CASE2:bb[0-9]+]], [[NOT_CASE2:bb[0-9]+]]
+ case (foo(), _):
+ // CHECK: [[CASE2]]:
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[CONT]]
+ b()
+ // CHECK: [[NOT_CASE2]]:
+ // CHECK: function_ref @$S6switch3barSiyF
+ // CHECK: cond_br {{%.*}}, [[CASE3_GUARD:bb[0-9]+]], [[NOT_CASE3:bb[0-9]+]]
+ // CHECK: [[CASE3_GUARD]]:
+ // CHECK: function_ref @$S6switch6runcedSbyF
+ // CHECK: cond_br {{%.*}}, [[CASE3:bb[0-9]+]], [[NOT_CASE3_GUARD:bb[0-9]+]]
+ case (_, bar()) where runced():
+ // CHECK: [[CASE3]]:
+ // CHECK: function_ref @$S6switch1cyyF
+ // CHECK: br [[CONT]]
+ c()
+ // CHECK: [[NOT_CASE3_GUARD]]:
+ // CHECK: [[NOT_CASE3]]:
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: cond_br {{%.*}}, [[CASE4_GUARD_1:bb[0-9]+]], [[NOT_CASE4_1:bb[0-9]+]]
+ // CHECK: [[CASE4_GUARD_1]]:
+ // CHECK: function_ref @$S6switch3barSiyF
+ // CHECK: cond_br {{%.*}}, [[CASE4_GUARD_2:bb[0-9]+]], [[NOT_CASE4_2:bb[0-9]+]]
+ // CHECK: [[CASE4_GUARD_2]]:
+ // CHECK: function_ref @$S6switch6fungedSbyF
+ // CHECK: cond_br {{%.*}}, [[CASE4:bb[0-9]+]], [[NOT_CASE4_3:bb[0-9]+]]
+ case (foo(), bar()) where funged():
+ // CHECK: [[CASE4]]:
+ // CHECK: function_ref @$S6switch1dyyF
+ // CHECK: br [[CONT]]
+ d()
+ // CHECK: [[NOT_CASE4_3]]:
+ // CHECK: [[NOT_CASE4_2]]:
+ // CHECK: [[NOT_CASE4_1]]:
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: cond_br {{%.*}}, [[CASE5_GUARD_1:bb[0-9]+]], [[NOT_CASE5:bb[0-9]+]]
+ // CHECK: [[CASE5_GUARD_1]]:
+ // CHECK: function_ref @$S6switch3barSiyF
+ // CHECK: cond_br {{%.*}}, [[YES_CASE5:bb[0-9]+]], [[NOT_CASE5:bb[0-9]+]]
+ // CHECK: [[YES_CASE5]]:
+ case (foo(), bar()):
+ // CHECK: function_ref @$S6switch1eyyF
+ // CHECK: br [[CONT]]
+ e()
+ // CHECK: [[NOT_CASE5]]:
+ // CHECK: br [[CASE6:bb[0-9]+]]
+ case _:
+ // CHECK: [[CASE6]]:
+ // CHECK: function_ref @$S6switch1fyyF
+ // CHECK: br [[CONT]]
+ f()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1gyyF
+ g()
+}
+
+// CHECK-LABEL: sil hidden @$S6switch5test9yyF
+func test9() {
+ switch (foo(), bar()) {
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: function_ref @$S6switch3barSiyF
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: cond_br {{%.*}}, [[YES_CASE1:bb[0-9]+]], [[NOT_CASE1:bb[0-9]+]]
+ // CHECK: [[YES_CASE1]]:
+ case (foo(), _):
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+
+ // CHECK: [[NOT_CASE1]]:
+ // CHECK: function_ref @$S6switch6foobarSi_SityF
+ // CHECK: cond_br {{%.*}}, [[CASE2:bb[0-9]+]], [[NOT_CASE2:bb[0-9]+]]
+ case foobar():
+ // CHECK: [[CASE2]]:
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[CONT]]
+ b()
+
+ // CHECK: [[NOT_CASE2]]:
+ // CHECK: br [[CASE3:bb[0-9]+]]
+ case _:
+ // CHECK: [[CASE3]]:
+ // CHECK: function_ref @$S6switch1cyyF
+ // CHECK: br [[CONT]]
+ c()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1dyyF
+ d()
+}
+
+// CHECK-LABEL: sil hidden @$S6switch6test10yyF
+func test10() {
+ switch (foo(), bar()) {
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: function_ref @$S6switch3barSiyF
+ // CHECK: cond_br {{%.*}}, [[YES_CASE1:bb[0-9]+]], [[NOT_CASE1:bb[0-9]+]]
+ // CHECK: [[YES_CASE1]]:
+ case (foo()...bar(), _):
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+
+ // CHECK: [[NOT_CASE1]]:
+ // CHECK: br [[CASE2:bb[0-9]+]]
+ case _:
+ // CHECK: [[CASE2]]:
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[CONT]]
+ b()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1cyyF
+ c()
+}
+
+protocol P { func p() }
+
+struct X : P { func p() {} }
+struct Y : P { func p() {} }
+struct Z : P { func p() {} }
+
+// CHECK-LABEL: sil hidden @$S6switch10test_isa_11pyAA1P_p_tF
+func test_isa_1(p: P) {
+ // CHECK: [[PTMPBUF:%[0-9]+]] = alloc_stack $P
+ // CHECK-NEXT: copy_addr %0 to [initialization] [[PTMPBUF]] : $*P
+ switch p {
+ // CHECK: [[TMPBUF:%[0-9]+]] = alloc_stack $X
+ // CHECK: checked_cast_addr_br copy_on_success P in [[P:%.*]] : $*P to X in [[TMPBUF]] : $*X, [[IS_X:bb[0-9]+]], [[IS_NOT_X:bb[0-9]+]]
+
+ case is X:
+ // CHECK: [[IS_X]]:
+ // CHECK-NEXT: load [trivial] [[TMPBUF]]
+ // CHECK-NEXT: dealloc_stack [[TMPBUF]]
+ // CHECK-NEXT: destroy_addr [[PTMPBUF]]
+ // CHECK-NEXT: dealloc_stack [[PTMPBUF]]
+ a()
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+
+ // CHECK: [[IS_NOT_X]]:
+ // CHECK: checked_cast_addr_br copy_on_success P in [[P]] : $*P to Y in {{%.*}} : $*Y, [[IS_Y:bb[0-9]+]], [[IS_NOT_Y:bb[0-9]+]]
+
+// CHECK: [[IS_Y]]:
+ case is Y:
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[Y_CONT:bb[0-9]+]]
+ b()
+
+ // CHECK: [[IS_NOT_Y]]:
+ // CHECK: checked_cast_addr_br copy_on_success P in [[P]] : $*P to Z in {{%.*}} : $*Z, [[IS_Z:bb[0-9]+]], [[IS_NOT_Z:bb[0-9]+]]
+
+ // CHECK: [[IS_Z]]:
+ case is Z:
+ // CHECK: function_ref @$S6switch1cyyF
+ // CHECK: br [[Z_CONT:bb[0-9]+]]
+ c()
+
+ // CHECK: [[IS_NOT_Z]]:
+ case _:
+ // CHECK: function_ref @$S6switch1dyyF
+ // CHECK: br [[CONT]]
+ d()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1eyyF
+ e()
+}
+
+// CHECK-LABEL: sil hidden @$S6switch10test_isa_21pyAA1P_p_tF
+func test_isa_2(p: P) {
+ switch (p, foo()) {
+ // CHECK: checked_cast_addr_br copy_on_success P in [[P:%.*]] : $*P to X in {{%.*}} : $*X, [[IS_X:bb[0-9]+]], [[IS_NOT_X:bb[0-9]+]]
+
+ // CHECK: [[IS_X]]:
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: cond_br {{%.*}}, [[CASE1:bb[0-9]+]], [[NOT_CASE1:bb[0-9]+]]
+ case (is X, foo()):
+ // CHECK: [[CASE1]]:
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+
+ // CHECK: [[IS_NOT_X]]:
+ // CHECK: checked_cast_addr_br copy_on_success P in [[P]] : $*P to Y in {{%.*}} : $*Y, [[IS_Y:bb[0-9]+]], [[IS_NOT_Y:bb[0-9]+]]
+
+ // CHECK: [[IS_Y]]:
+ // CHECK: function_ref @$S6switch3fooSiyF
+ // CHECK: cond_br {{%.*}}, [[CASE2:bb[0-9]+]], [[NOT_CASE2:bb[0-9]+]]
+ case (is Y, foo()):
+ // CHECK: [[CASE2]]:
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[CONT]]
+ b()
+
+ // CHECK: [[NOT_CASE2]]:
+ // CHECK: [[IS_NOT_Y]]:
+
+ // CHECK: checked_cast_addr_br copy_on_success P in [[P:%.*]] : $*P to X in {{%.*}} : $*X, [[CASE3:bb[0-9]+]], [[IS_NOT_X:bb[0-9]+]]
+
+ case (is X, _):
+ // CHECK: [[CASE3]]:
+ // CHECK: function_ref @$S6switch1cyyF
+ // CHECK: br [[CONT]]
+ c()
+
+ // -- case (is Y, foo()):
+ // CHECK: [[IS_NOT_X]]:
+ // CHECK: checked_cast_addr_br copy_on_success P in [[P]] : $*P to Y in {{%.*}} : $*Y, [[IS_Y:bb[0-9]+]], [[IS_NOT_Y:bb[0-9]+]]
+ // CHECK: [[IS_Y]]:
+ // CHECK: function_ref @$S6switch3barSiyF
+ // CHECK: cond_br {{%.*}}, [[CASE4:bb[0-9]+]], [[NOT_CASE4:bb[0-9]+]]
+ case (is Y, bar()):
+ // CHECK: [[CASE4]]:
+ // CHECK: function_ref @$S6switch1dyyF
+ // CHECK: br [[CONT]]
+ d()
+
+ // CHECK: [[NOT_CASE4]]:
+ // CHECK: br [[CASE5:bb[0-9]+]]
+ // CHECK: [[IS_NOT_Y]]:
+ // CHECK: br [[CASE5]]
+ case _:
+ // CHECK: [[CASE5]]:
+ // CHECK: function_ref @$S6switch1eyyF
+ // CHECK: br [[CONT]]
+ e()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1fyyF
+ f()
+}
+
+class B {}
+class C : B {}
+class D1 : C {}
+class D2 : D1 {}
+class E : C {}
+
+// CHECK-LABEL: sil hidden @$S6switch16test_isa_class_11xyAA1BC_tF : $@convention(thin) (@guaranteed B) -> () {
+func test_isa_class_1(x: B) {
+ // CHECK: bb0([[X:%.*]] : $B):
+ // CHECK: [[X_COPY:%.*]] = copy_value [[X]]
+ // CHECK: checked_cast_br [[X_COPY]] : $B to $D1, [[IS_D1:bb[0-9]+]], [[IS_NOT_D1:bb[0-9]+]]
+ switch x {
+
+ // CHECK: [[IS_D1]]([[CAST_D1:%.*]]):
+ // CHECK: [[CAST_D1_COPY:%.*]] = copy_value [[CAST_D1]]
+ // CHECK: function_ref @$S6switch6runcedSbyF : $@convention(thin) () -> Bool
+ // CHECK: cond_br {{%.*}}, [[YES_CASE1:bb[0-9]+]], [[NO_CASE1:bb[0-9]+]]
+
+ // CHECK: [[YES_CASE1]]:
+ case is D1 where runced():
+ // CHECK: destroy_value [[CAST_D1_COPY]]
+ // CHECK: destroy_value [[X_COPY]]
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+
+ // CHECK: [[NO_CASE1]]:
+ // CHECK: destroy_value [[CAST_D1_COPY]]
+ // CHECK: br [[NEXT_CASE:bb5]]
+
+ // CHECK: [[IS_NOT_D1]]:
+ // CHECK: br [[NEXT_CASE]]
+
+ // CHECK: [[NEXT_CASE]]
+ // CHECK: checked_cast_br [[X_COPY]] : $B to $D2, [[IS_D2:bb[0-9]+]], [[IS_NOT_D2:bb[0-9]+]]
+ case is D2:
+ // CHECK: [[IS_D2]]([[CAST_D2:%.*]]):
+ // CHECK: [[CAST_D2_COPY:%.*]] = copy_value [[CAST_D2]]
+ // CHECK: destroy_value [[CAST_D2_COPY]]
+ // CHECK: destroy_value [[X_COPY]]
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[CONT]]
+ b()
+
+ // CHECK: [[IS_NOT_D2]]:
+ // CHECK: br [[NEXT_CASE:bb8]]
+
+ // CHECK: [[NEXT_CASE]]:
+ // CHECK: checked_cast_br [[X_COPY]] : $B to $E, [[IS_E:bb[0-9]+]], [[IS_NOT_E:bb[0-9]+]]
+ case is E where funged():
+ // CHECK: [[IS_E]]([[CAST_E:%.*]]):
+ // CHECK: [[CAST_E_COPY:%.*]] = copy_value [[CAST_E]]
+ // CHECK: function_ref @$S6switch6fungedSbyF
+ // CHECK: cond_br {{%.*}}, [[CASE3:bb[0-9]+]], [[NO_CASE3:bb[0-9]+]]
+
+ // CHECK: [[CASE3]]:
+ // CHECK: destroy_value [[CAST_E_COPY]]
+ // CHECK: destroy_value [[X_COPY]]
+ // CHECK: function_ref @$S6switch1cyyF
+ // CHECK: br [[CONT]]
+ c()
+
+ // CHECK: [[NO_CASE3]]:
+ // CHECK: destroy_value [[CAST_E_COPY]]
+ // CHECK: br [[NEXT_CASE:bb13]]
+
+ // CHECK: [[IS_NOT_E]]:
+ // CHECK: br [[NEXT_CASE]]
+
+ // CHECK: [[NEXT_CASE]]
+ // CHECK: checked_cast_br [[X_COPY]] : $B to $C, [[IS_C:bb[0-9]+]], [[IS_NOT_C:bb[0-9]+]]
+
+ case is C:
+ // CHECK: [[IS_C]]([[CAST_C:%.*]]):
+ // CHECK: [[CAST_C_COPY:%.*]] = copy_value [[CAST_C]]
+ // CHECK: destroy_value [[CAST_C_COPY]]
+ // CHECK: destroy_value [[X_COPY]]
+ // CHECK: function_ref @$S6switch1dyyF
+ // CHECK: br [[CONT]]
+ d()
+
+ // CHECK: [[IS_NOT_C]]:
+ // CHECK: br [[NEXT_CASE:bb16]]
+
+ // CHECK: [[NEXT_CASE]]:
+ default:
+ // CHECK: destroy_value [[X_COPY]]
+ // CHECK: function_ref @$S6switch1eyyF
+ // CHECK: br [[CONT]]
+ e()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: [[F_FUNC:%.*]] = function_ref @$S6switch1fyyF : $@convention(thin) () -> ()
+ // CHECK: apply [[F_FUNC]]()
+ f()
+}
+// CHECK: } // end sil function '$S6switch16test_isa_class_11xyAA1BC_tF'
+
+// CHECK-LABEL: sil hidden @$S6switch16test_isa_class_21xyXlAA1BC_tF : $@convention(thin)
+func test_isa_class_2(x: B) -> AnyObject {
+ // CHECK: bb0([[X:%.*]] : $B):
+ // CHECK: [[X_COPY:%.*]] = copy_value [[X]]
+ switch x {
+
+ // CHECK: checked_cast_br [[X_COPY]] : $B to $D1, [[IS_D1:bb[0-9]+]], [[IS_NOT_D1:bb[0-9]+]]
+ case let y as D1 where runced():
+ // CHECK: [[IS_D1]]([[CAST_D1:%.*]] : $D1):
+ // CHECK: [[CAST_D1_COPY:%.*]] = copy_value [[CAST_D1]]
+ // CHECK: function_ref @$S6switch6runcedSbyF
+ // CHECK: cond_br {{%.*}}, [[CASE1:bb[0-9]+]], [[NO_CASE1:bb[0-9]+]]
+
+ // CHECK: [[CASE1]]:
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: [[BORROWED_CAST_D1_COPY:%.*]] = begin_borrow [[CAST_D1_COPY]]
+ // CHECK: [[CAST_D1_COPY_COPY:%.*]] = copy_value [[BORROWED_CAST_D1_COPY]]
+ // CHECK: [[RET:%.*]] = init_existential_ref [[CAST_D1_COPY_COPY]]
+ // CHECK: end_borrow [[BORROWED_CAST_D1_COPY]] from [[CAST_D1_COPY]]
+ // CHECK: destroy_value [[CAST_D1_COPY]]
+ // CHECK: destroy_value [[X_COPY]] : $B
+ // CHECK: br [[CONT:bb[0-9]+]]([[RET]] : $AnyObject)
+ a()
+ return y
+
+ // CHECK: [[NO_CASE1]]:
+ // CHECK: destroy_value [[CAST_D1_COPY]]
+ // CHECK: br [[NEXT_CASE:bb5]]
+
+ // CHECK: [[IS_NOT_D1]]:
+ // CHECK: br [[NEXT_CASE]]
+
+ // CHECK: [[NEXT_CASE]]:
+ // CHECK: checked_cast_br [[X_COPY]] : $B to $D2, [[CASE2:bb[0-9]+]], [[IS_NOT_D2:bb[0-9]+]]
+ case let y as D2:
+ // CHECK: [[CASE2]]([[CAST_D2:%.*]]):
+ // CHECK: [[CAST_D2_COPY:%.*]] = copy_value [[CAST_D2]]
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: [[BORROWED_CAST_D2_COPY:%.*]] = begin_borrow [[CAST_D2_COPY]]
+ // CHECK: [[CAST_D2_COPY_COPY:%.*]] = copy_value [[BORROWED_CAST_D2_COPY]]
+ // CHECK: [[RET:%.*]] = init_existential_ref [[CAST_D2_COPY_COPY]]
+ // CHECK: end_borrow [[BORROWED_CAST_D2_COPY]] from [[CAST_D2_COPY]]
+ // CHECK: destroy_value [[CAST_D2_COPY]]
+ // CHECK: destroy_value [[X_COPY]]
+ // CHECK: br [[CONT]]([[RET]] : $AnyObject)
+ b()
+ return y
+
+ // CHECK: [[IS_NOT_D2]]:
+ // CHECK: br [[NEXT_CASE:bb8]]
+
+ // CHECK: [[NEXT_CASE]]:
+ // CHECK: checked_cast_br [[X_COPY]] : $B to $E, [[IS_E:bb[0-9]+]], [[IS_NOT_E:bb[0-9]+]]
+ case let y as E where funged():
+ // CHECK: [[IS_E]]([[CAST_E:%.*]]):
+ // CHECK: [[CAST_E_COPY:%.*]] = copy_value [[CAST_E]]
+ // CHECK: function_ref @$S6switch6fungedSbyF
+ // CHECK: cond_br {{%.*}}, [[CASE3:bb[0-9]+]], [[NO_CASE3:bb[0-9]+]]
+
+ // CHECK: [[CASE3]]:
+ // CHECK: function_ref @$S6switch1cyyF
+ // CHECK: [[BORROWED_CAST_E_COPY:%.*]] = begin_borrow [[CAST_E_COPY]]
+ // CHECK: [[CAST_E_COPY_COPY:%.*]] = copy_value [[BORROWED_CAST_E_COPY]]
+ // CHECK: [[RET:%.*]] = init_existential_ref [[CAST_E_COPY_COPY]]
+ // CHECK: end_borrow [[BORROWED_CAST_E_COPY]] from [[CAST_E_COPY]]
+ // CHECK: destroy_value [[CAST_E_COPY]]
+ // CHECK: destroy_value [[X_COPY]] : $B
+ // CHECK: br [[CONT]]([[RET]] : $AnyObject)
+ c()
+ return y
+
+ // CHECK: [[NO_CASE3]]:
+ // CHECK destroy_value [[CAST_E_COPY]]
+ // CHECK: br [[NEXT_CASE:bb13]]
+
+ // CHECK: [[IS_NOT_E]]:
+ // CHECK: br [[NEXT_CASE]]
+
+ // CHECK: [[NEXT_CASE]]
+ // CHECK: checked_cast_br [[X_COPY]] : $B to $C, [[CASE4:bb[0-9]+]], [[IS_NOT_C:bb[0-9]+]]
+ case let y as C:
+ // CHECK: [[CASE4]]([[CAST_C:%.*]]):
+ // CHECK: [[CAST_C_COPY:%.*]] = copy_value [[CAST_C]]
+ // CHECK: function_ref @$S6switch1dyyF
+ // CHECK: [[BORROWED_CAST_C_COPY:%.*]] = begin_borrow [[CAST_C_COPY]]
+ // CHECK: [[CAST_C_COPY_COPY:%.*]] = copy_value [[BORROWED_CAST_C_COPY]]
+ // CHECK: [[RET:%.*]] = init_existential_ref [[CAST_C_COPY_COPY]]
+ // CHECK: end_borrow [[BORROWED_CAST_C_COPY]] from [[CAST_C_COPY]]
+ // CHECK: destroy_value [[CAST_C_COPY]]
+ // CHECK: destroy_value [[X_COPY]]
+ // CHECK: br [[CONT]]([[RET]] : $AnyObject)
+ d()
+ return y
+
+ // CHECK: [[IS_NOT_C]]:
+ // CHECK: br [[NEXT_CASE:bb16]]
+
+ // CHECK: [[NEXT_CASE]]:
+ default:
+ // CHECK: destroy_value [[X_COPY]]
+ // CHECK: function_ref @$S6switch1eyyF
+ // CHECK: [[X_COPY_2:%.*]] = copy_value [[X]]
+ // CHECK: [[RET:%.*]] = init_existential_ref [[X_COPY_2]]
+ // CHECK: br [[CONT]]([[RET]] : $AnyObject)
+ e()
+ return x
+ }
+
+ // CHECK: [[CONT]]([[T0:%.*]] : $AnyObject):
+ // CHECK: return [[T0]]
+}
+// CHECK: } // end sil function '$S6switch16test_isa_class_21xyXlAA1BC_tF'
+
+enum MaybePair {
+ case Neither
+ case Left(Int)
+ case Right(String)
+ case Both(Int, String)
+}
+
+// CHECK-LABEL: sil hidden @$S6switch12test_union_11uyAA9MaybePairO_tF
+func test_union_1(u: MaybePair) {
+ switch u {
+ // CHECK: switch_enum [[SUBJECT:%.*]] : $MaybePair,
+ // CHECK: case #MaybePair.Neither!enumelt: [[IS_NEITHER:bb[0-9]+]],
+ // CHECK: case #MaybePair.Left!enumelt.1: [[IS_LEFT:bb[0-9]+]],
+ // CHECK: case #MaybePair.Right!enumelt.1: [[IS_RIGHT:bb[0-9]+]],
+ // CHECK: case #MaybePair.Both!enumelt.1: [[IS_BOTH:bb[0-9]+]]
+
+ // CHECK: [[IS_NEITHER]]:
+ // CHECK-NOT: destroy_value
+ case .Neither:
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+
+ // CHECK: [[IS_LEFT]]({{%.*}}):
+ // CHECK-NOT: destroy_value
+ case (.Left):
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[CONT]]
+ b()
+
+ // CHECK: [[IS_RIGHT]]([[STR:%.*]] : $String):
+ case var .Right:
+ // CHECK: destroy_value [[STR]] : $String
+ // CHECK: function_ref @$S6switch1cyyF
+ // CHECK: br [[CONT]]
+ c()
+
+ // CHECK: [[IS_BOTH]]([[TUP:%.*]] : $(Int, String)):
+ case .Both:
+ // CHECK: tuple_extract [[TUP]] : $(Int, String), 0
+ // CHECK: [[TUP_STR:%.*]] = tuple_extract [[TUP]] : $(Int, String), 1
+ // CHECK: destroy_value [[TUP_STR]] : $String
+ // CHECK: function_ref @$S6switch1dyyF
+ // CHECK: br [[CONT]]
+ d()
+ }
+
+ // CHECK: [[CONT]]:
+ // CHECK-NOT: switch_enum [[SUBJECT]]
+ // CHECK: function_ref @$S6switch1eyyF
+ e()
+}
+
+// CHECK-LABEL: sil hidden @$S6switch12test_union_31uyAA9MaybePairO_tF : $@convention(thin) (@guaranteed MaybePair) -> () {
+func test_union_3(u: MaybePair) {
+ // CHECK: bb0([[ARG:%.*]] : $MaybePair):
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: switch_enum [[SUBJECT]] : $MaybePair,
+ // CHECK: case #MaybePair.Neither!enumelt: [[IS_NEITHER:bb[0-9]+]],
+ // CHECK: case #MaybePair.Left!enumelt.1: [[IS_LEFT:bb[0-9]+]],
+ // CHECK: case #MaybePair.Right!enumelt.1: [[IS_RIGHT:bb[0-9]+]],
+ // CHECK: default [[DEFAULT:bb[0-9]+]]
+ switch u {
+ // CHECK: [[IS_NEITHER]]:
+ case .Neither:
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+
+ // CHECK: [[IS_LEFT]]({{%.*}}):
+ case .Left:
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[CONT]]
+ b()
+
+ // CHECK: [[IS_RIGHT]]([[STR:%.*]] : $String):
+ case .Right:
+ // CHECK: destroy_value [[STR]] : $String
+ // CHECK: function_ref @$S6switch1cyyF
+ // CHECK: br [[CONT]]
+ c()
+
+ // CHECK: [[DEFAULT]]:
+ // -- Ensure the fully-opaque value is destroyed in the default case.
+ // CHECK: destroy_value [[ARG_COPY]] :
+ // CHECK: function_ref @$S6switch1dyyF
+ // CHECK: br [[CONT]]
+
+ default:
+ d()
+ }
+
+ // CHECK: [[CONT]]:
+ // CHECK-NOT: switch_enum [[ARG]]
+ // CHECK: function_ref @$S6switch1eyyF
+ e()
+}
+
+// CHECK-LABEL: sil hidden @$S6switch12test_union_41uyAA9MaybePairO_tF
+func test_union_4(u: MaybePair) {
+ switch u {
+ // CHECK: switch_enum {{%.*}} : $MaybePair,
+ // CHECK: case #MaybePair.Neither!enumelt: [[IS_NEITHER:bb[0-9]+]],
+ // CHECK: case #MaybePair.Left!enumelt.1: [[IS_LEFT:bb[0-9]+]],
+ // CHECK: case #MaybePair.Right!enumelt.1: [[IS_RIGHT:bb[0-9]+]],
+ // CHECK: case #MaybePair.Both!enumelt.1: [[IS_BOTH:bb[0-9]+]]
+
+ // CHECK: [[IS_NEITHER]]:
+ case .Neither(_):
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+
+ // CHECK: [[IS_LEFT]]({{%.*}}):
+ case .Left(_):
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[CONT]]
+ b()
+
+ // CHECK: [[IS_RIGHT]]({{%.*}}):
+ case .Right(_):
+ // CHECK: function_ref @$S6switch1cyyF
+ // CHECK: br [[CONT]]
+ c()
+
+ // CHECK: [[IS_BOTH]]({{%.*}}):
+ case .Both(_):
+ // CHECK: function_ref @$S6switch1dyyF
+ // CHECK: br [[CONT]]
+ d()
+ }
+
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1eyyF
+ e()
+}
+
+// CHECK-LABEL: sil hidden @$S6switch12test_union_51uyAA9MaybePairO_tF
+func test_union_5(u: MaybePair) {
+ switch u {
+ // CHECK: switch_enum {{%.*}} : $MaybePair,
+ // CHECK: case #MaybePair.Neither!enumelt: [[IS_NEITHER:bb[0-9]+]],
+ // CHECK: case #MaybePair.Left!enumelt.1: [[IS_LEFT:bb[0-9]+]],
+ // CHECK: case #MaybePair.Right!enumelt.1: [[IS_RIGHT:bb[0-9]+]],
+ // CHECK: case #MaybePair.Both!enumelt.1: [[IS_BOTH:bb[0-9]+]]
+
+ // CHECK: [[IS_NEITHER]]:
+ case .Neither():
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+
+ // CHECK: [[IS_LEFT]]({{%.*}}):
+ case .Left(_):
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[CONT]]
+ b()
+
+ // CHECK: [[IS_RIGHT]]({{%.*}}):
+ case .Right(_):
+ // CHECK: function_ref @$S6switch1cyyF
+ // CHECK: br [[CONT]]
+ c()
+
+ // CHECK: [[IS_BOTH]]({{%.*}}):
+ case .Both(_, _):
+ // CHECK: function_ref @$S6switch1dyyF
+ // CHECK: br [[CONT]]
+ d()
+ }
+
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1eyyF
+ e()
+}
+
+enum MaybeAddressOnlyPair {
+ case Neither
+ case Left(P)
+ case Right(String)
+ case Both(P, String)
+}
+
+// CHECK-LABEL: sil hidden @$S6switch22test_union_addr_only_11uyAA20MaybeAddressOnlyPairO_tF
+func test_union_addr_only_1(u: MaybeAddressOnlyPair) {
+ switch u {
+ // CHECK: switch_enum_addr [[ENUM_ADDR:%.*]] : $*MaybeAddressOnlyPair,
+ // CHECK: case #MaybeAddressOnlyPair.Neither!enumelt: [[IS_NEITHER:bb[0-9]+]],
+ // CHECK: case #MaybeAddressOnlyPair.Left!enumelt.1: [[IS_LEFT:bb[0-9]+]],
+ // CHECK: case #MaybeAddressOnlyPair.Right!enumelt.1: [[IS_RIGHT:bb[0-9]+]],
+ // CHECK: case #MaybeAddressOnlyPair.Both!enumelt.1: [[IS_BOTH:bb[0-9]+]]
+
+ // CHECK: [[IS_NEITHER]]:
+ case .Neither:
+ // CHECK: function_ref @$S6switch1ayyF
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+
+ // CHECK: [[IS_LEFT]]:
+ // CHECK: [[P:%.*]] = unchecked_take_enum_data_addr [[ENUM_ADDR]] : $*MaybeAddressOnlyPair, #MaybeAddressOnlyPair.Left!enumelt.1
+ case .Left(_):
+ // CHECK: destroy_addr [[P]]
+ // CHECK: function_ref @$S6switch1byyF
+ // CHECK: br [[CONT]]
+ b()
+
+ // CHECK: [[IS_RIGHT]]:
+ // CHECK: [[STR_ADDR:%.*]] = unchecked_take_enum_data_addr [[ENUM_ADDR]] : $*MaybeAddressOnlyPair, #MaybeAddressOnlyPair.Right!enumelt.1
+ // CHECK: [[STR:%.*]] = load [take] [[STR_ADDR]]
+ case .Right(_):
+ // CHECK: destroy_value [[STR]] : $String
+ // CHECK: function_ref @$S6switch1cyyF
+ // CHECK: br [[CONT]]
+ c()
+
+ // CHECK: [[IS_BOTH]]:
+ // CHECK: [[P_STR_TUPLE:%.*]] = unchecked_take_enum_data_addr [[ENUM_ADDR]] : $*MaybeAddressOnlyPair, #MaybeAddressOnlyPair.Both!enumelt.1
+ case .Both(_):
+ // CHECK: destroy_addr [[P_STR_TUPLE]]
+ // CHECK: function_ref @$S6switch1dyyF
+ // CHECK: br [[CONT]]
+ d()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S6switch1eyyF
+ e()
+}
+
+enum Generic<T, U> {
+ case Foo(T)
+ case Bar(U)
+}
+
+// Check that switching over a generic instance generates verified SIL.
+func test_union_generic_instance(u: Generic<Int, String>) {
+ switch u {
+ case .Foo(var x):
+ a()
+ case .Bar(var y):
+ b()
+ }
+ c()
+}
+
+enum Foo { case A, B }
+
+// CHECK-LABEL: sil hidden @$S6switch05test_A11_two_unions1x1yyAA3FooO_AFtF
+func test_switch_two_unions(x: Foo, y: Foo) {
+ // CHECK: [[T0:%.*]] = tuple (%0 : $Foo, %1 : $Foo)
+ // CHECK: [[X:%.*]] = tuple_extract [[T0]] : $(Foo, Foo), 0
+ // CHECK: [[Y:%.*]] = tuple_extract [[T0]] : $(Foo, Foo), 1
+
+ // CHECK: switch_enum [[Y]] : $Foo, case #Foo.A!enumelt: [[IS_CASE1:bb[0-9]+]], default [[IS_NOT_CASE1:bb[0-9]+]]
+
+ switch (x, y) {
+ // CHECK: [[IS_CASE1]]:
+ case (_, Foo.A):
+ // CHECK: function_ref @$S6switch1ayyF
+ a()
+
+ // CHECK: [[IS_NOT_CASE1]]:
+ // CHECK: switch_enum [[X]] : $Foo, case #Foo.B!enumelt: [[IS_CASE2:bb[0-9]+]], default [[IS_NOT_CASE2:bb[0-9]+]]
+ // CHECK: [[IS_CASE2]]:
+ case (Foo.B, _):
+ // CHECK: function_ref @$S6switch1byyF
+ b()
+
+ // CHECK: [[IS_NOT_CASE2]]:
+ // CHECK: switch_enum [[Y]] : $Foo, case #Foo.B!enumelt: [[IS_CASE3:bb[0-9]+]], default [[UNREACHABLE:bb[0-9]+]]
+ // CHECK: [[IS_CASE3]]:
+ case (_, Foo.B):
+ // CHECK: function_ref @$S6switch1cyyF
+ c()
+
+ // CHECK: [[UNREACHABLE]]:
+ // CHECK: unreachable
+ }
+}
+
+
+// <rdar://problem/14826416>
+func rdar14826416<T, U>(t: T, u: U) {
+ switch t {
+ case is Int: markUsed("Int")
+ case is U: markUsed("U")
+ case _: markUsed("other")
+ }
+}
+// CHECK-LABEL: sil hidden @$S6switch12rdar14826416{{[_0-9a-zA-Z]*}}F
+// CHECK: checked_cast_addr_br copy_on_success T in {{%.*}} : $*T to Int in {{%.*}} : $*Int, [[IS_INT:bb[0-9]+]], [[ISNT_INT:bb[0-9]+]]
+// CHECK: [[ISNT_INT]]:
+// CHECK: checked_cast_addr_br copy_on_success T in {{%.*}} : $*T to U in {{%.*}} : $*U, [[ISNT_INT_IS_U:bb[0-9]+]], [[ISNT_INT_ISNT_U:bb[0-9]+]]
+
+// <rdar://problem/14835992>
+class Rdar14835992 {}
+class SubRdar14835992 : Rdar14835992 {}
+
+// CHECK-LABEL: sil hidden @$S6switch12rdar14835992{{[_0-9a-zA-Z]*}}F
+func rdar14835992<T, U>(t: Rdar14835992, tt: T, uu: U) {
+ switch t {
+ case is SubRdar14835992: markUsed("Sub")
+ case is T: markUsed("T")
+ case is U: markUsed("U")
+ case _: markUsed("other")
+ }
+}
+
+
+
+
+// <rdar://problem/17272985>
+enum ABC { case A, B, C }
+
+// CHECK-LABEL: sil hidden @$S6switch18testTupleWildcardsyyAA3ABCO_ADtF
+// CHECK: [[X:%.*]] = tuple_extract {{%.*}} : $(ABC, ABC), 0
+// CHECK: [[Y:%.*]] = tuple_extract {{%.*}} : $(ABC, ABC), 1
+// CHECK: switch_enum [[X]] : $ABC, case #ABC.A!enumelt: [[X_A:bb[0-9]+]], default [[X_NOT_A:bb[0-9]+]]
+// CHECK: [[X_A]]:
+// CHECK: function_ref @$S6switch1ayyF
+// CHECK: [[X_NOT_A]]:
+// CHECK: switch_enum [[Y]] : $ABC, case #ABC.A!enumelt: [[Y_A:bb[0-9]+]], case #ABC.B!enumelt: [[Y_B:bb[0-9]+]], case #ABC.C!enumelt: [[Y_C:bb[0-9]+]]
+// CHECK-NOT: default
+// CHECK: [[Y_A]]:
+// CHECK: function_ref @$S6switch1byyF
+// CHECK: [[Y_B]]:
+// CHECK: function_ref @$S6switch1cyyF
+// CHECK: [[Y_C]]:
+// CHECK: switch_enum [[X]] : $ABC, case #ABC.C!enumelt: [[X_C:bb[0-9]+]], default [[X_NOT_C:bb[0-9]+]]
+// CHECK: [[X_C]]:
+// CHECK: function_ref @$S6switch1dyyF
+// CHECK: [[X_NOT_C]]:
+// CHECK: function_ref @$S6switch1eyyF
+func testTupleWildcards(_ x: ABC, _ y: ABC) {
+ switch (x, y) {
+ case (.A, _):
+ a()
+ case (_, .A):
+ b()
+ case (_, .B):
+ c()
+ case (.C, .C):
+ d()
+ default:
+ e()
+ }
+}
+
+enum LabeledScalarPayload {
+ case Payload(name: Int)
+}
+
+// CHECK-LABEL: sil hidden @$S6switch24testLabeledScalarPayloadyypAA0cdE0OF
+func testLabeledScalarPayload(_ lsp: LabeledScalarPayload) -> Any {
+ // CHECK: switch_enum {{%.*}}, case #LabeledScalarPayload.Payload!enumelt.1: bb1
+ switch lsp {
+ // CHECK: bb1([[TUPLE:%.*]] : $(name: Int)):
+ // CHECK: [[X:%.*]] = tuple_extract [[TUPLE]]
+ // CHECK: [[ANY_X_ADDR:%.*]] = init_existential_addr {{%.*}}, $Int
+ // CHECK: store [[X]] to [trivial] [[ANY_X_ADDR]]
+ case let .Payload(x):
+ return x
+ }
+}
+
+// There should be no unreachable generated.
+// CHECK-LABEL: sil hidden @$S6switch19testOptionalPatternyySiSgF
+func testOptionalPattern(_ value : Int?) {
+ // CHECK: switch_enum %0 : $Optional<Int>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: [[NILBB:bb[0-9]+]]
+ switch value {
+ case 1?: a()
+ case 2?: b()
+ case nil: d()
+ default: e()
+ }
+}
+
+
+// x? and .none should both be considered "similar" and thus handled in the same
+// switch on the enum kind. There should be no unreachable generated.
+// CHECK-LABEL: sil hidden @$S6switch19testOptionalEnumMixyS2iSgF
+func testOptionalEnumMix(_ a : Int?) -> Int {
+ // CHECK: debug_value %0 : $Optional<Int>, let, name "a"
+ // CHECK-NEXT: switch_enum %0 : $Optional<Int>, case #Optional.some!enumelt.1: [[SOMEBB:bb[0-9]+]], case #Optional.none!enumelt: [[NILBB:bb[0-9]+]]
+ switch a {
+ case let x?:
+ return 0
+
+ // CHECK: [[SOMEBB]](%3 : $Int):
+ // CHECK-NEXT: debug_value %3 : $Int, let, name "x"
+ // CHECK: integer_literal $Builtin.Int2048, 0
+
+ case .none:
+ return 42
+
+ // CHECK: [[NILBB]]:
+ // CHECK: integer_literal $Builtin.Int2048, 42
+ }
+}
+
+// x? and nil should both be considered "similar" and thus handled in the same
+// switch on the enum kind. There should be no unreachable generated.
+// CHECK-LABEL: sil hidden @$S6switch26testOptionalEnumMixWithNilyS2iSgF
+func testOptionalEnumMixWithNil(_ a : Int?) -> Int {
+ // CHECK: debug_value %0 : $Optional<Int>, let, name "a"
+ // CHECK-NEXT: switch_enum %0 : $Optional<Int>, case #Optional.some!enumelt.1: [[SOMEBB:bb[0-9]+]], case #Optional.none!enumelt: [[NILBB:bb[0-9]+]]
+ switch a {
+ case let x?:
+ return 0
+
+ // CHECK: [[SOMEBB]](%3 : $Int):
+ // CHECK-NEXT: debug_value %3 : $Int, let, name "x"
+ // CHECK: integer_literal $Builtin.Int2048, 0
+
+ case nil:
+ return 42
+
+ // CHECK: [[NILBB]]:
+ // CHECK: integer_literal $Builtin.Int2048, 42
+ }
+}
+
+// SR-3518
+// CHECK-LABEL: sil hidden @$S6switch43testMultiPatternsWithOuterScopeSameNamedVar4base6filterySiSg_AEtF
+func testMultiPatternsWithOuterScopeSameNamedVar(base: Int?, filter: Int?) {
+ switch(base, filter) {
+
+ case (.some(let base), .some(let filter)):
+ // CHECK: bb2(%10 : $Int):
+ // CHECK-NEXT: debug_value %8 : $Int, let, name "base"
+ // CHECK-NEXT: debug_value %10 : $Int, let, name "filter"
+ print("both: \(base), \(filter)")
+ case (.some(let base), .none), (.none, .some(let base)):
+ // CHECK: bb3:
+ // CHECK-NEXT: debug_value %8 : $Int, let, name "base"
+ // CHECK-NEXT: br bb6(%8 : $Int)
+
+ // CHECK: bb5([[OTHER_BASE:%.*]] : $Int)
+ // CHECK-NEXT: debug_value [[OTHER_BASE]] : $Int, let, name "base"
+ // CHECK-NEXT: br bb6([[OTHER_BASE]] : $Int)
+
+ // CHECK: bb6([[ARG:%.*]] : $Int):
+ print("single: \(base)")
+ default:
+ print("default")
+ }
+}
+
+// All cases are unreachable, either structurally (tuples involving Never) or
+// nominally (empty enums). We fold all of these to 'unreachable'.
+enum MyNever {}
+func ~= (_ : MyNever, _ : MyNever) -> Bool { return true }
+func myFatalError() -> MyNever { fatalError("asdf") }
+
+func testUninhabitedSwitchScrutinee() {
+ func test1(x : MyNever) {
+ // CHECK: bb0(%0 : $MyNever):
+ // CHECK-NEXT: debug_value %0 : $MyNever, let, name "x"
+ // CHECK-NEXT: unreachable
+ switch x {
+ case myFatalError(): break
+ case myFatalError(): break
+ case myFatalError(): break
+ }
+ }
+ func test2(x : Never) {
+ // CHECK: bb0(%0 : $Never):
+ // CHECK-NEXT: debug_value %0 : $Never, let, name "x"
+ // CHECK-NEXT: unreachable
+ switch (x, x) {}
+ }
+ func test3(x : Never) {
+ // CHECK: unreachable
+ // CHECK-NEXT: } // end sil function '$S6switch30testUninhabitedSwitchScrutineeyyF5test3L_1xys5NeverO_tF'
+ switch (x, 5, x) {}
+ }
+ func test4(x : Never) {
+ // CHECK: unreachable
+ // CHECK-NEXT: } // end sil function '$S6switch30testUninhabitedSwitchScrutineeyyF5test4L_1xys5NeverO_tF'
+ switch ((8, 6, 7), (5, 3, (0, x))) {}
+ }
+ func test5() {
+ // CHECK: %0 = function_ref @$S6switch12myFatalErrorAA7MyNeverOyF : $@convention(thin) () -> MyNever
+ // CHECK-NEXT: %1 = apply %0() : $@convention(thin) () -> MyNever
+ // CHECK-NEXT: unreachable
+ switch myFatalError() {}
+ }
+}
diff --git a/test/SILGen/plus_zero_switch_abstraction.swift b/test/SILGen/plus_zero_switch_abstraction.swift
new file mode 100644
index 0000000..86ebbc9
--- /dev/null
+++ b/test/SILGen/plus_zero_switch_abstraction.swift
@@ -0,0 +1,46 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -parse-stdlib %s | %FileCheck %s
+
+struct A {}
+
+enum Optionable<T> {
+ case Summn(T)
+ case Nuttn
+}
+
+// CHECK-LABEL: sil hidden @$S18switch_abstraction18enum_reabstraction1x1ayAA10OptionableOyAA1AVAHcG_AHtF : $@convention(thin) (@guaranteed Optionable<(A) -> A>, A) -> ()
+// CHECK: switch_enum {{%.*}} : $Optionable<(A) -> A>, case #Optionable.Summn!enumelt.1: [[DEST:bb[0-9]+]]
+// CHECK: [[DEST]]([[ORIG:%.*]] : @owned $@callee_guaranteed (@in_guaranteed A) -> @out A):
+// CHECK: [[REABSTRACT:%.*]] = function_ref @$S{{.*}}TR :
+// CHECK: [[SUBST:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACT]]([[ORIG]])
+func enum_reabstraction(x x: Optionable<(A) -> A>, a: A) {
+ switch x {
+ case .Summn(var f):
+ f(a)
+ case .Nuttn:
+ ()
+ }
+}
+
+enum Wacky<A, B> {
+ case Foo(A)
+ case Bar((B) -> A)
+}
+
+// CHECK-LABEL: sil hidden @$S18switch_abstraction45enum_addr_only_to_loadable_with_reabstraction{{[_0-9a-zA-Z]*}}F : $@convention(thin) <T> (@in_guaranteed Wacky<T, A>, A) -> @out T {
+// CHECK: switch_enum_addr [[ENUM:%.*]] : $*Wacky<T, A>, {{.*}} case #Wacky.Bar!enumelt.1: [[DEST:bb[0-9]+]]
+// CHECK: [[DEST]]:
+// CHECK: [[ORIG_ADDR:%.*]] = unchecked_take_enum_data_addr [[ENUM]] : $*Wacky<T, A>, #Wacky.Bar
+// CHECK: [[ORIG:%.*]] = load [take] [[ORIG_ADDR]]
+// CHECK: [[REABSTRACT:%.*]] = function_ref @$S{{.*}}TR :
+// CHECK: [[SUBST:%.*]] = partial_apply [callee_guaranteed] [[REABSTRACT]]<T>([[ORIG]])
+func enum_addr_only_to_loadable_with_reabstraction<T>(x x: Wacky<T, A>, a: A)
+ -> T
+{
+ switch x {
+ case .Foo(var b):
+ return b
+ case .Bar(var f):
+ return f(a)
+ }
+}
diff --git a/test/SILGen/plus_zero_switch_isa.swift b/test/SILGen/plus_zero_switch_isa.swift
new file mode 100644
index 0000000..7ad4e70
--- /dev/null
+++ b/test/SILGen/plus_zero_switch_isa.swift
@@ -0,0 +1,74 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
+
+func markUsed<T>(_ t: T) {}
+
+// rdar://17772217
+func testSwitchOnExistential(_ value: Any) {
+ switch value {
+ case true as Bool: markUsed("true")
+ case false as Bool: markUsed("false")
+ default: markUsed("default")
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10switch_isa23testSwitchOnExistentialyyypF :
+// CHECK: [[ANY:%.*]] = alloc_stack $Any
+// CHECK: copy_addr %0 to [initialization] [[ANY]]
+// CHECK: [[BOOL:%.*]] = alloc_stack $Bool
+// CHECK: checked_cast_addr_br copy_on_success Any in [[ANY]] : $*Any to Bool in [[BOOL]] : $*Bool, [[IS_BOOL:bb[0-9]+]], [[IS_NOT_BOOL:bb[0-9]+]]
+// CHECK: [[IS_BOOL]]:
+// CHECK: [[T0:%.*]] = load [trivial] [[BOOL]]
+
+enum Foo {
+ case A
+}
+enum Bar<T> {
+ case B(T)
+}
+func testSwitchEnumOnExistential(_ value: Any) {
+ switch value {
+ case Foo.A:
+ ()
+ case Bar<Int>.B(let i):
+ ()
+ case Bar<Foo>.B(let f):
+ ()
+ default:
+ ()
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S10switch_isa27testSwitchEnumOnExistentialyyypF : $@convention(thin) (@in_guaranteed Any) -> ()
+// CHECK: checked_cast_addr_br copy_on_success Any in {{%.*}} : $*Any to Foo
+// CHECK: checked_cast_addr_br copy_on_success Any in {{%.*}} : $*Any to Bar<Int>
+// CHECK: checked_cast_addr_br copy_on_success Any in {{%.*}} : $*Any to Bar<Foo>
+
+class B {}
+class D: B {}
+
+func guardFn(_ l: D, _ r: D) -> Bool { return true }
+
+// rdar://problem/21087371
+// CHECK-LABEL: sil hidden @$S10switch_isa32testSwitchTwoIsPatternsWithGuard_1ryAA1BC_AEtF
+// CHECK: checked_cast_br {{%.*}} : $B to $D, [[R_CAST_YES:bb[0-9]+]], [[R_CAST_NO:bb[0-9]+]]
+// CHECK: [[R_CAST_YES]]({{.*}}):
+// CHECK: checked_cast_br {{%.*}} : $B to $D, [[L_CAST_YES:bb[0-9]+]], [[L_CAST_NO:bb[0-9]+]]
+// CHECK: [[L_CAST_YES]]({{.*}}):
+// CHECK: function_ref @$S10switch_isa7guardFnySbAA1DC_ADtF
+// CHECK: cond_br {{%.*}}, [[GUARD_YES:bb[0-9]+]], [[GUARD_NO:bb[0-9]+]]
+// CHECK: [[GUARD_NO]]:
+// CHECK-NEXT: destroy_value [[R2:%.*]] : $D
+// CHECK-NEXT: destroy_value [[L2:%.*]] : $D
+// CHECK-NEXT: br [[CONT:bb[0-9]+]]
+// CHECK: [[L_CAST_NO]]:
+// CHECK-NEXT: destroy_value [[R2:%.*]] : $D
+// CHECK-NEXT: br [[CONT]]
+func testSwitchTwoIsPatternsWithGuard(_ l: B, r: B) {
+ switch (l, r) {
+ case (let l2 as D, let r2 as D) where guardFn(l2, r2):
+ break
+ default:
+ break
+ }
+}
diff --git a/test/SILGen/plus_zero_switch_multiple_entry_address_only.swift b/test/SILGen/plus_zero_switch_multiple_entry_address_only.swift
new file mode 100644
index 0000000..1e70918
--- /dev/null
+++ b/test/SILGen/plus_zero_switch_multiple_entry_address_only.swift
@@ -0,0 +1,190 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend %s -emit-silgen | %FileCheck %s
+
+enum E {
+case a(Any)
+case b(Any)
+case c(Any)
+}
+
+// CHECK-LABEL: sil hidden @$S34switch_multiple_entry_address_only8takesAnyyyypF : $@convention(thin) (@in_guaranteed Any) -> ()
+func takesAny(_ x: Any) {}
+
+// CHECK-LABEL: sil hidden @$S34switch_multiple_entry_address_only0B9LabelsLet1eyAA1EO_tF : $@convention(thin) (@in_guaranteed E) -> ()
+func multipleLabelsLet(e: E) {
+ // CHECK: bb0
+ // CHECK: [[X_PHI:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: [[E_COPY:%.*]] = alloc_stack $E
+ // CHECK-NEXT: copy_addr %0 to [initialization] [[E_COPY]]
+ // CHECK-NEXT: switch_enum_addr [[E_COPY]] : $*E, case #E.a!enumelt.1: bb1, case #E.b!enumelt.1: bb2, default bb4
+
+ // CHECK: bb1:
+ // CHECK-NEXT: [[E_PAYLOAD:%.*]] = unchecked_take_enum_data_addr [[E_COPY]] : $*E, #E.a!enumelt.1
+ // CHECK-NEXT: [[ANY_BOX:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: copy_addr [take] [[E_PAYLOAD]] to [initialization] [[ANY_BOX]]
+ // CHECK-NEXT: copy_addr [[ANY_BOX]] to [initialization] [[X_PHI]]
+ // CHECK-NEXT: destroy_addr [[ANY_BOX]]
+ // CHECK-NEXT: dealloc_stack [[ANY_BOX]]
+ // CHECK-NEXT: dealloc_stack [[E_COPY]]
+ // CHECK-NEXT: br bb3
+
+ // CHECK: bb2:
+ // CHECK-NEXT: [[E_PAYLOAD:%.*]] = unchecked_take_enum_data_addr [[E_COPY]] : $*E, #E.b!enumelt.1
+ // CHECK-NEXT: [[ANY_BOX:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: copy_addr [take] [[E_PAYLOAD]] to [initialization] [[ANY_BOX]]
+ // CHECK-NEXT: copy_addr [[ANY_BOX]] to [initialization] [[X_PHI]]
+ // CHECK-NEXT: destroy_addr [[ANY_BOX]]
+ // CHECK-NEXT: dealloc_stack [[ANY_BOX]]
+ // CHECK-NEXT: dealloc_stack [[E_COPY]]
+ // CHECK-NEXT: br bb3
+
+ // CHECK: bb3:
+ // CHECK: [[FN:%.*]] = function_ref @$S34switch_multiple_entry_address_only8takesAnyyyypF
+ // CHECK-NEXT: apply [[FN]]([[X_PHI]]
+ // CHECK-NEXT: destroy_addr [[X_PHI]]
+ // CHECK-NEXT: br bb6
+
+ // CHECK: bb4:
+ // CHECK-NEXT: br bb5
+
+ // CHECK: bb5:
+ // CHECK-NEXT: destroy_addr [[E_COPY]]
+ // CHECK-NEXT: dealloc_stack [[E_COPY]]
+ // CHECK-NEXT: br bb6
+
+ // CHECK: bb6:
+ // CHECK-NEXT: dealloc_stack [[X_PHI]]
+ // CHECK-NEXT: tuple ()
+ // CHECK-NEXT: return
+
+ switch e {
+ case .a(let x), .b(let x):
+ takesAny(x)
+ default:
+ break
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S34switch_multiple_entry_address_only0B9LabelsVar1eyAA1EO_tF : $@convention(thin) (@in_guaranteed E) -> ()
+func multipleLabelsVar(e: E) {
+ // CHECK: bb0
+ // CHECK: [[X_PHI:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: [[E_COPY:%.*]] = alloc_stack $E
+ // CHECK-NEXT: copy_addr %0 to [initialization] [[E_COPY]]
+ // CHECK-NEXT: switch_enum_addr [[E_COPY]] : $*E, case #E.a!enumelt.1: bb1, case #E.b!enumelt.1: bb2, default bb4
+
+ // CHECK: bb1:
+ // CHECK-NEXT: [[E_PAYLOAD:%.*]] = unchecked_take_enum_data_addr [[E_COPY]] : $*E, #E.a!enumelt.1
+ // CHECK-NEXT: [[ANY_BOX:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: copy_addr [take] [[E_PAYLOAD]] to [initialization] [[ANY_BOX]]
+ // CHECK-NEXT: copy_addr [[ANY_BOX]] to [initialization] [[X_PHI]]
+ // CHECK-NEXT: destroy_addr [[ANY_BOX]]
+ // CHECK-NEXT: dealloc_stack [[ANY_BOX]]
+ // CHECK-NEXT: dealloc_stack [[E_COPY]]
+ // CHECK-NEXT: br bb3
+
+ // CHECK: bb2:
+ // CHECK-NEXT: [[E_PAYLOAD:%.*]] = unchecked_take_enum_data_addr [[E_COPY]] : $*E, #E.b!enumelt.1
+ // CHECK-NEXT: [[ANY_BOX:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: copy_addr [take] [[E_PAYLOAD]] to [initialization] [[ANY_BOX]]
+ // CHECK-NEXT: copy_addr [[ANY_BOX]] to [initialization] [[X_PHI]]
+ // CHECK-NEXT: destroy_addr [[ANY_BOX]]
+ // CHECK-NEXT: dealloc_stack [[ANY_BOX]]
+ // CHECK-NEXT: dealloc_stack [[E_COPY]]
+ // CHECK-NEXT: br bb3
+
+ // CHECK: bb3:
+ // CHECK-NEXT: [[ANY_BOX:%.*]] = alloc_box ${ var Any }, var, name "x"
+ // CHECK-NEXT: [[BOX_PAYLOAD:%.*]] = project_box [[ANY_BOX]] : ${ var Any }, 0
+ // CHECK-NEXT: copy_addr [take] [[X_PHI]] to [initialization] [[BOX_PAYLOAD]]
+ // CHECK-NEXT: [[ACCESS:%.*]] = begin_access [read] [unknown] [[BOX_PAYLOAD]]
+ // CHECK-NEXT: [[ANY_STACK:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: copy_addr [[ACCESS]] to [initialization] [[ANY_STACK]]
+ // CHECK-NEXT: end_access [[ACCESS]]
+ // CHECK: [[FN:%.*]] = function_ref @$S34switch_multiple_entry_address_only8takesAnyyyypF
+ // CHECK-NEXT: apply [[FN]]([[ANY_STACK]]
+ // CHECK-NEXT: destroy_addr [[ANY_STACK]]
+ // CHECK-NEXT: dealloc_stack [[ANY_STACK]]
+ // CHECK-NEXT: destroy_value [[ANY_BOX]]
+ // CHECK-NEXT: br bb6
+
+ // CHECK: bb4:
+ // CHECK-NEXT: br bb5
+
+ // CHECK: bb5:
+ // CHECK-NEXT: destroy_addr [[E_COPY]]
+ // CHECK-NEXT: dealloc_stack [[E_COPY]]
+ // CHECK-NEXT: br bb6
+
+ // CHECK: bb6:
+ // CHECK-NEXT: dealloc_stack [[X_PHI]]
+ // CHECK-NEXT: tuple ()
+ // CHECK-NEXT: return
+
+ switch e {
+ case .a(var x), .b(var x):
+ takesAny(x)
+ default:
+ break
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S34switch_multiple_entry_address_only20fallthroughWithValue1eyAA1EO_tF : $@convention(thin) (@in_guaranteed E) -> ()
+func fallthroughWithValue(e: E) {
+ // CHECK: bb0
+ // CHECK: [[X_PHI:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: [[E_COPY:%.*]] = alloc_stack $E
+ // CHECK-NEXT: copy_addr %0 to [initialization] [[E_COPY]]
+ // CHECK-NEXT: switch_enum_addr [[E_COPY]] : $*E, case #E.a!enumelt.1: bb1, case #E.b!enumelt.1: bb2, default bb4
+
+ // CHECK: bb1:
+ // CHECK-NEXT: [[E_PAYLOAD:%.*]] = unchecked_take_enum_data_addr [[E_COPY]] : $*E, #E.a!enumelt.1
+ // CHECK-NEXT: [[ORIGINAL_ANY_BOX:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: copy_addr [take] [[E_PAYLOAD]] to [initialization] [[ORIGINAL_ANY_BOX]]
+ // CHECK: [[FN1:%.*]] = function_ref @$S34switch_multiple_entry_address_only8takesAnyyyypF
+ // CHECK-NEXT: apply [[FN1]]([[ORIGINAL_ANY_BOX]]
+ // CHECK-NEXT: copy_addr [[ORIGINAL_ANY_BOX]] to [initialization] [[X_PHI]]
+ // CHECK-NEXT: destroy_addr [[ORIGINAL_ANY_BOX]]
+ // CHECK-NEXT: dealloc_stack [[ORIGINAL_ANY_BOX]]
+ // CHECK-NEXT: dealloc_stack [[E_COPY]]
+ // CHECK-NEXT: br bb3
+
+ // CHECK: bb2:
+ // CHECK-NEXT: [[E_PAYLOAD:%.*]] = unchecked_take_enum_data_addr [[E_COPY]] : $*E, #E.b!enumelt.1
+ // CHECK-NEXT: [[ANY_BOX:%.*]] = alloc_stack $Any
+ // CHECK-NEXT: copy_addr [take] [[E_PAYLOAD]] to [initialization] [[ANY_BOX]]
+ // CHECK-NEXT: copy_addr [[ANY_BOX]] to [initialization] [[X_PHI]]
+ // CHECK-NEXT: destroy_addr [[ANY_BOX]]
+ // CHECK-NEXT: dealloc_stack [[ANY_BOX]]
+ // CHECK-NEXT: dealloc_stack [[E_COPY]]
+ // CHECK-NEXT: br bb3
+
+ // CHECK: bb3:
+ // CHECK: [[FN2:%.*]] = function_ref @$S34switch_multiple_entry_address_only8takesAnyyyypF
+ // CHECK-NEXT: apply [[FN2]]([[X_PHI]]
+ // CHECK-NEXT: destroy_addr [[X_PHI]]
+ // CHECK-NEXT: br bb6
+
+ // CHECK: bb4:
+ // CHECK-NEXT: br bb5
+
+ // CHECK: bb5:
+ // CHECK-NEXT: destroy_addr [[E_COPY]]
+ // CHECK-NEXT: dealloc_stack [[E_COPY]]
+ // CHECK-NEXT: br bb6
+
+ // CHECK: bb6:
+ // CHECK-NEXT: dealloc_stack [[X_PHI]]
+ // CHECK-NEXT: tuple ()
+ // CHECK-NEXT: return
+
+ switch e {
+ case .a(let x):
+ takesAny(x)
+ fallthrough
+ case .b(let x):
+ takesAny(x)
+ default:
+ break
+ }
+}
diff --git a/test/SILGen/plus_zero_switch_var.swift b/test/SILGen/plus_zero_switch_var.swift
new file mode 100644
index 0000000..becf093
--- /dev/null
+++ b/test/SILGen/plus_zero_switch_var.swift
@@ -0,0 +1,750 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
+
+// TODO: Implement tuple equality in the library.
+// BLOCKED: <rdar://problem/13822406>
+func ~= (x: (Int, Int), y: (Int, Int)) -> Bool {
+ return x.0 == y.0 && x.1 == y.1
+}
+
+// Some fake predicates for pattern guards.
+func runced() -> Bool { return true }
+func funged() -> Bool { return true }
+func ansed() -> Bool { return true }
+
+func runced(x x: Int) -> Bool { return true }
+func funged(x x: Int) -> Bool { return true }
+func ansed(x x: Int) -> Bool { return true }
+
+func foo() -> Int { return 0 }
+func bar() -> Int { return 0 }
+func foobar() -> (Int, Int) { return (0, 0) }
+
+func foos() -> String { return "" }
+func bars() -> String { return "" }
+
+func a() {}
+func b() {}
+func c() {}
+func d() {}
+func e() {}
+func f() {}
+func g() {}
+
+func a(x x: Int) {}
+func b(x x: Int) {}
+func c(x x: Int) {}
+func d(x x: Int) {}
+
+func a(x x: String) {}
+func b(x x: String) {}
+
+func aa(x x: (Int, Int)) {}
+func bb(x x: (Int, Int)) {}
+func cc(x x: (Int, Int)) {}
+
+// CHECK-LABEL: sil hidden @$S10switch_var05test_B2_1yyF
+func test_var_1() {
+ // CHECK: function_ref @$S10switch_var3fooSiyF
+ switch foo() {
+ // CHECK: [[XADDR:%.*]] = alloc_box ${ var Int }
+ // CHECK: [[X:%.*]] = project_box [[XADDR]]
+ // CHECK-NOT: br bb
+ case var x:
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[X]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var1a1xySi_tF
+ // CHECK: destroy_value [[XADDR]]
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a(x: x)
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S10switch_var1byyF
+ b()
+}
+
+// CHECK-LABEL: sil hidden @$S10switch_var05test_B2_2yyF
+func test_var_2() {
+ // CHECK: function_ref @$S10switch_var3fooSiyF
+ switch foo() {
+ // CHECK: [[XADDR:%.*]] = alloc_box ${ var Int }
+ // CHECK: [[X:%.*]] = project_box [[XADDR]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[X]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var6runced1xSbSi_tF
+ // CHECK: cond_br {{%.*}}, [[CASE1:bb[0-9]+]], [[NO_CASE1:bb[0-9]+]]
+ // -- TODO: Clean up these empty waypoint bbs.
+ case var x where runced(x: x):
+ // CHECK: [[CASE1]]:
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[X]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var1a1xySi_tF
+ // CHECK: destroy_value [[XADDR]]
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a(x: x)
+ // CHECK: [[NO_CASE1]]:
+ // CHECK: [[YADDR:%.*]] = alloc_box ${ var Int }
+ // CHECK: [[Y:%.*]] = project_box [[YADDR]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[Y]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var6funged1xSbSi_tF
+ // CHECK: cond_br {{%.*}}, [[CASE2:bb[0-9]+]], [[NO_CASE2:bb[0-9]+]]
+ case var y where funged(x: y):
+ // CHECK: [[CASE2]]:
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[Y]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var1b1xySi_tF
+ // CHECK: destroy_value [[YADDR]]
+ // CHECK: br [[CONT]]
+ b(x: y)
+ // CHECK: [[NO_CASE2]]:
+ // CHECK: br [[CASE3:bb[0-9]+]]
+ case var z:
+ // CHECK: [[CASE3]]:
+ // CHECK: [[ZADDR:%.*]] = alloc_box ${ var Int }
+ // CHECK: [[Z:%.*]] = project_box [[ZADDR]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[Z]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var1c1xySi_tF
+ // CHECK: destroy_value [[ZADDR]]
+ // CHECK: br [[CONT]]
+ c(x: z)
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S10switch_var1dyyF
+ d()
+}
+
+// CHECK-LABEL: sil hidden @$S10switch_var05test_B2_3yyF
+func test_var_3() {
+ // CHECK: function_ref @$S10switch_var3fooSiyF
+ // CHECK: function_ref @$S10switch_var3barSiyF
+ switch (foo(), bar()) {
+ // CHECK: [[XADDR:%.*]] = alloc_box ${ var (Int, Int) }
+ // CHECK: [[X:%.*]] = project_box [[XADDR]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[X]]
+ // CHECK: tuple_element_addr [[READ]] : {{.*}}, 0
+ // CHECK: function_ref @$S10switch_var6runced1xSbSi_tF
+ // CHECK: cond_br {{%.*}}, [[CASE1:bb[0-9]+]], [[NO_CASE1:bb[0-9]+]]
+ case var x where runced(x: x.0):
+ // CHECK: [[CASE1]]:
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[X]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var2aa1xySi_Sit_tF
+ // CHECK: destroy_value [[XADDR]]
+ // CHECK: br [[CONT:bb[0-9]+]]
+ aa(x: x)
+ // CHECK: [[NO_CASE1]]:
+ // CHECK: br [[NO_CASE1_TARGET:bb[0-9]+]]
+
+ // CHECK: [[NO_CASE1_TARGET]]:
+ // CHECK: [[YADDR:%.*]] = alloc_box ${ var Int }
+ // CHECK: [[Y:%.*]] = project_box [[YADDR]]
+ // CHECK: [[ZADDR:%.*]] = alloc_box ${ var Int }
+ // CHECK: [[Z:%.*]] = project_box [[ZADDR]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[Y]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var6funged1xSbSi_tF
+ // CHECK: cond_br {{%.*}}, [[CASE2:bb[0-9]+]], [[NO_CASE2:bb[0-9]+]]
+ case (var y, var z) where funged(x: y):
+ // CHECK: [[CASE2]]:
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[Y]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var1a1xySi_tF
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[Z]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var1b1xySi_tF
+ // CHECK: destroy_value [[ZADDR]]
+ // CHECK: destroy_value [[YADDR]]
+ // CHECK: br [[CONT]]
+ a(x: y)
+ b(x: z)
+ // CHECK: [[NO_CASE2]]:
+ // CHECK: [[WADDR:%.*]] = alloc_box ${ var (Int, Int) }
+ // CHECK: [[W:%.*]] = project_box [[WADDR]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[W]]
+ // CHECK: tuple_element_addr [[READ]] : {{.*}}, 0
+ // CHECK: function_ref @$S10switch_var5ansed1xSbSi_tF
+ // CHECK: cond_br {{%.*}}, [[CASE3:bb[0-9]+]], [[NO_CASE3:bb[0-9]+]]
+ case var w where ansed(x: w.0):
+ // CHECK: [[CASE3]]:
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[W]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var2bb1xySi_Sit_tF
+ // CHECK: br [[CONT]]
+ bb(x: w)
+ // CHECK: [[NO_CASE3]]:
+ // CHECK: destroy_value [[WADDR]]
+ // CHECK: br [[CASE4:bb[0-9]+]]
+ case var v:
+ // CHECK: [[CASE4]]:
+ // CHECK: [[VADDR:%.*]] = alloc_box ${ var (Int, Int) }
+ // CHECK: [[V:%.*]] = project_box [[VADDR]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[V]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var2cc1xySi_Sit_tF
+ // CHECK: destroy_value [[VADDR]]
+ // CHECK: br [[CONT]]
+ cc(x: v)
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: function_ref @$S10switch_var1dyyF
+ d()
+}
+
+protocol P { func p() }
+
+struct X : P { func p() {} }
+struct Y : P { func p() {} }
+struct Z : P { func p() {} }
+
+// CHECK-LABEL: sil hidden @$S10switch_var05test_B2_41pyAA1P_p_tF
+func test_var_4(p p: P) {
+ // CHECK: function_ref @$S10switch_var3fooSiyF
+ switch (p, foo()) {
+ // CHECK: [[PAIR:%.*]] = alloc_stack $(P, Int)
+ // CHECK: store
+ // CHECK: [[PAIR_0:%.*]] = tuple_element_addr [[PAIR]] : $*(P, Int), 0
+ // CHECK: [[T0:%.*]] = tuple_element_addr [[PAIR]] : $*(P, Int), 1
+ // CHECK: [[PAIR_1:%.*]] = load [trivial] [[T0]] : $*Int
+ // CHECK: [[TMP:%.*]] = alloc_stack $X
+ // CHECK: checked_cast_addr_br copy_on_success P in [[PAIR_0]] : $*P to X in [[TMP]] : $*X, [[IS_X:bb[0-9]+]], [[IS_NOT_X:bb[0-9]+]]
+
+ // CHECK: [[IS_X]]:
+ // CHECK: [[T0:%.*]] = load [trivial] [[TMP]] : $*X
+ // CHECK: [[XADDR:%.*]] = alloc_box ${ var Int }
+ // CHECK: [[X:%.*]] = project_box [[XADDR]]
+ // CHECK: store [[PAIR_1]] to [trivial] [[X]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[X]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var6runced1xSbSi_tF
+ // CHECK: cond_br {{%.*}}, [[CASE1:bb[0-9]+]], [[NO_CASE1:bb[0-9]+]]
+ case (is X, var x) where runced(x: x):
+ // CHECK: [[CASE1]]:
+ // CHECK: function_ref @$S10switch_var1a1xySi_tF
+ // CHECK: destroy_value [[XADDR]]
+ // CHECK: dealloc_stack [[TMP]]
+ // CHECK: destroy_addr [[PAIR_0]] : $*P
+ // CHECK: dealloc_stack [[PAIR]]
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a(x: x)
+
+ // CHECK: [[NO_CASE1]]:
+ // CHECK: destroy_value [[XADDR]]
+ // CHECK: dealloc_stack [[TMP]]
+ // CHECK: br [[NEXT:bb[0-9]+]]
+ // CHECK: [[IS_NOT_X]]:
+ // CHECK: dealloc_stack [[TMP]]
+ // CHECK: br [[NEXT]]
+
+ // CHECK: [[NEXT]]:
+ // CHECK: [[TMP:%.*]] = alloc_stack $Y
+ // CHECK: checked_cast_addr_br copy_on_success P in [[PAIR_0]] : $*P to Y in [[TMP]] : $*Y, [[IS_Y:bb[0-9]+]], [[IS_NOT_Y:bb[0-9]+]]
+
+ // CHECK: [[IS_Y]]:
+ // CHECK: [[T0:%.*]] = load [trivial] [[TMP]] : $*Y
+ // CHECK: [[YADDR:%.*]] = alloc_box ${ var Int }
+ // CHECK: [[Y:%.*]] = project_box [[YADDR]]
+ // CHECK: store [[PAIR_1]] to [trivial] [[Y]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[Y]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var6funged1xSbSi_tF
+ // CHECK: cond_br {{%.*}}, [[CASE2:bb[0-9]+]], [[NO_CASE2:bb[0-9]+]]
+
+ case (is Y, var y) where funged(x: y):
+ // CHECK: [[CASE2]]:
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[Y]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var1b1xySi_tF
+ // CHECK: destroy_value [[YADDR]]
+ // CHECK: dealloc_stack [[TMP]]
+ // CHECK: destroy_addr [[PAIR_0]] : $*P
+ // CHECK: dealloc_stack [[PAIR]]
+ // CHECK: br [[CONT]]
+ b(x: y)
+
+ // CHECK: [[NO_CASE2]]:
+ // CHECK: destroy_value [[YADDR]]
+ // CHECK: dealloc_stack [[TMP]]
+ // CHECK: br [[NEXT:bb[0-9]+]]
+ // CHECK: [[IS_NOT_Y]]:
+ // CHECK: dealloc_stack [[TMP]]
+ // CHECK: br [[NEXT]]
+
+ // CHECK: [[NEXT]]:
+ // CHECK: [[ZADDR:%.*]] = alloc_box ${ var (P, Int) }
+ // CHECK: [[Z:%.*]] = project_box [[ZADDR]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[Z]]
+ // CHECK: tuple_element_addr [[READ]] : {{.*}}, 1
+ // CHECK: function_ref @$S10switch_var5ansed1xSbSi_tF
+ // CHECK: cond_br {{%.*}}, [[CASE3:bb[0-9]+]], [[DFLT_NO_CASE3:bb[0-9]+]]
+ case var z where ansed(x: z.1):
+ // CHECK: [[CASE3]]:
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[Z]]
+ // CHECK: tuple_element_addr [[READ]] : {{.*}}, 1
+ // CHECK: function_ref @$S10switch_var1c1xySi_tF
+ // CHECK: destroy_value [[ZADDR]]
+ // CHECK-NEXT: dealloc_stack [[PAIR]]
+ // CHECK: br [[CONT]]
+ c(x: z.1)
+
+ // CHECK: [[DFLT_NO_CASE3]]:
+ // CHECK: destroy_value [[ZADDR]]
+ // CHECK: br [[CASE4:bb[0-9]+]]
+ case (_, var w):
+ // CHECK: [[CASE4]]:
+ // CHECK: [[PAIR_0:%.*]] = tuple_element_addr [[PAIR]] : $*(P, Int), 0
+ // CHECK: [[WADDR:%.*]] = alloc_box ${ var Int }
+ // CHECK: [[W:%.*]] = project_box [[WADDR]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[W]]
+ // CHECK: load [trivial] [[READ]]
+ // CHECK: function_ref @$S10switch_var1d1xySi_tF
+ // CHECK: destroy_value [[WADDR]]
+ // CHECK: destroy_addr [[PAIR_0]] : $*P
+ // CHECK: dealloc_stack [[PAIR]]
+ // CHECK: br [[CONT]]
+ d(x: w)
+ }
+ e()
+}
+
+// CHECK-LABEL: sil hidden @$S10switch_var05test_B2_5yyF : $@convention(thin) () -> () {
+func test_var_5() {
+ // CHECK: function_ref @$S10switch_var3fooSiyF
+ // CHECK: function_ref @$S10switch_var3barSiyF
+ switch (foo(), bar()) {
+ // CHECK: [[XADDR:%.*]] = alloc_box ${ var (Int, Int) }
+ // CHECK: [[X:%.*]] = project_box [[XADDR]]
+ // CHECK: cond_br {{%.*}}, [[CASE1:bb[0-9]+]], [[NO_CASE1:bb[0-9]+]]
+ case var x where runced(x: x.0):
+ // CHECK: [[CASE1]]:
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a()
+ // CHECK: [[NO_CASE1]]:
+ // CHECK: [[YADDR:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[Y:%[0-9]+]] = project_box [[YADDR]]
+ // CHECK: [[ZADDR:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[Z:%[0-9]+]] = project_box [[ZADDR]]
+ // CHECK: cond_br {{%.*}}, [[CASE2:bb[0-9]+]], [[NO_CASE2:bb[0-9]+]]
+ case (var y, var z) where funged(x: y):
+ // CHECK: [[CASE2]]:
+ // CHECK: destroy_value [[ZADDR]]
+ // CHECK: destroy_value [[YADDR]]
+ // CHECK: br [[CONT]]
+ b()
+ // CHECK: [[NO_CASE2]]:
+ // CHECK: destroy_value [[ZADDR]]
+ // CHECK: destroy_value [[YADDR]]
+ // CHECK: cond_br {{%.*}}, [[CASE3:bb[0-9]+]], [[NO_CASE3:bb[0-9]+]]
+ case (_, _) where runced():
+ // CHECK: [[CASE3]]:
+ // CHECK: br [[CONT]]
+ c()
+ // CHECK: [[NO_CASE3]]:
+ // CHECK: br [[CASE4:bb[0-9]+]]
+ case _:
+ // CHECK: [[CASE4]]:
+ // CHECK: br [[CONT]]
+ d()
+ }
+ // CHECK: [[CONT]]:
+ e()
+}
+
+// CHECK-LABEL: sil hidden @$S10switch_var05test_B7_returnyyF : $@convention(thin) () -> () {
+func test_var_return() {
+ switch (foo(), bar()) {
+ case var x where runced():
+ // CHECK: [[XADDR:%[0-9]+]] = alloc_box ${ var (Int, Int) }
+ // CHECK: [[X:%[0-9]+]] = project_box [[XADDR]]
+ // CHECK: function_ref @$S10switch_var1ayyF
+ // CHECK: destroy_value [[XADDR]]
+ // CHECK: br [[EPILOG:bb[0-9]+]]
+ a()
+ return
+ // CHECK: [[YADDR:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[Y:%[0-9]+]] = project_box [[YADDR]]
+ // CHECK: [[ZADDR:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[Z:%[0-9]+]] = project_box [[ZADDR]]
+ case (var y, var z) where funged():
+ // CHECK: function_ref @$S10switch_var1byyF
+ // CHECK: destroy_value [[ZADDR]]
+ // CHECK: destroy_value [[YADDR]]
+ // CHECK: br [[EPILOG]]
+ b()
+ return
+ case var w where ansed():
+ // CHECK: [[WADDR:%[0-9]+]] = alloc_box ${ var (Int, Int) }
+ // CHECK: [[W:%[0-9]+]] = project_box [[WADDR]]
+ // CHECK: function_ref @$S10switch_var1cyyF
+ // CHECK-NOT: destroy_value [[ZADDR]]
+ // CHECK-NOT: destroy_value [[YADDR]]
+ // CHECK: destroy_value [[WADDR]]
+ // CHECK: br [[EPILOG]]
+ c()
+ return
+ case var v:
+ // CHECK: [[VADDR:%[0-9]+]] = alloc_box ${ var (Int, Int) }
+ // CHECK: [[V:%[0-9]+]] = project_box [[VADDR]]
+ // CHECK: function_ref @$S10switch_var1dyyF
+ // CHECK-NOT: destroy_value [[ZADDR]]
+ // CHECK-NOT: destroy_value [[YADDR]]
+ // CHECK: destroy_value [[VADDR]]
+ // CHECK: br [[EPILOG]]
+ d()
+ return
+ }
+}
+
+// When all of the bindings in a column are immutable, don't emit a mutable
+// box. <rdar://problem/15873365>
+// CHECK-LABEL: sil hidden @$S10switch_var8test_letyyF : $@convention(thin) () -> () {
+func test_let() {
+ // CHECK: [[FOOS:%.*]] = function_ref @$S10switch_var4foosSSyF
+ // CHECK: [[VAL:%.*]] = apply [[FOOS]]()
+ // CHECK: [[VAL_COPY:%.*]] = copy_value [[VAL]]
+ // CHECK: function_ref @$S10switch_var6runcedSbyF
+ // CHECK: cond_br {{%.*}}, [[CASE1:bb[0-9]+]], [[NO_CASE1:bb[0-9]+]]
+ switch foos() {
+ case let x where runced():
+ // CHECK: [[CASE1]]:
+ // CHECK: [[BORROWED_VAL_COPY:%.*]] = begin_borrow [[VAL_COPY]]
+ // CHECK: [[A:%.*]] = function_ref @$S10switch_var1a1xySS_tF
+ // CHECK: apply [[A]]([[BORROWED_VAL_COPY]])
+ // CHECK: destroy_value [[VAL_COPY]]
+ // CHECK: destroy_value [[VAL]]
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a(x: x)
+ // CHECK: [[NO_CASE1]]:
+ // CHECK: destroy_value [[VAL_COPY]]
+ // CHECK: br [[TRY_CASE2:bb[0-9]+]]
+ // CHECK: [[TRY_CASE2]]:
+ // CHECK: [[VAL_COPY_2:%.*]] = copy_value [[VAL]]
+ // CHECK: function_ref @$S10switch_var6fungedSbyF
+ // CHECK: cond_br {{%.*}}, [[CASE2:bb[0-9]+]], [[NO_CASE2:bb[0-9]+]]
+ case let y where funged():
+ // CHECK: [[CASE2]]:
+ // CHECK: [[BORROWED_VAL_COPY_2:%.*]] = begin_borrow [[VAL_COPY_2]]
+ // CHECK: [[B:%.*]] = function_ref @$S10switch_var1b1xySS_tF
+ // CHECK: apply [[B]]([[BORROWED_VAL_COPY_2]])
+ // CHECK: destroy_value [[VAL_COPY_2]]
+ // CHECK: destroy_value [[VAL]]
+ // CHECK: br [[CONT]]
+ b(x: y)
+ // CHECK: [[NO_CASE2]]:
+ // CHECK: destroy_value [[VAL_COPY_2]]
+ // CHECK: br [[NEXT_CASE:bb6]]
+
+ // CHECK: [[NEXT_CASE]]:
+ // CHECK: [[VAL_COPY_3:%.*]] = copy_value [[VAL]]
+ // CHECK: function_ref @$S10switch_var4barsSSyF
+ // CHECK: [[BORROWED_VAL_COPY_3:%.*]] = begin_borrow [[VAL_COPY_3]]
+ // CHECK: store_borrow [[BORROWED_VAL_COPY_3]] to [[IN_ARG:%.*]] :
+ // CHECK: apply {{%.*}}<String>({{.*}}, [[IN_ARG]])
+ // CHECK: cond_br {{%.*}}, [[YES_CASE3:bb[0-9]+]], [[NO_CASE3:bb[0-9]+]]
+ // ExprPatterns implicitly contain a 'let' binding.
+ case bars():
+ // CHECK: [[YES_CASE3]]:
+ // CHECK: destroy_value [[VAL_COPY_3]]
+ // CHECK: destroy_value [[VAL]]
+ // CHECK: function_ref @$S10switch_var1cyyF
+ // CHECK: br [[CONT]]
+ c()
+ // CHECK: [[NO_CASE3]]:
+ // CHECK: destroy_value [[VAL_COPY_3]]
+ // CHECK: br [[NEXT_CASE:bb9+]]
+
+ // CHECK: [[NEXT_CASE]]:
+ case _:
+ // CHECK: destroy_value [[VAL]]
+ // CHECK: function_ref @$S10switch_var1dyyF
+ // CHECK: br [[CONT]]
+ d()
+ }
+ // CHECK: [[CONT]]:
+ // CHECK: return
+}
+// CHECK: } // end sil function '$S10switch_var8test_letyyF'
+
+// If one of the bindings is a "var", allocate a box for the column.
+// CHECK-LABEL: sil hidden @$S10switch_var015test_mixed_let_B0yyF : $@convention(thin) () -> () {
+func test_mixed_let_var() {
+ // CHECK: bb0:
+ // CHECK: [[FOOS:%.*]] = function_ref @$S10switch_var4foosSSyF
+ // CHECK: [[VAL:%.*]] = apply [[FOOS]]()
+ switch foos() {
+
+ // First pattern.
+ // CHECK: [[BOX:%.*]] = alloc_box ${ var String }, var, name "x"
+ // CHECK: [[PBOX:%.*]] = project_box [[BOX]]
+ // CHECK: [[VAL_COPY:%.*]] = copy_value [[VAL]]
+ // CHECK: store [[VAL_COPY]] to [init] [[PBOX]]
+ // CHECK: cond_br {{.*}}, [[CASE1:bb[0-9]+]], [[NOCASE1:bb[0-9]+]]
+ case var x where runced():
+ // CHECK: [[CASE1]]:
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBOX]]
+ // CHECK: [[X:%.*]] = load [copy] [[READ]]
+ // CHECK: [[A:%.*]] = function_ref @$S10switch_var1a1xySS_tF
+ // CHECK: apply [[A]]([[X]])
+ // CHECK: destroy_value [[BOX]]
+ // CHECK: br [[CONT:bb[0-9]+]]
+ a(x: x)
+
+ // CHECK: [[NOCASE1]]:
+ // CHECK: destroy_value [[BOX]]
+ // CHECK: br [[NEXT_PATTERN:bb[0-9]+]]
+
+ // CHECK: [[NEXT_PATTERN]]:
+ // CHECK: [[VAL_COPY:%.*]] = copy_value [[VAL]]
+ // CHECK: cond_br {{.*}}, [[CASE2:bb[0-9]+]], [[NOCASE2:bb[0-9]+]]
+ case let y where funged():
+
+ // CHECK: [[CASE2]]:
+ // CHECK: [[BORROWED_VAL_COPY:%.*]] = begin_borrow [[VAL_COPY]]
+ // CHECK: [[B:%.*]] = function_ref @$S10switch_var1b1xySS_tF
+ // CHECK: apply [[B]]([[BORROWED_VAL_COPY]])
+ // CHECK: end_borrow [[BORROWED_VAL_COPY]] from [[VAL_COPY]]
+ // CHECK: destroy_value [[VAL_COPY]]
+ // CHECK: destroy_value [[VAL]]
+ // CHECK: br [[CONT]]
+ b(x: y)
+
+ // CHECK: [[NOCASE2]]:
+ // CHECK: destroy_value [[VAL_COPY]]
+ // CHECK: br [[NEXT_CASE:bb[0-9]+]]
+
+ // CHECK: [[NEXT_CASE]]
+ // CHECK: [[VAL_COPY:%.*]] = copy_value [[VAL]]
+ // CHECK: [[BORROWED_VAL_COPY:%.*]] = begin_borrow [[VAL_COPY]]
+ // CHECK: store_borrow [[BORROWED_VAL_COPY]] to [[TMP_VAL_COPY_ADDR:%.*]] :
+ // CHECK: apply {{.*}}<String>({{.*}}, [[TMP_VAL_COPY_ADDR]])
+ // CHECK: cond_br {{.*}}, [[CASE3:bb[0-9]+]], [[NOCASE3:bb[0-9]+]]
+ case bars():
+ // CHECK: [[CASE3]]:
+ // CHECK: destroy_value [[VAL_COPY]]
+ // CHECK: destroy_value [[VAL]]
+ // CHECK: [[FUNC:%.*]] = function_ref @$S10switch_var1cyyF : $@convention(thin) () -> ()
+ // CHECK: apply [[FUNC]]()
+ // CHECK: br [[CONT]]
+ c()
+
+ // CHECK: [[NOCASE3]]:
+ // CHECK: destroy_value [[VAL_COPY]]
+ // CHECK: br [[NEXT_CASE:bb[0-9]+]]
+
+ // CHECK: [[NEXT_CASE]]:
+ // CHECK: destroy_value [[VAL]]
+ // CHECK: [[D_FUNC:%.*]] = function_ref @$S10switch_var1dyyF : $@convention(thin) () -> ()
+ // CHECK: apply [[D_FUNC]]()
+ // CHECK: br [[CONT]]
+ case _:
+ d()
+ }
+
+ // CHECK: [[CONT]]:
+ // CHECK: return
+}
+// CHECK: } // end sil function '$S10switch_var015test_mixed_let_B0yyF'
+
+// CHECK-LABEL: sil hidden @$S10switch_var23test_multiple_patterns1yyF : $@convention(thin) () -> () {
+func test_multiple_patterns1() {
+ // CHECK: function_ref @$S10switch_var6foobarSi_SityF
+ switch foobar() {
+ // CHECK-NOT: br bb
+ case (0, let x), (let x, 0):
+ // CHECK: cond_br {{%.*}}, [[FIRST_MATCH_CASE:bb[0-9]+]], [[FIRST_FAIL:bb[0-9]+]]
+ // CHECK: [[FIRST_MATCH_CASE]]:
+ // CHECK: debug_value [[FIRST_X:%.*]] :
+ // CHECK: br [[CASE_BODY:bb[0-9]+]]([[FIRST_X]] : $Int)
+ // CHECK: [[FIRST_FAIL]]:
+ // CHECK: cond_br {{%.*}}, [[SECOND_MATCH_CASE:bb[0-9]+]], [[SECOND_FAIL:bb[0-9]+]]
+ // CHECK: [[SECOND_MATCH_CASE]]:
+ // CHECK: debug_value [[SECOND_X:%.*]] :
+ // CHECK: br [[CASE_BODY]]([[SECOND_X]] : $Int)
+ // CHECK: [[CASE_BODY]]([[BODY_VAR:%.*]] : $Int):
+ // CHECK: [[A:%.*]] = function_ref @$S10switch_var1a1xySi_tF
+ // CHECK: apply [[A]]([[BODY_VAR]])
+ a(x: x)
+ default:
+ // CHECK: [[SECOND_FAIL]]:
+ // CHECK: function_ref @$S10switch_var1byyF
+ b()
+ }
+}
+
+// FIXME(integers): the following checks should be updated for the new integer
+// protocols. <rdar://problem/29939484>
+// XCHECK-LABEL: sil hidden @$S10switch_var23test_multiple_patterns2yyF : $@convention(thin) () -> () {
+func test_multiple_patterns2() {
+ let t1 = 2
+ let t2 = 4
+ // XCHECK: debug_value [[T1:%.*]] :
+ // XCHECK: debug_value [[T2:%.*]] :
+ switch (0,0) {
+ // XCHECK-NOT: br bb
+ case (_, let x) where x > t1, (let x, _) where x > t2:
+ // XCHECK: [[FIRST_X:%.*]] = tuple_extract {{%.*}} : $(Int, Int), 1
+ // XCHECK: debug_value [[FIRST_X]] :
+ // XCHECK: apply {{%.*}}([[FIRST_X]], [[T1]])
+ // XCHECK: cond_br {{%.*}}, [[FIRST_MATCH_CASE:bb[0-9]+]], [[FIRST_FAIL:bb[0-9]+]]
+ // XCHECK: [[FIRST_MATCH_CASE]]:
+ // XCHECK: br [[CASE_BODY:bb[0-9]+]]([[FIRST_X]] : $Int)
+ // XCHECK: [[FIRST_FAIL]]:
+ // XCHECK: debug_value [[SECOND_X:%.*]] :
+ // XCHECK: apply {{%.*}}([[SECOND_X]], [[T2]])
+ // XCHECK: cond_br {{%.*}}, [[SECOND_MATCH_CASE:bb[0-9]+]], [[SECOND_FAIL:bb[0-9]+]]
+ // XCHECK: [[SECOND_MATCH_CASE]]:
+ // XCHECK: br [[CASE_BODY]]([[SECOND_X]] : $Int)
+ // XCHECK: [[CASE_BODY]]([[BODY_VAR:%.*]] : $Int):
+ // XCHECK: [[A:%.*]] = function_ref @$S10switch_var1aySi1x_tF
+ // XCHECK: apply [[A]]([[BODY_VAR]])
+ a(x: x)
+ default:
+ // XCHECK: [[SECOND_FAIL]]:
+ // XCHECK: function_ref @$S10switch_var1byyF
+ b()
+ }
+}
+
+enum Foo {
+ case A(Int, Double)
+ case B(Double, Int)
+ case C(Int, Int, Double)
+}
+
+// CHECK-LABEL: sil hidden @$S10switch_var23test_multiple_patterns3yyF : $@convention(thin) () -> () {
+func test_multiple_patterns3() {
+ let f = Foo.C(0, 1, 2.0)
+ switch f {
+ // CHECK: switch_enum {{%.*}} : $Foo, case #Foo.A!enumelt.1: [[A:bb[0-9]+]], case #Foo.B!enumelt.1: [[B:bb[0-9]+]], case #Foo.C!enumelt.1: [[C:bb[0-9]+]]
+ case .A(let x, let n), .B(let n, let x), .C(_, let x, let n):
+ // CHECK: [[A]]({{%.*}} : $(Int, Double)):
+ // CHECK: [[A_X:%.*]] = tuple_extract
+ // CHECK: [[A_N:%.*]] = tuple_extract
+ // CHECK: br [[CASE_BODY:bb[0-9]+]]([[A_X]] : $Int, [[A_N]] : $Double)
+
+ // CHECK: [[B]]({{%.*}} : $(Double, Int)):
+ // CHECK: [[B_N:%.*]] = tuple_extract
+ // CHECK: [[B_X:%.*]] = tuple_extract
+ // CHECK: br [[CASE_BODY]]([[B_X]] : $Int, [[B_N]] : $Double)
+
+ // CHECK: [[C]]({{%.*}} : $(Int, Int, Double)):
+ // CHECK: [[C__:%.*]] = tuple_extract
+ // CHECK: [[C_X:%.*]] = tuple_extract
+ // CHECK: [[C_N:%.*]] = tuple_extract
+ // CHECK: br [[CASE_BODY]]([[C_X]] : $Int, [[C_N]] : $Double)
+
+ // CHECK: [[CASE_BODY]]([[BODY_X:%.*]] : $Int, [[BODY_N:%.*]] : $Double):
+ // CHECK: [[FUNC_A:%.*]] = function_ref @$S10switch_var1a1xySi_tF
+ // CHECK: apply [[FUNC_A]]([[BODY_X]])
+ a(x: x)
+ }
+}
+
+enum Bar {
+ case Y(Foo, Int)
+ case Z(Int, Foo)
+}
+
+// CHECK-LABEL: sil hidden @$S10switch_var23test_multiple_patterns4yyF : $@convention(thin) () -> () {
+func test_multiple_patterns4() {
+ let b = Bar.Y(.C(0, 1, 2.0), 3)
+ switch b {
+ // CHECK: switch_enum {{%.*}} : $Bar, case #Bar.Y!enumelt.1: [[Y:bb[0-9]+]], case #Bar.Z!enumelt.1: [[Z:bb[0-9]+]]
+ case .Y(.A(let x, _), _), .Y(.B(_, let x), _), .Y(.C, let x), .Z(let x, _):
+ // CHECK: [[Y]]({{%.*}} : $(Foo, Int)):
+ // CHECK: [[Y_F:%.*]] = tuple_extract
+ // CHECK: [[Y_X:%.*]] = tuple_extract
+ // CHECK: switch_enum [[Y_F]] : $Foo, case #Foo.A!enumelt.1: [[A:bb[0-9]+]], case #Foo.B!enumelt.1: [[B:bb[0-9]+]], case #Foo.C!enumelt.1: [[C:bb[0-9]+]]
+
+ // CHECK: [[A]]({{%.*}} : $(Int, Double)):
+ // CHECK: [[A_X:%.*]] = tuple_extract
+ // CHECK: [[A_N:%.*]] = tuple_extract
+ // CHECK: br [[CASE_BODY:bb[0-9]+]]([[A_X]] : $Int)
+
+ // CHECK: [[B]]({{%.*}} : $(Double, Int)):
+ // CHECK: [[B_N:%.*]] = tuple_extract
+ // CHECK: [[B_X:%.*]] = tuple_extract
+ // CHECK: br [[CASE_BODY]]([[B_X]] : $Int)
+
+ // CHECK: [[C]]({{%.*}} : $(Int, Int, Double)):
+ // CHECK: br [[CASE_BODY]]([[Y_X]] : $Int)
+
+ // CHECK: [[Z]]({{%.*}} : $(Int, Foo)):
+ // CHECK: [[Z_X:%.*]] = tuple_extract
+ // CHECK: [[Z_F:%.*]] = tuple_extract
+ // CHECK: br [[CASE_BODY]]([[Z_X]] : $Int)
+
+ // CHECK: [[CASE_BODY]]([[BODY_X:%.*]] : $Int):
+ // CHECK: [[FUNC_A:%.*]] = function_ref @$S10switch_var1a1xySi_tF
+ // CHECK: apply [[FUNC_A]]([[BODY_X]])
+ a(x: x)
+ }
+}
+
+func aaa(x x: inout Int) {}
+
+// CHECK-LABEL: sil hidden @$S10switch_var23test_multiple_patterns5yyF : $@convention(thin) () -> () {
+func test_multiple_patterns5() {
+ let b = Bar.Y(.C(0, 1, 2.0), 3)
+ switch b {
+ // CHECK: switch_enum {{%.*}} : $Bar, case #Bar.Y!enumelt.1: [[Y:bb[0-9]+]], case #Bar.Z!enumelt.1: [[Z:bb[0-9]+]]
+ case .Y(.A(var x, _), _), .Y(.B(_, var x), _), .Y(.C, var x), .Z(var x, _):
+ // CHECK: [[Y]]({{%.*}} : $(Foo, Int)):
+ // CHECK: [[Y_F:%.*]] = tuple_extract
+ // CHECK: [[Y_X:%.*]] = tuple_extract
+ // CHECK: switch_enum [[Y_F]] : $Foo, case #Foo.A!enumelt.1: [[A:bb[0-9]+]], case #Foo.B!enumelt.1: [[B:bb[0-9]+]], case #Foo.C!enumelt.1: [[C:bb[0-9]+]]
+
+ // CHECK: [[A]]({{%.*}} : $(Int, Double)):
+ // CHECK: [[A_X:%.*]] = tuple_extract
+ // CHECK: [[A_N:%.*]] = tuple_extract
+ // CHECK: br [[CASE_BODY:bb[0-9]+]]([[A_X]] : $Int)
+
+ // CHECK: [[B]]({{%.*}} : $(Double, Int)):
+ // CHECK: [[B_N:%.*]] = tuple_extract
+ // CHECK: [[B_X:%.*]] = tuple_extract
+ // CHECK: br [[CASE_BODY]]([[B_X]] : $Int)
+
+ // CHECK: [[C]]({{%.*}} : $(Int, Int, Double)):
+ // CHECK: br [[CASE_BODY]]([[Y_X]] : $Int)
+
+ // CHECK: [[Z]]({{%.*}} : $(Int, Foo)):
+ // CHECK: [[Z_X:%.*]] = tuple_extract
+ // CHECK: [[Z_F:%.*]] = tuple_extract
+ // CHECK: br [[CASE_BODY]]([[Z_X]] : $Int)
+
+ // CHECK: [[CASE_BODY]]([[BODY_X:%.*]] : $Int):
+ // CHECK: store [[BODY_X]] to [trivial] [[BOX_X:%.*]] : $*Int
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[BOX_X]]
+ // CHECK: [[FUNC_AAA:%.*]] = function_ref @$S10switch_var3aaa1xySiz_tF
+ // CHECK: apply [[FUNC_AAA]]([[WRITE]])
+ aaa(x: &x)
+ }
+}
+
+// rdar://problem/29252758 -- local decls must not be reemitted.
+func test_against_reemission(x: Bar) {
+ switch x {
+ case .Y(let a, _), .Z(_, let a):
+ let b = a
+ }
+}
+
+class C {}
+class D: C {}
+func f(_: D) -> Bool { return true }
+
+// CHECK-LABEL: sil hidden @{{.*}}test_multiple_patterns_value_semantics
+func test_multiple_patterns_value_semantics(_ y: C) {
+ switch y {
+ // CHECK: checked_cast_br {{%.*}} : $C to $D, [[AS_D:bb[0-9]+]], [[NOT_AS_D:bb[0-9]+]]
+ // CHECK: [[AS_D]]({{.*}}):
+ // CHECK: cond_br {{%.*}}, [[F_TRUE:bb[0-9]+]], [[F_FALSE:bb[0-9]+]]
+ // CHECK: [[F_TRUE]]:
+ // CHECK: [[BINDING:%.*]] = copy_value [[ORIG:%.*]] :
+ // CHECK: destroy_value [[ORIG]]
+ // CHECK: br {{bb[0-9]+}}([[BINDING]]
+ case let x as D where f(x), let x as D: break
+ default: break
+ }
+}
diff --git a/test/SILGen/plus_zero_testable-multifile-other.swift b/test/SILGen/plus_zero_testable-multifile-other.swift
new file mode 100644
index 0000000..b517849
--- /dev/null
+++ b/test/SILGen/plus_zero_testable-multifile-other.swift
@@ -0,0 +1,45 @@
+// REQUIRES: plus_zero_runtime
+// This test is paired with testable-multifile.swift.
+
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module %S/Inputs/TestableMultifileHelper.swift -enable-testing -o %t
+
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -I %t %s %S/testable-multifile.swift -module-name main | %FileCheck %s
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -I %t %S/testable-multifile.swift %s -module-name main | %FileCheck %s
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -I %t -primary-file %s %S/testable-multifile.swift -module-name main | %FileCheck %s
+
+// Just make sure we don't crash later on.
+// RUN: %target-swift-frontend -emit-ir -enable-sil-ownership -I %t -primary-file %s %S/testable-multifile.swift -module-name main -o /dev/null
+// RUN: %target-swift-frontend -emit-ir -enable-sil-ownership -I %t -O -primary-file %s %S/testable-multifile.swift -module-name main -o /dev/null
+
+func use<F: Fooable>(_ f: F) { f.foo() }
+func test(internalFoo: FooImpl, publicFoo: PublicFooImpl) {
+ use(internalFoo)
+ use(publicFoo)
+
+ internalFoo.foo()
+ publicFoo.foo()
+}
+
+// CHECK-LABEL: sil hidden @$S4main4test11internalFoo06publicD0yAA0D4ImplV_AA06PublicdF0VtF
+// CHECK: [[USE_1:%.+]] = function_ref @$S4main3useyyxAA7FooableRzlF
+// CHECK: = apply [[USE_1]]<FooImpl>({{%.+}}) : $@convention(thin) <τ_0_0 where τ_0_0 : Fooable> (@in_guaranteed τ_0_0) -> ()
+// CHECK: [[USE_2:%.+]] = function_ref @$S4main3useyyxAA7FooableRzlF
+// CHECK: = apply [[USE_2]]<PublicFooImpl>({{%.+}}) : $@convention(thin) <τ_0_0 where τ_0_0 : Fooable> (@in_guaranteed τ_0_0) -> ()
+// CHECK: [[IMPL_1:%.+]] = function_ref @$S23TestableMultifileHelper13HasDefaultFooPAAE3fooyyF
+// CHECK: = apply [[IMPL_1]]<FooImpl>({{%.+}}) : $@convention(method) <τ_0_0 where τ_0_0 : HasDefaultFoo> (@in_guaranteed τ_0_0) -> ()
+// CHECK: [[IMPL_2:%.+]] = function_ref @$S23TestableMultifileHelper13HasDefaultFooPAAE3fooyyF
+// CHECK: = apply [[IMPL_2]]<PublicFooImpl>({{%.+}}) : $@convention(method) <τ_0_0 where τ_0_0 : HasDefaultFoo> (@in_guaranteed τ_0_0) -> ()
+// CHECK: } // end sil function '$S4main4test11internalFoo06publicD0yAA0D4ImplV_AA06PublicdF0VtF'
+
+func test(internalSub: Sub, publicSub: PublicSub) {
+ internalSub.foo()
+ publicSub.foo()
+}
+
+// CHECK-LABEL: sil hidden @$S4main4test11internalSub06publicD0yAA0D0C_AA06PublicD0CtF
+// CHECK: bb0([[ARG0:%.*]] : @guaranteed $Sub, [[ARG1:%.*]] : @guaranteed $PublicSub):
+// CHECK: = class_method [[ARG0]] : $Sub, #Sub.foo!1
+// CHECK: = class_method [[ARG1]] : $PublicSub, #PublicSub.foo!1
+// CHECK: } // end sil function '$S4main4test11internalSub06publicD0yAA0D0C_AA06PublicD0CtF'
+
diff --git a/test/SILGen/plus_zero_tuples.swift b/test/SILGen/plus_zero_tuples.swift
new file mode 100644
index 0000000..c0e0a3d
--- /dev/null
+++ b/test/SILGen/plus_zero_tuples.swift
@@ -0,0 +1,166 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+class C {}
+
+enum Foo {
+ case X(C, Int)
+}
+
+// <rdar://problem/16020428>
+// CHECK-LABEL: sil hidden @$S6tuples8matchFoo1xyAA0C0O_tF
+func matchFoo(x x: Foo) {
+ switch x {
+ case .X(let x):
+ ()
+ }
+}
+
+protocol P { func foo() }
+struct A : P { func foo() {} }
+
+func make_int() -> Int { return 0 }
+func make_p() -> P { return A() }
+func make_xy() -> (x: Int, y: P) { return (make_int(), make_p()) }
+
+// CHECK-LABEL: sil hidden @$S6tuples17testShuffleOpaqueyyF
+func testShuffleOpaque() {
+ // CHECK: [[X:%.*]] = alloc_box ${ var P }
+ // CHECK-NEXT: [[PBX:%.*]] = project_box [[X]]
+ // CHECK: [[Y:%.*]] = alloc_box ${ var Int }
+ // CHECK-NEXT: [[PBY:%.*]] = project_box [[Y]]
+
+ // CHECK: [[T0:%.*]] = function_ref @$S6tuples7make_xySi1x_AA1P_p1ytyF
+ // CHECK-NEXT: [[T1:%.*]] = apply [[T0]]([[PBX]])
+ // CHECK-NEXT: store [[T1]] to [trivial] [[PBY]]
+ var (x,y) : (y:P, x:Int) = make_xy()
+
+ // CHECK-NEXT: [[PAIR:%.*]] = alloc_box ${ var (y: P, x: Int) }
+ // CHECK-NEXT: [[PBPAIR:%.*]] = project_box [[PAIR]]
+ // CHECK-NEXT: [[PAIR_0:%.*]] = tuple_element_addr [[PBPAIR]] : $*(y: P, x: Int), 0
+ // CHECK-NEXT: [[PAIR_1:%.*]] = tuple_element_addr [[PBPAIR]] : $*(y: P, x: Int), 1
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[T0:%.*]] = function_ref @$S6tuples7make_xySi1x_AA1P_p1ytyF
+ // CHECK-NEXT: [[T1:%.*]] = apply [[T0]]([[PAIR_0]])
+ // CHECK-NEXT: store [[T1]] to [trivial] [[PAIR_1]]
+ var pair : (y:P, x:Int) = make_xy()
+
+ // CHECK-NEXT: [[TEMP:%.*]] = alloc_stack $P
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[T0:%.*]] = function_ref @$S6tuples7make_xySi1x_AA1P_p1ytyF
+ // CHECK-NEXT: [[T1:%.*]] = apply [[T0]]([[TEMP]])
+ // CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PBPAIR]] : $*(y: P, x: Int)
+ // CHECK-NEXT: [[PAIR_0:%.*]] = tuple_element_addr [[WRITE]] : $*(y: P, x: Int), 0
+ // CHECK-NEXT: copy_addr [take] [[TEMP]] to [[PAIR_0]]
+ // CHECK-NEXT: [[PAIR_1:%.*]] = tuple_element_addr [[WRITE]] : $*(y: P, x: Int), 1
+ // CHECK-NEXT: assign [[T1]] to [[PAIR_1]]
+ // CHECK-NEXT: end_access [[WRITE]] : $*(y: P, x: Int)
+ // CHECK-NEXT: dealloc_stack [[TEMP]]
+ pair = make_xy()
+}
+
+// CHECK-LABEL: testShuffleTuple
+func testShuffleTuple() {
+ // CHECK: [[X:%.*]] = alloc_box ${ var P }
+ // CHECK-NEXT: [[PBX:%.*]] = project_box [[X]]
+ // CHECK: [[Y:%.*]] = alloc_box ${ var Int }
+ // CHECK-NEXT: [[PBY:%.*]] = project_box [[Y]]
+
+ // CHECK: [[T0:%.*]] = function_ref @$S6tuples8make_intSiyF
+ // CHECK-NEXT: [[T1:%.*]] = apply [[T0]]()
+ // CHECK-NEXT: store [[T1]] to [trivial] [[PBY]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[T0:%.*]] = function_ref @$S6tuples6make_pAA1P_pyF
+ // CHECK-NEXT: apply [[T0]]([[PBX]])
+ var (x,y) : (y:P, x:Int) = (x: make_int(), y: make_p())
+
+ // CHECK-NEXT: [[PAIR:%.*]] = alloc_box ${ var (y: P, x: Int) }
+ // CHECK-NEXT: [[PBPAIR:%.*]] = project_box [[PAIR]]
+ // CHECK-NEXT: [[PAIR_0:%.*]] = tuple_element_addr [[PBPAIR]] : $*(y: P, x: Int), 0
+ // CHECK-NEXT: [[PAIR_1:%.*]] = tuple_element_addr [[PBPAIR]] : $*(y: P, x: Int), 1
+ // CHECK-NEXT: // function_ref
+ // CHECK: [[T0:%.*]] = function_ref @$S6tuples8make_intSiyF
+ // CHECK-NEXT: [[T1:%.*]] = apply [[T0]]()
+ // CHECK-NEXT: store [[T1]] to [trivial] [[PAIR_1]]
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[T0:%.*]] = function_ref @$S6tuples6make_pAA1P_pyF
+ // CHECK-NEXT: apply [[T0]]([[PAIR_0]])
+ var pair : (y:P, x:Int) = (x: make_int(), y: make_p())
+
+ // This isn't really optimal; we should be evaluating make_p directly
+ // into the temporary.
+ // CHECK-NEXT: // function_ref
+ // CHECK: [[T0:%.*]] = function_ref @$S6tuples8make_intSiyF
+ // CHECK-NEXT: [[INT:%.*]] = apply [[T0]]()
+ // CHECK-NEXT: [[TEMP:%.*]] = alloc_stack $P
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[T0:%.*]] = function_ref @$S6tuples6make_pAA1P_pyF
+ // CHECK-NEXT: apply [[T0]]([[TEMP]])
+ // CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PBPAIR]] : $*(y: P, x: Int)
+ // CHECK-NEXT: [[PAIR_0:%.*]] = tuple_element_addr [[WRITE]] : $*(y: P, x: Int), 0
+ // CHECK-NEXT: copy_addr [take] [[TEMP]] to [[PAIR_0]]
+ // CHECK-NEXT: [[PAIR_1:%.*]] = tuple_element_addr [[WRITE]] : $*(y: P, x: Int), 1
+ // CHECK-NEXT: assign [[INT]] to [[PAIR_1]]
+ // CHECK-NEXT: end_access [[WRITE]] : $*(y: P, x: Int)
+ // CHECK-NEXT: dealloc_stack [[TEMP]]
+ pair = (x: make_int(), y: make_p())
+}
+
+enum GenericEnum<T> {
+ case one(T)
+
+ static var callback: (T) -> Void { fatalError() }
+}
+
+// CHECK-LABEL: $S6tuples16testTupleUnsplatyyF
+func testTupleUnsplat() {
+ // CHECK: debug_value [[X:%.+]] : $Int, let, name "x"
+ // CHECK: debug_value [[Y:%.+]] : $Int, let, name "y"
+ let x = 1, y = 2
+
+ // CHECK: [[TUPLE:%.+]] = tuple ([[X]] : $Int, [[Y]] : $Int)
+ // CHECK: enum $GenericEnum<(Int, Int)>, #GenericEnum.one!enumelt.1, [[TUPLE]]
+ _ = GenericEnum<(Int, Int)>.one((x, y))
+ // CHECK: [[TUPLE:%.+]] = tuple ([[X]] : $Int, [[Y]] : $Int)
+ // CHECK: enum $GenericEnum<(Int, Int)>, #GenericEnum.one!enumelt.1, [[TUPLE]]
+ _ = GenericEnum<(Int, Int)>.one(x, y)
+
+ // CHECK: [[THUNK:%.+]] = function_ref @$SSi_SitIegn_S2iIegyy_TR
+ // CHECK: [[REABSTRACTED:%.+]] = partial_apply [callee_guaranteed] [[THUNK]]({{%.+}})
+ // CHECK: [[BORROW:%.*]] = begin_borrow [[REABSTRACTED]]
+ // CHECK: apply [[BORROW]]([[X]], [[Y]])
+ _ = GenericEnum<(Int, Int)>.callback((x, y))
+ // CHECK: [[THUNK:%.+]] = function_ref @$SSi_SitIegn_S2iIegyy_TR
+ // CHECK: [[REABSTRACTED:%.+]] = partial_apply [callee_guaranteed] [[THUNK]]({{%.+}})
+ // CHECK: [[BORROW:%.*]] = begin_borrow [[REABSTRACTED]]
+ // CHECK: apply [[BORROW]]([[X]], [[Y]])
+ _ = GenericEnum<(Int, Int)>.callback(x, y)
+} // CHECK: end sil function '$S6tuples16testTupleUnsplatyyF'
+
+// Make sure that we use a load_borrow instead of a load [take] when RValues are
+// formed with isGuaranteed set.
+extension P {
+ // CHECK-LABEL: sil hidden @$S6tuples1PPAAE12immutableUse5tupleyAA1CC5index_x5valuet_tFZ
+ // CHECK: bb0([[TUP0:%.*]] : @guaranteed $C, [[TUP1:%.*]] : @trivial $*Self
+ // Allocate space for the RValue.
+ // CHECK: [[RVALUE:%.*]] = alloc_stack $(index: C, value: Self), let, name "tuple"
+ //
+ // Initialize the RValue. (This is here to help pattern matching).
+ // CHECK: [[ZERO_ADDR:%.*]] = tuple_element_addr [[RVALUE]] : $*(index: C, value: Self), 0
+ // CHECK: [[TUP0_COPY:%.*]] = copy_value [[TUP0]]
+ // CHECK: store [[TUP0_COPY]] to [init] [[ZERO_ADDR]]
+ // CHECK: [[ONE_ADDR:%.*]] = tuple_element_addr [[RVALUE]] : $*(index: C, value: Self), 1
+ // CHECK: copy_addr [[TUP1]] to [initialization] [[ONE_ADDR]]
+ //
+ // What we are actually trying to check. Note that there is no actual use of
+ // LOADED_CLASS. This is b/c of the nature of the RValue we are working with.
+ // CHECK: [[ZERO_ADDR:%.*]] = tuple_element_addr [[RVALUE]] : $*(index: C, value: Self), 0
+ // CHECK: [[LOADED_CLASS:%.*]] = load_borrow [[ZERO_ADDR]]
+ // CHECK: [[ONE_ADDR:%.*]] = tuple_element_addr [[RVALUE]] : $*(index: C, value: Self), 1
+ // CHECK: apply {{.*}}([[ONE_ADDR]]) : $@convention(witness_method: P)
+ // CHECK: end_borrow [[LOADED_CLASS]] from [[ZERO_ADDR]]
+ // CHECK: destroy_addr [[RVALUE]]
+ // CHECK: dealloc_stack [[RVALUE]]
+ public static func immutableUse(tuple: (index: C, value: Self)) -> () {
+ return tuple.value.foo()
+ }
+}
diff --git a/test/SILGen/plus_zero_types.swift b/test/SILGen/plus_zero_types.swift
new file mode 100644
index 0000000..ff5aae4
--- /dev/null
+++ b/test/SILGen/plus_zero_types.swift
@@ -0,0 +1,105 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -parse-as-library -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+class C {
+ var member: Int = 0
+
+ // Methods have method calling convention.
+ // CHECK-LABEL: sil hidden @$S5types1CC3foo1xySi_tF : $@convention(method) (Int, @guaranteed C) -> () {
+ func foo(x x: Int) {
+ // CHECK: bb0([[X:%[0-9]+]] : @trivial $Int, [[THIS:%[0-9]+]] : @guaranteed $C):
+ member = x
+
+ // CHECK-NOT: copy_value
+ // CHECK: [[FN:%[0-9]+]] = class_method %1 : $C, #C.member!setter.1
+ // CHECK: apply [[FN]](%0, %1) : $@convention(method) (Int, @guaranteed C) -> ()
+ // CHECK-NOT: destroy_value
+ }
+ // CHECK: } // end sil function '$S5types1CC3foo1xySi_tF'
+}
+
+struct S {
+ var member: Int
+
+ // CHECK-LABEL: sil hidden @{{.*}}1SV3foo{{.*}} : $@convention(method) (Int, @inout S) -> ()
+ mutating
+ func foo(x x: Int) {
+ var x = x
+ // CHECK: bb0([[X:%[0-9]+]] : @trivial $Int, [[THIS:%[0-9]+]] : @trivial $*S):
+ member = x
+ // CHECK: [[XBOX:%[0-9]+]] = alloc_box ${ var Int }
+ // CHECK: [[XADDR:%[0-9]+]] = project_box [[XBOX]]
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[XADDR]] : $*Int
+ // CHECK: [[X:%.*]] = load [trivial] [[READ]] : $*Int
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[THIS]] : $*S
+ // CHECK: [[MEMBER:%[0-9]+]] = struct_element_addr [[WRITE]] : $*S, #S.member
+ // CHECK: assign [[X]] to [[MEMBER]] : $*Int
+ }
+
+ class SC {
+ // CHECK-LABEL: sil hidden @$S5types1SV2SCC3bar{{.*}}
+ func bar() {}
+ }
+}
+
+func f() {
+ class FC {
+ func zim() {}
+ }
+}
+
+func g(b b : Bool) {
+ if (b) {
+ class FC {
+ func zim() {}
+ }
+ } else {
+ class FC {
+ func zim() {}
+ }
+ }
+}
+
+struct ReferencedFromFunctionStruct {
+ let f: (ReferencedFromFunctionStruct) -> () = {x in ()}
+ let g: (ReferencedFromFunctionEnum) -> () = {x in ()}
+}
+
+enum ReferencedFromFunctionEnum {
+ case f((ReferencedFromFunctionEnum) -> ())
+ case g((ReferencedFromFunctionStruct) -> ())
+}
+
+// CHECK-LABEL: sil hidden @$S5types34referencedFromFunctionStructFieldsyyAA010ReferencedcdE0Vc_yAA0gcD4EnumOctADF{{.*}} : $@convention(thin) (@guaranteed ReferencedFromFunctionStruct) -> (@owned @callee_guaranteed (@guaranteed ReferencedFromFunctionStruct) -> (), @owned @callee_guaranteed (@guaranteed ReferencedFromFunctionEnum) -> ()) {
+// CHECK: bb0([[X:%.*]] : @guaranteed $ReferencedFromFunctionStruct):
+// CHECK: [[F:%.*]] = struct_extract [[X]] : $ReferencedFromFunctionStruct, #ReferencedFromFunctionStruct.f
+// CHECK: [[COPIED_F:%.*]] = copy_value [[F]] : $@callee_guaranteed (@guaranteed ReferencedFromFunctionStruct) -> ()
+// CHECK: [[G:%.*]] = struct_extract [[X]] : $ReferencedFromFunctionStruct, #ReferencedFromFunctionStruct.g
+// CHECK: [[COPIED_G:%.*]] = copy_value [[G]] : $@callee_guaranteed (@guaranteed ReferencedFromFunctionEnum) -> ()
+// CHECK: [[RESULT:%.*]] = tuple ([[COPIED_F]] : {{.*}}, [[COPIED_G]] : {{.*}})
+// CHECK: return [[RESULT]]
+// CHECK: } // end sil function '$S5types34referencedFromFunctionStructFieldsyyAA010ReferencedcdE0Vc_yAA0gcD4EnumOctADF'
+func referencedFromFunctionStructFields(_ x: ReferencedFromFunctionStruct)
+ -> ((ReferencedFromFunctionStruct) -> (), (ReferencedFromFunctionEnum) -> ()) {
+ return (x.f, x.g)
+}
+
+// CHECK-LABEL: sil hidden @$S5types32referencedFromFunctionEnumFieldsyyAA010ReferencedcdE0OcSg_yAA0gcD6StructVcSgtADF
+// CHECK: bb{{[0-9]+}}([[F:%.*]] : @owned $@callee_guaranteed (@guaranteed ReferencedFromFunctionEnum) -> ()):
+// CHECK: bb{{[0-9]+}}([[G:%.*]] : @owned $@callee_guaranteed (@guaranteed ReferencedFromFunctionStruct) -> ()):
+func referencedFromFunctionEnumFields(_ x: ReferencedFromFunctionEnum)
+ -> (
+ ((ReferencedFromFunctionEnum) -> ())?,
+ ((ReferencedFromFunctionStruct) -> ())?
+ ) {
+ switch x {
+ case .f(let f):
+ return (f, nil)
+ case .g(let g):
+ return (nil, g)
+ }
+}
+
+// CHECK-LABEL: sil private @$S5types1fyyF2FCL_C3zimyyF
+// CHECK-LABEL: sil private @$S5types1g1bySb_tF2FCL_C3zimyyF
+// CHECK-LABEL: sil private @$S5types1g1bySb_tF2FCL0_C3zimyyF
diff --git a/test/SILGen/plus_zero_unmanaged.swift b/test/SILGen/plus_zero_unmanaged.swift
new file mode 100644
index 0000000..0a8d7b2
--- /dev/null
+++ b/test/SILGen/plus_zero_unmanaged.swift
@@ -0,0 +1,57 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -emit-sil %s | %FileCheck %s
+
+class C {}
+
+struct Holder {
+ unowned(unsafe) var value: C
+}
+_ = Holder(value: C())
+// CHECK-LABEL:sil hidden @$S9unmanaged6HolderV{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@owned C, @thin Holder.Type) -> Holder
+// CHECK: bb0([[T0:%.*]] : $C,
+// CHECK-NEXT: [[T1:%.*]] = ref_to_unmanaged [[T0]] : $C to $@sil_unmanaged C
+// CHECK-NEXT: strong_release [[T0]] : $C
+// CHECK-NEXT: [[T2:%.*]] = struct $Holder ([[T1]] : $@sil_unmanaged C)
+// CHECK-NEXT: return [[T2]] : $Holder
+
+func set(holder holder: inout Holder) {
+ holder.value = C()
+}
+// CHECK-LABEL:sil hidden @$S9unmanaged3set6holderyAA6HolderVz_tF : $@convention(thin) (@inout Holder) -> ()
+// CHECK: bb0([[ADDR:%.*]] : $*Holder):
+// CHECK: [[T0:%.*]] = function_ref @$S9unmanaged1CC{{[_0-9a-zA-Z]*}}fC
+// CHECK: [[C:%.*]] = apply [[T0]](
+// CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [static] [[ADDR]] : $*Holder
+// CHECK-NEXT: [[T0:%.*]] = struct_element_addr [[WRITE]] : $*Holder, #Holder.value
+// CHECK-NEXT: [[T1:%.*]] = ref_to_unmanaged [[C]]
+// CHECK-NEXT: store [[T1]] to [[T0]]
+// CHECK-NEXT: strong_release [[C]]
+// CHECK-NEXT: end_access [[WRITE]] : $*Holder
+// CHECK-NEXT: tuple ()
+// CHECK-NEXT: return
+
+func get(holder holder: inout Holder) -> C {
+ return holder.value
+}
+// CHECK-LABEL:sil hidden @$S9unmanaged3get6holderAA1CCAA6HolderVz_tF : $@convention(thin) (@inout Holder) -> @owned C
+// CHECK: bb0([[ADDR:%.*]] : $*Holder):
+// CHECK-NEXT: debug_value_addr %0 : $*Holder, var, name "holder", argno 1
+// CHECK-NEXT: [[READ:%.*]] = begin_access [read] [static] [[ADDR]] : $*Holder
+// CHECK-NEXT: [[T0:%.*]] = struct_element_addr [[READ]] : $*Holder, #Holder.value
+// CHECK-NEXT: [[T1:%.*]] = load [[T0]] : $*@sil_unmanaged C
+// CHECK-NEXT: [[T2:%.*]] = unmanaged_to_ref [[T1]]
+// CHECK-NEXT: strong_retain [[T2]]
+// CHECK-NEXT: end_access [[READ]] : $*Holder
+// CHECK-NEXT: return [[T2]]
+
+func project(fn fn: () -> Holder) -> C {
+ return fn().value
+}
+// CHECK-LABEL: sil hidden @$S9unmanaged7project2fnAA1CCAA6HolderVyXE_tF : $@convention(thin) (@noescape @callee_guaranteed () -> Holder) -> @owned C
+// CHECK: bb0([[FN:%.*]] : $@noescape @callee_guaranteed () -> Holder):
+// CHECK-NEXT: debug_value
+// CHECK-NEXT: [[T0:%.*]] = apply [[FN]]()
+// CHECK-NEXT: [[T1:%.*]] = struct_extract [[T0]] : $Holder, #Holder.value
+// CHECK-NEXT: [[T2:%.*]] = unmanaged_to_ref [[T1]]
+// CHECK-NEXT: strong_retain [[T2]]
+// CHECK-NEXT: return [[T2]]
diff --git a/test/SILGen/plus_zero_unmanaged_ownership.swift b/test/SILGen/plus_zero_unmanaged_ownership.swift
new file mode 100644
index 0000000..8384266
--- /dev/null
+++ b/test/SILGen/plus_zero_unmanaged_ownership.swift
@@ -0,0 +1,69 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -module-name Swift -emit-silgen %s | %FileCheck %s
+
+class C {}
+
+enum Optional<T> {
+case none
+case some(T)
+}
+
+precedencegroup AssignmentPrecedence {
+ assignment: true
+ associativity: right
+}
+
+struct Holder {
+ unowned(unsafe) var value: C
+}
+
+_ = Holder(value: C())
+// CHECK-LABEL:sil hidden @$Ss6HolderV{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@owned C, @thin Holder.Type) -> Holder
+// CHECK: bb0([[T0:%.*]] : @owned $C,
+// CHECK-NEXT: [[T1:%.*]] = ref_to_unmanaged [[T0]] : $C to $@sil_unmanaged C
+// CHECK-NEXT: destroy_value [[T0]] : $C
+// CHECK-NEXT: [[T2:%.*]] = struct $Holder ([[T1]] : $@sil_unmanaged C)
+// CHECK-NEXT: return [[T2]] : $Holder
+// CHECK-NEXT: } // end sil function '$Ss6HolderV5valueABs1CC_tcfC'
+func set(holder holder: inout Holder) {
+ holder.value = C()
+}
+
+// CHECK-LABEL: sil hidden @$Ss3set6holderys6HolderVz_tF : $@convention(thin) (@inout Holder) -> () {
+// CHECK: bb0([[ADDR:%.*]] : @trivial $*Holder):
+// CHECK: [[T0:%.*]] = function_ref @$Ss1CC{{[_0-9a-zA-Z]*}}fC
+// CHECK: [[C:%.*]] = apply [[T0]](
+// CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [unknown] [[ADDR]] : $*Holder
+// CHECK-NEXT: [[T0:%.*]] = struct_element_addr [[WRITE]] : $*Holder, #Holder.value
+// CHECK-NEXT: [[T1:%.*]] = ref_to_unmanaged [[C]]
+// CHECK-NEXT: assign [[T1]] to [[T0]]
+// CHECK-NEXT: destroy_value [[C]]
+// CHECK-NEXT: end_access [[WRITE]] : $*Holder
+// CHECK: } // end sil function '$Ss3set6holderys6HolderVz_tF'
+
+func get(holder holder: inout Holder) -> C {
+ return holder.value
+}
+// CHECK-LABEL: sil hidden @$Ss3get6holders1CCs6HolderVz_tF : $@convention(thin) (@inout Holder) -> @owned C {
+// CHECK: bb0([[ADDR:%.*]] : @trivial $*Holder):
+// CHECK-NEXT: debug_value_addr %0 : $*Holder, var, name "holder", argno 1
+// CHECK-NEXT: [[READ:%.*]] = begin_access [read] [unknown] [[ADDR]] : $*Holder
+// CHECK-NEXT: [[T0:%.*]] = struct_element_addr [[READ]] : $*Holder, #Holder.value
+// CHECK-NEXT: [[T1:%.*]] = load [trivial] [[T0]] : $*@sil_unmanaged C
+// CHECK-NEXT: [[T2:%.*]] = unmanaged_to_ref [[T1]]
+// CHECK-NEXT: [[T2_COPY:%.*]] = copy_value [[T2]]
+// CHECK-NEXT: end_access [[READ]] : $*Holder
+// CHECK-NEXT: return [[T2_COPY]]
+
+func project(fn fn: () -> Holder) -> C {
+ return fn().value
+}
+// CHECK-LABEL: sil hidden @$Ss7project2fns1CCs6HolderVyXE_tF : $@convention(thin) (@noescape @callee_guaranteed () -> Holder) -> @owned C {
+// CHECK: bb0([[FN:%.*]] : @trivial $@noescape @callee_guaranteed () -> Holder):
+// CHECK-NEXT: debug_value
+// CHECK-NEXT: [[T0:%.*]] = apply [[FN]]()
+// CHECK-NEXT: [[T1:%.*]] = struct_extract [[T0]] : $Holder, #Holder.value
+// CHECK-NEXT: [[T2:%.*]] = unmanaged_to_ref [[T1]]
+// CHECK-NEXT: [[COPIED_T2:%.*]] = copy_value [[T2]]
+// CHECK-NOT: destroy_value [[BORROWED_FN_COPY]]
+// CHECK-NEXT: return [[COPIED_T2]]
diff --git a/test/SILGen/plus_zero_unowned.swift b/test/SILGen/plus_zero_unowned.swift
new file mode 100644
index 0000000..ff712fb
--- /dev/null
+++ b/test/SILGen/plus_zero_unowned.swift
@@ -0,0 +1,162 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+func takeClosure(_ fn: () -> Int) {}
+
+class C {
+ func f() -> Int { return 42 }
+}
+
+struct A {
+ unowned var x: C
+}
+_ = A(x: C())
+// CHECK-LABEL: sil hidden @$S7unowned1AV{{[_0-9a-zA-Z]*}}fC
+// CHECK: bb0([[X:%.*]] : @owned $C, %1 : @trivial $@thin A.Type):
+// CHECK: [[X_UNOWNED:%.*]] = ref_to_unowned [[X]] : $C to $@sil_unowned C
+// CHECK: [[X_UNOWNED_COPY:%.*]] = copy_value [[X_UNOWNED]]
+// CHECK: destroy_value [[X]]
+// CHECK: [[A:%.*]] = struct $A ([[X_UNOWNED_COPY]] : $@sil_unowned C)
+// CHECK: return [[A]]
+// CHECK: }
+
+protocol P {}
+struct X: P {}
+
+struct AddressOnly {
+ unowned var x: C
+ var p: P
+}
+_ = AddressOnly(x: C(), p: X())
+// CHECK-LABEL: sil hidden @$S7unowned11AddressOnlyV{{[_0-9a-zA-Z]*}}fC
+// CHECK: bb0([[RET:%.*]] : @trivial $*AddressOnly, [[X:%.*]] : @owned $C, {{.*}}):
+// CHECK: [[X_ADDR:%.*]] = struct_element_addr [[RET]] : $*AddressOnly, #AddressOnly.x
+// CHECK: [[X_UNOWNED:%.*]] = ref_to_unowned [[X]] : $C to $@sil_unowned C
+// CHECK: [[X_UNOWNED_COPY:%.*]] = copy_value [[X_UNOWNED]] : $@sil_unowned C
+// CHECK: store [[X_UNOWNED_COPY]] to [init] [[X_ADDR]]
+// CHECK: destroy_value [[X]]
+// CHECK: }
+
+// CHECK-LABEL: sil hidden @$S7unowned5test01cyAA1CC_tF : $@convention(thin) (@guaranteed C) -> () {
+func test0(c c: C) {
+ // CHECK: bb0([[ARG:%.*]] : @guaranteed $C):
+
+ var a: A
+ // CHECK: [[A1:%.*]] = alloc_box ${ var A }, var, name "a"
+ // CHECK: [[MARKED_A1:%.*]] = mark_uninitialized [var] [[A1]]
+ // CHECK: [[PBA:%.*]] = project_box [[MARKED_A1]]
+
+ unowned var x = c
+ // CHECK: [[X:%.*]] = alloc_box ${ var @sil_unowned C }
+ // CHECK: [[PBX:%.*]] = project_box [[X]]
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: [[T2:%.*]] = ref_to_unowned [[ARG_COPY]] : $C to $@sil_unowned C
+ // CHECK: [[T2_COPY:%.*]] = copy_value [[T2]] : $@sil_unowned C
+ // CHECK: store [[T2_COPY]] to [init] [[PBX]] : $*@sil_unowned C
+ // CHECK: destroy_value [[ARG_COPY]]
+
+ a.x = c
+ // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]]
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PBA]]
+ // CHECK: [[T1:%.*]] = struct_element_addr [[WRITE]] : $*A, #A.x
+ // CHECK: [[T2:%.*]] = ref_to_unowned [[ARG_COPY]] : $C
+ // CHECK: [[T2_COPY:%.*]] = copy_value [[T2]] : $@sil_unowned C
+ // CHECK: assign [[T2_COPY]] to [[T1]] : $*@sil_unowned C
+ // CHECK: destroy_value [[ARG_COPY]]
+
+ a.x = x
+ // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[PBX]]
+ // CHECK: [[T2:%.*]] = load_borrow [[READ]] : $*@sil_unowned C
+ // CHECK: [[T3:%.*]] = copy_unowned_value [[T2]] : $@sil_unowned C
+ // CHECK: end_borrow [[T2]] from [[READ]]
+ // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PBA]]
+ // CHECK: [[XP:%.*]] = struct_element_addr [[WRITE]] : $*A, #A.x
+ // CHECK: [[T4:%.*]] = ref_to_unowned [[T3]] : $C to $@sil_unowned C
+ // CHECK: [[T4_COPY:%.*]] = copy_value [[T4]] : $@sil_unowned C
+ // CHECK: assign [[T4_COPY]] to [[XP]] : $*@sil_unowned C
+ // CHECK: destroy_value [[T3]] : $C
+ // CHECK: destroy_value [[X]]
+ // CHECK: destroy_value [[MARKED_A1]]
+}
+// CHECK: } // end sil function '$S7unowned5test01cyAA1CC_tF'
+
+// CHECK-LABEL: sil hidden @{{.*}}testunowned_local
+func testunowned_local() -> C {
+ // CHECK: [[C:%.*]] = apply
+ let c = C()
+
+ // CHECK: [[UC:%.*]] = alloc_box ${ var @sil_unowned C }, let, name "uc"
+ // CHECK: [[PB_UC:%.*]] = project_box [[UC]]
+ // CHECK: [[BORROWED_C:%.*]] = begin_borrow [[C]]
+ // CHECK: [[C_COPY:%.*]] = copy_value [[BORROWED_C]]
+ // CHECK: [[tmp1:%.*]] = ref_to_unowned [[C_COPY]] : $C to $@sil_unowned C
+ // CHECK: [[tmp1_copy:%.*]] = copy_value [[tmp1]]
+ // CHECK: store [[tmp1_copy]] to [init] [[PB_UC]]
+ // CHECK: destroy_value [[C_COPY]]
+ // CHECK: end_borrow [[BORROWED_C]] from [[C]]
+ unowned let uc = c
+
+ // CHECK: [[tmp2:%.*]] = load_borrow [[PB_UC]]
+ // CHECK: [[tmp3:%.*]] = copy_unowned_value [[tmp2]]
+ // CHECK: end_borrow [[tmp2]] from [[PB_UC]]
+ return uc
+
+ // CHECK: destroy_value [[UC]]
+ // CHECK: destroy_value [[C]]
+ // CHECK: return [[tmp3]]
+}
+
+// <rdar://problem/16877510> capturing an unowned let crashes in silgen
+func test_unowned_let_capture(_ aC : C) {
+ unowned let bC = aC
+ takeClosure { bC.f() }
+}
+
+// CHECK-LABEL: sil private @$S7unowned05test_A12_let_captureyyAA1CCFSiyXEfU_ : $@convention(thin) (@guaranteed @sil_unowned C) -> Int {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $@sil_unowned C):
+// CHECK-NEXT: debug_value %0 : $@sil_unowned C, let, name "bC", argno 1
+// CHECK-NEXT: [[UNOWNED_ARG:%.*]] = copy_unowned_value [[ARG]] : $@sil_unowned C
+// CHECK-NEXT: [[BORROWED_UNOWNED_ARG:%.*]] = begin_borrow [[UNOWNED_ARG]]
+// CHECK-NEXT: [[FUN:%.*]] = class_method [[BORROWED_UNOWNED_ARG]] : $C, #C.f!1 : (C) -> () -> Int, $@convention(method) (@guaranteed C) -> Int
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[FUN]]([[BORROWED_UNOWNED_ARG]]) : $@convention(method) (@guaranteed C) -> Int
+// CHECK-NEXT: end_borrow [[BORROWED_UNOWNED_ARG]]
+// CHECK-NEXT: destroy_value [[UNOWNED_ARG]]
+// CHECK-NEXT: return [[RESULT]] : $Int
+
+
+
+// <rdar://problem/16880044> unowned let properties don't work as struct and class members
+class TestUnownedMember {
+ unowned let member : C
+ init(inval: C) {
+ self.member = inval
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S7unowned17TestUnownedMemberC5invalAcA1CC_tcfc :
+// CHECK: bb0([[ARG1:%.*]] : @owned $C, [[SELF_PARAM:%.*]] : @owned $TestUnownedMember):
+// CHECK: [[SELF:%.*]] = mark_uninitialized [rootself] [[SELF_PARAM]] : $TestUnownedMember
+// CHECK: [[BORROWED_SELF:%.*]] = begin_borrow [[SELF]]
+// CHECK: [[BORROWED_ARG1:%.*]] = begin_borrow [[ARG1]]
+// CHECK: [[ARG1_COPY:%.*]] = copy_value [[BORROWED_ARG1]]
+// CHECK: [[FIELDPTR:%.*]] = ref_element_addr [[BORROWED_SELF]] : $TestUnownedMember, #TestUnownedMember.member
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [dynamic] [[FIELDPTR]] : $*@sil_unowned C
+// CHECK: [[INVAL:%.*]] = ref_to_unowned [[ARG1_COPY]] : $C to $@sil_unowned C
+// CHECK: [[INVAL_COPY:%.*]] = copy_value [[INVAL]] : $@sil_unowned C
+// CHECK: assign [[INVAL_COPY]] to [[WRITE]] : $*@sil_unowned C
+// CHECK: destroy_value [[ARG1_COPY]] : $C
+// CHECK: end_borrow [[BORROWED_ARG1]] from [[ARG1]]
+// CHECK: end_borrow [[BORROWED_SELF]] from [[SELF]]
+// CHECK: [[RET_SELF:%.*]] = copy_value [[SELF]]
+// CHECK: destroy_value [[SELF]]
+// CHECK: destroy_value [[ARG1]]
+// CHECK: return [[RET_SELF]] : $TestUnownedMember
+// CHECK: } // end sil function '$S7unowned17TestUnownedMemberC5invalAcA1CC_tcfc'
+
+// Just verify that lowering an unowned reference to a type parameter
+// doesn't explode.
+struct Unowned<T: AnyObject> {
+ unowned var object: T
+}
+func takesUnownedStruct(_ z: Unowned<C>) {}
+// CHECK-LABEL: sil hidden @$S7unowned18takesUnownedStructyyAA0C0VyAA1CCGF : $@convention(thin) (@guaranteed Unowned<C>) -> ()
diff --git a/test/SILGen/plus_zero_vtable_thunks_reabstraction_final.swift b/test/SILGen/plus_zero_vtable_thunks_reabstraction_final.swift
new file mode 100644
index 0000000..4cd5aee
--- /dev/null
+++ b/test/SILGen/plus_zero_vtable_thunks_reabstraction_final.swift
@@ -0,0 +1,49 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+protocol Fooable {
+ func foo(_ x: Int) -> Int?
+}
+
+protocol Barrable {
+ associatedtype Bar
+ func foo(_ x: Bar) -> Bar?
+}
+
+class GenericSuper<T> {
+ func foo(_ x: T) -> T? {
+ return nil
+ }
+}
+
+class NongenericSub: GenericSuper<Int>, Fooable {
+ override func foo(_ x: Int) -> Int? {
+ return 6502
+ }
+}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S33vtable_thunks_reabstraction_final13NongenericSubCAA7FooableA2aDP3foo{{[_0-9a-zA-Z]*}}FTW
+// CHECK: class_method {{%.*}} : $NongenericSub, #NongenericSub.foo!1 {{.*}}, $@convention(method) (@in_guaranteed Int, @guaranteed NongenericSub) -> @out Optional<Int>
+
+class GenericSub<U: AnyObject>: GenericSuper<U>, Barrable {
+ override func foo(_ x: U) -> U? {
+ return x
+ }
+}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S33vtable_thunks_reabstraction_final10GenericSubCyxGAA8BarrableA2aEP3fooy3BarQzSgAIFTW
+// CHECK: class_method {{%.*}} : $GenericSub<τ_0_0>, #GenericSub.foo!1 {{.*}}, $@convention(method) <τ_0_0 where τ_0_0 : AnyObject> (@in_guaranteed τ_0_0, @guaranteed GenericSub<τ_0_0>) -> @out Optional<τ_0_0>
+
+class C {}
+
+// CHECK-LABEL: sil hidden @$S33vtable_thunks_reabstraction_final4testyyF
+func test() {
+ // CHECK: class_method {{%.*}} : $NongenericSub, #NongenericSub.foo!1 {{.*}}, $@convention(method) (@in_guaranteed Int, @guaranteed NongenericSub) -> @out Optional<Int>
+ NongenericSub().foo(0)
+
+ // FIXME: rdar://problem/21167978
+ // let f = NongenericSub().curried(0)
+
+ // CHECK: class_method {{%.*}} : $GenericSub<C>, #GenericSub.foo!1 {{.*}}, $@convention(method) <τ_0_0 where τ_0_0 : AnyObject> (@in_guaranteed τ_0_0, @guaranteed GenericSub<τ_0_0>) -> @out Optional<τ_0_0>
+ GenericSub<C>().foo(C())
+}
diff --git a/test/SILGen/plus_zero_vtables_objc.swift b/test/SILGen/plus_zero_vtables_objc.swift
new file mode 100644
index 0000000..ef5fbb0
--- /dev/null
+++ b/test/SILGen/plus_zero_vtables_objc.swift
@@ -0,0 +1,95 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -sdk %S/Inputs -emit-silgen -I %S/Inputs -enable-source-import %s -disable-objc-attr-requires-foundation-module | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import gizmo
+
+// Test ObjC base class
+
+class Hoozit : Gizmo {
+ // Overrides Gizmo.frob
+ override func frob() {}
+
+ // Overrides Gizmo.funge
+ override func funge() {}
+
+ // Overrides Gizmo.foo
+ final override func foo() {}
+
+ func anse() {}
+ func incorrige() {}
+}
+
+// CHECK-LABEL: sil hidden @$S12vtables_objc10callHoozityyAA0D0CF : $@convention(thin) (@guaranteed Hoozit) -> ()
+func callHoozit(_ h: Hoozit) {
+ // CHECK: objc_method {{.*}} : $Hoozit, #Hoozit.frob!1.foreign
+ h.frob()
+ // CHECK: function_ref @$S12vtables_objc6HoozitC3fooyyF
+ h.foo()
+ // CHECK: class_method {{.*}} : $Hoozit, #Hoozit.anse!1
+ h.anse()
+ // CHECK: return
+}
+
+class Wotsit : Hoozit {
+ // Overrides Gizmo.funge
+ override func funge() {}
+
+ // Overrides Hoozit.incorrige
+ override func incorrige() {}
+
+ // Overrides Gizmo.frob
+ final override func frob() {}
+}
+
+// CHECK-LABEL: sil hidden @$S12vtables_objc10callWotsityyAA0D0CF : $@convention(thin) (@guaranteed Wotsit) -> ()
+func callWotsit(_ w: Wotsit) {
+ // CHECK: objc_method {{.*}} : $Wotsit, #Wotsit.funge!1.foreign
+ w.funge()
+ // CHECK: class_method {{.*}} : $Wotsit, #Wotsit.incorrige!1
+ w.incorrige()
+ // CHECK: function_ref @$S12vtables_objc6WotsitC4frobyyF
+ w.frob()
+ // CHECK: return
+}
+
+// Entries only exist for native Swift methods
+
+// CHECK: sil_vtable Hoozit {
+// CHECK-NEXT: #Hoozit.anse!1: {{.*}} : @$S12vtables_objc6HoozitC4anse{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: #Hoozit.incorrige!1: {{.*}} : @$S12vtables_objc6HoozitC9incorrige{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: #Hoozit.init!initializer.1: (Hoozit.Type) -> () -> Hoozit? : @$S12vtables_objc6HoozitCACSgycfc
+// CHECK-NEXT: #Hoozit.init!initializer.1: (Hoozit.Type) -> (Int) -> Hoozit? : @$S12vtables_objc6HoozitC7bellsOnACSgSi_tcfc
+// CHECK-NEXT: #Hoozit.deinit!deallocator: @$S12vtables_objc6HoozitCfD
+// CHECK-NEXT: }
+
+// CHECK: sil_vtable Wotsit {
+// CHECK-NEXT: #Hoozit.anse!1: {{.*}} : @$S12vtables_objc6HoozitC4anse{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: #Hoozit.incorrige!1: {{.*}} : @$S12vtables_objc6WotsitC9incorrige{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: #Hoozit.init!initializer.1: (Hoozit.Type) -> () -> Hoozit? : @$S12vtables_objc6WotsitCACSgycfc
+// CHECK-NEXT: #Hoozit.init!initializer.1: (Hoozit.Type) -> (Int) -> Hoozit? : @$S12vtables_objc6WotsitC7bellsOnACSgSi_tcfc
+// CHECK-NEXT: #Wotsit.deinit!deallocator: @$S12vtables_objc6WotsitCfD
+// CHECK-NEXT: }
+
+// <rdar://problem/15282548>
+// CHECK: sil_vtable Base {
+// CHECK: #Base.init!initializer.1: {{.*}} : @$S12vtables_objc4BaseC{{[_0-9a-zA-Z]*}}fc
+// CHECK: }
+// CHECK: sil_vtable Derived {
+// CHECK: #Base.init!initializer.1: {{.*}} : @$S12vtables_objc7DerivedC{{[_0-9a-zA-Z]*}}fc
+// CHECK: }
+@objc class Base {}
+
+extension Base {
+ // note: does not have a vtable slot, because it is from an extension
+ func identify() -> Int {
+ return 0
+ }
+}
+
+class Derived : Base {
+ override func identify() -> Int {
+ return 1
+ }
+}
diff --git a/test/SILGen/plus_zero_weak.swift b/test/SILGen/plus_zero_weak.swift
new file mode 100644
index 0000000..919a55f
--- /dev/null
+++ b/test/SILGen/plus_zero_weak.swift
@@ -0,0 +1,87 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+class C {
+ func f() -> Int { return 42 }
+}
+
+func takeClosure(fn: @escaping () -> Int) {}
+
+struct A {
+ weak var x: C?
+}
+
+// CHECK: sil hidden @$S4weak5test01cyAA1CC_tF : $@convention(thin) (@guaranteed C) -> () {
+func test0(c c: C) {
+ var c = c
+// CHECK: bb0(%0 : @guaranteed $C):
+// CHECK: [[C:%.*]] = alloc_box ${ var C }
+// CHECK-NEXT: [[PBC:%.*]] = project_box [[C]]
+
+ var a: A
+// CHECK: [[A1:%.*]] = alloc_box ${ var A }
+// CHECK: [[MARKED_A1:%.*]] = mark_uninitialized [var] [[A1]]
+// CHECK-NEXT: [[PBA:%.*]] = project_box [[MARKED_A1]]
+
+ weak var x = c
+// CHECK: [[X:%.*]] = alloc_box ${ var @sil_weak Optional<C> }, var, name "x"
+// CHECK-NEXT: [[PBX:%.*]] = project_box [[X]]
+// Implicit conversion
+// CHECK-NEXT: [[READ:%.*]] = begin_access [read] [unknown] [[PBC]]
+// CHECK-NEXT: [[TMP:%.*]] = load [copy] [[READ]] : $*C
+// CHECK-NEXT: end_access [[READ]]
+// CHECK-NEXT: [[OPTVAL:%.*]] = enum $Optional<C>, #Optional.some!enumelt.1, [[TMP]] : $C
+// CHECK-NEXT: store_weak [[OPTVAL]] to [initialization] [[PBX]] : $*@sil_weak Optional<C>
+// CHECK-NEXT: destroy_value [[OPTVAL]] : $Optional<C>
+
+ a.x = c
+// Implicit conversion
+// CHECK-NEXT: [[READ:%.*]] = begin_access [read] [unknown] [[PBC]]
+// CHECK-NEXT: [[TMP:%.*]] = load [copy] [[READ]] : $*C
+// CHECK-NEXT: end_access [[READ]]
+// CHECK-NEXT: [[OPTVAL:%.*]] = enum $Optional<C>, #Optional.some!enumelt.1, [[TMP]] : $C
+
+// Drill to a.x
+// CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [unknown] [[PBA]]
+// CHECK-NEXT: [[A_X:%.*]] = struct_element_addr [[WRITE]] : $*A, #A.x
+
+// Store to a.x.
+// CHECK-NEXT: store_weak [[OPTVAL]] to [[A_X]] : $*@sil_weak Optional<C>
+// CHECK-NEXT: destroy_value [[OPTVAL]] : $Optional<C>
+}
+
+// <rdar://problem/16871284> silgen crashes on weak capture
+// CHECK: closure #1 () -> Swift.Int in weak.testClosureOverWeak() -> ()
+// CHECK-LABEL: sil private @$S4weak19testClosureOverWeakyyFSiycfU_ : $@convention(thin) (@guaranteed { var @sil_weak Optional<C> }) -> Int {
+// CHECK: bb0(%0 : @guaranteed ${ var @sil_weak Optional<C> }):
+// CHECK-NEXT: %1 = project_box %0
+// CHECK-NEXT: debug_value_addr %1 : $*@sil_weak Optional<C>, var, name "bC", argno 1
+// CHECK-NEXT: [[READ:%.*]] = begin_access [read] [unknown] %1
+// CHECK-NEXT: [[STK:%.*]] = alloc_stack $Optional<C>
+// CHECK-NEXT: [[VAL:%.*]] = load_weak [[READ]] : $*@sil_weak Optional<C>
+// CHECK-NEXT: store [[VAL]] to [init] [[STK]] : $*Optional<C>
+func testClosureOverWeak() {
+ weak var bC = C()
+ takeClosure { bC!.f() }
+}
+
+class CC {
+ weak var x: CC?
+
+ // CHECK-LABEL: sil hidden @$S4weak2CCC{{[_0-9a-zA-Z]*}}fc : $@convention(method) (@owned CC) -> @owned CC {
+ // CHECK: bb0([[SELF:%.*]] : @owned $CC):
+ // CHECK: [[UNINIT_SELF:%.*]] = mark_uninitialized [rootself] [[SELF]] : $CC
+ // CHECK: [[FOO:%.*]] = alloc_box ${ var Optional<CC> }, var, name "foo"
+ // CHECK: [[PB:%.*]] = project_box [[FOO]]
+ // CHECK: [[BORROWED_UNINIT_SELF:%.*]] = begin_borrow [[UNINIT_SELF]]
+ // CHECK: [[X:%.*]] = ref_element_addr [[BORROWED_UNINIT_SELF]] : $CC, #CC.x
+ // CHECK: [[READ:%.*]] = begin_access [read] [dynamic] [[X]] : $*@sil_weak Optional<CC>
+ // CHECK: [[VALUE:%.*]] = load_weak [[READ]] : $*@sil_weak Optional<CC>
+ // CHECK: store [[VALUE]] to [init] [[PB]] : $*Optional<CC>
+ // CHECK: end_borrow [[BORROWED_UNINIT_SELF]] from [[UNINIT_SELF]]
+ // CHECK: destroy_value [[FOO]]
+ // CHECK: } // end sil function '$S4weak2CCC{{[_0-9a-zA-Z]*}}fc'
+ init() {
+ var foo = x
+ }
+}
diff --git a/test/SILGen/plus_zero_weak_multiple_modules.swift b/test/SILGen/plus_zero_weak_multiple_modules.swift
new file mode 100644
index 0000000..2c97546
--- /dev/null
+++ b/test/SILGen/plus_zero_weak_multiple_modules.swift
@@ -0,0 +1,23 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -emit-module-path=%t/weak_other.swiftmodule -module-name=weak_other %S/Inputs/weak_other.swift
+// RUN: %target-swift-frontend -I %t -emit-silgen -enable-sil-ownership %s | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-runtime
+
+import weak_other
+
+// CHECK-LABEL: sil hidden @$S21weak_multiple_modules11doSomething2uiSb0A6_other2UIC_tF : $@convention(thin) (@guaranteed UI) -> Bool
+func doSomething(ui: UI) -> Bool {
+ // CHECK: ref_element_addr
+ // CHECK-objc: load_unowned
+ // CHECK-native: load_borrow
+ // CHECK-native: copy_unowned_value
+ // CHECK-native: end_borrow
+ // CHECK: open_existential_ref
+ // CHECK: witness_method
+ // CHECK: apply
+ // CHECK: open_existential_ref
+ // CHECK: function_ref
+ // CHECK: apply
+ // CHECK: return
+ return ui.environment.router.flags.asBoolean()
+}
diff --git a/test/SILGen/plus_zero_without_actually_escaping.swift b/test/SILGen/plus_zero_without_actually_escaping.swift
new file mode 100644
index 0000000..cce3e9c
--- /dev/null
+++ b/test/SILGen/plus_zero_without_actually_escaping.swift
@@ -0,0 +1,46 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+var escapeHatch: Any = 0
+
+// CHECK-LABEL: sil hidden @$S25without_actually_escaping9letEscape1fyycyyXE_tF
+func letEscape(f: () -> ()) -> () -> () {
+ // CHECK: bb0([[ARG:%.*]] : @trivial $@noescape @callee_guaranteed () -> ()):
+ // TODO: Use a canary wrapper instead of just copying the nonescaping value
+ // CHECK: [[ESCAPABLE_COPY:%.*]] = partial_apply [callee_guaranteed] {{%.*}}([[ARG]])
+ // CHECK: [[MD_ESCAPABLE_COPY:%.*]] = mark_dependence [[ESCAPABLE_COPY]]
+ // CHECK: [[BORROW_MD_ESCAPABLE_COPY:%.*]] = begin_borrow [[MD_ESCAPABLE_COPY]]
+ // CHECK: [[SUB_CLOSURE:%.*]] = function_ref @
+ // CHECK: [[RESULT:%.*]] = apply [[SUB_CLOSURE]]([[BORROW_MD_ESCAPABLE_COPY]])
+ // CHECK: destroy_value [[MD_ESCAPABLE_COPY]]
+ // CHECK: return [[RESULT]]
+ return withoutActuallyEscaping(f) { return $0 }
+}
+
+
+// CHECK-LABEL: sil hidden @$S25without_actually_escaping14letEscapeThrow1fyycyycyKXE_tKF
+// CHECK: bb0([[ARG:%.*]] : @trivial $@noescape @callee_guaranteed () -> (@owned @callee_guaranteed () -> (), @error Error)):
+// CHECK: [[CVT:%.*]] = function_ref @$SIeg_s5Error_pIgozo_Ieg_sAA_pIegozo_TR
+// CHECK: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[CVT]]([[ARG]])
+// CHECK: [[MD:%.*]] = mark_dependence [[CLOSURE]] : {{.*}} on [[ARG]]
+// CHECK: [[BORROW:%.*]] = begin_borrow [[MD]]
+// CHECK: [[COPY:%.*]] = copy_value [[BORROW]]
+// CHECK: [[USER:%.*]] = function_ref @$S25without_actually_escaping14letEscapeThrow1fyycyycyKXE_tKFyycyycyKcKXEfU_
+// CHECK: try_apply [[USER]]([[COPY]]) : {{.*}}, normal bb1, error bb2
+//
+// CHECK: bb1([[RES:%.*]] : @owned $@callee_guaranteed () -> ()):
+// CHECK: [[ESCAPED:%.*]] = is_escaping_closure [[BORROW]]
+// CHECK: cond_fail [[ESCAPED]] : $Builtin.Int1
+// CHECK: end_borrow [[BORROW]] from [[MD]]
+// CHECK: destroy_value [[MD]]
+// CHECK: return [[RES]]
+//
+// CHECK: bb2([[ERR:%.*]] : @owned $Error):
+// CHECK: end_borrow [[BORROW]] from [[MD]]
+// CHECK: destroy_value [[MD]]
+// CHECK: throw [[ERR]] : $Error
+// CHECK: }
+
+func letEscapeThrow(f: () throws -> () -> ()) throws -> () -> () {
+ return try withoutActuallyEscaping(f) { return try $0() }
+}
diff --git a/test/SILGen/plus_zero_witness_same_type.swift b/test/SILGen/plus_zero_witness_same_type.swift
new file mode 100644
index 0000000..93335d1
--- /dev/null
+++ b/test/SILGen/plus_zero_witness_same_type.swift
@@ -0,0 +1,35 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
+// RUN: %target-swift-frontend -enable-sil-ownership -emit-ir %s
+
+protocol Fooable {
+ associatedtype Bar
+
+ func foo<T: Fooable where T.Bar == Self.Bar>(x x: T) -> Self.Bar
+}
+
+struct X {}
+
+// Ensure that the protocol witness for requirements with same-type constraints
+// is set correctly. <rdar://problem/16369105>
+// CHECK-LABEL: sil private [transparent] [thunk] @$S17witness_same_type3FooVAA7FooableA2aDP3foo1x3BarQzqd___tAaDRd__AHQyd__AIRSlFTW : $@convention(witness_method: Fooable) <τ_0_0 where τ_0_0 : Fooable, τ_0_0.Bar == X> (@in_guaranteed τ_0_0, @in_guaranteed Foo) -> @out X
+struct Foo: Fooable {
+ typealias Bar = X
+
+ func foo<T: Fooable where T.Bar == X>(x x: T) -> X { return X() }
+}
+
+// rdar://problem/19049566
+// CHECK-LABEL: sil shared [transparent] [serialized] [thunk] @$S17witness_same_type14LazySequenceOfVyxq_Gs0E0AAsAEP12makeIterator0H0QzyFTW : $@convention(witness_method: Sequence) <τ_0_0, τ_0_1 where τ_0_0 : Sequence, τ_0_1 == τ_0_0.Element> (@in_guaranteed LazySequenceOf<τ_0_0, τ_0_1>) -> @out AnyIterator<τ_0_1>
+public struct LazySequenceOf<SS : Sequence, A where SS.Iterator.Element == A> : Sequence {
+ public func makeIterator() -> AnyIterator<A> {
+ var opt: AnyIterator<A>?
+ return opt!
+ }
+ public subscript(i : Int) -> A {
+ get {
+ var opt: A?
+ return opt!
+ }
+ }
+}
diff --git a/test/SILGen/plus_zero_witness_tables.swift b/test/SILGen/plus_zero_witness_tables.swift
new file mode 100644
index 0000000..e188c03
--- /dev/null
+++ b/test/SILGen/plus_zero_witness_tables.swift
@@ -0,0 +1,551 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -I %S/Inputs -enable-source-import %s -disable-objc-attr-requires-foundation-module > %t.sil
+// RUN: %FileCheck -check-prefix=TABLE -check-prefix=TABLE-ALL %s < %t.sil
+// RUN: %FileCheck -check-prefix=SYMBOL %s < %t.sil
+
+// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -I %S/Inputs -enable-source-import %s -disable-objc-attr-requires-foundation-module -enable-testing > %t.testable.sil
+// RUN: %FileCheck -check-prefix=TABLE-TESTABLE -check-prefix=TABLE-ALL %s < %t.testable.sil
+// RUN: %FileCheck -check-prefix=SYMBOL-TESTABLE %s < %t.testable.sil
+
+import witness_tables_b
+
+struct Arg {}
+
+@objc class ObjCClass {}
+
+infix operator <~>
+
+protocol AssocReqt {
+ func requiredMethod()
+}
+
+protocol ArchetypeReqt {
+ func requiredMethod()
+}
+
+protocol AnyProtocol {
+ associatedtype AssocType
+ associatedtype AssocWithReqt: AssocReqt
+
+ func method(x: Arg, y: Self)
+ func generic<A: ArchetypeReqt>(x: A, y: Self)
+
+ func assocTypesMethod(x: AssocType, y: AssocWithReqt)
+
+ static func staticMethod(x: Self)
+
+ static func <~>(x: Self, y: Self)
+}
+
+protocol ClassProtocol : class {
+ associatedtype AssocType
+ associatedtype AssocWithReqt: AssocReqt
+
+ func method(x: Arg, y: Self)
+ func generic<B: ArchetypeReqt>(x: B, y: Self)
+
+ func assocTypesMethod(x: AssocType, y: AssocWithReqt)
+
+ static func staticMethod(x: Self)
+
+ static func <~>(x: Self, y: Self)
+}
+
+@objc protocol ObjCProtocol {
+ func method(x: ObjCClass)
+ static func staticMethod(y: ObjCClass)
+}
+
+class SomeAssoc {}
+
+struct ConformingAssoc : AssocReqt {
+ func requiredMethod() {}
+}
+// TABLE-LABEL: sil_witness_table hidden ConformingAssoc: AssocReqt module witness_tables {
+// TABLE-TESTABLE-LABEL: sil_witness_table [serialized] ConformingAssoc: AssocReqt module witness_tables {
+// TABLE-ALL-NEXT: method #AssocReqt.requiredMethod!1: {{.*}} : @$S14witness_tables15ConformingAssocVAA0D4ReqtA2aDP14requiredMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-ALL-NEXT: }
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables15ConformingAssocVAA0D4ReqtA2aDP14requiredMethod{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AssocReqt) (@in_guaranteed ConformingAssoc) -> ()
+// SYMBOL-TESTABLE: sil shared [transparent] [serialized] [thunk] @$S14witness_tables15ConformingAssocVAA0D4ReqtA2aDP14requiredMethod{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AssocReqt) (@in_guaranteed ConformingAssoc) -> ()
+
+struct ConformingStruct : AnyProtocol {
+ typealias AssocType = SomeAssoc
+ typealias AssocWithReqt = ConformingAssoc
+
+ func method(x: Arg, y: ConformingStruct) {}
+ func generic<D: ArchetypeReqt>(x: D, y: ConformingStruct) {}
+
+ func assocTypesMethod(x: SomeAssoc, y: ConformingAssoc) {}
+
+ static func staticMethod(x: ConformingStruct) {}
+}
+func <~>(x: ConformingStruct, y: ConformingStruct) {}
+// TABLE-LABEL: sil_witness_table hidden ConformingStruct: AnyProtocol module witness_tables {
+// TABLE-NEXT: associated_type AssocType: SomeAssoc
+// TABLE-NEXT: associated_type AssocWithReqt: ConformingAssoc
+// TABLE-NEXT: associated_type_protocol (AssocWithReqt: AssocReqt): ConformingAssoc: AssocReqt module witness_tables
+// TABLE-NEXT: method #AnyProtocol.method!1: {{.*}} : @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.generic!1: {{.*}} : @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.assocTypesMethod!1: {{.*}} : @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.staticMethod!1: {{.*}} : @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: method #AnyProtocol."<~>"!1: {{.*}} : @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: }
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (Arg, @in_guaranteed ConformingStruct, @in_guaranteed ConformingStruct) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW {{.*}}: ArchetypeReqt> (@in_guaranteed τ_0_0, @in_guaranteed ConformingStruct, @in_guaranteed ConformingStruct) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed SomeAssoc, @in_guaranteed ConformingAssoc, @in_guaranteed ConformingStruct) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed ConformingStruct, @thick ConformingStruct.Type) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed ConformingStruct, @in_guaranteed ConformingStruct, @thick ConformingStruct.Type) -> ()
+// SYMBOL-TESTABLE: sil shared [transparent] [serialized] [thunk] @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (Arg, @in_guaranteed ConformingStruct, @in_guaranteed ConformingStruct) -> ()
+// SYMBOL-TESTABLE: sil shared [transparent] [serialized] [thunk] @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) <τ_0_0 where τ_0_0 : ArchetypeReqt> (@in_guaranteed τ_0_0, @in_guaranteed ConformingStruct, @in_guaranteed ConformingStruct) -> ()
+// SYMBOL-TESTABLE: sil shared [transparent] [serialized] [thunk] @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed SomeAssoc, @in_guaranteed ConformingAssoc, @in_guaranteed ConformingStruct) -> ()
+// SYMBOL-TESTABLE: sil shared [transparent] [serialized] [thunk] @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed ConformingStruct, @thick ConformingStruct.Type) -> ()
+// SYMBOL-TESTABLE: sil shared [transparent] [serialized] [thunk] @$S14witness_tables16ConformingStructVAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed ConformingStruct, @in_guaranteed ConformingStruct, @thick ConformingStruct.Type) -> ()
+
+protocol AddressOnly {}
+
+struct ConformingAddressOnlyStruct : AnyProtocol {
+ var p: AddressOnly // force address-only layout with a protocol-type field
+
+ typealias AssocType = SomeAssoc
+ typealias AssocWithReqt = ConformingAssoc
+
+ func method(x: Arg, y: ConformingAddressOnlyStruct) {}
+ func generic<E: ArchetypeReqt>(x: E, y: ConformingAddressOnlyStruct) {}
+
+ func assocTypesMethod(x: SomeAssoc, y: ConformingAssoc) {}
+
+ static func staticMethod(x: ConformingAddressOnlyStruct) {}
+}
+func <~>(x: ConformingAddressOnlyStruct, y: ConformingAddressOnlyStruct) {}
+// TABLE-LABEL: sil_witness_table hidden ConformingAddressOnlyStruct: AnyProtocol module witness_tables {
+// TABLE-NEXT: associated_type AssocType: SomeAssoc
+// TABLE-NEXT: associated_type AssocWithReqt: ConformingAssoc
+// TABLE-NEXT: associated_type_protocol (AssocWithReqt: AssocReqt): ConformingAssoc: AssocReqt module witness_tables
+// TABLE-NEXT: method #AnyProtocol.method!1: {{.*}} : @$S14witness_tables27ConformingAddressOnlyStructVAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.generic!1: {{.*}} : @$S14witness_tables27ConformingAddressOnlyStructVAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.assocTypesMethod!1: {{.*}} : @$S14witness_tables27ConformingAddressOnlyStructVAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.staticMethod!1: {{.*}} : @$S14witness_tables27ConformingAddressOnlyStructVAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: method #AnyProtocol."<~>"!1: {{.*}} : @$S14witness_tables27ConformingAddressOnlyStructVAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: }
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables27ConformingAddressOnlyStructVAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (Arg, @in_guaranteed ConformingAddressOnlyStruct, @in_guaranteed ConformingAddressOnlyStruct) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables27ConformingAddressOnlyStructVAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) <τ_0_0 where τ_0_0 : ArchetypeReqt> (@in_guaranteed τ_0_0, @in_guaranteed ConformingAddressOnlyStruct, @in_guaranteed ConformingAddressOnlyStruct) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables27ConformingAddressOnlyStructVAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed SomeAssoc, @in_guaranteed ConformingAssoc, @in_guaranteed ConformingAddressOnlyStruct) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables27ConformingAddressOnlyStructVAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed ConformingAddressOnlyStruct, @thick ConformingAddressOnlyStruct.Type) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables27ConformingAddressOnlyStructVAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed ConformingAddressOnlyStruct, @in_guaranteed ConformingAddressOnlyStruct, @thick ConformingAddressOnlyStruct.Type) -> ()
+
+class ConformingClass : AnyProtocol {
+ typealias AssocType = SomeAssoc
+ typealias AssocWithReqt = ConformingAssoc
+
+ func method(x: Arg, y: ConformingClass) {}
+ func generic<F: ArchetypeReqt>(x: F, y: ConformingClass) {}
+
+ func assocTypesMethod(x: SomeAssoc, y: ConformingAssoc) {}
+
+ class func staticMethod(x: ConformingClass) {}
+}
+func <~>(x: ConformingClass, y: ConformingClass) {}
+// TABLE-LABEL: sil_witness_table hidden ConformingClass: AnyProtocol module witness_tables {
+// TABLE-NEXT: associated_type AssocType: SomeAssoc
+// TABLE-NEXT: associated_type AssocWithReqt: ConformingAssoc
+// TABLE-NEXT: associated_type_protocol (AssocWithReqt: AssocReqt): ConformingAssoc: AssocReqt module witness_tables
+// TABLE-NEXT: method #AnyProtocol.method!1: {{.*}} : @$S14witness_tables15ConformingClassCAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.generic!1: {{.*}} : @$S14witness_tables15ConformingClassCAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.assocTypesMethod!1: {{.*}} : @$S14witness_tables15ConformingClassCAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.staticMethod!1: {{.*}} : @$S14witness_tables15ConformingClassCAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: method #AnyProtocol."<~>"!1: {{.*}} : @$S14witness_tables15ConformingClassCAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: }
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables15ConformingClassCAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (Arg, @in_guaranteed ConformingClass, @in_guaranteed ConformingClass) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables15ConformingClassCAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) <τ_0_0 where τ_0_0 : ArchetypeReqt> (@in_guaranteed τ_0_0, @in_guaranteed ConformingClass, @in_guaranteed ConformingClass) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables15ConformingClassCAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed SomeAssoc, @in_guaranteed ConformingAssoc, @in_guaranteed ConformingClass) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables15ConformingClassCAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed ConformingClass, @thick ConformingClass.Type) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables15ConformingClassCAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed ConformingClass, @in_guaranteed ConformingClass, @thick ConformingClass.Type) -> ()
+
+struct ConformsByExtension {}
+extension ConformsByExtension : AnyProtocol {
+ typealias AssocType = SomeAssoc
+ typealias AssocWithReqt = ConformingAssoc
+
+ func method(x: Arg, y: ConformsByExtension) {}
+ func generic<G: ArchetypeReqt>(x: G, y: ConformsByExtension) {}
+
+ func assocTypesMethod(x: SomeAssoc, y: ConformingAssoc) {}
+
+ static func staticMethod(x: ConformsByExtension) {}
+}
+func <~>(x: ConformsByExtension, y: ConformsByExtension) {}
+// TABLE-LABEL: sil_witness_table hidden ConformsByExtension: AnyProtocol module witness_tables {
+// TABLE-NEXT: associated_type AssocType: SomeAssoc
+// TABLE-NEXT: associated_type AssocWithReqt: ConformingAssoc
+// TABLE-NEXT: associated_type_protocol (AssocWithReqt: AssocReqt): ConformingAssoc: AssocReqt module witness_tables
+// TABLE-NEXT: method #AnyProtocol.method!1: {{.*}} : @$S14witness_tables19ConformsByExtensionVAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.generic!1: {{.*}} : @$S14witness_tables19ConformsByExtensionVAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.assocTypesMethod!1: {{.*}} : @$S14witness_tables19ConformsByExtensionVAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.staticMethod!1: {{.*}} : @$S14witness_tables19ConformsByExtensionVAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: method #AnyProtocol."<~>"!1: {{.*}} : @$S14witness_tables19ConformsByExtensionVAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: }
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables19ConformsByExtensionVAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (Arg, @in_guaranteed ConformsByExtension, @in_guaranteed ConformsByExtension) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables19ConformsByExtensionVAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) <τ_0_0 where τ_0_0 : ArchetypeReqt> (@in_guaranteed τ_0_0, @in_guaranteed ConformsByExtension, @in_guaranteed ConformsByExtension) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables19ConformsByExtensionVAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed SomeAssoc, @in_guaranteed ConformingAssoc, @in_guaranteed ConformsByExtension) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables19ConformsByExtensionVAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed ConformsByExtension, @thick ConformsByExtension.Type) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables19ConformsByExtensionVAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed ConformsByExtension, @in_guaranteed ConformsByExtension, @thick ConformsByExtension.Type) -> ()
+
+extension OtherModuleStruct : AnyProtocol {
+ typealias AssocType = SomeAssoc
+ typealias AssocWithReqt = ConformingAssoc
+
+ func method(x: Arg, y: OtherModuleStruct) {}
+ func generic<H: ArchetypeReqt>(x: H, y: OtherModuleStruct) {}
+
+ func assocTypesMethod(x: SomeAssoc, y: ConformingAssoc) {}
+
+ static func staticMethod(x: OtherModuleStruct) {}
+}
+func <~>(x: OtherModuleStruct, y: OtherModuleStruct) {}
+// TABLE-LABEL: sil_witness_table hidden OtherModuleStruct: AnyProtocol module witness_tables {
+// TABLE-NEXT: associated_type AssocType: SomeAssoc
+// TABLE-NEXT: associated_type AssocWithReqt: ConformingAssoc
+// TABLE-NEXT: associated_type_protocol (AssocWithReqt: AssocReqt): ConformingAssoc: AssocReqt module witness_tables
+// TABLE-NEXT: method #AnyProtocol.method!1: {{.*}} : @$S16witness_tables_b17OtherModuleStructV0a1_B011AnyProtocolA2dEP6method{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.generic!1: {{.*}} : @$S16witness_tables_b17OtherModuleStructV0a1_B011AnyProtocolA2dEP7generic{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.assocTypesMethod!1: {{.*}} : @$S16witness_tables_b17OtherModuleStructV0a1_B011AnyProtocolA2dEP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.staticMethod!1: {{.*}} : @$S16witness_tables_b17OtherModuleStructV0a1_B011AnyProtocolA2dEP12staticMethod{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: method #AnyProtocol."<~>"!1: {{.*}} : @$S16witness_tables_b17OtherModuleStructV0a1_B011AnyProtocolA2dEP3ltgoi{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: }
+// SYMBOL: sil private [transparent] [thunk] @$S16witness_tables_b17OtherModuleStructV0a1_B011AnyProtocolA2dEP6method{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (Arg, @in_guaranteed OtherModuleStruct, @in_guaranteed OtherModuleStruct) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S16witness_tables_b17OtherModuleStructV0a1_B011AnyProtocolA2dEP7generic{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) <τ_0_0 where τ_0_0 : ArchetypeReqt> (@in_guaranteed τ_0_0, @in_guaranteed OtherModuleStruct, @in_guaranteed OtherModuleStruct) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S16witness_tables_b17OtherModuleStructV0a1_B011AnyProtocolA2dEP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed SomeAssoc, @in_guaranteed ConformingAssoc, @in_guaranteed OtherModuleStruct) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S16witness_tables_b17OtherModuleStructV0a1_B011AnyProtocolA2dEP12staticMethod{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed OtherModuleStruct, @thick OtherModuleStruct.Type) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S16witness_tables_b17OtherModuleStructV0a1_B011AnyProtocolA2dEP3ltgoi{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed OtherModuleStruct, @in_guaranteed OtherModuleStruct, @thick OtherModuleStruct.Type) -> ()
+
+protocol OtherProtocol {}
+
+struct ConformsWithMoreGenericWitnesses : AnyProtocol, OtherProtocol {
+ typealias AssocType = SomeAssoc
+ typealias AssocWithReqt = ConformingAssoc
+
+ func method<I, J>(x: I, y: J) {}
+ func generic<K, L>(x: K, y: L) {}
+
+ func assocTypesMethod<M, N>(x: M, y: N) {}
+
+ static func staticMethod<O>(x: O) {}
+}
+func <~> <P: OtherProtocol>(x: P, y: P) {}
+// TABLE-LABEL: sil_witness_table hidden ConformsWithMoreGenericWitnesses: AnyProtocol module witness_tables {
+// TABLE-NEXT: associated_type AssocType: SomeAssoc
+// TABLE-NEXT: associated_type AssocWithReqt: ConformingAssoc
+// TABLE-NEXT: associated_type_protocol (AssocWithReqt: AssocReqt): ConformingAssoc: AssocReqt module witness_tables
+// TABLE-NEXT: method #AnyProtocol.method!1: {{.*}} : @$S14witness_tables32ConformsWithMoreGenericWitnessesVAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.generic!1: {{.*}} : @$S14witness_tables32ConformsWithMoreGenericWitnessesVAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.assocTypesMethod!1: {{.*}} : @$S14witness_tables32ConformsWithMoreGenericWitnessesVAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.staticMethod!1: {{.*}} : @$S14witness_tables32ConformsWithMoreGenericWitnessesVAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: method #AnyProtocol."<~>"!1: {{.*}} : @$S14witness_tables32ConformsWithMoreGenericWitnessesVAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: }
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables32ConformsWithMoreGenericWitnessesVAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (Arg, @in_guaranteed ConformsWithMoreGenericWitnesses, @in_guaranteed ConformsWithMoreGenericWitnesses) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables32ConformsWithMoreGenericWitnessesVAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) <τ_0_0 where τ_0_0 : ArchetypeReqt> (@in_guaranteed τ_0_0, @in_guaranteed ConformsWithMoreGenericWitnesses, @in_guaranteed ConformsWithMoreGenericWitnesses) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables32ConformsWithMoreGenericWitnessesVAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed SomeAssoc, @in_guaranteed ConformingAssoc, @in_guaranteed ConformsWithMoreGenericWitnesses) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables32ConformsWithMoreGenericWitnessesVAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed ConformsWithMoreGenericWitnesses, @thick ConformsWithMoreGenericWitnesses.Type) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables32ConformsWithMoreGenericWitnessesVAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: AnyProtocol) (@in_guaranteed ConformsWithMoreGenericWitnesses, @in_guaranteed ConformsWithMoreGenericWitnesses, @thick ConformsWithMoreGenericWitnesses.Type) -> ()
+
+class ConformingClassToClassProtocol : ClassProtocol {
+ typealias AssocType = SomeAssoc
+ typealias AssocWithReqt = ConformingAssoc
+
+ func method(x: Arg, y: ConformingClassToClassProtocol) {}
+ func generic<Q: ArchetypeReqt>(x: Q, y: ConformingClassToClassProtocol) {}
+
+ func assocTypesMethod(x: SomeAssoc, y: ConformingAssoc) {}
+
+ class func staticMethod(x: ConformingClassToClassProtocol) {}
+}
+func <~>(x: ConformingClassToClassProtocol,
+ y: ConformingClassToClassProtocol) {}
+// TABLE-LABEL: sil_witness_table hidden ConformingClassToClassProtocol: ClassProtocol module witness_tables {
+// TABLE-NEXT: associated_type AssocType: SomeAssoc
+// TABLE-NEXT: associated_type AssocWithReqt: ConformingAssoc
+// TABLE-NEXT: associated_type_protocol (AssocWithReqt: AssocReqt): ConformingAssoc: AssocReqt module witness_tables
+// TABLE-NEXT: method #ClassProtocol.method!1: {{.*}} : @$S14witness_tables017ConformingClassToD8ProtocolCAA0dF0A2aDP6method{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #ClassProtocol.generic!1: {{.*}} : @$S14witness_tables017ConformingClassToD8ProtocolCAA0dF0A2aDP7generic{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #ClassProtocol.assocTypesMethod!1: {{.*}} : @$S14witness_tables017ConformingClassToD8ProtocolCAA0dF0A2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #ClassProtocol.staticMethod!1: {{.*}} : @$S14witness_tables017ConformingClassToD8ProtocolCAA0dF0A2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: method #ClassProtocol."<~>"!1: {{.*}} : @$S14witness_tables017ConformingClassToD8ProtocolCAA0dF0A2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: }
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables017ConformingClassToD8ProtocolCAA0dF0A2aDP6method{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: ClassProtocol) (Arg, @guaranteed ConformingClassToClassProtocol, @guaranteed ConformingClassToClassProtocol) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables017ConformingClassToD8ProtocolCAA0dF0A2aDP7generic{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: ClassProtocol) <τ_0_0 where τ_0_0 : ArchetypeReqt> (@in_guaranteed τ_0_0, @guaranteed ConformingClassToClassProtocol, @guaranteed ConformingClassToClassProtocol) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables017ConformingClassToD8ProtocolCAA0dF0A2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: ClassProtocol) (@in_guaranteed SomeAssoc, @in_guaranteed ConformingAssoc, @guaranteed ConformingClassToClassProtocol) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables017ConformingClassToD8ProtocolCAA0dF0A2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: ClassProtocol) (@guaranteed ConformingClassToClassProtocol, @thick ConformingClassToClassProtocol.Type) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables017ConformingClassToD8ProtocolCAA0dF0A2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: ClassProtocol) (@guaranteed ConformingClassToClassProtocol, @guaranteed ConformingClassToClassProtocol, @thick ConformingClassToClassProtocol.Type) -> ()
+
+class ConformingClassToObjCProtocol : ObjCProtocol {
+ @objc func method(x: ObjCClass) {}
+ @objc class func staticMethod(y: ObjCClass) {}
+}
+// TABLE-NOT: sil_witness_table hidden ConformingClassToObjCProtocol
+
+struct ConformingGeneric<R: AssocReqt> : AnyProtocol {
+ typealias AssocType = SomeAssoc
+ typealias AssocWithReqt = R
+
+ func method(x: Arg, y: ConformingGeneric) {}
+ func generic<Q: ArchetypeReqt>(x: Q, y: ConformingGeneric) {}
+
+ func assocTypesMethod(x: SomeAssoc, y: R) {}
+
+ static func staticMethod(x: ConformingGeneric) {}
+}
+func <~> <R: AssocReqt>(x: ConformingGeneric<R>, y: ConformingGeneric<R>) {}
+// TABLE-LABEL: sil_witness_table hidden <R where R : AssocReqt> ConformingGeneric<R>: AnyProtocol module witness_tables {
+// TABLE-NEXT: associated_type AssocType: SomeAssoc
+// TABLE-NEXT: associated_type AssocWithReqt: R
+// TABLE-NEXT: associated_type_protocol (AssocWithReqt: AssocReqt): dependent
+// TABLE-NEXT: method #AnyProtocol.method!1: {{.*}} : @$S14witness_tables17ConformingGenericVyxGAA11AnyProtocolA2aEP6method{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.generic!1: {{.*}} : @$S14witness_tables17ConformingGenericVyxGAA11AnyProtocolA2aEP7generic{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.assocTypesMethod!1: {{.*}} : @$S14witness_tables17ConformingGenericVyxGAA11AnyProtocolA2aEP16assocTypesMetho{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.staticMethod!1: {{.*}} : @$S14witness_tables17ConformingGenericVyxGAA11AnyProtocolA2aEP12staticMethod{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: method #AnyProtocol."<~>"!1: {{.*}} : @$S14witness_tables17ConformingGenericVyxGAA11AnyProtocolA2aEP3ltgoi{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: }
+
+protocol AnotherProtocol {}
+
+struct ConformingGenericWithMoreGenericWitnesses<S: AssocReqt>
+ : AnyProtocol, AnotherProtocol
+{
+ typealias AssocType = SomeAssoc
+ typealias AssocWithReqt = S
+
+ func method<T, U>(x: T, y: U) {}
+ func generic<V, W>(x: V, y: W) {}
+
+ func assocTypesMethod<X, Y>(x: X, y: Y) {}
+
+ static func staticMethod<Z>(x: Z) {}
+}
+func <~> <AA: AnotherProtocol, BB: AnotherProtocol>(x: AA, y: BB) {}
+// TABLE-LABEL: sil_witness_table hidden <S where S : AssocReqt> ConformingGenericWithMoreGenericWitnesses<S>: AnyProtocol module witness_tables {
+// TABLE-NEXT: associated_type AssocType: SomeAssoc
+// TABLE-NEXT: associated_type AssocWithReqt: S
+// TABLE-NEXT: associated_type_protocol (AssocWithReqt: AssocReqt): dependent
+// TABLE-NEXT: method #AnyProtocol.method!1: {{.*}} : @$S14witness_tables025ConformingGenericWithMoreD9WitnessesVyxGAA11AnyProtocolA2aEP6method{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.generic!1: {{.*}} : @$S14witness_tables025ConformingGenericWithMoreD9WitnessesVyxGAA11AnyProtocolA2aEP7{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.assocTypesMethod!1: {{.*}} : @$S14witness_tables025ConformingGenericWithMoreD9WitnessesVyxGAA11AnyProtocolA2aEP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.staticMethod!1: {{.*}} : @$S14witness_tables025ConformingGenericWithMoreD9WitnessesVyxGAA11AnyProtocolA2aEP12staticMethod{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: method #AnyProtocol."<~>"!1: {{.*}} : @$S14witness_tables025ConformingGenericWithMoreD9WitnessesVyxGAA11AnyProtocolA2aEP3ltgoi{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: }
+
+protocol InheritedProtocol1 : AnyProtocol {
+ func inheritedMethod()
+}
+
+protocol InheritedProtocol2 : AnyProtocol {
+ func inheritedMethod()
+}
+
+protocol InheritedClassProtocol : class, AnyProtocol {
+ func inheritedMethod()
+}
+
+struct InheritedConformance : InheritedProtocol1 {
+ typealias AssocType = SomeAssoc
+ typealias AssocWithReqt = ConformingAssoc
+
+ func method(x: Arg, y: InheritedConformance) {}
+ func generic<H: ArchetypeReqt>(x: H, y: InheritedConformance) {}
+
+ func assocTypesMethod(x: SomeAssoc, y: ConformingAssoc) {}
+
+ static func staticMethod(x: InheritedConformance) {}
+
+ func inheritedMethod() {}
+}
+func <~>(x: InheritedConformance, y: InheritedConformance) {}
+// TABLE-LABEL: sil_witness_table hidden InheritedConformance: InheritedProtocol1 module witness_tables {
+// TABLE-NEXT: base_protocol AnyProtocol: InheritedConformance: AnyProtocol module witness_tables
+// TABLE-NEXT: method #InheritedProtocol1.inheritedMethod!1: {{.*}} : @$S14witness_tables20InheritedConformanceVAA0C9Protocol1A2aDP15inheritedMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: }
+// TABLE-LABEL: sil_witness_table hidden InheritedConformance: AnyProtocol module witness_tables {
+// TABLE-NEXT: associated_type AssocType: SomeAssoc
+// TABLE-NEXT: associated_type AssocWithReqt: ConformingAssoc
+// TABLE-NEXT: associated_type_protocol (AssocWithReqt: AssocReqt): ConformingAssoc: AssocReqt module witness_tables
+// TABLE-NEXT: method #AnyProtocol.method!1: {{.*}} : @$S14witness_tables20InheritedConformanceVAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.generic!1: {{.*}} : @$S14witness_tables20InheritedConformanceVAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.assocTypesMethod!1: {{.*}} : @$S14witness_tables20InheritedConformanceVAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.staticMethod!1: {{.*}} : @$S14witness_tables20InheritedConformanceVAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: method #AnyProtocol."<~>"!1: {{.*}} : @$S14witness_tables20InheritedConformanceVAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: }
+
+struct RedundantInheritedConformance : InheritedProtocol1, AnyProtocol {
+ typealias AssocType = SomeAssoc
+ typealias AssocWithReqt = ConformingAssoc
+
+ func method(x: Arg, y: RedundantInheritedConformance) {}
+ func generic<H: ArchetypeReqt>(x: H, y: RedundantInheritedConformance) {}
+
+ func assocTypesMethod(x: SomeAssoc, y: ConformingAssoc) {}
+
+ static func staticMethod(x: RedundantInheritedConformance) {}
+
+ func inheritedMethod() {}
+}
+func <~>(x: RedundantInheritedConformance, y: RedundantInheritedConformance) {}
+// TABLE-LABEL: sil_witness_table hidden RedundantInheritedConformance: InheritedProtocol1 module witness_tables {
+// TABLE-NEXT: base_protocol AnyProtocol: RedundantInheritedConformance: AnyProtocol module witness_tables
+// TABLE-NEXT: method #InheritedProtocol1.inheritedMethod!1: {{.*}} : @$S14witness_tables29RedundantInheritedConformanceVAA0D9Protocol1A2aDP15inheritedMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: }
+// TABLE-LABEL: sil_witness_table hidden RedundantInheritedConformance: AnyProtocol module witness_tables {
+// TABLE-NEXT: associated_type AssocType: SomeAssoc
+// TABLE-NEXT: associated_type AssocWithReqt: ConformingAssoc
+// TABLE-NEXT: associated_type_protocol (AssocWithReqt: AssocReqt): ConformingAssoc: AssocReqt module witness_tables
+// TABLE-NEXT: method #AnyProtocol.method!1: {{.*}} : @$S14witness_tables29RedundantInheritedConformanceVAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.generic!1: {{.*}} : @$S14witness_tables29RedundantInheritedConformanceVAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.assocTypesMethod!1: {{.*}} : @$S14witness_tables29RedundantInheritedConformanceVAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.staticMethod!1: {{.*}} : @$S14witness_tables29RedundantInheritedConformanceVAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: method #AnyProtocol."<~>"!1: {{.*}} : @$S14witness_tables29RedundantInheritedConformanceVAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: }
+
+struct DiamondInheritedConformance : InheritedProtocol1, InheritedProtocol2 {
+ typealias AssocType = SomeAssoc
+ typealias AssocWithReqt = ConformingAssoc
+
+ func method(x: Arg, y: DiamondInheritedConformance) {}
+ func generic<H: ArchetypeReqt>(x: H, y: DiamondInheritedConformance) {}
+
+ func assocTypesMethod(x: SomeAssoc, y: ConformingAssoc) {}
+
+ static func staticMethod(x: DiamondInheritedConformance) {}
+
+ func inheritedMethod() {}
+}
+func <~>(x: DiamondInheritedConformance, y: DiamondInheritedConformance) {}
+// TABLE-LABEL: sil_witness_table hidden DiamondInheritedConformance: InheritedProtocol1 module witness_tables {
+// TABLE-NEXT: base_protocol AnyProtocol: DiamondInheritedConformance: AnyProtocol module witness_tables
+// TABLE-NEXT: method #InheritedProtocol1.inheritedMethod!1: {{.*}} : @$S14witness_tables27DiamondInheritedConformanceVAA0D9Protocol1A2aDP15inheritedMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: }
+// TABLE-LABEL: sil_witness_table hidden DiamondInheritedConformance: InheritedProtocol2 module witness_tables {
+// TABLE-NEXT: base_protocol AnyProtocol: DiamondInheritedConformance: AnyProtocol module witness_tables
+// TABLE-NEXT: method #InheritedProtocol2.inheritedMethod!1: {{.*}} : @$S14witness_tables27DiamondInheritedConformanceVAA0D9Protocol2A2aDP15inheritedMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: }
+// TABLE-LABEL: sil_witness_table hidden DiamondInheritedConformance: AnyProtocol module witness_tables {
+// TABLE-NEXT: associated_type AssocType: SomeAssoc
+// TABLE-NEXT: associated_type AssocWithReqt: ConformingAssoc
+// TABLE-NEXT: associated_type_protocol (AssocWithReqt: AssocReqt): ConformingAssoc: AssocReqt module witness_tables
+// TABLE-NEXT: method #AnyProtocol.method!1: {{.*}} : @$S14witness_tables27DiamondInheritedConformanceVAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.generic!1: {{.*}} : @$S14witness_tables27DiamondInheritedConformanceVAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.assocTypesMethod!1: {{.*}} : @$S14witness_tables27DiamondInheritedConformanceVAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.staticMethod!1: {{.*}} : @$S14witness_tables27DiamondInheritedConformanceVAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: method #AnyProtocol."<~>"!1: {{.*}} : @$S14witness_tables27DiamondInheritedConformanceVAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: }
+
+class ClassInheritedConformance : InheritedClassProtocol {
+ typealias AssocType = SomeAssoc
+ typealias AssocWithReqt = ConformingAssoc
+
+ func method(x: Arg, y: ClassInheritedConformance) {}
+ func generic<H: ArchetypeReqt>(x: H, y: ClassInheritedConformance) {}
+
+ func assocTypesMethod(x: SomeAssoc, y: ConformingAssoc) {}
+
+ class func staticMethod(x: ClassInheritedConformance) {}
+
+ func inheritedMethod() {}
+}
+func <~>(x: ClassInheritedConformance, y: ClassInheritedConformance) {}
+// TABLE-LABEL: sil_witness_table hidden ClassInheritedConformance: InheritedClassProtocol module witness_tables {
+// TABLE-NEXT: base_protocol AnyProtocol: ClassInheritedConformance: AnyProtocol module witness_tables
+// TABLE-NEXT: method #InheritedClassProtocol.inheritedMethod!1: {{.*}} : @$S14witness_tables25ClassInheritedConformanceCAA0dC8ProtocolA2aDP15inheritedMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: }
+// TABLE-LABEL: sil_witness_table hidden ClassInheritedConformance: AnyProtocol module witness_tables {
+// TABLE-NEXT: associated_type AssocType: SomeAssoc
+// TABLE-NEXT: associated_type AssocWithReqt: ConformingAssoc
+// TABLE-NEXT: associated_type_protocol (AssocWithReqt: AssocReqt): ConformingAssoc: AssocReqt module witness_tables
+// TABLE-NEXT: method #AnyProtocol.method!1: {{.*}} : @$S14witness_tables25ClassInheritedConformanceCAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.generic!1: {{.*}} : @$S14witness_tables25ClassInheritedConformanceCAA11AnyProtocolA2aDP7generic{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.assocTypesMethod!1: {{.*}} : @$S14witness_tables25ClassInheritedConformanceCAA11AnyProtocolA2aDP16assocTypesMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: method #AnyProtocol.staticMethod!1: {{.*}} : @$S14witness_tables25ClassInheritedConformanceCAA11AnyProtocolA2aDP12staticMethod{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: method #AnyProtocol."<~>"!1: {{.*}} : @$S14witness_tables25ClassInheritedConformanceCAA11AnyProtocolA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW
+// TABLE-NEXT: }
+// -- Witnesses have the 'self' abstraction level of their protocol.
+// AnyProtocol has no class bound, so its witnesses treat Self as opaque.
+// InheritedClassProtocol has a class bound, so its witnesses treat Self as
+// a reference value.
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables25ClassInheritedConformanceCAA0dC8ProtocolA2aDP15inheritedMethod{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: InheritedClassProtocol) (@guaranteed ClassInheritedConformance) -> ()
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables25ClassInheritedConformanceCAA11AnyProtocolA2aDP6method{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: AnyProtocol) (Arg, @in_guaranteed ClassInheritedConformance, @in_guaranteed ClassInheritedConformance) -> ()
+
+struct GenericAssocType<T> : AssocReqt {
+ func requiredMethod() {}
+}
+
+protocol AssocTypeWithReqt {
+ associatedtype AssocType : AssocReqt
+}
+
+struct ConformsWithDependentAssocType1<CC: AssocReqt> : AssocTypeWithReqt {
+ typealias AssocType = CC
+}
+// TABLE-LABEL: sil_witness_table hidden <CC where CC : AssocReqt> ConformsWithDependentAssocType1<CC>: AssocTypeWithReqt module witness_tables {
+// TABLE-NEXT: associated_type AssocType: CC
+// TABLE-NEXT: associated_type_protocol (AssocType: AssocReqt): dependent
+// TABLE-NEXT: }
+
+struct ConformsWithDependentAssocType2<DD> : AssocTypeWithReqt {
+ typealias AssocType = GenericAssocType<DD>
+}
+// TABLE-LABEL: sil_witness_table hidden <DD> ConformsWithDependentAssocType2<DD>: AssocTypeWithReqt module witness_tables {
+// TABLE-NEXT: associated_type AssocType: GenericAssocType<DD>
+// TABLE-NEXT: associated_type_protocol (AssocType: AssocReqt): <T> GenericAssocType<T>: AssocReqt module witness_tables
+// TABLE-NEXT: }
+
+protocol InheritedFromObjC : ObjCProtocol {
+ func inheritedMethod()
+}
+
+class ConformsInheritedFromObjC : InheritedFromObjC {
+ @objc func method(x: ObjCClass) {}
+ @objc class func staticMethod(y: ObjCClass) {}
+ func inheritedMethod() {}
+}
+// TABLE-LABEL: sil_witness_table hidden ConformsInheritedFromObjC: InheritedFromObjC module witness_tables {
+// TABLE-NEXT: method #InheritedFromObjC.inheritedMethod!1: {{.*}} : @$S14witness_tables25ConformsInheritedFromObjCCAA0deF1CA2aDP15inheritedMethod{{[_0-9a-zA-Z]*}}FTW
+// TABLE-NEXT: }
+
+protocol ObjCAssoc {
+ associatedtype AssocType : ObjCProtocol
+}
+
+struct HasObjCAssoc : ObjCAssoc {
+ typealias AssocType = ConformsInheritedFromObjC
+}
+// TABLE-LABEL: sil_witness_table hidden HasObjCAssoc: ObjCAssoc module witness_tables {
+// TABLE-NEXT: associated_type AssocType: ConformsInheritedFromObjC
+// TABLE-NEXT: }
+
+protocol Initializer {
+ init(arg: Arg)
+}
+
+// TABLE-LABEL: sil_witness_table hidden HasInitializerStruct: Initializer module witness_tables {
+// TABLE-NEXT: method #Initializer.init!allocator.1: {{.*}} : @$S14witness_tables20HasInitializerStructVAA0D0A2aDP{{[_0-9a-zA-Z]*}}fCTW
+// TABLE-NEXT: }
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables20HasInitializerStructVAA0D0A2aDP{{[_0-9a-zA-Z]*}}fCTW : $@convention(witness_method: Initializer) (Arg, @thick HasInitializerStruct.Type) -> @out HasInitializerStruct
+struct HasInitializerStruct : Initializer {
+ init(arg: Arg) { }
+}
+
+// TABLE-LABEL: sil_witness_table hidden HasInitializerClass: Initializer module witness_tables {
+// TABLE-NEXT: method #Initializer.init!allocator.1: {{.*}} : @$S14witness_tables19HasInitializerClassCAA0D0A2aDP{{[_0-9a-zA-Z]*}}fCTW
+// TABLE-NEXT: }
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables19HasInitializerClassCAA0D0A2aDP{{[_0-9a-zA-Z]*}}fCTW : $@convention(witness_method: Initializer) (Arg, @thick HasInitializerClass.Type) -> @out HasInitializerClass
+class HasInitializerClass : Initializer {
+ required init(arg: Arg) { }
+}
+
+// TABLE-LABEL: sil_witness_table hidden HasInitializerEnum: Initializer module witness_tables {
+// TABLE-NEXT: method #Initializer.init!allocator.1: {{.*}} : @$S14witness_tables18HasInitializerEnumOAA0D0A2aDP{{[_0-9a-zA-Z]*}}fCTW
+// TABLE-NEXT: }
+// SYMBOL: sil private [transparent] [thunk] @$S14witness_tables18HasInitializerEnumOAA0D0A2aDP{{[_0-9a-zA-Z]*}}fCTW : $@convention(witness_method: Initializer) (Arg, @thick HasInitializerEnum.Type) -> @out HasInitializerEnum
+enum HasInitializerEnum : Initializer {
+ case A
+
+ init(arg: Arg) { self = .A }
+}
+
diff --git a/test/SILGen/plus_zero_witnesses.swift b/test/SILGen/plus_zero_witnesses.swift
new file mode 100644
index 0000000..f618418
--- /dev/null
+++ b/test/SILGen/plus_zero_witnesses.swift
@@ -0,0 +1,513 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen %s -disable-objc-attr-requires-foundation-module -enable-sil-ownership | %FileCheck %s
+
+infix operator <~> {}
+
+func archetype_method<T: X>(x: T, y: T) -> T {
+ var x = x
+ var y = y
+ return x.selfTypes(x: y)
+}
+// CHECK-LABEL: sil hidden @$S9witnesses16archetype_method{{[_0-9a-zA-Z]*}}F{{.*}} : $@convention(thin) <T where T : X> (@in_guaranteed T, @in_guaranteed T) -> @out T {
+// CHECK: [[METHOD:%.*]] = witness_method $T, #X.selfTypes!1 : {{.*}} : $@convention(witness_method: X) <τ_0_0 where τ_0_0 : X> (@in_guaranteed τ_0_0, @inout τ_0_0) -> @out τ_0_0
+// CHECK: apply [[METHOD]]<T>({{%.*}}, {{%.*}}, {{%.*}}) : $@convention(witness_method: X) <τ_0_0 where τ_0_0 : X> (@in_guaranteed τ_0_0, @inout τ_0_0) -> @out τ_0_0
+// CHECK: }
+
+func archetype_generic_method<T: X>(x: T, y: Loadable) -> Loadable {
+ var x = x
+ return x.generic(x: y)
+}
+// CHECK-LABEL: sil hidden @$S9witnesses24archetype_generic_method{{[_0-9a-zA-Z]*}}F{{.*}} : $@convention(thin) <T where T : X> (@in_guaranteed T, Loadable) -> Loadable {
+// CHECK: [[METHOD:%.*]] = witness_method $T, #X.generic!1 : {{.*}} : $@convention(witness_method: X) <τ_0_0 where τ_0_0 : X><τ_1_0> (@in_guaranteed τ_1_0, @inout τ_0_0) -> @out τ_1_0
+// CHECK: apply [[METHOD]]<T, Loadable>({{%.*}}, {{%.*}}, {{%.*}}) : $@convention(witness_method: X) <τ_0_0 where τ_0_0 : X><τ_1_0> (@in_guaranteed τ_1_0, @inout τ_0_0) -> @out τ_1_0
+// CHECK: }
+
+// CHECK-LABEL: sil hidden @$S9witnesses32archetype_associated_type_method{{[_0-9a-zA-Z]*}}F : $@convention(thin) <T where T : WithAssoc> (@in_guaranteed T, @in_guaranteed T.AssocType) -> @out T
+// CHECK: apply %{{[0-9]+}}<T>
+func archetype_associated_type_method<T: WithAssoc>(x: T, y: T.AssocType) -> T {
+ return x.useAssocType(x: y)
+}
+
+protocol StaticMethod { static func staticMethod() }
+
+// CHECK-LABEL: sil hidden @$S9witnesses23archetype_static_method{{[_0-9a-zA-Z]*}}F : $@convention(thin) <T where T : StaticMethod> (@in_guaranteed T) -> ()
+func archetype_static_method<T: StaticMethod>(x: T) {
+ // CHECK: [[METHOD:%.*]] = witness_method $T, #StaticMethod.staticMethod!1 : {{.*}} : $@convention(witness_method: StaticMethod) <τ_0_0 where τ_0_0 : StaticMethod> (@thick τ_0_0.Type) -> ()
+ // CHECK: apply [[METHOD]]<T>
+ T.staticMethod()
+}
+
+protocol Existentiable {
+ func foo() -> Loadable
+ func generic<T>() -> T
+}
+
+func protocol_method(x: Existentiable) -> Loadable {
+ return x.foo()
+}
+// CHECK-LABEL: sil hidden @$S9witnesses15protocol_method1xAA8LoadableVAA13Existentiable_p_tF : $@convention(thin) (@in_guaranteed Existentiable) -> Loadable {
+// CHECK: [[METHOD:%.*]] = witness_method $[[OPENED:@opened(.*) Existentiable]], #Existentiable.foo!1
+// CHECK: apply [[METHOD]]<[[OPENED]]>({{%.*}})
+// CHECK: }
+
+func protocol_generic_method(x: Existentiable) -> Loadable {
+ return x.generic()
+}
+// CHECK-LABEL: sil hidden @$S9witnesses23protocol_generic_method1xAA8LoadableVAA13Existentiable_p_tF : $@convention(thin) (@in_guaranteed Existentiable) -> Loadable {
+// CHECK: [[METHOD:%.*]] = witness_method $[[OPENED:@opened(.*) Existentiable]], #Existentiable.generic!1
+// CHECK: apply [[METHOD]]<[[OPENED]], Loadable>({{%.*}}, {{%.*}})
+// CHECK: }
+
+@objc protocol ObjCAble {
+ func foo()
+}
+
+// CHECK-LABEL: sil hidden @$S9witnesses20protocol_objc_method1xyAA8ObjCAble_p_tF : $@convention(thin) (@guaranteed ObjCAble) -> ()
+// CHECK: objc_method {{%.*}} : $@opened({{.*}}) ObjCAble, #ObjCAble.foo!1.foreign
+func protocol_objc_method(x: ObjCAble) {
+ x.foo()
+}
+
+struct Loadable {}
+protocol AddrOnly {}
+protocol Classes : class {}
+
+protocol X {
+ mutating
+ func selfTypes(x: Self) -> Self
+ mutating
+ func loadable(x: Loadable) -> Loadable
+ mutating
+ func addrOnly(x: AddrOnly) -> AddrOnly
+ mutating
+ func generic<A>(x: A) -> A
+ mutating
+ func classes<A2: Classes>(x: A2) -> A2
+ static func <~>(_ x: Self, y: Self) -> Self
+}
+protocol Y {}
+
+protocol WithAssoc {
+ associatedtype AssocType
+ func useAssocType(x: AssocType) -> Self
+}
+
+protocol ClassBounded : class {
+ func selfTypes(x: Self) -> Self
+}
+
+struct ConformingStruct : X {
+ mutating
+ func selfTypes(x: ConformingStruct) -> ConformingStruct { return x }
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses16ConformingStructVAA1XA2aDP9selfTypes{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: X) (@in_guaranteed ConformingStruct, @inout ConformingStruct) -> @out ConformingStruct {
+ // CHECK: bb0(%0 : @trivial $*ConformingStruct, %1 : @trivial $*ConformingStruct, %2 : @trivial $*ConformingStruct):
+ // CHECK-NEXT: %3 = load [trivial] %1 : $*ConformingStruct
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: %4 = function_ref @$S9witnesses16ConformingStructV9selfTypes{{[_0-9a-zA-Z]*}}F : $@convention(method) (ConformingStruct, @inout ConformingStruct) -> ConformingStruct
+ // CHECK-NEXT: %5 = apply %4(%3, %2) : $@convention(method) (ConformingStruct, @inout ConformingStruct) -> ConformingStruct
+ // CHECK-NEXT: store %5 to [trivial] %0 : $*ConformingStruct
+ // CHECK-NEXT: %7 = tuple ()
+ // CHECK-NEXT: return %7 : $()
+ // CHECK-NEXT: }
+
+ mutating
+ func loadable(x: Loadable) -> Loadable { return x }
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses16ConformingStructVAA1XA2aDP8loadable{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: X) (Loadable, @inout ConformingStruct) -> Loadable {
+ // CHECK: bb0(%0 : @trivial $Loadable, %1 : @trivial $*ConformingStruct):
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: %2 = function_ref @$S9witnesses16ConformingStructV8loadable{{[_0-9a-zA-Z]*}}F : $@convention(method) (Loadable, @inout ConformingStruct) -> Loadable
+ // CHECK-NEXT: %3 = apply %2(%0, %1) : $@convention(method) (Loadable, @inout ConformingStruct) -> Loadable
+ // CHECK-NEXT: return %3 : $Loadable
+ // CHECK-NEXT: }
+
+ mutating
+ func addrOnly(x: AddrOnly) -> AddrOnly { return x }
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses16ConformingStructVAA1XA2aDP8addrOnly{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: X) (@in_guaranteed AddrOnly, @inout ConformingStruct) -> @out AddrOnly {
+ // CHECK: bb0(%0 : @trivial $*AddrOnly, %1 : @trivial $*AddrOnly, %2 : @trivial $*ConformingStruct):
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: %3 = function_ref @$S9witnesses16ConformingStructV8addrOnly{{[_0-9a-zA-Z]*}}F : $@convention(method) (@in_guaranteed AddrOnly, @inout ConformingStruct) -> @out AddrOnly
+ // CHECK-NEXT: %4 = apply %3(%0, %1, %2) : $@convention(method) (@in_guaranteed AddrOnly, @inout ConformingStruct) -> @out AddrOnly
+ // CHECK-NEXT: %5 = tuple ()
+ // CHECK-NEXT: return %5 : $()
+ // CHECK-NEXT: }
+
+ mutating
+ func generic<C>(x: C) -> C { return x }
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses16ConformingStructVAA1XA2aDP7generic{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: X) <τ_0_0> (@in_guaranteed τ_0_0, @inout ConformingStruct) -> @out τ_0_0 {
+ // CHECK: bb0(%0 : @trivial $*τ_0_0, %1 : @trivial $*τ_0_0, %2 : @trivial $*ConformingStruct):
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: %3 = function_ref @$S9witnesses16ConformingStructV7generic{{[_0-9a-zA-Z]*}}F : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @inout ConformingStruct) -> @out τ_0_0
+ // CHECK-NEXT: %4 = apply %3<τ_0_0>(%0, %1, %2) : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @inout ConformingStruct) -> @out τ_0_0
+ // CHECK-NEXT: %5 = tuple ()
+ // CHECK-NEXT: return %5 : $()
+ // CHECK-NEXT: }
+ mutating
+ func classes<C2: Classes>(x: C2) -> C2 { return x }
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses16ConformingStructVAA1XA2aDP7classes{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: X) <τ_0_0 where τ_0_0 : Classes> (@guaranteed τ_0_0, @inout ConformingStruct) -> @owned τ_0_0 {
+ // CHECK: bb0(%0 : @guaranteed $τ_0_0, %1 : @trivial $*ConformingStruct):
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: %2 = function_ref @$S9witnesses16ConformingStructV7classes{{[_0-9a-zA-Z]*}}F : $@convention(method) <τ_0_0 where τ_0_0 : Classes> (@guaranteed τ_0_0, @inout ConformingStruct) -> @owned τ_0_0
+ // CHECK-NEXT: %3 = apply %2<τ_0_0>(%0, %1) : $@convention(method) <τ_0_0 where τ_0_0 : Classes> (@guaranteed τ_0_0, @inout ConformingStruct) -> @owned τ_0_0
+ // CHECK-NEXT: return %3 : $τ_0_0
+ // CHECK-NEXT: }
+}
+func <~>(_ x: ConformingStruct, y: ConformingStruct) -> ConformingStruct { return x }
+// CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses16ConformingStructVAA1XA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: X) (@in_guaranteed ConformingStruct, @in_guaranteed ConformingStruct, @thick ConformingStruct.Type) -> @out ConformingStruct {
+// CHECK: bb0([[ARG1:%.*]] : @trivial $*ConformingStruct, [[ARG2:%.*]] : @trivial $*ConformingStruct, [[ARG3:%.*]] : @trivial $*ConformingStruct, [[ARG4:%.*]] : @trivial $@thick ConformingStruct.Type):
+// CHECK-NEXT: [[LOADED_ARG2:%.*]] = load [trivial] [[ARG2]] : $*ConformingStruct
+// CHECK-NEXT: [[LOADED_ARG3:%.*]] = load [trivial] [[ARG3]] : $*ConformingStruct
+// CHECK-NEXT: // function_ref
+// CHECK-NEXT: [[FUNC:%.*]] = function_ref @$S9witnesses3ltgoiyAA16ConformingStructVAD_ADtF : $@convention(thin) (ConformingStruct, ConformingStruct) -> ConformingStruct
+// CHECK-NEXT: [[FUNC_RESULT:%.*]] = apply [[FUNC]]([[LOADED_ARG2]], [[LOADED_ARG3]]) : $@convention(thin) (ConformingStruct, ConformingStruct) -> ConformingStruct
+// CHECK-NEXT: store [[FUNC_RESULT]] to [trivial] [[ARG1]] : $*ConformingStruct
+// CHECK-NEXT: %9 = tuple ()
+// CHECK-NEXT: return %9 : $()
+// CHECK-NEXT: }
+
+final class ConformingClass : X {
+ func selfTypes(x: ConformingClass) -> ConformingClass { return x }
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses15ConformingClassCAA1XA2aDP9selfTypes{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: X) (@in_guaranteed ConformingClass, @inout ConformingClass) -> @out ConformingClass {
+ // CHECK: bb0([[ARG1:%.*]] : @trivial $*ConformingClass, [[ARG2:%.*]] : @trivial $*ConformingClass, [[ARG3:%.*]] : @trivial $*ConformingClass):
+ // -- load and copy_value 'self' from inout witness 'self' parameter
+ // CHECK: [[ARG2_LOADED:%.*]] = load_borrow [[ARG2]] : $*ConformingClass
+ // CHECK: [[ARG3_LOADED:%.*]] = load_borrow [[ARG3]] : $*ConformingClass
+ // CHECK: [[FUNC:%.*]] = function_ref @$S9witnesses15ConformingClassC9selfTypes{{[_0-9a-zA-Z]*}}F
+ // CHECK: [[FUNC_RESULT:%.*]] = apply [[FUNC]]([[ARG2_LOADED]], [[ARG3_LOADED]]) : $@convention(method) (@guaranteed ConformingClass, @guaranteed ConformingClass) -> @owned ConformingClass
+ // CHECK: store [[FUNC_RESULT]] to [init] [[ARG1]] : $*ConformingClass
+ // CHECK: end_borrow [[ARG3_LOADED]] from [[ARG3]]
+ // CHECK: } // end sil function '$S9witnesses15ConformingClassCAA1XA2aDP9selfTypes{{[_0-9a-zA-Z]*}}FTW'
+ func loadable(x: Loadable) -> Loadable { return x }
+ func addrOnly(x: AddrOnly) -> AddrOnly { return x }
+ func generic<D>(x: D) -> D { return x }
+ func classes<D2: Classes>(x: D2) -> D2 { return x }
+}
+func <~>(_ x: ConformingClass, y: ConformingClass) -> ConformingClass { return x }
+
+extension ConformingClass : ClassBounded { }
+// CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses15ConformingClassCAA0C7BoundedA2aDP9selfTypes{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: ClassBounded) (@guaranteed ConformingClass, @guaranteed ConformingClass) -> @owned ConformingClass {
+// CHECK: bb0([[C0:%.*]] : @guaranteed $ConformingClass, [[C1:%.*]] : @guaranteed $ConformingClass):
+// CHECK-NEXT: function_ref
+// CHECK-NEXT: [[FUN:%.*]] = function_ref @$S9witnesses15ConformingClassC9selfTypes{{[_0-9a-zA-Z]*}}F
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[FUN]]([[C0]], [[C1]]) : $@convention(method) (@guaranteed ConformingClass, @guaranteed ConformingClass) -> @owned ConformingClass
+// CHECK-NEXT: return [[RESULT]] : $ConformingClass
+// CHECK-NEXT: }
+
+struct ConformingAOStruct : X {
+ var makeMeAO : AddrOnly
+
+ mutating
+ func selfTypes(x: ConformingAOStruct) -> ConformingAOStruct { return x }
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses18ConformingAOStructVAA1XA2aDP9selfTypes{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: X) (@in_guaranteed ConformingAOStruct, @inout ConformingAOStruct) -> @out ConformingAOStruct {
+ // CHECK: bb0(%0 : @trivial $*ConformingAOStruct, %1 : @trivial $*ConformingAOStruct, %2 : @trivial $*ConformingAOStruct):
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: %3 = function_ref @$S9witnesses18ConformingAOStructV9selfTypes{{[_0-9a-zA-Z]*}}F : $@convention(method) (@in_guaranteed ConformingAOStruct, @inout ConformingAOStruct) -> @out ConformingAOStruct
+ // CHECK-NEXT: %4 = apply %3(%0, %1, %2) : $@convention(method) (@in_guaranteed ConformingAOStruct, @inout ConformingAOStruct) -> @out ConformingAOStruct
+ // CHECK-NEXT: %5 = tuple ()
+ // CHECK-NEXT: return %5 : $()
+ // CHECK-NEXT: }
+ func loadable(x: Loadable) -> Loadable { return x }
+ func addrOnly(x: AddrOnly) -> AddrOnly { return x }
+ func generic<D>(x: D) -> D { return x }
+ func classes<D2: Classes>(x: D2) -> D2 { return x }
+}
+func <~>(_ x: ConformingAOStruct, y: ConformingAOStruct) -> ConformingAOStruct { return x }
+
+struct ConformsWithMoreGeneric : X, Y {
+ mutating
+ func selfTypes<E>(x: E) -> E { return x }
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses23ConformsWithMoreGenericVAA1XA2aDP9selfTypes{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: X) (@in_guaranteed ConformsWithMoreGeneric, @inout ConformsWithMoreGeneric) -> @out ConformsWithMoreGeneric {
+ // CHECK: bb0(%0 : @trivial $*ConformsWithMoreGeneric, %1 : @trivial $*ConformsWithMoreGeneric, %2 : @trivial $*ConformsWithMoreGeneric):
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: [[WITNESS_FN:%.*]] = function_ref @$S9witnesses23ConformsWithMoreGenericV9selfTypes{{[_0-9a-zA-Z]*}}F : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @inout ConformsWithMoreGeneric) -> @out τ_0_0
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[WITNESS_FN]]<ConformsWithMoreGeneric>(%0, %1, %2) : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @inout ConformsWithMoreGeneric) -> @out τ_0_0
+ // CHECK-NEXT: [[RESULT:%.*]] = tuple ()
+ // CHECK-NEXT: return [[RESULT]] : $()
+ // CHECK-NEXT: }
+ func loadable<F>(x: F) -> F { return x }
+ mutating
+ func addrOnly<G>(x: G) -> G { return x }
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses23ConformsWithMoreGenericVAA1XA2aDP8addrOnly{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: X) (@in_guaranteed AddrOnly, @inout ConformsWithMoreGeneric) -> @out AddrOnly {
+ // CHECK: bb0(%0 : @trivial $*AddrOnly, %1 : @trivial $*AddrOnly, %2 : @trivial $*ConformsWithMoreGeneric):
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: %3 = function_ref @$S9witnesses23ConformsWithMoreGenericV8addrOnly{{[_0-9a-zA-Z]*}}F : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @inout ConformsWithMoreGeneric) -> @out τ_0_0
+ // CHECK-NEXT: %4 = apply %3<AddrOnly>(%0, %1, %2) : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @inout ConformsWithMoreGeneric) -> @out τ_0_0
+ // CHECK-NEXT: [[RESULT:%.*]] = tuple ()
+ // CHECK-NEXT: return [[RESULT]] : $()
+ // CHECK-NEXT: }
+
+ mutating
+ func generic<H>(x: H) -> H { return x }
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses23ConformsWithMoreGenericVAA1XA2aDP7generic{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: X) <τ_0_0> (@in_guaranteed τ_0_0, @inout ConformsWithMoreGeneric) -> @out τ_0_0 {
+ // CHECK: bb0(%0 : @trivial $*τ_0_0, %1 : @trivial $*τ_0_0, %2 : @trivial $*ConformsWithMoreGeneric):
+ // CHECK-NEXT: // function_ref
+ // CHECK-NEXT: %3 = function_ref @$S9witnesses23ConformsWithMoreGenericV7generic{{[_0-9a-zA-Z]*}}F : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @inout ConformsWithMoreGeneric) -> @out τ_0_0
+ // CHECK-NEXT: %4 = apply %3<τ_0_0>(%0, %1, %2) : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @inout ConformsWithMoreGeneric) -> @out τ_0_0
+ // CHECK-NEXT: [[RESULT:%.*]] = tuple ()
+ // CHECK-NEXT: return [[RESULT]] : $()
+ // CHECK-NEXT: }
+
+ mutating
+ func classes<I>(x: I) -> I { return x }
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses23ConformsWithMoreGenericVAA1XA2aDP7classes{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: X) <τ_0_0 where τ_0_0 : Classes> (@guaranteed τ_0_0, @inout ConformsWithMoreGeneric) -> @owned τ_0_0 {
+ // CHECK: bb0([[ARG0:%.*]] : @guaranteed $τ_0_0, [[ARG1:%.*]] : @trivial $*ConformsWithMoreGeneric):
+ // CHECK-NEXT: [[SELF_BOX:%.*]] = alloc_stack $τ_0_0
+ // CHECK-NEXT: [[ARG0_COPY:%.*]] = copy_value [[ARG0]]
+ // CHECK-NEXT: store [[ARG0_COPY]] to [init] [[SELF_BOX]] : $*τ_0_0
+ // CHECK-NEXT: // function_ref witnesses.ConformsWithMoreGeneric.classes
+ // CHECK-NEXT: [[WITNESS_FN:%.*]] = function_ref @$S9witnesses23ConformsWithMoreGenericV7classes{{[_0-9a-zA-Z]*}}F : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @inout ConformsWithMoreGeneric) -> @out τ_0_0
+ // CHECK-NEXT: [[RESULT_BOX:%.*]] = alloc_stack $τ_0_0
+ // CHECK-NEXT: [[RESULT:%.*]] = apply [[WITNESS_FN]]<τ_0_0>([[RESULT_BOX]], [[SELF_BOX]], %1) : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @inout ConformsWithMoreGeneric) -> @out τ_0_0
+ // CHECK-NEXT: [[RESULT:%.*]] = load [take] [[RESULT_BOX]] : $*τ_0_0
+ // CHECK-NEXT: dealloc_stack [[RESULT_BOX]] : $*τ_0_0
+ // CHECK-NEXT: destroy_addr [[SELF_BOX]]
+ // CHECK-NEXT: dealloc_stack [[SELF_BOX]] : $*τ_0_0
+ // CHECK-NEXT: return [[RESULT]] : $τ_0_0
+ // CHECK-NEXT: }
+}
+func <~> <J: Y, K: Y>(_ x: J, y: K) -> K { return y }
+// CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses23ConformsWithMoreGenericVAA1XA2aDP3ltgoi{{[_0-9a-zA-Z]*}}FZTW : $@convention(witness_method: X) (@in_guaranteed ConformsWithMoreGeneric, @in_guaranteed ConformsWithMoreGeneric, @thick ConformsWithMoreGeneric.Type) -> @out ConformsWithMoreGeneric {
+// CHECK: bb0(%0 : @trivial $*ConformsWithMoreGeneric, %1 : @trivial $*ConformsWithMoreGeneric, %2 : @trivial $*ConformsWithMoreGeneric, %3 : @trivial $@thick ConformsWithMoreGeneric.Type):
+// CHECK-NEXT: // function_ref
+// CHECK-NEXT: [[WITNESS_FN:%.*]] = function_ref @$S9witnesses3ltgoi{{[_0-9a-zA-Z]*}}F : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : Y, τ_0_1 : Y> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_1) -> @out τ_0_1
+// CHECK-NEXT: [[RESULT:%.*]] = apply [[WITNESS_FN]]<ConformsWithMoreGeneric, ConformsWithMoreGeneric>(%0, %1, %2) : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : Y, τ_0_1 : Y> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_1) -> @out τ_0_1
+// CHECK-NEXT: [[RESULT:%.*]] = tuple ()
+// CHECK-NEXT: return [[RESULT]] : $()
+// CHECK-NEXT: }
+
+protocol LabeledRequirement {
+ func method(x: Loadable)
+}
+
+struct UnlabeledWitness : LabeledRequirement {
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses16UnlabeledWitnessVAA18LabeledRequirementA2aDP6method{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: LabeledRequirement) (Loadable, @in_guaranteed UnlabeledWitness) -> ()
+ func method(x _: Loadable) {}
+}
+
+protocol LabeledSelfRequirement {
+ func method(x: Self)
+}
+
+struct UnlabeledSelfWitness : LabeledSelfRequirement {
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses20UnlabeledSelfWitnessVAA07LabeledC11RequirementA2aDP6method{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: LabeledSelfRequirement) (@in_guaranteed UnlabeledSelfWitness, @in_guaranteed UnlabeledSelfWitness) -> ()
+ func method(x _: UnlabeledSelfWitness) {}
+}
+
+protocol UnlabeledRequirement {
+ func method(x _: Loadable)
+}
+
+struct LabeledWitness : UnlabeledRequirement {
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses14LabeledWitnessVAA20UnlabeledRequirementA2aDP6method{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: UnlabeledRequirement) (Loadable, @in_guaranteed LabeledWitness) -> ()
+ func method(x: Loadable) {}
+}
+
+protocol UnlabeledSelfRequirement {
+ func method(_: Self)
+}
+
+struct LabeledSelfWitness : UnlabeledSelfRequirement {
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses18LabeledSelfWitnessVAA09UnlabeledC11RequirementA2aDP6method{{[_0-9a-zA-Z]*}}FTW : $@convention(witness_method: UnlabeledSelfRequirement) (@in_guaranteed LabeledSelfWitness, @in_guaranteed LabeledSelfWitness) -> ()
+ func method(_ x: LabeledSelfWitness) {}
+}
+
+protocol ReadOnlyRequirement {
+ var prop: String { get }
+ static var prop: String { get }
+}
+
+struct ImmutableModel: ReadOnlyRequirement {
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses14ImmutableModelVAA19ReadOnlyRequirementA2aDP4propSSvgTW : $@convention(witness_method: ReadOnlyRequirement) (@in_guaranteed ImmutableModel) -> @owned String
+ let prop: String = "a"
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses14ImmutableModelVAA19ReadOnlyRequirementA2aDP4propSSvgZTW : $@convention(witness_method: ReadOnlyRequirement) (@thick ImmutableModel.Type) -> @owned String
+ static let prop: String = "b"
+}
+
+protocol FailableRequirement {
+ init?(foo: Int)
+}
+
+protocol NonFailableRefinement: FailableRequirement {
+ init(foo: Int)
+}
+
+protocol IUOFailableRequirement {
+ init!(foo: Int)
+}
+
+struct NonFailableModel: FailableRequirement, NonFailableRefinement, IUOFailableRequirement {
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses16NonFailableModelVAA0C11Requirement{{[_0-9a-zA-Z]*}}fCTW : $@convention(witness_method: FailableRequirement) (Int, @thick NonFailableModel.Type) -> @out Optional<NonFailableModel>
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses16NonFailableModelVAA0bC10Refinement{{[_0-9a-zA-Z]*}}fCTW : $@convention(witness_method: NonFailableRefinement) (Int, @thick NonFailableModel.Type) -> @out NonFailableModel
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses16NonFailableModelVAA22IUOFailableRequirement{{[_0-9a-zA-Z]*}}fCTW : $@convention(witness_method: FailableRequirement) (Int, @thick NonFailableModel.Type) -> @out Optional<NonFailableModel>
+ init(foo: Int) {}
+}
+
+struct FailableModel: FailableRequirement, IUOFailableRequirement {
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses13FailableModelVAA0B11Requirement{{[_0-9a-zA-Z]*}}fCTW
+
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses13FailableModelVAA22IUOFailableRequirement{{[_0-9a-zA-Z]*}}fCTW
+ // CHECK: bb0([[SELF:%[0-9]+]] : @trivial $*Optional<FailableModel>, [[FOO:%[0-9]+]] : @trivial $Int, [[META:%[0-9]+]] : @trivial $@thick FailableModel.Type):
+ // CHECK: [[FN:%.*]] = function_ref @$S9witnesses13FailableModelV{{[_0-9a-zA-Z]*}}fC
+ // CHECK: [[INNER:%.*]] = apply [[FN]](
+ // CHECK: store [[INNER]] to [trivial] [[SELF]]
+ // CHECK: return
+ init?(foo: Int) {}
+}
+
+struct IUOFailableModel : NonFailableRefinement, IUOFailableRequirement {
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses16IUOFailableModelVAA21NonFailableRefinement{{[_0-9a-zA-Z]*}}fCTW
+ // CHECK: bb0([[SELF:%[0-9]+]] : @trivial $*IUOFailableModel, [[FOO:%[0-9]+]] : @trivial $Int, [[META:%[0-9]+]] : @trivial $@thick IUOFailableModel.Type):
+ // CHECK: [[META:%[0-9]+]] = metatype $@thin IUOFailableModel.Type
+ // CHECK: [[INIT:%[0-9]+]] = function_ref @$S9witnesses16IUOFailableModelV{{[_0-9a-zA-Z]*}}fC : $@convention(method) (Int, @thin IUOFailableModel.Type) -> Optional<IUOFailableModel>
+ // CHECK: [[IUO_RESULT:%[0-9]+]] = apply [[INIT]]([[FOO]], [[META]]) : $@convention(method) (Int, @thin IUOFailableModel.Type) -> Optional<IUOFailableModel>
+ // CHECK: bb2([[RESULT:%.*]] : @trivial $IUOFailableModel):
+ // CHECK: store [[RESULT]] to [trivial] [[SELF]] : $*IUOFailableModel
+ // CHECK: return
+ init!(foo: Int) { return nil }
+}
+
+protocol FailableClassRequirement: class {
+ init?(foo: Int)
+}
+
+protocol NonFailableClassRefinement: FailableClassRequirement {
+ init(foo: Int)
+}
+
+protocol IUOFailableClassRequirement: class {
+ init!(foo: Int)
+}
+
+final class NonFailableClassModel: FailableClassRequirement, NonFailableClassRefinement, IUOFailableClassRequirement {
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses21NonFailableClassModelCAA0cD11Requirement{{[_0-9a-zA-Z]*}}fCTW : $@convention(witness_method: FailableClassRequirement) (Int, @thick NonFailableClassModel.Type) -> @owned Optional<NonFailableClassModel>
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses21NonFailableClassModelCAA0bcD10Refinement{{[_0-9a-zA-Z]*}}fCTW : $@convention(witness_method: NonFailableClassRefinement) (Int, @thick NonFailableClassModel.Type) -> @owned NonFailableClassModel
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses21NonFailableClassModelCAA011IUOFailableD11Requirement{{[_0-9a-zA-Z]*}}fCTW : $@convention(witness_method: FailableClassRequirement) (Int, @thick NonFailableClassModel.Type) -> @owned Optional<NonFailableClassModel>
+ init(foo: Int) {}
+}
+
+final class FailableClassModel: FailableClassRequirement, IUOFailableClassRequirement {
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses18FailableClassModelCAA0bC11Requirement{{[_0-9a-zA-Z]*}}fCTW
+
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses18FailableClassModelCAA011IUOFailableC11Requirement{{[_0-9a-zA-Z]*}}fCTW
+ // CHECK: [[FUNC:%.*]] = function_ref @$S9witnesses18FailableClassModelC{{[_0-9a-zA-Z]*}}fC
+ // CHECK: [[INNER:%.*]] = apply [[FUNC]](%0, %1)
+ // CHECK: return [[INNER]] : $Optional<FailableClassModel>
+ init?(foo: Int) {}
+}
+
+final class IUOFailableClassModel: NonFailableClassRefinement, IUOFailableClassRequirement {
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses21IUOFailableClassModelCAA011NonFailableC10Refinement{{[_0-9a-zA-Z]*}}fCTW
+ // CHECK: bb0({{.*}}):
+ // CHECK: [[FUNC:%.*]] = function_ref @$S9witnesses21IUOFailableClassModelC3fooACSgSi_tcfC : $@convention(method) (Int, @thick IUOFailableClassModel.Type) -> @owned Optional<IUOFailableClassModel>
+ // CHECK: [[VALUE:%.*]] = apply [[FUNC]]({{.*}})
+ // CHECK: switch_enum [[VALUE]] : $Optional<IUOFailableClassModel>, case #Optional.some!enumelt.1: [[SOMEBB:bb[0-9]+]], case #Optional.none!enumelt: [[NONEBB:bb[0-9]+]]
+ //
+ // CHECK: [[NONEBB]]:
+ // CHECK: unreachable
+ //
+ // CHECK: [[SOMEBB]]([[RESULT:%.*]] : @owned $IUOFailableClassModel)
+ // CHECK: return [[RESULT]] : $IUOFailableClassModel
+ // CHECK: } // end sil function '$S9witnesses21IUOFailableClassModelCAA011NonFailableC10Refinement{{[_0-9a-zA-Z]*}}fCTW'
+
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses21IUOFailableClassModelCAA0bC11Requirement{{[_0-9a-zA-Z]*}}fCTW
+ init!(foo: Int) {}
+
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses21IUOFailableClassModelCAA08FailableC11Requirement{{[_0-9a-zA-Z]*}}fCTW
+ // CHECK: [[FUNC:%.*]] = function_ref @$S9witnesses21IUOFailableClassModelC{{[_0-9a-zA-Z]*}}fC
+ // CHECK: [[INNER:%.*]] = apply [[FUNC]](%0, %1)
+ // CHECK: return [[INNER]] : $Optional<IUOFailableClassModel>
+}
+
+protocol HasAssoc {
+ associatedtype Assoc
+}
+
+protocol GenericParameterNameCollisionProtocol {
+ func foo<T>(_ x: T)
+ associatedtype Assoc2
+ func bar<T>(_ x: (T) -> Assoc2)
+}
+
+struct GenericParameterNameCollision<T: HasAssoc> :
+ GenericParameterNameCollisionProtocol {
+
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses29GenericParameterNameCollisionVyxGAA0bcdE8ProtocolA2aEP3fooyyqd__lFTW : $@convention(witness_method: GenericParameterNameCollisionProtocol) <τ_0_0 where τ_0_0 : HasAssoc><τ_1_0> (@in_guaranteed τ_1_0, @in_guaranteed GenericParameterNameCollision<τ_0_0>) -> () {
+ // CHECK: bb0(%0 : @trivial $*τ_1_0, %1 : @trivial $*GenericParameterNameCollision<τ_0_0>):
+ // CHECK: apply {{%.*}}<τ_0_0, τ_1_0>
+ func foo<U>(_ x: U) {}
+
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses29GenericParameterNameCollisionVyxGAA0bcdE8ProtocolA2aEP3baryy6Assoc2Qzqd__XElFTW : $@convention(witness_method: GenericParameterNameCollisionProtocol) <τ_0_0 where τ_0_0 : HasAssoc><τ_1_0> (@noescape @callee_guaranteed (@in_guaranteed τ_1_0) -> @out τ_0_0.Assoc, @in_guaranteed GenericParameterNameCollision<τ_0_0>) -> () {
+ // CHECK: bb0(%0 : @trivial $@noescape @callee_guaranteed (@in_guaranteed τ_1_0) -> @out τ_0_0.Assoc, %1 : @trivial $*GenericParameterNameCollision<τ_0_0>):
+ // CHECK: apply {{%.*}}<τ_0_0, τ_1_0>
+ func bar<V>(_ x: (V) -> T.Assoc) {}
+}
+
+protocol PropertyRequirement {
+ var width: Int { get set }
+ static var height: Int { get set }
+ var depth: Int { get set }
+}
+
+class PropertyRequirementBase {
+ var width: Int = 12
+ static var height: Int = 13
+}
+
+class PropertyRequirementWitnessFromBase : PropertyRequirementBase, PropertyRequirement {
+ var depth: Int = 14
+
+ // Make sure the contravariant return type in materializeForSet works correctly
+
+ // If the witness is in a base class of the conforming class, make sure we have a bit_cast in there:
+
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses34PropertyRequirementWitnessFromBaseCAA0bC0A2aDP5widthSivmTW : {{.*}} {
+ // CHECK: bb0({{.*}} : @trivial $Builtin.RawPointer, {{.*}} : @trivial $*Builtin.UnsafeValueBuffer, [[ARG2:%.*]] : @trivial $*PropertyRequirementWitnessFromBase):
+ // CHECK-NEXT: [[ARG2_LOADED:%[0-9][0-9]*]] = load_borrow [[ARG2]]
+ // CHECK-NEXT: [[CAST_ARG2_LOADED:%[0-9][0-9]*]] = upcast [[ARG2_LOADED]] : $PropertyRequirementWitnessFromBase to $PropertyRequirementBase
+ // CHECK-NEXT: [[METH:%.*]] = class_method [[CAST_ARG2_LOADED]] : $PropertyRequirementBase, #PropertyRequirementBase.width!materializeForSet.1
+ // CHECK-NEXT: [[RES:%.*]] = apply [[METH]]({{.*}}, {{.*}}, [[CAST_ARG2_LOADED]]) : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed PropertyRequirementBase) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ // CHECK-NEXT: [[CAR:%.*]] = tuple_extract [[RES]] : $({{.*}}), 0
+ // CHECK-NEXT: [[CADR:%.*]] = tuple_extract [[RES]] : $({{.*}}), 1
+ // CHECK-NEXT: [[TUPLE:%.*]] = tuple ([[CAR]] : {{.*}}, [[CADR]] : {{.*}})
+ // CHECK-NEXT: end_borrow [[ARG2_LOADED]] from [[ARG2]]
+ // CHECK-NEXT: return [[TUPLE]]
+
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses34PropertyRequirementWitnessFromBaseCAA0bC0A2aDP6heightSivmZTW : {{.*}} {
+ // CHECK: [[OBJ:%.*]] = upcast %2 : $@thick PropertyRequirementWitnessFromBase.Type to $@thick PropertyRequirementBase.Type
+ // CHECK: [[METH:%.*]] = function_ref @$S9witnesses23PropertyRequirementBaseC6heightSivmZ
+ // CHECK-NEXT: [[RES:%.*]] = apply [[METH]]
+ // CHECK-NEXT: [[CAR:%.*]] = tuple_extract [[RES]] : $({{.*}}), 0
+ // CHECK-NEXT: [[CADR:%.*]] = tuple_extract [[RES]] : $({{.*}}), 1
+ // CHECK-NEXT: [[TUPLE:%.*]] = tuple ([[CAR]] : {{.*}}, [[CADR]] : {{.*}})
+ // CHECK-NEXT: return [[TUPLE]]
+
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses34PropertyRequirementWitnessFromBaseCAA0bC0A2aDP5depthSivmTW
+ // CHECK: bb0({{.*}} : @trivial $Builtin.RawPointer, {{.*}} : @trivial $*Builtin.UnsafeValueBuffer, [[ARG2:%.*]] : @trivial $*PropertyRequirementWitnessFromBase):
+ // CHECK: [[ARG2_LOADED:%[0-9][0-9]*]] = load_borrow [[ARG2]]
+ // CHECK: [[METH:%.*]] = class_method [[ARG2_LOADED]] : $PropertyRequirementWitnessFromBase, #PropertyRequirementWitnessFromBase.depth!materializeForSet.1
+ // CHECK-NEXT: [[RES:%.*]] = apply [[METH]]({{.*}}, {{.*}}, [[ARG2_LOADED]]) : $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @guaranteed PropertyRequirementWitnessFromBase) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>)
+ // CHECK-NEXT: tuple_extract
+ // CHECK-NEXT: tuple_extract
+ // CHECK-NEXT: [[RES:%.*]] = tuple
+ // CHECK-NEXT: end_borrow [[ARG2_LOADED]] from [[ARG2]]
+ // CHECK-NEXT: return [[RES]]
+}
+
+protocol Crashable {
+ func crash()
+}
+
+class CrashableBase {
+ func crash() {}
+}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S9witnesses16GenericCrashableCyxGAA0C0A2aEP5crashyyFTW : $@convention(witness_method: Crashable) <τ_0_0> (@in_guaranteed GenericCrashable<τ_0_0>) -> ()
+// CHECK: bb0(%0 : @trivial $*GenericCrashable<τ_0_0>):
+// CHECK-NEXT: [[SELF:%.*]] = load_borrow %0 : $*GenericCrashable<τ_0_0>
+// CHECK-NEXT: [[BASE:%.*]] = upcast [[SELF]] : $GenericCrashable<τ_0_0> to $CrashableBase
+// CHECK-NEXT: [[FN:%.*]] = class_method [[BASE]] : $CrashableBase, #CrashableBase.crash!1 : (CrashableBase) -> () -> (), $@convention(method) (@guaranteed CrashableBase) -> ()
+// CHECK-NEXT: apply [[FN]]([[BASE]]) : $@convention(method) (@guaranteed CrashableBase) -> ()
+// CHECK-NEXT: [[RESULT:%.*]] = tuple ()
+// CHECK-NEXT: end_borrow [[SELF]] from %0
+// CHECK-NEXT: return [[RESULT]] : $()
+
+class GenericCrashable<T> : CrashableBase, Crashable {}
diff --git a/test/SILGen/plus_zero_witnesses_class.swift b/test/SILGen/plus_zero_witnesses_class.swift
new file mode 100644
index 0000000..3ec494b
--- /dev/null
+++ b/test/SILGen/plus_zero_witnesses_class.swift
@@ -0,0 +1,104 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -emit-silgen %s | %FileCheck %s
+
+protocol Fooable: class {
+ func foo()
+ static func bar()
+ init()
+}
+
+class Foo: Fooable {
+
+ func foo() { }
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S15witnesses_class3FooCAA7FooableA2aDP3foo{{[_0-9a-zA-Z]*}}FTW
+ // CHECK-NOT: function_ref
+ // CHECK: class_method
+
+ class func bar() {}
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S15witnesses_class3FooCAA7FooableA2aDP3bar{{[_0-9a-zA-Z]*}}FZTW
+ // CHECK-NOT: function_ref
+ // CHECK: class_method
+
+ required init() {}
+ // CHECK-LABEL: sil private [transparent] [thunk] @$S15witnesses_class3FooCAA7FooableA2aDP{{[_0-9a-zA-Z]*}}fCTW
+ // CHECK-NOT: function_ref
+ // CHECK: class_method
+}
+
+// CHECK-LABEL: sil hidden @$S15witnesses_class3genyyxAA7FooableRzlF
+// CHECK: bb0([[SELF:%.*]] : @guaranteed $T)
+// CHECK-NOT: copy_value [[SELF]]
+// CHECK: [[METHOD:%.*]] = witness_method $T
+// CHECK: apply [[METHOD]]<T>([[SELF]])
+// CHECK-NOT: destroy_value [[SELF]]
+// CHECK: return
+func gen<T: Fooable>(_ foo: T) {
+ foo.foo()
+}
+
+// CHECK-LABEL: sil hidden @$S15witnesses_class2exyyAA7Fooable_pF
+// CHECK: bb0([[SELF:%[0-0]+]] : @guaranteed $Fooable):
+// CHECK: [[SELF_PROJ:%.*]] = open_existential_ref [[SELF]]
+// CHECK: [[METHOD:%.*]] = witness_method $[[OPENED:@opened(.*) Fooable]],
+// CHECK-NOT: copy_value [[SELF_PROJ]] : $
+// CHECK: apply [[METHOD]]<[[OPENED]]>([[SELF_PROJ]])
+// CHECK-NOT: destroy_value [[SELF]]
+// CHECK: return
+func ex(_ foo: Fooable) {
+ foo.foo()
+}
+
+// Default implementations in a protocol extension
+protocol HasDefaults {
+ associatedtype T = Self
+
+ func hasDefault()
+
+ func hasDefaultTakesT(_: T)
+
+ func hasDefaultGeneric<U : Fooable>(_: U)
+
+ func hasDefaultGenericTakesT<U : Fooable>(_: T, _: U)
+}
+
+extension HasDefaults {
+ func hasDefault() {}
+
+ func hasDefaultTakesT(_: T) {}
+
+ func hasDefaultGeneric<U : Fooable>(_: U) {}
+
+ func hasDefaultGenericTakesT<U : Fooable>(_: T, _: U) {}
+}
+
+protocol Barable {}
+
+class UsesDefaults<X : Barable> : HasDefaults {}
+
+// Covariant Self:
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15witnesses_class12UsesDefaultsCyxGAA03HasD0A2aEP10hasDefaultyyFTW : $@convention(witness_method: HasDefaults) <τ_0_0><τ_1_0 where τ_0_0 : UsesDefaults<τ_1_0>, τ_1_0 : Barable> (@in_guaranteed τ_0_0) -> ()
+// CHECK: [[FN:%.*]] = function_ref @$S15witnesses_class11HasDefaultsPAAE10hasDefaultyyF : $@convention(method) <τ_0_0 where τ_0_0 : HasDefaults> (@in_guaranteed τ_0_0) -> ()
+// CHECK: apply [[FN]]<τ_0_0>(
+// CHECK: return
+
+// Invariant Self, since type signature contains an associated type:
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15witnesses_class12UsesDefaultsCyxGAA03HasD0A2aEP16hasDefaultTakesTyy1TQzFTW : $@convention(witness_method: HasDefaults) <τ_0_0 where τ_0_0 : Barable> (@in_guaranteed UsesDefaults<τ_0_0>, @in_guaranteed UsesDefaults<τ_0_0>) -> ()
+// CHECK: [[FN:%.*]] = function_ref @$S15witnesses_class11HasDefaultsPAAE16hasDefaultTakesTyy1TQzF : $@convention(method) <τ_0_0 where τ_0_0 : HasDefaults> (@in_guaranteed τ_0_0.T, @in_guaranteed τ_0_0) -> ()
+// CHECK: apply [[FN]]<UsesDefaults<τ_0_0>>(
+// CHECK: return
+
+// Covariant Self:
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15witnesses_class12UsesDefaultsCyxGAA03HasD0A2aEP17hasDefaultGenericyyqd__AA7FooableRd__lFTW : $@convention(witness_method: HasDefaults) <τ_0_0><τ_1_0 where τ_0_0 : UsesDefaults<τ_1_0>, τ_1_0 : Barable><τ_2_0 where τ_2_0 : Fooable> (@guaranteed τ_2_0, @in_guaranteed τ_0_0) -> ()
+// CHECK: [[FN:%.*]] = function_ref @$S15witnesses_class11HasDefaultsPAAE17hasDefaultGenericyyqd__AA7FooableRd__lF : $@convention(method) <τ_0_0 where τ_0_0 : HasDefaults><τ_1_0 where τ_1_0 : Fooable> (@guaranteed τ_1_0, @in_guaranteed τ_0_0) -> ()
+// CHECK: apply [[FN]]<τ_0_0, τ_2_0>(
+// CHECK: return
+
+// Invariant Self, since type signature contains an associated type:
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S15witnesses_class12UsesDefaultsCyxGAA03HasD0A2aEP23hasDefaultGenericTakesTyy1TQz_qd__tAA7FooableRd__lFTW : $@convention(witness_method: HasDefaults) <τ_0_0 where τ_0_0 : Barable><τ_1_0 where τ_1_0 : Fooable> (@in_guaranteed UsesDefaults<τ_0_0>, @guaranteed τ_1_0, @in_guaranteed UsesDefaults<τ_0_0>) -> ()
+// CHECK: [[FN:%.*]] = function_ref @$S15witnesses_class11HasDefaultsPAAE23hasDefaultGenericTakesTyy1TQz_qd__tAA7FooableRd__lF : $@convention(method) <τ_0_0 where τ_0_0 : HasDefaults><τ_1_0 where τ_1_0 : Fooable> (@in_guaranteed τ_0_0.T, @guaranteed τ_1_0, @in_guaranteed τ_0_0) -> ()
+// CHECK: apply [[FN]]<UsesDefaults<τ_0_0>, τ_1_0>(
+// CHECK: return
diff --git a/test/SILGen/pointer_conversion.swift b/test/SILGen/pointer_conversion.swift
index c47f89c..9d540d2 100644
--- a/test/SILGen/pointer_conversion.swift
+++ b/test/SILGen/pointer_conversion.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -sdk %S/Inputs -I %S/Inputs -enable-source-import %s | %FileCheck %s
// FIXME: rdar://problem/19648117 Needs splitting objc parts out
diff --git a/test/SILGen/properties.swift b/test/SILGen/properties.swift
index d108a13..841c8b8 100644
--- a/test/SILGen/properties.swift
+++ b/test/SILGen/properties.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -parse-as-library -emit-silgen -disable-objc-attr-requires-foundation-module %s | %FileCheck %s
var zero: Int = 0
@@ -238,7 +239,7 @@
// -- writeback to val.ref.val_prop
// CHECK: switch_enum [[OPT_CALLBACK]] : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: [[WRITEBACK:bb[0-9]+]], case #Optional.none!enumelt: [[CONT:bb[0-9]+]]
// CHECK: [[WRITEBACK]]([[CALLBACK_ADDR:%.*]] : $Builtin.RawPointer):
- // CHECK: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout Ref, @thick Ref.Type) -> ()
+ // CHECK: [[CALLBACK:%.*]] = pointer_to_thin_function [[CALLBACK_ADDR]] : $Builtin.RawPointer to $@convention(method) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed Ref, @thick Ref.Type) -> ()
// CHECK: [[REF_MAT:%.*]] = alloc_stack $Ref
// CHECK: store [[VAL_REF]] to [init] [[REF_MAT]]
// CHECK: [[T0:%.*]] = metatype $@thick Ref.Type
diff --git a/test/SILGen/property_abstraction.swift b/test/SILGen/property_abstraction.swift
index 6499fc7..beb71e7 100644
--- a/test/SILGen/property_abstraction.swift
+++ b/test/SILGen/property_abstraction.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -emit-silgen %s | %FileCheck %s
struct Int {
diff --git a/test/SILGen/protocol_extensions.swift b/test/SILGen/protocol_extensions.swift
index b125092..f01358e 100644
--- a/test/SILGen/protocol_extensions.swift
+++ b/test/SILGen/protocol_extensions.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -disable-objc-attr-requires-foundation-module -emit-silgen %s | %FileCheck %s
public protocol P1 {
diff --git a/test/SILGen/protocol_optional.swift b/test/SILGen/protocol_optional.swift
index 72e7f7c..550908f 100644
--- a/test/SILGen/protocol_optional.swift
+++ b/test/SILGen/protocol_optional.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -parse-as-library -emit-silgen -disable-objc-attr-requires-foundation-module -enable-sil-ownership %s | %FileCheck %s
@objc protocol P1 {
diff --git a/test/SILGen/protocol_resilience.swift b/test/SILGen/protocol_resilience.swift
index 04cef96..f28b215 100644
--- a/test/SILGen/protocol_resilience.swift
+++ b/test/SILGen/protocol_resilience.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -enable-sil-ownership -enable-resilience -emit-module-path=%t/resilient_protocol.swiftmodule -module-name=resilient_protocol %S/../Inputs/resilient_protocol.swift
// RUN: %target-swift-frontend -I %t -emit-silgen -enable-sil-ownership -enable-resilience %s | %FileCheck %s
diff --git a/test/SILGen/protocols.swift b/test/SILGen/protocols.swift
index 11072b7..15ff6b3 100644
--- a/test/SILGen/protocols.swift
+++ b/test/SILGen/protocols.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
//===----------------------------------------------------------------------===//
diff --git a/test/SILGen/reabstract-tuple.swift b/test/SILGen/reabstract-tuple.swift
index 13cada1..d3cfb5d 100644
--- a/test/SILGen/reabstract-tuple.swift
+++ b/test/SILGen/reabstract-tuple.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -emit-silgen -verify %s | %FileCheck %s
// SR-3090:
diff --git a/test/SILGen/reabstract.swift b/test/SILGen/reabstract.swift
index 5c51858..8736780 100644
--- a/test/SILGen/reabstract.swift
+++ b/test/SILGen/reabstract.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -enable-sil-ownership %s | %FileCheck %s
func takeFn<T>(_ f : (T) -> T?) {}
diff --git a/test/SILGen/reabstract_lvalue.swift b/test/SILGen/reabstract_lvalue.swift
index 63d8a74..8cbd9b8 100644
--- a/test/SILGen/reabstract_lvalue.swift
+++ b/test/SILGen/reabstract_lvalue.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
struct MyMetatypeIsThin {}
diff --git a/test/SILGen/result_abstraction.swift b/test/SILGen/result_abstraction.swift
index a15924d..e2b49e1 100644
--- a/test/SILGen/result_abstraction.swift
+++ b/test/SILGen/result_abstraction.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
struct S {}
diff --git a/test/SILGen/retaining_globals.swift b/test/SILGen/retaining_globals.swift
index 211070e..87756cc 100644
--- a/test/SILGen/retaining_globals.swift
+++ b/test/SILGen/retaining_globals.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -import-objc-header %S/Inputs/globals.h -emit-silgen -enable-sil-ownership %s | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILGen/rethrows.swift b/test/SILGen/rethrows.swift
index 908fb03..ad23e4a 100644
--- a/test/SILGen/rethrows.swift
+++ b/test/SILGen/rethrows.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -emit-sil -verify %s | %FileCheck %s
@discardableResult
diff --git a/test/SILGen/scalar_to_tuple_args.swift b/test/SILGen/scalar_to_tuple_args.swift
index 41476ee..8fd38f6 100644
--- a/test/SILGen/scalar_to_tuple_args.swift
+++ b/test/SILGen/scalar_to_tuple_args.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
func inoutWithDefaults(_ x: inout Int, y: Int = 0, z: Int = 0) {}
diff --git a/test/SILGen/shared.swift b/test/SILGen/shared.swift
index dd3c974..c0af68e 100644
--- a/test/SILGen/shared.swift
+++ b/test/SILGen/shared.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen %s -disable-objc-attr-requires-foundation-module -enable-sil-ownership | %FileCheck %s
class RefAggregate {}
diff --git a/test/SILGen/sil_locations.swift b/test/SILGen/sil_locations.swift
index e43cf3d..7614fb1 100644
--- a/test/SILGen/sil_locations.swift
+++ b/test/SILGen/sil_locations.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -Xllvm -sil-print-debuginfo -emit-verbose-sil -enable-sil-ownership %s | %FileCheck %s
// FIXME: Not sure if this an ideal source info for the branch -
@@ -76,7 +77,7 @@
func useTemplateTest() -> Int {
return templateTest(5);
// CHECK-LABEL: sil hidden @$S13sil_locations15useTemplateTestSiyF
- // CHECK: function_ref @$SSi2{{[_0-9a-zA-Z]*}}fC :{{.*}}, loc "{{.*}}":77
+ // CHECK: function_ref @$SSi2{{[_0-9a-zA-Z]*}}fC :{{.*}}, loc "{{.*}}":78
}
func foo(_ x: Int) -> Int {
diff --git a/test/SILGen/source_location.swift b/test/SILGen/source_location.swift
index 85a7296..67916ef 100644
--- a/test/SILGen/source_location.swift
+++ b/test/SILGen/source_location.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -Xllvm -sil-print-debuginfo -emit-silgen -enable-sil-ownership %s | %FileCheck %s
func printSourceLocation(file: String = #file, line: Int = #line) {}
diff --git a/test/SILGen/specialize_attr.swift b/test/SILGen/specialize_attr.swift
index ac5b27d..0c45041 100644
--- a/test/SILGen/specialize_attr.swift
+++ b/test/SILGen/specialize_attr.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -emit-verbose-sil %s | %FileCheck %s
// CHECK-LABEL: @_specialize(exported: false, kind: full, where T == Int, U == Float)
diff --git a/test/SILGen/statements.swift b/test/SILGen/statements.swift
index 8b86759..212f42e 100644
--- a/test/SILGen/statements.swift
+++ b/test/SILGen/statements.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -parse-as-library -emit-silgen -enable-sil-ownership -verify %s | %FileCheck %s
class MyClass {
diff --git a/test/SILGen/struct_resilience.swift b/test/SILGen/struct_resilience.swift
index 40d578e..5d50e67 100644
--- a/test/SILGen/struct_resilience.swift
+++ b/test/SILGen/struct_resilience.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -enable-resilience -emit-module-path=%t/resilient_struct.swiftmodule -enable-sil-ownership -module-name=resilient_struct %S/../Inputs/resilient_struct.swift
// RUN: %target-swift-frontend -I %t -enable-sil-ownership -emit-silgen -enable-resilience %s | %FileCheck %s
diff --git a/test/SILGen/subclass_existentials.swift b/test/SILGen/subclass_existentials.swift
index efcbdbf..dbd0cba 100644
--- a/test/SILGen/subclass_existentials.swift
+++ b/test/SILGen/subclass_existentials.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -parse-as-library -primary-file %s -verify | %FileCheck %s
// RUN: %target-swift-frontend -emit-ir -parse-as-library -primary-file %s
diff --git a/test/SILGen/super.swift b/test/SILGen/super.swift
index f762ee1..c00184c 100644
--- a/test/SILGen/super.swift
+++ b/test/SILGen/super.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -I %t -emit-module -emit-module-path=%t/resilient_struct.swiftmodule -module-name resilient_struct %S/../Inputs/resilient_struct.swift
// RUN: %target-swift-frontend -I %t -emit-module -emit-module-path=%t/resilient_class.swiftmodule -module-name resilient_class %S/../Inputs/resilient_class.swift
diff --git a/test/SILGen/switch.swift b/test/SILGen/switch.swift
index b64ab66..175a476 100644
--- a/test/SILGen/switch.swift
+++ b/test/SILGen/switch.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
func markUsed<T>(_ t: T) {}
diff --git a/test/SILGen/switch_abstraction.swift b/test/SILGen/switch_abstraction.swift
index c4bdccd..3b8e042 100644
--- a/test/SILGen/switch_abstraction.swift
+++ b/test/SILGen/switch_abstraction.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -parse-stdlib %s | %FileCheck %s
struct A {}
diff --git a/test/SILGen/switch_isa.swift b/test/SILGen/switch_isa.swift
index a7eca4d..4977f99 100644
--- a/test/SILGen/switch_isa.swift
+++ b/test/SILGen/switch_isa.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
func markUsed<T>(_ t: T) {}
diff --git a/test/SILGen/switch_multiple_entry_address_only.swift b/test/SILGen/switch_multiple_entry_address_only.swift
index 735c9ec..2a94457 100644
--- a/test/SILGen/switch_multiple_entry_address_only.swift
+++ b/test/SILGen/switch_multiple_entry_address_only.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend %s -emit-silgen | %FileCheck %s
enum E {
diff --git a/test/SILGen/switch_var.swift b/test/SILGen/switch_var.swift
index 4660bf1..cc8b022 100644
--- a/test/SILGen/switch_var.swift
+++ b/test/SILGen/switch_var.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
// TODO: Implement tuple equality in the library.
diff --git a/test/SILGen/testable-multifile-other.swift b/test/SILGen/testable-multifile-other.swift
index 792d3ae..e33d15c 100644
--- a/test/SILGen/testable-multifile-other.swift
+++ b/test/SILGen/testable-multifile-other.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// This test is paired with testable-multifile.swift.
// RUN: %empty-directory(%t)
diff --git a/test/SILGen/tuples.swift b/test/SILGen/tuples.swift
index e9b4714..a05a467 100644
--- a/test/SILGen/tuples.swift
+++ b/test/SILGen/tuples.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
class C {}
diff --git a/test/SILGen/types.swift b/test/SILGen/types.swift
index b30c8c2..d996b3e 100644
--- a/test/SILGen/types.swift
+++ b/test/SILGen/types.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -parse-as-library -emit-silgen -enable-sil-ownership %s | %FileCheck %s
class C {
diff --git a/test/SILGen/unmanaged.swift b/test/SILGen/unmanaged.swift
index 9e939f9..c8d98ea 100644
--- a/test/SILGen/unmanaged.swift
+++ b/test/SILGen/unmanaged.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -emit-sil %s | %FileCheck %s
class C {}
diff --git a/test/SILGen/unmanaged_ownership.swift b/test/SILGen/unmanaged_ownership.swift
index ecb0309..21d447b 100644
--- a/test/SILGen/unmanaged_ownership.swift
+++ b/test/SILGen/unmanaged_ownership.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -parse-stdlib -module-name Swift -emit-silgen %s | %FileCheck %s
class C {}
diff --git a/test/SILGen/unowned.swift b/test/SILGen/unowned.swift
index d55585f..7c7e8a8 100644
--- a/test/SILGen/unowned.swift
+++ b/test/SILGen/unowned.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
func takeClosure(_ fn: () -> Int) {}
diff --git a/test/SILGen/vtable_thunks_reabstraction_final.swift b/test/SILGen/vtable_thunks_reabstraction_final.swift
index 0d31336..68e4b6b 100644
--- a/test/SILGen/vtable_thunks_reabstraction_final.swift
+++ b/test/SILGen/vtable_thunks_reabstraction_final.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
protocol Fooable {
diff --git a/test/SILGen/vtables_objc.swift b/test/SILGen/vtables_objc.swift
index c0d32a7..eb45a91 100644
--- a/test/SILGen/vtables_objc.swift
+++ b/test/SILGen/vtables_objc.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -sdk %S/Inputs -emit-silgen -I %S/Inputs -enable-source-import %s -disable-objc-attr-requires-foundation-module | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILGen/weak.swift b/test/SILGen/weak.swift
index f9fe4a7..0e2567c 100644
--- a/test/SILGen/weak.swift
+++ b/test/SILGen/weak.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen -enable-sil-ownership %s | %FileCheck %s
class C {
diff --git a/test/SILGen/weak_multiple_modules.swift b/test/SILGen/weak_multiple_modules.swift
index fe5bd5c..dcfdd34 100644
--- a/test/SILGen/weak_multiple_modules.swift
+++ b/test/SILGen/weak_multiple_modules.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -emit-module-path=%t/weak_other.swiftmodule -module-name=weak_other %S/Inputs/weak_other.swift
// RUN: %target-swift-frontend -I %t -emit-silgen -enable-sil-ownership %s | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-runtime
diff --git a/test/SILGen/without_actually_escaping.swift b/test/SILGen/without_actually_escaping.swift
index cd91ae1..1719770 100644
--- a/test/SILGen/without_actually_escaping.swift
+++ b/test/SILGen/without_actually_escaping.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
var escapeHatch: Any = 0
diff --git a/test/SILGen/witness_same_type.swift b/test/SILGen/witness_same_type.swift
index 69bf55e..b5659c5 100644
--- a/test/SILGen/witness_same_type.swift
+++ b/test/SILGen/witness_same_type.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership %s | %FileCheck %s
// RUN: %target-swift-frontend -enable-sil-ownership -emit-ir %s
diff --git a/test/SILGen/witness_tables.swift b/test/SILGen/witness_tables.swift
index d5ae931..9e0f98b 100644
--- a/test/SILGen/witness_tables.swift
+++ b/test/SILGen/witness_tables.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-silgen -enable-sil-ownership -I %S/Inputs -enable-source-import %s -disable-objc-attr-requires-foundation-module > %t.sil
// RUN: %FileCheck -check-prefix=TABLE -check-prefix=TABLE-ALL %s < %t.sil
// RUN: %FileCheck -check-prefix=SYMBOL %s < %t.sil
diff --git a/test/SILGen/witnesses.swift b/test/SILGen/witnesses.swift
index bf8da17..e78392d 100644
--- a/test/SILGen/witnesses.swift
+++ b/test/SILGen/witnesses.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -emit-silgen %s -disable-objc-attr-requires-foundation-module -enable-sil-ownership | %FileCheck %s
infix operator <~> {}
diff --git a/test/SILGen/witnesses_class.swift b/test/SILGen/witnesses_class.swift
index 461c980..64ca7a1 100644
--- a/test/SILGen/witnesses_class.swift
+++ b/test/SILGen/witnesses_class.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -emit-silgen %s | %FileCheck %s
protocol Fooable: class {
diff --git a/test/SILOptimizer/Inputs/TestMod.sil b/test/SILOptimizer/Inputs/TestMod.sil
index 3e12d13..9ae4a7a 100644
--- a/test/SILOptimizer/Inputs/TestMod.sil
+++ b/test/SILOptimizer/Inputs/TestMod.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// Test module for the specialize_cg_update_crash.sil test.
sil_stage canonical
diff --git a/test/SILOptimizer/Inputs/plus_zero_TestMod.sil b/test/SILOptimizer/Inputs/plus_zero_TestMod.sil
new file mode 100644
index 0000000..62126fb
--- /dev/null
+++ b/test/SILOptimizer/Inputs/plus_zero_TestMod.sil
@@ -0,0 +1,64 @@
+// REQUIRES: plus_zero_runtime
+// Test module for the specialize_cg_update_crash.sil test.
+
+sil_stage canonical
+
+import Builtin
+
+func genlibfunc<X>(x: X) -> X
+
+func genlibfunc2<X>(x: X) -> X
+
+func genlibfunc3<X>(x: X) -> X
+
+class MyClass {
+ init()
+ func mymethod<X>(x: X) -> X
+ deinit
+}
+
+sil @_TFC7TestMod7MyClassD : $@convention(method) (@owned MyClass) -> ()
+sil @_TFC7TestMod7MyClasscfMS0_FT_S0_ : $@convention(method) (@owned MyClass) -> @owned MyClass
+
+sil @_TF7TestMod11genlibfunc3urFq_q_ : $@convention(thin) <X> (@in_guaranteed X) -> @out X {
+bb0(%0 : $*X, %1 : $*X):
+ %4 = tuple ()
+ return %4 : $()
+}
+
+sil @_TF7TestMod11genlibfunc2urFq_q_ : $@convention(thin) <X> (@in_guaranteed X) -> @out X {
+bb0(%0 : $*X, %1 : $*X):
+ %3 = function_ref @_TF7TestMod11genlibfunc3urFq_q_ : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ %9 = tuple ()
+ return %9 : $()
+}
+
+sil @_TFC7TestMod7MyClass8mymethodurfS0_Fq_q_ : $@convention(method) <X> (@in_guaranteed X, @guaranteed MyClass) -> @out X {
+bb0(%0 : $*X, %1 : $*X, %2 : $MyClass):
+ %5 = function_ref @_TF7TestMod11genlibfunc3urFq_q_ : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ %11 = tuple ()
+ return %11 : $()
+}
+
+// This is the critical function.
+sil @_TF7TestMod10genlibfuncurFq_q_ : $@convention(thin) <X> (@in_guaranteed X) -> @out X {
+bb0(%0 : $*X, %1 : $*X):
+
+ // First reference the method, which lets the method be deserialized, but not processed.
+ %x0 = function_ref @_TFC7TestMod7MyClass8mymethodurfS0_Fq_q_ : $@convention(method) <X> (@in_guaranteed X, @guaranteed MyClass) -> @out X
+
+ // Then reference the metatype which reads the vtable and processes the method.
+ // The bug was that during reading the vtable (and processing the vtable functions),
+ // the callback (to update the CG) was lost.
+ %x4 = metatype $@thick MyClass.Type
+
+ %17 = tuple ()
+ return %17 : $()
+}
+
+sil_vtable MyClass {
+ #MyClass.init!initializer.1: @_TFC7TestMod7MyClasscfMS0_FT_S0_ // TestMod.MyClass.init (TestMod.MyClass.Type)() -> TestMod.MyClass
+ #MyClass.mymethod!1: @_TFC7TestMod7MyClass8mymethodurfS0_Fq_q_ // TestMod.MyClass.mymethod <A> (TestMod.MyClass)(A) -> A
+ #MyClass.deinit!deallocator: @_TFC7TestMod7MyClassD // TestMod.MyClass.__deallocating_deinit
+}
+
diff --git a/test/SILOptimizer/access_enforcement_noescape.swift b/test/SILOptimizer/access_enforcement_noescape.swift
index b9930d6..ef753a5 100644
--- a/test/SILOptimizer/access_enforcement_noescape.swift
+++ b/test/SILOptimizer/access_enforcement_noescape.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -enforce-exclusivity=checked -Onone -emit-sil -swift-version 4 -verify -parse-as-library %s
// RUN: %target-swift-frontend -enable-sil-ownership -enforce-exclusivity=checked -Onone -emit-sil -swift-version 3 -parse-as-library %s | %FileCheck %s
// REQUIRES: asserts
diff --git a/test/SILOptimizer/access_marker_mandatory.swift b/test/SILOptimizer/access_marker_mandatory.swift
index 3f01c45..be19716 100644
--- a/test/SILOptimizer/access_marker_mandatory.swift
+++ b/test/SILOptimizer/access_marker_mandatory.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -parse-as-library -Xllvm -sil-full-demangle -emit-sil -Onone -enforce-exclusivity=checked %s | %FileCheck %s
public struct S {
diff --git a/test/SILOptimizer/access_marker_verify.swift b/test/SILOptimizer/access_marker_verify.swift
index 3ef80fa..3e7cd7f 100644
--- a/test/SILOptimizer/access_marker_verify.swift
+++ b/test/SILOptimizer/access_marker_verify.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-verify-exclusivity -enforce-exclusivity=checked -enable-sil-ownership -emit-silgen -swift-version 4 -parse-as-library %s | %FileCheck %s
// RUN: %target-swift-frontend -enable-verify-exclusivity -enforce-exclusivity=checked -enable-sil-ownership -Onone -emit-sil -swift-version 4 -parse-as-library %s
// RUN: %target-swift-frontend -enable-verify-exclusivity -enforce-exclusivity=checked -enable-sil-ownership -O -emit-sil -swift-version 4 -parse-as-library %s
@@ -754,7 +755,7 @@
// CHECK-NOT: begin_access
// CHECK: store [[PA]] to [init] [[ADR]] : $*@callee_guaranteed () -> @out Int
// CHECK: [[PTR:%.*]] = address_to_pointer [[ADR]] : $*@callee_guaranteed () -> @out Int to $Builtin.RawPointer
-// CHECK: [[FPTR:%.*]] = thin_function_to_pointer %{{.*}} : $@convention(witness_method: Abstractable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout C, @thick C.Type) -> () to $Builtin.RawPointer
+// CHECK: [[FPTR:%.*]] = thin_function_to_pointer %{{.*}} : $@convention(witness_method: Abstractable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @in_guaranteed C, @thick C.Type) -> () to $Builtin.RawPointer
// CHECK: [[ENUM:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[FPTR]] : $Builtin.RawPointer
// CHECK: [[R:%.*]] = tuple ([[PTR]] : $Builtin.RawPointer, [[ENUM]] : $Optional<Builtin.RawPointer>)
// CHECK: return [[R]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
diff --git a/test/SILOptimizer/array_element_propagation.sil b/test/SILOptimizer/array_element_propagation.sil
index 55a6515..438b01a 100644
--- a/test/SILOptimizer/array_element_propagation.sil
+++ b/test/SILOptimizer/array_element_propagation.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -array-element-propagation %s | %FileCheck %s
sil_stage canonical
diff --git a/test/SILOptimizer/bridged_casts_folding.swift b/test/SILOptimizer/bridged_casts_folding.swift
index 9623da3..1716b1f 100644
--- a/test/SILOptimizer/bridged_casts_folding.swift
+++ b/test/SILOptimizer/bridged_casts_folding.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -O -emit-sil %s | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILOptimizer/capture_promotion_generic_context.sil b/test/SILOptimizer/capture_promotion_generic_context.sil
index 845eedf..7287e75 100644
--- a/test/SILOptimizer/capture_promotion_generic_context.sil
+++ b/test/SILOptimizer/capture_promotion_generic_context.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-sil -O -Xllvm -sil-fso-enable-generics=false %s | %FileCheck %s
sil_stage raw
diff --git a/test/SILOptimizer/capture_promotion_generic_context_ownership.sil b/test/SILOptimizer/capture_promotion_generic_context_ownership.sil
index c456d05..e2dc783 100644
--- a/test/SILOptimizer/capture_promotion_generic_context_ownership.sil
+++ b/test/SILOptimizer/capture_promotion_generic_context_ownership.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -emit-sil -O -Xllvm -sil-fso-enable-generics=false %s | %FileCheck %s
sil_stage raw
diff --git a/test/SILOptimizer/cast_folding_no_bridging.sil b/test/SILOptimizer/cast_folding_no_bridging.sil
index 54f6d27..ed7a539 100644
--- a/test/SILOptimizer/cast_folding_no_bridging.sil
+++ b/test/SILOptimizer/cast_folding_no_bridging.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -O -emit-sil %s | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILOptimizer/cast_folding_objc_generics.swift b/test/SILOptimizer/cast_folding_objc_generics.swift
index 1dd55c6..d6ad317 100644
--- a/test/SILOptimizer/cast_folding_objc_generics.swift
+++ b/test/SILOptimizer/cast_folding_objc_generics.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -O -emit-sil %s | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILOptimizer/cast_folding_objc_no_foundation.swift b/test/SILOptimizer/cast_folding_objc_no_foundation.swift
index b5304ff..17a88ee 100644
--- a/test/SILOptimizer/cast_folding_objc_no_foundation.swift
+++ b/test/SILOptimizer/cast_folding_objc_no_foundation.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -O -emit-sil %s | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILOptimizer/dead_code_elimination.sil b/test/SILOptimizer/dead_code_elimination.sil
index fdc3742..535cd1a 100644
--- a/test/SILOptimizer/dead_code_elimination.sil
+++ b/test/SILOptimizer/dead_code_elimination.sil
@@ -1,5 +1,7 @@
// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -enable-sil-verify-all -dce %s | %FileCheck %s
+// REQUIRES: rdar34013900
+
sil_stage canonical
import Builtin
diff --git a/test/SILOptimizer/devirt_covariant_return.swift b/test/SILOptimizer/devirt_covariant_return.swift
index a1f838d..be2da43 100644
--- a/test/SILOptimizer/devirt_covariant_return.swift
+++ b/test/SILOptimizer/devirt_covariant_return.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -O -Xllvm -disable-sil-cm-rr-cm=0 -Xllvm -sil-inline-generics=false -primary-file %s -emit-sil -sil-inline-threshold 1000 -Xllvm -sil-disable-pass=ObjectOutliner -sil-verify-all | %FileCheck %s
// Make sure that we can dig all the way through the class hierarchy and
diff --git a/test/SILOptimizer/devirt_default_case.swift b/test/SILOptimizer/devirt_default_case.swift
index f5a2126..5d86209 100644
--- a/test/SILOptimizer/devirt_default_case.swift
+++ b/test/SILOptimizer/devirt_default_case.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -O -module-name devirt_default_case -emit-sil %s | %FileCheck -check-prefix=CHECK -check-prefix=CHECK-NORMAL %s
// RUN: %target-swift-frontend -O -module-name devirt_default_case -emit-sil -enable-testing %s | %FileCheck -check-prefix=CHECK -check-prefix=CHECK-TESTABLE %s
diff --git a/test/SILOptimizer/devirt_nested_class.swift b/test/SILOptimizer/devirt_nested_class.swift
index e4e1fd9..520ffc6 100644
--- a/test/SILOptimizer/devirt_nested_class.swift
+++ b/test/SILOptimizer/devirt_nested_class.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-sil -O %s | %FileCheck %s
fileprivate class Outer<T> {
diff --git a/test/SILOptimizer/devirt_protocol_method_invocations.swift b/test/SILOptimizer/devirt_protocol_method_invocations.swift
index 92d38bf..d05e1ba 100644
--- a/test/SILOptimizer/devirt_protocol_method_invocations.swift
+++ b/test/SILOptimizer/devirt_protocol_method_invocations.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -O -emit-sil %s | %FileCheck %s
protocol PPP {
diff --git a/test/SILOptimizer/devirt_speculative_nested.swift b/test/SILOptimizer/devirt_speculative_nested.swift
index ea35da2..41bbdfa 100644
--- a/test/SILOptimizer/devirt_speculative_nested.swift
+++ b/test/SILOptimizer/devirt_speculative_nested.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend %s -parse-as-library -O -emit-sil | %FileCheck %s
// RUN: %target-swift-frontend %s -parse-as-library -Osize -emit-sil
//
diff --git a/test/SILOptimizer/devirt_value_metatypes.swift b/test/SILOptimizer/devirt_value_metatypes.swift
index 93d6b01..69ce24f 100644
--- a/test/SILOptimizer/devirt_value_metatypes.swift
+++ b/test/SILOptimizer/devirt_value_metatypes.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-sil -O %s | %FileCheck %s
open class A {
diff --git a/test/SILOptimizer/devirt_witness_method_conformance.swift b/test/SILOptimizer/devirt_witness_method_conformance.swift
index 61cb7ae..b8f8c66 100644
--- a/test/SILOptimizer/devirt_witness_method_conformance.swift
+++ b/test/SILOptimizer/devirt_witness_method_conformance.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -O -emit-ir -primary-file %s | %FileCheck %s
// This is a swift file because the crash doesn't reproduce with SIL.
@inline(never)
diff --git a/test/SILOptimizer/globalopt-iter.sil b/test/SILOptimizer/globalopt-iter.sil
index b69962d..9daabd7 100644
--- a/test/SILOptimizer/globalopt-iter.sil
+++ b/test/SILOptimizer/globalopt-iter.sil
@@ -8,7 +8,8 @@
// CHECK: sil @patatino : $@convention(thin) () -> () {
// CHECK: bb0:
-// CHECK-NEXT: %0 = global_value @patatinoTv_ : $B
+// CHECK-NEXT: integer_literal
+// CHECK-NEXT: global_value @patatinoTv_ : $B
// CHECK-NEXT: strong_retain
// CHECK-NEXT: strong_release
// CHECK-NEXT: tuple ()
@@ -16,9 +17,10 @@
// CHECK-NEXT: }
sil @patatino : $@convention(thin) () -> () {
- %1 = alloc_ref [stack] $B
+ %0 = integer_literal $Builtin.Word, 0
+ %1 = alloc_ref [tail_elems $Int64 * %0 : $Builtin.Word] $B
set_deallocating %1 : $B
- dealloc_ref [stack] %1 : $B
+ dealloc_ref %1 : $B
%45 = tuple ()
return %45 : $()
}
diff --git a/test/SILOptimizer/let_properties_opts.swift b/test/SILOptimizer/let_properties_opts.swift
index 9351c22..d0c96e8 100644
--- a/test/SILOptimizer/let_properties_opts.swift
+++ b/test/SILOptimizer/let_properties_opts.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend %s -O -emit-sil | %FileCheck -check-prefix=CHECK-WMO %s
// RUN: %target-swift-frontend -primary-file %s -O -emit-sil | %FileCheck %s
diff --git a/test/SILOptimizer/mandatory_inlining.swift b/test/SILOptimizer/mandatory_inlining.swift
index a765c18..0f5d34d 100644
--- a/test/SILOptimizer/mandatory_inlining.swift
+++ b/test/SILOptimizer/mandatory_inlining.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -enable-sil-ownership -sil-verify-all -primary-file %s -emit-sil -o - -verify | %FileCheck %s
// These tests are deliberately shallow, because I do not want to depend on the
diff --git a/test/SILOptimizer/objectoutliner.sil b/test/SILOptimizer/objectoutliner.sil
index 7e94f44..c13e622 100644
--- a/test/SILOptimizer/objectoutliner.sil
+++ b/test/SILOptimizer/objectoutliner.sil
@@ -35,9 +35,10 @@
// CHECK: return
sil @outline_global_simple : $@convention(thin) () -> () {
bb0:
+ %0 = integer_literal $Builtin.Word, 0
%1 = integer_literal $Builtin.Int64, 1
%4 = struct $Int64 (%1 : $Builtin.Int64)
- %7 = alloc_ref $Obj
+ %7 = alloc_ref [tail_elems $Int64 * %0 : $Builtin.Word] $Obj
%9 = ref_element_addr %7 : $Obj, #Obj.value
store %4 to %9 : $*Int64
strong_release %7 : $Obj
@@ -83,9 +84,10 @@
// CHECK-NEXT: return
sil @handle_deallocation : $@convention(thin) () -> () {
bb0:
+ %0 = integer_literal $Builtin.Word, 0
%3 = integer_literal $Builtin.Int64, 3
%4 = struct $Int64 (%3 : $Builtin.Int64)
- %5 = alloc_ref $Obj
+ %5 = alloc_ref [tail_elems $Int64 * %0 : $Builtin.Word] $Obj
%6 = ref_element_addr %5 : $Obj, #Obj.value
store %4 to %6 : $*Int64
set_deallocating %5 : $Obj
@@ -94,15 +96,32 @@
return %r : $()
}
+// CHECK-LABEL: sil @dont_outline_without_tail_elems
+// CHECK: alloc_ref
+// CHECK: store
+// CHECK: return
+sil @dont_outline_without_tail_elems : $@convention(thin) () -> () {
+bb0:
+ %1 = integer_literal $Builtin.Int64, 1
+ %4 = struct $Int64 (%1 : $Builtin.Int64)
+ %7 = alloc_ref $Obj
+ %9 = ref_element_addr %7 : $Obj, #Obj.value
+ store %4 to %9 : $*Int64
+ strong_release %7 : $Obj
+ %r = tuple ()
+ return %r : $()
+}
+
// CHECK-LABEL: sil @dont_outline_global_double_store
// CHECK: alloc_ref
// CHECK: store
// CHECK: return
sil @dont_outline_global_double_store : $@convention(thin) () -> () {
bb0:
+ %0 = integer_literal $Builtin.Word, 0
%1 = integer_literal $Builtin.Int64, 1
%4 = struct $Int64 (%1 : $Builtin.Int64)
- %7 = alloc_ref $Obj
+ %7 = alloc_ref [tail_elems $Int64 * %0 : $Builtin.Word] $Obj
%9 = ref_element_addr %7 : $Obj, #Obj.value
store %4 to %9 : $*Int64
store %4 to %9 : $*Int64
@@ -116,9 +135,10 @@
// CHECK: return
sil @dont_outline_global_missing_store : $@convention(thin) () -> () {
bb0:
+ %0 = integer_literal $Builtin.Word, 0
%1 = integer_literal $Builtin.Int64, 1
%4 = struct $Int64 (%1 : $Builtin.Int64)
- %7 = alloc_ref $Obj
+ %7 = alloc_ref [tail_elems $Int64 * %0 : $Builtin.Word] $Obj
%9 = ref_element_addr %7 : $Obj, #Obj.value
strong_release %7 : $Obj
%r = tuple ()
@@ -148,9 +168,10 @@
// CHECK: return
sil @dont_outline_global_unknown_addr_use : $@convention(thin) () -> () {
bb0:
+ %0 = integer_literal $Builtin.Word, 0
%1 = integer_literal $Builtin.Int64, 1
%4 = struct $Int64 (%1 : $Builtin.Int64)
- %7 = alloc_ref $Obj
+ %7 = alloc_ref [tail_elems $Int64 * %0 : $Builtin.Word] $Obj
%9 = ref_element_addr %7 : $Obj, #Obj.value
store %4 to %9 : $*Int64
%10 = address_to_pointer %9 : $*Int64 to $Builtin.RawPointer
@@ -167,8 +188,9 @@
sil @dont_outline_global_escaping_obj : $@convention(thin) (@inout Obj) -> () {
bb0(%0: $*Obj):
%1 = integer_literal $Builtin.Int64, 1
+ %2 = integer_literal $Builtin.Word, 0
%4 = struct $Int64 (%1 : $Builtin.Int64)
- %7 = alloc_ref $Obj
+ %7 = alloc_ref [tail_elems $Int64 * %2 : $Builtin.Word] $Obj
%9 = ref_element_addr %7 : $Obj, #Obj.value
store %4 to %9 : $*Int64
store %7 to %0 : $*Obj
diff --git a/test/SILOptimizer/performance_inliner.sil b/test/SILOptimizer/performance_inliner.sil
index 6984d00..acdedf0 100644
--- a/test/SILOptimizer/performance_inliner.sil
+++ b/test/SILOptimizer/performance_inliner.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -enable-sil-verify-all %s -inline -sil-combine | %FileCheck %s
sil_stage canonical
diff --git a/test/SILOptimizer/plus_zero_access_enforcement_noescape.swift b/test/SILOptimizer/plus_zero_access_enforcement_noescape.swift
new file mode 100644
index 0000000..07fb511
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_access_enforcement_noescape.swift
@@ -0,0 +1,593 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -enforce-exclusivity=checked -Onone -emit-sil -swift-version 4 -verify -parse-as-library %s
+// RUN: %target-swift-frontend -enable-sil-ownership -enforce-exclusivity=checked -Onone -emit-sil -swift-version 3 -parse-as-library %s | %FileCheck %s
+// REQUIRES: asserts
+
+// This tests SILGen and AccessEnforcementSelection as a single set of tests.
+// (Some static/dynamic enforcement selection is done in SILGen, and some is
+// deferred. That may change over time but we want the outcome to be the same).
+//
+// These tests attempt to fully cover the possibilities of reads and
+// modifications to captures along with `inout` arguments on both the caller and
+// callee side.
+
+// Helper
+func doOne(_ f: () -> ()) {
+ f()
+}
+
+// Helper
+func doTwo(_: ()->(), _: ()->()) {}
+
+// Helper
+func doOneInout(_: ()->(), _: inout Int) {}
+
+// Error: Cannot capture nonescaping closure.
+// This triggers an early diagnostics, so it's handled in inout_capture_disgnostics.swift.
+// func reentrantCapturedNoescape(fn: (() -> ()) -> ()) {
+// let c = { fn {} }
+// fn(c)
+// }
+
+// Helper
+struct Frob {
+ mutating func outerMut() { doOne { innerMut() } }
+ mutating func innerMut() {}
+}
+
+// Allow nested mutable access via closures.
+func nestedNoEscape(f: inout Frob) {
+ doOne { f.outerMut() }
+}
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape14nestedNoEscape1fyAA4FrobVz_tF : $@convention(thin) (@inout Frob) -> () {
+// CHECK-NOT: begin_access
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape14nestedNoEscape1fyAA4FrobVz_tF'
+
+// closure #1 in nestedNoEscape(f:)
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape14nestedNoEscape1fyAA4FrobVz_tFyyXEfU_ : $@convention(thin) (@inout_aliasable Frob) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [static] %0 : $*Frob
+// CHECK: %{{.*}} = apply %{{.*}}([[ACCESS]]) : $@convention(method) (@inout Frob) -> ()
+// CHECK: end_access [[ACCESS]] : $*Frob
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape14nestedNoEscape1fyAA4FrobVz_tFyyXEfU_'
+
+// Allow aliased noescape reads.
+func readRead() {
+ var x = 3
+ // Inside each closure: [read] [static]
+ doTwo({ _ = x }, { _ = x })
+ x = 42
+}
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape8readReadyyF : $@convention(thin) () -> () {
+// CHECK: [[ALLOC:%.*]] = alloc_stack $Int, var, name "x"
+// CHECK-NOT: begin_access
+// CHECK: apply
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape8readReadyyF'
+
+// closure #1 in readRead()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape8readReadyyFyyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK-NOT: begin_access [read] [dynamic]
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape8readReadyyFyyXEfU_'
+
+// closure #2 in readRead()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape8readReadyyFyyXEfU0_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK-NOT: begin_access [read] [dynamic]
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape8readReadyyFyyXEfU0_'
+
+// Allow aliased noescape reads of an `inout` arg.
+func inoutReadRead(x: inout Int) {
+ // Inside each closure: [read] [static]
+ doTwo({ _ = x }, { _ = x })
+}
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape09inoutReadE01xySiz_tF : $@convention(thin) (@inout Int) -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT1:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[PA2:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT2:%.*]] = convert_escape_to_noescape [[PA2]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK-NOT: begin_access
+// CHECK: apply %{{.*}}([[CVT1]], [[CVT2]])
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape09inoutReadE01xySiz_tF'
+
+// closure #1 in inoutReadRead(x:)
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape09inoutReadE01xySiz_tFyyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK-NOT: begin_access [read] [dynamic]
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape09inoutReadE01xySiz_tFyyXEfU_'
+
+// closure #2 in inoutReadRead(x:)
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape09inoutReadE01xySiz_tFyyXEfU0_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK-NOT: begin_access [read] [dynamic]
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape09inoutReadE01xySiz_tFyyXEfU0_'
+
+// Allow aliased noescape read + boxed read.
+func readBoxRead() {
+ var x = 3
+ let c = { _ = x }
+ // Inside may-escape closure `c`: [read] [dynamic]
+ // Inside never-escape closure: [read] [dynamic]
+ doTwo(c, { _ = x })
+ x = 42
+}
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape11readBoxReadyyF : $@convention(thin) () -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT1:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[PA2:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT2:%.*]] = convert_escape_to_noescape [[PA2]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK-NOT: begin_access
+// CHECK: apply %{{.*}}([[CVT1]], [[CVT2]])
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape11readBoxReadyyF'
+
+// closure #1 in readBoxRead()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape11readBoxReadyyFyycfU_ : $@convention(thin) (@guaranteed { var Int }) -> () {
+// CHECK: [[ADDR:%.*]] = project_box %0 : ${ var Int }, 0
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [dynamic] [[ADDR]] : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape11readBoxReadyyFyycfU_'
+
+// closure #2 in readBoxRead()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape11readBoxReadyyFyyXEfU0_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [dynamic] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape11readBoxReadyyFyyXEfU0_'
+
+// Error: cannout capture inout.
+//
+// func inoutReadReadBox(x: inout Int) {
+// let c = { _ = x }
+// doTwo({ _ = x }, c)
+// }
+
+// Allow aliased noescape read + write.
+func readWrite() {
+ var x = 3
+ // Inside closure 1: [read] [static]
+ // Inside closure 2: [modify] [static]
+ doTwo({ _ = x }, { x = 42 })
+}
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape9readWriteyyF : $@convention(thin) () -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT1:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[PA2:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT2:%.*]] = convert_escape_to_noescape [[PA2]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK-NOT: begin_access
+// CHECK: apply %{{.*}}([[CVT1]], [[CVT2]])
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape9readWriteyyF'
+
+// closure #1 in readWrite()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape9readWriteyyFyyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK-NOT: [[ACCESS:%.*]] = begin_access [read] [dynamic]
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape9readWriteyyFyyXEfU_'
+
+// closure #2 in readWrite()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape9readWriteyyFyyXEfU0_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK-NOT: [[ACCESS:%.*]] = begin_access [modify] [dynamic]
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape9readWriteyyFyyXEfU0_'
+
+// Allow aliased noescape read + write of an `inout` arg.
+func inoutReadWrite(x: inout Int) {
+ // Inside closure 1: [read] [static]
+ // Inside closure 2: [modify] [static]
+ doTwo({ _ = x }, { x = 3 })
+}
+
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape14inoutReadWrite1xySiz_tF : $@convention(thin) (@inout Int) -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT1:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[PA2:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT2:%.*]] = convert_escape_to_noescape [[PA2]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: apply %{{.*}}([[CVT1]], [[CVT2]])
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape14inoutReadWrite1xySiz_tF'
+
+// closure #1 in inoutReadWrite(x:)
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape14inoutReadWrite1xySiz_tFyyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape14inoutReadWrite1xySiz_tFyyXEfU_'
+
+// closure #2 in inoutReadWrite(x:)
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape14inoutReadWrite1xySiz_tFyyXEfU0_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape14inoutReadWrite1xySiz_tFyyXEfU0_'
+
+
+func readBoxWrite() {
+ var x = 3
+ let c = { _ = x }
+ // Inside may-escape closure `c`: [read] [dynamic]
+ // Inside never-escape closure: [modify] [dynamic]
+ doTwo(c, { x = 42 })
+}
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape12readBoxWriteyyF : $@convention(thin) () -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT1:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[PA2:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT2:%.*]] = convert_escape_to_noescape [[PA2]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK-NOT: begin_access
+// CHECK: apply %{{.*}}([[CVT1]], [[CVT2]])
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape12readBoxWriteyyF'
+
+// closure #1 in readBoxWrite()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape12readBoxWriteyyFyycfU_ : $@convention(thin) (@guaranteed { var Int }) -> () {
+// CHECK: [[ADDR:%.*]] = project_box %0 : ${ var Int }, 0
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [dynamic] [[ADDR]] : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape12readBoxWriteyyFyycfU_'
+
+// closure #2 in readBoxWrite()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape12readBoxWriteyyFyyXEfU0_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [dynamic] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape12readBoxWriteyyFyyXEfU0_'
+
+// Error: cannout capture inout.
+// func inoutReadBoxWrite(x: inout Int) {
+// let c = { _ = x }
+// doTwo({ x = 42 }, c)
+// }
+
+func readWriteBox() {
+ var x = 3
+ let c = { x = 42 }
+ // Inside may-escape closure `c`: [modify] [dynamic]
+ // Inside never-escape closure: [read] [dynamic]
+ doTwo({ _ = x }, c)
+}
+
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape12readWriteBoxyyF : $@convention(thin) () -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[PA2:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT2:%.*]] = convert_escape_to_noescape [[PA2]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[CVT1:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK-NOT: begin_access
+// CHECK: apply %{{.*}}([[CVT2]], [[CVT1]])
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape12readWriteBoxyyF'
+
+// closure #1 in readWriteBox()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape12readWriteBoxyyFyycfU_ : $@convention(thin) (@guaranteed { var Int }) -> () {
+// CHECK: [[ADDR:%.*]] = project_box %0 : ${ var Int }, 0
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [dynamic] [[ADDR]] : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape12readWriteBoxyyFyycfU_'
+
+// closure #2 in readWriteBox()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape12readWriteBoxyyFyyXEfU0_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [dynamic] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape12readWriteBoxyyFyyXEfU0_'
+
+// Error: cannout capture inout.
+// func inoutReadWriteBox(x: inout Int) {
+// let c = { x = 42 }
+// doTwo({ _ = x }, c)
+// }
+
+// Error: noescape read + write inout.
+func readWriteInout() {
+ var x = 3
+ // Around the call: [modify] [static]
+ // Inside closure: [modify] [static]
+ // expected-error@+2{{overlapping accesses to 'x', but modification requires exclusive access; consider copying to a local variable}}
+ // expected-note@+1{{conflicting access is here}}
+ doOneInout({ _ = x }, &x)
+}
+
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape14readWriteInoutyyF : $@convention(thin) () -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[ACCESS2:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: apply %{{.*}}([[CVT]], [[ACCESS2]])
+// CHECK: end_access [[ACCESS2]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape14readWriteInoutyyF'
+
+// closure #1 in readWriteInout()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape14readWriteInoutyyFyyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape14readWriteInoutyyFyyXEfU_'
+
+// Error: noescape read + write inout of an inout.
+func inoutReadWriteInout(x: inout Int) {
+ // Around the call: [modify] [static]
+ // Inside closure: [modify] [static]
+ // expected-error@+2{{overlapping accesses to 'x', but modification requires exclusive access; consider copying to a local variable}}
+ // expected-note@+1{{conflicting access is here}}
+ doOneInout({ _ = x }, &x)
+}
+
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape19inoutReadWriteInout1xySiz_tF : $@convention(thin) (@inout Int) -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[ACCESS2:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: apply %{{.*}}([[CVT]], [[ACCESS2]])
+// CHECK: end_access [[ACCESS2]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape19inoutReadWriteInout1xySiz_tF'
+
+// closure #1 in inoutReadWriteInout(x:)
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape19inoutReadWriteInout1xySiz_tFyyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape19inoutReadWriteInout1xySiz_tFyyXEfU_'
+
+// Traps on boxed read + write inout.
+// Covered by Interpreter/enforce_exclusive_access.swift.
+func readBoxWriteInout() {
+ var x = 3
+ let c = { _ = x }
+ // Around the call: [modify] [dynamic]
+ // Inside closure: [read] [dynamic]
+ doOneInout(c, &x)
+}
+
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape17readBoxWriteInoutyyF : $@convention(thin) () -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [dynamic] %1 : $*Int
+// CHECK: apply %{{.*}}([[CVT]], [[ACCESS]])
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape17readBoxWriteInoutyyF'
+
+// closure #1 in readBoxWriteInout()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape17readBoxWriteInoutyyFyycfU_ : $@convention(thin) (@guaranteed { var Int }) -> () {
+// CHECK: [[ADDR:%.*]] = project_box %0 : ${ var Int }, 0
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [dynamic] [[ADDR]] : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape17readBoxWriteInoutyyFyycfU_'
+
+// Error: inout cannot be captured.
+// This triggers an early diagnostics, so it's handled in inout_capture_disgnostics.swift.
+// func inoutReadBoxWriteInout(x: inout Int) {
+// let c = { _ = x }
+// doOneInout(c, &x)
+// }
+
+// Allow aliased noescape write + write.
+func writeWrite() {
+ var x = 3
+ // Inside closure 1: [modify] [static]
+ // Inside closure 2: [modify] [static]
+ doTwo({ x = 42 }, { x = 87 })
+ _ = x
+}
+
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape10writeWriteyyF : $@convention(thin) () -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT1:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[PA2:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT2:%.*]] = convert_escape_to_noescape [[PA2]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK-NOT: begin_access
+// CHECK: apply %{{.*}}([[CVT1]], [[CVT2]])
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape10writeWriteyyF'
+
+// closure #1 in writeWrite()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape10writeWriteyyFyyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape10writeWriteyyFyyXEfU_'
+
+// closure #2 in writeWrite()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape10writeWriteyyFyyXEfU0_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape10writeWriteyyFyyXEfU0_'
+
+
+// Allow aliased noescape write + write of an `inout` arg.
+func inoutWriteWrite(x: inout Int) {
+ // Inside closure 1: [modify] [static]
+ // Inside closure 2: [modify] [static]
+ doTwo({ x = 42}, { x = 87 })
+}
+
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape010inoutWriteE01xySiz_tF : $@convention(thin) (@inout Int) -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT1:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[PA2:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT2:%.*]] = convert_escape_to_noescape [[PA2]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK-NOT: begin_access
+// CHECK: apply %{{.*}}([[CVT1]], [[CVT2]])
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape010inoutWriteE01xySiz_tF'
+
+// closure #1 in inoutWriteWrite(x:)
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape010inoutWriteE01xySiz_tFyyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape010inoutWriteE01xySiz_tFyyXEfU_'
+
+// closure #2 in inoutWriteWrite(x:)
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape010inoutWriteE01xySiz_tFyyXEfU0_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape010inoutWriteE01xySiz_tFyyXEfU0_'
+
+// Traps on aliased boxed write + noescape write.
+// Covered by Interpreter/enforce_exclusive_access.swift.
+func writeWriteBox() {
+ var x = 3
+ let c = { x = 87 }
+ // Inside may-escape closure `c`: [modify] [dynamic]
+ // Inside never-escape closure: [modify] [dynamic]
+ doTwo({ x = 42 }, c)
+ _ = x
+}
+
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape13writeWriteBoxyyF : $@convention(thin) () -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[PA2:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT2:%.*]] = convert_escape_to_noescape [[PA2]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[CVT1:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK-NOT: begin_access
+// CHECK: apply %{{.*}}([[CVT2]], [[CVT1]])
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape13writeWriteBoxyyF'
+
+// closure #1 in writeWriteBox()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape13writeWriteBoxyyFyycfU_ : $@convention(thin) (@guaranteed { var Int }) -> () {
+// CHECK: [[ADDR:%.*]] = project_box %0 : ${ var Int }, 0
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [dynamic] [[ADDR]] : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape13writeWriteBoxyyFyycfU_'
+
+// closure #2 in writeWriteBox()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape13writeWriteBoxyyFyyXEfU0_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [dynamic] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape13writeWriteBoxyyFyyXEfU0_'
+
+// Error: inout cannot be captured.
+// func inoutWriteWriteBox(x: inout Int) {
+// let c = { x = 87 }
+// doTwo({ x = 42 }, c)
+// }
+
+// Error: on noescape write + write inout.
+func writeWriteInout() {
+ var x = 3
+ // Around the call: [modify] [static]
+ // Inside closure: [modify] [static]
+ // expected-error@+2{{overlapping accesses to 'x', but modification requires exclusive access; consider copying to a local variable}}
+ // expected-note@+1{{conflicting access is here}}
+ doOneInout({ x = 42 }, &x)
+}
+
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape15writeWriteInoutyyF : $@convention(thin) () -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[ACCESS2:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: apply %{{.*}}([[CVT]], [[ACCESS2]])
+// CHECK: end_access [[ACCESS2]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape15writeWriteInoutyyF'
+
+// closure #1 in writeWriteInout()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape15writeWriteInoutyyFyyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape15writeWriteInoutyyFyyXEfU_'
+
+// Error: on noescape write + write inout.
+func inoutWriteWriteInout(x: inout Int) {
+ // Around the call: [modify] [static]
+ // Inside closure: [modify] [static]
+ // expected-error@+2{{overlapping accesses to 'x', but modification requires exclusive access; consider copying to a local variable}}
+ // expected-note@+1{{conflicting access is here}}
+ doOneInout({ x = 42 }, &x)
+}
+
+// inoutWriteWriteInout(x:)
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape010inoutWriteE5Inout1xySiz_tF : $@convention(thin) (@inout Int) -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[ACCESS2:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: apply %{{.*}}([[CVT]], [[ACCESS2]])
+// CHECK: end_access [[ACCESS2]]
+// CHECK-LABEL: // end sil function '$S27access_enforcement_noescape010inoutWriteE5Inout1xySiz_tF'
+
+// closure #1 in inoutWriteWriteInout(x:)
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape010inoutWriteE5Inout1xySiz_tFyyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape010inoutWriteE5Inout1xySiz_tFyyXEfU_'
+
+// Traps on boxed write + write inout.
+// Covered by Interpreter/enforce_exclusive_access.swift.
+func writeBoxWriteInout() {
+ var x = 3
+ let c = { x = 42 }
+ // Around the call: [modify] [dynamic]
+ // Inside closure: [modify] [dynamic]
+ doOneInout(c, &x)
+}
+
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape18writeBoxWriteInoutyyF : $@convention(thin) () -> () {
+// CHECK: [[PA1:%.*]] = partial_apply [callee_guaranteed]
+// CHECK: [[CVT:%.*]] = convert_escape_to_noescape [[PA1]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [dynamic] %1 : $*Int
+// CHECK: apply %{{.*}}([[CVT]], [[ACCESS]])
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape18writeBoxWriteInoutyyF'
+
+// closure #1 in writeBoxWriteInout()
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape18writeBoxWriteInoutyyFyycfU_ : $@convention(thin) (@guaranteed { var Int }) -> () {
+// CHECK: [[ADDR:%.*]] = project_box %0 : ${ var Int }, 0
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [dynamic] [[ADDR]] : $*Int
+// CHECK: end_access [[ACCESS]]
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape18writeBoxWriteInoutyyFyycfU_'
+
+// Error: Cannot capture inout
+// This triggers an early diagnostics, so it's handled in inout_capture_disgnostics.swift.
+// func inoutWriteBoxWriteInout(x: inout Int) {
+// let c = { x = 42 }
+// doOneInout(c, &x)
+// }
+
+// Helper
+func doBlockInout(_: @convention(block) ()->(), _: inout Int) {}
+
+func readBlockWriteInout() {
+ var x = 3
+ // Around the call: [modify] [static]
+ // Inside closure: [read] [static]
+ // expected-warning@+2{{overlapping accesses to 'x', but modification requires exclusive access; consider copying to a local variable}}
+ // expected-note@+1{{conflicting access is here}}
+ doBlockInout({ _ = x }, &x)
+}
+
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape19readBlockWriteInoutyyF : $@convention(thin) () -> () {
+// CHECK: [[F1:%.*]] = function_ref @$S27access_enforcement_noescape19readBlockWriteInoutyyFyyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> ()
+// CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[F1]](%0) : $@convention(thin) (@inout_aliasable Int) -> ()
+// CHECK-NOT: begin_access
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: apply
+// CHECK: end_access [[WRITE]] : $*Int
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape19readBlockWriteInoutyyF'
+
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape19readBlockWriteInoutyyFyyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: begin_access [read] [static] %0 : $*Int
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape19readBlockWriteInoutyyFyyXEfU_'
+
+// Test AccessSummaryAnalysis.
+//
+// The captured @inout_aliasable argument to `doOne` is re-partially applied,
+// then stored is a box before passing it to doBlockInout.
+func noEscapeBlock() {
+ var x = 3
+ doOne {
+ // expected-warning@+2{{overlapping accesses to 'x', but modification requires exclusive access; consider copying to a local variable}}
+ // expected-note@+1{{conflicting access is here}}
+ doBlockInout({ _ = x }, &x)
+ }
+}
+// CHECK-LABEL: sil hidden @$S27access_enforcement_noescape13noEscapeBlockyyF : $@convention(thin) () -> () {
+// CHECK: partial_apply [callee_guaranteed]
+// CHECK-NOT: begin_access
+// CHECK: apply
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape13noEscapeBlockyyF'
+
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape13noEscapeBlockyyFyyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: [[F1:%.*]] = function_ref @$S27access_enforcement_noescape13noEscapeBlockyyFyyXEfU_yyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> ()
+// CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] [[F1]](%0) : $@convention(thin) (@inout_aliasable Int) -> ()
+// CHECK: [[CVT:%.*]] = convert_escape_to_noescape [[PA]] : $@callee_guaranteed () -> () to $@noescape @callee_guaranteed () -> ()
+// CHECK: [[STORAGE:%.*]] = alloc_stack $@block_storage @noescape @callee_guaranteed () -> ()
+// CHECK: [[ADDR:%.*]] = project_block_storage [[STORAGE]] : $*@block_storage @noescape @callee_guaranteed () -> ()
+// CHECK: store [[CVT]] to [[ADDR]] : $*@noescape @callee_guaranteed () -> ()
+// CHECK: [[F2:%.*]] = function_ref @$SIg_IyB_TR : $@convention(c) (@inout_aliasable @block_storage @noescape @callee_guaranteed () -> ()) -> ()
+// CHECK: [[BLOCK:%.*]] = init_block_storage_header [[STORAGE]] : $*@block_storage @noescape @callee_guaranteed () -> (), invoke [[F2]] : $@convention(c) (@inout_aliasable @block_storage @noescape @callee_guaranteed () -> ()) -> (), type $@convention(block) @noescape () -> ()
+// CHECK: [[ARG:%.*]] = copy_block [[BLOCK]] : $@convention(block) @noescape () -> ()
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [static] %0 : $*Int
+// CHECK: apply %{{.*}}([[ARG]], [[WRITE]]) : $@convention(thin) (@guaranteed @convention(block) @noescape () -> (), @inout Int) -> ()
+// CHECK: end_access [[WRITE]] : $*Int
+// CHECK: dealloc_stack [[STORAGE]] : $*@block_storage @noescape @callee_guaranteed () -> ()
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape13noEscapeBlockyyFyyXEfU_'
+
+// CHECK-LABEL: sil private @$S27access_enforcement_noescape13noEscapeBlockyyFyyXEfU_yyXEfU_ : $@convention(thin) (@inout_aliasable Int) -> () {
+// CHECK: begin_access [read] [static] %0 : $*Int
+// CHECK-LABEL: } // end sil function '$S27access_enforcement_noescape13noEscapeBlockyyFyyXEfU_yyXEfU_'
diff --git a/test/SILOptimizer/plus_zero_access_marker_mandatory.swift b/test/SILOptimizer/plus_zero_access_marker_mandatory.swift
new file mode 100644
index 0000000..dde3001
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_access_marker_mandatory.swift
@@ -0,0 +1,86 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -parse-as-library -Xllvm -sil-full-demangle -emit-sil -Onone -enforce-exclusivity=checked %s | %FileCheck %s
+
+public struct S {
+ var i: Int
+ var o: AnyObject
+}
+
+// CHECK-LABEL: sil [noinline] @$S23access_marker_mandatory5initSyAA1SVSi_yXltF : $@convention(thin) (Int, @guaranteed AnyObject) -> @owned S {
+// CHECK: bb0(%0 : $Int, %1 : $AnyObject):
+// CHECK: [[STK:%.*]] = alloc_stack $S, var, name "s"
+// CHECK: cond_br %{{.*}}, bb1, bb2
+// CHECK: bb1:
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [static] [[STK]] : $*S
+// CHECK: store %{{.*}} to [[WRITE]] : $*S
+// CHECK: end_access [[WRITE]]
+// CHECK: bb2:
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [static] [[STK]] : $*S
+// CHECK: store %{{.*}} to [[WRITE]] : $*S
+// CHECK: end_access [[WRITE]]
+// CHECK: bb3:
+// CHECK: [[READ:%.*]] = begin_access [read] [static] [[STK]] : $*S
+// CHECK: [[RET:%.*]] = load [[READ]] : $*S
+// CHECK: end_access [[READ]]
+// CHECK: destroy_addr [[STK]]
+// CHECK: dealloc_stack [[STK]]
+// CHECK: return [[RET]] : $S
+// CHECK-LABEL: } // end sil function '$S23access_marker_mandatory5initSyAA1SVSi_yXltF'
+@inline(never)
+public func initS(_ x: Int, _ o: AnyObject) -> S {
+ var s: S
+ if x == 0 {
+ s = S(i: 1, o: o)
+ } else {
+ s = S(i: x, o: o)
+ }
+ return s
+}
+
+@inline(never)
+func takeS(_ s: S) {}
+
+// CHECK-LABEL: sil @$S23access_marker_mandatory14modifyAndReadS1oyyXl_tF : $@convention(thin) (@guaranteed AnyObject) -> () {
+// CHECK: bb0(%0 : $AnyObject):
+// CHECK: [[STK:%.*]] = alloc_stack $S, var, name "s"
+// CHECK: [[FINIT:%.*]] = function_ref @$S23access_marker_mandatory5initSyAA1SVSi_yXltF : $@convention(thin) (Int, @guaranteed AnyObject) -> @owned S
+// CHECK: [[INITS:%.*]] = apply [[FINIT]](%{{.*}}, %0) : $@convention(thin) (Int, @guaranteed AnyObject) -> @owned S
+// CHECK: store [[INITS]] to [[STK]] : $*S
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [static] [[STK]] : $*S
+// CHECK: [[ADDRI:%.*]] = struct_element_addr [[WRITE]] : $*S, #S.i
+// CHECK: store %{{.*}} to [[ADDRI]] : $*Int
+// CHECK: end_access [[WRITE]]
+// CHECK: [[READ:%.*]] = begin_access [read] [static] [[STK]] : $*S
+// CHECK: end_access [[READ]]
+// CHECK: [[FTAKE:%.*]] = function_ref @$S23access_marker_mandatory5takeSyyAA1SVF : $@convention(thin) (@guaranteed S) -> ()
+// CHECK: apply [[FTAKE]](%{{.*}}) : $@convention(thin) (@guaranteed S) -> ()
+// CHECK-LABEL: } // end sil function '$S23access_marker_mandatory14modifyAndReadS1oyyXl_tF'
+public func modifyAndReadS(o: AnyObject) {
+ var s = initS(3, o)
+ s.i = 42
+ takeS(s)
+}
+
+// Test capture promotion followed by stack promotion.
+// Access enforcement selection must run after capture promotion
+// so that we never stack promote something with dynamic access.
+// Otherwise, we may try to convert the access to [deinit] which
+// doesn't make sense dynamically.
+//
+// CHECK-LABEL: sil hidden @$S23access_marker_mandatory19captureStackPromoteSiycyF : $@convention(thin) () -> @owned @callee_guaranteed () -> Int {
+// CHECK-LABEL: bb0:
+// CHECK: [[STK:%.*]] = alloc_stack $Int, var, name "x"
+// CHECK: [[WRITE:%.*]] = begin_access [modify] [static] [[STK]] : $*Int
+// CHECK: store %{{.*}} to [[WRITE]] : $*Int
+// CHECK: end_access [[WRITE]] : $*Int
+// CHECK: [[F:%.*]] = function_ref @$S23access_marker_mandatory19captureStackPromoteSiycyFSiycfU_Tf2i_n : $@convention(thin) (Int) -> Int
+// CHECK: [[C:%.*]] = partial_apply [callee_guaranteed] [[F]](%{{.*}}) : $@convention(thin) (Int) -> Int
+// CHECK: dealloc_stack [[STK]] : $*Int
+// CHECK: return [[C]] : $@callee_guaranteed () -> Int
+// CHECK-LABEL: } // end sil function '$S23access_marker_mandatory19captureStackPromoteSiycyF'
+func captureStackPromote() -> () -> Int {
+ var x = 1
+ x = 2
+ let f = { x }
+ return f
+}
diff --git a/test/SILOptimizer/plus_zero_access_marker_verify.swift b/test/SILOptimizer/plus_zero_access_marker_verify.swift
new file mode 100644
index 0000000..f24f230
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_access_marker_verify.swift
@@ -0,0 +1,1000 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-verify-exclusivity -enforce-exclusivity=checked -enable-sil-ownership -emit-silgen -swift-version 4 -parse-as-library %s | %FileCheck %s
+// RUN: %target-swift-frontend -enable-verify-exclusivity -enforce-exclusivity=checked -enable-sil-ownership -Onone -emit-sil -swift-version 4 -parse-as-library %s
+// RUN: %target-swift-frontend -enable-verify-exclusivity -enforce-exclusivity=checked -enable-sil-ownership -O -emit-sil -swift-version 4 -parse-as-library %s
+// REQUIRES: asserts
+
+// Test the combination of SILGen + DiagnoseStaticExclusivity with verification.
+//
+// This is a collection of tests that cover SILGen cases that require special
+// handling for exclusivity verification. SILGen must generate access markers,
+// possibly unenforced, to satisfy the verification run during the
+// DiagnoseStaticExclusivity pass.
+//
+// These cases are mostly covered by existing SILGen tests, but need to be
+// repeated here to ensure they are run with exclusivity verification enabled.
+import SwiftShims
+
+protocol P {}
+struct StructP : P {}
+
+protocol PBar {
+ func bar()
+}
+
+class BaseClass {
+ init() {}
+}
+class SubClass : BaseClass {
+ override required init() {}
+}
+
+enum E {
+case V(Int)
+}
+
+func takesClosure(_ f: () -> ()) {
+ f()
+}
+
+// --- struct initialization.
+struct StructOfInt {
+ var i: Int
+
+ init() {
+ i = 1
+ }
+
+ mutating func changeMe() {
+ i = 3
+ }
+}
+// The verifier ignores the load of the self box.
+// CHECK-LABEL: sil hidden @$S20access_marker_verify11StructOfIntVACycfC : $@convention(method) (@thin StructOfInt.Type) -> StructOfInt {
+// CHECK: bb0(%0 : @trivial $@thin StructOfInt.Type):
+// CHECK: [[BOX:%.*]] = alloc_box ${ var StructOfInt }, var, name "self"
+// CHECK: [[UNINIT:%.*]] = mark_uninitialized [rootself] [[BOX]] : ${ var StructOfInt }
+// CHECK: [[PROJ:%.*]] = project_box [[UNINIT]] : ${ var StructOfInt }, 0
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [unknown] [[PROJ]] : $*StructOfInt
+// CHECK: [[ADR:%.*]] = struct_element_addr [[ACCESS]] : $*StructOfInt, #StructOfInt.i
+// CHECK: assign %{{.*}} to [[ADR]] : $*Int
+// CHECK: end_access [[ACCESS]] : $*StructOfInt
+// CHECK-NOT: begin_access
+// CHECK: [[VAL:%.*]] = load [trivial] [[PROJ]] : $*StructOfInt
+// CHECK: destroy_value [[UNINIT]] : ${ var StructOfInt }
+// CHECK: return [[VAL]] : $StructOfInt
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify11StructOfIntVACycfC'
+
+// --- class initialization.
+class SuperHasInt {
+ var i: Int
+
+ init() {
+ i = 3
+ }
+}
+
+class SubHasInt : SuperHasInt {
+ var j: Int
+
+ override init() {
+ j = 4
+ super.init()
+ }
+
+ init(x: Int) {
+ j = x
+ super.init()
+ }
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify11SuperHasIntCACycfc : $@convention(method) (@owned SuperHasInt) -> @owned SuperHasInt {
+// CHECK: bb0(%0 : @owned $SuperHasInt):
+// CHECK: [[UNINIT:%.*]] = mark_uninitialized [rootself] %0 : $SuperHasInt
+// CHECK: [[BORROW:%.*]] = begin_borrow [[UNINIT]] : $SuperHasInt
+// CHECK: [[ADR:%.*]] = ref_element_addr [[BORROW]] : $SuperHasInt, #SuperHasInt.i
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [dynamic] [[ADR]] : $*Int
+// CHECK: assign %{{.*}} to [[ACCESS]] : $*Int
+// CHECK: end_access [[ACCESS]] : $*Int
+// CHECK: end_borrow [[BORROW]] from [[UNINIT]] : $SuperHasInt, $SuperHasInt
+// CHECK-NOT: begin_access
+// CHECK: [[VAL:%.*]] = copy_value [[UNINIT]] : $SuperHasInt
+// CHECK: destroy_value [[UNINIT]] : $SuperHasInt
+// CHECK: return [[VAL]] : $SuperHasInt
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify11SuperHasIntCACycfc'
+
+// CHECK-LABEL: sil hidden @$S20access_marker_verify9SubHasIntCACycfc : $@convention(method) (@owned SubHasInt) -> @owned SubHasInt {
+// CHECK: bb0(%0 : @owned $SubHasInt):
+// CHECK: [[BOX:%.*]] = alloc_box ${ var SubHasInt }, let, name "self"
+// CHECK: [[UNINIT:%.*]] = mark_uninitialized [derivedself] [[BOX]] : ${ var SubHasInt }
+// CHECK: [[PROJ:%.*]] = project_box [[UNINIT]] : ${ var SubHasInt }, 0
+// CHECK-NOT: begin_access
+// CHECK: store %0 to [init] [[PROJ]] : $*SubHasInt
+// CHECK-NOT: begin_access
+// CHECK: [[BORROW:%.*]] = load_borrow [[PROJ]] : $*SubHasInt
+// CHECK: [[ADR:%.*]] = ref_element_addr [[BORROW]] : $SubHasInt, #SubHasInt.j
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [dynamic] [[ADR]] : $*Int
+// CHECK: assign %{{.*}} to [[ACCESS]] : $*Int
+// CHECK: end_access [[ACCESS]] : $*Int
+// CHECK: end_borrow [[BORROW]] from [[PROJ]] : $SubHasInt, $*SubHasInt
+// CHECK-NOT: begin_access
+// CHECK: load [take] [[PROJ]] : $*SubHasInt
+// CHECK: upcast %{{.*}} : $SubHasInt to $SuperHasInt
+// CHECK: function_ref @$S20access_marker_verify11SuperHasIntCACycfc : $@convention(method) (@owned SuperHasInt) -> @owned SuperHasInt
+// CHECK: apply
+// CHECK: unchecked_ref_cast %{{.*}} : $SuperHasInt to $SubHasInt
+// CHECK-NOT: begin_access
+// CHECK: store %{{.*}} to [init] [[PROJ]] : $*SubHasInt
+// CHECK: [[VAL:%.*]] = load [copy] [[PROJ]] : $*SubHasInt
+// CHECK: destroy_value [[UNINIT]] : ${ var SubHasInt }
+// CHECK: return [[VAL]] : $SubHasInt
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify9SubHasIntCACycfc'
+
+// CHECK-LABEL: sil hidden @$S20access_marker_verify9SubHasIntC1xACSi_tcfc : $@convention(method) (Int, @owned SubHasInt) -> @owned SubHasInt {
+// CHECK: bb0(%0 : @trivial $Int, %1 : @owned $SubHasInt):
+// CHECK: [[BOX:%.*]] = alloc_box ${ var SubHasInt }, let, name "self"
+// CHECK: [[UNINIT:%.*]] = mark_uninitialized [derivedself] [[BOX]] : ${ var SubHasInt }
+// CHECK: [[PROJ:%.*]] = project_box [[UNINIT]] : ${ var SubHasInt }, 0
+// CHECK-NOT: begin_access
+// CHECK: store %{{.*}} to [init] [[PROJ]] : $*SubHasInt
+// CHECK-NOT: begin_access
+// CHECK: [[BORROW:%.*]] = load_borrow [[PROJ]] : $*SubHasInt
+// CHECK: [[ADR:%.*]] = ref_element_addr [[BORROW]] : $SubHasInt, #SubHasInt.j
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [dynamic] [[ADR]] : $*Int
+// CHECK: assign %0 to [[ACCESS]] : $*Int
+// CHECK: end_access [[ACCESS]] : $*Int
+// CHECK: end_borrow [[BORROW]] from [[PROJ]] : $SubHasInt, $*SubHasInt
+// CHECK-NOT: begin_access
+// CHECK: load [take] [[PROJ]] : $*SubHasInt
+// CHECK: upcast %{{.*}} : $SubHasInt to $SuperHasInt
+// CHECK: function_ref @$S20access_marker_verify11SuperHasIntCACycfc : $@convention(method) (@owned SuperHasInt) -> @owned SuperHasInt
+// CHECK: apply
+// CHECK: unchecked_ref_cast %{{.*}} : $SuperHasInt to $SubHasInt
+// CHECK-NOT: begin_access
+// CHECK: store %{{.*}} to [init] [[PROJ]] : $*SubHasInt
+// CHECK: [[VAL:%.*]] = load [copy] [[PROJ]] : $*SubHasInt
+// CHECK: destroy_value [[UNINIT]] : ${ var SubHasInt }
+// CHECK: return [[VAL]] : $SubHasInt
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify9SubHasIntC1xACSi_tcfc'
+
+// --- access `let` property.
+class LetClass {
+ let x = 3
+}
+
+// FIXME: should be a [unknown] access.
+//
+// CHECK-LABEL: sil hidden @$S20access_marker_verify10testGetLet1cSiAA0F5ClassC_tF : $@convention(thin) (@guaranteed LetClass) -> Int {
+// CHECK: bb0(%0 : @guaranteed $LetClass):
+// CHECK: ref_element_addr
+// CHECK: begin_access [read] [dynamic]
+// CHECK: load [trivial]
+// CHECK: end_access
+// CHECK: return
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify10testGetLet1cSiAA0F5ClassC_tF'
+func testGetLet(c: LetClass) -> Int {
+ return c.x
+}
+
+// --- initialize let property and superclass.
+struct IntWrapper {
+ var x: Int
+}
+
+final class SubWrapper : BaseClass {
+ let val: IntWrapper
+
+ init(_ val: IntWrapper) {
+ self.val = val
+ super.init()
+ }
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify10SubWrapperCyAcA03IntE0Vcfc : $@convention(method) (IntWrapper, @owned SubWrapper) -> @owned SubWrapper {
+// CHECK: bb0(%0 : @trivial $IntWrapper, %1 : @owned $SubWrapper):
+// CHECK: alloc_box ${ var SubWrapper }, let, name "self"
+// CHECK: mark_uninitialized [derivedself]
+// CHECK: project_box
+// CHECK-NOT: begin_access
+// CHECK: store %1 to [init]
+// CHECK-NOT: begin_access
+// CHECK: load_borrow
+// CHECK: ref_element_addr
+// CHECK: begin_access [modify] [dynamic]
+// CHECK: assign %0 to
+// CHECK: end_access
+// CHECK: end_borrow
+// CHECK-NOT: begin_access
+// CHECK: load [take]
+// CHECK-NOT: begin_access
+// CHECK: store %{{.*}} to [init]
+// CHECK: [[VAL:%.*]] = load [copy]
+// CHECK: destroy_value %{{.*}} : ${ var SubWrapper }
+// CHECK: return [[VAL]] : $SubWrapper
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify10SubWrapperCyAcA03IntE0Vcfc'
+
+// --- captured local.
+func testCaptureLocal() -> ()->() {
+ var x = 1
+ let f = { x = 3 }
+ _ = x
+ return f
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify16testCaptureLocalyycyF : $@convention(thin) () -> @owned @callee_guaranteed () -> () {
+// CHECK: bb0:
+// CHECK: alloc_box ${ var Int }, var, name "x"
+// CHECK: [[PROJ:%.*]] = project_box
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [unsafe] [[PROJ]] : $*Int
+// CHECK: store %{{.*}} to [trivial] [[ACCESS]]
+// CHECK: end_access
+// CHECK: [[CAPTURE:%.*]] = copy_value %0 : ${ var Int }
+// CHECK: partial_apply [callee_guaranteed] %{{.*}}([[CAPTURE]]) : $@convention(thin) (@guaranteed { var Int }) -> ()
+// CHECK: alloc_stack $Int
+// CHECK: [[UNINIT:%.*]] = mark_uninitialized [var]
+// CHECK: begin_access [read] [unknown] [[PROJ]]
+// CHECK: [[VAL:%.*]] = load [trivial]
+// CHECK: end_access
+// CHECK-NOT: begin_access
+// CHECK: assign [[VAL]] to [[UNINIT]] : $*Int
+// CHECK: return {{.*}} : $@callee_guaranteed () -> ()
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify16testCaptureLocalyycyF'
+
+// --- mutating struct.
+func testModifyS(_ arg: StructOfInt) -> StructOfInt {
+ var lhs: StructOfInt
+ lhs = arg
+ lhs.changeMe()
+ return lhs
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify11testModifySyAA11StructOfIntVADF : $@convention(thin) (StructOfInt) -> StructOfInt {
+// CHECK: bb0(%0 : @trivial $StructOfInt):
+// CHECK: alloc_box ${ var StructOfInt }, var, name "lhs"
+// CHECK: mark_uninitialized [var]
+// CHECK: project_box
+// CHECK: begin_access [modify] [unknown]
+// CHECK: assign
+// CHECK: end_access
+// CHECK: begin_access [modify] [unknown]
+// CHECK: function_ref @$S20access_marker_verify11StructOfIntV8changeMeyyF : $@convention(method) (@inout StructOfInt) -> ()
+// CHECK: apply
+// CHECK: end_access
+// CHECK: begin_access [read] [unknown]
+// CHECK: load [trivial]
+// CHECK: end_access
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify11testModifySyAA11StructOfIntVADF'
+
+// --- initialize LValue.
+protocol HasIntGetter {
+ var x: Int { get }
+}
+func testInitLValue(p: HasIntGetter) -> Int {
+ var x = p.x
+ return x
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify14testInitLValue1pSiAA12HasIntGetter_p_tF : $@convention(thin) (@in_guaranteed HasIntGetter) -> Int {
+// CHECK: bb0(%0 : @trivial $*HasIntGetter):
+// CHECK: alloc_box ${ var Int }, var, name "x"
+// CHECK: [[PROJ:%.*]] = project_box
+// CHECK: [[OPENED:%.*]] = open_existential_addr immutable_access %0
+// CHECK: [[X:%.*]] = alloc_stack $@opened
+// CHECK-NOT: begin_access
+// CHECK: copy_addr %{{.*}} to [initialization] [[X]] : $*@opened
+// CHECK: witness_method $@opened
+// CHECK: apply %{{.*}}<@opened("{{.*}}") HasIntGetter>([[X]]) : $@convention(witness_method: HasIntGetter) <τ_0_0 where τ_0_0 : HasIntGetter> (@in_guaranteed τ_0_0) -> Int
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [unsafe] [[PROJ]] : $*Int
+// CHECK: store %{{.*}} to [trivial] [[ACCESS]] : $*Int
+// CHECK: end_access
+// CHECK: destroy_addr
+// CHECK: dealloc_stack
+// CHECK: begin_access [read] [unknown] [[PROJ]]
+// CHECK: load [trivial]
+// CHECK: end_access
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify14testInitLValue1pSiAA12HasIntGetter_p_tF'
+
+// --- initialize let.
+func testCopyS(_ arg: StructOfInt) -> StructOfInt {
+ let lhs: StructOfInt
+ lhs = arg
+ return lhs
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify9testCopySyAA11StructOfIntVADF : $@convention(thin) (StructOfInt) -> StructOfInt {
+// CHECK: bb0(%0 : @trivial $StructOfInt):
+// CHECK: alloc_stack $StructOfInt, let, name "lhs"
+// CHECK: [[UNINIT:%.*]] = mark_uninitialized [var]
+// CHECK-NOT: begin_access
+// CHECK: assign %0 to [[UNINIT]] : $*StructOfInt
+// CHECK-NOT: begin_access
+// CHECK: %5 = load [trivial] [[UNINIT]] : $*StructOfInt
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify9testCopySyAA11StructOfIntVADF'
+
+// --- local var init (single buffer).
+func testLocalVarInit(_ arg: StructOfInt) -> Int {
+ var lhs = arg
+ return lhs.i
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify16testLocalVarInitySiAA11StructOfIntVF : $@convention(thin) (StructOfInt) -> Int {
+// CHECK: bb0(%0 : @trivial $StructOfInt):
+// CHECK: alloc_box ${ var StructOfInt }, var, name "lhs"
+// CHECK: [[BOX:%.*]] = project_box
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [unsafe] [[BOX]]
+// CHECK: store %0 to [trivial] [[ACCESS]]
+// CHECK: end_access
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify16testLocalVarInitySiAA11StructOfIntVF'
+
+// --- init generic enum
+enum GenericEnum<T> {
+case V(T)
+
+ init?(t: T) {
+ self = .V(t)
+ }
+}
+
+func testInitGenericEnum<T>(t: T) -> GenericEnum<T>? {
+ return GenericEnum(t: t)
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify11GenericEnumO1tACyxGSgx_tcfC : $@convention(method) <T> (@in T, @thin GenericEnum<T>.Type) -> @out Optional<GenericEnum<T>> {
+// CHECK: bb0(%0 : @trivial $*Optional<GenericEnum<T>>, %1 : @trivial $*T, %2 : @trivial $@thin GenericEnum<T>.Type):
+// CHECK: alloc_box $<τ_0_0> { var GenericEnum<τ_0_0> } <T>, var, name "self"
+// CHECK: mark_uninitialized [delegatingself] %3 : $<τ_0_0> { var GenericEnum<τ_0_0> } <T>
+// CHECK: [[PROJ:%.*]] = project_box
+// CHECK: [[STK:%.*]] = alloc_stack $GenericEnum<T>
+// CHECK: [[ADR1:%.*]] = init_enum_data_addr [[STK]]
+// CHECK-NOT: begin_access
+// CHECK: copy_addr %1 to [initialization] [[ADR1]] : $*T
+// CHECK: inject_enum_addr
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [unknown] [[PROJ]]
+// CHECK: copy_addr [take] %{{.*}} to [[ACCESS]] : $*GenericEnum<T>
+// CHECK: end_access [[ACCESS]] : $*GenericEnum<T>
+// CHECK: [[ADR2:%.*]] = init_enum_data_addr %0
+// CHECK-NOT: begin_access
+// CHECK: copy_addr %{{.*}} to [initialization] [[ADR2]] : $*GenericEnum<T>
+// CHECK: inject_enum_addr %0 : $*Optional<GenericEnum<T>>, #Optional.some!enumelt.1
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify11GenericEnumO1tACyxGSgx_tcfC'
+
+// -- initialize indirect enum.
+enum IndirectEnum {
+ indirect case V(Int)
+}
+
+func testIndirectEnum() -> IndirectEnum {
+ return IndirectEnum.V(3)
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify16testIndirectEnumAA0eF0OyF : $@convention(thin) () -> @owned IndirectEnum {
+// CHECK: bb0:
+// CHECK: alloc_box ${ var Int }
+// CHECK: [[PROJ:%.*]] = project_box
+// CHECK: apply
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [unsafe] [[PROJ]]
+// CHECK: store %{{.*}} to [trivial] [[ACCESS]] : $*Int
+// CHECK: end_access
+// CHECK: enum $IndirectEnum, #IndirectEnum.V!enumelt.1
+// CHECK: return
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify16testIndirectEnumAA0eF0OyF'
+
+// -- indirect enum with getter.
+enum IntEnum {
+ indirect case int(Int)
+
+ var getValue: Int {
+ switch self {
+ case .int(let x): return x
+ }
+ }
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify7IntEnumO8getValueSivg : $@convention(method) (@guaranteed IntEnum) -> Int {
+// CHECK: bb0(%0 : @guaranteed $IntEnum):
+// CHECK: switch_enum %{{.*}} : $IntEnum, case #IntEnum.int!enumelt.1: bb1
+// CHECK: bb1(%{{.*}} : @owned ${ var Int }):
+// CHECK: [[PROJ:%.*]] = project_box
+// CHECK-NOT: begin_access
+// CHECK: load [trivial] [[PROJ]] : $*Int
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify7IntEnumO8getValueSivg'
+
+// -- indirect enum reference.
+enum RefEnum {
+ indirect case ref(BaseClass)
+
+ var getValue: BaseClass {
+ switch self {
+ case .ref(let c): return c
+ }
+ }
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify7RefEnumO8getValueAA9BaseClassCvg : $@convention(method) (@guaranteed RefEnum) -> @owned BaseClass {
+// CHECK: bb0(%0 : @guaranteed $RefEnum):
+// CHECK: switch_enum %{{.*}} : $RefEnum, case #RefEnum.ref!enumelt.1: bb1
+// CHECK: bb1(%{{.*}} : @owned ${ var BaseClass }):
+// CHECK: [[PROJ:%.*]] = project_box %{{.*}} : ${ var BaseClass }, 0
+// CHECK-NOT: begin_access
+// CHECK: load_borrow [[PROJ]] : $*BaseClass
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify7RefEnumO8getValueAA9BaseClassCvg'
+
+// --- indirect enum pattern.
+func testEnumPattern(ie: IndirectEnum) -> Bool {
+ guard case .V(let kind) = ie else {
+ return false
+ }
+ _ = kind
+ return true
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify15testEnumPattern2ieSbAA08IndirectE0O_tF : $@convention(thin) (@guaranteed IndirectEnum) -> Bool {
+// CHECK: bb0(%0 : @guaranteed $IndirectEnum):
+// CHECK: switch_enum %{{.*}} : $IndirectEnum, case #IndirectEnum.V!enumelt.1: [[BBV:bb.*]], default bb
+// CHECK: [[BBV]](%{{.*}} : @owned ${ var Int }):
+// CHECK: [[PROJ:%.*]] = project_box
+// CHECK-NOT: begin_access
+// CHECK: load [trivial] [[PROJ]] : $*Int
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify15testEnumPattern2ieSbAA08IndirectE0O_tF'
+
+// --- enum LValue.
+struct StructOfEnum {
+ var e: E
+ var f: E
+}
+func enumLValueHelper(_: inout E, _: inout E) {}
+
+// CHECK-LABEL: sil hidden @$S20access_marker_verify14testEnumLValue1syAA08StructOfE0Vz_tF : $@convention(thin) (@inout StructOfEnum) -> () {
+// CHECK: bb0(%0 : @trivial $*StructOfEnum):
+// CHECK: begin_access [modify] [unknown] %0 : $*StructOfEnum
+// CHECK: struct_element_addr %2 : $*StructOfEnum, #StructOfEnum.e
+// CHECK: begin_access [modify] [unknown] %0 : $*StructOfEnum
+// CHECK: struct_element_addr %4 : $*StructOfEnum, #StructOfEnum.f
+// CHECK: function_ref @$S20access_marker_verify16enumLValueHelperyyAA1EOz_ADztF : $@convention(thin) (@inout E, @inout E) -> ()
+// CHECK: apply %6(%3, %5) : $@convention(thin) (@inout E, @inout E) -> ()
+// CHECK: end_access %4 : $*StructOfEnum
+// CHECK: end_access %2 : $*StructOfEnum
+// CHECK: %10 = tuple ()
+// CHECK: return %10 : $()
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify14testEnumLValue1syAA08StructOfE0Vz_tF'
+func testEnumLValue(s: inout StructOfEnum) {
+ enumLValueHelper(&s.e, &s.f)
+}
+
+// --- Optional access.
+func accessOptionalArray(_ dict : [Int : [Int]] = [:]) {
+ var dict = dict
+ dict[1]?.append(2)
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify0A13OptionalArrayyys10DictionaryVySiSaySiGGF : $@convention(thin) (@guaranteed Dictionary<Int, Array<Int>>) -> () {
+// CHECK: bb0(%0 : @guaranteed $Dictionary<Int, Array<Int>>):
+// CHECK: alloc_box ${ var Dictionary<Int, Array<Int>> }, var, name "dict"
+// CHECK: [[PROJ:%.*]] = project_box
+// ----- initialize the box.
+// CHECK: [[INITACCESS:%.*]] = begin_access [modify] [unsafe] [[PROJ]]
+// CHECK: store %{{.*}} to [init] [[INITACCESS]]
+// CHECK: end_access [[INITACCESS]]
+// ----- begin formal access for Dictionary.subscript.setter
+// CHECK: [[BOXACCESS:%.*]] = begin_access [modify] [unknown] [[PROJ]]
+// CHECK: [[TEMP:%.*]] = alloc_stack $Optional<Array<Int>>
+// CHECK: load_borrow [[BOXACCESS]] : $*Dictionary<Int, Array<Int>>
+// ----- Initialize some trivial temporaries.
+// CHECK: alloc_stack $Int
+// CHECK-NOT: begin_access
+// CHECK: store %{{.*}} to [trivial]
+// ----- Call Dictionary.subscript.getter.
+// CHECK-NOT: begin_access
+// CHECK: apply %{{.*}}<Int, [Int]>
+// ----- access the temporary array result of the getter
+// CHECK: [[TEMPACCESS:%.*]] = begin_access [modify] [unsafe] [[TEMP]]
+// CHECK: select_enum_addr [[TEMPACCESS]] : $*Optional<Array<Int>>, case #Optional.some!enumelt.1
+// CHECK: cond_br %{{.*}}, bb2, bb1
+//
+// CHECK: bb1:
+// CHECK: [[TEMPARRAY:%.*]] = load [copy] [[TEMPACCESS]]
+// CHECK: [[WRITEBACK:%.*]] = alloc_stack $Optional<Array<Int>>
+// CHECK-NOT: begin_access
+// CHECK: store [[TEMPARRAY]] to [init] [[WRITEBACK]]
+// CHECK: alloc_stack $Int
+// CHECK-NOT: begin_access
+// CHECK: store %{{.*}} to [trivial] %29 : $*Int
+// Call Dictionary.subscript.setter
+// CHECK: apply %{{.*}}<Int, [Int]>([[WRITEBACK]], %{{.*}}, [[BOXACCESS]]) : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@in Optional<τ_0_1>, @in τ_0_0, @inout Dictionary<τ_0_0, τ_0_1>) -> ()
+// CHECK: end_access [[TEMPACCESS]] : $*Optional<Array<Int>>
+// CHECK: end_access [[BOXACCESS]] : $*Dictionary<Int, Array<Int>>
+// CHECK: br
+//
+// CHECK: bb2:
+// CHECK-NOT: begin_access
+// CHECK: [[TEMPARRAYADR:%.*]] = unchecked_take_enum_data_addr [[TEMPACCESS]] : $*Optional<Array<Int>>, #Optional.some!enumelt.1
+// ----- call Array.append
+// CHECK: alloc_stack $Int
+// CHECK: store %{{.*}} to [trivial]
+// CHECK: function_ref @$SSa6appendyyxF : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @inout Array<τ_0_0>) -> ()
+// CHECK: apply %{{.*}}<Int>(%{{.*}}, [[TEMPARRAYADR]]) : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @inout Array<τ_0_0>) -> ()
+// CHECK: [[TEMPARRAYVAL:%.*]] = load [take] [[TEMPACCESS]] : $*Optional<Array<Int>>
+// CHECK: [[ARRAYCOPY:%.*]] = alloc_stack $Optional<Array<Int>>
+// CHECK: store [[TEMPARRAYVAL]] to [init] [[ARRAYCOPY]] : $*Optional<Array<Int>>
+// CHECK: alloc_stack $Int
+// CHECK: store %{{.*}} to [trivial]
+// ----- call Dictionary.subscript.setter
+// CHECK: apply %{{.*}}<Int, [Int]>([[ARRAYCOPY]], %{{.*}}, [[BOXACCESS]]) : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@in Optional<τ_0_1>, @in τ_0_0, @inout Dictionary<τ_0_0, τ_0_1>) -> ()
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify0A13OptionalArrayyys10DictionaryVySiSaySiGGF'
+
+// --- Optional map.
+enum OptionalWithMap<Wrapped> {
+ case none
+
+ case some(Wrapped)
+
+ init(_ some: Wrapped) { self = .some(some) }
+
+ func map<U>(
+ _ transform: (Wrapped) throws -> U
+ ) rethrows -> U? {
+ switch self {
+ case .some(let y):
+ return .some(try transform(y))
+ case .none:
+ return .none
+ }
+ }
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify15OptionalWithMapO3mapyqd__Sgqd__xKXEKlF : $@convention(method) <Wrapped><U> (@noescape @callee_guaranteed (@in_guaranteed Wrapped) -> (@out U, @error Error), @in_guaranteed OptionalWithMap<Wrapped>) -> (@out Optional<U>, @error Error) {
+// CHECK: bb0(%0 : @trivial $*Optional<U>, %1 : @trivial $@noescape @callee_guaranteed (@in_guaranteed Wrapped) -> (@out U, @error Error), %2 : @trivial $*OptionalWithMap<Wrapped>):
+// CHECK: [[STK:%.]] = alloc_stack $OptionalWithMap<Wrapped>
+// CHECK-NOT: begin_access
+// CHECK: copy_addr %2 to [initialization] [[STK]] : $*OptionalWithMap<Wrapped>
+// CHECK: switch_enum_addr [[STK]] : $*OptionalWithMap<Wrapped>, case #OptionalWithMap.some!enumelt.1: [[BBSOME:bb.*]], case #OptionalWithMap.none!enumelt: bb
+//
+// CHECK: [[BBSOME]]:
+// CHECK-NOT: begin_access
+// CHECK: [[ADR:%.*]] = unchecked_take_enum_data_addr [[STK]]
+// CHECK: alloc_stack $Wrapped, let, name "y"
+// CHECK-NOT: begin_access
+// CHECK: copy_addr [take] [[ADR]] to [initialization]
+// ----- call transform.
+// CHECK: try_apply
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify15OptionalWithMapO3mapyqd__Sgqd__xKXEKlF'
+
+// --- delegating initializer.
+struct DelegatingInit {
+ var i: Int
+ init(i: Int) {
+ self.i = i
+ }
+ init() {
+ self.init(i: 4)
+ }
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify14DelegatingInitV1iACSi_tcfC : $@convention(method) (Int, @thin DelegatingInit.Type) -> DelegatingInit {
+// CHECK: bb0(%0 : @trivial $Int, %1 : @trivial $@thin DelegatingInit.Type):
+// CHECK: alloc_box ${ var DelegatingInit }, var, name "self"
+// CHECK: mark_uninitialized [rootself] %2 : ${ var DelegatingInit }
+// CHECK: [[BOX:%.*]] = project_box
+// CHECK: begin_access [modify] [unknown]
+// CHECK: struct_element_addr
+// CHECK: assign
+// CHECK: end_access
+// CHECK-NOT: begin_access
+// CHECK: load [trivial] [[BOX]] : $*DelegatingInit
+// CHECK: destroy_value
+// CHECK: return %10 : $DelegatingInit
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify14DelegatingInitV1iACSi_tcfC'
+
+// --- addressor.
+func testAddressor(p: UnsafePointer<Int>) -> Int {
+ return p.pointee
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify13testAddressor1pSiSPySiG_tF : $@convention(thin) (UnsafePointer<Int>) -> Int {
+// CHECK: bb0(%0 : @trivial $UnsafePointer<Int>):
+// CHECK: apply
+// CHECK: struct_extract
+// CHECK: [[ADR:%.*]] = pointer_to_address
+// CHECK-NOT: begin_access
+// CHECK: load [trivial] [[ADR]] : $*Int
+// CHECK: return
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify13testAddressor1pSiSPySiG_tF'
+
+// --- shims.
+func testShims() -> UInt32 {
+ return _SwiftKeyPathBufferHeader_SizeMask
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify9testShimss6UInt32VyF : $@convention(thin) () -> UInt32 {
+// CHECK: bb0:
+// CHECK: [[GA:%.*]] = global_addr @_SwiftKeyPathBufferHeader_SizeMask : $*UInt32
+// CHECK-NOT: begin_access
+// CHECK: load [trivial] [[GA]] : $*UInt32
+// CHECK: return
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify9testShimss6UInt32VyF'
+
+// --- global variable initialization.
+var globalString1 = "⓪" // start non-empty
+// CHECK-LABEL: sil private @globalinit_33_{{.*}}_func0 : $@convention(c) () -> () {
+// CHECK: alloc_global @$S20access_marker_verify13globalString1SSvp
+// CHECK: [[GA:%.*]] = global_addr @$S20access_marker_verify13globalString1SSvp : $*String
+// CHECK: apply
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [unsafe] [[GA]] : $*String
+// CHECK: store %{{.*}} to [init] [[ACCESS]] : $*String
+// CHECK: end_access
+// CHECK-LABEL: } // end sil function 'globalinit_33_180BF7B9126DB0C8C6C26F15ACD01908_func0'
+
+var globalString2 = globalString1
+// CHECK-LABEL: sil private @globalinit_33_180BF7B9126DB0C8C6C26F15ACD01908_func1 : $@convention(c) () -> () {
+// CHECK: alloc_global @$S20access_marker_verify13globalString2SSvp
+// CHECK: [[GA:%.*]] = global_addr @$S20access_marker_verify13globalString2SSvp : $*String
+// CHECK: apply
+// CHECK: [[PTR:%.*]] = pointer_to_address
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [dynamic] [[PTR]] : $*String
+// CHECK-NOT: begin_access
+// CHECK: copy_addr [[ACCESS]] to [initialization] [[GA]] : $*String
+// CHECK: end_access [[ACCESS]] : $*String
+// CHECK-NOT: end_access
+// CHECK-LABEL: } // end sil function 'globalinit_33_180BF7B9126DB0C8C6C26F15ACD01908_func1'
+
+
+// --- getter.
+struct GenericStructWithGetter<T> {
+ var t: T
+ var val: Int
+
+ struct Value {
+ internal var val: Int
+
+ internal init(_ val: Int) { self.val = val }
+ }
+ var value : Value {
+ get { return Value(val) }
+ }
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify23GenericStructWithGetterV5valueAC5ValueVyx_Gvg : $@convention(method) <T> (@in_guaranteed GenericStructWithGetter<T>) -> GenericStructWithGetter<T>.Value {
+// CHECK: bb0(%0 : @trivial $*GenericStructWithGetter<T>):
+// CHECK: [[ADR:%.*]] = struct_element_addr %0 : $*GenericStructWithGetter<T>, #GenericStructWithGetter.val
+// CHECK-NOT: begin_access
+// CHECK: load [trivial] [[ADR]] : $*Int
+// CHECK: apply
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify23GenericStructWithGetterV5valueAC5ValueVyx_Gvg'
+
+// --- setter.
+struct StructWithSetter {
+ var _val: Int
+
+ internal var val: Int {
+ get {
+ return _val
+ }
+ set {
+ _val = newValue
+ }
+ }
+
+ mutating func inc(incVal: Int) {
+ val += incVal
+ }
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify16StructWithSetterV3inc0G3ValySi_tF : $@convention(method) (Int, @inout StructWithSetter) -> () {
+// CHECK: bb0(%0 : @trivial $Int, %1 : @trivial $*StructWithSetter):
+// CHECK: [[FORMALACCESS:%.*]] = begin_access [modify] [unknown] %1
+// CHECK: alloc_stack $Int
+// CHECK: load [trivial] [[FORMALACCESS]] : $*StructWithSetter
+// CHECK: [[GETTER:%.*]] = function_ref @$S20access_marker_verify16StructWithSetterV3valSivg
+// CHECK: apply [[GETTER]]
+// CHECK: begin_access [modify] [unsafe]
+// CHECK: store %{{.*}} to [trivial]
+// CHECK: end_access
+// CHECK: begin_access [modify] [unsafe]
+// CHECK: [[INC:%.*]] = function_ref @$SSi2peoiyySiz_SitFZ
+// CHECK: apply [[INC]]
+// CHECK: load [trivial] %13 : $*Int
+// CHECK: [[SETTER:%.*]] = function_ref @$S20access_marker_verify16StructWithSetterV3valSivs
+// CHECK: apply [[SETTER]]
+// CHECK: end_access
+// CHECK: end_access [[FORMALACCESS]]
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify16StructWithSetterV3inc0G3ValySi_tF'
+
+// --- lazy inout.
+func increment(_ x: inout Int) { x += 1 }
+
+final class LazyFinalClassProperty {
+ lazy var cat: Int = 5
+}
+
+func inoutWriteOfLazyFinalClassProperty(l: inout LazyFinalClassProperty) {
+ increment(&l.cat)
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify34inoutWriteOfLazyFinalClassProperty1lyAA0ghiJ0Cz_tF : $@convention(thin) (@inout LazyFinalClassProperty) -> () {
+// CHECK: bb0(%0 : @trivial $*LazyFinalClassProperty):
+// CHECK: [[FORMALACCESS:%.*]] = begin_access [read] [unknown] %0 : $*LazyFinalClassProperty
+// CHECK: load [copy] [[FORMALACCESS]] : $*LazyFinalClassProperty
+// CHECK: end_access [[FORMALACCESS]] : $*LazyFinalClassProperty
+// CHECK: // function_ref LazyFinalClassProperty.cat.getter
+// CHECK: [[GETTER:%.*]] = function_ref @$S20access_marker_verify22LazyFinalClassPropertyC3catSivg
+// CHECK: apply [[GETTER]]
+// CHECK: begin_access [modify] [unsafe]
+// CHECK: store %{{.*}} to [trivial]
+// CHECK: end_access
+// CHECK: [[TEMPACCESS:%.*]] = begin_access [modify] [unsafe] %5 : $*Int
+// CHECK: [[INC:%.*]] = function_ref @$S20access_marker_verify9incrementyySizF : $@convention(thin) (@inout Int) -> ()
+// CHECK: apply [[INC]]([[TEMPACCESS]]) : $@convention(thin) (@inout Int) -> ()
+// CHECK: load [trivial] [[TEMPACCESS]] : $*Int
+// CHECK: [[SETTER:%.*]] = function_ref @$S20access_marker_verify22LazyFinalClassPropertyC3catSivs
+// CHECK: apply [[SETTER]]
+// CHECK: end_access [[TEMPACCESS]] : $*Int
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify34inoutWriteOfLazyFinalClassProperty1lyAA0ghiJ0Cz_tF'
+
+// --- lazy getter.
+func inoutAccessOfLazyFinalClassProperty(
+ l: inout LazyFinalClassProperty
+) -> Int {
+ return l.cat
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify35inoutAccessOfLazyFinalClassProperty1lSiAA0ghiJ0Cz_tF : $@convention(thin) (@inout LazyFinalClassProperty) -> Int {
+// CHECK: bb0(%0 : @trivial $*LazyFinalClassProperty):
+// CHECK: begin_access [read] [unknown] %0
+// CHECK: load [copy]
+// CHECK: end_access
+// CHECK: [[GETTER:%.*]] = function_ref @$S20access_marker_verify22LazyFinalClassPropertyC3catSivg : $@convention(method) (@guaranteed LazyFinalClassProperty) -> Int
+// CHECK: apply [[GETTER]]
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify35inoutAccessOfLazyFinalClassProperty1lSiAA0ghiJ0Cz_tF'
+
+// --- polymorphic getter
+protocol Abstractable {
+ associatedtype Result
+ var storedFunction: () -> Result { get set }
+}
+
+class C : Abstractable {
+ var storedFunction: () -> Int = { 0 }
+}
+// CHECK-LABEL: sil private [transparent] [thunk] @$S20access_marker_verify1CCAA12AbstractableA2aDP14storedFunction6ResultQzycvmTW : $@convention(witness_method: Abstractable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout C) -> (Builtin.RawPointer, Optional<Builtin.RawPointer>) {
+// CHECK: bb0(%0 : @trivial $Builtin.RawPointer, %1 : @trivial $*Builtin.UnsafeValueBuffer, %2 : @trivial $*C):
+// CHECK: [[ADR:%.*]] = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*@callee_guaranteed () -> @out Int
+// CHECK: [[TEMP:%.*]] = alloc_stack $@callee_guaranteed () -> Int
+// CHECK: [[GETTER:%.*]] = apply
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [unsafe] [[TEMP]] : $*@callee_guaranteed () -> Int
+// CHECK: store %{{.*}} to [init] [[ACCESS]] : $*@callee_guaranteed () -> Int
+// CHECK: end_access [[ACCESS]] : $*@callee_guaranteed () -> Int
+// CHECK-NOT: begin_access
+// CHECK: load [copy] [[TEMP]] : $*@callee_guaranteed () -> Int
+// CHECK: [[PA:%.*]] = partial_apply
+// CHECK: destroy_addr [[TEMP]] : $*@callee_guaranteed () -> Int
+// CHECK-NOT: begin_access
+// CHECK: store [[PA]] to [init] [[ADR]] : $*@callee_guaranteed () -> @out Int
+// CHECK: [[PTR:%.*]] = address_to_pointer [[ADR]] : $*@callee_guaranteed () -> @out Int to $Builtin.RawPointer
+// CHECK: [[FPTR:%.*]] = thin_function_to_pointer %{{.*}} : $@convention(witness_method: Abstractable) (Builtin.RawPointer, @inout Builtin.UnsafeValueBuffer, @inout C, @thick C.Type) -> () to $Builtin.RawPointer
+// CHECK: [[ENUM:%.*]] = enum $Optional<Builtin.RawPointer>, #Optional.some!enumelt.1, [[FPTR]] : $Builtin.RawPointer
+// CHECK: [[R:%.*]] = tuple ([[PTR]] : $Builtin.RawPointer, [[ENUM]] : $Optional<Builtin.RawPointer>)
+// CHECK: return [[R]] : $(Builtin.RawPointer, Optional<Builtin.RawPointer>)
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify1CCAA12AbstractableA2aDP14storedFunction6ResultQzycvmTW'
+
+// --- writeback address-only.
+var addressOnly: P {
+ get {
+ return StructP()
+ }
+ set {}
+}
+
+func takesInoutP(x: inout P) {}
+
+func testWriteback() {
+ takesInoutP(x: &addressOnly)
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify13testWritebackyyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK: %0 = alloc_stack $P
+// CHECK: [[GETTER:%.*]] = apply
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [unsafe] %0 : $*P
+// Call takesInoutP
+// CHECK: apply %{{.*}}([[ACCESS]]) : $@convention(thin) (@inout P) -> ()
+// Call addressOnly.setter
+// CHECK: apply %{{.*}}([[ACCESS]]) : $@convention(thin) (@in P) -> ()
+// CHECK: end_access [[ACCESS]] : $*P
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify13testWritebackyyF'
+
+// --- writeback temp.
+struct MutableStorage {
+ mutating func push() {}
+}
+
+class Container {
+ var storage: MutableStorage
+
+ init() {
+ storage = MutableStorage()
+ }
+
+ func testWritebackTemp() {
+ self.storage.push()
+ }
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify9ContainerC17testWritebackTempyyF : $@convention(method) (@guaranteed Container) -> () {
+// CHECK: bb0(%0 : @guaranteed $Container):
+// call storage.materializeForSet
+// CHECK: [[MATSET:%.*]] = class_method %0 : $Container, #Container.storage!materializeForSet.1
+// CHECK: apply [[MATSET]]
+// call MutableStorage.push()
+// CHECK: apply %{{.*}}(%{{.*}}) : $@convention(method) (@inout MutableStorage) -> ()
+// CHECK: switch_enum %{{.*}} : $Optional<Builtin.RawPointer>, case #Optional.some!enumelt.1: [[BBSOME:bb.*]], case #Optional.none!enumelt: bb
+// CHECK: [[BBSOME]]([[WB:%.*]] : @trivial $Builtin.RawPointer):
+// CHECK: [[WBF:%.*]] = pointer_to_thin_function [[WB]]
+// CHECK: [[TEMP:%.*]] = alloc_stack $Container
+// CHECK: [[ACCESS:%.*]] = begin_access [modify] [unsafe] [[TEMP]] : $*Container
+// CHECK: store_borrow %0 to [[ACCESS]] : $*Container
+// writeback
+// CHECK: apply [[WBF]]
+// CHECK: end_access [[ACCESS]] : $*Container
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify9ContainerC17testWritebackTempyyF'
+
+// --- return mixed tuple
+protocol HasClassGetter {
+ var c: BaseClass { get }
+}
+func testMixedTuple(p: HasClassGetter) -> (BaseClass, Any) {
+ return (p.c, p.c)
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify14testMixedTuple1pAA9BaseClassC_yptAA03HasH6Getter_p_tF : $@convention(thin) (@in_guaranteed HasClassGetter) -> (@owned BaseClass, @out Any) {
+// CHECK: bb0(%0 : @trivial $*Any, %1 : @trivial $*HasClassGetter):
+// CHECK: [[P1:%.*]] = open_existential_addr immutable_access %1 : $*HasClassGetter to $*@opened
+// CHECK: [[TEMP1:%.*]] = alloc_stack $@opened
+// CHECK-NOT: begin_access
+// CHECK: copy_addr [[P1]] to [initialization] [[TEMP1]] : $*@opened
+// CHECK-NOT: begin_access
+// CHECK: [[OUTC:%.*]] = apply {{.*}} $@convention(witness_method: HasClassGetter) <τ_0_0 where τ_0_0 : HasClassGetter> (@in_guaranteed τ_0_0) -> @owned BaseClass
+// CHECK: [[OUTANY:%.*]] = init_existential_addr %0 : $*Any, $BaseClass
+// CHECK: [[P2:%.*]] = open_existential_addr immutable_access %1 : $*HasClassGetter to $*@opened
+// CHECK: [[TEMP2:%.*]] = alloc_stack $@opened
+// CHECK-NOT: begin_access
+// CHECK: copy_addr [[P2]] to [initialization] [[TEMP2]] : $*@opened
+// CHECK-NOT: begin_access
+// CHECK: apply {{.*}} $@convention(witness_method: HasClassGetter) <τ_0_0 where τ_0_0 : HasClassGetter> (@in_guaranteed τ_0_0) -> @owned BaseClass
+// CHECK: store %{{.*}} to [init] [[OUTANY]] : $*BaseClass
+// CHECK: return [[OUTC]] : $BaseClass
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify14testMixedTuple1pAA9BaseClassC_yptAA03HasH6Getter_p_tF'
+
+// --- existential cast.
+internal protocol CanCast {
+ func unbox<T : Hashable>() -> T?
+}
+
+internal struct CanCastStruct<Base : Hashable> : CanCast {
+ internal var base: Base
+
+ internal func unbox<T : Hashable>() -> T? {
+ return (self as CanCast as? CanCastStruct<T>)?.base
+ }
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify13CanCastStructV5unboxqd__Sgys8HashableRd__lF : $@convention(method) <Base where Base : Hashable><T where T : Hashable> (@in_guaranteed CanCastStruct<Base>) -> @out Optional<T> {
+// CHECK: bb0(%0 : @trivial $*Optional<T>, %1 : @trivial $*CanCastStruct<Base>):
+// CHECK: [[OUT_ENUM:%.*3]] = init_enum_data_addr %0 : $*Optional<T>, #Optional.some!enumelt.1
+// CHECK: [[TEMP_SUB:%.*]] = alloc_stack $Optional<CanCastStruct<T>>
+// CHECK: [[TEMP_BASE:%.*]] = alloc_stack $CanCast
+// CHECK: [[TEMP_BASE_ADR:%.*]] = init_existential_addr [[TEMP_BASE]] : $*CanCast, $CanCastStruct<Base>
+// CHECK-NOT: begin_access
+// CHECK: copy_addr %1 to [initialization] [[TEMP_BASE_ADR]] : $*CanCastStruct<Base>
+// CHECK-NOT: begin_access
+// CHECK: [[TEMP_SUB_ADR:%.*]] = init_enum_data_addr [[TEMP_SUB]] : $*Optional<CanCastStruct<T>>, #Optional.some!enumelt.1
+// CHECK-NOT: begin_access
+// CHECK: checked_cast_addr_br take_always CanCast in [[TEMP_BASE]] : $*CanCast to CanCastStruct<T> in [[TEMP_SUB_ADR]] : $*CanCastStruct<T>
+// CHECK-NOT: begin_access
+// CHECK: [[TEMP_DATA:%.*]] = unchecked_take_enum_data_addr [[TEMP_SUB]] : $*Optional<CanCastStruct<T>>, #Optional.some!enumelt.1
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [unsafe] [[TEMP_DATA]] : $*CanCastStruct<T>
+// CHECK: [[BASE_ADR:%.*]] = struct_element_addr [[ACCESS]] : $*CanCastStruct<T>, #CanCastStruct.base
+// CHECK-NOT: begin_access
+// CHECK: copy_addr [[BASE_ADR]] to [initialization] [[OUT_ENUM]] : $*T
+// CHECK: end_access [[ACCESS]] : $*CanCastStruct<T>
+// CHECK-NOT: begin_access
+// CHECK: inject_enum_addr %0 : $*Optional<T>, #Optional.some!enumelt.1
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify13CanCastStructV5unboxqd__Sgys8HashableRd__lF'
+
+// --- open existential
+protocol Q : PBar {}
+
+func testOpenExistential(p: PBar) {
+ let q0 = p as? Q
+ if q0 != nil, let q = q0 {
+ q.bar()
+ }
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify19testOpenExistential1pyAA4PBar_p_tF : $@convention(thin) (@in_guaranteed PBar) -> () {
+// CHECK: bb0(%0 : @trivial $*PBar):
+// CHECK: [[Q0:%.*]] = alloc_stack $Optional<Q>, let, name "q0"
+// CHECK: [[PBAR:%.*]] = alloc_stack $PBar
+// CHECK-NOT: begin_access
+// CHECK: copy_addr %0 to [initialization] [[PBAR]] : $*PBar
+// CHECK-NOT: begin_access
+// CHECK: [[Q0_DATA:%.*]] = init_enum_data_addr [[Q0]] : $*Optional<Q>, #Optional.some!enumelt.1
+// CHECK-NOT: begin_access
+// CHECK: checked_cast_addr_br take_always PBar in [[PBAR]] : $*PBar to Q in [[Q0_DATA]] : $*Q, bb1, bb2
+// CHECK-NOT: begin_access
+// CHECK: inject_enum_addr [[Q0]] : $*Optional<Q>, #Optional.some!enumelt.1
+// CHECK-NOT: begin_access
+// CHECK: apply %{{.*}}<Q>([[Q0]], {{.*}}) : $@convention(method) <τ_0_0> (@in_guaranteed Optional<τ_0_0>, _OptionalNilComparisonType, @thin Optional<τ_0_0>.Type) -> Bool
+// CHECK: [[Q:%.*]] = alloc_stack $Q, let, name "q"
+// CHECK: [[OPT_Q:%.*]] = alloc_stack $Optional<Q>
+// CHECK-NOT: begin_access
+// CHECK: copy_addr [[Q0]] to [initialization] [[OPT_Q]] : $*Optional<Q>
+// CHECK-NOT: begin_access
+// CHECK: switch_enum_addr [[OPT_Q]] : $*Optional<Q>, case #Optional.some!enumelt.1: bb
+// CHECK-NOT: begin_access
+// CHECK: [[OPT_Q_ADR:%.*]] = unchecked_take_enum_data_addr [[OPT_Q]] : $*Optional<Q>, #Optional.some!enumelt.1
+// CHECK-NOT: begin_access
+// CHECK: copy_addr [take] [[OPT_Q_ADR]] to [initialization] [[Q]] : $*Q
+// CHECK-NOT: begin_access
+// CHECK: [[Q_ADR:%.*]] = open_existential_addr immutable_access [[Q]] : $*Q to $*@opened("{{.*}}") Q
+// CHECK: witness_method $@opened("{{.*}}") Q, #PBar.bar!1
+// CHECK: apply %{{.*}}<@opened("{{.*}}") Q>([[Q_ADR]])
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify19testOpenExistential1pyAA4PBar_p_tF'
+
+// --- local existential
+func getP() -> P {
+ struct S : P {}
+ return S()
+}
+
+func testLocalExistential() {
+ var p = getP()
+ takesClosure { p = getP() }
+ _ = p
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify20testLocalExistentialyyF : $@convention(thin) () -> () {
+// CHECK: alloc_box ${ var P }, var, name "p"
+// CHECK: [[PROJ:%.*]] = project_box %{{.*}} : ${ var P }, 0
+// CHECK-NOT: begin_access
+// CHECK: apply %{{.*}}([[PROJ]]) : $@convention(thin) () -> @out P
+// CHECK-NOT: begin_access
+// CHECK: partial_apply [callee_guaranteed] %{{.*}}([[PROJ]]) : $@convention(thin) (@inout_aliasable P) -> ()
+// CHECK-NOT: begin_access
+// CHECK: apply
+// CHECK: [[TMP:%.*]] = alloc_stack $P
+// CHECK: [[UNINIT:%.*]] = mark_uninitialized [var] [[TMP]] : $*P
+// CHECK: [[ACCESS:%.*]] = begin_access [read] [unknown] [[PROJ]] : $*P
+// CHECK: [[COPY:%.*]] = alloc_stack $P
+// CHECK-NOT: begin_access
+// CHECK: copy_addr [[ACCESS]] to [initialization] [[COPY]] : $*P
+// CHECK: end_access
+// CHECK-NOT: begin_access
+// CHECK: copy_addr [take] [[COPY]] to [[UNINIT]] : $*P
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify20testLocalExistentialyyF'
+
+// --- address-only argument.
+protocol UsesSelf {
+ func bar(_: Self)
+}
+
+extension UsesSelf {
+ static func testSelf(a: Self, b: Self) {
+ a.bar(b)
+ }
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify8UsesSelfPAAE04testE01a1byx_xtFZ : $@convention(method) <Self where Self : UsesSelf> (@in_guaranteed Self, @in_guaranteed Self, @thick Self.Type) -> () {
+// CHECK: bb0(%0 : @trivial $*Self, %1 : @trivial $*Self, %2 : @trivial $@thick Self.Type):
+// CHECK: apply %{{.*}}<Self>(%1, %0) : $@convention(witness_method: UsesSelf) <τ_0_0 where τ_0_0 : UsesSelf> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0) -> ()
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify8UsesSelfPAAE04testE01a1byx_xtFZ'
+
+// --- autoclosure
+struct StructWithLayout {
+ internal init() {
+ _sanityCheck(MemoryLayout.size(ofValue: self) >= 0)
+ }
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify16StructWithLayoutVACycfC : $@convention(method) (@thin StructWithLayout.Type) -> StructWithLayout {
+// CHECK: bb0(%0 : @trivial $@thin StructWithLayout.Type):
+// CHECK: alloc_box ${ var StructWithLayout }, var, name "self"
+// CHECK: mark_uninitialized [rootself] %{{.*}} : ${ var StructWithLayout }
+// CHECK: [[PROJ:%.*]] = project_box %{{.*}} : ${ var StructWithLayout }, 0
+// CHECK: [[PA:%.*]] = partial_apply [callee_guaranteed] %{{.*}}([[PROJ]]) : $@convention(thin) (@inout_aliasable StructWithLayout) -> Bool
+// CHECK: [[CLOSURE:%.*]] = convert_escape_to_noescape [[PA]] : $@callee_guaranteed () -> Bool to $@noescape @callee_guaranteed () -> Bool
+// call default argument
+// CHECK: apply %{{.*}}() : $@convention(thin) () -> StaticString
+// call StaticString.init
+// CHECK: apply
+// call UInt.init(_builtinIntegerLiteral:)
+// CHECK: apply
+// call _sanityCheck(_:_:file:line:)
+// CHECK: apply %{{.*}}([[CLOSURE]], {{.*}})
+// CHECK: load [trivial] [[PROJ]] : $*StructWithLayout
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify16StructWithLayoutVACycfC'
+
+// --- pointer_to_address
+// Verification should ignore this case.
+func testPointerInit(x: Int, y: UnsafeMutablePointer<Int>) {
+ y.pointee = x
+}
+// CHECK-LABEL: sil hidden @$S20access_marker_verify15testPointerInit1x1yySi_SpySiGtF : $@convention(thin) (Int, UnsafeMutablePointer<Int>) -> () {
+// CHECK: bb0(%0 : @trivial $Int, %1 : @trivial $UnsafeMutablePointer<Int>):
+// call addressor
+// CHECK: [[POINTEE:%.*]] = apply %{{.*}}<Int>(%1) : $@convention(method) <τ_0_0> (UnsafeMutablePointer<τ_0_0>) -> UnsafeMutablePointer<τ_0_0>
+// CHECK: [[RAWPTR:%.*]] = struct_extract [[POINTEE]] : $UnsafeMutablePointer<Int>, #UnsafeMutablePointer._rawValue
+// CHECK: [[ADR:%.*]] = pointer_to_address [[RAWPTR]] : $Builtin.RawPointer to [strict] $*Int
+// CHECK-NOT: begin_access
+// CHECK: assign %0 to [[ADR]] : $*Int
+// CHECK-LABEL: } // end sil function '$S20access_marker_verify15testPointerInit1x1yySi_SpySiGtF'
diff --git a/test/SILOptimizer/plus_zero_array_element_propagation.sil b/test/SILOptimizer/plus_zero_array_element_propagation.sil
new file mode 100644
index 0000000..8973b9a
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_array_element_propagation.sil
@@ -0,0 +1,387 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -array-element-propagation %s | %FileCheck %s
+sil_stage canonical
+
+import Builtin
+import Swift
+
+struct MyInt {
+ @sil_stored var _value: Builtin.Int64
+}
+
+struct MyBool {}
+struct _MyDependenceToken {}
+
+struct _MyBridgeStorage {
+ @sil_stored var rawValue : Builtin.BridgeObject
+}
+
+struct _MyArrayBuffer<T> {
+ @sil_stored var _storage : _MyBridgeStorage
+}
+
+
+struct MyArray<T> {
+ @sil_stored var _buffer : _MyArrayBuffer<T>
+}
+
+sil @swift_bufferAllocate : $@convention(thin)() -> @owned AnyObject
+sil [_semantics "array.uninitialized"] @adoptStorage : $@convention(thin) (@owned AnyObject, MyInt, @thin MyArray<MyInt>.Type) -> @owned (MyArray<MyInt>, UnsafeMutablePointer<MyInt>)
+sil [_semantics "array.props.isNativeTypeChecked"] @hoistableIsNativeTypeChecked : $@convention(method) (@guaranteed MyArray<MyInt>) -> MyBool
+sil [_semantics "array.check_subscript"] @checkSubscript : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+sil [_semantics "array.get_element"] @getElement : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> @out MyInt
+sil [_semantics "array.get_element"] @getElement2 : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> MyInt
+sil @unknown_array_use : $@convention(method) (@guaranteed MyArray<MyInt>) -> MyBool
+sil [_semantics "array.uninitialized"] @arrayAdoptStorage : $@convention(thin) (@owned AnyObject, MyInt, @thin Array<MyInt>.Type) -> @owned (Array<MyInt>, UnsafeMutablePointer<MyInt>)
+sil @arrayInit : $@convention(method) (@thin Array<MyInt>.Type) -> @owned Array<MyInt>
+sil [_semantics "array.append_contentsOf"] @arrayAppendContentsOf : $@convention(method) (@owned Array<MyInt>, @inout Array<MyInt>) -> ()
+
+// CHECK-LABEL: sil @propagate01
+// CHECK: struct $MyInt
+// CHECK: [[V0:%.*]] = integer_literal $Builtin.Int64, 0
+// CHECK: [[I0:%.*]] = struct $MyInt ([[V0]] : $Builtin.Int64)
+// CHECK: [[V1:%.*]] = integer_literal $Builtin.Int64, 1
+// CHECK: [[I1:%.*]] = struct $MyInt ([[V1]] : $Builtin.Int64)
+// CHECK: [[V2:%.*]] = integer_literal $Builtin.Int64, 2
+// CHECK: [[I2:%.*]] = struct $MyInt ([[V2]] : $Builtin.Int64)
+// CHECK: [[S0:%.*]] = alloc_stack $MyInt
+// CHECK: [[HFUN:%.*]] = function_ref @hoistableIsNativeTypeChecked
+// CHECK-NOT: apply [[HFUN]]
+// CHECK: [[CFUN:%.*]] = function_ref @checkSubscript
+// CHECK-NOT: apply [[CFUN]]
+// CHECK: [[GFUN:%.*]] = function_ref @getElement
+// CHECK-NOT: apply [[GFUN]]
+// CHECK-NOT: apply [[HFUN]]
+// CHECK-NOT: apply [[CFUN]]
+// CHECK-NOT: apply [[GFUN]]
+// CHECK: store [[I0]] to [[S0]]
+// CHECK: [[S1:%.*]] = alloc_stack $MyInt
+// CHECK: store [[I1]] to [[S1]]
+// CHECK: [[S2:%.*]] = alloc_stack $MyInt
+// CHECK: store [[I2]] to [[S2]]
+// CHECK: return
+
+sil @propagate01 : $@convention(thin) () -> () {
+ %0 = function_ref @swift_bufferAllocate : $@convention(thin) () -> @owned AnyObject
+ %1 = integer_literal $Builtin.Int64, 3
+ %2 = struct $MyInt (%1 : $Builtin.Int64)
+ %3 = apply %0() : $@convention(thin) () -> @owned AnyObject
+ %4 = metatype $@thin MyArray<MyInt>.Type
+ %5 = function_ref @adoptStorage : $@convention(thin) (@owned AnyObject, MyInt, @thin MyArray<MyInt>.Type) -> @owned (MyArray<MyInt>, UnsafeMutablePointer<MyInt>)
+ %6 = apply %5(%3, %2, %4) : $@convention(thin) (@owned AnyObject, MyInt, @thin MyArray<MyInt>.Type) -> @owned (MyArray<MyInt>, UnsafeMutablePointer<MyInt>)
+ %7 = tuple_extract %6 : $(MyArray<MyInt>, UnsafeMutablePointer<MyInt>), 0
+ %8 = tuple_extract %6 : $(MyArray<MyInt>, UnsafeMutablePointer<MyInt>), 1
+ debug_value %7 : $MyArray<MyInt>
+ debug_value %8 : $UnsafeMutablePointer<MyInt>
+ %9 = struct_extract %8 : $UnsafeMutablePointer<MyInt>, #UnsafeMutablePointer._rawValue
+ %10 = pointer_to_address %9 : $Builtin.RawPointer to [strict] $*MyInt
+ %11 = integer_literal $Builtin.Int64, 0
+ %12 = struct $MyInt (%11 : $Builtin.Int64)
+ store %12 to %10 : $*MyInt
+ %13 = integer_literal $Builtin.Word, 1
+ %14 = index_addr %10 : $*MyInt, %13 : $Builtin.Word
+ %15 = integer_literal $Builtin.Int64, 1
+ %16 = struct $MyInt (%15 : $Builtin.Int64)
+ store %16 to %14 : $*MyInt
+ %17 = integer_literal $Builtin.Word, 2
+ %18 = index_addr %10 : $*MyInt, %17 : $Builtin.Word
+ %19 = integer_literal $Builtin.Int64, 2
+ %20 = struct $MyInt (%19 : $Builtin.Int64)
+ store %20 to %18 : $*MyInt
+ %23 = struct_extract %7 : $MyArray<MyInt>, #MyArray._buffer
+ %24 = struct_extract %23 : $_MyArrayBuffer<MyInt>, #_MyArrayBuffer._storage
+ %25 = struct_extract %24 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
+ %26 = alloc_stack $MyInt
+ debug_value %7 : $MyArray<MyInt>
+ %27 = function_ref @hoistableIsNativeTypeChecked : $@convention(method) (@guaranteed MyArray<MyInt>) -> MyBool
+ %28 = apply %27(%7) : $@convention(method) (@guaranteed MyArray<MyInt>) -> MyBool
+ debug_value %28 : $MyBool // id: %104
+ %29 = function_ref @checkSubscript : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+ %30 = apply %29(%12, %28, %7) : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+ debug_value %30 : $_MyDependenceToken
+ %31 = function_ref @getElement : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> @out MyInt
+ %32 = apply %31(%26, %12, %28, %30, %7) : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> @out MyInt
+ %35 = alloc_stack $MyInt
+ debug_value %16 : $MyInt
+ debug_value %7 : $MyArray<MyInt>
+ debug_value %28 : $MyBool
+ strong_retain %25 : $Builtin.BridgeObject
+ %36 = apply %29(%16, %28, %7) : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+ debug_value %36 : $_MyDependenceToken
+ %37 = apply %31(%35, %16, %28, %36, %7) : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> @out MyInt
+ strong_release %25 : $Builtin.BridgeObject
+ %44 = alloc_stack $MyInt
+ debug_value %7 : $MyArray<MyInt>
+ debug_value %28 : $MyBool
+ strong_retain %25 : $Builtin.BridgeObject
+ %45 = apply %29(%20, %28, %7) : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+ debug_value %45 : $_MyDependenceToken
+ %46 = apply %31(%44, %20, %28, %45, %7) : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> @out MyInt
+ strong_release %25 : $Builtin.BridgeObject
+ %52 = tuple ()
+ dealloc_stack %44 : $*MyInt
+ dealloc_stack %35 : $*MyInt
+ dealloc_stack %26 : $*MyInt
+ strong_release %25 : $Builtin.BridgeObject
+ return %52 : $()
+}
+
+// CHECK-LABEL: sil @propagate_with_get_element_returning_direct_result
+// CHECK: struct $MyInt
+// CHECK: [[V0:%.*]] = integer_literal $Builtin.Int64, 0
+// CHECK: [[I0:%.*]] = struct $MyInt ([[V0]] : $Builtin.Int64)
+// CHECK: [[V1:%.*]] = integer_literal $Builtin.Int64, 1
+// CHECK: [[I1:%.*]] = struct $MyInt ([[V1]] : $Builtin.Int64)
+// CHECK: [[V2:%.*]] = integer_literal $Builtin.Int64, 2
+// CHECK: [[I2:%.*]] = struct $MyInt ([[V2]] : $Builtin.Int64)
+// CHECK: [[S0:%.*]] = alloc_stack $MyInt
+// CHECK: [[HFUN:%.*]] = function_ref @hoistableIsNativeTypeChecked
+// CHECK-NOT: apply [[HFUN]]
+// CHECK: [[CFUN:%.*]] = function_ref @checkSubscript
+// CHECK-NOT: apply [[CFUN]]
+// CHECK: [[GFUN:%.*]] = function_ref @getElement
+// CHECK-NOT: apply [[GFUN]]
+// CHECK-NOT: apply [[HFUN]]
+// CHECK-NOT: apply [[CFUN]]
+// CHECK-NOT: apply [[GFUN]]
+// CHECK: store [[I0]] to [[S0]]
+// CHECK: [[S1:%.*]] = alloc_stack $MyInt
+// CHECK: store [[I1]] to [[S1]]
+// CHECK: [[S2:%.*]] = alloc_stack $MyInt
+// CHECK: store [[I2]] to [[S2]]
+// CHECK: return
+
+sil @propagate_with_get_element_returning_direct_result : $@convention(thin) () -> () {
+ %0 = function_ref @swift_bufferAllocate : $@convention(thin) () -> @owned AnyObject
+ %1 = integer_literal $Builtin.Int64, 3
+ %2 = struct $MyInt (%1 : $Builtin.Int64)
+ %3 = apply %0() : $@convention(thin) () -> @owned AnyObject
+ %4 = metatype $@thin MyArray<MyInt>.Type
+ %5 = function_ref @adoptStorage : $@convention(thin) (@owned AnyObject, MyInt, @thin MyArray<MyInt>.Type) -> @owned (MyArray<MyInt>, UnsafeMutablePointer<MyInt>)
+ %6 = apply %5(%3, %2, %4) : $@convention(thin) (@owned AnyObject, MyInt, @thin MyArray<MyInt>.Type) -> @owned (MyArray<MyInt>, UnsafeMutablePointer<MyInt>)
+ %7 = tuple_extract %6 : $(MyArray<MyInt>, UnsafeMutablePointer<MyInt>), 0
+ %8 = tuple_extract %6 : $(MyArray<MyInt>, UnsafeMutablePointer<MyInt>), 1
+ debug_value %7 : $MyArray<MyInt>
+ debug_value %8 : $UnsafeMutablePointer<MyInt>
+ %9 = struct_extract %8 : $UnsafeMutablePointer<MyInt>, #UnsafeMutablePointer._rawValue
+ %10 = pointer_to_address %9 : $Builtin.RawPointer to [strict] $*MyInt
+ %11 = integer_literal $Builtin.Int64, 0
+ %12 = struct $MyInt (%11 : $Builtin.Int64)
+ store %12 to %10 : $*MyInt
+ %13 = integer_literal $Builtin.Word, 1
+ %14 = index_addr %10 : $*MyInt, %13 : $Builtin.Word
+ %15 = integer_literal $Builtin.Int64, 1
+ %16 = struct $MyInt (%15 : $Builtin.Int64)
+ store %16 to %14 : $*MyInt
+ %17 = integer_literal $Builtin.Word, 2
+ %18 = index_addr %10 : $*MyInt, %17 : $Builtin.Word
+ %19 = integer_literal $Builtin.Int64, 2
+ %20 = struct $MyInt (%19 : $Builtin.Int64)
+ store %20 to %18 : $*MyInt
+ %23 = struct_extract %7 : $MyArray<MyInt>, #MyArray._buffer
+ %24 = struct_extract %23 : $_MyArrayBuffer<MyInt>, #_MyArrayBuffer._storage
+ %25 = struct_extract %24 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
+ %26 = alloc_stack $MyInt
+ debug_value %7 : $MyArray<MyInt>
+ %27 = function_ref @hoistableIsNativeTypeChecked : $@convention(method) (@guaranteed MyArray<MyInt>) -> MyBool
+ %28 = apply %27(%7) : $@convention(method) (@guaranteed MyArray<MyInt>) -> MyBool
+ debug_value %28 : $MyBool // id: %104
+ %29 = function_ref @checkSubscript : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+ %30 = apply %29(%12, %28, %7) : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+ debug_value %30 : $_MyDependenceToken
+ %31 = function_ref @getElement2 : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> MyInt
+ %32 = apply %31(%12, %28, %30, %7) : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> MyInt
+ store %32 to %26 : $*MyInt
+ %35 = alloc_stack $MyInt
+ debug_value %16 : $MyInt
+ debug_value %7 : $MyArray<MyInt>
+ debug_value %28 : $MyBool
+ strong_retain %25 : $Builtin.BridgeObject
+ %36 = apply %29(%16, %28, %7) : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+ debug_value %36 : $_MyDependenceToken
+ %37 = apply %31(%16, %28, %36, %7) : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> MyInt
+ store %37 to %35 : $*MyInt
+ strong_release %25 : $Builtin.BridgeObject
+ %44 = alloc_stack $MyInt
+ debug_value %7 : $MyArray<MyInt>
+ debug_value %28 : $MyBool
+ strong_retain %25 : $Builtin.BridgeObject
+ %45 = apply %29(%20, %28, %7) : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+ debug_value %45 : $_MyDependenceToken
+ %46 = apply %31(%20, %28, %45, %7) : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> MyInt
+ store %46 to %44 : $*MyInt
+ strong_release %25 : $Builtin.BridgeObject
+ %52 = tuple ()
+ dealloc_stack %44 : $*MyInt
+ dealloc_stack %35 : $*MyInt
+ dealloc_stack %26 : $*MyInt
+ strong_release %25 : $Builtin.BridgeObject
+ return %52 : $()
+}
+
+// CHECK-LABEL: sil @repeated_initialization
+// CHECK: [[GFUN:%.*]] = function_ref @getElement
+// CHECK: apply [[GFUN]]
+// CHECK: apply [[GFUN]]
+// CHECK: return
+
+sil @repeated_initialization : $@convention(thin) () -> () {
+ %0 = function_ref @swift_bufferAllocate : $@convention(thin) () -> @owned AnyObject
+ %1 = integer_literal $Builtin.Int64, 2
+ %2 = struct $MyInt (%1 : $Builtin.Int64)
+ %3 = apply %0() : $@convention(thin) () -> @owned AnyObject
+ %4 = metatype $@thin MyArray<MyInt>.Type
+ %5 = function_ref @adoptStorage : $@convention(thin) (@owned AnyObject, MyInt, @thin MyArray<MyInt>.Type) -> @owned (MyArray<MyInt>, UnsafeMutablePointer<MyInt>)
+ %6 = apply %5(%3, %2, %4) : $@convention(thin) (@owned AnyObject, MyInt, @thin MyArray<MyInt>.Type) -> @owned (MyArray<MyInt>, UnsafeMutablePointer<MyInt>)
+ %7 = tuple_extract %6 : $(MyArray<MyInt>, UnsafeMutablePointer<MyInt>), 0
+ %8 = tuple_extract %6 : $(MyArray<MyInt>, UnsafeMutablePointer<MyInt>), 1
+ %9 = struct_extract %8 : $UnsafeMutablePointer<MyInt>, #UnsafeMutablePointer._rawValue
+ %10 = pointer_to_address %9 : $Builtin.RawPointer to [strict] $*MyInt
+ %11 = integer_literal $Builtin.Int64, 0
+ %12 = struct $MyInt (%11 : $Builtin.Int64)
+ store %12 to %10 : $*MyInt
+ %13 = integer_literal $Builtin.Word, 0
+ %14 = index_addr %10 : $*MyInt, %13 : $Builtin.Word
+ %15 = integer_literal $Builtin.Int64, 1
+ %16 = struct $MyInt (%15 : $Builtin.Int64)
+ store %16 to %14 : $*MyInt
+ %23 = struct_extract %7 : $MyArray<MyInt>, #MyArray._buffer
+ %24 = struct_extract %23 : $_MyArrayBuffer<MyInt>, #_MyArrayBuffer._storage
+ %25 = struct_extract %24 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
+ %26 = alloc_stack $MyInt
+ %27 = function_ref @hoistableIsNativeTypeChecked : $@convention(method) (@guaranteed MyArray<MyInt>) -> MyBool
+ %28 = apply %27(%7) : $@convention(method) (@guaranteed MyArray<MyInt>) -> MyBool
+ %29 = function_ref @checkSubscript : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+ %30 = apply %29(%12, %28, %7) : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+ %31 = function_ref @getElement : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> @out MyInt
+ %32 = apply %31(%26, %12, %28, %30, %7) : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> @out MyInt
+ %35 = alloc_stack $MyInt
+ strong_retain %25 : $Builtin.BridgeObject
+ %36 = apply %29(%16, %28, %7) : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+ %37 = apply %31(%35, %16, %28, %36, %7) : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> @out MyInt
+ strong_release %25 : $Builtin.BridgeObject
+ %52 = tuple ()
+ dealloc_stack %35 : $*MyInt
+ dealloc_stack %26 : $*MyInt
+ strong_release %25 : $Builtin.BridgeObject
+ return %52 : $()
+}
+
+// CHECK-LABEL: sil @unknown_use
+// CHECK: [[GFUN:%.*]] = function_ref @getElement
+// CHECK: apply [[GFUN]]
+// CHECK: return
+
+sil @unknown_use : $@convention(thin) () -> () {
+ %0 = function_ref @swift_bufferAllocate : $@convention(thin) () -> @owned AnyObject
+ %1 = integer_literal $Builtin.Int64, 2
+ %2 = struct $MyInt (%1 : $Builtin.Int64)
+ %3 = apply %0() : $@convention(thin) () -> @owned AnyObject
+ %4 = metatype $@thin MyArray<MyInt>.Type
+ %5 = function_ref @adoptStorage : $@convention(thin) (@owned AnyObject, MyInt, @thin MyArray<MyInt>.Type) -> @owned (MyArray<MyInt>, UnsafeMutablePointer<MyInt>)
+ %6 = apply %5(%3, %2, %4) : $@convention(thin) (@owned AnyObject, MyInt, @thin MyArray<MyInt>.Type) -> @owned (MyArray<MyInt>, UnsafeMutablePointer<MyInt>)
+ %7 = tuple_extract %6 : $(MyArray<MyInt>, UnsafeMutablePointer<MyInt>), 0
+ %8 = tuple_extract %6 : $(MyArray<MyInt>, UnsafeMutablePointer<MyInt>), 1
+ %9 = struct_extract %8 : $UnsafeMutablePointer<MyInt>, #UnsafeMutablePointer._rawValue
+ %10 = pointer_to_address %9 : $Builtin.RawPointer to [strict] $*MyInt
+ %11 = integer_literal $Builtin.Int64, 0
+ %12 = struct $MyInt (%11 : $Builtin.Int64)
+ store %12 to %10 : $*MyInt
+ %23 = struct_extract %7 : $MyArray<MyInt>, #MyArray._buffer
+ %24 = struct_extract %23 : $_MyArrayBuffer<MyInt>, #_MyArrayBuffer._storage
+ %25 = struct_extract %24 : $_MyBridgeStorage, #_MyBridgeStorage.rawValue
+ %26 = alloc_stack $MyInt
+ %27 = function_ref @hoistableIsNativeTypeChecked : $@convention(method) (@guaranteed MyArray<MyInt>) -> MyBool
+ %28 = apply %27(%7) : $@convention(method) (@guaranteed MyArray<MyInt>) -> MyBool
+ %29 = function_ref @checkSubscript : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+ %30 = apply %29(%12, %28, %7) : $@convention(method) (MyInt, MyBool, @guaranteed MyArray<MyInt>) -> _MyDependenceToken
+ %31 = function_ref @getElement : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> @out MyInt
+ %32 = apply %31(%26, %12, %28, %30, %7) : $@convention(method) (MyInt, MyBool, _MyDependenceToken, @guaranteed MyArray<MyInt>) -> @out MyInt
+ %33 = function_ref @unknown_array_use : $@convention(method) (@guaranteed MyArray<MyInt>) -> MyBool
+ %34 = apply %33(%7) : $@convention(method) (@guaranteed MyArray<MyInt>) -> MyBool
+ %52 = tuple ()
+ dealloc_stack %26 : $*MyInt
+ strong_release %25 : $Builtin.BridgeObject
+ return %52 : $()
+}
+
+// CHECK-LABEL: sil @append_contentsOf_int
+// CHECK: [[ASFUN:%.*]] = function_ref @arrayAdoptStorage
+// CHECK-NEXT: [[ARR:%.*]] = apply [[ASFUN]]
+// CHECK-NEXT: [[OWNER:%.*]] = tuple_extract [[ARR]]{{.*}}, 0
+// CHECK-NOT: apply [[ACFUN]]
+// CHECK: [[AEFUN:%.*]] = function_ref @$SSa6appendyyxF
+// CHECK-NEXT: [[STACK:%.*]] = alloc_stack $MyInt
+// CHECK-NEXT: store %{{[0-9]+}} to [[STACK]]
+// CHECK-NEXT: apply [[AEFUN]]<MyInt>([[STACK]]
+// CHECK-NEXT: dealloc_stack [[STACK]]
+// CHECK-NEXT: release_value [[OWNER]]
+// CHECK: return
+sil @append_contentsOf_int : $@convention(thin) () -> () {
+ %0 = function_ref @swift_bufferAllocate : $@convention(thin) () -> @owned AnyObject
+ %1 = integer_literal $Builtin.Int64, 1
+ %2 = struct $MyInt (%1 : $Builtin.Int64)
+ %3 = apply %0() : $@convention(thin) () -> @owned AnyObject
+ %4 = metatype $@thin Array<MyInt>.Type
+ %5 = function_ref @arrayAdoptStorage : $@convention(thin) (@owned AnyObject, MyInt, @thin Array<MyInt>.Type) -> @owned (Array<MyInt>, UnsafeMutablePointer<MyInt>)
+ %6 = apply %5(%3, %2, %4) : $@convention(thin) (@owned AnyObject, MyInt, @thin Array<MyInt>.Type) -> @owned (Array<MyInt>, UnsafeMutablePointer<MyInt>)
+ %7 = tuple_extract %6 : $(Array<MyInt>, UnsafeMutablePointer<MyInt>), 0
+ %8 = tuple_extract %6 : $(Array<MyInt>, UnsafeMutablePointer<MyInt>), 1
+ %9 = struct_extract %8 : $UnsafeMutablePointer<MyInt>, #UnsafeMutablePointer._rawValue
+ %10 = pointer_to_address %9 : $Builtin.RawPointer to [strict] $*MyInt
+ %11 = integer_literal $Builtin.Int64, 27
+ %12 = struct $MyInt (%11 : $Builtin.Int64)
+ store %12 to %10 : $*MyInt
+ %13 = alloc_stack $Array<MyInt>
+ %14 = metatype $@thin Array<MyInt>.Type
+ %15 = function_ref @arrayInit : $@convention(method) (@thin Array<MyInt>.Type) -> @owned Array<MyInt>
+ %16 = apply %15(%14) : $@convention(method) (@thin Array<MyInt>.Type) -> @owned Array<MyInt>
+ store %16 to %13 : $*Array<MyInt>
+ %17 = function_ref @arrayAppendContentsOf : $@convention(method) (@owned Array<MyInt>, @inout Array<MyInt>) -> ()
+ %18 = apply %17(%7, %13) : $@convention(method) (@owned Array<MyInt>, @inout Array<MyInt>) -> ()
+ dealloc_stack %13 : $*Array<MyInt>
+ %19 = tuple ()
+ return %19 : $()
+}
+
+class Hello {
+}
+
+sil [_semantics "array.uninitialized"] @adoptStorageHello : $@convention(method) (@owned _ContiguousArrayStorage<Hello>, MyInt, @thin Array<Hello>.Type) -> (@owned Array<Hello>, UnsafeMutablePointer<Hello>)
+sil [_semantics "array.append_contentsOf"] @arrayAppendContentsOfHello : $@convention(method) (@owned Array<Hello>, @inout Array<Hello>) -> ()
+
+// CHECK-LABEL: sil @append_contentsOf_class
+// CHECK: [[ASFUN:%.*]] = function_ref @adoptStorageHello
+// CHECK-NEXT: [[ARR:%.*]] = apply [[ASFUN]]
+// CHECK-NEXT: [[OWNER:%.*]] = tuple_extract [[ARR]]{{.*}}, 0
+// CHECK: strong_retain %1 : $Hello
+// CHECK-NEXT: store %1 to %{{[0-9]+}} : $*Hello
+// CHECK-NOT: apply
+// CHECK: [[AEFUN:%.*]] = function_ref @$SSa6appendyyxF
+// CHECK-NEXT: strong_retain %1 : $Hello
+// CHECK-NEXT: [[STACK:%.*]] = alloc_stack $Hello
+// CHECK-NEXT: store %1 to [[STACK]]
+// CHECK-NEXT: apply [[AEFUN]]<Hello>([[STACK]], %0)
+// CHECK-NEXT: dealloc_stack [[STACK]]
+// CHECK-NEXT: strong_release %1
+// CHECK-NEXT: release_value [[OWNER]]
+// CHECK-NEXT: return
+sil @append_contentsOf_class : $@convention(thin) (@inout Array<Hello>, @owned Hello) -> @owned Hello {
+bb0(%0 : $*Array<Hello>, %1 : $Hello):
+ %4 = integer_literal $Builtin.Word, 1
+ %5 = integer_literal $Builtin.Int64, 1
+ %6 = struct $MyInt (%5 : $Builtin.Int64)
+ %7 = alloc_ref [tail_elems $Hello * %4 : $Builtin.Word] $_ContiguousArrayStorage<Hello>
+ %8 = metatype $@thin Array<Hello>.Type
+ %9 = function_ref @adoptStorageHello : $@convention(method) (@owned _ContiguousArrayStorage<Hello>, MyInt, @thin Array<Hello>.Type) -> (@owned Array<Hello>, UnsafeMutablePointer<Hello>)
+ %10 = apply %9(%7, %6, %8) : $@convention(method) (@owned _ContiguousArrayStorage<Hello>, MyInt, @thin Array<Hello>.Type) -> (@owned Array<Hello>, UnsafeMutablePointer<Hello>)
+ %11 = tuple_extract %10 : $(Array<Hello>, UnsafeMutablePointer<Hello>), 0
+ %12 = tuple_extract %10 : $(Array<Hello>, UnsafeMutablePointer<Hello>), 1
+ %13 = struct_extract %12 : $UnsafeMutablePointer<Hello>, #UnsafeMutablePointer._rawValue
+ %22 = pointer_to_address %13 : $Builtin.RawPointer to [strict] $*Hello
+ strong_retain %1 : $Hello
+ store %1 to %22 : $*Hello
+ %25 = function_ref @arrayAppendContentsOfHello : $@convention(method) (@owned Array<Hello>, @inout Array<Hello>) -> ()
+ %26 = apply %25(%11, %0) : $@convention(method) (@owned Array<Hello>, @inout Array<Hello>) -> ()
+ return %1 : $Hello
+}
diff --git a/test/SILOptimizer/plus_zero_bridged_casts_folding.swift b/test/SILOptimizer/plus_zero_bridged_casts_folding.swift
new file mode 100644
index 0000000..5ef60d6
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_bridged_casts_folding.swift
@@ -0,0 +1,949 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -O -emit-sil %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+// Check that casts between bridged types are replaced by more
+// efficient code sequences.
+//
+// In particular, checked_cast_* and unconditional_checked_* instructions,
+// which are pretty expensive at run-time (e.g. because they use
+// runtime _dynamicCast calls and check conformances at run-time),
+// should be replaced by invocations of specialized bridging functions,
+// which make use of statically known compile-time conformances and
+// do not perform any conformance checks at run-time.
+
+import Foundation
+
+public func forcedCast<NS, T>(_ ns: NS) -> T {
+ return ns as! T
+}
+
+public func condCast<NS, T>(_ ns: NS) -> T? {
+ return ns as? T
+}
+
+// Check optimizations of casts from NSString to String
+
+var nsString: NSString = "string"
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding29testForcedCastNStoSwiftStringSSyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$SSS10FoundationE26_forceBridgeFromObjectiveC_6resultySo8NSStringC_SSSgztFZ : $@convention(method) (@guaranteed NSString, @inout Optional<String>, @thin String.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNStoSwiftString() -> String {
+ var o: String = forcedCast(nsString)
+ return o
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding27testCondCastNStoSwiftStringSSSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$SSS10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo8NSStringC_SSSgztFZ : $@convention(method) (@guaranteed NSString, @inout Optional<String>, @thin String.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNStoSwiftString() -> String? {
+ var o: String? = condCast(nsString)
+ return o
+}
+
+
+// Check optimizations of casts from NSNumber to Int
+
+var nsIntNumber = NSNumber(value: 1)
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding32testForcedCastNSNumberToSwiftIntSiyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$SSi10FoundationE26_forceBridgeFromObjectiveC_6resultySo8NSNumberC_SiSgztFZ : $@convention(method) (@guaranteed NSNumber, @inout Optional<Int>, @thin Int.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNSNumberToSwiftInt() -> Int {
+ var o: Int = forcedCast(nsIntNumber)
+ return o
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding30testCondCastNSNumberToSwiftIntSiSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$SSi10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo8NSNumberC_SiSgztFZ : $@convention(method) (@guaranteed NSNumber, @inout Optional<Int>, @thin Int.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNSNumberToSwiftInt() -> Int? {
+ var o: Int? = condCast(nsIntNumber)
+ return o
+}
+
+// Check optimizations of casts from NSNumber to Double
+
+var nsDoubleNumber = NSNumber(value: 1.234)
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding35testForcedCastNSNumberToSwiftDoubleSdyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$SSd10FoundationE26_forceBridgeFromObjectiveC_6resultySo8NSNumberC_SdSgztFZ : $@convention(method) (@guaranteed NSNumber, @inout Optional<Double>, @thin Double.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNSNumberToSwiftDouble() -> Double {
+ var o: Double = forcedCast(nsDoubleNumber)
+ return o
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding33testCondCastNSNumberToSwiftDoubleSdSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$SSd10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo8NSNumberC_SdSgztFZ : $@convention(method) (@guaranteed NSNumber, @inout Optional<Double>, @thin Double.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNSNumberToSwiftDouble() -> Double? {
+ var o: Double? = condCast(nsDoubleNumber)
+ return o
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding38testForcedCastNSIntNumberToSwiftDoubleSdyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$SSd10FoundationE26_forceBridgeFromObjectiveC_6resultySo8NSNumberC_SdSgztFZ : $@convention(method) (@guaranteed NSNumber, @inout Optional<Double>, @thin Double.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNSIntNumberToSwiftDouble() -> Double {
+ var o: Double = forcedCast(nsIntNumber)
+ return o
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding36testCondCastNSIntNumberToSwiftDoubleSdSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$SSd10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo8NSNumberC_SdSgztFZ : $@convention(method) (@guaranteed NSNumber, @inout Optional<Double>, @thin Double.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNSIntNumberToSwiftDouble() -> Double? {
+ var o: Double? = condCast(nsIntNumber)
+ return o
+}
+
+
+
+// Check optimization of casts from NSArray to Swift Array
+
+var nsArrInt: NSArray = [1, 2, 3, 4]
+var nsArrDouble: NSArray = [1.1, 2.2, 3.3, 4.4]
+var nsArrString: NSArray = ["One", "Two", "Three", "Four"]
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding31testForcedCastNStoSwiftArrayIntSaySiGyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$SSa10FoundationE26_forceBridgeFromObjectiveC_6resultySo7NSArrayC_SayxGSgztFZ : $@convention(method) <τ_0_0> (@guaranteed NSArray, @inout Optional<Array<τ_0_0>>, @thin Array<τ_0_0>.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNStoSwiftArrayInt() -> [Int] {
+ var arr: [Int] = forcedCast(nsArrInt)
+ return arr
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding29testCondCastNStoSwiftArrayIntSaySiGSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$SSa10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo7NSArrayC_SayxGSgztFZ : $@convention(method) <τ_0_0> (@guaranteed NSArray, @inout Optional<Array<τ_0_0>>, @thin Array<τ_0_0>.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNStoSwiftArrayInt() -> [Int]? {
+ var arrOpt: [Int]? = condCast(nsArrInt)
+ return arrOpt
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding34testForcedCastNStoSwiftArrayDoubleSaySdGyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$SSa10FoundationE26_forceBridgeFromObjectiveC_6resultySo7NSArrayC_SayxGSgztFZ : $@convention(method) <τ_0_0> (@guaranteed NSArray, @inout Optional<Array<τ_0_0>>, @thin Array<τ_0_0>.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNStoSwiftArrayDouble() -> [Double] {
+ var arr: [Double] = forcedCast(nsArrDouble)
+ return arr
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding32testCondCastNStoSwiftArrayDoubleSaySdGSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$SSa10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo7NSArrayC_SayxGSgztFZ : $@convention(method) <τ_0_0> (@guaranteed NSArray, @inout Optional<Array<τ_0_0>>, @thin Array<τ_0_0>.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNStoSwiftArrayDouble() -> [Double]? {
+ var arrOpt: [Double]? = condCast(nsArrDouble)
+ return arrOpt
+}
+
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding34testForcedCastNStoSwiftArrayStringSaySSGyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$SSa10FoundationE26_forceBridgeFromObjectiveC_6resultySo7NSArrayC_SayxGSgztFZ : $@convention(method) <τ_0_0> (@guaranteed NSArray, @inout Optional<Array<τ_0_0>>, @thin Array<τ_0_0>.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNStoSwiftArrayString() -> [String] {
+ var arr: [String] = forcedCast(nsArrString)
+ return arr
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding32testCondCastNStoSwiftArrayStringSaySSGSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$SSa10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo7NSArrayC_SayxGSgztFZ : $@convention(method) <τ_0_0> (@guaranteed NSArray, @inout Optional<Array<τ_0_0>>, @thin Array<τ_0_0>.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNStoSwiftArrayString() -> [String]? {
+ var arrOpt: [String]? = condCast(nsArrString)
+ return arrOpt
+}
+
+
+
+// Check optimization of casts from NSDictionary to Swift Dictionary
+
+var nsDictInt: NSDictionary = [1:1, 2:2, 3:3, 4:4]
+var nsDictDouble: NSDictionary = [1.1 : 1.1, 2.2 : 2.2, 3.3 : 3.3, 4.4 : 4.4]
+var nsDictString: NSDictionary = ["One":"One", "Two":"Two", "Three":"Three", "Four":"Four"]
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding30testForcedCastNStoSwiftDictInts10DictionaryVyS2iGyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$Ss10DictionaryV10FoundationE26_forceBridgeFromObjectiveC_6resultySo12NSDictionaryC_AByxq_GSgztFZ : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@guaranteed NSDictionary, @inout Optional<Dictionary<τ_0_0, τ_0_1>>, @thin Dictionary<τ_0_0, τ_0_1>.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNStoSwiftDictInt() -> [Int: Int] {
+ var dict: [Int: Int] = forcedCast(nsDictInt)
+ return dict
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding28testCondCastNStoSwiftDictInts10DictionaryVyS2iGSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$Ss10DictionaryV10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo12NSDictionaryC_AByxq_GSgztFZ : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@guaranteed NSDictionary, @inout Optional<Dictionary<τ_0_0, τ_0_1>>, @thin Dictionary<τ_0_0, τ_0_1>.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNStoSwiftDictInt() -> [Int: Int]? {
+ var dictOpt: [Int: Int]? = condCast(nsDictInt)
+ return dictOpt
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding33testForcedCastNStoSwiftDictDoubles10DictionaryVyS2dGyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$Ss10DictionaryV10FoundationE26_forceBridgeFromObjectiveC_6resultySo12NSDictionaryC_AByxq_GSgztFZ : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@guaranteed NSDictionary, @inout Optional<Dictionary<τ_0_0, τ_0_1>>, @thin Dictionary<τ_0_0, τ_0_1>.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNStoSwiftDictDouble() -> [Double: Double] {
+ var dict: [Double: Double] = forcedCast(nsDictDouble)
+ return dict
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding31testCondCastNStoSwiftDictDoubles10DictionaryVyS2dGSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$Ss10DictionaryV10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo12NSDictionaryC_AByxq_GSgztFZ : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@guaranteed NSDictionary, @inout Optional<Dictionary<τ_0_0, τ_0_1>>, @thin Dictionary<τ_0_0, τ_0_1>.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNStoSwiftDictDouble() -> [Double: Double]? {
+ var dictOpt: [Double: Double]? = condCast(nsDictDouble)
+ return dictOpt
+}
+
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding33testForcedCastNStoSwiftDictStrings10DictionaryVyS2SGyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$Ss10DictionaryV10FoundationE26_forceBridgeFromObjectiveC_6resultySo12NSDictionaryC_AByxq_GSgztFZ : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@guaranteed NSDictionary, @inout Optional<Dictionary<τ_0_0, τ_0_1>>, @thin Dictionary<τ_0_0, τ_0_1>.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNStoSwiftDictString() -> [String: String] {
+ var dict: [String: String] = forcedCast(nsDictString)
+ return dict
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding31testCondCastNStoSwiftDictStrings10DictionaryVyS2SGSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$Ss10DictionaryV10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo12NSDictionaryC_AByxq_GSgztFZ : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@guaranteed NSDictionary, @inout Optional<Dictionary<τ_0_0, τ_0_1>>, @thin Dictionary<τ_0_0, τ_0_1>.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNStoSwiftDictString() -> [String: String]? {
+ var dictOpt: [String: String]? = condCast(nsDictString)
+ return dictOpt
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding40testForcedCastNSDictStringtoSwiftDictInts10DictionaryVyS2iGyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$Ss10DictionaryV10FoundationE26_forceBridgeFromObjectiveC_6resultySo12NSDictionaryC_AByxq_GSgztFZ : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@guaranteed NSDictionary, @inout Optional<Dictionary<τ_0_0, τ_0_1>>, @thin Dictionary<τ_0_0, τ_0_1>.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNSDictStringtoSwiftDictInt() -> [Int: Int] {
+ var dictOpt: [Int: Int] = forcedCast(nsDictString)
+ return dictOpt
+}
+
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding38testCondCastNSDictStringtoSwiftDictInts10DictionaryVyS2iGSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$Ss10DictionaryV10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo12NSDictionaryC_AByxq_GSgztFZ : $@convention(method) <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (@guaranteed NSDictionary, @inout Optional<Dictionary<τ_0_0, τ_0_1>>, @thin Dictionary<τ_0_0, τ_0_1>.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNSDictStringtoSwiftDictInt() -> [Int: Int]? {
+ var dictOpt: [Int: Int]? = condCast(nsDictString)
+ return dictOpt
+}
+
+
+// Check optimization of casts from NSSet to Swift Set
+
+var nsSetInt: NSSet = [1, 2, 3, 4]
+var nsSetDouble: NSSet = [1.1, 2.2, 3.3, 4.4]
+var nsSetString: NSSet = ["One", "Two", "Three", "Four"]
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding29testForcedCastNStoSwiftSetInts0I0VySiGyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$Ss3SetV10FoundationE26_forceBridgeFromObjectiveC_6resultySo5NSSetC_AByxGSgztFZ : $@convention(method) <τ_0_0 where τ_0_0 : Hashable> (@guaranteed NSSet, @inout Optional<Set<τ_0_0>>, @thin Set<τ_0_0>.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNStoSwiftSetInt() -> Set<Int> {
+ var set: Set<Int> = forcedCast(nsSetInt)
+ return set
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding27testCondCastNStoSwiftSetInts0I0VySiGSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$Ss3SetV10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo5NSSetC_AByxGSgztFZ : $@convention(method) <τ_0_0 where τ_0_0 : Hashable> (@guaranteed NSSet, @inout Optional<Set<τ_0_0>>, @thin Set<τ_0_0>.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNStoSwiftSetInt() -> Set<Int>? {
+ var setOpt: Set<Int>? = condCast(nsSetInt)
+ return setOpt
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding32testForcedCastNStoSwiftSetDoubles0I0VySdGyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$Ss3SetV10FoundationE26_forceBridgeFromObjectiveC_6resultySo5NSSetC_AByxGSgztFZ : $@convention(method) <τ_0_0 where τ_0_0 : Hashable> (@guaranteed NSSet, @inout Optional<Set<τ_0_0>>, @thin Set<τ_0_0>.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNStoSwiftSetDouble() -> Set<Double> {
+ var set: Set<Double> = forcedCast(nsSetDouble)
+ return set
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding30testCondCastNStoSwiftSetDoubles0I0VySdGSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$Ss3SetV10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo5NSSetC_AByxGSgztFZ : $@convention(method) <τ_0_0 where τ_0_0 : Hashable> (@guaranteed NSSet, @inout Optional<Set<τ_0_0>>, @thin Set<τ_0_0>.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNStoSwiftSetDouble() -> Set<Double>? {
+ var setOpt: Set<Double>? = condCast(nsSetDouble)
+ return setOpt
+}
+
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding32testForcedCastNStoSwiftSetStrings0I0VySSGyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @$Ss3SetV10FoundationE26_forceBridgeFromObjectiveC_6resultySo5NSSetC_AByxGSgztFZ : $@convention(method) <τ_0_0 where τ_0_0 : Hashable> (@guaranteed NSSet, @inout Optional<Set<τ_0_0>>, @thin Set<τ_0_0>.Type) -> ()
+// CHECK: return
+@inline(never)
+public func testForcedCastNStoSwiftSetString() -> Set<String> {
+ var set: Set<String> = forcedCast(nsSetString)
+ return set
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding30testCondCastNStoSwiftSetStrings0I0VySSGSgyF
+// CHECK-NOT: checked_cast
+// CHECK: function_ref @$Ss3SetV10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo5NSSetC_AByxGSgztFZ : $@convention(method) <τ_0_0 where τ_0_0 : Hashable> (@guaranteed NSSet, @inout Optional<Set<τ_0_0>>, @thin Set<τ_0_0>.Type) -> Bool
+// CHECK: return
+@inline(never)
+public func testCondCastNStoSwiftSetString() -> Set<String>? {
+ var setOpt: Set<String>? = condCast(nsSetString)
+ return setOpt
+}
+
+
+// Check optimizations of casts from String to NSString
+
+var swiftString: String = "string"
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding29testForcedCastSwiftToNSStringSo0I0CyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testForcedCastSwiftToNSString() -> NSString {
+ var o: NSString = forcedCast(swiftString)
+ return o
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding27testCondCastSwiftToNSStringSo0I0CSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testCondCastSwiftToNSString() -> NSString? {
+ var o: NSString? = condCast(swiftString)
+ return o
+}
+
+
+// Check optimizations of casts from Int to NSNumber
+
+var swiftIntNumber: Int = 1
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding32testForcedCastSwiftIntToNSNumberSo0J0CyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testForcedCastSwiftIntToNSNumber() -> NSNumber {
+ var o: NSNumber = forcedCast(swiftIntNumber)
+ return o
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding30testCondCastSwiftIntToNSNumberSo0J0CSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testCondCastSwiftIntToNSNumber() -> NSNumber? {
+ var o: NSNumber? = condCast(swiftIntNumber)
+ return o
+}
+
+// Check optimizations of casts from Double to NSNumber
+
+var swiftDoubleNumber: Double = 1.234
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding35testForcedCastSwiftDoubleToNSNumberSo0J0CyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testForcedCastSwiftDoubleToNSNumber() -> NSNumber {
+ var o: NSNumber = forcedCast(swiftDoubleNumber)
+ return o
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding33testCondCastSwiftDoubleToNSNumberSo0J0CSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testCondCastSwiftDoubleToNSNumber() -> NSNumber? {
+ var o: NSNumber? = condCast(swiftDoubleNumber)
+ return o
+}
+
+
+// Check optimization of casts from Swift Array to NSArray
+
+var arrInt: [Int] = [1, 2, 3, 4]
+var arrDouble: [Double] = [1.1, 2.2, 3.3, 4.4]
+var arrString: [String] = ["One", "Two", "Three", "Four"]
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding31testForcedCastSwiftToNSArrayIntSo0I0CyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testForcedCastSwiftToNSArrayInt() -> NSArray {
+ var arr: NSArray = forcedCast(arrInt)
+ return arr
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding29testCondCastSwiftToNSArrayIntSo0I0CSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testCondCastSwiftToNSArrayInt() -> NSArray? {
+ var arrOpt: NSArray? = condCast(arrInt)
+ return arrOpt
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding34testForcedCastSwiftToNSArrayDoubleSo0I0CyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testForcedCastSwiftToNSArrayDouble() -> NSArray {
+ var arr: NSArray = forcedCast(arrDouble)
+ return arr
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding32testCondCastSwiftToNSArrayDoubleSo0I0CSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testCondCastSwiftToNSArrayDouble() -> NSArray? {
+ var arrOpt: NSArray? = condCast(arrDouble)
+ return arrOpt
+}
+
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding34testForcedCastSwiftToNSArrayStringSo0I0CyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testForcedCastSwiftToNSArrayString() -> NSArray {
+ var arr: NSArray = forcedCast(arrString)
+ return arr
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding32testCondCastSwiftToNSArrayStringSo0I0CSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testCondCastSwiftToNSArrayString() -> NSArray? {
+ var arrOpt: NSArray? = condCast(arrString)
+ return arrOpt
+}
+
+
+// Check optimization of casts from Swift Dict to NSDict
+
+var dictInt: [Int: Int] = [1:1, 2:2, 3:3, 4:4]
+var dictDouble: [Double: Double] = [1.1 : 1.1, 2.2 : 2.2, 3.3 : 3.3, 4.4 : 4.4]
+var dictString: [String: String] = ["One":"One", "Two":"Two", "Three":"Three", "Four":"Four"]
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding30testForcedCastSwiftToNSDictIntSo12NSDictionaryCyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testForcedCastSwiftToNSDictInt() -> NSDictionary {
+ var dict: NSDictionary = forcedCast(dictInt)
+ return dict
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding28testCondCastSwiftToNSDictIntSo12NSDictionaryCSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testCondCastSwiftToNSDictInt() -> NSDictionary? {
+ var dictOpt: NSDictionary? = condCast(dictInt)
+ return dictOpt
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding33testForcedCastSwiftToNSDictDoubleSo12NSDictionaryCyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testForcedCastSwiftToNSDictDouble() -> NSDictionary {
+ var dict: NSDictionary = forcedCast(dictDouble)
+ return dict
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding31testCondCastSwiftToNSDictDoubleSo12NSDictionaryCSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testCondCastSwiftToNSDictDouble() -> NSDictionary? {
+ var dictOpt: NSDictionary? = condCast(dictDouble)
+ return dictOpt
+}
+
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding33testForcedCastSwiftToNSDictStringSo12NSDictionaryCyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testForcedCastSwiftToNSDictString() -> NSDictionary {
+ var dict: NSDictionary = forcedCast(dictString)
+ return dict
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding31testCondCastSwiftToNSDictStringSo12NSDictionaryCSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testCondCastSwiftToNSDictString() -> NSDictionary? {
+ var dictOpt: NSDictionary? = condCast(dictString)
+ return dictOpt
+}
+
+
+// Check optimization of casts from Swift Set to NSSet
+
+var setInt: Set<Int> = [1, 2, 3, 4]
+var setDouble: Set<Double> = [1.1, 2.2, 3.3, 4.4]
+var setString: Set<String> = ["One", "Two", "Three", "Four"]
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding29testForcedCastSwiftToNSSetIntSo0I0CyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testForcedCastSwiftToNSSetInt() -> NSSet {
+ var set: NSSet = forcedCast(setInt)
+ return set
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding27testCondCastSwiftToNSSetIntSo0I0CSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testCondCastSwiftToNSSetInt() -> NSSet? {
+ var setOpt: NSSet? = condCast(setInt)
+ return setOpt
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding32testForcedCastSwiftToNSSetDoubleSo0I0CyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testForcedCastSwiftToNSSetDouble() -> NSSet {
+ var set: NSSet = forcedCast(setDouble)
+ return set
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding30testCondCastSwiftToNSSetDoubleSo0I0CSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testCondCastSwiftToNSSetDouble() -> NSSet? {
+ var setOpt: NSSet? = condCast(setDouble)
+ return setOpt
+}
+
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding32testForcedCastSwiftToNSSetStringSo0I0CyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testForcedCastSwiftToNSSetString() -> NSSet {
+ var set: NSSet = forcedCast(setString)
+ return set
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding30testCondCastSwiftToNSSetStringSo0I0CSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: return
+@inline(never)
+public func testCondCastSwiftToNSSetString() -> NSSet? {
+ var setOpt: NSSet? = condCast(setString)
+ return setOpt
+}
+
+// Casts involving generics cannot be optimized.
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding25testForcedCastFromGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: unconditional_checked
+// CHECK: return
+@inline(never)
+public func testForcedCastFromGeneric<T>(_ x: T) -> NSString {
+ var set: NSString = x as! NSString
+ return set
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding23testForcedCastToGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: unconditional_checked
+// CHECK: return
+@inline(never)
+public func testForcedCastToGeneric<T>(_ x: T) -> T {
+ var set: T = nsString as! T
+ return set
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding23testCondCastFromGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: checked_cast_addr_br
+// CHECK: return
+@inline(never)
+public func testCondCastFromGeneric<T>(_ x: T) -> NSString? {
+ var setOpt: NSString? = x as? NSString
+ return setOpt
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding21testCondCastToGeneric{{[_0-9a-zA-Z]*}}F
+// CHECK: checked_cast_addr_br
+// CHECK: return
+@inline(never)
+public func testCondCastToGeneric<T>(_ x: T) -> T? {
+ var setOpt: T? = nsString as? T
+ return setOpt
+}
+
+
+// Run-time tests
+
+//// ObjC -> Swift
+
+// Arrays
+print("NS to Swift arrays: Start")
+print(testForcedCastNStoSwiftArrayInt())
+print(testCondCastNStoSwiftArrayInt())
+
+print(testForcedCastNStoSwiftArrayDouble())
+print(testCondCastNStoSwiftArrayDouble())
+
+print(testForcedCastNStoSwiftArrayString())
+print(testCondCastNStoSwiftArrayString())
+print("NS to Swift arrays: End")
+
+// Dicts
+print("NS to Swift dictionaries: Start")
+print(testForcedCastNStoSwiftDictInt())
+print(testCondCastNStoSwiftDictInt())
+
+print(testForcedCastNStoSwiftDictDouble())
+print(testCondCastNStoSwiftDictDouble())
+
+print(testForcedCastNStoSwiftDictString())
+print(testCondCastNStoSwiftDictString())
+print(testCondCastNSDictStringtoSwiftDictInt())
+// This line should crash at run-time
+//print(testForcedCastNSDictStringtoSwiftDictInt())
+print("NS to Swift dictionaries: End")
+
+// Sets
+print("NS to Swift sets: Start")
+print(testForcedCastNStoSwiftSetInt())
+print(testCondCastNStoSwiftSetInt())
+
+print(testForcedCastNStoSwiftSetDouble())
+print(testCondCastNStoSwiftSetDouble())
+
+print(testForcedCastNStoSwiftSetString())
+print(testCondCastNStoSwiftSetString())
+print("NS to Swift sets: End")
+
+
+// Basic types
+
+print("NS to Swift basic types: Start")
+print(testForcedCastNSNumberToSwiftInt())
+print(testCondCastNSNumberToSwiftInt())
+
+print(testForcedCastNSNumberToSwiftDouble())
+print(testCondCastNSNumberToSwiftDouble())
+
+print(testForcedCastNSIntNumberToSwiftDouble())
+print(testCondCastNSIntNumberToSwiftDouble())
+
+print(testForcedCastNStoSwiftString())
+print(testCondCastNStoSwiftString())
+print("NS to Swift basic types: End")
+
+//// Swift -> ObjC
+
+// Basic types
+
+print("Swift to NS basic types: Start")
+print(testForcedCastSwiftIntToNSNumber())
+print(testCondCastSwiftIntToNSNumber())
+
+print(testForcedCastSwiftDoubleToNSNumber())
+print(testCondCastSwiftDoubleToNSNumber())
+
+print(testForcedCastSwiftToNSString())
+print(testCondCastSwiftToNSString())
+print("Swift to NS basic types: End")
+
+// Arrays
+print("Swift to NS arrays: Start")
+
+print(testForcedCastSwiftToNSArrayInt())
+print(testCondCastSwiftToNSArrayInt())
+
+print(testForcedCastSwiftToNSArrayDouble())
+print(testCondCastSwiftToNSArrayDouble())
+
+print(testForcedCastSwiftToNSArrayString())
+print(testCondCastSwiftToNSArrayString())
+
+print("Swift to NS arrays: End")
+
+
+// Dicts
+print("Swift to NS dictionaries: Start")
+
+print(testForcedCastSwiftToNSDictInt())
+print(testCondCastSwiftToNSDictInt())
+
+print(testForcedCastSwiftToNSDictDouble())
+print(testCondCastSwiftToNSDictDouble())
+
+print(testForcedCastSwiftToNSDictString())
+print(testCondCastSwiftToNSDictString())
+
+print("Swift to NS dictionaries: End")
+
+// Sets
+print("Swift to NS sets: Start")
+
+print(testForcedCastSwiftToNSSetInt())
+print(testCondCastSwiftToNSSetInt())
+
+print(testForcedCastSwiftToNSSetDouble())
+print(testCondCastSwiftToNSSetDouble())
+
+print(testForcedCastSwiftToNSSetString())
+print(testCondCastSwiftToNSSetString())
+
+print("Swift to NS sets: End")
+
+// Check optimizations of casts from String to CFString
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding29testForcedCastSwiftToCFStringSo0I3RefayF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: unchecked_ref_cast{{.*}}: $NSString to $CFString
+// CHECK: end{{.*}}$S21bridged_casts_folding29testForcedCastSwiftToCFStringSo0I3RefayF
+@inline(never)
+public func testForcedCastSwiftToCFString() -> CFString {
+ let o: CFString = forcedCast(swiftString)
+ return o
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding27testCondCastSwiftToCFStringSo0I3RefaSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: unchecked_ref_cast{{.*}}: $NSString to $CFString
+// CHECK: end{{.*}}$S21bridged_casts_folding27testCondCastSwiftToCFStringSo0I3RefaSgyF
+@inline(never)
+public func testCondCastSwiftToCFString() -> CFString? {
+ let o: CFString? = condCast(swiftString)
+ return o
+}
+
+// Check optimizations of casts from Int to CFNumber
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding32testForcedCastSwiftIntToCFNumberSo0J3RefayF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: unchecked_ref_cast{{.*}}: $NSNumber to $CFNumber
+// CHECK: end{{.*}}$S21bridged_casts_folding32testForcedCastSwiftIntToCFNumberSo0J3RefayF
+@inline(never)
+public func testForcedCastSwiftIntToCFNumber() -> CFNumber {
+ let o: CFNumber = forcedCast(swiftIntNumber)
+ return o
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding30testCondCastSwiftIntToCFNumberSo0J3RefaSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: unchecked_ref_cast{{.*}}: $NSNumber to $CFNumber
+// CHECK: end{{.*}}$S21bridged_casts_folding30testCondCastSwiftIntToCFNumberSo0J3RefaSgyF
+@inline(never)
+public func testCondCastSwiftIntToCFNumber() -> CFNumber? {
+ let o: CFNumber? = condCast(swiftIntNumber)
+ return o
+}
+
+// Check optimization of casts from Swift Array to CFArray
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding31testForcedCastSwiftToCFArrayIntSo0I3RefayF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: unchecked_ref_cast{{.*}}: $NSArray to $CFArray
+// CHECK: end{{.*}}$S21bridged_casts_folding31testForcedCastSwiftToCFArrayIntSo0I3RefayF
+@inline(never)
+public func testForcedCastSwiftToCFArrayInt() -> CFArray {
+ let arr: CFArray = forcedCast(arrInt)
+ return arr
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding29testCondCastSwiftToCFArrayIntSo0I3RefaSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: unchecked_ref_cast{{.*}}: $NSArray to $CFArray
+// CHECK: end{{.*}}$S21bridged_casts_folding29testCondCastSwiftToCFArrayIntSo0I3RefaSgyF
+@inline(never)
+public func testCondCastSwiftToCFArrayInt() -> CFArray? {
+ let arrOpt: CFArray? = condCast(arrInt)
+ return arrOpt
+}
+
+// Check optimization of casts from Swift Dict to CFDictionary
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding30testForcedCastSwiftToCFDictIntSo15CFDictionaryRefayF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: unchecked_ref_cast{{.*}}: $NSDictionary to $CFDictionary
+// CHECK: end{{.*}}$S21bridged_casts_folding30testForcedCastSwiftToCFDictIntSo15CFDictionaryRefayF
+@inline(never)
+public func testForcedCastSwiftToCFDictInt() -> CFDictionary {
+ let dict: CFDictionary = forcedCast(dictInt)
+ return dict
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding28testCondCastSwiftToCFDictIntSo15CFDictionaryRefaSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: unchecked_ref_cast{{.*}}: $NSDictionary to $CFDictionary
+// CHECK: end{{.*}}$S21bridged_casts_folding28testCondCastSwiftToCFDictIntSo15CFDictionaryRefaSgyF
+@inline(never)
+public func testCondCastSwiftToCFDictInt() -> CFDictionary? {
+ let dictOpt: CFDictionary? = condCast(dictInt)
+ return dictOpt
+}
+
+// Check optimization of casts from Swift Set to CFSet
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding29testForcedCastSwiftToCFSetIntSo0I3RefayF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: unchecked_ref_cast{{.*}}: $NSSet to $CFSet
+// CHECK: end{{.*}}$S21bridged_casts_folding29testForcedCastSwiftToCFSetIntSo0I3RefayF
+@inline(never)
+public func testForcedCastSwiftToCFSetInt() -> CFSet {
+ let set: CFSet = forcedCast(setInt)
+ return set
+}
+
+// CHECK-LABEL: sil [noinline] @$S21bridged_casts_folding27testCondCastSwiftToCFSetIntSo0I3RefaSgyF
+// CHECK-NOT: unconditional_checked
+// CHECK: function_ref @{{.*}}_bridgeToObjectiveC
+// CHECK: unchecked_ref_cast{{.*}}: $NSSet to $CFSet
+// CHECK: end{{.*}}$S21bridged_casts_folding27testCondCastSwiftToCFSetIntSo0I3RefaSgyF
+@inline(never)
+public func testCondCastSwiftToCFSetInt() -> CFSet? {
+ let setOpt: CFSet? = condCast(setInt)
+ return setOpt
+}
+
+public class NSObjectSubclass : NSObject { }
+
+var anyHashable: AnyHashable = 0
+
+// CHECK-LABEL: $S21bridged_casts_folding29testUncondCastSwiftToSubclassAA08NSObjectI0CyF
+// CHECK: [[GLOBAL:%[0-9]+]] = global_addr @$S21bridged_casts_folding11anyHashables03AnyE0Vv
+// CHECK: [[FUNC:%.*]] = function_ref @$Ss11AnyHashableV10FoundationE19_bridgeToObjectiveCSo8NSObjectCyF
+// CHECK-NEXT: apply [[FUNC]]([[GLOBAL]])
+// CHECK-NEXT: unconditional_checked_cast {{%.*}} : $NSObject to $NSObjectSubclass
+// CHECK: } // end sil function '$S21bridged_casts_folding29testUncondCastSwiftToSubclassAA08NSObjectI0CyF'
+@inline(never)
+public func testUncondCastSwiftToSubclass() -> NSObjectSubclass {
+ return anyHashable as! NSObjectSubclass
+}
+
+class MyThing: Hashable {
+ let name: String
+
+ init(name: String) {
+ self.name = name
+ }
+
+ deinit {
+ Swift.print("Deinit \(name)")
+ }
+
+ var hashValue: Int {
+ return 0
+ }
+
+ static func ==(lhs: MyThing, rhs: MyThing) -> Bool {
+ return false
+ }
+}
+
+// CHECK-LABEL: sil hidden [noinline] @$S21bridged_casts_folding26doSomethingWithAnyHashableyys0gH0VF : $@convention(thin) (@in_guaranteed AnyHashable) -> () {
+// CHECK: %2 = alloc_stack $AnyHashable
+// CHECK: copy_addr %0 to [initialization] %2 : $*AnyHashable
+// CHECK: checked_cast_addr_br take_always AnyHashable in %2 : $*AnyHashable to MyThing
+@inline(never)
+func doSomethingWithAnyHashable(_ item: AnyHashable) {
+ _ = item as? MyThing
+}
+
+@inline(never)
+public func testMyThing() {
+ let x = MyThing(name: "B")
+ doSomethingWithAnyHashable(x)
+}
diff --git a/test/SILOptimizer/plus_zero_capture_promotion_generic_context.sil b/test/SILOptimizer/plus_zero_capture_promotion_generic_context.sil
new file mode 100644
index 0000000..8f08930
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_capture_promotion_generic_context.sil
@@ -0,0 +1,124 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-sil -O -Xllvm -sil-fso-enable-generics=false %s | %FileCheck %s
+
+sil_stage raw
+
+import Builtin
+
+typealias Int = Builtin.Int32
+
+// rdar://problem/28945854: When a nongeneric closure was formed inside a
+// generic function, the capture promotion pass would erroneously try to
+// apply the generic caller's substitutions to the nongeneric callee, violating
+// invariants.
+
+// CHECK-LABEL: sil @$S14promotable_boxTf2i_n : $@convention(thin) (Builtin.Int32) -> Builtin.Int32
+
+sil @promotable_box : $@convention(thin) (<τ_0_0> { var τ_0_0 } <Int>) -> Int {
+entry(%b : $<τ_0_0> { var τ_0_0 } <Int>):
+ %a = project_box %b : $<τ_0_0> { var τ_0_0 } <Int>, 0
+ %v = load %a : $*Int
+ return %v : $Int
+}
+
+// CHECK-LABEL: sil {{.*}}@call_promotable_box_from_generic
+// CHECK: [[F:%.*]] = function_ref @$S14promotable_boxTf2i_n
+// CHECK: partial_apply [callee_guaranteed] [[F]](
+
+sil @call_promotable_box_from_generic : $@convention(thin) <T> (@in T, Int) -> @owned @callee_guaranteed () -> Int {
+entry(%0 : $*T, %1 : $Int):
+ destroy_addr %0 : $*T
+ %f = function_ref @promotable_box : $@convention(thin) (<τ_0_0> { var τ_0_0 } <Int>) -> Int
+ %b = alloc_box $<τ_0_0> { var τ_0_0 } <Int>
+ %a = project_box %b : $<τ_0_0> { var τ_0_0 } <Int>, 0
+ store %1 to %a : $*Int
+ %k = partial_apply [callee_guaranteed] %f(%b) : $@convention(thin) (<τ_0_0> { var τ_0_0 } <Int>) -> Int
+ return %k : $@callee_guaranteed () -> Int
+}
+
+protocol P {}
+
+// CHECK-LABEL: sil @$S22generic_promotable_boxTf2ni_n : $@convention(thin) <T> (@in T, Builtin.Int32) -> Builtin.Int32
+// CHECK: bb0(%0 : $*T, %1 : $Builtin.Int32):
+// CHECK-NEXT: return %1 : $Builtin.Int32
+
+sil @generic_promotable_box : $@convention(thin) <T> (@in T, <τ_0_0> { var τ_0_0 } <Int>) -> Int {
+entry(%0 : $*T, %b : $<τ_0_0> { var τ_0_0 } <Int>):
+ %a = project_box %b : $<τ_0_0> { var τ_0_0 } <Int>, 0
+ %v = load %a : $*Int
+ return %v : $Int
+}
+
+// CHECK-LABEL: sil @call_generic_promotable_box_from_different_generic
+// CHECK: bb0(%0 : $*T, %1 : $*U, %2 : $Builtin.Int32):
+// CHECK-NEXT: destroy_addr %0 : $*T
+// CHECK-NEXT: destroy_addr %1 : $*U
+// CHECK: [[F:%.*]] = function_ref @$S22generic_promotable_boxTf2ni_n : $@convention(thin) <τ_0_0> (@in τ_0_0, Builtin.Int32) -> Builtin.Int32
+// CHECK-NEXT: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[F]]<U>(%2)
+// CHECK-NEXT: return [[CLOSURE]]
+
+sil @call_generic_promotable_box_from_different_generic : $@convention(thin) <T, U: P> (@in T, @in U, Int) -> @owned @callee_guaranteed (@in U) -> Int {
+entry(%0 : $*T, %1 : $*U, %2 : $Int):
+ destroy_addr %0 : $*T
+ destroy_addr %1 : $*U
+ %f = function_ref @generic_promotable_box : $@convention(thin) <V> (@in V, <τ_0_0> { var τ_0_0 } <Int>) -> Int
+ %b = alloc_box $<τ_0_0> { var τ_0_0 } <Int>
+ %a = project_box %b : $<τ_0_0> { var τ_0_0 } <Int>, 0
+ store %2 to %a : $*Int
+ %k = partial_apply [callee_guaranteed] %f<U>(%b) : $@convention(thin) <V> (@in V, <τ_0_0> { var τ_0_0 } <Int>) -> Int
+ return %k : $@callee_guaranteed (@in U) -> Int
+}
+
+enum E<X> {
+ case None
+ case Some(X)
+}
+
+struct R<T> {
+}
+
+// Check that the capture promotion took place and the function now
+// take argument of a type E<(R<T>) -> Builtin.Int32>, which used
+// to be a slot inside a box.
+// CHECK-LABEL: sil @$S23generic_promotable_box2Tf2nni_n : $@convention(thin) <T> (@in R<T>, @in Builtin.Int32, @owned E<(R<T>) -> Builtin.Int32>) -> ()
+// CHECK: bb0(%0 : $*R<T>, %1 : $*Builtin.Int32, %2 : $E<(R<T>) -> Builtin.Int32>):
+// CHECK-NOT: project_box
+// CHECK: switch_enum %2 : $E<(R<T>) -> Builtin.Int32>
+// CHECK-NOT: project_box
+// CHECK: } // end sil function '$S23generic_promotable_box2Tf2nni_n'
+sil @generic_promotable_box2 : $@convention(thin) <T> (@in R<T>, @in Int, <τ_0_0> { var E<(R<τ_0_0>) -> Int> } <T>) -> () {
+entry(%0: $*R<T>, %1 : $*Int, %b : $<τ_0_0> { var E< (R<τ_0_0>)->Int > } <T>):
+ %a = project_box %b : $<τ_0_0> { var E<(R<τ_0_0>)->Int> } <T>, 0
+ %e = load %a : $*E<(R<T>)->Int>
+ switch_enum %e : $E<(R<T>)->Int>, case #E.Some!enumelt.1 : bb1, default bb2
+
+bb1(%f : $@callee_guaranteed (@in_guaranteed R<T>) -> @out Int):
+ %t = tuple ()
+ apply %f(%1, %0) : $@callee_guaranteed (@in_guaranteed R<T>) -> @out Int
+ br exit
+bb2:
+ br exit
+exit:
+ %r = tuple ()
+ return %r : $()
+}
+
+// Check that alloc_box was eliminated and a specialized version of the
+// closure is invoked.
+// CHECK-LABEL: sil @call_generic_promotable_box_from_different_generic2
+// CHECK: bb0(%0 : $*R<T>, %1 : $*E<(R<U>) -> Builtin.Int32>, %2 : $*Builtin.Int32):
+// CHECK: %3 = load %1 : $*E<(R<U>) -> Builtin.Int32>
+// CHECK: [[F:%.*]] = function_ref @$S23generic_promotable_box2Tf2nni_n : $@convention(thin) <τ_0_0> (@in R<τ_0_0>, @in Builtin.Int32, @owned E<(R<τ_0_0>) -> Builtin.Int32>) -> ()
+// CHECK-NEXT: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[F]]<U>(%2, %3)
+// CHECK-NEXT: return [[CLOSURE]]
+
+sil @call_generic_promotable_box_from_different_generic2 : $@convention(thin) <T, U: P> (@in R<T>, @in E<(R<U>)->Int>, @in Int) -> @owned @callee_guaranteed (@in R<U>) -> () {
+entry(%0 : $*R<T>, %1 : $*E<(R<U>)->Int>, %2 : $*Int):
+ destroy_addr %0 : $*R<T>
+ %f = function_ref @generic_promotable_box2 : $@convention(thin) <V> (@in R<V>, @in Int, <τ_0_0> { var E<(R<τ_0_0>)->Int> } <V>) -> ()
+ %b = alloc_box $<τ_0_0> { var E<(R<τ_0_0>)->Int> } <U>
+ %a = project_box %b : $<τ_0_0> { var E<(R<τ_0_0>)->Int> } <U>, 0
+ copy_addr [take] %1 to [initialization] %a : $*E<(R<U>)->Int>
+ %k = partial_apply [callee_guaranteed] %f<U>(%2, %b) : $@convention(thin) <V> (@in R<V>, @in Int, <τ_0_0> { var E<(R<τ_0_0>)->Int> } <V>) -> ()
+ return %k : $@callee_guaranteed (@in R<U>) -> ()
+}
diff --git a/test/SILOptimizer/plus_zero_capture_promotion_generic_context_ownership.sil b/test/SILOptimizer/plus_zero_capture_promotion_generic_context_ownership.sil
new file mode 100644
index 0000000..77ac818
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_capture_promotion_generic_context_ownership.sil
@@ -0,0 +1,131 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -emit-sil -O -Xllvm -sil-fso-enable-generics=false %s | %FileCheck %s
+
+sil_stage raw
+
+import Builtin
+
+typealias Int = Builtin.Int32
+
+// rdar://problem/28945854: When a nongeneric closure was formed inside a
+// generic function, the capture promotion pass would erroneously try to
+// apply the generic caller's substitutions to the nongeneric callee, violating
+// invariants.
+
+// CHECK-LABEL: sil @$S14promotable_boxTf2i_n : $@convention(thin) (Builtin.Int32) -> Builtin.Int32
+sil @promotable_box : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> Int {
+entry(%b : @owned $<τ_0_0> { var τ_0_0 } <Int>):
+ %a = project_box %b : $<τ_0_0> { var τ_0_0 } <Int>, 0
+ %v = load [trivial] %a : $*Int
+ destroy_value %b : $<τ_0_0> { var τ_0_0 } <Int>
+ return %v : $Int
+}
+
+// CHECK-LABEL: sil {{.*}}@call_promotable_box_from_generic
+// CHECK: [[F:%.*]] = function_ref @$S14promotable_boxTf2i_n
+// CHECK: partial_apply [callee_guaranteed] [[F]](
+
+sil @call_promotable_box_from_generic : $@convention(thin) <T> (@in T, Int) -> @owned @callee_guaranteed () -> Int {
+entry(%0 : @trivial $*T, %1 : @trivial $Int):
+ destroy_addr %0 : $*T
+ %f = function_ref @promotable_box : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> Int
+ %b = alloc_box $<τ_0_0> { var τ_0_0 } <Int>
+ %a = project_box %b : $<τ_0_0> { var τ_0_0 } <Int>, 0
+ store %1 to [trivial] %a : $*Int
+ %k = partial_apply [callee_guaranteed] %f(%b) : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> Int
+ return %k : $@callee_guaranteed () -> Int
+}
+
+protocol P {}
+
+// CHECK-LABEL: sil @$S22generic_promotable_boxTf2ni_n : $@convention(thin) <T> (@in T, Builtin.Int32) -> Builtin.Int32
+// CHECK: bb0([[ARG0:%.*]] : $*T, [[ARG1:%.*]] : $Builtin.Int32):
+// CHECK-NEXT: return [[ARG1]] : $Builtin.Int32
+
+sil @generic_promotable_box : $@convention(thin) <T> (@in T, @owned <τ_0_0> { var τ_0_0 } <Int>) -> Int {
+entry(%0 : @trivial $*T, %b : @owned $<τ_0_0> { var τ_0_0 } <Int>):
+ %a = project_box %b : $<τ_0_0> { var τ_0_0 } <Int>, 0
+ %v = load [trivial] %a : $*Int
+ destroy_value %b : $<τ_0_0> { var τ_0_0 } <Int>
+ return %v : $Int
+}
+
+// CHECK-LABEL: sil @call_generic_promotable_box_from_different_generic
+// CHECK: bb0([[ARG0:%.*]] : $*T, [[ARG1:%.*]] : $*U, [[ARG2:%.*]] : $Builtin.Int32):
+// CHECK-NEXT: destroy_addr [[ARG0]] : $*T
+// CHECK-NEXT: destroy_addr [[ARG1]] : $*U
+// CHECK: [[F:%.*]] = function_ref @$S22generic_promotable_boxTf2ni_n : $@convention(thin) <τ_0_0> (@in τ_0_0, Builtin.Int32) -> Builtin.Int32
+// CHECK-NEXT: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[F]]<U>([[ARG2]])
+// CHECK-NEXT: return [[CLOSURE]]
+
+sil @call_generic_promotable_box_from_different_generic : $@convention(thin) <T, U: P> (@in T, @in U, Int) -> @owned @callee_guaranteed (@in U) -> Int {
+entry(%0 : @trivial $*T, %1 : @trivial $*U, %2 : @trivial $Int):
+ destroy_addr %0 : $*T
+ destroy_addr %1 : $*U
+ %f = function_ref @generic_promotable_box : $@convention(thin) <V> (@in V, @owned <τ_0_0> { var τ_0_0 } <Int>) -> Int
+ %b = alloc_box $<τ_0_0> { var τ_0_0 } <Int>
+ %a = project_box %b : $<τ_0_0> { var τ_0_0 } <Int>, 0
+ store %2 to [trivial] %a : $*Int
+ %k = partial_apply [callee_guaranteed] %f<U>(%b) : $@convention(thin) <V> (@in V, @owned <τ_0_0> { var τ_0_0 } <Int>) -> Int
+ return %k : $@callee_guaranteed (@in U) -> Int
+}
+
+enum E<X> {
+ case None
+ case Some(X)
+}
+
+struct R<T> {
+}
+
+// Check that the capture promotion took place and the function now
+// take argument of a type E<(R<T>) -> Builtin.Int32>, which used
+// to be a slot inside a box.
+// CHECK-LABEL: sil @$S23generic_promotable_box2Tf2nni_n : $@convention(thin) <T> (@in R<T>, @in Builtin.Int32, @owned E<(R<T>) -> Builtin.Int32>) -> ()
+// CHECK: bb0([[ARG0:%.*]] : $*R<T>, [[ARG1:%.*]] : $*Builtin.Int32, [[ARG2:%.*]] : $E<(R<T>) -> Builtin.Int32>):
+// CHECK-NOT: project_box
+// CHECK: switch_enum [[ARG2]] : $E<(R<T>) -> Builtin.Int32>
+// CHECK-NOT: project_box
+// CHECK: } // end sil function '$S23generic_promotable_box2Tf2nni_n'
+sil @generic_promotable_box2 : $@convention(thin) <T> (@in R<T>, @in Int, @owned <τ_0_0> { var E<(R<τ_0_0>) -> Int> } <T>) -> () {
+entry(%0 : @trivial $*R<T>, %1 : @trivial $*Int, %b : @owned $<τ_0_0> { var E<(R<τ_0_0>)->Int> } <T>):
+ %a = project_box %b : $<τ_0_0> { var E<(R<τ_0_0>)->Int> } <T>, 0
+ %e = load [copy] %a : $*E<(R<T>)->Int>
+ switch_enum %e : $E<(R<T>)->Int>, case #E.Some!enumelt.1 : bb1, default bb2
+
+bb1(%f : @owned $@callee_guaranteed (@in_guaranteed R<T>) -> @out Int):
+ %bf = begin_borrow %f : $@callee_guaranteed (@in_guaranteed R<T>) -> @out Int
+ apply %bf(%1, %0) : $@callee_guaranteed (@in_guaranteed R<T>) -> @out Int
+ end_borrow %bf from %f : $@callee_guaranteed (@in_guaranteed R<T>) -> @out Int , $@callee_guaranteed (@in_guaranteed R<T>) -> @out Int
+ destroy_value %f : $@callee_guaranteed (@in_guaranteed R<T>) -> @out Int
+ br exit
+
+bb2(%original : @owned $E<(R<T>)->Int>):
+ destroy_value %original : $E<(R<T>)->Int>
+ br exit
+
+exit:
+ destroy_value %b : $<τ_0_0> { var E<(R<τ_0_0>)->Int> } <T>
+ %r = tuple ()
+ return %r : $()
+}
+
+// Check that alloc_box was eliminated and a specialized version of the
+// closure is invoked.
+// CHECK-LABEL: sil @call_generic_promotable_box_from_different_generic2
+// CHECK: bb0([[ARG0:%.*]] : $*R<T>, [[ARG1:%.*]] : $*E<(R<U>) -> Builtin.Int32>, [[ARG2:%.*]] : $*Builtin.Int32):
+// CHECK: %3 = load [[ARG1]] : $*E<(R<U>) -> Builtin.Int32>
+// CHECK: [[F:%.*]] = function_ref @$S23generic_promotable_box2Tf2nni_n : $@convention(thin) <τ_0_0> (@in R<τ_0_0>, @in Builtin.Int32, @owned E<(R<τ_0_0>) -> Builtin.Int32>) -> ()
+// CHECK-NEXT: [[CLOSURE:%.*]] = partial_apply [callee_guaranteed] [[F]]<U>(%2, %3)
+// CHECK-NEXT: return [[CLOSURE]]
+
+sil @call_generic_promotable_box_from_different_generic2 : $@convention(thin) <T, U: P> (@in R<T>, @in E<(R<U>)->Int>, @in Int) -> @owned @callee_guaranteed (@in R<U>) -> () {
+entry(%0 : @trivial $*R<T>, %1 : @trivial $*E<(R<U>)->Int>, %2 : @trivial $*Int):
+ destroy_addr %0 : $*R<T>
+ %f = function_ref @generic_promotable_box2 : $@convention(thin) <V> (@in R<V>, @in Int, @owned <τ_0_0> { var E<(R<τ_0_0>)->Int> } <V>) -> ()
+ %b = alloc_box $<τ_0_0> { var E<(R<τ_0_0>)->Int> } <U>
+ %a = project_box %b : $<τ_0_0> { var E<(R<τ_0_0>)->Int> } <U>, 0
+ copy_addr [take] %1 to [initialization] %a : $*E<(R<U>)->Int>
+ %k = partial_apply [callee_guaranteed] %f<U>(%2, %b) : $@convention(thin) <V> (@in R<V>, @in Int, @owned <τ_0_0> { var E<(R<τ_0_0>)->Int> } <V>) -> ()
+ return %k : $@callee_guaranteed (@in R<U>) -> ()
+}
diff --git a/test/SILOptimizer/plus_zero_cast_folding_no_bridging.sil b/test/SILOptimizer/plus_zero_cast_folding_no_bridging.sil
new file mode 100644
index 0000000..4b4c661
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_cast_folding_no_bridging.sil
@@ -0,0 +1,103 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -O -emit-sil %s | %FileCheck %s
+// REQUIRES: objc_interop
+
+// We want to check that casts between two types which are both Swift types or
+// both are ObjC types are not optimized by the cast optimizer into casts
+// to/from ObjC.
+
+sil_stage raw
+
+import Builtin
+import Swift
+import SwiftShims
+import Foundation
+
+
+// CHECK-LABEL: sil @testSwiftToSwift : $@convention(thin) (@in Set<Int>, @guaranteed Set<Int>)
+// CHECK: bb0
+// CHECK-NOT: checked_cast_addr_br
+// CHECK-NOT: _bridgeToObjectiveC
+// CHECK-NOT: _conditionallyBridgeFromObjectiveC_bridgeable
+// CHECK: return
+sil @testSwiftToSwift : $@convention(thin) (@in Set<Int>, @guaranteed Set<Int>) -> @owned Set<Int> {
+bb0(%0 : $*Set<Int>, %1 : $Set<Int>):
+ %3 = alloc_stack $Set<Int>
+ copy_addr %0 to [initialization] %3 : $*Set<Int>
+ %5 = alloc_stack $Set<Int>
+ checked_cast_addr_br take_always Set<Int> in %3 : $*Set<Int> to Set<Int> in %5 : $*Set<Int>, bb1, bb3
+
+bb1:
+ destroy_addr %0 : $*Set<Int>
+ %8 = load %5 : $*Set<Int>
+ br bb2(%8 : $Set<Int>)
+
+bb2(%14 : $Set<Int>):
+ dealloc_stack %5 : $*Set<Int>
+ dealloc_stack %3 : $*Set<Int>
+ return %14 : $Set<Int>
+
+bb3:
+ br bb2(%1 : $Set<Int>)
+}
+
+// CHECK-LABEL: sil @testObjCToObjC : $@convention(thin) (NSSet, NSSet)
+// CHECK: bb0
+// CHECK-NOT: checked_cast_br
+// CHECK-NOT: BridgeFromObjectiveC
+// CHECK-NOT: bridgeToObjectiveC
+// CHECK: return
+sil @testObjCToObjC : $@convention(thin) (NSSet, NSSet) -> @owned NSSet {
+bb0(%0 : $NSSet, %1 : $NSSet):
+ checked_cast_br %0 : $NSSet to $NSSet, bb1, bb3
+
+bb1(%2 : $NSSet):
+ br bb2(%2 : $NSSet)
+
+bb2(%14 : $NSSet):
+ return %14 : $NSSet
+
+bb3:
+ br bb2(%1 : $NSSet)
+}
+
+sil @fail : $@convention(thin) () -> Never
+
+// CHECK-LABEL: sil @testCFToObjC
+// CHECK: bb0(
+// CHECK-NEXT: [[T0:%.*]] = load %1 : $*CFString
+// CHECK-NEXT: [[T1:%.*]] = unchecked_ref_cast [[T0]] : $CFString to $NSString
+// CHECK-NEXT: store [[T1]] to %0 : $*NSString
+sil @testCFToObjC : $@convention(thin) (@in CFString) -> @out NSString {
+bb0(%0 : $*NSString, %1 : $*CFString):
+ checked_cast_addr_br take_always CFString in %1 : $*CFString to NSString in %0 : $*NSString, bb1, bb2
+
+bb1:
+ %ret = tuple ()
+ return %ret : $()
+
+bb2:
+ %fn = function_ref @fail : $@convention(thin) () -> Never
+ apply %fn() : $@convention(thin) () -> Never
+ unreachable
+}
+
+// CHECK-LABEL: sil @testCFToSwift
+// CHECK: bb0(
+// CHECK-NEXT: [[T0:%.*]] = load %1 : $*CFString
+// CHECK-NEXT: [[T1:%.*]] = unchecked_ref_cast [[T0]] : $CFString to $NSString
+// CHECK: [[FN:%.*]] = function_ref @$SSS10FoundationE34_conditionallyBridgeFromObjectiveC_6resultSbSo8NSStringC_SSSgztFZ : $@convention(method) (@guaranteed NSString, @inout Optional<String>, @thin String.Type) -> Bool
+// CHECK: apply [[FN]]([[T1]], {{.*}}, {{.*}})
+sil @testCFToSwift : $@convention(thin) (@in CFString) -> @out String {
+bb0(%0 : $*String, %1 : $*CFString):
+ checked_cast_addr_br take_always CFString in %1 : $*CFString to String in %0 : $*String, bb1, bb2
+
+bb1:
+ %ret = tuple ()
+ return %ret : $()
+
+bb2:
+ %fn = function_ref @fail : $@convention(thin) () -> Never
+ apply %fn() : $@convention(thin) () -> Never
+ unreachable
+}
diff --git a/test/SILOptimizer/plus_zero_cast_folding_objc_generics.swift b/test/SILOptimizer/plus_zero_cast_folding_objc_generics.swift
new file mode 100644
index 0000000..effe201
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_cast_folding_objc_generics.swift
@@ -0,0 +1,29 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -O -emit-sil %s | %FileCheck %s
+// REQUIRES: objc_interop
+
+import objc_generics
+
+// CHECK-LABEL: sil shared [noinline] @$S26cast_folding_objc_generics26testObjCGenericParamChangeySo12GenericClassCySo8NSStringCGADySo15NSMutableStringCGFTf4n_g : $@convention(thin) (@guaranteed GenericClass<NSMutableString>) -> GenericClass<NSString> {
+// CHECK: upcast
+// CHECK-NOT: int_trap
+@inline(never)
+public func testObjCGenericParamChange(_ a: GenericClass<NSMutableString>) -> GenericClass<NSString> {
+ return a as! GenericClass<NSString>
+}
+
+// CHECK-LABEL: sil shared [noinline] @$S26cast_folding_objc_generics34testObjCGenericParamChangeSubclassySo07GenericJ0CySo8NSStringCGSo0K5ClassCySo15NSMutableStringCGFTf4n_g : $@convention(thin) (@guaranteed GenericClass<NSMutableString>) -> GenericSubclass<NSString> {
+// CHECK: unconditional_checked_cast
+// CHECK-NOT: int_trap
+@inline(never)
+public func testObjCGenericParamChangeSubclass(_ a: GenericClass<NSMutableString>) -> GenericSubclass<NSString> {
+ return a as! GenericSubclass<NSString>
+}
+
+// CHECK-LABEL: sil shared [noinline] @$S26cast_folding_objc_generics36testObjCGenericParamChangeSuperclassySo12GenericClassCySo8NSStringCGSo0K8SubclassCySo15NSMutableStringCGFTf4n_g : $@convention(thin) (@guaranteed GenericSubclass<NSMutableString>) -> GenericClass<NSString> {
+// CHECK: upcast
+// CHECK-NOT: int_trap
+@inline(never)
+public func testObjCGenericParamChangeSuperclass(_ a: GenericSubclass<NSMutableString>) -> GenericClass<NSString> {
+ return a as! GenericClass<NSString>
+}
diff --git a/test/SILOptimizer/plus_zero_cast_folding_objc_no_foundation.swift b/test/SILOptimizer/plus_zero_cast_folding_objc_no_foundation.swift
new file mode 100644
index 0000000..5648147
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_cast_folding_objc_no_foundation.swift
@@ -0,0 +1,67 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -O -emit-sil %s | %FileCheck %s
+// REQUIRES: objc_interop
+
+// TODO: Update optimizer for id-as-Any changes.
+
+// Note: no 'import Foundation'
+
+struct PlainStruct {}
+
+// CHECK-LABEL: sil hidden [noinline] @$S31cast_folding_objc_no_foundation23testAnyObjectToArrayIntySbyXlF : $@convention(thin) (@guaranteed AnyObject) -> Bool {
+// CHECK: bb0(%0 : $AnyObject):
+// CHECK: [[SOURCE:%.*]] = alloc_stack $AnyObject
+// CHECK: [[TARGET:%.*]] = alloc_stack $Array<Int>
+// CHECK: checked_cast_addr_br take_always AnyObject in [[SOURCE]] : $*AnyObject to Array<Int> in [[TARGET]] : $*Array<Int>, bb1, bb2
+@inline(never)
+func testAnyObjectToArrayInt(_ a: AnyObject) -> Bool {
+ return a is [Int]
+}
+
+// CHECK-LABEL: sil hidden [noinline] @$S31cast_folding_objc_no_foundation26testAnyObjectToArrayStringySbyXlF : $@convention(thin) (@guaranteed AnyObject) -> Bool {
+// CHECK: bb0(%0 : $AnyObject):
+// CHECK: [[SOURCE:%.*]] = alloc_stack $AnyObject
+// CHECK: [[TARGET:%.*]] = alloc_stack $Array<String>
+// CHECK: checked_cast_addr_br take_always AnyObject in [[SOURCE]] : $*AnyObject to Array<String> in [[TARGET]] : $*Array<String>, bb1, bb2
+@inline(never)
+func testAnyObjectToArrayString(_ a: AnyObject) -> Bool {
+ return a is [String]
+}
+
+// CHECK-LABEL: sil hidden [noinline] @$S31cast_folding_objc_no_foundation30testAnyObjectToArrayNotBridgedySbyXlF : $@convention(thin) (@guaranteed AnyObject) -> Bool {
+// CHECK: bb0(%0 : $AnyObject):
+// CHECK: [[SOURCE:%.*]] = alloc_stack $AnyObject
+// CHECK: [[TARGET:%.*]] = alloc_stack $Array<PlainStruct>
+// CHECK: checked_cast_addr_br take_always AnyObject in [[SOURCE]] : $*AnyObject to Array<PlainStruct> in [[TARGET]] : $*Array<PlainStruct>, bb1, bb2
+@inline(never)
+func testAnyObjectToArrayNotBridged(_ a: AnyObject) -> Bool {
+ return a is [PlainStruct]
+}
+
+// CHECK-LABEL: sil hidden [noinline] @$S31cast_folding_objc_no_foundation25testAnyObjectToDictionaryySbyXlF : $@convention(thin) (@guaranteed AnyObject) -> Bool {
+// CHECK: bb0(%0 : $AnyObject):
+// CHECK: [[SOURCE:%.*]] = alloc_stack $AnyObject
+// CHECK: [[TARGET:%.*]] = alloc_stack $Dictionary<Int, String>
+// CHECK: checked_cast_addr_br take_always AnyObject in [[SOURCE]] : $*AnyObject to Dictionary<Int, String> in [[TARGET]] : $*Dictionary<Int, String>, bb1, bb2
+@inline(never)
+func testAnyObjectToDictionary(_ a: AnyObject) -> Bool {
+ return a is [Int: String]
+}
+
+// CHECK-LABEL: sil hidden [noinline] @$S31cast_folding_objc_no_foundation21testAnyObjectToStringySbyXlF : $@convention(thin) (@guaranteed AnyObject) -> Bool {
+// CHECK: bb0(%0 : $AnyObject):
+// CHECK: [[SOURCE:%.*]] = alloc_stack $AnyObject
+// CHECK: [[TARGET:%.*]] = alloc_stack $String
+// CHECK: checked_cast_addr_br take_always AnyObject in [[SOURCE]] : $*AnyObject to String in [[TARGET]] : $*String, bb1, bb2
+@inline(never)
+func testAnyObjectToString(_ a: AnyObject) -> Bool {
+ return a is String
+}
+
+class SomeObject {}
+
+print(testAnyObjectToArrayInt(SomeObject()))
+print(testAnyObjectToArrayString(SomeObject()))
+print(testAnyObjectToArrayNotBridged(SomeObject()))
+print(testAnyObjectToDictionary(SomeObject()))
+print(testAnyObjectToString(SomeObject()))
diff --git a/test/SILOptimizer/plus_zero_devirt_covariant_return.swift b/test/SILOptimizer/plus_zero_devirt_covariant_return.swift
new file mode 100644
index 0000000..8c12f8d
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_devirt_covariant_return.swift
@@ -0,0 +1,351 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -O -Xllvm -disable-sil-cm-rr-cm=0 -Xllvm -sil-inline-generics=false -primary-file %s -emit-sil -sil-inline-threshold 1000 -Xllvm -sil-disable-pass=ObjectOutliner -sil-verify-all | %FileCheck %s
+
+// Make sure that we can dig all the way through the class hierarchy and
+// protocol conformances with covariant return types correctly. The verifier
+// should trip if we do not handle things correctly.
+//
+// TODO: this is not working right now: rdar://problem/33461095
+// As a side-test it also checks if all allocs can be promoted to the stack.
+
+// CHECK-LABEL: sil hidden @$S23devirt_covariant_return6driveryyF : $@convention(thin) () -> () {
+// CHECK: bb0
+// CHECK: alloc_ref
+// CHECK: alloc_ref
+// CHECK: function_ref @unknown1a : $@convention(thin) () -> ()
+// CHECK: apply
+// CHECK: function_ref @defenestrate : $@convention(thin) () -> ()
+// CHECK: apply
+// CHECK: function_ref @unknown2a : $@convention(thin) () -> ()
+// CHECK: apply
+// CHECK: apply
+// CHECK: function_ref @unknown3a : $@convention(thin) () -> ()
+// CHECK: apply
+// CHECK: apply
+// CHECK: tuple
+// CHECK: return
+
+@_silgen_name("unknown1a")
+func unknown1a() -> ()
+@_silgen_name("unknown1b")
+func unknown1b() -> ()
+@_silgen_name("unknown2a")
+func unknown2a() -> ()
+@_silgen_name("unknown2b")
+func unknown2b() -> ()
+@_silgen_name("unknown3a")
+func unknown3a() -> ()
+@_silgen_name("unknown3b")
+func unknown3b() -> ()
+@_silgen_name("defenestrate")
+func defenestrate() -> ()
+
+class B<T> {
+ // We do not specialize typealias's correctly now.
+ //typealias X = B
+ func doSomething() -> B<T> {
+ unknown1a()
+ return self
+ }
+
+ // See comment in protocol P
+ //class func doSomethingMeta() {
+ // unknown1b()
+ //}
+
+ func doSomethingElse() {
+ defenestrate()
+ }
+}
+
+class B2<T> : B<T> {
+ // When we have covariance in protocols, change this to B2.
+ // We do not specialize typealias correctly now.
+ //typealias X = B
+ override func doSomething() -> B2<T> {
+ unknown2a()
+ return self
+ }
+
+ // See comment in protocol P
+ //override class func doSomethingMeta() {
+ // unknown2b()
+ //}
+}
+
+class B3<T> : B2<T> {
+ override func doSomething() -> B3<T> {
+ unknown3a()
+ return self
+ }
+}
+
+func WhatShouldIDo<T>(_ b : B<T>) -> B<T> {
+ b.doSomething().doSomethingElse()
+ return b
+}
+
+func doSomethingWithB<T>(_ b : B<T>) {
+
+}
+
+struct S {}
+
+func driver() -> () {
+ let b = B<S>()
+ let b2 = B2<S>()
+ let b3 = B3<S>()
+
+ WhatShouldIDo(b)
+ WhatShouldIDo(b2)
+ WhatShouldIDo(b3)
+}
+
+driver()
+
+public class Bear {
+ public init?(fail: Bool) {
+ if fail { return nil }
+ }
+
+ // Check that devirtualizer can handle convenience initializers, which have covariant optional
+ // return types.
+ // CHECK-LABEL: sil @$S23devirt_covariant_return4BearC{{[_0-9a-zA-Z]*}}fc
+ // CHECK: checked_cast_br [exact] %{{.*}} : $Bear to $PolarBear
+ // CHECK: upcast %{{.*}} : $Optional<PolarBear> to $Optional<Bear>
+ // CHECK: }
+ public convenience init?(delegateFailure: Bool, failAfter: Bool) {
+ self.init(fail: delegateFailure)
+ if failAfter { return nil }
+ }
+}
+
+final class PolarBear: Bear {
+
+ override init?(fail: Bool) {
+ super.init(fail: fail)
+ }
+
+ init?(chainFailure: Bool, failAfter: Bool) {
+ super.init(fail: chainFailure)
+ if failAfter { return nil }
+ }
+}
+
+
+
+
+class Payload {
+ let value: Int32
+ init(_ n: Int32) {
+ value = n
+ }
+
+ func getValue() -> Int32 {
+ return value
+ }
+}
+
+final class Payload1: Payload {
+ override init(_ n: Int32) {
+ super.init(n)
+ }
+}
+
+class C {
+ func doSomething() -> Payload? {
+ return Payload(1)
+ }
+}
+
+
+final class C1:C {
+ // Override base method, but return a non-optional result
+ override func doSomething() -> Payload {
+ return Payload(2)
+ }
+}
+
+final class C2:C {
+ // Override base method, but return a non-optional result of a type,
+ // which is derived from the expected type.
+ override func doSomething() -> Payload1 {
+ return Payload1(2)
+ }
+}
+
+// Check that the Optional return value from doSomething
+// gets properly unwrapped into a Payload object and then further
+// devirtualized.
+// CHECK-LABEL: sil hidden [noinline] @$S23devirt_covariant_return7driver1ys5Int32VAA2C1CF
+// CHECK: integer_literal $Builtin.Int32, 2
+// CHECK: struct $Int32 (%{{.*}} : $Builtin.Int32)
+// CHECK-NOT: class_method
+// CHECK-NOT: function_ref
+// CHECK: return
+@inline(never)
+func driver1(_ c: C1) -> Int32 {
+ return c.doSomething().getValue()
+}
+
+// Check that the Optional return value from doSomething
+// gets properly unwrapped into a Payload object and then further
+// devirtualized.
+// CHECK-LABEL: sil hidden [noinline] @$S23devirt_covariant_return7driver3ys5Int32VAA1CCF
+// CHECK: bb{{[0-9]+}}(%{{[0-9]+}} : $C2):
+// CHECK-NOT: bb{{.*}}:
+// check that for C2, we convert the non-optional result into an optional and then cast.
+// CHECK: enum $Optional
+// CHECK-NEXT: upcast
+// CHECK: return
+@inline(never)
+func driver3(_ c: C) -> Int32 {
+ return c.doSomething()!.getValue()
+}
+
+public class D {
+ let v: Int32
+ init(_ n: Int32) {
+ v = n
+ }
+}
+
+public class D1 : D {
+
+ public func foo() -> D? {
+ return nil
+ }
+
+ public func boo() -> Int32 {
+ return foo()!.v
+ }
+}
+
+let sD = D(0)
+
+public class D2: D1 {
+ // Override base method, but return a non-optional result
+ override public func foo() -> D {
+ return sD
+ }
+}
+
+// Check that the boo call gets properly devirtualized and that
+// that D2.foo() is inlined thanks to this.
+// CHECK-LABEL: sil hidden [noinline] @$S23devirt_covariant_return7driver2ys5Int32VAA2D2CF
+// CHECK-NOT: class_method
+// CHECK: checked_cast_br [exact] %{{.*}} : $D1 to $D2
+// CHECK: bb2
+// CHECK: global_addr
+// CHECK: load
+// CHECK: ref_element_addr
+// CHECK: bb3
+// CHECK: class_method
+// CHECK: }
+@inline(never)
+func driver2(_ d: D2) -> Int32 {
+ return d.boo()
+}
+
+class AA {
+}
+
+class BB : AA {
+}
+
+class CCC {
+ @inline(never)
+ func foo(_ b: BB) -> (AA, AA) {
+ return (b, b)
+ }
+}
+
+class DDD : CCC {
+ @inline(never)
+ override func foo(_ b: BB) -> (BB, BB) {
+ return (b, b)
+ }
+}
+
+
+class EEE : CCC {
+ @inline(never)
+ override func foo(_ b: BB) -> (AA, AA) {
+ return (b, b)
+ }
+}
+
+// Check that c.foo() is devirtualized, because the optimizer can handle the casting the return type
+// correctly, i.e. it can cast (BBB, BBB) into (AAA, AAA)
+// CHECK-LABEL: sil hidden [noinline] @$S23devirt_covariant_return37testDevirtOfMethodReturningTupleTypes_1bAA2AAC_AEtAA3CCCC_AA2BBCtF
+// CHECK: checked_cast_br [exact] %{{.*}} : $CCC to $CCC
+// CHECK: checked_cast_br [exact] %{{.*}} : $CCC to $DDD
+// CHECK: checked_cast_br [exact] %{{.*}} : $CCC to $EEE
+// CHECK: class_method
+// CHECK: }
+@inline(never)
+func testDevirtOfMethodReturningTupleTypes(_ c: CCC, b: BB) -> (AA, AA) {
+ return c.foo(b)
+}
+
+
+class AAAA {
+}
+
+class BBBB : AAAA {
+}
+
+class CCCC {
+ let a: BBBB
+ var foo : (AAAA, AAAA) {
+ @inline(never)
+ get {
+ return (a, a)
+ }
+ }
+ init(x: BBBB) { a = x }
+}
+
+class DDDD : CCCC {
+ override var foo : (BBBB, BBBB) {
+ @inline(never)
+ get {
+ return (a, a)
+ }
+ }
+}
+
+// Check devirtualization of methods with optional results, where
+// optional results need to be casted.
+// CHECK-LABEL: sil [noinline] @{{.*}}testOverridingMethodWithOptionalResult
+// CHECK: checked_cast_br [exact] %{{.*}} : $F to $F
+// CHECK: checked_cast_br [exact] %{{.*}} : $F to $G
+// CHECK: switch_enum
+// CHECK: checked_cast_br [exact] %{{.*}} : $F to $H
+// CHECK: switch_enum
+@inline(never)
+public func testOverridingMethodWithOptionalResult(_ f: F) -> (F?, Int)? {
+ return f.foo()
+}
+
+
+public class F {
+ @inline(never)
+ public func foo() -> (F?, Int)? {
+ return (F(), 1)
+ }
+}
+
+public class G: F {
+ @inline(never)
+ override public func foo() -> (G?, Int)? {
+ return (G(), 2)
+ }
+}
+
+public class H: F {
+ @inline(never)
+ override public func foo() -> (H?, Int)? {
+ return nil
+ }
+}
diff --git a/test/SILOptimizer/plus_zero_devirt_default_case.swift b/test/SILOptimizer/plus_zero_devirt_default_case.swift
new file mode 100644
index 0000000..c6eeaa8
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_devirt_default_case.swift
@@ -0,0 +1,276 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -O -module-name devirt_default_case -emit-sil %s | %FileCheck -check-prefix=CHECK -check-prefix=CHECK-NORMAL %s
+// RUN: %target-swift-frontend -O -module-name devirt_default_case -emit-sil -enable-testing %s | %FileCheck -check-prefix=CHECK -check-prefix=CHECK-TESTABLE %s
+
+@_silgen_name("action")
+func action(_ n:Int) -> ()
+
+// public class
+open class Base1 {
+ @inline(never) func inner() { action(1)}
+ func middle() { inner() }
+// Check that call to Base1.middle cannot be devirtualized
+//
+// CHECK-LABEL: sil @$S19devirt_default_case5Base1C5outer{{[_0-9a-zA-Z]*}}F
+// CHECK: class_method
+// CHECK: } // end sil function '$S19devirt_default_case5Base1C5outer{{[_0-9a-zA-Z]*}}F'
+ public func outer() {
+ middle()
+ }
+}
+
+// public class
+open class Derived1 : Base1 {
+ override func inner() { action(2) }
+ @inline(never) final override func middle() { inner() }
+}
+
+// private class
+private class Base2 {
+ @inline(never) func inner() { action(3)}
+ func middle() { inner() }
+ func outer() { middle() }
+}
+
+// private class
+private class Derived2 : Base2 {
+ override func inner() { action(4) }
+ @inline(never) final override func middle() { inner() }
+}
+
+
+// Check that call to Base2.middle can be devirtualized
+//
+// CHECK-LABEL: sil @$S19devirt_default_case9callOuteryS2iF
+// CHECK: function_ref @$S19devirt_default_case5Base233_{{.*}}5inner
+// CHECK: function_ref @$S19devirt_default_case8Derived233_{{.*}}6middle
+// CHECK-NOT: class_method
+// CHECK: } // end sil function '$S19devirt_default_case9callOuteryS2iF'
+public func callOuter(_ x: Int) -> Int {
+
+ var o:Base2
+
+ if x == 1 {
+ o = Base2()
+ } else {
+ o = Derived2()
+ }
+
+ o.outer()
+ return x
+}
+
+// internl class
+class Base3 {
+ @inline(never) func inner() { action(5)}
+ @inline(never) func middle() { inner() }
+// Check that call to Base3.middle can be devirtualized when not compiling
+// for testing.
+//
+// CHECK-LABEL: sil{{( hidden)?}} [noinline] @$S19devirt_default_case5Base3C5outeryyF : $@convention(method) (@guaranteed Base3) -> () {
+// CHECK: function_ref @$S19devirt_default_case5Base3C6middleyyF
+// CHECK: function_ref @$S19devirt_default_case8Derived333_{{.*}}6middle
+// CHECK-NORMAL-NOT: class_method
+// CHECK-TESTABLE: class_method %0 : $Base3, #Base3.middle!1
+// CHECK: } // end sil function '$S19devirt_default_case5Base3C5outeryyF'
+ @inline(never) func outer() {
+ middle()
+ }
+}
+
+// private class
+private class Derived3 : Base3 {
+ override func inner() { action(6) }
+ @inline(never) final override func middle() { inner() }
+ override func outer() {
+ }
+}
+
+class A2 { @inline(never) func f() -> Int { return 0 } }
+class B2 : A2 {}
+class C2 : A2 {}
+class D2: B2 {}
+class E2 :C2 {}
+
+class A3 { @inline(never) func f() -> Int { return 0 } }
+class B3 : A3 { @inline(never) override func f() -> Int { return 1 }}
+class C3 : A3 {}
+class D3: C3 {}
+class E3 :C3 {}
+
+// CHECK-TESTABLE: sil{{( hidden)?}} [noinline] @$S19devirt_default_case3fooySiAA2A3CF
+
+public func testfoo1() -> Int {
+ return foo(E2())
+}
+
+
+public func testfoo3() -> Int {
+ return foo(E3())
+}
+
+// Check that call to A3.f() can be devirtualized.
+//
+// CHECK-NORMAL: sil hidden [noinline] @$S19devirt_default_case3fooySiAA2A3CF
+// CHECK-NORMAL: function_ref @$S19devirt_default_case2B3C1fSiyFTf4d_n
+// CHECK-NORMAL: function_ref @$S19devirt_default_case2A3C1fSiyFTf4d_n
+// CHECK-NORMAL-NOT: class_method
+// CHECK: } // end sil function '$S19devirt_default_case3fooySiAA2A3CF'
+
+class Base4 {
+ @inline(never)
+ func test() {
+// Check that call to foo() can be devirtualized
+//
+// CHECK-LABEL: sil{{( hidden)?}} [noinline] @$S19devirt_default_case5Base4C4testyyF
+// CHECK: function_ref @$S19devirt_default_case5Base4C3fooyyFTf4d_n
+// CHECK: function_ref @$S19devirt_default_case8Derived4C3fooyyFTf4d_n
+// CHECK-NORMAL-NOT: class_method
+// CHECK-TESTABLE: class_method %0 : $Base4, #Base4.foo!1
+// CHECK: } // end sil function '$S19devirt_default_case5Base4C4testyyF'
+ foo()
+ }
+
+ @inline(never) func foo() { }
+}
+
+
+// A, C,D,E all use the same implementation.
+// B has its own implementation.
+@inline(never)
+func foo(_ a: A3) -> Int {
+ return a.f()
+}
+
+class Derived4 : Base4 {
+ @inline(never) override func foo() { }
+}
+
+open class Base5 {
+ @inline(never)
+ open func test() {
+ foo()
+ }
+
+ @inline(never) public final func foo() { }
+}
+
+class Derived5 : Base5 {
+}
+
+open class C6 {
+ func bar() -> Int { return 1 }
+}
+
+class D6 : C6 {
+ override func bar() -> Int { return 2 }
+}
+
+@inline(never)
+func check_static_class_devirt(_ c: C6) -> Int {
+// Check that C.bar() and D.bar() are devirtualized.
+//
+// CHECK-LABEL: sil{{( hidden)?}} [noinline] @$S19devirt_default_case019check_static_class_A0ySiAA2C6CF
+// CHECK: checked_cast_br [exact] %0 : $C6 to $C6
+// CHECK: checked_cast_br [exact] %0 : $C6 to $D6
+// CHECK: class_method
+// CHECK: } // end sil function '$S19devirt_default_case019check_static_class_A0ySiAA2C6CF'
+ return c.bar()
+}
+
+public func test_check_static_class_devirt() -> Int {
+ return check_static_class_devirt(D6())
+}
+
+
+class A7 { @inline(never) func foo() -> Bool { return false } }
+class B7 : A7 { @inline(never) override func foo() -> Bool { return true } }
+
+public func test_check_call_on_downcasted_instance() -> Bool {
+ return check_call_on_downcasted_instance(B7())
+}
+
+@inline(never)
+func callIt(_ b3: Base3, _ b4: Base4, _ b5: Base5) {
+ b3.outer()
+ b4.test()
+ b5.test()
+}
+
+public func externalEntryPoint() {
+ callIt(Base3(), Base4(), Base5())
+}
+
+open class M {
+ func foo() -> Int32 {
+ return 0
+ }
+}
+
+
+open class M1: M {
+ @inline(never)
+ override func foo() -> Int32 {
+ return 1
+ }
+}
+
+internal class M2: M1 {
+ @inline(never)
+ override func foo() -> Int32 {
+ return 2
+ }
+}
+
+internal class M3: M1 {
+ @inline(never)
+ override func foo() -> Int32 {
+ return 3
+ }
+}
+
+internal class M22: M2 {
+ @inline(never)
+ override func foo() -> Int32 {
+ return 22
+ }
+}
+
+internal class M222: M22 {
+ @inline(never)
+ override func foo() -> Int32 {
+ return 222
+ }
+}
+
+internal class M33: M3 {
+ @inline(never)
+ override func foo() -> Int32 {
+ return 33
+ }
+}
+
+
+// Check that speculative devirtualization tries to devirtualize the first N
+// alternatives, if it has too many.
+// The alternatives should be taken in a breadth-first order, starting with
+// the static type of the instance.
+
+@inline(never)
+public func testSpeculativeDevirtualizationWithTooManyAlternatives(_ c:M1) -> Int32{
+ return c.foo()
+}
+
+
+@inline(never)
+func foo(_ a: A2) -> Int {
+ return a.f()
+}
+
+@inline(never)
+func check_call_on_downcasted_instance(_ a: A7) -> Bool {
+ if a is B7 {
+ return (a as! B7).foo()
+ }
+ return a.foo()
+}
diff --git a/test/SILOptimizer/plus_zero_devirt_nested_class.swift b/test/SILOptimizer/plus_zero_devirt_nested_class.swift
new file mode 100644
index 0000000..936d6d9
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_devirt_nested_class.swift
@@ -0,0 +1,31 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-sil -O %s | %FileCheck %s
+
+fileprivate class Outer<T> {
+ class Inner<U> : Base<T, U> {
+ @_optimize(none)
+ override func method<V>(v: V) {}
+ }
+}
+
+fileprivate class Base<T, U> {
+ @_optimize(none)
+ func method<V>(v: V) {}
+}
+
+fileprivate class Derived<T, U> : Outer<T>.Inner<U> {}
+
+@_transparent
+fileprivate func bar<T, U, V>(b: Base<T, U>, v: V) {
+ b.method(v: v)
+}
+
+fileprivate func foo<T, U, V>(d: Outer<T>.Inner<U>, v: V) {
+ bar(b: d, v: v)
+}
+
+foo(d: Outer<Int>.Inner<Int>(), v: 0)
+
+// CHECK-LABEL: sil @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32
+// CHECK: function_ref @$S19devirt_nested_class5Outer{{.*}}LC5InnerC6method1vyqd0___tlF : $@convention(method) <τ_0_0><τ_1_0><τ_2_0> (@in_guaranteed τ_2_0, @guaranteed Outer<τ_0_0>.Inner<τ_1_0>) -> ()
+// CHECK: return
diff --git a/test/SILOptimizer/plus_zero_devirt_protocol_method_invocations.swift b/test/SILOptimizer/plus_zero_devirt_protocol_method_invocations.swift
new file mode 100644
index 0000000..2b1a325
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_devirt_protocol_method_invocations.swift
@@ -0,0 +1,266 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -O -emit-sil %s | %FileCheck %s
+
+protocol PPP {
+ func f()
+}
+
+protocol QQQ : PPP {
+}
+
+protocol RRR : QQQ {
+}
+
+struct S : RRR {}
+
+extension QQQ {
+ @_optimize(none)
+ func f() {}
+}
+
+// Test that all witness_method instructions are devirtualized.
+// This test used to crash the compiler because it uses inherited conformances.
+// CHECK-LABEL: sil @$S34devirt_protocol_method_invocations24testInheritedConformanceyyF : $@convention(thin) () -> ()
+// CHECK-NOT: witness_method
+// CHECK-NOT: class_method
+// CHECK: apply
+// CHECK: // end sil function '$S34devirt_protocol_method_invocations24testInheritedConformanceyyF'
+public func testInheritedConformance() {
+ (S() as QQQ).f()
+}
+
+// Test that a witness_method instruction using an indirectly-inherited conformance
+// is devirtualized.
+//
+// This test used to crash the compiler because it uses inherited conformances.
+// CHECK-LABEL: sil @$S34devirt_protocol_method_invocations34testIndirectlyInheritedConformanceyyF : $@convention(thin) () -> ()
+// CHECK-NOT: witness_method
+// CHECK: apply
+// CHECK: // end sil function '$S34devirt_protocol_method_invocations34testIndirectlyInheritedConformanceyyF'
+public func testIndirectlyInheritedConformance() {
+ (S() as RRR).f()
+}
+
+
+public protocol Foo {
+ func foo(_ x:Int) -> Int
+}
+
+public extension Foo {
+ func boo(_ x:Int) -> Int32 {
+ return 2222 + Int32(x)
+ }
+
+ func getSelf() -> Self {
+ return self
+ }
+}
+
+var gg = 1111
+
+open class C : Foo {
+ @inline(never)
+ open func foo(_ x:Int) -> Int {
+ gg += 1
+ return gg + x
+ }
+}
+
+@_transparent
+func callfoo(_ f: Foo) -> Int {
+ return f.foo(2) + f.foo(2)
+}
+
+@_transparent
+func callboo(_ f: Foo) -> Int32 {
+ return f.boo(2) + f.boo(2)
+}
+
+@_transparent
+func callGetSelf(_ f: Foo) -> Foo {
+ return f.getSelf()
+}
+
+// Check that methods returning Self are not devirtualized and do not crash the compiler.
+// CHECK-LABEL: sil [noinline] @$S34devirt_protocol_method_invocations05test_a1_b11_extension_C33_invocation_with_self_return_typeyAA3Foo_pAA1CCF
+// CHECK: init_existential_addr
+// CHECK: open_existential_addr
+// CHECK: return
+@inline(never)
+public func test_devirt_protocol_extension_method_invocation_with_self_return_type(_ c: C) -> Foo {
+ return callGetSelf(c)
+}
+
+// Check that calls to f.foo() get devirtualized and are not invoked
+// via the expensive witness_method instruction.
+// To achieve that the information about a concrete type C should
+// be propagated from init_existential_addr into witness_method and
+// apply instructions.
+
+// CHECK-LABEL: sil [noinline] @$S34devirt_protocol_method_invocations05test_a1_b1_C11_invocationySiAA1CCF
+// CHECK-NOT: witness_method
+// CHECK: checked_cast
+// CHECK-NOT: checked_cast
+// CHECK: bb1(
+// CHECK-NOT: checked_cast
+// CHECK: return
+// CHECK: bb2(
+// CHECK-NOT: checked_cast
+// CHECK: function_ref
+// CHECK: apply
+// CHECK: apply
+// CHECK: br bb1(
+// CHECK: bb3
+// CHECK-NOT: checked_cast
+// CHECK: apply
+// CHECK: apply
+// CHECK: br bb1(
+
+// Check that calls of a method boo() from the protocol extension
+// get devirtualized and are not invoked via the expensive witness_method instruction
+// or by passing an existential as a parameter.
+// To achieve that the information about a concrete type C should
+// be propagated from init_existential_addr into apply instructions.
+// In fact, the call is expected to be inlined and then constant-folded
+// into a single integer constant.
+
+// CHECK-LABEL: sil [noinline] @$S34devirt_protocol_method_invocations05test_a1_b11_extension_C11_invocationys5Int32VAA1CCF
+// CHECK-NOT: checked_cast
+// CHECK-NOT: open_existential
+// CHECK-NOT: witness_method
+// CHECK-NOT: apply
+// CHECK: integer_literal
+// CHECK: return
+
+// CHECK: sil @$S34devirt_protocol_method_invocations12test24114020SiyF
+// CHECK: [[T0:%.*]] = integer_literal $Builtin.Int{{.*}}, 1
+// CHECK: [[T1:%.*]] = struct $Int ([[T0]] : $Builtin.Int{{.*}})
+// CHECK: return [[T1]]
+
+// CHECK: sil @$S34devirt_protocol_method_invocations14testExMetatypeSiyF
+// CHECK: [[T0:%.*]] = builtin "sizeof"<Int>
+// CHECK: [[T1:%.*]] = builtin {{.*}}([[T0]]
+// CHECK: [[T2:%.*]] = struct $Int ([[T1]] : {{.*}})
+// CHECK: return [[T2]] : $Int
+
+@inline(never)
+public func test_devirt_protocol_method_invocation(_ c: C) -> Int {
+ return callfoo(c)
+}
+
+@inline(never)
+public func test_devirt_protocol_extension_method_invocation(_ c: C) -> Int32 {
+ return callboo(c)
+}
+
+
+// Make sure that we are not crashing with an assertion due to specialization
+// of methods with the Self return type as an argument.
+// rdar://20868966
+protocol Proto {
+ func f() -> Self
+}
+
+class CC : Proto {
+ func f() -> Self { return self }
+}
+
+func callDynamicSelfExistential(_ p: Proto) {
+ p.f()
+}
+
+public func testSelfReturnType() {
+ callDynamicSelfExistential(CC())
+}
+
+
+// Make sure that we are not crashing with an assertion due to specialization
+// of methods with the Self return type.
+// rdar://20955745.
+protocol CP : class { func f() -> Self }
+func callDynamicSelfClassExistential(_ cp: CP) { cp.f() }
+class PP : CP {
+ func f() -> Self { return self }
+}
+
+callDynamicSelfClassExistential(PP())
+
+// Make sure we handle indirect conformances.
+// rdar://24114020
+protocol Base {
+ var x: Int { get }
+}
+protocol Derived : Base {
+}
+struct SimpleBase : Derived {
+ var x: Int
+}
+public func test24114020() -> Int {
+ let base: Derived = SimpleBase(x: 1)
+ return base.x
+}
+
+protocol StaticP {
+ static var size: Int { get }
+}
+struct HasStatic<T> : StaticP {
+ static var size: Int { return MemoryLayout<T>.size }
+}
+public func testExMetatype() -> Int {
+ let type: StaticP.Type = HasStatic<Int>.self
+ return type.size
+}
+
+// rdar://32288618
+public func testExMetatypeVar() -> Int {
+ var type: StaticP.Type = HasStatic<Int>.self
+ return type.size
+}
+
+// IRGen used to crash on the testPropagationOfConcreteTypeIntoExistential method.
+// rdar://26286278
+
+protocol MathP {
+ var sum: Int32 { get nonmutating set }
+ func done()
+}
+
+extension MathP {
+ @inline(never)
+ func plus() -> Self {
+ sum += 1
+ return self
+ }
+
+ @inline(never)
+ func minus() {
+ sum -= 1
+ if sum == 0 {
+ done()
+ }
+ }
+}
+
+protocol MathA : MathP {}
+
+public final class V {
+ var a: MathA
+
+ init(a: MathA) {
+ self.a = a
+ }
+}
+
+// Check that all witness_method invocations are devirtualized.
+// CHECK-LABEL: sil [noinline] @$S34devirt_protocol_method_invocations44testPropagationOfConcreteTypeIntoExistential1v1xyAA1VC_s5Int32VtF
+// CHECK-NOT: witness_method
+// CHECK-NOT: class_method
+// CHECK: return
+@inline(never)
+public func testPropagationOfConcreteTypeIntoExistential(v: V, x: Int32) {
+ let y = v.a.plus()
+ defer {
+ y.minus()
+ }
+}
+
diff --git a/test/SILOptimizer/plus_zero_devirt_speculative_nested.swift b/test/SILOptimizer/plus_zero_devirt_speculative_nested.swift
new file mode 100644
index 0000000..bc6a9e8
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_devirt_speculative_nested.swift
@@ -0,0 +1,32 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend %s -parse-as-library -O -emit-sil | %FileCheck %s
+// RUN: %target-swift-frontend %s -parse-as-library -Osize -emit-sil
+//
+// Test speculative devirtualization.
+
+public class Outer<T> {
+ final class Inner : Base {
+ @inline(never) override func update() {
+ }
+ }
+}
+
+public class Base {
+ @inline(never) func update() { }
+}
+
+// FIXME: We don't speculate to the override Outer<T>.Inner.update() here,
+// because we cannot express the cast -- the cast "returns" a new archetype
+// T, much like an opened existential.
+//
+// But at least, we shouldn't crash.
+
+// CHECK-LABEL: sil @$S25devirt_speculative_nested3foo1xyAA4BaseC_tF : $@convention(thin) (@guaranteed Base) -> ()
+// CHECK: checked_cast_br [exact] %0 : $Base to $Base
+// CHECK: function_ref @$S25devirt_speculative_nested4BaseC6updateyyF
+// CHECK: class_method %0 : $Base, #Base.update!1
+// CHECK: return
+
+public func foo(x: Base) {
+ x.update()
+}
diff --git a/test/SILOptimizer/plus_zero_devirt_value_metatypes.swift b/test/SILOptimizer/plus_zero_devirt_value_metatypes.swift
new file mode 100644
index 0000000..b324eab
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_devirt_value_metatypes.swift
@@ -0,0 +1,63 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-sil -O %s | %FileCheck %s
+
+open class A {
+ @inline(never)
+ class func foo() {
+ }
+}
+
+
+class B: A {
+ @inline(never)
+ override class func foo() {}
+}
+
+// CHECK-LABEL: sil @$S22devirt_value_metatypes17testValueMetatypeyyAA1ACF
+// CHECK: value_metatype $@thick A.Type
+// CHECK: checked_cast_br
+// CHECK: checked_cast_br
+// CHECK: class_method
+// CHECK: }
+public func testValueMetatype(_ x:A) {
+ type(of: x).foo()
+}
+
+open class C {
+ @inline(never)
+ class func foo() -> Int { return 0 }
+}
+
+open class D : C {
+ @inline(never)
+ override class func foo() -> Int { return 1 }
+}
+
+// CHECK-LABEL: sil @$S22devirt_value_metatypes5testDySiAA1DCF
+// CHECK-NOT: value_metatype %
+// D.foo is an internal method, D has no subclasses and it is a wmo compilation,
+// therefore D.foo method invocation can be devirtualized.
+// CHECK: function_ref @$S22devirt_value_metatypes1DC3fooSiyFZTf4d_n
+// CHECK-NOT: value_metatype %
+// CHECK-NOT: checked_cast_br
+// CHECK-NOT: class_method
+// CHECK: }
+public func testD(_ x: D) -> Int {
+ return (type(of: x) as C.Type).foo()
+}
+
+
+public final class E : C {
+ @inline(never)
+ override class func foo() -> Int { return 1 }
+}
+
+// CHECK-LABEL: sil @$S22devirt_value_metatypes5testEySiAA1ECF
+// CHECK-NOT: value_metatype $@thick E.Type
+// CHECK_NOT: checked_cast_br
+// CHECK: function_ref
+// CHECK: apply
+// CHECK: return
+public func testE(_ x: E) -> Int {
+ return (type(of: x) as C.Type).foo()
+}
diff --git a/test/SILOptimizer/plus_zero_devirt_witness_method_conformance.swift b/test/SILOptimizer/plus_zero_devirt_witness_method_conformance.swift
new file mode 100644
index 0000000..f3da042
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_devirt_witness_method_conformance.swift
@@ -0,0 +1,20 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -O -emit-ir -primary-file %s | %FileCheck %s
+// This is a swift file because the crash doesn't reproduce with SIL.
+@inline(never)
+func callFoo<T: X>(_ x: T) {
+ x.foo()
+}
+public func a(y: Sub) {
+ callFoo(y)
+ // specialization of callFoo for Sub:
+// CHECK-LABEL: define linkonce_odr hidden swiftcc void @"$S33devirt_witness_method_conformance7callFooyyxAA1XRzlFAA3SubC_Tg5"({{.*}}) local_unnamed_addr
+}
+protocol X {
+ func foo()
+}
+extension X {
+ func foo() {}
+}
+public class Base: X {}
+public class Sub: Base {}
diff --git a/test/SILOptimizer/plus_zero_let_properties_opts.swift b/test/SILOptimizer/plus_zero_let_properties_opts.swift
new file mode 100644
index 0000000..12be391
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_let_properties_opts.swift
@@ -0,0 +1,356 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend %s -O -emit-sil | %FileCheck -check-prefix=CHECK-WMO %s
+// RUN: %target-swift-frontend -primary-file %s -O -emit-sil | %FileCheck %s
+
+// Test propagation of non-static let properties with compile-time constant values.
+
+// TODO: Once this optimization can remove the propagated fileprivate/internal let properties or
+// mark them as ones without a storage, new tests should be added here to check for this
+// functionality.
+
+// FIXME: This test is written in Swift instead of SIL, because there are some problems
+// with SIL deserialization (rdar://22636911)
+
+// Check that initializers do not contain a code to initialize fileprivate or
+// internal (if used with WMO) properties, because their values are propagated into
+// their uses and they cannot be accessed from other modules. Therefore the
+// initialization code could be removed.
+// Specifically, the initialization code for Prop1, Prop2 and Prop3 can be removed.
+
+// CHECK-WMO-LABEL: sil @$S19let_properties_opts3FooC{{[_0-9a-zA-Z]*}}fc : $@convention(method) (Int32, @owned Foo) -> @owned Foo
+// CHECK-WMO-NOT: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop1
+// CHECK-WMO-NOT: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop2
+// CHECK-WMO-NOT: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop3
+// CHECK-WMO: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop0
+// CHECK-WMO: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop1
+// CHECK-WMO: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop2
+// CHECK-WMO: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop3
+// CHECK-WMO: return
+
+// CHECK-WMO-LABEL: sil @$S19let_properties_opts3FooC{{[_0-9a-zA-Z]*}}fc : $@convention(method) (Int64, @owned Foo) -> @owned Foo
+// CHECK-WMO-NOT: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop1
+// CHECK-WMO-NOT: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop2
+// CHECK-WMO-NOT: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop3
+// CHECK-WMO: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop0
+// CHECK-WMO: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop1
+// CHECK-WMO: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop2
+// CHECK-WMO: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop3
+// CHECK-WMO: return
+
+// Check that initializers do not contain a code to initialize fileprivate properties,
+// because their values are propagated into their uses and they cannot be accessed
+// from other modules. Therefore the initialization code could be removed.
+// Specifically, the initialization code for Prop2 can be removed.
+
+// CHECK-LABEL: sil @$S19let_properties_opts3FooC{{[_0-9a-zA-Z]*}}fc : $@convention(method) (Int32, @owned Foo) -> @owned Foo
+// CHECK: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop0
+// CHECK: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop1
+// CHECK: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop2
+// CHECK: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop3
+// CHECK: return
+
+// CHECK-LABEL: sil @$S19let_properties_opts3FooC{{[_0-9a-zA-Z]*}}fc : $@convention(method) (Int64, @owned Foo) -> @owned Foo
+// CHECK: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop0
+// CHECK: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop1
+// CHECK: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop2
+// CHECK: ref_element_addr %{{[0-9]+}} : $Foo, #Foo.Prop3
+// CHECK: return
+
+public class Foo {
+ public let Prop0: Int32 = 1
+ let Prop1: Int32 = 1 + 4/2 + 8
+ fileprivate let Prop2: Int32 = 3*7
+ internal let Prop3: Int32 = 4*8
+ public init(i:Int32) {}
+ public init(i:Int64) {}
+}
+
+public class Foo1 {
+ let Prop1: Int32
+ fileprivate let Prop2: Int32 = 3*7
+ internal let Prop3: Int32 = 4*8
+ public init(i:Int32) {
+ Prop1 = 11
+ }
+
+ public init(i:Int64) {
+ Prop1 = 1111
+ }
+}
+
+public struct Boo {
+ public let Prop0: Int32 = 1
+ let Prop1: Int32 = 1 + 4/2 + 8
+ fileprivate let Prop2: Int32 = 3*7
+ internal let Prop3: Int32 = 4*8
+ public init(i:Int32) {}
+ public init(i:Int64) {}
+}
+
+public class Foo2 {
+ internal let x: Int32
+ @inline(never)
+ init(count: Int32) {
+ if count < 2 {
+ x = 5
+ } else {
+ x = 10
+ }
+ }
+}
+
+public class C {}
+
+struct Boo3 {
+ //public
+ let Prop0: Int32
+ let Prop1: Int32
+ fileprivate let Prop2: Int32
+ internal let Prop3: Int32
+
+ @inline(__always)
+ init(_ f1: C, _ f2: C) {
+ self.Prop0 = 0
+ self.Prop1 = 1
+ self.Prop2 = 2
+ self.Prop3 = 3
+ }
+
+ init(_ v: C) {
+ self.Prop0 = 10
+ self.Prop1 = 11
+ self.Prop2 = 12
+ self.Prop3 = 13
+ }
+}
+
+// The initializer of this struct can be defined elsewhere,
+// e.g. in an extension of this struct in a different module.
+public struct StructWithOnlyPublicLetProperties {
+ public let Prop0: Int32
+ public let Prop1: Int32
+
+ init(_ v: Int32, _ u: Int32) {
+ Prop0 = 10
+ Prop1 = 11
+ }
+}
+
+// The initializer of this struct cannot be defined outside
+// of the current module, because it contains an internal stored
+// property, which is impossible to initialize outside of this module.
+public struct StructWithPublicAndInternalLetProperties {
+ public let Prop0: Int32
+ internal let Prop1: Int32
+
+ init(_ v: Int32, _ u: Int32) {
+ Prop0 = 10
+ Prop1 = 11
+ }
+}
+
+// The initializer of this struct cannot be defined elsewhere,
+// because it contains a fileprivate stored property, which is
+// impossible to initialize outside of this file.
+public struct StructWithPublicAndInternalAndPrivateLetProperties {
+ public let Prop0: Int32
+ internal let Prop1: Int32
+ fileprivate let Prop2: Int32
+
+ init(_ v: Int32, _ u: Int32) {
+ Prop0 = 10
+ Prop1 = 11
+ Prop2 = 12
+ }
+}
+
+
+// Check that Foo1.Prop1 is not constant-folded, because its value is unknown, since it is initialized differently
+// by Foo1 initializers.
+
+// CHECK-LABEL: sil @$S19let_properties_opts13testClassLet1ys5Int32VAA4Foo1CF : $@convention(thin) (@guaranteed Foo1) -> Int32
+// bb0
+// CHECK: ref_element_addr %{{[0-9]+}} : $Foo1, #Foo1.Prop1
+// CHECK-NOT: ref_element_addr %{{[0-9]+}} : $Foo1, #Foo1.Prop2
+// CHECK-NOT: ref_element_addr %{{[0-9]+}} : $Foo1, #Foo1.Prop3
+// CHECK: return
+public func testClassLet1(_ f: Foo1) -> Int32 {
+ return f.Prop1 + f.Prop2 + f.Prop3
+}
+
+// Check that Foo1.Prop1 is not constant-folded, because its value is unknown, since it is initialized differently
+// by Foo1 initializers.
+
+// CHECK-LABEL: sil @$S19let_properties_opts13testClassLet1ys5Int32VAA4Foo1CzF : $@convention(thin) (@inout Foo1) -> Int32
+// bb0
+// CHECK: ref_element_addr %{{[0-9]+}} : $Foo1, #Foo1.Prop1
+// CHECK-NOT: ref_element_addr %{{[0-9]+}} : $Foo1, #Foo1.Prop2
+// CHECK-NOT: ref_element_addr %{{[0-9]+}} : $Foo1, #Foo1.Prop3
+// CHECK: return
+public func testClassLet1(_ f: inout Foo1) -> Int32 {
+ return f.Prop1 + f.Prop2 + f.Prop3
+}
+
+// Check that return expressions in all subsequent functions can be constant folded, because the values of let properties
+// are known to be constants of simple types.
+
+// CHECK: sil @$S19let_properties_opts12testClassLetys5Int32VAA3FooCF : $@convention(thin) (@guaranteed Foo) -> Int32
+// CHECK: bb0
+// CHECK: integer_literal $Builtin.Int32, 75
+// CHECK-NEXT: struct $Int32
+// CHECK-NEXT: return
+public func testClassLet(_ f: Foo) -> Int32 {
+ return f.Prop1 + f.Prop1 + f.Prop2 + f.Prop3
+}
+
+// CHECK-LABEL: sil @$S19let_properties_opts12testClassLetys5Int32VAA3FooCzF : $@convention(thin) (@inout Foo) -> Int32
+// CHECK: bb0
+// CHECK: integer_literal $Builtin.Int32, 75
+// CHECK-NEXT: struct $Int32
+// CHECK-NEXT: return
+public func testClassLet(_ f: inout Foo) -> Int32 {
+ return f.Prop1 + f.Prop1 + f.Prop2 + f.Prop3
+}
+
+// CHECK-LABEL: sil @$S19let_properties_opts18testClassPublicLetys5Int32VAA3FooCF : $@convention(thin) (@guaranteed Foo) -> Int32
+// CHECK: bb0
+// CHECK: integer_literal $Builtin.Int32, 1
+// CHECK-NEXT: struct $Int32
+// CHECK-NEXT: return
+public func testClassPublicLet(_ f: Foo) -> Int32 {
+ return f.Prop0
+}
+
+// CHECK-LABEL: sil @$S19let_properties_opts13testStructLetys5Int32VAA3BooVF : $@convention(thin) (Boo) -> Int32
+// CHECK: bb0
+// CHECK: integer_literal $Builtin.Int32, 75
+// CHECK-NEXT: struct $Int32
+// CHECK-NEXT: return
+public func testStructLet(_ b: Boo) -> Int32 {
+ return b.Prop1 + b.Prop1 + b.Prop2 + b.Prop3
+}
+
+// CHECK-LABEL: sil @$S19let_properties_opts13testStructLetys5Int32VAA3BooVzF : $@convention(thin) (@inout Boo) -> Int32
+// CHECK: bb0
+// CHECK: integer_literal $Builtin.Int32, 75
+// CHECK-NEXT: struct $Int32
+// CHECK-NEXT: return
+public func testStructLet(_ b: inout Boo) -> Int32 {
+ return b.Prop1 + b.Prop1 + b.Prop2 + b.Prop3
+}
+
+// CHECK-LABEL: sil @$S19let_properties_opts19testStructPublicLetys5Int32VAA3BooVF : $@convention(thin) (Boo) -> Int32
+// CHECK: bb0
+// CHECK: integer_literal $Builtin.Int32, 1
+// CHECK-NEXT: struct $Int32
+// CHECK-NEXT: return
+public func testStructPublicLet(_ b: Boo) -> Int32 {
+ return b.Prop0
+}
+
+// Check that f.x is not constant folded, because the initializer of Foo2 has multiple
+// assignments to the property x with different values.
+// CHECK-LABEL: sil @$S19let_properties_opts13testClassLet2ys5Int32VAA4Foo2CF : $@convention(thin) (@guaranteed Foo2) -> Int32
+// bb0
+// CHECK: ref_element_addr %{{[0-9]+}} : $Foo2, #Foo2.x
+// CHECK-NOT: ref_element_addr %{{[0-9]+}} : $Foo2, #Foo2.x
+// CHECK-NOT: ref_element_addr %{{[0-9]+}} : $Foo2, #Foo2.x
+// CHECK: return
+public func testClassLet2(_ f: Foo2) -> Int32 {
+ return f.x + f.x
+}
+
+// Check that the sum of properties is not folded into a constant.
+// CHECK-WMO-LABEL: sil hidden [noinline] @$S19let_properties_opts27testStructWithMultipleInitsys5Int32VAA4Boo3V_AFtF : $@convention(thin) (Boo3, Boo3) -> Int32
+// CHECK-WMO: bb0
+// No constant folding should have been performed.
+// CHECK-WMO-NOT: integer_literal $Builtin.Int32, 92
+// CHECK-WMO: struct_extract
+// CHECK-WMO: }
+@inline(never)
+func testStructWithMultipleInits( _ boos1: Boo3, _ boos2: Boo3) -> Int32 {
+ let count1 = boos1.Prop0 + boos1.Prop1 + boos1.Prop2 + boos1.Prop3
+ let count2 = boos2.Prop0 + boos2.Prop1 + boos2.Prop2 + boos2.Prop3
+ return count1 + count2
+}
+
+public func testStructWithMultipleInitsAndInlinedInitializer() {
+ let things = [C()]
+ // This line results in inlining of the initializer Boo3(C, C) and later
+ // removal of this initializer by the dead function elimination pass.
+ // As a result, only one initializer, Boo3(C) is seen by the Let Properties Propagation
+ // pass. This pass may think that there is only one initializer and take the
+ // values of let properties assigned there as constants and try to propagate
+ // those values into uses. But this is wrong! The pass should be clever enough
+ // to detect all stores to the let properties, including those outside of
+ // initializers, e.g. inside inlined initializers. And if it detects all such
+ // stores it should understand that values of let properties in Boo3 are not
+ // statically known constant initializers with the same value and thus
+ // cannot be propagated.
+ let boos1 = things.map { Boo3($0, C()) }
+ let boos2 = things.map(Boo3.init)
+ print(testStructWithMultipleInits(boos1[0], boos2[0]))
+}
+
+// Since all properties are public, they can be initialized in a
+// different module.
+// Their values are not known and cannot be propagated.
+
+// CHECK-LABEL: sil @$S19let_properties_opts31testStructPropertyAccessibilityys5Int32VAA0E27WithOnlyPublicLetPropertiesVF
+// CHECK: struct_extract %0 : $StructWithOnlyPublicLetProperties, #StructWithOnlyPublicLetProperties.Prop0
+// CHECK: return
+
+// CHECK-WMO-LABEL: sil @$S19let_properties_opts31testStructPropertyAccessibilityys5Int32VAA0E27WithOnlyPublicLetPropertiesVF
+// CHECK-WMO: struct_extract %0 : $StructWithOnlyPublicLetProperties, #StructWithOnlyPublicLetProperties.Prop0
+// CHECK-WMO: return
+public func testStructPropertyAccessibility(_ b: StructWithOnlyPublicLetProperties) -> Int32 {
+ return b.Prop0 + b.Prop1
+}
+
+// Properties can be initialized in a different file in the same module.
+// Their values are not known and cannot be propagated,
+// unless it is a WMO compilation.
+
+// CHECK-LABEL: sil @$S19let_properties_opts31testStructPropertyAccessibilityys5Int32VAA0E34WithPublicAndInternalLetPropertiesVF
+// CHECK: struct_extract %0 : $StructWithPublicAndInternalLetProperties, #StructWithPublicAndInternalLetProperties.Prop0
+// CHECK-NOT: integer_literal $Builtin.Int32, 21
+// CHECK: return
+
+// CHECK-WMO-LABEL: sil @$S19let_properties_opts31testStructPropertyAccessibilityys5Int32VAA0E34WithPublicAndInternalLetPropertiesVF
+// CHECK-WMO: integer_literal $Builtin.Int32, 21
+// CHECK-WMO-NEXT: struct $Int32
+// CHECK-WMO-NEXT: return
+public func testStructPropertyAccessibility(_ b: StructWithPublicAndInternalLetProperties) -> Int32 {
+ return b.Prop0 + b.Prop1
+}
+
+// Properties can be initialized only in this file, because one of the
+// properties is fileprivate.
+// Therefore their values are known and can be propagated.
+
+// CHECK: sil @$S19let_properties_opts31testStructPropertyAccessibilityys5Int32VAA0e21WithPublicAndInternalK20PrivateLetPropertiesVF
+// CHECK: integer_literal $Builtin.Int32, 33
+// CHECK-NEXT: struct $Int32
+// CHECK-NEXT: return
+
+// CHECK-WMO-LABEL: sil @$S19let_properties_opts31testStructPropertyAccessibilityys5Int32VAA0e21WithPublicAndInternalK20PrivateLetPropertiesVF
+// CHECK-WMO: integer_literal $Builtin.Int32, 33
+// CHECK-WMO-NEXT: struct $Int32
+// CHECK-WMO-NEXT: return
+public func testStructPropertyAccessibility(_ b: StructWithPublicAndInternalAndPrivateLetProperties) -> Int32 {
+ return b.Prop0 + b.Prop1 + b.Prop2
+}
+
+// Force use of initializers, otherwise they got removed by the dead-function-elimination pass
+// and the values of let properties cannot be determined.
+public func useInitializers() -> StructWithOnlyPublicLetProperties {
+ return StructWithOnlyPublicLetProperties(1, 1)
+}
+
+public func useInitializers() -> StructWithPublicAndInternalLetProperties {
+ return StructWithPublicAndInternalLetProperties(1, 1)
+}
+
+public func useInitializers() -> StructWithPublicAndInternalAndPrivateLetProperties {
+ return StructWithPublicAndInternalAndPrivateLetProperties(1, 1)
+}
diff --git a/test/SILOptimizer/plus_zero_mandatory_inlining.swift b/test/SILOptimizer/plus_zero_mandatory_inlining.swift
new file mode 100644
index 0000000..3dec6cb
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_mandatory_inlining.swift
@@ -0,0 +1,177 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -enable-sil-ownership -sil-verify-all -primary-file %s -emit-sil -o - -verify | %FileCheck %s
+
+// These tests are deliberately shallow, because I do not want to depend on the
+// specifics of SIL generation, which might change for reasons unrelated to this
+// pass
+
+func foo(_ x: Float) -> Float {
+ return bar(x);
+}
+
+// CHECK-LABEL: sil hidden @$S18mandatory_inlining3foo{{[_0-9a-zA-Z]*}}F
+// CHECK: bb0(%0 : $Float):
+// CHECK-NEXT: debug_value %0 : $Float, let, name "x"
+// CHECK-NEXT: return %0
+
+@_transparent func bar(_ x: Float) -> Float {
+ return baz(x)
+}
+
+// CHECK-LABEL: sil hidden [transparent] @$S18mandatory_inlining3bar{{[_0-9a-zA-Z]*}}F
+ // CHECK-NOT: function_ref
+ // CHECK-NOT: apply
+ // CHECK: return
+
+@_transparent func baz(_ x: Float) -> Float {
+ return x
+}
+
+// CHECK-LABEL: sil hidden [transparent] @$S18mandatory_inlining3baz{{[_0-9a-zA-Z]*}}F
+// CHECK: return
+
+func spam(_ x: Int) -> Int {
+ return x
+}
+
+// CHECK-LABEL: sil hidden @$S18mandatory_inlining4spam{{[_0-9a-zA-Z]*}}F
+
+@_transparent func ham(_ x: Int) -> Int {
+ return spam(x)
+}
+
+// CHECK-LABEL: sil hidden [transparent] @$S18mandatory_inlining3ham{{[_0-9a-zA-Z]*}}F
+ // CHECK: function_ref @$S18mandatory_inlining4spam{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply
+ // CHECK: return
+
+func eggs(_ x: Int) -> Int {
+ return ham(x)
+}
+
+// CHECK-LABEL: sil hidden @$S18mandatory_inlining4eggs{{[_0-9a-zA-Z]*}}F
+ // CHECK: function_ref @$S18mandatory_inlining4spam{{[_0-9a-zA-Z]*}}F
+ // CHECK: apply
+ // CHECK: return
+
+@_transparent func call_auto_closure(_ x: @autoclosure () -> Bool) -> Bool {
+ return x()
+}
+
+func test_auto_closure_with_capture(_ x: Bool) -> Bool {
+ return call_auto_closure(x)
+}
+
+// This should be fully inlined and simply return x; however, there's a lot of
+// non-SSA cruft that I don't want this test to depend on, so I'm just going
+// to verify that it doesn't have any function applications left
+
+// CHECK-LABEL: sil hidden @{{.*}}test_auto_closure_with_capture
+ // CHECK-NOT: = apply
+ // CHECK: return
+
+func test_auto_closure_without_capture() -> Bool {
+ return call_auto_closure(false)
+}
+
+// This should be fully inlined and simply return false, which is easier to check for
+
+// CHECK-LABEL: sil hidden @$S18mandatory_inlining33test_auto_closure_without_captureSbyF
+ // CHECK: [[FV:%.*]] = integer_literal $Builtin.Int1, 0
+ // CHECK: [[FALSE:%.*]] = struct $Bool ([[FV:%.*]] : $Builtin.Int1)
+ // CHECK: return [[FALSE]]
+
+infix operator &&& : LogicalConjunctionPrecedence
+infix operator ||| : LogicalDisjunctionPrecedence
+
+@_transparent func &&& (lhs: Bool, rhs: @autoclosure () -> Bool) -> Bool {
+ if lhs {
+ return rhs()
+ }
+
+ return false
+}
+
+@_transparent func ||| (lhs: Bool, rhs: @autoclosure () -> Bool) -> Bool {
+ if lhs {
+ return true
+ }
+
+ return rhs()
+}
+
+func test_chained_short_circuit(_ x: Bool, y: Bool, z: Bool) -> Bool {
+ return x &&& (y ||| z)
+}
+
+// The test below just makes sure there are no uninlined [transparent] calls
+// left (i.e. the autoclosure and the short-circuiting boolean operators are
+// recursively inlined properly)
+
+// CHECK-LABEL: sil hidden @$S18mandatory_inlining26test_chained_short_circuit{{[_0-9a-zA-Z]*}}F
+ // CHECK-NOT: = apply [transparent]
+ // CHECK: return
+
+
+// Union element constructors should be inlined automatically.
+enum X {
+ case onetransp
+ case twotransp
+}
+
+func testInlineUnionElement() -> X {
+ return X.onetransp
+ // CHECK-LABEL: sil hidden @$S18mandatory_inlining22testInlineUnionElementAA1XOyF
+ // CHECK: enum $X, #X.onetransp!enumelt
+ // CHECK-NOT: = apply
+ // CHECK: return
+}
+
+
+
+@_transparent
+func call_let_auto_closure(_ x: @autoclosure () -> Bool) -> Bool {
+ return x()
+}
+
+// CHECK-LABEL: sil hidden @{{.*}}test_let_auto_closure_with_value_capture
+// CHECK: bb0(%0 : $Bool):
+// CHECK-NEXT: debug_value %0 : $Bool
+// CHECK-NEXT: return %0 : $Bool
+// CHECK-LABEL: // end sil function '{{.*}}test_let_auto_closure_with_value_capture
+func test_let_auto_closure_with_value_capture(_ x: Bool) -> Bool {
+ return call_let_auto_closure(x)
+}
+
+
+class C {}
+
+// CHECK-LABEL: sil hidden [transparent] @$S18mandatory_inlining25class_constrained_generic{{[_0-9a-zA-Z]*}}F
+@_transparent
+func class_constrained_generic<T : C>(_ o: T) -> AnyClass? {
+ // CHECK: return
+ return T.self
+}
+
+// CHECK-LABEL: sil hidden @$S18mandatory_inlining6invokeyyAA1CCF : $@convention(thin) (@guaranteed C) -> () {
+func invoke(_ c: C) {
+ // CHECK-NOT: function_ref @$S18mandatory_inlining25class_constrained_generic{{[_0-9a-zA-Z]*}}F
+ // CHECK-NOT: apply
+ // CHECK: init_existential_metatype
+ _ = class_constrained_generic(c)
+ // CHECK: return
+}
+
+// Make sure we don't crash.
+@_transparent
+public func mydo(_ what: @autoclosure () -> ()) {
+ what()
+}
+public class A {
+ public func bar() {}
+ public func foo(_ act: (@escaping () ->()) -> ()) {
+ act { [unowned self] in
+ mydo( self.bar() )
+ }
+ }
+}
diff --git a/test/SILOptimizer/plus_zero_performance_inliner.sil b/test/SILOptimizer/plus_zero_performance_inliner.sil
new file mode 100644
index 0000000..e19b0c9
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_performance_inliner.sil
@@ -0,0 +1,972 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -enable-sil-verify-all %s -inline -sil-combine | %FileCheck %s
+
+sil_stage canonical
+
+import Builtin
+import Swift
+
+/////////////////////
+// Inlining Tests //
+/////////////////////
+
+// *NOTE* These tests currently validate whether or not we
+// visit nodes in the correct order since we do not explore inlined
+// code for more apply inst to inline. After that point, we will
+// probably need to do one of the following:
+//
+// 1. Introduce a flag to turn off the exploration behavior.
+// 2. Introduce some sort of debug output that displays the callgraph
+// traversal order.
+
+// Node -> Node
+
+sil @test1_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %2 = integer_literal $Builtin.Int1, 0
+ %3 = builtin "umul_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
+ %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
+ return %4: $Builtin.Int64
+}
+
+// CHECK-LABEL: sil @test1
+// CHECK: bb0([[INPUT:%[0-9]+]] : $Builtin.Int64)
+// CHECK: integer_literal $Builtin.Int1, 0
+// CHECK: [[MUL_TUPLE_RESULT:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[INPUT]] : {{.*}}, [[INPUT]]
+// CHECK: [[MUL_RESULT:%[0-9]+]] = tuple_extract [[MUL_TUPLE_RESULT]]
+// CHECK: return [[MUL_RESULT]]
+sil @test1 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %1 = function_ref @test1_multiply_leaf : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ %2 = apply %1 (%0) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ return %2 : $Builtin.Int64
+}
+
+// Node
+// / \
+// v v
+// Node -> Node
+
+// CHECK-LABEL: sil @test2_add_leaf
+
+sil @test2_add_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %2 = integer_literal $Builtin.Int1, 0
+ %3 = builtin "uadd_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
+ %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
+ return %4: $Builtin.Int64
+}
+
+sil @test2_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %2 = integer_literal $Builtin.Int1, 0
+ %3 = builtin "umul_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
+ %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
+ return %4: $Builtin.Int64
+}
+
+sil @test2_add_then_multiply : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %1 = function_ref @test2_add_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %2 = apply %1(%0) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %3 = function_ref @test2_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %4 = apply %3(%2) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ return %4 : $Builtin.Int64
+}
+
+// CHECK-LABEL: sil @test2 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+// bb0([[INPUT:%[0-9]+]] : $Builtin.Int64):
+// CHECK: [[UADD_RESULT_TUPLE:%[0-9]+]] = builtin "uadd_with_overflow_Int64"([[INPUT]] : {{.*}}, [[INPUT]]
+// CHECK: [[UADD_RESULT:%[0-9]+]] = tuple_extract [[UADD_RESULT_TUPLE]] : $(Builtin.Int64, Builtin.Int1), 0
+// CHECK: [[UADD_RESULT_TUPLE2:%[0-9]+]] = builtin "uadd_with_overflow_Int64"([[UADD_RESULT]] : {{.*}}, [[UADD_RESULT]]
+// CHECK: [[UADD_RESULT2:%[0-9]+]] = tuple_extract [[UADD_RESULT_TUPLE2]]
+// CHECK: [[UMUL_RESULT_TUPLE:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[UADD_RESULT2]] : {{.*}}, [[UADD_RESULT2]]
+// CHECK: [[UMUL_RESULT:%[0-9]+]] = tuple_extract [[UMUL_RESULT_TUPLE]]
+// CHECK: return [[UMUL_RESULT]] : $Builtin.Int64
+sil @test2 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %1 = function_ref @test2_add_leaf: $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ %2 = apply %1 (%0) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ %3 = function_ref @test2_add_then_multiply : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ %4 = apply %3 (%2) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ return %4 : $Builtin.Int64
+}
+
+// Node
+// / \
+// v v
+// Node Node
+// \ /
+// v v
+// Node
+
+// CHECK-LABEL: sil @test3_add_leaf
+
+sil @test3_add_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %2 = integer_literal $Builtin.Int1, 0
+ %3 = builtin "uadd_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
+ %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
+ return %4: $Builtin.Int64
+}
+
+sil @test3_sub_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %1 = integer_literal $Builtin.Int64, 1
+ %2 = integer_literal $Builtin.Int1, 0
+ %3 = builtin "usub_with_overflow_Int64"(%0 : $Builtin.Int64, %1 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
+ %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
+ return %4: $Builtin.Int64
+}
+
+sil @test3_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %2 = integer_literal $Builtin.Int1, 0
+ %3 = builtin "umul_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
+ %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
+ return %4: $Builtin.Int64
+}
+
+sil @test3_add_then_multiply : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %1 = function_ref @test3_add_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %2 = apply %1(%0) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %3 = function_ref @test3_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %4 = apply %3(%2) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ return %4 : $Builtin.Int64
+}
+
+sil @test3_sub_then_multiply : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %1 = function_ref @test3_sub_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %2 = apply %1(%0) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %3 = function_ref @test3_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %4 = apply %3(%2) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ return %4 : $Builtin.Int64
+}
+
+// CHECK-LABEL: sil @test3 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+// CHECK: bb0([[INPUT:%[0-9]+]] : $Builtin.Int64):
+// CHECK: [[LITERAL1:%[0-9]+]] = integer_literal {{.*}}, 1
+// CHECK: [[USUB_RESULT_TUPLE:%[0-9]+]] = builtin "usub_with_overflow_Int64"([[INPUT]] : {{.*}}, [[LITERAL1]] : {{.*}}
+// CHECK: [[USUB_RESULT:%[0-9]+]] = tuple_extract [[USUB_RESULT_TUPLE]]
+// CHECK: [[UMUL_RESULT_TUPLE:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[USUB_RESULT]] : {{.*}}, [[USUB_RESULT]]
+// CHECK: [[UMUL_RESULT:%[0-9]+]] = tuple_extract [[UMUL_RESULT_TUPLE]]
+// CHECK: [[UADD_RESULT_TUPLE:%[0-9]+]] = builtin "uadd_with_overflow_Int64"([[UMUL_RESULT]] : {{.*}}, [[UMUL_RESULT]]
+// CHECK: [[UADD_RESULT:%[0-9]+]] = tuple_extract [[UADD_RESULT_TUPLE]]
+// CHECK: [[UMUL_RESULT_TUPLE2:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[UADD_RESULT]] : {{.*}}, [[UADD_RESULT]]
+// CHECK: [[UMUL_RESULT:%[0-9]+]] = tuple_extract [[UMUL_RESULT_TUPLE2]]
+// CHECK: return [[UMUL_RESULT]]
+sil @test3 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %1 = function_ref @test3_sub_then_multiply : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ %2 = apply %1 (%0) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ %3 = function_ref @test3_add_then_multiply : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ %4 = apply %3 (%2) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ return %4 : $Builtin.Int64
+}
+
+// Node
+// / \
+// v v
+// Node -> Node
+// \ /
+// v v
+// Node
+
+// CHECK-LABEL: sil @test4_add_leaf
+
+sil @test4_add_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %2 = integer_literal $Builtin.Int1, 0
+ %3 = builtin "uadd_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
+ %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
+ return %4: $Builtin.Int64
+}
+
+sil @test4_sub_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %2 = integer_literal $Builtin.Int1, 0
+ %3 = builtin "usub_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
+ %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
+ return %4: $Builtin.Int64
+}
+
+sil @test4_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %2 = integer_literal $Builtin.Int1, 0
+ %3 = builtin "umul_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
+ %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
+ return %4: $Builtin.Int64
+}
+
+sil @test4_add_then_multiply : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %1 = function_ref @test4_add_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %2 = apply %1(%0) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %3 = function_ref @test4_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %4 = apply %3(%2) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ return %4 : $Builtin.Int64
+}
+
+sil @test4_add_then_multiply_then_multiply : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %1 = function_ref @test4_add_then_multiply : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %2 = apply %1(%0) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %3 = function_ref @test4_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %4 = apply %3(%2) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ return %4 : $Builtin.Int64
+}
+
+// CHECK-LABEL: sil @test4 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+// CHECK: bb0([[INPUT:%[0-9]+]] : $Builtin.Int64):
+// CHECK: [[UADD_RESULT_TUPLE:%[0-9]+]] = builtin "uadd_with_overflow_Int64"([[INPUT]] : {{.*}}, [[INPUT]]
+// CHECK: [[UADD_RESULT:%[0-9]+]] = tuple_extract [[UADD_RESULT_TUPLE]]
+// CHECK: [[UMUL_RESULT_TUPLE:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[UADD_RESULT]] : {{.*}}, [[UADD_RESULT]]
+// CHECK: [[UMUL_RESULT:%[0-9]+]] = tuple_extract [[UMUL_RESULT_TUPLE]]
+
+// CHECK: [[UADD_RESULT_TUPLE2:%[0-9]+]] = builtin "uadd_with_overflow_Int64"([[UMUL_RESULT]] : {{.*}}, [[UMUL_RESULT]]
+// CHECK: [[UADD_RESULT2:%[0-9]+]] = tuple_extract [[UADD_RESULT_TUPLE2]]
+// CHECK: [[UMUL_RESULT_TUPLE2:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[UADD_RESULT2]] : {{.*}}, [[UADD_RESULT2]]
+// CHECK: [[UMUL_RESULT2:%[0-9]+]] = tuple_extract [[UMUL_RESULT_TUPLE2]]
+
+// CHECK: [[UMUL_RESULT_TUPLE3:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[UMUL_RESULT2]] : {{.*}}, [[UMUL_RESULT2]]
+// CHECK: [[UMUL_RESULT3:%[0-9]+]] = tuple_extract [[UMUL_RESULT_TUPLE3]]
+// CHECK: return [[UMUL_RESULT3]] : $Builtin.Int64
+sil @test4 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %1 = function_ref @test4_add_then_multiply : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ %2 = apply %1 (%0) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ %3 = function_ref @test4_add_then_multiply_then_multiply : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ %4 = apply %3 (%2) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
+ return %4 : $Builtin.Int64
+}
+
+// Circular Inline.
+
+// CHECK-LABEL: sil @test5
+// CHECK: bb0([[INPUT:%[0-9]+]] : $Builtin.Int64):
+// CHECK: [[FUN:%[0-9]+]] = function_ref @test5 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+// CHECK: [[FUN_RESULT:%[0-9]+]] = apply [[FUN]]([[INPUT]]) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+// CHECK: return [[FUN_RESULT]] : $Builtin.Int64
+sil @test5 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $Builtin.Int64):
+ %1 = function_ref @test5 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ %2 = apply %1(%0) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
+ return %2 : $Builtin.Int64
+}
+
+//////////////////////
+// Apply Type Tests //
+//////////////////////
+
+// CHECK-LABEL: sil @generic_function
+sil @generic_function : $@convention(thin) <T> (@in T, @in T) -> Builtin.Int8 {
+bb0(%0 : $*T, %1 : $*T):
+ %2 = integer_literal $Builtin.Int8, 2
+ return %2 : $Builtin.Int8
+}
+
+// IGNORE-THIS-CHECK-LABEL: sil @ignore_applies_with_substitutions
+
+// We can't deserialize apply_inst with subst lists. When radar://14443304
+// is fixed then we should uncomment this test.
+
+// sil @ignore_applies_with_substitutions : $@convention(thin) (Builtin.Int64) -> Builtin.Int8 {
+// bb0(%0 : $Builtin.Int64):
+// %1 = function_ref @generic_function : $@convention(thin) <T> (@in T, @in T) -> Builtin.Int8
+// %2 = apply %1<T = Builtin.Int64>(%0, %0) : $@convention(thin) <T> (@in T, @in T) -> Builtin.Int8
+// return %2 : $Builtin.Int8
+// }
+
+// CHECK-LABEL: sil @trivial_fun
+
+sil @trivial_fun : $@convention(thin) () -> (Builtin.Int64) {
+ %0 = integer_literal $Builtin.Int64, 32
+ return %0 : $Builtin.Int64
+}
+
+protocol P {}
+extension Int64: P {}
+
+// We can inline function_refs with witness_method calling convention.
+sil @trivial_witness_method : $@convention(witness_method: P) (@inout Int64) -> Int64 {
+bb0(%0 : $*Int64):
+ %1 = load %0 : $*Int64
+ return %1 : $Int64
+}
+
+// CHECK-LABEL: sil @trivial_witness_method_caller : $@convention(thin) () -> ()
+// CHECK-NOT: apply .*@convention(witness_method
+// CHECK: return
+sil @trivial_witness_method_caller : $@convention(thin) () -> () {
+ %0 = alloc_box ${ var Int64 }, var, name "x"
+ %1 = project_box %0 : ${ var Int64 }, 0
+ %2 = function_ref @$Ss5Int64V22_builtinIntegerLiteralABBi2048__tcfC : $@convention(method) (Builtin.Int2048, @thin Int64.Type) -> Int64 // user: %5
+ %3 = metatype $@thin Int64.Type
+ %4 = integer_literal $Builtin.Int2048, 0
+ %5 = apply %2(%4, %3) : $@convention(method) (Builtin.Int2048, @thin Int64.Type) -> Int64
+ store %5 to %1 : $*Int64
+ %6 = function_ref @trivial_witness_method : $@convention(witness_method: P) (@inout Int64) -> Int64
+ %7 = apply %6 (%1) : $@convention(witness_method: P) (@inout Int64) -> Int64
+ %8 = tuple()
+ return %8 : $()
+}
+
+// Int64.init(_builtinIntegerLiteral:)
+sil [transparent] [serialized] @$Ss5Int64V22_builtinIntegerLiteralABBi2048__tcfC : $@convention(method) (Builtin.Int2048, @thin Int64.Type) -> Int64
+
+
+// We can inline function_refs with c calling convention.
+sil @trivial_c : $@convention(c) (@inout Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $*Builtin.Int64):
+ %1 = load %0 : $*Builtin.Int64
+ return %1 : $Builtin.Int64
+}
+
+// CHECK-LABEL: sil @trivial_c_caller : $@convention(thin) () -> ()
+// CHECK-NOT: apply
+// CHECK: return
+sil @trivial_c_caller : $@convention(thin) () -> () {
+ %0 = alloc_stack $Builtin.Int64
+ %1 = integer_literal $Builtin.Int64, 0
+ store %1 to %0 : $*Builtin.Int64
+ %2 = function_ref @trivial_c : $@convention(c) (@inout Builtin.Int64) -> Builtin.Int64
+ apply %2 (%0) : $@convention(c) (@inout Builtin.Int64) -> Builtin.Int64
+ dealloc_stack %0 : $*Builtin.Int64
+ %3 = tuple()
+ return %3 : $()
+}
+
+// We can inline function_refs with objc_method calling convention.
+//
+// ObjC calls are unable to be devirtualized since at runtime the call
+// could change. But there is no reason in principal why we could not
+// (if there existed something like sealed classes in objc perhaps?),
+// inline a function_ref to such a call.
+sil @trivial_objc : $@convention(objc_method) (@inout Builtin.Int64) -> Builtin.Int64 {
+bb0(%0 : $*Builtin.Int64):
+ %1 = load %0 : $*Builtin.Int64
+ return %1 : $Builtin.Int64
+}
+
+// CHECK-LABEL: sil @trivial_objc_caller : $@convention(thin) () -> ()
+// CHECK-NOT: apply
+// CHECK: return
+sil @trivial_objc_caller : $@convention(thin) () -> () {
+ %0 = alloc_stack $Builtin.Int64
+ %1 = integer_literal $Builtin.Int64, 0
+ store %1 to %0 : $*Builtin.Int64
+ %2 = function_ref @trivial_objc : $@convention(objc_method) (@inout Builtin.Int64) -> Builtin.Int64
+ apply %2 (%0) : $@convention(objc_method) (@inout Builtin.Int64) -> Builtin.Int64
+ dealloc_stack %0 : $*Builtin.Int64
+ %3 = tuple()
+ return %3 : $()
+}
+
+//////////
+// Misc //
+//////////
+
+// Make sure SILCloner does not get into an infinite loop here.
+sil @_TFsoi1xFT3lhsVs5UWord3rhsS__S_ : $@convention(thin) (UInt32, UInt32) -> UInt32 {
+bb0(%0 : $UInt32, %1 : $UInt32):
+ %3 = struct_extract %0 : $UInt32, #UInt32._value // user: %5
+ %4 = struct_extract %1 : $UInt32, #UInt32._value // user: %5
+ %5 = builtin "xor_Int32"(%3 : $Builtin.Int32, %4 : $Builtin.Int32) : $Builtin.Int32 // user: %6
+ %6 = struct $UInt32 (%5 : $Builtin.Int32) // user: %7
+ return %6 : $UInt32 // id: %7
+}
+
+sil @_TFsop1tFT1aVs5UWord_S_ : $@convention(thin) (UInt32) -> UInt32 {
+bb0(%0 : $UInt32):
+ // function_ref Swift.^ [infix] (lhs : Swift.UInt32, rhs : Swift.UInt32) -> Swift.UInt32
+ %1 = function_ref @_TFsoi1xFT3lhsVs5UWord3rhsS__S_ : $@convention(thin) (UInt32, UInt32) -> UInt32 // user: %6
+ // function_ref Swift.~ [prefix] (a : Swift.UInt32) -> Swift.UInt32
+ %2 = function_ref @_TFsop1tFT1aVs5UWord_S_ : $@convention(thin) (UInt32) -> UInt32 // user: %5
+ %3 = integer_literal $Builtin.Int32, 0 // user: %4
+ %4 = struct $UInt32 (%3 : $Builtin.Int32) // user: %5
+ %5 = apply %2(%4) : $@convention(thin) (UInt32) -> UInt32 // user: %6
+ %6 = apply %1(%0, %5) : $@convention(thin) (UInt32, UInt32) -> UInt32 // user: %7
+ return %6 : $UInt32 // id: %7
+}
+
+// Transparent function may inline private functions.
+//
+sil private @private_ret_undef : $@convention(thin) () -> () {
+entry:
+ return undef : $()
+}
+
+sil @uses_private : $@convention(thin) () -> () {
+entry:
+ %f = function_ref @private_ret_undef : $@convention(thin) () -> ()
+ %z = apply %f() : $@convention(thin) () -> ()
+ return %z : $()
+}
+
+// CHECK-LABEL: sil [transparent] @transparent_uses_uses_private : $@convention(thin) () -> () {
+// CHECK-NOT: function_ref @uses_private
+// CHECK: return
+sil [transparent] @transparent_uses_uses_private : $@convention(thin) () -> () {
+entry:
+ %f = function_ref @uses_private : $@convention(thin) () -> ()
+ %z = apply %f() : $@convention(thin) () -> ()
+ return %z : $()
+}
+
+// Test fragile-resilient inlining rules:
+// Everything is allowed except inlining of a resilient function into a fragile function.
+
+sil @resilient_function : $@convention(thin) () -> () {
+entry:
+ return undef : $()
+}
+
+sil [serialized] @fragile_function : $@convention(thin) () -> () {
+entry:
+ return undef : $()
+}
+
+// CHECK-LABEL: sil [serialized] @fragile_calls_resilient : $@convention(thin) () -> () {
+// CHECK: function_ref @resilient_function
+// CHECK: return
+sil [serialized] @fragile_calls_resilient : $@convention(thin) () -> () {
+entry:
+ %f = function_ref @resilient_function : $@convention(thin) () -> ()
+ %z = apply %f() : $@convention(thin) () -> ()
+ return %z : $()
+}
+
+// CHECK-LABEL: sil [serialized] @fragile_calls_fragile : $@convention(thin) () -> () {
+// CHECK-NOT: function_ref @resilient_function
+// CHECK: return
+sil [serialized] @fragile_calls_fragile : $@convention(thin) () -> () {
+entry:
+ %f = function_ref @fragile_function : $@convention(thin) () -> ()
+ %z = apply %f() : $@convention(thin) () -> ()
+ return %z : $()
+}
+
+// CHECK-LABEL: sil @resilient_calls_fragile : $@convention(thin) () -> () {
+// CHECK-NOT: function_ref @resilient_function
+// CHECK: return
+sil @resilient_calls_fragile : $@convention(thin) () -> () {
+entry:
+ %f = function_ref @fragile_function : $@convention(thin) () -> ()
+ %z = apply %f() : $@convention(thin) () -> ()
+ return %z : $()
+}
+
+// CHECK-LABEL: sil @resilient_calls_resilient : $@convention(thin) () -> () {
+// CHECK-NOT: function_ref @resilient_function
+// CHECK: return
+sil @resilient_calls_resilient : $@convention(thin) () -> () {
+entry:
+ %f = function_ref @resilient_function : $@convention(thin) () -> ()
+ %z = apply %f() : $@convention(thin) () -> ()
+ return %z : $()
+}
+
+// CHECK-LABEL: sil @calls_self
+// CHECK-NEXT: bb0:
+// CHECK: function_ref @calls_self
+// CHECK-NEXT: apply
+// CHECK-NEXT: return
+sil @calls_self : $@convention(thin) () -> () {
+entry:
+ %f = function_ref @calls_self : $@convention(thin) () -> ()
+ %z = apply %f() : $@convention(thin) () -> ()
+ return %z : $()
+}
+
+// Visibility Tests
+// These tests stem from a time where visibility had an influence
+// on the inlining. This is no longer the case so we just check
+// if everything can be inlined, regardless of visibility.
+
+sil_global private @private_global : $Builtin.Word
+sil private @private_function : $@convention(thin) () -> () {
+ %0 = integer_literal $Builtin.Int32, 0
+ %1 = tuple()
+ return %1 : $()
+}
+sil @references_private_global : $@convention(thin) () -> () {
+ %0 = global_addr @private_global : $*Builtin.Word
+ %1 = tuple()
+ return %1 : $()
+}
+sil @references_private_function : $@convention(thin) () -> () {
+ %0 = function_ref @private_function : $@convention(thin) () -> ()
+ %1 = tuple()
+ return %1 : $()
+}
+
+sil_global shared @shared_global : $Builtin.Word
+sil shared @shared_function : $@convention(thin) () -> () {
+ %0 = integer_literal $Builtin.Int32, 1
+ %1 = tuple()
+ return %1 : $()
+}
+sil @references_shared_global : $@convention(thin) () -> () {
+ %0 = global_addr @shared_global : $*Builtin.Word
+ %1 = tuple()
+ return %1 : $()
+}
+sil @references_shared_function : $@convention(thin) () -> () {
+ %0 = function_ref @shared_function : $@convention(thin) () -> ()
+ %1 = tuple()
+ return %1 : $()
+}
+
+sil_global hidden @hidden_global : $Builtin.Word
+sil hidden @hidden_function : $@convention(thin) () -> () {
+ %0 = integer_literal $Builtin.Int32, 2
+ %1 = tuple()
+ return %1 : $()
+}
+sil @references_hidden_global : $@convention(thin) () -> () {
+ %0 = global_addr @hidden_global : $*Builtin.Word
+ %1 = tuple()
+ return %1 : $()
+}
+sil @references_hidden_function : $@convention(thin) () -> () {
+ %0 = function_ref @hidden_function : $@convention(thin) () -> ()
+ %1 = tuple()
+ return %1 : $()
+}
+
+sil_global @public_global : $Builtin.Word
+sil @public_function : $@convention(thin) () -> () {
+ %0 = integer_literal $Builtin.Int32, 4
+ %1 = tuple()
+ return %1 : $()
+}
+
+sil @references_public_global : $@convention(thin) () -> () {
+ %0 = global_addr @public_global : $*Builtin.Word
+ %1 = tuple()
+ return %1 : $()
+}
+sil @references_public_function : $@convention(thin) () -> () {
+ %0 = function_ref @public_function : $@convention(thin) () -> ()
+ %1 = tuple()
+ return %1 : $()
+}
+
+// CHECK-LABEL: sil private @private_function_test : $@convention(thin) () -> () {
+// CHECK-NOT: function_ref
+// CHECK: return
+sil private @private_function_test : $@convention(thin) () -> () {
+ %0 = function_ref @references_public_function : $@convention(thin) () -> ()
+ %1 = function_ref @references_shared_function : $@convention(thin) () -> ()
+ %2 = function_ref @references_hidden_function : $@convention(thin) () -> ()
+ %3 = function_ref @references_private_function : $@convention(thin) () -> ()
+ %4 = function_ref @references_public_global : $@convention(thin) () -> ()
+ %5 = function_ref @references_shared_global : $@convention(thin) () -> ()
+ %6 = function_ref @references_hidden_global : $@convention(thin) () -> ()
+ %7 = function_ref @references_private_global : $@convention(thin) () -> ()
+ apply %0() : $@convention(thin) () -> ()
+ apply %1() : $@convention(thin) () -> ()
+ apply %2() : $@convention(thin) () -> ()
+ apply %3() : $@convention(thin) () -> ()
+ apply %4() : $@convention(thin) () -> ()
+ apply %5() : $@convention(thin) () -> ()
+ apply %6() : $@convention(thin) () -> ()
+ apply %7() : $@convention(thin) () -> ()
+ %8 = tuple()
+ return %8 : $()
+}
+
+// CHECK-LABEL: sil shared @shared_function_test : $@convention(thin) () -> () {
+// CHECK-NOT: function_ref
+// CHECK: return
+sil shared @shared_function_test : $@convention(thin) () -> () {
+ %0 = function_ref @references_public_function : $@convention(thin) () -> ()
+ %1 = function_ref @references_shared_function : $@convention(thin) () -> ()
+ %2 = function_ref @references_hidden_function : $@convention(thin) () -> ()
+ %3 = function_ref @references_private_function : $@convention(thin) () -> ()
+ %4 = function_ref @references_public_global : $@convention(thin) () -> ()
+ %5 = function_ref @references_shared_global : $@convention(thin) () -> ()
+ %6 = function_ref @references_hidden_global : $@convention(thin) () -> ()
+ %7 = function_ref @references_private_global : $@convention(thin) () -> ()
+ apply %0() : $@convention(thin) () -> ()
+ apply %1() : $@convention(thin) () -> ()
+ apply %2() : $@convention(thin) () -> ()
+ apply %3() : $@convention(thin) () -> ()
+ apply %4() : $@convention(thin) () -> ()
+ apply %5() : $@convention(thin) () -> ()
+ apply %6() : $@convention(thin) () -> ()
+ apply %7() : $@convention(thin) () -> ()
+ %8 = tuple()
+ return %8 : $()
+}
+
+// CHECK-LABEL: sil hidden @hidden_function_test : $@convention(thin) () -> () {
+// CHECK-NOT: function_ref
+// CHECK: return
+sil hidden @hidden_function_test : $@convention(thin) () -> () {
+ %0 = function_ref @references_public_function : $@convention(thin) () -> ()
+ %1 = function_ref @references_shared_function : $@convention(thin) () -> ()
+ %2 = function_ref @references_hidden_function : $@convention(thin) () -> ()
+ %3 = function_ref @references_private_function : $@convention(thin) () -> ()
+ %4 = function_ref @references_public_global : $@convention(thin) () -> ()
+ %5 = function_ref @references_shared_global : $@convention(thin) () -> ()
+ %6 = function_ref @references_hidden_global : $@convention(thin) () -> ()
+ %7 = function_ref @references_private_global : $@convention(thin) () -> ()
+ apply %0() : $@convention(thin) () -> ()
+ apply %1() : $@convention(thin) () -> ()
+ apply %2() : $@convention(thin) () -> ()
+ apply %3() : $@convention(thin) () -> ()
+ apply %4() : $@convention(thin) () -> ()
+ apply %5() : $@convention(thin) () -> ()
+ apply %6() : $@convention(thin) () -> ()
+ apply %7() : $@convention(thin) () -> ()
+ %8 = tuple()
+ return %8 : $()
+}
+
+// CHECK-LABEL: sil @public_function_test : $@convention(thin) () -> () {
+// CHECK-NOT: function_ref
+// CHECK: return
+sil @public_function_test : $@convention(thin) () -> () {
+ %0 = function_ref @references_public_function : $@convention(thin) () -> ()
+ %1 = function_ref @references_shared_function : $@convention(thin) () -> ()
+ %2 = function_ref @references_hidden_function : $@convention(thin) () -> ()
+ %3 = function_ref @references_private_function : $@convention(thin) () -> ()
+ %4 = function_ref @references_public_global : $@convention(thin) () -> ()
+ %5 = function_ref @references_shared_global : $@convention(thin) () -> ()
+ %6 = function_ref @references_hidden_global : $@convention(thin) () -> ()
+ %7 = function_ref @references_private_global : $@convention(thin) () -> ()
+ apply %0() : $@convention(thin) () -> ()
+ apply %1() : $@convention(thin) () -> ()
+ apply %2() : $@convention(thin) () -> ()
+ apply %3() : $@convention(thin) () -> ()
+ apply %4() : $@convention(thin) () -> ()
+ apply %5() : $@convention(thin) () -> ()
+ apply %6() : $@convention(thin) () -> ()
+ apply %7() : $@convention(thin) () -> ()
+ %8 = tuple()
+ return %8 : $()
+}
+
+// CHECK-LABEL: sil hidden_external @hidden_external_function_test : $@convention(thin) () -> () {
+// CHECK-NOT: function_ref
+// CHECK: return
+sil hidden_external @hidden_external_function_test : $@convention(thin) () -> () {
+ %0 = function_ref @references_public_function : $@convention(thin) () -> ()
+ %1 = function_ref @references_shared_function : $@convention(thin) () -> ()
+ %2 = function_ref @references_hidden_function : $@convention(thin) () -> ()
+ %3 = function_ref @references_private_function : $@convention(thin) () -> ()
+ %4 = function_ref @references_public_global : $@convention(thin) () -> ()
+ %5 = function_ref @references_shared_global : $@convention(thin) () -> ()
+ %6 = function_ref @references_hidden_global : $@convention(thin) () -> ()
+ %7 = function_ref @references_private_global : $@convention(thin) () -> ()
+ apply %0() : $@convention(thin) () -> ()
+ apply %1() : $@convention(thin) () -> ()
+ apply %2() : $@convention(thin) () -> ()
+ apply %3() : $@convention(thin) () -> ()
+ apply %4() : $@convention(thin) () -> ()
+ apply %5() : $@convention(thin) () -> ()
+ apply %6() : $@convention(thin) () -> ()
+ apply %7() : $@convention(thin) () -> ()
+ %8 = tuple()
+ return %8 : $()
+}
+
+// CHECK-LABEL: sil public_external @public_external_function_test : $@convention(thin) () -> () {
+// CHECK-NOT: function_ref
+// CHECK: return
+sil public_external @public_external_function_test : $@convention(thin) () -> () {
+ %0 = function_ref @references_public_function : $@convention(thin) () -> ()
+ %1 = function_ref @references_shared_function : $@convention(thin) () -> ()
+ %2 = function_ref @references_hidden_function : $@convention(thin) () -> ()
+ %3 = function_ref @references_private_function : $@convention(thin) () -> ()
+ %4 = function_ref @references_public_global : $@convention(thin) () -> ()
+ %5 = function_ref @references_shared_global : $@convention(thin) () -> ()
+ %6 = function_ref @references_hidden_global : $@convention(thin) () -> ()
+ %7 = function_ref @references_private_global : $@convention(thin) () -> ()
+ apply %0() : $@convention(thin) () -> ()
+ apply %1() : $@convention(thin) () -> ()
+ apply %2() : $@convention(thin) () -> ()
+ apply %3() : $@convention(thin) () -> ()
+ apply %4() : $@convention(thin) () -> ()
+ apply %5() : $@convention(thin) () -> ()
+ apply %6() : $@convention(thin) () -> ()
+ apply %7() : $@convention(thin) () -> ()
+ %8 = tuple()
+ return %8 : $()
+}
+
+// CHECK-LABEL: @caller_of_noinline
+sil @caller_of_noinline : $@convention(thin) () -> () {
+bb0:
+ // CHECK: function_ref @noinline_callee
+ // CHECK: apply
+ %0 = function_ref @noinline_callee : $@convention(thin) () -> Int
+ %1 = apply %0() : $@convention(thin) () -> Int
+ %2 = tuple ()
+ return %2 : $()
+}
+// CHECK-LABEL: [noinline] @noinline_callee
+sil [noinline] @noinline_callee : $@convention(thin) () -> Int {
+bb0:
+ %0 = function_ref @_TFSi33_convertFromBuiltinIntegerLiteralfMSiFBi2048_Si : $@convention(thin) (Builtin.Int2048, @thin Int.Type) -> Int
+ %1 = metatype $@thin Int.Type
+ %2 = integer_literal $Builtin.Int2048, 0
+ %3 = apply %0(%2, %1) : $@convention(thin) (Builtin.Int2048, @thin Int.Type) -> Int
+ return %3 : $Int
+}
+sil [transparent] @_TFSi33_convertFromBuiltinIntegerLiteralfMSiFBi2048_Si : $@convention(thin) (Builtin.Int2048, @thin Int.Type) -> Int
+
+sil @unknown_function : $@convention(thin) () -> ()
+
+sil @coldcall : $@convention(thin) () -> () {
+bb0:
+ // make it a non-trivial function
+ %f = function_ref @unknown_function : $@convention(thin) () -> ()
+ %a1 = apply %f() : $@convention(thin) () -> ()
+ %a2 = apply %f() : $@convention(thin) () -> ()
+ %a3 = apply %f() : $@convention(thin) () -> ()
+ %a4 = apply %f() : $@convention(thin) () -> ()
+ %a5 = apply %f() : $@convention(thin) () -> ()
+ %a6 = apply %f() : $@convention(thin) () -> ()
+ %a7 = apply %f() : $@convention(thin) () -> ()
+ %a8 = apply %f() : $@convention(thin) () -> ()
+ %a9 = apply %f() : $@convention(thin) () -> ()
+ %a10 = apply %f() : $@convention(thin) () -> ()
+ %a11 = apply %f() : $@convention(thin) () -> ()
+ %a12 = apply %f() : $@convention(thin) () -> ()
+ %a13 = apply %f() : $@convention(thin) () -> ()
+ %a14 = apply %f() : $@convention(thin) () -> ()
+ %a15 = apply %f() : $@convention(thin) () -> ()
+ %a16 = apply %f() : $@convention(thin) () -> ()
+ %a17 = apply %f() : $@convention(thin) () -> ()
+ %a18 = apply %f() : $@convention(thin) () -> ()
+ %a19 = apply %f() : $@convention(thin) () -> ()
+ %a20 = apply %f() : $@convention(thin) () -> ()
+ %a21 = apply %f() : $@convention(thin) () -> ()
+ %a22 = apply %f() : $@convention(thin) () -> ()
+ %0 = tuple () // user: %1
+ return %0 : $() // id: %1
+}
+
+// Generic call to "branchHint" for use in specialized @slowPath
+sil public_external [transparent] [_semantics "branchhint"] @_TFs11_branchHintUs7Boolean__FTQ_Sb_Sb : $@convention(thin)(Bool, Bool) -> Bool {
+bb0(%0 : $Bool, %1 : $Bool):
+ return %0 : $Bool
+}
+
+// Specialized call to "slowPath" for use in @coldcall_caller
+sil shared [noinline] [transparent] [_semantics "slowpath"] @_TTSgSbSbs7Boolean___TFs9_slowPathUs7Boolean__FQ_Sb : $@convention(thin) (Bool) -> Bool {
+bb0(%0 : $Bool):
+ %3 = integer_literal $Builtin.Int1, 0
+ %4 = struct $Bool (%3 : $Builtin.Int1)
+ %5 = function_ref @_TFs11_branchHintUs7Boolean__FTQ_Sb_Sb : $@convention(thin) (Bool, Bool) -> Bool
+ %6 = apply %5(%0, %4) : $@convention(thin) (Bool, Bool) -> Bool
+ return %6 : $Bool
+}
+
+// CHECK-LABEL: @coldcall_caller
+// CHECK: slowPath
+// CHECK-LABEL: bb1:
+// CHECK: function_ref @coldcall
+// CHECK: apply
+// CHECK-LABEL: bb2:
+sil @coldcall_caller : $@convention(thin) (Int32) -> () {
+bb0(%0 : $Int32):
+ %1 = alloc_stack $Bool // users: %7, %9, %11
+ %2 = integer_literal $Builtin.Int32, 0 // user: %5
+ %4 = struct_extract %0 : $Int32, #Int32._value // user: %5
+ %5 = builtin "cmp_eq_Word"(%4 : $Builtin.Int32, %2 : $Builtin.Int32) : $Builtin.Int1 // user: %6
+ %6 = struct $Bool (%5 : $Builtin.Int1) // user: %7
+ store %6 to %1 : $*Bool // id: %7
+ %8 = function_ref @_TTSgSbSbs7Boolean___TFs9_slowPathUs7Boolean__FQ_Sb : $@convention(thin) (Bool) -> Bool // user: %9
+ %9 = apply %8(%6) : $@convention(thin) (Bool) -> Bool // user: %10
+ %10 = struct_extract %9 : $Bool, #Bool._value // user: %12
+ dealloc_stack %1 : $*Bool // id: %11
+ cond_br %10, bb1, bb2 // id: %12
+
+bb1: // Preds: bb0
+ %13 = function_ref @coldcall : $@convention(thin) () -> () // user: %14
+ %14 = apply %13() : $@convention(thin) () -> ()
+ br bb2 // id: %15
+
+bb2: // Preds: bb0 bb1
+ %16 = tuple () // user: %17
+ return %16 : $() // id: %17
+}
+
+sil @slowHelper : $@convention(thin) () -> () {
+bb0:
+ // make it a non-trivial function
+ %f = function_ref @unknown_function : $@convention(thin) () -> ()
+ %a1 = apply %f() : $@convention(thin) () -> ()
+ %a2 = apply %f() : $@convention(thin) () -> ()
+ %a3 = apply %f() : $@convention(thin) () -> ()
+ %a4 = apply %f() : $@convention(thin) () -> ()
+ %a5 = apply %f() : $@convention(thin) () -> ()
+ %a6 = apply %f() : $@convention(thin) () -> ()
+ %a7 = apply %f() : $@convention(thin) () -> ()
+ %a8 = apply %f() : $@convention(thin) () -> ()
+ %a9 = apply %f() : $@convention(thin) () -> ()
+ %a10 = apply %f() : $@convention(thin) () -> ()
+ %a11 = apply %f() : $@convention(thin) () -> ()
+ %a12 = apply %f() : $@convention(thin) () -> ()
+ %a13 = apply %f() : $@convention(thin) () -> ()
+ %a14 = apply %f() : $@convention(thin) () -> ()
+ %a15 = apply %f() : $@convention(thin) () -> ()
+ %a16 = apply %f() : $@convention(thin) () -> ()
+ %a17 = apply %f() : $@convention(thin) () -> ()
+ %a18 = apply %f() : $@convention(thin) () -> ()
+ %a19 = apply %f() : $@convention(thin) () -> ()
+ %a20 = apply %f() : $@convention(thin) () -> ()
+ %a21 = apply %f() : $@convention(thin) () -> ()
+ %a22 = apply %f() : $@convention(thin) () -> ()
+ %t = tuple ()
+ return %t : $()
+}
+
+sil [transparent] [_semantics "fastpath"] @fastPathHelper : $@convention(thin) (Bool) -> Bool
+
+// fastpath.closedTest0 () -> ()
+// From <rdar://problem/17611447> _fastPath kills optimizer
+// First test that the inliner is not inlining the slow call.
+// Then test that same calls is not inlined when transparent.
+// CHECK-LABEL: @testNoInlineSlow
+// CHECK-LABEL: bb0:
+// CHECK: function_ref @fastPathHelper
+// CHECK-LABEL: bb1:
+// CHECK: function_ref @slowHelper
+// CHECK-LABEL: bb2:
+sil @testNoInlineSlow : $@convention(thin) () -> () {
+bb0:
+ %f1 = function_ref @fastPathHelper : $@convention(thin) (Bool) -> Bool
+ %v9 = alloc_stack $Bool
+ %v12 = integer_literal $Builtin.Int1, 0
+ %v16 = struct $Bool (%v12 : $Builtin.Int1)
+ store %v16 to %v9 : $*Bool // id: %17
+ %v18 = apply %f1(%v16) : $@convention(thin) (Bool) -> Bool
+ %v19 = struct_extract %v18 : $Bool, #Bool._value
+ dealloc_stack %v9 : $*Bool // id: %20
+ cond_br %v19, bb2, bb1 // id: %21
+
+bb1:
+ %f2 = function_ref @slowHelper : $@convention(thin) () -> ()
+ %r2 = apply %f2() : $@convention(thin) () -> ()
+ br bb2
+
+bb2:
+ %t3 = tuple ()
+ return %t3 : $()
+}
+
+// CHECK-LABEL: @testInlineSlowTransparent
+// CHECK-LABEL: bb0:
+// CHECK: function_ref @fastPathHelper
+// CHECK-LABEL: bb1:
+// CHECK: function_ref @slowHelper
+// CHECK-LABEL: bb2:
+sil @testInlineSlowTransparent : $@convention(thin) () -> () {
+bb0:
+ %f1 = function_ref @fastPathHelper : $@convention(thin) (Bool) -> Bool
+ %v9 = alloc_stack $Bool
+ %v12 = integer_literal $Builtin.Int1, 0
+ %v16 = struct $Bool (%v12 : $Builtin.Int1)
+ store %v16 to %v9 : $*Bool // id: %17
+ %v18 = apply %f1(%v16) : $@convention(thin) (Bool) -> Bool
+ %v19 = struct_extract %v18 : $Bool, #Bool._value
+ dealloc_stack %v9 : $*Bool // id: %20
+ cond_br %v19, bb2, bb1 // id: %21
+
+bb1:
+ %f2 = function_ref @slowHelper : $@convention(thin) () -> ()
+ %r2 = apply %f2() : $@convention(thin) () -> ()
+ br bb2
+
+bb2:
+ %t3 = tuple ()
+ return %t3 : $()
+}
+
+// Attempt to ensure that calling the devirtualizer on a try_apply
+// from the performance inliner doesn't result in an assert/crash.
+
+class C {
+ @inline(never) func callThrowing<T>(other: T, closure: @escaping () throws -> T) -> T
+}
+
+// CHECK-LABEL: sil [noinline] @callThrowing
+sil [noinline] @callThrowing : $@convention(method) <T> (@in_guaranteed T, @guaranteed @callee_owned () -> (@out T, @error Error), @guaranteed C) -> @out T {
+bb0(%0 : $*T, %1 : $*T, %2 : $@callee_owned () -> (@out T, @error Error), %3 : $C):
+ strong_retain %2 : $@callee_owned () -> (@out T, @error Error)
+ try_apply %2(%0) : $@callee_owned () -> (@out T, @error Error), normal bb1, error bb4
+
+bb1(%6 : $()):
+ br bb2
+
+bb2:
+ strong_release %2 : $@callee_owned () -> (@out T, @error Error)
+ destroy_addr %1 : $*T
+ %10 = tuple ()
+ return %10 : $()
+
+bb3:
+ copy_addr %1 to [initialization] %0 : $*T
+ strong_release %15 : $Error
+ br bb2
+
+bb4(%15 : $Error):
+ br bb3
+}
+
+
+// CHECK-LABEL: sil @callNonThrowing
+sil @callNonThrowing : $@convention(thin) (@owned C) -> Int32 {
+bb0(%0 : $C):
+ %1 = integer_literal $Builtin.Int32, 1
+ %2 = struct $Int32 (%1 : $Builtin.Int32)
+ %3 = alloc_stack $Int32
+ store %2 to %3 : $*Int32
+ %5 = function_ref @theClosure : $@convention(thin) () -> (Int32, @error Error)
+ %6 = thin_to_thick_function %5 : $@convention(thin) () -> (Int32, @error Error) to $@callee_owned () -> (Int32, @error Error)
+ %7 = function_ref @reabstractionThunk : $@convention(thin) (@owned @callee_owned () -> (Int32, @error Error)) -> (@out Int32, @error Error)
+ %8 = partial_apply %7(%6) : $@convention(thin) (@owned @callee_owned () -> (Int32, @error Error)) -> (@out Int32, @error Error)
+ %9 = alloc_stack $Int32
+ %10 = function_ref @callThrowing : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @guaranteed @callee_owned () -> (@out τ_0_0, @error Error), @guaranteed C) -> @out τ_0_0
+ %11 = apply %10<Int32>(%9, %3, %8, %0) : $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @guaranteed @callee_owned () -> (@out τ_0_0, @error Error), @guaranteed C) -> @out τ_0_0
+ %12 = load %9 : $*Int32
+ dealloc_stack %9 : $*Int32
+ dealloc_stack %3 : $*Int32
+ strong_release %0 : $C
+// CHECK: return
+ return %12 : $Int32
+}
+
+
+// CHECK-LABEL: sil @theClosure
+sil @theClosure : $@convention(thin) () -> (Int32, @error Error) {
+bb0:
+ %0 = integer_literal $Builtin.Int32, 0
+ %1 = struct $Int32 (%0 : $Builtin.Int32)
+ return %1 : $Int32
+}
+
+// CHECK-LABEL: sil [transparent] [reabstraction_thunk] @reabstractionThunk
+sil [transparent] [reabstraction_thunk] @reabstractionThunk : $@convention(thin) (@owned @callee_owned () -> (Int32, @error Error)) -> (@out Int32, @error Error) {
+bb0(%0 : $*Int32, %1 : $@callee_owned () -> (Int32, @error Error)):
+ try_apply %1() : $@callee_owned () -> (Int32, @error Error), normal bb1, error bb2
+
+bb1(%3 : $Int32):
+ store %3 to %0 : $*Int32
+ %5 = tuple ()
+ return %5 : $()
+
+bb2(%7 : $Error):
+ %8 = builtin "willThrow"(%7 : $Error) : $()
+ throw %7 : $Error
+}
+
+sil_vtable C {
+ #C.callThrowing!1: @callThrowing
+}
diff --git a/test/SILOptimizer/plus_zero_spec_archetype_method.swift b/test/SILOptimizer/plus_zero_spec_archetype_method.swift
new file mode 100644
index 0000000..f76cf39
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_spec_archetype_method.swift
@@ -0,0 +1,45 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -O -Xllvm -sil-disable-pass=FunctionSignatureOpts -disable-arc-opts -emit-sil -primary-file %s | %FileCheck %s
+
+// We can't deserialize apply_inst with subst lists. When radar://14443304
+// is fixed then we should convert this test to a SIL test.
+
+protocol pingable {
+ func ping()
+}
+
+class ABC : pingable {
+ @inline(never)
+ func ping() {}
+}
+
+@inline(never)
+func generic_call<T : pingable>(x x: T) {
+ x.ping()
+}
+
+struct A<B> : pingable {
+ @inline(never)
+ func ping() {}
+}
+
+@inline(never)
+func useFoo<T>(x x: T) {
+ let a = A<T>()
+ generic_call(x: a)
+}
+
+//CHECK-LABEL: sil @$S21spec_archetype_method21interesting_code_hereyyF
+//CHECK: function_ref @$S21spec_archetype_method12generic_call{{[_0-9a-zA-Z]*}}FAA3ABCC_Tg5
+//CHECK-NEXT: apply
+//CHECK: function_ref @$S21spec_archetype_method6useFoo{{[_0-9a-zA-Z]*}}FAA3ABCC_Tg5 : $@convention(thin) (@in_guaranteed ABC) -> ()
+//CHECK-NEXT: apply
+//CHECK: return
+public
+func interesting_code_here() {
+ let x = ABC()
+ // Make sure that we can specialize the function generic_call that has a
+ // generic call to x.ping().
+ generic_call(x: x)
+ useFoo(x: x)
+}
diff --git a/test/SILOptimizer/plus_zero_specialize_anyobject.swift b/test/SILOptimizer/plus_zero_specialize_anyobject.swift
new file mode 100644
index 0000000..5d5326c
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_specialize_anyobject.swift
@@ -0,0 +1,23 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -O -sil-inline-threshold 0 -emit-sil -primary-file %s | %FileCheck %s
+
+// rdar://problem/20338028
+protocol PA: class { }
+protocol PB { associatedtype B: PA }
+
+class CA: PA { }
+class CB: PB { typealias B = CA }
+
+struct S<A: PB> {
+ @_transparent
+ func crash() -> Bool {
+ let a: A.B? = nil
+ return a === a
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S20specialize_anyobject6callit{{[_0-9a-zA-Z]*}}F
+func callit(s: S<CB>) {
+ // CHECK: function_ref @$Ss3eeeoiySbyXlSg_ABtF : $@convention(thin) (@guaranteed Optional<AnyObject>, @guaranteed Optional<AnyObject>) -> Bool
+ s.crash()
+}
diff --git a/test/SILOptimizer/plus_zero_specialize_cg_update_crash.sil b/test/SILOptimizer/plus_zero_specialize_cg_update_crash.sil
new file mode 100644
index 0000000..01b0190
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_specialize_cg_update_crash.sil
@@ -0,0 +1,33 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -parse-stdlib -parse-as-library -module-name TestMod %S/Inputs/TestMod.sil -emit-module-path %t/TestMod.swiftmodule
+// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -enable-sil-verify-all -inline -I %t %s | %FileCheck %s
+
+// Test if the CG is updated correctly during specialization and
+// there is no crash because of a missing CG node for a deserialized function.
+
+sil_stage canonical
+
+import Builtin
+import TestMod
+
+struct MyStruct {
+}
+
+sil @_TF7TestMod10genlibfuncurFq_q_ : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out τ_0_0
+sil @_TF7TestMod11genlibfunc2urFq_q_ : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out τ_0_0
+
+// CHECK-LABEL: sil @testit
+sil @testit : $@convention(thin) () -> MyStruct {
+bb0:
+ %x0 = function_ref @_TF7TestMod10genlibfuncurFq_q_ : $@convention(thin) <X> (@in_guaranteed X) -> @out X
+ %13 = function_ref @_TF7TestMod11genlibfunc2urFq_q_ : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ %14 = alloc_stack $MyStruct
+ %16 = alloc_stack $MyStruct
+ %17 = apply %13<MyStruct>(%16, %14) : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> @out τ_0_0
+ %18 = struct $MyStruct ()
+ dealloc_stack %16 : $*MyStruct
+ dealloc_stack %14 : $*MyStruct
+ return %18 : $MyStruct
+}
+
diff --git a/test/SILOptimizer/plus_zero_specialize_checked_cast_branch.swift b/test/SILOptimizer/plus_zero_specialize_checked_cast_branch.swift
new file mode 100644
index 0000000..4f6073d
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_specialize_checked_cast_branch.swift
@@ -0,0 +1,338 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-sil -O -sil-inline-threshold 0 %s -o - | %FileCheck %s
+
+class C {}
+class D : C {}
+class E {}
+
+struct NotUInt8 { var value: UInt8 }
+struct NotUInt64 { var value: UInt64 }
+
+var b = NotUInt8(value: 0)
+var c = C()
+var d = D()
+var e = E()
+var f = NotUInt64(value: 0)
+var o : AnyObject = c
+
+////////////////////////
+// Arch to Arch Casts //
+////////////////////////
+public func ArchetypeToArchetypeCast<T1, T2>(t1 : T1, t2 : T2) -> T2 {
+ if let x = t1 as? T2 {
+ return x
+ }
+ _preconditionFailure("??? Profit?")
+}
+
+// x -> y where x and y are unrelated.
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch011ArchetypeToE4Cast2t12t2q_x_q_tr0_lFAA1CC_AA1ECTg5 : $@convention(thin) (@in_guaranteed C, @in_guaranteed E) -> @owned E {
+// CHECK: bb0
+// CHECK-NOT: bb1
+// CHECK: %2 = integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail %2 : $Builtin.Int1
+// CHECK: unreachable
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch28ArchetypeToConcreteCastUInt81tAA03NotI0Vx_tlFAE_Tg5 : $@convention(thin) (NotUInt8) -> NotUInt8 {
+// CHECK: bb0
+// CHECK: return %0 : $NotUInt8
+
+// CHECK-LABEL: sil shared [thunk] [always_inline] @$S30specialize_checked_cast_branch24ArchetypeToConcreteCastC1tAA1CCx_tlFAE_Tg5 : $@convention(thin) (@in_guaranteed C) -> @owned C {
+// CHECK: bb0
+// CHECK: [[REF:%.*]] = function_ref @$S30specialize_checked_cast_branch24ArchetypeToConcreteCastC1tAA1CCx_tlFAE_Tg5Tf4n_g : $@convention(thin) (@in_guaranteed C) -> C
+// CHECK: [[RET:%.*]] = apply [[REF]](%0) : $@convention(thin) (@in_guaranteed C) -> C
+// CHECK: strong_retain [[RET]]
+// CHECK: return [[RET]] : $C
+
+// CHECK-LABEL: sil shared [thunk] [always_inline] @$S30specialize_checked_cast_branch24ArchetypeToConcreteCastC1tAA1CCx_tlFAA1DC_Tg5 : $@convention(thin) (@in_guaranteed D) -> @owned C {
+// CHECK: bb0
+// CHECK: [[REF:%.*]] = function_ref @$S30specialize_checked_cast_branch24ArchetypeToConcreteCastC1tAA1CCx_tlFAA1DC_Tg5Tf4n_g : $@convention(thin) (@in_guaranteed D) -> C
+// CHECK: [[RET:%.*]] = apply [[REF]](%0) : $@convention(thin) (@in_guaranteed D) -> C
+// CHECK: strong_retain [[RET]]
+// CHECK: return [[RET]] : $C
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch24ArchetypeToConcreteCastE1tAA1ECx_tlFAA1CC_Tg5 : $@convention(thin) (@in_guaranteed C) -> @owned E {
+// CHECK: bb0
+// CHECK: [[TRUE:%.*]] = integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail [[TRUE]]
+// CHECK: unreachable
+
+// x -> x where x is not a class.
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch011ArchetypeToE4Cast2t12t2q_x_q_tr0_lFAA8NotUInt8V_AFTg5Tf4nd_n : $@convention(thin) (NotUInt8) -> NotUInt8 {
+// CHECK: bb0
+// CHECK-NOT: bb1
+// CHECK: return %0 : $NotUInt8
+
+// x -> y where x,y are not classes and x is a different type from y.
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch011ArchetypeToE4Cast2t12t2q_x_q_tr0_lFAA8NotUInt8V_AA0J6UInt64VTg5Tf4dd_n : $@convention(thin) () -> NotUInt64 {
+// CHECK: bb0
+// CHECK-NOT: bb1
+// CHECK: %0 = integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail %0 : $Builtin.Int1
+// CHECK: unreachable
+
+// x -> y where x is not a class but y is.
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch011ArchetypeToE4Cast2t12t2q_x_q_tr0_lFAA8NotUInt8V_AA1CCTg5Tf4dn_n : $@convention(thin) (@in_guaranteed C) -> @owned C {
+// CHECK: bb0
+// CHECK-NOT: bb1
+// CHECK: %1 = integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail %1 : $Builtin.Int1
+// CHECK: unreachable
+
+// y -> x where x is a class but y is not.
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch011ArchetypeToE4Cast2t12t2q_x_q_tr0_lFAA1CC_AA8NotUInt8VTg5Tf4nd_n : $@convention(thin) (@in_guaranteed C) -> NotUInt8 {
+// CHECK: bb0
+// CHECK-NOT: bb1
+// CHECK: %1 = integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail %1 : $Builtin.Int1
+// CHECK: unreachable
+
+// y -> x where x is a super class of y.
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch011ArchetypeToE4Cast2t12t2q_x_q_tr0_lFAA1DC_AA1CCTg5Tf4nn_g : $@convention(thin) (@in_guaranteed D, @in_guaranteed C) -> C {
+// CHECK: [[T0:%.*]] = load %0 : $*D
+// CHECK: [[T1:%.*]] = upcast [[T0]] : $D to $C
+// CHECK: return [[T1]] : $C
+
+
+_ = ArchetypeToArchetypeCast(t1: c, t2: d)
+_ = ArchetypeToArchetypeCast(t1: c, t2: c)
+_ = ArchetypeToArchetypeCast(t1: b, t2: b)
+_ = ArchetypeToArchetypeCast(t1: b, t2: f)
+_ = ArchetypeToArchetypeCast(t1: b, t2: c)
+_ = ArchetypeToArchetypeCast(t1: c, t2: b)
+_ = ArchetypeToArchetypeCast(t1: d, t2: c)
+_ = ArchetypeToArchetypeCast(t1: c, t2: e)
+
+///////////////////////////
+// Archetype To Concrete //
+///////////////////////////
+
+func ArchetypeToConcreteCastUInt8<T>(t : T) -> NotUInt8 {
+ if let x = t as? NotUInt8 {
+ return x
+ }
+ _preconditionFailure("??? Profit?")
+}
+
+func ArchetypeToConcreteCastC<T>(t : T) -> C {
+ if let x = t as? C {
+ return x
+ }
+ _preconditionFailure("??? Profit?")
+}
+
+func ArchetypeToConcreteCastD<T>(t : T) -> D {
+ if let x = t as? D {
+ return x
+ }
+ _preconditionFailure("??? Profit?")
+}
+
+func ArchetypeToConcreteCastE<T>(t : T) -> E {
+ if let x = t as? E {
+ return x
+ }
+ _preconditionFailure("??? Profit?")
+}
+
+_ = ArchetypeToConcreteCastUInt8(t: b)
+
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch28ArchetypeToConcreteCastUInt81tAA03NotI0Vx_tlFAA0J6UInt64V_Tg5Tf4d_n : $@convention(thin) () -> NotUInt8 {
+// CHECK: bb0
+// CHECK-NOT: checked_cast_br
+// CHECK: [[TRUE:%.*]] = integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail [[TRUE]]
+// CHECK: unreachable
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch24ArchetypeToConcreteCastC1tAA1CCx_tlFAA8NotUInt8V_Tg5Tf4d_n : $@convention(thin) () -> @owned C {
+// CHECK: bb0
+// CHECK-NOT: checked_cast_br
+// CHECK: [[TRUE:%.*]] = integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail [[TRUE]]
+// CHECK: unreachable
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch24ArchetypeToConcreteCastC1tAA1CCx_tlFAA1DC_Tg5Tf4n_g : $@convention(thin) (@in_guaranteed D) -> C {
+// CHECK: bb0
+// CHECK: [[LOAD:%.*]] = load %0 : $*D
+// CHECK: [[CAST:%.*]] = upcast [[LOAD]] : $D to $C
+// CHECK: return [[CAST]]
+
+// x -> y where x is a super class of y.
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch24ArchetypeToConcreteCastD1tAA1DCx_tlFAA1CC_Tg5Tf4n_g : $@convention(thin) (@in_guaranteed C) -> D {
+// CHECK: [[LOAD:%.*]] = load %0 : $*C
+// CHECK: checked_cast_br [[LOAD]] : $C to $D,
+// CHECK: bb1([[T0:%.*]] : $D):
+// CHECK: return [[T0]] : $D
+// CHECK: bb2:
+// CHECK: integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail
+// CHECK: unreachable
+
+_ = ArchetypeToConcreteCastUInt8(t: c)
+_ = ArchetypeToConcreteCastUInt8(t: f)
+_ = ArchetypeToConcreteCastC(t: c)
+_ = ArchetypeToConcreteCastC(t: b)
+_ = ArchetypeToConcreteCastC(t: d)
+_ = ArchetypeToConcreteCastC(t: e)
+_ = ArchetypeToConcreteCastD(t: c)
+_ = ArchetypeToConcreteCastE(t: c)
+
+///////////////////////////
+// Concrete To Archetype //
+///////////////////////////
+
+func ConcreteToArchetypeCastUInt8<T>(t: NotUInt8, t2: T) -> T {
+ if let x = t as? T {
+ return x
+ }
+ _preconditionFailure("??? Profit?")
+}
+func ConcreteToArchetypeCastC<T>(t: C, t2: T) -> T {
+ if let x = t as? T {
+ return x
+ }
+ _preconditionFailure("??? Profit?")
+}
+func ConcreteToArchetypeCastD<T>(t: D, t2: T) -> T {
+ if let x = t as? T {
+ return x
+ }
+ _preconditionFailure("??? Profit?")
+}
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch28ConcreteToArchetypeCastUInt81t2t2xAA03NotI0V_xtlFAF_Tg5Tf4nd_n : $@convention(thin) (NotUInt8) -> NotUInt8
+// CHECK: bb0
+// CHECK: return %0
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch28ConcreteToArchetypeCastUInt81t2t2xAA03NotI0V_xtlFAA1CC_Tg5Tf4dn_n : $@convention(thin) (@in_guaranteed C) -> @owned C {
+// CHECK: bb0
+// CHECK: [[TRUE:%.*]] = integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail [[TRUE]]
+// CHECK: unreachable
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch28ConcreteToArchetypeCastUInt81t2t2xAA03NotI0V_xtlFAA0K6UInt64V_Tg5Tf4dd_n : $@convention(thin) () -> NotUInt64
+// CHECK: bb0
+// CHECK: [[TRUE:%.*]] = integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail [[TRUE]]
+// CHECK: unreachable
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch24ConcreteToArchetypeCastC1t2t2xAA1CC_xtlFAF_Tg5Tf4nn_g : $@convention(thin) (@guaranteed C, @in_guaranteed C) -> C {
+// CHECK: bb0
+// CHECK: return %0
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch24ConcreteToArchetypeCastC1t2t2xAA1CC_xtlFAA8NotUInt8V_Tg5Tf4dd_n : $@convention(thin) () -> NotUInt8
+// CHECK: bb0
+// CHECK: [[TRUE:%.*]] = integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail [[TRUE]]
+// CHECK: unreachable
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch24ConcreteToArchetypeCastC1t2t2xAA1CC_xtlFAA1DC_Tg5Tf4nn_g : $@convention(thin) (@guaranteed C, @in_guaranteed D) -> D {
+// CHECK: bb0
+// CHECK: checked_cast_br %0 : $C to $D
+// CHECK: bb1
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch24ConcreteToArchetypeCastC1t2t2xAA1CC_xtlFAA1EC_Tg5Tf4dn_n : $@convention(thin) (@in_guaranteed E) -> @owned E {
+// CHECK: bb0
+// CHECK: [[TRUE:%.*]] = integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail [[TRUE]]
+// CHECK: unreachable
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch24ConcreteToArchetypeCastD1t2t2xAA1DC_xtlFAA1CC_Tg5Tf4nn_g : $@convention(thin) (@guaranteed D, @in_guaranteed C) -> C {
+// CHECK: bb0
+// CHECK: [[T0:%.*]] = upcast %0 : $D to $C
+// CHECK: return [[T0]]
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch21SuperToArchetypeCastC1c1txAA1CC_xtlFAF_Tg5Tf4nn_g : $@convention(thin) (@guaranteed C, @in_guaranteed C) -> C {
+// CHECK: bb0
+// CHECK-NOT: bb1
+// CHECK: return %0 : $C
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch21SuperToArchetypeCastC1c1txAA1CC_xtlFAA1DC_Tg5Tf4nn_g : $@convention(thin) (@guaranteed C, @in_guaranteed D) -> D {
+// CHECK: bb0
+// CHECK: checked_cast_br %0 : $C to $D, bb1, bb2
+// CHECK: bb1(
+// CHECK: return
+// CHECK: bb2
+// CHECK: integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail
+// CHECK: unreachable
+
+_ = ConcreteToArchetypeCastUInt8(t: b, t2: b)
+_ = ConcreteToArchetypeCastUInt8(t: b, t2: c)
+_ = ConcreteToArchetypeCastUInt8(t: b, t2: f)
+_ = ConcreteToArchetypeCastC(t: c, t2: c)
+_ = ConcreteToArchetypeCastC(t: c, t2: b)
+_ = ConcreteToArchetypeCastC(t: c, t2: d)
+_ = ConcreteToArchetypeCastC(t: c, t2: e)
+_ = ConcreteToArchetypeCastD(t: d, t2: c)
+
+////////////////////////
+// Super To Archetype //
+////////////////////////
+
+func SuperToArchetypeCastC<T>(c : C, t : T) -> T {
+ if let x = c as? T {
+ return x
+ }
+ _preconditionFailure("??? Profit?")
+}
+
+func SuperToArchetypeCastD<T>(d : D, t : T) -> T {
+ if let x = d as? T {
+ return x
+ }
+ _preconditionFailure("??? Profit?")
+}
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch21SuperToArchetypeCastC1c1txAA1CC_xtlFAA8NotUInt8V_Tg5Tf4dd_n : $@convention(thin) () -> NotUInt8 {
+// CHECK: bb0
+// CHECK: [[TRUE:%.*]] = integer_literal $Builtin.Int1, -1
+// CHECK: cond_fail [[TRUE]]
+// CHECK: unreachable
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch21SuperToArchetypeCastD1d1txAA1DC_xtlFAA1CC_Tg5Tf4nn_g : $@convention(thin) (@guaranteed D, @in_guaranteed C) -> C {
+// CHECK: bb0
+// CHECK: [[T0:%.*]] = upcast %0 : $D to $C
+// CHECK: return [[T0]]
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch21SuperToArchetypeCastD1d1txAA1DC_xtlFAF_Tg5Tf4nn_g : $@convention(thin) (@guaranteed D, @in_guaranteed D) -> D {
+// CHECK: bb0
+// CHECK: return %0 : $D
+
+_ = SuperToArchetypeCastC(c: c, t: c)
+_ = SuperToArchetypeCastC(c: c, t: d)
+_ = SuperToArchetypeCastC(c: c, t: b)
+_ = SuperToArchetypeCastD(d: d, t: c)
+_ = SuperToArchetypeCastD(d: d, t: d)
+
+//////////////////////////////
+// Existential To Archetype //
+//////////////////////////////
+
+func ExistentialToArchetypeCast<T>(o : AnyObject, t : T) -> T {
+ if let x = o as? T {
+ return x
+ }
+ _preconditionFailure("??? Profit?")
+}
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch26ExistentialToArchetypeCast1o1txyXl_xtlFAA1CC_Tg5Tf4nn_g : $@convention(thin) (@guaranteed AnyObject, @in_guaranteed C) -> C {
+// CHECK: bb0
+// CHECK: checked_cast_br %0 : $AnyObject to $C
+// CHECK: bb1
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch26ExistentialToArchetypeCast1o1txyXl_xtlFAA8NotUInt8V_Tg5Tf4nd_n : $@convention(thin) (@guaranteed AnyObject) -> NotUInt8 {
+// CHECK: bb0
+// CHECK: checked_cast_addr_br take_always AnyObject in {{%.*}} : $*AnyObject to NotUInt8 in {{%.*}} : $*NotUInt8,
+// CHECK: bb1
+
+// CHECK-LABEL: sil shared @$S30specialize_checked_cast_branch26ExistentialToArchetypeCast1o1txyXl_xtlFyXl_Tg5Tf4nn_g : $@convention(thin) (@guaranteed AnyObject, @in_guaranteed AnyObject) -> AnyObject
+// CHECK: bb0
+// CHECK-NOT: checked_cast_br %
+// CHECK: return %0 : $AnyObject
+// CHECK-NOT: checked_cast_br %
+
+_ = ExistentialToArchetypeCast(o: o, t: c)
+_ = ExistentialToArchetypeCast(o: o, t: b)
+_ = ExistentialToArchetypeCast(o: o, t: o)
diff --git a/test/SILOptimizer/plus_zero_specialize_dynamic_self.swift b/test/SILOptimizer/plus_zero_specialize_dynamic_self.swift
new file mode 100644
index 0000000..4348be6
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_specialize_dynamic_self.swift
@@ -0,0 +1,30 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-inline-generics -emit-sil -O -primary-file %s | %FileCheck %s
+
+protocol P {}
+
+extension P {
+ @_optimize(none) func method1() {}
+
+ @inline(__always) func method2() { method1() }
+}
+
+class C<T> : P {
+ // CHECK-LABEL: sil shared [always_inline] @$S23specialize_dynamic_self1CC11returnsSelfACyxGXDyFSi_Tg5 : $@convention(method) (@guaranteed C<Int>) -> @owned C<Int>
+ // CHECK: [[RESULT:%.*]] = alloc_stack $C<Int>
+ // CHECK: [[FN:%.*]] = function_ref @$S23specialize_dynamic_self1PPAAE7method1yyF : $@convention(method) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> ()
+ // CHECK: apply [[FN]]<@dynamic_self C<Int>>([[RESULT]]) : $@convention(method) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> ()
+ // CHECK: return %0 : $C<Int>
+ @inline(__always)
+ final func returnsSelf() -> Self {
+ method2()
+ return self
+ }
+}
+
+// CHECK-LABEL: sil hidden @$S23specialize_dynamic_self8usesCInt1cyAA1CCySiG_tF : $@convention(thin) (@guaranteed C<Int>) -> () {
+// CHECK: function_ref @$S23specialize_dynamic_self1CC11returnsSelfACyxGXDyFSi_Tg5 : $@convention(method) (@guaranteed C<Int>) -> @owned C<Int>
+// CHECK: return
+func usesCInt(c: C<Int>) {
+ _ = c.returnsSelf()
+}
diff --git a/test/SILOptimizer/plus_zero_specialize_inherited_multifile.swift b/test/SILOptimizer/plus_zero_specialize_inherited_multifile.swift
new file mode 100644
index 0000000..387094d
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_specialize_inherited_multifile.swift
@@ -0,0 +1,19 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -primary-file %s %S/Inputs/specialize_inherited_multifile.swift -O -emit-sil -sil-verify-all | %FileCheck %s
+
+@_optimize(none) func takesBase<T : Base>(t: T) {}
+
+@inline(never) func takesHasAssocType<T : HasAssocType>(t: T) {
+ takesBase(t: t.value)
+}
+
+// Make sure the ConcreteDerived : Base conformance is available here.
+
+// CHECK-LABEL: sil shared [noinline] @$S30specialize_inherited_multifile17takesHasAssocType1tyx_tAA0efG0RzlFAA08ConcreteefG0C_Tg5 : $@convention(thin) (@in_guaranteed ConcreteHasAssocType) -> ()
+// CHECK: [[FN:%.*]] = function_ref @$S30specialize_inherited_multifile9takesBase1tyx_tAA0E0RzlF
+// CHECK: apply [[FN]]<ConcreteDerived>({{%.*}})
+// CHECK: return
+
+public func takesConcreteHasAssocType(c: ConcreteHasAssocType) {
+ takesHasAssocType(t: c)
+}
diff --git a/test/SILOptimizer/plus_zero_specialize_partial_apply.swift b/test/SILOptimizer/plus_zero_specialize_partial_apply.swift
new file mode 100644
index 0000000..9297335
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_specialize_partial_apply.swift
@@ -0,0 +1,245 @@
+// REQUIRES: plus_zero_runtime
+// First check the SIL.
+// RUN: %target-swift-frontend -O -Xllvm -sil-disable-pass=FunctionSignatureOpts -module-name=test -emit-sil -primary-file %s | %FileCheck %s
+
+// Also do an end-to-end test to check all components, including IRGen.
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -O -Xllvm -sil-disable-pass=FunctionSignatureOpts -module-name=test %s -o %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s -check-prefix=CHECK-OUTPUT
+// REQUIRES: executable_test
+
+struct MyError : Error {
+ let _code : Int
+ init(_ xx: Int) {
+ _code = xx
+ }
+}
+
+// We need a reabstraction thunk to convert from direct args/result to indirect
+// args/result, which is expected in the returned closure.
+
+// CHECK-LABEL: sil shared [noinline] @$S4test16generic_get_funcyxxcx_SbtlFSi_Tg5 : $@convention(thin) (Int, Bool) -> @owned @callee_guaranteed (@in_guaranteed Int) -> @out Int {
+// CHECK: [[F:%[0-9]+]] = function_ref @$S4test16generic_get_funcyxxcx_SbtlF0B0L_yxxlFSi_TG5 : $@convention(thin) (@in_guaranteed Int, Bool, @guaranteed <τ_0_0> { var τ_0_0 } <Int>) -> @out Int
+// CHECK: [[PA:%[0-9]+]] = partial_apply [callee_guaranteed] [[F]](%1, %{{[0-9]+}}) : $@convention(thin) (@in_guaranteed Int, Bool, @guaranteed <τ_0_0> { var τ_0_0 } <Int>) -> @out Int
+// CHECK: return [[PA]] : $@callee_guaranteed (@in_guaranteed Int) -> @out Int
+@inline(never)
+func generic_get_func<T>(_ t1: T, _ b: Bool) -> (T) -> T {
+
+ @inline(never)
+ func generic(_ t2: T) -> T {
+ return b ? t1 : t2
+ }
+
+ return generic
+}
+
+// CHECK-LABEL: sil hidden [noinline] @$S4test7testit1yS2icSbF : $@convention(thin) (Bool) -> @owned @callee_guaranteed (Int) -> Int {
+// CHECK: [[F:%[0-9]+]] = function_ref @$S4test16generic_get_funcyxxcx_SbtlFSi_Tg5 : $@convention(thin) (Int, Bool) -> @owned @callee_guaranteed (@in_guaranteed Int) -> @out Int
+// CHECK: [[CL:%[0-9]+]] = apply [[F]](%{{[0-9]+}}, %0) : $@convention(thin) (Int, Bool) -> @owned @callee_guaranteed (@in_guaranteed Int) -> @out Int
+// CHECK: [[TH:%[0-9]+]] = function_ref @$SS2iIegnr_S2iIegyd_TR : $@convention(thin) (Int, @guaranteed @callee_guaranteed (@in_guaranteed Int) -> @out Int) -> Int
+// CHECK: [[RET:%[0-9]+]] = partial_apply [callee_guaranteed] [[TH]]([[CL]])
+// CHECK: return [[RET]] : $@callee_guaranteed (Int) -> Int
+@inline(never)
+func testit1(_ b: Bool) -> (Int) -> Int {
+ return generic_get_func(27, b)
+}
+
+
+@inline(never)
+func generic2<T>(_ t1: T, t2: T, b: Bool) -> T {
+ return b ? t1 : t2
+}
+
+// No reabstraction thunk is needed because the returned closure expects direct
+// args/result anyway.
+
+// CHECK-LABEL: sil hidden [noinline] @$S4test17concrete_get_funcS2i_SiSbtcyF : $@convention(thin) () -> @owned @callee_guaranteed (Int, Int, Bool) -> Int {
+// CHECK: [[F:%[0-9]+]] = function_ref @$S4test8generic2_2t21bxx_xSbtlFSi_Tg5 : $@convention(thin) (Int, Int, Bool) -> Int
+// CHECK: [[RET:%[0-9]+]] = thin_to_thick_function [[F]] : $@convention(thin) (Int, Int, Bool) -> Int to $@callee_guaranteed (Int, Int, Bool) -> Int
+// CHECK: return [[RET]] : $@callee_guaranteed (Int, Int, Bool) -> Int
+@inline(never)
+func concrete_get_func() -> (Int, Int, Bool) -> Int {
+ return generic2
+}
+
+@inline(never)
+func testit2() -> (Int, Int, Bool) -> Int {
+ return concrete_get_func()
+}
+
+
+@inline(never)
+func generic3<T>(_ t1: T, _ t2: T, _ b: Bool) -> T {
+ return b ? t1 : t2
+}
+
+// No reabstraction thunk is needed because we directly apply the returned closure.
+
+// CHECK-LABEL: sil hidden [noinline] @$S4test7testit3ySiSbF : $@convention(thin) (Bool) -> Int {
+// CHECK: [[F:%[0-9]+]] = function_ref @$S4test8generic3yxx_xSbtlFSi_Tg5 : $@convention(thin) (Int, Int, Bool) -> Int
+// CHECK: [[RET:%[0-9]+]] = apply [[F]]({{.*}}) : $@convention(thin) (Int, Int, Bool) -> Int
+// CHECK: return [[RET]] : $Int
+@inline(never)
+func testit3(_ b: Bool) -> Int {
+ return generic3(270, 28, b)
+}
+
+// The same three test cases again, but with throwing functions.
+
+// We need a reabstraction thunk to convert from direct args/result to indirect
+// args/result, which is expected in the returned closure.
+
+// CHECK-LABEL: sil shared [noinline] @$S4test25generic_get_func_throwingyxxKcSblFSi_Tg5 : $@convention(thin) (Bool) -> @owned @callee_guaranteed (@in_guaranteed Int) -> (@out Int, @error Error) {
+// CHECK: [[F:%[0-9]+]] = function_ref @$S4test25generic_get_func_throwingyxxKcSblF0B0L_yxxKlFSi_TG5 : $@convention(thin) (@in_guaranteed Int, Bool) -> (@out Int, @error Error)
+// CHECK: [[PA:%[0-9]+]] = partial_apply [callee_guaranteed] [[F]](%0) : $@convention(thin) (@in_guaranteed Int, Bool) -> (@out Int, @error Error)
+// CHECK: return [[PA]] : $@callee_guaranteed (@in_guaranteed Int) -> (@out Int, @error Error)
+@inline(never)
+func generic_get_func_throwing<T>(_ b: Bool) -> (T) throws -> T {
+
+ @inline(never)
+ func generic(_ t2: T) throws -> T {
+ if b {
+ throw MyError(123)
+ }
+ return t2
+ }
+
+ return generic
+}
+
+// CHECK-LABEL: sil hidden [noinline] @$S4test16testit1_throwingyS2iKcSbF : $@convention(thin) (Bool) -> @owned @callee_guaranteed (Int) -> (Int, @error Error) {
+// CHECK: [[F:%[0-9]+]] = function_ref @$S4test25generic_get_func_throwingyxxKcSblFSi_Tg5 : $@convention(thin) (Bool) -> @owned @callee_guaranteed (@in_guaranteed Int) -> (@out Int, @error Error)
+// CHECK: [[CL:%[0-9]+]] = apply [[F]](%0) : $@convention(thin) (Bool) -> @owned @callee_guaranteed (@in_guaranteed Int) -> (@out Int, @error Error)
+// CHECK: [[TH:%[0-9]+]] = function_ref @$SS2is5Error_pIegnrzo_S2isAA_pIegydzo_TR : $@convention(thin) (Int, @guaranteed @callee_guaranteed (@in_guaranteed Int) -> (@out Int, @error Error)) -> (Int, @error Error)
+// CHECK: [[RET:%[0-9]+]] = partial_apply [callee_guaranteed] [[TH]]([[CL]])
+// CHECK: return [[RET]] : $@callee_guaranteed (Int) -> (Int, @error Error)
+@inline(never)
+func testit1_throwing(_ b: Bool) -> (Int) throws -> Int {
+ return generic_get_func_throwing(b)
+}
+
+
+@inline(never)
+func generic2_throwing<T>(_ t1: T, b: Bool) throws -> T {
+ if b {
+ throw MyError(124)
+ }
+ return t1
+}
+
+// No reabstraction thunk is needed because the returned closure expects direct
+// args/result anyway.
+
+// CHECK-LABEL: sil hidden [noinline] @$S4test26concrete_get_func_throwingS2i_SbtKcyF : $@convention(thin) () -> @owned @callee_guaranteed (Int, Bool) -> (Int, @error Error) {
+// CHECK: [[F:%[0-9]+]] = function_ref @$S4test17generic2_throwing_1bxx_SbtKlFSi_Tg5 : $@convention(thin) (Int, Bool) -> (Int, @error Error)
+// CHECK: [[RET:%[0-9]+]] = thin_to_thick_function [[F]] : $@convention(thin) (Int, Bool) -> (Int, @error Error) to $@callee_guaranteed (Int, Bool) -> (Int, @error Error)
+// CHECK: return [[RET]] : $@callee_guaranteed (Int, Bool) -> (Int, @error Error)
+@inline(never)
+func concrete_get_func_throwing() -> (Int, Bool) throws -> Int {
+ return generic2_throwing
+}
+
+@inline(never)
+func testit2_throwing() -> (Int, Bool) throws -> Int {
+ return concrete_get_func_throwing()
+}
+
+
+
+@inline(never)
+func generic3_throwing<T>(_ t1: T, _ b: Bool) throws -> T {
+ if b {
+ throw MyError(125)
+ }
+ return t1
+}
+
+// No reabstraction thunk is needed because we directly apply the returned closure.
+
+// CHECK-LABEL: sil hidden [noinline] @$S4test16testit3_throwingySiSbF : $@convention(thin) (Bool) -> Int {
+// CHECK: [[F:%[0-9]+]] = function_ref @$S4test17generic3_throwingyxx_SbtKlFSi_Tg5 : $@convention(thin) (Int, Bool) -> (Int, @error Error)
+// CHECK: try_apply [[F]](%{{[0-9]+}}, %0) : $@convention(thin) (Int, Bool) -> (Int, @error Error), normal bb{{[0-9]+}}, error bb{{[0-9]+}}
+// CHECK: }
+@inline(never)
+func testit3_throwing(_ b: Bool) -> Int {
+ do {
+ return try generic3_throwing(271, b)
+ } catch {
+ return error._code
+ }
+}
+
+// CHECK-LABEL: sil shared [transparent] [thunk] @$S4test16generic_get_funcyxxcx_SbtlF0B0L_yxxlFSi_TG5 : $@convention(thin) (@in_guaranteed Int, Bool, @guaranteed <τ_0_0> { var τ_0_0 } <Int>) -> @out Int {
+// CHECK: bb0(%0 : $*Int, %1 : $*Int, %2 : $Bool, %3 : $<τ_0_0> { var τ_0_0 } <Int>):
+// CHECK: [[LD:%[0-9]+]] = load %1 : $*Int
+// CHECK: [[F:%[0-9]+]] = function_ref @$S4test16generic_get_funcyxxcx_SbtlF0B0L_yxxlFSi_Tg5 : $@convention(thin) (Int, Bool, @guaranteed <τ_0_0> { var τ_0_0 } <Int>) -> Int
+// CHECK: [[RET:%[0-9]+]] = apply [[F]]([[LD]], %2, %3)
+// CHECK: store [[RET]] to %0 : $*Int
+// CHECK: return %{{[0-9]*}} : $()
+
+// CHECK-LABEL: sil shared [transparent] [thunk] @$S4test25generic_get_func_throwingyxxKcSblF0B0L_yxxKlFSi_TG5 : $@convention(thin) (@in_guaranteed Int, Bool) -> (@out Int, @error Error) {
+// CHECK: bb0(%0 : $*Int, %1 : $*Int, %2 : $Bool):
+// CHECK: [[LD:%[0-9]+]] = load %1 : $*Int
+// CHECK: [[F:%[0-9]+]] = function_ref @$S4test25generic_get_func_throwingyxxKcSblF0B0L_yxxKlFSi_Tg5 : $@convention(thin) (Int, Bool) -> (Int, @error Error)
+// CHECK: try_apply [[F]]([[LD]], %2) : $@convention(thin) (Int, Bool) -> (Int, @error Error), normal bb1, error bb2
+// CHECK: bb1([[NORMAL:%[0-9]+]] : $Int):
+// CHECK: store [[NORMAL]] to %0 : $*Int
+// CHECK: return %{{[0-9]*}} : $()
+// CHECK: bb2([[ERROR:%[0-9]+]] : $Error):
+// CHECK: throw [[ERROR]] : $Error
+
+
+// The main program.
+// Check if the generated executable produces the correct output.
+
+// CHECK-OUTPUT: 18
+print(testit1(false)(18))
+// CHECK-OUTPUT: 27
+print(testit1(true)(18))
+
+// CHECK-OUTPUT: 4
+print(testit2()(3, 4, false))
+// CHECK-OUTPUT: 3
+print(testit2()(3, 4, true))
+
+// CHECK-OUTPUT: 28
+print(testit3(false))
+// CHECK-OUTPUT: 270
+print(testit3(true))
+
+var x: Int
+do {
+ x = try testit1_throwing(false)(19)
+} catch {
+ x = error._code
+}
+// CHECK-OUTPUT: 19
+print(x)
+do {
+ x = try testit1_throwing(true)(19)
+} catch {
+ x = error._code
+}
+// CHECK-OUTPUT: 123
+print(x)
+
+do {
+ x = try testit2_throwing()(20, false)
+} catch {
+ x = error._code
+}
+// CHECK-OUTPUT: 20
+print(x)
+do {
+ x = try testit2_throwing()(20, true)
+} catch {
+ x = error._code
+}
+// CHECK-OUTPUT: 124
+print(x)
+
+// CHECK-OUTPUT: 271
+print(testit3_throwing(false))
+// CHECK-OUTPUT: 125
+print(testit3_throwing(true))
+
diff --git a/test/SILOptimizer/plus_zero_specialize_same_type_constraint.swift b/test/SILOptimizer/plus_zero_specialize_same_type_constraint.swift
new file mode 100644
index 0000000..f8db643
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_specialize_same_type_constraint.swift
@@ -0,0 +1,54 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -O -emit-sil -primary-file %s | %FileCheck %s
+
+protocol FirstChild {}
+
+protocol FirstParent {
+ associatedtype Child : FirstChild
+
+ var firstChild: Child { get }
+}
+
+protocol SecondChild {}
+
+protocol SecondParent {
+ associatedtype Child : SecondChild
+
+ var secondChild: Child { get }
+}
+
+@_optimize(none)
+func takesFirstChild<T : FirstChild>(t: T) {}
+
+@_optimize(none)
+func takesSecondChild<T : SecondChild>(t: T) {}
+
+@inline(never)
+func doStuff<First : FirstParent, Second : SecondParent>(f: First, s: Second)
+ where First.Child == Second.Child {
+ takesFirstChild(t: f.firstChild)
+ takesSecondChild(t: f.firstChild)
+
+ takesFirstChild(t: s.secondChild)
+ takesSecondChild(t: s.secondChild)
+}
+
+struct ConcreteChild : FirstChild, SecondChild {}
+
+struct ConcreteFirstParent<T> : FirstParent {
+ var firstChild: ConcreteChild { return ConcreteChild() }
+}
+
+struct ConcreteSecondParent<T> : SecondParent {
+ var secondChild: ConcreteChild { return ConcreteChild() }
+}
+
+doStuff(f: ConcreteFirstParent<ConcreteChild>(),
+ s: ConcreteSecondParent<ConcreteChild>())
+
+// CHECK-LABEL: sil shared [noinline] @$S31specialize_same_type_constraint7doStuff1f1syx_q_tAA11FirstParentRzAA06SecondH0R_5ChildQy_AGRtzr0_lFAA08ConcretegH0VyAA0kJ0VG_AA0kiH0VyAMGTg5Tf4dd_n : $@convention(thin) () -> () {
+// CHECK: [[FIRST:%.*]] = function_ref @$S31specialize_same_type_constraint15takesFirstChild1tyx_tAA0fG0RzlF
+// CHECK: apply [[FIRST]]<ConcreteChild>({{.*}}) : $@convention(thin) <τ_0_0 where τ_0_0 : FirstChild> (@in_guaranteed τ_0_0) -> ()
+// CHECK: [[SECOND:%.*]] = function_ref @$S31specialize_same_type_constraint16takesSecondChild1tyx_tAA0fG0RzlF
+// CHECK: apply [[SECOND]]<ConcreteChild>({{.*}}) : $@convention(thin) <τ_0_0 where τ_0_0 : SecondChild> (@in_guaranteed τ_0_0) -> ()
+// CHECK: return
diff --git a/test/SILOptimizer/plus_zero_specialize_self.swift b/test/SILOptimizer/plus_zero_specialize_self.swift
new file mode 100644
index 0000000..b181e3e
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_specialize_self.swift
@@ -0,0 +1,20 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -O -sil-inline-threshold 0 -emit-sil -primary-file %s | %FileCheck %s
+
+// CHECK-NOT: generic specialization <Swift.AnyObject, Self> of specialize_self.cast <A, B>(A) -> Swift.Optional<B>
+
+// CHECK-LABEL: specialize_self.cast<A, B>(A) -> Swift.Optional<B>
+// CHECK-NEXT: sil hidden @$S15specialize_self4cast{{[_0-9a-zA-Z]*}}F : $@convention(thin) <T, R> (@in_guaranteed T) -> @out Optional<R>
+func cast<T,R>(_ x: T) -> R? {
+ return x as? R
+}
+
+// CHECK-LABEL: static specialize_self.Base.returnIfSelf(Swift.AnyObject) -> Swift.Optional<Self>
+// CHECK-NEXT: sil hidden @$S15specialize_self4BaseC12returnIfSelf{{[_0-9a-zA-Z]*}}FZ : $@convention(method) (@guaranteed AnyObject, @thick Base.Type) -> @owned Optional<Base>
+// CHECK: [[CAST:%[0-9]+]] = function_ref @$S15specialize_self4cast{{[_0-9a-zA-Z]*}}F
+// CHECK: apply [[CAST]]<AnyObject, @dynamic_self Base>
+class Base {
+ class func returnIfSelf(_ x: AnyObject) -> Self? {
+ return cast(x)
+ }
+}
diff --git a/test/SILOptimizer/plus_zero_specialize_self_conforming.swift b/test/SILOptimizer/plus_zero_specialize_self_conforming.swift
new file mode 100644
index 0000000..1c01bc2
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_specialize_self_conforming.swift
@@ -0,0 +1,25 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-sil -O -primary-file %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+
+@objc protocol P {}
+
+@_optimize(none)
+func takesP<T : P>(_: T) {}
+
+@inline(__always)
+func callsTakesP<T : P>(_ t: T) {
+ takesP(t)
+}
+
+// CHECK-LABEL: sil hidden @$S26specialize_self_conforming16callsTakesPWithPyyAA1P_pF : $@convention(thin) (@guaranteed P) -> () {
+// CHECK: [[FN:%.*]] = function_ref @$S26specialize_self_conforming6takesPyyxAA1PRzlF : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@guaranteed τ_0_0) -> ()
+// CHECK: apply [[FN]]<P>(%0) : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@guaranteed τ_0_0) -> ()
+// CHECK: return
+
+func callsTakesPWithP(_ p: P) {
+ callsTakesP(p)
+}
diff --git a/test/SILOptimizer/plus_zero_specialize_unconditional_checked_cast.swift b/test/SILOptimizer/plus_zero_specialize_unconditional_checked_cast.swift
new file mode 100644
index 0000000..6f6977d
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_specialize_unconditional_checked_cast.swift
@@ -0,0 +1,381 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -Xllvm -sil-disable-pass=FunctionSignatureOpts -emit-sil -o - -O %s | %FileCheck %s
+
+//////////////////
+// Declarations //
+//////////////////
+
+public class C {}
+public class D : C {}
+public class E {}
+
+public struct NotUInt8 { var value: UInt8 }
+public struct NotUInt64 { var value: UInt64 }
+
+var b = NotUInt8(value: 0)
+var c = C()
+var d = D()
+var e = E()
+var f = NotUInt64(value: 0)
+var o : AnyObject = c
+
+////////////////////////////
+// Archetype To Archetype //
+////////////////////////////
+
+@inline(never)
+public func ArchetypeToArchetype<T1, T2>(t t: T1, t2: T2) -> T2 {
+ return t as! T2
+}
+
+ArchetypeToArchetype(t: b, t2: b)
+ArchetypeToArchetype(t: c, t2: c)
+ArchetypeToArchetype(t: b, t2: c)
+ArchetypeToArchetype(t: c, t2: b)
+ArchetypeToArchetype(t: c, t2: d)
+ArchetypeToArchetype(t: d, t2: c)
+ArchetypeToArchetype(t: c, t2: e)
+ArchetypeToArchetype(t: b, t2: f)
+
+// x -> x where x is not a class.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast011ArchetypeToE0{{[_0-9a-zA-Z]*}}FAA8NotUInt8V{{.*}}Tg5 : $@convention(thin) (NotUInt8, NotUInt8) -> NotUInt8 {
+// CHECK-NOT: unconditional_checked_cast archetype_to_archetype
+
+// x -> x where x is a class.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast011ArchetypeToE0{{[_0-9a-zA-Z]*}}FAA1CC{{.*}}Tg5 : $@convention(thin) (@in_guaranteed C, @in_guaranteed C) -> @owned C {
+// CHECK-NOT: unconditional_checked_cast archetype_to_archetype
+
+// x -> y where x is not a class but y is.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast011ArchetypeToE0{{[_0-9a-zA-Z]*}}FAA8NotUInt8V_AA1CCTg5 : $@convention(thin) (NotUInt8, @in_guaranteed C) -> @owned C {
+// CHECK-NOT: unconditional_checked_cast_addr
+// CHECK-NOT: unconditional_checked_cast_addr
+// CHECK: builtin "int_trap"
+// CHECK-NOT: unconditional_checked_cast_addr
+
+// y -> x where x is not a class but y is.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast011ArchetypeToE0{{[_0-9a-zA-Z]*}}FAA1CC_AA8NotUInt8VTg5 : $@convention(thin) (@in_guaranteed C, NotUInt8) -> NotUInt8 {
+// CHECK-NOT: unconditional_checked_cast archetype_to_archetype
+// CHECK: builtin "int_trap"
+// CHECK-NOT: unconditional_checked_cast archetype_to_archetype
+
+// x -> y where x is a super class of y.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast011ArchetypeToE0{{[_0-9a-zA-Z]*}}FAA1CC_AA1DCTg5 : $@convention(thin) (@in_guaranteed C, @in_guaranteed D) -> @owned D {
+// CHECK: [[STACK:%[0-9]+]] = alloc_stack $C
+// TODO: This should be optimized to an unconditional_checked_cast without the need of alloc_stack: rdar://problem/24775038
+// CHECK: unconditional_checked_cast_addr C in [[STACK]] : $*C to D in
+
+// y -> x where x is a super class of y.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast011ArchetypeToE0{{[_0-9a-zA-Z]*}}FAA1DC_AA1CCTg5 : $@convention(thin) (@in_guaranteed D, @in_guaranteed C) -> @owned C {
+// CHECK-NOT: unconditional_checked_cast archetype_to_archetype
+// CHECK: upcast {{%[0-9]+}} : $D to $C
+// CHECK-NOT: unconditional_checked_cast archetype_to_archetype
+
+// x -> y where x and y are unrelated classes.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast011ArchetypeToE0{{[_0-9a-zA-Z]*}}FAA1CC_AA1ECTg5 : $@convention(thin) (@in_guaranteed C, @in_guaranteed E) -> @owned E {
+// CHECK-NOT: unconditional_checked_cast archetype_to_archetype
+// CHECK: builtin "int_trap"
+// CHECK-NOT: unconditional_checked_cast archetype_to_archetype
+
+// x -> y where x and y are unrelated non classes.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast011ArchetypeToE0{{[_0-9a-zA-Z]*}}FAA8NotUInt8V_AA0H6UInt64VTg5 : $@convention(thin) (NotUInt8, NotUInt64) -> NotUInt64 {
+// CHECK-NOT: unconditional_checked_cast archetype_to_archetype
+// CHECK-NOT: unconditional_checked_cast archetype_to_archetype
+// CHECK: builtin "int_trap"
+// CHECK-NOT: unconditional_checked_cast archetype_to_archetype
+
+
+///////////////////////////
+// Archetype To Concrete //
+///////////////////////////
+
+@inline(never)
+public func ArchetypeToConcreteConvertUInt8<T>(t t: T) -> NotUInt8 {
+ return t as! NotUInt8
+}
+ArchetypeToConcreteConvertUInt8(t: b)
+ArchetypeToConcreteConvertUInt8(t: c)
+ArchetypeToConcreteConvertUInt8(t: f)
+
+// x -> x where x is not a class.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast31ArchetypeToConcreteConvertUInt8{{[_0-9a-zA-Z]*}}3Not{{.*}}Tg5 : $@convention(thin) (NotUInt8) -> NotUInt8 {
+// CHECK: bb0
+// CHECK-NEXT: debug_value %0
+// CHECK-NEXT: return %0
+
+// x -> y where y is a class but x is not.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast31ArchetypeToConcreteConvertUInt8{{[_0-9a-zA-Z]*}}FAA1CC_Tg5
+// CHECK: bb0
+// CHECK: builtin "int_trap"
+// CHECK: unreachable
+// CHECK-NEXT: }
+
+// x -> y where x,y are not classes and x is a different type from y.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast31ArchetypeToConcreteConvertUInt8{{[_0-9a-zA-Z]*}}3Not{{.*}}Tg5
+// CHECK: bb0
+// CHECK: builtin "int_trap"
+// CHECK: unreachable
+// CHECK-NEXT: }
+
+// x -> x where x is a class.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast27ArchetypeToConcreteConvertC{{[_0-9a-zA-Z]*}}Tg5 : $@convention(thin) (@in_guaranteed C) -> @owned C {
+// CHECK: bb0
+// CHECK-NEXT: debug_value_addr %0
+// CHECK-NEXT: %2 = load %0 : $*C
+// CHECK: return %2
+
+// x -> y where x is a class but y is not.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast27ArchetypeToConcreteConvertC{{[_0-9a-zA-Z]*}}FAA8NotUInt8V_Tg5
+// CHECK: bb0
+// CHECK: builtin "int_trap"
+// CHECK: unreachable
+// CHECK-NEXT: }
+
+// x -> y where x,y are classes and x is a super class of y.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast27ArchetypeToConcreteConvertC{{[_0-9a-zA-Z]*}}FAA1DC_Tg5 : $@convention(thin) (@in_guaranteed D) -> @owned C {
+// CHECK: bb0
+// CHECK-NEXT: debug_value_addr %0
+// CHECK-NEXT: %2 = load %0 : $*D
+// CHECK: [[UC:%[0-9]+]] = upcast %2
+// CHECK: return [[UC]]
+
+// x -> y where x,y are classes, but x is unrelated to y.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast27ArchetypeToConcreteConvertC{{[_0-9a-zA-Z]*}}FAA1EC_Tg5
+// CHECK: bb0
+// CHECK: builtin "int_trap"
+// CHECK: unreachable
+// CHECK-NEXT: }
+
+@inline(never)
+public func ArchetypeToConcreteConvertC<T>(t t: T) -> C {
+ return t as! C
+}
+
+ArchetypeToConcreteConvertC(t: c)
+ArchetypeToConcreteConvertC(t: b)
+ArchetypeToConcreteConvertC(t: d)
+ArchetypeToConcreteConvertC(t: e)
+
+@inline(never)
+public func ArchetypeToConcreteConvertD<T>(t t: T) -> D {
+ return t as! D
+}
+
+ArchetypeToConcreteConvertD(t: c)
+
+// x -> y where x,y are classes and x is a sub class of y.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast27ArchetypeToConcreteConvertD{{[_0-9a-zA-Z]*}}FAA1CC_Tg5 : $@convention(thin) (@in_guaranteed C) -> @owned D {
+// CHECK: bb0(%0 : $*C):
+// CHECK-DAG: [[STACK_C:%[0-9]+]] = alloc_stack $C
+// CHECK-DAG: store {{.*}} to [[STACK_C]]
+// CHECK-DAG: [[STACK_D:%[0-9]+]] = alloc_stack $D
+// TODO: This should be optimized to an unconditional_checked_cast without the need of alloc_stack: rdar://problem/24775038
+// CHECK-DAG: unconditional_checked_cast_addr C in [[STACK_C]] : $*C to D in [[STACK_D]] : $*D
+// CHECK-DAG: [[LOAD:%[0-9]+]] = load [[STACK_D]]
+// CHECK: return [[LOAD]]
+
+@inline(never)
+public func ArchetypeToConcreteConvertE<T>(t t: T) -> E {
+ return t as! E
+}
+
+ArchetypeToConcreteConvertE(t: c)
+
+// x -> y where x,y are classes, but y is unrelated to x. The idea is
+// to make sure that the fact that y is concrete does not affect the
+// result.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast27ArchetypeToConcreteConvertE{{[_0-9a-zA-Z]*}}FAA1CC_Tg5
+// CHECK: bb0
+// CHECK: builtin "int_trap"
+// CHECK: unreachable
+// CHECK-NEXT: }
+
+
+///////////////////////////
+// Concrete to Archetype //
+///////////////////////////
+
+@inline(never)
+public func ConcreteToArchetypeConvertUInt8<T>(t t: NotUInt8, t2: T) -> T {
+ return t as! T
+}
+
+ConcreteToArchetypeConvertUInt8(t: b, t2: b)
+ConcreteToArchetypeConvertUInt8(t: b, t2: c)
+ConcreteToArchetypeConvertUInt8(t: b, t2: f)
+
+// x -> x where x is not a class.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast31ConcreteToArchetypeConvertUInt8{{[_0-9a-zA-Z]*}}3Not{{.*}}Tg5 : $@convention(thin) (NotUInt8, NotUInt8) -> NotUInt8 {
+// CHECK: bb0(%0 : $NotUInt8, %1 : $NotUInt8):
+// CHECK-NEXT: debug_value %0
+// CHECK-NEXT: return %0
+
+// x -> y where x is not a class but y is a class.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast31ConcreteToArchetypeConvertUInt8{{[_0-9a-zA-Z]*}}FAA1CC_Tg5 : $@convention(thin) (NotUInt8, @in_guaranteed C) -> @owned C {
+// CHECK: bb0
+// CHECK: builtin "int_trap"
+// CHECK: unreachable
+// CHECK-NEXT: }
+
+// x -> y where x,y are different non class types.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast31ConcreteToArchetypeConvertUInt8{{[_0-9a-zA-Z]*}}Not{{.*}}Tg5 : $@convention(thin) (NotUInt8, NotUInt64) -> NotUInt64 {
+// CHECK: bb0
+// CHECK: builtin "int_trap"
+// CHECK: unreachable
+// CHECK-NEXT: }
+
+@inline(never)
+public func ConcreteToArchetypeConvertC<T>(t t: C, t2: T) -> T {
+ return t as! T
+}
+
+ConcreteToArchetypeConvertC(t: c, t2: c)
+ConcreteToArchetypeConvertC(t: c, t2: b)
+ConcreteToArchetypeConvertC(t: c, t2: d)
+ConcreteToArchetypeConvertC(t: c, t2: e)
+
+
+// x -> x where x is a class.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast27ConcreteToArchetypeConvertC{{[_0-9a-zA-Z]*}}Tg5 : $@convention(thin) (@guaranteed C, @in_guaranteed C) -> @owned C {
+// CHECK: bb0(%0 : $C, %1 : $*C):
+// CHECK: return %0
+
+// x -> y where x is a class but y is not.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast27ConcreteToArchetypeConvertC{{[_0-9a-zA-Z]*}}Not{{.*}}Tg5 : $@convention(thin) (@guaranteed C, NotUInt8) -> NotUInt8 {
+// CHECK: bb0
+// CHECK: builtin "int_trap"
+// CHECK: unreachable
+// CHECK-NEXT: }
+
+// x -> y where x is a super class of y.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast27ConcreteToArchetypeConvertC{{[_0-9a-zA-Z]*}}FAA1DC_Tg5 : $@convention(thin) (@guaranteed C, @in_guaranteed D) -> @owned D {
+// CHECK: bb0(%0 : $C, %1 : $*D):
+// CHECK-DAG: [[STACK_C:%[0-9]+]] = alloc_stack $C
+// CHECK-DAG: store %0 to [[STACK_C]]
+// CHECK-DAG: [[STACK_D:%[0-9]+]] = alloc_stack $D
+// TODO: This should be optimized to an unconditional_checked_cast without the need of alloc_stack: rdar://problem/24775038
+// CHECK-DAG: unconditional_checked_cast_addr C in [[STACK_C]] : $*C to D in [[STACK_D]] : $*D
+// CHECK-DAG: [[LOAD:%[0-9]+]] = load [[STACK_D]]
+// CHECK: return [[LOAD]]
+
+// x -> y where x and y are unrelated classes.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast27ConcreteToArchetypeConvertC{{[_0-9a-zA-Z]*}}FAA1EC_Tg5 : $@convention(thin) (@guaranteed C, @in_guaranteed E) -> @owned E {
+// CHECK: bb0(%0 : $C, %1 : $*E):
+// CHECK-NEXT: builtin "int_trap"
+// CHECK-NEXT: unreachable
+// CHECK-NEXT: }
+
+@inline(never)
+public func ConcreteToArchetypeConvertD<T>(t t: D, t2: T) -> T {
+ return t as! T
+}
+
+ConcreteToArchetypeConvertD(t: d, t2: c)
+
+// x -> y where x is a subclass of y.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast27ConcreteToArchetypeConvertD{{[_0-9a-zA-Z]*}}FAA1CC_Tg5 : $@convention(thin) (@guaranteed D, @in_guaranteed C) -> @owned C {
+// CHECK: bb0(%0 : $D, %1 : $*C):
+// CHECK-DAG: [[UC:%[0-9]+]] = upcast %0
+// CHECK: return [[UC]]
+
+
+////////////////////////
+// Super To Archetype //
+////////////////////////
+
+@inline(never)
+public func SuperToArchetypeC<T>(c c : C, t : T) -> T {
+ return c as! T
+}
+
+SuperToArchetypeC(c: c, t: c)
+SuperToArchetypeC(c: c, t: d)
+SuperToArchetypeC(c: c, t: b)
+
+
+// x -> x where x is a class.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast17SuperToArchetypeC{{[_0-9a-zA-Z]*}}Tg5 : $@convention(thin) (@guaranteed C, @in_guaranteed C) -> @owned C {
+// CHECK: bb0(%0 : $C, %1 : $*C):
+// CHECK: return %0
+
+// x -> y where x is a super class of y.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast17SuperToArchetypeC{{[_0-9a-zA-Z]*}}FAA1DC_Tg5 : $@convention(thin) (@guaranteed C, @in_guaranteed D) -> @owned D {
+// CHECK: bb0
+// CHECK: unconditional_checked_cast_addr C in
+
+// x -> y where x is a class and y is not.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast17SuperToArchetypeC{{[_0-9a-zA-Z]*}}FAA8NotUInt8V_Tg5 : $@convention(thin) (@guaranteed C, NotUInt8) -> NotUInt8 {
+// CHECK: bb0
+// CHECK: builtin "int_trap"
+// CHECK: unreachable
+// CHECK-NEXT: }
+
+@inline(never)
+public func SuperToArchetypeD<T>(d d : D, t : T) -> T {
+ return d as! T
+}
+
+SuperToArchetypeD(d: d, t: c)
+SuperToArchetypeD(d: d, t: d)
+
+// *NOTE* The frontend is smart enough to turn this into an upcast. When this
+// test is converted to SIL, this should be fixed appropriately.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast17SuperToArchetypeD{{[_0-9a-zA-Z]*}}FAA1CC_Tg5 : $@convention(thin) (@guaranteed D, @in_guaranteed C) -> @owned C {
+// CHECK-NOT: unconditional_checked_cast super_to_archetype
+// CHECK: upcast
+// CHECK-NOT: unconditional_checked_cast super_to_archetype
+
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast17SuperToArchetypeD{{[_0-9a-zA-Z]*}}Tg5 : $@convention(thin) (@guaranteed D, @in_guaranteed D) -> @owned D {
+// CHECK: bb0(%0 : $D, %1 : $*D):
+// CHECK: return %0
+
+//////////////////////////////
+// Existential To Archetype //
+//////////////////////////////
+
+@inline(never)
+public func ExistentialToArchetype<T>(o o : AnyObject, t : T) -> T {
+ return o as! T
+}
+
+// AnyObject -> Class.
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast22ExistentialToArchetype{{[_0-9a-zA-Z]*}}FAA1CC_Tg5 : $@convention(thin) (@guaranteed AnyObject, @in_guaranteed C) -> @owned C {
+// CHECK: unconditional_checked_cast_addr AnyObject in {{%.*}} : $*AnyObject to C
+
+// AnyObject -> Non Class (should always fail)
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast22ExistentialToArchetype{{[_0-9a-zA-Z]*}}FAA8NotUInt8V_Tg5 : $@convention(thin) (@guaranteed AnyObject, NotUInt8) -> NotUInt8 {
+// CHECK-NOT: builtin "int_trap"()
+// CHECK-NOT: unreachable
+// CHECK: return
+
+// AnyObject -> AnyObject
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast22ExistentialToArchetype{{[_0-9a-zA-Z]*}}yXl{{.*}}Tg5 : $@convention(thin) (@guaranteed AnyObject, @in_guaranteed AnyObject) -> @owned AnyObject {
+// CHECK: bb0(%0 : $AnyObject, %1 : $*AnyObject):
+// CHECK: return %0
+
+ExistentialToArchetype(o: o, t: c)
+ExistentialToArchetype(o: o, t: b)
+ExistentialToArchetype(o: o, t: o)
+
+// Ensure that a downcast from an Optional source is not promoted to a
+// value cast. We could do the promotion, but the optimizer would need
+// to insert the Optional unwrapping logic before the cast.
+//
+// CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast15genericDownCastyq_x_q_mtr0_lFAA1CCSg_AA1DCTg5 : $@convention(thin) (@in_guaranteed Optional<C>, @thick D.Type) -> @owned D {
+// CHECK: bb0(%0 : $*Optional<C>, %1 : $@thick D.Type):
+// CHECK-DAG: [[STACK_D:%[0-9]+]] = alloc_stack $D
+// CHECK-DAG: [[STACK_C:%[0-9]+]] = alloc_stack $Optional<C>
+// CHECK-DAG: %5 = load %0 : $*Optional<C>
+// CHECK-DAG: store %5 to [[STACK_C]]
+// TODO: This should be optimized to an unconditional_checked_cast without the need of alloc_stack: rdar://problem/24775038
+// CHECK-DAG: unconditional_checked_cast_addr Optional<C> in [[STACK_C]] : $*Optional<C> to D in [[STACK_D]] : $*D
+// CHECK-DAG: [[LOAD:%[0-9]+]] = load [[STACK_D]]
+// CHECK: return [[LOAD]]
+@inline(never)
+public func genericDownCast<T, U>(_ a: T, _ : U.Type) -> U {
+ return a as! U
+}
+
+public func callGenericDownCast(_ c: C?) -> D {
+ return genericDownCast(c, D.self)
+}
+
diff --git a/test/SILOptimizer/plus_zero_specialized_anyobject_conformance.swift b/test/SILOptimizer/plus_zero_specialized_anyobject_conformance.swift
new file mode 100644
index 0000000..5cc511e
--- /dev/null
+++ b/test/SILOptimizer/plus_zero_specialized_anyobject_conformance.swift
@@ -0,0 +1,24 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -O -sil-inline-threshold 0 -emit-sil -primary-file %s | %FileCheck %s
+
+// rdar://problem/31910351
+
+// Check that swift compiler does not crash on this input.
+
+public protocol P {
+ func use<T:AnyObject>(_ t: T)
+}
+
+public class C<T> {
+}
+
+public func callee(_ t: C<Int32>?, _ p: P) {
+ // This call results in a creation of a specialized conformance of C<Int32> to AnyObject.
+ p.use(t!)
+}
+
+// CHECK-LABEL: sil @$S33specialized_anyobject_conformance7caller11pyAA1P_p_tF : $@convention(thin) (@in_guaranteed P) -> () {
+public func caller1(p: P) {
+ callee(C<Int32>(), p)
+}
+
diff --git a/test/SILOptimizer/spec_archetype_method.swift b/test/SILOptimizer/spec_archetype_method.swift
index b206b7a..c1bdc18 100644
--- a/test/SILOptimizer/spec_archetype_method.swift
+++ b/test/SILOptimizer/spec_archetype_method.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -O -Xllvm -sil-disable-pass=FunctionSignatureOpts -disable-arc-opts -emit-sil -primary-file %s | %FileCheck %s
// We can't deserialize apply_inst with subst lists. When radar://14443304
diff --git a/test/SILOptimizer/specialize_anyobject.swift b/test/SILOptimizer/specialize_anyobject.swift
index 4b6b8f7..3549297 100644
--- a/test/SILOptimizer/specialize_anyobject.swift
+++ b/test/SILOptimizer/specialize_anyobject.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -O -sil-inline-threshold 0 -emit-sil -primary-file %s | %FileCheck %s
// rdar://problem/20338028
diff --git a/test/SILOptimizer/specialize_cg_update_crash.sil b/test/SILOptimizer/specialize_cg_update_crash.sil
index 4267d5e..317bdce 100644
--- a/test/SILOptimizer/specialize_cg_update_crash.sil
+++ b/test/SILOptimizer/specialize_cg_update_crash.sil
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -parse-stdlib -parse-as-library -module-name TestMod %S/Inputs/TestMod.sil -emit-module-path %t/TestMod.swiftmodule
// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -enable-sil-verify-all -inline -I %t %s | %FileCheck %s
diff --git a/test/SILOptimizer/specialize_checked_cast_branch.swift b/test/SILOptimizer/specialize_checked_cast_branch.swift
index a61de44..87f8234 100644
--- a/test/SILOptimizer/specialize_checked_cast_branch.swift
+++ b/test/SILOptimizer/specialize_checked_cast_branch.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-sil -O -sil-inline-threshold 0 %s -o - | %FileCheck %s
class C {}
diff --git a/test/SILOptimizer/specialize_dynamic_self.swift b/test/SILOptimizer/specialize_dynamic_self.swift
index c801480..835abec 100644
--- a/test/SILOptimizer/specialize_dynamic_self.swift
+++ b/test/SILOptimizer/specialize_dynamic_self.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-inline-generics -emit-sil -O -primary-file %s | %FileCheck %s
protocol P {}
diff --git a/test/SILOptimizer/specialize_inherited_multifile.swift b/test/SILOptimizer/specialize_inherited_multifile.swift
index 96da56e..f6921c0 100644
--- a/test/SILOptimizer/specialize_inherited_multifile.swift
+++ b/test/SILOptimizer/specialize_inherited_multifile.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -primary-file %s %S/Inputs/specialize_inherited_multifile.swift -O -emit-sil -sil-verify-all | %FileCheck %s
@_optimize(none) func takesBase<T : Base>(t: T) {}
diff --git a/test/SILOptimizer/specialize_partial_apply.swift b/test/SILOptimizer/specialize_partial_apply.swift
index fafb263..db5172e 100644
--- a/test/SILOptimizer/specialize_partial_apply.swift
+++ b/test/SILOptimizer/specialize_partial_apply.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// First check the SIL.
// RUN: %target-swift-frontend -O -Xllvm -sil-disable-pass=FunctionSignatureOpts -module-name=test -emit-sil -primary-file %s | %FileCheck %s
diff --git a/test/SILOptimizer/specialize_same_type_constraint.swift b/test/SILOptimizer/specialize_same_type_constraint.swift
index fe11b5b..e80cda3 100644
--- a/test/SILOptimizer/specialize_same_type_constraint.swift
+++ b/test/SILOptimizer/specialize_same_type_constraint.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -O -emit-sil -primary-file %s | %FileCheck %s
protocol FirstChild {}
diff --git a/test/SILOptimizer/specialize_self.swift b/test/SILOptimizer/specialize_self.swift
index 4bc585d..4384da9 100644
--- a/test/SILOptimizer/specialize_self.swift
+++ b/test/SILOptimizer/specialize_self.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -O -sil-inline-threshold 0 -emit-sil -primary-file %s | %FileCheck %s
// CHECK-NOT: generic specialization <Swift.AnyObject, Self> of specialize_self.cast <A, B>(A) -> Swift.Optional<B>
diff --git a/test/SILOptimizer/specialize_self_conforming.swift b/test/SILOptimizer/specialize_self_conforming.swift
index c182da3..847fa94e 100644
--- a/test/SILOptimizer/specialize_self_conforming.swift
+++ b/test/SILOptimizer/specialize_self_conforming.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-sil -O -primary-file %s | %FileCheck %s
// REQUIRES: objc_interop
diff --git a/test/SILOptimizer/specialize_unconditional_checked_cast.swift b/test/SILOptimizer/specialize_unconditional_checked_cast.swift
index d4cbb5a..31ab14a 100644
--- a/test/SILOptimizer/specialize_unconditional_checked_cast.swift
+++ b/test/SILOptimizer/specialize_unconditional_checked_cast.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -Xllvm -sil-disable-pass=FunctionSignatureOpts -emit-sil -o - -O %s | %FileCheck %s
//////////////////
diff --git a/test/SILOptimizer/specialized_anyobject_conformance.swift b/test/SILOptimizer/specialized_anyobject_conformance.swift
index 89f63f7..d127df0 100644
--- a/test/SILOptimizer/specialized_anyobject_conformance.swift
+++ b/test/SILOptimizer/specialized_anyobject_conformance.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -O -sil-inline-threshold 0 -emit-sil -primary-file %s | %FileCheck %s
// rdar://problem/31910351
diff --git a/test/Sanitizers/tsan.swift b/test/Sanitizers/tsan.swift
index 214274a..3b793f5 100644
--- a/test/Sanitizers/tsan.swift
+++ b/test/Sanitizers/tsan.swift
@@ -3,7 +3,11 @@
// REQUIRES: executable_test
// REQUIRES: tsan_runtime
// UNSUPPORTED: OS=tvos
-#if os(OSX) || os(iOS)
+
+// https://bugs.swift.org/browse/SR-6622
+// XFAIL: linux
+
+#if os(macOS) || os(iOS)
import Darwin
#elseif os(Linux) || os(FreeBSD) || os(PS4) || os(Android) || os(Cygwin)
import Glibc
@@ -34,7 +38,7 @@
var racey_x: Int;
for _ in 1...5 {
-#if os(OSX) || os(iOS)
+#if os(macOS) || os(iOS)
var t : pthread_t?
#else
var t : pthread_t = 0
@@ -45,7 +49,7 @@
return nil
}, nil)
-#if os(OSX) || os(iOS)
+#if os(macOS) || os(iOS)
threads.append(t!)
#else
threads.append(t)
diff --git a/test/Sanitizers/witness_table_lookup.swift b/test/Sanitizers/witness_table_lookup.swift
index f0120ac..202880e 100644
--- a/test/Sanitizers/witness_table_lookup.swift
+++ b/test/Sanitizers/witness_table_lookup.swift
@@ -3,6 +3,9 @@
// REQUIRES: executable_test
// REQUIRES: tsan_runtime
+// https://bugs.swift.org/browse/SR-6622
+// XFAIL: linux
+
// Check that TSan does not report spurious races in witness table lookup.
func consume(_ x: Any) {}
diff --git a/test/Sema/fixed_ambiguities/plus_zero_rdar27198177.swift b/test/Sema/fixed_ambiguities/plus_zero_rdar27198177.swift
new file mode 100644
index 0000000..39fbc60
--- /dev/null
+++ b/test/Sema/fixed_ambiguities/plus_zero_rdar27198177.swift
@@ -0,0 +1,7 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-sil -verify %s -swift-version 4 | %FileCheck %s
+
+let arr = ["A", "B", "C"]
+let lazy: LazyMapCollection = arr.lazy.map { $0 }
+// CHECK: function_ref @$Ss22LazyCollectionProtocolPsE6filterys0a6FilterB0Vy8ElementsQzGSb7ElementQzcF : $@convention(method) <τ_0_0 where τ_0_0 : LazyCollectionProtocol> (@guaranteed @callee_guaranteed (@in_guaranteed τ_0_0.Element) -> Bool, @in_guaranteed τ_0_0) -> @out LazyFilterCollection<τ_0_0.Elements>
+_ = lazy.filter { $0 > "A" }.count
diff --git a/test/Sema/fixed_ambiguities/plus_zero_rdar33142386.swift b/test/Sema/fixed_ambiguities/plus_zero_rdar33142386.swift
new file mode 100644
index 0000000..ea617e2
--- /dev/null
+++ b/test/Sema/fixed_ambiguities/plus_zero_rdar33142386.swift
@@ -0,0 +1,6 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-sil -verify %s -swift-version 4 | %FileCheck %s
+
+let x: String = "ultimate question"
+// CHECK: function_ref @$Ss26RangeReplaceableCollectionPsE6filteryxSb7ElementQzKXEKF : $@convention(method) <τ_0_0 where τ_0_0 : RangeReplaceableCollection> (@noescape @callee_guaranteed (@in_guaranteed τ_0_0.Element) -> (Bool, @error Error), @in_guaranteed τ_0_0) -> (@out τ_0_0, @error Error)
+_ = x.filter({ $0 == " " }).count < 3
diff --git a/test/Sema/fixed_ambiguities/plus_zero_rdar35623181.swift b/test/Sema/fixed_ambiguities/plus_zero_rdar35623181.swift
new file mode 100644
index 0000000..43e9c26
--- /dev/null
+++ b/test/Sema/fixed_ambiguities/plus_zero_rdar35623181.swift
@@ -0,0 +1,9 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-sil -verify %s | %FileCheck %s
+
+extension Sequence where Element == String {
+ func record() -> String {
+ // CHECK: function_ref @$Ss20LazySequenceProtocolPsE3mapys0a3MapB0Vy8ElementsQzqd__Gqd__7ElementQzclF : $@convention(method) <τ_0_0 where τ_0_0 : LazySequenceProtocol><τ_1_0> (@guaranteed @callee_guaranteed (@in_guaranteed τ_0_0.Element) -> @out τ_1_0, @in_guaranteed τ_0_0) -> @out LazyMapSequence<τ_0_0.Elements, τ_1_0
+ return lazy.map({ $0 }).joined(separator: ",")
+ }
+}
diff --git a/test/Sema/fixed_ambiguities/plus_zero_rdar36333688.swift b/test/Sema/fixed_ambiguities/plus_zero_rdar36333688.swift
new file mode 100644
index 0000000..81b8f77
--- /dev/null
+++ b/test/Sema/fixed_ambiguities/plus_zero_rdar36333688.swift
@@ -0,0 +1,31 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %target-swift-frontend -emit-sil -verify %s | %FileCheck %s
+
+infix operator +=+ : AdditionPrecedence
+extension RangeReplaceableCollection {
+ public static func +=+ <
+ Other : Sequence
+ >(lhs: Self, rhs: Other) -> Self
+ where Element == Other.Element {
+ fatalError()
+ }
+
+ public static func +=+ <
+ Other : Sequence
+ >(lhs: Other, rhs: Self) -> Self
+ where Element == Other.Element {
+ fatalError()
+ }
+
+ public static func +=+ <
+ Other : RangeReplaceableCollection
+ >(lhs: Self, rhs: Other) -> Self
+ where Element == Other.Element {
+ fatalError()
+ }
+}
+
+func rdar36333688(_ first: Int, _ rest: Int...) {
+ // CHECK: function_ref @{{.*}} : $@convention(method) <τ_0_0 where τ_0_0 : RangeReplaceableCollection><τ_1_0 where τ_1_0 : RangeReplaceableCollection, τ_0_0.Element == τ_1_0.Element> (@in_guaranteed τ_0_0, @in_guaranteed τ_1_0, @thick τ_0_0.Type) -> @out τ_0_0
+ let _ = [first] +=+ rest
+}
diff --git a/test/Sema/fixed_ambiguities/rdar27198177.swift b/test/Sema/fixed_ambiguities/rdar27198177.swift
index 0cfad49..bd240b3 100644
--- a/test/Sema/fixed_ambiguities/rdar27198177.swift
+++ b/test/Sema/fixed_ambiguities/rdar27198177.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-sil -verify %s -swift-version 4 | %FileCheck %s
let arr = ["A", "B", "C"]
diff --git a/test/Sema/fixed_ambiguities/rdar33142386.swift b/test/Sema/fixed_ambiguities/rdar33142386.swift
index 798fc6b..e6fd493 100644
--- a/test/Sema/fixed_ambiguities/rdar33142386.swift
+++ b/test/Sema/fixed_ambiguities/rdar33142386.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-sil -verify %s -swift-version 4 | %FileCheck %s
let x: String = "ultimate question"
diff --git a/test/Sema/fixed_ambiguities/rdar35623181.swift b/test/Sema/fixed_ambiguities/rdar35623181.swift
index d72f4b6..d3278c8 100644
--- a/test/Sema/fixed_ambiguities/rdar35623181.swift
+++ b/test/Sema/fixed_ambiguities/rdar35623181.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-sil -verify %s | %FileCheck %s
extension Sequence where Element == String {
diff --git a/test/Sema/fixed_ambiguities/rdar36333688.swift b/test/Sema/fixed_ambiguities/rdar36333688.swift
index b7827cc..3417b6a 100644
--- a/test/Sema/fixed_ambiguities/rdar36333688.swift
+++ b/test/Sema/fixed_ambiguities/rdar36333688.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %target-swift-frontend -emit-sil -verify %s | %FileCheck %s
infix operator +=+ : AdditionPrecedence
diff --git a/test/Serialization/function.swift b/test/Serialization/function.swift
index 6e9074a..93e74be 100644
--- a/test/Serialization/function.swift
+++ b/test/Serialization/function.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/def_func.swift
// RUN: llvm-bcanalyzer %t/def_func.swiftmodule | %FileCheck %s
diff --git a/test/Serialization/objc.swift b/test/Serialization/objc.swift
index 90bf773..d2ba2bf 100644
--- a/test/Serialization/objc.swift
+++ b/test/Serialization/objc.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/def_objc.swift -disable-objc-attr-requires-foundation-module
// RUN: llvm-bcanalyzer %t/def_objc.swiftmodule | %FileCheck %s
diff --git a/test/Serialization/plus_zero_function.swift b/test/Serialization/plus_zero_function.swift
new file mode 100644
index 0000000..0332f22
--- /dev/null
+++ b/test/Serialization/plus_zero_function.swift
@@ -0,0 +1,120 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/def_func.swift
+// RUN: llvm-bcanalyzer %t/def_func.swiftmodule | %FileCheck %s
+// RUN: %target-swift-frontend -emit-silgen -I %t %s | %FileCheck %s -check-prefix=SIL
+
+// CHECK-NOT: FALL_BACK_TO_TRANSLATION_UNIT
+// CHECK-NOT: UnknownCode
+
+import def_func
+
+func useEq<T: EqualOperator>(_ x: T, y: T) -> Bool {
+ return x == y
+}
+
+// SIL: sil @main
+// SIL: [[RAW:%.+]] = global_addr @$S8function3rawSivp : $*Int
+// SIL: [[ZERO:%.+]] = function_ref @$S8def_func7getZeroSiyF : $@convention(thin) () -> Int
+// SIL: [[RESULT:%.+]] = apply [[ZERO]]() : $@convention(thin) () -> Int
+// SIL: store [[RESULT]] to [trivial] [[RAW]] : $*Int
+var raw = getZero()
+
+// Check that 'raw' is an Int
+var cooked : Int = raw
+
+
+// SIL: [[GET_INPUT:%.+]] = function_ref @$S8def_func8getInput1xS2i_tF : $@convention(thin) (Int) -> Int
+// SIL: {{%.+}} = apply [[GET_INPUT]]({{%.+}}) : $@convention(thin) (Int) -> Int
+var raw2 = getInput(x: raw)
+
+// SIL: [[GET_SECOND:%.+]] = function_ref @$S8def_func9getSecond_1yS2i_SitF : $@convention(thin) (Int, Int) -> Int
+// SIL: {{%.+}} = apply [[GET_SECOND]]({{%.+}}, {{%.+}}) : $@convention(thin) (Int, Int) -> Int
+var raw3 = getSecond(raw, y: raw2)
+
+// SIL: [[USE_NESTED:%.+]] = function_ref @$S8def_func9useNested_1nySi1x_Si1yt_SitF : $@convention(thin) (Int, Int, Int) -> ()
+// SIL: {{%.+}} = apply [[USE_NESTED]]({{%.+}}, {{%.+}}, {{%.+}}) : $@convention(thin) (Int, Int, Int) -> ()
+useNested((raw, raw2), n: raw3)
+
+// SIL: [[VA_SIZE:%.+]] = integer_literal $Builtin.Word, 2
+// SIL: {{%.+}} = apply {{%.*}}<Int>([[VA_SIZE]])
+// SIL: [[VARIADIC:%.+]] = function_ref @$S8def_func8variadic1x_ySd_SidtF : $@convention(thin) (Double, @guaranteed Array<Int>) -> ()
+// SIL: {{%.+}} = apply [[VARIADIC]]({{%.+}}, {{%.+}}) : $@convention(thin) (Double, @guaranteed Array<Int>) -> ()
+variadic(x: 2.5, 4, 5)
+
+// SIL: [[VARIADIC:%.+]] = function_ref @$S8def_func9variadic2_1xySid_SdtF : $@convention(thin) (@guaranteed Array<Int>, Double) -> ()
+variadic2(1, 2, 3, x: 5.0)
+
+// SIL: [[SLICE_SIZE:%.+]] = integer_literal $Builtin.Word, 3
+// SIL: {{%.+}} = apply {{%.*}}<Int>([[SLICE_SIZE]])
+// SIL: [[SLICE:%.+]] = function_ref @$S8def_func5slice1xySaySiG_tF : $@convention(thin) (@guaranteed Array<Int>) -> ()
+// SIL: {{%.+}} = apply [[SLICE]]({{%.+}}) : $@convention(thin) (@guaranteed Array<Int>) -> ()
+slice(x: [2, 4, 5])
+
+optional(x: .some(23))
+optional(x: .none)
+
+
+// SIL: [[MAKE_PAIR:%.+]] = function_ref @$S8def_func8makePair{{[_0-9a-zA-Z]*}}F : $@convention(thin) <τ_0_0, τ_0_1> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_1) -> (@out τ_0_0, @out τ_0_1)
+// SIL: {{%.+}} = apply [[MAKE_PAIR]]<Int, Double>({{%.+}}, {{%.+}})
+
+var pair : (Int, Double) = makePair(a: 1, b: 2.5)
+
+// SIL: [[DIFFERENT_A:%.+]] = function_ref @$S8def_func9different{{[_0-9a-zA-Z]*}}F : $@convention(thin) <τ_0_0 where τ_0_0 : Equatable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0) -> Bool
+// SIL: [[DIFFERENT_B:%.+]] = function_ref @$S8def_func9different{{[_0-9a-zA-Z]*}}F : $@convention(thin) <τ_0_0 where τ_0_0 : Equatable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0) -> Bool
+
+_ = different(a: 1, b: 2)
+_ = different(a: false, b: false)
+
+// SIL: [[DIFFERENT2_A:%.+]] = function_ref @$S8def_func10different2{{[_0-9a-zA-Z]*}}F : $@convention(thin) <τ_0_0 where τ_0_0 : Equatable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0) -> Bool
+// SIL: [[DIFFERENT2_B:%.+]] = function_ref @$S8def_func10different2{{[_0-9a-zA-Z]*}}F : $@convention(thin) <τ_0_0 where τ_0_0 : Equatable> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0) -> Bool
+_ = different2(a: 1, b: 2)
+_ = different2(a: false, b: false)
+
+
+struct IntWrapper1 : Wrapped {
+ typealias Value = Int
+ func getValue() -> Int { return 1 }
+}
+struct IntWrapper2 : Wrapped {
+ typealias Value = Int
+ func getValue() -> Int { return 2 }
+}
+
+// SIL: [[DIFFERENT_WRAPPED:%.+]] = function_ref @$S8def_func16differentWrapped1a1bSbx_q_tAA0D0RzAaER_5ValueQy_AFRtzr0_lF : $@convention(thin) <τ_0_0, τ_0_1 where τ_0_0 : Wrapped, τ_0_1 : Wrapped, τ_0_0.Value == τ_0_1.Value> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_1) -> Bool
+
+
+_ = differentWrapped(a: IntWrapper1(), b: IntWrapper2())
+
+
+// SIL: {{%.+}} = function_ref @$S8def_func10overloaded1xySi_tF : $@convention(thin) (Int) -> ()
+// SIL: {{%.+}} = function_ref @$S8def_func10overloaded1xySb_tF : $@convention(thin) (Bool) -> ()
+
+overloaded(x: 1)
+overloaded(x: false)
+
+
+// SIL: {{%.+}} = function_ref @primitive : $@convention(thin) () -> ()
+primitive()
+
+
+if raw == 5 {
+ testNoReturnAttr()
+ testNoReturnAttrPoly(x: 5)
+}
+// SIL: {{%.+}} = function_ref @$S8def_func16testNoReturnAttrs5NeverOyF : $@convention(thin) () -> Never
+// SIL: {{%.+}} = function_ref @$S8def_func20testNoReturnAttrPoly{{[_0-9a-zA-Z]*}}F : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> Never
+
+
+// SIL: sil @$S8def_func16testNoReturnAttrs5NeverOyF : $@convention(thin) () -> Never
+// SIL: sil @$S8def_func20testNoReturnAttrPoly{{[_0-9a-zA-Z]*}}F : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> Never
+
+do {
+ try throws1()
+ _ = try throws2(1)
+} catch _ {}
+// SIL: sil @$S8def_func7throws1yyKF : $@convention(thin) () -> @error Error
+// SIL: sil @$S8def_func7throws2{{[_0-9a-zA-Z]*}}F : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> (@out τ_0_0, @error Error)
+
+// LLVM: }
+
diff --git a/test/Serialization/plus_zero_objc.swift b/test/Serialization/plus_zero_objc.swift
new file mode 100644
index 0000000..787e961
--- /dev/null
+++ b/test/Serialization/plus_zero_objc.swift
@@ -0,0 +1,39 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/def_objc.swift -disable-objc-attr-requires-foundation-module
+// RUN: llvm-bcanalyzer %t/def_objc.swiftmodule | %FileCheck %s
+// RUN: %target-swift-frontend -emit-silgen -I %t %s -o - | %FileCheck %s -check-prefix=SIL
+
+// CHECK-NOT: UnknownCode
+
+import def_objc
+
+// SIL: sil hidden @$S4objc9testProto3objy04def_A09ObjCProto_p_tF : $@convention(thin) (@guaranteed ObjCProto) -> () {
+func testProto(obj obj: ObjCProto) {
+ // SIL: = objc_method {{%.*}} : $@opened({{.*}}) ObjCProto, #ObjCProto.doSomething!1.foreign
+ obj.doSomething()
+}
+
+// SIL: sil hidden @$S4objc9testClass3objy04def_A09ObjCClassC_tF : $@convention(thin) (@guaranteed ObjCClass) -> () {
+func testClass(obj obj: ObjCClass) {
+ // SIL: = objc_method %{{.+}} : $ObjCClass, #ObjCClass.implicitlyObjC!1.foreign
+ obj.implicitlyObjC()
+
+ // SIL: = objc_method %{{.+}} : $@objc_metatype ObjCClass.Type, #ObjCClass.classMethod!1.foreign
+ ObjCClass.classMethod()
+}
+
+// SIL: sil hidden @$S4objc15testNativeClass3objy04def_A012NonObjCClassC_tF : $@convention(thin) (@guaranteed NonObjCClass) -> () {
+func testNativeClass(obj obj: NonObjCClass) {
+ // SIL: = objc_method %{{.+}} : $NonObjCClass, #NonObjCClass.doSomething!1.foreign
+ // SIL: = objc_method %{{.+}} : $NonObjCClass, #NonObjCClass.objcMethod!1.foreign
+ obj.doSomething()
+ obj.objcMethod()
+
+ // SIL: objc_method [[OBJ:%[0-9]+]] : $NonObjCClass, #NonObjCClass.objcProp!getter.1.foreign
+ var x = obj.objcProp
+
+ // SIL: objc_method [[OBJ:%[0-9]+]] : $NonObjCClass, #NonObjCClass.subscript!getter.1.foreign
+ _ = obj[42]
+}
+
diff --git a/test/Serialization/plus_zero_serialize_attr.swift b/test/Serialization/plus_zero_serialize_attr.swift
new file mode 100644
index 0000000..ea32612
--- /dev/null
+++ b/test/Serialization/plus_zero_serialize_attr.swift
@@ -0,0 +1,84 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -parse-as-library -o %t %s
+// RUN: llvm-bcanalyzer %t/serialize_attr.swiftmodule | %FileCheck %s -check-prefix=BCANALYZER
+// RUN: %target-sil-opt -enable-sil-verify-all -disable-sil-linking %t/serialize_attr.swiftmodule | %FileCheck %s
+
+// BCANALYZER-NOT: UnknownCode
+
+// @_semantics
+// -----------------------------------------------------------------------------
+
+//CHECK-DAG: @_semantics("crazy") func foo()
+@_inlineable
+@_versioned
+@_semantics("crazy") func foo() -> Int { return 5}
+
+// @_optimize
+// -----------------------------------------------------------------------------
+
+//CHECK-DAG: @_optimize(none) func test_onone()
+@_inlineable
+@_versioned
+@_optimize(none)
+func test_onone() -> Int { return 5}
+
+//CHECK-DAG: @_optimize(speed) func test_ospeed()
+@_inlineable
+@_versioned
+@_optimize(speed)
+func test_ospeed() -> Int { return 5}
+
+//CHECK-DAG: @_optimize(size) func test_osize()
+@_inlineable
+@_versioned
+@_optimize(size)
+func test_osize() -> Int { return 5}
+
+// @_specialize
+// -----------------------------------------------------------------------------
+
+// These lines should be contiguous.
+// CHECK-DAG: @_specialize(exported: false, kind: full, where T == Int, U == Float)
+// CHECK-DAG: func specializeThis<T, U>(_ t: T, u: U)
+@_inlineable
+@_versioned
+@_specialize(where T == Int, U == Float)
+func specializeThis<T, U>(_ t: T, u: U) {}
+
+public protocol PP {
+ associatedtype PElt
+}
+public protocol QQ {
+ associatedtype QElt
+}
+
+public struct RR : PP {
+ public typealias PElt = Float
+}
+public struct SS : QQ {
+ public typealias QElt = Int
+}
+
+public struct GG<T : PP> {}
+
+// These three lines should be contiguous, however, there is no way to
+// sequence FileCheck directives while using CHECK-DAG as the outer
+// label, and the declaration order is unpredictable.
+//
+// CHECK-DAG: class CC<T> where T : PP {
+// CHECK-DAG: @_specialize(exported: false, kind: full, where T == RR, U == SS)
+// CHECK-DAG: @inline(never) func foo<U>(_ u: U, g: GG<T>) -> (U, GG<T>) where U : QQ
+public class CC<T : PP> {
+ @_inlineable
+ @_versioned
+ @inline(never)
+ @_specialize(where T==RR, U==SS)
+ func foo<U : QQ>(_ u: U, g: GG<T>) -> (U, GG<T>) {
+ return (u, g)
+ }
+}
+
+// CHECK-DAG: sil [serialized] [_specialize exported: false, kind: full, where T == Int, U == Float] [canonical] @$S14serialize_attr14specializeThis_1uyx_q_tr0_lF : $@convention(thin) <T, U> (@in_guaranteed T, @in_guaranteed U) -> () {
+
+// CHECK-DAG: sil [serialized] [noinline] [_specialize exported: false, kind: full, where T == RR, U == SS] [canonical] @$S14serialize_attr2CCC3foo_1gqd___AA2GGVyxGtqd___AHtAA2QQRd__lF : $@convention(method) <T where T : PP><U where U : QQ> (@in_guaranteed U, GG<T>, @guaranteed CC<T>) -> (@out U, GG<T>) {
diff --git a/test/Serialization/plus_zero_transparent-std.swift b/test/Serialization/plus_zero_transparent-std.swift
new file mode 100644
index 0000000..0a92f03
--- /dev/null
+++ b/test/Serialization/plus_zero_transparent-std.swift
@@ -0,0 +1,58 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -parse-stdlib -o %t %S/Inputs/def_transparent_std.swift
+// RUN: llvm-bcanalyzer %t/def_transparent_std.swiftmodule | %FileCheck %s
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-sil -sil-debug-serialization -parse-stdlib -I %t %s | %FileCheck %s -check-prefix=SIL
+
+// CHECK-NOT: UnknownCode
+
+import def_transparent_std
+
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S19def_transparent_std3foo1x1yBi1_Bi1__Bi1_tF : $@convention(thin) (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 {
+// SIL: = builtin "cmp_eq_Int1"(%0 : $Builtin.Int1, %1 : $Builtin.Int1) : $Builtin.Int1
+func test_foo(x: Builtin.Int1, y: Builtin.Int1) -> Builtin.Int1 {
+ var a = foo(x: x, y: y)
+ return a
+}
+
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S19def_transparent_std12assign_tuple1x1yyBi64__Bot_BptF : $@convention(thin) (Builtin.Int64, @guaranteed Builtin.NativeObject, Builtin.RawPointer) -> () {
+// SIL: = tuple (%0 : $Builtin.Int64, %1 : $Builtin.NativeObject)
+// SIL: retain_value
+// SIL: = tuple_extract
+// SIL: = tuple_extract
+// SIL: = pointer_to_address
+// SIL: = tuple
+// SIL: = load
+func test_tuple(x: (Builtin.Int64, Builtin.NativeObject),
+ y: Builtin.RawPointer) {
+ assign_tuple(x: x, y: y)
+}
+
+func test_conversion(c: C, t32: Builtin.Int32) {
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S19def_transparent_std22class_to_native_object1cBoAA1CC_tF : $@convention(thin) (@guaranteed C) -> @owned Builtin.NativeObject {
+// SIL: bb0(%0 : $C):
+// SIL: unchecked_ref_cast %0 : $C to $Builtin.NativeObject
+// SIL-NEXT: strong_retain
+// SIL-NEXT: return
+ var b = class_to_native_object(c: c)
+
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S19def_transparent_std24class_from_native_object1pAA1CCBo_tF : $@convention(thin) (@guaranteed Builtin.NativeObject) -> @owned C {
+// SIL: unchecked_ref_cast %0 : $Builtin.NativeObject to $C
+ var c = class_from_native_object(p: b)
+
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S19def_transparent_std20class_to_raw_pointer1cBpAA1CC_tF : $@convention(thin) (@guaranteed C) -> Builtin.RawPointer {
+// SIL: ref_to_raw_pointer %0 : $C to $Builtin.RawPointer
+ var d = class_to_raw_pointer(c: c)
+
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S19def_transparent_std22class_from_raw_pointer1pAA1CCBp_tF : $@convention(thin) (Builtin.RawPointer) -> @owned C {
+// SIL: raw_pointer_to_ref %0 : $Builtin.RawPointer to $C
+ var e = class_from_raw_pointer(p: d)
+
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S19def_transparent_std5gep321p1iBpBp_Bi32_tF : $@convention(thin) (Builtin.RawPointer, Builtin.Int32) -> Builtin.RawPointer {
+// SIL: index_raw_pointer %0 : $Builtin.RawPointer, %1 : $Builtin.Int32
+ var f = gep32(p: d, i: t32)
+
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S19def_transparent_std11destroy_obj1xyBp_tF : $@convention(thin) (Builtin.RawPointer) -> () {
+// SIL: pointer_to_address %0 : $Builtin.RawPointer to [strict] $*Builtin.NativeObject
+ destroy_obj(x: d)
+}
diff --git a/test/Serialization/plus_zero_transparent.swift b/test/Serialization/plus_zero_transparent.swift
new file mode 100644
index 0000000..3fd2497
--- /dev/null
+++ b/test/Serialization/plus_zero_transparent.swift
@@ -0,0 +1,73 @@
+// REQUIRES: plus_zero_runtime
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/def_transparent.swift
+// RUN: llvm-bcanalyzer %t/def_transparent.swiftmodule | %FileCheck %s
+// RUN: %target-swift-frontend -emit-silgen -sil-link-all -I %t %s | %FileCheck %s -check-prefix=SIL
+
+// CHECK-NOT: UnknownCode
+
+import def_transparent
+
+// SIL-LABEL: sil @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 {
+// SIL: [[RAW:%.+]] = global_addr @$S11transparent3rawSbvp : $*Bool
+// SIL: [[FUNC:%.+]] = function_ref @$S15def_transparent15testTransparent1xS2b_tF : $@convention(thin) (Bool) -> Bool
+// SIL: [[RESULT:%.+]] = apply [[FUNC]]({{%.+}}) : $@convention(thin) (Bool) -> Bool
+// SIL: store [[RESULT]] to [trivial] [[RAW]] : $*Bool
+var raw = testTransparent(x: false)
+
+// SIL: [[TMP:%.+]] = global_addr @$S11transparent3tmps5Int32Vvp : $*Int32
+// SIL: [[FUNC2:%.+]] = function_ref @$S15def_transparent11testBuiltins5Int32VyF : $@convention(thin) () -> Int32
+// SIL: [[RESULT2:%.+]] = apply [[FUNC2]]() : $@convention(thin) () -> Int32
+// SIL: store [[RESULT2]] to [trivial] [[TMP]] : $*Int32
+var tmp = testBuiltin()
+
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S15def_transparent15testTransparent1xS2b_tF : $@convention(thin) (Bool) -> Bool {
+// SIL: bb0(%0 : $Bool):
+// SIL: return %0 : $Bool
+
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S15def_transparent11testBuiltins5Int32VyF : $@convention(thin) () -> Int32 {
+// SIL: bb0:
+// SIL: integer_literal $Builtin.Int32, 300
+// SIL: string_literal utf8 "foo"
+// SIL: return %{{.*}} : $Int32
+
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S15def_transparent7test_bryyF : $@convention(thin) () -> () {
+// SIL: bb{{.*}}:
+// SIL: cond_br %{{.*}}, bb{{.*}}, bb{{.*}}
+// SIL: bb{{.*}}:
+// SIL: br bb{{.*}}
+func wrap_br() {
+ test_br()
+}
+
+// SIL-LABEL: sil public_external [serialized] [canonical] @$S15def_transparent9do_switch1uyAA9MaybePairO_tF : $@convention(thin) (@guaranteed MaybePair) -> () {
+// SIL: bb0(%0 : $MaybePair):
+// SIL: retain_value %0 : $MaybePair
+// SIL: switch_enum %0 : $MaybePair, case #MaybePair.Neither!enumelt: bb[[CASE1:[0-9]+]], case #MaybePair.Left!enumelt.1: bb[[CASE2:[0-9]+]], case #MaybePair.Right!enumelt.1: bb[[CASE3:[0-9]+]], case #MaybePair.Both!enumelt.1: bb[[CASE4:[0-9]+]]
+// SIL: bb[[CASE4]](%{{.*}} : $(Int32, String)):
+// SIL: bb[[CASE3]](%{{.*}} : $String):
+// SIL: bb[[CASE2]](%{{.*}} : $Int32):
+// SIL: bb[[CASE1]]:
+func test_switch(u: MaybePair) {
+ do_switch(u: u)
+}
+
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S15def_transparent7WrapperV3ValACs5Int32V_tcfC : $@convention(method) (Int32, @thin Wrapper.Type) -> Wrapper {
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S15def_transparent7WrapperV8getValue{{[_0-9a-zA-Z]*}}F : $@convention(method) (Wrapper) -> Int32 {
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S15def_transparent7WrapperV10valueAgains5Int32Vvg : $@convention(method) (Wrapper) -> Int32 {
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S15def_transparent7WrapperV13getValueAgain{{[_0-9a-zA-Z]*}}F : $@convention(method) (Wrapper) -> Int32 {
+func test_wrapper() {
+ var w = Wrapper(Val: 42)
+
+ print(w.value, terminator: "")
+ print(w.getValue(), terminator: "")
+ print(w.valueAgain, terminator: "")
+ print(w.getValueAgain(), terminator: "")
+}
+
+// SIL-LABEL: sil public_external [transparent] [serialized] [canonical] @$S15def_transparent17open_existentials1p2cpyAA1P_p_AA2CP_ptF
+func test_open_existentials(p: P, cp: CP) {
+ // SIL: open_existential_addr immutable_access [[EXIST:%[0-9]+]] : $*P to $*@opened([[N:".*"]]) P
+ // SIL: open_existential_ref [[EXIST:%[0-9]+]] : $CP to $@opened([[M:".*"]]) CP
+ open_existentials(p: p, cp: cp)
+}
diff --git a/test/Serialization/serialize_attr.swift b/test/Serialization/serialize_attr.swift
index 8456016..501abe1 100644
--- a/test/Serialization/serialize_attr.swift
+++ b/test/Serialization/serialize_attr.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -parse-as-library -o %t %s
// RUN: llvm-bcanalyzer %t/serialize_attr.swiftmodule | %FileCheck %s -check-prefix=BCANALYZER
diff --git a/test/Serialization/transparent-std.swift b/test/Serialization/transparent-std.swift
index 76f887d..1e51fae 100644
--- a/test/Serialization/transparent-std.swift
+++ b/test/Serialization/transparent-std.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -parse-stdlib -o %t %S/Inputs/def_transparent_std.swift
// RUN: llvm-bcanalyzer %t/def_transparent_std.swiftmodule | %FileCheck %s
diff --git a/test/Serialization/transparent.swift b/test/Serialization/transparent.swift
index 72a46a3..89f29dd 100644
--- a/test/Serialization/transparent.swift
+++ b/test/Serialization/transparent.swift
@@ -1,3 +1,4 @@
+// REQUIRES: plus_one_runtime
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/def_transparent.swift
// RUN: llvm-bcanalyzer %t/def_transparent.swiftmodule | %FileCheck %s
diff --git a/test/lit.site.cfg.in b/test/lit.site.cfg.in
index 0b5957b..c8c7a39 100644
--- a/test/lit.site.cfg.in
+++ b/test/lit.site.cfg.in
@@ -36,6 +36,8 @@
config.coverage_mode = "@SWIFT_ANALYZE_CODE_COVERAGE@"
config.lldb_build_root = "@LLDB_BUILD_DIR@"
+# Please remember to handle empty strings and/or unset variables correctly.
+
if "@SWIFT_ASAN_BUILD@" == "TRUE":
config.available_features.add("asan")
else:
@@ -89,10 +91,10 @@
if "@SWIFT_ENABLE_SOURCEKIT_TESTS@" == "TRUE":
config.available_features.add('sourcekit')
-if "@SWIFT_ENABLE_GUARANTEED_NORMAL_ARGUMENTS@" == "FALSE":
- config.available_features.add('plus_one_runtime')
-else:
+if "@SWIFT_ENABLE_GUARANTEED_NORMAL_ARGUMENTS@" == "TRUE":
config.available_features.add('plus_zero_runtime')
+else:
+ config.available_features.add('plus_one_runtime')
# Let the main config do the real work.
if config.test_exec_root is None:
diff --git a/test/stdlib/CodableTests.swift b/test/stdlib/CodableTests.swift
index 8498145..566398c 100644
--- a/test/stdlib/CodableTests.swift
+++ b/test/stdlib/CodableTests.swift
@@ -117,7 +117,7 @@
// MARK: - Tests
class TestCodable : TestCodableSuper {
// MARK: - AffineTransform
-#if os(OSX)
+#if os(macOS)
lazy var affineTransformValues: [Int : AffineTransform] = [
#line : AffineTransform.identity,
#line : AffineTransform(),
@@ -776,7 +776,7 @@
"test_UUID_Plist" : TestCodable.test_UUID_Plist,
]
-#if os(OSX)
+#if os(macOS)
tests["test_AffineTransform_JSON"] = TestCodable.test_AffineTransform_JSON
tests["test_AffineTransform_Plist"] = TestCodable.test_AffineTransform_Plist
#endif
diff --git a/test/stdlib/ErrorHandling.swift b/test/stdlib/ErrorHandling.swift
index b733542..ea5d427 100644
--- a/test/stdlib/ErrorHandling.swift
+++ b/test/stdlib/ErrorHandling.swift
@@ -1,9 +1,6 @@
// RUN: %target-run-simple-swift
// REQUIRES: executable_test
-// FIXME: <https://bugs.swift.org/browse/SR-7146> 2 tests are failing on linux in optimized mode
-// UNSUPPORTED: OS=linux-gnu
-
//
// Tests for error handling in standard library APIs.
//
diff --git a/test/stdlib/FloatConstants.swift b/test/stdlib/FloatConstants.swift
index e3847f4..5d40927 100644
--- a/test/stdlib/FloatConstants.swift
+++ b/test/stdlib/FloatConstants.swift
@@ -1,6 +1,6 @@
// RUN: %target-typecheck-verify-swift
-#if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
import Darwin
#elseif os(Linux) || os(FreeBSD) || os(PS4) || os(Android)
import Glibc
diff --git a/test/stdlib/FloatingPoint.swift.gyb b/test/stdlib/FloatingPoint.swift.gyb
index 24cd535..6df78cb 100644
--- a/test/stdlib/FloatingPoint.swift.gyb
+++ b/test/stdlib/FloatingPoint.swift.gyb
@@ -577,8 +577,8 @@
%for Self in ['Float', 'Double']:
FloatingPoint.test("${Self}.nextUp, .nextDown/nan") {
let x = ${Self}.nan
- expectBitwiseEqual(x, x.nextUp)
- expectBitwiseEqual(x, x.nextDown)
+ expectTrue(x.nextUp.isNaN)
+ expectTrue(x.nextDown.isNaN)
expectTrue((-x).nextDown.isNaN)
expectTrue((-x).nextUp.isNaN)
}
diff --git a/test/stdlib/MathConstants.swift b/test/stdlib/MathConstants.swift
index fd3c3a0..2ecc54d 100644
--- a/test/stdlib/MathConstants.swift
+++ b/test/stdlib/MathConstants.swift
@@ -1,6 +1,6 @@
// RUN: %target-typecheck-verify-swift
-#if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
import Darwin
#elseif os(Linux) || os(FreeBSD) || os(PS4) || os(Android)
import Glibc
diff --git a/test/stdlib/Metal.swift b/test/stdlib/Metal.swift
index cb6d50e..682df24 100644
--- a/test/stdlib/Metal.swift
+++ b/test/stdlib/Metal.swift
@@ -72,7 +72,7 @@
/* Setup */
let device = MTLCreateSystemDefaultDevice()!
- #if os(OSX)
+ #if os(macOS)
let options = MTLResourceOptions.storageModeManaged
#else
let options = MTLResourceOptions.storageModePrivate
@@ -81,7 +81,7 @@
/* Call APIs */
- #if os(OSX)
+ #if os(macOS)
buf.didModifyRange(0..<4)
#endif
buf.addDebugMarker("test marker", range: 0..<4)
@@ -97,7 +97,7 @@
let queue = device.makeCommandQueue()!
let cmdBuf = queue.makeCommandBuffer()!
- #if os(OSX)
+ #if os(macOS)
let options = MTLResourceOptions.storageModeManaged
#else
let options = MTLResourceOptions.storageModePrivate
@@ -162,7 +162,7 @@
let queue = device.makeCommandQueue()!
let cmdBuf = queue.makeCommandBuffer()!
- #if os(OSX)
+ #if os(macOS)
let options = MTLResourceOptions.storageModeManaged
#else
let options = MTLResourceOptions.storageModePrivate
@@ -182,7 +182,7 @@
let encoder = cmdBuf.makeRenderCommandEncoder(descriptor: rpDesc)!
encoder.useResources([buf], usage: MTLResourceUsage.read)
encoder.useHeaps([heap])
- #if os(OSX)
+ #if os(macOS)
encoder.setViewports([MTLViewport()])
encoder.setScissorRects([MTLScissorRect(x:0, y:0, width:1, height:1)])
#endif
diff --git a/test/stdlib/NSStringAPI.swift b/test/stdlib/NSStringAPI.swift
index ac7bd20..cf9afb9 100644
--- a/test/stdlib/NSStringAPI.swift
+++ b/test/stdlib/NSStringAPI.swift
@@ -1329,7 +1329,7 @@
}
func getHomeDir() -> String {
-#if os(OSX)
+#if os(macOS)
return String(cString: getpwuid(getuid()).pointee.pw_dir)
#elseif os(iOS) || os(tvOS) || os(watchOS)
// getpwuid() returns null in sandboxed apps under iOS simulator.
diff --git a/test/stdlib/NSValueBridging.swift.gyb b/test/stdlib/NSValueBridging.swift.gyb
index 685aadf..5b322b8 100644
--- a/test/stdlib/NSValueBridging.swift.gyb
+++ b/test/stdlib/NSValueBridging.swift.gyb
@@ -59,7 +59,7 @@
// For historic reasons, macOS has different NSValue methods for the
// CoreGraphics types from other Apple platforms.
-#if os(OSX)
+#if os(macOS)
${ testCase("CGRect", "CGRect(x: 17, y: 38, width: 6, height: 79)", "rect", "(==)") }
${ testCase("CGPoint", "CGPoint(x: 17, y: 38)", "point", "(==)") }
diff --git a/test/stdlib/Reflection_objc.swift b/test/stdlib/Reflection_objc.swift
index 28286f7..414221c 100644
--- a/test/stdlib/Reflection_objc.swift
+++ b/test/stdlib/Reflection_objc.swift
@@ -15,7 +15,7 @@
import Swift
import Foundation
-#if os(OSX)
+#if os(macOS)
import AppKit
typealias OSImage = NSImage
diff --git a/test/stdlib/Runtime.swift.gyb b/test/stdlib/Runtime.swift.gyb
index e386aac..67ee2bf 100644
--- a/test/stdlib/Runtime.swift.gyb
+++ b/test/stdlib/Runtime.swift.gyb
@@ -9,7 +9,7 @@
import StdlibUnittest
import SwiftShims
-#if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
import Darwin
#elseif os(Linux) || os(FreeBSD) || os(PS4) || os(Android)
import Glibc
@@ -553,7 +553,7 @@
}
Runtime.test("SwiftError layout constants for LLDB") {
-#if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
let RTLD_DEFAULT = UnsafeMutableRawPointer(bitPattern: -2)
#elseif os(Linux)
let RTLD_DEFAULT = UnsafeMutableRawPointer(bitPattern: 0)
@@ -565,7 +565,7 @@
dlsym(RTLD_DEFAULT, "_swift_lldb_offsetof_SwiftError_typeMetadata")!
let sizeof_SwiftError =
dlsym(RTLD_DEFAULT, "_swift_lldb_sizeof_SwiftError")!
-#if os(OSX) || os(iOS) || os(watchOS) || os(tvOS)
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
#if arch(i386) || arch(arm)
expectEqual(20, offsetof_SwiftError_typeMetadata.load(as: UInt.self))
expectEqual(36, sizeof_SwiftError.load(as: UInt.self))
@@ -1671,7 +1671,7 @@
// _stdlib_isOSVersionAtLeast is broken for
// watchOS. rdar://problem/20234735
-#if os(OSX) || os(iOS) || os(tvOS) || os(watchOS)
+#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
// This test assumes that no version component on an OS we test upon
// will ever be greater than 1066 and that every major version will always
// be greater than 1.
diff --git a/test/stdlib/TestAffineTransform.swift b/test/stdlib/TestAffineTransform.swift
index ad2b07a..a0b384a 100644
--- a/test/stdlib/TestAffineTransform.swift
+++ b/test/stdlib/TestAffineTransform.swift
@@ -12,7 +12,7 @@
import Foundation
-#if os(OSX)
+#if os(macOS)
#if FOUNDATION_XCTEST
import XCTest
diff --git a/test/stdlib/TestURL.swift b/test/stdlib/TestURL.swift
index 637e043..8c0128c 100644
--- a/test/stdlib/TestURL.swift
+++ b/test/stdlib/TestURL.swift
@@ -67,7 +67,7 @@
}
}
-#if os(OSX)
+#if os(macOS)
func testQuarantineProperties() {
// Test the quarantine stuff; it has special logic
if #available(OSX 10.11, iOS 9.0, *) {
@@ -383,7 +383,7 @@
URLTests.test("testBasics") { TestURL().testBasics() }
URLTests.test("testProperties") { TestURL().testProperties() }
URLTests.test("testSetProperties") { TestURL().testSetProperties() }
-#if os(OSX)
+#if os(macOS)
URLTests.test("testQuarantineProperties") { TestURL().testQuarantineProperties() }
#endif
URLTests.test("testMoreSetProperties") { TestURL().testMoreSetProperties() }
diff --git a/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake b/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake
index 441c019..6b8b3f3 100644
--- a/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake
+++ b/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake
@@ -238,9 +238,9 @@
add_dependencies(${name} ${LLVM_COMMON_DEPENDS})
endif()
- target_link_libraries(${name} ${SOURCEKITEXE_LINK_LIBS})
+ target_link_libraries(${name} PRIVATE ${SOURCEKITEXE_LINK_LIBS})
swift_common_llvm_config(${name} ${SOURCEKITEXE_LLVM_COMPONENT_DEPENDS})
- target_link_libraries(${name} ${LLVM_COMMON_LIBS})
+ target_link_libraries(${name} PRIVATE ${LLVM_COMMON_LIBS})
set_target_properties(${name} PROPERTIES FOLDER "SourceKit executables")
if (NOT SWIFT_ASAN_BUILD)
@@ -422,9 +422,9 @@
add_dependencies(${name} ${LLVM_COMMON_DEPENDS})
endif(LLVM_COMMON_DEPENDS)
- target_link_libraries(${name} ${SOURCEKITXPC_LINK_LIBS})
+ target_link_libraries(${name} PRIVATE ${SOURCEKITXPC_LINK_LIBS})
swift_common_llvm_config(${name} ${SOURCEKITXPC_LLVM_COMPONENT_DEPENDS})
- target_link_libraries(${name} ${LLVM_COMMON_LIBS})
+ target_link_libraries(${name} PRIVATE ${LLVM_COMMON_LIBS})
add_dependencies(${framework_target} ${name})
diff --git a/tools/SourceKit/lib/Support/ImmutableTextBuffer.cpp b/tools/SourceKit/lib/Support/ImmutableTextBuffer.cpp
index b42a3ed..5a12804 100644
--- a/tools/SourceKit/lib/Support/ImmutableTextBuffer.cpp
+++ b/tools/SourceKit/lib/Support/ImmutableTextBuffer.cpp
@@ -177,7 +177,8 @@
Length += I.piece().size();
}
- auto MemBuf = llvm::MemoryBuffer::getNewUninitMemBuffer(Length, Filename);
+ auto MemBuf =
+ llvm::WritableMemoryBuffer::getNewUninitMemBuffer(Length, Filename);
char *Ptr = (char*)MemBuf->getBufferStart();
for (RewriteRope::iterator I = Rope.begin(), E = Rope.end(); I != E;
I.MoveToNextPiece()) {
@@ -186,7 +187,7 @@
Ptr += Text.size();
}
- return MemBuf;
+ return std::move(MemBuf);
}
ImmutableTextBufferRef EditableTextBuffer::getBufferForSnapshot(
diff --git a/tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp b/tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp
index c756578..7804d6c 100644
--- a/tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp
+++ b/tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp
@@ -156,10 +156,11 @@
}
const char *Position = InputFile->getBufferStart() + CodeCompletionOffset;
- std::unique_ptr<llvm::MemoryBuffer> NewBuffer =
- llvm::MemoryBuffer::getNewUninitMemBuffer(InputFile->getBufferSize() + 1,
+ std::unique_ptr<llvm::WritableMemoryBuffer> NewBuffer =
+ llvm::WritableMemoryBuffer::getNewUninitMemBuffer(
+ InputFile->getBufferSize() + 1,
InputFile->getBufferIdentifier());
- char *NewBuf = const_cast<char*>(NewBuffer->getBufferStart());
+ char *NewBuf = NewBuffer->getBufferStart();
char *NewPos = std::copy(InputFile->getBufferStart(), Position, NewBuf);
*NewPos = '\0';
std::copy(Position, InputFile->getBufferEnd(), NewPos+1);
diff --git a/tools/SourceKit/tools/sourcekitd/lib/API/CompactArray.cpp b/tools/SourceKit/tools/sourcekitd/lib/API/CompactArray.cpp
index 8f9f978..914a4a3 100644
--- a/tools/SourceKit/tools/sourcekitd/lib/API/CompactArray.cpp
+++ b/tools/SourceKit/tools/sourcekitd/lib/API/CompactArray.cpp
@@ -71,10 +71,10 @@
std::unique_ptr<llvm::MemoryBuffer>
CompactArrayBuilderImpl::createBuffer() const {
- std::unique_ptr<llvm::MemoryBuffer> Buf;
- Buf = llvm::MemoryBuffer::getNewUninitMemBuffer(sizeInBytes());
- copyInto(const_cast<char *>(Buf->getBufferStart()), Buf->getBufferSize());
- return Buf;
+ std::unique_ptr<llvm::WritableMemoryBuffer> Buf;
+ Buf = llvm::WritableMemoryBuffer::getNewUninitMemBuffer(sizeInBytes());
+ copyInto(Buf->getBufferStart(), Buf->getBufferSize());
+ return std::move(Buf);
}
void CompactArrayBuilderImpl::appendTo(SmallVectorImpl<char> &Buf) const {
diff --git a/tools/SourceKit/tools/sourcekitd/lib/API/DocStructureArray.cpp b/tools/SourceKit/tools/sourcekitd/lib/API/DocStructureArray.cpp
index c03f0d8..c71cb00 100644
--- a/tools/SourceKit/tools/sourcekitd/lib/API/DocStructureArray.cpp
+++ b/tools/SourceKit/tools/sourcekitd/lib/API/DocStructureArray.cpp
@@ -249,11 +249,11 @@
// * offset of top structure array (relative to structure array section) (1)
size_t headerSize = sizeof(uint64_t) * 6;
- auto result = llvm::MemoryBuffer::getNewUninitMemBuffer(
+ auto result = llvm::WritableMemoryBuffer::getNewUninitMemBuffer(
inheritedTypesBufferSize + attrsBufferSize + elementsBufferSize +
structureArrayBufferSize + structureBufferSize + headerSize);
- char *start = const_cast<char *>(result->getBufferStart());
+ char *start = result->getBufferStart();
char *headerPtr = start;
char *ptr = start + headerSize;
@@ -277,7 +277,7 @@
assert(headerPtr == start + (headerSize - sizeof(topOffset)));
memcpy(headerPtr, &topOffset, sizeof(topOffset));
- return result;
+ return std::move(result);
}
namespace {
diff --git a/tools/SourceKit/tools/sourcekitd/lib/API/sourcekitdAPI-XPC.cpp b/tools/SourceKit/tools/sourcekitd/lib/API/sourcekitdAPI-XPC.cpp
index 4dedc75..60dffda 100644
--- a/tools/SourceKit/tools/sourcekitd/lib/API/sourcekitdAPI-XPC.cpp
+++ b/tools/SourceKit/tools/sourcekitd/lib/API/sourcekitdAPI-XPC.cpp
@@ -245,7 +245,7 @@
CustomBufferKind Kind, std::unique_ptr<llvm::MemoryBuffer> MemBuf) {
std::unique_ptr<llvm::MemoryBuffer> CustomBuf;
- CustomBuf = llvm::MemoryBuffer::getNewUninitMemBuffer(
+ CustomBuf = llvm::WritableMemoryBuffer::getNewUninitMemBuffer(
sizeof(uint64_t) + MemBuf->getBufferSize());
char *BufPtr = (char*)CustomBuf->getBufferStart();
*reinterpret_cast<uint64_t*>(BufPtr) = (uint64_t)Kind;
diff --git a/tools/SwiftSyntax/SyntaxNodes.swift.gyb b/tools/SwiftSyntax/SyntaxNodes.swift.gyb
index 7df2872..2d57718 100644
--- a/tools/SwiftSyntax/SyntaxNodes.swift.gyb
+++ b/tools/SwiftSyntax/SyntaxNodes.swift.gyb
@@ -196,7 +196,7 @@
% end
% for trait in TRAITS:
-public protocol ${trait.trait_name}Syntax {
+public protocol ${trait.trait_name}Syntax: Syntax {
% for child in trait.children:
% ret_type = child.type_name
% if child.is_optional:
diff --git a/tools/driver/CMakeLists.txt b/tools/driver/CMakeLists.txt
index cd9f779..766d3d4 100644
--- a/tools/driver/CMakeLists.txt
+++ b/tools/driver/CMakeLists.txt
@@ -13,7 +13,7 @@
)
if(HAVE_UNICODE_LIBEDIT)
- target_link_libraries(swift edit)
+ target_link_libraries(swift PRIVATE edit)
endif()
swift_create_post_build_symlink(swift
diff --git a/tools/sil-opt/SILOpt.cpp b/tools/sil-opt/SILOpt.cpp
index 1467da4..57a9951 100644
--- a/tools/sil-opt/SILOpt.cpp
+++ b/tools/sil-opt/SILOpt.cpp
@@ -326,7 +326,7 @@
SILOpts.EnableSILOwnership = EnableSILOwnershipOpt;
SILOpts.AssumeUnqualifiedOwnershipWhenParsing =
AssumeUnqualifiedOwnershipWhenParsing;
- SILOpts.EnableGuaranteedNormalArguments =
+ SILOpts.EnableGuaranteedNormalArguments |=
EnableGuaranteedNormalArguments;
SILOpts.VerifyExclusivity = VerifyExclusivity;
diff --git a/tools/swift-api-digester/swift-api-digester.cpp b/tools/swift-api-digester/swift-api-digester.cpp
index fbf14b9..8a41b3e 100644
--- a/tools/swift-api-digester/swift-api-digester.cpp
+++ b/tools/swift-api-digester/swift-api-digester.cpp
@@ -939,7 +939,7 @@
SDKNodeInitInfo Info(Ctx);
NodeVector Children;
- for (auto Pair : *Node) {
+ for (auto &Pair : *Node) {
switch(parseKeyKind(GetScalarString(Pair.getKey()))) {
case KeyKind::KK_kind:
Kind = parseSDKNodeKind(GetScalarString(Pair.getValue()));
diff --git a/tools/swift-ide-test/CMakeLists.txt b/tools/swift-ide-test/CMakeLists.txt
index e260cab..a3afd93 100644
--- a/tools/swift-ide-test/CMakeLists.txt
+++ b/tools/swift-ide-test/CMakeLists.txt
@@ -14,7 +14,7 @@
# If libxml2 is available, make it available for swift-ide-test.
if(SWIFT_HAVE_LIBXML)
include_directories(SYSTEM ${LIBXML2_INCLUDE_DIR})
- target_link_libraries(swift-ide-test ${LIBXML2_LIBRARIES})
+ target_link_libraries(swift-ide-test PRIVATE ${LIBXML2_LIBRARIES})
add_definitions(-DSWIFT_HAVE_LIBXML="1")
endif()
@@ -23,4 +23,4 @@
SOURCE "${SWIFT_SOURCE_DIR}/utils/swift-api-dump.py"
DESTINATION "${SWIFT_RUNTIME_OUTPUT_INTDIR}/swift-api-dump.py"
COMMENT "Creating development symlink for swift-api-dump.py.")
-
\ No newline at end of file
+
diff --git a/tools/swift-llvm-opt/LLVMOpt.cpp b/tools/swift-llvm-opt/LLVMOpt.cpp
index a744f42..2a7de50 100644
--- a/tools/swift-llvm-opt/LLVMOpt.cpp
+++ b/tools/swift-llvm-opt/LLVMOpt.cpp
@@ -37,7 +37,7 @@
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/Bitcode/BitcodeWriterPass.h"
-#include "llvm/CodeGen/CommandFlags.h"
+#include "llvm/CodeGen/CommandFlags.def"
#include "llvm/CodeGen/TargetPassConfig.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DebugInfo.h"
@@ -136,7 +136,7 @@
return TheTarget->createTargetMachine(
TheTriple.getTriple(), CPUStr, FeaturesStr, Options,
- Optional<Reloc::Model>(RelocModel), CMModel, GetCodeGenOptLevel());
+ Optional<Reloc::Model>(RelocModel), getCodeModel(), GetCodeGenOptLevel());
}
static void dumpOutput(llvm::Module &M, llvm::raw_ostream &os) {
@@ -271,14 +271,14 @@
M->setTargetTriple(llvm::Triple::normalize(TargetTriple));
// Figure out what stream we are supposed to write to...
- std::unique_ptr<llvm::tool_output_file> Out;
+ std::unique_ptr<llvm::ToolOutputFile> Out;
// Default to standard output.
if (OutputFilename.empty())
OutputFilename = "-";
std::error_code EC;
Out.reset(
- new llvm::tool_output_file(OutputFilename, EC, llvm::sys::fs::F_None));
+ new llvm::ToolOutputFile(OutputFilename, EC, llvm::sys::fs::F_None));
if (EC) {
errs() << EC.message() << '\n';
return 1;
diff --git a/tools/swift-remoteast-test/CMakeLists.txt b/tools/swift-remoteast-test/CMakeLists.txt
index 9ae0bb0..73f5ac4 100644
--- a/tools/swift-remoteast-test/CMakeLists.txt
+++ b/tools/swift-remoteast-test/CMakeLists.txt
@@ -8,7 +8,7 @@
set_target_properties(swift-remoteast-test PROPERTIES ENABLE_EXPORTS 1)
if(HAVE_UNICODE_LIBEDIT)
- target_link_libraries(swift-remoteast-test edit)
+ target_link_libraries(swift-remoteast-test PRIVATE edit)
endif()
# If building as part of clang, make sure the headers are installed.
diff --git a/tools/swift-stdlib-tool/CMakeLists.txt b/tools/swift-stdlib-tool/CMakeLists.txt
index 0de9578..a585b1b 100644
--- a/tools/swift-stdlib-tool/CMakeLists.txt
+++ b/tools/swift-stdlib-tool/CMakeLists.txt
@@ -2,7 +2,7 @@
swift-stdlib-tool.mm)
find_library(FOUNDATION NAMES Foundation)
-target_link_libraries(swift-stdlib-tool ${FOUNDATION})
+target_link_libraries(swift-stdlib-tool PRIVATE ${FOUNDATION})
swift_install_in_component(compiler
TARGETS swift-stdlib-tool
diff --git a/unittests/AST/CMakeLists.txt b/unittests/AST/CMakeLists.txt
index 5c58c84..12f912d 100644
--- a/unittests/AST/CMakeLists.txt
+++ b/unittests/AST/CMakeLists.txt
@@ -7,6 +7,7 @@
)
target_link_libraries(SwiftASTTests
+ PRIVATE
swiftAST
# FIXME: Circular dependencies.
swiftParse
diff --git a/unittests/Basic/CMakeLists.txt b/unittests/Basic/CMakeLists.txt
index 74613f7..4152a70 100644
--- a/unittests/Basic/CMakeLists.txt
+++ b/unittests/Basic/CMakeLists.txt
@@ -35,6 +35,7 @@
add_dependencies(SwiftBasicTests "${gyb_dependency_targets}")
target_link_libraries(SwiftBasicTests
+ PRIVATE
swiftBasic
clangBasic
)
diff --git a/unittests/Driver/CMakeLists.txt b/unittests/Driver/CMakeLists.txt
index d96dd4a..d85fc16 100644
--- a/unittests/Driver/CMakeLists.txt
+++ b/unittests/Driver/CMakeLists.txt
@@ -3,5 +3,6 @@
)
target_link_libraries(SwiftDriverTests
+ PRIVATE
swiftDriver
)
diff --git a/unittests/IDE/CMakeLists.txt b/unittests/IDE/CMakeLists.txt
index ce0e38f..f55846d 100644
--- a/unittests/IDE/CMakeLists.txt
+++ b/unittests/IDE/CMakeLists.txt
@@ -3,5 +3,6 @@
Placeholders.cpp
)
target_link_libraries(SwiftIDETests
+ PRIVATE
swiftIDE
)
diff --git a/unittests/Parse/CMakeLists.txt b/unittests/Parse/CMakeLists.txt
index b7c2f38..1eb943d 100644
--- a/unittests/Parse/CMakeLists.txt
+++ b/unittests/Parse/CMakeLists.txt
@@ -6,6 +6,7 @@
)
target_link_libraries(SwiftParseTests
+ PRIVATE
swiftSIL
swiftClangImporter
swiftParse
diff --git a/unittests/Reflection/CMakeLists.txt b/unittests/Reflection/CMakeLists.txt
index 91ce58d..0354f0c 100644
--- a/unittests/Reflection/CMakeLists.txt
+++ b/unittests/Reflection/CMakeLists.txt
@@ -4,6 +4,7 @@
add_swift_unittest(SwiftReflectionTests
TypeRef.cpp)
target_link_libraries(SwiftReflectionTests
+ PRIVATE
swiftReflection${SWIFT_PRIMARY_VARIANT_SUFFIX})
endif()
endif()
diff --git a/unittests/SourceKit/Support/CMakeLists.txt b/unittests/SourceKit/Support/CMakeLists.txt
index 5f0e79d..da17a05 100644
--- a/unittests/SourceKit/Support/CMakeLists.txt
+++ b/unittests/SourceKit/Support/CMakeLists.txt
@@ -4,5 +4,6 @@
)
target_link_libraries(SourceKitSupportTests
+ PRIVATE
SourceKitSupport
)
diff --git a/unittests/SourceKit/SwiftLang/CMakeLists.txt b/unittests/SourceKit/SwiftLang/CMakeLists.txt
index fc89375..ca018cc 100644
--- a/unittests/SourceKit/SwiftLang/CMakeLists.txt
+++ b/unittests/SourceKit/SwiftLang/CMakeLists.txt
@@ -6,6 +6,7 @@
)
target_link_libraries(SourceKitSwiftLangTests
+ PRIVATE
SourceKitSwiftLang
)
diff --git a/unittests/SwiftDemangle/CMakeLists.txt b/unittests/SwiftDemangle/CMakeLists.txt
index f080917..9ba1aeb 100644
--- a/unittests/SwiftDemangle/CMakeLists.txt
+++ b/unittests/SwiftDemangle/CMakeLists.txt
@@ -7,6 +7,7 @@
)
target_link_libraries(SwiftDemangleTests
+ PRIVATE
swiftDemangle
)
endif()
diff --git a/unittests/Syntax/CMakeLists.txt b/unittests/Syntax/CMakeLists.txt
index 1b9f0cf..20dc5d4 100644
--- a/unittests/Syntax/CMakeLists.txt
+++ b/unittests/Syntax/CMakeLists.txt
@@ -12,4 +12,5 @@
)
target_link_libraries(SwiftSyntaxTests
+ PRIVATE
swiftSyntax)
diff --git a/unittests/runtime/CMakeLists.txt b/unittests/runtime/CMakeLists.txt
index 5d1c174..e504de1 100644
--- a/unittests/runtime/CMakeLists.txt
+++ b/unittests/runtime/CMakeLists.txt
@@ -56,6 +56,7 @@
# FIXME: cross-compile for all variants.
target_link_libraries(SwiftRuntimeTests
+ PRIVATE
swiftCore${SWIFT_PRIMARY_VARIANT_SUFFIX}
${PLATFORM_TARGET_LINK_LIBRARIES}
${swift_runtime_test_extra_libraries}
diff --git a/unittests/runtime/LongTests/CMakeLists.txt b/unittests/runtime/LongTests/CMakeLists.txt
index 665cf5e..7b77ddb 100644
--- a/unittests/runtime/LongTests/CMakeLists.txt
+++ b/unittests/runtime/LongTests/CMakeLists.txt
@@ -48,6 +48,7 @@
# FIXME: cross-compile for all variants.
target_link_libraries(SwiftRuntimeLongTests
+ PRIVATE
swiftCore${SWIFT_PRIMARY_VARIANT_SUFFIX}
${PLATFORM_TARGET_LINK_LIBRARIES}
${swift_runtime_test_extra_libraries}
diff --git a/utils/build-script-impl b/utils/build-script-impl
index 1f885b3..b7e70e3 100755
--- a/utils/build-script-impl
+++ b/utils/build-script-impl
@@ -70,7 +70,7 @@
llvm-num-parallel-lto-link-jobs "" "The number of parallel link jobs to use when compiling llvm"
swift-stdlib-build-type "Debug" "the CMake build variant for Swift"
swift-stdlib-enable-assertions "1" "enable assertions in Swift"
- swift-stdlib-enable-resilience "0" "build the Swift stdlib and overlays with resilience enabled"
+ swift-stdlib-enable-resilience "1" "build the Swift stdlib and overlays with resilience enabled"
swift-stdlib-use-nonatomic-rc "0" "build the Swift stdlib and overlays with nonatomic reference count operations enabled"
lldb-build-type "Debug" "the CMake build variant for LLDB"
lldb-build-with-xcode "1" "Use xcodebuild to build LLDB, instead of CMake"
@@ -2346,6 +2346,15 @@
fi
;;
esac
+ if [[ "${BUILD_TOOLCHAIN_ONLY}" ]]; then
+ cmake_options+=(
+ -DLLDB_INCLUDE_TESTS=NO
+ )
+ else
+ cmake_options+=(
+ -DLLDB_INCLUDE_TESTS=YES
+ )
+ fi
;;
llbuild)
cmake_options=(
@@ -2823,16 +2832,17 @@
fi
call mkdir -p "${results_dir}"
with_pushd "${results_dir}" \
- call env SWIFTCC="$(build_directory $LOCAL_HOST swift)/bin/swiftc" \
- SWIFTLIBS="${swift_build_dir}/lib/swift" \
- "${LLDB_SOURCE_DIR}"/test/dotest.py \
- --executable "${lldb_executable}" \
- ${LLDB_TEST_DEBUG_SERVER} \
- ${LLDB_TEST_SUBDIR_CLAUSE} \
- ${LLDB_TEST_CATEGORIES} \
- ${LLDB_DOTEST_CC_OPTS} \
- ${LLDB_FORMATTER_OPTS} \
- -E "${DOTEST_EXTRA}"
+ call env SWIFTCC="$(build_directory $LOCAL_HOST swift)/bin/swiftc" \
+ SWIFTLIBS="${swift_build_dir}/lib/swift" \
+ "${LLDB_SOURCE_DIR}"/test/dotest.py \
+ --executable "${lldb_executable}" \
+ ${LLDB_TEST_DEBUG_SERVER} \
+ ${LLDB_TEST_SUBDIR_CLAUSE} \
+ ${LLDB_TEST_CATEGORIES} \
+ ${LLDB_DOTEST_CC_OPTS} \
+ ${LLDB_FORMATTER_OPTS} \
+ --build-dir "${lldb_build_dir}/lldb-test-build.noindex" \
+ -E "${DOTEST_EXTRA}"
continue
;;
llbuild)
diff --git a/validation-test/stdlib/FixedPoint.swift.gyb b/validation-test/stdlib/FixedPoint.swift.gyb
index 6cecc0c..f405b05 100644
--- a/validation-test/stdlib/FixedPoint.swift.gyb
+++ b/validation-test/stdlib/FixedPoint.swift.gyb
@@ -51,15 +51,6 @@
if dst <= ((1 << (dst_bits - 1)) - 1):
return dst
return dst - mask - 1
-
-def get_fixed_point_hash(bit_pattern, src_bits, word_bits):
- if src_bits <= word_bits:
- bit_pattern = prepare_bit_pattern(bit_pattern, src_bits, True)
- return prepare_bit_pattern(bit_pattern, word_bits, True)
- if src_bits == word_bits * 2:
- return prepare_bit_pattern(
- bit_pattern ^ (bit_pattern >> 32), word_bits, True)
-
}%
//===----------------------------------------------------------------------===//
@@ -250,8 +241,15 @@
% input = prepare_bit_pattern(bit_pattern, self_ty.bits, self_ty.is_signed)
let input = get${Self}(${input})
let output = getInt(input.hashValue)
- let expected = getInt(${get_fixed_point_hash(input, self_ty.bits, word_bits)})
- expectEqual(expected, output)
+
+ var hasher = _SipHash13(key: _Hasher._secretKey)
+% if prepare_bit_pattern(input, word_bits, self_ty.is_signed) == input:
+ hasher.append(${input} as ${"" if self_ty.is_signed else "U"}Int)
+% else:
+ hasher.append(input)
+% end
+ let expected = getInt(Int(truncatingIfNeeded: hasher.finalize()))
+ expectEqual(expected, output, "input: \(input)")
}
% end
@@ -269,7 +267,6 @@
${gyb.execute_template(
hash_value_test_template,
prepare_bit_pattern=prepare_bit_pattern,
- get_fixed_point_hash=get_fixed_point_hash,
test_bit_patterns=test_bit_patterns,
word_bits=32)}
@@ -278,7 +275,6 @@
${gyb.execute_template(
hash_value_test_template,
prepare_bit_pattern=prepare_bit_pattern,
- get_fixed_point_hash=get_fixed_point_hash,
test_bit_patterns=test_bit_patterns,
word_bits=64)}
diff --git a/validation-test/stdlib/Hashing.swift b/validation-test/stdlib/Hashing.swift
index 0018c42..a88498d 100644
--- a/validation-test/stdlib/Hashing.swift
+++ b/validation-test/stdlib/Hashing.swift
@@ -8,109 +8,65 @@
var HashingTestSuite = TestSuite("Hashing")
-HashingTestSuite.test("_mixUInt32/GoldenValues") {
- expectEqual(0x11b882c9, _mixUInt32(0x0))
- expectEqual(0x60d0aafb, _mixUInt32(0x1))
- expectEqual(0x636847b5, _mixUInt32(0xffff))
- expectEqual(0x203f5350, _mixUInt32(0xffff_ffff))
-
- expectEqual(0xb8747ef6, _mixUInt32(0xa62301f9))
- expectEqual(0xef4eeeb2, _mixUInt32(0xfe1b46c6))
- expectEqual(0xd44c9cf1, _mixUInt32(0xe4daf7ca))
- expectEqual(0xfc1eb1de, _mixUInt32(0x33ff6f5c))
- expectEqual(0x5605f0c0, _mixUInt32(0x13c2a2b8))
- expectEqual(0xd9c48026, _mixUInt32(0xf3ad1745))
- expectEqual(0x471ab8d0, _mixUInt32(0x656eff5a))
- expectEqual(0xfe265934, _mixUInt32(0xfd2268c9))
+func checkHash(
+ for value: UInt64,
+ withKey key: (UInt64, UInt64),
+ expected: UInt64,
+ file: String = #file, line: UInt = #line
+) {
+ var hasher = _Hasher(key: key)
+ hasher.append(bits: value)
+ let hash = hasher.finalize()
+ expectEqual(
+ hash, Int(truncatingIfNeeded: expected),
+ file: file, line: line)
}
-HashingTestSuite.test("_mixInt32/GoldenValues") {
- expectEqual(Int32(bitPattern: 0x11b882c9 as UInt32), _mixInt32(0x0))
+HashingTestSuite.test("_Hasher/CustomKeys") {
+ // This assumes _Hasher implements SipHash-1-3.
+ checkHash(for: 0, withKey: (0, 0), expected: 0xbd60acb658c79e45)
+ checkHash(for: 0, withKey: (0, 1), expected: 0x1ce32b0b44e61175)
+ checkHash(for: 0, withKey: (1, 0), expected: 0x9c44b7c8df2ca74b)
+ checkHash(for: 0, withKey: (1, 1), expected: 0x9653ca0a3b455506)
+ checkHash(for: 0, withKey: (.max, .max), expected: 0x3ab336a4895e4d36)
+
+ checkHash(for: 1, withKey: (0, 0), expected: 0x1e9f734161d62dd9)
+ checkHash(for: 1, withKey: (0, 1), expected: 0xb6fcf32d09f76cba)
+ checkHash(for: 1, withKey: (1, 0), expected: 0xacb556b13007504a)
+ checkHash(for: 1, withKey: (1, 1), expected: 0x7defec680db51d24)
+ checkHash(for: 1, withKey: (.max, .max), expected: 0x212798441870ef6b)
+
+ checkHash(for: .max, withKey: (0, 0), expected: 0x2f205be2fec8e38d)
+ checkHash(for: .max, withKey: (0, 1), expected: 0x3ff7fa33381ecf7b)
+ checkHash(for: .max, withKey: (1, 0), expected: 0x404afd8eb2c4b22a)
+ checkHash(for: .max, withKey: (1, 1), expected: 0x855642d657c1bd46)
+ checkHash(for: .max, withKey: (.max, .max), expected: 0x5b16b7a8181980c2)
}
-HashingTestSuite.test("_mixUInt64/GoldenValues") {
- expectEqual(0xb2b2_4f68_8dc4_164d, _mixUInt64(0x0))
- expectEqual(0x792e_33eb_0685_57de, _mixUInt64(0x1))
- expectEqual(0x9ec4_3423_1b42_3dab, _mixUInt64(0xffff))
- expectEqual(0x4cec_e9c9_01fa_9a84, _mixUInt64(0xffff_ffff))
- expectEqual(0xcba5_b650_bed5_b87c, _mixUInt64(0xffff_ffff_ffff))
- expectEqual(0xe583_5646_3fb8_ac99, _mixUInt64(0xffff_ffff_ffff_ffff))
+HashingTestSuite.test("_Hasher/DefaultKey") {
+ let value: UInt64 = 0x0102030405060708
- expectEqual(0xf5d0079f828d43a5, _mixUInt64(0x94ce7d9319f8d233))
- expectEqual(0x61900a6be9db9c3f, _mixUInt64(0x2728821e8c5b1f7))
- expectEqual(0xf2fd34b1b7d4b46e, _mixUInt64(0xe7f67ec98c64f482))
- expectEqual(0x216199ed628c821, _mixUInt64(0xd7c277b5438873ac))
- expectEqual(0xb1b486ff5f2e0e53, _mixUInt64(0x8399f1d563c42f82))
- expectEqual(0x61acc92bd91c030, _mixUInt64(0x488cefd48a2c4bfd))
- expectEqual(0xa7a52d6e4a8e3ddf, _mixUInt64(0x270a15116c351f95))
- expectEqual(0x98ceedc363c4e56a, _mixUInt64(0xe5fb9b5f6c426a84))
+ let defaultHash = _hashValue(for: value)
+
+ var defaultHasher = _Hasher()
+ defaultHasher.append(bits: value)
+ expectEqual(defaultHasher.finalize(), defaultHash)
+
+ var customHasher = _Hasher(key: _Hasher._secretKey)
+ customHasher.append(bits: value)
+ expectEqual(customHasher.finalize(), defaultHash)
}
-HashingTestSuite.test("_mixUInt64/GoldenValues") {
- expectEqual(Int64(bitPattern: 0xb2b2_4f68_8dc4_164d as UInt64), _mixInt64(0x0))
-}
+HashingTestSuite.test("_Hasher/keyOverride") {
+ let value: UInt64 = 0x0102030405060708
+ let expected = Int(truncatingIfNeeded: 0x661dac5d71c78013 as UInt64)
-HashingTestSuite.test("_mixUInt/GoldenValues") {
-#if arch(i386) || arch(arm)
- expectEqual(0x11b8_82c9, _mixUInt(0x0))
-#elseif arch(x86_64) || arch(arm64) || arch(powerpc64) || arch(powerpc64le) || arch(s390x)
- expectEqual(0xb2b2_4f68_8dc4_164d, _mixUInt(0x0))
-#else
- fatalError("unimplemented")
-#endif
-}
+ let originalKey = _Hasher._secretKey
+ _Hasher._secretKey = (1, 2)
+ let hash = _hashValue(for: value)
+ _Hasher._secretKey = originalKey
-HashingTestSuite.test("_mixInt/GoldenValues") {
-#if arch(i386) || arch(arm)
- expectEqual(Int(bitPattern: 0x11b8_82c9 as UInt), _mixInt(0x0))
-#elseif arch(x86_64) || arch(arm64) || arch(powerpc64) || arch(powerpc64le) || arch(s390x)
- expectEqual(Int(bitPattern: 0xb2b2_4f68_8dc4_164d as UInt), _mixInt(0x0))
-#else
- fatalError("unimplemented")
-#endif
-}
-
-HashingTestSuite.test("_squeezeHashValue/Int") {
- // Check that the function can return values that cover the whole range.
- func checkRange(_ r: Int) {
- var results = Set<Int>()
- for _ in 0..<(14 * r) {
- let v = _squeezeHashValue(randInt(), r)
- expectTrue(v < r)
- results.insert(v)
- }
- expectEqual(r, results.count)
- }
- checkRange(1)
- checkRange(2)
- checkRange(4)
- checkRange(8)
- checkRange(16)
-}
-
-HashingTestSuite.test("String/hashValue/topBitsSet") {
-#if _runtime(_ObjC)
-#if arch(x86_64) || arch(arm64)
- // Make sure that we don't accidentally throw away bits by storing the result
- // of NSString.hash into an int in the runtime.
-
- // This is the bit pattern that we xor to NSString's hash value.
- let hashOffset = UInt(bitPattern: 0x429b_1266_0000_0000 as Int)
- let hash = "efghijkl".hashValue
- // When we are not equal to the top bit of the xor'ed hashOffset pattern
- // there where some bits set.
- let topHashBits = UInt(bitPattern: hash) & 0xffff_ffff_0000_0000
- expectTrue(hash > 0)
- expectTrue(topHashBits != hashOffset)
-#endif
-#endif
-}
-
-HashingTestSuite.test("overridePerExecutionHashSeed/overflow") {
- // Test that we don't use checked arithmetic on the seed.
- _HashingDetail.fixedSeedOverride = UInt64.max
- expectEqual(0x4344_dc3a_239c_3e81, _mixUInt64(0xffff_ffff_ffff_ffff))
- _HashingDetail.fixedSeedOverride = 0
+ expectEqual(hash, expected)
}
runAllTests()
diff --git a/validation-test/stdlib/HashingAvalanche.swift b/validation-test/stdlib/HashingAvalanche.swift
index 51b89da..09b3365 100644
--- a/validation-test/stdlib/HashingAvalanche.swift
+++ b/validation-test/stdlib/HashingAvalanche.swift
@@ -47,12 +47,12 @@
// White-box testing: assume that the other N-bit to N-bit mixing functions
// just dispatch to these. (Avalanche test is relatively expensive.)
-HashingTestSuite.test("_mixUInt64/avalanche") {
- avalancheTest(64, _mixUInt64, 0.02)
+HashingTestSuite.test("_Hasher.append(UInt64)/avalanche") {
+ avalancheTest(64, { UInt64(truncatingIfNeeded: _hashValue(for: $0)) }, 0.02)
}
-HashingTestSuite.test("_mixUInt32/avalanche") {
- avalancheTest(32, { UInt64(_mixUInt32(UInt32($0 & 0xffff_ffff))) }, 0.02)
+HashingTestSuite.test("_Hasher.append(UInt32)/avalanche") {
+ avalancheTest(32, { UInt64(truncatingIfNeeded: _hashValue(for: $0)) }, 0.02)
}
runAllTests()
diff --git a/validation-test/stdlib/SipHash.swift b/validation-test/stdlib/SipHash.swift
index cbf5edb..7bda072 100644
--- a/validation-test/stdlib/SipHash.swift
+++ b/validation-test/stdlib/SipHash.swift
@@ -243,12 +243,61 @@
#endif
}
+func loadPartialUnalignedUInt64LE(
+ from p: UnsafeRawPointer,
+ byteCount: Int
+) -> UInt64 {
+ _sanityCheck((0..<8).contains(byteCount))
+ var result: UInt64 = 0
+ if byteCount >= 1 { result |= UInt64(p.load(fromByteOffset: 0, as: UInt8.self)) }
+ if byteCount >= 2 { result |= UInt64(p.load(fromByteOffset: 1, as: UInt8.self)) &<< (8 as UInt64) }
+ if byteCount >= 3 { result |= UInt64(p.load(fromByteOffset: 2, as: UInt8.self)) &<< (16 as UInt64) }
+ if byteCount >= 4 { result |= UInt64(p.load(fromByteOffset: 3, as: UInt8.self)) &<< (24 as UInt64) }
+ if byteCount >= 5 { result |= UInt64(p.load(fromByteOffset: 4, as: UInt8.self)) &<< (32 as UInt64) }
+ if byteCount >= 6 { result |= UInt64(p.load(fromByteOffset: 5, as: UInt8.self)) &<< (40 as UInt64) }
+ if byteCount >= 7 { result |= UInt64(p.load(fromByteOffset: 6, as: UInt8.self)) &<< (48 as UInt64) }
+ return result
+}
+
+func loadPartialUnalignedUInt32LE(
+ from p: UnsafeRawPointer,
+ byteCount: Int
+) -> UInt32 {
+ _sanityCheck((0..<4).contains(byteCount))
+ var result: UInt32 = 0
+ if byteCount >= 1 { result |= UInt32(p.load(fromByteOffset: 0, as: UInt8.self)) }
+ if byteCount >= 2 { result |= UInt32(p.load(fromByteOffset: 1, as: UInt8.self)) &<< (8 as UInt32) }
+ if byteCount >= 3 { result |= UInt32(p.load(fromByteOffset: 2, as: UInt8.self)) &<< (16 as UInt32) }
+ return result
+}
+
+func loadPartialUnalignedUIntLE(
+ from p: UnsafeRawPointer,
+ byteCount: Int
+) -> UInt {
+#if arch(i386) || arch(arm)
+ return UInt(loadPartialUnalignedUInt32LE(from: p, byteCount: byteCount))
+#elseif arch(x86_64) || arch(arm64) || arch(powerpc64) || arch(powerpc64le) || arch(s390x)
+ return UInt(loadPartialUnalignedUInt64LE(from: p, byteCount: byteCount))
+#endif
+}
+
% for data_type in ['Int', 'Int64', 'Int32']:
func loadUnaligned${data_type}LE(
from p: UnsafeRawPointer
) -> ${data_type} {
return ${data_type}(bitPattern: loadUnalignedU${data_type}LE(from: p))
}
+
+func loadPartialUnaligned${data_type}LE(
+ from p: UnsafeRawPointer,
+ byteCount: Int
+) -> ${data_type} {
+ return ${data_type}(
+ bitPattern: loadPartialUnalignedU${data_type}LE(
+ from: p,
+ byteCount: byteCount))
+}
% end
% for data_type in ['UInt', 'Int', 'UInt64', 'Int64', 'UInt32', 'Int32']:
@@ -257,85 +306,45 @@
) -> ${data_type} {
return ${data_type}(littleEndian: loadUnaligned${data_type}LE(from: p))
}
+func loadPartialUnaligned${data_type}(
+ from p: UnsafeRawPointer,
+ byteCount: Int
+) -> ${data_type} {
+ return ${data_type}(littleEndian:
+ loadPartialUnaligned${data_type}LE(from: p, byteCount: byteCount))
+}
% end
% for (Self, tests) in [
-% ('_SipHash13Context', 'sipHash13Tests'),
-% ('_SipHash24Context', 'sipHash24Tests')
+% ('_SipHash13', 'sipHash13Tests'),
+% ('_SipHash24', 'sipHash24Tests')
% ]:
-SipHashTests.test("${Self}/Oneshot").forEach(in: ${tests}) {
- test in
-
- expectEqual(
- test.output,
- ${Self}.hash(
- data: test.input,
- dataByteCount: test.input.count,
- key: test.key))
-}
-
-SipHashTests.test("${Self}.append(UnsafeRawPointer)")
- .forEach(in: cartesianProduct(${tests}, incrementalPatterns)) {
- test_ in
- let (test, pattern) = test_
-
- var context = ${Self}(key: test.key)
- var startIndex = 0
- var chunkSizeIndex = 0
- while startIndex != test.input.endIndex {
- let chunkSize = min(
- pattern[chunkSizeIndex],
- test.input.endIndex - startIndex)
- context.append(
- Array(test.input[startIndex..<(startIndex+chunkSize)]),
- byteCount: chunkSize)
- startIndex += chunkSize
- chunkSizeIndex += 1
- chunkSizeIndex %= pattern.count
- }
- expectEqual(
- test.output,
- context.finalizeAndReturnHash())
-
- // Check that we can query the hash value more than once.
- expectEqual(
- test.output,
- context.finalizeAndReturnHash())
-}
-
% for data_type in ['UInt', 'Int', 'UInt64', 'Int64', 'UInt32', 'Int32']:
SipHashTests.test("${Self}.append(${data_type})").forEach(in: ${tests}) {
test in
- var context = ${Self}(key: test.key)
+ var hasher = ${Self}(key: test.key)
let chunkSize = MemoryLayout<${data_type}>.size
var startIndex = 0
let endIndex = test.input.count - (test.input.count % chunkSize)
while startIndex != endIndex {
- context.append(
+ hasher.append(
loadUnaligned${data_type}(
from: Array(
test.input[startIndex..<(startIndex+chunkSize)])))
startIndex += chunkSize
}
- context.append(
- Array(test.input.suffix(from: endIndex)),
- byteCount: test.input.count - endIndex)
-
- expectEqual(
- test.output,
- context.finalizeAndReturnHash())
+ let tailCount = test.input.count - endIndex
+ let hash = hasher.finalize(
+ tailBytes: loadPartialUnalignedUInt64(
+ from: Array(test.input.suffix(from: endIndex)),
+ byteCount: tailCount),
+ tailByteCount: tailCount)
+ expectEqual(test.output, hash)
}
% end
-
-SipHashTests.test("${Self}/AppendAfterFinalizing") {
- var context = ${Self}(key: (0, 0))
- _ = context.finalizeAndReturnHash()
- expectCrashLater()
- context.append([], byteCount: 0)
-}
% end
runAllTests()
