Xcode 11 Beta 2 Release

Notes
Xcode 11 beta 2 release notes downloaded by
GeeksCorner and sponsored by Creativley
Social.

Xcode 11 Beta 2 Release

Notes
Update your apps to use new features, and test
your apps against API changes.

Overview
Xcode 11 includes SDKs for iOS 13, macOS Catalina 10.15,
watchOS 6, and tvOS 13. Xcode 11 supports on-device
debugging for iOS 8 and later, tvOS 9 and later, and watchOS 2
and later. Xcode 11 requires a Mac running macOS Mojave
10.14.4 or later.
General
New Features
• Xcode 11 beta supports development with SwiftUI.

Note

Tools for SwiftUI development are only available when
running on macOS Catalina 10.15 beta.


• Xcode supports uploading apps from the Organizer

window or from the command line with xcodebuild or xcrun
altool. Application Loader is no longer included with Xcode.
(29008875)
• LaunchServices on macOS now respects the selected
Xcode when launching Instruments, Simulator, and other
developer tools embedded within Xcode. For example,
when you double-click an Instruments trace in Finder, the
version of Instruments for the selected Xcode launches.
Change which Xcode is used with xcode-select from the
command line. (6757601)
• Editors can be added to any window without needing the
Assistant Editor. Editors are added using the “Add Editor”
button in the jump bar or the File > New > Editor
command. Each editor can now be in one of three modes:
“Editor Only”, “Editor and Assistant” or “Editor and
Canvas”. The latter two modes automatically show relevant
content when available. When using multiple editors, the
View > Editor > Focus command can be used to
temporarily expand the active editor to fill the entire
window, hiding other editors. For source control support,
the Code Review button in the Toolbar replaces the
Comparison Editor. The “Show Authors” command is now
available from the Source Editor’s Editor menu. The SCM
Log is now in the Inspector Area. (43806898)
Known Issues
• Xcode 11 beta doesn’t support working with SwiftUI in a
project configured to use UIKit for Mac. (51201699)
• When you launch Xcode on macOS 10.15 beta, the
required packages installer might display erroneously.
(51080815)

Workaround: Continue through the installer.
• The Environment Overrides button doesn’t appear in the
debug bar for watchOS and iOS app extension targets until
you pause the process. (51203640)

Resolved Issues
• The Foundation integration for the Combine framework is
now available. The following Foundation and Grand
Central Dispatch integrations with Combine are available:
KeyValueObserving, NotificationCenter, RunLoop,
OperationQueue, Timer, URLSession, DispatchQueue,
JSONEncoder, JSONDecoder, PropertyListEncoder,
PropertyListDecoder, and the @Published property
wrapper. (51241500)
• Issue text is no longer light when using a light theme with a
dark system appearance. (48230278)

Apple Clang Compiler

New Features
• Clang now provides a mechanism for controlling exit-time
destructor registration. You can disable these globally with
the flag -fno-c++-static-destructors, or apply the attribute
[[clang::no_destroy]] to disable the destructors of specific
variables. The attribute [[clang::always_destroy]] was also
added to enable destructors of specific variables when -
fno-c++-static-destructors is used. (21734598)
• As an extension, C++11 enums with fixed underlying types
are now supported in all language modes. (43831380)
• Deprecation warnings will be issued when standard library
facilities that were deprecated in the active Standard
version are used. (46881474)
• Stack checking is on by default on all platforms to prevent
memory corruptions. (25859140)
• The machine code outliner is on by default under -Oz. It
reduces code size by identifying identical code sequences
across functions. Such sequences are encapsulated
(“outlined”) in a single compiler generated function. Each
original code sequence is replaced with a call to that
outlined function. (46385499)
• In order to improve performance and security the static
linker (ld) now moves globals that are marked as constant
into a new segment: __DATA_CONST. These globals may
consist of compiler generated pointers that the dynamic
linker (dyld) needs to fix up during load, but are otherwise
constant such as vtables and explicitly declared constant
pointers. Once dyld has finished loading the image it
makes __DATA_CONST readonly. This change doesn’t
impact well behaved code, but may break code that
depends on undefined behavior such as using a type pun
to write to a pointer that’s declared as const. (50898833)

static int value1 = 0; // Stored in __DATA
• static int value2 = 0; // Stored in __DATA
• const int * const valuePtr = &value1; // Stored in __DATA_CONST
•
• // ERROR: Attempting to store a value to a constant pointer
• (int *)valuePtr = &value2;
• 








• Clang now supports the C++17 <filesystem> library for iOS

13, macOS 10.15, watchOS 6, and tvOS 13. (50988273)
Known Issues
• An if (@available(…)) check never succeeds when present
in an object file or static archive built with Xcode 9 or
Xcode 10, but linked by Xcode 11 into an app or framework
that’s running on a iOS 13, macOS 10.15, watchOS 6, or
tvOS 13. (51109405)

Workaround: Rebuild the object file or static archive with
Xcode 11.
• When using manual retain-release, exceptions thrown from
the following methods or any functions or methods they
transitively call might not be caught: release, autorelease,
retain, alloc, or allocWithZone. (50253394)

Resolved Issues
• The <experimental/optional> and <experimental/variant>
headers are removed. Use <optional> and <variant> from
C++17 instead. (50175894)
• Resolved a long compile-time issue in the loop-invariant
code motion pass of the optimizer. (39648918)
Asset Catalog
New Features
• Assets can now be cut, copied, pasted, and duplicated
using the menu or keyboard shortcuts. (27107912)

Known Issues
• Interface Builder’s image inspector crashes when the asset
catalog has a symbol and bitmap image assets with the
same name. (51279661)
• New user-defined images added to the asset catalog don’t
show up in the image view image combo box until you
restart Xcode on macOS 10.15. (51090225)
• Runtime lookup of NSDataAsset might return the wrong
data when an asset has variants specified for iPad and
UIKit for Mac. (49990047)

Workaround: Use a different name for the UIKit for Mac
asset.

Build System
New Features
• Run script phases and custom build rules may declare and
emit a dependencies file, in the Makefile-style .d format
output used by some compilers and build tools. The build
system checks the files listed for changes during
subsequent builds when determining if the rule or phase
should be executed. (49226986)
• Projects may now use custom build rules to process
header files (APPLY_RULES_IN_COPY_HEADERS).
(48185100)
• Custom build rules can now specify additional, static input
files that are used during execution. These resolved input
file paths are supplied to rule scripts using the
SCRIPT_INPUT_FILE_# environment variables.
(49645853)
• Xcode removes some entries from the Info.plist file of a
product at build time if the entries are not appropriate for
the platform being built for, which is useful for targets which
are configured to build for multiple platforms. This behavior
can be disabled by setting the build setting
DISABLE_INFOPLIST_PLATFORM_PROCESSING to
YES, in which case the target must assume the
responsibility of managing these entries appropriately.
(47797497)
• Custom build rules can now declare that they should run
once per architecture (the default), or run only once across
all architectures. This is useful for custom rules which are
 architecture-neutral, for example, code generation tools
that generate files that don’t differ per architecture.
(47716990)
• XCFrameworks make it possible to bundle a binary
framework or library for multiple platforms —including iOS
devices, iOS simulators, and UIKit for Mac — into a single
distributable .xcframework bundle that your developers can
use within their own applications. An .xcframework bundle
can be added to an Xcode target’s Link Libraries phase
and Xcode uses the right platform’s version of the included
framework or library at build time. Creation of
XCFrameworks is supported from the command line using
xcodebuild -create-xcframework. Frameworks or libraries
bundled in an XCFramework should be built with the Build
Libraries for Distribution build setting set to YES.
(49948269)

Known Issues
• Watch targets that override the Architectures build setting
to just armv7k may fail to process in TestFlight and Xcode’s
enterprise distribution workflow. (51104990)

Workaround: Build the watchOS app with armv7k and
arm64_32.
• Incremental builds to may fail to codesign properly for non-
source related changes to your project, such as resource
file modifications, which can result in the app failing to
launch. (41254808)

Workaround: Change a source file within the same target
to trigger the codesign process, or perform a clean build.
• Updating your iOS app for Mac compatibility may show
new error diagnostics stating that certain frameworks or
functionality is not available on the Mac. If one of these
diagnostics is shown erroneously, you can disable it by
setting the VALIDATE_WORKSPACE build setting to NO.
(50607174)
• The new build system doesn’t evaluate a leading tilde (~)
in paths in build settings to the user’s home directory.
(41339901)

Workaround: Use $(HOME) instead.
• If a target enables RUN_CLANG_STATIC_ANALYZER,
then single file processing commands — such as Compile,
Preprocess, Show Assembly — won’t work correctly
because they generate the static analyzer output file rather
than the appropriate output. (43340227)

Workaround: Disable RUN_CLANG_STATIC_ANALYZER
in the target.
• If the build of an app-hosted test target — where
TEST_HOST is defined — fails, subsequent builds may fail
when signing the app product because the test target is
incomplete and unsigned when the initial signing of the app
occurs. (43402096)

Workaround: Perform a clean build. Or, manually delete
the unsigned test bundle from inside the app target’s
product and rebuild.
• Targets which override the Architectures and Valid
Architectures build settings for iOS may need to remove or
conditionalize the overrides to build correctly for Mac when
using UIKit for Mac. (51074742)
• When using Xcode on macOS 10.15, some files —
especially xib and storyboard files — might be copied
rather than compiled, resulting in an incorrect build
product. (49351105)

Workaround: In the File Inspector for the file which is
being copied, toggle the Type popup away from Default -
<some type> then back to Default. This resets the file type
in the project file to the correct type and enables the build
system to match it to the correct tool to process it.
• After closing and reopening a project, or when performing
incremental builds using xcodebuild, diagnostics from prior
builds regarding incompatible frameworks, app extensions,
and code signing settings may be displayed without a
 description in the Issue Navigator and Build Log.
(51131884)

Workaround: Use the Product menu to Clean Build
Folder, then build again.
• When building for the first time users may get a popup
stating that SimulatorTrampoline would like access to
Desktop Files because ibtool running in simulator needs
access to these files to compile storyboards. (51114450)

Workaround: Allow access to the files in the prompt.
• Some features that aren’t supported by the legacy build
system are ignored instead of emitting an error. This
includes use of build rule or script phase dependency files,
input declarations for custom build rules, and the
APPLY_RULES_IN_COPY_HEADERS build setting.
(51318274)
Resolved Issues
• By default, Xcode’s new build system doesn’t detect
changes in directories declared as inputs to shell script
build phases. Enabling the build setting
ALLOW_RECURSIVE_SCRIPT_INPUTS causes it to do
so. However, if any of the files inside such a directory are
generated by a task that depends on the output of the
script phase, then a dependency cycle error is emitted and
must be resolved by restructuring the target. (41126633)
• The build system no longer crashes when building some
targets that use On Demand Resources. (49072702)

Command Line Tools

Known Issues
• pip3 is unavailable using the default shell PATH.
(50877974)

 Workaround: Use xcrun to find and execute pip3. For
example: xcrun pip3.
• Python 3 is unavailable in the Command Line Tools
package. (51727440)

Workaround: Install Xcode 11 and select it using xcode-
select.

Core Data
New Features
• There is now a checkbox that makes it possible for you to
distinguish whether the default value of a string attribute
should be nil or the empty string. When set, the default
value is the empty string if no other default is specified.
(26534406)
• The Xcode 11 data model file format no longer writes out or
preserves deprecated Sync Services information for
entities or properties. (32524648)
• The Core Data data model editor has added support for
derived attributes when using the Xcode 11 data model file
format and an appropriate deployment target. (45567066)
• When creating an application using Core Data, there is a
new checkbox to also enable CloudKit support for the data
model’s default configuration. This can also be enabled for
an existing data model using the new configuration
inspector. When a data model configuration supports
CloudKit, the data model editor performs additional
validation to ensure the model conforms to the
requirements for Core Data CloudKit support. (51126024)
Resolved Issues
• Using the UUID attribute type, the URI attribute type, or the
persistent history feature properly generates an error when
used with a data model file format prior to the format used
in Xcode 9. (50188371)
Debugging
New Features
• The graphical filter in the Size inspector for debugging view
hierarchies identifies which attributes on the selected view
are constrained. Selecting attributes in the filter narrows
the displayed constraints to ones matching that attribute.
Standard modifier keys such as Shift and Command can
be used to expand the selection showing the union of
constraints matching those attributes. (44864394)
• You can now debug the view hierarchies of watchOS apps.
(45173634)
• You can now simulate network conditions and thermal
states for a connected device from the Devices and
Simulators window. (44608479)
• The view debugger shows UIWindowScene instances in
the debug navigator and canvas. (45378799)
• View debugging can be disabled in the scheme options.
(45928299)
• The Size inspector for debugging view hierarchies has
more details about constraints including a filter, hover
highlighting in the editor, and better descriptions.
(16153188)
• The view debugger supports debugging iPad apps on Mac.
(37507479)
• The view debugger inspector shows contentTintColor for
NSImageView and NSButton. (49506123)
• The view debugger now shows the names of iOS named
and system colors. (45162028)
• The view debugger shows trait collection information.
(45161975)
• The view debugger shows the names of UIImage
instances. (45327089)
• The view debugger now shows symbol information, like
baseline and midline. (49508874)
• The debug bar appearance switcher supports changing
between dark and light modes on iOS. (45161907)
• The “Pause on issues” checkboxes in the Diagnostics tab
of the Scheme Editor are replaced by regular breakpoints.
You can use the Breakpoints Navigator to create a
Runtime Issue Breakpoint. (31409112)
• Override system settings like appearance, dynamic type,
and accessibility options for the debugged process
using Environment overrides, accessible from the debug
bar. (45848655)
• The debugger supports working with crash logs (.crash
files). (48408310)
• The debugger can debug tvOS Top Shelf extensions.
(48869701)
• Xcode can prefer using Wi-Fi to connect to a Watch when
installing or debugging an app. (50313856)
• The VoiceOver actions menu for breakpoints includes an
action to jump to the corresponding line of code.
(44941178)
• When debugging views with constraints, double clicking a
constraint in the size inspector selects that constraint in the
editor and show information for the constraint in the
inspector. (18842905)
Known Issues
• Debugging symbols might be unavailable for Apple Watch.
(26995636)

Workaround: Verify that you have a working internet
connection and that you’re signed into your Apple ID in
Preferences > Accounts.
• A preview debug session ends if the preview is no longer
visible, including when stepping or view debugging.
(50593619)

Workaround: Ensure that the preview remains open by
opening files in split mode or separate tabs. For example,
 hold down Option while clicking the Step Into or Debug
View Hierarchy buttons to open them in separate editor
splits.
• You can’t debug on-device previews. (51183159)

Workaround: Debug live previews on the canvas or debug
the app on the device by directly deploying it there.
• If the process is already started, adding a runtime issue
breakpoint has no effect. (49433870)

Workaround: Add the runtime issue breakpoint before
running the process.
• On macOS 10.15, dragging the process item in the Debug
Navigator might crash Xcode. (48453949)
• Debugging a watch app in a watchOS simulator might fail
the first time the simulator boots. (50263836)

Workaround: Wait until the watch simulator finishes
booting, then start debugging it again.
• App and thermal state tracks in the Energy Impact gauge
might stop updating. (50968828)

Workaround: Stop and rerun the app.


Resolved Issues
• Items in the view debugger can be revealed in the Debug
navigator from the context menu. (18598643)
• Improved the formatting of Swift class names when
debugging the view hierarchy. (39679411)
• Fixed an issue where the debug console would display a
page column guide. (49693398)
• Breakpoints support the VoiceOver command to open the
shortcut menu. (44940944)


Deprecations
• Scripting language runtimes such as Python, Ruby, and
Perl are included in macOS for compatibility with legacy
 software. In future versions of macOS, scripting language
runtimes won’t be available by default, and may require
you to install an additional package. If your software
depends on scripting languages, it’s recommended that
you bundle the runtime within the app. (49764202)
• Use of Python 2.7 isn’t recommended. This version is
included in macOS for compatibility with legacy software.
Future versions of macOS won’t include Python 2.7.
Instead, it’s recommended that you run python3 in
Terminal. (51097165)
• The Quartz Composer framework is deprecated. Starting in
macOS 10.15, the Quartz Composer framework will be
marked as deprecated and remain present for compatibility
purposes. Transition to frameworks such as Core Image,
SceneKit, or Metal if your app is using Quartz Composer.
(50911608)
• Command line tool support for Subversion — including
svn, git-svn, and related commands — is no longer
provided by Xcode. If you need Subversion or related
command line tools, install the Command Line Tools
package by running xcode-select --install. (50266910)

Devices
Known Issues
• Building and running a watchOS app on a device might
show a system spinner indefinitely. (51726238)

Workaround: Reboot the device.

Resolved Issues
• Resolved an issue that prevented running a watch app
built with the thread sanitizer enabled on older versions of
watchOS. (49288795)
• Resolved an issue with half point frame differences caused
by switching between Retina and non-Retina monitors.
(20175879)

Instruments
New Features
• Tracks in Instruments can now be formed in hierarchies.
They can now represent any engineering type and are
created using Custom Instruments. (28615789)
• Instruments now allows for copying multiple rows from a
table at one time. (39326522)
• Instruments allows for creating scopes for easier
navigation within the trace document. (49022012)
• <os-signpost-point-schema> is available in the Custom
Instruments to match point events coming from
os_signpost(_:dso:log:name:signpostID:). (50586708)

Known Issues
• The selected track isn’t rendered in the Touch Bar area of
Instruments. (50186374)
• When profiling a standalone watchOS app, an iOS
simulator is launched. (49788679)

Interface Builder
New Features
• UIViewController instances now default to the Automatic
modal presentation mode. Modal presentation segues can
override this setting. (48129590)
• Interface Builder supports Dark Mode on iOS. (45314199)
• Interface Builder’s device bar lets you switch between the
light and dark appearance for iOS apps. (45282451)
• You can add SwiftUI hosting controllers, such as
UIHostingController, to connect a storyboard controller flow
to a hosting controller that manages a SwiftUI view
hierarchy. You can populate the contents of a hosting
controller in Interface Builder by providing a custom
subclass that programmatically sets the rootView of the
controller. (46039344)

You can also set the root view of a UIHostingController or
NSHostingController using a Segue Action.
• The object library now matches the selected system-wide
appearance. (50874168)
• The NSStackView inspector now allows configuring
negative spacing. (49012055)
• NSSwitch is available when running on macOS 10.15.
(47566686)
• Cells in a UITableView can now self size with Auto Layout
constrained views in the canvas. To opt into the behavior
for existing table views, enable “Automatic” for the table
view estimated item size, and “Automatic” for cell’s height
in the Size inspector. (35735970)
• NSView and UIView have a layout mode option in the Size
inspector to explicitly opt into “translates autoresizing mask
into constraints”. The default setting is “Automatic”, which
is the existing behavior. “Automatic” implies that “translate
autoresizing mask into constraints” is off when a view
affect by constraints in the storyboard or XIB, but on if
unconstrained. (37352354)
• Improved the reliability of Auto Layout constraint
generation with “Add Missing Constraints”. (43694622)
• The contents of a UIScrollView are scrollable within the
canvas, once its subviews are fully constrained with Auto
Layout constraints. (44727961)
• Cells in a UICollectionView can now self size with Auto
Layout constrained views in the canvas. To opt into the
behavior for existing collection views, enable “Automatic”
for the collection view’s estimated size, and “Automatic” for
 cell’s size from the Size inspector.

If deploying before iOS 13, you can activate self sizing
collection view cells by calling
performBatchUpdates(_:completion:) during
viewDidLoad(). (45617083)
• In inspector font popovers, the Family popup now renders
menu items as a preview of the applicable font.
(31484154)
• Update Frames can now be performed document-wide for
misplaced frames, without selecting a view. (22076710)
• Content and Frame Layout guides are supported for
UIScrollView and can be enabled in the Size inspector for
more control over your scrollable content. (29711618)
• Interface Builder supports the new Apple TV tab bar style.
(47598643)
• The new WKInterfaceTextField interface element is
available for watchOS. (45754186)
• The canvas supports customizing iPad app interfaces for
Mac. (37797710)
• SF Symbols are available in image inspector properties.
(47532055)
• The UIImageView inspector includes support for
configuring symbols. (47797500)
• A view controller method annotated with the new
@IBSegueAction attribute can be used to create a segue’s
destination view controller in code, using a custom
initializer with any required values. This makes it possible
to use view controllers with non-optional initialization
requirements in storyboards. Create a connection from a
segue to an @IBSegueAction method on its source view
controller. On new OS versions that support Segue
Actions, that method will be called and the value it returns
will be the destinationViewController of the segue object
passed to prepare(for:sender:). Multiple @IBSegueAction
methods may be defined on a single source view
controller, which can alleviate the need to check segue
 identifier strings in prepare(for:sender:). (47091566)

An IBSegueAction method takes up to three parameters: a
coder, the sender, and the segue’s identifier. The first
parameter is required, and the other parameters can be
omitted from your method’s signature if desired. The
NSCoder must be passed through to the destination view
controller’s initializer, to ensure it’s customized with values
configured in storyboard. The method returns a view
controller that matches the destination controller type
defined in the storyboard, or nil to cause a destination
controller to be initialized with the standard init(coder:)
method. If you know you don’t need to return nil, the return
type can be non-optional.

In Swift, add the @IBSegueAction attribute:

@IBSegueAction
• func makeDogController(coder: NSCoder, sender: Any?,
segueIdentifier: String?) -> ViewController? {
• PetController(
• coder: coder,
• petName: self.selectedPetName, type: .dog
• )
• }
• 







In Objective-C, add IBSegueAction in front of the return
type:

- (IBSegueAction ViewController *)makeDogController:(NSCoder
*)coder
• sender:(id)sender
• segueIdentifier:(NSString *)segueIdentifier
• {
• return [PetController initWithCoder:coder
• petName:self.selectedPetName
• type:@"dog"];
• }
• 








Known Issues
• Storyboards and XIB files created with Xcode 11 that
contain Quaternary System Fill Color, Secondary System
Fill Color, Tertiary System Fill Color, or System Fill Color
crash previous versions of Xcode when opened.
(51233884)
• When viewing an iPad storyboard with the Mac device
selected in the device bar, custom fonts added by the
project don’t render. (48528374)
• Xcode crashes when you open a XIB or storyboard file with
a custom view that is tagged as IBDesignable if that project
contains Swift packages. (50551974)
• UIKit menus configured in Interface Builder are available at
runtime on macOS, but not on iOS. (51077651)
• ARView objects in Apple TV storyboards crash Interface
Builder rendering. (50971800)
• The iOS status bar is not displayed in the Interface Builder
canvas. (48639919)
• View controller scenes that contain menu commands
created with Xcode 11 cause the app to crash when
running on iOS 12. (50871098)
• Storyboards and XIB files in iOS and tvOS template
projects created with Xcode 11 need to be saved with
Xcode 11 at least once before opening them in previous
versions of Xcode. (51230799)
• UILabel, UITextField, and UITextView instances with
alignment set to “center” or “right” in Interface Builder have
the wrong alignment when designing for or running on
macOS. (50062524)

Workaround: Reapply the desired alignment in
awakeFromNib().
• If a symbol has a light and dark mode representation, the
dark mode representation isn’t picked up in the storyboard.
(50354204)
• The light or dark interface style group in the Interface
Builder device bar doesn’t take effect when viewing a UIKit
storyboard for Mac. (50929581)
• Projects created with Xcode versions prior to Xcode 11
beta retain their default custom color when opened in
Xcode 11 beta. (50828300)

Resolved Issues
• Dragging out a new iOS Main Menu no longer causes a
crash if you drag across an existing menu in the canvas.
(51237295)
• Resolved a performance regression associated with
opening storyboards and .xib files. (51282755)
• The inspector for UIDatePicker now shows only the
properties applicable to the selected mode. (26726319)
• The preview editor’s menu for adding iOS devices now
matches the current canvas orientation. (48818470)
• Preview editor items now preserve the configured locale or
pseudo-locale. (48303753)
• UIDatePicker objects configured as Count Down in
Interface Builder now use the specified duration at runtime.
(23426425)
• The Embed In bar button is also visible in documents not
using Auto Layout. (46855203)
• Subclasses of NSControl now have unique icons in the
library and document outline. (24231920)

Library
Known Issues
• Some UI controls from the object library don’t switch to
dark mode. (49830961)

LLDB
New Features
• LLDB’s Python scripting is now based on Python 3. If you
are using Python extensions that aren’t compatible with
Python 3, they will break. To help with the transition, you
can run in Python 2 mode by setting a default:

defaults write com.apple.dt.lldb DefaultPythonVersion 2
• 







Python 2 support will be removed in the future. (47806994)
• Swift Decimal values have a data formatter in LLDB,
making them display in a readable way. (38983073)
• LLDB now supports examining Swift types that are
compiled with support for library evolution. (48018240)

Resolved Issues
• Redeclaring self in Swift code works properly with LLDB.
(39611934)
• The Swift REPL and LLDB’s python scripting work properly
when the python binary in PATH isn’t the system one.
(40961425)
• Multiple issues that prevented LLDB from accessing
variables while debugging XCTest tests are resolved.
(41471338)

Localization
New Features
• You can now localize assets in asset catalogs. Localization
is enabled in the attribute inspector. (12948139)
• The settings bundle is now included in Xcode Localization
Catalogs. (12495197)
• The manual page for genstrings has documents its
behavior in more detail. (19709369)
• The genstrings tool is enhanced and merged with the
extractLocStrings tool. The previous version is deprecated,
has been renamed to ogenstrings, and must now be
invoked with xcrun. Any scripts that invoked xcrun
extractLocStrings should be changed to use genstrings,
but a compatibility symbolic link is currently provided that
invokes genstrings. (19709395)
• The genstrings tool now takes an -encoding argument that
allows specification of the file encoding for input files.
(48224455)
• The updated version of genstrings has improved error
reporting, and may report errors in scenarios that were
previously silently accepted. As an example, genstrings
MyApp/* will fail if the MyApp directory contains a
subdirectory, because genstrings file arguments are
required to be source files. (48304658)
• The genstrings tool can now take any number of -s
arguments to specify additional macros similar to
NSLocalizedString or functions from which to extract
strings. For example, genstrings -s MyErrorSring -s
MyUIString myfile.swift treats both MyErrorString and
MyUIString as equivalent to NSLocalizedString.
(48734596)

Note

Using -s arguments doesn’t suppress support for
NSLocalizedString or CFCopyLocalizedString.


• The Export for Localization command and genstrings tool

now support multiline Swift and Objective-C strings, and
 have relaxed whitespace requirements when recognizing
arguments to NSLocalizedString. (50516442)
• The performance of the Export for Localization command
is substantially improved. (40548416)

Resolved Issues
• The Export for Localization command and genstrings tool
no longer crash on escaped, high Unicode code points
such as \U0001F603. (18898240)
• Importing a localized string that contains embedded
newlines now produces strings files with escaped \n
sequences. (44649979)
• XLIFF files produced by Xcode localization export now add
xml:space="preserve" to <trans-unit /> elements to ensure
that whitespace is preserved. (44928807)

Organizer
New Features
• The new Metrics organizer shows battery life and
performance analytics for your app to help you drive
optimizations.
• Metrics are reported for your app when distributed on the
App Store and after sufficient field use.
• The available metrics are battery drain, launch time, hang
rate, memory, and disk writes.
• You can filter data by device and usage characteristics.
(43028903)

Playgrounds
Known Issues
• SwiftUI live views and inline results in playgrounds aren’t
supported in Xcode 11 beta. (42226387)
• Playgrounds in a workspace can’t import targets from a
Swift package. (47668990)
• The top few lines of a playground might become stuck
under the top of the window. Closing and reopening the
playground restores scrolling. (47529397)
• When running on macOS 10.15, playgrounds might
encounter a delay in starting execution when in the
presence of a slow or unreliable internet connection.
(48995467)

Workaround: Turn off all network connections or move to
a more reliable connection to alleviate this delay.
• Quick looks and inline result previews of views in UIKit
may display as blank rectangles. (50787870)

Resolved Issues
• Playgrounds no longer crash if your code references a
view off of the main thread. (46579594)

Project Navigator
New Features
• Xcode can find assets in your workspace or project using
the Find navigator. The Asset catalog Editor also supports
find and replace, and you can rename assets using
Replace. (14279237)

Reality Composer
Known Issues
• The RealityKit ARView class isn’t found at runtime when
loading a storyboard if its module isn’t specified in Interface
 Builder. The following error message displays in the Xcode
console: “Unknown class ARView in Interface Builder
file.” (50840767)

Workaround: ARView is a Swift view class, and requires
both its class name (ARView) and module (RealityKit) to be
specified in the Interface Builder inspector.
• RealityKit’s ARView class is not found at runtime when
loading a storyboard if RealityKit isn’t otherwise used
within the Xcode project. The following error message
displays in the Xcode console: “Unknown class
_TtC10RealityKit6ARView in Interface Builder
file.” (50900969)

Workaround: This issue occurs if you import RealityKit
and define an @IBOutlet with a type of ARView, but don’t
otherwise use RealityKit symbols in your project. To ensure
that RealityKit is loaded at runtime with this configuration,
manually add RealityKit to your target’s Link Binary with
Libraries build phase.
• Code generated for each scene in a Reality Composer
project with multiple scenes that contain notification
triggers or notify actions may contain notification triggers
and notify actions from other scenes. Calling a notification
trigger or a notify action which isn’t part of the loaded
scene does nothing. (51008577)

Workaround: Check your Reality Composer project for
which notification triggers and notify actions are available
for a given scene prior to calling them.
• The .reality file generated automatically by Xcode from a
Reality Composer project only contains the first scene in
the project. (51048599)

Workaround: Export each scene from Reality Composer
as separate .reality files and include them in your app.
Alternatively, export all scenes from Reality Composer as a
single .reality File and use RealityKit’s load methods to
load a particular scene.
Resolved Issues
• RealityKit is available in iOS simulators. (48603396)

Server
Known Issues
• Swift packages sometimes don’t appear in the Xcode
Server bot configuration Repositories pane. (50058808)
• Xcode Server is unable to automatically sign apps that use
the iCloud, Application Groups, Apple Pay, or Wallet
capabilities. (44704694)

Workaround: Use manual signing to build these projects
with Xcode Server.
• When editing bots for a project that authenticates with
SSH, Xcode Server may disable some project-specific
settings. (51009722)

Workaround: Either replace repositories in the
Repositories tab when editing the bot or use HTTPS-based
authentication with your Xcode Server integrations.
• Xcode Server can cause a crash when a bot is created
from the context menu of any integration. (51082255)

Workaround: Create bots from the context menu of the
server or from the Product menu in Xcode.
• Xcode Server doesn’t currently support UIKit for Mac.
(50602873)
• Build issues occurring in a source file built by multiple
targets may be marked resolved and reintroduced on every
integration. (46523551)

Signing and Distribution

New Features
• Signing and capabilities settings are now combined within
a new Signing & Capabilities tab in the Project Editor. The
new tab enables using different app capabilities across
 multiple build configurations. The new capabilities library
makes it possible to search for available capabilities.
(35254597)
• Xcode 11 supports the new Apple Development and Apple
Distribution certificate types. These certificates support
building, running, and distributing apps on any Apple
platform. Preexisting iOS and macOS development and
distribution certificates continue to work, however, new
certificates you create in Xcode 11 use the new types.
Previous versions of Xcode don’t support these
certificates. (45527608)

Known Issues
• Xcode 11 throws an error when creating new signing
certificates for members of the iOS Developer University
Program. (50640287)

Workaround: Use an older version of Xcode to generate a
signing certificate.
• In-App purchase content bundles may fail to build in Xcode
11 with a code signing error. (50736776)

Workaround: Add CODE_SIGNING_ALLOWED=NO to
the In-App purchase content target’s build settings.
• Automatic signing may fail with the error “This request is
forbidden for security reasons” when creating a
development certificate. (50964225)

Workaround: You may have hit a certificate limit for your
account. View your Apple Developer account in Safari and
revoke any development certificates that you aren’t using,
then try again in Xcode.
• The archive action does not code sign command-line
executable products from Swift packages. (48717735)

Workaround: Manually sign archived executables using
the codesign tool before distributing them.
• Mac provisioning profiles that you have manually installed
using the bot editor’s Signing tab will be installed using the
wrong file extension, causing integrations to fail.
 (47636041)

Workaround: Sign into your bot user’s account and
rename the affected profiles in the ~/Library/MobileDevice/
Provisioning Profiles directory.

Resolved Issues
• Resolved an issue where Xcode incorrectly reported: “No
iTunes Connect access for the team” when uploading to
the App Store. (39292849)

Simulator
New Features
• Metal is available in iOS 13 and tvOS 13 simulators when
running on macOS 10.15. Metal code is executed on the
host Mac GPU, and is significantly faster than simulated
OpenGL code.

The APIs in SceneKit, CoreAnimation, and other system
frameworks abstract many differences between GPUs,
reducing the need for device-specific code. When running
on earlier versions of macOS or in an environment where
Metal is not available, simulators continue to use software
rendered OpenGL. If your Mac has multiple GPUs, use the
File menu in Simulator to select which GPU to use. If the
GPU in use becomes unavailable, any simulators using it
automatically shut down. (18430676)
• Xcode no longer creates every available iOS simulator
device by default. Instead a set of the most commonly
used devices are created. To create other devices — or
multiple instances of a device — open the Devices window,
select Simulators, click the + button, enter a name, and
select the relevant device type and OS version.
(49428617)
• CAMetalLayer is available in iOS 13 and tvOS 13
simulators. (45101325)
• iOS 13, watchOS 6, and tvOS 13 simulators now have a
dyld shared cache. This improves simulator launch times
and reduces the number of open file handles used by
simulator processes. If you report an issue you believe is
related to the shared cache, include a simctl diagnose and
the output of launching your program with
DYLD_PRINT_LIBRARIES=1. (13632739)
• simctl now accepts short aliases for runtime names. This
means you can create a new iPhone X simulator with a
command like simctl create 'iPhone X' iOS13. (41089607)
• For headless and continuous integration scenarios, you
can configure CoreSimulator to skip compositing
operations in the virtual frame buffer by setting defaults
write com.apple.CoreSimulator
FramebufferServerRendererPolicy to none. In this mode
simulators can’t be viewed and simctl io is unable to take
screenshots or record videos. (48264341)
• Bundles without a CFBundleVersion are invalid and can’t
be properly installed on devices or simulators.
CoreSimulator now checks and rejects such bundles
earlier in the process with a clearer error message.
(49892531)
• The Simulator dock icon now includes a menu to quickly
boot a simulator. (43067512)
• Simulator’s File menu now includes a GPU selection menu
to control which GPU is used by Metal support in
simulators and for compositing by Simulator’s virtual frame
buffer. If the Use External GPU When Available item is
checked, any simulators booted after an external GPU is
connected use the external GPU. If the external GPU is
disconnected, any simulators using it automatically shut
down. Changes to these settings only take effect when a
simulator is booted. Simulators already booted when this
 setting is changed continue using the previously selected
GPU until they’re restarted. (46134036)
• Game controller input is available in iOS simulators.
(50082777)

Known Issues
• Core Image shaders using Metal fail to run iOS 13
simulators with the error “Metal DAG compiler
disabled.” (51521248)
• When running on Apple Watch Series 3, apps built using
SwiftUI might behave as if they are running on Apple
Watch Series 4. (50678109)
• Simulator doesn’t deliver game controller events to
simulated devices when Simulator isn’t the foreground
application when running on macOS 10.15. (51759699)
• iOS simulators might not color match Metal content to the
display’s color space. (50625671)
• When running on macOS versions before 10.15 some
IOSurface instances are leaked by processes running in
Simulator. This shows up as high memory usage by
SimRenderServer even when no apps are running in
simulators. Simulators running on macOS 10.15 aren’t
affected. (50880827)

Workaround: Periodically shutdown any running
simulators to release these IOSurface instances and free
the memory.
• iCloud sync isn’t available in iOS simulators. (50924245)
• Simulator doesn’t display the checkmark for Touch ID >
Enrolled when it’s enrolled. (50553667)
• Automatic synchronization of pasteboards between host
and simulated devices does not work. (46686100)

Workaround: Use Simulator’s manual Get Pasteboard
and Send Pasteboard commands.
• Simulator doesn’t distribute the load if multiple GPUs in a
system match the chosen GPU policy. Only the first
matching GPU, as returned by MTLCopyAllDevices(), is
 used. (50608554)

Workaround: You may see higher performance by locating
the simulator window on the display directly connected to
the GPU the simulator is using, which avoids copying
across GPUs.

Note

As with any app that leverages the GPU, the performance
behavior for an externally connected display varies
depending on workload.




• Video recording of the iOS 13, tvOS 13, and watchOS 6

simulator through xcrun simctl io <UDID> recordVideo
returns an error instead of recording video. (50625716)
• iOS 13 simulators have a simulated display connected
even when TVOut is configured as “disconnected".
(50829453)
• Safari’s share to Simulator has no effect. (49331693,
49416352)
• watchOS simulators don’t honor a breakpoint on a cold
boot. (51148192)

Workaround: Completely boot the simulator before
launching the app you’re debugging.
• The Rotate Device Automatically option in Simulator has
no effect in iOS 13 simulators. (51147050)

Resolved Issues
• Game controllers work properly with iPad simulators.
(51034639)
• Resolved an issue that prevented simulator devices
running versions of iOS prior to iOS 13 from rendering the
display correctly. (50963987)
• IOSurface is now functional in iOS 13, watchOS 6, and
tvOS 13 simulators. (11051639)
• Apps in a simulator that plays audio no longer
automatically also open the microphone for input.
(32406954)
• The previously deprecated availability field in simctl list’s
JSON output is removed. Use the isAvailable Boolean field
to determine availability. (45142676)
• ATSC texture formats are supported by transparently
decompressing them on the CPU prior to uploading them
to the macOS GPU. (51347811)

Source Control
New Features
• You can now cherry-pick changes from one branch to
another. (18285039)
• When cloning a new repository, you can now select the
branch to check out from the list of available branches.
(41122122)
• Using the new source control file inspector, you can
browse the full history of a file for the current branch. The
log inspector is available for all file types, including
Interface Builder documents. (45109443)
• You can now stash changes and manage stashes from the
source control navigator. Additionally, Xcode offers to
automatically stash and restore changes for source control
operations like pulling from a repository. (8797804)
• Source control authors are now available on a per-editor
basis. (45108927)

Known Issues
• Viewing the changes for a revision of a file from the source
control log inspector may fail if that file has since been
renamed. (49673170)
• If an author isn’t configured in Preferences > Source
Control, pulling with rebase may fail. (48680076)
• Filtering packages in the Add Package assistant isn’t
supported for Bitbucket Cloud or Bitbucket Server hosted
accounts. (47290085)
• Filtering packages in the Add Package assistant isn’t
supported for GitLab or GitLab Self-Managed hosted
accounts. (47290125)
• Source control functionality is limited when a Swift package
is selected in the Project Navigator, and the content of the
Package.swift file is shown. (50696823)

Workaround: Select the Package.swift file directly before
using source control features.
• When using xcodebuild, resolving packages may fail to
verify SSH fingerprints unless that fingerprint is already in
the ~/.ssh/known_hosts file. (50686014)

Workaround: SSH into the host and verify the fingerprint
from the command line before using xcodebuild, or
manually add the host fingerprint to the ~/.ssh/
known_hosts file.

Resolved Issues
• Resolved issues where hosted account providers like
GitHub and BitBucket were unavailable in the add account
sheet, and previously added accounts would be disabled.
(47645098)
• Addresses an issue where source control operations in
Xcode presented a “Couldn’t communicate with helper
application” dialog. (47227781)
• Fixes a performance issue where Personal, organizational
and Starred repositories took a long time to load.
(48620126)
• Addresses an issue where user avatars from GitHub didn’t
always load after adding a GitHub account. (48698029)
• Fixes a bug where some source editor menu options were
unavailable in the Code Review Editor. (48774008)
Source Editor
New Features
• Semantic highlighting, code completion, live issues,
symbol search, and jump-to-definition are now supported
for the Metal shading language. (45144204)
• Introduces the ability to view inline code diffs for changes
in the Source Editor by clicking on the Source Control
Change Bar and choosing Show or Hide Change.
(49073551)
• Added new High Contrast (Dark) theme and High Contrast
(Light) theme. Also added new settings for Marks, Type
Declarations and Other Declarations. (50036007)
• Added dedicated syntax coloring for declarations in Swift
files, which can be customized in Preferences > Fonts &
Colors under Type Declarations and Other Declarations.

Declaration coloring for C-family languages isn’t supported.
(10342935)
• Xcode’s source editor now supports spell checking.
(32062963)
• Xcode 11’s source editor introduces a mini map of the file.
The mini map includes legible text for Mark:, highlighted
lines with errors and warnings, source control changes,
breakpoints, and highlighted Find results. The mini map is
enabled by default and can be turned off per editor.
(35939517)
• Added syntax highlighting for markup in documentation
comments and playground markup. You can customize the
prose font in Preferences > Fonts & Colors under
Documentation Markup, and customize delimiter
appearance in Preferences > Text Editing > Display.
(42941263)
• Toggle Comments supports multiple cursors. (44319433)
• When dragging and dropping text, space is opened up
between lines to make it easier to see where text will be
dropped. When dragging full lines, Xcode only allows
drops to occur between other lines. (44735912)
• The editor allows hierarchical code folding. (47502128)
• Code folding supports square brackets, and parentheses.
(50460404)
• // MARK: comments and #pragma mark directives now
draw a separator line in the editor. The preference for
showing mark separators is in Preferences > Text Editing >
Display > Show Mark Separators. (7299224)

Known Issues
• C++ operator overloads aren’t shown in the jump bar.
(50841460)
Resolved Issues
• NSProgressIndicator objects now preserve the current
value configured in the inspector when built and run.
(43257511)
• Resolved an issue where Xcode erroneously opened an
assistant editor when you ran Fix All Issues using a
keyboard shortcut. (37995114)
• Added dedicated syntax coloring for // MARK: comments
and #pragma mark directives, which you can customize in
Preferences > Fonts & Colors > Mark. (22114159)
• You can command-click on Swift operators to use Quick
Help and Jump to Definition. (32695862)
• Resolved an issue that could occur when editing an
unclosed block in Objective-C. (48201424)
• Resolved an issue where code completion sorted
deprecated symbols ahead of their nondeprecated
counterparts. (38422586)
• Resolved an issue where code completion rows appeared
empty when deleting text. (48621410)
• Resolved an issue where C++ functions weren’t parsed
correctly when using throw or noexcept clauses.
(37682611)
• Accessibility Zoom focus now follows the insertion point in
the source editor while typing. (32775118)
• VoiceOver doesn’t repeat the previous line when moving
by line in the source editor. (34334763)
• VoiceOver has rotors in the source editor for methods,
errors, warnings, breakpoints, and marks which makes it
easy to search for and move to the line of code
corresponding to an error or other rotor item. (34493080)
• VoiceOver text attributes now include the number of
spaces, number of tabs, indent level and line number for a
line of code in the source editor. (34607795)
• VoiceOver no longer speaks extra characters around
placeholder tokens when reading in the source editor, and
says that they are placeholders. (44941610)
• Resolved an issue where C++ raw strings didn’t highlight
correctly. (10770485)
• Resolved an issue of issues where C++ class declarations
didn’t parse correctly when using qualified names,
templates, or multiple inheritance. (11286215)
• Resolved an issue where local classes nested inside
functions or methods weren’t shown in the jump bar.
(13337638)
• Resolved an issue where C++11 trailing return types
weren’t properly recognized. (13634062)
• Resolved an issue where C++ typed enums were not
parsed correctly. (13693443)
• Improved the parsing of declarations that use availability
macros and attributes. (14569168)
• Resolved an issue where C++ numeric literals with single
quotes were not recognized. (18121031)
• Resolved an issue where struct member functions were
not parsed correctly. (27946356)
• Resolved an issue where enum declarations were not
displayed in the Jump Bar correctly. (32518576)
• Improved the recognition of classes and functions in
JavaScript. (42537831)
• Resolved an issue where functions returning enum types
were not parsed correctly. (46164630)
• Resolved an issue where unsigned and long integer literals
were not syntax colored correctly. (47138177)
• Updated JavaScript syntax highlighting to include
ECMAScript 6 keywords. (47354463)
• Fixed an issue where double clicking on a C++ destructor
name would also select the tilde (~). (6368356)


Static Analyzer
New Features
• The static analyzer checks for violations of the MIG calling
convention in mach server routines. These violations can
lead to use-after-free vulnerabilities. (35380337)
• The static analyzer checks for violations of IOKit and
libkern reference counting rules with respect to out-
parameters. (46357478)
• The static analyzer checks for violations of DriverKit
reference counting rules. These violations can lead to
leaks and use-after-free issues. (50349513)

Swift
New Features
• The memberwise initializer for structures now provides
default values for variables that hold default expressions.
(SE-0242, 47130624)

struct Dog {
• var name = "Generic dog name"
• var age = 0
•
• // The synthesized memberwise initializer
• init(name: String = "Generic dog name", age: Int = 0)
• }
•
• let sparky = Dog(name: "Sparky") // Dog(name: "Sparky", age: 0)
• 








• An @autoclosure parameter can now be declared using a

type alias. (SR-2688, 50560849)

class Foo {
• typealias FooClosure = () -> String
• func fooFunction(closure: @autoclosure FooClosure) {}
• }
• 








• Methods declared using the @objc attribute inside a class

can now return Self. (SR-7601, 50560991)

class MyClass: NSObject {
• @objc func clone() -> Self { return self }
• }
• 






• Key path expressions can now include references to tuple

elements. (50562288)
• Single-parameter functions that accept values of type Any
are no longer preferred over other functions. (50562333)
• Conversions between tuple types are now fully
implemented. Previously, the following would diagnose an
error. (SR-2672, 12340004)

let values: (Int, Int) = (10, 15)
• let converted: (Int?, Any) = values
• 








• You can now declare and use type subscripts, just like type
properties and type methods. Declare one by applying the
static or, in classes, class modifier to the subscript
declaration. (SE-0254, 16555559)

// Declare a type with a static subscript:
• enum ProcessEnvironment {
• static subscript(name: String) -> String? {
• get { getenv(name) }
• set { setenv(name, to: newValue) }
• }
• }
•
• // Use it with any of these syntaxes:
• ProcessEnvironment["PATH"]! += ":/usr/local/bin"
• ProcessEnvironment["PATH"]! += ":/usr/local/bin"
• someVarOfProcessEnvironmentDotType["PATH"]! += ":/usr/local/
bin"
• 







Type subscripts can also be used with dynamic member
lookup to create dynamic type properties.

// Declare a type with a static subscript:
• @dynamicMemberLookup
• enum ProcessEnvironment {
• // …As above…
• static subscript(dynamicMember name: String) -> String? {
• get { self[name] }
• set { self[name] = newValue }
• }
• }
•
• // Now you can use property syntax with ProcessEnvironment:
• ProcessEnvironment.PATH! += ":/usr/local/bin"
• ProcessEnvironment.self.PATH! += ":/usr/local/bin"
• someVarOfProcessEnvironmentDotType.PATH! += ":/usr/local/bin"
• 








• Assigning Optional.none to an enumeration that also has a

none case, or comparing such an enumeration with
Optional.none now produces a warning. Such expressions
create an ambiguity because the compiler chooses
Optional.none over the none case defined by your own
enumeration. (SR-2176, 26126801)

enum Foo { case none }
•
• // Assigned Optional.none instead of Foo.none.
• let foo: Foo? = .none
• // Comparing with Optional.none instead of Foo.none.
• let isEqual = foo == .none
• 







The compiler provides a warning along with a fix-it to
replace .none with Optional.none or Foo.none to resolve
the ambiguity.
• Functions can now hide their concrete return type by
declaring what protocols it conforms to, instead of
specifying the exact return type:

func makeACollection() -> some Collection {
• return [1, 2, 3]
• }
• 







Code that calls the function can use the interface of the
protocol, but doesn’t have visibility into the underlying type.
(SE-0244, 40538331)
• Enum cases can now be matched against an optional
enum without requiring a ‘?’ at the end of the pattern.
(SR-7799, 41494702)

enum Foo { case zero, one }
•
• let foo: Foo? = .zero
•
• switch foo {
• case .zero: break
• case .one: break
• case .none: break
• }
• 








• The existing @dynamicMemberLookup attribute now

supports typed key path implementations. (SE-0252,
49069813)

struct Point {
• var x, y: Int
• }
•
• @dynamicMemberLookup
• struct Box<T> {
• var v: T
•
• init(_ v: T) {
• self.v = v
• }
•
• subscript<U>(dynamicMember member: KeyPath<T, U>) -> U {
• get { return v[keyPath: member] }
• }
• }
•
• var box = Box(Point(x: 0, y: 0))
• _ = box.x
• 








• You can now use the Self expression to refer to the

innermost nominal type inside structure, enumeration and
class declarations. For example, the two method
declarations inside this structure are equivalent:

struct Box<Value> {
• func transform1() -> Self { return self }
• func transform2() -> Box<Value> { return self }
• }
• 







In classes, Self is the dynamic type of the self value, as
before. Existing restrictions on Self in declaration types still
apply; that is, Self can only appear as the return type of a
method. However, Self can now be used inside the body of
a method without limitation. (SE-0068, 17892696)
• Array and ContiguousArray now have the
init(unsafeUninitializedCapacity:initializingWith:) initializer,
which provides access to the array’s uninitialized storage.
(21880692)
• More thorough checking has been implemented for
restrictions around escaping closures capturing in-out
 parameters or values of noescape type. While most code
isn’t affected, there are edge cases where the Swift 5.0
compiler accepted code that violated these restrictions.
(SR-8546, SR-9043, 43355341)

An example of invalid code which was incorrectly accepted
by the Swift 5.0 compiler is an @escaping closure that
calls a local function that references an in-out parameter
from an outer scope:

struct BadCaptureExample {
• var escapingClosure: () -> ()
•
• mutating func takesInOut(_ x: inout Int) {
• func localFunction() {
• x += 1
• }
•
• escapingClosure = { localFunction() }
• }
• }
• 







The compiler now correctly diagnoses the above code by
pointing out that the capture of x by localFunction() is
invalid, since localFunction() is referenced from an
@escaping closure.

This also addresses certain cases where the compiler
incorrectly diagnosed certain code as invalid, when in fact
no violation of restrictions had taken place. For example:

func takesNoEscape(_ fn: () -> ()) {
• func localFunction() {
• fn()
• }
•
• { localFunction() }()
• }
• 










Known Issues
• APIs deprecated before macOS 10.9 show up as
available-but-deprecated rather than unavailable when
compiling with the Require Only App-Extension-Safe API
build setting, including an old version of read(from:ofType:)
that doesn’t support throwing. (51417764)
• The @frozen attribute for structures and enumerations is
unavailable. (36597490)
• The Swift REPL might not launch from Terminal.
(51374106)
• Declarations with some Protocol return types require the
Swift 5.1 runtime in iOS 13, macOS 10.15, watchOS 6, or
tvOS 13, but the Swift compiler doesn’t enforce this.
Running an app that uses some return types on previous
operating system versions might crash at runtime, either
because of missing swift_getOpaqueTypeMetadata
symbols, or because of a failure to demangle a string that
contains the substring “Qo_”. (50731151)

Workaround: Only deploy binaries that use some return
types to iOS 13, macOS 10.15, watchOS 6, and tvOS 13.
Avoid them in code that must run on previous operating
system versions.
• If a type has the same name as its containing module,
importing that module from a module interface might fail.
(48445154)

Workaround: Rename the type so it no longer conflicts
with the module name.
• If a type uses a some Protocol return type to satisfy an
associated type requirement of a protocol, and that
 associated type is referred to by name inside another
generic declaration, the compiler might crash. (50509030)

protocol HasAssocType {
• associatedtype Assoc
•
• func assoc() -> Assoc
• }
•
• struct GenericWithOpaqueAssoc<T>: HasAssocType {
• func assoc() -> some Any { return 0 }
• }
•
• struct OtherGeneric<X, Y, Z> {
• var x: GenericWithOpaqueAssoc<X>.Assoc
• var y: GenericWithOpaqueAssoc<Y>.Assoc
• var z: GenericWithOpaqueAssoc<Z>.Assoc
• }
• 







Workaround: Explicitly specify the concrete return type in
the declaration that provides the associated type.

Resolved Issues
• Static libraries are now always force-loaded in their entirety
during linking, fixing runtime errors related to demangling
failures. (47598583)
• weak and unowned stored properties no longer inhibit the
automatic synthesis of Equatable or Hashable
conformance. (SR-9827, 50566123)
• If symbols in a crash log aren’t properly demangled, run
the swift-demangle command and pass in the content of
the crash log. (34920390)

SwiftUI
Known Issues
• Instances of PreviewProvider for views with body
properties that contain a ForEach view at the top level
result in multiple previews. (50711038)
• Pinching to zoom is unavailable in live previews.
(51183125)

Workaround: Exit live mode or use the zoom controls in
the canvas or editor menu.
• Named colors aren’t editable in the Attributes Inspector.
(51287606)

Workaround: Use the source editor when working with
named colors.
• Selecting then reselecting a named color in the Color
inspector might crash Xcode. (51304163)
• Static previews for iOS, tvOS, and watchOS don’t support
SceneKit, MapKit, and Metal views, and experience a
delay when rendering updates. (50965310)
• Drag and drop operations that result in insertions of
containers around an existing view and a new sibling in the
container don’t work if the existing view is at the top level
of a conditional statement in a view builder. For example,
you can’t drop an HStack or VStack around the Text.
(50300406):

var body: some View {
• VStack {
• if true {
• Text("Hello World")
• }
• }
• }
• 









 Workaround: Embed the existing view into a container —
either in the canvas or the source editor — then drop the
new view into that container.
• Static watchOS previews show black text on a black
background. (51676439)

Workaround: Apply the colorScheme(.dark) modifier to the
previews.
• Previews in packages always perform a full build of the
active scheme. (51030302)
• Dragging a Text modifier onto text in the canvas that
already has a View modifier such as
frame(width:height:alignment:) results in a compilation
error. (50712235)

Workaround: Reorder the modifiers so that modifiers
specific to Text appear before any View modifiers.
• Using withAnimation(_:_:) to change state in a root view
isn’t reflected in live previews. (51164838)
• HStack and VStack inspectors don’t support custom layout
guides. (49710501)

Workaround: Use the source editor for custom layout
guides.
• The attribute inspector doesn’t allow specifying flexible
frames. (51310989)
• Entering live preview mode in the canvas might take
several seconds the first time. (46505269)
• PreviewProvider instances defined in projects that don’t
have -DDEBUG set for OTHER_SWIFT_FLAGS that are
also wrapped in #if DEBUG conditionals don’t display in
the canvas. (51138834)

Workaround: Remove the conditional compilation block
from around the PreviewProvider declaration.
• Animations may escape out of their context in live
previews. This may cause live previews to not match on-
device previews. (50708417)
• Opening the same file in a new window then closing that
window causes previews in the first window to display an
 error. (47619828)

Workaround: Choose Try Again in the first window when
the error appears.
• Previews may fail or update incorrectly when switching
between files. (50841287)

Workaround: Add a newline to the end of the active file,
then click Resume in the banner that appears.
• The attributes inspector stays visible after the canvas
closes, gets stuck on the last selected item, and doesn’t
function. (50958316)

Workaround: Reopen the canvas or switch to a different
file.
• watchOS previews might fail if you select a physical phone
that’s paired with a watch as the run destination from the
Scheme pop-up menu. (50861269)

Workaround: Select a watchOS simulator while working
with previews.
• Previews don’t work for macOS apps with App Sandbox
enabled. (51088926)
• Previews don’t appear in the canvas for private and
fileprivate structures that conform to PreviewProvider.
(47011316)

Workaround: Remove the private or fileprivate access
control from your conforming type.
• Previews might take several seconds to update when
switching devices in the run destination selector the first
time. (47562171)
• Previews might temporarily show the incorrect device
chrome when switching devices using the run destination
from the Scheme pop-up menu. (49496647)
• The canvas doesn’t support focus. (50275735)
• Undo is unavailable in the canvas. (49651153)

Workaround: Bring the source editor into focus and
perform the undo there.
• The insertion indicator only shows on the topmost item for
repeated content such as content in a List or ForEach
view. (50244112)

SwiftUI Tutorials
Known Issues
• After following Section 7, Step 7 in the Building Lists and
Navigation tutorial in Xcode, you might encounter an error
in your project’s SceneDelegate.swift file. (51334559)

Workaround: Update line 14 of SceneDelegate.swift to
use LandmarkList instead of LandmarkDetail:

window.rootViewController = UIHostingController(rootView:
LandmarkList())
• 








• After following Section 5, Step 3 in the Handling User Input

tutorial in Xcode, you might encounter an error in the
preview provider. (51341785)

Workaround: Undo the change to the LandmarkDetail
initializer, so that you only add the environmentObject(_:)
modifier:

struct LandmarkDetail_Preview: PreviewProvider {
• static var previews: some View {
• LandmarkDetail(landmark: landmarkData[0])
• .environmentObject(UserData())
• }
• }
• 







Swift Packages
Known Issues
• Previews aren’t supported for standalone packages.
(51072409)
• Swift packages don’t support adding resource files — such
as images, storyboards, or audio — in a target. (SR-2866,
33389529)
• Searching for package repositories in the Add Package
Dependency sheet might not complete when there are no
search results. (51223367)

Workaround: Cancel the search, enter the repository URL
in the text field, then select Next.
• Code completion doesn’t work for Swift package targets if
the name of the target declared in the Package.swift
manifest file differs in casing with the directory name for
that target. (49648458)

Workaround: Use path property to provide the exact
casing of target’s name as on disk or update target name
in the manifest to match the directory name on disk.
• Adding a new file in a C-family target of a Swift package
creates the file with the .swift extension. (31395814)

Workaround: Rename the new file with the desired
extension.
• Swift packages don’t support adding resource files — for
example, images, storyboards, or audio — in a target.
(SR-2866)
• Swift packages don’t support processing localized strings
files. (48190792)
• Moving a local package in a project will convert it into a
folder reference. (50320585)
• A package product that is linked into both app and its test
target results in duplicated symbols. (50348625)

 Workaround: Link a package product only in the app or
test target.
• Swift packages that use unsafeFlags build settings aren’t
supported. (50354068)
• The scheme that’s autogenerated for a Swift package isn’t
automatically updated when the package adds or removes
targets. (50586754)

Workaround: Delete the scheme from the swiftpm/xcode/
xcshareddata/xcschemes directory inside the package
directory, then reopen the package to automatically
generate a new scheme.
• Targets of a Swift package build with debug-conditional
settings if the build configuration selected in the scheme is
not named Debug or Release. (50696202)
• Removing a local package reference from a workspace
removes its package products from all Xcode targets in the
workspace, even when other references to that local
package remain in the workspace. (50706448)

Workaround: Add package product references back to the
relevant targets.
• Previewing code in Swift packages which are not
referenced by the active scheme and not being linked into
an app target is not supported and shows an incorrect
error message. (50909384)
• Test targets of newly-created Swift packages fail to build
for watchOS because XCTest is unavailable on watchOS.
(51054894)

Workaround: Surround any code in watchOS test targets
which references the XCTest framework or its APIs with
conditional compilation statements. For example:

#if !os(watchOS)
• // XCTest code
• #endif
• 





 


• Xcode crashes if a local package overrides a remote

package in a project and the local package has an
unsatisfiable package dependency. (51183216)

Workaround: Open the local package separately in Xcode
and ensure that its package dependencies are resolvable.

Testing
New Features
• Support for writing XCTest-based tests for apps that adopt
SwiftUI. (35224680)
• Test Plans are a new way to manage which tests run, and
how those tests run. Schemes can reference multiple test
plans, and define a default test plan for automation. A new
Test Plan editor supports defining test configurations,
which can inherit shared settings from the plan itself.
Running tests in Xcode now runs tests across all test
configurations. The Source Editor test diamonds are
updated to support running a test in a single configuration,
and the Test Navigator is updated to allow choosing the
active test plan. Test reports are updated to support
displaying results generated by a test plan. (16138582)
• XCTest includes augmented performance testing
capabilities with the new measure(metrics:options:block:)
method and related methods. The metrics argument
requires a list of objects conforming to the XCTMetric
protocol. You can either implement your own custom
metrics or use XCTClockMetric, XCTOSSignpostMetric,
XCTCPUMetric, XCTMemoryMetric, or XCTStorageMetric.
(49430032)

The following shows an example performance test that
measures the CPU and Memory impact of sorting a list:

func testExample() {
• // Measures the CPU and memory impact of sorting the input list.
• measure(metrics: [XCTCPUMetric(), XCTMemoryMetric()]) {
• sortedList = qsort(list: self.fiftyNumbersFrom0to100)
• }
• }
• 








• Added an assertion function, XCTUnwrap, for use in Swift

tests. XCTUnwrap asserts that an Optional variable’s value
is not nil, returning its value if the assertion succeeds. This
removes the need to combine
XCTAssertNotNil(_:_:file:line:) with either unwrapping the
value or dealing with conditional chaining for the rest of the
test. For example:

func testFirstNameNotEmpty() throws {
• let forenames: [String] = customer.forenames
•
• let firstName = try XCTUnwrap(forenames.first)
• XCTAssertFalse(firstName.isEmpty)
• }
• 







XCTUnwrap is a throwing assertion, and is best used in a
throwing test method as in the above example. (30667432)
• xccov now supports being passed result bundles directly, in
addition to raw report and archive files. For example, to
view the coverage report within a result bundle, invoke
xccov as follows: xccov view --report /path/to/
result_bundle.xcresult. (50500789)
• The format of result bundles changed in Xcode 11. A result
bundle is an asset produced by Xcode 11 with the xcresult
file extension that contains information about the build,
 tests, code coverage, and more. Any xcresult files
produced with Xcode 10 or earlier cannot be read by
Xcode 11. A result bundle can be produced by passing -
resultBundlePath ./Example.xcresult to an xcodebuild
invocation and the Example.xcresult can then be opened in
Xcode. Xcode also creates result bundles in Derived Data.
The current result bundle version number is 3, which can
be specified by passing the xcodebuild flag -
resultBundleVersion 3. Version 3 is the default in Xcode 11,
but it is still recommended for automation to explicitly pass
the flag, so that any potential future versions that become
the default do not cause issues to existing tools. Result
bundles can be inspected using xcresulttool. A JSON
representation of the root object of the result bundle can be
exported using xcrun xcresulttool get --format json --path ./
Example.xcresult and any nested object, identified by its
reference found in the JSON output, can be exported by
adding the flag --id REF. xcresulttool also provides the
description of its format using xcrun xcresulttool
formatDescription. (41633595)
• If a test runs on multiple destinations and fails on some but
not others, the test report displays a summary describing
the destinations on which the test failed, e.g. “Failed on
iPad destinations running iOS 12.0”. (49164968)
• When running a test or test class via a source editor test
diamond, option-clicking the diamond presents a popover
that allows the test to be run under a specific configuration
in the active test plan (if the test plan has multiple
configurations). (46348663)
• When viewing a test report for tests that ran on multiple
destinations (such as an Xcode Server integration, or a
result bundle generated by an xcodebuild invocation with
multiple destination specifiers), it’s now possible to filter the
displayed results by destination. Clicking on the devices
button in the scope bar will present a list of the destinations
on which the tests ran, including the ability to hide or show
 only the destinations of interest. In addition, it’s now
possible to filter to only those tests that failed on one
destination but succeeded on another, via the “Mixed”
button in the scope bar. (48981032)
• Result bundles produced by xcodebuild can now be
shared, double-clicked, and opened in Xcode directly.
(38620469)
• Introduces support for writing XCTest-based tests for
applications that adopt UIKit For Mac. (41530313)
• Code Coverage is now enabled by default for newly
created test plans. (48749597)
• In UI testing on macOS, mouse moves, including calls to
the hover API as well as calls to click, scroll, and other
APIs will move the cursor progressively across the screen,
just as a user would in real interactions, rather than
instantly moving the cursor to the final location. This may
cause problems for tests involving UI that is heavily
dependent on mouseover behavior. (49430331)
• The .xctestrun file format is modified for Test Plans to
include information about how to perform each test
configuration in the plan. When running xcodebuild build-
for-testing for a scheme that uses test plans, the generated
.xctestrun files use FormatVersion 2 and have a revised
property list structure. .xctestrun files generated for
schemes which don’t use test plans continue to use
FormatVersion 1, and xcodebuild test-without-building
accepts either version. (46346053)
• The Code Coverage setting in the test plan editor doesn’t
support selecting individual targets to gather code
coverage for. If the test plan was created by converting a
scheme to use test plans, and that scheme had individual
code coverage targets selected at the time of conversion,
those targets are preserved in the resulting test plan but
aren’t editable within the plan. (50502861)
• xcodebuild is enhanced with new options supporting Test
Plans. Use the new -showTestPlans option to list all test
 plans associated with a scheme. Use the new -testPlan
<name> option to specify which test plans associated with
a scheme to use for testing or building tests. If -testPlan
<name> is not specified, xcodebuild test will use the
scheme’s default test plan. (46346197)
• Xcode 11 introduces the option to automatically include
screenshots from XCTest in Xcode Localization Catalogs.
Enable Localization Screenshots in your test plan or in the
scheme editor, then check “include screenshots” when
exporting for localization. (28656175)
Known Issues
• The Execute in Parallel checkbox in the test action of a
scheme is disabled for test targets of a Swift package.
(47564543)
• The test plan editor allows enabling certain combinations
of sanitizers and memory diagnostics which are
incompatible and should not be simultaneously enabled.
For example, Address Sanitizer and Guard Malloc, or
Address Sanitizer and Thread Sanitizer. (49739613)

Workaround: Don’t configure a test plan with a
combination of sanitizers and memory diagnostic settings
which are incompatible. If an incompatible setting is
inherited in a test configuration by the test plan’s Shared
Settings, manually override the setting to disable it for the
affected test configuration.
• Editing a test plan which references test targets in a
different project than the project which contains the active
scheme will cause those test targets to be labeled
“Missing”. (50148373)

Workaround: Switch the active scheme to a scheme
contained by the same project where that plan’s test
targets are defined.
• In a workspace that contains Swift packages, attempting to
run tests while the packages are being resolved can cause
Xcode to be unable to run tests until the workspace is
reopened. (48719922)

 Workaround: Wait until all packages are downloaded and
resolved before running tests.
• The new XCTUnwrap API is not available when building
Swift package tests using the Swift Package Manager.
(51115369)
• In UI tests for UIKit apps on macOS, attempts to interact
with elements inside of a table view cell may fail with an
error about hit testing. (50745246)

Workaround: Perform the interaction on an
XCUICoordinate instance that represents the midpoint of
the element. For example:

app.cells.staticTexts["My Cell Content"]
• .coordinate(
• withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5)
• )
• .tap()
• 








• Running tests with code coverage enabled fails to produce

a coverage report for iOS apps in the simulator or on a
Mac. (51091751)
Resolved Issues
• Resolved a crash that could occur while checking for
device availability when starting a testing operation.
(51245770)
• Resolved an issue that prevented code coverage reports
from being generated for iOS apps that are run in
Simulator or on a Mac. (51241460)
• The exists property on XCUIElement now produces test
failures in situations where XCTest is unable to inspect the
application’s UI — for example, due to the app’s main
thread being unresponsive — instead of returning false in
those situations. (37359653)
• The unit test discovery mechanism is more efficient for
large projects. The test navigator gets populated faster
after reopening a project. (32567980)

UIKit for Mac

Known Issues
• On-Demand Resources (ODR) aren’t supported on
macOS, so when you build an iOS target that uses ODR
for the Mac, you’ll need to make some changes. Xcode
automatically disables ODR so that those resources are
built into the bundle of the target building them, rather than
in separate asset bundles. Update your code to load those
resources from the app bundle rather than from asset
bundles. (50358184)
• The color asset variant for UIKit for Mac isn’t passed at
runtime. (51113192)
• The NSDataAsset asset variation for UIKit for Mac returns
nil at runtime. (50022757)