Split SyntaxNode into TreeNode & SyntaxData (#193)

Closes #192

Co-authored-by: c42f <[email protected]>

Author: timholy

src/syntax_tree.jl

@@ -1,20 +1,43 @@
 #-------------------------------------------------------------------------------
 # AST interface, built on top of raw tree
 
-"""
-Design options:
-* rust-analyzer treats their version of an untyped syntax node as a cursor into
-  the green tree. They deallocate aggressively.
-"""
-mutable struct SyntaxNode
+abstract type AbstractSyntaxData end
+
+mutable struct TreeNode{NodeData}   # ? prevent others from using this with NodeData <: AbstractSyntaxData?
+    parent::Union{Nothing,TreeNode{NodeData}}
+    children::Union{Nothing,Vector{TreeNode{NodeData}}}
+    data::Union{Nothing,NodeData}
+end
+
+# Implement "pass-through" semantics for field access: access fields of `data`
+# as if they were part of `TreeNode`
+function Base.getproperty(node::TreeNode, name::Symbol)
+    name === :parent && return getfield(node, :parent)
+    name === :children && return getfield(node, :children)
+    d = getfield(node, :data)
+    name === :data && return d
+    return getproperty(d, name)
+end
+
+function Base.setproperty!(node::TreeNode, name::Symbol, x)
+    name === :parent && return setfield!(node, :parent, x)
+    name === :children && return setfield!(node, :children, x)
+    name === :data && return setfield!(node, :data, x)
+    d = getfield(node, :data)
+    return setfield!(d, name, x)
+end
+
+const AbstractSyntaxNode = TreeNode{<:AbstractSyntaxData}
+
+struct SyntaxData <: AbstractSyntaxData
     source::SourceFile
     raw::GreenNode{SyntaxHead}
     position::Int
-    parent::Union{Nothing,SyntaxNode}
-    is_leaf::Bool
     val::Any
 end
 
+const SyntaxNode = TreeNode{SyntaxData}
+
 # Value of an error node with no children
 struct ErrorVal
 end
@@ -106,7 +129,7 @@ function SyntaxNode(source::SourceFile, raw::GreenNode{SyntaxHead}, position::In
             @debug "Leaf node of kind $k unknown to SyntaxNode"
             ErrorVal()
         end
-        return SyntaxNode(source, raw, position, nothing, true, val)
+        return SyntaxNode(nothing, nothing, SyntaxData(source, raw, position, val))
     else
         cs = SyntaxNode[]
         pos = position
@@ -117,30 +140,31 @@ function SyntaxNode(source::SourceFile, raw::GreenNode{SyntaxHead}, position::In
             end
             pos += rawchild.span
         end
-        node = SyntaxNode(source, raw, position, nothing, false, cs)
+        node = SyntaxNode(nothing, cs, SyntaxData(source, raw, position, nothing))
         for c in cs
             c.parent = node
         end
         return node
     end
 end
 
-head(node::SyntaxNode) = head(node.raw)
+haschildren(node::TreeNode) = node.children !== nothing
+children(node::TreeNode) = (c = node.children; return c === nothing ? () : c)
+
 
-haschildren(node::SyntaxNode) = !node.is_leaf
-children(node::SyntaxNode) = haschildren(node) ? node.val::Vector{SyntaxNode} : ()
+head(node::SyntaxNode) = head(node.raw)
 
 span(node::SyntaxNode) = span(node.raw)
 
-first_byte(node::SyntaxNode) = node.position
-last_byte(node::SyntaxNode)  = node.position + span(node) - 1
+first_byte(node::AbstractSyntaxNode) = node.position
+last_byte(node::AbstractSyntaxNode)  = node.position + span(node) - 1
 
 """
     sourcetext(node)
 
 Get the full source text of a node.
 """
-function sourcetext(node::SyntaxNode)
+function sourcetext(node::AbstractSyntaxNode)
     val_range = (node.position-1) .+ (1:span(node))
     view(node.source, val_range)
 end
@@ -150,7 +174,7 @@ function interpolate_literal(node::SyntaxNode, val)
     SyntaxNode(node.source, node.raw, node.position, node.parent, true, val)
 end
 
-function _show_syntax_node(io, current_filename, node::SyntaxNode, indent)
+function _show_syntax_node(io, current_filename, node::AbstractSyntaxNode, indent)
     fname = node.source.filename
     line, col = source_location(node.source, node.position)
     posstr = "$(lpad(line, 4)):$(rpad(col,3))│$(lpad(first_byte(node),6)):$(rpad(last_byte(node),6))│"
@@ -173,7 +197,7 @@ function _show_syntax_node(io, current_filename, node::SyntaxNode, indent)
     end
 end
 
-function _show_syntax_node_sexpr(io, node::SyntaxNode)
+function _show_syntax_node_sexpr(io, node::AbstractSyntaxNode)
     if !haschildren(node)
         if is_error(node)
             print(io, "(", untokenize(head(node)), ")")
@@ -193,24 +217,24 @@ function _show_syntax_node_sexpr(io, node::SyntaxNode)
     end
 end
 
-function Base.show(io::IO, ::MIME"text/plain", node::SyntaxNode)
+function Base.show(io::IO, ::MIME"text/plain", node::AbstractSyntaxNode)
     println(io, "line:col│ byte_range  │ tree                                   │ file_name")
     _show_syntax_node(io, Ref{Union{Nothing,String}}(nothing), node, "")
 end
 
-function Base.show(io::IO, ::MIME"text/x.sexpression", node::SyntaxNode)
+function Base.show(io::IO, ::MIME"text/x.sexpression", node::AbstractSyntaxNode)
     _show_syntax_node_sexpr(io, node)
 end
 
-function Base.show(io::IO, node::SyntaxNode)
+function Base.show(io::IO, node::AbstractSyntaxNode)
     _show_syntax_node_sexpr(io, node)
 end
 
-function Base.push!(node::SyntaxNode, child::SyntaxNode)
+function Base.push!(node::SN, child::SN) where SN<:AbstractSyntaxNode
     if !haschildren(node)
         error("Cannot add children")
     end
-    args = node.val::Vector{SyntaxNode}
+    args = children(node)
     push!(args, child)
 end
 
@@ -239,7 +263,7 @@ end
 
 function setchild!(node::SyntaxNode, path, x)
     n1 = child(node, path[1:end-1]...)
-    n1.val[path[end]] = x
+    n1.children[path[end]] = x
 end
 
 # We can overload multidimensional Base.getindex / Base.setindex! for node

test/syntax_tree.jl

@@ -27,6 +27,13 @@
     @test sprint(JuliaSyntax.highlight, tt, t, 1, 3) == "a*\e[48;2;40;40;70mb\e[0;0m + c"
     @test sprint(JuliaSyntax.highlight, tt, t.raw, 5) == "a*b + \e[48;2;40;40;70mc\e[0;0m"
 
+    # Pass-through field access
+    node = child(t, 1, 1)
+    @test node.val === :a
+    # The specific error text has evolved over Julia versions. Check that it involves `SyntaxData` and immutability
+    e = try node.val = :q catch e e end
+    @test occursin("immutable", e.msg) && occursin("SyntaxData", e.msg)
+
     node = parse(SyntaxNode, "f()")
     push!(node, parse(SyntaxNode, "x"))
     @test length(children(node)) == 2