Remove old v0.6 compatibility code

Author: ScottPJones

Project.toml

@@ -4,7 +4,7 @@ authors  = ["ScottPJones <[email protected]>"]
 keywords = ["Strings"]
 license  = "MIT"
 uuid     = "e79e7a6a-7bb1-5a4d-9d64-da657b06f53a"
-version  = "0.2.0"
+version  = "0.3.0"
 
 [deps]
 Unicode = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"

src/StrBase.jl

@@ -45,8 +45,7 @@ const SCU = SingleCU()
 const MCU = MultiCU()
 
 include("types.jl")
-@static V6_COMPAT && include("compat.jl")
-@static NEW_ITERATE && include("fixparse.jl")
+include("fixparse.jl")
 include("chars.jl")
 include("access.jl")
 include("traits.jl")

src/compat.jl

@@ -130,18 +130,16 @@ end
 @propagate_inbounds nextind(str::MaybeSub{T}, i::Int, nchar::Int) where {T<:Str} =
     (@_inline_meta(); _nextind(EncodingStyle(T), str, i, nchar))
 
-@static if NEW_ITERATE
-    @propagate_inbounds function _iterate(::SingleCU, T, str, pos)
-        @_inline_meta()
-        T(get_codeunit(str, pos)), pos + 1
-    end
-    @propagate_inbounds function iterate(str::MaybeSub{T}, pos::Integer=firstindex(str)
-                                         )::Union{Nothing,Tuple{eltype(T),Int}} where {T<:Str}
-        @_inline_meta()
-        pos > ncodeunits(str) && return nothing
-        @boundscheck pos <= 0 && boundserr(str, pos)
-        _iterate(EncodingStyle(T), eltype(T), str, pos)
-    end
+@propagate_inbounds function _iterate(::SingleCU, T, str, pos)
+    @_inline_meta()
+    T(get_codeunit(str, pos)), pos + 1
+end
+@propagate_inbounds function iterate(str::MaybeSub{T}, pos::Integer=firstindex(str)
+                                     )::Union{Nothing,Tuple{eltype(T),Int}} where {T<:Str}
+    @_inline_meta()
+    pos > ncodeunits(str) && return nothing
+    @boundscheck pos <= 0 && boundserr(str, pos)
+    _iterate(EncodingStyle(T), eltype(T), str, pos)
 end
 
 @propagate_inbounds index(str::MaybeSub{T}, i::Integer) where {T<:Str} =
@@ -155,11 +153,6 @@ end
 @propagate_inbounds reverseind(str::MaybeSub{T}, i::Integer) where {T<:Str} =
     (@_inline_meta(); _index(EncodingStyle(T), str, Int(ncodeunits(str) - i + 1)))
 
-@static if V6_COMPAT
-    @propagate_inbounds ind2chr(str::MaybeSub{T}, i::Int) where {T<:Str} = length(str, 1, i)
-    @propagate_inbounds chr2ind(str::MaybeSub{T}, i::Int) where {T<:Str} = nextind(str, 0, i)
-end
-
 @propagate_inbounds function is_valid(str::MaybeSub{T}, i::Integer) where {T<:Str}
     @_inline_meta()
     @boundscheck 1 <= i <= ncodeunits(str) || return false

src/core.jl

@@ -120,8 +120,6 @@ const _not_found = 0:-1
 found(::Type{<:AbstractString}, v) = v != 0
 find_result(::Type{<:AbstractString}, v) = v
 
-@static if !V6_COMPAT
-
 nothing_sentinel(i) = first(i) == 0 ? nothing : i
 Base.findfirst(a, b::Str)   = nothing_sentinel(find(First, a, b))
 Base.findlast(a, b::Str)    = nothing_sentinel(find(Last, a, b))
@@ -132,8 +130,6 @@ Base.findlast(a::Str, b::AbstractString)    = nothing_sentinel(find(Last, a, b))
 Base.findnext(a::Str, b::AbstractString, i) = nothing_sentinel(find(Fwd, a, b, i))
 Base.findprev(a::Str, b::AbstractString, i) = nothing_sentinel(find(Rev, a, b, i))
 
-end
-
 function find(::Type{D}, fun::Function, str::AbstractString, pos::Integer) where {D<:Direction}
     pos < Int(D===Fwd) && (@boundscheck boundserr(str, pos); return 0)
     if pos > (len = ncodeunits(str))

src/search.jl

@@ -696,11 +696,9 @@ end
 first(str::Str, n::Integer) = str[1:min(end, nextind(str, 0, n))]
 last(str::Str, n::Integer)  = str[max(1, prevind(str, ncodeunits(str)+1, n)):end]
 
-const Chrs = @static V6_COMPAT ? Union{Char,AbstractChar} : Chr
-
 # low level mem support functions
 
-const HAS_WMEM = !(@static V6_COMPAT ? is_windows() : Sys.iswindows())
+const HAS_WMEM = !Sys.iswindows()
 
 @static if HAS_WMEM
 
@@ -900,15 +898,15 @@ end
 
 (^)(str::T, cnt::Integer) where {T<:Str} = repeat(str, cnt)
 
-function repeat(ch::CP, cnt::Integer) where {CP <: Chrs}
+function repeat(ch::CP, cnt::Integer) where {CP <: Chr}
     C = codepoint_cse(CP)
     cnt > 1 && return Str(C, _repeat(EncodingStyle(C), C, codepoint(ch), cnt))
     cnt == 1 && return _convert(C, codepoint(ch))
     cnt == 0 && return empty_str(C)
     repeaterr(cnt)
 end
 
-(^)(ch::CP, cnt::Integer) where {CP <: Chrs} = repeat(ch, cnt)
+(^)(ch::CP, cnt::Integer) where {CP <: Chr} = repeat(ch, cnt)
 
 function repeat(ch::C, cnt::Integer) where {C<:Union{ASCIIChr,LatinChr}}
     if cnt > 0

src/support.jl

@@ -120,8 +120,7 @@ sizeof(s::Str) = sizeof(s.data) + 1 - STR_KEEP_NUL
 """Codeunits of string as a Vector"""
 _data(s::Vector{UInt8}) = s
 _data(s::String)        = s
-_data(s::Str{<:Byte_CSEs}) =
-    @static V6_COMPAT ? Vector{UInt8}(s.data) : unsafe_wrap(Vector{UInt8}, s.data)
+_data(s::Str{<:Byte_CSEs}) = unsafe_wrap(Vector{UInt8}, s.data)
 
 """Pointer to codeunits of string"""
 pointer(s::Str{<:Byte_CSEs}) = pointer(s.data)

src/types.jl

@@ -6,17 +6,8 @@ Licensed under MIT License, see LICENSE.md
 =#
 
 # Recommended by deprecate
-@static if V6_COMPAT
-    text_width(str::AbstractString) = strwidth(str)
-    text_width(str::Str) = mapreduce(text_width, +, 0, str)
-
-    import Base: normalize_string
-    Base.normalize_string(str::Str, opt::Symbol) = normalize(str, opt)
-    Base.strwidth(str::Str) = text_width(str)
-else
-    text_width(str::Str) = mapreduce(text_width, +, str; init=0)
-    Base.Unicode.normalize(str::Str, opt::Symbol) = normalize(str, opt)
-end
+text_width(str::Str) = mapreduce(text_width, +, str; init=0)
+Base.Unicode.normalize(str::Str, opt::Symbol) = normalize(str, opt)
 
 ############################################################################
 

src/unicode.jl

@@ -3,11 +3,6 @@ Copyright 2018 Gandalf Software, Inc., Scott P. Jones
 Licensed under MIT License, see LICENSE.md
 =#
 
-@static if V6_COMPAT
-    Base.hex(chr::C)      where {C<:Chr} = hex(codepoint(chr))
-    Base.hex(chr::C, pad) where {C<:Chr} = hex(codepoint(chr), pad)
-end
-
 const CT = ChrBase.CaseTables
 
 function _check_char(ch, tab)
@@ -115,11 +110,9 @@ function _upper_utf8(beg, off, len)
             out += 1
         elseif ch < 0xc4
             ch = (ch << 6) | (get_codeunit(pnt += 1) & 0x3f)
-            if !V6_COMPAT && ch == 0xdf
-                out = output_utf8_3byte!(out, 0x1e9e)
-            else
-                out = output_utf8_2byte!(out, _upper_bmp(ch))
-            end
+            out = (ch == 0xdf
+                   ? output_utf8_3byte!(out, 0x1e9e)
+                   : output_utf8_2byte!(out, _upper_bmp(ch)))
         elseif ch < 0xe0
             # 2 byte
             c16 = get_utf8_2byte(pnt += 1, ch)
@@ -223,7 +216,7 @@ end
 @inline function _check_uppercase(ch, pnt)
     # ch < 0xc2 && return false (not needed, validated UTF-8 string)
     cont = get_codeunit(pnt)
-    ch == 0xc3 ? ((cont > (V6_COMPAT ? 0x9f : 0x9e)) & (cont != 0xb7)) : (cont == 0xb5)
+    ch == 0xc3 ? ((cont > 0x9e) & (cont != 0xb7)) : (cont == 0xb5)
 end
 
 function uppercase(str::MaybeSub{S}) where {C<:UTF8CSE,S<:Str{C}}

src/utf8case.jl

@@ -100,9 +100,7 @@ end
 
 function checkkeep(keepempty, keep, fun)
     keep === nothing && return keepempty
-    @static V6_COMPAT ||
-        Base.depwarn("The `keep` keyword argument is deprecated; use `keepempty` instead", fun)
-    keep
+    Base.depwarn("The `keep` keyword argument is deprecated; use `keepempty` instead", fun)
 end
 
 splitarr(::Type{C}) where {C<:CSE} = SubString{Str{basecse(C),Nothing,Nothing,Nothing}}[]