names -> fieldnames rename for composite types in Base

- deprecate names()
- abstract getting number of fields with `nfields`

base/Enums.jl

@@ -94,9 +94,9 @@ macro enum(T,syms...)
  Base.typemin{E<:$(esc(typename))}(x::Type{E}) = E($lo)
  Base.typemax{E<:$(esc(typename))}(x::Type{E}) = E($hi)
  Base.length{E<:$(esc(typename))}(x::Type{E}) = $(length(vals))
- Base.names{E<:$(esc(typename))}(x::Type{E}) = [$(map(x->Meta.quot(x[1]), vals)...)]
  Base.next{E<:$(esc(typename))}(x::Type{E},s) = (E($values[s]),s+1)
  Base.done{E<:$(esc(typename))}(x::Type{E},s) = s > $(length(values))
+ Base.names{E<:$(esc(typename))}(x::Type{E}) = [$(map(x->Meta.quot(x[1]), vals)...)]
  function Base.print{E<:$(esc(typename))}(io::IO,x::E)
  for (sym, i) in $vals
  if i == x.val

base/REPLCompletions.jl

@@ -44,7 +44,7 @@ function complete_symbol(sym, ffunc)
  end
  else
  # We're now looking for a type
- fields = t.names
+ fields = fieldnames(t)
  found = false
  for i in 1:length(fields)
  s == fields[i] || continue
@@ -79,7 +79,7 @@ function complete_symbol(sym, ffunc)
  end
  else
  # Looking for a member of a type
- fields = t.names
+ fields = fieldnames(t)
  for field in fields
  s = string(field)
  if startswith(s, name)

base/deepcopy.jl

@@ -27,17 +27,18 @@ function deepcopy_internal(x, stackdict::ObjectIdDict)
 end
 
 function _deepcopy_t(x, T::DataType, stackdict::ObjectIdDict)
- isbits(T) | isempty(T.names) && return x
+ nf = nfields(T)
+ (isbits(T) || nf == 0) && return x
  if T.mutable
  y = ccall(:jl_new_struct_uninit, Any, (Any,), T)
  stackdict[x] = y
- for i in 1:length(T.names)
+ for i in 1:nf
  if isdefined(x,i)
  y.(i) = deepcopy_internal(x.(i), stackdict)
  end
  end
  else
- fields = Any[deepcopy_internal(x.(i), stackdict) for i in 1:length(T.names)]
+ fields = Any[deepcopy_internal(x.(i), stackdict) for i in 1:nf]
  y = ccall(:jl_new_structv, Any, (Any, Ptr{Void}, UInt32),
  T, pointer(fields), length(fields))
  end

base/deprecated.jl

@@ -301,3 +301,6 @@ end
 # 8898
 @deprecate precision(x::DateTime) eps(x)
 @deprecate precision(x::Date) eps(x)
+
+@deprecate names(t::DataType) fieldnames(t)
+@deprecate names(v) fieldnames(v)

base/exports.jl

@@ -1073,6 +1073,7 @@ export
 # types
  convert,
  fieldoffsets,
+ fieldnames,
  isleaftype,
  oftype,
  promote,

base/help.jl

@@ -126,8 +126,9 @@ function help(io::IO, fname::AbstractString, obj=0)
  println(io)
  end
  end
- if length(obj.names) > 0
- println(io, " fields : ", obj.names)
+ fields = fieldnames(obj)
+ if !isempty(fields)
+ println(io, " fields : ", fields)
  end
  elseif isgeneric(obj)
  writemime(io, "text/plain", obj); println()

base/inference.jl

@@ -343,7 +343,7 @@ const getfield_tfunc = function (A, s0, name)
  end
  end
  end
- for i=1:length(s.names)
+ for i=1:nfields(s)
  if is(s.names[i],fld)
  R = s.types[i]
  if s.parameters === ()
@@ -360,7 +360,7 @@ const getfield_tfunc = function (A, s0, name)
  return Bottom
  end
  i::Int = A[2]
- if i < 1 || i > length(s.names)
+ if i < 1 || i > nfields(s)
  return Bottom
  end
  return s.types[i]

base/markdown/Julia/interp.jl

@@ -41,7 +41,7 @@ toexpr(xs::Vector{Any}) = Expr(:cell1d, map(toexpr, xs)...)
 
 function deftoexpr(T)
  @eval function toexpr(md::$T)
- Expr(:call, typeof(md), $(map(x->:(toexpr(md.$x)), names(T))...))
+ Expr(:call, typeof(md), $(map(x->:(toexpr(md.$x)), fieldnames(T))...))
  end
 end
 

base/multi.jl

@@ -110,8 +110,8 @@ type WorkerConfig
  environ::Nullable{Dict}
 
  function WorkerConfig()
- wc=new()
- for n in names(WorkerConfig)
+ wc = new()
+ for n in fieldnames(WorkerConfig)
  T = eltype(fieldtype(WorkerConfig, n))
  setfield!(wc, n, Nullable{T}())
  end

base/multidimensional.jl

@@ -26,12 +26,12 @@ let implemented = IntSet()
  # Create the types
  indextype = symbol("CartesianIndex_$N")
  if !in(N,implemented)
- fieldnames = [symbol("I_$i") for i = 1:N]
- fields = [Expr(:(::), fieldnames[i], :Int) for i = 1:N]
+ fnames = [symbol("I_$i") for i = 1:N]
+ fields = [Expr(:(::), fnames[i], :Int) for i = 1:N]
  extype = Expr(:type, false, Expr(:(<:), indextype, Expr(:curly, :CartesianIndex, N)), Expr(:block, fields...))
  eval(extype)
- argsleft = [Expr(:(::), fieldnames[i], :Real) for i = 1:N]
- argsright = [Expr(:call,:to_index,fieldnames[i]) for i=1:N]
+ argsleft = [Expr(:(::), fnames[i], :Real) for i = 1:N]
+ argsright = [Expr(:call,:to_index,fnames[i]) for i=1:N]
  exconstructor = Expr(:(=),Expr(:call,:(Base.call),:(::Type{CartesianIndex{$N}}),argsleft...),Expr(:call,indextype,argsright...))
  eval(exconstructor)
  push!(implemented,N)

base/reflection.jl

@@ -5,7 +5,7 @@ current_module() = ccall(:jl_get_current_module, Any, ())::Module
 
 function fullname(m::Module)
  if m === Main
- ()
+ return ()
  elseif module_parent(m) === m
  # not Main, but is its own parent, means a prior Main module
  n = ()
@@ -20,22 +20,32 @@ function fullname(m::Module)
  end
  return n
  else
- tuple(fullname(module_parent(m))..., module_name(m))
+ return tuple(fullname(module_parent(m))..., module_name(m))
  end
 end
 
 names(m::Module, all::Bool, imported::Bool) = ccall(:jl_module_names, Array{Symbol,1}, (Any,Int32,Int32), m, all, imported)
 names(m::Module, all::Bool) = names(m, all, false)
 names(m::Module) = names(m, false, false)
-names(t::DataType) = collect(t.names)
 
-function names(v)
+fieldnames(t::DataType) = collect(t.names)
+function fieldnames(v)
  t = typeof(v)
- if isa(t,DataType)
- return names(t)
- else
- throw(ArgumentError("cannot call names() on a non-composite type"))
+ if !isa(t,DataType)
+ throw(ArgumentError("cannot call fieldnames() on a non-composite type"))
+ end
+ return fieldnames(t)
+end
+
+fieldname(t::DataType, i::Integer) = t.names[i]
+
+nfields(t::DataType) = length(t.names)
+function nfields(v)
+ t = typeof(v)
+ if !isa(DataType)
+ throw(ArgumentError("cannot call nfields() on a non-composite type"))
  end
+ return nfields(t)
 end
 
 isconst(s::Symbol) =
@@ -49,7 +59,7 @@ object_id(x::ANY) = ccall(:jl_object_id, UInt, (Any,), x)
 
 # type predicates
 isimmutable(x::ANY) = (isa(x,Tuple) || !typeof(x).mutable)
-isstructtype(t::DataType) = t.names!=() || (t.size==0 && !t.abstract)
+isstructtype(t::DataType) = nfields(t) != 0 || (t.size==0 && !t.abstract)
 isstructtype(x) = false
 isbits(t::DataType) = !t.mutable & t.pointerfree & isleaftype(t)
 isbits(t::Type) = false
@@ -60,7 +70,7 @@ typeintersect(a::ANY,b::ANY) = ccall(:jl_type_intersection, Any, (Any,Any), a, b
 typeseq(a::ANY,b::ANY) = a<:b && b<:a
 
 function fieldoffsets(x::DataType)
- offsets = Array(Int, length(x.names))
+ offsets = Array(Int, nfields(x))
  ccall(:jl_field_offsets, Void, (Any, Ptr{Int}), x, offsets)
  offsets
 end

base/serialize.jl

@@ -315,11 +315,12 @@ function serialize(s, x)
  return write_as_tag(s, x)
  end
  t = typeof(x)
+ nf = nfields(t)
  serialize_type(s, t)
- if length(t.names)==0 && t.size>0
+ if nf == 0 && t.size > 0
  write(s, x)
  else
- for i in 1:length(t.names)
+ for i in 1:nf
  if isdefined(x, i)
  serialize(s, getfield(x, i))
  else
@@ -527,11 +528,11 @@ end
 
 # default DataType deserializer
 function deserialize(s, t::DataType)
- if length(t.names)==0 && t.size>0
+ nf = nfields(t)
+ if nf == 0 && t.size > 0
  # bits type
  return read(s, t)
  end
- nf = length(t.names)
  if nf == 0
  return ccall(:jl_new_struct, Any, (Any,Any...), t)
  elseif isbits(t)
@@ -552,7 +553,7 @@ function deserialize(s, t::DataType)
  end
  else
  x = ccall(:jl_new_struct_uninit, Any, (Any,), t)
- for i in 1:length(t.names)
+ for i in 1:nf
  tag = int32(read(s, UInt8))
  if tag==0 || !is(deser_tag[tag], UndefRefTag)
  ccall(:jl_set_nth_field, Void, (Any, Csize_t, Any), x, i-1, handle_deserialize(s, tag))

base/show.jl

@@ -6,7 +6,8 @@ function show(io::IO, x::ANY)
  t = typeof(x)::DataType
  show(io, t)
  print(io, '(')
- if t.names !== () || t.size==0
+ nf = nfields(t)
+ if nf != 0 || t.size==0
  recorded = false
  oid = object_id(x)
  shown_set = get(task_local_storage(), :SHOWNSET, nothing)
@@ -22,15 +23,15 @@ function show(io::IO, x::ANY)
  push!(shown_set, oid)
  recorded = true
 
- n = length(t.names)
- for i=1:n
- f = t.names[i]
+ nf = nfields(t)
+ for i=1:nf
+ f = fieldname(t, i)
  if !isdefined(x, f)
  print(io, undef_ref_str)
  else
  show(io, x.(f))
  end
- if i < n
+ if i < nf
  print(io, ',')
  end
  end
@@ -735,10 +736,10 @@ end
 function xdump(fn::Function, io::IO, x, n::Int, indent)
  T = typeof(x)
  print(io, T, " ")
- if isa(T, DataType) && length(T.names) > 0
+ if isa(T, DataType) && nfields(T) > 0
  println(io)
  if n > 0
- for field in T.names
+ for field in fieldnames(T)
  if field != symbol("") # prevents segfault if symbol is blank
  print(io, indent, " ", field, ": ")
  if isdefined(x,field)
@@ -787,18 +788,19 @@ xdump(fn::Function, io::IO, x::Array, n::Int, indent) =
 xdump(fn::Function, io::IO, x::UnionType, n::Int, indent) = println(io, x)
 function xdump(fn::Function, io::IO, x::DataType, n::Int, indent)
  println(io, x, "::", typeof(x), " ", " <: ", super(x))
+ fields = fieldnames(x)
  if n > 0
- for idx in 1:min(10,length(x.names))
- if x.names[idx] != symbol("") # prevents segfault if symbol is blank
- print(io, indent, " ", x.names[idx], "::")
+ for idx in 1:min(10, length(fields))
+ if fields[idx] != symbol("") # prevents segfault if symbol is blank
+ print(io, indent, " ", fields[idx], "::")
  if isa(x.types[idx], DataType)
- xdump(fn, io, x.types[idx], n - 1, string(indent, " "))
+ xdump(fn, io, fieldtype(x,idx), n - 1, string(indent, " "))
  else
- println(io, x.types[idx])
+ println(io, fieldtype(x,idx))
  end
  end
  end
- if length(x.names) > 10
+ if length(fields) > 10
  println(io, indent, " ...")
  end
  end
@@ -816,7 +818,7 @@ function dumptype(io::IO, x, n::Int, indent)
  typargs(t) = split(string(t), "{")[1]
  # todo: include current module?
  for m in (Core, Base)
- for s in names(m)
+ for s in fieldnames(m)
  if isdefined(m,s)
  t = eval(m,s)
  if isa(t, TypeConstructor)

base/sparse/cholmod.jl

@@ -795,10 +795,14 @@ sparse(D::Dense) = sparse(Sparse(D))
 
 # Calculate the offset into the stype field of the cholmod_sparse_struct and
 # change the value
-function change_stype!(A::Sparse, i::Integer)
- offset = fieldoffsets(C_Sparse)[names(C_Sparse) .== :stype][1]
- unsafe_store!(convert(Ptr{Cint}, A.p), i, div(offset, 4) + 1)
- A
+let offidx=findfirst(fieldnames(C_Sparse) .== :stype)
+
+ global change_stype!
+ function change_stype!(A::Sparse, i::Integer)
+ offset = fieldoffsets(C_Sparse)[offidx]
+ unsafe_store!(convert(Ptr{Cint}, A.p), i, div(offset, 4) + 1)
+ return A
+ end
 end
 
 free!(A::Dense) = free_dense!(A.p)