Merge pull request #23741 from xedin/verify-kp-subscript-hashable-via-solver
[CSSolver] Move keypath subscript index Hashable conformance verification to solver
diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index 1479ab9..6063c62 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -253,6 +253,10 @@
"-whole-module-optimization" "-num-threads" "4")
set(BENCHOPTS_SINGLEFILE "")
+option(SWIFT_BENCHMARK_USE_OS_LIBRARIES
+ "Runtime link against the Swift libraries on the target (/usr/lib/swift)."
+ FALSE)
+
configure_build()
#===-----------------------------------------------------------------------===#
@@ -268,10 +272,18 @@
message("--")
message("-- Swift Benchmark Suite:")
message("-- SWIFT_BENCHMARK_BUILT_STANDALONE = ${SWIFT_BENCHMARK_BUILT_STANDALONE}")
-message("-- SWIFT_EXEC = ${SWIFT_EXEC}")
-message("-- SWIFT_BENCHMARK_EXTRA_FLAGS = ${SWIFT_BENCHMARK_EXTRA_FLAGS}")
+message("-- SWIFT_BENCHMARK_USE_OS_LIBRARIES = ${SWIFT_BENCHMARK_USE_OS_LIBRARIES}")
+message("-- SWIFT_EXEC = ${SWIFT_EXEC}")
message("-- SWIFT_LIBRARY_PATH = ${SWIFT_LIBRARY_PATH}")
-message("-- CLANG_EXEC = ${CLANG_EXEC}")
+if (SWIFT_RPATH_BASE)
+message("-- SWIFT_RPATH_BASE = ${SWIFT_RPATH_BASE}")
+endif()
+if (SWIFT_RPATH)
+message("-- SWIFT_RPATH = ${SWIFT_RPATH}")
+message("--- ** WARNING ** Benchmarking against Swift-in-the-OS")
+endif()
+message("-- CLANG_EXEC = ${CLANG_EXEC}")
+message("-- SWIFT_BENCHMARK_EXTRA_FLAGS = ${SWIFT_BENCHMARK_EXTRA_FLAGS}")
message("-- SWIFT_OPTIMIZATION_LEVELS = ${SWIFT_OPTIMIZATION_LEVELS}")
message("-- ONLY_PLATFORMS = ${ONLY_PLATFORMS}")
message("-- PAGE_ALIGNMENT_OPTION = ${PAGE_ALIGNMENT_OPTION}")
diff --git a/benchmark/README.md b/benchmark/README.md
index 44ba62b..657863f 100644
--- a/benchmark/README.md
+++ b/benchmark/README.md
@@ -28,6 +28,11 @@
OS X benchmark driver binaries are placed in `bin` alongside `swiftc`.
Additional platform binaries are placed in the `benchmark/bin` build directory.
+The required Swift standard library dylibs are placed in `lib`. The
+drivers dynamically link Swift standard library dylibs from a path
+relative to their run-time location (../lib/swift) so the standard
+library should be distributed alongside them.
+
Building Independently
----------------------
@@ -43,15 +48,19 @@
* `-DSWIFT_LIBRARY_PATH`
* An absolute path to the Swift standard library to use during compilation
(default: `swiftc_directory`/../lib/swift)
+* `-DSWIFT_DARWIN_XCRUN_TOOLCHAIN`
+ * The Xcode toolchain to use when invoking `xcrun` to find `clang`.
+ (default: XcodeDefault)
* `-DONLY_PLATFORMS`
* A list of platforms to build the benchmarks for
(default: "macosx;iphoneos;appletvos;watchos")
* `-DSWIFT_OPTIMIZATION_LEVELS`
* A list of Swift optimization levels to build against
(default: "O;Onone;Osize")
-* `-DSWIFT_BENCHMARK_EMIT_SIB`
- * A boolean value indicating whether .sib files should be generated
- alongside .o files (default: FALSE)
+* `-DSWIFT_BENCHMARK_USE_OS_LIBRARIES`
+ * Enable this option to link the benchmark binaries against the target
+ machine's Swift standard library and runtime installed with the OS.
+ (default: OFF)
The following build targets are available:
@@ -66,13 +75,40 @@
1. `$ cd benchmark`
2. `$ mkdir build`
3. `$ cd build`
-4. `$ cmake ..`
-5. `$ make -j8 swift-benchmark-macosx-x86_64`
+4. `$ cmake ../benchmark -G Ninja -DSWIFT_EXEC=[path to built swiftc]`
+5. `$ ninja swift-benchmark-macosx-x86_64`
-Benchmark driver binaries are placed in `build/bin` and the required Swift
-standard library dylibs are placed in `build/lib`. The drivers dynamically link
-Swift standard library dylibs from a path relative to their location
-(../lib/swift) so the standard library should be distributed alongside them.
+Benchmark binaries are placed in `bin`.
+
+The binaries dynamically link Swift standard library dylibs from a
+path determined by the configuration. If `SWIFT_LIBRARY_PATH` is set,
+they link against the absolute path provided, regardless of where the
+binaries are installed. Otherwise, the runtime library path is
+relative to the benchmark binary at the time it was executed
+(`@executable_path/../lib/swift/<platform>`).
+
+For example, to benchmark against a locally built `swiftc`, including
+any standard library changes in that build, you might configure using:
+
+ cmake ../benchmark -G Ninja -DSWIFT_EXEC=<src>/swift/build/swift-macosx-x86_64/bin/swiftc
+ ninja swift-benchmark-iphoneos-arm64
+
+To build against the installed Xcode, simply omit SWIFT_EXEC:
+
+ cmake ../benchmark -G Ninja
+ ninja swift-benchmark-iphoneos-arm64
+
+In both examples above, to run the benchmarks on a device, the dynamic
+libraries must then be copied onto the device into the library path
+relative to `swiftc`. To benchmark against the target machine's
+installed libraries instead, enable
+`SWIFT_BENCHMARK_USE_OS_LIBRARIES`.
+
+ cmake ../benchmark -G Ninja -DSWIFT_BENCHMARK_USE_OS_LIBRARIES=ON
+ ninja swift-benchmark-iphoneos-arm64
+
+This will reflect the performance of the Swift standard library
+installed on the device, not the one included in the Swift root.
Using the Benchmark Driver
--------------------------
diff --git a/benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake b/benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake
index 953eeae..bc05c8f 100644
--- a/benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake
+++ b/benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake
@@ -24,6 +24,9 @@
if(${c_compiler} STREQUAL "clang")
set(CLANG_EXEC ${CMAKE_C_COMPILER})
else()
+ if(NOT SWIFT_DARWIN_XCRUN_TOOLCHAIN)
+ set(SWIFT_DARWIN_XCRUN_TOOLCHAIN "XcodeDefault")
+ endif()
runcmd(COMMAND "xcrun" "-toolchain" "${SWIFT_DARWIN_XCRUN_TOOLCHAIN}" "-f" "clang"
VARIABLE CLANG_EXEC
ERROR "Unable to find Clang driver")
@@ -57,12 +60,47 @@
endif()
endif()
- # We always infer the SWIFT_LIBRARY_PATH from SWIFT_EXEC unless
- # SWIFT_LIBRARY_PATH is specified explicitly.
- if(NOT SWIFT_LIBRARY_PATH)
- get_filename_component(tmp_dir "${SWIFT_EXEC}" DIRECTORY)
- get_filename_component(tmp_dir "${tmp_dir}" DIRECTORY)
- set(SWIFT_LIBRARY_PATH "${tmp_dir}/lib/swift")
+ # Set LIBRARY_PATH and either RPATH or RPATH_BASE. To build and run
+ # for multiple platforms, RPATH_BASE must be set instead of RPATH. It
+ # is the platform-independent runtime library directory. The platform
+ # subdirectory name will be appended to form a different RPATH for
+ # on platform.
+
+ # If requested, use Swift-in-the-OS. This way, the benchmarks may be built
+ # standalone on the host, and the binaries can run directly from a temp dir
+ # on any target machine. Of course, this factors out performance changes in
+ # stdlib or overlays.
+ if(SWIFT_BENCHMARK_USE_OS_LIBRARIES)
+ set(SWIFT_RPATH "/usr/lib/swift")
+ endif()
+
+ # When SWIFT_LIBRARY_PATH is specified explicitly for a standalone
+ # build, use it as an absolute RPATH_BASE. This only works when
+ # running benchmarks on the host machine. Otherwise, RPATH is set
+ # assuming that libraries will be installed later (manually)
+ # relative to the benchmark binaries.
+ #
+ # When not building standalone, SWIFT_LIBRARY_PATH is set by LLVM
+ # cmake to the build directory for Swift dylibs. Otherwise, assume
+ # that the dylibs are built relative to SWIFT_EXEC.
+ if(SWIFT_LIBRARY_PATH AND SWIFT_BENCHMARK_BUILT_STANDALONE)
+ if (NOT SWIFT_RPATH)
+ set(SWIFT_RPATH_BASE ${SWIFT_LIBRARY_PATH})
+ endif()
+ else()
+ if (NOT SWIFT_LIBRARY_PATH)
+ get_filename_component(tmp_dir "${SWIFT_EXEC}" DIRECTORY)
+ get_filename_component(tmp_dir "${tmp_dir}" DIRECTORY)
+ set(SWIFT_LIBRARY_PATH "${tmp_dir}/lib/swift")
+ endif()
+ if (NOT SWIFT_RPATH)
+ # If the benchmarks are built against a local swift build, assume that
+ # either the benchmarks will be installed in the swift build dir,
+ # or the swift libraries will be installed in the benchmark location in
+ # a platform specific subdirectory.
+ # This way, performance always factors in changes to the libraries.
+ set(SWIFT_RPATH_BASE "@executable_path/../lib/swift")
+ endif()
endif()
endmacro()
@@ -571,6 +609,11 @@
# both do exactly the same thing with both sets of arguments. It also lets us
# avoid issues around code-signing.
if (is_darwin)
+ if (SWIFT_RPATH)
+ set(SWIFT_LINK_RPATH "${SWIFT_RPATH}")
+ else()
+ set(SWIFT_LINK_RPATH "${SWIFT_RPATH_BASE}/${BENCH_COMPILE_ARCHOPTS_PLATFORM}")
+ endif()
add_custom_command(
OUTPUT "${OUTPUT_EXEC}"
DEPENDS
@@ -593,7 +636,7 @@
"-lobjc"
"-L${SWIFT_LIBRARY_PATH}/${BENCH_COMPILE_ARCHOPTS_PLATFORM}"
"-Xlinker" "-rpath"
- "-Xlinker" "@executable_path/../lib/swift/${BENCH_COMPILE_ARCHOPTS_PLATFORM}"
+ "-Xlinker" "${SWIFT_LINK_RPATH}"
${bench_library_objects}
${bench_driver_objects}
${SWIFT_BENCH_OBJFILES}
@@ -612,7 +655,7 @@
"${SWIFT_EXEC}"
"-O"
"-target" "${target}"
- "-L${SWIFT_LIBRARY_PATH}/${BENCH_COMPILE_ARCHOPTS_PLATFORM}"
+ "-L${SWIFT_LIBRARY_PATH}"
${bench_library_objects}
${bench_driver_objects}
${SWIFT_BENCH_OBJFILES}
diff --git a/benchmark/scripts/build_script_helper.py b/benchmark/scripts/build_script_helper.py
new file mode 100755
index 0000000..1cd61ce
--- /dev/null
+++ b/benchmark/scripts/build_script_helper.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+from __future__ import print_function
+
+import argparse
+import os
+import shutil
+import subprocess
+
+
+def perform_build(args, swiftbuild_path, config, binary_name, opt_flag):
+ assert(config in ['debug', 'release'])
+ assert(binary_name in ['Benchmark_O', 'Benchmark_Onone'])
+ assert(opt_flag in ['-O', '-Onone'])
+
+ inner_build_dir = os.path.join(args.build_path, binary_name)
+ swiftbuild_args = [
+ swiftbuild_path,
+ '--package-path', args.package_path,
+ '--build-path', inner_build_dir,
+ '--configuration', config,
+ '-Xswiftc', '-Xllvm',
+ '-Xswiftc', '-align-module-to-page-size',
+ '-Xswiftc', opt_flag,
+ ]
+ if args.verbose:
+ swiftbuild_args.append('--verbose')
+ subprocess.call(swiftbuild_args)
+
+ # Copy the benchmark file into the final ./bin directory.
+ binpath = os.path.join(inner_build_dir, config, 'SwiftBench')
+ finalpath = os.path.join(args.build_path, 'bin', binary_name)
+ shutil.copy(binpath, finalpath)
+
+
+def main():
+ parser = argparse.ArgumentParser()
+ parser.add_argument('--verbose', '-v', action='store_true')
+ parser.add_argument('--package-path', type=str, required=True)
+ parser.add_argument('--build-path', type=str, required=True)
+ parser.add_argument('--toolchain', type=str, required=True)
+
+ args = parser.parse_args()
+
+ # Create our bin directory so we can copy in the binaries.
+ bin_dir = os.path.join(args.build_path, 'bin')
+ if not os.path.isdir(bin_dir):
+ os.makedirs(bin_dir)
+
+ swiftbuild_path = os.path.join(args.toolchain, 'usr', 'bin', 'swift-build')
+ perform_build(args, swiftbuild_path, 'debug', 'Benchmark_Onone', '-Onone')
+ perform_build(args, swiftbuild_path, 'release', 'Benchmark_O', '-O')
+
+
+if __name__ == "__main__":
+ main()
diff --git a/benchmark/utils/build_script_helper.py b/benchmark/utils/build_script_helper.py
deleted file mode 100755
index e5b873f..0000000
--- a/benchmark/utils/build_script_helper.py
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/usr/bin/env python
-
-from __future__ import print_function
-
-import argparse
-import os
-import subprocess
-
-
-def main():
- parser = argparse.ArgumentParser()
- parser.add_argument('--verbose', '-v', action='store_true')
- parser.add_argument('--package-path', type=str, required=True)
- parser.add_argument('--build-path', type=str, required=True)
- parser.add_argument('--toolchain', type=str, required=True)
-
- # Build the debug/release versions.
- args = parser.parse_args()
- swiftbuild_path = os.path.join(args.toolchain, 'usr', 'bin', 'swift-build')
- swiftbuild_args = [
- swiftbuild_path,
- '--package-path', args.package_path,
- '--build-path', args.build_path,
- '--configuration', 'debug',
- ]
- if args.verbose:
- swiftbuild_args.append('--verbose')
- subprocess.call(swiftbuild_args)
-
- swiftbuild_args = [
- swiftbuild_path,
- '--package-path', args.package_path,
- '--build-path', args.build_path,
- '--configuration', 'release',
- '-Xswiftc', '-Xllvm',
- '-Xswiftc', '-align-module-to-page-size',
- ]
- if args.verbose:
- swiftbuild_args.append('--verbose')
- subprocess.call(swiftbuild_args)
-
-
-if __name__ == "__main__":
- main()
diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake
index f9e079e..368f717 100644
--- a/cmake/modules/AddSwift.cmake
+++ b/cmake/modules/AddSwift.cmake
@@ -1312,7 +1312,7 @@
# doing so will result in incorrect symbol resolution and linkage. We created
# import library targets when the library was added. Use that to adjust the
# link libraries.
- if(SWIFTLIB_SINGLE_SDK STREQUAL WINDOWS AND NOT CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
+ if(SWIFTLIB_SINGLE_SDK STREQUAL WINDOWS AND NOT CMAKE_SYSTEM_NAME STREQUAL Windows)
foreach(library_list LINK_LIBRARIES INTERFACE_LINK_LIBRARIES PRIVATE_LINK_LIBRARIES)
set(import_libraries)
foreach(library ${SWIFTLIB_SINGLE_${library_list}})
diff --git a/cmake/modules/SwiftComponents.cmake b/cmake/modules/SwiftComponents.cmake
index a637e31..cae4d32 100644
--- a/cmake/modules/SwiftComponents.cmake
+++ b/cmake/modules/SwiftComponents.cmake
@@ -84,6 +84,7 @@
else()
list(REMOVE_ITEM _SWIFT_DEFAULT_COMPONENTS "sourcekit-xpc-service")
endif()
+list(REMOVE_ITEM _SWIFT_DEFAULT_COMPONENTS "stdlib-experimental")
macro(swift_configure_components)
# Set the SWIFT_INSTALL_COMPONENTS variable to the default value if it is not passed in via -D
diff --git a/cmake/modules/SwiftSharedCMakeConfig.cmake b/cmake/modules/SwiftSharedCMakeConfig.cmake
index 76a731b..790d6cb 100644
--- a/cmake/modules/SwiftSharedCMakeConfig.cmake
+++ b/cmake/modules/SwiftSharedCMakeConfig.cmake
@@ -62,32 +62,34 @@
set(${product}_NATIVE_LLVM_TOOLS_PATH "${LLVM_TOOLS_BINARY_DIR}")
endif()
- if(CMAKE_CROSSCOMPILING)
- set(LLVM_NATIVE_BUILD_DIR "${LLVM_BINARY_DIR}/NATIVE")
- if(NOT EXISTS "${LLVM_NATIVE_BUILD_DIR}")
- message(FATAL_ERROR
- "Attempting to cross-compile swift standalone but no native LLVM build
- found. Please cross-compile LLVM as well.")
- endif()
+ if(SWIFT_INCLUDE_TOOLS)
+ if(CMAKE_CROSSCOMPILING)
+ set(LLVM_NATIVE_BUILD_DIR "${LLVM_BINARY_DIR}/NATIVE")
+ if(NOT EXISTS "${LLVM_NATIVE_BUILD_DIR}")
+ message(FATAL_ERROR
+ "Attempting to cross-compile swift standalone but no native LLVM build
+ found. Please cross-compile LLVM as well.")
+ endif()
- if(CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
- set(HOST_EXECUTABLE_SUFFIX ".exe")
- endif()
+ if(CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
+ set(HOST_EXECUTABLE_SUFFIX ".exe")
+ endif()
- if(NOT CMAKE_CONFIGURATION_TYPES)
- set(LLVM_TABLEGEN_EXE
- "${LLVM_NATIVE_BUILD_DIR}/bin/llvm-tblgen${HOST_EXECUTABLE_SUFFIX}")
+ if(NOT CMAKE_CONFIGURATION_TYPES)
+ set(LLVM_TABLEGEN_EXE
+ "${LLVM_NATIVE_BUILD_DIR}/bin/llvm-tblgen${HOST_EXECUTABLE_SUFFIX}")
+ else()
+ # NOTE: LLVM NATIVE build is always built Release, as is specified in
+ # CrossCompile.cmake
+ set(LLVM_TABLEGEN_EXE
+ "${LLVM_NATIVE_BUILD_DIR}/Release/bin/llvm-tblgen${HOST_EXECUTABLE_SUFFIX}")
+ endif()
else()
- # NOTE: LLVM NATIVE build is always built Release, as is specified in
- # CrossCompile.cmake
- set(LLVM_TABLEGEN_EXE
- "${LLVM_NATIVE_BUILD_DIR}/Release/bin/llvm-tblgen${HOST_EXECUTABLE_SUFFIX}")
- endif()
- else()
- find_program(LLVM_TABLEGEN_EXE "llvm-tblgen" HINTS ${LLVM_TOOLS_BINARY_DIR}
- NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
- if(LLVM_TABLEGEN_EXE STREQUAL "LLVM_TABLEGEN_EXE-NOTFOUND")
- message(FATAL_ERROR "Failed to find tablegen in ${LLVM_TOOLS_BINARY_DIR}")
+ find_program(LLVM_TABLEGEN_EXE "llvm-tblgen" HINTS ${LLVM_TOOLS_BINARY_DIR}
+ NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+ if(LLVM_TABLEGEN_EXE STREQUAL "LLVM_TABLEGEN_EXE-NOTFOUND")
+ message(FATAL_ERROR "Failed to find tablegen in ${LLVM_TOOLS_BINARY_DIR}")
+ endif()
endif()
endif()
diff --git a/docs/WindowsBuild.md b/docs/WindowsBuild.md
index afc01ac..0f6d4fd 100644
--- a/docs/WindowsBuild.md
+++ b/docs/WindowsBuild.md
@@ -359,6 +359,7 @@
```cmd
md S:\b\llbuild
cd S:\b\llbuild
+set AR=llvm-ar
cmake -G Ninja^
-DCMAKE_BUILD_TYPE=RelWithDebInfo^
-DCMAKE_C_COMPILER=cl^
diff --git a/include/swift/AST/DiagnosticsParse.def b/include/swift/AST/DiagnosticsParse.def
index 056beca..03320e3 100644
--- a/include/swift/AST/DiagnosticsParse.def
+++ b/include/swift/AST/DiagnosticsParse.def
@@ -1377,21 +1377,6 @@
"unexpected version number in '%0' attribute for non-specific platform "
"'*'", (StringRef))
-// autoclosure
-ERROR(attr_autoclosure_expected_r_paren,PointsToFirstBadToken,
- "expected ')' in @autoclosure", ())
-ERROR(attr_noescape_conflicts_escaping_autoclosure,none,
- "@noescape conflicts with @autoclosure(escaping)", ())
-ERROR(attr_noescape_implied_by_autoclosure,none,
- "@noescape is implied by @autoclosure and should not be "
- "redundantly specified", ())
-ERROR(attr_autoclosure_escaping_deprecated,none,
- "@autoclosure(escaping) has been removed; use @autoclosure @escaping instead",
- ())
-ERROR(attr_noescape_deprecated,none,
- "@noescape is the default and has been removed",
- ())
-
// convention
ERROR(convention_attribute_expected_lparen,none,
"expected '(' after 'convention' attribute", ())
diff --git a/include/swift/AST/DiagnosticsSIL.def b/include/swift/AST/DiagnosticsSIL.def
index 8943975..180a9cd 100644
--- a/include/swift/AST/DiagnosticsSIL.def
+++ b/include/swift/AST/DiagnosticsSIL.def
@@ -116,6 +116,33 @@
ERROR(objc_selector_malformed,none,"the type ObjectiveC.Selector is malformed",
())
+// Invalid escaping capture diagnostics.
+ERROR(escaping_inout_capture,none,
+ "escaping closure captures 'inout' parameter %0", (Identifier))
+NOTE(inout_param_defined_here,none,
+ "parameter %0 is declared 'inout'", (Identifier))
+ERROR(escaping_mutable_self_capture,none,
+ "escaping closure captures mutating 'self' parameter", ())
+
+ERROR(escaping_noescape_param_capture,none,
+ "escaping closure captures non-escaping parameter %0", (Identifier))
+NOTE(noescape_param_defined_here,none,
+ "parameter %0 is implicitly non-escaping", (Identifier))
+
+ERROR(escaping_noescape_var_capture,none,
+ "escaping closure captures non-escaping value", ())
+
+NOTE(value_captured_here,none,"captured here", ())
+
+NOTE(value_captured_transitively,none,
+ "captured indirectly by this call", ())
+
+ERROR(err_noescape_param_call,none,
+ "passing a %select{|closure which captures a }1non-escaping function "
+ "parameter %0 to a call to a non-escaping function parameter can allow "
+ "re-entrant modification of a variable",
+ (DeclName, unsigned))
+
// Definite initialization diagnostics.
NOTE(variable_defined_here,none,
"%select{variable|constant}0 defined here", (bool))
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
index f2bf2c6..cdc22f3 100644
--- a/include/swift/AST/DiagnosticsSema.def
+++ b/include/swift/AST/DiagnosticsSema.def
@@ -289,11 +289,6 @@
"declared closure result %0 is incompatible with contextual type %1",
(Type, Type))
-ERROR(err_noescape_param_call,none,
- "passing a %select{|closure which captures a }1non-escaping function "
- "parameter %0 to a call to a non-escaping function parameter can allow "
- "re-entrant modification of a variable",
- (DeclName, unsigned))
ERROR(cannot_call_function_value,none,
"cannot invoke value of function type with argument list '%0'",
(StringRef))
@@ -2900,21 +2895,6 @@
"%0, declared here, captures %1",
(Identifier, Identifier))
-ERROR(closure_implicit_capture_without_noescape,none,
- "escaping closures can only capture inout parameters explicitly by value",
- ())
-ERROR(closure_implicit_capture_mutating_self,none,
- "escaping closure cannot capture a mutating self parameter",
- ())
-NOTE(create_mutating_copy_or_capture_self,none,
- "create a mutating copy of self, or explicitly capture self for immutability",
- ())
-ERROR(nested_function_with_implicit_capture_argument,none,
- "nested function with %select{an |}0implicitly captured inout "
- "parameter%select{|s}0 can only be used as a non-escaping argument", (bool))
-ERROR(nested_function_escaping_inout_capture,none,
- "nested function cannot capture inout parameter and escape", ())
-
WARNING(recursive_accessor_reference,none,
"attempting to %select{access|modify}1 %0 within its own "
"%select{getter|setter}1", (Identifier, bool))
@@ -3039,19 +3019,10 @@
NOTE(silence_debug_description_in_interpolation_segment_call,none,
"use 'String(describing:)' to silence this warning", ())
-ERROR(invalid_noescape_use,none,
- "non-escaping %select{value|parameter}1 %0 may only be called",
- (Identifier, bool))
NOTE(noescape_parameter,none,
"parameter %0 is implicitly non-escaping",
(Identifier))
-ERROR(closure_noescape_use,none,
- "closure use of non-escaping parameter %0 may allow it to escape",
- (Identifier))
-ERROR(decl_closure_noescape_use,none,
- "declaration closing over non-escaping parameter %0 may allow it to escape",
- (Identifier))
ERROR(passing_noescape_to_escaping,none,
"passing non-escaping parameter %0 to function expecting an @escaping closure",
(Identifier))
@@ -3524,8 +3495,6 @@
// Functions
ERROR(attribute_requires_function_type,none,
"@%0 attribute only applies to function types", (StringRef))
-ERROR(attribute_not_supported,none,
- "this attribute is not supported", ())
ERROR(unsupported_convention,none,
"convention '%0' not supported", (StringRef))
ERROR(unreferenced_generic_parameter,none,
diff --git a/include/swift/AST/Pattern.h b/include/swift/AST/Pattern.h
index 869fd2b..e5655da 100644
--- a/include/swift/AST/Pattern.h
+++ b/include/swift/AST/Pattern.h
@@ -221,7 +221,9 @@
void print(llvm::raw_ostream &OS,
const PrintOptions &Options = PrintOptions()) const;
- void dump() const;
+ LLVM_ATTRIBUTE_DEPRECATED(
+ void dump() const LLVM_ATTRIBUTE_USED,
+ "only for use within the debugger");
/// walk - This recursively walks the AST rooted at this pattern.
Pattern *walk(ASTWalker &walker);
diff --git a/include/swift/AST/TypeRepr.h b/include/swift/AST/TypeRepr.h
index 188dc2f..e31d9f7 100644
--- a/include/swift/AST/TypeRepr.h
+++ b/include/swift/AST/TypeRepr.h
@@ -160,7 +160,9 @@
void print(raw_ostream &OS, const PrintOptions &Opts = PrintOptions()) const;
void print(ASTPrinter &Printer, const PrintOptions &Opts) const;
- void dump() const;
+ LLVM_ATTRIBUTE_DEPRECATED(
+ void dump() const LLVM_ATTRIBUTE_USED,
+ "only for use within the debugger");
/// Clone the given type representation.
TypeRepr *clone(const ASTContext &ctx) const;
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
index af96e0e..0c49b95 100644
--- a/include/swift/AST/Types.h
+++ b/include/swift/AST/Types.h
@@ -622,10 +622,14 @@
return getRecursiveProperties().isLValue();
}
- /// Is a type with these properties materializable: that is, is it a
- /// first-class value type?
+ /// Is this a first-class value type, meaning it is not an InOutType or a
+ /// tuple type containing an InOutType?
bool isMaterializable();
+ /// Is this a non-escaping type, that is, a non-escaping function type or a
+ /// tuple type containing a non-escaping type?
+ bool isNoEscape() const;
+
/// Determine whether the type is dependent on DynamicSelf.
bool hasDynamicSelfType() const {
return getRecursiveProperties().hasDynamicSelf();
@@ -647,11 +651,6 @@
return getRecursiveProperties().hasDependentMember();
}
- /// Check if this type is a valid type for the LHS of an assignment.
- /// This mainly means hasLValueType(), but empty tuples and tuples of empty
- /// tuples also qualify.
- bool isAssignableType();
-
/// isExistentialType - Determines whether this type is an existential type,
/// whose real (runtime) type is unknown but which is known to conform to
/// some set of protocols. Protocol and protocol-conformance types are
diff --git a/include/swift/Migrator/FixitFilter.h b/include/swift/Migrator/FixitFilter.h
index b6c64d6..cf5e705 100644
--- a/include/swift/Migrator/FixitFilter.h
+++ b/include/swift/Migrator/FixitFilter.h
@@ -127,8 +127,6 @@
Info.ID == diag::where_inside_brackets.ID ||
Info.ID == diag::selector_construction_suggest.ID ||
Info.ID == diag::selector_literal_deprecated_suggest.ID ||
- Info.ID == diag::attr_noescape_deprecated.ID ||
- Info.ID == diag::attr_autoclosure_escaping_deprecated.ID ||
Info.ID == diag::attr_warn_unused_result_removed.ID ||
Info.ID == diag::any_as_anyobject_fixit.ID ||
Info.ID == diag::deprecated_protocol_composition.ID ||
diff --git a/include/swift/Reflection/ReflectionContext.h b/include/swift/Reflection/ReflectionContext.h
index 84392c1..656ff88 100644
--- a/include/swift/Reflection/ReflectionContext.h
+++ b/include/swift/Reflection/ReflectionContext.h
@@ -202,7 +202,7 @@
RangeEnd - RangeStart);
auto findMachOSectionByName = [&](std::string Name)
- -> std::pair<std::pair<const char *, const char *>, uint64_t> {
+ -> std::pair<const char *, const char *> {
for (unsigned I = 0; I < NumSect; ++I) {
auto S = reinterpret_cast<typename T::Section *>(
SectionsBuf + (I * sizeof(typename T::Section)));
@@ -213,9 +213,9 @@
auto LocalSectStart =
reinterpret_cast<const char *>(SectBufData + RemoteSecStart - RangeStart);
auto LocalSectEnd = reinterpret_cast<const char *>(LocalSectStart + S->size);
- return {{LocalSectStart, LocalSectEnd}, 0};
+ return {LocalSectStart, LocalSectEnd};
}
- return {{nullptr, nullptr}, 0};
+ return {nullptr, nullptr};
};
auto FieldMdSec = findMachOSectionByName("__swift5_fieldmd");
@@ -225,24 +225,24 @@
auto TypeRefMdSec = findMachOSectionByName("__swift5_typeref");
auto ReflStrMdSec = findMachOSectionByName("__swift5_reflstr");
- if (FieldMdSec.first.first == nullptr &&
- AssocTySec.first.first == nullptr &&
- BuiltinTySec.first.first == nullptr &&
- CaptureSec.first.first == nullptr &&
- TypeRefMdSec.first.first == nullptr &&
- ReflStrMdSec.first.first == nullptr)
+ if (FieldMdSec.first == nullptr &&
+ AssocTySec.first == nullptr &&
+ BuiltinTySec.first == nullptr &&
+ CaptureSec.first == nullptr &&
+ TypeRefMdSec.first == nullptr &&
+ ReflStrMdSec.first == nullptr)
return false;
auto LocalStartAddress = reinterpret_cast<uint64_t>(SectBuf.get());
auto RemoteStartAddress = static_cast<uint64_t>(RangeStart);
ReflectionInfo info = {
- {{FieldMdSec.first.first, FieldMdSec.first.second}, 0},
- {{AssocTySec.first.first, AssocTySec.first.second}, 0},
- {{BuiltinTySec.first.first, BuiltinTySec.first.second}, 0},
- {{CaptureSec.first.first, CaptureSec.first.second}, 0},
- {{TypeRefMdSec.first.first, TypeRefMdSec.first.second}, 0},
- {{ReflStrMdSec.first.first, ReflStrMdSec.first.second}, 0},
+ {{FieldMdSec.first, FieldMdSec.second}, 0},
+ {{AssocTySec.first, AssocTySec.second}, 0},
+ {{BuiltinTySec.first, BuiltinTySec.second}, 0},
+ {{CaptureSec.first, CaptureSec.second}, 0},
+ {{TypeRefMdSec.first, TypeRefMdSec.second}, 0},
+ {{ReflStrMdSec.first, ReflStrMdSec.second}, 0},
LocalStartAddress,
RemoteStartAddress};
@@ -310,7 +310,7 @@
sizeof(llvm::object::coff_section) * COFFFileHdr->NumberOfSections);
auto findCOFFSectionByName = [&](llvm::StringRef Name)
- -> std::pair<std::pair<const char *, const char *>, uint32_t> {
+ -> std::pair<const char *, const char *> {
for (size_t i = 0; i < COFFFileHdr->NumberOfSections; ++i) {
const llvm::object::coff_section *COFFSec =
reinterpret_cast<const llvm::object::coff_section *>(
@@ -336,45 +336,43 @@
End -= 8;
}
- return {{Begin, End}, 0};
+ return {Begin, End};
}
- return {{nullptr, nullptr}, 0};
+ return {nullptr, nullptr};
};
- std::pair<std::pair<const char *, const char *>, uint32_t> CaptureSec =
+ std::pair<const char *, const char *> CaptureSec =
findCOFFSectionByName(".sw5cptr");
- std::pair<std::pair<const char *, const char *>, uint32_t> TypeRefMdSec =
+ std::pair<const char *, const char *> TypeRefMdSec =
findCOFFSectionByName(".sw5tyrf");
- std::pair<std::pair<const char *, const char *>, uint32_t> FieldMdSec =
+ std::pair<const char *, const char *> FieldMdSec =
findCOFFSectionByName(".sw5flmd");
- std::pair<std::pair<const char *, const char *>, uint32_t> AssocTySec =
+ std::pair<const char *, const char *> AssocTySec =
findCOFFSectionByName(".sw5asty");
- std::pair<std::pair<const char *, const char *>, uint32_t> BuiltinTySec =
+ std::pair<const char *, const char *> BuiltinTySec =
findCOFFSectionByName(".sw5bltn");
- std::pair<std::pair<const char *, const char *>, uint32_t> ReflStrMdSec =
+ std::pair<const char *, const char *> ReflStrMdSec =
findCOFFSectionByName(".sw5rfst");
- if (FieldMdSec.first.first == nullptr &&
- AssocTySec.first.first == nullptr &&
- BuiltinTySec.first.first == nullptr &&
- CaptureSec.first.first == nullptr &&
- TypeRefMdSec.first.first == nullptr &&
- ReflStrMdSec.first.first == nullptr)
+ if (FieldMdSec.first == nullptr &&
+ AssocTySec.first == nullptr &&
+ BuiltinTySec.first == nullptr &&
+ CaptureSec.first == nullptr &&
+ TypeRefMdSec.first == nullptr &&
+ ReflStrMdSec.first == nullptr)
return false;
+
auto LocalStartAddress = reinterpret_cast<uintptr_t>(DOSHdrBuf.get());
auto RemoteStartAddress =
static_cast<uintptr_t>(ImageStart.getAddressData());
ReflectionInfo Info = {
- {{FieldMdSec.first.first, FieldMdSec.first.second}, FieldMdSec.second},
- {{AssocTySec.first.first, AssocTySec.first.second}, AssocTySec.second},
- {{BuiltinTySec.first.first, BuiltinTySec.first.second},
- BuiltinTySec.second},
- {{CaptureSec.first.first, CaptureSec.first.second}, CaptureSec.second},
- {{TypeRefMdSec.first.first, TypeRefMdSec.first.second},
- TypeRefMdSec.second},
- {{ReflStrMdSec.first.first, ReflStrMdSec.first.second},
- ReflStrMdSec.second},
+ {{FieldMdSec.first, FieldMdSec.second}, 0},
+ {{AssocTySec.first, AssocTySec.second}, 0},
+ {{BuiltinTySec.first, BuiltinTySec.second}, 0},
+ {{CaptureSec.first, CaptureSec.second}, 0},
+ {{TypeRefMdSec.first, TypeRefMdSec.second}, 0},
+ {{ReflStrMdSec.first, ReflStrMdSec.second}, 0},
LocalStartAddress,
RemoteStartAddress};
this->addReflectionInfo(Info);
@@ -450,7 +448,7 @@
auto StrTab = reinterpret_cast<const char *>(StrTabBuf.get());
auto findELFSectionByName = [&](std::string Name)
- -> std::pair<std::pair<const char *, const char *>, uint64_t> {
+ -> std::pair<const char *, const char *> {
// Now for all the sections, find their name.
for (const typename T::Section *Hdr : SecHdrVec) {
uint32_t Offset = Hdr->sh_name;
@@ -462,9 +460,9 @@
auto SecSize = Hdr->sh_size;
auto SecBuf = this->getReader().readBytes(SecStart, SecSize);
auto SecContents = reinterpret_cast<const char *>(SecBuf.get());
- return {{SecContents, SecContents + SecSize}, 0};
+ return {SecContents, SecContents + SecSize};
}
- return {{nullptr, nullptr}, 0};
+ return {nullptr, nullptr};
};
auto FieldMdSec = findELFSectionByName("swift5_fieldmd");
@@ -476,12 +474,12 @@
// We succeed if at least one of the sections is present in the
// ELF executable.
- if (FieldMdSec.first.first == nullptr &&
- AssocTySec.first.first == nullptr &&
- BuiltinTySec.first.first == nullptr &&
- CaptureSec.first.first == nullptr &&
- TypeRefMdSec.first.first == nullptr &&
- ReflStrMdSec.first.first == nullptr)
+ if (FieldMdSec.first == nullptr &&
+ AssocTySec.first == nullptr &&
+ BuiltinTySec.first == nullptr &&
+ CaptureSec.first == nullptr &&
+ TypeRefMdSec.first == nullptr &&
+ ReflStrMdSec.first == nullptr)
return false;
auto LocalStartAddress = reinterpret_cast<uint64_t>(Buf.get());
@@ -489,15 +487,12 @@
static_cast<uint64_t>(ImageStart.getAddressData());
ReflectionInfo info = {
- {{FieldMdSec.first.first, FieldMdSec.first.second}, FieldMdSec.second},
- {{AssocTySec.first.first, AssocTySec.first.second}, AssocTySec.second},
- {{BuiltinTySec.first.first, BuiltinTySec.first.second},
- BuiltinTySec.second},
- {{CaptureSec.first.first, CaptureSec.first.second}, CaptureSec.second},
- {{TypeRefMdSec.first.first, TypeRefMdSec.first.second},
- TypeRefMdSec.second},
- {{ReflStrMdSec.first.first, ReflStrMdSec.first.second},
- ReflStrMdSec.second},
+ {{FieldMdSec.first, FieldMdSec.second}, 0},
+ {{AssocTySec.first, AssocTySec.second}, 0},
+ {{BuiltinTySec.first, BuiltinTySec.second}, 0},
+ {{CaptureSec.first, CaptureSec.second}, 0},
+ {{TypeRefMdSec.first, TypeRefMdSec.second}, 0},
+ {{ReflStrMdSec.first, ReflStrMdSec.second}, 0},
LocalStartAddress,
RemoteStartAddress};
diff --git a/include/swift/SIL/SILLocation.h b/include/swift/SIL/SILLocation.h
index 126bb60..1a86a4d 100644
--- a/include/swift/SIL/SILLocation.h
+++ b/include/swift/SIL/SILLocation.h
@@ -687,6 +687,8 @@
: SILLocation(D, MandatoryInlinedKind, F) {}
MandatoryInlinedLocation(SourceLoc L, unsigned F)
: SILLocation(L, MandatoryInlinedKind, F) {}
+ MandatoryInlinedLocation(DebugLoc L, unsigned F)
+ : SILLocation(L, MandatoryInlinedKind, F) {}
};
/// Used on the instruction performing auto-generated cleanup such as
diff --git a/include/swift/SILOptimizer/PassManager/Passes.def b/include/swift/SILOptimizer/PassManager/Passes.def
index 605e470..e048e0b 100644
--- a/include/swift/SILOptimizer/PassManager/Passes.def
+++ b/include/swift/SILOptimizer/PassManager/Passes.def
@@ -134,6 +134,8 @@
"Indirect Call Devirtualization")
PASS(DiagnoseInfiniteRecursion, "diagnose-infinite-recursion",
"Diagnose Infinitely-Recursive Code")
+PASS(DiagnoseInvalidEscapingCaptures, "diagnose-invalid-escaping-captures",
+ "Diagnose Invalid Escaping Captures")
PASS(DiagnoseStaticExclusivity, "diagnose-static-exclusivity",
"Static Enforcement of Law of Exclusivity")
PASS(DiagnoseUnreachable, "diagnose-unreachable",
diff --git a/include/swift/SILOptimizer/Utils/PerformanceInlinerUtils.h b/include/swift/SILOptimizer/Utils/PerformanceInlinerUtils.h
index 27da047..6a6e221 100644
--- a/include/swift/SILOptimizer/Utils/PerformanceInlinerUtils.h
+++ b/include/swift/SILOptimizer/Utils/PerformanceInlinerUtils.h
@@ -312,6 +312,7 @@
SILLoopInfo *LI;
llvm::DenseMap<const SILBasicBlock *, BlockInfo *> BlockInfos;
std::vector<BlockInfo> BlockInfoStorage;
+ bool valid = false;
BlockInfo *getBlockInfo(const SILBasicBlock *BB) {
BlockInfo *BI = BlockInfos[BB];
@@ -381,15 +382,22 @@
public:
ShortestPathAnalysis(SILFunction *F, SILLoopInfo *LI) : F(F), LI(LI) { }
- bool isValid() const { return !BlockInfos.empty(); }
+ bool isValid() const { return valid; }
/// Compute the distances. The function \p getApplyLength returns the length
/// of a function call.
template <typename Func>
void analyze(ColdBlockInfo &CBI, Func getApplyLength) {
assert(!isValid());
+ valid = true;
+ unsigned numBlocks = F->size();
- BlockInfoStorage.resize(F->size());
+ // As the complexity of the analysis is more than linear with the number of blocks,
+ // disable it for huge functions. In this case inlining will be less aggressive.
+ if (numBlocks > 2000)
+ return;
+
+ BlockInfoStorage.resize(numBlocks);
// First step: compute the length of the blocks.
unsigned BlockIdx = 0;
@@ -433,6 +441,11 @@
/// shortest path in the function.
int getScopeLength(SILBasicBlock *BB, int LoopDepth) {
assert(BB->getParent() == F);
+
+ // Return a conservative default if the analysis was not done due to a high number of blocks.
+ if (BlockInfos.empty())
+ return ColdBlockLength;
+
if (LoopDepth >= MaxNumLoopLevels)
LoopDepth = MaxNumLoopLevels - 1;
return getBlockInfo(BB)->getScopeLength(LoopDepth);
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
index cd4581f..a6a1d45 100644
--- a/lib/AST/ASTPrinter.cpp
+++ b/lib/AST/ASTPrinter.cpp
@@ -985,6 +985,33 @@
printTypeLoc(TP->getTypeLoc());
}
+/// Determines if we are required to print the name of a property declaration,
+/// or if we can elide it by printing a '_' instead.
+static bool mustPrintPropertyName(VarDecl *decl, PrintOptions opts) {
+ // If we're not allowed to omit the name, we must print it.
+ if (!opts.OmitNameOfInaccessibleProperties) return true;
+
+ // If it contributes to the parent's storage, we must print it because clients
+ // need to be able to directly access the storage.
+ // FIXME: We might be able to avoid printing names for some of these
+ // if we serialized references to them using field indices.
+ if (contributesToParentTypeStorage(decl)) return true;
+
+ // If it's public or @usableFromInline, we must print the name because it's a
+ // visible entry-point.
+ if (isPublicOrUsableFromInline(decl)) return true;
+
+ // If it has an initial value, we must print the name because it's used in
+ // the mangled name of the initializer expression generator function.
+ // FIXME: We _could_ figure out a way to generate an entry point
+ // for the initializer expression without revealing the name. We just
+ // don't have a mangling for it.
+ if (decl->hasInitialValue()) return true;
+
+ // If none of those are true, we can elide the name of the variable.
+ return false;
+}
+
void PrintAST::printPattern(const Pattern *pattern) {
switch (pattern->getKind()) {
case PatternKind::Any:
@@ -995,16 +1022,13 @@
auto named = cast<NamedPattern>(pattern);
auto decl = named->getDecl();
recordDeclLoc(decl, [&]{
- if (Options.OmitNameOfInaccessibleProperties &&
- contributesToParentTypeStorage(decl) &&
- !isPublicOrUsableFromInline(decl) &&
- // FIXME: We need to figure out a way to generate an entry point
- // for the initializer expression without revealing the name.
- !decl->hasInitialValue())
- Printer << "_";
- else
+ // FIXME: This always returns true now, because of the FIXMEs listed in
+ // mustPrintPropertyName.
+ if (mustPrintPropertyName(decl, Options))
Printer.printName(named->getBoundName());
- });
+ else
+ Printer << "_";
+ });
break;
}
diff --git a/lib/AST/DeclContext.cpp b/lib/AST/DeclContext.cpp
index 81c5283..748dde7 100644
--- a/lib/AST/DeclContext.cpp
+++ b/lib/AST/DeclContext.cpp
@@ -309,7 +309,8 @@
/// domains, this ensures that only sufficiently-conservative access patterns
/// are used.
ResilienceExpansion DeclContext::getResilienceExpansion() const {
- for (const auto *dc = this; dc->isLocalContext(); dc = dc->getParent()) {
+ for (const auto *dc = getLocalContext(); dc && dc->isLocalContext();
+ dc = dc->getParent()) {
// Default argument initializer contexts have their resilience expansion
// set when they're type checked.
if (isa<DefaultArgumentInitializer>(dc)) {
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
index 59226e5..da9a401 100644
--- a/lib/AST/Type.cpp
+++ b/lib/AST/Type.cpp
@@ -543,19 +543,6 @@
return false;
}
-
-bool TypeBase::isAssignableType() {
- if (hasLValueType()) return true;
- if (auto tuple = getAs<TupleType>()) {
- for (auto eltType : tuple->getElementTypes()) {
- if (!eltType->isAssignableType())
- return false;
- }
- return true;
- }
- return false;
-}
-
Type TypeBase::getRValueType() {
// If the type is not an lvalue, this is a no-op.
if (!hasLValueType())
@@ -3079,6 +3066,24 @@
return unresolvedDepMemTy;
}
+bool TypeBase::isNoEscape() const {
+ auto type = getCanonicalType();
+
+ if (auto silFuncTy = dyn_cast<SILFunctionType>(type))
+ return silFuncTy->isNoEscape();
+
+ if (auto funcTy = dyn_cast<FunctionType>(type))
+ return funcTy->isNoEscape();
+
+ if (auto tupleTy = dyn_cast<TupleType>(type)) {
+ for (auto eltTy : tupleTy.getElementTypes())
+ if (eltTy->isNoEscape())
+ return true;
+ }
+
+ return false;
+}
+
static Type getConcreteTypeForSuperclassTraversing(Type t) {
if (t->isExistentialType()) {
return t->getExistentialLayout().getSuperclass();
diff --git a/lib/ClangImporter/ImportType.cpp b/lib/ClangImporter/ImportType.cpp
index 15222c1..5752c36 100644
--- a/lib/ClangImporter/ImportType.cpp
+++ b/lib/ClangImporter/ImportType.cpp
@@ -515,6 +515,7 @@
type->getElementType(), ImportTypeKind::Abstract,
false /* No NSUIntegerAsInt */, Bridgeability::None,
OptionalTypeKind::OTK_None);
+ if (!element) { return Type(); }
unsigned count = type->getNumElements();
// Import vector-of-one as the element type.
if (count == 1) { return element; }
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
index 3fa1141..8d1f51c 100644
--- a/lib/Parse/ParseDecl.cpp
+++ b/lib/Parse/ParseDecl.cpp
@@ -1999,31 +1999,10 @@
StringRef Text = Tok.getText();
SourceLoc Loc = consumeToken();
- bool isAutoclosureEscaping = false;
- SourceRange autoclosureEscapingParenRange;
StringRef conventionName;
StringRef witnessMethodProtocol;
- // Handle @autoclosure(escaping)
- if (attr == TAK_autoclosure) {
- // We need to do a bit of lookahead here to make sure we parse a (weird)
- // type like: "@autoclosure (escaping) -> Int" correctly (escaping is the
- // name of a type here). We also want to support the case where the
- // function type coming up is a typealias, e.g. "@autoclosure (escaping) T".
- if (Tok.is(tok::l_paren) && peekToken().getText() == "escaping") {
- Parser::BacktrackingScope Backtrack(*this);
- consumeToken(tok::l_paren);
- consumeToken(tok::identifier);
- isAutoclosureEscaping =
- Tok.is(tok::r_paren) && peekToken().isNot(tok::arrow);
- }
-
- if (isAutoclosureEscaping) {
- autoclosureEscapingParenRange.Start = consumeToken(tok::l_paren);
- consumeToken(tok::identifier);
- autoclosureEscapingParenRange.End = consumeToken(tok::r_paren);
- }
- } else if (attr == TAK_convention) {
+ if (attr == TAK_convention) {
SourceLoc LPLoc;
if (!consumeIfNotAtStartOfLine(tok::l_paren)) {
if (!justChecking)
@@ -2086,48 +2065,10 @@
switch (attr) {
default: break;
case TAK_autoclosure:
- // Handle @autoclosure(escaping)
- if (isAutoclosureEscaping) {
- // @noescape @autoclosure(escaping) makes no sense.
- if (Attributes.has(TAK_noescape)) {
- diagnose(Loc, diag::attr_noescape_conflicts_escaping_autoclosure);
- } else {
- diagnose(Loc, diag::attr_autoclosure_escaping_deprecated)
- .fixItReplace(autoclosureEscapingParenRange, " @escaping ");
- }
- Attributes.setAttr(TAK_escaping, Loc);
- } else if (Attributes.has(TAK_noescape) && !isInSILMode()) {
- diagnose(Loc, diag::attr_noescape_implied_by_autoclosure);
- }
- break;
-
- case TAK_noescape:
- // You can't specify @noescape and @escaping together.
- if (Attributes.has(TAK_escaping)) {
- diagnose(Loc, diag::attr_escaping_conflicts_noescape);
- return false;
- }
-
- // @noescape after @autoclosure is redundant.
- if (Attributes.has(TAK_autoclosure) && !isInSILMode()) {
- diagnose(Loc, diag::attr_noescape_implied_by_autoclosure);
- }
-
- // @noescape is deprecated and no longer used
- // In SIL, the polarity of @escaping is reversed.
- // @escaping is the default and @noescape is explicit.
- if (!isInSILMode()) {
- diagnose(Loc, diag::attr_noescape_deprecated)
- .fixItRemove({Attributes.AtLoc, Loc});
- }
- break;
case TAK_escaping:
- // You can't specify @noescape and @escaping together.
- if (Attributes.has(TAK_noescape)) {
- diagnose(Loc, diag::attr_escaping_conflicts_noescape);
- return false;
- }
+ case TAK_noescape:
break;
+
case TAK_out:
case TAK_in:
case TAK_owned:
diff --git a/lib/SIL/LinearLifetimeChecker.cpp b/lib/SIL/LinearLifetimeChecker.cpp
index 661fff4..09d630f 100644
--- a/lib/SIL/LinearLifetimeChecker.cpp
+++ b/lib/SIL/LinearLifetimeChecker.cpp
@@ -486,6 +486,25 @@
// have been detected by initializing our consuming uses. So we are done.
if (consumingUses.size() == 1 &&
consumingUses[0].getParent() == value->getParentBlock()) {
+ // Check if any of our non consuming uses are not in the parent block. We
+ // flag those as additional use after frees. Any in the same block, we would
+ // have flagged.
+ if (llvm::any_of(nonConsumingUses, [&](BranchPropagatedUser user) {
+ return user.getParent() != value->getParentBlock();
+ })) {
+ state.error.handleUseAfterFree([&] {
+ llvm::errs() << "Function: '" << value->getFunction()->getName()
+ << "'\n"
+ << "Found use after free due to unvisited non lifetime "
+ "ending uses?!\n"
+ << "Value: " << *value << " Remaining Users:\n";
+ for (const auto &user : nonConsumingUses) {
+ llvm::errs() << "User: " << *user.getInst();
+ }
+ llvm::errs() << "\n";
+ });
+ }
+
return state.error;
}
diff --git a/lib/SIL/SILLocation.cpp b/lib/SIL/SILLocation.cpp
index 7a86050..015c415 100644
--- a/lib/SIL/SILLocation.cpp
+++ b/lib/SIL/SILLocation.cpp
@@ -217,6 +217,9 @@
if (L.isInTopLevel())
return MandatoryInlinedLocation::getModuleLocation(L.getSpecialFlags());
+ if (L.isDebugInfoLoc())
+ return MandatoryInlinedLocation(L.getDebugInfoLoc(), L.getSpecialFlags());
+
llvm_unreachable("Cannot construct Inlined loc from the given location.");
}
diff --git a/lib/SILGen/SILGenPattern.cpp b/lib/SILGen/SILGenPattern.cpp
index 19448f5..ed0ea22 100644
--- a/lib/SILGen/SILGenPattern.cpp
+++ b/lib/SILGen/SILGenPattern.cpp
@@ -2497,11 +2497,48 @@
PatternMatchEmission &Emission;
};
+namespace {
+
+struct UnexpectedEnumCaseInfo {
+ CanType subjectTy;
+ ManagedValue metatype;
+ ManagedValue rawValue;
+ NullablePtr<const EnumDecl> singleObjCEnum;
+
+ UnexpectedEnumCaseInfo(CanType subjectTy, ManagedValue metatype,
+ ManagedValue rawValue, const EnumDecl *singleObjCEnum)
+ : subjectTy(subjectTy), metatype(metatype), rawValue(rawValue),
+ singleObjCEnum(singleObjCEnum) {
+ assert(isa<MetatypeInst>(metatype));
+ assert(bool(rawValue) && isa<UncheckedTrivialBitCastInst>(rawValue));
+ assert(singleObjCEnum->hasRawType());
+ }
+
+ UnexpectedEnumCaseInfo(CanType subjectTy, ManagedValue valueMetatype)
+ : subjectTy(subjectTy), metatype(valueMetatype), rawValue(),
+ singleObjCEnum() {
+ assert(isa<ValueMetatypeInst>(valueMetatype));
+ }
+
+ bool isSingleObjCEnum() const { return singleObjCEnum.isNonNull(); }
+
+ void cleanupInstsIfUnused() {
+ auto f = [](SILValue v) {
+ if (!v->use_empty())
+ return;
+ cast<SingleValueInstruction>(v)->eraseFromParent();
+ };
+ f(metatype.getValue());
+ if (rawValue)
+ f(rawValue.getValue());
+ }
+};
+
+} // end anonymous namespace
+
static void emitDiagnoseOfUnexpectedEnumCaseValue(SILGenFunction &SGF,
SILLocation loc,
- ManagedValue value,
- Type subjectTy,
- const EnumDecl *enumDecl) {
+ UnexpectedEnumCaseInfo ueci) {
ASTContext &ctx = SGF.getASTContext();
auto diagnoseFailure = ctx.getDiagnoseUnexpectedEnumCaseValue();
if (!diagnoseFailure) {
@@ -2509,25 +2546,6 @@
return;
}
- assert(enumDecl->isObjC());
- assert(enumDecl->hasRawType());
- assert(value.getType().isTrivial(SGF.F));
-
- // Get the enum type as an Any.Type value.
- SILType metatypeType = SGF.getLoweredType(
- AbstractionPattern::getOpaque(),
- MetatypeType::get(subjectTy));
- SILValue metatype = SGF.B.createMetatype(loc, metatypeType);
-
- // Bitcast the enum value to its raw type. (This is only safe for @objc
- // enums.)
- SILType loweredRawType = SGF.getLoweredType(enumDecl->getRawType());
- assert(loweredRawType.isTrivial(SGF.F));
- assert(loweredRawType.isObject());
- auto rawValue = SGF.B.createUncheckedTrivialBitCast(loc, value,
- loweredRawType);
- auto materializedRawValue = rawValue.materialize(SGF, loc);
-
auto genericSig = diagnoseFailure->getGenericSignature();
auto subs = SubstitutionMap::get(
genericSig,
@@ -2537,10 +2555,10 @@
assert(genericParam->getIndex() < 2);
switch (genericParam->getIndex()) {
case 0:
- return subjectTy;
+ return ueci.subjectTy;
case 1:
- return enumDecl->getRawType();
+ return ueci.singleObjCEnum.get()->getRawType();
default:
llvm_unreachable("wrong generic signature for expected case value");
@@ -2548,16 +2566,14 @@
},
LookUpConformanceInSignature(*genericSig));
- SGF.emitApplyOfLibraryIntrinsic(loc, diagnoseFailure, subs,
- {ManagedValue::forUnmanaged(metatype),
- materializedRawValue},
- SGFContext());
+ SGF.emitApplyOfLibraryIntrinsic(
+ loc, diagnoseFailure, subs,
+ {ueci.metatype, ueci.rawValue.materialize(SGF, loc)}, SGFContext());
}
static void emitDiagnoseOfUnexpectedEnumCase(SILGenFunction &SGF,
SILLocation loc,
- ManagedValue value,
- Type subjectTy) {
+ UnexpectedEnumCaseInfo ueci) {
ASTContext &ctx = SGF.getASTContext();
auto diagnoseFailure = ctx.getDiagnoseUnexpectedEnumCase();
if (!diagnoseFailure) {
@@ -2565,21 +2581,14 @@
return;
}
- // Get the switched-upon value's type.
- SILType metatypeType = SGF.getLoweredType(
- AbstractionPattern::getOpaque(),
- MetatypeType::get(subjectTy)->getCanonicalType());
- ManagedValue metatype = SGF.B.createValueMetatype(loc, metatypeType, value);
-
auto diagnoseSignature = diagnoseFailure->getGenericSignature();
auto genericArgsMap = SubstitutionMap::get(
diagnoseSignature,
- [&](SubstitutableType *type) -> Type { return subjectTy; },
+ [&](SubstitutableType *type) -> Type { return ueci.subjectTy; },
LookUpConformanceInSignature(*diagnoseSignature));
SGF.emitApplyOfLibraryIntrinsic(loc, diagnoseFailure, genericArgsMap,
- metatype,
- SGFContext());
+ ueci.metatype, SGFContext());
}
static void switchCaseStmtSuccessCallback(SILGenFunction &SGF,
@@ -2778,6 +2787,38 @@
return {subjectMV.copy(*this, S), CastConsumptionKind::TakeAlways};
}());
+ // If we need to diagnose an unexpected enum case or unexpected enum case
+ // value, we need access to a value metatype for the subject. Emit this state
+ // now before we emit the actual switch to ensure that the subject has not
+ // been consumed.
+ auto unexpectedEnumCaseInfo = ([&]() -> UnexpectedEnumCaseInfo {
+ SILLocation loc = RegularLocation::getAutoGeneratedLocation();
+ CanType canSubjectTy = subjectTy->getCanonicalType();
+ CanType metatypeType = MetatypeType::get(canSubjectTy)->getCanonicalType();
+ SILType loweredMetatypeType =
+ getLoweredType(AbstractionPattern::getOpaque(), metatypeType);
+ ManagedValue value = subject.getFinalManagedValue();
+
+ if (auto *singleEnumDecl = canSubjectTy->getEnumOrBoundGenericEnum()) {
+ if (singleEnumDecl->isObjC()) {
+ auto metatype = ManagedValue::forUnmanaged(
+ B.createMetatype(loc, loweredMetatypeType));
+
+ // Bitcast the enum value to its raw type. (This is only safe for @objc
+ // enums.)
+ SILType loweredRawType = getLoweredType(singleEnumDecl->getRawType());
+ assert(loweredRawType.isTrivial(F));
+ assert(loweredRawType.isObject());
+ auto rawValue =
+ B.createUncheckedTrivialBitCast(loc, value, loweredRawType);
+ return {canSubjectTy, metatype, rawValue, singleEnumDecl};
+ }
+ }
+
+ return {canSubjectTy,
+ B.createValueMetatype(loc, loweredMetatypeType, value)};
+ }());
+
auto failure = [&](SILLocation location) {
// If we fail to match anything, we trap. This can happen with a switch
// over an @objc enum, which may contain any value of its underlying type,
@@ -2786,18 +2827,12 @@
SWIFT_DEFER { B.createUnreachable(location); };
// Special case: if it's a single @objc enum, we can print the raw value.
- CanType ty = S->getSubjectExpr()->getType()->getCanonicalType();
- if (auto *singleEnumDecl = ty->getEnumOrBoundGenericEnum()) {
- if (singleEnumDecl->isObjC()) {
- emitDiagnoseOfUnexpectedEnumCaseValue(*this, location,
- subject.getFinalManagedValue(),
- subjectTy, singleEnumDecl);
- return;
- }
+ if (unexpectedEnumCaseInfo.isSingleObjCEnum()) {
+ emitDiagnoseOfUnexpectedEnumCaseValue(*this, location,
+ unexpectedEnumCaseInfo);
+ return;
}
- emitDiagnoseOfUnexpectedEnumCase(*this, location,
- subject.getFinalManagedValue(),
- subjectTy);
+ emitDiagnoseOfUnexpectedEnumCase(*this, location, unexpectedEnumCaseInfo);
};
// Set up an initial clause matrix.
@@ -2823,6 +2858,10 @@
} else {
B.emitBlock(contBB);
}
+
+ // Now that we have emitted everything, see if our unexpected enum case info
+ // metatypes were actually used. If not, delete them.
+ unexpectedEnumCaseInfo.cleanupInstsIfUnused();
}
void SILGenFunction::emitSwitchFallthrough(FallthroughStmt *S) {
diff --git a/lib/SILOptimizer/Mandatory/CMakeLists.txt b/lib/SILOptimizer/Mandatory/CMakeLists.txt
index 2eb58e0..58b5537 100644
--- a/lib/SILOptimizer/Mandatory/CMakeLists.txt
+++ b/lib/SILOptimizer/Mandatory/CMakeLists.txt
@@ -7,6 +7,7 @@
DIMemoryUseCollector.cpp
DataflowDiagnostics.cpp
DiagnoseInfiniteRecursion.cpp
+ DiagnoseInvalidEscapingCaptures.cpp
DiagnoseStaticExclusivity.cpp
DiagnoseUnreachable.cpp
GuaranteedARCOpts.cpp
diff --git a/lib/SILOptimizer/Mandatory/DiagnoseInvalidEscapingCaptures.cpp b/lib/SILOptimizer/Mandatory/DiagnoseInvalidEscapingCaptures.cpp
new file mode 100644
index 0000000..f0a7fe2
--- /dev/null
+++ b/lib/SILOptimizer/Mandatory/DiagnoseInvalidEscapingCaptures.cpp
@@ -0,0 +1,455 @@
+//===--- DiagnoseInvalidEscapingCaptures.cpp ------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a diagnostic pass to diagnose escaping closures that
+// capture mutable storage locations or noescape function values.
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/AST/ASTContext.h"
+#include "swift/AST/DiagnosticsSIL.h"
+#include "swift/AST/Types.h"
+#include "swift/SIL/ApplySite.h"
+#include "swift/SIL/InstructionUtils.h"
+#include "swift/SIL/SILArgument.h"
+#include "swift/SIL/SILBasicBlock.h"
+#include "swift/SIL/SILInstruction.h"
+#include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "llvm/Support/Debug.h"
+
+using namespace swift;
+
+template <typename... T, typename... U>
+static InFlightDiagnostic diagnose(ASTContext &Context, SILLocation loc,
+ Diag<T...> diag, U &&... args) {
+ return Context.Diags.diagnose(loc.getSourceLoc(), diag,
+ std::forward<U>(args)...);
+}
+
+template <typename... T, typename... U>
+static InFlightDiagnostic diagnose(ASTContext &Context, SourceLoc loc,
+ Diag<T...> diag, U &&... args) {
+ return Context.Diags.diagnose(loc, diag,
+ std::forward<U>(args)...);
+}
+
+// Check if a use of a value derived from a partial_apply can cause the
+// closure to escape. For "pass-through" uses that build a new value from
+// the partial_apply, followUses() is called to evaluate the uses of the
+// derived value.
+template <typename FollowUse>
+static bool checkNoEscapePartialApplyUse(Operand *oper, FollowUse followUses) {
+ SILInstruction *user = oper->getUser();
+
+ if (isa<ConvertEscapeToNoEscapeInst>(user) ||
+ isa<CopyBlockWithoutEscapingInst>(user))
+ return false;
+
+ // Ignore uses that are totally uninteresting. partial_apply [stack] is
+ // terminated by a dealloc_stack instruction.
+ if (isIncidentalUse(user) || onlyAffectsRefCount(user) ||
+ isa<DeallocStackInst>(user))
+ return false;
+
+ // Before checking conversions in general below (getSingleValueCopyOrCast),
+ // check for convert_function to [without_actually_escaping]. Assume such
+ // conversion are not actually escaping without following their uses.
+ if (auto *CFI = dyn_cast<ConvertFunctionInst>(user)) {
+ if (CFI->withoutActuallyEscaping())
+ return false;
+ }
+
+ // Look through copies, borrows, and conversions.
+ if (SingleValueInstruction *copy = getSingleValueCopyOrCast(user)) {
+ // Only follow the copied operand. Other operands are incidental,
+ // as in the second operand of mark_dependence.
+ if (oper->getOperandNumber() == 0)
+ followUses(copy);
+
+ return false;
+ }
+
+ // @noescape block storage can be passed as an Optional (Nullable).
+ if (auto *EI = dyn_cast<EnumInst>(user)) {
+ followUses(EI);
+ return false;
+ }
+
+ // Look through Phis.
+ if (auto *BI = dyn_cast<BranchInst>(user)) {
+ const SILPhiArgument *arg = BI->getArgForOperand(oper);
+ followUses(arg);
+ return false;
+ }
+
+ if (auto *CBI = dyn_cast<CondBranchInst>(user)) {
+ const SILPhiArgument *arg = CBI->getArgForOperand(oper);
+ if (arg) // If the use isn't the branch condition, follow it.
+ followUses(arg);
+ return false;
+ }
+
+ // Look through ObjC closures.
+ if (auto *SI = dyn_cast<StoreInst>(user)) {
+ if (oper->getOperandNumber() == StoreInst::Src) {
+ if (auto *PBSI = dyn_cast<ProjectBlockStorageInst>(
+ SI->getDest())) {
+ SILValue storageAddr = PBSI->getOperand();
+ // The closure is stored to block storage. Recursively visit all
+ // uses of any initialized block storage values derived from this
+ // storage address..
+ for (Operand *oper : storageAddr->getUses()) {
+ if (auto *IBS = dyn_cast<InitBlockStorageHeaderInst>(oper->getUser()))
+ followUses(IBS);
+ }
+ return false;
+ }
+ }
+ }
+
+ if (auto *PAI = dyn_cast<PartialApplyInst>(user)) {
+ // Recurse through partial_apply chains.
+ if (oper->get() == PAI->getCallee()) {
+ followUses(PAI);
+ return false;
+ }
+
+ // Look through re-abstraction thunks.
+ if (isPartialApplyOfReabstractionThunk(PAI)) {
+ // However, first check for withoutActuallyEscaping, which is always
+ // a valid non-escaping use.
+ SILFunction *thunkDef = PAI->getReferencedFunction();
+ if (!thunkDef->isWithoutActuallyEscapingThunk())
+ followUses(PAI);
+ return false;
+ }
+ }
+
+ // Anything else is flagged as an escaping use.
+ return true;
+}
+
+const ParamDecl *getParamDeclFromOperand(SILValue value) {
+ if (auto *arg = dyn_cast<SILArgument>(value))
+ if (auto *decl = dyn_cast_or_null<ParamDecl>(arg->getDecl()))
+ return decl;
+
+ return nullptr;
+}
+
+static bool checkForEscapingPartialApplyUses(PartialApplyInst *PAI) {
+ // Avoid exponential path exploration.
+ SmallVector<Operand *, 8> uses;
+ llvm::SmallDenseSet<Operand *, 8> visited;
+ auto uselistInsert = [&](Operand *operand) {
+ if (visited.insert(operand).second)
+ uses.push_back(operand);
+ };
+
+ for (Operand *use : PAI->getUses())
+ uselistInsert(use);
+
+
+ // Search for any uses of the closure that might potentially escape.
+ bool foundEscapingUse = false;
+ while (!uses.empty()) {
+ Operand *oper = uses.pop_back_val();
+ foundEscapingUse |= checkNoEscapePartialApplyUse(oper, [&](SILValue V) {
+ for (Operand *use : V->getUses())
+ uselistInsert(use);
+ });
+ }
+
+ // If there aren't any, we're fine.
+ return foundEscapingUse;
+}
+
+// Given a partial_apply forming a closure, together with one of its operands,
+// find a usage of the corresponding argument inside the closure body, and
+// diagnose it as a capture use.
+//
+// This makes a best-effort attempt at finding a "good" capture usage; it may
+// not emit anything.
+//
+// The \c DC parameter is the DeclContext of the original function being
+// analyzed by this diagnostic pass. We use it to distinguish calls of closures
+// from calls of other unrelated functions, by checking the DeclContext of the
+// called closure.
+static void diagnoseCaptureLoc(ASTContext &Context, DeclContext *DC,
+ PartialApplyInst *PAI, Operand *oper) {
+ assert(DC != nullptr &&
+ "Invalid capture in function with no source location information");
+
+ SmallVector<Operand *, 8> uses;
+ llvm::SmallDenseSet<Operand *, 8> visited;
+ auto uselistInsert = [&](Operand *operand) {
+ if (visited.insert(operand).second)
+ uses.push_back(operand);
+ };
+
+ auto lookInsideClosure = [&](ApplySite site, Operand *oper) -> bool {
+ auto *F = site.getCalleeFunction();
+ if (F == nullptr || F->empty())
+ return false;
+
+ auto *otherDC = F->getDeclContext();
+ if (otherDC == nullptr || DC == nullptr ||
+ !otherDC->isChildContextOf(DC))
+ return false;
+
+ // Map an operand of an apply instruction to an argument inside
+ // the callee.
+ auto args = F->getArguments();
+ auto argIndex = site.getCalleeArgIndex(*oper);
+ auto arg = args[argIndex];
+
+ // Look for a usage of the callee argument.
+ for (Operand *use : arg->getUses())
+ uselistInsert(use);
+
+ return true;
+ };
+
+ lookInsideClosure(PAI, oper);
+
+ while (!uses.empty()) {
+ Operand *oper = uses.pop_back_val();
+ SILInstruction *user = oper->getUser();
+
+ if (isIncidentalUse(user) || onlyAffectsRefCount(user))
+ continue;
+
+ // Look through copies, borrows, and conversions.
+ if (SingleValueInstruction *copy = getSingleValueCopyOrCast(user)) {
+ // Only follow the copied operand. Other operands are incidental,
+ // as in the second operand of mark_dependence.
+ if (oper->getOperandNumber() == 0) {
+ for (auto *use : copy->getUses())
+ uselistInsert(use);
+ continue;
+ }
+ }
+
+ // If the usage is a capture of the value by another closure, look inside
+ // the body of that closure.
+ if (auto site = ApplySite::isa(user)) {
+ if (lookInsideClosure(site, oper)) {
+ diagnose(Context, site.getLoc(), diag::value_captured_transitively);
+ continue;
+ }
+ }
+
+ // Otherwise, we might have found one of the "real" usages of the capture.
+ // Diagnose it here.
+ SILValue val = oper->get();
+ SILLocation loc = val.getLoc();
+ if (loc.isASTNode<VarDecl>())
+ loc = user->getLoc();
+ diagnose(Context, loc, diag::value_captured_here);
+ }
+}
+
+// Diagnose this partial_apply if it captures a non-escaping value and has
+// an escaping use.
+static void checkPartialApply(ASTContext &Context, DeclContext *DC,
+ PartialApplyInst *PAI) {
+ // Re-abstraction thunks are not useful to look at. We'll diagnose the
+ // original closure instead.
+ if (isPartialApplyOfReabstractionThunk(PAI))
+ return;
+
+ ApplySite apply(PAI);
+
+ // Collect any non-escaping captures.
+ SmallVector<Operand *, 2> inoutCaptures;
+ SmallVector<Operand *, 2> noEscapeCaptures;
+
+ for (auto &oper : apply.getArgumentOperands()) {
+ SILValue value = oper.get();
+
+ // Captures of inout parameters cannot escape.
+ if (apply.getArgumentConvention(oper)
+ == SILArgumentConvention::Indirect_InoutAliasable)
+ inoutCaptures.push_back(&oper);
+
+ // Captures of noescape function types or tuples containing noescape
+ // function types cannot escape.
+ if (value->getType().getASTType()->isNoEscape()) {
+ noEscapeCaptures.push_back(&oper);
+ }
+ }
+
+ // A partial_apply without non-escaping captures is always valid.
+ if (inoutCaptures.empty() && noEscapeCaptures.empty())
+ return;
+
+ // A partial_apply without escaping uses is always valid.
+ if (!checkForEscapingPartialApplyUses(PAI))
+ return;
+
+ // Otherwise, we have at least one escaping use of a partial_apply
+ // capturing a non-escaping value. We need to emit diagnostics.
+
+ // First, diagnose the inout captures, if any.
+ for (auto inoutCapture : inoutCaptures) {
+ auto *param = getParamDeclFromOperand(inoutCapture->get());
+ if (param->isSelfParameter())
+ diagnose(Context, PAI->getLoc(), diag::escaping_mutable_self_capture);
+ else {
+ diagnose(Context, PAI->getLoc(), diag::escaping_inout_capture,
+ param->getName());
+ diagnose(Context, param->getLoc(), diag::inout_param_defined_here,
+ param->getName());
+ }
+
+ diagnoseCaptureLoc(Context, DC, PAI, inoutCapture);
+ }
+
+ // Finally, diagnose captures of values with noescape type.
+ for (auto noEscapeCapture : noEscapeCaptures) {
+ if (auto *param = getParamDeclFromOperand(noEscapeCapture->get())) {
+ diagnose(Context, PAI->getLoc(), diag::escaping_noescape_param_capture,
+ param->getName());
+ diagnose(Context, param->getLoc(), diag::noescape_param_defined_here,
+ param->getName());
+ } else {
+ diagnose(Context, PAI->getLoc(), diag::escaping_noescape_var_capture);
+ }
+
+ diagnoseCaptureLoc(Context, DC, PAI, noEscapeCapture);
+ }
+}
+
+// Enforce exclusivity restrictions on recursive uses of non-escaping closures.
+// Exclusivity requires a Non-Escaping Recursion Restriction rule (SE-0176):
+// A non-escaping closure A may not be recursively invoked during the
+// execution of a non-escaping closure B which captures the same local
+// variable or inout parameter unless:
+// - A is defined within B or
+// - A is a local function declaration which is referenced directly by B.
+//
+// This is conservatively approximated with a Non-Escaping Parameter Call
+// Restriction rule (NPCR), as implemented below:
+// A function may not call a non-escaping function parameter passing a
+// non-escaping function parameter as an argument.
+// For the purposes of this rule, a closure which captures a non-escaping
+// function parameter is treated the same as the parameter.
+//
+// Note: The compiler does not enforce recursion via
+// withoutActuallyEscaping. This undefined behavior is exposed to programmers.
+//
+// TODO: Verify that all uses of noescaping function arguments are SIL patterns
+// that are recognized below to prove that this diagnostic is complete.
+static void checkApply(ASTContext &Context, FullApplySite site) {
+ auto isNoEscapeParam = [&](SILValue value) -> const ParamDecl * {
+ // If the value is an escaping, do not enforce any restrictions.
+ if (!value->getType().getASTType()->isNoEscape())
+ return nullptr;
+
+ // If the value is not a function parameter, do not enforce any restrictions.
+ return getParamDeclFromOperand(value);
+ };
+
+ // If the callee is not a no-escape parameter, there is nothing to check.
+ auto callee = site.getCalleeOrigin();
+ if (!isNoEscapeParam(callee))
+ return;
+
+ // See if any of our arguments are noescape parameters, or closures capturing
+ // noescape parameters.
+ SmallVector<std::pair<SILValue, bool>, 4> args;
+ llvm::SmallDenseSet<SILValue, 4> visited;
+ auto arglistInsert = [&](SILValue arg, bool capture) {
+ if (visited.insert(arg).second)
+ args.emplace_back(arg, capture);
+ };
+
+ for (auto arg : site.getArguments())
+ arglistInsert(arg, /*capture=*/false);
+
+ while (!args.empty()) {
+ auto pair = args.pop_back_val();
+ auto arg = pair.first;
+ bool capture = pair.second;
+
+ if (auto *CI = dyn_cast<ConversionInst>(arg)) {
+ arglistInsert(CI->getConverted(), /*capture=*/false);
+ continue;
+ }
+
+ // If one of our call arguments is a noescape parameter, diagnose the
+ // violation.
+ if (auto *param = isNoEscapeParam(arg)) {
+ diagnose(Context, site.getLoc(), diag::err_noescape_param_call,
+ param->getName(), capture);
+ return;
+ }
+
+ // If one of our call arguments is a closure, recursively visit all of
+ // the closure's captures.
+ if (auto *PAI = dyn_cast<PartialApplyInst>(arg)) {
+ ApplySite site(PAI);
+ for (auto arg : site.getArguments())
+ arglistInsert(arg, /*capture=*/true);
+ continue;
+ }
+ }
+}
+
+static void checkForViolationsAtInstruction(ASTContext &Context,
+ DeclContext *DC,
+ SILInstruction *I) {
+ if (auto *PAI = dyn_cast<PartialApplyInst>(I))
+ checkPartialApply(Context, DC, PAI);
+
+ if (isa<ApplyInst>(I) || isa<TryApplyInst>(I)) {
+ FullApplySite site(I);
+ checkApply(Context, site);
+ }
+}
+
+static void checkEscapingCaptures(SILFunction *F) {
+ if (F->empty())
+ return;
+
+ auto &Context =F->getASTContext();
+ auto *DC = F->getDeclContext();
+
+ for (auto &BB : *F) {
+ for (auto &I : BB)
+ checkForViolationsAtInstruction(Context, DC, &I);
+ }
+}
+
+namespace {
+
+class DiagnoseInvalidEscapingCaptures : public SILFunctionTransform {
+public:
+ DiagnoseInvalidEscapingCaptures() {}
+
+private:
+ void run() override {
+ SILFunction *F = getFunction();
+
+ // Don't rerun diagnostics on deserialized functions.
+ if (F->wasDeserializedCanonical())
+ return;
+
+ checkEscapingCaptures(F);
+ }
+};
+
+} // end anonymous namespace
+
+SILTransform *swift::createDiagnoseInvalidEscapingCaptures() {
+ return new DiagnoseInvalidEscapingCaptures();
+}
diff --git a/lib/SILOptimizer/Mandatory/DiagnoseStaticExclusivity.cpp b/lib/SILOptimizer/Mandatory/DiagnoseStaticExclusivity.cpp
index e8afc71..df09c54 100644
--- a/lib/SILOptimizer/Mandatory/DiagnoseStaticExclusivity.cpp
+++ b/lib/SILOptimizer/Mandatory/DiagnoseStaticExclusivity.cpp
@@ -672,10 +672,7 @@
// =============================================================================
// The data flow algorithm that drives diagnostics.
-// Forward declare verification entry points.
-#ifndef NDEBUG
-static void checkNoEscapePartialApply(PartialApplyInst *PAI);
-#endif
+// Forward declare verification entry point.
static void checkAccessedAddress(Operand *memOper, StorageMap &Accesses);
namespace {
@@ -863,20 +860,7 @@
checkForViolationAtApply(TAI, State);
return;
}
-#ifndef NDEBUG
- // FIXME: Once AllocBoxToStack is fixed to correctly set noescape
- // closure types, move this PartialApply verification into the
- // SILVerifier to better pinpoint the offending pass.
- if (auto *PAI = dyn_cast<PartialApplyInst>(&I)) {
- ApplySite apply(PAI);
- if (llvm::any_of(apply.getArgumentOperands(), [apply](Operand &oper) {
- return apply.getArgumentConvention(oper)
- == SILArgumentConvention::Indirect_InoutAliasable;
- })) {
- checkNoEscapePartialApply(PAI);
- }
- }
-#endif
+
// Sanity check to make sure entries are properly removed.
assert((!isa<ReturnInst>(&I) || State.Accesses->empty())
&& "Entries were not properly removed?!");
@@ -949,159 +933,6 @@
// =============================================================================
// Verification
-#ifndef NDEBUG
-// This must handle exactly the same SIL patterns as
-// swift::funcClosureForAppliedArg but in forward order.
-template <typename FollowUse>
-static void checkNoEscapePartialApplyUse(Operand *oper, FollowUse followUses) {
- SILInstruction *user = oper->getUser();
-
- // Ignore uses that are totally uninteresting. partial_apply [stack] is
- // terminated by a dealloc_stack instruction.
- if (isIncidentalUse(user) || onlyAffectsRefCount(user) ||
- isa<DeallocStackInst>(user))
- return;
-
- // Before checking conversions in general below (getSingleValueCopyOrCast),
- // check for convert_function to [without_actually_escaping]. Assume such
- // conversion are not actually escaping without following their uses.
- if (auto *CFI = dyn_cast<ConvertFunctionInst>(user)) {
- if (CFI->withoutActuallyEscaping())
- return;
- }
-
- // Look through copies, borrows, and conversions.
- if (SingleValueInstruction *copy = getSingleValueCopyOrCast(user)) {
- // Only follow the copied operand. Other operands are incidental,
- // as in the second operand of mark_dependence.
- if (oper->getOperandNumber() == 0)
- followUses(copy);
-
- return;
- }
-
- switch (user->getKind()) {
- default:
- break;
-
- // Look through Optionals.
- case SILInstructionKind::EnumInst:
- // @noescape block storage can be passed as an Optional (Nullable).
- followUses(cast<EnumInst>(user));
- return;
-
- // Look through Phis.
- case SILInstructionKind::BranchInst: {
- const SILPhiArgument *arg = cast<BranchInst>(user)->getArgForOperand(oper);
- followUses(arg);
- return;
- }
- case SILInstructionKind::CondBranchInst: {
- const SILPhiArgument *arg =
- cast<CondBranchInst>(user)->getArgForOperand(oper);
- if (arg) // If the use isn't the branch condition, follow it.
- followUses(arg);
- return;
- }
- // Look through ObjC closures.
- case SILInstructionKind::StoreInst:
- if (oper->getOperandNumber() == StoreInst::Src) {
- if (auto *PBSI = dyn_cast<ProjectBlockStorageInst>(
- cast<StoreInst>(user)->getDest())) {
- SILValue storageAddr = PBSI->getOperand();
- // The closure is stored to block storage. Recursively visit all
- // uses of any initialized block storage values derived from this
- // storage address..
- for (Operand *oper : storageAddr->getUses()) {
- if (auto *IBS = dyn_cast<InitBlockStorageHeaderInst>(oper->getUser()))
- followUses(IBS);
- }
- return;
- }
- }
- break;
-
- case SILInstructionKind::IsEscapingClosureInst:
- // May be generated by withoutActuallyEscaping.
- return;
-
- case SILInstructionKind::PartialApplyInst: {
- // Recurse through partial_apply to handle special cases before handling
- // ApplySites in general below.
- PartialApplyInst *PAI = cast<PartialApplyInst>(user);
- // Use the same logic as checkForViolationAtApply applied to a def-use
- // traversal.
- //
- // checkForViolationAtApply recurses through partial_apply chains.
- if (oper->get() == PAI->getCallee()) {
- followUses(PAI);
- return;
- }
- // checkForViolationAtApply also uses findClosuresForAppliedArg which in
- // turn checks isPartialApplyOfReabstractionThunk.
- //
- // A closure with @inout_aliasable arguments may be applied to a
- // thunk as "escaping", but as long as the thunk is only used as a
- // '@noescape" type then it is safe.
- if (isPartialApplyOfReabstractionThunk(PAI)) {
- // Don't follow thunks that were generated by withoutActuallyEscaping.
- SILFunction *thunkDef = PAI->getReferencedFunction();
- if (!thunkDef->isWithoutActuallyEscapingThunk())
- followUses(PAI);
- return;
- }
- // Handle this use like a normal applied argument.
- break;
- }
- };
-
- // Handle ApplySites in general after checking PartialApply above.
- if (isa<ApplySite>(user)) {
- SILValue arg = oper->get();
- auto argumentFnType = getSILFunctionTypeForValue(arg);
- if (argumentFnType && argumentFnType->isNoEscape()) {
- // Verify that the inverse operation, finding a partial_apply from a
- // @noescape argument, is consistent.
- TinyPtrVector<PartialApplyInst *> partialApplies;
- findClosuresForFunctionValue(arg, partialApplies);
- assert(!partialApplies.empty()
- && "cannot find partial_apply from @noescape function argument");
- return;
- }
- llvm::dbgs() << "Applied argument must be @noescape function type: " << *arg;
- }
- else
- llvm::dbgs() << "Unexpected partial_apply use: " << *user;
-
- llvm_unreachable("A partial_apply with @inout_aliasable may only be "
- "used as a @noescape function type argument.");
-}
-
-// If a partial apply has @inout_aliasable arguments, it may only be used as
-// a @noescape function type in a way that is recognized by
-// DiagnoseStaticExclusivity.
-static void checkNoEscapePartialApply(PartialApplyInst *PAI) {
- SmallVector<Operand *, 8> uses;
- // Avoid exponential path exploration.
- llvm::SmallDenseSet<Operand *, 8> visited;
- auto uselistInsert = [&](Operand *operand) {
- if (visited.insert(operand).second)
- uses.push_back(operand);
- };
-
- for (Operand *use : PAI->getUses())
- uselistInsert(use);
-
- while (!uses.empty()) {
- Operand *oper = uses.pop_back_val();
- checkNoEscapePartialApplyUse(oper, [&](SILValue V) {
- for (Operand *use : V->getUses())
- uselistInsert(use);
- });
- }
-}
-#endif
-
// Check that the given address-type operand is guarded by begin/end access
// markers.
static void checkAccessedAddress(Operand *memOper, StorageMap &Accesses) {
diff --git a/lib/SILOptimizer/PassManager/PassPipeline.cpp b/lib/SILOptimizer/PassManager/PassPipeline.cpp
index ca06e8b..0eaea4f 100644
--- a/lib/SILOptimizer/PassManager/PassPipeline.cpp
+++ b/lib/SILOptimizer/PassManager/PassPipeline.cpp
@@ -81,6 +81,7 @@
static void addMandatoryOptPipeline(SILPassPipelinePlan &P) {
P.startPipeline("Guaranteed Passes");
+ P.addDiagnoseInvalidEscapingCaptures();
P.addDiagnoseStaticExclusivity();
P.addCapturePromotion();
diff --git a/lib/SILOptimizer/Transforms/SimplifyCFG.cpp b/lib/SILOptimizer/Transforms/SimplifyCFG.cpp
index 638af9a..2a77459 100644
--- a/lib/SILOptimizer/Transforms/SimplifyCFG.cpp
+++ b/lib/SILOptimizer/Transforms/SimplifyCFG.cpp
@@ -81,6 +81,10 @@
ConstantFolder ConstFolder;
+ // True if the function has a large amount of blocks. In this case we turn off some expensive
+ // optimizations.
+ bool isVeryLargeFunction = false;
+
void constFoldingCallback(SILInstruction *I) {
// If a terminal instruction gets constant folded (like cond_br), it
// enables further simplify-CFG optimizations.
@@ -1226,11 +1230,13 @@
if (DestBB->getArgument(i) != BI->getArg(i)) {
SILValue Val = BI->getArg(i);
DestBB->getArgument(i)->replaceAllUsesWith(Val);
- if (auto *I = dyn_cast<SingleValueInstruction>(Val)) {
- // Replacing operands may trigger constant folding which then could
- // trigger other simplify-CFG optimizations.
- ConstFolder.addToWorklist(I);
- ConstFolder.processWorkList();
+ if (!isVeryLargeFunction) {
+ if (auto *I = dyn_cast<SingleValueInstruction>(Val)) {
+ // Replacing operands may trigger constant folding which then could
+ // trigger other simplify-CFG optimizations.
+ ConstFolder.addToWorklist(I);
+ ConstFolder.processWorkList();
+ }
}
} else {
// We must be processing an unreachable part of the cfg with a cycle.
@@ -1290,7 +1296,7 @@
// If this unconditional branch has BBArgs, check to see if duplicating the
// destination would allow it to be simplified. This is a simple form of jump
// threading.
- if (!BI->getArgs().empty() &&
+ if (!isVeryLargeFunction && !BI->getArgs().empty() &&
tryJumpThreading(BI))
return true;
@@ -3067,6 +3073,9 @@
LLVM_DEBUG(llvm::dbgs() << "### Run SimplifyCFG on " << Fn.getName() << '\n');
+ // Disable some expensive optimizations if the function is huge.
+ isVeryLargeFunction = (Fn.size() > 10000);
+
// First remove any block not reachable from the entry.
bool Changed = removeUnreachableBlocks(Fn);
diff --git a/lib/SILOptimizer/Utils/PerformanceInlinerUtils.cpp b/lib/SILOptimizer/Utils/PerformanceInlinerUtils.cpp
index 25ba688..72724f4 100644
--- a/lib/SILOptimizer/Utils/PerformanceInlinerUtils.cpp
+++ b/lib/SILOptimizer/Utils/PerformanceInlinerUtils.cpp
@@ -418,6 +418,10 @@
getWeight(SILBasicBlock *BB, Weight CallerWeight) {
assert(BB->getParent() == F);
+ // Return a conservative default if the analysis was not done due to a high number of blocks.
+ if (BlockInfos.empty())
+ return Weight(CallerWeight.ScopeLength + ColdBlockLength, CallerWeight.LoopWeight);
+
SILLoop *Loop = LI->getLoopFor(BB);
if (!Loop) {
// We are not in a loop. So just account the length of our function scope
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
index 4e6f3ad..616386f 100644
--- a/lib/Sema/CSApply.cpp
+++ b/lib/Sema/CSApply.cpp
@@ -2856,10 +2856,8 @@
auto tupleTy =
TupleType::get(TupleTypeElt(paramTy, ctx.Id_dynamicMember), ctx);
- auto loc = nameLoc;
- Expr *index = TupleExpr::create(ctx, loc, argExpr, ctx.Id_dynamicMember,
- loc, loc, /*hasTrailingClosure*/ false,
- /*implicit*/ true);
+ Expr *index =
+ TupleExpr::createImplicit(ctx, argExpr, ctx.Id_dynamicMember);
index->setType(tupleTy);
cs.cacheType(index);
@@ -2867,7 +2865,7 @@
return buildSubscript(
base, index, ctx.Id_dynamicMember,
/*trailingClosure*/ false, cs.getConstraintLocator(expr),
- /*isImplicit*/ false, AccessSemantics::Ordinary, overload);
+ /*isImplicit*/ true, AccessSemantics::Ordinary, overload);
}
Type getTypeOfDynamicMemberIndex(const SelectedOverload &overload) {
@@ -7222,46 +7220,6 @@
// Try closing the existential, if there is one.
closeExistential(result, locator);
- // Extract all arguments.
- auto *CEA = arg;
-
- // The argument is either a ParenExpr or TupleExpr.
- ArrayRef<Expr *> arguments;
-
- SmallVector<Expr *, 1> Scratch;
- if (auto *TE = dyn_cast<TupleExpr>(CEA))
- arguments = TE->getElements();
- else if (auto *PE = dyn_cast<ParenExpr>(CEA)) {
- Scratch.push_back(PE->getSubExpr());
- arguments = makeArrayRef(Scratch);
- }
- else {
- Scratch.push_back(apply->getArg());
- arguments = makeArrayRef(Scratch);
- }
-
- for (auto arg: arguments) {
- bool isNoEscape = false;
- while (1) {
- if (auto AFT = cs.getType(arg)->getAs<AnyFunctionType>()) {
- isNoEscape = isNoEscape || AFT->isNoEscape();
- }
-
- if (auto conv = dyn_cast<ImplicitConversionExpr>(arg))
- arg = conv->getSubExpr();
- else if (auto *PE = dyn_cast<ParenExpr>(arg))
- arg = PE->getSubExpr();
- else
- break;
- }
- if (!isNoEscape) {
- if (auto DRE = dyn_cast<DeclRefExpr>(arg))
- if (auto FD = dyn_cast<FuncDecl>(DRE->getDecl())) {
- tc.addEscapingFunctionAsArgument(FD, apply);
- }
- }
- }
-
if (unwrapResult)
return forceUnwrapResult(result);
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
index 873c0ed..7f74879 100644
--- a/lib/Sema/CSSimplify.cpp
+++ b/lib/Sema/CSSimplify.cpp
@@ -1641,12 +1641,12 @@
return getTypeMatchFailure(locator);
// FIXME; Feels like a hack...nothing actually "conforms" here, and
- // we need to disallow conversions from @noescape functions to Any.
+ // we need to disallow conversions from types containing @noescape
+ // functions to Any.
// Conformance to 'Any' always holds.
if (type2->isAny()) {
- auto *fnTy = type1->getAs<FunctionType>();
- if (!fnTy || !fnTy->isNoEscape())
+ if (!type1->isNoEscape())
return getTypeMatchSuccess();
if (shouldAttemptFixes()) {
@@ -1835,21 +1835,19 @@
return getTypeMatchFailure(locator);
}
- // Disallow bindings of noescape functions to type variables that
- // represent an opened archetype. If we allowed this it would allow
- // the noescape function to potentially escape.
- if (auto *fnTy = type->getAs<FunctionType>()) {
- if (fnTy->isNoEscape() && typeVar->getImpl().getGenericParameter()) {
- if (shouldAttemptFixes()) {
- auto *fix = MarkExplicitlyEscaping::create(
- *this, getConstraintLocator(locator));
- if (recordFix(fix))
- return getTypeMatchFailure(locator);
-
- // Allow no-escape function to be bound with recorded fix.
- } else {
+ // Disallow bindings of types containing noescape functions to type
+ // variables that represent an opened generic parameter. If we allowed
+ // this it would allow noescape functions to potentially escape.
+ if (type->isNoEscape() && typeVar->getImpl().getGenericParameter()) {
+ if (shouldAttemptFixes()) {
+ auto *fix = MarkExplicitlyEscaping::create(
+ *this, getConstraintLocator(locator));
+ if (recordFix(fix))
return getTypeMatchFailure(locator);
- }
+
+ // Allow no-escape function to be bound with recorded fix.
+ } else {
+ return getTypeMatchFailure(locator);
}
}
@@ -2413,23 +2411,21 @@
type2->isExistentialType()) {
// Penalize conversions to Any, and disallow conversions of
- // noescape functions to Any.
+ // types containing noescape functions to Any.
if (kind >= ConstraintKind::Conversion && type2->isAny()) {
- if (auto *fnTy = type1->getAs<FunctionType>()) {
- if (fnTy->isNoEscape()) {
- if (shouldAttemptFixes()) {
- auto &ctx = getASTContext();
- auto *fix = MarkExplicitlyEscaping::create(
- *this, getConstraintLocator(locator), ctx.TheAnyType);
- if (recordFix(fix))
- return getTypeMatchFailure(locator);
-
- // Allow 'no-escape' functions to be converted to 'Any'
- // with a recorded fix that helps us to properly diagnose
- // such situations.
- } else {
+ if (type1->isNoEscape()) {
+ if (shouldAttemptFixes()) {
+ auto &ctx = getASTContext();
+ auto *fix = MarkExplicitlyEscaping::create(
+ *this, getConstraintLocator(locator), ctx.TheAnyType);
+ if (recordFix(fix))
return getTypeMatchFailure(locator);
- }
+
+ // Allow 'no-escape' functions to be converted to 'Any'
+ // with a recorded fix that helps us to properly diagnose
+ // such situations.
+ } else {
+ return getTypeMatchFailure(locator);
}
}
diff --git a/lib/Sema/MiscDiagnostics.cpp b/lib/Sema/MiscDiagnostics.cpp
index 6ceaf46..f4d7fc4 100644
--- a/lib/Sema/MiscDiagnostics.cpp
+++ b/lib/Sema/MiscDiagnostics.cpp
@@ -63,7 +63,6 @@
bool isExprStmt) {
class DiagnoseWalker : public ASTWalker {
SmallPtrSet<Expr*, 4> AlreadyDiagnosedMetatypes;
- SmallPtrSet<DeclRefExpr*, 4> AlreadyDiagnosedNoEscapes;
SmallPtrSet<DeclRefExpr*, 4> AlreadyDiagnosedBitCasts;
// Keep track of acceptable DiscardAssignmentExpr's.
@@ -84,23 +83,6 @@
DiagnoseWalker(TypeChecker &TC, const DeclContext *DC, bool isExprStmt)
: IsExprStmt(isExprStmt), TC(TC), DC(DC) {}
- // Selector for the partial_application_of_function_invalid diagnostic
- // message.
- struct PartialApplication {
- enum : unsigned {
- MutatingMethod,
- SuperInit,
- SelfInit,
- };
- enum : unsigned {
- Error,
- CompatibilityWarning,
- };
- unsigned compatibilityWarning: 1;
- unsigned kind : 2;
- unsigned level : 29;
- };
-
// Not interested in going outside a basic expression.
std::pair<bool, Stmt *> walkToStmtPre(Stmt *S) override {
return { false, S };
@@ -129,9 +111,6 @@
checkUseOfMetaTypeName(Base);
}
- // Verify noescape parameter uses.
- checkNoEscapeParameterUse(DRE, Parent.getAsExpr(), OperandKind::None);
-
// Verify warn_unqualified_access uses.
checkUnqualifiedAccessUse(DRE);
@@ -155,12 +134,6 @@
if (auto *IOE = dyn_cast<InOutExpr>(SE->getBase()))
if (IOE->isImplicit())
AcceptableInOutExprs.insert(IOE);
-
- visitIndices(SE, [&](unsigned argIndex, Expr *arg) {
- arg = lookThroughArgument(arg);
- if (auto *DRE = dyn_cast<DeclRefExpr>(arg))
- checkNoEscapeParameterUse(DRE, SE, OperandKind::Argument);
- });
}
if (auto *KPE = dyn_cast<KeyPathExpr>(E)) {
@@ -170,21 +143,6 @@
}
}
- if (auto *AE = dyn_cast<CollectionExpr>(E)) {
- visitCollectionElements(AE, [&](unsigned argIndex, Expr *arg) {
- arg = lookThroughArgument(arg);
- if (auto *DRE = dyn_cast<DeclRefExpr>(arg))
- checkNoEscapeParameterUse(DRE, AE, OperandKind::Argument);
- });
- }
-
- // Check decl refs in withoutActuallyEscaping blocks.
- if (auto MakeEsc = dyn_cast<MakeTemporarilyEscapableExpr>(E)) {
- if (auto DRE =
- dyn_cast<DeclRefExpr>(MakeEsc->getNonescapingClosureValue()))
- checkNoEscapeParameterUse(DRE, MakeEsc, OperandKind::MakeEscapable);
- }
-
// Check function calls, looking through implicit conversions on the
// function and inspecting the arguments directly.
if (auto *Call = dyn_cast<ApplyExpr>(E)) {
@@ -221,7 +179,6 @@
ConcreteDeclRef callee;
if (auto *calleeDRE = dyn_cast<DeclRefExpr>(base)) {
- checkNoEscapeParameterUse(calleeDRE, Call, OperandKind::Callee);
checkForSuspiciousBitCasts(calleeDRE, Call);
callee = calleeDRE->getDeclRef();
@@ -267,12 +224,6 @@
unwrapped, operand);
}
}
-
- // Also give special treatment to noescape function arguments.
- arg = lookThroughArgument(arg);
-
- if (auto *DRE = dyn_cast<DeclRefExpr>(arg))
- checkNoEscapeParameterUse(DRE, Call, OperandKind::Argument);
});
}
@@ -339,25 +290,12 @@
}
}
- static void visitIndices(SubscriptExpr *subscript,
- llvm::function_ref<void(unsigned, Expr*)> fn) {
- auto *indexArgs = subscript->getIndex();
- argExprVisitArguments(indexArgs, fn);
- }
-
static void visitArguments(ApplyExpr *apply,
llvm::function_ref<void(unsigned, Expr*)> fn) {
auto *arg = apply->getArg();
argExprVisitArguments(arg, fn);
}
- static void visitCollectionElements(CollectionExpr *collection,
- llvm::function_ref<void(unsigned, Expr*)> fn) {
- auto elts = collection->getElements();
- for (auto i : indices(elts))
- fn(i, elts[i]);
- }
-
static Expr *lookThroughArgument(Expr *arg) {
while (1) {
if (auto conv = dyn_cast<ImplicitConversionExpr>(arg))
@@ -474,159 +412,6 @@
TC.diagnose(E->getStartLoc(), diag::value_of_module_type);
}
- class NoEscapeArgument {
- llvm::PointerIntPair<ParamDecl*, 1, bool> ParamAndIsCapture;
- public:
- NoEscapeArgument() {}
- NoEscapeArgument(ParamDecl *param, bool isCapture)
- : ParamAndIsCapture(param, isCapture) {
- assert(param);
- }
-
- explicit operator bool() const {
- return ParamAndIsCapture.getPointer() != nullptr;
- }
-
- ParamDecl *getDecl() const { return ParamAndIsCapture.getPointer(); }
- bool isDeclACapture() const { return ParamAndIsCapture.getInt(); }
-
- static NoEscapeArgument find(TypeChecker &tc, ValueDecl *decl,
- bool isCapture) {
- if (auto param = dyn_cast<ParamDecl>(decl)) {
- if (auto fnType =
- param->getInterfaceType()->getAs<AnyFunctionType>()) {
- if (fnType->isNoEscape())
- return { param, isCapture };
- }
- return {};
- }
-
- if (auto fn = dyn_cast<AbstractFunctionDecl>(decl)) {
- if (fn->getDeclContext()->isLocalContext()) {
- return findInCaptures(tc, fn);
- }
- return {};
- }
-
- // FIXME: captures of computed local vars? Can these be non-escaping?
- return {};
- }
-
- static NoEscapeArgument findInCaptures(TypeChecker &tc,
- AnyFunctionRef fn) {
- // Ensure we have accurate capture information for the function.
- tc.computeCaptures(fn);
-
- for (const auto &capture : fn.getCaptureInfo().getCaptures()) {
- if (capture.isDynamicSelfMetadata()) continue;
- if (auto param = find(tc, capture.getDecl(), true))
- return param;
- }
- return {};
- }
- };
-
- /// Enforce the exclusivity rule against calling a non-escaping
- /// function parameter with another non-escaping function parameter
- /// as an argument.
- void checkNoEscapeParameterCall(ApplyExpr *apply) {
- NoEscapeArgument noescapeArgument;
- Expr *problematicArg = nullptr;
-
- visitArguments(apply, [&](unsigned argIndex, Expr *arg) {
- // Just find the first problematic argument.
- if (noescapeArgument) return;
-
- // Remember the expression which used the argument.
- problematicArg = arg;
-
- // Look through the same set of nodes that we look through when
- // checking for no-escape functions.
- arg = lookThroughArgument(arg);
-
- // If the argument isn't noescape, ignore it.
- auto fnType = arg->getType()->getAs<AnyFunctionType>();
- if (!fnType || !fnType->isNoEscape())
- return;
-
- // Okay, it should be a closure or a decl ref.
- if (auto declRef = dyn_cast<DeclRefExpr>(arg)) {
- noescapeArgument =
- NoEscapeArgument::find(TC, declRef->getDecl(), false);
- } else if (auto closure = dyn_cast<AbstractClosureExpr>(arg)) {
- noescapeArgument =
- NoEscapeArgument::findInCaptures(TC, closure);
- } else {
- // This can happen with withoutActuallyEscaping.
- assert(isa<OpaqueValueExpr>(arg) &&
- "unexpected expression yielding noescape closure");
- }
- });
-
- if (!noescapeArgument) return;
-
- TC.diagnose(apply->getLoc(),
- diag::err_noescape_param_call,
- noescapeArgument.getDecl()->getName(),
- noescapeArgument.isDeclACapture())
- .highlight(problematicArg->getSourceRange());
- }
-
- enum class OperandKind {
- None,
- Callee,
- Argument,
- MakeEscapable,
- };
-
- /// The DRE argument is a reference to a noescape parameter. Verify that
- /// its uses are ok.
- void checkNoEscapeParameterUse(DeclRefExpr *DRE, Expr *parent,
- OperandKind useKind) {
- // This only cares about declarations of noescape function type.
- auto AFT = DRE->getType()->getAs<FunctionType>();
- if (!AFT || !AFT->isNoEscape())
- return;
-
- // Only diagnose this once. If we check and accept this use higher up in
- // the AST, don't recheck here.
- if (!AlreadyDiagnosedNoEscapes.insert(DRE).second)
- return;
-
- // The only valid use of the noescape parameter is an immediate call,
- // either as the callee or as an argument (in which case, the typechecker
- // validates that the noescape bit didn't get stripped off), or as
- // a special case, e.g. in the binding of a withoutActuallyEscaping block
- // or the argument of a type(of: ...).
- if (parent) {
- if (auto apply = dyn_cast<ApplyExpr>(parent)) {
- if (isa<ParamDecl>(DRE->getDecl()) && useKind == OperandKind::Callee)
- checkNoEscapeParameterCall(apply);
- return;
- } else if (isa<SubscriptExpr>(parent)
- && useKind == OperandKind::Argument) {
- return;
- } else if (isa<MakeTemporarilyEscapableExpr>(parent)) {
- return;
- } else if (isa<DynamicTypeExpr>(parent)) {
- return;
- }
- }
-
- TC.diagnose(DRE->getStartLoc(), diag::invalid_noescape_use,
- cast<VarDecl>(DRE->getDecl())->getName(),
- isa<ParamDecl>(DRE->getDecl()));
-
- // If we're a parameter, emit a helpful fixit to add @escaping
- auto paramDecl = dyn_cast<ParamDecl>(DRE->getDecl());
- if (paramDecl) {
- TC.diagnose(paramDecl->getStartLoc(), diag::noescape_parameter,
- paramDecl->getName())
- .fixItInsert(paramDecl->getTypeLoc().getSourceRange().Start,
- "@escaping ");
- }
- }
-
// Diagnose metatype values that don't appear as part of a property,
// method, or constructor reference.
void checkUseOfMetaTypeName(Expr *E) {
@@ -2276,7 +2061,8 @@
vdi->second |= Flag;
}
- void markBaseOfAbstractStorageDeclStore(Expr *E, ConcreteDeclRef decl);
+ void markBaseOfStorageUse(Expr *E, ConcreteDeclRef decl, unsigned flags);
+ void markBaseOfStorageUse(Expr *E, bool isMutating);
void markStoredOrInOutExpr(Expr *E, unsigned Flags);
@@ -2655,29 +2441,57 @@
}
}
-/// Handle a store to "x.y" where 'base' is the expression for x and 'decl' is
-/// the decl for 'y'.
-void VarDeclUsageChecker::
-markBaseOfAbstractStorageDeclStore(Expr *base, ConcreteDeclRef decl) {
- // If the base is a class or an rvalue, then this store just loads the base.
- if (base->getType()->isAnyClassReferenceType() ||
- !(base->getType()->hasLValueType() || base->isSemanticallyInOutExpr())) {
+/// Handle a use of "x.y" or "x[0]" where 'base' is the expression for x and
+/// 'decl' is the property or subscript.
+///
+/// TODO: Rip this out and just rely on LValueAccessKind.
+void VarDeclUsageChecker::markBaseOfStorageUse(Expr *base, ConcreteDeclRef decl,
+ unsigned flags) {
+ // If the base is an rvalue, then we know that this is a non-mutating access.
+ // Note that we can have mutating accesses even when the base has class or
+ // metatype type due to protocols and protocol extensions.
+ if (!base->getType()->hasLValueType() &&
+ !base->isSemanticallyInOutExpr()) {
base->walk(*this);
return;
}
- // If the store is to a non-mutating member, then this is just a load, even
- // if the base is an inout expr.
- auto *ASD = cast<AbstractStorageDecl>(decl.getDecl());
- if (ASD->isSettable(nullptr) && !ASD->isSetterMutating()) {
- // Sema conservatively converts the base to inout expr when it is an lvalue.
- // Look through it because we know it isn't actually doing a load/store.
- if (auto *ioe = dyn_cast<InOutExpr>(base))
- base = ioe->getSubExpr();
+ // Compute whether this access is to a mutating member.
+ auto *ASD = dyn_cast_or_null<AbstractStorageDecl>(decl.getDecl());
+ bool isMutating = false;
+ if (!ASD) {
+ // If there's no abstract storage declaration (which should hopefully
+ // only happen with invalid code), treat the base access as mutating if
+ // the subobject is being mutated and the base type is not a class
+ // or metatype.
+ if (flags & RK_Written) {
+ Type type = base->getType()->getRValueType()->getInOutObjectType();
+ if (!type->isAnyClassReferenceType() && !type->is<AnyMetatypeType>())
+ isMutating = true;
+ }
+ } else {
+ // Otherwise, consider whether the accessors are mutating.
+ if (flags & RK_Read)
+ isMutating |= ASD->isGetterMutating();
+ if (flags & RK_Written)
+ isMutating |= ASD->isSettable(nullptr) && ASD->isSetterMutating();
+ }
+
+ markBaseOfStorageUse(base, isMutating);
+}
+
+void VarDeclUsageChecker::markBaseOfStorageUse(Expr *base, bool isMutating) {
+ // CSApply sometimes wraps the base in an InOutExpr just because the
+ // base is an l-value; look through that so we can get more precise
+ // checking.
+ if (auto *ioe = dyn_cast<InOutExpr>(base))
+ base = ioe->getSubExpr();
+
+ if (!isMutating) {
base->walk(*this);
return;
}
-
+
// Otherwise this is a read and write of the base.
return markStoredOrInOutExpr(base, RK_Written|RK_Read);
}
@@ -2712,25 +2526,22 @@
if (auto *SE = dyn_cast<SubscriptExpr>(E)) {
// The index of the subscript is evaluated as an rvalue.
SE->getIndex()->walk(*this);
- if (SE->hasDecl())
- markBaseOfAbstractStorageDeclStore(SE->getBase(), SE->getDecl());
- else // FIXME: Should not be needed!
- markStoredOrInOutExpr(SE->getBase(), RK_Written|RK_Read);
-
+ markBaseOfStorageUse(SE->getBase(), SE->getDecl(), Flags);
return;
}
// Likewise for key path applications. An application of a WritableKeyPath
- // reads and writes its base.
+ // reads and writes its base; an application of a ReferenceWritableKeyPath
+ // only reads its base; the other KeyPath types cannot be written at all.
if (auto *KPA = dyn_cast<KeyPathApplicationExpr>(E)) {
auto &C = KPA->getType()->getASTContext();
KPA->getKeyPath()->walk(*this);
- if (KPA->getKeyPath()->getType()->getAnyNominal()
- == C.getWritableKeyPathDecl())
- markStoredOrInOutExpr(KPA->getBase(), RK_Written|RK_Read);
- if (KPA->getKeyPath()->getType()->getAnyNominal()
- == C.getReferenceWritableKeyPathDecl())
- markStoredOrInOutExpr(KPA->getBase(), RK_Read);
+
+ bool isMutating =
+ (Flags & RK_Written) &&
+ KPA->getKeyPath()->getType()->getAnyNominal()
+ == C.getWritableKeyPathDecl();
+ markBaseOfStorageUse(KPA->getBase(), isMutating);
return;
}
@@ -2738,10 +2549,10 @@
return markStoredOrInOutExpr(ioe->getSubExpr(), RK_Written|RK_Read);
if (auto *MRE = dyn_cast<MemberRefExpr>(E)) {
- markBaseOfAbstractStorageDeclStore(MRE->getBase(), MRE->getMember());
+ markBaseOfStorageUse(MRE->getBase(), MRE->getMember(), Flags);
return;
}
-
+
if (auto *TEE = dyn_cast<TupleElementExpr>(E))
return markStoredOrInOutExpr(TEE->getBase(), Flags);
@@ -2750,6 +2561,12 @@
if (auto *BOE = dyn_cast<BindOptionalExpr>(E))
return markStoredOrInOutExpr(BOE->getSubExpr(), Flags);
+
+ // Bind existential expressions.
+ if (auto *OEE = dyn_cast<OpenExistentialExpr>(E)) {
+ OpaqueValueMap[OEE->getOpaqueValue()] = OEE->getExistentialValue();
+ return markStoredOrInOutExpr(OEE->getSubExpr(), Flags);
+ }
// If this is an OpaqueValueExpr that we've seen a mapping for, jump to the
// mapped value.
@@ -2788,8 +2605,16 @@
if (auto VD = dyn_cast<VarDecl>(MRE->getMember().getDecl())) {
if (AssociatedGetter == VD && AssociatedGetterRefExpr == nullptr)
AssociatedGetterRefExpr = MRE;
+ markBaseOfStorageUse(MRE->getBase(), MRE->getMember(), RK_Read);
+ return { false, E };
}
}
+ if (auto SE = dyn_cast<SubscriptExpr>(E)) {
+ SE->getIndex()->walk(*this);
+ markBaseOfStorageUse(SE->getBase(), SE->getDecl(), RK_Read);
+ return { false, E };
+ }
+
// If this is an AssignExpr, see if we're mutating something that we know
// about.
if (auto *assign = dyn_cast<AssignExpr>(E)) {
@@ -2810,6 +2635,13 @@
// If we see an OpenExistentialExpr, remember the mapping for its OpaqueValue.
if (auto *oee = dyn_cast<OpenExistentialExpr>(E))
OpaqueValueMap[oee->getOpaqueValue()] = oee->getExistentialValue();
+
+ // Visit bindings.
+ if (auto ove = dyn_cast<OpaqueValueExpr>(E)) {
+ if (auto mapping = OpaqueValueMap.lookup(ove))
+ mapping->walk(*this);
+ return { false, E };
+ }
// If we saw an ErrorExpr, take note of this.
if (isa<ErrorExpr>(E))
diff --git a/lib/Sema/ResilienceDiagnostics.cpp b/lib/Sema/ResilienceDiagnostics.cpp
index 10bc318..27c31b8 100644
--- a/lib/Sema/ResilienceDiagnostics.cpp
+++ b/lib/Sema/ResilienceDiagnostics.cpp
@@ -25,7 +25,8 @@
std::pair<FragileFunctionKind, bool>
TypeChecker::getFragileFunctionKind(const DeclContext *DC) {
- for (; DC->isLocalContext(); DC = DC->getParent()) {
+ for (DC = DC->getLocalContext(); DC && DC->isLocalContext();
+ DC = DC->getParent()) {
if (isa<DefaultArgumentInitializer>(DC)) {
// Default argument generators of public functions cannot reference
// @usableFromInline declarations; all other fragile function kinds
@@ -176,6 +177,11 @@
diagName = accessor->getStorage()->getFullName();
}
+ // Swift 5.0 did not check the underlying types of local typealiases.
+ // FIXME: Conditionalize this once we have a new language mode.
+ if (isa<TypeAliasDecl>(DC))
+ downgradeToWarning = DowngradeToWarning::Yes;
+
auto diagID = diag::resilience_decl_unavailable;
if (downgradeToWarning == DowngradeToWarning::Yes)
diagID = diag::resilience_decl_unavailable_warn;
diff --git a/lib/Sema/TypeCheckAccess.cpp b/lib/Sema/TypeCheckAccess.cpp
index faf5e84..1c1ac6e 100644
--- a/lib/Sema/TypeCheckAccess.cpp
+++ b/lib/Sema/TypeCheckAccess.cpp
@@ -1494,12 +1494,12 @@
offendingType->getFullName(), M->getName());
highlightOffendingType(TC, diag, complainRepr);
}
-
- static_assert(std::is_convertible<DiagnoseGenerically,
- CheckImplementationOnlyCallback>::value,
- "DiagnoseGenerically has wrong call signature");
};
+ static_assert(std::is_convertible<DiagnoseGenerically,
+ CheckImplementationOnlyCallback>::value,
+ "DiagnoseGenerically has wrong call signature");
+
DiagnoseGenerically getDiagnoseCallback(const Decl *D) {
return DiagnoseGenerically(TC, D);
}
diff --git a/lib/Sema/TypeCheckCaptures.cpp b/lib/Sema/TypeCheckCaptures.cpp
index 2fc3b0e..8828920 100644
--- a/lib/Sema/TypeCheckCaptures.cpp
+++ b/lib/Sema/TypeCheckCaptures.cpp
@@ -199,34 +199,6 @@
|| !isa<VarDecl>(VD)
|| !cast<VarDecl>(VD)->getType()->hasRetainablePointerRepresentation()))
checkType(VD->getInterfaceType(), VD->getLoc());
-
- // If VD is a noescape decl, then the closure we're computing this for
- // must also be noescape.
- if (AFR.hasType() &&
- !AFR.getType()->hasError() &&
- VD->hasInterfaceType() &&
- VD->getInterfaceType()->is<AnyFunctionType>() &&
- VD->getInterfaceType()->castTo<AnyFunctionType>()->isNoEscape() &&
- !capture.isNoEscape() &&
- // Don't repeatedly diagnose the same thing.
- Diagnosed.insert(VD).second) {
-
- // Otherwise, diagnose this as an invalid capture.
- bool isDecl = AFR.getAbstractFunctionDecl() != nullptr;
-
- TC.diagnose(Loc, isDecl ? diag::decl_closure_noescape_use
- : diag::closure_noescape_use,
- VD->getBaseName().getIdentifier());
-
- // If we're a parameter, emit a helpful fixit to add @escaping
- auto paramDecl = dyn_cast<ParamDecl>(VD);
- if (paramDecl) {
- TC.diagnose(paramDecl->getStartLoc(), diag::noescape_parameter,
- paramDecl->getName())
- .fixItInsert(paramDecl->getTypeLoc().getSourceRange().Start,
- "@escaping ");
- }
- }
}
bool shouldWalkIntoLazyInitializers() override {
@@ -393,24 +365,6 @@
if (!validateForwardCapture(DRE->getDecl()))
return { false, DRE };
- bool isInOut = (isa<ParamDecl>(D) && cast<ParamDecl>(D)->isInOut());
- bool isNested = false;
- if (auto f = AFR.getAbstractFunctionDecl())
- isNested = f->getDeclContext()->isLocalContext();
-
- if (isInOut && !AFR.isKnownNoEscape() && !isNested) {
- if (D->getBaseName() == D->getASTContext().Id_self) {
- TC.diagnose(DRE->getLoc(),
- diag::closure_implicit_capture_mutating_self);
- TC.diagnose(DRE->getLoc(),
- diag::create_mutating_copy_or_capture_self);
- } else {
- TC.diagnose(DRE->getLoc(),
- diag::closure_implicit_capture_without_noescape);
- }
- return { false, DRE };
- }
-
// We're going to capture this, compute flags for the capture.
unsigned Flags = 0;
@@ -734,28 +688,6 @@
if (AFR.getBody())
AFR.getBody()->walk(finder);
- unsigned inoutCount = 0;
- for (auto C : Captures) {
- if (auto PD = dyn_cast<ParamDecl>(C.getDecl()))
- if (PD->isInOut())
- inoutCount++;
- }
-
- if (inoutCount > 0) {
- if (auto e = AFR.getAbstractFunctionDecl()) {
- for (auto returnOccurrence : getEscapingFunctionAsReturnValue(e)) {
- diagnose(returnOccurrence->getReturnLoc(),
- diag::nested_function_escaping_inout_capture);
- }
- auto occurrences = getEscapingFunctionAsArgument(e);
- for (auto occurrence : occurrences) {
- diagnose(occurrence->getLoc(),
- diag::nested_function_with_implicit_capture_argument,
- inoutCount > 1);
- }
- }
- }
-
if (AFR.hasType() && !AFR.isObjC()) {
finder.checkType(AFR.getType(), getCaptureLoc(AFR));
}
diff --git a/lib/Sema/TypeCheckStmt.cpp b/lib/Sema/TypeCheckStmt.cpp
index e3d5c55..6121eab 100644
--- a/lib/Sema/TypeCheckStmt.cpp
+++ b/lib/Sema/TypeCheckStmt.cpp
@@ -472,11 +472,7 @@
tryDiagnoseUnnecessaryCastOverOptionSet(TC.Context, E, ResultTy,
DC->getParentModule());
}
- while (auto ICE = dyn_cast<ImplicitConversionExpr>(E))
- E = ICE->getSubExpr();
- if (auto DRE = dyn_cast<DeclRefExpr>(E))
- if (auto FD = dyn_cast<FuncDecl>(DRE->getDecl()))
- TC.addEscapingFunctionAsReturnValue(FD, RS);
+
return RS;
}
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
index 6767a8b..6d2443b 100644
--- a/lib/Sema/TypeCheckType.cpp
+++ b/lib/Sema/TypeCheckType.cpp
@@ -24,6 +24,7 @@
#include "swift/Strings.h"
#include "swift/AST/ASTVisitor.h"
#include "swift/AST/ASTWalker.h"
+#include "swift/AST/DiagnosticsParse.h"
#include "swift/AST/ExistentialLayout.h"
#include "swift/AST/ForeignErrorConvention.h"
#include "swift/AST/GenericEnvironment.h"
@@ -2053,7 +2054,8 @@
auto checkUnsupportedAttr = [&](TypeAttrKind attr) {
if (attrs.has(attr)) {
- diagnose(attrs.getLoc(attr), diag::attribute_not_supported);
+ diagnose(attrs.getLoc(attr), diag::unknown_attribute,
+ TypeAttributes::getAttrName(attr));
attrs.clearAttribute(attr);
}
};
@@ -2061,7 +2063,12 @@
// Some function representation attributes are not supported at source level;
// only SIL knows how to handle them. Reject them unless this is a SIL input.
if (!(options & TypeResolutionFlags::SILType)) {
- for (auto silOnlyAttr : {TAK_callee_owned, TAK_callee_guaranteed}) {
+ for (auto silOnlyAttr : {TAK_pseudogeneric,
+ TAK_callee_owned,
+ TAK_callee_guaranteed,
+ TAK_noescape,
+ TAK_yield_once,
+ TAK_yield_many}) {
checkUnsupportedAttr(silOnlyAttr);
}
}
@@ -2181,7 +2188,7 @@
}
// Resolve the function type directly with these attributes.
- FunctionType::ExtInfo extInfo(rep, attrs.has(TAK_noescape),
+ FunctionType::ExtInfo extInfo(rep, /*noescape=*/false,
fnRepr->throws());
ty = resolveASTFunctionType(fnRepr, options, extInfo);
@@ -2208,7 +2215,7 @@
}
// Handle @escaping
- if (hasFunctionAttr && ty->is<FunctionType>()) {
+ if (ty->is<FunctionType>()) {
if (attrs.has(TAK_escaping)) {
// The attribute is meaningless except on non-variadic parameter types.
if (!isParam || options.getBaseContext() == TypeResolverContext::EnumElementDecl) {
@@ -2233,9 +2240,6 @@
if (hasFunctionAttr && !fnRepr) {
if (attrs.has(TAK_autoclosure)) {
- // @autoclosure usually auto-implies @noescape,
- // don't complain about both of them.
- attrs.clearAttribute(TAK_noescape);
// @autoclosure is going to be diagnosed when type of
// the parameter is validated, because that attribute
// applies to the declaration now.
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
index 7aabd5d..b76b4eb 100644
--- a/lib/Sema/TypeChecker.h
+++ b/lib/Sema/TypeChecker.h
@@ -606,61 +606,9 @@
llvm::DenseMap<AnyFunctionRef, std::vector<Expr*>> LocalCFunctionPointers;
private:
- /// Return statements with functions as return values.
- llvm::DenseMap<AbstractFunctionDecl *, llvm::DenseSet<ReturnStmt *>>
- FunctionAsReturnValue;
-
- /// Function apply expressions with a certain function as an argument.
- llvm::DenseMap<AbstractFunctionDecl *, llvm::DenseSet<ApplyExpr *>>
- FunctionAsEscapingArg;
-
/// The # of times we have performed typo correction.
unsigned NumTypoCorrections = 0;
-public:
- /// Record an occurrence of a function that captures inout values as an
- /// argument.
- ///
- /// \param decl the function that occurs as an argument.
- ///
- /// \param apply the expression in which the function appears.
- void addEscapingFunctionAsArgument(AbstractFunctionDecl *decl,
- ApplyExpr *apply) {
- FunctionAsEscapingArg[decl].insert(apply);
- }
-
- /// Find occurrences of a function that captures inout values as arguments.
- ///
- /// \param decl the function that occurs as an argument.
- ///
- /// \returns Expressions in which the function appears as arguments.
- llvm::DenseSet<ApplyExpr *> &
- getEscapingFunctionAsArgument(AbstractFunctionDecl *decl) {
- return FunctionAsEscapingArg[decl];
- }
-
- /// Record an occurrence of a function that captures inout values as a return
- /// value
- ///
- /// \param decl the function that occurs as a return value.
- ///
- /// \param stmt the expression in which the function appears.
- void addEscapingFunctionAsReturnValue(AbstractFunctionDecl *decl,
- ReturnStmt *stmt) {
- FunctionAsReturnValue[decl].insert(stmt);
- }
-
- /// Find occurrences of a function that captures inout values as return
- /// values.
- ///
- /// \param decl the function that occurs as a return value.
- ///
- /// \returns Expressions in which the function appears as arguments.
- llvm::DenseSet<ReturnStmt *> &
- getEscapingFunctionAsReturnValue(AbstractFunctionDecl *decl) {
- return FunctionAsReturnValue[decl];
- }
-
private:
Type MaxIntegerType;
Type NSObjectType;
diff --git a/stdlib/CMakeLists.txt b/stdlib/CMakeLists.txt
index ecf078b..95ecb33 100644
--- a/stdlib/CMakeLists.txt
+++ b/stdlib/CMakeLists.txt
@@ -143,7 +143,7 @@
"swift-stdlib-${platform}-${arch}"
"copy-legacy-layouts-${platform}-${arch}")
- swift_install_in_component(stdlib
+ swift_install_in_component(compiler
FILES ${input}
DESTINATION "lib/swift/${platform}/")
else()
diff --git a/stdlib/private/StdlibUnittest/StdlibUnittest.swift b/stdlib/private/StdlibUnittest/StdlibUnittest.swift
index 55a89e0..3bbe192 100644
--- a/stdlib/private/StdlibUnittest/StdlibUnittest.swift
+++ b/stdlib/private/StdlibUnittest/StdlibUnittest.swift
@@ -1777,7 +1777,7 @@
}
public func _parseDottedVersionTriple(_ s: String) -> (Int, Int, Int) {
- var array = _parseDottedVersion(s)
+ let array = _parseDottedVersion(s)
if array.count >= 4 {
fatalError("unexpected version")
}
diff --git a/stdlib/public/SwiftShims/CMakeLists.txt b/stdlib/public/SwiftShims/CMakeLists.txt
index 88a51ce..5fe05a0 100644
--- a/stdlib/public/SwiftShims/CMakeLists.txt
+++ b/stdlib/public/SwiftShims/CMakeLists.txt
@@ -105,7 +105,7 @@
COMMENT "Symlinking Clang resource headers into ${SWIFTLIB_DIR}/clang")
add_dependencies(copy_shim_headers symlink_clang_headers)
-swift_install_in_component(compiler
+swift_install_in_component(stdlib
FILES ${sources}
DESTINATION "lib/swift/shims")
diff --git a/stdlib/public/core/Builtin.swift b/stdlib/public/core/Builtin.swift
index 446b924..87067619 100644
--- a/stdlib/public/core/Builtin.swift
+++ b/stdlib/public/core/Builtin.swift
@@ -301,17 +301,6 @@
_ = Builtin.assume_Int1(condition._value)
}
-// This function is no longer used but must be kept for ABI compatibility
-// because references to it may have been inlined.
-@usableFromInline
-internal func _branchHint(_ actual: Bool, expected: Bool) -> Bool {
- // The LLVM intrinsic underlying int_expect_Int1 now requires an immediate
- // argument for the expected value so we cannot call it here. This should
- // never be called in cases where performance matters, so just return the
- // value without any branch hint.
- return actual
-}
-
//===--- Runtime shim wrappers --------------------------------------------===//
/// Returns `true` iff the class indicated by `theClass` uses native
diff --git a/stdlib/public/core/LegacyABI.swift b/stdlib/public/core/LegacyABI.swift
index 604a86b..05b783b 100644
--- a/stdlib/public/core/LegacyABI.swift
+++ b/stdlib/public/core/LegacyABI.swift
@@ -60,3 +60,14 @@
return try copy.withUTF8(body)
}
}
+
+// This function is no longer used but must be kept for ABI compatibility
+// because references to it may have been inlined.
+@usableFromInline
+internal func _branchHint(_ actual: Bool, expected: Bool) -> Bool {
+ // The LLVM intrinsic underlying int_expect_Int1 now requires an immediate
+ // argument for the expected value so we cannot call it here. This should
+ // never be called in cases where performance matters, so just return the
+ // value without any branch hint.
+ return actual
+}
diff --git a/stdlib/public/core/SIMDVector.swift b/stdlib/public/core/SIMDVector.swift
index dce9b33..2d8aa80 100644
--- a/stdlib/public/core/SIMDVector.swift
+++ b/stdlib/public/core/SIMDVector.swift
@@ -33,7 +33,7 @@
/// conform to `SIMD`.
public protocol SIMDStorage {
/// The type of scalars in the vector space.
- associatedtype Scalar : Codable, Hashable
+ associatedtype Scalar: Codable, Hashable
/// The number of scalars, or elements, in the vector.
var scalarCount: Int { get }
@@ -48,26 +48,37 @@
subscript(index: Int) -> Scalar { get set }
}
+extension SIMDStorage {
+ /// The number of scalars, or elements, in a vector of this type.
+ @_alwaysEmitIntoClient
+ public static var scalarCount: Int {
+ // Wouldn't it make more sense to define the instance var in terms of the
+ // static var? Yes, probably, but by doing it this way we make the static
+ // var backdeployable.
+ return Self().scalarCount
+ }
+}
+
/// A type that can be used as an element in a SIMD vector.
public protocol SIMDScalar {
- associatedtype SIMDMaskScalar : SIMDScalar & FixedWidthInteger & SignedInteger
- associatedtype SIMD2Storage : SIMDStorage where SIMD2Storage.Scalar == Self
- associatedtype SIMD4Storage : SIMDStorage where SIMD4Storage.Scalar == Self
- associatedtype SIMD8Storage : SIMDStorage where SIMD8Storage.Scalar == Self
- associatedtype SIMD16Storage : SIMDStorage where SIMD16Storage.Scalar == Self
- associatedtype SIMD32Storage : SIMDStorage where SIMD32Storage.Scalar == Self
- associatedtype SIMD64Storage : SIMDStorage where SIMD64Storage.Scalar == Self
+ associatedtype SIMDMaskScalar: SIMDScalar & FixedWidthInteger & SignedInteger
+ associatedtype SIMD2Storage: SIMDStorage where SIMD2Storage.Scalar == Self
+ associatedtype SIMD4Storage: SIMDStorage where SIMD4Storage.Scalar == Self
+ associatedtype SIMD8Storage: SIMDStorage where SIMD8Storage.Scalar == Self
+ associatedtype SIMD16Storage: SIMDStorage where SIMD16Storage.Scalar == Self
+ associatedtype SIMD32Storage: SIMDStorage where SIMD32Storage.Scalar == Self
+ associatedtype SIMD64Storage: SIMDStorage where SIMD64Storage.Scalar == Self
}
/// A SIMD vector of a fixed number of elements.
-public protocol SIMD : SIMDStorage,
- Codable,
- Hashable,
- CustomStringConvertible,
- ExpressibleByArrayLiteral {
+public protocol SIMD: SIMDStorage,
+ Codable,
+ Hashable,
+ CustomStringConvertible,
+ ExpressibleByArrayLiteral {
/// The mask type resulting from pointwise comparisons of this vector type.
- associatedtype MaskStorage : SIMD
- where MaskStorage.Scalar : FixedWidthInteger & SignedInteger
+ associatedtype MaskStorage: SIMD
+ where MaskStorage.Scalar: FixedWidthInteger & SignedInteger
}
extension SIMD {
@@ -176,8 +187,10 @@
/// Creates a vector from the given sequence.
///
- /// - Parameter scalars: The elements to use in the vector. `scalars` must
- /// have the same number of elements as the vector type.
+ /// - Precondition: `scalars` must have the same number of elements as the
+ /// vector type.
+ ///
+ /// - Parameter scalars: The elements to use in the vector.
@inlinable
public init<S: Sequence>(_ scalars: S) where S.Element == Scalar {
self.init()
@@ -193,11 +206,116 @@
_preconditionFailure("Not enough elements in sequence.")
}
}
+
+ /// Extracts the scalars at specified indices to form a SIMD2.
+ ///
+ /// The elements of the index vector are wrapped modulo the count of elements
+ /// in this vector. Because of this, the index is always in-range and no trap
+ /// can occur.
+ @_alwaysEmitIntoClient
+ public subscript<Index>(index: SIMD2<Index>) -> SIMD2<Scalar>
+ where Index: FixedWidthInteger {
+ var result = SIMD2<Scalar>()
+ for i in result.indices {
+ result[i] = self[Int(index[i]) % scalarCount]
+ }
+ return result
+ }
+
+ /// Extracts the scalars at specified indices to form a SIMD3.
+ ///
+ /// The elements of the index vector are wrapped modulo the count of elements
+ /// in this vector. Because of this, the index is always in-range and no trap
+ /// can occur.
+ @_alwaysEmitIntoClient
+ public subscript<Index>(index: SIMD3<Index>) -> SIMD3<Scalar>
+ where Index: FixedWidthInteger {
+ var result = SIMD3<Scalar>()
+ for i in result.indices {
+ result[i] = self[Int(index[i]) % scalarCount]
+ }
+ return result
+ }
+
+ /// Extracts the scalars at specified indices to form a SIMD4.
+ ///
+ /// The elements of the index vector are wrapped modulo the count of elements
+ /// in this vector. Because of this, the index is always in-range and no trap
+ /// can occur.
+ @_alwaysEmitIntoClient
+ public subscript<Index>(index: SIMD4<Index>) -> SIMD4<Scalar>
+ where Index: FixedWidthInteger {
+ var result = SIMD4<Scalar>()
+ for i in result.indices {
+ result[i] = self[Int(index[i]) % scalarCount]
+ }
+ return result
+ }
+
+ /// Extracts the scalars at specified indices to form a SIMD8.
+ ///
+ /// The elements of the index vector are wrapped modulo the count of elements
+ /// in this vector. Because of this, the index is always in-range and no trap
+ /// can occur.
+ @_alwaysEmitIntoClient
+ public subscript<Index>(index: SIMD8<Index>) -> SIMD8<Scalar>
+ where Index: FixedWidthInteger {
+ var result = SIMD8<Scalar>()
+ for i in result.indices {
+ result[i] = self[Int(index[i]) % scalarCount]
+ }
+ return result
+ }
+
+ /// Extracts the scalars at specified indices to form a SIMD16.
+ ///
+ /// The elements of the index vector are wrapped modulo the count of elements
+ /// in this vector. Because of this, the index is always in-range and no trap
+ /// can occur.
+ @_alwaysEmitIntoClient
+ public subscript<Index>(index: SIMD16<Index>) -> SIMD16<Scalar>
+ where Index: FixedWidthInteger {
+ var result = SIMD16<Scalar>()
+ for i in result.indices {
+ result[i] = self[Int(index[i]) % scalarCount]
+ }
+ return result
+ }
+
+ /// Extracts the scalars at specified indices to form a SIMD32.
+ ///
+ /// The elements of the index vector are wrapped modulo the count of elements
+ /// in this vector. Because of this, the index is always in-range and no trap
+ /// can occur.
+ @_alwaysEmitIntoClient
+ public subscript<Index>(index: SIMD32<Index>) -> SIMD32<Scalar>
+ where Index: FixedWidthInteger {
+ var result = SIMD32<Scalar>()
+ for i in result.indices {
+ result[i] = self[Int(index[i]) % scalarCount]
+ }
+ return result
+ }
+
+ /// Extracts the scalars at specified indices to form a SIMD64.
+ ///
+ /// The elements of the index vector are wrapped modulo the count of elements
+ /// in this vector. Because of this, the index is always in-range and no trap
+ /// can occur.
+ @_alwaysEmitIntoClient
+ public subscript<Index>(index: SIMD64<Index>) -> SIMD64<Scalar>
+ where Index: FixedWidthInteger {
+ var result = SIMD64<Scalar>()
+ for i in result.indices {
+ result[i] = self[Int(index[i]) % scalarCount]
+ }
+ return result
+ }
}
// Implementations of comparison operations. These should eventually all
// be replaced with @_semantics to lower directly to vector IR nodes.
-extension SIMD where Scalar : Comparable {
+extension SIMD where Scalar: Comparable {
/// Returns a vector mask with the result of a pointwise less than
/// comparison.
@_transparent
@@ -215,6 +333,18 @@
for i in result.indices { result[i] = lhs[i] <= rhs[i] }
return result
}
+
+ /// The least element in the vector.
+ @_alwaysEmitIntoClient
+ public func min() -> Scalar {
+ return indices.reduce(into: self[0]) { $0 = Swift.min($0, self[$1]) }
+ }
+
+ /// The greatest element in the vector.
+ @_alwaysEmitIntoClient
+ public func max() -> Scalar {
+ return indices.reduce(into: self[0]) { $0 = Swift.max($0, self[$1]) }
+ }
}
// These operations should never need @_semantics; they should be trivial
@@ -268,7 +398,7 @@
}
}
-extension SIMD where Scalar : Comparable {
+extension SIMD where Scalar: Comparable {
/// Returns a vector mask with the result of a pointwise greater than or
/// equal comparison.
@_transparent
@@ -336,15 +466,31 @@
public static func .>(lhs: Self, rhs: Scalar) -> SIMDMask<MaskStorage> {
return lhs .> Self(repeating: rhs)
}
+
+ @_alwaysEmitIntoClient
+ public mutating func clamp(lowerBound: Self, upperBound: Self) {
+ self = self.clamped(lowerBound: lowerBound, upperBound: upperBound)
+ }
+
+ @_alwaysEmitIntoClient
+ public func clamped(lowerBound: Self, upperBound: Self) -> Self {
+ return Swift.min(upperBound, Swift.max(lowerBound, self))
+ }
}
-extension SIMD where Scalar : FixedWidthInteger {
+extension SIMD where Scalar: FixedWidthInteger {
/// A vector with zero in all lanes.
@_transparent
public static var zero: Self {
return Self()
}
+ /// A vector with one in all lanes.
+ @_alwaysEmitIntoClient
+ public static var one: Self {
+ return Self(repeating: 1)
+ }
+
/// Returns a vector with random values from within the specified range in
/// all lanes, using the given generator as a source for randomness.
@inlinable
@@ -390,16 +536,22 @@
}
}
-extension SIMD where Scalar : FloatingPoint {
+extension SIMD where Scalar: FloatingPoint {
/// A vector with zero in all lanes.
@_transparent
public static var zero: Self {
return Self()
}
+
+ /// A vector with one in all lanes.
+ @_alwaysEmitIntoClient
+ public static var one: Self {
+ return Self(repeating: 1)
+ }
}
extension SIMD
-where Scalar : BinaryFloatingPoint, Scalar.RawSignificand : FixedWidthInteger {
+where Scalar: BinaryFloatingPoint, Scalar.RawSignificand: FixedWidthInteger {
/// Returns a vector with random values from within the specified range in
/// all lanes, using the given generator as a source for randomness.
@inlinable
@@ -446,11 +598,11 @@
}
@_fixed_layout
-public struct SIMDMask<Storage> : SIMD
- where Storage : SIMD,
- Storage.Scalar : FixedWidthInteger & SignedInteger {
+public struct SIMDMask<Storage>: SIMD
+ where Storage: SIMD,
+ Storage.Scalar: FixedWidthInteger & SignedInteger {
- public var _storage : Storage
+ public var _storage: Storage
public typealias MaskStorage = Storage
@@ -506,7 +658,7 @@
// Implementations of integer operations. These should eventually all
// be replaced with @_semantics to lower directly to vector IR nodes.
-extension SIMD where Scalar : FixedWidthInteger {
+extension SIMD where Scalar: FixedWidthInteger {
@_transparent
public var leadingZeroBitCount: Self {
var result = Self()
@@ -604,11 +756,20 @@
for i in result.indices { result[i] = lhs[i] % rhs[i] }
return result
}
+
+ /// Returns the sum of the scalars in the vector, computed with wrapping
+ /// addition.
+ ///
+ /// Equivalent to indices.reduce(into: 0) { $0 &+= self[$1] }.
+ @_alwaysEmitIntoClient
+ public func wrappedSum() -> Scalar {
+ return indices.reduce(into: 0) { $0 &+= self[$1] }
+ }
}
// Implementations of floating-point operations. These should eventually all
// be replaced with @_semantics to lower directly to vector IR nodes.
-extension SIMD where Scalar : FloatingPoint {
+extension SIMD where Scalar: FloatingPoint {
@_transparent
public static func +(lhs: Self, rhs: Self) -> Self {
var result = Self()
@@ -657,6 +818,28 @@
for i in result.indices { result[i] = self[i].rounded(rule) }
return result
}
+
+ /// Returns the least scalar in the vector.
+ @_alwaysEmitIntoClient
+ public func min() -> Scalar {
+ return indices.reduce(into: self[0]) { $0 = Scalar.minimum($0, self[$1]) }
+ }
+
+ /// Returns the greatest scalar in the vector.
+ @_alwaysEmitIntoClient
+ public func max() -> Scalar {
+ return indices.reduce(into: self[0]) { $0 = Scalar.maximum($0, self[$1]) }
+ }
+
+ /// Returns the sum of the scalars in the vector.
+ @_alwaysEmitIntoClient
+ public func sum() -> Scalar {
+ // Implementation note: this eventually be defined to lower to either
+ // llvm.experimental.vector.reduce.fadd or an explicit tree-sum. Open-
+ // coding the tree sum is problematic, we probably need to define a
+ // Swift Builtin to support it.
+ return indices.reduce(into: 0) { $0 += self[$1] }
+ }
}
extension SIMDMask {
@@ -683,7 +866,7 @@
// These operations should never need @_semantics; they should be trivial
// wrappers around the core operations defined above.
-extension SIMD where Scalar : FixedWidthInteger {
+extension SIMD where Scalar: FixedWidthInteger {
@_transparent
public static func &(lhs: Scalar, rhs: Self) -> Self {
@@ -961,7 +1144,7 @@
}
}
-extension SIMD where Scalar : FloatingPoint {
+extension SIMD where Scalar: FloatingPoint {
@_transparent
public static prefix func -(rhs: Self) -> Self {
@@ -1085,7 +1268,6 @@
}
extension SIMDMask {
-
@_transparent
public static func .&(lhs: Bool, rhs: SIMDMask) -> SIMDMask {
return SIMDMask(repeating: lhs) .& rhs
@@ -1146,3 +1328,72 @@
lhs = lhs .| rhs
}
}
+
+/// True if any lane of mask is true.
+@_alwaysEmitIntoClient
+public func any<Storage>(_ mask: SIMDMask<Storage>) -> Bool {
+ return mask._storage.min() < 0
+}
+
+/// True if every lane of mask is true.
+@_alwaysEmitIntoClient
+public func all<Storage>(_ mask: SIMDMask<Storage>) -> Bool {
+ return mask._storage.max() < 0
+}
+
+/// The lanewise minimum of two vectors.
+///
+/// Each element of the result is the minimum of the corresponding elements
+/// of the inputs.
+@_alwaysEmitIntoClient
+public func min<V>(_ lhs: V, _ rhs: V) -> V
+where V: SIMD, V.Scalar: Comparable {
+ var result = V()
+ for i in result.indices {
+ result[i] = min(lhs[i], rhs[i])
+ }
+ return result
+}
+
+/// The lanewise maximum of two vectors.
+///
+/// Each element of the result is the maximum of the corresponding elements
+/// of the inputs.
+@_alwaysEmitIntoClient
+public func max<V>(_ lhs: V, _ rhs: V) -> V
+where V: SIMD, V.Scalar: Comparable {
+ var result = V()
+ for i in result.indices {
+ result[i] = max(lhs[i], rhs[i])
+ }
+ return result
+}
+
+
+/// The lanewise minimum of two vectors.
+///
+/// Each element of the result is the minimum of the corresponding elements
+/// of the inputs.
+@_alwaysEmitIntoClient
+public func min<V>(_ lhs: V, _ rhs: V) -> V
+where V: SIMD, V.Scalar: FloatingPoint {
+ var result = V()
+ for i in result.indices {
+ result[i] = V.Scalar.minimum(lhs[i], rhs[i])
+ }
+ return result
+}
+
+/// The lanewise maximum of two vectors.
+///
+/// Each element of the result is the maximum of the corresponding elements
+/// of the inputs.
+@_alwaysEmitIntoClient
+public func max<V>(_ lhs: V, _ rhs: V) -> V
+where V: SIMD, V.Scalar: FloatingPoint {
+ var result = V()
+ for i in result.indices {
+ result[i] = V.Scalar.maximum(lhs[i], rhs[i])
+ }
+ return result
+}
diff --git a/stdlib/public/core/SIMDVectorTypes.swift.gyb b/stdlib/public/core/SIMDVectorTypes.swift.gyb
index 76cb579..c245561 100644
--- a/stdlib/public/core/SIMDVectorTypes.swift.gyb
+++ b/stdlib/public/core/SIMDVectorTypes.swift.gyb
@@ -26,7 +26,7 @@
% storageN = 4 if n == 3 else n
/// A vector of ${spelledNumbers[n]} scalar values.
@_fixed_layout
-public struct SIMD${n}<Scalar> : SIMD where Scalar: SIMDScalar {
+public struct SIMD${n}<Scalar>: SIMD where Scalar: SIMDScalar {
public var _storage: Scalar.SIMD${storageN}Storage
@@ -69,9 +69,9 @@
/// Creates a new vector from the given elements.
///
/// - Parameters:
- % for i in range(n):
+% for i in range(n):
/// - ${'xyzw'[i]}: The ${ordinalPositions[i]} element of the vector.
- % end
+% end
@_transparent
public init(${', '.join([c + ': Scalar' for c in 'xyzw'[:n]])}) {
self.init(${', '.join('xyzw'[:n])})
@@ -113,14 +113,14 @@
% end
}
-extension SIMD${n} where Scalar : FixedWidthInteger {
+extension SIMD${n} where Scalar: FixedWidthInteger {
/// Creates a new vector from the given vector, truncating the bit patterns
/// of the given vector's elements if necessary.
///
/// - Parameter other: The vector to convert.
@inlinable
public init<Other>(truncatingIfNeeded other: SIMD${n}<Other>)
- where Other : FixedWidthInteger {
+ where Other: FixedWidthInteger {
self.init()
for i in indices { self[i] = Scalar(truncatingIfNeeded: other[i]) }
}
@@ -131,7 +131,7 @@
/// - Parameter other: The vector to convert.
@inlinable
public init<Other>(clamping other: SIMD${n}<Other>)
- where Other : FixedWidthInteger {
+ where Other: FixedWidthInteger {
self.init()
for i in indices { self[i] = Scalar(clamping: other[i]) }
}
@@ -148,14 +148,14 @@
_ other: SIMD${n}<Other>,
rounding rule: FloatingPointRoundingRule = .towardZero
)
- where Other : BinaryFloatingPoint {
+ where Other: BinaryFloatingPoint {
self.init()
// TODO: this should clamp
for i in indices { self[i] = Scalar(other[i].rounded(rule)) }
}
}
-extension SIMD${n} : CustomDebugStringConvertible {
+extension SIMD${n}: CustomDebugStringConvertible {
public var debugDescription: String {
return "SIMD${n}<\(Scalar.self)>(${', '.join(map(lambda c:
'\\(self['+ str(c) + '])',
@@ -163,13 +163,13 @@
}
}
-extension SIMD${n} where Scalar : BinaryFloatingPoint {
+extension SIMD${n} where Scalar: BinaryFloatingPoint {
/// Creates a new vector from the given vector of integers.
///
/// - Parameter other: The vector to convert.
@inlinable
public init<Other>(_ other: SIMD${n}<Other>)
- where Other : FixedWidthInteger {
+ where Other: FixedWidthInteger {
self.init()
for i in indices { self[i] = Scalar(other[i]) }
}
@@ -179,7 +179,7 @@
/// - Parameter other: The vector to convert.
@inlinable
public init<Other>(_ other: SIMD${n}<Other>)
- where Other : BinaryFloatingPoint {
+ where Other: BinaryFloatingPoint {
self.init()
for i in indices { self[i] = Scalar(other[i]) }
}
@@ -187,11 +187,27 @@
%end
+extension SIMD3 {
+ /// A three-element vector created by appending a scalar to a two-element vector.
+ @_alwaysEmitIntoClient
+ public init(_ xy: SIMD2<Scalar>, _ z: Scalar) {
+ self.init(xy.x, xy.y, z)
+ }
+}
+
+extension SIMD4 {
+ /// A four-element vector created by appending a scalar to a three-element vector.
+ @_alwaysEmitIntoClient
+ public init(_ xyz: SIMD3<Scalar>, _ w: Scalar) {
+ self.init(xyz.x, xyz.y, xyz.z, w)
+ }
+}
+
%for self_type in all_integer_types(word_bits):
% Self = self_type.stdlib_name
% BuiltinName = self_type.builtin_name
% Mask = Self if self_type.is_signed else self_type.get_opposite_signedness().stdlib_name
-extension ${Self} : SIMDScalar {
+extension ${Self}: SIMDScalar {
public typealias SIMDMaskScalar = ${Mask}
@@ -200,7 +216,7 @@
/// Storage for a vector of ${spelledNumbers[n]} integers.
@_fixed_layout
@_alignment(${bytes if bytes <= 16 else 16})
- public struct SIMD${n}Storage : SIMDStorage {
+ public struct SIMD${n}Storage: SIMDStorage {
public var _value: Builtin.Vec${n}x${BuiltinName}
@@ -236,7 +252,7 @@
%end
%for (Self, bits) in [('Float',32), ('Double',64)]:
-extension ${Self} : SIMDScalar {
+extension ${Self}: SIMDScalar {
public typealias SIMDMaskScalar = Int${bits}
@@ -245,7 +261,7 @@
/// Storage for a vector of ${spelledNumbers[n]} floating-point values.
@_fixed_layout
@_alignment(${bytes if bytes <= 16 else 16})
- public struct SIMD${n}Storage : SIMDStorage {
+ public struct SIMD${n}Storage: SIMDStorage {
public var _value: Builtin.Vec${n}xFPIEEE${bits}
diff --git a/stdlib/public/core/SmallString.swift b/stdlib/public/core/SmallString.swift
index 9d4570c..c3a973a 100644
--- a/stdlib/public/core/SmallString.swift
+++ b/stdlib/public/core/SmallString.swift
@@ -32,10 +32,8 @@
@usableFromInline
internal var _storage: RawBitPattern
- @inlinable
- internal var rawBits: RawBitPattern {
- @inline(__always) get { return _storage }
- }
+ @inlinable @inline(__always)
+ internal var rawBits: RawBitPattern { return _storage }
@inlinable
internal var leadingRawBits: UInt64 {
@@ -76,15 +74,13 @@
}
extension _SmallString {
- @inlinable
+ @inlinable @inline(__always)
internal static var capacity: Int {
- @inline(__always) get {
#if arch(i386) || arch(arm)
- return 10
+ return 10
#else
- return 15
+ return 15
#endif
- }
}
// Get an integer equivalent to the _StringObject.discriminatedObjectRawBits
@@ -95,30 +91,20 @@
return _storage.1.littleEndian
}
- @inlinable
- internal var capacity: Int {
- @inline(__always) get {
- return _SmallString.capacity
- }
- }
+ @inlinable @inline(__always)
+ internal var capacity: Int { return _SmallString.capacity }
- @inlinable
+ @inlinable @inline(__always)
internal var count: Int {
- @inline(__always) get {
- return _StringObject.getSmallCount(fromRaw: rawDiscriminatedObject)
- }
+ return _StringObject.getSmallCount(fromRaw: rawDiscriminatedObject)
}
- @inlinable
- internal var unusedCapacity: Int {
- @inline(__always) get { return capacity &- count }
- }
+ @inlinable @inline(__always)
+ internal var unusedCapacity: Int { return capacity &- count }
- @inlinable
+ @inlinable @inline(__always)
internal var isASCII: Bool {
- @inline(__always) get {
- return _StringObject.getSmallIsASCII(fromRaw: rawDiscriminatedObject)
- }
+ return _StringObject.getSmallIsASCII(fromRaw: rawDiscriminatedObject)
}
// Give raw, nul-terminated code units. This is only for limited internal
@@ -170,11 +156,11 @@
@usableFromInline
internal typealias SubSequence = _SmallString
- @inlinable
- internal var startIndex: Int { @inline(__always) get { return 0 } }
+ @inlinable @inline(__always)
+ internal var startIndex: Int { return 0 }
- @inlinable
- internal var endIndex: Int { @inline(__always) get { return count } }
+ @inlinable @inline(__always)
+ internal var endIndex: Int { return count }
@inlinable
internal subscript(_ idx: Int) -> UInt8 {
@@ -196,15 +182,12 @@
}
}
- @inlinable // FIXME(inline-always) was usableFromInline
- // testable
+ @inlinable @inline(__always)
internal subscript(_ bounds: Range<Index>) -> SubSequence {
- @inline(__always) get {
- // TODO(String performance): In-vector-register operation
- return self.withUTF8 { utf8 in
- let rebased = UnsafeBufferPointer(rebasing: utf8[bounds])
- return _SmallString(rebased)._unsafelyUnwrappedUnchecked
- }
+ // TODO(String performance): In-vector-register operation
+ return self.withUTF8 { utf8 in
+ let rebased = UnsafeBufferPointer(rebasing: utf8[bounds])
+ return _SmallString(rebased)._unsafelyUnwrappedUnchecked
}
}
}
diff --git a/stdlib/public/core/StringCharacterView.swift b/stdlib/public/core/StringCharacterView.swift
index d25e984..826cce9 100644
--- a/stdlib/public/core/StringCharacterView.swift
+++ b/stdlib/public/core/StringCharacterView.swift
@@ -35,25 +35,20 @@
/// The position of the first character in a nonempty string.
///
/// In an empty string, `startIndex` is equal to `endIndex`.
- @inlinable
- public var startIndex: Index {
- @inline(__always) get { return _guts.startIndex }
- }
+ @inlinable @inline(__always)
+ public var startIndex: Index { return _guts.startIndex }
/// A string's "past the end" position---that is, the position one greater
/// than the last valid subscript argument.
///
/// In an empty string, `endIndex` is equal to `startIndex`.
- @inlinable
- public var endIndex: Index {
- @inline(__always) get { return _guts.endIndex }
- }
+ @inlinable @inline(__always)
+ public var endIndex: Index { return _guts.endIndex }
/// The number of characters in a string.
+ @inline(__always)
public var count: Int {
- @inline(__always) get {
- return distance(from: startIndex, to: endIndex)
- }
+ return distance(from: startIndex, to: endIndex)
}
/// Returns the position immediately after the given index.
@@ -190,16 +185,14 @@
///
/// - Parameter i: A valid index of the string. `i` must be less than the
/// string's end index.
- @inlinable
+ @inlinable @inline(__always)
public subscript(i: Index) -> Character {
- @inline(__always) get {
- _boundsCheck(i)
+ _boundsCheck(i)
- let i = _guts.scalarAlign(i)
- let distance = _characterStride(startingAt: i)
- return _guts.errorCorrectedCharacter(
- startingAt: i._encodedOffset, endingAt: i._encodedOffset &+ distance)
- }
+ let i = _guts.scalarAlign(i)
+ let distance = _characterStride(startingAt: i)
+ return _guts.errorCorrectedCharacter(
+ startingAt: i._encodedOffset, endingAt: i._encodedOffset &+ distance)
}
@inlinable @inline(__always)
diff --git a/stdlib/public/core/StringGuts.swift b/stdlib/public/core/StringGuts.swift
index 0b4b580..773f1e2 100644
--- a/stdlib/public/core/StringGuts.swift
+++ b/stdlib/public/core/StringGuts.swift
@@ -37,9 +37,9 @@
// Raw
extension _StringGuts {
- @inlinable
+ @inlinable @inline(__always)
internal var rawBits: _StringObject.RawBitPattern {
- @inline(__always) get { return _object.rawBits }
+ return _object.rawBits
}
}
@@ -78,34 +78,33 @@
// Queries
extension _StringGuts {
// The number of code units
- @inlinable
- internal var count: Int { @inline(__always) get { return _object.count } }
+ @inlinable @inline(__always)
+ internal var count: Int { return _object.count }
- @inlinable
- internal var isEmpty: Bool { @inline(__always) get { return count == 0 } }
+ @inlinable @inline(__always)
+ internal var isEmpty: Bool { return count == 0 }
- @inlinable
- internal var isSmall: Bool {
- @inline(__always) get { return _object.isSmall }
- }
+ @inlinable @inline(__always)
+ internal var isSmall: Bool { return _object.isSmall }
+ @inline(__always)
internal var isSmallASCII: Bool {
- @inline(__always) get { return _object.isSmall && _object.smallIsASCII }
+ return _object.isSmall && _object.smallIsASCII
}
- @inlinable
+ @inlinable @inline(__always)
internal var asSmall: _SmallString {
- @inline(__always) get { return _SmallString(_object) }
+ return _SmallString(_object)
}
- @inlinable
+ @inlinable @inline(__always)
internal var isASCII: Bool {
- @inline(__always) get { return _object.isASCII }
+ return _object.isASCII
}
- @inlinable
+ @inlinable @inline(__always)
internal var isFastASCII: Bool {
- @inline(__always) get { return isFastUTF8 && _object.isASCII }
+ return isFastUTF8 && _object.isASCII
}
@inline(__always)
@@ -134,9 +133,9 @@
internal var isFastUTF8: Bool { return _fastPath(_object.providesFastUTF8) }
// A String which does not provide fast access to contiguous UTF-8 code units
- @inlinable
+ @inlinable @inline(__always)
internal var isForeign: Bool {
- @inline(__always) get { return _slowPath(_object.isForeign) }
+ return _slowPath(_object.isForeign)
}
@inlinable @inline(__always)
@@ -259,11 +258,10 @@
return numWritten
}
+ @inline(__always)
internal var utf8Count: Int {
- @inline(__always) get {
- if _fastPath(self.isFastUTF8) { return count }
- return String(self).utf8.count
- }
+ if _fastPath(self.isFastUTF8) { return count }
+ return String(self).utf8.count
}
}
@@ -272,13 +270,13 @@
@usableFromInline
internal typealias Index = String.Index
- @inlinable
+ @inlinable @inline(__always)
internal var startIndex: String.Index {
- @inline(__always) get { return Index(_encodedOffset: 0) }
+ return Index(_encodedOffset: 0)
}
- @inlinable
+ @inlinable @inline(__always)
internal var endIndex: String.Index {
- @inline(__always) get { return Index(_encodedOffset: self.count) }
+ return Index(_encodedOffset: self.count)
}
}
diff --git a/stdlib/public/core/StringIndex.swift b/stdlib/public/core/StringIndex.swift
index 7974004..78dbb7e 100644
--- a/stdlib/public/core/StringIndex.swift
+++ b/stdlib/public/core/StringIndex.swift
@@ -49,18 +49,13 @@
}
extension String.Index {
- @inlinable
- internal var orderingValue: UInt64 {
- // TODO(String micro-performance): Consider mask instead of shift
- @inline(__always) get { return _rawBits &>> 14 }
- }
+ @inlinable @inline(__always)
+ internal var orderingValue: UInt64 { return _rawBits &>> 14 }
// Whether this is at the canonical "start" position, that is encoded AND
// transcoded offset of 0.
- @inlinable
- internal var isZeroPosition: Bool {
- @inline(__always) get { return orderingValue == 0 }
- }
+ @inlinable @inline(__always)
+ internal var isZeroPosition: Bool { return orderingValue == 0 }
/// The UTF-16 code unit offset corresponding to this Index
public func utf16Offset<S: StringProtocol>(in s: S) -> Int {
@@ -80,11 +75,9 @@
return Int(truncatingIfNeeded: _rawBits &>> 16)
}
- @inlinable
+ @inlinable @inline(__always)
internal var transcodedOffset: Int {
- @inline(__always) get {
- return Int(truncatingIfNeeded: orderingValue & 0x3)
- }
+ return Int(truncatingIfNeeded: orderingValue & 0x3)
}
@usableFromInline
@@ -164,45 +157,35 @@
// Creation helpers, which will make migration easier if we decide to use and
// propagate the reserved bits.
extension String.Index {
- @inlinable
+ @inlinable @inline(__always)
internal var strippingTranscoding: String.Index {
- @inline(__always) get {
- return String.Index(_encodedOffset: self._encodedOffset)
- }
+ return String.Index(_encodedOffset: self._encodedOffset)
}
- @inlinable
+ @inlinable @inline(__always)
internal var nextEncoded: String.Index {
- @inline(__always) get {
- _internalInvariant(self.transcodedOffset == 0)
- return String.Index(_encodedOffset: self._encodedOffset &+ 1)
- }
+ _internalInvariant(self.transcodedOffset == 0)
+ return String.Index(_encodedOffset: self._encodedOffset &+ 1)
}
- @inlinable
+ @inlinable @inline(__always)
internal var priorEncoded: String.Index {
- @inline(__always) get {
- _internalInvariant(self.transcodedOffset == 0)
- return String.Index(_encodedOffset: self._encodedOffset &- 1)
- }
+ _internalInvariant(self.transcodedOffset == 0)
+ return String.Index(_encodedOffset: self._encodedOffset &- 1)
}
- @inlinable
+ @inlinable @inline(__always)
internal var nextTranscoded: String.Index {
- @inline(__always) get {
- return String.Index(
- encodedOffset: self._encodedOffset,
- transcodedOffset: self.transcodedOffset &+ 1)
- }
+ return String.Index(
+ encodedOffset: self._encodedOffset,
+ transcodedOffset: self.transcodedOffset &+ 1)
}
- @inlinable
+ @inlinable @inline(__always)
internal var priorTranscoded: String.Index {
- @inline(__always) get {
- return String.Index(
- encodedOffset: self._encodedOffset,
- transcodedOffset: self.transcodedOffset &- 1)
- }
+ return String.Index(
+ encodedOffset: self._encodedOffset,
+ transcodedOffset: self.transcodedOffset &- 1)
}
// Get an index with an encoded offset relative to this one.
diff --git a/stdlib/public/core/StringObject.swift b/stdlib/public/core/StringObject.swift
index 3351fc0..c5db9f5 100644
--- a/stdlib/public/core/StringObject.swift
+++ b/stdlib/public/core/StringObject.swift
@@ -90,12 +90,10 @@
return .immortal(biased)
}
- @inlinable
+ @inlinable @inline(__always)
internal var isImmortal: Bool {
- @inline(__always) get {
- if case .immortal = self { return true }
- return false
- }
+ if case .immortal = self { return true }
+ return false
}
}
@@ -191,11 +189,9 @@
}
}
#else
- @inlinable
+ @inlinable @inline(__always)
internal var rawBits: RawBitPattern {
- @inline(__always) get {
- return (_countAndFlagsBits, discriminatedObjectRawBits)
- }
+ return (_countAndFlagsBits, discriminatedObjectRawBits)
}
@inlinable @inline(__always)
@@ -298,9 +294,9 @@
*/
extension _StringObject.Nibbles {
// The canonical empty sting is an empty small string
- @inlinable
+ @inlinable @inline(__always)
internal static var emptyString: UInt64 {
- @inline(__always) get { return _StringObject.Nibbles.small(isASCII: true) }
+ return _StringObject.Nibbles.small(isASCII: true)
}
}
@@ -381,9 +377,7 @@
// Discriminator for large, mortal (i.e. managed), swift-native strings
@inlinable @inline(__always)
- internal static func largeMortal() -> UInt64 {
- return 0x0000_0000_0000_0000
- }
+ internal static func largeMortal() -> UInt64 { return 0x0000_0000_0000_0000 }
internal static func largeCocoa(providesFastUTF8: Bool) -> UInt64 {
return providesFastUTF8 ? 0x4000_0000_0000_0000 : 0x5000_0000_0000_0000
@@ -391,38 +385,30 @@
}
extension _StringObject {
- @inlinable
+ @inlinable @inline(__always)
internal static var nativeBias: UInt {
- @inline(__always) get {
#if arch(i386) || arch(arm)
- return 20
+ return 20
#else
- return 32
+ return 32
#endif
- }
}
- @inlinable
+ @inlinable @inline(__always)
internal var isImmortal: Bool {
- @inline(__always) get {
- return (discriminatedObjectRawBits & 0x8000_0000_0000_0000) != 0
- }
+ return (discriminatedObjectRawBits & 0x8000_0000_0000_0000) != 0
}
- @inlinable
- internal var isMortal: Bool {
- @inline(__always) get { return !isImmortal }
- }
+ @inlinable @inline(__always)
+ internal var isMortal: Bool { return !isImmortal }
- @inlinable
+ @inlinable @inline(__always)
internal var isSmall: Bool {
- @inline(__always) get {
- return (discriminatedObjectRawBits & 0x2000_0000_0000_0000) != 0
- }
+ return (discriminatedObjectRawBits & 0x2000_0000_0000_0000) != 0
}
- @inlinable
- internal var isLarge: Bool { @inline(__always) get { return !isSmall } }
+ @inlinable @inline(__always)
+ internal var isLarge: Bool { return !isSmall }
// Whether this string can provide access to contiguous UTF-8 code units:
// - Small strings can by spilling to the stack
@@ -430,17 +416,13 @@
// - Shared strings can:
// - Cocoa strings which respond to e.g. CFStringGetCStringPtr()
// - Non-Cocoa shared strings
- @inlinable
+ @inlinable @inline(__always)
internal var providesFastUTF8: Bool {
- @inline(__always) get {
- return (discriminatedObjectRawBits & 0x1000_0000_0000_0000) == 0
- }
+ return (discriminatedObjectRawBits & 0x1000_0000_0000_0000) == 0
}
- @inlinable
- internal var isForeign: Bool {
- @inline(__always) get { return !providesFastUTF8 }
- }
+ @inlinable @inline(__always)
+ internal var isForeign: Bool { return !providesFastUTF8 }
// Whether we are native or shared, i.e. we have a backing class which
// conforms to `_AbstractStringStorage`
@@ -555,26 +537,20 @@
return Int(truncatingIfNeeded: (x & 0x0F00_0000_0000_0000) &>> 56)
}
- @inlinable
+ @inlinable @inline(__always)
internal var smallCount: Int {
- @inline(__always)
- get {
- _internalInvariant(isSmall)
- return _StringObject.getSmallCount(fromRaw: discriminatedObjectRawBits)
- }
+ _internalInvariant(isSmall)
+ return _StringObject.getSmallCount(fromRaw: discriminatedObjectRawBits)
}
@inlinable
internal static func getSmallIsASCII(fromRaw x: UInt64) -> Bool {
return x & 0x4000_0000_0000_0000 != 0
}
- @inlinable
+ @inlinable @inline(__always)
internal var smallIsASCII: Bool {
- @inline(__always)
- get {
- _internalInvariant(isSmall)
- return _StringObject.getSmallIsASCII(fromRaw: discriminatedObjectRawBits)
- }
+ _internalInvariant(isSmall)
+ return _StringObject.getSmallIsASCII(fromRaw: discriminatedObjectRawBits)
}
@inlinable @inline(__always)
@@ -797,31 +773,25 @@
return _countAndFlags.count
}
- @inlinable
+ @inlinable @inline(__always)
internal var largeAddressBits: UInt {
- @inline(__always) get {
- _internalInvariant(isLarge)
- return UInt(truncatingIfNeeded:
- discriminatedObjectRawBits & Nibbles.largeAddressMask)
- }
+ _internalInvariant(isLarge)
+ return UInt(truncatingIfNeeded:
+ discriminatedObjectRawBits & Nibbles.largeAddressMask)
}
- @inlinable
+ @inlinable @inline(__always)
internal var nativeUTF8Start: UnsafePointer<UInt8> {
- @inline(__always) get {
- _internalInvariant(largeFastIsTailAllocated)
- return UnsafePointer(
- bitPattern: largeAddressBits &+ _StringObject.nativeBias
- )._unsafelyUnwrappedUnchecked
- }
+ _internalInvariant(largeFastIsTailAllocated)
+ return UnsafePointer(
+ bitPattern: largeAddressBits &+ _StringObject.nativeBias
+ )._unsafelyUnwrappedUnchecked
}
- @inlinable
+ @inlinable @inline(__always)
internal var nativeUTF8: UnsafeBufferPointer<UInt8> {
- @inline(__always) get {
- _internalInvariant(largeFastIsTailAllocated)
- return UnsafeBufferPointer(start: nativeUTF8Start, count: largeCount)
- }
+ _internalInvariant(largeFastIsTailAllocated)
+ return UnsafeBufferPointer(start: nativeUTF8Start, count: largeCount)
}
// Resilient way to fetch a pointer
@@ -847,47 +817,44 @@
}
}
+ @inline(__always)
internal var nativeStorage: __StringStorage {
- @inline(__always) get {
#if arch(i386) || arch(arm)
- guard case .native(let storage) = _variant else {
- _internalInvariantFailure()
- }
- return _unsafeUncheckedDowncast(storage, to: __StringStorage.self)
-#else
- _internalInvariant(hasNativeStorage)
- return Builtin.reinterpretCast(largeAddressBits)
-#endif
+ guard case .native(let storage) = _variant else {
+ _internalInvariantFailure()
}
+ return _unsafeUncheckedDowncast(storage, to: __StringStorage.self)
+#else
+ _internalInvariant(hasNativeStorage)
+ return Builtin.reinterpretCast(largeAddressBits)
+#endif
}
+ @inline(__always)
internal var sharedStorage: __SharedStringStorage {
- @inline(__always) get {
#if arch(i386) || arch(arm)
- guard case .native(let storage) = _variant else {
- _internalInvariantFailure()
- }
- return _unsafeUncheckedDowncast(storage, to: __SharedStringStorage.self)
-#else
- _internalInvariant(largeFastIsShared && !largeIsCocoa)
- _internalInvariant(hasSharedStorage)
- return Builtin.reinterpretCast(largeAddressBits)
-#endif
+ guard case .native(let storage) = _variant else {
+ _internalInvariantFailure()
}
+ return _unsafeUncheckedDowncast(storage, to: __SharedStringStorage.self)
+#else
+ _internalInvariant(largeFastIsShared && !largeIsCocoa)
+ _internalInvariant(hasSharedStorage)
+ return Builtin.reinterpretCast(largeAddressBits)
+#endif
}
+ @inline(__always)
internal var cocoaObject: AnyObject {
- @inline(__always) get {
#if arch(i386) || arch(arm)
- guard case .bridged(let object) = _variant else {
- _internalInvariantFailure()
- }
- return object
-#else
- _internalInvariant(largeIsCocoa && !isImmortal)
- return Builtin.reinterpretCast(largeAddressBits)
-#endif
+ guard case .bridged(let object) = _variant else {
+ _internalInvariantFailure()
}
+ return object
+#else
+ _internalInvariant(largeIsCocoa && !isImmortal)
+ return Builtin.reinterpretCast(largeAddressBits)
+#endif
}
}
@@ -896,20 +863,16 @@
// The number of code units stored
//
// TODO(String micro-performance): Check generated code
- @inlinable
- internal var count: Int {
- @inline(__always) get { return isSmall ? smallCount : largeCount }
- }
+ @inlinable @inline(__always)
+ internal var count: Int { return isSmall ? smallCount : largeCount }
//
// Whether the string is all ASCII
//
- @inlinable
+ @inlinable @inline(__always)
internal var isASCII: Bool {
- @inline(__always) get {
- if isSmall { return smallIsASCII }
- return _countAndFlags.isASCII
- }
+ if isSmall { return smallIsASCII }
+ return _countAndFlags.isASCII
}
@inline(__always)
diff --git a/stdlib/public/core/StringStorage.swift b/stdlib/public/core/StringStorage.swift
index a1e1fca..1c9e2ac 100644
--- a/stdlib/public/core/StringStorage.swift
+++ b/stdlib/public/core/StringStorage.swift
@@ -423,8 +423,9 @@
private var mutableStart: UnsafeMutablePointer<UInt8> {
return UnsafeMutablePointer(Builtin.projectTailElems(self, UInt8.self))
}
+ @inline(__always)
private var mutableEnd: UnsafeMutablePointer<UInt8> {
- @inline(__always) get { return mutableStart + count }
+ return mutableStart + count
}
@inline(__always)
@@ -432,19 +433,20 @@
return UnsafePointer(mutableStart)
}
+ @inline(__always)
private final var end: UnsafePointer<UInt8> {
- @inline(__always) get { return UnsafePointer(mutableEnd) }
+ return UnsafePointer(mutableEnd)
}
// Point to the nul-terminator.
+ @inline(__always)
private final var terminator: UnsafeMutablePointer<UInt8> {
- @inline(__always) get { return mutableEnd }
+ return mutableEnd
}
+ @inline(__always)
private var codeUnits: UnsafeBufferPointer<UInt8> {
- @inline(__always) get {
- return UnsafeBufferPointer(start: start, count: count)
- }
+ return UnsafeBufferPointer(start: start, count: count)
}
// @opaque
@@ -467,18 +469,15 @@
// required nul-terminator.
//
// NOTE: Callers who wish to mutate this storage should enfore nul-termination
+ @inline(__always)
private var unusedStorage: UnsafeMutableBufferPointer<UInt8> {
- @inline(__always) get {
- return UnsafeMutableBufferPointer(
- start: mutableEnd, count: unusedCapacity)
- }
+ return UnsafeMutableBufferPointer(
+ start: mutableEnd, count: unusedCapacity)
}
// The capacity available for appending. Note that this excludes the required
// nul-terminator.
- internal var unusedCapacity: Int {
- get { return _realCapacity &- count &- 1 }
- }
+ internal var unusedCapacity: Int { return _realCapacity &- count &- 1 }
#if !INTERNAL_CHECKS_ENABLED
@inline(__always) internal func _invariantCheck() {}
diff --git a/stdlib/public/core/StringUTF16View.swift b/stdlib/public/core/StringUTF16View.swift
index 6cb85b9..9e9ed6e 100644
--- a/stdlib/public/core/StringUTF16View.swift
+++ b/stdlib/public/core/StringUTF16View.swift
@@ -128,19 +128,15 @@
/// The position of the first code unit if the `String` is
/// nonempty; identical to `endIndex` otherwise.
- @inlinable
- public var startIndex: Index {
- @inline(__always) get { return _guts.startIndex }
- }
+ @inlinable @inline(__always)
+ public var startIndex: Index { return _guts.startIndex }
/// The "past the end" position---that is, the position one greater than
/// the last valid subscript argument.
///
/// In an empty UTF-16 view, `endIndex` is equal to `startIndex`.
- @inlinable
- public var endIndex: Index {
- @inline(__always) get { return _guts.endIndex }
- }
+ @inlinable @inline(__always)
+ public var endIndex: Index { return _guts.endIndex }
@inlinable @inline(__always)
public func index(after i: Index) -> Index {
@@ -242,22 +238,20 @@
///
/// - Parameter position: A valid index of the view. `position` must be
/// less than the view's end index.
- @inlinable
+ @inlinable @inline(__always)
public subscript(i: Index) -> UTF16.CodeUnit {
- @inline(__always) get {
- String(_guts)._boundsCheck(i)
+ String(_guts)._boundsCheck(i)
- if _fastPath(_guts.isFastUTF8) {
- let scalar = _guts.fastUTF8Scalar(
- startingAt: _guts.scalarAlign(i)._encodedOffset)
- if scalar.value <= 0xFFFF {
- return UInt16(truncatingIfNeeded: scalar.value)
- }
- return scalar.utf16[i.transcodedOffset]
+ if _fastPath(_guts.isFastUTF8) {
+ let scalar = _guts.fastUTF8Scalar(
+ startingAt: _guts.scalarAlign(i)._encodedOffset)
+ if scalar.value <= 0xFFFF {
+ return UInt16(truncatingIfNeeded: scalar.value)
}
-
- return _foreignSubscript(position: i)
+ return scalar.utf16[i.transcodedOffset]
}
+
+ return _foreignSubscript(position: i)
}
}
@@ -314,10 +308,8 @@
extension String.UTF16View: CustomStringConvertible {
- @inlinable
- public var description: String {
- @inline(__always) get { return String(_guts) }
- }
+ @inlinable @inline(__always)
+ public var description: String { return String(_guts) }
}
extension String.UTF16View: CustomDebugStringConvertible {
@@ -500,8 +492,8 @@
// Breadcrumb-aware acceleration
extension String.UTF16View {
// A simple heuristic we can always tweak later. Not needed for correctness
- @inlinable
- internal var _shortHeuristic: Int { @inline(__always) get { return 32 } }
+ @inlinable @inline(__always)
+ internal var _shortHeuristic: Int { return 32 }
@usableFromInline
@_effects(releasenone)
diff --git a/stdlib/public/core/StringUTF8View.swift b/stdlib/public/core/StringUTF8View.swift
index 81b8bdb..c641a08 100644
--- a/stdlib/public/core/StringUTF8View.swift
+++ b/stdlib/public/core/StringUTF8View.swift
@@ -121,19 +121,15 @@
/// nonempty.
///
/// If the UTF-8 view is empty, `startIndex` is equal to `endIndex`.
- @inlinable
- public var startIndex: Index {
- @inline(__always) get { return _guts.startIndex }
- }
+ @inlinable @inline(__always)
+ public var startIndex: Index { return _guts.startIndex }
/// The "past the end" position---that is, the position one
/// greater than the last valid subscript argument.
///
/// In an empty UTF-8 view, `endIndex` is equal to `startIndex`.
- @inlinable
- public var endIndex: Index {
- @inline(__always) get { return _guts.endIndex }
- }
+ @inlinable @inline(__always)
+ public var endIndex: Index { return _guts.endIndex }
/// Returns the next consecutive position after `i`.
///
@@ -209,30 +205,26 @@
///
/// - Parameter position: A valid index of the view. `position`
/// must be less than the view's end index.
- @inlinable
+ @inlinable @inline(__always)
public subscript(i: Index) -> UTF8.CodeUnit {
- @inline(__always) get {
- String(_guts)._boundsCheck(i)
- if _fastPath(_guts.isFastUTF8) {
- return _guts.withFastUTF8 { utf8 in utf8[_unchecked: i._encodedOffset] }
- }
-
- return _foreignSubscript(position: i)
+ String(_guts)._boundsCheck(i)
+ if _fastPath(_guts.isFastUTF8) {
+ return _guts.withFastUTF8 { utf8 in utf8[_unchecked: i._encodedOffset] }
}
+
+ return _foreignSubscript(position: i)
}
}
extension String.UTF8View: CustomStringConvertible {
- @inlinable
- public var description: String {
- @inline(__always) get { return String(String(_guts)) }
- }
+ @inlinable @inline(__always)
+ public var description: String { return String(_guts) }
}
extension String.UTF8View: CustomDebugStringConvertible {
- public var debugDescription: String {
- return "UTF8View(\(self.description.debugDescription))"
- }
+ public var debugDescription: String {
+ return "UTF8View(\(self.description.debugDescription))"
+ }
}
@@ -289,14 +281,12 @@
}
extension String.UTF8View {
- @inlinable
+ @inlinable @inline(__always)
public var count: Int {
- @inline(__always) get {
- if _fastPath(_guts.isFastUTF8) {
- return _guts.count
- }
- return _foreignCount()
+ if _fastPath(_guts.isFastUTF8) {
+ return _guts.count
}
+ return _foreignCount()
}
}
diff --git a/stdlib/public/core/StringUnicodeScalarView.swift b/stdlib/public/core/StringUnicodeScalarView.swift
index d46792d..5a9a589 100644
--- a/stdlib/public/core/StringUnicodeScalarView.swift
+++ b/stdlib/public/core/StringUnicodeScalarView.swift
@@ -91,19 +91,15 @@
/// nonempty.
///
/// If the string is empty, `startIndex` is equal to `endIndex`.
- @inlinable
- public var startIndex: Index {
- @inline(__always) get { return _guts.startIndex }
- }
+ @inlinable @inline(__always)
+ public var startIndex: Index { return _guts.startIndex }
/// The "past the end" position---that is, the position one greater than
/// the last valid subscript argument.
///
/// In an empty Unicode scalars view, `endIndex` is equal to `startIndex`.
- @inlinable
- public var endIndex: Index {
- @inline(__always) get { return _guts.endIndex }
- }
+ @inlinable @inline(__always)
+ public var endIndex: Index { return _guts.endIndex }
/// Returns the next consecutive location after `i`.
///
@@ -156,13 +152,11 @@
///
/// - Parameter position: A valid index of the character view. `position`
/// must be less than the view's end index.
- @inlinable
+ @inlinable @inline(__always)
public subscript(position: Index) -> Unicode.Scalar {
- @inline(__always) get {
- String(_guts)._boundsCheck(position)
- let i = _guts.scalarAlign(position)
- return _guts.errorCorrectedScalar(startingAt: i._encodedOffset).0
- }
+ String(_guts)._boundsCheck(position)
+ let i = _guts.scalarAlign(position)
+ return _guts.errorCorrectedScalar(startingAt: i._encodedOffset).0
}
}
@@ -201,10 +195,8 @@
}
extension String.UnicodeScalarView: CustomStringConvertible {
- @inlinable
- public var description: String {
- @inline(__always) get { return String(_guts) }
- }
+ @inlinable @inline(__always)
+ public var description: String { return String(_guts) }
}
extension String.UnicodeScalarView: CustomDebugStringConvertible {
diff --git a/stdlib/public/core/Substring.swift b/stdlib/public/core/Substring.swift
index 1d89c3b..809a25d 100644
--- a/stdlib/public/core/Substring.swift
+++ b/stdlib/public/core/Substring.swift
@@ -148,14 +148,11 @@
public typealias Index = String.Index
public typealias SubSequence = Substring
- @inlinable
- public var startIndex: Index {
- @inline(__always) get { return _slice.startIndex }
- }
- @inlinable
- public var endIndex: Index {
- @inline(__always) get { return _slice.endIndex }
- }
+ @inlinable @inline(__always)
+ public var startIndex: Index { return _slice.startIndex }
+
+ @inlinable @inline(__always)
+ public var endIndex: Index { return _slice.endIndex }
@inlinable @inline(__always)
public func index(after i: Index) -> Index {
@@ -309,10 +306,8 @@
}
extension Substring : CustomStringConvertible {
- @inlinable
- public var description: String {
- @inline(__always) get { return String(self) }
- }
+ @inlinable @inline(__always)
+ public var description: String { return String(self) }
}
extension Substring : CustomDebugStringConvertible {
diff --git a/test/Constraints/anyhashable-collection-cast.swift b/test/Constraints/anyhashable-collection-cast.swift
index 2465dcb..a951761 100644
--- a/test/Constraints/anyhashable-collection-cast.swift
+++ b/test/Constraints/anyhashable-collection-cast.swift
@@ -18,6 +18,6 @@
func testLValueCoerce() {
var lvalue = "lvalue"
- var map: [AnyHashable : Any] = [lvalue: lvalue]
+ let map: [AnyHashable : Any] = [lvalue: lvalue]
lvalue = map[lvalue] as! String
}
diff --git a/test/Generics/non_generic_derived_class.swift b/test/Generics/non_generic_derived_class.swift
index bb89992..1934011 100644
--- a/test/Generics/non_generic_derived_class.swift
+++ b/test/Generics/non_generic_derived_class.swift
@@ -9,3 +9,10 @@
class Derived : Base<Int> {}
var a = Derived.f(42)
+
+protocol SR9160_EmptyProtocol {}
+class SR9160_AbstractFoobar<Foo> {}
+// This used to cause the swift compiler to never finish compiling.
+final class SR9160_SomeFoobar: SR9160_AbstractFoobar<SR9160_SomeFoobar.Foo> {
+ enum Foo: SR9160_EmptyProtocol {}
+}
diff --git a/test/IRGen/pic.swift b/test/IRGen/pic.swift
index e38c587..da75ae9 100644
--- a/test/IRGen/pic.swift
+++ b/test/IRGen/pic.swift
@@ -1,7 +1,7 @@
// <rdar://problem/15358345> Check that we always use PIC relocations on all
// platforms.
-// RUN: %target-swift-frontend %s -module-name main -S -o - | %FileCheck -check-prefix=%target-cpu %s
+// RUN: %target-swift-frontend %s -module-name main -S -o - | %FileCheck -check-prefix=%target-cpu -check-prefix=%target-cpu-%target-sdk-name %s
var global: Int = 0
@@ -20,12 +20,26 @@
// armv7-LABEL: {{_?}}$s4main10use_globalSiyF:
// Check for the runtime memory enforcement call. The global address may be
// materialized in a different register prior to that call.
-// armv7: bl _swift_beginAccess
-// armv7: movw [[R_ADR:r.*]], :lower16:(_$s4main6globalSivp-([[PIC_0:L.*]]+4))
-// armv7: movt [[R_ADR]], :upper16:(_$s4main6globalSivp-([[PIC_0]]+4))
-// armv7: [[PIC_0]]:{{$}}
-// armv7: add [[R_ADR]], pc
-// armv7: ldr [[R_ADR]], {{\[}}[[R_ADR]]{{\]}}
+// armv7: bl {{_?}}swift_beginAccess
+// armv7-iphoneos: movw [[R_ADR:r.*]], :lower16:(_$s4main6globalSivp-([[PIC_0:L.*]]+4))
+// armv7-iphoneos: movt [[R_ADR]], :upper16:(_$s4main6globalSivp-([[PIC_0]]+4))
+// armv7-iphoneos: [[PIC_0]]:{{$}}
+// armv7-iphoneos: ldr [[R_ADR]], {{\[}}[[R_ADR]]{{\]}}
+
+// armv7-android: ldr [[R_ADR:r.*]], .LCPI[[PIC_0:[0-9]_[0-9]]]
+// armv7-android: .LPC[[PIC_0]]:{{$}}
+// armv7-android: add [[R_ADR]], pc
+// armv7-android: bl {{_?}}swift_endAccess
+// armv7-android: .LCPI[[PIC_0]]:{{$}}
+// armv7-android: .long ($s4main6globalSivp)-(.LPC[[PIC_0]]+8)
+
+// armv7-linux: ldr [[R_ADR:r.*]], .LCPI[[PIC_0:[0-9]_[0-9]]]
+// armv7-linux: .LPC[[PIC_0]]:{{$}}
+// armv7-linux: add [[R_ADR]], pc
+// armv7-linux: bl {{_?}}swift_endAccess
+// armv7-linux: .LCPI[[PIC_0]]:{{$}}
+// armv7-linux: .long ($s4main6globalSivp)-(.LPC[[PIC_0]]+8)
+
// armv7s-LABEL: {{_?}}$s4main10use_globalSiyF:
// armv7s: bl _swift_beginAccess
@@ -53,13 +67,15 @@
// arm64: ldr x0, [sp]
// aarch64-LABEL: $s4main10use_globalSiyF:
-// aarch64: adrp [[REG1:x[0-9]+]], ($s4main6globalSivp@PAGE)
-// aarch64: add [[REG1]], [[REG1]], :lo12:($s4main6globalSivp)
-// aarch64: bl swift_beginAccess
-// aarch64: ldr [[REG2:x[0-9]+]], {{\[}}[[REG1]]{{\]}}
-// aarch64: str [[REG2]], [sp]
-// aarch64: bl swift_endAccess
-// aarch64: ldr x0, [sp]
+// aarch64: bl swift_beginAccess
+// aarch64-windows: adrp [[REG1:x[0-9]+]], ($s4main6globalSivp@PAGE)
+// aarch64-linux: adrp [[REG1:x[0-9]+]], ($s4main6globalSivp)
+// aarch64-android: adrp [[REG1:x[0-9]+]], ($s4main6globalSivp)
+// aarch64: add [[REG1]], [[REG1]], :lo12:($s4main6globalSivp)
+// aarch64: ldr [[REG2:x[0-9]+]], {{\[}}[[REG1]]{{\]}}
+// aarch64: str [[REG2]], [sp]
+// aarch64: bl swift_endAccess
+// aarch64: ldr x0, [sp]
// powerpc64le-LABEL: {{_?}}$s4main10use_globalSiyF:
// powerpc64le: bl swift_beginAccess
diff --git a/test/Misc/fatal_error.swift b/test/Misc/fatal_error.swift
index e5e14f5..154da6a 100644
--- a/test/Misc/fatal_error.swift
+++ b/test/Misc/fatal_error.swift
@@ -1,5 +1,6 @@
// RUN: not %target-swift-frontend -typecheck %s -sdk "" 2>&1 | %FileCheck -check-prefix=CHECK -check-prefix=NO-MODULE %s
// RUN: not %target-swift-frontend -typecheck %s -resource-dir / 2>&1 | %FileCheck -check-prefix=CHECK -check-prefix=NO-STDLIB %s
+// REQUIRES: rdar49665477
// NO-MODULE: error: no such module 'NonExistent'
diff --git a/test/Parse/swift3_warnings_swift4_errors_version_4.swift b/test/Parse/swift3_warnings_swift4_errors_version_4.swift
index 661190d..ef715e6 100644
--- a/test/Parse/swift3_warnings_swift4_errors_version_4.swift
+++ b/test/Parse/swift3_warnings_swift4_errors_version_4.swift
@@ -13,9 +13,12 @@
let y: protocol<P1> // expected-error {{'protocol<...>' composition syntax has been removed and is not needed here}}}
let z: protocol<P1, P2> // expected-error {{'protocol<...>' composition syntax has been removed; join the protocols using '&'}}
-func bar(f: @noescape () -> ()) {} // expected-error {{@noescape is the default and has been removed}}
+func bar(f: @noescape () -> ()) {} // expected-error {{unknown attribute 'noescape'}}
-func baz(f: @autoclosure(escaping) () -> ()) {} // expected-error {{@autoclosure(escaping) has been removed; use @autoclosure @escaping instead}}
+func baz(f: @autoclosure(escaping) () -> ()) {}
+// expected-error @-1 {{use of undeclared type 'escaping'}}
+// expected-error @-2 {{unnamed parameters must be written with the empty name '_'}}
+// expected-error @-3 {{expected ',' separator}}
prefix operator +++ {} // expected-error {{operator should no longer be declared with body}}
postfix operator +++ {} // expected-error {{operator should no longer be declared with body}}
diff --git a/test/ParseableInterface/private-stored-members.swift b/test/ParseableInterface/private-stored-members.swift
index 8ccb6cd..2c21f68 100644
--- a/test/ParseableInterface/private-stored-members.swift
+++ b/test/ParseableInterface/private-stored-members.swift
@@ -21,12 +21,12 @@
// COMMON-NEXT: let publicLet: [[BOOL:(Swift\.)?Bool]]{{$}}
public let publicLet: Bool
-// CHECK-NEXT: internal var _: [[INT64]]{{$}}
-// RESILIENT-NOT: internal var _: [[INT64]]{{$}}
+// CHECK-NEXT: internal var internalVar: [[INT64]]{{$}}
+// RESILIENT-NOT: internal var internalVar: [[INT64]]{{$}}
var internalVar: Int64
-// CHECK-NEXT: internal let _: [[BOOL]]{{$}}
-// RESILIENT-NOT: internal let _: [[BOOL]]{{$}}
+// CHECK-NEXT: internal let internalLet: [[BOOL]]{{$}}
+// RESILIENT-NOT: internal let internalLet: [[BOOL]]{{$}}
let internalLet: Bool
// COMMON-NEXT: @usableFromInline
@@ -37,12 +37,12 @@
// COMMON-NEXT: internal let ufiLet: [[BOOL]]{{$}}
@usableFromInline let ufiLet: Bool
-// CHECK-NEXT: private var _: [[INT64]]{{$}}
-// RESILIENT-NOT: private var _: [[INT64]]{{$}}
+// CHECK-NEXT: private var privateVar: [[INT64]]{{$}}
+// RESILIENT-NOT: private var privateVar: [[INT64]]{{$}}
private var privateVar: Int64
-// CHECK-NEXT: private let _: [[BOOL]]{{$}}
-// RESILIENT-NOT: private let _: [[BOOL]]{{$}}
+// CHECK-NEXT: private let privateLet: [[BOOL]]{{$}}
+// RESILIENT-NOT: private let privateLet: [[BOOL]]{{$}}
private let privateLet: Bool
// CHECK-NOT: private var
diff --git a/test/ParseableInterface/stored-properties.swift b/test/ParseableInterface/stored-properties.swift
index 03ecbbb..e139b54 100644
--- a/test/ParseableInterface/stored-properties.swift
+++ b/test/ParseableInterface/stored-properties.swift
@@ -49,7 +49,8 @@
// COMMON-NEXT: }
public private(set) var storedPrivateSet: Int
- // CHECK: private var _: [[BOOL]]
+ // CHECK: private var privateVar: [[BOOL]]
+ // RESILIENT-NOT: private var privateVar: [[BOOL]]
private var privateVar: Bool
// CHECK: @_hasStorage @_hasInitialValue public var storedWithObserversInitialValue: [[INT]] {
diff --git a/test/SIL/ownership-verifier/over_consume.sil b/test/SIL/ownership-verifier/over_consume.sil
index 7cd4fbf..42a12b1 100644
--- a/test/SIL/ownership-verifier/over_consume.sil
+++ b/test/SIL/ownership-verifier/over_consume.sil
@@ -22,6 +22,13 @@
case none
}
+protocol Error {}
+
+struct NativeObjectPair {
+ var obj1 : Builtin.NativeObject
+ var obj2 : Builtin.NativeObject
+}
+
class SuperKlass {
func doSomething()
}
@@ -485,3 +492,35 @@
%5 = tuple(%3 : $ClassProt, %4 : $ClassProt)
return %5 : $(ClassProt, ClassProt)
}
+
+sil [ossa] @eliminate_copy_try_apple_callee : $@convention(thin) (@owned Builtin.NativeObject) -> @error Error {
+entry(%0 : @owned $Builtin.NativeObject):
+ %9999 = tuple()
+ return %9999 : $()
+}
+
+
+// CHECK-LABEL: Function: 'use_after_free_consume_in_same_block'
+// CHECK: Found use after free due to unvisited non lifetime ending uses?!
+// CHECK: Value: %3 = copy_value %2 : $Builtin.NativeObject
+// CHECK: Remaining Users:
+// CHECK: User: %10 = apply %7(%3) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+sil [ossa] @use_after_free_consume_in_same_block : $@convention(thin) (@owned NativeObjectPair) -> @error Error {
+bb0(%0 : @owned $NativeObjectPair):
+ %1 = begin_borrow %0 : $NativeObjectPair
+ %2 = struct_extract %1 : $NativeObjectPair, #NativeObjectPair.obj1
+ %3 = copy_value %2 : $Builtin.NativeObject
+ end_borrow %1 : $NativeObjectPair
+ destroy_value %0 : $NativeObjectPair
+ %4 = function_ref @eliminate_copy_try_apple_callee : $@convention(thin) (@owned Builtin.NativeObject) -> @error Error
+ %5 = function_ref @guaranteed_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+ try_apply %4(%3) : $@convention(thin) (@owned Builtin.NativeObject) -> @error Error, normal bb1, error bb2
+
+bb1(%errorEmptyTup: $()):
+ apply %5(%3) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
+ %9999 = tuple()
+ return %9999 : $()
+
+bb2(%error : @owned $Error):
+ throw %error : $Error
+}
diff --git a/test/SILGen/enum.swift b/test/SILGen/enum.swift
index ac064f4..7f1fd19 100644
--- a/test/SILGen/enum.swift
+++ b/test/SILGen/enum.swift
@@ -249,8 +249,8 @@
// CHECK: bb0(%0 : $Optional<SR7799>):
// CHECK-NEXT: debug_value %0 : $Optional<SR7799>, let, name "bar", argno 1
// CHECK-NEXT: switch_enum %0 : $Optional<SR7799>, case #Optional.some!enumelt.1: bb1, default bb4
-// CHECK: bb1(%3 : $SR7799):
-// CHECK-NEXT: switch_enum %3 : $SR7799, case #SR7799.one!enumelt: bb2, case #SR7799.two!enumelt: bb3
+// CHECK: bb1([[PHI_ARG:%.*]] : $SR7799):
+// CHECK-NEXT: switch_enum [[PHI_ARG]] : $SR7799, case #SR7799.one!enumelt: bb2, case #SR7799.two!enumelt: bb3
func sr7799(bar: SR7799?) {
switch bar {
case .one: print("one")
diff --git a/test/SILGen/enum_resilience.swift b/test/SILGen/enum_resilience.swift
index 5b6e1cc..c27f773 100644
--- a/test/SILGen/enum_resilience.swift
+++ b/test/SILGen/enum_resilience.swift
@@ -12,6 +12,7 @@
// CHECK-LABEL: sil hidden [ossa] @$s15enum_resilience15resilientSwitchyy0c1_A06MediumOF : $@convention(thin) (@in_guaranteed Medium) -> ()
// CHECK: [[BOX:%.*]] = alloc_stack $Medium
// CHECK-NEXT: copy_addr %0 to [initialization] [[BOX]]
+// CHECK-NEXT: [[METATYPE:%.+]] = value_metatype $@thick Medium.Type, [[BOX]] : $*Medium
// 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]]
@@ -32,7 +33,6 @@
// CHECK-NEXT: dealloc_stack [[BOX]]
// CHECK-NEXT: br bb6
// CHECK: bb5:
-// CHECK-NEXT: [[METATYPE:%.+]] = value_metatype $@thick Medium.Type, [[BOX]] : $*Medium
// CHECK-NEXT: // function_ref
// CHECK-NEXT: [[DIAGNOSE:%.+]] = function_ref @$ss27_diagnoseUnexpectedEnumCase
// CHECK-NEXT: = apply [[DIAGNOSE]]<Medium>([[METATYPE]]) : $@convention(thin) <τ_0_0> (@thick τ_0_0.Type) -> Never
diff --git a/test/SILGen/enum_resilience_testable.swift b/test/SILGen/enum_resilience_testable.swift
index c1b3a46..75260ea 100644
--- a/test/SILGen/enum_resilience_testable.swift
+++ b/test/SILGen/enum_resilience_testable.swift
@@ -17,6 +17,7 @@
// CHECK-LABEL: sil hidden [ossa] @$s24enum_resilience_testable15resilientSwitchyy0d1_A06MediumOF : $@convention(thin) (@in_guaranteed Medium) -> ()
// CHECK: [[BOX:%.*]] = alloc_stack $Medium
// CHECK-NEXT: copy_addr %0 to [initialization] [[BOX]]
+// CHECK-NEXT: [[METATYPE:%.+]] = value_metatype $@thick Medium.Type, [[BOX]] : $*Medium
// 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]]
@@ -37,7 +38,6 @@
// CHECK-NEXT: dealloc_stack [[BOX]]
// CHECK-NEXT: br bb6
// CHECK: bb5:
-// CHECK-NEXT: [[METATYPE:%.+]] = value_metatype $@thick Medium.Type, [[BOX]] : $*Medium
// CHECK-NEXT: // function_ref
// CHECK-NEXT: [[DIAGNOSE:%.+]] = function_ref @$ss27_diagnoseUnexpectedEnumCase
// CHECK-NEXT: = apply [[DIAGNOSE]]<Medium>([[METATYPE]]) : $@convention(thin) <τ_0_0> (@thick τ_0_0.Type) -> Never
diff --git a/test/SILGen/switch.swift b/test/SILGen/switch.swift
index c5c14ff..6bf6335 100644
--- a/test/SILGen/switch.swift
+++ b/test/SILGen/switch.swift
@@ -1029,8 +1029,8 @@
case let x?:
return 0
- // CHECK: [[SOMEBB]](%3 : $Int):
- // CHECK-NEXT: debug_value %3 : $Int, let, name "x"
+ // CHECK: [[SOMEBB]]([[X:%.*]] : $Int):
+ // CHECK-NEXT: debug_value [[X]] : $Int, let, name "x"
// CHECK: integer_literal $Builtin.IntLiteral, 0
case .none:
@@ -1051,8 +1051,8 @@
case let x?:
return 0
- // CHECK: [[SOMEBB]](%3 : $Int):
- // CHECK-NEXT: debug_value %3 : $Int, let, name "x"
+ // CHECK: [[SOMEBB]]([[X:%.*]] : $Int):
+ // CHECK-NEXT: debug_value [[X]] : $Int, let, name "x"
// CHECK: integer_literal $Builtin.IntLiteral, 0
case nil:
diff --git a/test/SILGen/switch_objc.swift b/test/SILGen/switch_objc.swift
index 72fe068..914bc41 100644
--- a/test/SILGen/switch_objc.swift
+++ b/test/SILGen/switch_objc.swift
@@ -25,3 +25,30 @@
return false
}
}
+
+@objc enum ObjCEnum : UInt8 {
+case first
+case second
+}
+
+// CHECK-LABEL: sil hidden [ossa] @$s11switch_objc44checkObjCEnumUnhandledCaseDiagnosticEmission1xyAA0dE0O_tF : $@convention(thin) (ObjCEnum) -> () {
+// CHECK: bb0([[ARG:%.*]] :
+// CHECK: [[METATYPE:%.*]] = metatype $@thick ObjCEnum.Type
+// CHECK: [[ARG_INT_REPR:%.*]] = unchecked_trivial_bit_cast [[ARG]]
+// CHECK: switch_enum [[ARG]] : $ObjCEnum, {{.*}}, default [[DEFAULT_BB:bb[0-9]+]]
+//
+// CHECK: [[DEFAULT_BB]](
+// CHECK: [[STACK_SLOT:%.*]] = alloc_stack $UInt8
+// CHECK: store [[ARG_INT_REPR]] to [trivial] [[STACK_SLOT]]
+// CHECK: [[DIAGNOSE_FUNC:%.*]] = function_ref @$ss32_diagnoseUnexpectedEnumCaseValue4type03rawE0s5NeverOxm_q_tr0_lF : $@convention(thin) <τ_0_0, τ_0_1> (@thick τ_0_0.Type, @in_guaranteed τ_0_1) -> Never
+// CHECK: apply [[DIAGNOSE_FUNC]]<ObjCEnum, UInt8>([[METATYPE]], [[STACK_SLOT]])
+// CHECK: unreachable
+// CHECK: } // end sil function '$s11switch_objc44checkObjCEnumUnhandledCaseDiagnosticEmission1xyAA0dE0O_tF'
+func checkObjCEnumUnhandledCaseDiagnosticEmission(x: ObjCEnum) {
+ switch x {
+ case .first:
+ break
+ case .second:
+ break
+ }
+}
diff --git a/test/SILOptimizer/allocbox_to_stack_not_crash.swift b/test/SILOptimizer/allocbox_to_stack_not_crash.swift
deleted file mode 100644
index 3441124..0000000
--- a/test/SILOptimizer/allocbox_to_stack_not_crash.swift
+++ /dev/null
@@ -1,15 +0,0 @@
-// RUN: %target-swift-frontend %s -emit-ir -verify
-
-// Verify we don't crash on this.
-// rdar://15595118
-infix operator ~>
-protocol Target {}
-
-func ~> <Target, Arg0, Result>(x: inout Target, f: @escaping (_: inout Target, _: Arg0) -> Result) -> (Arg0) -> Result {
- return { f(&x, $0) } // expected-error {{escaping closures can only capture inout parameters explicitly by value}}
-}
-
-func ~> (x: inout Int, f: @escaping (_: inout Int, _: Target) -> Target) -> (Target) -> Target {
- return { f(&x, $0) } // expected-error {{escaping closures can only capture inout parameters explicitly by value}}
-}
-
diff --git a/test/SILOptimizer/allocbox_to_stack_not_crash_ownership.swift b/test/SILOptimizer/allocbox_to_stack_not_crash_ownership.swift
deleted file mode 100644
index 3441124..0000000
--- a/test/SILOptimizer/allocbox_to_stack_not_crash_ownership.swift
+++ /dev/null
@@ -1,15 +0,0 @@
-// RUN: %target-swift-frontend %s -emit-ir -verify
-
-// Verify we don't crash on this.
-// rdar://15595118
-infix operator ~>
-protocol Target {}
-
-func ~> <Target, Arg0, Result>(x: inout Target, f: @escaping (_: inout Target, _: Arg0) -> Result) -> (Arg0) -> Result {
- return { f(&x, $0) } // expected-error {{escaping closures can only capture inout parameters explicitly by value}}
-}
-
-func ~> (x: inout Int, f: @escaping (_: inout Int, _: Target) -> Target) -> (Target) -> Target {
- return { f(&x, $0) } // expected-error {{escaping closures can only capture inout parameters explicitly by value}}
-}
-
diff --git a/test/SILOptimizer/exclusivity_static_diagnostics.swift b/test/SILOptimizer/exclusivity_static_diagnostics.swift
index 7d73d30..9e4dca5 100644
--- a/test/SILOptimizer/exclusivity_static_diagnostics.swift
+++ b/test/SILOptimizer/exclusivity_static_diagnostics.swift
@@ -607,10 +607,10 @@
}
}
-// TODO: A conflict should also be detected here. However, the
-// typechecker does not allow it. Enable the following test if we ever
-// remove this case from the typechecker test:
-// diag_invalid_inout_captures.swift.
-// public func nestedConflict(x: inout Int) {
-// doit(x: &x, x == 0 ? { x = 1 } : { x = 2})
-// }
+func doit(x: inout Int, _ fn: () -> ()) {}
+
+func nestedConflict(x: inout Int) {
+ doit(x: &x, x == 0 ? { x = 1 } : { x = 2})
+ // expected-error@-1 2{{overlapping accesses to 'x', but modification requires exclusive access; consider copying to a local variable}}
+ // expected-note@-2 2{{conflicting access is here}}
+}
diff --git a/test/SILOptimizer/inout_capture_diagnostics.swift b/test/SILOptimizer/inout_capture_diagnostics.swift
deleted file mode 100644
index 1d91dc0..0000000
--- a/test/SILOptimizer/inout_capture_diagnostics.swift
+++ /dev/null
@@ -1,28 +0,0 @@
-// RUN: %target-swift-frontend -enforce-exclusivity=checked -Onone -emit-sil -swift-version 4 -verify -parse-as-library %s
-//
-// This is an adjunct to access_enforcement_noescape.swift to cover early static diagnostics.
-
-// Helper
-func doOneInout(_: ()->(), _: inout Int) {}
-
-// Error: Cannot capture nonescaping closure.
-// expected-note@+1{{parameter 'fn' is implicitly non-escaping}}
-func reentrantCapturedNoescape(fn: (() -> ()) -> ()) {
- // expected-error@+1{{closure use of non-escaping parameter 'fn' may allow it to escape}}
- let c = { fn {} }
- fn(c)
-}
-
-// Error: inout cannot be captured.
-func inoutReadBoxWriteInout(x: inout Int) {
- // expected-error@+1{{escaping closures can only capture inout parameters explicitly by value}}
- let c = { _ = x }
- doOneInout(c, &x)
-}
-
-// Error: Cannot capture inout
-func inoutWriteBoxWriteInout(x: inout Int) {
- // expected-error@+1{{escaping closures can only capture inout parameters explicitly by value}}
- let c = { x = 42 }
- doOneInout(c, &x)
-}
diff --git a/test/SILOptimizer/invalid_escaping_captures.swift b/test/SILOptimizer/invalid_escaping_captures.swift
new file mode 100644
index 0000000..e11e8f9
--- /dev/null
+++ b/test/SILOptimizer/invalid_escaping_captures.swift
@@ -0,0 +1,178 @@
+// RUN: %target-swift-frontend -emit-sil %s -verify
+
+func takesEscaping(_: @escaping () -> ()) {}
+
+func takesNonEscaping(_ fn: () -> ()) { fn() }
+
+func badClosureCaptureInOut1(x: inout Int) { // expected-note {{parameter 'x' is declared 'inout'}}
+ takesEscaping { // expected-error {{escaping closure captures 'inout' parameter 'x'}}
+ x += 1 // expected-note {{captured here}}
+ }
+}
+
+func badClosureCaptureInOut2(x: inout Int, b: Bool) { // expected-note 2{{parameter 'x' is declared 'inout'}}
+ takesEscaping(b ? { // expected-error {{escaping closure captures 'inout' parameter 'x'}}
+ x += 1 // expected-note {{captured here}}
+ } : { // expected-error {{escaping closure captures 'inout' parameter 'x'}}
+ x -= 1 // expected-note {{captured here}}
+ })
+}
+
+func badClosureCaptureNoEscape1(y: () -> ()) { // expected-note {{parameter 'y' is implicitly non-escaping}}
+ takesEscaping { // expected-error {{escaping closure captures non-escaping parameter 'y'}}
+ y() // expected-note {{captured here}}
+ }
+}
+
+func badClosureCaptureNoEscape2(y: () -> (), b: Bool) { // expected-note 2{{parameter 'y' is implicitly non-escaping}}
+ takesEscaping(b ? { // expected-error {{escaping closure captures non-escaping parameter 'y'}}
+ y() // expected-note {{captured here}}
+ } : { // expected-error {{escaping closure captures non-escaping parameter 'y'}}
+ y() // expected-note {{captured here}}
+ })
+}
+
+func badClosureCaptureNoEscape3(y: () -> ()) {
+ let yy = (y, y)
+
+ takesEscaping { // expected-error {{escaping closure captures non-escaping value}}
+ yy.0() // expected-note {{captured here}}
+ }
+}
+
+func badClosureCaptureNoEscape4(y: () -> (), z: () -> (), b: Bool) {
+ let x = b ? y : z
+
+ takesEscaping { // expected-error {{escaping closure captures non-escaping value}}
+ x() // expected-note {{captured here}}
+ }
+}
+
+func badLocalFunctionCaptureInOut1(x: inout Int) { // expected-note {{parameter 'x' is declared 'inout'}}
+ func local() {
+ x += 1 // expected-note {{captured here}}
+ }
+
+ takesEscaping(local) // expected-error {{escaping closure captures 'inout' parameter 'x'}}
+}
+
+func badLocalFunctionCaptureInOut2(x: inout Int) { // expected-note {{parameter 'x' is declared 'inout'}}
+ func local() {
+ x += 1 // expected-note {{captured here}}
+ }
+
+ takesEscaping { // expected-error {{escaping closure captures 'inout' parameter 'x'}}
+ local() // expected-note {{captured indirectly by this call}}
+ }
+}
+
+func badLocalFunctionCaptureInOut3(x: inout Int) { // expected-note {{parameter 'x' is declared 'inout'}}
+ func local1() {
+ x += 1 // expected-note {{captured here}}
+ }
+
+ func local2() {
+ local1() // expected-note {{captured indirectly by this call}}
+ }
+
+ takesEscaping(local2) // expected-error {{escaping closure captures 'inout' parameter 'x'}}
+}
+
+func badLocalFunctionCaptureNoEscape1(y: () -> ()) { // expected-note {{parameter 'y' is implicitly non-escaping}}
+ func local() {
+ y() // expected-note {{captured here}}
+ }
+
+ takesEscaping(local) // expected-error {{escaping closure captures non-escaping parameter 'y'}}
+}
+
+func badLocalFunctionCaptureNoEscape2(y: () -> ()) { // expected-note {{parameter 'y' is implicitly non-escaping}}
+ func local() {
+ y() // expected-note {{captured here}}
+ }
+
+ takesEscaping { // expected-error {{escaping closure captures non-escaping parameter 'y'}}
+ local() // expected-note {{captured indirectly by this call}}
+ }
+}
+
+func badLocalFunctionCaptureNoEscape3(y: () -> ()) { // expected-note {{parameter 'y' is implicitly non-escaping}}
+ func local1() {
+ y() // expected-note {{captured here}}
+ }
+
+ func local2() {
+ local1() // expected-note {{captured indirectly by this call}}
+ }
+
+ takesEscaping(local2) // expected-error {{escaping closure captures non-escaping parameter 'y'}}
+}
+
+func badLocalFunctionCaptureNoEscape4(y: () -> ()) { // expected-note {{parameter 'y' is implicitly non-escaping}}
+ func local1() {
+ takesNonEscaping(y) // expected-note {{captured here}}
+ }
+
+ func local2() {
+ local1() // expected-note {{captured indirectly by this call}}
+ }
+
+ takesEscaping(local2) // expected-error {{escaping closure captures non-escaping parameter 'y'}}
+}
+
+// Capturing 'self' produces a different diagnostic.
+struct SelfCapture {
+ var a: Int
+ mutating func badLocalFunctionCaptureInOut() {
+ // FIXME: The 'captured here' location chosen here is not ideal, because
+ // the original closure is formed in a closure that is nested inside the
+ // local function. That's a funny edge case that trips up the heuristics.
+ func _foo() {
+ a += 1
+ takesEscaping { // expected-error {{escaping closure captures mutating 'self' parameter}}
+ _foo() // expected-note {{captured here}}
+ }
+ }
+ }
+}
+
+// Make sure reabstraction thunks don't cause problems.
+func takesEscapingGeneric<T>(_: @escaping () -> T) {}
+
+func testGenericClosureReabstraction(x: inout Int) { // expected-note {{parameter 'x' is declared 'inout'}}
+ takesEscapingGeneric { () -> Int in // expected-error {{escaping closure captures 'inout' parameter 'x'}}
+ x += 1 // expected-note {{captured here}}
+ return 0
+ }
+}
+
+func testGenericLocalFunctionReabstraction(x: inout Int) { // expected-note {{parameter 'x' is declared 'inout'}}
+ func local() -> Int {
+ x += 1 // expected-note {{captured here}}
+ return 0
+ }
+ takesEscapingGeneric(local) // expected-error {{escaping closure captures 'inout' parameter 'x'}}
+}
+
+// Make sure that withoutActuallyEscaping counts as a safe use.
+func goodUseOfNoEscapeClosure(fn: () -> (), fn2: () -> ()) {
+ withoutActuallyEscaping(fn) { _fn in
+ takesEscaping(_fn)
+ }
+}
+
+// Some random regression tests
+infix operator ~>
+protocol Target {}
+
+func ~> <Target, Arg0, Result>(x: inout Target, f: @escaping (_: inout Target, _: Arg0) -> Result) -> (Arg0) -> Result {
+ // expected-note@-1 {{parameter 'x' is declared 'inout'}}
+ return { f(&x, $0) } // expected-note {{captured here}}
+ // expected-error@-1 {{escaping closure captures 'inout' parameter 'x'}}
+}
+
+func ~> (x: inout Int, f: @escaping (_: inout Int, _: Target) -> Target) -> (Target) -> Target {
+ // expected-note@-1 {{parameter 'x' is declared 'inout'}}
+ return { f(&x, $0) } // expected-note {{captured here}}
+ // expected-error@-1 {{escaping closure captures 'inout' parameter 'x'}}
+}
\ No newline at end of file
diff --git a/test/SILOptimizer/noescape_param_exclusivity.swift b/test/SILOptimizer/noescape_param_exclusivity.swift
new file mode 100644
index 0000000..5d4c74a
--- /dev/null
+++ b/test/SILOptimizer/noescape_param_exclusivity.swift
@@ -0,0 +1,48 @@
+// RUN: %target-swift-frontend -emit-sil %s -verify
+
+func test0(a: (() -> ()) -> (), b: () -> ()) {
+ a(b) // expected-error {{passing a non-escaping function parameter 'b' to a call to a non-escaping function parameter can allow re-entrant modification of a variable}}
+}
+
+func test0(fn: (() -> ()) -> ()) {
+ fn { fn {} } // expected-error {{passing a closure which captures a non-escaping function parameter 'fn' to a call to a non-escaping function parameter can allow re-entrant modification of a variable}}
+}
+
+func test1(fn: (() -> ()) -> ()) {
+ func foo() {
+ fn { fn {} } // expected-error {{passing a closure which captures a non-escaping function parameter 'fn' to a call to a non-escaping function parameter can allow re-entrant modification of a variable}}
+ }
+}
+
+func test2(x: inout Int, fn: (() -> ()) -> ()) {
+ func foo(myfn: () -> ()) {
+ x += 1
+ myfn()
+ }
+
+ // Make sure we only complain about calls to noescape parameters.
+ foo { fn {} }
+}
+
+func test3(fn: (() -> ()) -> ()) {
+ { myfn in myfn { fn {} } }(fn) // expected-error {{passing a closure which captures a non-escaping function parameter 'fn' to a call to a non-escaping function parameter can allow re-entrant modification of a variable}}
+}
+
+func test4(fn: (() -> ()) -> ()) {
+ func foo() {
+ fn {}
+ }
+
+ fn(foo) // expected-error {{passing a closure which captures a non-escaping function parameter 'fn' to a call to a non-escaping function parameter can allow re-entrant modification of a variable}}
+}
+
+// rdar://problem/34496304
+func test5(outer: (() throws -> Int) throws -> Int) throws -> Int {
+ func descend(_ inner: (() throws -> Int) throws -> Int) throws -> Int {
+ return try inner { // expected-error {{passing a closure which captures a non-escaping function parameter 'inner' to a call to a non-escaping function parameter can allow re-entrant modification of a variable}}
+ try descend(inner)
+ }
+ }
+
+ return try descend(outer)
+}
\ No newline at end of file
diff --git a/test/SILOptimizer/verify_noescape_closure.sil b/test/SILOptimizer/verify_noescape_closure.sil
deleted file mode 100644
index 872b86f..0000000
--- a/test/SILOptimizer/verify_noescape_closure.sil
+++ /dev/null
@@ -1,37 +0,0 @@
-// RUN: %empty-directory(%t)
-// RUN: not --crash %target-sil-opt -enable-sil-verify-all -enforce-exclusivity=unchecked -diagnose-static-exclusivity %s 2> %t/err.txt
-// RUN: %FileCheck %s < %t/err.txt
-
-// REQUIRES: asserts
-
-// The test in this file is meant to fail during verification which currently
-// only runs in the diagnose-static-exclusivity pass, but will eventually run in
-// SIL verification.
-
-import Builtin
-import Swift
-
-// CHECK: Applied argument must be @noescape function type: %{{.*}} = partial_apply
-// CHECK: A partial_apply with @inout_aliasable may only be used as a @noescape function type argument.
-
-sil @takesEscapingClosure : $@convention(thin) (@owned @callee_owned () -> ()) -> ()
-
-sil hidden [ossa] @closureWithArgument : $@convention(thin) (@inout_aliasable Int) -> () {
-bb0(%1 : $*Int):
- %3 = tuple ()
- return %3 : $()
-}
-
-sil [ossa] @missingNoescape : $@convention(thin) (Int) ->() {
-bb0(%0 : $Int):
- %2 = alloc_box ${ var Int }
- %3 = project_box %2 : ${ var Int }, 0
- store %0 to [trivial] %3 : $*Int
- %4 = function_ref @takesEscapingClosure : $@convention(thin) (@owned @callee_owned () -> ()) -> ()
- %5 = function_ref @closureWithArgument : $@convention(thin) (@inout_aliasable Int) -> ()
- %6 = partial_apply %5(%3) : $@convention(thin) (@inout_aliasable Int) -> ()
- %8 = apply %4(%6) : $@convention(thin) (@owned @callee_owned () -> ()) -> ()
- destroy_value %2 : ${ var Int }
- %9 = tuple ()
- return %9 : $()
-}
diff --git a/test/Sema/diag_invalid_inout_captures.swift b/test/Sema/diag_invalid_inout_captures.swift
deleted file mode 100644
index 354dfb8..0000000
--- a/test/Sema/diag_invalid_inout_captures.swift
+++ /dev/null
@@ -1,63 +0,0 @@
-// RUN: %target-typecheck-verify-swift
-
-func no_escape(_ you_say_price_of_my_love_is: () -> ()) {}
-func do_escape(_ not_a_price_you_are_willing_to_pay: @escaping () -> ()) {}
-
-struct you_cry_in_your_tea {
- mutating func which_you_hurl_in_the_sea_when_you_see_me_go_by() {
- no_escape { _ = self } // OK
- do_escape { _ = self } // expected-error {{escaping closure cannot capture a mutating self parameter}}
- // expected-note@-1 {{create a mutating copy of self, or explicitly capture self for immutability}}
- do_escape {
- [self] in
- _ = self // OK
- self.other_mutator() // expected-error {{cannot use mutating member on immutable value: 'self' is an immutable capture}}
- }
- }
-
- mutating func other_mutator() {}
-}
-
-func why_so_sad(line: inout String) {
- no_escape { line = "Remember we made an arrangement when you went away" } // OK
- do_escape { line = "now you're making me mad" } // expected-error {{escaping closures can only capture inout parameters explicitly by value}}
- do_escape { [line] in _ = line } // OK
-}
-
-func remember(line: inout String) -> () -> Void {
- func despite_our_estrangement() {
- line = "I'm your man"
- }
- no_escape(despite_our_estrangement)
- do_escape(despite_our_estrangement) // expected-error {{nested function with an implicitly captured inout parameter can only be used as a non-escaping argument}}
-
- return despite_our_estrangement // expected-error {{nested function cannot capture inout parameter and escape}}
-}
-
-// This arrangement should be legal, but the type checker does not currently allow it.
-//
-// TODO: If the type checker is ever fixed, we should enable the corresponding test in
-// SILOptimizer/exclusivity_static_diagnostics.swift.
-func its_complicated(condition: inout Int) {
- no_escape(condition == 0 ? { condition = 1 } : { condition = 2}) // expected-error 2 {{escaping closures can only capture inout parameters explicitly by value}}
-}
-
-// rdar://problem/46322943 - Improve error message about mutating self capture in escaping closures
-func rdar46322943() {
- struct S {
- var bar = 1
-
- func foo(_ fn: () -> Void) {
- fn()
- }
-
- mutating func main() {
- let fn = {
- self.bar += 1
- // expected-error@-1 {{escaping closure cannot capture a mutating self parameter}}
- // expected-note@-2 {{create a mutating copy of self, or explicitly capture self for immutability}}
- }
- self.foo(fn)
- }
- }
-}
diff --git a/test/api-digester/Inputs/stdlib-stable-abi.json b/test/api-digester/Inputs/stdlib-stable-abi.json
index b8a3605..c45369c 100644
--- a/test/api-digester/Inputs/stdlib-stable-abi.json
+++ b/test/api-digester/Inputs/stdlib-stable-abi.json
@@ -223181,81 +223181,6 @@
]
}
]
- },
- {
- "kind": "Conformance",
- "name": "RandomAccessCollection",
- "printedName": "RandomAccessCollection",
- "children": [
- {
- "kind": "TypeWitness",
- "name": "Element",
- "printedName": "Element",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "UInt",
- "printedName": "UInt",
- "usr": "s:Su"
- }
- ]
- },
- {
- "kind": "TypeWitness",
- "name": "Index",
- "printedName": "Index",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Int",
- "printedName": "Int",
- "usr": "s:Si"
- }
- ]
- },
- {
- "kind": "TypeWitness",
- "name": "SubSequence",
- "printedName": "SubSequence",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Slice",
- "printedName": "Slice<UInt.Words>",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Words",
- "printedName": "UInt.Words",
- "usr": "s:Su5WordsV"
- }
- ],
- "usr": "s:s5SliceV"
- }
- ]
- },
- {
- "kind": "TypeWitness",
- "name": "Indices",
- "printedName": "Indices",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Range",
- "printedName": "Range<Int>",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Int",
- "printedName": "Int",
- "usr": "s:Si"
- }
- ],
- "usr": "s:Sn"
- }
- ]
- }
- ]
}
]
},
@@ -227320,81 +227245,6 @@
]
}
]
- },
- {
- "kind": "Conformance",
- "name": "RandomAccessCollection",
- "printedName": "RandomAccessCollection",
- "children": [
- {
- "kind": "TypeWitness",
- "name": "Element",
- "printedName": "Element",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "UInt",
- "printedName": "UInt",
- "usr": "s:Su"
- }
- ]
- },
- {
- "kind": "TypeWitness",
- "name": "Index",
- "printedName": "Index",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Int",
- "printedName": "Int",
- "usr": "s:Si"
- }
- ]
- },
- {
- "kind": "TypeWitness",
- "name": "SubSequence",
- "printedName": "SubSequence",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Slice",
- "printedName": "Slice<Int.Words>",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Words",
- "printedName": "Int.Words",
- "usr": "s:Si5WordsV"
- }
- ],
- "usr": "s:s5SliceV"
- }
- ]
- },
- {
- "kind": "TypeWitness",
- "name": "Indices",
- "printedName": "Indices",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Range",
- "printedName": "Range<Int>",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Int",
- "printedName": "Int",
- "usr": "s:Si"
- }
- ],
- "usr": "s:Sn"
- }
- ]
- }
- ]
}
]
},
diff --git a/test/api-digester/Inputs/stdlib-stable.json b/test/api-digester/Inputs/stdlib-stable.json
index 532686c..5cbab5c 100644
--- a/test/api-digester/Inputs/stdlib-stable.json
+++ b/test/api-digester/Inputs/stdlib-stable.json
@@ -156358,109 +156358,6 @@
]
}
]
- },
- {
- "kind": "Conformance",
- "name": "RandomAccessCollection",
- "printedName": "RandomAccessCollection",
- "children": [
- {
- "kind": "TypeWitness",
- "name": "Element",
- "printedName": "Element",
- "children": [
- {
- "kind": "TypeNameAlias",
- "name": "Element",
- "printedName": "UInt.Words.Element",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "UInt",
- "printedName": "UInt",
- "usr": "s:Su"
- }
- ]
- }
- ]
- },
- {
- "kind": "TypeWitness",
- "name": "Index",
- "printedName": "Index",
- "children": [
- {
- "kind": "TypeNameAlias",
- "name": "Index",
- "printedName": "UInt.Words.Index",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Int",
- "printedName": "Int",
- "usr": "s:Si"
- }
- ]
- }
- ]
- },
- {
- "kind": "TypeWitness",
- "name": "SubSequence",
- "printedName": "SubSequence",
- "children": [
- {
- "kind": "TypeNameAlias",
- "name": "SubSequence",
- "printedName": "UInt.Words.SubSequence",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Slice",
- "printedName": "Slice<UInt.Words>",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Words",
- "printedName": "UInt.Words",
- "usr": "s:Su5WordsV"
- }
- ],
- "usr": "s:s5SliceV"
- }
- ]
- }
- ]
- },
- {
- "kind": "TypeWitness",
- "name": "Indices",
- "printedName": "Indices",
- "children": [
- {
- "kind": "TypeNameAlias",
- "name": "Indices",
- "printedName": "UInt.Words.Indices",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Range",
- "printedName": "Range<Int>",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Int",
- "printedName": "Int",
- "usr": "s:Si"
- }
- ],
- "usr": "s:Sn"
- }
- ]
- }
- ]
- }
- ]
}
]
},
@@ -160153,109 +160050,6 @@
]
}
]
- },
- {
- "kind": "Conformance",
- "name": "RandomAccessCollection",
- "printedName": "RandomAccessCollection",
- "children": [
- {
- "kind": "TypeWitness",
- "name": "Element",
- "printedName": "Element",
- "children": [
- {
- "kind": "TypeNameAlias",
- "name": "Element",
- "printedName": "Int.Words.Element",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "UInt",
- "printedName": "UInt",
- "usr": "s:Su"
- }
- ]
- }
- ]
- },
- {
- "kind": "TypeWitness",
- "name": "Index",
- "printedName": "Index",
- "children": [
- {
- "kind": "TypeNameAlias",
- "name": "Index",
- "printedName": "Int.Words.Index",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Int",
- "printedName": "Int",
- "usr": "s:Si"
- }
- ]
- }
- ]
- },
- {
- "kind": "TypeWitness",
- "name": "SubSequence",
- "printedName": "SubSequence",
- "children": [
- {
- "kind": "TypeNameAlias",
- "name": "SubSequence",
- "printedName": "Int.Words.SubSequence",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Slice",
- "printedName": "Slice<Int.Words>",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Words",
- "printedName": "Int.Words",
- "usr": "s:Si5WordsV"
- }
- ],
- "usr": "s:s5SliceV"
- }
- ]
- }
- ]
- },
- {
- "kind": "TypeWitness",
- "name": "Indices",
- "printedName": "Indices",
- "children": [
- {
- "kind": "TypeNameAlias",
- "name": "Indices",
- "printedName": "Int.Words.Indices",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Range",
- "printedName": "Range<Int>",
- "children": [
- {
- "kind": "TypeNominal",
- "name": "Int",
- "printedName": "Int",
- "usr": "s:Si"
- }
- ],
- "usr": "s:Sn"
- }
- ]
- }
- ]
- }
- ]
}
]
},
diff --git a/test/attr/attr_autoclosure.swift b/test/attr/attr_autoclosure.swift
index 14ded18..67aa6d7 100644
--- a/test/attr/attr_autoclosure.swift
+++ b/test/attr/attr_autoclosure.swift
@@ -68,40 +68,22 @@
@autoclosure let delayed: () -> Int // expected-error {{attribute can only be applied to types, not declarations}}
}
-// @autoclosure(escaping)
+// @autoclosure(escaping) is no longer a thing; just make sure we don't crash
// expected-error @+1 {{attribute can only be applied to types, not declarations}}
func func10(@autoclosure(escaping _: () -> ()) { } // expected-error{{expected parameter name followed by ':'}}
-func func11(_: @autoclosure(escaping) @noescape () -> ()) { } // expected-error{{@escaping conflicts with @noescape}}
- // expected-error@-1{{@autoclosure(escaping) has been removed; use @autoclosure @escaping instead}} {{28-38= @escaping}}
-
-class Super {
- func f1(_ x: @autoclosure(escaping) () -> ()) { }
- // expected-error@-1{{@autoclosure(escaping) has been removed; use @autoclosure @escaping instead}} {{28-38= @escaping}}
- func f2(_ x: @autoclosure(escaping) () -> ()) { } // expected-note {{potential overridden instance method 'f2' here}}
- // expected-error@-1{{@autoclosure(escaping) has been removed; use @autoclosure @escaping instead}} {{28-38= @escaping}}
- func f3(x: @autoclosure () -> ()) { }
-}
-
-class Sub : Super {
- override func f1(_ x: @autoclosure(escaping)() -> ()) { }
- // expected-error@-1{{@autoclosure(escaping) has been removed; use @autoclosure @escaping instead}} {{37-47= @escaping }}
- override func f2(_ x: @autoclosure () -> ()) { } // expected-error{{does not override any method}} // expected-note{{type does not match superclass instance method with type '(@autoclosure @escaping () -> ()) -> ()'}}
- override func f3(_ x: @autoclosure(escaping) () -> ()) { } // expected-error{{does not override any method}}
- // expected-error@-1{{@autoclosure(escaping) has been removed; use @autoclosure @escaping instead}} {{37-47= @escaping}}
-}
+func func11(_: @autoclosure(escaping) @noescape () -> ()) { } // expected-error{{use of undeclared type 'escaping'}}
+// expected-error @-1 {{attribute can only be applied to types, not declarations}}
+// expected-error @-2 {{expected ',' separator}}
+// expected-error @-3 {{expected parameter name followed by ':'}}
func func12_sink(_ x: @escaping () -> Int) { }
func func12a(_ x: @autoclosure () -> Int) {
- // expected-note@-1{{parameter 'x' is implicitly non-escaping}}
+ // expected-note@-1{{parameter 'x' is implicitly non-escaping}}
func12_sink(x) // expected-error {{passing non-escaping parameter 'x' to function expecting an @escaping closure}}
}
-func func12b(_ x: @autoclosure(escaping) () -> Int) {
- // expected-error@-1{{@autoclosure(escaping) has been removed; use @autoclosure @escaping instead}} {{31-41= @escaping}}
- func12_sink(x) // ok
-}
func func12c(_ x: @autoclosure @escaping () -> Int) {
func12_sink(x) // ok
}
@@ -116,7 +98,7 @@
func test() {
func12a(x + foo()) // okay
- func12b(x + foo())
+ func12c(x + foo())
// expected-error@-1{{reference to property 'x' in closure requires explicit 'self.' to make capture semantics explicit}} {{13-13=self.}}
// expected-error@-2{{call to method 'foo' in closure requires explicit 'self.' to make capture semantics explicit}} {{17-17=self.}}
}
@@ -131,8 +113,6 @@
let _ : AutoclosureFailableOf<Int> = .Success(42)
let _ : (@autoclosure () -> ()) -> ()
-let _ : (@autoclosure(escaping) () -> ()) -> ()
- // expected-error@-1{{@autoclosure(escaping) has been removed; use @autoclosure @escaping instead}} {{22-32= @escaping}}
// escaping is the name of param type
let _ : (@autoclosure(escaping) -> ()) -> () // expected-error {{use of undeclared type 'escaping'}}
@@ -210,10 +190,9 @@
func same<T>(_: T, _: T) {}
func takesAnAutoclosure(_ fn: @autoclosure () -> Int, _ efn: @escaping @autoclosure () -> Int) {
- // expected-note@-1 2{{parameter 'fn' is implicitly non-escaping}}
-
- var _ = fn // expected-error {{non-escaping parameter 'fn' may only be called}}
- let _ = fn // expected-error {{non-escaping parameter 'fn' may only be called}}
+ // These are OK -- they count as non-escaping uses
+ var _ = fn
+ let _ = fn
var _ = efn
let _ = efn
diff --git a/test/attr/attr_escaping.swift b/test/attr/attr_escaping.swift
index 9c62c45..b51a230 100644
--- a/test/attr/attr_escaping.swift
+++ b/test/attr/attr_escaping.swift
@@ -5,17 +5,17 @@
func wrongParamType(a: @escaping Int) {} // expected-error {{@escaping attribute only applies to function types}}
-func conflictingAttrs(_ fn: @noescape @escaping () -> Int) {} // expected-error {{@escaping conflicts with @noescape}}
- // expected-error@-1{{@noescape is the default and has been removed}} {{29-39=}}
+func conflictingAttrs(_ fn: @noescape @escaping () -> Int) {} // expected-error {{unknown attribute 'noescape'}}
func takesEscaping(_ fn: @escaping () -> Int) {} // ok
func callEscapingWithNoEscape(_ fn: () -> Int) {
// expected-note@-1{{parameter 'fn' is implicitly non-escaping}} {{37-37=@escaping }}
- // expected-note@-2{{parameter 'fn' is implicitly non-escaping}} {{37-37=@escaping }}
takesEscaping(fn) // expected-error{{passing non-escaping parameter 'fn' to function expecting an @escaping closure}}
- let _ = fn // expected-error{{non-escaping parameter 'fn' may only be called}}
+
+ // This is a non-escaping use:
+ let _ = fn
}
typealias IntSugar = Int
@@ -60,16 +60,6 @@
func callEscapingAutoclosureWithNoEscape(_ fn: () -> Int) {
takesEscapingAutoclosure(1+1)
}
-func callEscapingAutoclosureWithNoEscape_2(_ fn: () -> Int) {
- // expected-note@-1{{parameter 'fn' is implicitly non-escaping}}
-
- takesEscapingAutoclosure(fn()) // expected-error{{closure use of non-escaping parameter 'fn' may allow it to escape}}
-}
-func callEscapingAutoclosureWithNoEscape_3(_ fn: @autoclosure () -> Int) {
- // expected-note@-1{{parameter 'fn' is implicitly non-escaping}}
-
- takesEscapingAutoclosure(fn()) // expected-error{{closure use of non-escaping parameter 'fn' may allow it to escape}}
-}
let foo: @escaping (Int) -> Int // expected-error{{@escaping attribute may only be used in function parameter position}} {{10-20=}}
diff --git a/test/attr/attr_inlinable_typealias.swift b/test/attr/attr_inlinable_typealias.swift
index 850ad8b..2c2488c 100644
--- a/test/attr/attr_inlinable_typealias.swift
+++ b/test/attr/attr_inlinable_typealias.swift
@@ -5,6 +5,7 @@
internal typealias InternalAlias = Int
// expected-note@-1 {{type alias 'InternalAlias' is not '@usableFromInline' or public}}
+// expected-note@-2 * {{type alias 'InternalAlias' is not '@usableFromInline' or public}}
@usableFromInline typealias UsableFromInlineAlias = Int
@@ -21,3 +22,8 @@
_ = PublicAlias.self
}
+
+@inlinable public func localTypealiases() {
+ typealias LocalAlias = InternalAlias // expected-warning {{type alias 'InternalAlias' is internal and should not be referenced from an '@inlinable' function}}
+ typealias GenericAlias<T> = (T, InternalAlias) // expected-warning {{type alias 'InternalAlias' is internal and should not be referenced from an '@inlinable' function}}
+}
diff --git a/test/attr/attr_noescape.swift b/test/attr/attr_noescape.swift
index 737a5cb..dad2f0d 100644
--- a/test/attr/attr_noescape.swift
+++ b/test/attr/attr_noescape.swift
@@ -2,12 +2,11 @@
@noescape var fn : () -> Int = { 4 } // expected-error {{attribute can only be applied to types, not declarations}}
-func conflictingAttrs(_ fn: @noescape @escaping () -> Int) {} // expected-error {{@escaping conflicts with @noescape}}
-// expected-error@-1{{@noescape is the default and has been removed}} {{29-39=}}
+func conflictingAttrs(_ fn: @noescape @escaping () -> Int) {} // expected-error {{unknown attribute 'noescape'}}
func doesEscape(_ fn : @escaping () -> Int) {}
-func takesGenericClosure<T>(_ a : Int, _ fn : @noescape () -> T) {} // expected-error{{@noescape is the default and has been removed}} {{47-57=}}
+func takesGenericClosure<T>(_ a : Int, _ fn : @noescape () -> T) {} // expected-error 2{{unknown attribute 'noescape'}}
var globalAny: Any = 0
@@ -25,33 +24,14 @@
}
func takesNoEscapeClosure(_ fn : () -> Int) {
- // expected-note@-1{{parameter 'fn' is implicitly non-escaping}} {{34-34=@escaping }}
- // expected-note@-2{{parameter 'fn' is implicitly non-escaping}} {{34-34=@escaping }}
- // expected-note@-3{{parameter 'fn' is implicitly non-escaping}} {{34-34=@escaping }}
- // expected-note@-4{{parameter 'fn' is implicitly non-escaping}} {{34-34=@escaping }}
- // expected-note@-5{{parameter 'fn' is implicitly non-escaping}} {{34-34=@escaping }}
- // expected-note@-6{{parameter 'fn' is implicitly non-escaping}} {{34-34=@escaping }}
- // expected-note@-7{{parameter 'fn' is implicitly non-escaping}} {{34-34=@escaping }}
- // expected-note@-8{{parameter 'fn' is implicitly non-escaping}} {{34-34=@escaping }}
+ // expected-note@-1 5{{parameter 'fn' is implicitly non-escaping}} {{34-34=@escaping }}
takesNoEscapeClosure { 4 } // ok
_ = fn() // ok
- var x = fn // expected-error {{non-escaping parameter 'fn' may only be called}}
-
// This is ok, because the closure itself is noescape.
takesNoEscapeClosure { fn() }
- // This is not ok, because it escapes the 'fn' closure.
- doesEscape { fn() } // expected-error {{closure use of non-escaping parameter 'fn' may allow it to escape}}
-
- // This is not ok, because it escapes the 'fn' closure.
- func nested_function() {
- _ = fn() // expected-error {{declaration closing over non-escaping parameter 'fn' may allow it to escape}}
- }
-
- takesNoEscapeClosure(fn) // ok
-
doesEscape(fn) // expected-error {{passing non-escaping parameter 'fn' to function expecting an @escaping closure}}
takesGenericClosure(4, fn) // ok
takesGenericClosure(4) { fn() } // ok.
@@ -64,6 +44,7 @@
_ = "\(takesArray([fn]))" // expected-error {{using non-escaping parameter 'fn' in a context expecting an @escaping closure}}
assignToGlobal(fn) // expected-error {{converting non-escaping value to 'T' may allow it to escape}}
+ assignToGlobal((fn, fn)) // expected-error {{converting non-escaping value to 'T' may allow it to escape}}
}
class SomeClass {
@@ -190,22 +171,21 @@
// Implicit conversions (in this case to @convention(block)) are ok.
@_silgen_name("whatever")
-func takeNoEscapeAsObjCBlock(_: @noescape @convention(block) () -> Void) // expected-error{{@noescape is the default and has been removed}} {{33-43=}}
-func takeNoEscapeTest2(_ fn : @noescape () -> ()) { // expected-error{{@noescape is the default and has been removed}} {{31-41=}}
+func takeNoEscapeAsObjCBlock(_: @noescape @convention(block) () -> Void) // expected-error{{unknown attribute 'noescape'}}
+func takeNoEscapeTest2(_ fn : @noescape () -> ()) { // expected-error{{unknown attribute 'noescape'}}
takeNoEscapeAsObjCBlock(fn)
}
-// Autoclosure implies noescape, but produce nice diagnostics so people know
-// why noescape problems happen.
+// Autoclosure implies noescape..
func testAutoclosure(_ a : @autoclosure () -> Int) { // expected-note{{parameter 'a' is implicitly non-escaping}}
- doesEscape { a() } // expected-error {{closure use of non-escaping parameter 'a' may allow it to escape}}
+ doesEscape(a) // expected-error {{passing non-escaping parameter 'a' to function expecting an @escaping closure}}
}
// <rdar://problem/19470858> QoI: @autoclosure implies @noescape, so you shouldn't be allowed to specify both
-func redundant(_ fn : @noescape // expected-error @+1 {{@noescape is implied by @autoclosure and should not be redundantly specified}}
+func redundant(_ fn : @noescape
@autoclosure () -> Int) {
- // expected-error@-2{{@noescape is the default and has been removed}} {{23-33=}}
+ // expected-error@-2{{unknown attribute 'noescape'}}
}
@@ -222,26 +202,26 @@
struct S : P2 {
typealias Element = Int
- func each(_ transform: @noescape (Int) -> ()) { // expected-error{{@noescape is the default and has been removed}} {{26-36=}}
- overloadedEach(self, // expected-error {{cannot invoke 'overloadedEach' with an argument list of type '(S, (Int) -> (), Int)'}}
+ func each(_ transform: @noescape (Int) -> ()) { // expected-error{{unknown attribute 'noescape'}}
+ overloadedEach(self, // expected-error {{cannot invoke 'overloadedEach' with an argument list of type '(S, (Int) -> (), Int)'}}
+ // expected-note @-1 {{overloads for 'overloadedEach' exist with these partially matching parameter lists: (O, @escaping (O.Element) -> (), T), (P, @escaping (P.Element) -> (), T)}}
transform, 1)
- // expected-note @-2 {{overloads for 'overloadedEach' exist with these partially matching parameter lists: (O, @escaping (O.Element) -> (), T), (P, @escaping (P.Element) -> (), T)}}
}
}
// rdar://19763676 - False positive in @noescape analysis triggered by parameter label
-func r19763676Callee(_ f: @noescape (_ param: Int) -> Int) {} // expected-error{{@noescape is the default and has been removed}} {{27-37=}}
+func r19763676Callee(_ f: @noescape (_ param: Int) -> Int) {} // expected-error{{unknown attribute 'noescape'}}
-func r19763676Caller(_ g: @noescape (Int) -> Int) { // expected-error{{@noescape is the default and has been removed}} {{27-37=}}
+func r19763676Caller(_ g: @noescape (Int) -> Int) { // expected-error{{unknown attribute 'noescape'}}
r19763676Callee({ _ in g(1) })
}
// <rdar://problem/19763732> False positive in @noescape analysis triggered by default arguments
-func calleeWithDefaultParameters(_ f: @noescape () -> (), x : Int = 1) {} // expected-error{{@noescape is the default and has been removed}} {{39-49=}}
-func callerOfDefaultParams(_ g: @noescape () -> ()) { // expected-error{{@noescape is the default and has been removed}} {{33-43=}}
+func calleeWithDefaultParameters(_ f: @noescape () -> (), x : Int = 1) {} // expected-error{{unknown attribute 'noescape'}}
+func callerOfDefaultParams(_ g: @noescape () -> ()) { // expected-error{{unknown attribute 'noescape'}}
calleeWithDefaultParameters(g)
}
@@ -269,22 +249,22 @@
/// SR-770 - Currying and `noescape`/`rethrows` don't work together anymore
-func curriedFlatMap<A, B>(_ x: [A]) -> (@noescape (A) -> [B]) -> [B] { // expected-error{{@noescape is the default and has been removed}} {{41-50=}}
+func curriedFlatMap<A, B>(_ x: [A]) -> (@noescape (A) -> [B]) -> [B] { // expected-error 2{{unknown attribute 'noescape'}}
return { f in
x.flatMap(f)
}
}
-func curriedFlatMap2<A, B>(_ x: [A]) -> (@noescape (A) -> [B]) -> [B] { // expected-error{{@noescape is the default and has been removed}} {{42-51=}}
- return { (f : @noescape (A) -> [B]) in // expected-error{{@noescape is the default and has been removed}} {{17-27=}}
+func curriedFlatMap2<A, B>(_ x: [A]) -> (@noescape (A) -> [B]) -> [B] { // expected-error 2{{unknown attribute 'noescape'}}
+ return { (f : @noescape (A) -> [B]) in // expected-error{{unknown attribute 'noescape'}}
x.flatMap(f)
}
}
func bad(_ a : @escaping (Int)-> Int) -> Int { return 42 }
-func escapeNoEscapeResult(_ x: [Int]) -> (@noescape (Int) -> Int) -> Int { // expected-error{{@noescape is the default and has been removed}} {{43-52=}}
- return { f in // expected-note{{parameter 'f' is implicitly non-escaping}}
- bad(f) // expected-error {{passing non-escaping parameter 'f' to function expecting an @escaping closure}}
+func escapeNoEscapeResult(_ x: [Int]) -> (@noescape (Int) -> Int) -> Int { // expected-error{{unknown attribute 'noescape'}}
+ return { f in // expected-note {{parameter 'f' is implicitly non-escaping}}
+ bad(f) // expected-error {{passing non-escaping parameter 'f' to function expecting an @escaping closure}}
}
}
@@ -293,7 +273,7 @@
//
// Old syntax -- @noescape is the default, and is redundant
-typealias CompletionHandlerNE = @noescape (_ success: Bool) -> () // expected-error{{@noescape is the default and has been removed}} {{33-43=}}
+typealias CompletionHandlerNE = @noescape (_ success: Bool) -> () // expected-error{{unknown attribute 'noescape'}}
// Explicit @escaping is not allowed here
typealias CompletionHandlerE = @escaping (_ success: Bool) -> () // expected-error{{@escaping attribute may only be used in function parameter position}} {{32-42=}}
@@ -304,19 +284,16 @@
var escape : CompletionHandlerNE
var escapeOther : CompletionHandler
func doThing1(_ completion: (_ success: Bool) -> ()) {
- // expected-note@-1{{parameter 'completion' is implicitly non-escaping}}
- // expected-error @+1 {{non-escaping parameter 'completion' may only be called}}
- escape = completion // expected-error {{declaration closing over non-escaping parameter 'escape' may allow it to escape}}
+ // expected-note@-1 {{parameter 'completion' is implicitly non-escaping}}
+ escape = completion // expected-error {{assigning non-escaping parameter 'completion' to an @escaping closure}}
}
func doThing2(_ completion: CompletionHandlerNE) {
- // expected-note@-1{{parameter 'completion' is implicitly non-escaping}}
- // expected-error @+1 {{non-escaping parameter 'completion' may only be called}}
- escape = completion // expected-error {{declaration closing over non-escaping parameter 'escape' may allow it to escape}}
+ // expected-note@-1 {{parameter 'completion' is implicitly non-escaping}}
+ escape = completion // expected-error {{assigning non-escaping parameter 'completion' to an @escaping closure}}
}
func doThing3(_ completion: CompletionHandler) {
- // expected-note@-1{{parameter 'completion' is implicitly non-escaping}}
- // expected-error @+1 {{non-escaping parameter 'completion' may only be called}}
- escape = completion // expected-error {{declaration closing over non-escaping parameter 'escape' may allow it to escape}}
+ // expected-note@-1 {{parameter 'completion' is implicitly non-escaping}}
+ escape = completion // expected-error {{assigning non-escaping parameter 'completion' to an @escaping closure}}
}
func doThing4(_ completion: @escaping CompletionHandler) {
escapeOther = completion
@@ -324,11 +301,8 @@
// <rdar://problem/19997680> @noescape doesn't work on parameters of function type
func apply<T, U>(_ f: @noescape (T) -> U, g: @noescape (@noescape (T) -> U) -> U) -> U {
- // expected-error@-1{{@noescape is the default and has been removed}} {{23-33=}}
- // expected-error@-2{{@noescape is the default and has been removed}} {{46-56=}}
- // expected-error@-3{{@noescape is the default and has been removed}} {{57-66=}}
+ // expected-error@-1 6{{unknown attribute 'noescape'}}
return g(f)
- // expected-error@-1{{passing a non-escaping function parameter 'f' to a call to a non-escaping function parameter}}
}
// <rdar://problem/19997577> @noescape cannot be applied to locals, leading to duplication of code
@@ -337,8 +311,8 @@
case Function(() -> r19997577Type, () -> r19997577Type)
case Sum(() -> r19997577Type, () -> r19997577Type)
- func reduce<Result>(_ initial: Result, _ combine: @noescape (Result, r19997577Type) -> Result) -> Result { // expected-error{{@noescape is the default and has been removed}} {{53-63=}}
- let binary: @noescape (r19997577Type, r19997577Type) -> Result = { combine(combine(combine(initial, self), $0), $1) } // expected-error{{@noescape is the default and has been removed}} {{17-27=}}
+ func reduce<Result>(_ initial: Result, _ combine: @noescape (Result, r19997577Type) -> Result) -> Result { // expected-error 2{{unknown attribute 'noescape'}}
+ let binary: @noescape (r19997577Type, r19997577Type) -> Result = { combine(combine(combine(initial, self), $0), $1) } // expected-error{{unknown attribute 'noescape'}}
switch self {
case .Unit:
return combine(initial, self)
@@ -352,7 +326,7 @@
// type attribute and decl attribute
func noescapeD(@noescape f: @escaping () -> Bool) {} // expected-error {{attribute can only be applied to types, not declarations}}
-func noescapeT(f: @noescape () -> Bool) {} // expected-error{{@noescape is the default and has been removed}} {{19-29=}}
+func noescapeT(f: @noescape () -> Bool) {} // expected-error{{unknown attribute 'noescape'}}
func noescapeG<T>(@noescape f: () -> T) {} // expected-error{{attribute can only be applied to types, not declarations}}
func autoclosureD(@autoclosure f: () -> Bool) {} // expected-error {{attribute can only be applied to types, not declarations}}
@@ -360,7 +334,7 @@
func autoclosureG<T>(@autoclosure f: () -> T) {} // expected-error{{attribute can only be applied to types, not declarations}}
func noescapeD_noescapeT(@noescape f: @noescape () -> Bool) {} // expected-error {{attribute can only be applied to types, not declarations}}
- // expected-error@-1{{@noescape is the default and has been removed}} {{39-49=}}
+ // expected-error@-1{{unknown attribute 'noescape'}}
func autoclosureD_noescapeT(@autoclosure f: @noescape () -> Bool) {} // expected-error {{attribute can only be applied to types, not declarations}}
- // expected-error@-1{{@noescape is the default and has been removed}} {{45-55=}}
+ // expected-error@-1{{unknown attribute 'noescape'}}
diff --git a/test/attr/attributes.swift b/test/attr/attributes.swift
index 5905819..2eb337e 100644
--- a/test/attr/attributes.swift
+++ b/test/attr/attributes.swift
@@ -210,8 +210,9 @@
func func_type_attribute_with_space(x: @convention (c) () -> Int) {} // OK. Known attributes can have space before its paren.
-// @thin is not supported except in SIL.
-var thinFunc : @thin () -> () // expected-error {{attribute is not supported}}
+// @thin and @pseudogeneric are not supported except in SIL.
+var thinFunc : @thin () -> () // expected-error {{unknown attribute 'thin'}}
+var pseudoGenericFunc : @pseudogeneric () -> () // expected-error {{unknown attribute 'pseudogeneric'}}
@inline(never) func nolineFunc() {}
@inline(never) var noinlineVar : Int { return 0 }
diff --git a/test/decl/protocol/conforms/circular_validation.swift b/test/decl/protocol/conforms/circular_validation.swift
index ecb234e..055f3ea 100644
--- a/test/decl/protocol/conforms/circular_validation.swift
+++ b/test/decl/protocol/conforms/circular_validation.swift
@@ -11,3 +11,8 @@
static var x = 0 // expected-note {{candidate operates on a type, not an instance as required}}
var x = S.x // expected-note {{candidate references itself}}
}
+
+// FIXME: Lousy diagnostics on this case.
+protocol SR9224_Foo: SR9224_Foobar {} // expected-error 2 {{protocol 'SR9224_Foo' refines itself}}
+protocol SR9224_Bar: SR9224_Foobar {} // expected-error {{protocol 'SR9224_Bar' refines itself}} expected-note {{protocol 'SR9224_Bar' declared here}}
+typealias SR9224_Foobar = SR9224_Foo & SR9224_Bar
\ No newline at end of file
diff --git a/test/decl/var/usage.swift b/test/decl/var/usage.swift
index 22121ce..c577041 100644
--- a/test/decl/var/usage.swift
+++ b/test/decl/var/usage.swift
@@ -96,8 +96,24 @@
struct TestStruct {
var property = 42
-}
+ var mutatingProperty: Int {
+ mutating get { return 0 }
+ mutating set {}
+ }
+ var nonmutatingProperty: Int {
+ nonmutating get { return 0 }
+ nonmutating set {}
+ }
+ subscript(mutating index: Int) -> Int {
+ mutating get { return 0 }
+ mutating set {}
+ }
+ subscript(nonmutating index: Int) -> Int {
+ nonmutating get { return 0 }
+ nonmutating set {}
+ }
+}
func testStructMember() -> TestStruct {
var x = TestStruct() // ok
@@ -105,6 +121,53 @@
return x
}
+func testMutatingProperty_get() -> TestStruct {
+ var x = TestStruct() // ok
+ _ = x.mutatingProperty
+ return x
+}
+
+func testMutatingProperty_set() -> TestStruct {
+ var x = TestStruct() // ok
+ x.mutatingProperty = 17
+ return x
+}
+
+func testNonmutatingProperty_get() -> TestStruct {
+ var x = TestStruct() // expected-warning {{variable 'x' was never mutated; consider changing to 'let' constant}}
+ _ = x.nonmutatingProperty
+ return x
+}
+
+func testNonmutatingProperty_set() -> TestStruct {
+ var x = TestStruct() // expected-warning {{variable 'x' was never mutated; consider changing to 'let' constant}}
+ x.nonmutatingProperty = 17
+ return x
+}
+
+func testMutatingSubscript_get() -> TestStruct {
+ var x = TestStruct() // ok
+ _ = x[mutating: 4]
+ return x
+}
+
+func testMutatingSubscript_set() -> TestStruct {
+ var x = TestStruct() // ok
+ x[mutating: 4] = 17
+ return x
+}
+
+func testNonmutatingSubscript_get() -> TestStruct {
+ var x = TestStruct() // expected-warning {{variable 'x' was never mutated; consider changing to 'let' constant}}
+ _ = x[nonmutating: 4]
+ return x
+}
+
+func testNonmutatingSubscript_set() -> TestStruct {
+ var x = TestStruct() // expected-warning {{variable 'x' was never mutated; consider changing to 'let' constant}}
+ x[nonmutating: 4] = 17
+ return x
+}
func testSubscript() -> [Int] {
var x = [1,2,3] // ok
@@ -112,6 +175,11 @@
return x
}
+func testSubscriptNeverMutated() -> [Int] {
+ var x = [1,2,3] // expected-warning {{variable 'x' was never mutated; consider changing to 'let' constant}}
+ _ = x[1]
+ return x
+}
func testTuple(_ x : Int) -> Int {
var x = x
@@ -178,7 +246,10 @@
protocol Fooable {
mutating func mutFoo()
func immutFoo()
+ var mutatingProperty: Int { mutating get mutating set }
+ var nonmutatingProperty: Int { nonmutating get nonmutating set }
}
+
func testOpenExistential(_ x: Fooable,
y: Fooable) {
var x = x
@@ -187,6 +258,25 @@
y.immutFoo()
}
+func testOpenExistential_mutatingProperty_get(p: Fooable) {
+ var x = p
+ _ = x.mutatingProperty
+}
+
+func testOpenExistential_mutatingProperty_set(p: Fooable) {
+ var x = p
+ x.mutatingProperty = 4
+}
+
+func testOpenExistential_nonmutatingProperty_get(p: Fooable) {
+ var x = p // expected-warning {{variable 'x' was never mutated; consider changing to 'let' constant}}
+ _ = x.nonmutatingProperty
+}
+
+func testOpenExistential_nonmutatingProperty_set(p: Fooable) {
+ var x = p // expected-warning {{variable 'x' was never mutated; consider changing to 'let' constant}}
+ x.nonmutatingProperty = 4
+}
func couldThrow() throws {}
diff --git a/test/expr/postfix/call/noescape-param-exclusivity.swift b/test/expr/postfix/call/noescape-param-exclusivity.swift
deleted file mode 100644
index 0c658d3..0000000
--- a/test/expr/postfix/call/noescape-param-exclusivity.swift
+++ /dev/null
@@ -1,40 +0,0 @@
-// RUN: %target-typecheck-verify-swift -swift-version 4
-
-// FIXME: make these errors
-
-func test0(fn: (() -> ()) -> ()) {
- fn { fn {} } // expected-error {{passing a closure which captures a non-escaping function parameter 'fn' to a call to a non-escaping function parameter can allow re-entrant modification of a variable}}
-}
-
-func test1(fn: (() -> ()) -> ()) { // expected-note {{parameter 'fn' is implicitly non-escaping}}
- // TODO: infer that this function is noescape from its captures
- func foo() {
- fn { fn {} } // expected-error {{can allow re-entrant modification}}
- // expected-error@-1 {{declaration closing over non-escaping parameter 'fn' may allow it to escape}}
- }
-}
-
-func test2(x: inout Int, fn: (() -> ()) -> ()) {
- func foo(myfn: () -> ()) {
- x += 1
- myfn()
- }
-
- // Make sure we only complain about calls to noescape parameters.
- foo { fn {} }
-}
-
-func test3(fn: (() -> ()) -> ()) {
- { myfn in myfn { fn {} } }(fn) // expected-error {{can allow re-entrant modification}}
-}
-
-func test4(fn: (() -> ()) -> ()) { // expected-note {{parameter 'fn' is implicitly non-escaping}}
- // TODO: infer that this function is noescape from its captures
- func foo() {
- fn {}
- // expected-error@-1 {{declaration closing over non-escaping parameter 'fn' may allow it to escape}}
- // FIXME: if the above is ever not an error, we should diagnose at the call below
- }
-
- fn(foo)
-}
diff --git a/test/lit.cfg b/test/lit.cfg
index 945a8b6..b6cd795 100644
--- a/test/lit.cfg
+++ b/test/lit.cfg
@@ -170,9 +170,12 @@
# Choose between lit's internal shell pipeline runner and a real shell. If
# LIT_USE_INTERNAL_SHELL is in the environment, we use that as an override.
-use_lit_shell = os.environ.get('LIT_USE_INTERNAL_SHELL', not kIsWindows)
+use_lit_shell = os.environ.get('LIT_USE_INTERNAL_SHELL', kIsWindows)
+if not use_lit_shell:
+ config.available_features.add('shell')
+
config.test_format = swift_test.SwiftTest(coverage_mode=config.coverage_mode,
- execute_external=use_lit_shell)
+ execute_external=not use_lit_shell)
# suffixes: A list of file extensions to treat as test files.
config.suffixes = ['.swift', '.ll', '.sil', '.gyb', '.m', '.swiftinterface',
diff --git a/test/multifile/lazy.swift b/test/multifile/lazy.swift
index 9d7c478..63c7729 100644
--- a/test/multifile/lazy.swift
+++ b/test/multifile/lazy.swift
@@ -9,3 +9,9 @@
func test2(s: Test2) {
_ = s.property
}
+
+// rdar://49482742 - shouldn't warn about 's' never being mutated
+func test3() {
+ var s = Test1()
+ _ = s.property
+}
diff --git a/test/stdlib/StringCompatibilityDiagnostics4.swift b/test/stdlib/StringCompatibilityDiagnostics4.swift
index fcd3665..f1b4682 100644
--- a/test/stdlib/StringCompatibilityDiagnostics4.swift
+++ b/test/stdlib/StringCompatibilityDiagnostics4.swift
@@ -1,7 +1,7 @@
// RUN: %target-swift-frontend -typecheck -swift-version 4 %s -verify
func testPopFirst() {
- var str = "abc"
+ let str = "abc"
var charView: String.CharacterView // expected-warning{{'CharacterView' is deprecated: Please use String directly}}
charView = str.characters // expected-warning{{'characters' is deprecated: Please use String directly}}
dump(charView)
diff --git a/test/stdlib/TestJSONEncoder.swift b/test/stdlib/TestJSONEncoder.swift
index ff6fde8..9850c5d 100644
--- a/test/stdlib/TestJSONEncoder.swift
+++ b/test/stdlib/TestJSONEncoder.swift
@@ -256,7 +256,7 @@
/// our precision requests in every case. This bug effects Darwin, FreeBSD, and Linux currently
/// causing this test (which uses the current time) to fail occasionally.
let evalEdgeCase: (Date, Date) -> () = { decodedDate, expectedDate in
- if formattedLength(of: decodedDate.timeIntervalSinceReferenceDate) > DBL_DECIMAL_DIG + 2 {
+ if formattedLength(of: decodedDate.timeIntervalSinceReferenceDate) > DBL_DECIMAL_DIG {
let adjustedTimeIntervalSinceReferenceDate: (Date) -> Double = {
let adjustment = pow(10, Double(DBL_DECIMAL_DIG))
return Double(floor(adjustment * $0.timeIntervalSinceReferenceDate) / adjustment)
@@ -286,9 +286,15 @@
}
}
- // Test the above `snprintf` edge case evaluation with a known triggering case
- let knownBadDate = Date(timeIntervalSinceReferenceDate: 0.0021413276231263384)
- localTestRoundTrip(of: TopLevelWrapper(knownBadDate))
+ // Test the above `snprintf` edge case evaluation with known triggering cases
+
+ // Tests the two precision digits larger case
+ let knownBadDateTwoExtraDigits = Date(timeIntervalSinceReferenceDate: 0.0021413276231263384)
+ localTestRoundTrip(of: TopLevelWrapper(knownBadDateTwoExtraDigits))
+
+ // Tests the one precision digit larger case
+ let knownBadDateOneExtraDigit = Date(timeIntervalSinceReferenceDate: 576487829.7193049)
+ localTestRoundTrip(of: TopLevelWrapper(knownBadDateOneExtraDigit))
// We can't encode a top-level Date, so it'll be wrapped in a dictionary.
localTestRoundTrip(of: TopLevelWrapper(Date()))
diff --git a/test/type/infer/local_variables.swift b/test/type/infer/local_variables.swift
index a60335c..35bd6f6 100644
--- a/test/type/infer/local_variables.swift
+++ b/test/type/infer/local_variables.swift
@@ -20,11 +20,11 @@
func infer_generic_args() {
// Simple types
- var x : Dictionary = ["Hello" : 1]
+ let x : Dictionary = ["Hello" : 1]
var i : Int = x["Hello"]!
// Tuples
- var (d, s) : (Dictionary, Array) = ( ["Hello" : 1], [1, 2, 3] )
+ let (d, s) : (Dictionary, Array) = ( ["Hello" : 1], [1, 2, 3] )
i = d["Hello"]!
i = s[i]
diff --git a/tools/swift-api-digester/ModuleAnalyzerNodes.cpp b/tools/swift-api-digester/ModuleAnalyzerNodes.cpp
index 05d9d00..3b98998 100644
--- a/tools/swift-api-digester/ModuleAnalyzerNodes.cpp
+++ b/tools/swift-api-digester/ModuleAnalyzerNodes.cpp
@@ -1024,27 +1024,34 @@
}
}
+static
+StringRef printGenericSignature(SDKContext &Ctx, ArrayRef<Requirement> AllReqs) {
+ llvm::SmallString<32> Result;
+ llvm::raw_svector_ostream OS(Result);
+ if (AllReqs.empty())
+ return StringRef();
+ OS << "<";
+ bool First = true;
+ for (auto Req: AllReqs) {
+ if (!First) {
+ OS << ", ";
+ } else {
+ First = false;
+ }
+ if (Ctx.checkingABI())
+ getCanonicalRequirement(Req).print(OS, PrintOptions::printInterface());
+ else
+ Req.print(OS, PrintOptions::printInterface());
+ }
+ OS << ">";
+ return Ctx.buffer(OS.str());
+}
+
static StringRef printGenericSignature(SDKContext &Ctx, Decl *D) {
llvm::SmallString<32> Result;
llvm::raw_svector_ostream OS(Result);
if (auto *PD = dyn_cast<ProtocolDecl>(D)) {
- if (PD->getRequirementSignature().empty())
- return StringRef();
- OS << "<";
- bool First = true;
- for (auto Req: PD->getRequirementSignature()) {
- if (!First) {
- OS << ", ";
- } else {
- First = false;
- }
- if (Ctx.checkingABI())
- getCanonicalRequirement(Req).print(OS, PrintOptions::printInterface());
- else
- Req.print(OS, PrintOptions::printInterface());
- }
- OS << ">";
- return Ctx.buffer(OS.str());
+ return printGenericSignature(Ctx, PD->getRequirementSignature());
}
if (auto *GC = D->getAsGenericContext()) {
@@ -1059,6 +1066,11 @@
return StringRef();
}
+static
+StringRef printGenericSignature(SDKContext &Ctx, ProtocolConformance *Conf) {
+ return printGenericSignature(Ctx, Conf->getConditionalRequirements());
+}
+
static Optional<uint8_t> getSimilarMemberCount(NominalTypeDecl *NTD,
ValueDecl *VD,
llvm::function_ref<bool(Decl*)> Check) {
@@ -1161,6 +1173,9 @@
SDKNodeInitInfo::SDKNodeInitInfo(SDKContext &Ctx, ProtocolConformance *Conform):
SDKNodeInitInfo(Ctx, Conform->getProtocol()) {
+ // The conformance can be conditional. The generic signature keeps track of
+ // the requirements.
+ GenericSig = printGenericSignature(Ctx, Conform);
// Whether this conformance is ABI placeholder depends on the decl context
// of this conformance.
IsABIPlaceholder = isABIPlaceholderRecursive(Conform->getDeclContext()->
@@ -1562,9 +1577,12 @@
void swift::ide::api::
SwiftDeclCollector::addConformancesToTypeDecl(SDKNodeDeclType *Root,
NominalTypeDecl *NTD) {
+ // Avoid adding the same conformance twice.
+ SmallPtrSet<ProtocolConformance*, 4> Seen;
for (auto &Conf: NTD->getAllConformances()) {
- if (!Ctx.shouldIgnore(Conf->getProtocol()))
+ if (!Ctx.shouldIgnore(Conf->getProtocol()) && !Seen.count(Conf))
Root->addConformance(constructConformanceNode(Conf));
+ Seen.insert(Conf);
}
}
diff --git a/unittests/runtime/Mutex.cpp b/unittests/runtime/Mutex.cpp
index 6e67cec..7d5dac15 100644
--- a/unittests/runtime/Mutex.cpp
+++ b/unittests/runtime/Mutex.cpp
@@ -555,10 +555,12 @@
template <typename RW> void readLockWhileReadLockedThreaded(RW &lock) {
lock.readLock();
- std::vector<std::atomic<bool>> results(10);
+ const int threadCount = 10;
+
+ std::atomic<bool> results[threadCount] = {};
std::atomic<bool> done(false);
- threadedExecute(10,
+ threadedExecute(threadCount,
[&](int index) {
// Always perform at least one iteration of this loop to
// avoid spurious failures if this thread is slow to run.
@@ -596,10 +598,12 @@
template <typename RW> void readLockWhileWriteLockedThreaded(RW &lock) {
lock.writeLock();
- std::vector<std::atomic<int>> results(10);
+ const int threadCount = 10;
+
+ std::atomic<int> results[threadCount] = {};
std::atomic<bool> done(false);
- threadedExecute(10,
+ threadedExecute(threadCount,
[&](int index) {
// Always perform at least one iteration of this loop to
// avoid spurious failures if this thread is slow to run.
@@ -638,7 +642,7 @@
const int threadCount = 10;
- std::vector<std::atomic<int>> results(threadCount);
+ std::atomic<int> results[threadCount] = {};
std::atomic<bool> done(false);
threadedExecute(threadCount,
@@ -680,7 +684,7 @@
const int threadCount = 10;
- std::vector<std::atomic<int>> results(threadCount);
+ std::atomic<int> results[threadCount] = {};
std::atomic<bool> done(false);
threadedExecute(threadCount,
@@ -753,7 +757,7 @@
const int threadCount = 10;
- std::vector<std::atomic<bool>> results(threadCount);
+ std::atomic<bool> results[threadCount] = {};
std::atomic<bool> done(false);
threadedExecute(threadCount,
diff --git a/utils/WindowsSDKVFSOverlay.yaml.in b/utils/WindowsSDKVFSOverlay.yaml.in
index f2faf48..6147459 100644
--- a/utils/WindowsSDKVFSOverlay.yaml.in
+++ b/utils/WindowsSDKVFSOverlay.yaml.in
@@ -29,6 +29,9 @@
- name: "@UniversalCRTSdkDir@/Include/@UCRTVersion@/um"
type: directory
contents:
+ - name: accctrl.h
+ type: file
+ external-contents: "@UniversalCRTSdkDir@/Include/@UCRTVersion@/um/AccCtrl.h"
- name: commctrl.h
type: file
external-contents: "@UniversalCRTSdkDir@/Include/@UCRTVersion@/um/CommCtrl.h"
diff --git a/utils/build-script b/utils/build-script
index 6fd36fa..2d0cbd0 100755
--- a/utils/build-script
+++ b/utils/build-script
@@ -328,87 +328,98 @@
# FIXME: We should move the platform-derived arguments to be entirely
# data driven, so that we can eliminate this code duplication and just
# iterate over all supported platforms.
+ self.platforms_to_skip_build = self.__platforms_to_skip_build(args)
+ self.platforms_to_skip_test = self.__platforms_to_skip_test(args)
+ self.platforms_archs_to_skip_test = \
+ self.__platforms_archs_to_skip_test(args)
+ self.platforms_to_skip_test_host = \
+ self.__platforms_to_skip_test_host(args)
- self.platforms_to_skip_build = set()
+ self.build_libparser_only = args.build_libparser_only
+
+ def __platforms_to_skip_build(self, args):
+ platforms_to_skip_build = set()
if not args.build_linux:
- self.platforms_to_skip_build.add(StdlibDeploymentTarget.Linux)
+ platforms_to_skip_build.add(StdlibDeploymentTarget.Linux)
if not args.build_freebsd:
- self.platforms_to_skip_build.add(StdlibDeploymentTarget.FreeBSD)
+ platforms_to_skip_build.add(StdlibDeploymentTarget.FreeBSD)
if not args.build_cygwin:
- self.platforms_to_skip_build.add(StdlibDeploymentTarget.Cygwin)
+ platforms_to_skip_build.add(StdlibDeploymentTarget.Cygwin)
if not args.build_osx:
- self.platforms_to_skip_build.add(StdlibDeploymentTarget.OSX)
+ platforms_to_skip_build.add(StdlibDeploymentTarget.OSX)
if not args.build_ios_device:
- self.platforms_to_skip_build.add(StdlibDeploymentTarget.iOS)
+ platforms_to_skip_build.add(StdlibDeploymentTarget.iOS)
if not args.build_ios_simulator:
- self.platforms_to_skip_build.add(
- StdlibDeploymentTarget.iOSSimulator)
+ platforms_to_skip_build.add(StdlibDeploymentTarget.iOSSimulator)
if not args.build_tvos_device:
- self.platforms_to_skip_build.add(StdlibDeploymentTarget.AppleTV)
+ platforms_to_skip_build.add(StdlibDeploymentTarget.AppleTV)
if not args.build_tvos_simulator:
- self.platforms_to_skip_build.add(
+ platforms_to_skip_build.add(
StdlibDeploymentTarget.AppleTVSimulator)
if not args.build_watchos_device:
- self.platforms_to_skip_build.add(StdlibDeploymentTarget.AppleWatch)
+ platforms_to_skip_build.add(StdlibDeploymentTarget.AppleWatch)
if not args.build_watchos_simulator:
- self.platforms_to_skip_build.add(
+ platforms_to_skip_build.add(
StdlibDeploymentTarget.AppleWatchSimulator)
if not args.build_android:
- self.platforms_to_skip_build.add(StdlibDeploymentTarget.Android)
+ platforms_to_skip_build.add(StdlibDeploymentTarget.Android)
+ return platforms_to_skip_build
- self.platforms_to_skip_test = set()
- self.platforms_archs_to_skip_test = set()
+ def __platforms_to_skip_test(self, args):
+ platforms_to_skip_test = set()
if not args.test_linux:
- self.platforms_to_skip_test.add(StdlibDeploymentTarget.Linux)
+ platforms_to_skip_test.add(StdlibDeploymentTarget.Linux)
if not args.test_freebsd:
- self.platforms_to_skip_test.add(StdlibDeploymentTarget.FreeBSD)
+ platforms_to_skip_test.add(StdlibDeploymentTarget.FreeBSD)
if not args.test_cygwin:
- self.platforms_to_skip_test.add(StdlibDeploymentTarget.Cygwin)
+ platforms_to_skip_test.add(StdlibDeploymentTarget.Cygwin)
if not args.test_osx:
- self.platforms_to_skip_test.add(StdlibDeploymentTarget.OSX)
+ platforms_to_skip_test.add(StdlibDeploymentTarget.OSX)
if not args.test_ios_host:
- self.platforms_to_skip_test.add(StdlibDeploymentTarget.iOS)
+ platforms_to_skip_test.add(StdlibDeploymentTarget.iOS)
else:
exit_rejecting_arguments("error: iOS device tests are not " +
"supported in open-source Swift.")
if not args.test_ios_simulator:
- self.platforms_to_skip_test.add(
- StdlibDeploymentTarget.iOSSimulator)
- if not args.test_ios_32bit_simulator:
- self.platforms_archs_to_skip_test.add(
- StdlibDeploymentTarget.iOSSimulator.i386)
+ platforms_to_skip_test.add(StdlibDeploymentTarget.iOSSimulator)
if not args.test_tvos_host:
- self.platforms_to_skip_test.add(StdlibDeploymentTarget.AppleTV)
+ platforms_to_skip_test.add(StdlibDeploymentTarget.AppleTV)
else:
exit_rejecting_arguments("error: tvOS device tests are not " +
"supported in open-source Swift.")
if not args.test_tvos_simulator:
- self.platforms_to_skip_test.add(
- StdlibDeploymentTarget.AppleTVSimulator)
+ platforms_to_skip_test.add(StdlibDeploymentTarget.AppleTVSimulator)
if not args.test_watchos_host:
- self.platforms_to_skip_test.add(StdlibDeploymentTarget.AppleWatch)
+ platforms_to_skip_test.add(StdlibDeploymentTarget.AppleWatch)
else:
exit_rejecting_arguments("error: watchOS device tests are not " +
"supported in open-source Swift.")
if not args.test_watchos_simulator:
- self.platforms_to_skip_test.add(
+ platforms_to_skip_test.add(
StdlibDeploymentTarget.AppleWatchSimulator)
if not args.test_android:
- self.platforms_to_skip_test.add(StdlibDeploymentTarget.Android)
+ platforms_to_skip_test.add(StdlibDeploymentTarget.Android)
- self.platforms_to_skip_test_host = set()
+ return platforms_to_skip_test
+
+ def __platforms_archs_to_skip_test(self, args):
+ platforms_archs_to_skip_test = set()
+ if not args.test_ios_32bit_simulator:
+ platforms_archs_to_skip_test.add(
+ StdlibDeploymentTarget.iOSSimulator.i386)
+ return platforms_archs_to_skip_test
+
+ def __platforms_to_skip_test_host(self, args):
+ platforms_to_skip_test_host = set()
if not args.test_android_host:
- self.platforms_to_skip_test_host.add(
- StdlibDeploymentTarget.Android)
+ platforms_to_skip_test_host.add(StdlibDeploymentTarget.Android)
if not args.test_ios_host:
- self.platforms_to_skip_test_host.add(StdlibDeploymentTarget.iOS)
+ platforms_to_skip_test_host.add(StdlibDeploymentTarget.iOS)
if not args.test_tvos_host:
- self.platforms_to_skip_test_host.add(
- StdlibDeploymentTarget.AppleTV)
+ platforms_to_skip_test_host.add(StdlibDeploymentTarget.AppleTV)
if not args.test_watchos_host:
- self.platforms_to_skip_test_host.add(
- StdlibDeploymentTarget.AppleWatch)
- self.build_libparser_only = args.build_libparser_only
+ platforms_to_skip_test_host.add(StdlibDeploymentTarget.AppleWatch)
+ return platforms_to_skip_test_host
def initialize_runtime_environment(self):
"""Change the program environment for building."""
@@ -440,7 +451,7 @@
toolchain=self.toolchain,
source_dir=self.workspace.source_dir("ninja"),
build_dir=self.workspace.build_dir("build", "ninja"))
- ninja_build.do_build()
+ ninja_build.build()
self.toolchain.ninja = ninja_build.ninja_bin_path
def convert_to_impl_arguments(self):
@@ -893,35 +904,18 @@
"""Execute the invocation with the configured arguments."""
# Convert to a build-script-impl invocation.
- (impl_env, impl_args) = self.convert_to_impl_arguments()
+ (self.impl_env, self.impl_args) = self.convert_to_impl_arguments()
# If using the legacy implementation, delegate all behavior to
# `build-script-impl`.
if self.args.legacy_impl:
# Execute the underlying build script implementation.
- shell.call_without_sleeping([build_script_impl] + impl_args,
- env=impl_env, echo=True)
+ shell.call_without_sleeping([build_script_impl] + self.impl_args,
+ env=self.impl_env, echo=True)
return
# Otherwise, we compute and execute the individual actions ourselves.
- def execute_one_impl_action(host=None, product_class=None, name=None):
- if host is None:
- assert (product_class is None and
- name == "merged-hosts-lipo"), "invalid action"
- action_name = name
- elif product_class is None:
- assert name in ("package", "extractsymbols"), "invalid action"
- action_name = "{}-{}".format(host.name, name)
- else:
- assert name is not None, "invalid action"
- action_name = "{}-{}-{}".format(
- host.name, product_class.product_name(), name)
- shell.call_without_sleeping(
- [build_script_impl] + impl_args + [
- "--only-execute", action_name],
- env=impl_env, echo=self.args.verbose_build)
-
# Compute the list of hosts to operate on.
all_host_names = [
self.args.host_target] + self.args.cross_compile_hosts
@@ -954,17 +948,17 @@
" ".join(config.swift_benchmark_run_targets)))
for product_class in impl_product_classes:
- execute_one_impl_action(host_target, product_class, "build")
+ self._execute_build_action(host_target, product_class)
# Test...
for host_target in all_hosts:
for product_class in impl_product_classes:
- execute_one_impl_action(host_target, product_class, "test")
+ self._execute_test_action(host_target, product_class)
# Install...
for host_target in all_hosts:
for product_class in impl_product_classes:
- execute_one_impl_action(host_target, product_class, "install")
+ self._execute_install_action(host_target, product_class)
# Non-build-script-impl products...
# Note: currently only supports building for the host.
@@ -980,19 +974,51 @@
source_dir=self.workspace.source_dir(product_source),
build_dir=self.workspace.build_dir(
host_target, product_name))
- product.do_build(host_target)
- product.do_test(host_target)
+ product.build(host_target)
+ product.test(host_target)
# Extract symbols...
for host_target in all_hosts:
- execute_one_impl_action(host_target, name="extractsymbols")
+ self._execute_extract_symbols_action(host_target)
# Package...
for host_target in all_hosts:
- execute_one_impl_action(host_target, name="package")
+ self._execute_package_action(host_target)
# Lipo...
- execute_one_impl_action(name="merged-hosts-lipo")
+ self._execute_merged_host_lipo_action()
+
+ def _execute_build_action(self, host_target, product_class):
+ action_name = "{}-{}-build".format(host_target.name,
+ product_class.product_name())
+ self._execute_action(action_name)
+
+ def _execute_test_action(self, host_target, product_class):
+ action_name = "{}-{}-test".format(host_target.name,
+ product_class.product_name())
+ self._execute_action(action_name)
+
+ def _execute_install_action(self, host_target, product_class):
+ action_name = "{}-{}-install".format(host_target.name,
+ product_class.product_name())
+ self._execute_action(action_name)
+
+ def _execute_extract_symbols_action(self, host_target):
+ action_name = "{}-extractsymbols".format(host_target.name)
+ self._execute_action(action_name)
+
+ def _execute_package_action(self, host_target):
+ action_name = "{}-package".format(host_target.name)
+ self._execute_action(action_name)
+
+ def _execute_merged_host_lipo_action(self):
+ self._execute_action("merged-hosts-lipo")
+
+ def _execute_action(self, action_name):
+ shell.call_without_sleeping(
+ [build_script_impl] + self.impl_args +
+ ["--only-execute", action_name],
+ env=self.impl_env, echo=self.args.verbose_build)
# Provide a short delay so accidentally invoked clean builds can be canceled.
diff --git a/utils/build-script-impl b/utils/build-script-impl
index 449130c..fa7c1a5 100755
--- a/utils/build-script-impl
+++ b/utils/build-script-impl
@@ -3091,8 +3091,8 @@
LIBDISPATCH_BUILD_DIR="$(build_directory ${host} libdispatch)"
FOUNDATION_BUILD_DIR=$(build_directory ${host} foundation)
DOTEST_EXTRA="-I${FOUNDATION_BUILD_DIR}"
- DOTEST_EXTRA="-Xcc -F${FOUNDATION_BUILD_DIR}"
- DOTEST_EXTRA="-Xcc -F${FOUNDATION_BUILD_DIR}/CoreFoundation-prefix/System/Library/Frameworks"
+ DOTEST_EXTRA="${DOTEST_EXTRA} -Xcc -F${FOUNDATION_BUILD_DIR}"
+ DOTEST_EXTRA="${DOTEST_EXTRA} -Xcc -F${FOUNDATION_BUILD_DIR}/CoreFoundation-prefix/System/Library/Frameworks"
DOTEST_EXTRA="${DOTEST_EXTRA} -I${FOUNDATION_BUILD_DIR}/swift"
DOTEST_EXTRA="${DOTEST_EXTRA} -I${LIBDISPATCH_SOURCE_DIR}"
DOTEST_EXTRA="${DOTEST_EXTRA} -L${FOUNDATION_BUILD_DIR}"
diff --git a/utils/swift_build_support/swift_build_support/products/benchmarks.py b/utils/swift_build_support/swift_build_support/products/benchmarks.py
index aa1efd1..e62fe41 100644
--- a/utils/swift_build_support/swift_build_support/products/benchmarks.py
+++ b/utils/swift_build_support/swift_build_support/products/benchmarks.py
@@ -28,19 +28,19 @@
def is_build_script_impl_product(cls):
return False
- def do_build(self, host_target):
+ def build(self, host_target):
run_build_script_helper(host_target, self, self.args)
- def do_test(self, host_target):
+ def test(self, host_target):
"""Just run a single instance of the command for both .debug and
.release.
"""
cmdline = ['--num-iters=1', 'XorLoop']
- debug_bench = os.path.join(self.build_dir, 'debug', 'SwiftBench')
- shell.call([debug_bench] + cmdline)
+ bench_Onone = os.path.join(self.build_dir, 'bin', 'Benchmark_Onone')
+ shell.call([bench_Onone] + cmdline)
- release_bench = os.path.join(self.build_dir, 'release', 'SwiftBench')
- shell.call([release_bench] + cmdline)
+ bench_O = os.path.join(self.build_dir, 'bin', 'Benchmark_O')
+ shell.call([bench_O] + cmdline)
def run_build_script_helper(host_target, product, args):
@@ -59,7 +59,8 @@
# We use a separate python helper to enable quicker iteration when working
# on this by avoiding going through build-script to test small changes.
- helper_path = os.path.join(package_path, 'utils', 'build_script_helper.py')
+ helper_path = os.path.join(package_path, 'scripts',
+ 'build_script_helper.py')
build_cmd = [
helper_path,
diff --git a/utils/swift_build_support/swift_build_support/products/indexstoredb.py b/utils/swift_build_support/swift_build_support/products/indexstoredb.py
index 41b464a..2927038 100644
--- a/utils/swift_build_support/swift_build_support/products/indexstoredb.py
+++ b/utils/swift_build_support/swift_build_support/products/indexstoredb.py
@@ -27,10 +27,10 @@
def is_build_script_impl_product(cls):
return False
- def do_build(self, host_target):
+ def build(self, host_target):
run_build_script_helper('build', host_target, self, self.args)
- def do_test(self, host_target):
+ def test(self, host_target):
if self.args.test and self.args.test_indexstoredb:
run_build_script_helper('test', host_target, self, self.args)
diff --git a/utils/swift_build_support/swift_build_support/products/ninja.py b/utils/swift_build_support/swift_build_support/products/ninja.py
index d01ca29..8f4bcaa 100644
--- a/utils/swift_build_support/swift_build_support/products/ninja.py
+++ b/utils/swift_build_support/swift_build_support/products/ninja.py
@@ -32,7 +32,7 @@
def ninja_bin_path(self):
return os.path.join(self.build_dir, 'ninja')
- def do_build(self):
+ def build(self):
if os.path.exists(self.ninja_bin_path):
return
diff --git a/utils/swift_build_support/swift_build_support/products/product.py b/utils/swift_build_support/swift_build_support/products/product.py
index 6fb917f..db8b6f6 100644
--- a/utils/swift_build_support/swift_build_support/products/product.py
+++ b/utils/swift_build_support/swift_build_support/products/product.py
@@ -38,15 +38,15 @@
"""
return True
- def do_build(self, host_target):
- """do_build() -> void
+ def build(self, host_target):
+ """build() -> void
Perform the build, for a non-build-script-impl product.
"""
raise NotImplementedError
- def do_test(self, host_target):
- """do_build() -> void
+ def test(self, host_target):
+ """test() -> void
Run the tests, for a non-build-script-impl product.
"""
diff --git a/utils/swift_build_support/swift_build_support/products/sourcekitlsp.py b/utils/swift_build_support/swift_build_support/products/sourcekitlsp.py
index 61b141f..794a29f 100644
--- a/utils/swift_build_support/swift_build_support/products/sourcekitlsp.py
+++ b/utils/swift_build_support/swift_build_support/products/sourcekitlsp.py
@@ -23,11 +23,11 @@
def is_build_script_impl_product(cls):
return False
- def do_build(self, host_target):
+ def build(self, host_target):
indexstoredb.run_build_script_helper(
'build', host_target, self, self.args)
- def do_test(self, host_target):
+ def test(self, host_target):
if self.args.test and self.args.test_sourcekitlsp:
indexstoredb.run_build_script_helper(
'test', host_target, self, self.args)
diff --git a/utils/swift_build_support/tests/products/test_ninja.py b/utils/swift_build_support/tests/products/test_ninja.py
index 74cbbe4..3edc659 100644
--- a/utils/swift_build_support/tests/products/test_ninja.py
+++ b/utils/swift_build_support/tests/products/test_ninja.py
@@ -79,14 +79,14 @@
self.assertEqual(ninja_build.ninja_bin_path, '/path/to/build/ninja')
- def test_do_build(self):
+ def test_build(self):
ninja_build = Ninja(
args=self.args,
toolchain=self.toolchain,
source_dir=self.workspace.source_dir('ninja'),
build_dir=self.workspace.build_dir('build', 'ninja'))
- ninja_build.do_build()
+ ninja_build.build()
expect_env = ""
if platform.system() == "Darwin":
