algorithm
The implementation uses a specialized trie that has not been tuned to the table
data. I tried guessing parameter values that should work well, but did not do
any performance measurements.
There is no efficient way to initialize arrays with static data in Swift. The
required tables are being generated as C++ code in the runtime library.
rdar://16013860
Swift SVN r19340
underlying NSString when it ends in a high-surrogate code unit
The tests did not catch this because they were creating CFString, which,
as it turns out, does not perform bounds checking. Replaced the use of
CFString with a custom NSString subclass.
Swift SVN r19329
This one shows the unfortunate consequence that we need
Lazy[Forward|Bidirectional|RandomAccess]Collection. There's gonna be a
whole lotta gyb'bing going on...
Swift SVN r19316
It's both more rigorously correct and should prevent surprise when
constructing an Array from a filtered sequence. See the comments
in-code for details.
Swift SVN r19304
With following caveat for iOS.
- In iOS CoreImage is main module.
- CISampler is not defined in iOS
- CoreImage.CIFilter's apply is not available
in iOS.
// rdar://16726822
Swift SVN r19297
We haven't been advertising this syntax much, and it's closure form
was completely broken anyway, so don't jump through hoops to provide
great Fix-Its here.
Swift SVN r19277
This just renames the existing "uncheckedAdd" (and related) functions to addWithOverflow. These
were already "checked" and return the partial result + bool that we want.
Swift SVN r19246
This API exposes unmediated access to memory, and most users will never
see the UnsafeArray argument that's passed to the closure, so best to be
explicit.
Swift SVN r19243
If underlying NSString contained isolated surrogates, then we were crashing in
following ways:
- subscripting by index could crash;
- index pointing to the second code unit sequence was not moved backwards
correctly. Instead of moving it to pointing to the beginning of the view it
could be moved to point to the code unit before the beginning of the view.
Swift SVN r19230
Until we get an optimizer pass to remove get/set pairs, passing a
property that is a protocol requirement as inout from generic code is
always going to cause an extra retain, causing many unintended Array
copies.
Because this dropped reference counts to 1 in some cases, it exercised
previously-untested code paths and uncovered bugs, particularly in the
handling of subrange replacement on Slice<T>.
There are still differences in speed for short arrays of CGPoint that bear
investigation, but at least as things scale up, the ratio of time goes
to 1.
Fixes <rdar://problem/17040913> append and += on an array have
completely different performance
Swift SVN r19228
Give UnsafePointer versions of CMutablePointer._setIfNonNil and _withBridgeObject/Value. Also provide a version of 'withUnsafePointer' as a staging aid so that UnsafePointer can be used in place of CMutablePointer.
Swift SVN r19215
Because _demandUniqueMutableBuffer returns nil if the buffer already
exists, rename to _createUniqueMutableBuffer.
Because _requestUniqueMutableBuffer may return native backing storage
for a slice whose bounds don't exactly match the backing storage, rename
to _requestUniqueMutableBackingBuffer
Swift SVN r19214
Better to describe how the protocol can be used than how it can't. Also include a mention of Self type requirements as a source of non-existentiability.
Swift SVN r19207
We (correctly) import this as AutoreleasingUnsafePointer instead of UnsafePointer in the new regime, but need to stage out the old regime fully before switching over.
Swift SVN r19200
don't call into CoreFoundation to perform UTF-8 transcoding. CoreFoundation
can replace ill-formed sequences with a single byte, which is not good enough
to implement U+FFFD insertion. Instead, use the same transcoding routine as
for contiguous buffer.
Pulled out the transcoding routine into a generic function that should be
specialized and simplified for the case when input is UnsafeArray; we should
not be losing efficiency here.
Fixes <rdar://problem/17297055> [unicode] println crashes when given string
with unpaired surrogate
Swift SVN r19157
...where T is the equivalent Swift function type. This gives us proper type
safety (ish) for C function pointers while still not treating them the same
as Swift closures.
If the function type is not one we can represent in Swift, we fall back to
COpaquePointer. CFunctionPointer<T> and COpaquePointer can be explicitly
constructed from one another, but do not freely convert.
<rdar://problem/17215978>
Swift SVN r19154
implementation:
- don't crash on NSStrings that contain isolated surrogates (partial fix, there
is a different code path that dispatches CoreFoundation and it still
crashes);
- insert U+FFFD according to Unicode recommendation;
- fix decoding of surrogate pairs when the internal buffer is almost full
(we used to drop characters in that case, rdar://16833733 + dups).
Swift SVN r19147
