Make some iterators a subtype of AbstractVector.

Simplifies the implementation by reusing the AbstractArray implementation.

Author: maleadt

src/core/function.jl

@@ -83,15 +83,17 @@ export Argument, parameters
 end
 identify(::Type{Value}, ::Val{API.LLVMArgumentValueKind}) = Argument
 
-struct FunctionParameterSet
+struct FunctionParameterSet <: AbstractVector{Argument}
     f::Function
 end
 
 parameters(f::Function) = FunctionParameterSet(f)
 
-Base.eltype(::FunctionParameterSet) = Argument
+Base.size(iter::FunctionParameterSet) = (API.LLVMCountParams(iter.f),)
 
-function Base.getindex(iter::FunctionParameterSet, i)
+Base.IndexStyle(::FunctionParameterSet) = IndexLinear()
+
+function Base.getindex(iter::FunctionParameterSet, i::Int)
     @boundscheck 1 <= i <= length(iter) || throw(BoundsError(iter, i))
     return Argument(API.LLVMGetParam(iter.f, i-1))
 end
@@ -100,13 +102,7 @@ function Base.iterate(iter::FunctionParameterSet, state=API.LLVMGetFirstParam(it
     state == C_NULL ? nothing : (Argument(state), API.LLVMGetNextParam(state))
 end
 
-Base.last(iter::FunctionParameterSet) =
-    Argument(API.LLVMGetLastParam(iter.f))
-
-Base.isempty(iter::FunctionParameterSet) =
-    API.LLVMGetLastParam(iter.f) == C_NULL
-
-Base.length(iter::FunctionParameterSet) = API.LLVMCountParams(iter.f)
+Base.last(iter::FunctionParameterSet) = Argument(API.LLVMGetLastParam(iter.f))
 
 # NOTE: optimized `collect`
 function Base.collect(iter::FunctionParameterSet)
@@ -131,11 +127,10 @@ function Base.iterate(iter::FunctionBlockSet, state=API.LLVMGetFirstBasicBlock(i
     state == C_NULL ? nothing : (BasicBlock(state), API.LLVMGetNextBasicBlock(state))
 end
 
-Base.last(iter::FunctionBlockSet) =
-    BasicBlock(API.LLVMGetLastBasicBlock(iter.f))
+Base.first(iter::FunctionBlockSet) = BasicBlock(API.LLVMGetFirstBasicBlock(iter.f))
+Base.last(iter::FunctionBlockSet) = BasicBlock(API.LLVMGetLastBasicBlock(iter.f))
 
-Base.isempty(iter::FunctionBlockSet) =
-    API.LLVMGetLastBasicBlock(iter.f) == C_NULL
+Base.isempty(iter::FunctionBlockSet) = length(iter) == 0
 
 Base.length(iter::FunctionBlockSet) = API.LLVMCountBasicBlocks(iter.f)
 

src/core/instructions.jl

@@ -156,57 +156,50 @@ default_dest(switch::Instruction) =
 
 export successors
 
-struct TerminatorSuccessorSet
+struct TerminatorSuccessorSet <: AbstractVector{BasicBlock}
     term::Instruction
 end
 
 successors(term::Instruction) = TerminatorSuccessorSet(term)
 
-Base.eltype(::TerminatorSuccessorSet) = BasicBlock
+Base.size(iter::TerminatorSuccessorSet) = (API.LLVMGetNumSuccessors(iter.term),)
 
-function Base.getindex(iter::TerminatorSuccessorSet, i)
+Base.IndexStyle(::TerminatorSuccessorSet) = IndexLinear()
+
+function Base.getindex(iter::TerminatorSuccessorSet, i::Int)
     @boundscheck 1 <= i <= length(iter) || throw(BoundsError(iter, i))
     return BasicBlock(API.LLVMGetSuccessor(iter.term, i-1))
 end
 
-Base.setindex!(iter::TerminatorSuccessorSet, bb::BasicBlock, i) =
+Base.setindex!(iter::TerminatorSuccessorSet, bb::BasicBlock, i::Int) =
     API.LLVMSetSuccessor(iter.term, i-1, bb)
 
-function Base.iterate(iter::TerminatorSuccessorSet, i=1)
-    i >= length(iter) + 1 ? nothing : (iter[i], i+1)
-end
-
-Base.length(iter::TerminatorSuccessorSet) = API.LLVMGetNumSuccessors(iter.term)
-
-Base.lastindex(iter::TerminatorSuccessorSet) = length(iter)
-
 
 ## phi nodes
 
 # incoming iteration
 
 export PhiIncomingSet
 
-struct PhiIncomingSet
+struct PhiIncomingSet <: AbstractVector{Tuple{Value,BasicBlock}}
     phi::Instruction
 end
 
 incoming(phi::Instruction) = PhiIncomingSet(phi)
 
-Base.eltype(::PhiIncomingSet) = Tuple{Value,BasicBlock}
+Base.size(iter::PhiIncomingSet) = (API.LLVMCountIncoming(iter.phi),)
+
+Base.IndexStyle(::PhiIncomingSet) = IndexLinear()
 
-function Base.getindex(iter::PhiIncomingSet, i)
+function Base.getindex(iter::PhiIncomingSet, i::Int)
     @boundscheck 1 <= i <= length(iter) || throw(BoundsError(iter, i))
     return tuple(Value(API.LLVMGetIncomingValue(iter.phi, i-1)),
                        BasicBlock(API.LLVMGetIncomingBlock(iter.phi, i-1)))
 end
 
 function Base.append!(iter::PhiIncomingSet, args::Vector{Tuple{V, BasicBlock}} where V <: Value)
     vals, blocks = zip(args...)
-    API.LLVMAddIncoming(iter.phi, collect(vals),
-                        collect(blocks), length(args))
+    API.LLVMAddIncoming(iter.phi, collect(vals), collect(blocks), length(args))
 end
 
 Base.push!(iter::PhiIncomingSet, args::Tuple{<:Value, BasicBlock}) = append!(iter, [args])
-
-Base.length(iter::PhiIncomingSet) = API.LLVMCountIncoming(iter.phi)

src/core/value/user.jl

@@ -6,15 +6,17 @@ abstract type User <: Value end
 
 export operands
 
-struct UserOperandSet
+struct UserOperandSet <: AbstractVector{Value}
     user::User
 end
 
 operands(user::User) = UserOperandSet(user)
 
-Base.eltype(::UserOperandSet) = Value
+Base.size(iter::UserOperandSet) = (API.LLVMGetNumOperands(iter.user),)
 
-function Base.getindex(iter::UserOperandSet, i::Integer)   # TODO: otherwise unitrange indexing errors
+Base.IndexStyle(::UserOperandSet) = IndexLinear()
+
+function Base.getindex(iter::UserOperandSet, i::Int)
     @boundscheck 1 <= i <= length(iter) || throw(BoundsError(iter, i))
     return Value(API.LLVMGetOperand(iter.user, i-1))
 end
@@ -25,7 +27,3 @@ Base.setindex!(iter::UserOperandSet, val::Value, i) =
 function Base.iterate(iter::UserOperandSet, i=1)
     i >= length(iter) + 1 ? nothing : (iter[i], i+1)
 end
-
-Base.length(iter::UserOperandSet) = API.LLVMGetNumOperands(iter.user)
-
-Base.lastindex(iter::UserOperandSet) = length(iter)