Simplify setproperty specializations

Author: goerch

src/avl_tree.jl

@@ -14,10 +14,8 @@ end
 
 AVLTreeNode(d) = AVLTreeNode{Any}(d)
 
-_setproperty!(x::AVLTreeNode{T}, f, v) where {T} =
-    setfield!(x, f, v)
 Base.setproperty!(x::AVLTreeNode{T}, f::Symbol, v) where {T} =
-    _setproperty!(x, f, v)
+    setfield!(x, f, v)
 
 AVLTreeNode_or_null{T} = Union{AVLTreeNode{T}, Nothing}
 
@@ -45,7 +43,7 @@ end
 
 # computes the height of the subtree, which basically is
 # one added the maximum of the height of the left subtree and right subtree
-compute_height(node::AVLTreeNode) = Int8(1 + max(get_height(node.leftChild), get_height(node.rightChild)))
+compute_height(node::AVLTreeNode) = Int8(1) + max(get_height(node.leftChild), get_height(node.rightChild))
 
 get_subsize(node::AVLTreeNode_or_null) = (node == nothing) ? Int32(0) : node.subsize
 

src/red_black_tree.jl

@@ -17,10 +17,8 @@ end
 RBTreeNode() = RBTreeNode{Any}()
 RBTreeNode(d) = RBTreeNode{Any}(d)
 
-_setproperty!(x::RBTreeNode{K}, f, v) where {K} =
-    setfield!(x, f, v)
 Base.setproperty!(x::RBTreeNode{K}, f::Symbol, v) where {K} =
-    _setproperty!(x, f, v)
+    setfield!(x, f, v)
 
 function create_null_node(K::Type)
     node = RBTreeNode{K}()

src/splay_tree.jl

@@ -11,12 +11,15 @@ end
 SplayTreeNode(d) = SplayTreeNode{Any}(d)
 SplayTreeNode() = SplayTreeNode{Any}()
 
+Base.setproperty!(x::SplayTreeNode{K}, f::Symbol, v) where {K} =
+    setfield!(x, f, v)
+
 mutable struct SplayTree{K}
     root::Union{SplayTreeNode{K}, Nothing}
     count::Int
 
     SplayTree{K}() where K = new{K}(nothing, 0)
-end 
+end
 
 Base.length(tree::SplayTree) = tree.count
 
@@ -41,7 +44,7 @@ function left_rotate!(tree::SplayTree, node_x::SplayTreeNode)
         node_y.leftChild = node_x
     end
     node_x.parent = node_y
-end    
+end
 
 function right_rotate!(tree::SplayTree, node_x::SplayTreeNode)
     node_y = node_x.leftChild
@@ -59,7 +62,7 @@ function right_rotate!(tree::SplayTree, node_x::SplayTreeNode)
     end
     node_y.rightChild = node_x
     node_x.parent = node_y
-end 
+end
 
 # The splaying operation moves node_x to the root of the tree using the series of rotations.
 function splay!(tree::SplayTree, node_x::SplayTreeNode)
@@ -71,7 +74,7 @@ function splay!(tree::SplayTree, node_x::SplayTreeNode)
             if node_x == parent.leftChild
                 # zig rotation
                 right_rotate!(tree, node_x.parent)
-            else 
+            else
                 # zag rotation
                 left_rotate!(tree, node_x.parent)
             end
@@ -104,7 +107,7 @@ function maximum_node(node::Union{SplayTreeNode, Nothing})
     return node
 end
 
-# Join operations joins two trees S and T 
+# Join operations joins two trees S and T
 # All the items in S are smaller than the items in T.
 # This is a two-step process.
 # In the first step, splay the largest node in S. This moves the largest node to the root node.
@@ -157,10 +160,10 @@ function Base.delete!(tree::SplayTree{K}, d::K) where K
     x = search_node(tree, d)
     (x == nothing) && return tree
     t = nothing
-    s = nothing 
-    
+    s = nothing
+
     splay!(tree, x)
-    
+
     if x.rightChild !== nothing
         t = x.rightChild
         t.parent = nothing
@@ -211,7 +214,7 @@ function Base.push!(tree::SplayTree{K}, d0) where K
     return tree
 end
 
-function Base.getindex(tree::SplayTree{K}, ind) where K 
+function Base.getindex(tree::SplayTree{K}, ind) where K
     @boundscheck (1 <= ind <= tree.count) || throw(KeyError("$ind should be in between 1 and $(tree.count)"))
     function traverse_tree_inorder(node::Union{SplayTreeNode, Nothing})
         if (node != nothing)
@@ -222,6 +225,6 @@ function Base.getindex(tree::SplayTree{K}, ind) where K
             return K[]
         end
     end
-    arr = traverse_tree_inorder(tree.root) 
+    arr = traverse_tree_inorder(tree.root)
     return @inbounds arr[ind]
 end

test/runtests.jl

@@ -5,9 +5,8 @@ using Serialization
 
 import DataStructures: IntSet
 
-# These fail due to setproperty! specializations for AVL and RB tree.
-# @test [] == detect_ambiguities(Core, DataStructures)
-# @test [] == detect_ambiguities(Base, DataStructures)
+@test [] == detect_ambiguities(Core, DataStructures)
+@test [] == detect_ambiguities(Base, DataStructures)
 
 tests = ["deprecations",
          "int_set",