From 00b297c807db2bb503efe7d394dc4425470ce896 Mon Sep 17 00:00:00 2001 From: JP Simard Date: Sun, 24 Jun 2018 11:01:18 -0700 Subject: [PATCH] Update Linux Swift 4.1.50 fixtures --- .../LinuxCommandantSPM@swift-4.1.50.json | 266 +++++++++--------- ...inuxSimpleCodeCompletion@swift-4.1.50.json | 28 +- 2 files changed, 147 insertions(+), 147 deletions(-) diff --git a/Tests/SourceKittenFrameworkTests/Fixtures/LinuxCommandantSPM@swift-4.1.50.json b/Tests/SourceKittenFrameworkTests/Fixtures/LinuxCommandantSPM@swift-4.1.50.json index 137094f24..820aff78e 100644 --- a/Tests/SourceKittenFrameworkTests/Fixtures/LinuxCommandantSPM@swift-4.1.50.json +++ b/Tests/SourceKittenFrameworkTests/Fixtures/LinuxCommandantSPM@swift-4.1.50.json @@ -497,7 +497,7 @@ "key.substructure" : [ { "key.accessibility" : "source.lang.swift.accessibility.private", - "key.annotated_decl" : "private enum RawArgument : Equatable<\/Type><\/Declaration>", + "key.annotated_decl" : "private enum RawArgument : Equatable<\/Type><\/Declaration>", "key.attributes" : [ { "key.attribute" : "source.decl.attribute.private", @@ -525,7 +525,7 @@ } ], "key.filepath" : "Sources\/Commandant\/ArgumentParser.swift", - "key.fully_annotated_decl" : "private<\/syntaxtype.keyword> enum<\/syntaxtype.keyword> RawArgument<\/decl.name> : Equatable<\/ref.protocol><\/decl.enum>", + "key.fully_annotated_decl" : "private<\/syntaxtype.keyword> enum<\/syntaxtype.keyword> RawArgument<\/decl.name> : Equatable<\/ref.protocol><\/decl.enum>", "key.inheritedtypes" : [ { "key.name" : "Equatable" @@ -624,19 +624,19 @@ "key.substructure" : [ { "key.accessibility" : "source.lang.swift.accessibility.private", - "key.annotated_decl" : "case flag(OrderedSet<\/Type><Character<\/Type>>)<\/Declaration>", + "key.annotated_decl" : "case flag(OrderedSet<\/Type><Character<\/Type>>)<\/Declaration>", "key.doc.column" : 7, "key.doc.comment" : "One or more flag arguments (e.g 'r' and 'f' for `-rf`)", "key.doc.declaration" : "", "key.doc.file" : "Sources\/Commandant\/ArgumentParser.swift", - "key.doc.full_as_xml" : "flag(_:)<\/Name>s:10Commandant11RawArgument33_BA859BFBBE9DF3838A11641CB273713ELLO4flagyAdA10OrderedSetVys9CharacterVGcADmF<\/USR><\/Declaration>One or more flag arguments (e.g ‘r’ and ‘f’ for -rf<\/codeVoice>)<\/Para><\/Abstract><\/CommentParts><\/Other>", + "key.doc.full_as_xml" : "flag(_:)<\/Name>s:10Commandant11RawArgument33_BA859BFBBE9DF3838A11641CB273713ELLO4flagyAdA10OrderedSetVySJGcADmF<\/USR><\/Declaration>One or more flag arguments (e.g ‘r’ and ‘f’ for -rf<\/codeVoice>)<\/Para><\/Abstract><\/CommentParts><\/Other>", "key.doc.line" : 22, "key.doc.name" : "flag(_:)", "key.doc.type" : "Other", "key.doclength" : 59, "key.docoffset" : 483, "key.filepath" : "Sources\/Commandant\/ArgumentParser.swift", - "key.fully_annotated_decl" : "case<\/syntaxtype.keyword> flag<\/decl.name>(OrderedSet<\/ref.struct><Character<\/ref.struct>><\/decl.var.parameter.type><\/decl.var.parameter>)<\/decl.enumelement>", + "key.fully_annotated_decl" : "case<\/syntaxtype.keyword> flag<\/decl.name>(OrderedSet<\/ref.struct><Character<\/ref.struct>><\/decl.var.parameter.type><\/decl.var.parameter>)<\/decl.enumelement>", "key.kind" : "source.lang.swift.decl.enumelement", "key.length" : 27, "key.name" : "flag(_:)", @@ -647,8 +647,8 @@ "key.parsed_scope.end" : 22, "key.parsed_scope.start" : 22, "key.typename" : "(RawArgument.Type) -> (OrderedSet) -> RawArgument", - "key.typeusr" : "$Sy10Commandant11RawArgument33_BA859BFBBE9DF3838A11641CB273713ELLOAA10OrderedSetVys9CharacterVGcADmcD", - "key.usr" : "s:10Commandant11RawArgument33_BA859BFBBE9DF3838A11641CB273713ELLO4flagyAdA10OrderedSetVys9CharacterVGcADmF" + "key.typeusr" : "$Sy10Commandant11RawArgument33_BA859BFBBE9DF3838A11641CB273713ELLOAA10OrderedSetVySJGcADmcD", + "key.usr" : "s:10Commandant11RawArgument33_BA859BFBBE9DF3838A11641CB273713ELLO4flagyAdA10OrderedSetVySJGcADmF" } ] } @@ -688,64 +688,64 @@ "key.annotated_decl" : "== (_: Any.Type?, _: Any.Type?) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== <T>(_: T, _: T) -> Bool where T : RawRepresentable, T.RawValue : Equatable<\/RelatedName>" + "key.annotated_decl" : "== <T>(_: T, _: T) -> Bool where T : RawRepresentable, T.RawValue : Equatable<\/RelatedName>" }, { "key.annotated_decl" : "== (_: (), _: ()) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== <A, B>(_: (A, B), _: (A, B)) -> Bool where A : Equatable, B : Equatable<\/RelatedName>" + "key.annotated_decl" : "== <A, B>(_: (A, B), _: (A, B)) -> Bool where A : Equatable, B : Equatable<\/RelatedName>" }, { - "key.annotated_decl" : "== <A, B, C>(_: (A, B, C), _: (A, B, C)) -> Bool where A : Equatable, B : Equatable, C : Equatable<\/RelatedName>" + "key.annotated_decl" : "== <A, B, C>(_: (A, B, C), _: (A, B, C)) -> Bool where A : Equatable, B : Equatable, C : Equatable<\/RelatedName>" }, { - "key.annotated_decl" : "== <A, B, C, D>(_: (A, B, C, D), _: (A, B, C, D)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable<\/RelatedName>" + "key.annotated_decl" : "== <A, B, C, D>(_: (A, B, C, D), _: (A, B, C, D)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable<\/RelatedName>" }, { - "key.annotated_decl" : "== <A, B, C, D, E>(_: (A, B, C, D, E), _: (A, B, C, D, E)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable<\/RelatedName>" + "key.annotated_decl" : "== <A, B, C, D, E>(_: (A, B, C, D, E), _: (A, B, C, D, E)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable<\/RelatedName>" }, { - "key.annotated_decl" : "== <A, B, C, D, E, F>(_: (A, B, C, D, E, F), _: (A, B, C, D, E, F)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable<\/RelatedName>" + "key.annotated_decl" : "== <A, B, C, D, E, F>(_: (A, B, C, D, E, F), _: (A, B, C, D, E, F)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: ContiguousArray<ContiguousArray<Element>.Element>, _: ContiguousArray<ContiguousArray<Element>.Element>) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: ContiguousArray<ContiguousArray<Element>.Element>, _: ContiguousArray<ContiguousArray<Element>.Element>) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: ArraySlice<ArraySlice<Element>.Element>, _: ArraySlice<ArraySlice<Element>.Element>) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: ArraySlice<ArraySlice<Element>.Element>, _: ArraySlice<ArraySlice<Element>.Element>) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Array<Array<Element>.Element>, _: Array<Array<Element>.Element>) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Array<Array<Element>.Element>, _: Array<Array<Element>.Element>) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: Bool, _: Bool) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Character, _: Character) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Character, _: Character) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Character.UnicodeScalarView.Index, _: Character.UnicodeScalarView.Index) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Character.UnicodeScalarView.Index, _: Character.UnicodeScalarView.Index) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: CodingUserInfoKey, _: CodingUserInfoKey) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: ClosedRange<Bound>.Index, _: ClosedRange<Bound>.Index) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: ClosedRange<Bound>.Index, _: ClosedRange<Bound>.Index) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: ClosedRange<Bound>, _: ClosedRange<Bound>) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: ClosedRange<Bound>, _: ClosedRange<Bound>) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: OpaquePointer, _: OpaquePointer) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Dictionary<Key, Value>.Keys, _: Dictionary<Key, Value>.Keys) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Dictionary<Key, Value>.Keys, _: Dictionary<Key, Value>.Keys) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: [Key : Value], _: [Key : Value]) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: [Key : Value], _: [Key : Value]) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Dictionary<Key, Value>.Index, _: Dictionary<Key, Value>.Index) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Dictionary<Key, Value>.Index, _: Dictionary<Key, Value>.Index) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: LazyDropWhileCollection<Base>.Index, _: LazyDropWhileCollection<Base>.Index) -> Bool<\/RelatedName>" @@ -754,7 +754,7 @@ "key.annotated_decl" : "== (_: EmptyCollection<Element>, _: EmptyCollection<Element>) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: FlattenCollection<Base>.Index, _: FlattenCollection<Base>.Index) -> Bool<\/RelatedName>" @@ -763,13 +763,13 @@ "key.annotated_decl" : "== (_: FloatingPointSign, _: FloatingPointSign) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: AnyHashable, _: AnyHashable) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== <Other>(_: Self, _: Other) -> Bool where Other : BinaryInteger<\/RelatedName>" + "key.annotated_decl" : "== <Other>(_: Self, _: Other) -> Bool where Other : BinaryInteger<\/RelatedName>" }, { "key.annotated_decl" : "== (_: UInt8, _: UInt8) -> Bool<\/RelatedName>" @@ -811,10 +811,10 @@ "key.annotated_decl" : "== (_: Unicode.Scalar, _: Unicode.Scalar) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: ObjectIdentifier, _: ObjectIdentifier) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: ObjectIdentifier, _: ObjectIdentifier) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Wrapped?, _: Wrapped?) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Wrapped?, _: Wrapped?) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: Wrapped?, _: _OptionalNilComparisonType) -> Bool<\/RelatedName>" @@ -826,22 +826,22 @@ "key.annotated_decl" : "== (_: LazyPrefixWhileCollection<Base>.Index, _: LazyPrefixWhileCollection<Base>.Index) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Range<Range<Bound>.Bound>, _: Range<Range<Bound>.Bound>) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Range<Range<Bound>.Bound>, _: Range<Range<Bound>.Bound>) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: ReversedCollection<Base>.Index, _: ReversedCollection<Base>.Index) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Set<Element>, _: Set<Element>) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Set<Element>, _: Set<Element>) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Set<Element>.Index, _: Set<Element>.Index) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Set<Element>.Index, _: Set<Element>.Index) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== <S>(_: Self, _: S) -> Bool where S : StringProtocol<\/RelatedName>" + "key.annotated_decl" : "== <S>(_: Self, _: S) -> Bool where S : StringProtocol<\/RelatedName>" }, { "key.annotated_decl" : "== (_: String, _: String) -> Bool<\/RelatedName>" @@ -895,10 +895,10 @@ "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: FileAttributeKey, _: FileAttributeKey) -> Bool<\/RelatedName>" @@ -1051,7 +1051,7 @@ "key.annotated_decl" : "== (_: DispatchTimeInterval, _: DispatchTimeInterval) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== <T>(_: T, _: T) -> Bool where T : ResultProtocol, T.Error : Equatable, T.Value : Equatable<\/RelatedName>" + "key.annotated_decl" : "== <T>(_: T, _: T) -> Bool where T : ResultProtocol, T.Error : Equatable, T.Value : Equatable<\/RelatedName>" }, { "key.annotated_decl" : "== (_: NoError, _: NoError) -> Bool<\/RelatedName>" @@ -1065,7 +1065,7 @@ "key.usr" : "s:10Commandant2eeoi33_BA859BFBBE9DF3838A11641CB273713ELLySbAA11RawArgumentACLLO_AEtF" }, { - "key.annotated_decl" : "private enum RawArgument : Equatable<\/Type><\/Declaration>", + "key.annotated_decl" : "private enum RawArgument : Equatable<\/Type><\/Declaration>", "key.bodylength" : 214, "key.bodyoffset" : 930, "key.doc.column" : 14, @@ -1083,7 +1083,7 @@ } ], "key.filepath" : "Sources\/Commandant\/ArgumentParser.swift", - "key.fully_annotated_decl" : "private<\/syntaxtype.keyword> enum<\/syntaxtype.keyword> RawArgument<\/decl.name> : Equatable<\/ref.protocol><\/decl.enum>", + "key.fully_annotated_decl" : "private<\/syntaxtype.keyword> enum<\/syntaxtype.keyword> RawArgument<\/decl.name> : Equatable<\/ref.protocol><\/decl.enum>", "key.inheritedtypes" : [ { "key.name" : "CustomStringConvertible" @@ -1374,7 +1374,7 @@ "key.parsed_scope.start" : 99, "key.related_decls" : [ { - "key.annotated_decl" : "consumeBoolean(flag:)<\/RelatedName>" + "key.annotated_decl" : "consumeBoolean(flag:)<\/RelatedName>" } ], "key.substructure" : [ @@ -1615,7 +1615,7 @@ }, { "key.accessibility" : "source.lang.swift.accessibility.internal", - "key.annotated_decl" : "internal func consumeBoolean(flag: Character<\/Type>) -> Bool<\/Type><\/Declaration>", + "key.annotated_decl" : "internal func consumeBoolean(flag: Character<\/Type>) -> Bool<\/Type><\/Declaration>", "key.attributes" : [ { "key.attribute" : "source.decl.attribute.internal", @@ -1629,14 +1629,14 @@ "key.doc.comment" : "Returns whether the given flag was specified and removes it from the\nlist of arguments remaining.", "key.doc.declaration" : "internal func consumeBoolean(flag: Character) -> Bool", "key.doc.file" : "Sources\/Commandant\/ArgumentParser.swift", - "key.doc.full_as_xml" : "consumeBoolean(flag:)<\/Name>s:10Commandant14ArgumentParserC14consumeBoolean4flagSbs9CharacterV_tF<\/USR>internal func consumeBoolean(flag: Character) -> Bool<\/Declaration>Returns whether the given flag was specified and removes it from the list of arguments remaining.<\/Para><\/Abstract><\/CommentParts><\/Function>", + "key.doc.full_as_xml" : "consumeBoolean(flag:)<\/Name>s:10Commandant14ArgumentParserC14consumeBoolean4flagSbSJ_tF<\/USR>internal func consumeBoolean(flag: Character) -> Bool<\/Declaration>Returns whether the given flag was specified and removes it from the list of arguments remaining.<\/Para><\/Abstract><\/CommentParts><\/Function>", "key.doc.line" : 174, "key.doc.name" : "consumeBoolean(flag:)", "key.doc.type" : "Function", "key.doclength" : 107, "key.docoffset" : 4473, "key.filepath" : "Sources\/Commandant\/ArgumentParser.swift", - "key.fully_annotated_decl" : "internal<\/syntaxtype.keyword> func<\/syntaxtype.keyword> consumeBoolean<\/decl.name>(flag<\/decl.var.parameter.argument_label>: Character<\/ref.struct><\/decl.var.parameter.type><\/decl.var.parameter>) -> Bool<\/ref.struct><\/decl.function.returntype><\/decl.function.method.instance>", + "key.fully_annotated_decl" : "internal<\/syntaxtype.keyword> func<\/syntaxtype.keyword> consumeBoolean<\/decl.name>(flag<\/decl.var.parameter.argument_label>: Character<\/ref.struct><\/decl.var.parameter.type><\/decl.var.parameter>) -> Bool<\/ref.struct><\/decl.function.returntype><\/decl.function.method.instance>", "key.kind" : "source.lang.swift.decl.function.method.instance", "key.length" : 363, "key.name" : "consumeBoolean(flag:)", @@ -1655,8 +1655,8 @@ ], "key.typename" : "(ArgumentParser) -> (Character) -> Bool", - "key.typeusr" : "$S4flagSbs9CharacterV_tcD", - "key.usr" : "s:10Commandant14ArgumentParserC14consumeBoolean4flagSbs9CharacterV_tF" + "key.typeusr" : "$S4flagSbSJ_tcD", + "key.usr" : "s:10Commandant14ArgumentParserC14consumeBoolean4flagSbSJ_tF" } ], "key.typename" : "ArgumentParser.Type", @@ -1773,7 +1773,7 @@ "key.usr" : "s:10Commandant16ArgumentProtocolP" }, { - "key.annotated_decl" : "struct Int : FixedWidthInteger<\/Type>, SignedInteger<\/Type><\/Declaration>", + "key.annotated_decl" : "struct Int : FixedWidthInteger<\/Type>, SignedInteger<\/Type><\/Declaration>", "key.bodylength" : 113, "key.bodyoffset" : 478, "key.doc.declaration" : "struct Int : FixedWidthInteger, SignedInteger", @@ -1792,7 +1792,7 @@ "key.offset" : 460 } ], - "key.fully_annotated_decl" : "struct<\/syntaxtype.keyword> Int<\/decl.name> : FixedWidthInteger<\/ref.protocol>, SignedInteger<\/ref.protocol><\/decl.struct>", + "key.fully_annotated_decl" : "struct<\/syntaxtype.keyword> Int<\/decl.name> : FixedWidthInteger<\/ref.protocol>, SignedInteger<\/ref.protocol><\/decl.struct>", "key.groupname" : "Math\/Integers", "key.inheritedtypes" : [ { @@ -2230,7 +2230,7 @@ "CodeListing" : "" } ], - "key.doc.full_as_xml" : "RawRepresentable<\/Name>s:s16RawRepresentableP<\/USR>protocol RawRepresentable<\/Declaration>A type that can be converted to and from an associated raw value.<\/Para><\/Abstract>With a RawRepresentable<\/codeVoice> type, you can switch back and forth between a custom type and an associated RawValue<\/codeVoice> type without losing the value of the original RawRepresentable<\/codeVoice> type. Using the raw value of a conforming type streamlines interoperation with Objective-C and legacy APIs and simplifies conformance to other protocols, such as Equatable<\/codeVoice>, Comparable<\/codeVoice>, and Hashable<\/codeVoice>.<\/Para>The RawRepresentable<\/codeVoice> protocol is seen mainly in two categories of types: enumerations with raw value types and option sets.<\/Para>]]><\/rawHTML>Enumerations with Raw Values]]><\/rawHTML>For any enumeration with a string, integer, or floating-point raw type, the Swift compiler automatically adds RawRepresentable<\/codeVoice> conformance. When defining your own custom enumeration, you give it a raw type by specifying the raw type as the first item in the enumeration’s type inheritance list. You can also use literals to specify values for one or more cases.<\/Para>For example, the Counter<\/codeVoice> enumeration defined here has an Int<\/codeVoice> raw value type and gives the first case a raw value of 1<\/codeVoice>:<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>You can create a Counter<\/codeVoice> instance from an integer value between 1 and 5 by using the init?(rawValue:)<\/codeVoice> initializer declared in the RawRepresentable<\/codeVoice> protocol. This initializer is failable because although every case of the Counter<\/codeVoice> type has a corresponding Int<\/codeVoice> value, there are many Int<\/codeVoice> values that don’t<\/emphasis> correspond to a case of Counter<\/codeVoice>.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>]]><\/rawHTML>Option Sets]]><\/rawHTML>Option sets all conform to RawRepresentable<\/codeVoice> by inheritance using the OptionSet<\/codeVoice> protocol. Whether using an option set or creating your own, you use the raw value of an option set instance to store the instance’s bitfield. The raw value must therefore be of a type that conforms to the FixedWidthInteger<\/codeVoice> protocol, such as UInt8<\/codeVoice> or Int<\/codeVoice>. For example, the Direction<\/codeVoice> type defines an option set for the four directions you can move in a game.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>Unlike enumerations, option sets provide a nonfailable init(rawValue:)<\/codeVoice> initializer to convert from a raw value, because option sets don’t have an enumerated list of all possible cases. Option set values have a one-to-one correspondence with their associated raw values.<\/Para>In the case of the Directions<\/codeVoice> option set, an instance can contain zero, one, or more of the four defined directions. This example declares a constant with three currently allowed moves. The raw value of the allowedMoves<\/codeVoice> instance is the result of the bitwise OR of its three members’ raw values:<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>Option sets use bitwise operations on their associated raw values to implement their mathematical set operations. For example, the contains()<\/codeVoice> method on allowedMoves<\/codeVoice> performs a bitwise AND operation to check whether the option set contains an element.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing><\/Discussion><\/CommentParts><\/Class>", + "key.doc.full_as_xml" : "RawRepresentable<\/Name>s:SY<\/USR>protocol RawRepresentable<\/Declaration>A type that can be converted to and from an associated raw value.<\/Para><\/Abstract>With a RawRepresentable<\/codeVoice> type, you can switch back and forth between a custom type and an associated RawValue<\/codeVoice> type without losing the value of the original RawRepresentable<\/codeVoice> type. Using the raw value of a conforming type streamlines interoperation with Objective-C and legacy APIs and simplifies conformance to other protocols, such as Equatable<\/codeVoice>, Comparable<\/codeVoice>, and Hashable<\/codeVoice>.<\/Para>The RawRepresentable<\/codeVoice> protocol is seen mainly in two categories of types: enumerations with raw value types and option sets.<\/Para>]]><\/rawHTML>Enumerations with Raw Values]]><\/rawHTML>For any enumeration with a string, integer, or floating-point raw type, the Swift compiler automatically adds RawRepresentable<\/codeVoice> conformance. When defining your own custom enumeration, you give it a raw type by specifying the raw type as the first item in the enumeration’s type inheritance list. You can also use literals to specify values for one or more cases.<\/Para>For example, the Counter<\/codeVoice> enumeration defined here has an Int<\/codeVoice> raw value type and gives the first case a raw value of 1<\/codeVoice>:<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>You can create a Counter<\/codeVoice> instance from an integer value between 1 and 5 by using the init?(rawValue:)<\/codeVoice> initializer declared in the RawRepresentable<\/codeVoice> protocol. This initializer is failable because although every case of the Counter<\/codeVoice> type has a corresponding Int<\/codeVoice> value, there are many Int<\/codeVoice> values that don’t<\/emphasis> correspond to a case of Counter<\/codeVoice>.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>]]><\/rawHTML>Option Sets]]><\/rawHTML>Option sets all conform to RawRepresentable<\/codeVoice> by inheritance using the OptionSet<\/codeVoice> protocol. Whether using an option set or creating your own, you use the raw value of an option set instance to store the instance’s bitfield. The raw value must therefore be of a type that conforms to the FixedWidthInteger<\/codeVoice> protocol, such as UInt8<\/codeVoice> or Int<\/codeVoice>. For example, the Direction<\/codeVoice> type defines an option set for the four directions you can move in a game.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>Unlike enumerations, option sets provide a nonfailable init(rawValue:)<\/codeVoice> initializer to convert from a raw value, because option sets don’t have an enumerated list of all possible cases. Option set values have a one-to-one correspondence with their associated raw values.<\/Para>In the case of the Directions<\/codeVoice> option set, an instance can contain zero, one, or more of the four defined directions. This example declares a constant with three currently allowed moves. The raw value of the allowedMoves<\/codeVoice> instance is the result of the bitwise OR of its three members’ raw values:<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>Option sets use bitwise operations on their associated raw values to implement their mathematical set operations. For example, the contains()<\/codeVoice> method on allowedMoves<\/codeVoice> performs a bitwise AND operation to check whether the option set contains an element.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing><\/Discussion><\/CommentParts><\/Class>", "key.doc.name" : "RawRepresentable", "key.doc.type" : "Class", "key.fully_annotated_decl" : "protocol<\/syntaxtype.keyword> RawRepresentable<\/decl.name><\/decl.protocol>", @@ -2246,7 +2246,7 @@ "key.substructure" : [ { "key.accessibility" : "source.lang.swift.accessibility.public", - "key.annotated_decl" : "public static func from(string: String<\/Type>) -> Self<\/Type>?<\/Declaration>", + "key.annotated_decl" : "public static func from(string: String<\/Type>) -> Self<\/Type>?<\/Declaration>", "key.attributes" : [ { "key.attribute" : "source.decl.attribute.public", @@ -2257,7 +2257,7 @@ "key.bodylength" : 58, "key.bodyoffset" : 878, "key.filepath" : "Sources\/Commandant\/ArgumentProtocol.swift", - "key.fully_annotated_decl" : "public<\/syntaxtype.keyword> static<\/syntaxtype.keyword> func<\/syntaxtype.keyword> from<\/decl.name>(string<\/decl.var.parameter.argument_label>: String<\/ref.struct><\/decl.var.parameter.type><\/decl.var.parameter>) -> Self<\/ref.generic_type_param>?<\/decl.function.returntype><\/decl.function.method.static>", + "key.fully_annotated_decl" : "public<\/syntaxtype.keyword> static<\/syntaxtype.keyword> func<\/syntaxtype.keyword> from<\/decl.name>(string<\/decl.var.parameter.argument_label>: String<\/ref.struct><\/decl.var.parameter.type><\/decl.var.parameter>) -> Self<\/ref.generic_type_param>?<\/decl.function.returntype><\/decl.function.method.static>", "key.groupname" : "Protocols", "key.kind" : "source.lang.swift.decl.function.method.static", "key.length" : 102, @@ -2270,7 +2270,7 @@ "key.parsed_scope.start" : 35, "key.related_decls" : [ { - "key.annotated_decl" : "from(string: String) -> Self?<\/RelatedName>" + "key.annotated_decl" : "from(string: String) -> Self?<\/RelatedName>" }, { "key.annotated_decl" : "from(string: String) -> `Self`?<\/RelatedName>" @@ -2281,12 +2281,12 @@ ], "key.typename" : " (Self.Type) -> (String) -> Self?", "key.typeusr" : "$S6stringxSgSS_tcD", - "key.usr" : "s:s16RawRepresentableP10CommandantAC16ArgumentProtocolRzs06StringE00A5ValueABRpzrlE4from6stringxSgSS_tFZ" + "key.usr" : "s:SY10CommandantAA16ArgumentProtocolRzSy8RawValueSYRpzrlE4from6stringxSgSS_tFZ" } ], "key.typename" : "RawRepresentable.Protocol", - "key.typeusr" : "$Ss16RawRepresentable_pmD", - "key.usr" : "s:s16RawRepresentableP" + "key.typeusr" : "$SSY_pmD", + "key.usr" : "s:SY" }, { "key.annotated_decl" : "protocol RawRepresentable<\/Declaration>", @@ -2337,7 +2337,7 @@ "CodeListing" : "" } ], - "key.doc.full_as_xml" : "RawRepresentable<\/Name>s:s16RawRepresentableP<\/USR>protocol RawRepresentable<\/Declaration>A type that can be converted to and from an associated raw value.<\/Para><\/Abstract>With a RawRepresentable<\/codeVoice> type, you can switch back and forth between a custom type and an associated RawValue<\/codeVoice> type without losing the value of the original RawRepresentable<\/codeVoice> type. Using the raw value of a conforming type streamlines interoperation with Objective-C and legacy APIs and simplifies conformance to other protocols, such as Equatable<\/codeVoice>, Comparable<\/codeVoice>, and Hashable<\/codeVoice>.<\/Para>The RawRepresentable<\/codeVoice> protocol is seen mainly in two categories of types: enumerations with raw value types and option sets.<\/Para>]]><\/rawHTML>Enumerations with Raw Values]]><\/rawHTML>For any enumeration with a string, integer, or floating-point raw type, the Swift compiler automatically adds RawRepresentable<\/codeVoice> conformance. When defining your own custom enumeration, you give it a raw type by specifying the raw type as the first item in the enumeration’s type inheritance list. You can also use literals to specify values for one or more cases.<\/Para>For example, the Counter<\/codeVoice> enumeration defined here has an Int<\/codeVoice> raw value type and gives the first case a raw value of 1<\/codeVoice>:<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>You can create a Counter<\/codeVoice> instance from an integer value between 1 and 5 by using the init?(rawValue:)<\/codeVoice> initializer declared in the RawRepresentable<\/codeVoice> protocol. This initializer is failable because although every case of the Counter<\/codeVoice> type has a corresponding Int<\/codeVoice> value, there are many Int<\/codeVoice> values that don’t<\/emphasis> correspond to a case of Counter<\/codeVoice>.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>]]><\/rawHTML>Option Sets]]><\/rawHTML>Option sets all conform to RawRepresentable<\/codeVoice> by inheritance using the OptionSet<\/codeVoice> protocol. Whether using an option set or creating your own, you use the raw value of an option set instance to store the instance’s bitfield. The raw value must therefore be of a type that conforms to the FixedWidthInteger<\/codeVoice> protocol, such as UInt8<\/codeVoice> or Int<\/codeVoice>. For example, the Direction<\/codeVoice> type defines an option set for the four directions you can move in a game.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>Unlike enumerations, option sets provide a nonfailable init(rawValue:)<\/codeVoice> initializer to convert from a raw value, because option sets don’t have an enumerated list of all possible cases. Option set values have a one-to-one correspondence with their associated raw values.<\/Para>In the case of the Directions<\/codeVoice> option set, an instance can contain zero, one, or more of the four defined directions. This example declares a constant with three currently allowed moves. The raw value of the allowedMoves<\/codeVoice> instance is the result of the bitwise OR of its three members’ raw values:<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>Option sets use bitwise operations on their associated raw values to implement their mathematical set operations. For example, the contains()<\/codeVoice> method on allowedMoves<\/codeVoice> performs a bitwise AND operation to check whether the option set contains an element.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing><\/Discussion><\/CommentParts><\/Class>", + "key.doc.full_as_xml" : "RawRepresentable<\/Name>s:SY<\/USR>protocol RawRepresentable<\/Declaration>A type that can be converted to and from an associated raw value.<\/Para><\/Abstract>With a RawRepresentable<\/codeVoice> type, you can switch back and forth between a custom type and an associated RawValue<\/codeVoice> type without losing the value of the original RawRepresentable<\/codeVoice> type. Using the raw value of a conforming type streamlines interoperation with Objective-C and legacy APIs and simplifies conformance to other protocols, such as Equatable<\/codeVoice>, Comparable<\/codeVoice>, and Hashable<\/codeVoice>.<\/Para>The RawRepresentable<\/codeVoice> protocol is seen mainly in two categories of types: enumerations with raw value types and option sets.<\/Para>]]><\/rawHTML>Enumerations with Raw Values]]><\/rawHTML>For any enumeration with a string, integer, or floating-point raw type, the Swift compiler automatically adds RawRepresentable<\/codeVoice> conformance. When defining your own custom enumeration, you give it a raw type by specifying the raw type as the first item in the enumeration’s type inheritance list. You can also use literals to specify values for one or more cases.<\/Para>For example, the Counter<\/codeVoice> enumeration defined here has an Int<\/codeVoice> raw value type and gives the first case a raw value of 1<\/codeVoice>:<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>You can create a Counter<\/codeVoice> instance from an integer value between 1 and 5 by using the init?(rawValue:)<\/codeVoice> initializer declared in the RawRepresentable<\/codeVoice> protocol. This initializer is failable because although every case of the Counter<\/codeVoice> type has a corresponding Int<\/codeVoice> value, there are many Int<\/codeVoice> values that don’t<\/emphasis> correspond to a case of Counter<\/codeVoice>.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>]]><\/rawHTML>Option Sets]]><\/rawHTML>Option sets all conform to RawRepresentable<\/codeVoice> by inheritance using the OptionSet<\/codeVoice> protocol. Whether using an option set or creating your own, you use the raw value of an option set instance to store the instance’s bitfield. The raw value must therefore be of a type that conforms to the FixedWidthInteger<\/codeVoice> protocol, such as UInt8<\/codeVoice> or Int<\/codeVoice>. For example, the Direction<\/codeVoice> type defines an option set for the four directions you can move in a game.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>Unlike enumerations, option sets provide a nonfailable init(rawValue:)<\/codeVoice> initializer to convert from a raw value, because option sets don’t have an enumerated list of all possible cases. Option set values have a one-to-one correspondence with their associated raw values.<\/Para>In the case of the Directions<\/codeVoice> option set, an instance can contain zero, one, or more of the four defined directions. This example declares a constant with three currently allowed moves. The raw value of the allowedMoves<\/codeVoice> instance is the result of the bitwise OR of its three members’ raw values:<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>Option sets use bitwise operations on their associated raw values to implement their mathematical set operations. For example, the contains()<\/codeVoice> method on allowedMoves<\/codeVoice> performs a bitwise AND operation to check whether the option set contains an element.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing><\/Discussion><\/CommentParts><\/Class>", "key.doc.name" : "RawRepresentable", "key.doc.type" : "Class", "key.fully_annotated_decl" : "protocol<\/syntaxtype.keyword> RawRepresentable<\/decl.name><\/decl.protocol>", @@ -2353,7 +2353,7 @@ "key.substructure" : [ { "key.accessibility" : "source.lang.swift.accessibility.public", - "key.annotated_decl" : "public static func from(string: String<\/Type>) -> Self<\/Type>?<\/Declaration>", + "key.annotated_decl" : "public static func from(string: String<\/Type>) -> Self<\/Type>?<\/Declaration>", "key.attributes" : [ { "key.attribute" : "source.decl.attribute.public", @@ -2364,7 +2364,7 @@ "key.bodylength" : 58, "key.bodyoffset" : 1079, "key.filepath" : "Sources\/Commandant\/ArgumentProtocol.swift", - "key.fully_annotated_decl" : "public<\/syntaxtype.keyword> static<\/syntaxtype.keyword> func<\/syntaxtype.keyword> from<\/decl.name>(string<\/decl.var.parameter.argument_label>: String<\/ref.struct><\/decl.var.parameter.type><\/decl.var.parameter>) -> Self<\/ref.generic_type_param>?<\/decl.function.returntype><\/decl.function.method.static>", + "key.fully_annotated_decl" : "public<\/syntaxtype.keyword> static<\/syntaxtype.keyword> func<\/syntaxtype.keyword> from<\/decl.name>(string<\/decl.var.parameter.argument_label>: String<\/ref.struct><\/decl.var.parameter.type><\/decl.var.parameter>) -> Self<\/ref.generic_type_param>?<\/decl.function.returntype><\/decl.function.method.static>", "key.groupname" : "Protocols", "key.kind" : "source.lang.swift.decl.function.method.static", "key.length" : 102, @@ -2377,7 +2377,7 @@ "key.parsed_scope.start" : 41, "key.related_decls" : [ { - "key.annotated_decl" : "from(string: String) -> Self?<\/RelatedName>" + "key.annotated_decl" : "from(string: String) -> Self?<\/RelatedName>" }, { "key.annotated_decl" : "from(string: String) -> `Self`?<\/RelatedName>" @@ -2388,12 +2388,12 @@ ], "key.typename" : " (Self.Type) -> (String) -> Self?", "key.typeusr" : "$S6stringxSgSS_tcD", - "key.usr" : "s:s16RawRepresentableP10CommandantAC16ArgumentProtocolRzs17FixedWidthInteger0A5ValueABRpzrlE4from6stringxSgSS_tFZ" + "key.usr" : "s:SY10CommandantAA16ArgumentProtocolRzs17FixedWidthInteger8RawValueSYRpzrlE4from6stringxSgSS_tFZ" } ], "key.typename" : "RawRepresentable.Protocol", - "key.typeusr" : "$Ss16RawRepresentable_pmD", - "key.usr" : "s:s16RawRepresentableP" + "key.typeusr" : "$SSY_pmD", + "key.usr" : "s:SY" } ] } @@ -3020,8 +3020,8 @@ "key.parsed_scope.start" : 80, "key.setter_accessibility" : "source.lang.swift.accessibility.private", "key.typename" : "[String : CommandWrapper]", - "key.typeusr" : "$Ss10DictionaryVySS10Commandant14CommandWrapperVyxGGD", - "key.usr" : "s:10Commandant15CommandRegistryC14commandsByVerb33_1DD6990CD6DFDE28F713A55F8EE2B70ELLs10DictionaryVySSAA0B7WrapperVyxGGvp" + "key.typeusr" : "$SSDySS10Commandant14CommandWrapperVyxGGD", + "key.usr" : "s:10Commandant15CommandRegistryC14commandsByVerb33_1DD6990CD6DFDE28F713A55F8EE2B70ELLSDySSAA0B7WrapperVyxGGvp" }, { "key.accessibility" : "source.lang.swift.accessibility.public", @@ -7094,7 +7094,7 @@ "key.substructure" : [ { "key.accessibility" : "source.lang.swift.accessibility.internal", - "key.annotated_decl" : "internal struct OrderedSet<T> where T : Hashable<\/Type><\/Declaration>", + "key.annotated_decl" : "internal struct OrderedSet<T> where T : Hashable<\/Type><\/Declaration>", "key.attributes" : [ { "key.attribute" : "source.decl.attribute.internal", @@ -7115,7 +7115,7 @@ "key.doclength" : 30, "key.docoffset" : 0, "key.filepath" : "Sources\/Commandant\/OrderedSet.swift", - "key.fully_annotated_decl" : "internal<\/syntaxtype.keyword> struct<\/syntaxtype.keyword> OrderedSet<\/decl.name><T<\/decl.generic_type_param.name><\/decl.generic_type_param>> where<\/syntaxtype.keyword> T : Hashable<\/ref.protocol><\/decl.generic_type_requirement><\/decl.struct>", + "key.fully_annotated_decl" : "internal<\/syntaxtype.keyword> struct<\/syntaxtype.keyword> OrderedSet<\/decl.name><T<\/decl.generic_type_param.name><\/decl.generic_type_param>> where<\/syntaxtype.keyword> T : Hashable<\/ref.protocol><\/decl.generic_type_requirement><\/decl.struct>", "key.kind" : "source.lang.swift.decl.struct", "key.length" : 376, "key.name" : "OrderedSet", @@ -7127,7 +7127,7 @@ "key.parsed_scope.start" : 2, "key.substructure" : [ { - "key.annotated_decl" : "T : Hashable<\/Type><\/Declaration>", + "key.annotated_decl" : "T : Hashable<\/Type><\/Declaration>", "key.elements" : [ { "key.kind" : "source.lang.swift.structure.elem.typeref", @@ -7136,7 +7136,7 @@ } ], "key.filepath" : "Sources\/Commandant\/OrderedSet.swift", - "key.fully_annotated_decl" : "T<\/decl.generic_type_param.name> : Hashable<\/ref.protocol><\/decl.generic_type_param.constraint><\/decl.generic_type_param>", + "key.fully_annotated_decl" : "T<\/decl.generic_type_param.name> : Hashable<\/ref.protocol><\/decl.generic_type_param.constraint><\/decl.generic_type_param>", "key.inheritedtypes" : [ { "key.name" : "Hashable" @@ -7183,11 +7183,11 @@ }, { "key.accessibility" : "source.lang.swift.accessibility.internal", - "key.annotated_decl" : "init<S>(_ sequence: S<\/Type>) where T == S.Element, S : Sequence<\/Type><\/Declaration>", + "key.annotated_decl" : "init<S>(_ sequence: S<\/Type>) where T == S.Element, S : Sequence<\/Type><\/Declaration>", "key.bodylength" : 74, "key.bodyoffset" : 163, "key.filepath" : "Sources\/Commandant\/OrderedSet.swift", - "key.fully_annotated_decl" : "init<\/syntaxtype.keyword><S<\/decl.generic_type_param.name><\/decl.generic_type_param>>(_<\/decl.var.parameter.argument_label> sequence<\/decl.var.parameter.name>: S<\/ref.generic_type_param><\/decl.var.parameter.type><\/decl.var.parameter>) where<\/syntaxtype.keyword> T == S.Element<\/decl.generic_type_requirement>, S : Sequence<\/ref.protocol><\/decl.generic_type_requirement><\/decl.function.constructor>", + "key.fully_annotated_decl" : "init<\/syntaxtype.keyword><S<\/decl.generic_type_param.name><\/decl.generic_type_param>>(_<\/decl.var.parameter.argument_label> sequence<\/decl.var.parameter.name>: S<\/ref.generic_type_param><\/decl.var.parameter.type><\/decl.var.parameter>) where<\/syntaxtype.keyword> T == S.Element<\/decl.generic_type_requirement>, S : Sequence<\/ref.protocol><\/decl.generic_type_requirement><\/decl.function.constructor>", "key.kind" : "source.lang.swift.decl.function.method.instance", "key.length" : 130, "key.name" : "init(_:)", @@ -7199,7 +7199,7 @@ "key.parsed_scope.start" : 5, "key.substructure" : [ { - "key.annotated_decl" : "S : Sequence<\/Type><\/Declaration>", + "key.annotated_decl" : "S : Sequence<\/Type><\/Declaration>", "key.elements" : [ { "key.kind" : "source.lang.swift.structure.elem.typeref", @@ -7208,7 +7208,7 @@ } ], "key.filepath" : "Sources\/Commandant\/OrderedSet.swift", - "key.fully_annotated_decl" : "S<\/decl.generic_type_param.name> : Sequence<\/ref.protocol><\/decl.generic_type_param.constraint><\/decl.generic_type_param>", + "key.fully_annotated_decl" : "S<\/decl.generic_type_param.name> : Sequence<\/ref.protocol><\/decl.generic_type_param.constraint><\/decl.generic_type_param>", "key.inheritedtypes" : [ { "key.name" : "Sequence" @@ -7225,12 +7225,12 @@ "key.parsed_scope.start" : 5, "key.typename" : "S.Type", "key.typeusr" : "$Sqd__mD", - "key.usr" : "s:10Commandant10OrderedSetVyACyxGqd__c7ElementQyd__Rszs8SequenceRd__lufc1SL_qd__mfp" + "key.usr" : "s:10Commandant10OrderedSetVyACyxGqd__c7ElementQyd__RszSTRd__lufc1SL_qd__mfp" } ], "key.typename" : " (OrderedSet.Type) -> (S) -> OrderedSet", - "key.typeusr" : "$Sy10Commandant10OrderedSetVyxGqd__c7ElementQyd__Rszs8SequenceRd__luD", - "key.usr" : "s:10Commandant10OrderedSetVyACyxGqd__c7ElementQyd__Rszs8SequenceRd__lufc" + "key.typeusr" : "$Sy10Commandant10OrderedSetVyxGqd__c7ElementQyd__RszSTRd__luD", + "key.usr" : "s:10Commandant10OrderedSetVyACyxGqd__c7ElementQyd__RszSTRd__lufc" }, { "key.accessibility" : "source.lang.swift.accessibility.internal", @@ -7273,7 +7273,7 @@ "key.usr" : "s:10Commandant10OrderedSetV" }, { - "key.annotated_decl" : "internal struct OrderedSet<T> where T : Hashable<\/Type><\/Declaration>", + "key.annotated_decl" : "internal struct OrderedSet<T> where T : Hashable<\/Type><\/Declaration>", "key.bodylength" : 101, "key.bodyoffset" : 450, "key.doc.column" : 17, @@ -7291,7 +7291,7 @@ } ], "key.filepath" : "Sources\/Commandant\/OrderedSet.swift", - "key.fully_annotated_decl" : "internal<\/syntaxtype.keyword> struct<\/syntaxtype.keyword> OrderedSet<\/decl.name><T<\/decl.generic_type_param.name><\/decl.generic_type_param>> where<\/syntaxtype.keyword> T : Hashable<\/ref.protocol><\/decl.generic_type_requirement><\/decl.struct>", + "key.fully_annotated_decl" : "internal<\/syntaxtype.keyword> struct<\/syntaxtype.keyword> OrderedSet<\/decl.name><T<\/decl.generic_type_param.name><\/decl.generic_type_param>> where<\/syntaxtype.keyword> T : Hashable<\/ref.protocol><\/decl.generic_type_requirement><\/decl.struct>", "key.inheritedtypes" : [ { "key.name" : "Equatable" @@ -7315,7 +7315,7 @@ "Para" : "Equality is the inverse of inequality. For any values `a` and `b`, `a == b` implies that `a != b` is `false`." } ], - "key.doc.full_as_xml" : "==(_:_:)<\/Name>s:s9EquatableP2eeoiySbx_xtFZ<\/USR>static func == (lhs: Self, rhs: Self) -> Bool<\/Declaration>Returns a Boolean value indicating whether two values are equal.<\/Para><\/Abstract>lhs<\/Name>in<\/Direction>A value to compare.<\/Para><\/Discussion><\/Parameter>rhs<\/Name>in<\/Direction>Another value to compare.<\/Para><\/Discussion><\/Parameter><\/Parameters>Equality is the inverse of inequality. For any values a<\/codeVoice> and b<\/codeVoice>, a == b<\/codeVoice> implies that a != b<\/codeVoice> is false<\/codeVoice>.<\/Para><\/Discussion><\/CommentParts><\/Function>", + "key.doc.full_as_xml" : "==(_:_:)<\/Name>s:SQ2eeoiySbx_xtFZ<\/USR>static func == (lhs: Self, rhs: Self) -> Bool<\/Declaration>Returns a Boolean value indicating whether two values are equal.<\/Para><\/Abstract>lhs<\/Name>in<\/Direction>A value to compare.<\/Para><\/Discussion><\/Parameter>rhs<\/Name>in<\/Direction>Another value to compare.<\/Para><\/Discussion><\/Parameter><\/Parameters>Equality is the inverse of inequality. For any values a<\/codeVoice> and b<\/codeVoice>, a == b<\/codeVoice> implies that a != b<\/codeVoice> is false<\/codeVoice>.<\/Para><\/Discussion><\/CommentParts><\/Function>", "key.doc.name" : "==(_:_:)", "key.doc.parameters" : [ { @@ -7346,7 +7346,7 @@ "key.offset" : 452, "key.overrides" : [ { - "key.usr" : "s:s9EquatableP2eeoiySbx_xtFZ" + "key.usr" : "s:SQ2eeoiySbx_xtFZ" } ], "key.parsed_declaration" : "static func == (_ lhs: OrderedSet, rhs: OrderedSet) -> Bool", @@ -7357,64 +7357,64 @@ "key.annotated_decl" : "== (_: Any.Type?, _: Any.Type?) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== <T>(_: T, _: T) -> Bool where T : RawRepresentable, T.RawValue : Equatable<\/RelatedName>" + "key.annotated_decl" : "== <T>(_: T, _: T) -> Bool where T : RawRepresentable, T.RawValue : Equatable<\/RelatedName>" }, { "key.annotated_decl" : "== (_: (), _: ()) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== <A, B>(_: (A, B), _: (A, B)) -> Bool where A : Equatable, B : Equatable<\/RelatedName>" + "key.annotated_decl" : "== <A, B>(_: (A, B), _: (A, B)) -> Bool where A : Equatable, B : Equatable<\/RelatedName>" }, { - "key.annotated_decl" : "== <A, B, C>(_: (A, B, C), _: (A, B, C)) -> Bool where A : Equatable, B : Equatable, C : Equatable<\/RelatedName>" + "key.annotated_decl" : "== <A, B, C>(_: (A, B, C), _: (A, B, C)) -> Bool where A : Equatable, B : Equatable, C : Equatable<\/RelatedName>" }, { - "key.annotated_decl" : "== <A, B, C, D>(_: (A, B, C, D), _: (A, B, C, D)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable<\/RelatedName>" + "key.annotated_decl" : "== <A, B, C, D>(_: (A, B, C, D), _: (A, B, C, D)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable<\/RelatedName>" }, { - "key.annotated_decl" : "== <A, B, C, D, E>(_: (A, B, C, D, E), _: (A, B, C, D, E)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable<\/RelatedName>" + "key.annotated_decl" : "== <A, B, C, D, E>(_: (A, B, C, D, E), _: (A, B, C, D, E)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable<\/RelatedName>" }, { - "key.annotated_decl" : "== <A, B, C, D, E, F>(_: (A, B, C, D, E, F), _: (A, B, C, D, E, F)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable<\/RelatedName>" + "key.annotated_decl" : "== <A, B, C, D, E, F>(_: (A, B, C, D, E, F), _: (A, B, C, D, E, F)) -> Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: ContiguousArray<ContiguousArray<Element>.Element>, _: ContiguousArray<ContiguousArray<Element>.Element>) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: ContiguousArray<ContiguousArray<Element>.Element>, _: ContiguousArray<ContiguousArray<Element>.Element>) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: ArraySlice<ArraySlice<Element>.Element>, _: ArraySlice<ArraySlice<Element>.Element>) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: ArraySlice<ArraySlice<Element>.Element>, _: ArraySlice<ArraySlice<Element>.Element>) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Array<Array<Element>.Element>, _: Array<Array<Element>.Element>) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Array<Array<Element>.Element>, _: Array<Array<Element>.Element>) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: Bool, _: Bool) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Character, _: Character) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Character, _: Character) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Character.UnicodeScalarView.Index, _: Character.UnicodeScalarView.Index) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Character.UnicodeScalarView.Index, _: Character.UnicodeScalarView.Index) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: CodingUserInfoKey, _: CodingUserInfoKey) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: ClosedRange<Bound>.Index, _: ClosedRange<Bound>.Index) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: ClosedRange<Bound>.Index, _: ClosedRange<Bound>.Index) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: ClosedRange<Bound>, _: ClosedRange<Bound>) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: ClosedRange<Bound>, _: ClosedRange<Bound>) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: OpaquePointer, _: OpaquePointer) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Dictionary<Key, Value>.Keys, _: Dictionary<Key, Value>.Keys) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Dictionary<Key, Value>.Keys, _: Dictionary<Key, Value>.Keys) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: [Key : Value], _: [Key : Value]) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: [Key : Value], _: [Key : Value]) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Dictionary<Key, Value>.Index, _: Dictionary<Key, Value>.Index) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Dictionary<Key, Value>.Index, _: Dictionary<Key, Value>.Index) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: LazyDropWhileCollection<Base>.Index, _: LazyDropWhileCollection<Base>.Index) -> Bool<\/RelatedName>" @@ -7423,7 +7423,7 @@ "key.annotated_decl" : "== (_: EmptyCollection<Element>, _: EmptyCollection<Element>) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: FlattenCollection<Base>.Index, _: FlattenCollection<Base>.Index) -> Bool<\/RelatedName>" @@ -7432,13 +7432,13 @@ "key.annotated_decl" : "== (_: FloatingPointSign, _: FloatingPointSign) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: AnyHashable, _: AnyHashable) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== <Other>(_: Self, _: Other) -> Bool where Other : BinaryInteger<\/RelatedName>" + "key.annotated_decl" : "== <Other>(_: Self, _: Other) -> Bool where Other : BinaryInteger<\/RelatedName>" }, { "key.annotated_decl" : "== (_: UInt8, _: UInt8) -> Bool<\/RelatedName>" @@ -7480,10 +7480,10 @@ "key.annotated_decl" : "== (_: Unicode.Scalar, _: Unicode.Scalar) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: ObjectIdentifier, _: ObjectIdentifier) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: ObjectIdentifier, _: ObjectIdentifier) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Wrapped?, _: Wrapped?) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Wrapped?, _: Wrapped?) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: Wrapped?, _: _OptionalNilComparisonType) -> Bool<\/RelatedName>" @@ -7495,22 +7495,22 @@ "key.annotated_decl" : "== (_: LazyPrefixWhileCollection<Base>.Index, _: LazyPrefixWhileCollection<Base>.Index) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Range<Range<Bound>.Bound>, _: Range<Range<Bound>.Bound>) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Range<Range<Bound>.Bound>, _: Range<Range<Bound>.Bound>) -> Bool<\/RelatedName>" }, { "key.annotated_decl" : "== (_: ReversedCollection<Base>.Index, _: ReversedCollection<Base>.Index) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Set<Element>, _: Set<Element>) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Set<Element>, _: Set<Element>) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Set<Element>.Index, _: Set<Element>.Index) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Set<Element>.Index, _: Set<Element>.Index) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" + "key.annotated_decl" : "== (_: Self, _: Self) -> Bool<\/RelatedName>" }, { - "key.annotated_decl" : "== <S>(_: Self, _: S) -> Bool where S : StringProtocol<\/RelatedName>" + "key.annotated_decl" : "== <S>(_: Self, _: S) -> Bool where S : StringProtocol<\/RelatedName>" }, { "key.annotated_decl" : "== (_: String, _: String) -> Bool<\/RelatedName>" @@ -7551,7 +7551,7 @@ ], "key.typename" : " (OrderedSet.Type) -> (OrderedSet, OrderedSet) -> Bool", "key.typeusr" : "$SySb10Commandant10OrderedSetVyxG_ADtcD", - "key.usr" : "s:s9EquatableP2eeoiySbx_xtFZ" + "key.usr" : "s:SQ2eeoiySbx_xtFZ" } ], "key.typename" : "OrderedSet.Type", @@ -7559,7 +7559,7 @@ "key.usr" : "s:10Commandant10OrderedSetV" }, { - "key.annotated_decl" : "internal struct OrderedSet<T> where T : Hashable<\/Type><\/Declaration>", + "key.annotated_decl" : "internal struct OrderedSet<T> where T : Hashable<\/Type><\/Declaration>", "key.bodylength" : 331, "key.bodyoffset" : 588, "key.doc.column" : 17, @@ -7577,7 +7577,7 @@ } ], "key.filepath" : "Sources\/Commandant\/OrderedSet.swift", - "key.fully_annotated_decl" : "internal<\/syntaxtype.keyword> struct<\/syntaxtype.keyword> OrderedSet<\/decl.name><T<\/decl.generic_type_param.name><\/decl.generic_type_param>> where<\/syntaxtype.keyword> T : Hashable<\/ref.protocol><\/decl.generic_type_requirement><\/decl.struct>", + "key.fully_annotated_decl" : "internal<\/syntaxtype.keyword> struct<\/syntaxtype.keyword> OrderedSet<\/decl.name><T<\/decl.generic_type_param.name><\/decl.generic_type_param>> where<\/syntaxtype.keyword> T : Hashable<\/ref.protocol><\/decl.generic_type_requirement><\/decl.struct>", "key.inheritedtypes" : [ { "key.name" : "Collection" @@ -7610,7 +7610,7 @@ "Complexity" : "" } ], - "key.doc.full_as_xml" : "subscript(_:)<\/Name>s:s10CollectionPy7ElementQz5IndexQzcip<\/USR>subscript(position: Self.Index) -> Self.Element { get }<\/Declaration>Accesses the element at the specified position.<\/Para><\/Abstract>position<\/Name>in<\/Direction>The position of the element to access. position<\/codeVoice> must be a valid index of the collection that is not equal to the endIndex<\/codeVoice> property.<\/Para><\/Discussion><\/Parameter><\/Parameters>The following example accesses an element of an array through its subscript to print its value:<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>You can subscript a collection with any valid index other than the collection’s end index. The end index refers to the position one past the last element of a collection, so it doesn’t correspond with an element.<\/Para>O(1)<\/Para><\/Complexity><\/Discussion><\/CommentParts><\/Other>", + "key.doc.full_as_xml" : "subscript(_:)<\/Name>s:Sly7ElementQz5IndexQzcip<\/USR>subscript(position: Self.Index) -> Self.Element { get }<\/Declaration>Accesses the element at the specified position.<\/Para><\/Abstract>position<\/Name>in<\/Direction>The position of the element to access. position<\/codeVoice> must be a valid index of the collection that is not equal to the endIndex<\/codeVoice> property.<\/Para><\/Discussion><\/Parameter><\/Parameters>The following example accesses an element of an array through its subscript to print its value:<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>You can subscript a collection with any valid index other than the collection’s end index. The end index refers to the position one past the last element of a collection, so it doesn’t correspond with an element.<\/Para>O(1)<\/Para><\/Complexity><\/Discussion><\/CommentParts><\/Other>", "key.doc.name" : "subscript(_:)", "key.doc.parameters" : [ { @@ -7633,7 +7633,7 @@ "key.offset" : 590, "key.overrides" : [ { - "key.usr" : "s:s10CollectionPy7ElementQz5IndexQzcip" + "key.usr" : "s:Sly7ElementQz5IndexQzcip" } ], "key.parsed_declaration" : "subscript(position: Int) -> T", @@ -7644,7 +7644,7 @@ ], "key.typename" : " (Int) -> T", "key.typeusr" : "$SyxSicD", - "key.usr" : "s:s10CollectionPy7ElementQz5IndexQzcip" + "key.usr" : "s:Sly7ElementQz5IndexQzcip" }, { "key.accessibility" : "source.lang.swift.accessibility.internal", @@ -7660,7 +7660,7 @@ "Complexity" : "" } ], - "key.doc.full_as_xml" : "count<\/Name>s:s10CollectionP5countSivp<\/USR>var count: Int { get }<\/Declaration>The number of elements in the collection.<\/Para><\/Abstract>To check whether a collection is empty, use its isEmpty<\/codeVoice> property instead of comparing count<\/codeVoice> to zero. Unless the collection guarantees random-access performance, calculating count<\/codeVoice> can be an O(n<\/emphasis>) operation.<\/Para>O(1) if the collection conforms to RandomAccessCollection<\/codeVoice>; otherwise, O(n<\/emphasis>), where n<\/emphasis> is the length of the collection.<\/Para><\/Complexity><\/Discussion><\/CommentParts><\/Other>", + "key.doc.full_as_xml" : "count<\/Name>s:Sl5countSivp<\/USR>var count: Int { get }<\/Declaration>The number of elements in the collection.<\/Para><\/Abstract>To check whether a collection is empty, use its isEmpty<\/codeVoice> property instead of comparing count<\/codeVoice> to zero. Unless the collection guarantees random-access performance, calculating count<\/codeVoice> can be an O(n<\/emphasis>) operation.<\/Para>O(1) if the collection conforms to RandomAccessCollection<\/codeVoice>; otherwise, O(n<\/emphasis>), where n<\/emphasis> is the length of the collection.<\/Para><\/Complexity><\/Discussion><\/CommentParts><\/Other>", "key.doc.name" : "count", "key.doc.type" : "Other", "key.filepath" : "Sources\/Commandant\/OrderedSet.swift", @@ -7673,7 +7673,7 @@ "key.offset" : 653, "key.overrides" : [ { - "key.usr" : "s:s10CollectionP5countSivp" + "key.usr" : "s:Sl5countSivp" } ], "key.parsed_declaration" : "var count: Int", @@ -7681,7 +7681,7 @@ "key.parsed_scope.start" : 32, "key.typename" : "Int", "key.typeusr" : "$SSiD", - "key.usr" : "s:s10CollectionP5countSivp" + "key.usr" : "s:Sl5countSivp" }, { "key.accessibility" : "source.lang.swift.accessibility.internal", @@ -7700,7 +7700,7 @@ "Complexity" : "" } ], - "key.doc.full_as_xml" : "isEmpty<\/Name>s:s10CollectionP7isEmptySbvp<\/USR>var isEmpty: Bool { get }<\/Declaration>A Boolean value indicating whether the collection is empty.<\/Para><\/Abstract>When you need to check whether your collection is empty, use the isEmpty<\/codeVoice> property instead of checking that the count<\/codeVoice> property is equal to zero. For collections that don’t conform to RandomAccessCollection<\/codeVoice>, accessing the count<\/codeVoice> property iterates through the elements of the collection.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>O(1)<\/Para><\/Complexity><\/Discussion><\/CommentParts><\/Other>", + "key.doc.full_as_xml" : "isEmpty<\/Name>s:Sl7isEmptySbvp<\/USR>var isEmpty: Bool { get }<\/Declaration>A Boolean value indicating whether the collection is empty.<\/Para><\/Abstract>When you need to check whether your collection is empty, use the isEmpty<\/codeVoice> property instead of checking that the count<\/codeVoice> property is equal to zero. For collections that don’t conform to RandomAccessCollection<\/codeVoice>, accessing the count<\/codeVoice> property iterates through the elements of the collection.<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>O(1)<\/Para><\/Complexity><\/Discussion><\/CommentParts><\/Other>", "key.doc.name" : "isEmpty", "key.doc.type" : "Other", "key.filepath" : "Sources\/Commandant\/OrderedSet.swift", @@ -7713,7 +7713,7 @@ "key.offset" : 697, "key.overrides" : [ { - "key.usr" : "s:s10CollectionP7isEmptySbvp" + "key.usr" : "s:Sl7isEmptySbvp" } ], "key.parsed_declaration" : "var isEmpty: Bool", @@ -7721,7 +7721,7 @@ "key.parsed_scope.start" : 36, "key.typename" : "Bool", "key.typeusr" : "$SSbD", - "key.usr" : "s:s10CollectionP7isEmptySbvp" + "key.usr" : "s:Sl7isEmptySbvp" }, { "key.accessibility" : "source.lang.swift.accessibility.internal", @@ -7734,7 +7734,7 @@ "Para" : "If the collection is empty, `startIndex` is equal to `endIndex`." } ], - "key.doc.full_as_xml" : "startIndex<\/Name>s:s10CollectionP10startIndex0C0Qzvp<\/USR>var startIndex: Self.Index { get }<\/Declaration>The position of the first element in a nonempty collection.<\/Para><\/Abstract>If the collection is empty, startIndex<\/codeVoice> is equal to endIndex<\/codeVoice>.<\/Para><\/Discussion><\/CommentParts><\/Other>", + "key.doc.full_as_xml" : "startIndex<\/Name>s:Sl10startIndex0B0Qzvp<\/USR>var startIndex: Self.Index { get }<\/Declaration>The position of the first element in a nonempty collection.<\/Para><\/Abstract>If the collection is empty, startIndex<\/codeVoice> is equal to endIndex<\/codeVoice>.<\/Para><\/Discussion><\/CommentParts><\/Other>", "key.doc.name" : "startIndex", "key.doc.type" : "Other", "key.filepath" : "Sources\/Commandant\/OrderedSet.swift", @@ -7747,7 +7747,7 @@ "key.offset" : 746, "key.overrides" : [ { - "key.usr" : "s:s10CollectionP10startIndex0C0Qzvp" + "key.usr" : "s:Sl10startIndex0B0Qzvp" } ], "key.parsed_declaration" : "var startIndex: Int", @@ -7755,7 +7755,7 @@ "key.parsed_scope.start" : 40, "key.typename" : "Int", "key.typeusr" : "$SSiD", - "key.usr" : "s:s10CollectionP10startIndex0C0Qzvp" + "key.usr" : "s:Sl10startIndex0B0Qzvp" }, { "key.accessibility" : "source.lang.swift.accessibility.internal", @@ -7774,7 +7774,7 @@ "Para" : "If the collection is empty, `endIndex` is equal to `startIndex`." } ], - "key.doc.full_as_xml" : "endIndex<\/Name>s:s10CollectionP8endIndex0C0Qzvp<\/USR>var endIndex: Self.Index { get }<\/Declaration>The collection’s “past the end” position—that is, the position one greater than the last valid subscript argument.<\/Para><\/Abstract>When you need a range that includes the last element of a collection, use the half-open range operator (..<<\/codeVoice>) with endIndex<\/codeVoice>. The ..<<\/codeVoice> operator creates a range that doesn’t include the upper bound, so it’s always safe to use with endIndex<\/codeVoice>. For example:<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>If the collection is empty, endIndex<\/codeVoice> is equal to startIndex<\/codeVoice>.<\/Para><\/Discussion><\/CommentParts><\/Other>", + "key.doc.full_as_xml" : "endIndex<\/Name>s:Sl8endIndex0B0Qzvp<\/USR>var endIndex: Self.Index { get }<\/Declaration>The collection’s “past the end” position—that is, the position one greater than the last valid subscript argument.<\/Para><\/Abstract>When you need a range that includes the last element of a collection, use the half-open range operator (..<<\/codeVoice>) with endIndex<\/codeVoice>. The ..<<\/codeVoice> operator creates a range that doesn’t include the upper bound, so it’s always safe to use with endIndex<\/codeVoice>. For example:<\/Para><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/zCodeLineNumbered><\/CodeListing>If the collection is empty, endIndex<\/codeVoice> is equal to startIndex<\/codeVoice>.<\/Para><\/Discussion><\/CommentParts><\/Other>", "key.doc.name" : "endIndex", "key.doc.type" : "Other", "key.filepath" : "Sources\/Commandant\/OrderedSet.swift", @@ -7787,7 +7787,7 @@ "key.offset" : 800, "key.overrides" : [ { - "key.usr" : "s:s10CollectionP8endIndex0C0Qzvp" + "key.usr" : "s:Sl8endIndex0B0Qzvp" } ], "key.parsed_declaration" : "var endIndex: Int", @@ -7795,7 +7795,7 @@ "key.parsed_scope.start" : 44, "key.typename" : "Int", "key.typeusr" : "$SSiD", - "key.usr" : "s:s10CollectionP8endIndex0C0Qzvp" + "key.usr" : "s:Sl8endIndex0B0Qzvp" }, { "key.accessibility" : "source.lang.swift.accessibility.internal", @@ -7808,7 +7808,7 @@ "Para" : "The successor of an index must be well defined. For an index `i` into a collection `c`, calling `c.index(after: i)` returns the same index every time." } ], - "key.doc.full_as_xml" : "index(after:)<\/Name>s:s10CollectionP5index5after5IndexQzAF_tF<\/USR>func index(after i: Self.Index) -> Self.Index<\/Declaration>Returns the position immediately after the given index.<\/Para><\/Abstract>i<\/Name>in<\/Direction>A valid index of the collection. i<\/codeVoice> must be less than endIndex<\/codeVoice>.<\/Para><\/Discussion><\/Parameter><\/Parameters>The index value immediately after i<\/codeVoice>.<\/Para><\/ResultDiscussion>The successor of an index must be well defined. For an index i<\/codeVoice> into a collection c<\/codeVoice>, calling c.index(after: i)<\/codeVoice> returns the same index every time.<\/Para><\/Discussion><\/CommentParts><\/Function>", + "key.doc.full_as_xml" : "index(after:)<\/Name>s:Sl5index5after5IndexQzAD_tF<\/USR>func index(after i: Self.Index) -> Self.Index<\/Declaration>Returns the position immediately after the given index.<\/Para><\/Abstract>i<\/Name>in<\/Direction>A valid index of the collection. i<\/codeVoice> must be less than endIndex<\/codeVoice>.<\/Para><\/Discussion><\/Parameter><\/Parameters>The index value immediately after i<\/codeVoice>.<\/Para><\/ResultDiscussion>The successor of an index must be well defined. For an index i<\/codeVoice> into a collection c<\/codeVoice>, calling c.index(after: i)<\/codeVoice> returns the same index every time.<\/Para><\/Discussion><\/CommentParts><\/Function>", "key.doc.name" : "index(after:)", "key.doc.parameters" : [ { @@ -7836,7 +7836,7 @@ "key.offset" : 850, "key.overrides" : [ { - "key.usr" : "s:s10CollectionP5index5after5IndexQzAF_tF" + "key.usr" : "s:Sl5index5after5IndexQzAD_tF" } ], "key.parsed_declaration" : "func index(after i: Int) -> Int", @@ -7847,7 +7847,7 @@ ], "key.typename" : " (OrderedSet) -> (Int) -> Int", "key.typeusr" : "$S5afterS2i_tcD", - "key.usr" : "s:s10CollectionP5index5after5IndexQzAF_tF" + "key.usr" : "s:Sl5index5after5IndexQzAD_tF" } ], "key.typename" : "OrderedSet.Type", @@ -7938,7 +7938,7 @@ }, { "key.accessibility" : "source.lang.swift.accessibility.public", - "key.annotated_decl" : "public let flag: Character<\/Type>?<\/Declaration>", + "key.annotated_decl" : "public let flag: Character<\/Type>?<\/Declaration>", "key.attributes" : [ { "key.attribute" : "source.decl.attribute.public", @@ -7955,14 +7955,14 @@ } ], "key.doc.file" : "Sources\/Commandant\/Switch.swift", - "key.doc.full_as_xml" : "flag<\/Name>s:10Commandant6SwitchV4flags9CharacterVSgvp<\/USR>public let flag: Character?<\/Declaration>Optional single letter flag that enables this switch. For example, -v<\/codeVoice> would be used as a shorthand for --verbose<\/codeVoice>.<\/Para><\/Abstract>Multiple flags can be grouped together as a single argument and will split when parsing (e.g. rm -rf<\/codeVoice> treats ‘r’ and ‘f’ as inidividual flags).<\/Para><\/Discussion><\/CommentParts><\/Other>", + "key.doc.full_as_xml" : "flag<\/Name>s:10Commandant6SwitchV4flagSJSgvp<\/USR>public let flag: Character?<\/Declaration>Optional single letter flag that enables this switch. For example, -v<\/codeVoice> would be used as a shorthand for --verbose<\/codeVoice>.<\/Para><\/Abstract>Multiple flags can be grouped together as a single argument and will split when parsing (e.g. rm -rf<\/codeVoice> treats ‘r’ and ‘f’ as inidividual flags).<\/Para><\/Discussion><\/CommentParts><\/Other>", "key.doc.line" : 25, "key.doc.name" : "flag", "key.doc.type" : "Other", "key.doclength" : 287, "key.docoffset" : 555, "key.filepath" : "Sources\/Commandant\/Switch.swift", - "key.fully_annotated_decl" : "public<\/syntaxtype.keyword> let<\/syntaxtype.keyword> flag<\/decl.name>: Character<\/ref.struct>?<\/decl.var.type><\/decl.var.instance>", + "key.fully_annotated_decl" : "public<\/syntaxtype.keyword> let<\/syntaxtype.keyword> flag<\/decl.name>: Character<\/ref.struct>?<\/decl.var.type><\/decl.var.instance>", "key.kind" : "source.lang.swift.decl.var.instance", "key.length" : 20, "key.name" : "flag", @@ -7973,8 +7973,8 @@ "key.parsed_scope.end" : 25, "key.parsed_scope.start" : 25, "key.typename" : "Character?", - "key.typeusr" : "$Ss9CharacterVSgD", - "key.usr" : "s:10Commandant6SwitchV4flags9CharacterVSgvp" + "key.typeusr" : "$SSJSgD", + "key.usr" : "s:10Commandant6SwitchV4flagSJSgvp" }, { "key.accessibility" : "source.lang.swift.accessibility.public", @@ -8013,7 +8013,7 @@ }, { "key.accessibility" : "source.lang.swift.accessibility.public", - "key.annotated_decl" : "public init(flag: Character<\/Type>? = default, key: String<\/Type>, usage: String<\/Type>)<\/Declaration>", + "key.annotated_decl" : "public init(flag: Character<\/Type>? = default, key: String<\/Type>, usage: String<\/Type>)<\/Declaration>", "key.attributes" : [ { "key.attribute" : "source.decl.attribute.public", @@ -8024,7 +8024,7 @@ "key.bodylength" : 59, "key.bodyoffset" : 1075, "key.filepath" : "Sources\/Commandant\/Switch.swift", - "key.fully_annotated_decl" : "public<\/syntaxtype.keyword> init<\/syntaxtype.keyword>(flag<\/decl.var.parameter.argument_label>: Character<\/ref.struct>?<\/decl.var.parameter.type> = default<\/syntaxtype.keyword><\/decl.var.parameter>, key<\/decl.var.parameter.argument_label>: String<\/ref.struct><\/decl.var.parameter.type><\/decl.var.parameter>, usage<\/decl.var.parameter.argument_label>: String<\/ref.struct><\/decl.var.parameter.type><\/decl.var.parameter>)<\/decl.function.constructor>", + "key.fully_annotated_decl" : "public<\/syntaxtype.keyword> init<\/syntaxtype.keyword>(flag<\/decl.var.parameter.argument_label>: Character<\/ref.struct>?<\/decl.var.parameter.type> = default<\/syntaxtype.keyword><\/decl.var.parameter>, key<\/decl.var.parameter.argument_label>: String<\/ref.struct><\/decl.var.parameter.type><\/decl.var.parameter>, usage<\/decl.var.parameter.argument_label>: String<\/ref.struct><\/decl.var.parameter.type><\/decl.var.parameter>)<\/decl.function.constructor>", "key.kind" : "source.lang.swift.decl.function.method.instance", "key.length" : 118, "key.name" : "init(flag:key:usage:)", @@ -8038,8 +8038,8 @@ ], "key.typename" : "(Switch.Type) -> (Character?, String, String) -> Switch", - "key.typeusr" : "$S4flag3key5usage10Commandant6SwitchVs9CharacterVSg_S2StcD", - "key.usr" : "s:10Commandant6SwitchV4flag3key5usageACs9CharacterVSg_S2Stcfc" + "key.typeusr" : "$S4flag3key5usage10Commandant6SwitchVSJSg_S2StcD", + "key.usr" : "s:10Commandant6SwitchV4flag3key5usageACSJSg_S2Stcfc" } ], "key.typename" : "Switch.Type", diff --git a/Tests/SourceKittenFrameworkTests/Fixtures/LinuxSimpleCodeCompletion@swift-4.1.50.json b/Tests/SourceKittenFrameworkTests/Fixtures/LinuxSimpleCodeCompletion@swift-4.1.50.json index fd95886f2..0b22626c3 100644 --- a/Tests/SourceKittenFrameworkTests/Fixtures/LinuxSimpleCodeCompletion@swift-4.1.50.json +++ b/Tests/SourceKittenFrameworkTests/Fixtures/LinuxSimpleCodeCompletion@swift-4.1.50.json @@ -9,7 +9,7 @@ "sourcetext" : "addingReportingOverflow(<#T##other: Int##Int#>)", "typeName" : "(partialValue: Int, overflow: Bool)" }, { - "associatedUSRs" : "s:s13BinaryIntegerPsE8advanced2byxSi_tF", + "associatedUSRs" : "s:SzsE8advanced2byxSi_tF", "context" : "source.codecompletion.context.superclass", "descriptionKey" : "advanced(by: Int)", "docBrief" : "Returns a value that is offset the specified distance from this value.", @@ -19,7 +19,7 @@ "sourcetext" : "advanced(by: <#T##Int#>)", "typeName" : "Int" }, { - "associatedUSRs" : "s:Si8advanced2byS2i_tF s:s10StrideableP8advanced2byx6StrideQz_tF", + "associatedUSRs" : "s:Si8advanced2byS2i_tF s:Sx8advanced2byx6StrideQz_tF", "context" : "source.codecompletion.context.thisclass", "descriptionKey" : "advanced(by: Int)", "docBrief" : "Returns a value that is offset the specified distance from this value.", @@ -79,7 +79,7 @@ "sourcetext" : "customPlaygroundQuickLook", "typeName" : "PlaygroundQuickLook" }, { - "associatedUSRs" : "s:s13BinaryIntegerPsE11descriptionSSvp", + "associatedUSRs" : "s:SzsE11descriptionSSvp", "context" : "source.codecompletion.context.superclass", "descriptionKey" : "description", "docBrief" : "A textual representation of this value.", @@ -89,7 +89,7 @@ "sourcetext" : "description", "typeName" : "String" }, { - "associatedUSRs" : "s:s13BinaryIntegerPsE8distance2toSix_tF", + "associatedUSRs" : "s:SzsE8distance2toSix_tF", "context" : "source.codecompletion.context.superclass", "descriptionKey" : "distance(to: Int)", "docBrief" : "Returns the distance from this value to the given value, expressed as a stride.", @@ -99,7 +99,7 @@ "sourcetext" : "distance(to: <#T##Int#>)", "typeName" : "Int" }, { - "associatedUSRs" : "s:Si8distance2toS2i_tF s:s10StrideableP8distance2to6StrideQzx_tF", + "associatedUSRs" : "s:Si8distance2toS2i_tF s:Sx8distance2to6StrideQzx_tF", "context" : "source.codecompletion.context.thisclass", "descriptionKey" : "distance(to: Int)", "docBrief" : "Returns the distance from this value to the given value, expressed as a stride.", @@ -129,7 +129,7 @@ "sourcetext" : "dividingFullWidth(<#T##dividend: (high: Int, low: Int.Magnitude)##(high: Int, low: Int.Magnitude)#>)", "typeName" : "(quotient: Int, remainder: Int)" }, { - "associatedUSRs" : "s:Si6encode2toys7Encoder_p_tKF s:s9EncodableP6encode2toys7Encoder_p_tKF", + "associatedUSRs" : "s:Si6encode2toys7Encoder_p_tKF s:SE6encode2toys7Encoder_p_tKF", "context" : "source.codecompletion.context.thisclass", "descriptionKey" : "encode(to: Encoder) throws", "docBrief" : "Encodes this value into the given encoder.", @@ -139,7 +139,7 @@ "sourcetext" : "encode(to: <#T##Encoder#>)", "typeName" : "Void" }, { - "associatedUSRs" : "s:Si4hash4intoys6HasherVz_tF s:s8HashableP4hash4intoys6HasherVz_tF", + "associatedUSRs" : "s:Si4hash4intoys6HasherVz_tF s:SH4hash4intoys6HasherVz_tF", "context" : "source.codecompletion.context.thisclass", "descriptionKey" : "hash(into: &Hasher)", "docBrief" : "Hashes the essential components of this value by feeding them into the given hasher.", @@ -149,7 +149,7 @@ "sourcetext" : "hash(into: &<#T##Hasher#>)", "typeName" : "Void" }, { - "associatedUSRs" : "s:Si9hashValueSivp s:s8HashableP9hashValueSivp", + "associatedUSRs" : "s:Si9hashValueSivp s:SH9hashValueSivp", "context" : "source.codecompletion.context.thisclass", "descriptionKey" : "hashValue", "kind" : "source.lang.swift.decl.var.instance", @@ -178,7 +178,7 @@ "sourcetext" : "littleEndian", "typeName" : "Int" }, { - "associatedUSRs" : "s:Si9magnitudeSuvp s:s7NumericP9magnitude9MagnitudeQzvp", + "associatedUSRs" : "s:Si9magnitudeSuvp s:Sj9magnitude9MagnitudeQzvp", "context" : "source.codecompletion.context.thisclass", "descriptionKey" : "magnitude", "docBrief" : "The magnitude of this value.", @@ -228,7 +228,7 @@ "sourcetext" : "nonzeroBitCount", "typeName" : "Int" }, { - "associatedUSRs" : "s:s13BinaryIntegerPsE20quotientAndRemainder10dividingByx0C0_x9remaindertx_tF", + "associatedUSRs" : "s:SzsE20quotientAndRemainder10dividingByx0A0_x9remaindertx_tF", "context" : "source.codecompletion.context.superclass", "descriptionKey" : "quotientAndRemainder(dividingBy: Int)", "docBrief" : "Returns the quotient and remainder of this value divided by the given value.", @@ -248,7 +248,7 @@ "sourcetext" : "remainderReportingOverflow(dividingBy: <#T##Int#>)", "typeName" : "(partialValue: Int, overflow: Bool)" }, { - "associatedUSRs" : "s:Si6signumSiyF s:s13BinaryIntegerP6signumxyF", + "associatedUSRs" : "s:Si6signumSiyF s:Sz6signumxyF", "context" : "source.codecompletion.context.thisclass", "descriptionKey" : "signum()", "docBrief" : "Returns -1 if this value is negative and 1 if it’s positive; otherwise, 0.", @@ -258,7 +258,7 @@ "sourcetext" : "signum()", "typeName" : "Int" }, { - "associatedUSRs" : "s:s13BinaryIntegerPsE6signumxyF", + "associatedUSRs" : "s:SzsE6signumxyF", "context" : "source.codecompletion.context.superclass", "descriptionKey" : "signum()", "docBrief" : "Returns -1 if this value is negative and 1 if it’s positive; otherwise, 0.", @@ -278,7 +278,7 @@ "sourcetext" : "subtractingReportingOverflow(<#T##other: Int##Int#>)", "typeName" : "(partialValue: Int, overflow: Bool)" }, { - "associatedUSRs" : "s:Si20trailingZeroBitCountSivp s:s13BinaryIntegerP20trailingZeroBitCountSivp", + "associatedUSRs" : "s:Si20trailingZeroBitCountSivp s:Sz20trailingZeroBitCountSivp", "context" : "source.codecompletion.context.thisclass", "descriptionKey" : "trailingZeroBitCount", "docBrief" : "The number of trailing zeros in this value’s binary representation.", @@ -328,7 +328,7 @@ "sourcetext" : "unsafeSubtracting(<#T##other: Int##Int#>)", "typeName" : "Int" }, { - "associatedUSRs" : "s:Si5wordsSi5WordsVvp s:s13BinaryIntegerP5words5WordsQzvp", + "associatedUSRs" : "s:Si5wordsSi5WordsVvp s:Sz5words5WordsQzvp", "context" : "source.codecompletion.context.thisclass", "descriptionKey" : "words", "docBrief" : "A collection containing the words of this value’s binary representation, in order from the least significant to most significant.",