Updated Git to version 2.15.2 to address CVE-2018-11233 and CVE-2018-11235. (40631597)

Asset catalogs with ARKit assets can compile if the deployment version is less than 11.3. (39218934)

Resolved an issue that could cause a crash when dragging a .gif image into a Sticker Pack in an Asset Catalog. (38820366)

Resolved an issue that could cause progress to get stuck while editing AR assets in an Asset Catalog. (38393995)

Xcode 9.4 adds support for developing apps with ClassKit.

Adding a fetch request to a Core Data model containing a UUID or URI attribute will not crash Xcode. (39470899)

Fixed navigation of items with extensions in the Find navigator. (39601956)

Resolved an issue where loading a saved trace could result in an empty Symbols panel. (38813311)

Fixed an issue where exporting an app using Ad Hoc distribution would fail with an error about missing the beta-reports-active entitlement. (39462609)

In some situations, the compiler may crash during code generation for generic enumerations with multiple payloads inside generic functions where there are redundant protocol requirements or same-type constraints. In the crash log backtrace, this will show up as a crash inside MultiPayloadEnumImplStrategy::emitIndirectInitialize. (39040680)

Workaround: Make the affected enumeration an indirect enumeration.

Defining a private class nested inside an extension constrained with same-type constraints may lead to a runtime crash when the class is initialized. (39208961)

For example:

extension Optional where Wrapped == NSData {

    private class Foo {}

}

let x = Optional<NSData>.Foo()

Workaround: Move the class definition out of nested position, and nest a type alias to the class instead:

private class _Optional_NSData_Foo {}

extension Optional where Wrapped == NSData {

  typealias Foo = _Optional_NSData_Foo

}

let x = Optional<NSData>.Foo()

Fixed an issue causing the user to have to log in with their Apple ID repeatedly. (39573406)

Addressed an issue that would cause Xcode to hang when using Playgrounds. (37822125)

The new Energy organizer shows logs generated when your app or app extension exceeds a reasonable CPU threshold in the foreground or background causing battery drain on your user's device. (28640769)

The Energy organizer features include:

• Energy logs are reported for your app when distributed on TestFlight or the App Store.

• Server-side symbolication when uploading symbol information to Apple.

• Automatic client-side symbolication when symbol information is saved locally.

• CPU sample reports that are generated when your process is terminated for high CPU usage while the app is in the background.

• Grouping logs with similar backtraces in energy reports.

• Viewing the heaviest backtrace of CPU sample logs in the Debug navigator.

• Compressing log stack frames by non-user stack frames and low sample count stack frames.

Code coverage can now select the targets to include in a code coverage report. (27752500)

To configure the targets to include:

1. Open the Scheme editor.

2. Select the Test action.

3. Show the Options pane.

4. In the pane, enable Code Coverage.

5. In the pop-up menu, choose "some targets."

6. Select the targets for the code coverage report.

Text in the Code Snippets library filter bar now includes code completion shortcuts. (8147546)

User-defined code snippets now appear at the top of the library, rather than the bottom. (8901028)

Users may have to log in with their Apple ID repeatedly. (39347493)

Workaround: Set this user default in Terminal:

defaults write com.apple.dt.Xcode DVTDeveloperAccountUseKeychainService -bool NO

Then quit and relaunch Xcode. You may need to authenticate your Apple ID once more.

Xcode 9.3 adds a new IDEWorkspaceChecks.plist file to a workspace's shared data, to store the state of necessary workspace checks. Committing this file to source control will prevent unnecessary rerunning of those checks for each user opening the workspace. (37293167)

Resolved a performance issue when switching away from Issue Navigator into other Navigators, especially the Find Navigator. (35363603)

The source editor find and replace control now supports Full Keyboard Access. (33666790)

A class and instance method with the same selector on an Objective-C protocol are both callable on a class that implements that protocol. (34596043)

Dragging an image from Finder to an empty sticker pack is rejected. Xcode crashes when dragging an image in the Project navigator to an empty Sticker pack. (38509180)

Workaround: Create a new sticker in the empty sticker pack, then drag the image from Finder or Project navigator into the new sticker well.

App Icon set in Asset Catalog in a new watchOS template app does not include the App store icon. (37480050)

Workaround: Select watchOS 1.0 and later in the Attributes Inspector, this will generate the App store icon, set it back to watchOS 2.0 and later if only watchOS 2.0 is supported.

Xcode now runs more Swift build tasks in parallel with other commands. This may improve build times for Swift projects, but may also increase memory use during the build. This feature can be disabled from Terminal by setting a user default with defaults write com.apple.dt.Xcode BuildSystemScheduleInherentlyParallelCommandsSerially -bool YES. (35551983)

Added an option to optimizing by size (-Osize) to the Optimization Level for the Swift compiler to the Build Settings pane of the Project editor. When this mode is selected the Swift compiler minimizes the size of compiled code. (36887476)

The choice for compiling Swift code by file or by module moved from the Optimization Level setting to Compilation Mode, which is a new setting for the Swift compiler in the Build Settings pane of the Project editor. Previously this choice was combined with others in the Optimization Level setting. Compiling by file enables building only the files that changed, enabling faster builds. Compiling by module enables better optimization. (36887476)

When an .xcconfig file contains multiple assignments of the same build setting, later assignments using $(inherited) will inherit from earlier assignments when using the new build system. The old build system discards all except the last assignment. This can cause the evaluated result to be different if $(inherited) is used in the value. You can enable a setting to emit a warning if any of these cases are found by running defaults write com.apple.dt.XCBuild EnableCompatibilityWarningsForXCBuildTransition YES. (37833468)

When the new build system is enabled, changing the Info.plist file doesn’t cause Xcode to re-sign your app. This may cause your app to crash on launch after an incremental build. (34016924)

Workaround: After changing the Info.plist file, make a change to your app’s source code to trigger recompilation and re-signing, or perform a clean rebuild.

The new build system now supports all of the Product > Perform Action > Compile, Analyze, Preprocess, or Assemble operations for single-files. (31072405)

Improved new build system rebuild times for configurations which have the "DWARF with dSYM File" build setting enabled by performing only the necessary work for dSYM generation during incremental rebuilds. (30668974)

Prevented Spotlight from indexing the module cache folder for builds, by renaming the folder to ModuleCache.noindex which results in an improvement in overall build performance. (35212165)

Fixed an issue in which the Clean Build Folder command could fail to complete. (36117298)

When using the new build system, navigating from a build issue to a header now correctly opens the header in the project source instead of the copy built into the product. (29060887)

Fixed a bug which would sometimes cause the -showBuildSettings option to xcodebuild to hang. (33881306)

Single file actions in the new build system use the active run destination. (23767795)

Fixed several issues which could cause Convert to Current Swift Syntax not to work when using the new build system. (36265451)

Fixed an issue in the new build system that incorrectly rebuilt files on the next build after a build error. (35319783)

"Build system information" errors from the new build system now appear in both the Issue Navigator and in the build logs. (34873210)

Fixed an issue in which using Build and Analyze with the new build system could cause Xcode to crash. (32920792)

Fixed a problem with code completion on a line containing emoji or non-ASCII characters. (24906321)

In the Core Data editor, property settings for NSFetchRequest are now included in the compiled data model. (13432055)

Memory graph debugging now uses a cleaner, more compact layout for non-cycle graphs. (36987034)

Added new Core Animation debug options for iOS and tvOS devices that were previously available only in the Core Animation Instrument. Choose Debug > View Debugging > Rendering to access the options. (27976406)

Enhanced the performance of the po command when printing Objective-C objects in the console. (34197161)

NSLayoutConstraints listed for a selected view when debugging an app’s view hierarchy now show their identifier in the inspector. (34736382)

The Connect via Network checkbox may become unchecked when first enabling network development for a device. (36797900)

Workaround: Check the checkbox again.

The Activity view no longer displays "Untitled" instead of the progress of a device operation, such as an app install. (35620763)

Xcode may fail to capture a screen shot from an attached device. (36632000)

Documentation for the HealthKit framework is missing from the Developer Documentation window. (39005708)

Workaround: Read the HealthKit framework documentation on the web.

The "Import Sampler Data..." menu item has been removed from Instruments. Open the sample text output by selecting through the normal "Open..." panel. (36866911)

The Cocoa Layout template has been removed. The instrument is still available in the Library palette. To use the Cocoa Layout instrument, open the Library palette, create a document using the Blank template, and drag in the Cocoa Layout instrument from the library to the new document. (21963317)

The "Energy Log" instrument doesn't work for iPhone X and iPhone 8. (36569629)

The SceneKit instrument shows a warning icon on the right of the target selection with messages “view settings could not be restored”. The SceneKit Instrument still works correctly and the warning can be safely ignored. (38081921)

Profiling iOS framework unit tests works only for the Release configuration. (26883826)

Workaround: Modify the scheme's Test option to use the Release build configuration.

1. Product -> Scheme -> Edit Scheme…

2. Select the Test tab.

3. Change the Build Configuration to be Release.

4. Attempt to profile the framework unit test again.

Using a color from an asset catalog in the large title text attributes of a UINavigationBar results in a runtime exception. (35645022)

SKView from the object library does not behave correctly in Mac documents. (37127877)

Workaround: Drag out a custom view and set its class to SKView.

Toolbars or multiline labels in stack views no longer result in an Auto Layout misalignment on the canvas. This issue resulted in problems such as zero width multi-line labels, or in extra tall toolbars when an iPhone X was selected in the device bar. (35377301)

Placeholder text for UITextField now appears correctly on the Interface Builder canvas. (35909580)

Changing a segue from "Show Detail" to "Show" no longer keeps the action selector for Show Detail. This default action will be automatically restored when compiling or saving a storyboard with Xcode 9.3 or later. (23505175)

Removed spurious warnings for using NSImageNameTouchBar* constants in Touch Bar. (35773248)

System-provided fonts are no longer archived in the <customFonts> XML element for iOS and tvOS documents. This resolves exceptions in libFontParser.dylib when launching apps. (35126633)

Fixed an issue compiling macOS storyboards that resulted in incorrectly logging: "Unknown Window class (null) in Interface Builder file, creating generic Window instead." (34994636)

Increased the helpfulness of the VoiceOver descriptions and tooltips for control and text alignment items in the Attributes inspector. (29782636)

Added the LOCALIZED_STRING_MACRO_NAMES build setting for adding custom localized string macros in addition to the default NSLocalizedString and CFLocalizedString families of macros. Each entry in the build setting is the base name for a set of four localization macros. For example, adding MyErrorString to the list enables using MyErrorString(), MyErrorStringFromTable(), MyErrorStringFromTableInBundle(), and MyErrorStringWithDefaultValue() to localize strings in your project. (14842118)

Resolved a crash that could occur when selecting a log in the Crashes organizer. (34869501)

Resolved a crash that could occur when selecting the app version in the Crashes organizer. (35786034)

Resolved an issue that resulted in the incorrect error message "No accounts with iTunes Connect access have been found [...]" when uploading an app to the App Store. (18369136)

Improved the performance of the Organizer window when scrolling and resizing, and when loading many archives or many iTunes Connect apps. (18978906)

Selecting text contained in rendered markup in the Find Navigator may not work as expected. (36382602)

Workaround: Choose "Editor > Show Raw Markup" before selecting the text.

Playgrounds with nested functions run correctly when using a custom toolchain from swift.org. (28784059)

tvOS playgrounds now display their live views at the correct size. (35951627)

Find Navigator now correctly searches all playground page content. (35751178)

Fixed a crash that occurred when deleting text in a playground page that is displayed in multiple tabs. (34364618)

Projects created in Xcode 9.3 use a new project format that is incompatible with earlier versions of Xcode. To open projects in earlier versions, change the project format by selecting the project in the Project navigator, opening the Document inspector, and selecting the desired format from the Project Format pop-up menu. (35207662)

When adding a framework to a target, Xcode also checks that the path of the directory containing the added framework doesn't already exist in SYSTEM_FRAMEWORK_SEARCH_PATHS before adding that path to FRAMEWORK_SEARCH_PATHS. (29851042)

Xcode provides a new quick look preview generator for provisioning profiles. The preview includes the app identifier, expiration date, certificates, device identifiers, and entitlements encoded within the profile. (37042581)

Fixed a problem where a "Rename Failed" error would occur the second time you used the Refactor > Rename command. (36304316)

Updated the Report navigator for Xcode Server integrations to show repository commits, logs, and sub-nodes for test and coverage results. (34493798)

The debugger on macOS now requires the entitlement com.apple.security.get-task-allow to attach to apps built for macOS or for iOS, tvOS or watchOS apps built for Simulator. Xcode automatically injects this entitlement to your builds. The entitlement is stripped from apps distributed using the Organizer window. (34638816)

To disable Xcode injecting the entitlement, set CODE_SIGN_INJECT_BASE_ENTITLEMENTS to NO in the build settings for the target or app. (34638816)

When starting Xcode Server, an alert may appear asking to provide the passphrase to access the xcsd keychain. (37795722)

Workaround: Enter the passphrase which is stored in /Library/Developer/XcodeServer/SharedSecrets/XCSDKeychainSharedSecret.

Resolves an issue that would cause Xcode to sign with entitlements from a different build configuration. (37324488)

Resolves an issue where modifying your entitlements file sometimes did not trigger code signing to occur during your next build. (36882851)

On macOS 10.13.4, booting iOS 11 and later in the Simulator may take several minutes the first time. (35628711)

Improved the visual quality of scaled simulated iOS devices resulting in fewer visual artifacts. To get the best results, turn off Optimize Rendering in the Debug menu. (35295090)

The Comparison View of the Version Editor has been redesigned with improved scrolling and visual styling. (35254006)

Renamed user interface elements to clarify the information presented. In the Version editor "Blame View" is now "Authors View" and in the Source editor "Show Blame For Line" is now "Show Last Change For Line." (35031446)

Reverting changes in the Comparison View now restores the original whitespace even if it doesn't match the current formatting options. (35009545)

Git checkout operations no longer require committing changes to files that are unaffected by the operation. (35837784)

Tagging a branch in Git now tags the most recent available revision of that branch. (35250057)

Added Callers to the Structured Selection Action Popover. You can now command-click on functions, methods, and properties and quickly navigate to their callers. (32587508)

Text anti-aliasing can be disabled in the source editor by opening Terminal and running the following command:

defaults write com.apple.dt.Xcode SourceEditorDisableAntialiasing -bool YES

Set the default to NO to turn anti-aliasing on. (31378200)

Compiler notes can now be viewed in the source editor by clicking on the diagnostic icon. (35898603)

Enhanced Jump to Definition to show the file and line number for each result to help distinguish similar results. (32020190)

Fixed a problem where Undoing would not cancel an Edit All in Scope session when undoing past changes made with Edit All in Scope. (31906590)

Code coverage highlighting in a group of lines in the source editor now works correctly when a group contains multiple subranges with different highlighting. (34802960)

Fixed a problem with Edit All in Scope where typing was not coalesced into a single undo group. (31364117)

Significantly improved performance editing and navigating large, multi-megabyte files. (31689732)

Fixed a problem where printing would cut off the right and bottom edges of each page. (35427028)

Fixed a problem where scrolling by a page using Option-Page Up or Option-Page Down would scroll too far. (34873829)

Fixed a problem where copying text would not always preserve the syntax coloring when pasted into Keynote. (32823164)

Live issues no longer remain in the source editor after a build succeeds. (35810806)

Improved the reliability of Command-Click in the source editor. (35937969)

The source editor page guide is now positioned correctly when line wrapping is disabled and the editor is horizontally scrolled. (32699889)

Improved the accessibility of breakpoints, test statuses, issues, and warnings in the source editor. (33593039)

Fixed a problem where the source editor did not respect the "Reduce Motion" System Preference when folding code. (35474751)

Code coverage highlights in the source editor are no longer shown in the incorrect columns. (33040660)

Resolved an issue where breakpoints may appear on the incorrect line when code is folded. (38082660)

Improved the scroll bar accuracy for scrolling in large files. (32473788)

The code coverage ribbon now shows correctly when line wrapping is disabled in the source editor. (20928769)

Copying and pasting the contents of entire documents no longer adds an additional trailing newline. (36042915)

Fixed a problem where Quick Help, Find Call Hierarchy, Reveal in Symbol Navigator, and Copy Symbol Name would give information for the wrong symbol. (31889593)

Implicitly unwrapped optionals may be used only as a top level type for properties, function parameters, function return values, and variables. Nesting them inside other types is deprecated and results in a warning. This will change to an error in a later version of Swift. (SR-3023, SE-0054)

Swift now consistently enforces that you can’t override a computed property with a stored property, even when the overridden property is marked as lazy. If you need to use a stored value when overriding a property, define a separate property as backing storage and make it available through your override. (35870371)

The type checker now resolves a function overload as ambiguous when there is an overload that returns an optional type, another overload that returns a function type, and the function is called in a context where either overload's return type could be used. For example, on the last line of the the code example below, the type checker can't resolve which version of f to call because result has no explicit type information. (36892416)

struct S<T> {}

func f<T>(_: S<T>) -> T? { … }

func f<T>(_: S<T>) -> (T) -> Int { … }

let s = S<String>()

let result = f(s)    // now correctly reports the ambiguity as an error

Passing different kinds of optionals (? or !) to a function as inout no longer requires overriding that function. (36913150)

For example, the following code is now correct:

func takesOptional(i: inout Int?) { … }

var x: Int! = 1

takesOptional(&x)

Swift now supports conditional compilation based on available modules using canImport() with an argument that is the name of a module that may not be present on all platforms. This condition tests whether it's possible to import the module, but doesn't actually import it. If the module is present, the platform condition returns true; otherwise, it returns false. (SE-0075)

#if canImport(UIKit)

<#module-specific code#>

#endif

When swiftc is run from the command line, the default deployment target is set to the version of the currently running OS. (29948658)

Use of ownership keywords weak and unowned for property declarations in protocols now result in a warning (SE-0186). However, as noted in (SR-7182), ownership keywords still have an effect when defining a protocol marked @objc, because they control the interface presented in the generated Objective-C header. No warnings will be issued if the protocol is marked @objc.

Overriding a function when the only difference in the signature is the kind of optional (? or !) for an inout parameter is deprecated in all versions of Swift and results in a compiler warning. This will change to an error in a future version of Swift. (SR-6685)

Swift supports a new platform condition targetEnvironment with a single valid argument simulator. Conditional compilation of the form #if targetEnvironment(simulator) can now be used to detect when the build target is a simulator. The Swift compiler will attempt to detect, warn, and suggest the use of targetEnvironment(simulator) when evaluating platform conditions that appear to be testing for simulator environments indirectly, via the existing os() and arch() platform conditions. (SE-0190)

The compiler now warns for more cases of non-exclusive memory access. These are shown as warnings in the Swift 4.1 compiler and may become errors for all language modes in future versions of the compiler.

Examples of the new warnings include: an access to memory inside a nonescaping closure conflicting with an access that is already in progress, and a conflict in a closure with a non-generic type that is passed to a function expecting a generic closure. (SR-6103)

For example, the compiler now warns about overlapping accesses to the variable value:

var value = 7

withUnsafeMutablePointer(to: &value) {

  $0.pointee = value + 1

}

One way to avoid the warning is to make a copy of the local variable before passing it as inout:

var value = 7

let valueCopy = value

withUnsafeMutablePointer(to: &value) {

  $0.pointee = valueCopy + 1

}

Another way is to refer to the variable using a closure parameter instead of capturing it:

var value = 7

withUnsafeMutablePointer(to: &value) {

  $0.pointee = $0.pointee + 1

}

Calls to unavailable functions are permitted if the calling context is also marked unavailable. This simplifies writing code that can be compiled with and without application extension restrictions enabled. (34949130)

When a class conforms to a private or fileprivate protocol in one file, and the class is subclassed in another file or target, the compiler crashes with the messages "DESERIALIZATION FAILURE" and "top-level value not found." (22672176)

Workaround: Change the protocol to internal instead of private or fileprivate, or set the Optimization Level build setting to Whole Module Optimization (-O -whole-module-optimization.)

If a nested type in a codable type has the same name as a property of the codable type, the compiler will crash. (37570349)

Workaround: Rename either the nested type or the property.

A crash can occur during runtime whenever there is a generic class or a subclass of a generic class with a stored protocol metatype property. (38394640)

Example:

protocol P { }

class Generic<T> {

  let protocolMetatype: P.Type

}

Workaround: Box the metatype in a class.

class BoxedType {

  let p: P.Type

  init(_ type: P.Type) {

    p = type

  }

}

class Generic<T> {

  let boxedProtocolMetatype: BoxedType

}

In circumstances where protocol methods or base class methods defined in Objective-C claim to take non-null arguments of type id in their headers, but get invoked with nil values at runtime, Swift code compiled by Xcode 9.3 that overrides those methods may crash when the Swift implementations are invoked. (38675815)

Workaround: Change the Swift override to take a value of type Any?. For example, if you implement the UIApplicationDelegate protocol's application(_:open:sourceApplication:annotation:) method:

class AppDelegate: UIApplicationDelegate {

    func application(_ application: UIApplication, open url: URL, sourceApplication: String?, annotation: Any) -> Bool {

        return true

    }

}

The program may crash when passed nil as the annotation argument. Avoid the crash by making the annotation argument have type Any?:

class AppDelegate: UIApplicationDelegate {

      func application(_ application: UIApplication, open url: URL, sourceApplication: String?, annotation: Any?) -> Bool {

        return true

    }

}

Conditional conformances are unsupported when performing a dynamic cast (with is or as). (SE-0143)

For example:

print([1, 2, 3] is Codable) // Prints "false", but [Int]

                            // instances really are Codable.

try JSONEncoder().encode([1, 2, 3]) // Successfully encodes

                                    // the array as JSON.

Arrays only conform to Codable when their elements are also Codable, but checking for this conformance isn't supported at runtime.

While performing the is cast, the Swift runtime warns that it can't evaluate the conditional conformance:

warning: Swift runtime does not yet support dynamically querying conditional conformance ('Swift.Array<Swift.Int>': 'Swift.Decodable')

Generated headers for Swift content can be imported when a macro named any is defined. (34168022)

Assigning a Swift closure expression into a global block variable that is declared in Objective-C now works correctly. (36843476)

In a Swift class that is exposed to Objective-C, if init() is not supported then the +new method is marked as unavailable. (32405588)

Objective-C methods with selectors that start with add or remove are now named consistently when imported into Swift. Previously, each occurrence of the same selector could be nondeterministically named by using or not using the portion of the name after add or remove, such as importing addThing: as either add(_:) or addThing(_:). (33836975)

A synthesized implementation of == is automatically added to a structure or enumeration that declares a conformance to Equatable. This requires that all stored properties of a structure or all enumeration cases with associated values are Equatable.

Similarly, a synthesized implementation of hashValue is added when declaring a conformance to Hashable. This requires that all stored properties of a struct or all enum cases with associated values are Hashable.

Providing your own implementation of == or hashValue overrides the one synthesized by the compiler. (SE-0185)

If an extension adds an initializer to a structure that was declared in another module, the new initializer can't access self until it calls an initializer from the defining module. Attempting to access self before calling such an initializer results in a warning in Swift 4 and may result in an error in Swift 5. The requirement prevents an app from accidentally depending on the implementation details of a library. It also matches the existing requirement that cross-module initializers must be convenience initializers.

Code that extends a struct imported from C is most likely to be impacted. However, most imported C structs are given a zeroing no-argument initializer that can be called as self.init() before modifying specific properties.

Swift library authors who wish to continue allowing initialization on a per-member basis should explicitly declare a public memberwise initializer for clients that are in other modules. (SE-0189)

New recursive constraints require that the associated type conform to the enclosing protocol. The standard library protocols have been updated to use recursive constraints including:

• The Indices associated type has the same traversal requirements as the enclosing protocol, for example Collection.Indices conforms to Collection.

• Requiring that Numeric.Magnitude conform to Numeric.

• Using more efficient SubSequence types for lazy filter and map.

• Eliminating the *Indexable protocols.

(SE-0157)

For example, the SubSequence associated type of Sequence follows the enclosing protocol:

protocol Sequence {

  associatedtype Element

  associatedtype SubSequence: Sequence

  where SubSequence.Element == Element,

  SubSequence.SubSequence == SubSequence

  // ...

}

protocol Collection: Sequence where Self.SubSequence: Collection {

  // ...

}

Access control is enforced for subclasses of generic classes. A public class may not subclass an internal class. For source compatibility, these new diagnostics are warnings in Swift 4.1. (35119972)

KeyPaths now support subscript, optional chaining, and optional force-unwrapping components. (31768715)

Performance of the dependency resolution algorithm has been significantly improved when there are shared dependencies in a package graph. Up to a 12X improvement has been observed in certain cases (36777215).

When compiling jobs in parallel, the package manager determines the number of CPUs to use instead of using a hardcoded value. (35042923)

In a package graph that uses different URL schemes, such as ssh and http, dependencies are now resolved correctly by the package manager. (27573226)

The package manager now warns if a dependency is declared but not used. (35174605)

The package manager now displays an error when there are two products with the same name. (34494792)

Compiler warnings in Package.swift no longer prevent a build from completing successfully. (36324891)

The build command in Swift package manager now works correctly when products of type automatic are used with the --product option. (36509350)

The edit command for a package now finds a dependency correctly when the base name of the URL for the package and the name of the package in Package.swift don't match. (SR-6758)

Encodable and Decodable are now conditional conformances of Optional, Array, Dictionary, and Set that are available only when the type parameters conform to Encodable or Decodable. (SE-0143, SE-0166)

Optional, Array, and Dictionary now conform to the Equatable protocol if their element types conform to Equatable enabling the comparison of two values of composed types, such as [Int: [Int?]?]. (SE-0143)

Index types for most standard library collections now conform to Hashable enabling the indices to be used in key-path subscripts and in hashed collections. (SE-0188)

For example:

let s = "Hashable"

let p = \String.[s.startIndex]

s[keyPath: p] // "H"

The variant of Sequence.flatMap(_:) that accepts a closure returning an Optional value has been deprecated. Other variants of flatMap(_:) on both Sequence and Optional remain as is. (SE-0187)

Instances of IndexDistance associated type in the Swift standard library have been replaced by the concrete type Int. Algorithms that currently constrain IndexDistance to Int in their where clause, and algorithms that use IndexDistance within the body of a method, are supported by a deprecated type alias for IndexDistance in an extension on Collection. (SE-0191)

Reconciled APIs between the multiple forms of unsafe pointers: UnsafePointer, UnsafeMutablePointer, UnsafeRawPointer, UnsafeMutableRawPointer, UnsafeBufferPointer, UnsafeMutableBufferPointer, UnsafeRawBufferPointer, and UnsafeMutableRawBufferPointer. Functionality previously only available in some interfaces are now available in all the relevant interfaces. (SE-0184)

The changes are additive with the following exceptions:

• deallocate(capacity:) and deallocate(bytes:alignedTo:) are replaced by deallocate(). Simply removing the capacity argument or the bytes and alignedTo arguments preserves the behavior of the code.

• UnsafeMutableRawBufferPointer.allocate(count:) is replaced by UnsafeMutableRawBufferPointer.allocate(byteCount:alignment:). The behavior of the code can be preserved by adding an alignment argument, MemoryLayout<UInt>.alignment, to specify alignment on word boundaries.

• initializeMemory<T>(as:at:count:to:), is replaced by initializeMemory<T>(as:repeating:count:). The at parameter is removed. Initializing at an offset can be achieved by multiplying the element index by MemoryLayout<T>.stride and adding to the raw pointer base.

Some groups of collection types in the standard library, including slices and lazy collection wrappers, are now collapsed into single types using conditional conformance. The old types are available as deprecated type aliases for source compatibility. For more information on conditional conformance, see https://swift.org/blog/conditional-conformance/. (21935030)

xccov is a new command-line utility for inspecting the contents of Xcode coverage reports. It can be used to view coverage data in both human-readable and machine parseable format. To learn more, enter man xccov in Terminal. (37172926)

Classes that inherit from subclasses of XCTestCase now show inherited test methods in the Test navigator correctly. (34838443)

The code coverage line execution counts for block literals are now correct. (22581085)

Fixed an issue that could result in a code coverage report missing header files and any code in those header files. (28915357)

Code coverage data is now captured for applications that are the target of UI tests when tests are run with xcodebuild. (23913271)

Fixed an issue that resulted in the coverage report incorrectly displaying the "No Coverage Data" message. (36040075)

Fixed several performance bottlenecks with code coverage including generating coverage reports and loading coverage reports in the Reports Navigator. In addition, navigating between files in the source editor while viewing code coverage no longer results in the spinning cursor. (33353328)

Running tests on an iOS device with code coverage enabled no longer results in temporary freezes of the UI while downloading the code coverage profiles. (29681809)

An issue that could cause -[XCUIApplication launch] and -[XCUIApplication terminate] to fail if code coverage is enabled and the debugger is disabled has been resolved. (36590025)

The code coverage report now contains correct counts for static inline functions. (22520187)

XCTest UI interruption monitors now work correctly on devices and simulators running iOS 10. (33278282)

NSFileProviderExtension now works on iOS 9 and iOS 10 when the minimum supported OS version of the project is iOS 8.0 or earlier. (34828118)

A workspace containing many cross-project references no longer experiences significant user interface lag shortly after opening. (14558737)

When using Xcode 9.2 to create apps that deploy to iOS 8 and later, images in the asset catalog may be corrupted when viewed on devices running iOS 8.3 and earlier. (35379713)

Workaround: Build the app using Xcode 9.1, or use Xcode 9.2 and set the deployment target to iOS 8.4 or later.

Xcode now correctly compiles code that contains a std::function variable with an incomplete return type. (34010071)

When _POSIX_C_SOURCE is defined, including libc++ headers that depend on __threading_support, such as thread or mutex no longer results in an error. (31263056)

An experimental opt-in feature increases the number of concurrent build tasks that are run for Swift projects. This may improve build times for Swift projects, but may also increase memory use during the build. (35326759)

To enable this feature, open the Terminal and enter the following command:

defaults write com.apple.dt.Xcode BuildSystemScheduleInherentlyParallelCommandsExclusively -bool NO

To disable the feature, delete the preference by entering the command:

defaults delete com.apple.dt.Xcode BuildSystemScheduleInherentlyParallelCommandsExclusively

The build system no longer produces inconsistent header maps while indexing. This resolves an issue with debugging Swift code using lldb. (34716477)

The generated Objective-C @property declaration for a UUID attribute now always includes the nullable and copy annotations. (35273724)

Added support for the .mlmodel specification version 2 which includes float16 weights and custom layers in neural network models.

Updated the Model viewer to show custom layer dependencies.

Specifying a section inset reference point for a UICollectionView, such as relative to the Safe Area, is now supported in the Size inspector. (34812768)

Fixed a performance issue that resulted in frequent rebuilds when editing an IBDesignable view. (28360728)

Resolved a canvas rendering issue that sometimes occurred when switching the device configuration to iPhone X. (34424852)

Localization warnings are no longer reported for a UISegmentedControl containing only images and no text. (34601808)

Resolved a layout ambiguity with image-based UIToolbar buttons that resulted in a hang and in high CPU usage. (34057302)

Localization warnings are no longer reported for a UILabel with numberOfLines set to 0, or for any single-character text strings. (34767956)

Resolved a canvas responsiveness issue when rendering a Storyboard containing a UITextField. (34808049)

A layer-backed IBDesignable view no longer draws upside-down on the IB canvas. (34758240)

Resolved a crash that occurred when trying to change the font for a localization comment in the Identity inspector for iOS, tvOS, and watchOS documents. (26097921)

Device Bar labels are more concise when displayed as popup buttons. In addition, VoiceOver navigation is improved for groups around related mutually-exclusive buttons. (27480768)

When the device configuration is set to an iPhone X, the height of the UIToolbar shown on the canvas may be too large. The iOS runtime is not affected.

Workaround: Use a different device for editing on the canvas, or connect the scene to a navigation controller that contains a toolbar.

Xcode no longer crashes when navigating between pages in a playground. (34821667)

The Render Documentation checkbox now behaves correctly. (34627634)

In Simulator, apps with the audio background capability now continue playing audio when switched to the background. (34591587)

A watchOS app using Swift now runs on a simulated watchOS 2 device. (35063043)

iCloud Drive now syncs on a simulated device running iOS 11.2 or later. (34669593)

Swiping up to unlock a simulated iPhone X now works correctly. (33390776)

When both Xcode 9.0 and 9.1 are installed, Simulator in Xcode 9.1 may not show devices for iOS 11.0, tvOS 11.0, or watchOS 4.0 in the Hardware > Device menu. (34761843)

Workaround: Use Xcode 9.0 to build and run the app in Simulator on the desired device.

Use of some 3rd party firewall tools that install kexts may cause problems launching apps in Simulator. (34829500)

Workaround: Unload the problematic kexts using the kextunload command in the terminal. Disabling rules in the firewall application may not solve the problem.

A thrown Swift Error object with an assertion message greater than 255 characters that is not caught may result in Xcode crashing. (35487430)

UTF–16 string indices now increment correctly when there is a limiting index resulting in expressions such as Range(NSRange(location: 1, length: 0), in: "") returning nil instead of crashing. (34551055)

Opening the Swift Migration Assistant when a workspace or project contains a Swift Playground no longer crashes. (35175054)

MTKMesh.newMeshes(asset:device:) now populates the MDLMesh array in the return value correctly. (34624659)

Fixed a bug that resulted in some uses of key path literals with optional chaining (?) components that either crash with the error message "pointer with negative count", or in memory corruption at runtime. (35367114)

The XCUIElementType enumeration is now imported into Swift 4 as XCUIElement.ElementType, allowing the type name to be referenced in code. (34772051)

The new build system properly respects localizations for all files when copying them into the Resources folder. (34025522)

The Xcode debugger now displays improved error descriptions for most Swift fatal errors. (33365646)

Display of Swift fatal errors in the debugger is enabled only when the main executable is using Swift. (35163654)

Setting the Spring Loaded checkbox for drag and drop in the Interface Builder Attributes inspector now sets isSpringLoaded at runtime. (34284258)

Setting the large title text attributes of UINavigationBar now works correctly. (33979437)

When the Size simulated metric of a view controller is set to Freeform, Interface Builder now uses the freeform size for downstream view controllers with the Size metric set to Inferred. (33872052)

Setting a UITableView in a XIB file to Grouped style with automatic row heights no longer hangs Xcode. (33483932)

New checkbox and radio buttons added from the object library now have a default Vertical Content Hugging Priority that matches other NSButton objects. Priority values for existing objects remain unchanged. (21574446)

Dragging a row within the user-defined runtime attributes table no longer discards the dragged attributes. (18444777)

Clicking outside the text field when editing the key path of a user defined runtime attribute now works as expected. (12406749)

Mirroring the user interface now works correctly when running a macOS app using a scheme that sets the Application Language to Right-to-Left Pseudolanguage With Right-to-Left Strings. (33923833)

Reduced the number of false positive Auto Layout warnings for localized projects. (33849087)

The -importLocalizations option of the xcodebuild command now adds files from the XLIFF to the project. (17305567)

The Info.plist keys NSLocationAlwaysAndWhenInUseUsageDescription and NSFaceIDUsageDescription are now localizable for XLIFF export and import. (34589189, 34866053)

Uploading In-App Purchase content from the Xcode Organizer window now works correctly. (33951562)

Using a networked device for testing in Xcode Server currently requires that the user account for running integrations is logged in and that Xcode Server is the frontmost app. For information on setting up Xcode Server, see Perform Continuous Integration > Configure Xcode Server in Xcode Help. (33904987)

In Simulator, the video in an AVPlayerViewController no longer appears outside the safe area on the iPhone X. (34339660)

Improved the rendering quality of Simulator on 2016 and 2017 MacBook Pros. (33998687)

Reducing the sized of an iPhone X in Simulator by dragging no longer results in a edge swipe on the simulated device. (33974533)

Choosing Window -> Scale -> Actual Size in Simulator now sets an iPhone X to the correct size. (33908038)

Fixed an issue in Simulator's OpenGL that could cause SceneKit apps to run slowly and the CPU to hit 100% when attempting to pan in an MKMapView.

In Simulator, panning an MKMapView in a SceneKit app now works correctly. (33664759)

watchOS apps that use Swift may fail to run on a simulated device running any version of watchOS 2. (35063043)

Workaround: Test watchOS 2 apps on a device, or test in Simulator on watchOS 3 or later.

Xcode now supports using a Git worktree as a working copy. (24745300)

The source control history editor now updates correctly when updating the local working copy. (33919644)

The following ARKit and Metal symbols are now available for Swift on iOS. (34642200)

ARKit:

• ARFaceGeometry.verticies

• ARFaceGeometry.textureCoordinates

• ARFaceGeometry.triangleIndices

Metal:

• MTLRenderCommandEncoder.setTileBuffers(_:offsets:range:)

• MTLRenderCommandEncoder.setTileTextures(_:range:)

• MTLRenderCommandEncoder.setTileSamplerStates(_:range:)

• MTLRenderCommandEncoder.setTileSamplerStates(_:lodMinClamps:lodMaxClamps:range:)

When running a test action which involves multiple bundles, the xcodebuild command line tool no longer intermittently shuts down simulated devices. (33983007)

Testing no longer intermittently fails at the end of a successful test run with the error “DTXProxyChannel error 1.” (33948901)

When using Swift 4, referring to the nested enumeration type XCUIElement.Type by name is not possible. This can result in a compile time error in other places in your code when working with the type of an XCUIElement.Type. Using a value of the nested enumeration works correctly.

The issue doesn't occur in Swift 3 code because the enumeration is named XCUIElementType. (34772051)

Workaround: Add a type definition to your bridging header, such as:

#import <XCTest/XCTest.h>

typedef XCUIElementType FIX_XCUIElementDotTypeWorkaround;

In the Editor > Resolve Auto Layout Issues submenu, Add Missing Constraints and Reset to Suggested Constraints now create the correct constraints for a view that is in a view controller that is downstream of a navigation controller. (34603925)

Moving localized files in the structure editor no longer causes Xcode to crash. (34551605)

Adding files to a project now adds them to the selected targets. (34551617)

Reordering items in a group in the Project navigator no longer results in Xcode consuming excess CPU. (34551671)

In Simulator, the Settings app crashes the first time it is opened. Subsequent launches work correctly. (34522196)

Swift apps using generic casting and reflection now run correctly on macOS 10.9 and iOS 7. (34595478)

The following AVFoundation symbols are now correctly marked as public:

• AVCaptureDevice.Format.supportedColorSpaces

• AVCapturePhotoOutput.supportedFlashModes

• AVCapturePhotoOutput.availablePhotoPixelFormatTypes

• AVCapturePhotoOutput.availableRawPhotoPixelFormatTypes

• AVCapturePhotoSettings.availablePreviewPhotoPixelFormatTypes

(34538928)

Added Test and Tests as suffixes for determining file counterparts used in navigation and in the Assistant Editor. (28981734)

Added -runFirstLaunch, a new xcodebuild flag that checks the status of the license agreement and installs any packages required for launching Xcode. (23529342)

Core NFC can now be enabled via the Capabilities tab in Xcode. (32520707)

Added support for running multiple versions of the Xcode app at the same time, and of any associated tools such as Simulator. Xcode 9.0 can't be run at the same time as earlier versions. (23140937)

Fixed an issue causing App Store uploads to fail with error code –22421. (25068558)

On OS X 10.9 or iOS 7, running a Swift app that uses generic casting or reflection may result in an error that includes the wording object_isClass symbol not found. (33872748)

Uploading In-App Purchase content from Organizer window fails with the error message The archive contains nothing that can be signed. (33951562)

Workaround: Use Transporter to upload In-App Purchase content. For more information, see https://help.apple.com/itc/appsspec.

When exporting an ad-hoc or enterprise IPA, Swift symbol stripping requires enabling app thinning or Rebuild from Bitcode. For more information, see Distribution options in Xcode Help. (31737836)

Workaround: Enable app thinning or Rebuild from Bitcode when exporting the app.

Apps with a deployment target of iOS 11 no longer build a 32-bit slice. To build and include a 32-bit slice, set the deployment target to an earlier version of iOS. (32163517)

Added a check for using the memory for a variable that is out of scope. (32308829)

Added "Detect use of stack after return", an optional check for using the memory for a local function variable after the function has returned. Turn on the option in the Diagnostics pane of the Scheme editor. (32308829)

Address Sanitizer is now compatible with Malloc Scribble. (32359908)

Increased the performance of incremental link-time optimization. (22867330)

Added a warning for calls to performSelector where the method referred to by the selector may return a structure, union, or vector type. (12056271)

Updated -Wstrict-prototypes to warn about nonprototype functions, block declarations, and types in C and in Objective-C. (15060615)

Updated how the expected identifier error handles C++ keywords in Objective-C++ code. Identifiers that are valid in Objective-C but invalid in Objective-C++ have a more specific error message. An example of the new error is: error: expected identifier; 'new' is a keyword in Objective-C++ @protocol new ^. The parser has better recovery after this error, to improve error reporting in the rest of the file. (20626062)

Added -iframeworkwithsysroot, a command line option that prepends the system root path (-isysroot) to the path of the provided framework. (21316352)

Added -Wunguarded-availability, a new compiler flag that warns of an unguarded use of an Objective-C API that was introduced in a version of the OS that is later than the deployment target version.

To guard the use of new APIs, use an if statement combined with @available, a new Objective-C expression that checks the system version. For example:

if (@available(macOS 10.13, iOS 11, *)) {

   // The compiler will not warn about uses of APIs from macOS 10.13

   // or iOS 11 here

}

C or C++ code can use __builtin_available, a new builtin whose semantics are equivalent to @available.

The -Wunguarded-availability flag is off by default to prevent unexpected warnings in existing projects. -Wunguarded-availability-new, a less strict version of the compiler flag that warns about unguarded uses of APIs only when they were introduced in macOS 10.13 or later, iOS 11 or later, tvOS 11 or later, or watchOS 4 or later. The -Wunguarded-availability-new flag is on by default. (7184689)

The placeholder for a block parameter that uses a typedef instead of specifying the block type directly now expands to the block declaration when using code completion for setters of block properties. (21981862)

Xcode provides code-completion results for missing C++11 constructs and keywords. The following constructs are included in the code-completion results:

• static_assert

• alignas

The following keywords and special identifiers are included in the code-completion results:

• constexpr

• final

• noexcept

• override

• thread_local

The __auto_type keyword is included in code-completion results for code that uses C or Objective-C. (29219185)

Xcode provides code-completion results for members from dependent classes. For example:

template<typename T>

void appendIfTrue(std::vector<T> &dest, const T &value) {

   dest. // Xcode will now show relevant completion results after '.'

}

Note that code-completion results won’t be provided when the member expression includes a dependent base. For example:

template<typename T>

void appendIfTrue(std::vector<std::vector<T>> &dest, const T &value) {

   dest.at(0). // Xcode *will not* have the relevant completion results

               // for the members of std::vector here

}

(29818301)

The state of the #pragma pack directive in an included precompiled header is now preserved. (21359084)

Warnings for incomplete umbrella headers in module maps now trigger even when the umbrella header is part of a submodule. (22623686)

A redefinition error caused by the repeated inclusion of a nonmodular header now shows the include file stack leading to the repeated include. (24116019)

When the -E flag in Clang is used for preprocessing, the editor placeholder in source file error is no longer shown. (32718000)

Xcode fails to compile code that contains a std::function variable with an incomplete return type. For example, the following code below doesn't conform to the C++ standard. (34010071).

class Continuation {

   std::function<Continuation ()> m_next;

};

When the Symbols Hidden by Default build setting is enabled (-fvisibility=hidden) and a symbol declaration includes an availability attribute with a macOS availability such as API_AVAILABLE(macos(10.12), ios(10)), then the symbol’s visibility is set to default instead of hidden. (33655115)

Workaround: Use __attribute__((visibility("hidden"))) in addition to API_AVAILABLE to hide a declarations.

Vector parameter return values for an Objective-C method with a target earlier than macOS 10.11 or iOS 9 are no longer valid. (21662309)

Asset catalogs now support named colors that can be used in source files and Interface Builder. (28900538)

Asset catalogs now support high-efficiency image formats, including files with the .avci, .heic, and .heif file extensions. (29959599)

WatchKit App Store icons in the asset catalog are not uploaded when using Xcode to submit an app to the App Store. (33383969)

Workaround: Use the iTunes Connect web app to upload WatchKit App Store icons.

App store icons for tvOS include an unused slot for a 2x version of the icon. Any images in this slot are ignored. (33800909)

Apple TV 4K apps must include a 2x launch image to run at the higher resolution. (33968521)

Xcode 9 includes a new build system written from scratch in Swift. It is designed for higher reliability, and it catches project configuration problems that the standard build system does not. The performance of the build system (not including compilers, linkers, and other build tools) has been dramatically improved. This new build system is built on top of the Swift open source llbuild project.

In Xcode 9.0, the new build system is disabled by default. To enable the new build system, choose File > Project Settings or File > Workspace Settings, and then choose New Builds System for the Build System option in the menu. For a command-line build, pass the -UseNewBuildSystem=YES flag to xcodebuild. The new build system will become the default build system in a future version of Xcode. (19209225)

Although the new build system is highly compatible with existing projects, some projects may require changes due to the following:

• The new build system has stricter checks for cycles between elements in the build in order to prevent unnecessary rebuilds. To resolve the issue, make sure that any generated files are produced before they are required. For example, if a target both produces an output and depends on other targets that use the output, move the production of the output into its own target and run that target earlier in the build.

• It is an error for any individual file in the build to be produced by more than one build command. For example, if two targets each declare the same output file from a shell script phase, factor out the declaration of the output file into a single target.

• If an output file which is generated by a shell script is used as an input elsewhere in the build (for example, to another shell script), then that output must be declared as an explicit output by the script that generates it; otherwise the build system may attempt to search for the file before it has been generated, causing the build to fail.

• The traditional header map that was generated when the Always Search User Paths (ALWAYS_SEARCH_USER_PATHS) setting was YES is not supported by the new build system. Instead, set ALWAYS_SEARCH_USER_PATHS to NO and migrate to using modern header include syntax.

  • Add any needed header files that are in the project repository to the Xcode project to ensure they are available for use in #include (via the project wide header map).

  • Use quote-style include ("foo.h") for project headers, and reserve angle-bracket include (<foo.h>) for system headers.

• The new build system passes undefined_arch as the value for the ARCH environment variable when running shell script build phases. The value was previously not well defined. Any shell scripts depending on this value must behave correctly for all defined architectures being built, available via the ARCHS environment variable.

• The new build system supports the “clean build folder” behavior. The standard “clean” behavior is not supported.

For a target containing Swift and defining a module, the generated module.modulemap file now includes requires objc so it can be used by languages other than Objective-C (such as C++). (28650820)

The new Strip Swift Symbols (STRIP_SWIFT_SYMBOLS) build setting is enabled by default. It adjusts the level of symbol stripping so that when the linked product of the build is stripped, all Swift symbols are removed. This significantly reduces the size of Swift frameworks. If the lack of Swift symbols causes problems, such as when using dladdr(), this setting can be disabled. To view the exported symbols from file that has been stripped, use xcrun dyldinfo -export instead of nm. (31306055)

A scheme with code coverage enabled for the test action now enables code coverage for the run and analyze actions, reducing the need to build multiple versions of the application. To turn off code coverage for all actions other than test, use a separate scheme for those actions with code coverage disabled. (31848014)

Added Precompile Bridging Header (SWIFT_PRECOMPILE_BRIDGING_HEADER), a new build setting for the Swift compiler. This setting is enabled by default and adds a new optional step in mixed-source builds called PrecompileSwiftBridgingHeader, that improves overall build time. If unexpected errors occur during this step, disable this build setting to omit the optional step. (31851450)

Added Swift 3 @objc Inference (SWIFT_SWIFT3_OBJC_INFERENCE), a new build setting that controls how the Swift compiler infers @objc for declarations. By default the compiler uses the declared Swift version in the target to perform the inference. The new setting can be used to explicitly direct the Swift compiler to use either Swift 3 to Swift 4 inference rules. (32121595)

An autocreated scheme is saved to disk only if it has been edited. This helps prevent the accumulation of schemes for targets which were deleted, or are added to other schemes. (30266825)

For targets that use automatic signing, xcodebuild can now communicate with the Apple developer website to create and update provisioning profiles, signing certificates, and app IDs. To enable this behavior, choose Xcode > Preferences and add your Apple ID in the Accounts pane, and then pass the -allowProvisioningUpdates flag to xcodebuild when building your target. (27572834)

Added CODE_SIGN_STYLE, a build setting used to override a target’s signing style to Automatic or Manual when using xcodebuild. (28077832)

When a project is opened, Xcode may create a Recovered References group in the Project navigator. This group contains files that are referenced in a target but aren't referenced in the group tree of the project. If the group appears, move each file to the proper location in the project as appropriate. (22924751)

Changed the name of the build intermediates folder to Intermediates.noindex. This improves build times by preventing Spotlight from indexing the folder. (29336306)

Xcode supports static library targets which contain Swift code. Debugging applications that use Swift static libraries may require a complete set of build artifacts that are in their original location. (33297067)

When using the new build system, it is not possible to use the clean action in a project or workspace that uses the legacy or custom locations for derived data. (32296417)

Products built with code coverage enabled should not be submitted to the app store. Code coverage is disabled automatically when performing the archive scheme action. It is not recommended to distribute or submit apps built with the run action; if your workflow involves submitting a product built with the run action, you should switch to submitting the product of the archive action. The run action is the default action performed by xcodebuild when -scheme is passed with no explicit verb, or with the build verb; use the archive verb to build with the archive action. (32870905)

The new build system may not define all of the environment variables that the standard build system defines when launching shell scripts. If the new build system is not supplying an environment variable that your scripts use, please file a bug at https://bugreporter.apple.com with the name of the environment variable, the expected value in the old build system, and a brief explanation about what you are using the variable for. (24541618)

When using the new build system and using DWARF with dSYM File debugging information, the build may do unnecessary work to extract the dSYM on each build iteration, degrading build performance. (30668974)

Workaround: Enable DWARF with dSYM File only for the Release configuration.

With the new build system, switching between building the Debug and Release configuration of a project may result in unnecessary content rebuilding. (30924058)

For single files, the new build system does not yet support the Compile, Analyze, Preprocess, or Assemble operations of the Product > Perform Action submenu. (31072405)

When using the new build system, Interface Builder live views use the old build system. (31433718)

Projects using on-demand resources are not currently supported by the new build system. (31508570)

When using the new build system, the total number of build tasks reported in the activity area may not be computed correctly, and will continue to increase during the build. (31855141)

The build setting Separate Strip (SEPARATE_STRIP) is no longer supported nor is it displayed in the build settings editor. Xcode always strips binaries in a separate task and no longer instructs the linker to perform the strip. (31584192)

Data models generated in projects that use Swift 4 use Swift structures when possible. Data models generated in projects using Swift 3 are unchanged. (27512827)

Updated the model editor to present a unified interface for Core Data’s fetch indexes, property index, and entity compound indexes. Older data models are translated into fetch index form, and saved to the old file format when necessary. Compiling a data model for a target lower than iOS 11, watchOS 4, macOS 10.13, or tvOS 11 continues to generate a compatible model. (30843153)

Added a flag to the model editor for marking an attribute as preserved after deletion, to support persistent history tracking. (31204966)

Added support to the model editor for setting an entity's Core Spotlight display name expression. (31619747)

Added support to the model editor for creating fetch indexes from attributes, expressions, and relationships. (32407895)

The Crashes Organizer symbolicates unsymbolicated logs, if they are selected using a local .dSYM indexed by Spotlight. (22550064)

Added a number of fixes to increase the stability, reliability, presentation, performance, of the Crashes Organizer. (29500046)

Added wireless debugging for iOS and AppleTV. (10968305)

Added support for SpriteKit and SceneKit to the visual hierarchy debugger. SpriteKit nodes appear as views. SceneKit views open a snapshot in the SceneKit editor. Changes made to the editor can be saved and don't change the app. (29169315)

Added allocation backtraces to saved memory graph files exported by Xcode or generated by the leaks command line tool. Saving backtraces requires that malloc stack logging is enabled for the target. (25399716)

The Xcode Memory Debugger, Leaks instrument, and leaks command line tool should no longer report false positive leaks of small malloc blocks related to the use of weak references in process that use Swift. (29780048)

GPU performance counters are not available on devices with A7 or A8 processors. (32982421)

Removing a wireless development pairing from a device requires resetting the network settings by choosing Settings > General > Reset > Reset Network Settings. (31626631)

In the GPU Frame Debugger, argument encoders created before the start of a frame capture result in the app crashing while capturing. (32415645)

Workaround: Create argument encoders within the captured workload, or release them before capturing.

In the Devices pane of the Devices and Simulators window, the button to show the debug console for a paired Apple Watch now shows correctly when an iPhone with a paired watch is selected. (32365458)

Instruments can’t wake a sleeping device over a network. (33384362)

Workaround: Wake the device manually or by building and running the app.

After installing Xcode, the first time an app is run in Simulator the memory graph debugger and Instruments display no data. (34172871)

Workaround: Reboot the Mac.

Added the Layout Margins option in the Size inspector to enable specifying custom margins. For more information, see Positioning Content Within Layout Margins. (30086042)

Added support for the vertical baseline-to-baseline constraint added in iOS 11. (30086144)

Safe Area layout guides can be enabled for any subview and for XIB files. (32956031)

Interface Builder renders navigation bars, tab bars, and toolbars on the canvas as they appear on a device at runtime. (30983209)

To use the new usesAutomaticRowHeights property of NSTableView in Interface Builder, choose Automatic (Auto Layout) from the Size inspector, and then set a value for Row Height. This value is used by AppKit as part of the auto layout calculation. (29511510)

Added estimated row, header, and footer heights to the Size inspector in Interface Builder. These properties are used by UIKit to create self-sizing table cells by setting the estimated height to a value other than zero. (17995201)

Files created with Interface Builder files use the new safe area layout guide instead of top and bottom layout guides. Constraints that use the safe area are automatically converted to use top and bottom guides when deployed to a version of iOS or tvOS that doesn't support the new safe area guide. To enable the safe area guide in existing files, select the view controller or view, open the File inspector, and enable Use Safe Area Layout Guides. (29323293)

Interface Builder allows configuring the column sizing properties of UISplitViewController. (18359423)

Interface Builder supports setting textContentType on classes conforming to the UITextInputTraits protocol. On iOS 11, this improves the ability of AutoFill to populate with appropriate data including the Username and Password. (25019432)

When landscape is chosen from the Device configuration pane, Interface Builder now shows the correct height for the status, top, and bottom bars. In addition, IBDesignable views receive the the correct values for the current trait collection. (6799670)

When Vary for Traits mode is active, choosing Clear Constraints and Reset to Suggested Constraints affects only the active configuration. (27407689)

Fixed drawing issues that occurred when resizing the Interface Builder document outline view. (32137309)

Connecting outlets and actions to a Swift protocol-typed class now works correctly. (17023935)

Outlets, actions, and inspectable properties declared in classes that have a Swift protocol extensions now work correctly. (22201035)

Objective-C annotations such as NS_REFINED_FOR_SWIFT no longer prevent using IBInspectable with a property. (30509152)

Compiling a macOS storyboard with an NSTableView that uses Cocoa Bindings, no longer results in ibtool hanging. (18867270)

Using a Swift image literal within prepareForInterfaceBuilder() causes IBDesignablesAgentCocoaTouch to crash because live views are compiled in a different bundle. (28676479)

Workaround: Use UIImage(named:inBundle:compatibleWithTraitCollection:) for all image lookups, and use Bundle(for: type(of: self)) to find the bundle for the live view class.

The navigation bar doesn't shrink when scrolling view content if Prefers Large Titles is set for the navigation controller's navigation bar, or is set on the storyboard. (33229609)

Workaround: Add the following to the root view controller’s awakeFromNib method:

self.navigationController?.navigationBar.prefersLargeTitles = false

self.navigationController?.navigationBar.prefersLargeTitles = true

self.navigationController.navigationBar.prefersLargeTitles = NO;

self.navigationController.navigationBar.prefersLargeTitles = YES;

Interface Builder no longer compiles for targets targeting iOS 6 or earlier. Opening an Interface Builder document with an older deployment target converts them to iOS 7 and later. (28726486)

Added support to XLIFF for exporting and importing stringsdict files, including support for using the correct per-language plural variants. (16785521)

Added support for XLIFF export of encodings other than UTF-8. (18944510)

Xcode no longer exports localizations for test targets that don't contain their own localized resources. (16813531)

Exporting a localization that contains a localized resource that is a duplicated in more than one target no longer results in an error. The duplicated resource is exported only once. (19059103)

Xcode now uses \n and \t to represent newline and tab characters in generated strings files. (22981479)

Strings files with line endings other than the standard linefeed character now work correctly for both import and export. (30552675)

Added Main Thread Checker, a new runtime tool that finds calls to APIs in AppKit, UIKit, and WebKit that must be made from the main thread, but are made on other threads. These calls are reported as runtime issues. Main Thread Checker is automatically enabled during debugging and can be disabled in the Diagnostics tab of the Scheme editor. (29951764)

macOS playground execution may hang in the Running state with no results produced. This is more prevalent when changing pages. (32429211)

Workaround: Stop playground execution and rerun. If issue persists, close and reopen Xcode.

The liveTouchBar property of PlaygroundSupport is not supported. (31073754)

Groups in the Project Navigator are now more closely associated with directories in the file system. (28612132)

• Dragging files between groups in the Project Navigator moves the files in the filesystem and updates any associated SCM working copies.

• When a group is connected to folder in the filesystem, creating, renaming, and deleting groups updates the corresponding files and folders in the the filesystem.

• To remove a connection between a group and a folder in the filesystem, select the group, and then open the File inspector and click on the on the Clear path button (X).

• To add or update an association from a file or a folder in the filesystem to a file or a group in the project, select the file or group, open the File inspector, and drag the corresponding file or folder onto the Location section in the File inspector.

Renaming files no longer results in the error alert The file has been saved by another application. (31968242)

Dragging a file into a project from the Finder may move or copy the file in the Finder. (31042020)

Workaround: Create a reference to the file by Command-Option dragging the file into the project.

Adding protocol stubs by applying the Fix for “Do you want to add protocol stubs?” may not insert all the parts of a complex protocol such as Swift.Collection. (31078629)

Workaround: Use the Fix button and then add any missing protocol stubs.

Constructors for locally defined types, such as a structure defined inside a function body, cannot be refactored. (31695776)

When extracting a code snippet that uses a locally defined type the extracted function may use that locally defined type as a parameter, resulting in code that does not compile. An example of a locally defined type, is an enumeration defined in a function body. (32288968)

Renaming does not affect symbols found inside macro expansions. (31989492)

Renaming Swift enumeration cases with associated values doesn't rename their argument labels. (32126363)

Renaming a Swift class or protocol exported to Objective-C doesn't rename any references that use a forward @class declaration in a source file that doesn't include the generated MODULE-Swift.h header. (32275117)

Workaround: #include the generated MODULE-Swift.h header in your .m file.

Renaming a call or reference to a member-wise initializer does not rename the corresponding member properties. (32383812)

Workaround: Manually rename member properties from their definition or references.

Undo does not work while renaming. (32429491)

Workaround: Manually edit the new name, or use Cancel.

Revised the distribution workflows. (29054761)

When a new distribution signing certificate is required, Xcode prompts for permission. Signing certificates can be exported for sharing with other team members. Revoking distribution signing certificates is no longer supported by the distribution workflow. Specifying a team is no longer required when the app is signed when the archive is built.

Added manual signing support to the Xcode distribution methods. You can now specify manual signing assets when exporting or uploading your app. Profiles that are created manually are not modified by Xcode or xcodebuild.

In Xcode, exporting an app now exports a distribution summary property list file, a packaging log, and an export options property list file. The distribution summary property list file describes the content of the exported app, including signature information, symbol and bitcode settings, and the embedded content. The package log contains all of the commands used to transform the archived application into a distributable packaged app.

The export options property list file includes all of the choices made during the distribution workflow and can be passed to xcodebuild using the -exportOptionsPlist flag. The property list file includes new properties (signingStyle, signingCertificate, and provisioningProfiles) for specifying manual signing. See xcodebuild -help for the full list of supported ExportOptions keys.

Added support for automatic signing to xcodebuild using the -allowProvisioningUpdates and -allowProvisioningDeviceRegistration flags.

Added development and distribution signing flows to continuous integration. Bots can development-sign apps to run on multiple connected devices. For automatic signing, bots can register connected devices and update Xcode-managed profiles but not create distribution certificates.

Enabling code coverage for the Test action of a scheme also enables it for the Run action. This results in saving the build intermediates and products from both actions in the location used by the Run action. (32079317)

Added a Strip Swift Symbols option that controls stripping Swift symbols from the Swift standard library. For more information, see New Features in Building and Linking and the Strip Swift symbols topic in Xcode Help. (31669406)

Added face-up and face-down orientations for supported devices. (11393667)

Updated Simulator to save screenshots to the system screenshot directory instead of always saving screenshots to the desktop. (26127809)

Added the ability to attach to a simulated device started from the command line and to close a simulated device window without shutting down simulator. To leave a device running, hold down the Control key when closing a window or quitting the app, and then click the Keep Running button in the dialog that appears. Select the checkbox to make this the default action when closing or quitting. (31004084)

Add a Share Extension for importing items into simulators:

• Photos and videos are imported into the photo library of a device.

• Locations or pins from Maps.app set the device’s simulated location.

• App bundles are installed.

• URLs are opened in Safari.

Choose All Simulators to install the item to all open simulators. (31150602)

Added support for selecting the macOS audio input and output device for each simulated device by using the Hardware > Audio Input and Hardware > Audio Output menus. To use the Mac input or output device selected in System Preferences, choose System from the menu.

Selecting Bluetooth headphones may decrease the audio quality by placing the headphones in call mode. If that occurs, select a different device. (32337249)

Added support for starting multiple simultaneous devices to Simulator and remove the separate Simulator (Watch) app. (5687722)

Added a bezel to simulated devices. The buttons on the bezel send the appropriate event to the simulated device. The bezel supports moving the simulated device window and device gestures originating at the edge of the screen. Clicking and dragging away from the simulated screen moves the the window. Moving towards the simulated screen performs a gesture. (14020158, 31558767, 32061265, 32118310)

Added redirection of keyboard shortcuts to a simulated device. Choose Hardware > Keyboard> Send Menu Keyboard Shortcuts to toggle sending shortcuts to the frontmost device. The setting can be different for each device. For more information, choose Help > Simulator Help and navigate to Interact with devices > Redirect keyboard shortcuts. (31990219)

Updated Simulator runtimes for iOS 11 and later, tvOS 11 and later, and watchOS 4 and later to treat the filesystem as case sensitive to better simulate physical device behavior. (18609452)

Updated Simulator to enforce background execution policies to more closely match physical devices. A backgrounded app is scheduled for execution only if it has appropriate UIBackgroundTasks, has a plist background mode, or receives a notification. (16532261)

Simulator captures the output from a Siri remote paired with your Mac when there is at least one simulated Apple TV device. When the frontmost simulated device is an Apple TV, the output from the Siri remote is directed to the device, otherwise the output is ignored. Quitting Simulator returns control of the Siri remote to the Mac. (29960775)

When launching Simulator, if an older version of Simulator is currently running, the older version hands off any running simulated devices to the newer version and then quits. (32384840)

Running several simulators simultaneously may exceed the maximum number of processes or maximum open file limits. When this happens starting a new process, opening a new simulated device, or opening a file results in an error. Closing one or more simulated devices or closing open programs may resolve the issue.

macOS 10.13 and later automatically scales these limits based on available system memory. The limits are fixed values on earlier versions of macOS. The limits can be increased by using launchctl. For more information, choose Help > Simulator Help and navigate to Troubleshoot Simulator > Insufficient resources. (31179087)

Launching many simulated devices in rapid succession may prevent new process from spawning by using all the system resources. There may be no warning when this occurs. (31723508)

Workaround: Close Simulator windows or quit Simulator to shutdown devices for immediate recovery. Do not Force Quit Simulator as that does not shutdown the devices. For more information, choose Help > Simulator Help and navigate to Troubleshoot Simulator > Insufficient resources.

Reducing the size of an iPhone X simulated device by dragging the bezel may trigger an edge swipe instead of resizing the device. (33974533)

Workaround: Start by increasing the window size, and then decreasing to the desired size.

Choosing Window -> Scale -> Actual Size for a simulated iPhone X doesn't set the size correctly. (33908038)

Workaround: Manually resize the window to the correct size.

Using xcrun simctl uninstall to uninstall an app in Simulator results in a failure and hangs Simulator. (30586964)

Workaround: Use xcrun simctl erase to reset the device to its initial state, or delete the app from the device’s home screen in Simulator.

When using AVPlayerViewController in an iPhone X simulated device, video may appear outside of the safe area and be obscured by the sensor housing or rounded corners. (34339660)

The Source Control pane in Preferences now supports configuring Git author information, Git ignore file lists, and SVN ignore file lists. (10544339)

Updated the Accounts pane in Preferences to support integration with GitHub. As part of this update, repositories added in previous versions of Xcode are no longer available. Use Source Control > Clone to access a repository. Repositories for GitHub and GitHub Enterprise accounts registered in Xcode appear in the clone window. Other repositories can be accessed by entering the repository URL. (30191709)

Added support for configuring two-factor authentication and an SSH key to GitHub accounts to the Accounts pane in preferences. The credentials are used when performing source control operations. (28775680)

Added a Clone window that integrates directly with GitHub to show you the favorite, private, personal and organizational repositories for all of your accounts. Each repository, shows the metadata, project readme, and an option to create a local clone of the repository. (30960520)

Added a new Source Control navigator for viewing the working copies in the project or workspace. The navigator lists branches, tags, and remotes as well as push and pull counts. (29054970)

The contextual menu in the navigator includes the ability to:

• Create branches and tags.

• Configure remotes.

• Checkout a revision number.

• Merge changes between branches.

Added a history editor for viewing the full history of a branch or tag. Each commit includes the author, commit comments, and any branches or tags that are part of the commit. Clicking on a branch or tag in the Source Control navigator to show the history. (29054970)

Added a review files editor to show the changes made to the files in a commit. (29054970)

Added a Source Control inspector to show more details of a commit. (29054970)

Updated Xcode to fetch remote tracking branches automatically, mark updated files in the project navigator, and show push and pull counts in the Source Control navigator. (31839384)

github.com added support for one-click clone to Xcode from a repository in a web browser. (32294826)

When performing certain source control operations, such as a pull, the latest updates may not appear in the history view. (33919644)

Workaround: With the history view open, choose the Editor > Refresh History.

Removing the keychain credentials for a GitHub account added in Xcode using a tool other than Xcode prevents Xcode showing an authentication error. (33898250)

Workaround: Delete the GitHub account in Xcode and then add it.

Subversion integration will be deprecated in a future release. (33041914)

Command-plus (+) and Command-minus (-) now increase and decrease the size of the font in the source editor. (21423189)

Typing a opening delimiter in selected text adds a matching closing delimiter at the end of the selection. Auto-matched delimiters include double-quotes ("), parenthesis ("(" and ")"), square brackets ([ and ]), and braces ({ and }). (29164633)

The comment and uncomment functionality now works correctly with languages that support nesting block comments, such as Swift, and with others that don't, such as C. This results in more accurate commenting and uncommenting. (32193940)

Using VoiceOver to drag a connection from Interface Builder to the source editor sometimes fails to create the connection. (33198923)

Workaround: Declare the IBAction or IBOutlet in the source editor, and then drag the connection from the source editor to Interface Builder.

Updated Xcode to support both Swift 4.0 and Swift 3.2. The language mode is controlled by the Swift Language Version build setting. These two language modes are implemented using the same compiler and standard library, which enables linking targets using Swift 3 with targets using Swift 4 so that, in most cases, migration from Swift 3.2 to Swift 4 can be done on a target-by-target basis.

Although Swift 3.2 and Swift 4.0 are intended to be compatible, the differences in how they access Cocoa and Cocoa Touch APIs can lead to inconsistencies, which may limit how a library built with one version can be used by a client target built with the other. The most common issue is a member being absent from a type; in certain situations the client may be forbidden from subclassing certain classes or adopting certain protocols.

Swift 3.2 and Swift 4.0 do not support linking with targets compiled with versions of Swift earlier than 3.2.

As usual, if the compiler or SourceKit crashes, please file a bug report with your project and sources attached. If you are mixing Swift 3 and Swift 4 in your project, please mention that in the description of the issue. (31104045)

It is now an error to perform a second access to a variable while it is being modified. Such accesses lead to code that is hard both for programmers and the compiler to understand. In general, you need to rearrange your code (for example, by making a local copy) to prevent conflicting accesses.

For example, the following code attempts to read from the variable array while the sort() method is mutating it.

var array: [Int] = ...

array.sort { $0 < array[0] }  // Error

This rule is enforced by a combination of compile-time and run-time checks.

Static checks are used for most local variables, constants, and parameters. In Swift 4 mode, static failures are compile-time errors. In Swift 3 mode, static failures are a warning, but this will be strengthened to an error in a future release of Swift, so you should fix these warnings.

Dynamic checks are used for global variables, static type properties, class instance properties, and local variables that have been captured in an @escaping closure. In Swift 4 mode, failing a dynamic check causes a trap at runtime, much like integer overflow does. In Swift 3 mode, failing a dynamic check causes a warning to be printed to stderr.

The compile-time and runtime checks enforce the rule for accesses that occur within the same thread. Thread Sanitizer can catch most (but not all) violations that occur from different threads.

The common idiom of exchanging two elements of a collection using swap violates this rule. To support this pattern, there is now a swapAt(_:_:) method on all mutable collections. (SE–0176)

In Swift 4.0, extensions that are in the same file and that extend the same type share an access control scope. If the type that they extend is also in the same file, they share its access control scope. This means that private members declared in the type’s declaration can be accessed from extensions, and private members declared in one extension can be accessed from other extensions and from the type’s declaration. (SE–0169)

You can now write multiline string literals. A """ followed by a new line starts the literal, and a """ on a new line ends it. Every line after the initial quote must start with the same whitespace as the closing quote, which will be stripped out on compilation. (SE–0168)

SQLite APIs can now be imported into Swift under the module name SQLite3. (18640410)

In Swift 4.0, if an Objective-C class has a designated initializer that can’t be imported into Swift, any Swift subclasses of that class will not inherit any convenience initializers. (31563662)

All Core Foundation types implicitly conform to the Equatable and Hashable protocols in Swift 3.2 and 4.0. (SR–2388)

If you were previously adding these conformances in an extension, conditionalize the extension by using the following pattern:

#if swift(>=3.2)

   // Equatable and Hashable are provided by Swift.

#else

   extension TheCFTypeICareAbout: Hashable {

      static func ==(left: TheCFTypeICareAbout, right:

         TheCFTypeICareAbout) -> Bool {

            return CFEqual(left, right)

         }

         var hashValue: Int {

            return CFHash(self)

         }

      }

#endif

Subscript declarations can now be defined to have generic parameter lists. (SE–0148)

extension MyContainer {

   subscript<T: MyKeyConvertible>(key: T) { ... }

}

Protocol composition types can now contain one or more class type terms, forming a class-constrained protocol composition. (SE–0156)

protocol Paintable {

   func paint()

}

class Canvas {

   var origin: CGPoint

}

class Wall : Canvas, Paintable {

   func paint() { ... }

}

func render(_: Canvas & Paintable) { ... }

render(Wall())

Class-constrained protocol compositions can be written and used in both Swift 3 and Swift 4 mode.

Generated headers for Swift APIs map class-constrained protocol compositions to Objective-C protocol-qualified class types in both Swift 3 and Swift 4 mode — for example, NSSomeClass & SomeProtocol & OtherProtocol in Swift becomes NSSomeClass <SomeProtocol, OtherProtocol> in Objective-C. Similarly UIViewController<UITableViewDataSource, UITableViewDelegate> in Objective-C becomes UIViewController & UITableViewDataSource & UITableViewDelegate in Swift.

Objective-C APIs that use protocol-qualified class types differ in behavior when imported by a module compiled in Swift 3 mode and Swift 4 mode. In Swift 3 mode, these APIs will continue to import as protocol compositions without a class constraint — for example SomeProtocol & OtherProtocol. In Swift 4 mode, protocol-qualified class types import as class-constrained protocol compositions, for a more accurate mapping of APIs from Objective-C to Swift.

The current implementation of class-constrained protocol compositions lacks three features outlined in the Swift evolution proposal:

• In the evolution proposal, a class-constrained protocol composition is permitted to contain two different classes as long as one is a superclass of the other. The current implementation only allows multiple classes to appear in the composition if they are identical.

• In the evolution proposal, associated type and class inheritance clauses are generalized to allow class-constrained protocol compositions. The current implementation does not allow this.

• In the evolution proposal, protocol inheritance clauses are allowed to contain a class, placing a requirement that all conforming types are a subclass of the given class. The current implementation does not allow this.

These missing aspects of the proposal can be introduced in a future release without breaking source compatibility with existing code.

A new family of integer protocols enables more generic algorithms:

• Numeric, types that support arithmetic operators

• BinaryInteger, integer types that have a binary representation and support bitwise operations

• FixedWidthInteger, integer types that use a fixed size and support the concept of arithmetic operations that report overflow

Heterogeneous comparisons are now allowed, eliminating the need for numericCast(_:) in comparisons. For example, (42 as UInt) > (0 as Int) works.

With the introduction of smart shifts, it’s possible to shift a value by a negative amount, or to shift by a value of a different integer type without calling numericCast(_:). The result type is the type of the shifted value.

toIntMax() and init(_:IntMax) have been deprecated – numericCast converts directly between different integer types without going through the maximum width integer. (SE–0104)

Sequence has an associated type Element that is equivalent to Iterator.Element. The value of this associated type can be inferred from existing Sequence conformance. Code that already declares a type of Element may need to be altered to resolve conflicts. (32186094)

Slicing a raw buffer no longer results in the same raw buffer type. Specifically, UnsafeBufferPointer.SubSequence now has type RandomAccessSlice<UnsafeRawBufferPointer> with the same changes for the mutable version. Therefore, indexing into a raw buffer slice is no longer zero-based. This is required for raw buffers to fully conform to generic Collection. (SE–0138)

Passing a region within a buffer to another function that takes a buffer can no longer be done via subscript. This now requires explicit initialization, using a rebasing: initializer, which converts from a slice to a zero-based Unsafe[Mutable]RawBufferPointer:

takesRawBuffer(buffer[i..<j])  // Incorrect

takesRawBuffer(UnsafeRawBufferPointer(rebasing: buffer[i..<j]))  // Correct

Subscript assignment can no longer be done directly from a buffer. This now requires creation of a slice from the complete source buffer:

buffer[n..<m] = smaller_buffer  // Incorrect

buffer[n..<m] = smaller_buffer.[0...]  // Correct

The slice type of UnsafeRawBufferPointer no longer has a nonmutating subscript setter. So assigning into a mutable let buffer no longer compiles. The assigned buffer slice now needs to be a var.

// Incorrect

let slice = buffer[n..<m]

slice[i..<j] = buffer[k..<l]

// Correct

var slice = buffer[n..<m]

slice[i..<j] = buffer[k..<l]

A dictionary can be created from a sequence of keys and values, and can merge keys and values into an existing dictionary. (SE–0165)

let asciiTable = Dictionary(uniqueKeysWithValues: zip("abcdefghijklmnopqrstuvwxyz", 97...))

// ["w": 119, "n": 110, "u": 117, "v": 118, "x": 120, "q": 113, ...]

let vegetables = ["tomato", "carrot", "onion", "onion", "carrot", "onion"]

var vegetableCounts = Dictionary(zip(vegetables, repeatElement(1, count: Int.max)), uniquingKeysWith: +)

vegetableCounts.merge([("tomato", 1)], uniquingKeysWith: +)

// ["tomato": 2, "carrot": 2, "onion": 3]

Filtering a set of a dictionary produces a result with the same type as the receiver. To transform the values of a dictionary, keeping the same keys, use the mapValues(_:) method. (SE–0165)

let vowels: Set<Character> = ["a", "e", "i", "o", "u"]

let asciiVowels = asciiTable.filter({ vowels.contains($0.key) })

asciiVowels["a"]  // 97

asciiVowels["b"]  // nil

let asciiHexTable = asciiTable.mapValues({ "0x" + String($0, radix: 16) })

// ["w": "0x77", "n": "0x6e", "u": "0x75", "v": "0x76",  "x": "0x78", ...]

When using a key as a dictionary subscript, a default value to be returned can be supplied if the key is not present in the dictionary. (SE–0165)

for veg in ["tomato", "cauliflower"] {

    vegetableCounts[veg, default: 0] += 1

}

// ["tomato": 3, "carrot": 2, "onion": 3, "cauliflower": 1]

Added an init(grouping:by:) initializer to Dictionary that converts an array or other sequence into a dictionary, grouped by a particular trait. (SE–0165)

let buttons = ...  // an array of button instances

let buttonsByStatus = Dictionary(grouping: buttons, by: { $0.isEnabled })

// How many buttons are enabled?

print("Enabled:", buttonsByStatus[true]?.count ?? 0)

Dictionary and Set have a visible capacity property and a reserveCapacity(_:) method similar to Array, and a dictionary’s keys and values properties are represented by specialized collections. (SE–0165)

Added a new Substring type to Swift 4 that is returned when slicing a String. (SE-0163)

In Swift 3.2, slicing a String continues to return a String, but you can provide type context to get a Substring — for example, myString[i...] as Substring.

Substring presents an almost-identical API as that of String. A new protocol, StringProtocol, is available to write generic code that applies to either String or Substring.

String now conforms to BidirectionalCollection and RangeReplaceableCollection. (SE-0163)

A new RangeExpression protocol is now used to unify all range types (such as CountableRange and ClosedRange), and new one-sided ranges (such as PartialRangeUpTo) have been added. (SE-0172)

Any type that conforms to RangeExpression can now be used to slice a collection.

let numbers = [10, 20, 30, 40, 50, 60]

if let i = numbers.index(of: 40) {

    print(numbers[..<i])

}

// Prints "[10, 20, 30]"

Countable partial ranges can be used as sequences.

let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

let asciiTable = zip(65..., alphabet)

for (code, letter) in asciiTable {

    print(code, letter)

}

// "65 A"

// "66 B"

// "67 C"

// ...

// "89 Y"

// "90 Z"

NSNumber is stricter about the result of bridging some of its values to corresponding Swift value types.

Specifically, using an as? cast returns nil if the value stored by NSNumber does not fit into the requested Swift value type. For example, NSNumber(2) as? Bool returns nil, but NSNumber(1) as? Bool returns true.

To ignore this behavior and force a cast, use the appropriate conversion method on NSNumber instead. For example, myNumber.boolValue. (SE–0170)

The archival and serialization API is built in to Swift, with a focus on type-safe conversions from external formats directly into native Swift types, and interoperability with common formats like JSON and property list. The Encodable and Decodable protocols (along with Codable, which implies both), allow types to participate in encoding and decoding mechanisms. (SE–0166)

Many of the basic data types conform to Codable. Custom data types whose members all conform to Codable can use a compiler-generated implementation of these protocols by declaring protocol conformance.

public struct Person: Codable {

    let name: String

    let email: String

}

Updated Encoder and Decoder for type-safe conversion to and from the JSON and property list formats. Combined with the default Codable implementation, many types can natively convert to and from these formats, with no additional encoding or decoding work. (SE–0167)

import Foundation

let johnny = Person(name: "Johnny Appleseed", email: "johnny_appleseed@apple.com")

let encoder = JSONEncoder()

let data = try encoder.encode(johnny)

// data is {"name": "Johnny Appleseed", "email": "johnny_appleseed@apple.com"}

let decoder = JSONDecoder()

let person = try decoder.decode(Person.self, from: data)

print(person.name)

// Prints "Johnny Appleseed"

Swift 4 adds support for type-safe key path literals. They are formed using syntax that looks like this: \BaseType.propertyName. The backslash is important: it disambiguates between a key path to a property, and simply accessing the property. When the base type can be inferred, it can be elided producing expressions that look like: \.propertyName. Key path expressions produce instances from the hierarchy of KeyPath types listed below, where BaseType is the dynamic type of the base, and PropertyType the type of named property:

• KeyPath<BaseType, PropertyType> – readonly key path

• WritableKeyPath<BaseType, PropertyType> – read/write key path that can mutate a value type directly, similar to inout and mutating

• ReferenceWritablePath<BaseType, PropertyType> – read/write key path that can mutate reference types

These new key paths exist alongside the existing string #keyPath expressions introduced last year. #keyPath remains available for use with legacy String-based API. (SE–0161)

In Swift 4 mode, the type system properly distinguishes between functions that take one tuple argument, and functions that take multiple arguments. ([SE-0110])

In Swift 4 mode, a declaration is inferred to be @objc where it is required for semantic consistency of the programming model. Specifically, it is inferred in the following cases:

• The declaration is an override of an @objc declaration

• The declaration satisfies a requirement in an @objc protocol

• The declaration has one of the following attributes: @IBAction, @IBOutlet, @IBInspectable, @GKInspectable, or @NSManaged

Additionally, in Swift 4 mode, dynamic declarations that don’t have @objc inferred based on the rules above will need to be explicitly marked @objc. Swift 3.2 retains the more permissive Swift 3 rules for inference of @objc within subclasses of NSObject. However, the compiler emits warnings about places where the Objective-C entry points for these inference cases are used, such as in a #selector or #keyPath expression, via messaging through AnyObject, or direct uses in Objective-C code within a mixed Swift and Objective-C project. The warnings can be silenced by adding an explicit @objc. Uses of these entry points that are not statically visible to the compiler can be diagnosed at runtime by setting the environment variable SWIFT_DEBUG_IMPLICIT_OBJC_ENTRYPOINT to a value between 1 and 3, and then testing the application. (SE–0160)

The Swift compiler diagnoses attempts to use NSCoding with a class that doesn’t have a simple Objective-C runtime name. The names of these classes may be affected by unrelated changes. For example, the runtime name of a private class depends on the name of the containing source file. Alternatively, use the @objc attribute to explicitly specify a runtime name. If you archive the class under its current “mangled” name, the compiler provides a fix-it to use it. (32314195)

Protocols and associated types can now contain where clauses that provide additional restrictions on associated types. (SE–0142)

protocol StringRepresentable: RawRepresentable where RawValue == String {}

protocol RawStringWrapper {

    associatedtype Wrapped: RawRepresentable where Wrapper.RawValue == String

}

The Swift compiler now lazily and implicitly imports outer modules when importing a submodule after Swift finishes parsing the bridging header. This is a behavior change from previous releases where the import happened eagerly. As a result, some bridging headers that might have relied on the eager implicit import (such as by directly using a type defined in the outer module) will no longer compile; they will need to either forward-declare such definitions or explicitly import the outer module. (30615193)

In order for default argument expressions to be inlined into the caller in a future version of Swift, they must not reference any declarations that have less access than the enclosing function. (32189807)

// Before

private func computeTheBestInteger() -> Int {

    return 4

}

public func useAnInteger(_ x: Int = computeTheBestInteger().absoluteValue) {

    print(x)

}

There are multiple ways to modify existing code to satisfy this condition:

• Change the non-public reference to be public.

  public func computeTheBestInteger() -> Int {

  return 4

  }

  public func useAnInteger(_ x: Int = computeTheBestInteger().absoluteValue) {

  print(x)

  }

• Add a helper function.

  private func computeTheBestInteger() -> Int {

  return 4

  }

  public func defaultXForUseAnInteger() -> Int {

  return computeTheBestInteger().absoluteValue

  }

  public func useAnInteger(_ x: Int = computeTheBestInteger().absoluteValue) {

  print(x)

  }

• Use a sentinel value.

  private func computeTheBestInteger() -> Int {

  return 4

  }

  public func useAnInteger(_ xOrNil: Int? = nil) {

  let x = xOrNil ?? (computeTheBestInteger().absoluteValue)

  print(x)

  }

The compiler can now warn about individual expressions that take a long time to type check.

To enable this warning, go the Build Settings, Swift Compiler - Custom Flags, Other Swift Flags, and add the -Xfrontend -warn-long-expression-type-checking=<limit> flag, where <limit> is the lower limit of the number of milliseconds that an expression must take to type check in order for the warning to be emitted.

This allows users to identify those expressions that are contributing significantly to build times and rework them by splitting them up or adding type annotations to attempt to reduce the time spent on those expressions. (32619658)

Swift integer values can be used as an index in a bridged NSDictionary with NSNumber keys. (SR–3172)

When assigning nil to a lazy property with an ImplicitlyUnwrappedOptional type, the value is correctly set to nil. (32778003)

Covariant method overrides in classes are now fully supported, fixing many crashes and compile-time assertions when defining or calling such methods. (SR–1529)

class Bed {}

class Nook: Bed {}

class Cat<T> {

    func eat(snack: T) {}

    func play(game: String) {}

    func sleep(where: Nook) {}

}

class Dog: Cat<(Int, Int)> {

    // 'T' becomes concrete

    override func eat(snack: (Int, Int)) {}

    // 'game' becomes optional

    override func play(game: String?) {}

    // 'where' becomes a superclass

    override func sleep(where: Bed) {}

}

When the Precompile Bridging Header build setting is on, some configurations of headers in Framework targets can cause the compiler to mistakenly read a header twice, both as part of a module and as an independent, non-modular header. This can lead to warnings about duplicate Objective-C definitions, and ultimately compilation failures or compiler crashes due to incorrect cross-references between Swift module files. (33837253)

Workaround: Change the Precompile Bridging Header build setting to No for the affected target.

If a Swift class uses a type that is newer than its deployment target in a method exposed to Objective-C, the generated MyApp-Swift.h header will have warnings in it about the type being “partial,” due to the Swift compiler not including availability information. (33313703)

Workaround: Turn off the -Wunguarded-availability-new warning whenever the generated header is included.

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wunguarded-availability-new"

#include "MyApp-Swift.h"

#pragma clang diagnostic pop

The Swift compiler doesn't produce warnings when a method in a subclass is intended to match an optional method in a protocol adopted by the superclass. For example, if the superclass conforms to UITableViewDelegate, and the subclass declares a method incorrectly named tableView(_:editingStyleForRowAtIndexPath:) instead of tableView(_:editingStyleForRowAt:), the compiler will not warn about it. Additionally, if Swift 3 style inference of @objc is turned off the method will not be called at run time. Make sure to check any such methods carefully. (30489065, SR–3943)

When the Precompile Bridging Header build setting is on, the Swift compiler will no longer automatically read a module map file that is in the same directory as the bridging header. This may lead to errors of the form module ‘TheModule’ not found. (32810754)

Workaround: If reading a module map from this directory is needed, add it as an explicit search path under the User Header Search Paths build setting.

Attempting to use the Accelerate framework from Swift may generate linker errors about missing simd symbols such as error: Couldn't lookup symbols: __T04simd6float4VN (32457742)

Workaround: Add import simd to the Swift file.

Image literals result in an immediate run-time exit when used outside the main application target. (26873717)

Workaround: Continue using NSImage or UIImage APIs to create images in non-application targets.

The package manifest API used in a package's Package.swift file has been improved. Create a new package or use the package manager command swift package tools-version --set-current to opt into the new API. Packages can still use the previous manifest format. (SE–0158, SR-3949)

Added support for custom directory layouts for the source files in a package. Each target in a package can specify the path of the directory that contains the source files for that target. (SE–0162, SR–29)

Changed the default linking for C targets to static linking. Linking options are controlled in the package manifest by passing the .static or .dynamic case when specifying the type of a library product. (29730882)

Added support for a package to explicitly declare the products that the package vends to clients. Previously, the products were inferred based on the targets in the package. (SE–0146, SR–3606)

Updated the error messages for many package manager issues to be clearer and more informative. (29772725)

Updated the swift package edit command to detect dependency resolution errors before making changes by resolving package dependencies before placing the package into edit mode. (29772779)

Package dependencies can now refer to a branch name instead of a tagged version. Use a named branch as a package dependency only when the package is closely coupled with all of its clients. Tagged versions of a package must not depend on any branches. (SE–0150, SR–666)

Added the --path option to the swift package edit command to support "top-of-tree" development of a related set of packages by suspending the automatic checkout management of the remote package. This enables iterating on a package and several of its dependencies without having to commit and tag those changes to see the holistic result. (SE–0149, SR–3709)

Changed the --branch option of the swift package edit command to be optional. If no branch is provided, the Git repository is put into a "detached HEAD" state. (30120243)

A package can declare the required minimum version of the Swift tools needed to use the package. (SE–0152)

Building a package on macOS only requires that the Command Line Developer Tools are installed. Previously, Xcode needed to be installed. Running unit tests still requires Xcode. (30813768)

Updated Xcode projects generated by the package manager to use stable and readable object identifiers for objects such as targets, allowing Xcode schemes to continue referencing the same objects even when the project is regenerated with modified contents. (31019219)

Updated the error message for unsatisfiable package dependencies to explain the dependency requirements that are in conflict. (SR–4072, SR–4237)

Updated package manifest interpretation and package builds on macOS to use a sandbox, which prevents network access and file system modification. This helps mitigate the effect of maliciously crafted manifests. (31107213)

Updated newly cloned package dependencies on macOS to use read-only file permissions, reducing the risk of unintentional changes. When a package is put into edit mode, write permission is added for the files in that package. (31286403)

Updated the support of custom directory layouts on Linux by searching for LinuxMain.swift in all directory hierarchies contain a test target directory. The search continues to the package root directory. (31585721)

Updated dependency resolution by replacing the Package.pins file with the new Package.resolved file. The new file contains resolved dependency versions enabling dependency re-resolution to occur automatically in more cases. Commit the file with the package to use the new method of dependency resolution. In addition, the resolve command for swift package replaces the fetch command. (SE–0175)

Added a prerelease semantic versioning component to package version tags. (SR–1039)

Package dependencies are now cloned in parallel by default. (32286386)

Added the cLanguageStandard and cxxLanguageStandard properties to packages for specifying which language standard to use when compiling C and C++ targets. (SE–0181)

Code completion now works when editing the Package.swift manifest in an Xcode project generated from a Swift package. (33284557)

Creating static executables using the new option --static-swift-stdlib does not function correctly. (33861492)

Workaround: Build the package using the following command: swift build -Xswiftc -static-stdlib.

Changed NSFastEnumerationIterator from a class to a struct. Existing code that works directly with NSFastEnumerationIterator may have to switch to using a var instead of a let. (30905263)

Swift apps that transitively import the ModelIO framework but that do not use it will launch correctly on OS versions that do not contain the framework. (33471433)

The following AVFoundation APIs are temporarily unavailable (34378539):

• AVCaptureDevice.Format.supportedColorSpaces

• AVCaptureDevice.supportedFlashModes

• AVCapturePhotoOutput.availablePhotoPixelFormatTypes

• AVCapturePhotoOutput.availableRawPhotoPixelFormatTypes

• AVCapturePhotoSettings.availablePreviewPhotoPixelFormatTypes

Some APIs have changed to accept [NSAttributeKey: Any] dictionaries instead of [String: Any], such as NSString.size(withAttributes:) and NSString.draw(at:withAttributes:). These changes may produce errors after migration is completed. (32431618)

Workaround: Change the type to match the expected parameters in the variable declaration.

When a Dictionary that has an NSAttributedStringKey as key uses a String as an index, the compiler may return an error of the form: error: ambiguous reference to member 'subscript'. (32432013)

Workaround: Wrap the key object with NSAttributedStringKey(rawValue: ... )

The migrator does not properly handle cases where an API changes nullability and the right side of an if let statement becomes non-optional. This will produce errors such as: error: initializer for conditional binding must have Optional type, not '<TYPE>'. (32476453)

Workaround: Change the if let statement to make it an assignment with let instead.

Updated template macro expansion for new files. Improvements include:

• Added FILEHEADER, a new macro for the content of a standard file header comment.

• The contents of a macros can be defined using other macros. For example, the FILEHEADER macro is defined using other macros such as FILENAME and COPYRIGHT, and COPYRIGHT is defined using ORGANIZATIONNAME and YEAR.

• Macro expansions can include modifiers.

• It is possible override the default macros and to provide custom ones.

For more information, choose Help > Xcode Help and navigate to Appendixes > Text Macros. (5775785)

xcodebuild no longer launches Simulator when running tests. (27385435)

Added a teardown block API to XCTest for cleaning up the test state after it completes. (28097197)

Added an API to XCTest to wait on for an XCUIElement to exist before proceeding. (28483267)

Added support to XCTest for targeting multiple applications in a single UI test. This includes monitoring application state and making a backgrounded application the frontmost application. (28948745)

XCTest types that are closely associated with a particular class such as XCUIElement.Type are available as nested types in Swift 4. (29000570)

Added XCTActivity, a new API for grouping UI test activity together in test reports and logging. (30401267)

Added XCTAttachment, a new API for bundling diagnostic test resources, such as rich logging, with your test results. (30478677)

xcodebuild tests on multiple destinations simultaneously by default. Use the -disable-concurrent-testing command line argument to disable concurrent testing. (31964004)

Updated the save format for automatic captured screenshots to JPG. (32719585)

Added new APIs to XCTest for managing screenshots including scheme-level configuration options for disabling automatic screenshots, and for capturing screenshots of partial, individual or multiple displays. (21327915)

Updated UI testing to support targeting LSUIElements-based applications. (21344280)

Increased the performance of UI testing when the application is built and installed by Xcode. Also added firstMatch for restricting query execution in UI tests. (29544176, 22980005)

Added language and region specific configuration for tests the Xcode schemes. (28897796)

NSUInteger in XCTest APIs is imported into Swift 4 as Int rather than UInt, bringing it into alignment with other system frameworks. (29589664)

A test assertion during a UI test always results in XCTest capturing a screenshot. (28853076)

Xcode does not show correct file and line information for some test failures when the tests are run in the Simulator. (33810627)

xcodebuild test can intermittently fail with errors. (32881403, 32836473, 29122169, 32354498, 32852527).

The errors include:

• Launch session expired before checking in

• Early unexpected exit, operation never finished bootstrapping - no restart will be attempted

• App accessibility isn't loaded

• Domain=XCTestManagerErrorDomain Code=12 "Failed to get main window after 30 retries"

• Error Domain=DTServiceHubClient Code=–11 "unable to contact local DTServiceHub to bless simulator connection"

• Test runner failed to initialize for UI testing but did not provide any additional details

Workaround: Try running the test again.

When running a parallel test on macOS High Sierra, xcodebuild test can sometimes become unresponsive. (33206730)

Workaround: Cancel the test using Control-C and retry the test. Alternatively, disable parallel testing by using the -disable-concurrent-testing flag.

testmanagerd exiting unexpectedly with an error of Assertion failed: (staticHeader.header_magic == DTX_MESSAGE_MAGIC) results in a running xcodebuild test failing. (33470538)

Workaround: Try the test again.

Updated Thread Sanitizer to catch higher-level races on Objective-C and Swift collections, such as writing to a mutable array from different threads without using proper synchronization. (26798589)

Updated Thread Sanitizer to catch more cross-thread violations of the Swift rule that requires exclusive access to memory. For example, when multiple threads call mutating methods on the same structure without synchronization. (30455576)

The new build system no longer runs a shell script build phase with the legacy COMMAND_MODE. This results in utility programs, such as echo, conforming to Version 3 of the Single UNIX Specification. (33875525)

Added Undefined Behavior Sanitizer, a new low overhead runtime tool that finds several types of undefined behavior in C languages, such as integer overflows, invalid casts, and alignment violations. Undefined Behavior Sanitizer is enabled in the Diagnostics tab of the Scheme editor and is compatible with all other sanitizers. (15425728)

Added optional detection of nullability annotation violations at runtime. The feature is enabled in the Undefined Behavior Sanitizer section of Build Settings by setting Enable Nullability Annotation Checks to Yes. (30619298)

Added support for running tests in parallel on multiple devices and simulators to Xcode Server and xcodebuild. Bots can be configured to enable or disable parallel testing on devices and default to parallel testing. The output produced by xcodebuild when running tests in parallel has been updated and any automated tooling relying on the format of the output may need to be updated. (14254639)

Added support for automatic and manual provisioning configurations. Servers can be added from the updated bot editor by an agent or admin of the developer team. A scheme that requires manually specified certificates or profiles can shared with the server from the new Signing tab in the bot editor. (15437174)

Updated Xcode Server to support configuring additional arguments that are passed to xcodebuild when integrations are run. (23578597)

Added two-factor authentication to Xcode server. This can be used when joining your server to your development team, and eliminates the need for an app-specific password. (27002415)

Added sending an “all clear” email notification when all issues that are tracked by a bot have been resolved. (26179348)

Xcode Server no longer requires the macOS Server app. Configure your server and bots in the Server & Bots tab of Xcode Preferences. (28211693)

Updated bots to run tests in a specific language and region. (30382604)

Updated bot configuration to include an optional Export Options Plist that is to configure the export of an installable product from an archive. (31895193)

Copy, paste, and cmd+F now work as expected in the logs tab of an integration report. (14140192)

Xcode Server logs now support copy and paste. (26605066)

When an upgrade integration runs after installing a new version of Xcode, Xcode Server correctly indicates any changes in SDK versions. (30983641)

Testing on networked devices using Xcode Server doesn't work when Xcode Server is initialized with a different build service user account. (33904987)

Workaround: Select the main user account for the build service user when initializing Xcode Server.

Removing Server.app after configuring Xcode Server with Xcode 9 will stop the Xcode Server service. (31820819)

Workaround: Do not remove Server.app, or after removing start Xcode Server again from the Server & Bots preference pane or using the xcscontrol command-line tool.

Attempting to edit an Xcode Server bot may incorrectly display the error does not match this workspace even when it does. (31957021)

Workaround: Dismiss the dialog.

Screenshots may not always be captured during UI testing when Xcode Server is configured to perform integrations using a background user account. (34213968)

Xcode Server no longer includes hosting Git repositories. To continue using repositories that were set up in macOS Server, configure a new remote Git server and push your code to that remote. After upgrading to Xcode 9, any existing repositories are archived in /Library/Developer/XcodeServer/HostedRepositories. (31243129)

Added a 3GB memory class for graphics configurations to Asset Catalog. (30814729)

Fixed issues with Xcode Server that caused excessive CPU usage. (31874759)

Fixed issue with Xcode Server so that a bot can switch back to a previously used branch. (31721307)

Fixed an issue where valid C++ code involving a nested struct, enum, or lambda would fail to compile in C++1z mode. (31385254)

Xcode no longer produces an Update Signing report for targets that use manual signing. (31276851)

Fixed an issue preventing output without newlines from being printed in the Xcode Debug Console until there is more output. This issue prevented interactive programs from working with the Xcode Debug console, causing prompts to appear only after a user entered text with a newline. (31465525)

Interface Builder documents for iOS that contain a color based on an image pattern no longer result in a compiler error. Image pattern colors are not supported, and are now always converted to black when compiled. (31342191)

Fixed an issue that caused text to be hidden in Interface Builder documents that use a System size font. (31503323)

Fixed an issue preventing user interaction events being sent from inside the live view of an iOS playground that is running on a device with a non-Retina display, or on a device with a connected non-Retina display. (31445684)

Resolves an issue where variables in entitlements files were always expanded using the Debug build configuration instead of the active build configuration. (31456053)

Xcode now schedules Swift whole-module optimization jobs in parallel, enabling better utilization of multiple cores for building projects. (31478013)

Fixed an issue where the Swift 3 Migrator would not apply compiler fix-it items. (30984612)

Fixed an issue that could produce app archives that were larger than necessary. Support for app archives built in Xcode 8.3 will be deprecated. (31302382)

Intents Extensions are available on watchOS. (28372004)

Fixed a problem which would cause Xcode to crash when removing certain file or framework references from certain projects. (29118448)

Fixed an issue which caused the “update to recommended settings” warning to remain after updating to the recommended settings. (28447448)

The Apple LLVM compiler now supports nullability annotations on function and method parameters with an array type, and provides additional warnings for incomplete and suspicious nullability annotations. (25846421)

The compiler properly completes type information for forward-declared classes from C++ precompiled headers. (30173654)

When building a framework that has module maps in both the source and the install directories that define the same module, the compiler will show a redefinition message. (28638816)

Workaround: Rename the module map file in the source directory to a non-default name (the default name is module.modulemap or module.map), and set the Module Map File build setting to the renamed module map.

Scheme pre-action and post-action scripts now set the environment variable TARGET_DEVICE_IDENTIFIER to the UDID of the selected run destination device. (28078704)

Using xcodebuild -exportLocalizations or xcodebuild -importLocalization to export or import localizations from a project, no longer hangs after the operation is complete. (25857436)

When copying files the build system now preserves the extended attributes (xattrs) used by codesign for signing standalone files. (29453501)

The Mac will no longer sleep when a build is in progress. (29256278)

Xcode no longer crashes when the build system copies a file with an invalid code signature. (29656173)

Changes to xcconfig files no longer require restarting Xcode to take effect. (29805284)

Build issues from targets that are implicit dependencies of the active scheme are now shown in the issue navigator. (28719580)

xcodebuild no longer hangs when invoked with a project or workspace containing no schemes. (20450296)

After opening a project, an Update Signing report may be visible in the Reports Navigator for targets that use manual signing. No signing certificates, app IDs, or provisioning profiles are modified when this occurs. (31209546)

In the data model editor, changes to an entity’s Code Generation, Compound Indexes, and Uniqueness Constraints are now undoable and autosaved. (21205277)

When manually generating code for Core Data entities, generated Objective-C code properly uses «ClassName»+CoreDataClass.h rather than just ClassName.h in #import directives. (30343106)

Passing -showBuildSettings to xcodebuild for a project containing a Core Data model should no longer result in xcodebuild hanging. (26749142)

The view debugger now shows creation backtraces for many objects in the Object inspector. To show the backtraces, enable Malloc with the option “All Allocation and Free History” logging in the Diagnostics tab of the Manage Schemes dialog. (28715704)

Autocompletion is supported in Breakpoint navigator text fields. Completions for a file breakpoint are generated using information in the referenced file. Other breakpoint completions use general indexing information and may be slower. (28268983)

The Scheme editor now contains a text field to add an Intents Extension query instead of issuing an utterance vocally. (26456789)

Added the ability to visually debug the view hierarchy of an iOS iMessage extension running on iOS 10.3 or later. (28838632)

LLDB no longer hangs or prints incorrect values when evaluating Swift enumerations defined as an indirect enum. (29953436)

Running a watchOS Intents extension will automatically trigger Siri for a voice command. (29714417)

Activity and trace messages normally visible in LLDB thread summaries and thread detailed information are available when debugging processes running on beta versions of macOS, iOS, tvOS, or watchOS. (26370425)

When debugging a watchOS Intent extension using Watch Simulator, the session can end after about 30 seconds with the error message “Program ended with exit code: 0”. (30923914)

Workaround: In the iPhone simulator, open Settings > Siri > App Support and disable Siri for app.

The first time you run a Complication from Xcode in Simulator it may continually exit when you configure that Complication. (29858029)

Workaround: Re-run the scheme from Xcode.

Debugged processes may hang on launch if the console option for the scheme is set to “Use Terminal”. (29760580)

Workaround: Select “Use Xcode” for the console option of the scheme.

The FileMerge application now uses the same text infrastructure as Xcode. File navigation and syntax coloring are more consistent with Xcode. (8838481)

Updated the Instruments user interface. (28503173)

Inspector Refresh

Instruments previously contained three inspector panes: Record Settings, Display Settings, and Extended Detail. There are now two inspector panes: Extended Detail and Run Info. Extended Detail remains unchanged and continues to provide additional information about selected data in the detail pane. The new Run Info inspector pane displays information about the currently selected run, including the recording device information and recording settings when the run was taken.

Record Settings are now located in a Recording Options window. To display this window, choose File > Recording Options, press Option-Command-R, or click-and-hold the Record button in the toolbar and choose Recording Options from the menu that appears. The Recording Options window includes global and instrument-specific recording options.

The Display Settings inspector pane was previously used to change the graphing style of the timeline pane and to perform filtering in the detail pane. These features have been moved to new locations. If an instrument supports multiple graphing options, a down arrow now appears beside the instrument's icon when the pointer is positioned above the instrument in the timeline pane. Click the instrument's icon to open a popover containing editable graphing options. The down arrow appears only for instruments that have graphing options. Detail pane filtering options, including the text filter field previously located in the navigation bar of the detail pane, are now found at the bottom of the detail pane.

Visual Run Comparison

The ability to view graphs for multiple runs at the same time in the timeline pane has been removed. To switch between runs, choose Previous Run or Next Run from the Instruments menu, or click a navigation arrow in the activity viewer in the toolbar.

For more information, see Instruments Help. Open help by choosing Help > Instruments Help.

Interface Builder supports setting adjustsFontForContentSizeCategory to automatically adjust the size of text as the Dynamic Type setting changes. (25543597)

NSTextField objects created in Interface Builder now have allowsCharacterPickerTouchBarItem turned off by default. (29223278)

Auto layout issue buttons in the Interface Builder document outline are no longer clipped under the right margin. (14485840)

Swift @IBOutlet declarations that have a nullability type annotation are now detected. (29983196)

Setting an NSMenuItem's identifier in Interface Builder is supported on macOS 10.12 and higher. (23945473)

An NSDatePicker now uses NSDate instead of NSCalendarDate when added from the object library. (29639832)

Adding a UILabel to a tvOS Interface Builder document now uses the correct default font, UIFontTextStyleHeadline. (24172228)

Typing in the Model Key Path field for a Cocoa binding no longer hangs Xcode. (26487347)

The top of the library content no longer gets shifted under the header bar, which previously resulted in clipping. (27601428)

Connecting @IBAction methods from Interface Builder to Swift code now works when the sender parameter type is Any. (29639217)

Using NSColorPickerTouchBarItem in Interface Builder no longer creates a Touch Bar item that is disabled at runtime. (28670596)

Fixed a bug that prevented setting inspector checkboxes that correspond to bitmask properties, such as NSWindow.styleMask, UIAccessibility.accessibilityTraits, and UIPopoverPresentationController.permittedArrowDirections. (26613034)

Update frames for views with constraints now works with ambiguous views that have an unambiguous horizontal or vertical axis. (16019988)

Option for “Follow Readable Width” has been restored to the view controller Size inspector. (28246180)

Incremental Link-Time Optimization works properly with bitcode-enabled apps. (30109087)

Improved overall incremental Link-Time Optimization performance, including fixing an issue that was creating duplicate cache files. (29526668)

The Xcode Organizer now supports exporting tvOS apps for Enterprise distribution. (30000839)

Speed improvements have been made to the Organizer window. Opening the Organizer with many Archives and many iTunes Connect Products should open quickly. (28722427)

Under some configurations, iOS and tvOS Playgrounds may hang with no indication of completion. (30085996)

Workaround: If this occurs, rerun the Playground.

Xcode may crash while you are interacting with a playground's Project Navigator. (29741774)

Fixed an issue which caused Xcode to warn about Swift 2.3 deprecation even when the "Use Legacy Swift Language Version" setting is set to NO. (29655628)

Changed the user interface for managing signing certificates and provisioning profiles. Certificates are managed from the Accounts preferences pane by selecting a team and clicking Manage Certificates. Automatically managing signing is recommended, however if your app requires manually signing provisioning profiles are managed in the General tab of the project editor. Use the Provisioning Profile dropdown to import or download profiles. In addition it displays profiles that match the current signing configuration of the target. For more information, see Xcode Help. (28641027)

The simctl get_app_container command can now return the path of an app's data container or App Group containers. (30224453)

The simctl tool of the xcrun command line tool has two new commands that provide additional information for filing bug reports.

• simctl logverbose enables verbose logging on the specified device.

• simctl diagnose collects all relevant Simulator logs on the host and on the device, and then packages them into an archive that can be attached to bug reports.

For more information, see the help for each command by running xcrun simctl <tool name> help on the command line. (21001891)

You can invoke Siri using Hardware > Siri after enabling Siri in the Settings app on Simulator. (25176537)

Resolved an issue where Siri on a simulated watchOS device did not respond the first time Siri was enabled on a simulated iOS device. (29708878)

Launching an application or executing tests should no longer generate "Application <bundle> is installing or uninstalling, and cannot be launched" errors in Simulator. (30172453)

Videos recorded by the simctl tool of the xcrun command line tool now support scrubbing and import into video editors correctly. (29654098)

Recording a video with the simctl command line tool requires Metal-capable hardware. (29688949)

AVAssetExportSession may not return any presets on the iPad Pro (12.9 inch) Simulator. (30698677)

Workaround: Use a different Simulator.

Xcode Source Editor Extensions will now assert if you try to create a command with an identifier containing invalid characters (characters outside the range 0-9, A-Z, a-z, -, or .). (26615933)

Added a check for synthesized copy properties of mutable types, such as NSMutableArray. Calling the setter for these properties will store an immutable copy of the value. (21022397)

Added a check for calls to dispatch_once() that use an Objective-C instance variable as the predicate. Using an instance variable as a predicate may result in the passed-in block being executed multiple times or not at all. These calls should be rewritten to use either a lock, or to store the predicate in a global or static variable. (23390767)

Added a check for unintended comparisons between scalar values and NSNumber, CFNumberRef, and other number objects. (10228523)

Swift now warns when an NSObject subclass attempts to override the initialize class method, because Swift can't guarantee that the Objective-C method will be called. (28954946)

C functions that "return twice" are no longer imported into Swift and attempting to reference such a function will result in a compilation error.

Examples of functions that "return twice" include vfork and setjmp. These functions change the control flow of a program in ways that that are not supported in Swift. For example, definitive initialization of variables, a core Swift language feature, can not be guaranteed when these functions are used. Although this could be considered a source-breaking change, it's important to note that any use of these functions will most likely crash at runtime. (SR-2394)

Indirect fields from C structures and unions are now always imported. Previously they weren't imported when they belonged to a union. This is done by naming anonymous fields, for example:

typedef struct foo_t {

   union {

      int a;

      double b;

   };

} foo_t;

Is imported as:

struct foo_t {

   struct __Unnamed_union___Anonymous_field0 {

      var a : Int { get set }

      var b : Double { get set }

   }

   var __Anonymous_field0 : foo_t.__Unnamed_union___Anonymous_field0

   // a and b are computed properties accessing the content of __Anonymous_field0

   var a : Int { get set }

   var b : Double { get set }

}

Since new symbols are exposed from imported structure/unions, this may conflict with existing code that extended C types in order to provide their own accessors to the indirect fields. (30221279, PR-6531, PR-6816)

Swift REPL and interpreted scripts correctly determine the version of the OS that they are running on. (29433205)

#keyPath respects the original name of properties imported from Objective-C. (28543037)

The generated header for a mixed-source Swift target will now correctly reference Dispatch framework types using the usual typedefs (dispatch_queue_t) rather than their implementation details. (29790636)

Properties that satisfy requirements in Objective-C protocols work properly when they are declared with a willSet or didSet observing accessor. (30101703)

The LLVM and Swift compilers now emit correct diagnostics when using a custom module map that contains system headers. Examples include a module map with paths into the macOS SDK while building for iOS, or headers from /usr/include. (26866326)

The Swift compiler now raises an error when a let property or a variable of a protocol type is modified after initialization. Code that successfully compiled in previous releases may fail after upgrading. For example, the following code that compiled in previous versions now raises an error:

protocol P {

   mutating func f()

}

extension Int: P {

   mutating func f() { self += 1 }

}

func foo(x: Int) {

   let y: P

   y = x

   y.f()

}

(29716016)

Swift 3.1 includes a new warning of the form "implicit import of bridging header … via module … is deprecated and will be removed in a later version of Swift". This warning is no longer reported too frequently in contexts where it may not be easy to correct. (30202509)

Extending the Sequence or Collection protocols to add a typealias named Element can result in the Swift compiler crashing. More generally, this issue can occur when name collisions are encountered among type aliases within nested associated types. (30702721)

Workaround: Use a different name for the typealias, or write the type out explicitly, such as Iterator.Element.

AppKit's NSView.animator() method claims to return the Self type but really returns a proxy object. When called on a Swift subclass, this may lead to runtime crashes when trying to reference animatable properties of the view that were overridden in Swift:

public class MyView: NSView {

   public override var frame: NSRect {

      didSet {

         Swift.print(self.frame)

      }

   }

let view = MyView()

// The following line crashes

view.animator().frame = NSMakeRect(0.0, 0.0, 120.0, 120.0)

(27655718)

Workaround: Cast the result of view.animator() to AnyObject, then do method dispatch on the AnyObject value to ensure that the animator proxy is invoked with Objective-C messaging instead of Swift messaging. For example:

(view.animator() as AnyObject).setFrame(NSMakeRect(0.0, 0.0, 120.0, 120.0))

The Swift compiler may crash when an Objective-C category extends a system class, and that category adopts a protocol requiring a method matching the getter or setter of a property that is declared using @property.

For example, the MyLengthModifying protocol includes a method that matches the setter for the length property, and the protocol is part of the MyAdditions category extension to the NSMutableData system class:

@protocol MyLengthModifying

   - (void)setLength:(NSUInteger)length;

@end

@interface NSMutableData (MyAdditions) <MyLengthModifying>

@end

(SR-4022)

Workaround: Use a @property in your protocol instead of a method, even if the only important requirement is the setter.

withoutActuallyEscaping will fail to compile when given an @autoclosure argument. (SR-4188)

Workaround: Pass the autoclosure down to another function as a regular closure argument. For example:

func allValues(in array: [Int], smallerThan: @autoclosure () -> Int) -> Bool {

   func allValuesImpl(in array: [Int], smallerThan: () -> Int) -> Bool {

      return withoutActuallyEscaping(smallerThan) {

         escapableF in array.lazy.filter {$0 >= escapableF() }.isEmpty

      }

   }

   return allValuesImpl(in: array, smallerThan: smallerThan)

}

A new family of failable conversion initializers to all numeric types either completes successfully without loss of information, or returns nil. (SE-0080)

Extended the @available attribute to include varying API availability by Swift language version. An annotated API is compiled as usual and added to the library, but is made available only to a client built with a matching compiler version or a matching -swift-version when built for version compatibility. (SE-0141, SR-2709)

The Sequence protocol adds two new members, prefix(while:) and drop(while:). prefix(while:) requests the longest subsequence satisfying a predicate. drop(while:) requests the remaining subsequence after dropping the longest subsequence satisfying a predicate. (SE-0045)

Constrained extensions allow same-type constraints between generic parameters and concrete types. For example, the following code defines an extension on Array with Int elements:

extension Array where Element == Int { }

(SR-1009)

Nested types may now appear inside generic types, and nested types may have their own generic parameters:

struct OuterNonGeneric {

   struct InnerGeneric<T> {}

}

struct OuterGeneric<T> {

   struct InnerNonGeneric {}

   struct InnerGeneric<T> {}

}

extension OuterNonGeneric.InnerGeneric {}

extension OuterGeneric.InnerNonGeneric {}

extension OuterGeneric.InnerGeneric {}

(SR-1446)

The Swift compiler no longer incorrectly reports a version of Swift 3.0. (30081411)

String interpolations that do not use fully qualified names when referencing members of type extensions can fail in this release. This includes cases that worked in Swift 3. (30885036)

Workaround: Use a fully qualified name. For example, the following code worked in Swift 3, but results an error of “error: expression type 'String' is ambiguous without more context” in the current version:

extension Bool {

   static let yes = true

}

print("\(.yes)")

To fix the error use the fully qualified name in the print statement:

print("\(Bool.yes)")

The package manager no longer uses the auto-linking feature of module maps for C language targets. Packages which use custom module maps for their C language targets should remove the link statement from the module map. The package manager will automatically add the link flag if required.

For example, the following custom module map:

module MyCLib {

   header "foo.h"

   link "MyCLib"

   export *

}

Should be changed to:

module MyCLib {

   header "foo.h"

   export *

}

(30016942)

The Swift Package Manager now supports an edit mode for a package's dependencies. Putting a dependency in edit mode moves it from the managed dependency location to a local Packages directory and omits it from swift package update and related commands. This allows the user to manually manage checkout of the dependency, for example by committing fixes that are required only locally. By default, dependencies are no longer stored in the Packages directory unless they are in edit mode. A package can be put in edit mode with the swift package edit command, and can leave edit mode with the swift package unedit command. (SE-0082)

The Swift Package Manager now supports pinning a dependency to a specific version so that in a clean build, it resolves only to the pinned version. The swift build command will automatically record the version that is used for every dependency in a Package.pins file, unless autopinning is disabled with swift package pin --disable-autopin. Commit the Package.pins file to source control when you expect your package to use specific dependency versions without requiring those versions in your Package.swift manifest. The Package.pins file is used during initial dependency resolution to determine which dependency versions to use; swift package update will update all dependency versions and repin those dependencies to the new versions. If autopinning is off, pass the --repin flag to swift package update to override any manually-pinned versions. Pinning can be further controlled with the swift package pin and swift package unpin commands. (SE-0145)

Replaced the swift package clean=dist command with swift package reset which resets a package back to a clean state, with no dependencies checked out or build artifacts present. (28384606)

The swift package test command has a new --parallel option which executes tests in parallel. This mode of testing may cause problems for tests which are not written to be able to safely run in parallel. (28402178)

When a dependency of a package is in edit mode, operations which trigger dependency resolution, such as swift package update, will fail. (29944464)

Rebuilding a package in Swift Package Manager now avoids performing unnecessary work. (28037508)

swift package update incrementally updates dependencies instead of re-cloning them from the beginning. In addition, complex dependencies are resolved correctly. (26371453)

Added the XCUISiriService class to XCTest used for writing tests which activate Siri with a voice recognition string, and for queries for elements in the Siri UI. Use the class to write UI tests for Intents and Intents UI extensions. (29958123)

Added XCUIKeyModifierCapsLock as a preferred alternative for XCUIKeyModifierAlphaShift. This is consistent with the addition of NSEventModifierFlagCapsLock in macOS 10.12, as a preferred alternative for NSAlphaShiftKeyMask. (27375799)

XCTest adds new APIs to simplify writing asynchronous tests.

• A new class, XCTWaiter, is used to wait for an XCTestExpectation object independent of any XCTestCase instance, making it possible to wait inside helper functions and to test support libraries.

• New subclasses of XCTestExpectation are used for tests that wait for NSNotifications, Key Value Observation, NSPredicate evaluations, and Darwin notifications.

• XCTestExpectation has a new writable description property to simplify failure diagnosis in asynchronous tests.

• XCTestExpectation adds two new behaviors. Set .inverted to true to fail if the expectation is fulfilled. Set .expectedFulfillmentCount to specify the required number of calls to fulfill().

See documentation in XCTWaiter.h, XCTestExpectation.h, XCTNSPredicateExpectation.h, XCTNSNotificationExpectation.h, XCTKVOExpectation.h, and XCTDarwinNotificationExpectation.h for more details. (22539853)

The Test navigator now includes test classes and methods located in static libraries that are linked into test bundles. Note that it may be necessary to activate the test navigator before test diamonds for these tests appear in the source editor. (28173131)

Fixed a bug in the handling of XCTestExpectations that waited on predicates evaluated against XCUIElements. As a result, some tests which were previously succeeding despite ambiguous (incorrect) queries will start to fail. For instance, if your UI test now fails because of "Multiple matches found" and the element in question is the subject of a predicate expectation earlier in the test, your test is failing because of this fix and the element query will need to be updated to correct the ambiguity that is leading to multiple matches. (28139563)

Profile-Guided Optimization does not work when using the Test action. (30769613)

Fixed an issue that could cause building a project to fail with the error message “"Use Legacy Swift Language Version" (SWIFT_VERSION) is required to be configured correctly for targets which use Swift” when using a supported version of Swift. (29667880)

Xcode no longer warns about using deprecated Swift 2.3 code when the active scheme does not reference targets using Swift 2.3 code. (29671741)

"Convert to Current Swift Syntax" only converts targets referenced by the active scheme. (13997108)

Xcode 8.2 offers more Touch Bar actions and allows customizing the Touch Bar controls of the following editors and debuggers: source editor, Playground editor, Interface Builder, view debugger, and memory graph debugger. To customize the Touch Bar, open the desired editor and then choose View > Customize Touch Bar. (28462580)

Touch Bar API is available for macOS 10.12.2 or later. (28785230, 28785231)

Builds of iOS, tvOS, and watchOS targets may hang during CompileAssetCatalog, CompileStoryboard, or CompileXIB when running on OS X El Capitan. (28422833)

Workaround: Rebuild the target.

Using .xcconfig files will not cause projects to prompt about changes on disk when switching git branches. (28794807)

Command Line Tools (OS X 10.11) for Xcode 8.2 are available and support Swift 3.0 development from the command line on OS X El Capitan. (28234439)

Opening a data model with a minimum tools version earlier than Xcode 8.0 will not reset the code generation language to Objective-C. (29032095)

The Memory Debugger for macOS and the iOS Simulator fixes reporting of false memory leaks for Swift classes containing either fields of type enum, or classes that inherit from certain Objective-C framework classes. (27932061)

False reporting can still occur for iOS, watchOS, and tvOS applications. See (29335813) in Known Issues, below.

The Memory Debugger for iOS, watchOS, and tvOS applications can report false memory leaks when debugging Swift classes containing either fields of type enum, or classes that inherit from certain Objective-C framework classes. (29335813)

A UITabBarController correctly displays content instead of blue boxes. (27881406)

Fixed a crash on macOS 10.12 when a P3 color space other than the system default is installed. (26178719)

The supportsPressAndHold property works when using popover Touch Bar items from Interface Builder. (28701667)

Dragging an app onto a Simulator window installs the app. (23387069)

You can take videos and screenshots of Simulator using the xcrun Xcode command-line utility. To take a screenshot, run the command xcrun simctl io booted screenshot. To take a video, run the command xcrun simctl io booted recordVideo <filename>.<file extension>. (9887264)

Dragging a Live Photo resource into the Simulator imports the Live Photo instead of importing a photo and a video. (27906875)

Simulator renders the screen correctly when using iOS 9.1 or earlier. (27996364)

Keychain APIs work correctly in Simulator. (28338972)

Simulator can crash when saving a screenshot when running on OS X El Capitan. (29182710)

The crash does not occur on macOS Sierra.

Extensions which make imported Objective-C generic classes conform to protocols defined in Swift are compiled correctly. (28873860)

Objective-C generic types show as defined in generated headers with a suffix of -Swift.h. (28738008)

Type inference will properly unwrap optionals when used with generics and implicitly-unwrapped optionals. (28621624)

NSFileManager's enumerate(at:includingPropertiesForKeys:options:errorHandler:) method passes valid URLs to the error handler in code compiled with Swift 3.0.2.

There may still be some Objective-C methods in the SDKs that incorrectly annotate or assume a type to be nonnull rather than nullable. If the type is one that Swift treats as a struct, such as NSURL (Foundation.URL) or NSDate (Foundation.Date), this can lead to a run-time crash in a method with a name like bridgeFromObjectiveC; in other cases, it can lead to crashes or undefined behavior in user code. If you identify such a method, please file a report at bugreport.apple.com. For reference, the (now unnecessary) workaround for the newly-fixed NSFileManager API is shown below; it can be adapted for whichever API you want to call.

static inline NSDirectoryEnumerator<NSURL *> * _Nullable

fileManagerEnumeratorAtURL(NSFileManager *fileManager, NSURL * _Nonnull url,

                           NSArray<NSURLResourceKey> * _Nullable keys,

                           NSDirectoryEnumerationOptions options,

                           BOOL (^ _Nullable errorHandler)

                           (NSURL * _Nullable errorURL, NSError * _Nonnull error)) {

                                return [fileManager enumeratorAtURL:url

                                         includingPropertiesForKeys:keys

                                                            options:options

                           errorHandler:^(NSURL * _Nonnull errorURL, NSError * _Nonnull error) {

                               return errorHandler(errorURL, error);

                           }];

}

This function can be included in your bridging header (for an app or test target) or umbrella header (for a framework target). (27749845)

The Swift compiler may crash if a nested computed get-only property is defined and accessed within a generic function, a method of a protocol extension, or a method of a generic type. (28933116)

For example:

protocol Runcible {}

extension Runcible {

   func runce() -> Int {

      // Property definition crashes the compiler

      var localProperty: Int {

         print(self)

         return 0

      }

      return localProperty

   }

}

Workaround: Redefine the property as a nested function or provide a setter.

The Swift compiler may crash when an array of tuples is converted to add or remove element labels. (28425149)

For example:

typealias Foo = (x: Int, y: Int)

let foos = [(0, 0), (1, 1)] // has inferred type [(Int, Int)]

func getFoos() -> [Foo] {

   // Attempts implicit conversion from [(Int, Int)] to [(x: Int, y: Int)]

   return foos

}

Workaround: Avoid mixing array types of labeled tuples with arrays of unlabeled tuples.

The Swift compiler may crash if a method of a nested type refers to a nested function in the same scope. (28015090)

For example:

do {

   func foo() {}

   class Bar {

      init() {

         //the following line crashes the compiler

         foo()

      }

   }

}

Workaround: Move the function to the top level to avoid the crash.

For example, the following code shows the workaround for the example given above:

// Move the function to the top level

func foo() {}

do {

   class Bar {

      init() {

         foo()

      }

   }

}

When an NSDictionary is bridged into Swift as a Dictionary with AnyHashable keys, then using Swift integer values to index the dictionary may fail to find objects inside the dictionary. (29026017)

For example:

NSDictionary *makeDict() {

   return @{@(NSOrderedAscending): @"ascending"};

}

let dict = makeDict()

// Fails to find key in dictionary

dict[NSComparisonResult.orderedAscending.rawValue]

Workaround: Explicitly construct an NSNumber instance for the dictionary lookup key.

For example, the following code shows the workaround for the example given above:

dict[NSNumber(value: NSComparisonResult.orderedAscending.rawValue)]

Xcode 8.2 is the last release that will support Swift 2.3. Please migrate your projects to Swift 2.3 code to Swift 3 syntax by opening the project and choosing Edit > Convert > To Current Swift Syntax.

The Touch Bar simulator window can interfere with mouse events during macOS UI tests.

Workaround: As a temporary workaround, set the IDETestingDisableTouchBarSimulatorWindowBehavior user default to a YES to prevent the window from appearing during testing. (28531281, 28802822)

1. Quit Xcode if it's running.

2. Open the Terminal and enter the following command:

   defaults write com.apple.dt.xcode IDETestingDisableTouchBarSimulatorWindowBehavior -bool YES

Xcode 8.1 supports Touch Bar for Macs that include it, and supports adding Touch Bar functionality to your app. (28859277)

Before using Touch Bar functionality in your app, confirm that the app is running on a macOS version that includes support for Touch Bar using a runtime check.

• For example, the following Objective-C code performs a runtime check to make sure NSTouchBar is available:

  NSClassFromString(@"NSTouchBar") != nil

• In Swift code, do an availability check for macOS 10.12.1, and a runtime check for Touch Bar class availability. For example:

  NSClassFromString("NSTouchBar") != nil

When an Xcode project is stored in iCloud Drive, Xcode does not automatically detect iCloud Drive sync conflicts for projects or for files involved in the build. Note that the Documents and Desktop folders can be stored in iCloud Drive on macOS 10.12. (18161353)

Opening Xcode projects and workspaces stored in iCloud Drive, or changing source control branches for an open workspace or project stored in iCloud Drive, may sometimes cause Xcode to hang. Note that in macOS 10.12, your Documents and Desktop folders may optionally be iCloud Drive locations. (28212905)

OS X 10.11 was the last major release of macOS that supported the previously deprecated garbage collection runtime. Applications or features that depend upon garbage collection may not function properly or will not launch in macOS Sierra. Developers should use Automatic Reference Counting (ARC) or manual retain/release for memory management instead. (20589595)

The simctllaunch subcommand in xcrun now supports directing the app’s standard out and standard error to a file or to the local terminal. (27636817)

There is no Command Line Tools (OS X 10.11) for Xcode 8.1 beta 2 package. Xcode 8.1 beta 2 contains SDKs that are incompatible with earlier toolchains. Developers who want to make use of the Xcode 8 beta 2 SDKs from the command line must choose the SDK with xcode-select. Developers on OS X El Capitan who have installed versions of the Command Line Tools (OS X 10.11) for Xcode 8.1 beta 2 should install Command Line Tools (OS X 10.11) for Xcode 7.3.1. (28234439)

Adding a new entity to an Xcode 8 or later Core Data model sets the entity name and the class name to the same value. Changing the entity name changes the class name, unless the class name is different than the entity name. (27896843)

When using Core Data automatic code generation, changes made to a data model are now available after the model is saved or autosaved. (25789848)

In the Core Data editor, setting the module of a Swift NSManagedObject subclass to Current Product Module can cause Swift code generation to use an incorrect filename for the generated code, and to generate an empty import statement for other NSManagedObject subclasses. (26898508)

As a workaround, set the contents of the Module field for the desired entity to the default value:

1. In the Core Data editor, highlight the contents of the Module field for the desired entity.

2. Press the Delete key.

   The Module field now shows the default value, "Global namespace," in light gray.

Starting with macOS Sierra 10.12.1, Xcode 8.1 is required to debug processes that call exec() on themselves. For earlier Xcode versions, re-attach the debugger to the target process after the exec()] call. (28476369)

The Xcode debug button in the Touch Bar can sometimes remain in the Control Strip after a debug session has ended resulting in a button with no icon. The debug icon will re-appear in the button when starting a new debug session. (28776047)

Anonymous closure arguments in Swift cannot be used in LLDB expressions. For example, po $0 is not supported.

The values can be inspected in the LLDB command frame variable in Xcode’s Variables View. For example, fr va $0 displays the current value of the first argument. (28611943)

A Top Shelf extension is not automatically triggered when you debug a tvOS app from Xcode. As a workaround, use the remote to select a different Top Shelf item and then go back to the one you want to debug. (26131040)

Evaluating expressions in the Xcode Debug Console attached to an Apple Watch can cause the process to be suspended. This occurs when debugging a Notification before the user interface is displayed, for example, during the -init method. As a workaround, manually launch the Watch app on the device to resume the process. To avoid suspending the process, you can use logging instead of a breakpoint. (27459900)

Xcode Debugger cannot debug apps written in Objective-C only but that link against frameworks written in Swift only. (28312362)

The first time you debug a Today extension on a device, it is not offered as an extension to run. As a workaround, stop the process, then run and debug it again. (26427188)

watchOS 1 apps may fail to finish launching on Apple Watch devices. (27724931)

Debugger() and DebugStr() are deprecated and the scheme editor no longer provides the option to enable these functions. If your project uses these functions, enable them by setting the environment variable USERBREAK with a value of 1. (24631170)

Quick Help shows “Symbol not found” message for Objective-C user defined symbols. (28061632)

Use HeaderDoc documentation tags to add Quick Help comments to your symbols. The following comment block shows the general format for documenting a method:

/**

   @method myMethod:withTwoParameters:

   @abstract A short description for the QuickHelp popover

   @description A longer description for the QuickHelp pane

   @param paramName1 A description of the parameter

   @param paramName2 Another parameter description

   @return Description for the return value

*/

The Automation instrument has been removed from Instruments. Use Xcode’s UI Testing instead. (26761665)

Added Custom Gesture Recognizer to the object library. Use it for custom subclasses of UIGestureRecognizer or NSGestureRecognizer instead of a plain NSObject. This resolves an issue where a combination of stock and custom gesture recognizers on a UIView fails to compile. (27838954)

There is a new Update Frames button at the bottom of the canvas. Click the button to update the frames of the selected objects and their children on the Interface Builder canvas. (27818991)

The Pin button at the bottom of the canvas has been renamed to Add New Constraints. (27819014)

Dragging content into static UITableView cell on the canvas works again. (28026179)

Fixed auto layout performance issue with NSStackView using Gravity Areas distribution. (27910320)

Xcode 8.0 did not always restore view frames from storyboards and xibs when layouts were ambiguous. Xcode 8.1 fixes several of these issues. If you have encountered these issues, resolve the ambiguity in the Auto Layout issues and update frames. Xcode 8.1 will persist them correctly. (28221021, 28244619)

Resolved a layout hang when selecting Landscape orientation in the Device Bar on non-Retina displays when running on OS X 10.11. (27251685)

Xcode Debug Console no longer shows extra logging from system frameworks when debugging applications in the Simulator. (26652255, 27331147)

When using Swift 2.3, creating IBAction connections no longer inserts WithSender in the selector name. (25220368)

supportsPressAndHold does not work when using popover Touch Bar items from Interface Builder. (28701667)

To work around this, add an outlet to the popover item in code and call popoverItem.pressAndHoldTouchBar = popoverItem.popoverTouchBar.

Using NSColorPickerTouchBarItem in Interface Builder results in a Touch Bar item that is disabled at runtime. (28670596)

To enable the Touch Bar at runtime, add an outlet to the color picker item in code and call colorPickerItem.isEnabled = true.

Using NSSharingServicePickerTouchBarItem in Interface Builder results in a disabled Touch Bar item with a blank image. (28716331)

To set the image and enable the service picker at runtime, add an outlet to the service picker and set the image by calling servicePicker.buttonImage = NSImage(named: NSImageNameTouchBarShareTemplate). Then enable the service picker by calling servicePicker.isEnabled = true.

Creating an IBAction connection by control-dragging when using Swift 2.3 incorrectly includes WithSender in the selector, causing the application to crash at runtime. WithSender is added when control-dragging from a .swift file to the Interface Builder canvas, or when control-dragging from the canvas to the document outline. As a workaround, create the action connection by dragging from Interface Builder to the Swift source, or use Find > Find and Replace to manually remove WithSender. (27410040)

Interface Builder does not show correct bar heights (status bar, top bar, bottom bar) when picking landscape for a device in the device configuration bar. (6799670)

Objective-C now supports ARC-style weak references in files using manual reference counting (MRC). This behavior must be manually enabled in your project settings. __weak was previously accepted and ignored in MRC files; to avoid silently changing the behavior of code, if weak references are not enabled, the compiler will now warn on such uses of __weak. (28694859)

Manual reference counting (MRC) weak references are fully supported on macOS 10.12 Sierra, iOS 10.0, watchOS 3.0, and tvOS 10.0.

MRC weak references are partially supported on macOS Lion 10.7 through macOS El Capitan 10.11, iOS 5.0 through 9.0, watchOS 1.0 and 2.0, and tvOS 9.0. These versions do not support runtime metadata for __weak instance variables in classes whose @implementation is defined in MRC. Also NSCopyObject() will not work, and direct access to ivars by Key-Value Coding and Interface Builder will not work. To work around this, use KVC and IBOutlet on accessor methods or properties. (9674298)

The “Use Asset Catalog…” button in the Project Editor’s General tab does not immediately refresh after selecting an asset catalog. To work around this, after selecting an asset catalog, navigate away from the General tab and then back. (26381374)

SceneKit views (SCNView) do not render in Quick Look inside the Xcode Debugger when the current camera (SCNCamera) uses new effects such as color grading, color fringe, or saturation and contrast. (27653505)

When manually signing, Xcode requires your provisioning profile to contain all entitlements used by your default build configuration’s entitlements file. (28377448)

Inspector tooltips in Interface Builder are not available. (26664452)

The Xcode automatic signing system may fail to sign your app if you add your account or change your password while your project is open. As a workaround, close and reopen the project. (25627172)

When opening a project, Xcode only migrates the deprecated PROVISIONING_PROFILE setting to PROVISIONING_PROFILE_SPECIFIER when the setting is empty. (26281413)

Downloading profiles using the Download All Profiles button intermittently skips some profiles. As a workaround, use the developer website to download any missing profiles. (26412212)

Xcode may require a watch paired to your phone to be registered on the developer website even when developing an iOS only app. As a workaround, turn off your watch while developing, or develop using a different phone. (26885780)

Free provisioning accounts may experience issues launching apps on the watch for the first time. As a workaround, launch the app manually on the device and click Trust when the security sheet appears. (26629630)

Messages extensions signed with a personal team may fail to run on a device. As a workaround, on the device, go to Settings > General > Profiles & Device Management, tap on the profile name that authorized the app, and tap Trust. (26359174)

Sticker Pack apps can be used in 32-bit simulators (iPhone 5, iPad Retina) in Xcode. (27830469)

Simulator no longer leaks memory when a simulated device is booted, rotated, or the scale is changed. (27673601)

The GameKit framework is missing from the SDK for the watchOS simulator. To work around this issue, develop for GameKit using a watchOS device which does include the framework. (27899791)

All connected host controllers are seen as the same controller for tvOS in Simulator. As a workaround, test multiple controller functionality on an AppleTV. (27511145)

There is no way to trigger Siri from Simulator even though Siri APIs are available in Simulator runtimes. Use an Apple TV to test usage of the Siri APIs. (25957692)

Keychain APIs may fail to work in the Simulator if your entitlements file doesn’t contain a value for the application-identifier entitlement. To work around this issue, add a user-defined build setting to your target named ENTITLEMENTS_REQUIRED and set the value to YES. This will cause Xcode to automatically insert an application-identifier entitlement when building. (28338972)

Xcode features provided via extensions now work more reliably. (28341722)

In Xcode 8.1, an XCSourceTextRange is half-open: It includes the character at the start position, and excludes the character at the end position. Previous versions of Xcode were inconsistent when translating from the internal format to an XCSourceTextRange instance. All Xcode Source Editor Extensions built against Xcode 8.0 will continue to get the previous inconsistent behavior for binary compatibility.

An Xcode Source Editor Extension built against Xcode 8.1 that also needs to run in Xcode 8.0 can check the version of Xcode by comparing XCXcodeKitVersionNumber against the version listed in XcodeKit/XcodeKitDefines.h. (28131743)

Xcode Source Editor extensions don’t support adding Objective-C categories to XcodeKit classes. (26432410)

When Optional values are bridged to Objective-C objects, such as when an Optional is passed to an Objective-C API that takes nonnull id or when a [T?] array is bridged to an NSArray, the Swift runtime will now bridge the wrapped value if there is one. If a nil value is bridged, and the API does not accept a nil pointer, Swift will use NSNull to represent the nil value. (SE-0140)

All of Swift's standard number types now bridge to Objective-C as NSNumber instances. Structs such as CGRect, for which the NSValue class provides factory methods, now bridge to Objective-C as NSValue instances. (SE-0139)

Two types have been added to the Swift standard library: UnsafeRawBufferPointer and UnsafeMutableRawBufferPointer. They represent a non-owning view over a fixed region of memory (a buffer). They expose the underlying buffer as a Collection of UInt8 bytes, independent of the type of values held in that memory. This helps developers migrate to the UnsafePointer changes in Swift 3.0. For background, see the UnsafeRawPointer Migration Guide. In some cases, UnsafeRawBufferPointer provides a safe replacement for UnsafeBufferPointer<UInt8>. This is particularly useful for code that works with binary file formats and streaming I/O.

A new withUnsafeBytes(of:) function exposes a value's in-memory representation as an UnsafeRawBufferPointer. This example copies a heterogenous struct into a homogeneous array of bytes:

struct Header {

   var x: Int

   var y: Float

}

var header = Header(x: 0, y: 0.0)

var byteBuffer = [UInt8]()

withUnsafeBytes(of: &header) {

   (bytes: UnsafeRawBufferPointer) in byteBuffer += bytes

}

A new Array.withUnsafeBytes method exposes an array's underlying buffer as an UnsafeRawBufferPointer. This example copies an array of integers into an array of bytes:

let intArray = [1, 2, 3]

var byteBuffer = [UInt8]()

intArray.withUnsafeBytes {

   (bytes: UnsafeRawBufferPointer) in byteBuffer += bytes

}

(SE-0138)

The macro __swift__ will be defined when importing C and Objective-C code into Swift. The value of this macro will have the form XYYZZ, where X is the major version of the language, YY is the minor version of the language (always two digits), and ZZ is the “patch” version (also two digits). For example, in Swift 3.0.1, __swift__ will have the value 30001. Note that this macro is not defined in the legacy Swift 2.3 compiler, nor was it defined in the initial release of Swift 3. (26921435)

An issue with @NSManaged properties being used to satisfy protocol requirements has been fixed. (SR-2673)

Linking LTO files compiled with Xcode 8 to LTO files compiled with a previous Xcode release will now work even if Objective-C class properties are in use. (28017126)

The C attribute swift_error(zero_result) is now handled correctly. (27985744)

Access checking for overrides and for members that satisfy protocol requirements has been fixed to more closely match the Swift language proposal that introduced private and fileprivate (SE-0025.) This resolves some crashes, but can result in errors for code that was accepted in Xcode 8.0. To keep Swift 3 code compatible with Xcode 8.0, use private for top-level classes and structs instead of fileprivate. (27820665)

Swift Evolution proposal SE-0107 states that UnsafePointer.withMemoryRebound(to:capacity:) should produce a const UnsafePointer, but in Swift 3.0 it produces an UnsafeMutablePointer. As a result, Swift 3.0 incorrectly accepts code in this form:

let ptr: UnsafePointer<Int>

ptr.withMemoryRebound(to: UInt.self, capacity: 1) {

   takesUInt($0) // this implicitly converts to a mutable pointer

}

For Swift 3.0.1, change the code to:

ptr.withMemoryRebound(to: UInt.self, capacity: 1) {

   takesUInt(UnsafeMutablePointer(mutating: $0))

}

(28409842)

Extensions which make imported Objective-C generic classes conform to a Swift protocol can be miscompiled. This can result in a runtime crash in objc_retain or objc_msgSend when a class method is called generically through the protocol. (28873860)

As a workaround, declare the protocol as @objc or wrap the class instance in a generic struct that implements the protocol.

When using generics and implicitly-unwrapped optionals, type inference can fail to unwrap the optional, leading to compiler errors for valid code. (28621624)

As a workaround, explicitly unwrap the optional. For example, in the following valid code, the compiler gives an error because u is implicitly-unwrapped in the return statement.

func compare<T: Comparable>(v: T, u: T!) -> Bool {

   return v < u

}

Work around the error by explicitly unwrapping u:

func compare<T: Comparable>(v: T, u: T!) -> Bool {

   return v < u!

}

Objective-C methods with empty selector pieces (i.e. a colon with no name before it) may cause the Swift 3 compiler to crash. As a workaround, rename the methods or remove them from the bridging header includes. If neither of those alternatives are possible, guard the method declaration. For example:

#if !defined(__swift__) || __swift__ > 30001

(28448188)

Lazy initialization using a constructor with defaulted parameters can fail with the message “type of expression is ambiguous without more context”. As a workaround, wrap the call to the constructor into a separate function if you want to use the defaulted parameters such as:

struct Value {

   init(first: Int, second: Int? = 10) {}

}

class Test {

   static func createValue(first: Int) -> Value {

      return Value(first: first)

   }

   lazy var theValue = createValue(first: 5)

}

Calling the constructor without any of the parameters defaulted works as well. (28313602)

Some Objective-C methods in the SDKs may incorrectly annotate or assume a type to be nonnull rather than nullable. A type that Swift treats as a struct, such as NSURL (Foundation.URL) or NSDate (Foundation.Date), results in a run-time crash in a method with a name like bridgeFromObjectiveC; in other cases, it can lead to crashes or undefined behavior in user code. If you identify such a method, please file a report at bugreport.apple.com. As a workaround, add a trampoline function in Objective-C with the correct nullability annotations. For example, the following function will allow you to call FileManager'senumerator(at:includingPropertiesForKeys:options:errorHandler:) method with an error handler that accepts nil URLs:

static inline NSDirectoryEnumerator<NSURL *> * _Nullable

fileManagerEnumeratorAtURL(NSFileManager *fileManager, NSURL * _Nonnull url, NSArray<NSURLResourceKey> * _Nullable keys, NSDirectoryEnumerationOptions options, BOOL (^ _Nullable errorHandler)(NSURL * _Nullable errorURL, NSError * _Nonnull error)) {

     return [fileManager enumeratorAtURL:url includingPropertiesForKeys:keys options:options errorHandler:^(NSURL * _Nonnull errorURL, NSError * _Nonnull error) {

      return errorHandler(errorURL, error);

   }];

}

This function can be included in your bridging header (for an app or test target) or umbrella header (for a framework target). (27749845)

UI Recording in the Touch Bar only records tap interactions. (28500819, 28454674)

To work around this, record the test and then change the generated code for the test to the desired type of interaction. For example, replace the call to tap with doubleTap to change from a single-tap to a double-tap. For possible interactions, see the documentation for XCUIElement.

UI tests may fail to run for apps written with Swift 2.3. (26680406)

Keystroke events issued by Xcode UI tests may be dropped if TextExpander is enabled. (25203671)

Xcode Server reports the error “Verifying that Xcode is accessible” when Xcode is installed in a non-world-readable location other than /Applications. Since the service makes use of role accounts to run various service daemons, those role accounts need to be able to read Xcode. As a workaround, place Xcode in the /Applications folder. (26920334)

The clang static analyzer now checks for improper cleanup of synthesized instance variables in -dealloc methods. (6927496)

The indexing component has moved out of the Xcode process to an XPC service, providing the benefit of process isolation and accurate resource usage attribution. (24330820)

A fast scanner for unit tests is now available. The scanner will populate the Test navigator shortly after opening a project for the first time, eliminating the need to wait for indexing to parse all the unit test source files. It supports both Swift and Objective-C unit tests. (25716884)

Opening Xcode projects and workspaces stored in iCloud Drive, or changing source control branches for an open workspace or project stored in iCloud Drive, may sometimes cause Xcode to hang. Note that in macOS 10.12, your Documents and Desktop folders may optionally be iCloud Drive locations. (28212905)

On macOS 10.12, Xcode removes its custom motion animations from the user interface when the Reduce Motion setting is selected in System Preferences > Accessibility > Display. (26973957)

Address Sanitizer is supported in Swift and can catch memory corruption errors that get triggered by using types such as UnsafeMutablePointer. (21888114)

The new thread sanitizer feature combines compiler instrumentation and runtime monitoring to help find and understand data races and other concurrency bugs in Swift and Objective-C. Thread sanitizer is supported on 64-bit macOS and 64-bit simulators. (19432893)

Using a custom module map that contains system headers (directly or indirectly) can result in crashes of the LLVM or Swift compiler. For example, this can occur when using a module map with paths into the macOS SDK while building for iOS, or when using headers from the system /usr/include while building with any Xcode SDK.

To work around this issue, make sure the system headers mentioned in the module map or included by custom headers are always found in the current target's SDKROOT. (26866326)

Older versions of libobjc cannot fully handle the runtime metadata provided by the compiler for class properties. Therefore, if your deployment target is older than OS X 10.11 or iOS 9, some of this metadata will be absent. It is still safe to use class properties in projects deploying to newer OS versions, and the accessor methods will still show up in the runtime metadata. If you aren't using the Objective-C runtime to get information about class properties, you don't need to worry about this issue. (25616128)

Trying to link with LTO files compiled with Xcode 8 and files compiled with a previous Xcode release may fail if Objective-C class properties are in use. (28017126)

Activity and trace messages normally visible in LLDB thread summaries and thread detailed information is absent when debugging processes running on beta versions of macOS, iOS, tvOS, or watchOS. (26370425)

If any Swift code contains a private func == definition, LLDB fails to evaluate expressions in a Swift context with the error: binary operator '==' cannot be applied to two 'Int' operands. To work around this issue, make any == overloads in your program non-private. (27015195)

The new LLVM-based otool(1) exits non-zero on the first error it encounters for the files on the command line. This includes treating non-object files as errors. This differs from the old otool(1), available as otool-classic(1), which processes all files on the command line even if some have errors and does not treat non-object files as an error but as a warning. (26828015)

Applications compiled with Xcode 8 and a deployment target of iOS 7 may crash at launch with the following assertion:

Assertion failed: (maxCountIncludingZeroTerminator > 0 && tokenCount < maxCountIncludingZeroTerminator), function CUIRenditionKeyCopy, file /SourceCache/CoreUI/CoreUI-232.4/CoreTheme/ThemeStorage/CUIThemeRendition.m, line 185.

To work around this issue, update the deployment target to iOS 8.0 or later, or add a single image to the asset catalog that has at least five attributes specified across the image set, such as:

• scale (1x, 2x, 3x)

• idiom (add iPad,iPhone, and a universal asset)

• direction (left to right, right to left)

• width/height class (any & compact, and so forth)

• memory (add a 1 GB asset)

• graphics (add a Metal 1v2 asset)

It is not necessary to use the image in your code or to add all of these attributes. (27852391)

The PNG compression build settings Compress PNG Files and Remove Text Metadata From PNG Files are available for macOS in addition to iOS, watchOS, and tvOS. For macOS, both settings are off by default. (24638927)

The build setting ENABLE_ADDRESS_SANITIZER controls whether the address sanitizer is enabled across both the clang and swiftc compilers. Previously only CLANG_USE_ADDRESS_SANITIZER existed; that setting is now subordinate to ENABLE_ADDRESS_SANITIZER and should not be used by itself. If a project was previously using CLANG_USE_ADDRESS_SANITIZER as a build setting to enable the address sanitizer separate from the scheme option, then ENABLE_ADDRESS_SANITIZER should now be used instead. (24912445)

Xcode takes build settings set in xcconfig files into account when suggesting updates to your build settings. (13433596)

xcconfig files support conditional inclusion of other xcconfig files, using the syntax #include? instead of the usual #include (which still generates a warning, as before, if the file is missing). (11003005)

The static analyzer check for nullability violations now supports both aggressive and less aggressive levels of checking. The more-aggressive level checks for nullability violations in all calls and is enabled by default for new projects. The less-aggressive level checks for nullability violations in calls to project headers but not system headers. The less-aggressive level is enabled by default for existing projects. To turn on the more-aggressive level for existing projects, select "Yes (Aggressive)" for "Misuse of ‘nonnull’" in the Static Analyzer - General Issues section of the target build settings. (25120516)

The development team used for signing is now stored in a new build setting, DEVELOPMENT_TEAM. This allows overriding the development team using xcconfig files. As a result, the format of the new PROVISIONING_PROFILE_SPECIFIER build setting has changed. The old format, which included a team ID, is still supported, but it now needs to contain only a provisioning profile name. (27082795)

If your CODE_SIGN_ENTITLEMENTS value is conditionalized per SDK, add a setting for the appropriate simulator SDK(s) explicitly. Previous versions of Xcode fell back to the iOS SDK’s value; this is no longer the case. (26923346)

When the Enable Testability build setting is enabled, Xcode 8 will pass -export_dynamic to the linker to preserve all global symbols for testing. This effectively overrides dead code stripping, which can expose link failures from unused functions that reference undefined symbols. If necessary, disabling testability will allow the link to proceed without source changes. (27684883)

xcodebuild now supports a -quiet flag to suppress output other than errors and warnings. (5732994)

In macOS 10.12 and later, Xcode cleans up stale derived data, precompiled headers, and module caches. (23282174)

In Developer ID provisioning profiles, the value of the com.apple.developer.icloud-container-environment entitlement has changed from an array to a string. (26722546)

When exporting an app with Developer ID, Xcode will automatically generate Developer ID provisioning profiles for any bundles embedded in the app. (26827710)

Developer ID apps using profiles will not work on versions of OS X prior to 10.10. You can work around this issue by explicitly installing the profile before running the app. (26013718)

Xcode 8 does not automatically copy the aps-environment entitlement from provisioning profiles at build time. This behavior is intentional. To use this entitlement, either enable Push Notifications in the project editor’s Capabilities pane, or manually add the entitlement to your entitlements file. (28076333)

Xcode does not require code signing for iOS frameworks, and will skip signing a framework if a team is not specified. Frameworks should be signed when copied into the hosting product (using the Code Sign on Copy flag in a Copy Files build phase). (26892618)

Fixed a crash opening documents using a pattern color with NSPatternColorSpace. (26964970)

The Swift Package Manager tool for managing the distribution of Swift code is available on the command line. Help for the Swift Package Manager can be found by running swift package --help in Terminal. (25582703)

Xcode automatically generates classes or class extensions for the entities and properties in a Core Data data model. Automatic code generation is enabled and disabled on an entity by entity basis, and is enabled for all entities in new models that use the Xcode 8 file format. This feature is available for any data model that has been upgraded to the Xcode 8 format. You specify whether Xcode generates Swift or Objective-C code for a data model using the data model’s file inspector.

When automatic code generation is enabled for an entity, Xcode creates either a class or class extension for the entity as specified in the entity's inspector: the specified class name is used and the sources are placed in the project’s Derived Data. For both Swift and Objective-C, these classes are directly usable from the project’s code. For Objective-C, an additional header file is created for all generated entities in your model. The header file name conforms to the naming convention “DataModelName+CoreDataModel.h”.

The Xcode attribute inspector also allows a choice of whether to generate scalar or object properties. New attributes default to generating scalar properties where appropriate. For attributes that previously relied on filling in class information after code was manually generated (for example, transformable attributes and transient attributes with an undefined attribute type), specify the class to use in the attribute’s declaration directly in the attribute inspector. (22223273)

Debugging mixed Objective-C and Swift projects has been improved by displaying Swift instance variables even when showing Objective-C references to Swift types. (24083219)

Memory graph debugging is available for WatchKit extensions. (26563396)

In addition to the Xcode console, Terminal can be used for macOS process input and output while debugging. Open the scheme editor to edit your scheme’s Run action and then select the Use Terminal option in the Options tab. (23565724)

LLDB fully supports the Swift 3 language and includes numerous quality improvements to make Swift debugging more accurate and reliable. Note that when debugging Swift 2.3 code an earlier version of LLDB will be used, and most new LLDB features will not be available. (22509661)

Stepping into a specific function in a complex line of code is much easier. Consider the following example:

Resolved Issues(bar(), baz())

Previously, stepping into Resolved Issues() required stepping into and out of bar() and baz(). Now the sif alias makes this easy. The command sif Resolved Issues will step through other functions until it reaches the named target. If the expected target isn’t reached, it provides a safeguard by stopping after returning from the current scope. (24528770)

Xcode 8 now isolates LLDB as a distinct process. This is largely transparent but has the following implications:

• In the event of an unrecoverable failure while debugging, Xcode will be unaffected aside from closing the debug session.

• Multiple debugger versions can be used simultaneously. Projects containing Swift 2.3 code will use an earlier corresponding LLDB, and when working with an open source Swift toolchain, the included LLDB will be used.

(23418627)

LLDB now supports and correctly displays the value of thread-local variables. (7796742)

LLDB documentation has been significantly updated:

• A new LLDB Debugging Guide is available in Xcode help.

• LLDB’s built-in help text has been overhauled for clarity and consistency.

• When no help is available via help <topic> in LLDB, alternative suggestions are displayed.

• Command aliases can now have custom help text, and several of the key built-in aliases take advantage of this facility.

(24868841)

Expressions that can be trivially corrected using compiler fix-its are automatically fixed and executed. This ensures that LLDB doesn’t get in your way for something as simple as a missing semicolon or the wrong style of indirection in Objective-C; or the need to unwrap a value in Swift. (25351938)

Expressions in LLDB support an even wider array of scenarios. Declaring and capturing Objective-C blocks and C++ lambdas now works as expected, and declaring C and C++ functions is now possible using the new --top-level (or -p) option on the expression command. (22509903)

Two new command aliases make it easy to examine C-style arrays. The commands parray and poarray behave like their counterparts p and po when formatting each element of the specified array. The length of the array must be specified first, followed by a pointer to the array. The usual LLDB conveniences for specifying arguments using the result of expressions can be used for the length—for example, parray `argc` argv when stopped in a C, C++, or Objective-C main function. (12691162)

Processes built with thread sanitizer enabled will display relevant information when issues are detected while debugging with LLDB. (23956680)

Debugging a Notification extension works with the normal extension debugging workflow in Xcode. (23487932)

Debugging with address sanitizer does not result in a runtime error regarding dyld inserting the ASan library. (23805032)

Fixed a crash for macOS apps running with thread sanitizer when profiling from the Memory gauge. (26275485)

The view debugger shows the debug description for views in the inspector. (23976841)

The view debugger shows the frame for views in the size inspector. (24314615)

The view debugger functions normally when debugging on the iOS 8 simulator. (25802025)

Resolved an issue where view debugging could fail when not using auto layout, due to an unhandled assertion in an underlying system framework. (25311044)

Resolved stability issues with debugging extensions or watch apps in the simulator. (25338888)

Debugger() and DebugStr() are deprecated and the scheme editor no longer provides the option to enable these functions. If your project uses these functions, enable them by setting the environment variable USERBREAK with a value of 1. (24631170)

You must unlock devices when first connecting them to Xcode in order to use them for development. (25771635)

Instruments can't find the symbols downloaded for Apple Watch. As a workaround, find the device support folder for your Apple Watch version (it will be inside ~/Library/Developer/Xcode/watchOS DeviceSupport/), create an empty Info.plist file inside this folder, and restart Instruments. (27996340)

The Instruments Leaks template fails to report data against Swift apps with a Release configuration, because this configuration enables Whole Module Optimization by default. To work around this issue: if you're targeting a Swift app, temporarily turn off Whole Module Optimization when using either the Leaks template in Instruments or the Memory Graph Debugger in Xcode. (27906876)

The Automation instrument has been removed from Instruments. Use Xcode’s UI Testing instead. (26761665)

Interface Builder makes it easier to migrate to auto layout by no longer generating implicit constraints for views without constraints. (13728545, 24274870)

The size inspector now displays frame coordinates with greater precision, and can accept fractional point values on Retina displays for iOS. (8895377)

Storyboard and xib files support smooth zooming across iOS, tvOS, and watchOS, as well as editing at any zoom level. When using a mouse, operating the scroll wheel while holding down the option key allows you to zoom in and out. (5215027, 9635866, 11579591, 15011038, 21256576, 23379420)

A completely redesigned workflow for working with trait variations (for example, size classes), supports designing UI in terms of a real device size rather than by using intentionally abstract rectangles. Combined with a new mode for quickly introducing variations, it’s easier than ever to see what your UI looks like across multiple devices, orientations, and adaptations like Slide Over and Split View on iPad. (16901225, 23804474, 24012599)

Creating an @IBAction method by control-dragging from Interface Builder to a Swift 3 source file includes an underscore before the sender parameter, causing the corresponding Objective-C selector to match Swift 2 behavior. Converting to Swift 3 syntax modifies @IBAction methods by adding an underscore, preserving connections in existing IB documents. (26120871)

The Notes field in the Identity inspector now has "Comment For Localizer" placeholder text to more clearly indicate that it is included in an XLIFF export. (26802029)

Xcode 8 removes the ability to configure views without constraints with frame varying per size class. Views without constraints may look different after compiling with Xcode 8 when switching size classes at runtime. Going forward, use constraints and autoresizing masks with the device bar to achieve the desired layout. (25894544)

The canvas in Interface Builder renders visual interactions between iOS views as they appear at runtime, including accurate compositing of UIVisualEffectView. Designable views can now visually interact with their subviews. Rendering performance is significantly improved for tvOS documents. (21922006)

Interface Builder supports customizing UI elements for Dark interface style on tvOS and previewing in the assistant editor. This support is enabled by default for new xib and storyboard files; it can be enabled for existing documents by selecting the Uses Trait Variations option in the Identity inspector. (23343849)

Interface Builder supports colors in the Display P3 color space. In the system color panel, select RGB or HSB sliders, click the gear menu to the right of the popup button, and choose Display P3 from the list. (23612133)

The UI for customizing inspector properties for iOS size classes is improved, and defaults to the configuration that is currently active in the canvas. (26123851)

Xcode 8 provides numerous accessibility improvements, including VoiceOver enhancements to the design canvas, inspectors, document outline, and object library. (5306382)

While the canvas is varying for traits (indicated by a blue bottom bar) and has focus, the Delete key uninstalls the selected objects only for the current configuration. If the document outline has focus, or when the canvas is not in varying mode, the Delete key removes the selected objects from the document, affecting all configurations. (26153578)

Color values in Interface Builder documents correctly use color space during rendering and compilation. Earlier versions of Xcode mishandled color spaces saved in iOS and tvOS documents. Xcode 8 converts existing colors in a way that preserves their perceptual appearance on a device, and updates either the color space or component values in the source document as appropriate. (7645087)

Constraint constants with fractional (non-integer) values can now be configured in Interface Builder. (15963933)

Constraints to a view are now preserved when the view is embedded in a new view, or dragged to within a new superview. (9666331)

Storyboard and xib files can be scrolled while dragging objects or scenes, and during control-dragging to create connections. Dragging to the edge of the canvas activates autoscrolling. (25221374, 25631320)

Interface Builder's design canvas draws correctly when layer-backing is enabled in macOS xib and storyboard documents. This includes canvas decorations such as resize knobs, selection indicators, bounds rectangles, constraints, and segue arrows. (5565950)

Fixed a crash when navigating away from an Interface Builder document that uses custom fonts and designable views. (17237787)

NSBox properties that are inapplicable for custom box and separator lines are excluded from inspectors, warnings, and saved documents. This includes a localizable title for separator lines that was unintentionally included in XLIFF output. (5081354, 9939692, 14994467, 23877301)

Using a custom font in UILabel, UITextField, or UITextView with size classes enabled now correctly encodes the font for use at runtime. (18535469)

Xcode records custom font names once per document, rather than once for each use in a document. (18389741)

Inspector tooltips in Interface Builder are not available.

For projects with localizations in more than one language, Xcode automatically turns on the static analyzer check for missing localizability. (22807459)

XLIFF export no longer includes accessibilityIdentifier strings configured in Interface Builder. (24548071)

Logging for simulated key presses includes the glyph representations for modifier keys, as well as the glyph and symbol name for constants starting with XCUIKeyboardKey. (27374182)

Unified Logging is now supported for apps uploading to TestFlight and the App Store. (27794355)

A new target type for Metal libraries enables creating new projects, or new targets in existing projects, for platforms that support Metal. Targets of this type only compile Metal source files and produce Metal libraries. A Metal library produced in this manner can be added to the Copy Bundle Resources build phase of another target to make the Metal content available to that target's products. (17877026)

Objective-C now supports class properties, which interoperate with Swift type properties. They are declared as @property (class) NSString *someStringProperty;, and are never synthesized. (23891898)

C++ now supports the thread_local keyword, which declares thread-local storage (TLS) and supports C++ classes with non-trivial constructors and destructors. (9001553)

Incremental Link-Time Optimization (LTO) has been added and is a major redesign of the existing monolithic LTO mode. Incremental LTO addresses the three main limitations of monolithic LTO by making it parallel, memory lean, and incremental. (22252706)

The playground video tag now supports remote URLs. (24886083)

The first link included in a playground markup comment does not have its hit target reduced to the beginning of the linked text. (24920637)

Live views for iOS playgrounds display retina views on Macs with retina displays. (26945081)

The editor's Add Documentation command is enabled when editing a playground. (27395238)

Xcode 8 contains a project template for a cross-platform SpriteKit game. When you create a project from this template, you can choose which platforms should be supported (iOS, macOS, tvOS, watchOS). The resulting project will contain a target for each selected platform and will factor out content that is appropriate to be shared between all platforms. Shared content includes the primary SKScene subclass, sks files, and the main asset catalog. Platform-specific content is created for each supported platform including app delegates, view controllers, and so forth. (26543360)

The "Embed Binaries" section of the target editor correctly adds new embedded binaries. (27631378)

Xcode correctly embeds or links frameworks across projects without requiring you to set up a direct reference between the project that produces the framework and the project that embeds or links it. (27631386)

Changes made to projects from outside Xcode (for instance, from Git) do not cause Xcode to select a different active scheme. (16762297)

Xcode 8 provides completely rewritten AppleScript support. A new scripting dictionary provides the ability to automate Xcode workflows. New functionality includes, for example, the ability to perform "run" and "test" actions. Some previous functionality, such as manipulating files and groups in a workspace, has been curtailed for enhanced reliability. Open Script Editor.app and select File > Open Dictionary to access the Xcode scripting library.

Xcode scripts can be used in Automator workflows with the Run Script command. (22819339)

The signing system has been rewritten to include a new mode for automatically managing signing assets, in addition to a dedicated manual mode where the profiles for the target must be explicitly selected. When automatically managing signing assets, Xcode will create signing certificates, update app IDs, and create provisioning profiles. For manual mode, only custom created profiles can be selected and Xcode will not modify or create any signing assets.

Xcode now encodes profiles in the target using the PROVISIONING_PROFILE_SPECIFIER build setting. This setting allows specifying both the team ID and the name or identifier of the profile. (23992778)

UIContentSizeCategoryDidChangeNotification is delivered as expected in the iOS 10.0 Simulator runtime. (25303105)

SKVideoNode is usable in the iOS and tvOS Simulator Runtimes. (26433285)

The GameKit framework is missing from the SDK for the watchOS simulator. However, the framework is present for watchOS devices, so you can still do development of GameKit apps for watchOS on devices. (27899791)

Xcode now assumes that Git repositories with “core.precomposeunicode” unset or set to false are using macOS canonical decomposition normalization for Unicode filenames. This may cause repositories that have this unset or set to false to have trouble with some Unicode file names if the filename normalization in the repository was done on another platform. (26861162)

To work around this issue, make sure the configuration for Git repositories has “core.precomposeunicode” set to true. This will be the case for any repository created with the Git tools that ship with Xcode. Only leave it unset or set to false for compatibility with repositories that have Unicode filenames using macOS canonical decomposition normalization.

Xcode 8 adds support for Xcode source editor extensions. Application extensions provide additional commands in the Xcode Editor menu. These extensions can manipulate both text and selections. To create them, use the new Xcode Source Editor Extension target template in the macOS Application Extensions section when creating a project. (23194974)

To use the Editor's Comment/Uncomment Selection and Add Documentation commands—as well as other installed Xcode Extensions—on OS X 10.11, launch Xcode and install additional system components, then restart your Mac. (26106213)

The version of Swift 2 (2.3) used in Xcode 8 is very close to the version used in Xcode 7.3.1. However, it has been updated for the newer SDKs, and therefore is not compatible with Swift frameworks compiled in Xcode 7.3.1. Distributing binary Swift frameworks remains unsupported in Xcode 8. (25680392)

For information on migrating from Swift 2 to Swift 3, see the Swift Migration Guide.

When a Swift program traps at runtime due to an unexpected null value, the error message reports the source location of the ! operator or implicit unwrapping in the user's source code. (26919123)

Argument labels have been removed from Swift function types. Instead, they are part of the name of a function, subscript, or initializer. Calls to a function or initializer, or uses of a subscript, still require argument labels, as they always have:

func doSomething(x: Int, y: Int) {}

doSomething(x: 0, y: 0) // argument labels are required

However, unapplied references to functions or initializers no longer carry argument labels. For example:

 let f = doSomething(x:y:)   // inferred type is now (Int, Int) -> Void

Additionally, explicitly-written function types can no longer carry argument labels, although one can still provide a parameter name for documentation purposes using the _ in the argument label position:

typealias CompletionHandler =

  (token: Token, error: Error?) -> Void  // error: function types cannot have argument labels

typealias CompletionHandler =

  (_ token: Token, _ error: Error?) -> Void  // error: okay: names are for documentation purposes

(SE-0111)

Objective-C APIs using id now import into Swift as Any instead of as AnyObject. Similarly, APIs using untyped NSArray and NSDictionary import as [Any] and [AnyHashable: Any], respectively. (SE-0116)

Any is now accepted as a valid "sender" type for IBAction methods. (27853737)

Since id now imports as Any rather than AnyObject, you may see errors where you were previously performing dynamic lookup on AnyObject. For example:

guard let fileEnumerator = FileManager.default.enumerator(atPath: path) else {

  return

}

for fileName in fileEnumerator {

  if fileName.hasSuffix(".txt") { // error: value of type ‘Element’ (aka ‘Any’) has no member hasSuffix

   print(fileName)

  }

}

The fix is to either cast to AnyObject explicitly before doing the dynamic lookup, or force cast to a specific object type:

guard let fileEnumerator = FileManager.default.enumerator(atPath: path) else {

  return

}

for fileName in fileEnumerator {

  if (fileName as AnyObject).hasSuffix(".txt") {// cast to AnyObject

   print(fileName)

  }

}

(27639935)

Closure parameters are non-escaping by default, rather than explicitly being annotated with @noescape. Use @escaping to indicate that a closure parameter may escape. @autoclosure(escaping) is now written as @autoclosure @escaping. The annotations @noescape and @autoclosure(escaping) are deprecated. (SE-0103)

The @noreturn attribute on function declarations and function types has been removed, in favor of an empty Never type:

@noreturn func fatalError(msg: String) { ... } // old

func fatalError(msg: String) -> Never { ... }  // new

func performOperation<T>(continuation: @noreturn T -> ()) { ... } // old

func performOperation<T>(continuation: T -> Never) { ... }     // new

(SE-0102)

Xcode imports Objective-C protocol-qualified classes (for example Class <NSCoding>) into Swift as protocol type values (NSCoding.Type). (15101588)

The types UnsafePointer, UnsafeMutablePointer, AutoreleasingUnsafeMutablePointer, OpaquePointer, Selector, and NSZone now represent non-nullable pointers—that is, pointers that are never nil. A nullable pointer is now represented using Optional, for example,UnsafePointer<Int>?.

For types imported from C, non-object pointers (such as int *) now have their nullability taken into account:

• A pointer marked as _Nonnull, or within an NS_ASSUME_NONNULL_BEGIN/_END block, is imported as a non-optional value. Example: NSInteger * _Nonnull is imported as UnsafeMutablePointer<Int>.

• A pointer marked as _Nullable is imported as an optional value. Example: NSInteger * _Nullable is imported as UnsafeMutablePointer<Int>?.

• A pointer marked as _Null_unspecified, or an unannotated pointer outside of any NS_ASSUME_NONNULL_BEGIN/_END block, is imported as an implicitly-unwrapped optional value. Example: NSInteger * _Null_unspecified is imported as UnsafeMutablePointer<Int>!.

  The Swift standard library has been adjusted to match.

  One possible area of difficulty is passing a nullable pointer to a function that uses C variadics. Swift will not permit this directly, so as a workaround please use the following idiom to pass it as a pointer-sized integer value instead:

  Int(bitPattern: nullablePointer)

  The "pointee" types of imported pointers (for example, the id in id *) are no longer assumed to always be _Nullable even if annotated otherwise. However, an implicit or explicit annotation of _Null_unspecified on a pointee type is still imported as Optional. (SE-0055)

The "Ref" forms of CF type names have been removed from Swift. For example, use CFString instead of CFStringRef.

One exception is if there are types named both "Resolved Issues" and "Resolved IssuesRef," where "Resolved IssuesRef" is a Core Foundation type. In this case, both types will continue to be imported as they always have. (16888940)

Condition clauses in if, guard, and while statements use a more regular syntax. Prefix each pattern or optional binding with case or let, respectively, and separate all conditions with “,” instead of “where”. For example, the code previously written as:

if let a = a, b = b where a == b {}

is now written as:

if let a = a, let b = b, a == b {}

(SE-0099)

Nested generic functions can now capture bindings from the environment. For example:

func outer<T>(t: T) -> T {

  func inner<U>(u: U) -> (T, U) {

    return (t, u)

  }

  return inner(u: (t, t)).0

}

(22051279)

Function parameters now have consistent labeling across all function parameters. With this update the first parameter declarations will now match the existing behavior of the second and later parameters.

Code that was previously written as:

func Resolved Issues(x: Int, y: Int) {}

Resolved Issues(1, y: 2)

func bar(a a: Int, b: Int) {}

bar(a: 3, b: 4)

should now be written as:

func Resolved Issues(_ x: Int, y: Int) {}

Resolved Issues(1, y: 2)

func bar(a: Int, b: Int) {}

bar(a: 3, b: 4)

(SE-0046)

The Objective-C selectors for the getter or setter of a property can now be referenced with #selector. For example:

let sel1 = #selector(getter: UIView.backgroundColor) // sel1 has type Selector

let sel2 = #selector(setter: UIView.backgroundColor) // sel2 has type Selector

(SE-0064)

Collection subtype conversions and dynamic casts now work with protocol types. For example:

protocol P {}; extension Int: P {}

var x: [Int] = [1, 2, 3]

var p: [P] = x

var x2 = p as! [Int]

The hasPrefix and hasSuffix functions now consider the empty string to be a prefix and suffix of all strings. (SR-2131)

The None members of imported NS_OPTIONS option sets are marked as unavailable when they are imported. Use [] to make an empty option set, instead of a None member.

Generic typealiases are now supported. For example:

typealias StringDictionary<T> = Dictionary<String, T>

typealias IntFunction<T> = (T) -> Int

typealias MatchingTriple<T> = (T, T, T)

typealias BackwardTriple<T1, T2, T3> = (T3, T2, T1)

The @noescape attribute has been extended to be a more general type attribute. You can now declare values of @noescape function type. You can now also declare local variables of @noescape type, and use @noescape in typealiases. For example, the following is now valid code:

func apply<T, U>(@noescape f: T -> U,

           @noescape g: (@noescape T -> U) -> U) -> U {

  return g(f)

}

Curried function syntax has been removed, and now produces a compile-time error.

Generic signatures can now contain superclass requirements with generic parameter types. For example:

func f<Resolved Issuesd : Chunks<Meat>, Meat : Molerat>(f: Resolved Issuesd, m: Meat) {}

Catch blocks in rethrows functions can now throw errors. For example:

func process(f: () throws -> Int) rethrows -> Int {

  do {

    return try f()

  } catch is SomeError {

    throw OtherError()

  }

}

Throwing closure arguments of a rethrowing function can now be optional. For example:

func executeClosureIfNotNil(closure: (() throws -> Void)?) rethrows {

  try closure?()

}

The FloatingPoint protocol has been expanded to include most IEEE 754 required operations. A number of useful properties have been added to the protocol as well, representing quantities like the largest finite value or the smallest positive normal value (these correspond to the macros such as FLT_MAX defined in C).

While most of the changes are additive, there are four changes that will impact existing code:

• The % operator is no longer available for FloatingPoint types. The new method formTruncatingRemainder(dividingBy:) provides the old semantics if they are needed.

• The static property .NaN has been renamed .nan.

• The static property .quietNaN was redundant and has been removed. Use .nan instead.

• The predicate isSignaling has been renamed isSignalingNaN.

(SE-0067)

Most keywords are now allowed in member references. This allows the use of members after a dot without backticks. For example, "Resolved Issues.default." (SE-0071)

A key-path can now be formed with #keyPath. For example:

person.valueForKeyPath(#keyPath(Person.bestFriend.lastName))

(SE-0062)

The location of the inout attribute has been moved to after the : and before the parameter type. For example, code previously written as:

func Resolved Issues(inout x: Int) {

}

should now be written as:

func Resolved Issues(x: inout Int) {

}

(SE-0031)

The #line directive (which resets the logical source location for diagnostics and debug information) has been renamed to #sourceLocation. (SE-0034)

A declaration marked as private can now only be accessed within the lexical scope it is declared in (essentially the enclosing curly braces {}). A private declaration at the top level of a file can be accessed anywhere in that file, as in Swift 2. The access level formerly known as private is now called fileprivate. (SE-0025)

The compiler now provides an error when enum elements are accessed as instance members in instance methods. For example:

enum Color {

 case red, green, blue

 func combine(with color: Color) -> Color {

  return red

 }

}

In Swift 2.2, this is valid code. The correct way to write this in Swift 3 is:

return .red

(SE-0036)

It is now possible to declare variables in multiple patterns in cases. (SE-0043)

Initializers are now inherited even if the base class or derived class is generic:

class Base<T> {