highlander: remove all T <: String since String is concrete

Author: StefanKarpinski

base/datafmt.jl

@@ -119,7 +119,7 @@ function result(dlmoffsets::DLMOffsets)
     dlmoffsets.oarr
 end
 
-type DLMStore{T,S<:String} <: DLMHandler
+type DLMStore{T} <: DLMHandler
     hdr::Array{AbstractString, 2}
     data::Array{T, 2}
 
@@ -128,29 +128,29 @@ type DLMStore{T,S<:String} <: DLMHandler
     lastrow::Int
     lastcol::Int
     hdr_offset::Int
-    sbuff::S
+    sbuff::String
     auto::Bool
     eol::Char
 end
 
-function DLMStore{T,S<:String}(::Type{T}, dims::NTuple{2,Integer}, has_header::Bool, sbuff::S, auto::Bool, eol::Char)
+function DLMStore{T}(::Type{T}, dims::NTuple{2,Integer}, has_header::Bool, sbuff::String, auto::Bool, eol::Char)
     (nrows,ncols) = dims
     nrows <= 0 && throw(ArgumentError("number of rows in dims must be > 0, got $nrows"))
     ncols <= 0 && throw(ArgumentError("number of columns in dims must be > 0, got $ncols"))
     hdr_offset = has_header ? 1 : 0
-    DLMStore{T,S}(fill(SubString(sbuff,1,0), 1, ncols), Array(T, nrows-hdr_offset, ncols), nrows, ncols, 0, 0, hdr_offset, sbuff, auto, eol)
+    DLMStore{T}(fill(SubString(sbuff,1,0), 1, ncols), Array(T, nrows-hdr_offset, ncols), nrows, ncols, 0, 0, hdr_offset, sbuff, auto, eol)
 end
 
 _chrinstr(sbuff::String, chr::UInt8, startpos::Int, endpos::Int) = (endpos >= startpos) && (C_NULL != ccall(:memchr, Ptr{UInt8}, (Ptr{UInt8}, Int32, Csize_t), pointer(sbuff.data)+startpos-1, chr, endpos-startpos+1))
 
-function store_cell{T,S<:String}(dlmstore::DLMStore{T,S}, row::Int, col::Int, quoted::Bool, startpos::Int, endpos::Int)
+function store_cell{T}(dlmstore::DLMStore{T}, row::Int, col::Int, quoted::Bool, startpos::Int, endpos::Int)
     drow = row - dlmstore.hdr_offset
 
     ncols = dlmstore.ncols
     lastcol = dlmstore.lastcol
     lastrow = dlmstore.lastrow
     cells::Array{T,2} = dlmstore.data
-    sbuff::S = dlmstore.sbuff
+    sbuff = dlmstore.sbuff
 
     endpos = prevind(sbuff, nextind(sbuff,endpos))
     (endpos > 0) && ('\n' == dlmstore.eol) && ('\r' == Char(sbuff[endpos])) && (endpos = prevind(sbuff, endpos))
@@ -316,12 +316,12 @@ function dlm_fill(T::DataType, offarr::Vector{Vector{Int}}, dims::NTuple{2,Integ
     end
 end
 
-function colval{S<:String}(sbuff::S, startpos::Int, endpos::Int, cells::Array{Bool,2}, row::Int, col::Int)
+function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{Bool,2}, row::Int, col::Int)
     n = tryparse_internal(Bool, sbuff, startpos, endpos, false)
     isnull(n) || (cells[row, col] = get(n))
     isnull(n)
 end
-function colval{T<:Integer, S<:String}(sbuff::S, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int)
+function colval{T<:Integer}(sbuff::String, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int)
     n = tryparse_internal(T, sbuff, startpos, endpos, 0, false)
     isnull(n) || (cells[row, col] = get(n))
     isnull(n)
@@ -336,11 +336,11 @@ function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{Float32,
     isnull(n) || (cells[row, col] = get(n))
     isnull(n)
 end
-function colval{T<:AbstractString, S<:String}(sbuff::S, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int)
+function colval{T<:AbstractString}(sbuff::String, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int)
     cells[row, col] = SubString(sbuff, startpos, endpos)
     return false
 end
-function colval{S<:String}(sbuff::S, startpos::Int, endpos::Int, cells::Array{Any,2}, row::Int, col::Int)
+function colval(sbuff::String, startpos::Int, endpos::Int, cells::Array{Any,2}, row::Int, col::Int)
     # if array is of Any type, attempt parsing only the most common types: Int, Bool, Float64 and fallback to SubString
     len = endpos-startpos+1
     if len > 0
@@ -359,15 +359,15 @@ function colval{S<:String}(sbuff::S, startpos::Int, endpos::Int, cells::Array{An
     cells[row, col] = SubString(sbuff, startpos, endpos)
     false
 end
-function colval{T<:Char, S<:String}(sbuff::S, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int)
+function colval{T<:Char}(sbuff::String, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int)
     if startpos == endpos
         cells[row, col] = next(sbuff, startpos)[1]
         return false
     else
         return true
     end
 end
-colval{S<:String}(sbuff::S, startpos::Int, endpos::Int, cells::Array, row::Int, col::Int) = true
+colval(sbuff::String, startpos::Int, endpos::Int, cells::Array, row::Int, col::Int) = true
 
 function dlm_parse{T,D}(dbuff::T, eol::D, dlm::D, qchar::D, cchar::D,
                         ign_adj_dlm::Bool, allow_quote::Bool, allow_comments::Bool,
@@ -376,7 +376,7 @@ function dlm_parse{T,D}(dbuff::T, eol::D, dlm::D, qchar::D, cchar::D,
                                  isascii(dlm) &&
                                  (!allow_quote || isascii(qchar)) &&
                                  (!allow_comments || isascii(cchar)))
-    if (T <: String) && all_ascii
+    if T === String && all_ascii
         return dlm_parse(dbuff.data, eol % UInt8, dlm % UInt8, qchar % UInt8, cchar % UInt8,
                          ign_adj_dlm, allow_quote, allow_comments, skipstart, skipblanks, dh)
     end

base/hashing2.jl

@@ -172,7 +172,7 @@ hash(x::Float16, h::UInt) = hash(Float64(x), h)
 const memhash = UInt === UInt64 ? :memhash_seed : :memhash32_seed
 const memhash_seed = UInt === UInt64 ? 0x71e729fd56419c81 : 0x56419c81
 
-function hash{T<:String}(s::Union{T,SubString{T}}, h::UInt)
+function hash(s::Union{String,SubString{String}}, h::UInt)
     h += memhash_seed
     # note: use pointer(s) here (see #6058).
     ccall(memhash, UInt, (Ptr{UInt8}, Csize_t, UInt32), pointer(s), sizeof(s), h % UInt32) + h

base/parse.jl

@@ -54,7 +54,7 @@ function parseint_preamble(signed::Bool, base::Int, s::AbstractString, startpos:
     return sgn, base, j
 end
 
-function tryparse_internal{S<:String}(::Type{Bool}, sbuff::S, startpos::Int, endpos::Int, raise::Bool)
+function tryparse_internal(::Type{Bool}, sbuff::String, startpos::Int, endpos::Int, raise::Bool)
     len = endpos-startpos+1
     p = pointer(sbuff)+startpos-1
     (len == 4) && (0 == ccall(:memcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt), p, "true", 4)) && (return Nullable(true))
@@ -152,10 +152,10 @@ string(x::Union{Int8,Int16,Int32,Int64,Int128}) = dec(x)
 ## string to float functions ##
 
 tryparse(::Type{Float64}, s::String) = ccall(:jl_try_substrtod, Nullable{Float64}, (Ptr{UInt8},Csize_t,Csize_t), s, 0, sizeof(s))
-tryparse{T<:String}(::Type{Float64}, s::SubString{T}) = ccall(:jl_try_substrtod, Nullable{Float64}, (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset, s.endof)
+tryparse(::Type{Float64}, s::SubString{String}) = ccall(:jl_try_substrtod, Nullable{Float64}, (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset, s.endof)
 
 tryparse(::Type{Float32}, s::String) = ccall(:jl_try_substrtof, Nullable{Float32}, (Ptr{UInt8},Csize_t,Csize_t), s, 0, sizeof(s))
-tryparse{T<:String}(::Type{Float32}, s::SubString{T}) = ccall(:jl_try_substrtof, Nullable{Float32}, (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset, s.endof)
+tryparse(::Type{Float32}, s::SubString{String}) = ccall(:jl_try_substrtof, Nullable{Float32}, (Ptr{UInt8},Csize_t,Csize_t), s.string, s.offset, s.endof)
 
 tryparse{T<:Union{Float32,Float64}}(::Type{T}, s::AbstractString) = tryparse(T, bytestring(s))
 

base/regex.jl

@@ -172,10 +172,6 @@ function match(re::Regex, str::Union{SubString{String}, String}, idx::Integer, a
     RegexMatch(mat, cap, ovec[1]+1, off, re)
 end
 
-_utf8(str) = utf8(str)
-match{T<:String}(re::Regex, str::Union{T,SubString{T}}, idx::Integer, add_opts::UInt32=UInt32(0)) =
-    match(re, _utf8(str), idx, add_opts)
-
 match(r::Regex, s::AbstractString) = match(r, s, start(s))
 match(r::Regex, s::AbstractString, i::Integer) =
     throw(ArgumentError("regex matching is only available for bytestrings; use bytestring(s) to convert"))

base/strings/io.jl

@@ -70,7 +70,7 @@ print(io::IO, s::AbstractString) = (write(io, s); nothing)
 write(io::IO, s::AbstractString) = (len = 0; for c in s; len += write(io, c); end; len)
 show(io::IO, s::AbstractString) = print_quoted(io, s)
 
-write{T<:String}(to::AbstractIOBuffer, s::SubString{T}) =
+write(to::AbstractIOBuffer, s::SubString{String}) =
     s.endof==0 ? 0 : write_sub(to, s.string.data, s.offset + 1, nextind(s, s.endof) - 1)
 
 ## printing literal quoted string data ##
@@ -91,7 +91,7 @@ end
 
 # IOBuffer views of a (byte)string:
 IOBuffer(str::String) = IOBuffer(str.data)
-IOBuffer{T<:String}(s::SubString{T}) = IOBuffer(sub(s.string.data, s.offset + 1 : s.offset + sizeof(s)))
+IOBuffer(s::SubString{String}) = IOBuffer(sub(s.string.data, s.offset + 1 : s.offset + sizeof(s)))
 
 # join is implemented using IO
 function print_joined(io, strings, delim, last)

base/strings/types.jl

@@ -75,7 +75,7 @@ prevind(s::SubString, i::Integer) = prevind(s.string, i+s.offset)-s.offset
 
 convert{T<:AbstractString}(::Type{SubString{T}}, s::T) = SubString(s, 1, endof(s))
 
-bytestring{T <: String}(p::SubString{T}) = bytestring(p.string.data[1+p.offset:p.offset+nextind(p, p.endof)-1])
+bytestring(p::SubString{String}) = bytestring(p.string.data[1+p.offset:p.offset+nextind(p, p.endof)-1])
 
 function getindex(s::AbstractString, r::UnitRange{Int})
     if first(r) < 1 || endof(s) < last(r)
@@ -84,7 +84,7 @@ function getindex(s::AbstractString, r::UnitRange{Int})
     SubString(s, first(r), last(r))
 end
 
-function cmp{T<:String,S<:String}(a::SubString{T}, b::SubString{S})
+function cmp(a::SubString{String}, b::SubString{String})
     na = sizeof(a)
     nb = sizeof(b)
     c = ccall(:memcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt),
@@ -93,9 +93,9 @@ function cmp{T<:String,S<:String}(a::SubString{T}, b::SubString{S})
 end
 
 # don't make unnecessary copies when passing substrings to C functions
-cconvert{T<:String}(::Type{Ptr{UInt8}}, s::SubString{T}) = s
-cconvert{T<:String}(::Type{Ptr{Int8}}, s::SubString{T}) = s
-function unsafe_convert{T<:String, R<:Union{Int8, UInt8}}(::Type{Ptr{R}}, s::SubString{T})
+cconvert(::Type{Ptr{UInt8}}, s::SubString{String}) = s
+cconvert(::Type{Ptr{Int8}}, s::SubString{String}) = s
+function unsafe_convert{R<:Union{Int8, UInt8}}(::Type{Ptr{R}}, s::SubString{String})
     unsafe_convert(Ptr{R}, s.string.data) + s.offset
 end
 

base/unicode/utf32.jl

@@ -127,13 +127,13 @@ convert{T<:AbstractString, S<:Union{UInt32,Char,Int32}}(::Type{T}, v::AbstractVe
     convert(T, utf32(v))
 
 # specialize for performance reasons:
-function convert{T<:String, S<:Union{UInt32,Char,Int32}}(::Type{T}, data::AbstractVector{S})
+function convert{T<:Union{UInt32,Char,Int32}}(::Type{String}, data::AbstractVector{T})
     s = IOBuffer(Array(UInt8,length(data)), true, true)
     truncate(s,0)
     for x in data
         print(s, Char(x))
     end
-    convert(T, takebuf_string(s))
+    convert(String, takebuf_string(s))
 end
 
 convert(::Type{Vector{UInt32}}, str::UTF32String) = str.data
@@ -227,7 +227,7 @@ pointer(x::String, i::Integer) = pointer(x.data)+(i-1)
 pointer(x::Union{UTF16String,UTF32String}, i::Integer) = pointer(x)+(i-1)*sizeof(eltype(x.data))
 
 # pointer conversions of SubString of ASCII/UTF8/UTF16/UTF32:
-pointer{T<:String}(x::SubString{T}) = pointer(x.string.data) + x.offset
-pointer{T<:String}(x::SubString{T}, i::Integer) = pointer(x.string.data) + x.offset + (i-1)
+pointer(x::SubString{String}) = pointer(x.string.data) + x.offset
+pointer(x::SubString{String}, i::Integer) = pointer(x.string.data) + x.offset + (i-1)
 pointer{T<:Union{UTF16String,UTF32String}}(x::SubString{T}) = pointer(x.string.data) + x.offset*sizeof(eltype(x.string.data))
 pointer{T<:Union{UTF16String,UTF32String}}(x::SubString{T}, i::Integer) = pointer(x.string.data) + (x.offset + (i-1))*sizeof(eltype(x.string.data))